User-generated replayable game content with regamification data

Abstract

The invention relates to user-generated replayable game content utilizing regamification data. In one embodiment, a method includes receiving data related to a computer-based game using a logical engine, processing the data to generate events, processing the events or the data by the logical engine to generate build blocks, capturing one or more highlights in the computer-based game, and displaying the build blocks in the computer-based game. Wherein each captured bright spot corresponds to a selected start point and end point in the computer base game; processing the building base block by the logic engine to generate a bright spot attribute parameter, selecting a PGH bright spot in each of the bright spots, where the PGH bright spot corresponds to a selected start point and end point in one of the bright spots; the building base blocks associated with the selected PGH highlights are repeatedly processed by the logic engine to generate PGH attributes, and one or more PGH computer games are created based on the PGH attributes, where each of the PGH computer games includes a PGH rule associated with the PGH attributes and used to configure a play of the one or more PGH computer games.

Description

[0001] Cross-references

[0002] This application claims priority to U.S. application serial number 18 / 660,841, filed on May 10, 2024, entitled “USER-GENERATED REPLAYABLEGAMING CONTENT UTILIZING REGAMIFICATION DATA,” which claims priority to U.S. provisional application serial number 63 / 598,654, filed on November 14, 2023, entitled “USER-GENERATED REPLAYABLEGAMING CONTENT UTILIZING REGAMIFICATION DATA,” each of which is incorporated herein by reference in its entirety.

[0003] Incorporated by Reference

[0004] All publications, patents, and patent applications mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent, or patent application was specifically and individually indicated to be incorporated by reference. Technical Field

[0005] The subject matter of the present disclosure relates to electronic games, and in particular to the implementation of a system for creating and playing new games.

[0006] background

[0007] The problem of implementing electronic games has been recognized in the prior art, and various techniques have been developed to provide solutions. U.S. Patent No. 9,707,476B2, entitled "Method for creating a mini-game", proposes a method of creating a video mini-game based on a traditional game title using snapshot technology. The method creates a game based on a snapshot of a traditional game and provides a small segment of entertainment for players who do not want to play the entire traditional game. SUMMARY OF THE INVENTION

[0009] According to a first aspect of the present invention, there is provided a computer-implemented method for creating one or more playable gameplay highlights (PGH) computer games from a computer base game, the method comprising: receiving data related to the computer base game using a logic engine, wherein the data comprises one or more of the following: events, text, audio, images, video recordings, other videos describing the computer base game, and wherein the logic engine is included in a processor located in a server; processing the data to generate the events, and the events are processed by the logic engine to generate building blocks, or the data are processed by the logic engine to generate building blocks; capturing one or more highlights in the computer base game, wherein each of the one or more highlights corresponds to a selected starting point and an ending point in the computer base game; processing the building blocks by the logic engine to generate highlight attribute parameters, the highlight attribute parameters comprising parameters respectively corresponding to the one or more highlights. one or more of the possible goals, possible constraints, possible PGH ending criteria, possible ending conditions and possible scoring parameters related to each of the one or more highlights; selecting a PGH highlight in each of the one or more highlights, wherein the PGH highlight corresponds to a selected starting point and an ending point in one of the one or more highlights; processing the building blocks related to the selected PGH highlight by the logic engine (e.g., repeatedly) to generate PGH attributes, wherein the PGH attributes include one or more of the goals, constraints, PGH ending criteria, ending conditions and scoring parameters, the selected starting point and the ending point; creating the one or more PGH computer games based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, which are related to the PGH attributes and are used to configure the gameplay of the one or more PGH computer games.

[0010] In an embodiment, the method includes: recovering events related to the computer base game; continuously identifying events in the one or more PGH computer games; continuously streaming the identified events from the game client device to the logic engine; continuously processing the identified events using the logic engine to generate the building blocks; continuously processing the building blocks using the logic engine to determine whether PGH attribute parameters are obtained based on PGH rules; and when the PGH attribute parameters have been obtained, ending the gameplay of the one or more PGH computer games.

[0011] In an embodiment, the method includes generating a PGH state for each of the one or more PGH computer games, wherein generating the PGH state includes: calculating one or more of a scoring parameter, a state of a goal, a state of a constraint, and a state of a PGH end criterion; and transmitting the PGH state to a management module included in the server; and providing server events based on one or more of the PGH state and the building blocks.

[0012] In an embodiment, the method comprises transmitting a server event from a server to a gaming client device; and displaying the server event on a display.

[0013] In an embodiment, the method comprises calculating a PGH outcome for each of the one or more PGH computer games based on the event; transmitting the PGH outcome to a PGH application; and displaying the server event on a display of the game client device.

[0014] In an embodiment, the method comprises selecting said one or more highlight points by clicking one or more keys during gameplay of the base game.

[0015] In an embodiment, the method includes converting one or more of text, audio, images, video recording of the base game, other video into the event.

[0016] In an embodiment, the method comprises identifying an event in said computer base game using an event module, wherein said event module is included in a processor in a game client device.

[0017] In an embodiment, the method comprises selecting a timestamp start point and selecting a timestamp end point in said computer base game.

[0018] In an embodiment, the method includes transmitting a video of a computer base game captured by a video module in a game client device to a server; transmitting the one or more highlights from the server to a PGH application (PGH App); editing the video based on a selected PGH timestamp to generate a final PGH video; and creating the one or more PGH computer games based on the PGH attributes and the final PGH video.

[0019] In an embodiment, the method comprises creating one or more additional PGH computer games from the one or more PGH computer games.

[0020] In an embodiment, the method comprises creating two or more PGH computer games based on a single highlight of the one or more highlights.

[0021] In an embodiment, an event comprises an action or state of a character in the computer base game.

[0022] In an embodiment, each of the building blocks is formed by aggregating one or more of the events.

[0023] In an embodiment, an aggregate function combines two or more events of the same type or events of different types.

[0024] In an embodiment, the PGH attributes are selected by the creator of the PGH computer game or automatically selected by the logic engine.

[0025] In an embodiment, the PGH attributes also include one or more of: a name of the PGH, a description, a thumbnail "preview" image of the PGH computer game, and tags.

[0026] In an embodiment, the character is a player character (PC) or a non-player character (NPC).

[0027] In an embodiment, generative artificial intelligence (AI) algorithms and models are used to create goals or constraints or PGH end criteria or end conditions or scoring parameters.

[0028] In an embodiment, a gaming client device is comprised in said server.

[0029] In an embodiment, the one or more PGH computer games are loaded and run, and the loading and running include: resuming events from a base game; capturing video or other signals of the base game; transmitting the captured video or other signals to a server; processing the video using a video analysis processor, or processing the signal using a signal analysis processor; determining whether PGH attribute parameters are obtained based on PGH rules and the analyzed video or analyzed signal; and calculating scoring parameters.

[0030] According to a second aspect of the present invention, there is provided a computer-implemented method for creating one or more playable gameplay highlight (PGH) computer games from a computer base game, the method comprising: receiving data related to the computer base game using a logic engine, wherein the data comprises one or more of the following: events, text, audio, images, video recordings, other videos describing the computer base game, and wherein the logic engine is included in a processor located in a server; processing the data using the logic engine to generate events; capturing one or more highlights in the computer base game, wherein each of the one or more highlights corresponds to a selected starting point and an ending point in the computer base game; processing the events by the logic engine to generate highlight attribute parameters, the highlight attribute parameters comprising parameters respectively corresponding to the one or more highlights; one or more possible goals, possible constraints, possible PGH ending criteria, possible ending conditions and possible scoring parameters related to each of the one or more highlights; selecting a PGH highlight in each of the one or more highlights, wherein the PGH highlight corresponds to a selected starting point and an ending point in one of the one or more highlights; processing the event related to the selected PGH highlight by the logic engine to generate PGH attributes, wherein the PGH attributes include one or more of the goals, constraints, PGH ending criteria, ending conditions and scoring parameters; creating the one or more PGH computer games based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, which are related to the PGH attributes and are used to configure the gameplay of the one or more PGH computer games.

[0031] In an embodiment, the method includes: recovering events related to the base game; continuously identifying events in the one or more PGH computer games; continuously streaming the identified events from the game client device to the logic engine; continuously processing the identified events using the logic engine to generate the building blocks; continuously processing the building blocks using the logic engine to determine whether PGH attribute parameters are obtained based on PGH rules; and when the PGH attribute parameters have been obtained, ending the gameplay of the one or more PGH computer games.

[0032] In an embodiment, the method includes generating a PGH state for each of the one or more PGH computer games, wherein generating the PGH state includes: calculating one or more of a scoring parameter, a state of a goal, a state of a constraint, and a state of a PGH end criterion; and transmitting the PGH state to a management module included in the server; and providing server events based on one or more of the PGH state and the building blocks.

[0033] In an embodiment, the method comprises: transmitting a server event from a PGH server to a game client device; and displaying the server event on a display.

[0034] In an embodiment, the method comprises: calculating a PGH result for each of the one or more PGH computer games based on the identified event; transmitting the PGH result to a PGH application (PGH App); and displaying the server event on a display of the game client device.

[0035] In an embodiment, the method comprises selecting the one or more highlight points by clicking one or more keys during gameplay of the computer base game.

[0036] In an embodiment, the method comprises identifying an event in the computer base game using an event module, wherein the event module is included in a processor in a game client device.

[0037] In an embodiment, the method comprises: selecting a PGH highlight comprises: selecting a timestamp start point and selecting a timestamp end point in the computer base game.

[0038] In an embodiment, the method includes: transmitting a video of a computer base game captured by a video module in the game client device to a server; transmitting the one or more highlights from the server to a PGH application (PGHApp); editing the video based on a selected PGH timestamp to generate a final PGH video; and creating the one or more PGH computer games based on the PGH attributes and the final PGH video.

[0039] In an embodiment, the method comprises creating one or more additional PGH computer games from the one or more PGH computer games.

[0040] In an embodiment, the method comprises creating two or more PGH computer games based on a single highlight of the one or more highlights.

[0041] In an embodiment, the identified event comprises an action or state of a character in the computer base game.

[0042] In an embodiment, each of the building blocks is formed by aggregating one or more of the events.

[0043] In an embodiment, an aggregate function combines one or more events of the same type or different types.

[0044] In an embodiment, the PGH attributes are selected by the creator of the PGH computer game or automatically selected by the logic engine.

[0045] In an embodiment, the PGH attributes also include one or more of: a name of the PGH, a description, a thumbnail "preview" image of the PGH computer game, and tags.

[0046] In an embodiment, the character is a player character (PC) or a non-player character (NPC).

[0047] In an embodiment, generative artificial intelligence (AI) algorithms and models are used to create goals or constraints or PGH end criteria or end conditions or scoring parameters.

[0048] In an embodiment, a gaming client device is comprised in said server.

[0049] In an embodiment, the method includes: loading and running the one or more PGH computer games, wherein the loading and running includes: resuming events from a base game; capturing video or other signals of the base game; transmitting the captured video or other signals to a server; processing the video using a video analysis processor, or processing the signal using a signal analysis processor; determining whether PGH attribute parameters are obtained based on PGH rules and the analyzed video or analyzed signal; and calculating scoring parameters.

[0050] According to a third aspect of the present invention, a method performed by a game client device is provided for loading and running one or more playable gameplay highlights (PGH) computer games created based on a computer base game, the method comprising: recovering events related to the computer base game; identifying events (e.g., continuously) in the one or more PGH computer games; streaming the identified events from the game client device (e.g., continuously) to a logic engine; processing the identified events using the logic engine (e.g., continuously) to generate building blocks; processing the building blocks using the logic engine (e.g., continuously) to determine whether PGH attribute parameters have been obtained based on PGH rules; and ending the gameplay of the one or more PGH computer games when the PGH attribute parameters have been obtained.

[0051] In an embodiment, the method includes: generating a PGH state for each of the one or more PGH computer games, wherein generating the PGH state includes: calculating one or more of a scoring parameter, a state of a goal, a state of a constraint, and a state of a PGH end criterion; and transmitting the PGH state to a management module included in the server; and providing server events based on one or more of the PGH state and the building blocks.

[0052] In an embodiment, the method comprises: transmitting a server event from a PGH server to a game client device; and displaying the server event on a display.

[0053] In an embodiment, the method comprises: calculating a PGH result for each of the one or more PGH computer games based on the identified event; transmitting the PGH result to a PGH application (PGH App); and displaying the server event on a display of the game client device.

[0054] In an embodiment, the method comprises identifying an event in the computer base game using an event module, wherein the event module is included in a processor in a game client device.

[0055] In an embodiment, the method comprises creating one or more additional PGH computer games from the one or more PGH computer games.

[0056] In an embodiment, the identified event comprises an action or state of a character in the computer base game.

[0057] In an embodiment, each of the building blocks is formed by aggregating one or more of the events.

[0058] In an embodiment, an aggregate function combines one or more events of the same type or different types.

[0059] In an embodiment, the PGH attributes are selected by the creator of the PGH computer game or automatically selected by the logic engine.

[0060] In an embodiment, the PGH attributes also include one or more of: a name of the PGH, a description, a thumbnail "preview" image of the PGH computer game, and tags.

[0061] In an embodiment, generative artificial intelligence (AI) algorithms and models are used to create goals or constraints or PGH end criteria or end conditions or scoring parameters.

[0062] In an embodiment, a gaming client device is comprised in said server.

[0063] In an embodiment, the one or more PGH computer games are loaded and run, and the loading and running include: resuming events from a computer base game; capturing video or other signals of the base game; transmitting the captured video or other signals to a server; processing the video using a video analysis processor, or processing the signal using a signal analysis processor; determining whether PGH attribute parameters have been obtained based on PGH rules and the analyzed video or analyzed signal; and calculating scoring parameters.

[0064] According to a fourth aspect of the present invention, there is provided a system for creating one or more playable gameplay highlight (PGH) computer games from a computer base game, the system comprising a game client device, the game client device comprising a processing circuit, the processing circuit comprising one or more processors, the one or more processors comprising an event module configured to communicate with a PGH server, the PGH server comprising a storage unit for storing the PGH computer game and one or more server processors, wherein the server processor comprises a video processor, a logic engine and a PGH publisher, wherein the logic engine is configured and capable of: receiving data related to the computer base game, wherein the data comprises one or more of the following: events, text, audio, images, video recordings, other videos describing the base game; processing data to generate events; processing events to generate building blocks, or processing data to generate building blocks; capturing one or more highlights in the computer base game, wherein each of the captured one or more highlights one corresponding to a selected starting point and an ending point in the computer base game; the logic engine processes the building blocks to generate highlight attribute parameters, the highlight attribute parameters including one or more of possible goals, possible constraints, possible PGH ending criteria, possible ending conditions and possible scoring parameters respectively associated with each of the one or more highlights; selects a PGH highlight in each of the one or more highlights, wherein the PGH highlight corresponds to the selected starting point and an ending point in one of the one or more highlights; the logic engine, for example, repeatedly processes the building blocks associated with the selected PGH highlight to generate PGH attributes, the PGH attributes including one or more of goals, constraints, PGH ending criteria, ending conditions and scoring parameters; creates the one or more PGH computer games based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, which are associated with the PGH attributes and are used to configure the gameplay of the one or more PGH computer games.

[0065] In an embodiment, the one or more processors are further configured and capable of: loading and running the one or more PGH computer games, the loading and running including: resuming events related to the base game; continuously identifying events in the one or more PGH computer games; continuously streaming the identified events from the game client device to the logic engine; continuously processing the identified events using the logic engine to generate the building blocks; continuously processing the building blocks using the logic engine to determine whether PGH attribute parameters have been obtained based on PGH rules; and ending the gameplay of the one or more PGH computer games when the PGH attribute parameters have been obtained.

[0066] In an embodiment, the one or more processors are further configured and capable of: generating a PGH state for each of the one or more PGH computer games, wherein generating the PGH state includes: calculating one or more of a scoring parameter, a state of a goal, a state of a constraint, a state of a PGH end criterion; and transmitting the PGH state to a management module included in the server; and providing server events based on the PGH state, one or more of the building blocks.

[0067] In an embodiment, the one or more processors are further configured and capable of: recovering events from a base game; capturing video or other signals of the base game; transmitting the captured video or other signals to a server; processing the video using a video analysis processor, or processing the signal using a signal analysis processor; determining whether PGH attribute parameters are obtained based on PGH rules and the analyzed video or analyzed signal; and calculating scoring parameters.

[0068] According to a fifth aspect of the present invention, a non-transitory computer-readable medium is provided, which contains program instructions for creating one or more playable gameplay highlight (PGH) computer games from a computer base game, wherein execution of the program instructions by one or more processors of a computer system causes the one or more processors to perform a method, the method comprising: using a logic engine to receive events or data related to the computer base game, wherein the logic engine is included in a processor located in a server; processing events by the logic engine to generate building blocks, or processing data by the logic engine to generate building blocks; capturing one or more highlights in the computer base game, wherein each of the captured one or more highlights corresponds to a selected starting point and an ending point in the computer base game; processing the building blocks by the logic engine to generate highlight attribute parameters, the highlight attribute parameters including parameters corresponding to the one or more highlights, respectively. One or more of possible goals, possible constraints, possible PGH ending criteria, possible ending conditions and possible scoring parameters associated with each of one or more highlights; selecting a PGH highlight in each of the one or more highlights, wherein the PGH highlight corresponds to a selected starting point and an ending point in one of the one or more highlights; processing the building blocks associated with the selected PGH highlight by the logic engine (e.g., repeatedly) to generate PGH attributes, wherein the PGH attributes include one or more of the following: goals, constraints, PGH ending criteria, ending conditions and scoring parameters, the selected starting point and the ending point; creating the one or more PGH computer games based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, which are associated with the PGH attributes and are used to configure the gameplay of the one or more PGH computer games. BRIEF DESCRIPTION OF THE DRAWINGS

[0070] In order to understand the invention and to see how it may be carried out in practice, embodiments will be described by way of non-limiting examples with reference to the accompanying drawings, in which:

[0071] Figure 1A and Figure 1B A logic block diagram illustrating an example gaming system that can be used to create a PGH that enables players to re-experience historical gameplay scenarios according to some embodiments of the present invention;

[0072] Figure 1C A logic block diagram illustrating an example gaming system that can be used to replay a PGH that enables a player to re-experience a scenario of historical gameplay according to some embodiments of the present invention;

[0073] Figure 2An example user interface of a system for creating a PGH that enables players to re-experience scenarios of historical gameplay according to some embodiments of the present invention is shown;

[0074] Figure 3 is a flow chart of an example method of creating a PGH that enables players to re-experience scenarios of historical gameplay according to some embodiments of the present invention;

[0075] Figure 4 shows an example data structure of a PGH data object that enables a player to re-experience a scenario of historical gameplay according to some embodiments of the present invention;

[0076] FIG. 5A to FIG. 5E is a flow chart of an example method of replaying a PGH that enables a player to re-experience a scenario of historical gameplay according to some embodiments of the present invention;

[0077] Figure 6 is a flow chart of an example scenario of initial user creation and secondary user play of a PGH that enables players to re-experience a scenario of historical gameplay according to some embodiments of the present invention;

[0078] Fig. 7A is a high-level block diagram of an example system configured and capable of creating a PGH using building blocks based on one or more scenarios of historical gameplay in a computer base game according to some embodiments of the present invention;

[0079] Figure 7B is a high-level block diagram of an alternative system according to some embodiments of the present invention, the alternative system being configured and capable of creating a PGH based on one or more scenarios of historical gameplay in a base game, the alternative system comprising a Creation Input Module;

[0080] Figure 7C A flow chart showing a method for creating a PGH using building blocks based on one or more scenarios of historical gameplay according to an embodiment;

[0081] Fig.7D A flow chart is shown of a method for creating a PGH based on one or more scenarios of historical gameplay according to an embodiment, the method comprising receiving an identified event or processing data to produce an identified event;

[0082] Fig. 7E shows a high-level block diagram of an exemplary system for supporting loading and running a PGH created based on one or more scenarios of historical gameplay in a base game, according to an embodiment;

[0083] Figure 7F A method for loading and running a PGH computer game (such as in Fig. 7A A flowchart of the method of PGH) created in;

[0084] Figure 7G A method for loading and running a PGH computer game (such as in Figure 7B A flowchart of the method of PGH) created in;

[0085] Figure 7H It shows that according to the embodiment Fig. 7A A detailed block diagram description of the processor;

[0086] Fig.7I An alternative configuration architecture according to an embodiment is presented, wherein a logic engine may include a data conversion module configured and operable to receive and / or extract data and convert the data into identified events;

[0087] Figure 7J It shows that according to the embodiment Fig. 7A and Figure 7B A detailed block diagram of a device configured and capable of creating a PGH based on one or more scenarios of historical gameplay of a single player configuration;

[0088] Figure 7K A detailed block diagram of a system according to an embodiment is shown, the system being configured and capable of creating a PGH based on one or more scenarios of historical gameplay of a multiplayer configuration;

[0089] Figure 7L It shows that according to the embodiment Figure 7K A block diagram of a subset of a game that is configured and capable of publishing and distributing one or more assets of a base game and a PGH based on one or more scenarios of historical gameplay in a single player / multiplayer configuration;

[0090] Figure 7M A flow chart showing a method of asset extraction and decomposition according to an embodiment;

[0091] Fig. 8A A flow chart illustrating a method for creating a PGH based on one or more scenarios of historical gameplay in a multiplayer or single-player configuration according to an embodiment;

[0092] Figure 8B A method for playing a PGH (such as Fig. 8AA time flow chart of a method of creating a PGH) shown in FIG. 1 , wherein the PGH is created based on one or more scenarios of historical gameplay in a multiplayer or single player configuration;

[0093] Figure 8C Extraction and decomposition of base games and / or PGHs (such as Fig. 8A A flowchart of a method for creating an asset in a PGH) as shown in FIG;

[0094] Fig.8D A flow chart showing a method for publishing assets in a base game and / or PGH according to an embodiment;

[0095] 9A to 9E shows examples of event lists, target lists, constraint lists, score parameter lists, and end condition lists according to an embodiment;

[0096] FIG. 10A to FIG. 10G shows examples of screenshots of games and PGHs according to an embodiment;

[0097] Fig.11 shows examples of screenshots of games and PGHs according to an embodiment, including the status of objectives and PGH results;

[0098] Fig.12 shows an example data structure of a PGH data object according to some embodiments;

[0099] Fig.13 A flow chart showing a method for loading and running a PGH computer game according to an embodiment; and

[0100] Fig.14 A computer system suitable for incorporating methods, systems, and apparatus according to embodiments is shown.

[0101] Detailed Description of the Invention

[0102] In the following detailed description, many specific details are set forth in order to provide a thorough understanding of the present invention. However, it will be appreciated by those skilled in the art that the subject matter of the present disclosure may be practiced without these specific details. In other examples, well-known methods, processes, components and circuits are not described in detail in order not to obscure the subject matter of the present disclosure.

[0103] The embodiments disclosed herein may be combined in one or more of a variety of ways to provide a method for creating and running one or more playable gameplay highlights (PGH) computer games from a computer base game.

[0104] As used herein, like characters refer to like elements.

[0105] According to an embodiment, the present invention is configured to receive a basic / original computer game (e.g., computer base game 705) with historical rules and create a new game, which is defined as PGH in this article. The generated PGH can be related to the basic / original computer game, and / or inspired by the basic / original computer game, and / or based on the basic / original computer game. However, it should be emphasized that the relationship between the computer base game and the newly formed PGH mainly involves the theme in the original game. For example, in the case where the computer base game is an NBA or racing computer game, the original game and PGH will share the titles of NBA and racing games, and the titles of NBA and racing games will include characters such as basketball players and racing cars, respectively, so the original game and PGH will share some characters. However, the generated PGH includes new rules, goals and / or constraints not included in the original game, and therefore cannot be played according to these rules in the basic computer game.

[0106] Simply put, a PGH game takes inspiration from the genre or theme of the original game, but it introduces new gameplay mechanics, objectives, and restrictions that make it a different experience from the original game.

[0107] As described herein, new rules can be created by a user and / or automatically by the system. In some cases, new rules can be created using, for example, generative AI methods and systems, such as using a language model (e.g., Llama 2) to convert, for example, a user's free text input into structured rules and / or goals and / or scoring parameters.

[0108] One of the differences between the present invention and the prior art is the method of creating new playable content from a game. According to an embodiment, the present invention includes breaking down an original game into, for example, building blocks or any type of data by analyzing, for example, events in the game, and creating a new game (e.g., PGH) whose rules and gameplay are different from the original game based on identifying various events.

[0109] Specifically, analyzing events in the game includes analyzing gameplay data and identifying important events, and processing events on a server, for example, to create PGH building blocks. These building blocks are then used to develop new goals, constraints, and rules to enhance the original gameplay experience. In contrast, the prior art creates games such as "mini-games" by selecting a specific snapshot of the original game state at a selected starting point within the original game and identifying triggers for in-game events. Mini-games are generated using scripts based on snapshots and triggers, extracting limited portions of the game to provide shorter, independent experiences.

[0110] Another key difference between the present invention and the prior art is the expected player experience. The PGH generated by this method is intended to allow players to re-experience the exciting moments in the original game while introducing new elements, such as goals, constraints, and scoring mechanisms. This method enhances the original gameplay by adding new challenges and rewards. Prior art solutions (such as mini-games) do not introduce new elements, but provide a condensed version of the original gameplay starting from a predetermined point.

[0111] Additionally, the present invention differs from the prior art in its technical approach and the type of player experience it provides. The present invention emphasizes the use of new objectives and scoring parameters to record, analyze, and enhance gameplay highlights, while the prior art focuses on extracting specific scenarios from saved game states to create shorter, independent mini-game experiences, but not new game experiences. The methods, devices, and systems of the present invention add new elements to expand the original gameplay, while the prior art condenses the game into a bite-sized experience.

[0112] Therefore, while the rules of computer games of the prior art (such as mini-game rules) are equivalent to the rules of the base game, the rules in the PGH may include one or more goals that were never part of the base game. For example, in a digitized basketball game (e.g., an NBA computer game), in a single-game setting, a player selects an existing NBA team and plays against an AI or another player. The player's goal is to score more than the opposing team and win the game by doing so. A PGH created based on a specific highlight of an NBA game may have the following goals: a player makes more than X passes (e.g., 10) between their teammates within a specific time frame, scores a shot from a distance at least equal to the scoring distance of the highlight of the PGH creator, or steals the ball from the opposing team within a specific time frame.

[0113] Operations in accordance with the teachings herein may be performed by a computer specially constructed for the desired purposes or by a general-purpose computer specially configured for the desired purposes by a computer program stored in a non-transitory computer-readable storage medium.

[0114] In addition, embodiments of the presently disclosed subject matter are not described with reference to any particular programming language. It should be appreciated that a variety of programming languages ​​may be used to implement the teachings of the presently disclosed subject matter as described herein.

[0115] In recent years, certain moments in games have received global attention, comparable to the attention paid to great moments in the Olympics or professional sports. Some embodiments of the presently disclosed subject matter provide systems and methods for enabling gamers to identify noteworthy or exciting sequences in their gameplay, and then generate shareable "PGHs" based on these game sequences so that these sequences can be "re-experienced". These PGHs can then be shared, for example, on social media, and have the potential to gain their own virality.

[0116] Some embodiments of the presently disclosed subject matter provide systems and methods for enabling a game player to create an unlimited number of new games from a computer base game with only one "click", the new games having new rules not included in the base game.

[0117] Furthermore, PGH was created to address several key challenges in the gaming industry. First, it aims to solve the problem of game discoverability, which has become increasingly difficult due to the staggering number of game releases on various platforms. In 2023 alone, Steam saw 14,532 game releases, while mobile app stores featured over 100,000 new games. PGH enables gaming communities to promote and market games through organic, user-generated content, which allows even smaller studios to gain visibility without having to rely solely on traditional marketing methods.

[0118] Secondly, the PGH according to the embodiment enables gamers to capture their best game moments and convert these moments into playable highlights that can be shared across social media platforms. PGH not only enhances the gaming experience of the community, but also serves as a powerful marketing tool for game studios, developers, and publishers. By integrating the PGH SDK, studios can enable their communities to showcase games, create demos, and provide early access rights to the media while focusing on optimizing the gaming experience. In addition, PGH helps studios improve the lifetime value of their users by promoting discovery in the game and encouraging players to explore more items, levels, characters, and DLCs.

[0119] In some embodiments, as will be described in detail below, the systems and methods taught herein can be applied to a wide variety of games and virtual experiences.

[0120] Before setting forth the detailed description of the present invention, it may be useful to set forth definitions of certain terms that will be used hereinafter.

[0121] The term "tracking data" as used herein and throughout the specification and claims should be understood to encompass data describing the initial user's complete gameplay (e.g., a first-person shooter game). The term refers to detailed information that is recorded during a gameplay session to capture and reproduce game state and player actions.

[0122] The term "time-based data" as used herein and throughout the specification and claims should be understood to encompass changes or modifications to the game state that are triggered at specific points or intervals in time relative to the start of the PGH. These changes are not related to any specific in-game event or player action, but occur automatically at predetermined times. For example, a new enemy character is spawned at the 15 second mark of the PGH.

[0123] The term "event-based data" refers to changes or modifications to the game state that are triggered by specific in-game events or player actions. These changes occur dynamically in response to certain conditions being met or certain actions taken by the player or other game entities. For example, changing the behavior of an enemy character when the player enters a certain area of ​​the game world.

[0124] The term "virtual object" as used herein and throughout the specification and claims should be understood to encompass any distinct element or entity within the game world that has its own properties and behaviors. Examples of virtual objects include, but are not limited to, characters (player characters and non-player characters), items (e.g., weapons, power-ups, collectibles), vehicles, buildings, and interactive elements of the game environment. Each virtual object is defined by a data set that describes its various properties, such as visual appearance, animations, physical properties, behavior scripts, interactive capabilities, and gameplay-specific features.

[0125] The term "creator" as used herein and throughout the specification and claims should be understood to encompass individuals responsible for conceiving, designing, and creating elements of a computer game, including but not limited to the game's concepts, rules, mechanics, levels, environments, characters, and other assets. Note that some of the above elements may be created automatically by algorithms, by the original game developer and / or mechanics, or in collaboration with other creators.

[0126] The term "playable gameplay highlights (PGH)" or "PGH" or "PGHs" or "PGH Game" or "PGH Games" as used herein and throughout the specification and claims should be understood to cover playable content created, for example, by a game player based on historical gameplay of a computer game or his own original gameplay. According to an embodiment, the created playable content can be played by any one or more users as if they were the original game players in that particular gameplay moment. Such playable content is time-limited, consistent with the length of the original gameplay. Each PGH includes goals and / or constraints and / or scoring parameters and / or end conditions 1224 and / or end PGH criteria 1222 set by the creator or by an algorithm (e.g., an artificial intelligence (AI) algorithm) or by a mixture of the two (e.g., multiple goals, some of which are created by the creator and some of which are created by the algorithm) based on the creator's gameplay, and includes a scoring system that evaluates the performance of each player according to the set scoring parameters. In some embodiments, the PGH includes rules (eg, objectives and / or constraints and / or ending conditions and / or PGH ending criteria) and scoring parameters that were never part of the rules of the base game.

[0127] The terms "original game" or "game" or "base game" or "computer game" or "computer base game" as used herein and throughout the specification and claims should be understood to cover the first or source computer game played by the original or initial game player. Computer games or PGHs can be all kinds of computerized games, such as two-dimensional games and three-dimensional games, first-person and third-person games, single-player / multiplayer games, racing, shooting or turn-based (e.g., chess) games, virtual reality (VR) / augmented reality (AR) games, scored / unscored games, board games, competition games, tournament games, adventure games, prize games, etc. The term "game" also includes non-competitive virtual "experiences" such as VR / AR concerts or VR / AR explorations of virtual territories, etc.

[0128] As used herein and throughout the specification and claims, the terms "gameplay" or "gameplays" or "game play" or "game plays" should be understood to encompass the way a player interacts with a game, including the states, actions, rules, mechanics, and structure presented by the game, as well as the actions and states of the player used to progress in the game, as well as the actions and states of other players (e.g., NPC players or other players in a multiplayer game). Gameplay refers to the overall data attributes that allow the game to be played, including the game's design, flow, and the player's engagement with the game's systems and content (including the engagement of other players). It involves the challenges players face, the choices they make, the actions they take, and the feedback and rewards they receive as a result of their interactions with the game world.

[0129] The term "player" as used herein and throughout the specification and claims should be understood to cover a user playing a base game or a PGH.

[0130] The term "Highlight" or "Highlights" as used herein and throughout the specification and claims should be understood to encompass selected timestamps or time intervals during gameplay of a computer game for which a player wants to create a PGH. An example of a "Highlight" may be a 20 second duration in an NBA computer game in which no other player successfully takes the ball away from the player.

[0131] The term "state" as used herein and throughout the specification and claims should be understood to encompass characteristics of an entity during gameplay. Examples of a "state" could be, for example, a player's position or player's health in a computer game.

[0132] The term "action" as used herein and throughout the specification and claims should be understood to encompass operations and / or movements performed by a player during a game, such as jumping, shooting, etc.

[0133] As used herein and throughout the specification and claims, the terms "Event" or events or "Identified Event" or "Identified Events" should be understood to cover the actions and states of a player and / or the actions or states of a game.

[0134] The term "media" as used herein and throughout the specification and claims should be understood to cover recordings of frames, video and audio of computer games.

[0135] The term "configuration" as used herein and throughout the specification and claims should be understood to encompass characteristics that define the PGH, such as objectives, scoring parameters, starting and ending points, thumbnails, titles, and the like.

[0136] The term "URL" (Uniform Resource Locator) as used herein and throughout the specification and claims should be understood to encompass a shareable link to a particular PGH.

[0137] The terms "Rule" or "Rules" or "PGH Rules" as used herein and throughout the specification and claims should be understood to cover Boolean formulas / clauses, including logical operations based on, for example, Boolean conditions from the PGH. In particular, a rule may be defined as a logic paragraph, such as one or more binary logic paragraphs associated with a selected played computer game segment comprising a PGH (such as a PGH building block). The rule may be based on a generated "goal" and / or "constraint" and / or "end condition" and / or "end PGH criteria 1222". In Fig. 9B , Fig. 9C and Fig.9E An example of such a rule is shown in .

[0138] As used herein and throughout the specification and claims, the term "objective" or "objectives" should be understood to encompass one or more goals that a PGH player needs to accomplish in order to win in a PGH game. Fig. 9B Examples of possible targets are shown in .

[0139] As used herein and throughout the specification and claims, the term "constraint" or "constraints" should be understood to encompass one or more conditions that, if met, cause the player to lose the PGH. Fig. 9C Examples of possible constraints are shown in .

[0140] The terms "Score" or "Scores" or "Scoring Parameter" or "Scoring Parameters" or "Score Parameters" as used herein and throughout the specification and claims should be understood to encompass a list of conditions that, if met, result in a player gaining a score. Scores may be positive or negative, and are cumulative, such that each time a new condition is met, the score is updated positively (i.e., by adding the score to the accumulated score) or negatively (i.e., by subtracting the score from the accumulated score). Fig.9D Examples of possible scoring parameters are shown in .

[0141] The term "End Condition" or "End Conditions" as used herein and throughout the specification and claims should be understood to encompass a condition that, if met, ends the PGH, where either the player wins the PGH game, or the player loses the PGH, or there may be no predefined PGH win or loss. Fig.9E Examples of possible ending conditions are shown in .

[0142] The terms "EndPGH Criteria" or "End of PGH Criteria" as used herein and throughout the specification and claims should be understood to encompass conditions that, if met, end the PGH, where either the player wins the PGH game or the player loses the PGH, or there may be no predefined PGH win or loss. Examples of possible End PGH Criteria 1222 are time limits (e.g., the player has 30 seconds to reach a goal), number of turns (e.g., in a chess game, the user has 20 turns to reach a goal), a mixture of number of turns and time limits (e.g., in a chess game, you have 5 turns and 120 seconds to reach a goal).

[0143] The terms "PGH building block" or "building block" or "building blocks" or "data building blocks" as used herein and throughout the specification and claims should be understood to cover formulas formed based on identified events (such as "actions" and / or "states") to create one or more "goals" and / or one or more "constraints" and / or one or more "end conditions" and / or one or more "end PGH criteria 1222".

[0144] As used herein, the terms "non-transitory memory" and "non-transitory storage medium" should be broadly construed to cover any volatile or non-volatile computer memory suitable for use with the presently disclosed subject matter.

[0145] The term "stream" as used herein and throughout the specification and claims should be understood to encompass digital data (such as audio or video material) that is transmitted continuously, one or more packets at a time, and is typically intended for immediate processing or playback.

[0146] The term "streaming" as used herein and throughout the specification and claims should be understood to encompass the act, process, or instance of streaming data or accessing streamed data.

[0147] The term "replayer" as used herein and throughout the specification and claims should be understood to be equivalent to the term "secondary user".

[0148] The terms "PGH data object" or "data object" as used herein and throughout the specification and claims should be understood to encompass the data required to play the PGH.

[0149] As used herein and throughout the specification and claims, the terms "graphic element" or "graphic elements" or "graphic asset" or "asset" should be understood to cover visual components within a game, such as characters, environments, objects, user interface elements, special effects, animations, textures, and art styles. Examples of graphical elements include, but are not limited to: meshes; a comprehensive set of textures such as albedo, normal maps, height maps, occlusion, detail masks, and baked lightmaps; support for other texture maps such as metallic, roughness, and emission maps; secondary maps, including detail albedo and secondary normal maps; UV maps for texture coordinates; shaders and materials that define visual appearance and light interaction; animation rigs with keyframes and curves for movement; colliders for physical interactions; physics states for dynamics and kinematics; real-time lighting elements with shadow maps and global illumination; reflection probes and screen-space reflections for accurate reflections; particle systems for special effects; post-processing effects for visual enhancement, such as bloom, motion blur, depth of field, tone mapping, and color grading; sound assets for spatial audio effects; AI navigation meshes for character pathfinding; Level of Detail for performance optimization The system also includes an occlusion culling and frustum culling system for improved rendering efficiency; and comprehensive scripting capabilities for controlling game logic and interactions.

[0150] Follow now Figure 6 , Figure 6 Flowchart 600 illustrates an example sequence of a user playing a game, creating a derived PGH, and sharing the derived PGH with other users, according to some embodiments of the presently described subject matter.

[0151] The initial user may play (610) a computer-based game (eg, on a personal computer, smartphone, tablet computer, dedicated gaming device, etc.).

[0152] While playing the game, the initial user may perform an action to "capture" (620) the completed gameplay. As a non-limiting example, the initial user may click (via, for example, an input device) on a "PGH capture icon" that is part of the user interface of the game, or press a key combination on a keyboard (e.g., the Alt key + the "g" key on a keyboard). Note that alternatively, in some embodiments, the initial user may initiate the "capture" (620) process during or after gameplay using some suitable interface. Alternatively, the capture process may be automatically triggered, for example, by an algorithm (e.g., an artificial intelligence (AI) algorithm) that automatically scores the shareability of the gameplay or the likelihood that a particular gameplay is suitable for creating a PGH from it.

[0153] In some cases, the PGH may be generated and "captured" (620) while the game is being played, such as before the game is completed.

[0154] The initial user's device may then make the data of the completed gameplay available to the PGH creation server 630. Note that the transmission of the gameplay data to the PGH creation server may occur concurrently with the gameplay or after the gameplay, may involve intermediate entities, etc.

[0155] According to another embodiment, data for the entire game is uploaded to the PGH's servers all the time during gameplay, so that the user can select specific highlights to turn them into PGH at a later time.

[0156] The server may then present (640) a user interface (UI) to the initial user. The presented user interface may enable the initial user to select specific segments / highlights of the completed gameplay or completed game to be included in the PGH (e.g., a 45-second sequence of gameplay from a 15-minute game session). The presented user interface may also enable the initial user to select a specific goal for the PGH (e.g., kill a certain number of enemies, move the protagonist to a specific point on the game terrain, etc.).

[0157] Next, the server may create (650) a data object that allows the PGH to be played, and may make this data object available to other users. As a non-limiting example: the server may maintain a web page that enables users to peruse such data objects, and then access a particular object to play the corresponding PGH. In some cases, a link to the created data object is provided. In some cases, the data object may be shared using known sharing methods, such as by sharing a link (such as a hyperlink address of an address), and the like.

[0158] Such a "secondary" user may then access the newly created PGH (e.g., by downloading, streaming, loading, etc.) and then play (660) the PGH and perform his or her own original gaming actions on the PGH.

[0159] According to another embodiment, and as in 7A to 7F and FIG. 8A to FIG. 8DAs shown in detail in , a secondary user can click on a link such as a PGH link, which sends a request to a server (e.g., a PGH server) to load the corresponding game, and then loads the corresponding PGH. This can occur by sending a request to the cloud (e.g., via a browser) to run the PGH or opening a dedicated app (e.g., a PGH app) to run the PGH, for example, the dedicated app can be cloud-based, or opening the base game on the secondary user's device and then opening the PGH on top of the base game.

[0160] As will be described in detail below, in some embodiments, certain techniques are utilized to enable the secondary user to experience the original game scenario as experienced by the initial user, while ensuring that the progression of the game actually complies with the original game rules, game physics, etc. In some embodiments, these techniques include:

[0161] (i) Reproducing time-based events from the original game in the PGH. For example: if a new enemy appears at a particular time in the original user's gameplay, or if an existing enemy takes an action spontaneously, the PGH system can replicate those enemy actions in the PGH gameplay at the same time offset as in the original game based on the data included in the PGH data object.

[0162] (ii) Reproducing event-triggered reactions in the original game in the PGH. For example: if in response to the initial user firing a weapon at an enemy, the enemy changes its position and fires back, the PGH system can replicate the enemy's behavior based on the data included in the PGH data object in response to the protagonist controlled by the secondary user firing a weapon at the specific enemy.

[0163] iii) Caged / uncaged NPCs: In order to obtain robust PGH behavior, it may be desirable for an NPC in a PGH to repeat all or some of the behaviors in the original game for a certain duration of the PGH, and then behave according to its NPC characteristics after that time. An NPC on the PGH that behaves according to the original game behavior is referred to herein as a "caged NPC", while an NPC that behaves according to its characteristics and / or other factors is referred to herein as an "uncaged NPC".

[0164] In some embodiments, the PGH data object may include data indicating whether the initial state of the NPC is imprisoned or unimprisoned. In some embodiments, the PGH data object may also include data indicating that the NPC should transition from its initial state (e.g., imprisoned) to another state (e.g., unimprisoned) in response to a specific event.

[0165] For example, data in a PGH data object may indicate that a particular NPC should transition from being imprisoned to being unimprisoned at a certain time upon entering the PGH or in response to a particular event in the PGH.

[0166] In some cases, it's not just the imprisoned / unimprisoned NPCs that change behavior based on the secondary user's behavior. This claim is much broader than that, it refers to any behavior of the game. This means that if the secondary user will choose similar choices as the initial user, then the general behavior of the gameplay highlights will be similar (not identical), but if the secondary user is switching things up and choosing different choices than the initial user, then the gameplay will behave differently (a specific example is imprisoned / unimprisoned NPCs).

[0167] According to some embodiments, it's not just the imprisoned / unimprisoned NPCs that change behavior based on the secondary user's behavior. For example, if the secondary user would choose similar choices as the initial user, then the general behavior of the gameplay highlights would be similar (e.g., not the same), but if the secondary user is switching things up and choosing different choices than the initial user, then the gameplay would behave differently (a specific example being imprisoned / unimprisoned NPCs).

[0168] focus on Figure 1A , Figure 1A is a block diagram of an example system 100 for creating a PGH data segment (PDS) that enables a game player to play a PGH based on a scenario of historical gameplay, according to some embodiments of the presently disclosed subject matter.

[0169] The game system 100A supporting PGH creation may be a game device such as a Sony Tm Playstation Tm , Microsoft Tm Xbox Tm Etc. Alternatively, the game system 100A supporting PGH creation may be a programmable device such as a personal computer (PC), a smart phone, a tablet computer, etc. Alternatively, the game system 100A supporting PGH creation may be another suitable platform.

[0170] The gaming system 100A supporting PGH creation may include a processing circuit 110A, which may in turn include a processor 120A and a memory 130A.

[0171] The PGH creation-enabled gaming system 100A may be operably connected to, for example, various peripherals, such as gaming-related peripherals. Such peripherals may include, for example, a gaming display / audio system 180 and a gaming controller 170. Peripherals may also include a virtual reality / augmented reality headset or other kinds of gaming or other peripherals.

[0172] The processor 120A may be a suitable hardware-based electronic device with data processing capabilities, such as a general-purpose processor, a digital signal processor (DSP), a dedicated application-specific integrated circuit (ASIC), one or more cores in a multi-core processor, etc. The processor 120A may also be composed of, for example, multiple processors, multiple ASICs, virtual processors, combinations thereof, etc.

[0173] Memory 130A may be, for example, a suitable type of volatile and / or nonvolatile storage device, and may include, for example, a single physical memory component or multiple physical memory components. Memory 130A may also include virtual memory. Memory 130A may be configured, for example, to store various data used in computing.

[0174] The storage device 160 may be a suitable type of volatile or non-volatile storage device, such as a hard disk, a solid state drive, or the like.

[0175] The processing circuit 110A may be configured to execute several functional modules according to computer-readable instructions implemented on a non-transitory computer-readable storage medium. Such functional modules are hereinafter referred to as being included in the processing circuit. These modules may include, for example, a game engine 150, a tracker module 105, and game-specific logic 140.

[0176] The game engine 150 may be a software module that implements general game functions, such as:

[0177] -Manage devices such as the game display / audio system 180 and the game controller 170, including receiving input from (and sending output to) such devices.

[0178] - Implement virtual objects used and displayed in the game (such as game terrain, obstacles, etc.).

[0179] -Provide an application programming interface (API) for provisioning virtual objects, determining the current state of virtual objects, and managing virtual objects.

[0180] For example, game engine 150 may be a commercial game engine, such as Unreal Engine. TM 、Unity TM wait.

[0181] The game engine 150 may include various sub-modules that implement “bullet physics,” “vehicle movement,” etc., thereby enabling ongoing changes in the game state to occur autonomously within the game engine 150 .

[0182] The game engine 150 may implement game state method changes in response to, for example:

[0183] ■ Pseudo-randomly generated events, such as pseudo-randomly appearing enemies in a first-person shooter game;

[0184] ■Game controller device events, such as a user pressing a game controller device button to fire a weapon;

[0185] ■Characteristics of virtual objects - for example, a moving vehicle can have a continuously updated position within the game terrain.

[0186] Game-specific logic 140 may be a software module that, in conjunction with game engine 150 and peripherals such as game display / audio system 180 and game controller 170, implements the actual game (e.g., a first-person shooter game, a racing game, a turn-based game such as chess, etc.) Game-specific logic 140 may interact with game engine 150 via an API.

[0187] In some examples, the game-specific logic 140 initially supplies an initial game scenario to the game engine 150. As a non-limiting example: in a racing game, the game-specific logic 140 may initially supply the game engine 150 with virtual objects including a track with a specific topology, a first-person player car with a position on the track, non-player cars with specific appearance and motion characteristics, etc. The game-specific logic 140 may perform the supply of the initial game scenario via an API of the game engine 150.

[0188] The game-specific logic 140 may include a tracker module 105. The tracker module 105 may write tracking data to a storage device. The tracking data may include data indicating, for example:

[0189] a) data read from the game engine 150 by the game-specific logic 140 that describes the current properties of virtual objects and the relevant game state;

[0190] b) Data written (or to be written) by the game engine 150 to the game-specific logic 140 that describes - as programmed for the particular game - the current properties of the virtual objects and the relevant game state.

[0191] The tracker module 105 may write the tracking data in a specific data format (referred to herein as a "tracking data format"). The tracking data format may reduce complex virtual object definitions to a smaller amount of data. For example, a large number of virtual object characteristics describing a car (e.g., color, wheel style, height, etc.) may be represented by 3 bits that identify one of the 8 car types implemented in a racing game.

[0192] The tracer module 105 may write the trace data in, for example, 2 packets:

[0193] a) a packet containing data describing the initialization data, and

[0194] b) Packets containing data describing subsequent changes to virtual objects and game state events.

[0195] Data describing subsequent changes to virtual objects and game state events may include data indicating when the change occurred in the game (e.g., a timestamp).

[0196] Data describing subsequent changes to virtual objects and game state events may include, for example, images (e.g., screenshots) or video clips indicating game events at the time of the changes / events.

[0197] The game specific logic 140 may include an upload module 115. The upload module 115 may upload, for example, the tracking data 125 to, for example, a PDS server 195 via, for example, a network link 190.

[0198] For example, the PDS server 195 may be a suitable type of physical server or cloud-based server that includes processing circuitry 110B, which in turn may include a processor 120B and a memory 130B.

[0199] The processor 120B may be a suitable hardware-based electronic device with data processing capabilities, such as a general-purpose processor, a digital signal processor (DSP), a dedicated application-specific integrated circuit (ASIC), one or more cores in a multi-core processor, etc. The processor 120B may also be composed of, for example, multiple processors, multiple ASICs, virtual processors, combinations thereof, etc.

[0200] The memory 130B may be, for example, a suitable type of volatile and / or nonvolatile storage device, and may include, for example, a single physical memory component or multiple physical memory components. The memory 130B may also include virtual memory. The memory 130B may be configured, for example, to store various data used in computing.

[0201] The processing circuit 110B may be configured to execute several functional modules according to computer-readable instructions implemented on a non-transitory computer-readable storage medium. Such functional modules are hereinafter referred to as being included in the processing circuit. These modules may include, for example, a PGH creation module 145 and a re-gaming logic 135.

[0202] The PGH creation module 145 may be a software module that accesses the uploaded tracking data 155, presents (for example) a user interface (e.g., a web-based user interface) to the user, and then constructs the PGH data segment using the tracking data and (optionally) user input (i.e., user input for setting creation parameters, see, for example, 330). Figure 3 A flowchart of an example method of outputting a PDS is presented. Figure 4 An example format of a PGH data segment is presented.

[0203] The regamation logic 135 may be a software module that receives (eg, via a user interface such as a web-based user interface) data indicating scoring parameters for the PGH and / or game end criteria for the PGH.

[0204] As a non-limiting example, the tracking data may include data describing the initial user's complete playthrough of a game (e.g., a first-person shooter game). Within the complete playthrough of the game there may be multiple scenarios with many different types of enemies and targets, different terrains, and different objectives.

[0205] In some embodiments, the PGH creation module 145 may present a web-based interface to the initial user, allowing him or her to select a particular scenario within a longer game that will form the basis of the PGH. For example, the selected scenario may involve the protagonist needing to kill a specific number of enemies located at a specific location in a specific terrain. In some such embodiments, the web-based interface displays still images or video clips (included in the uploaded tracking data 155) to help the user select a scenario.

[0206] In some such embodiments, the re-gamification logic 135 may then provide a variety of possible game-specific scoring parameters (e.g., time to kill all enemies, number of enemies killed in 30 seconds, etc.) to the PGH creation module 145 and receive the initial user's selection.

[0207] In some embodiments, the PGH creation module 145 may create a PGH data segment 165. In some such embodiments, the PGH creation module 145 writes data indicating one or more virtual objects that were part of the initial state of the selected segment (i.e., the virtual objects that existed when the replaying user began playing the game). The data may be a derivative of the uploaded tracking data 155 and may be written to the PGH data segment 165 in a tracking data format or a different data format. The data may describe the virtual object in a manner sufficient to enable the replaying player to configure the virtual object into the game engine.

[0208] In some embodiments, the PGH creation module 145 may also write data indicating time-based modifications to the PGH. For example, the PGH creation module 145 may write data indicating one or more virtual objects to be added to the game, or one or more changes to already defined virtual objects, or one or more deletions to already defined virtual objects. The data indicating these virtual objects may be derivative data of the uploaded tracking data 155 and may be written to the PGH data segment 165 in a tracking data format or a different data format.

[0209] The data of the time-based modification may be accompanied by an explicit timestamp indicating the time offset in the PGH when the modification should occur. In some embodiments, the timestamp is implicit (eg, each time-based modification may represent a change occurring at 10ms intervals).

[0210] This data may describe the virtual object in a manner sufficient to enable a returning player to configure the virtual object into the game engine at the appropriate time offset.

[0211] As a non-limiting example: the PGH creation module 145, while processing the uploaded tracking data 155, may detect virtual object initializations and modifications that occur after the portion of the game used to create the PGH begins. As a more specific example: in some embodiments, the PGH creation module 145 may examine the uploaded tracking data 155 for tracking data that indicates that a new enemy suddenly appears from a newly visible terrain feature (such as a building). The PGH creation module 145 may then create time-based modifications to the PGH accordingly to create new virtual objects corresponding to the new enemies.

[0212] In some embodiments, the PGH creation module 145 may also write data indicating event-based modifications to the PGH. For example, the PGH creation module 145 may write data indicating one or more virtual objects to be added to the game, or data indicating one or more changes to already defined virtual objects, in response to a particular event occurring in the game (e.g., in response to an action by a protagonist). The data indicating these virtual objects may be derivative data of the uploaded tracking data 155, and may be written to the PGH data segment 165 in a tracking data format or a different data format.

[0213] The data may describe the virtual object in a manner sufficient to enable a returning player to configure the virtual object into the game engine in response to the indicated event.

[0214] As a non-limiting example: the PGH creation module 145, when processing the uploaded tracking data 155, can evaluate which virtual object initializations and modifications are due to the protagonist's actions or due to other game events, and which virtual object initializations and modifications are spontaneous, i.e., not caused by a causal sequence of other virtual objects. As a more specific example: in some embodiments, the PGH creation module 145 can examine tracking data from the uploaded tracking data 155, which indicates that a stationary non-player character (NPC) becomes active (e.g., by attacking the protagonist) in response to being hit by a projectile fired by the protagonist. The PGH creation module 145 can then determine that the NPC behavior is in response to the protagonist's behavior, and create event-based modifications to the PGH accordingly.

[0215] In some embodiments, the PGH creation module 145 may also write data indicating re-gamification data to the PGH. For example, the PGH creation module 145 may write data indicating scoring parameters and / or game end criteria to the PDS.

[0216] In some embodiments, PGH creation module 145 may write data into the PDS indicating virtual object release criteria associated with a particular virtual object (eg, in initialization data, time-based data, or event-based data).

[0217] The virtual object release criteria are events that cause the replaying player to stop their ongoing control of the game engine when the event occurs to replicate the virtual object behavior of the game played by the initial user. Thereafter, the replaying player can implement different behaviors on the object depending on the game situation. In some examples, the virtual object release criteria can be a time offset into the PGH.

[0218] As a non-limiting example: in a racing game, there may be an NPC car virtual object. The PGH creation module 145 may configure the PDS so that at a certain time offset when the replaying player plays the PGH, the car no longer reflects the behavior of the NPC car virtual object in the game played by the initial player, but follows a different behavior. For example, the original behavior of the NPC may be that the NPC car virtual object slows down before a certain turn in the road, and the non-mirrored behavior may be that the car speeds up in that particular turn.

[0219] focus on Figure 1B , Figure 1B is a block diagram of an example variation of a system for creating a PGH data segment (PDS) according to some embodiments of the presently disclosed subject matter. Figure 1B In some embodiments, the PGH creation function is divided between the PGH creation module 145A (located in the tracker module of the gaming system 100A) and the PGH creation module 145B (located in the PDS server). In this case, the PGH creation modules can be divided in any suitable manner. For example, in some embodiments, the PGH creation module 145A can prepare time-based modification data and event-based modification data, while the PGH creation module 145B can continue to receive user-selected scoring parameters and prepare re-gamification data.

[0220] focus on Figure 1C , Figure 1C is a block diagram of an example gaming system that supports playing PGH using a PGH data segment (PDS) based on a historical gameplay scheme, according to some embodiments of the presently disclosed subject matter.

[0221] use Figure 1C A PGH player of the system 100B can download the PGH data segment 165 from the PDS server 195, for example. The PDS replay module 185 can then use the PGH data segment 165 to provide the PGH. Figure 4 A detailed description of an example method for providing a PGH based on the PGH data segment 165 is presented.

[0222] focus on Figure 2 , Figure 2 is an example user interface presented to an initial player of a game according to some embodiments of the presently disclosed subject matter. Figure 2 The screen shown in includes a selection interface element (210) that enables the initial user to select a time range from the original game that will serve as the basis for the PGH. The interface also shows still frames of the gameplay, which can be images that are included in the uploaded tracking data 155 (after being placed in the tracking data 125 by the tracker module 105) and then extracted at the PDS server 195.

[0223] Figure 2 The screen shown also includes a scoring parameter interface element (220) and a game end criteria interface element (230), which may also be referred to as a "goal", wherein the scoring parameter interface element enables the initial user to specify the scoring parameters for the PGH and the game end criteria interface element enables the initial user to specify the conditions based on which the PGH should be completed.

[0224] Follow now Figure 3 , Figure 3 A flowchart 300 is shown of an example method of creating a PGH data segment according to some embodiments of the presently disclosed subject matter.

[0225] The processing circuit 110B of the PDS server 195 may receive ( 310 ) tracking data uploaded from, for example, the initial player's gaming system 100A.

[0226] The processing circuitry 110B of the PDS server 195 (e.g., the PGH creation module 145) may then present (320) a user interface (e.g., a web-based interface or a protocol-based interface, etc.) to the initial player to enable the user to specify parameters for creating a PGH based on the uploaded tracking data 155.

[0227] The processing circuitry 110B (eg, the PGH creation module 145 ) of the PDS server 195 may receive (or determine) ( 330 ) a start time, end criteria, and one or more scoring parameters for the PGH.

[0228] In some embodiments, the initial user can select a starting time (eg, a time offset in the original game that will be used as the starting point for the PGH) from a user interface.

[0229] In some other embodiments, the processing circuit 110B of the PDS server 195 (eg, the PGH creation module 145 ) determines the start time via a different mechanism (eg, starting from when the uploaded tracking data 155 starts).

[0230] In some embodiments, the initial user can select the PGH end criteria from the user interface. For example, the user can specify a time offset in the original game as the end, or the user can select the criteria for the end of the game, such as the number of enemies killed.

[0231] In some other embodiments, the processing circuitry 110B of the PDS server 195 (eg, the PGH creation module 145 ) determines the game end criteria via a different mechanism (eg, utilizing the end of the uploaded tracking data 155 ).

[0232] In some embodiments, the initial user can select one or more scoring parameters from the user interface. For example, the user can select a scoring parameter from a game-specific drop-down list presented by the user interface.

[0233] In some other embodiments, the processing circuit 110B of the PDS server 195 (e.g., the PGH creation module 145) determines the scoring parameter via a different mechanism (e.g., using a single scoring parameter suitable for the game). For example, if it is a racing game, the system may automatically set the scoring parameter to the time of one lap. If it is a first-person shooter game, the scoring parameter may be automatically set to the number of enemies killed.

[0234] The processing circuitry 110B (eg, the PGH creation module 145 ) of the PDS server 195 may then write ( 340 ) the initial virtual object data to the PGH data segment (PDS) 165 .

[0235] The processing circuitry 110B of the PDS server 195 (eg, the PGH creation module 145 ) may write ( 350 ) the time-based data to the PDS 165 , the time-based data including the new virtual object and / or the modified virtual object.

[0236] The processing circuitry 110B of the PDS server 195 (eg, the PGH creation module 145 ) may write ( 360 ) event-based data to the PDS 165 , the event-based data including the trigger event, the new virtual object, and / or the modified virtual object.

[0237] The processing circuitry 110B (eg, the PGH creation module 145 ) of the PDS server 195 may write ( 370 ) the re-gamification data (eg, game end criteria / goals, constraints, PGH end criteria, end conditions, scoring parameters) to the PDS 165 .

[0238] The processing circuitry 110B of the PDS server 195 (eg, the PGH creation module 145 ) may make the PDS 165 accessible (eg, downloadable) to enable others to play the PGH.

[0239] Follow now Figure 4 , Figure 4 An example data structure of a PGH data segment according to some embodiments of the presently disclosed subject matter is shown.

[0240] PGH data segment 400 may include initial virtual object data 410, which in turn may include zero or more virtual object descriptors 415A, 415B, ... 415n. Each virtual object descriptor may be a data packet representing a set of virtual object parameters that a game system supporting PGH play should instantiate when PGH starts.

[0241] The PGH data segment 400 may include time-based data 420, which may in turn include zero or more time descriptors (e.g., Figure 4 425B). Each time descriptor may describe a time offset of the PGH. Each time descriptor may be associated with one or more new virtual object descriptors (e.g., new virtual object descriptor 425C) and / or one or more changed virtual object descriptors (e.g., changed virtual object descriptor 425B).

[0242] Each new virtual object descriptor may be a data packet that represents a set of virtual object parameters that a gaming system supporting PGH play should instantiate at a time offset in the PGH (as indicated by the associated time descriptor).

[0243] Each changed virtual object descriptor may include an identifier of an already instantiated virtual object and may be a data packet representing a set of virtual object parameters that a gaming system supporting PGH gameplay should apply to the corresponding already instantiated virtual object at a time offset in the PGH (as indicated by the associated time descriptor).

[0244] The PGH data segment 400 may include event-based data 430, which may include zero or more event descriptors (e.g., event descriptors 435A-435C). Each event descriptor may relate to a virtual object within the PGH and may describe an event that may occur within the PGH (e.g., the death of an enemy, the protagonist reaching a target destination, etc.). Each event descriptor may be associated with one or more new virtual object descriptors (e.g., new virtual object descriptor 425C) and / or one or more changed virtual object descriptors (e.g., changed virtual object descriptor 425B).

[0245] As previously described, each changing virtual object descriptor may include an identifier of an already instantiated virtual object and may be a data packet representing a set of virtual object parameters that a gaming system supporting PGH gameplay should apply to a corresponding already instantiated virtual object in response to an event in the PGH (as indicated by an associated event descriptor).

[0246] The PGH data segment 400 may include re-gamification data 440, which may in turn include game-ending criteria 445A and scoring parameters 445B. Game-ending criteria 445A may include data indicating when the game system supporting the PGH gameplay should end the PGH (e.g., at a specific time, after completing a specific goal (such as the protagonist reaching a point in the terrain or killing a certain number of enemies) (or a combination of such criteria)). Scoring parameters 445B may include data indicating what the game system supporting the PGH gameplay should track and display as a measure of success in the PGH (e.g., number of enemies killed, strength of the protagonist, etc.).

[0247] Follow now FIG. 5A to FIG. 5E , FIG. 5A to FIG. 5E A flowchart 500 is shown of an example method of providing a PGH based on PGH data segments according to some embodiments of the presently disclosed subject matter.

[0248] FIG. 5A to FIG. 5E The method shown in FIG. 1 may be implemented by, for example, a game system 100B supporting PGH play or by Figure 7C , Fig.7D , Fig. 7E to execute the system shown in .

[0249] The processing circuit 110A (eg, the PDS replay module 185 ) may receive ( 510 ) the PDS 165 .

[0250] The processing circuit 110A (eg, the PDS replay module 185 ) may then control the game engine 150 to instantiate ( 520 ) the initial virtual object indicated in the PDS 165 .

[0251] The processing circuit 110A (eg, the PDS replay module 185 ) may configure ( 530 ) the game-specific logic 140 and the game engine 150 to, for example, maintain and appropriately display data indicated by the scoring parameters.

[0252] The processing circuit 110A (eg, the PDS replay module 185 ) may initiate ( 540 ) play of the PGH, for example, by controlling the game engine 150 appropriately.

[0253] After a certain time interval, processing circuit 110A (e.g., PDS replay module 185) may evaluate whether the PGH time offset matches (550) the time descriptor in the time-based data. If so, processing circuit 110A (e.g., PDS replay module 185) may control (560) game engine 150 to instantiate a new virtual object or modify an existing virtual object based on the new virtual object data or the changed virtual object data in the corresponding time-based data of PDS 165.

[0254] In some embodiments, the processing circuit 110A (e.g., the PDS replay module 185) evaluates the time-based data and only controls the game engine 150 to instantiate new virtual objects or modify existing virtual objects that are not the game protagonist or are not controlled by the protagonist. In such embodiments, the processing circuit 110A (e.g., the PDS replay module 185) filters out the protagonist and objects controlled by the protagonist simply because the PGH behavior of the game protagonist is controlled by the game player, not by the events of the historical game (although the events of the historical game may still be used for comparison purposes). In some other embodiments, virtual objects that are the game protagonist or controlled by the game protagonist do not exist in the PDS 165.

[0255] Similarly, in some embodiments, a non-player character (NPC) may initially operate in a mode described above as "imprisoned mode". In this state, the NPC may behave as it did in the original historical game played by the initial player. In such embodiments, upon the occurrence of a trigger (i.e., an event that the system has chosen to create), the NPC begins to exhibit changes in its behavior - for example, the NPC may exhibit behavior forward according to an artificial intelligence decision tree (rather than behavior in the historical game).

[0256] More specifically: In such an embodiment, the processing circuit 110A (e.g., the PDS replay module 185) evaluates the time-based data and only controls the game engine 150 to instantiate new virtual objects or modify existing virtual objects when they are not associated with virtual object release criteria that have been met. As described above, meeting the virtual object release criteria indicates that the corresponding virtual object (e.g., NPC, etc.) should no longer reflect the behavior in the historical game, but should operate according to different (e.g., game-specific) characteristics.

[0257] Processing circuitry 110A (e.g., PDS replay module 185) may continuously evaluate whether new game events occurring during the PGH match (570) event descriptors in the event-based data of PDS 165. If a match is found, processing circuitry 110A (e.g., PDS replay module 185) may control (580) game engine 150 to instantiate new virtual objects or modify existing virtual objects based on new virtual object data or changed virtual object data associated with the corresponding event-based data of PDS 165.

[0258] The processing circuit 110A (e.g., the PDS replay module 185) may continually evaluate whether new game events match 585 the scoring parameters of the regaming data of the PDS 165. If so, the processing circuit 110A (e.g., the PDS replay module 185) may control 588 the game engine 150 to display the updated scoring information.

[0259] The processing circuit 110A (e.g., the PDS replay module 185) may continuously evaluate (590) whether the game end criteria are met. If so, the processing circuit 110A (e.g., the PDS replay module 185) may end (595) the game. Otherwise, the game play may continue, for example, the processing circuit 110A (e.g., the PDS replay module 185) may return to re-evaluate (550) whether the PGH time offset matches (550) the time descriptor in the time-based data.

[0260] Reference now Fig. 7A , Fig. 7A is a high-level block diagram of an example system 700 configured and capable of creating a PGH based on one or more scenarios of historical gameplay in a base game, according to some embodiments of the present invention.

[0261] According to one embodiment, the system 700 includes the following main modules / devices:

[0262] 1. Game client device 701

[0263] 2. Launcher Module 702

[0264] 3.PGH server 703

[0265] 4.PGH App 704

[0266] 1. Game client device 701:

[0267] According to an embodiment, the game client device 701 refers to a device or software that is configured to enable a user (e.g., a player or creator) to play an original game (e.g., a base game 705) or a PGH, and to process the original game or PGH using one or more processors 708, such as identifying one or more "events" in the original game in real time (or near real time).

[0268] According to some embodiments, the game client device 701 may be hosted in a server such as a video streaming server.

[0269] The game client device 701 can be any type of device, such as a smartphone, a personal computer (PC), a virtual reality (VR) device / glasses, a tablet computer, a smart watch, etc.

[0270] The original game (eg, base game 705) can be any game that a user (eg, game player) wants to play, and further can be used to create and play a PGH based on or involving one or more scenarios of historical gameplay of the original game.

[0271] According to an embodiment, the game client device 701 includes one or more processors 708 that include or are in communication with an event module 709 and a video module 706 .

[0272] The event module 709 is configured and capable of identifying events 715 in the base game 705 (e.g., in the case of creating a new PGH) and / or in the PGH (e.g., in the case of playing the PGH), and continuously (e.g., in real time) streaming the identified events 715 to the PGH server 703. The events 715 may include, for example, "actions" and / or "states" of characters in the base game 705.

[0273] The game client device 701 also includes a video module 706 that is configured and capable of recording the base game 705 and / or a view of the game (e.g., the game and all content layers that appear on the game, such as the current score of the game, the remaining time, etc.), and transmitting it to the PGH server 703 as raw data, or transmitting it to the PGH server 703 after processing the data (e.g., after combining the frames into a video or video clip).

[0274] 2. Launcher module 702:

[0275] According to an embodiment, the launcher module 702 is a software platform configured and capable of hosting, publishing and executing the PGH 738 and / or base game 705 (such as Microsoft Games, Sony Games, etc.).

[0276] In some cases, the launcher module 702 may also take the form of a virtual platform, similar to platforms such as Steam and GeForce Now, or may be located in a cloud gaming platform.

[0277] 3. PGH server 703:

[0278] According to an embodiment, the PGH server 703 may be any type of server, such as a backend application that may be hosted on, for example, a data center, such as a private or public data center.

[0279] Private data centers are usually owned and operated by the gaming companies themselves. They are used to host game servers, store player data, and manage game content. Private data centers provide better control and security for sensitive game data, including player profiles, game statistics, and in-game transactions. They also provide the infrastructure needed for game development, testing, and deployment.

[0280] Public data centers such as public cloud data centers may be, for example, Amazon Web Services (AWS), Microsoft Azure, and Google Cloud Platform, which provide scalable infrastructure services that are widely used in the gaming industry.

[0281] According to an embodiment, the PGH server 703 includes one or more processors 712 and one or more storage devices 713. The one or more processors 712 include a logic engine 714, a video processor 763, and a PGH publisher 733.

[0282] According to some embodiments, the processor 712 may be located in a local or external device or system (such as an external server or an external device).

[0283] According to one embodiment, the architecture of system 700 includes a separation between a logic engine process and a video creation process. Logic engine 714 includes receiving recognized events in base game 705 to generate, for example, building blocks 716 (such as Fig. 7E ), the building blocks 716 are further converted into highlight attributes (such as goals and / or constraints and / or scoring parameters in the game), and the video creation includes cutting out and editing the selected segments from the base game 705 and further building / restoring the selected segments. The highlight attributes are added and synchronized on top of the selected segment video to generate PGH attributes 735 for the PGH publisher 733 and PGH timestamps 763' for the video processor 763.

[0284] According to some embodiments, the logic engine 714 is configured and capable of receiving and / or extracting the identified events 715 from the event module 709, processing and analyzing the identified events 715, and generating building blocks 716 using logic rules and / or mathematical formulas (e.g., aggregate functions) applied to one or more types of events. For example, during a shooting game, the identified events may consist of "kill" events within the PGH, and one of the building blocks may be the number of kills in the PGH. In this example, the identified events consist of all kill events, and the mathematical formula may be a counting function on all kill events within the identified events, thereby generating a kill count building block. Another example is a shooting game, where the building blocks may consist of more than one event type: the identified events may consist of all "jump" events and all "kill" events attached. A possible building block in this game may be "air kill", where an "air kill" refers to killing an enemy in the game while the user is jumping. In this case, the building block verifies whether the player made a kill while he was jumping. Based on the building blocks 716, the logic engine 714 is also configured to generate highlight attributes 714', which are transmitted to the PGH App 704 for creating the PGH 738. The highlight attributes 714' include parameters including, for example, possible goals, constraints, end conditions 1224, PGH end criteria 1222, and scoring parameters to be used to play the PGH and configure the PGH rules.

[0285] In some cases, the building block 716 may be the same as the identified event 715. This means that no mathematical formula or aggregation is applied to the identified event 715 to create the building block 716. Alternatively, the building block 716 is a direct copy of the identified event 715 without any modification. For example, in a racing game, one of the identified events is "Lap Completed", which is triggered every time the player completes a lap around the track. If no aggregation or mathematical formula is applied to this event, the corresponding building block 716 may also be just "Lap Completed". Therefore, in this case, if the identified event is "Lap Completed", the resulting building blocks will be the same: "Lap Completed". The logic engine 714 can then use these building blocks 716 directly without any transformation to generate potential goals and / or constraints and / or scoring parameters and / or end conditions 1224 and / or PGH end criteria 1222 for the PGH. For example, a potential goal may simply be "Complete a Lap". Therefore, when building block 716 is the same as identified event 715, this means that the event is used as is without applying any modification or calculation to these events during the building block creation step. In this case, the original event itself serves as the base component for generating highlight attributes.

[0286] According to an embodiment, the logic engine 714 uses the building blocks 716 in an intermediate step to calculate and generate PGH parameters that will be included in the PGH 738 and will be used when playing the future generated PGH. Specifically, the building blocks 716 are used as raw materials for calculating PGH parameters, which include, for example, one or more of the goals, constraints, end conditions 1224, PGH end criteria 1222, and scores that will be used to play the PGH 738. The building blocks are used to generate all possible combinations (or subsets of combinations) of potential goals, constraints, end conditions 1224, PGH end criteria 1222, and scores (included in the transmitted highlight attributes 714') for use by the PGH creator or player to generate the PGH. For example, a captured highlight of the base game includes "10 kills" of enemies within a one-minute time period, the identified event is "kill", and the building block 716 will be used to generate various possibilities of goals, constraints, end conditions 1224, PGH end criteria 1222, and scoring parameters based on the "10 kills" in the highlight. Therefore, once the creator selects a time period from the highlight, such as a 30-second segment, the goals, constraints, end conditions 1224, PGH end criteria 1222, and scores will be updated accordingly. More specifically, in this example, assume that the first 30 seconds of the highlight include 8 of the 10 kills, and the second 30 seconds include 2 kills, totaling 10 kills in 1 minute. A potential initial goal for a highlight may be to kill 10 enemies within a one minute time period, and after the user selects the first 30 seconds (where the start time of the highlight is 0 seconds and the end time is 30 seconds, and 8 kills occurred in the original highlight within the first 30 seconds), the potential goal is updated based on the events and building blocks of the first 30 seconds, in this particular example the potential goal is updated to kill 8 people, and possible constraints, end conditions 1224, PGH end criteria 1222 and scoring parameters are also updated respectively.

[0287] According to an embodiment, the video processor 763 is configured and capable of receiving the captured video 717, and processing the video to generate a highlight video 763" that is transmitted to the PGH App 704. The video processor 763 is also configured to receive a PGH timestamp 763' selected during the gameplay of the base game regarding a time interval based on which the creator or player wants to create the PGH 738. The video processor 763 edits (e.g., cuts out) a relevant subset of the video in the highlight video based on the timestamp 763' and creates a final PGH video 775. For example, the timestamp 763' may include a first timestamp = 30 seconds and a second timestamp = 65 seconds, and based on these timestamps, the video processor cuts out the video starting at the first timestamp (30 seconds) and ending at the second timestamp (65 seconds), creates a final PGH video 775 with a total duration of 35 seconds, and transmits the final PGH video 775 to the PGH publisher 733.

[0288] The PGH publisher 733 is configured and capable of receiving the PGH attributes 735 from the PGH App 704 and the final PGH video 775 from the video processor 763, and publishing the PGH 738. In some cases, the published PGH 738 may be stored at the storage device 713. The publishing includes generating a digital representation of the PGH, including, for example, Fig.12 1 . In some embodiments, the PGH publisher 733 creates the PGH data object 1200 based on the start point and the end point of the selected PGH attribute, wherein the PGH publisher 733 further extracts events based on the start point and the end point of the PGH attribute (e.g., only events associated with the period between the start point and the end point are used), and saves the events to the PGH data object 1200 so that the PGH can be restored. For example, the start point and the end point can correspond to timestamps relative to the highlight (e.g., for a highlight of 2 minutes and 0 seconds, the start point can be 0:12 and the end point can be 1:01, which corresponds to 0 minutes and 12 seconds from the start of the highlight to 1 minute and 1 second from the start of the highlight), or alternatively, the start point and the end point can be relative to the number of rounds in a turn-based game (e.g., the start point can be at round 34 and the end point can be round 78).

[0289] Figure 7H It shows that according to the embodiment Fig. 7A As described above, in some cases, the logic engine 714 is configured and capable of, for example, receiving and / or extracting identified events 715 from the event module 709, processing and analyzing the identified events 715, and generating building blocks 716 using logic rules and / or mathematical formulas (e.g., aggregate functions) applied to one or more types of events.

[0290] Alternatively or additionally, the logic engine 714 may include a data conversion module 741 that is configured and capable of receiving and / or extracting data 7150 and converting the data into identified events 715 and / or building blocks 716. The data conversion module is configured and capable of converting such diverse input data into a standardized format of identified events 715 and / or building blocks 716 so that it can be further processed by the logic engine 714. In some embodiments, the data 7150 may be converted based on known conversion modules, for example, if the data conversion module 741 receives a text description of a key moment in a game, it will analyze the text and extract relevant events, such as player actions or game state changes. These extracted events will then be converted into a format that is the same / close to the identified events 715 that are typically generated by the event module 709. Similarly, if the input data is an audio commentary describing a particular gameplay sequence, the data conversion module 741 will process the audio, transcribe the relevant portions, and convert the information into discrete identified events 715 that capture key aspects of the described gameplay. By normalizing the input data to identified events 715, the data conversion module 741 allows the system to create PGH data objects 1200 and recover PGH from a wider range of input sources (not just raw gameplay data). Other examples of known conversion modules are neural networks (e.g., deep neural networks) that receive data 7150 as input, which may be of one type or a combination of two or more types, and compute a representation (i.e., the last layer of a neural network, or an aggregation function based on running the data input on a neural network function) to convert the representation into identified events 715 and / or building blocks 716 as output.

[0291] According to an embodiment, the data conversion module 741 may be located outside the logic engine (eg, in another external processor in a server).

[0292] Data 7150 may include one or more of the following: events of the base game, text, audio, images, video recordings, other videos describing the base game.

[0293] According to some embodiments, the PGH logic engine 714 uses the building blocks 716 to calculate the PGH score 7120 based on the scoring parameters and sends them to the PGH rules 719 to calculate the PGH state 777, which includes: the target state 12260, the constraint state 12280, and the end PGH criteria state 12220 (e.g., which parts of the criteria have been achieved). The PGH state 777 is calculated based on one or more of the target 1226, the constraint 1228, the end PGH criteria 1222, and the end condition 1224.

[0294] Fig.7I The embodiment shown in the preceding Figure 7H All basic components and functions are depicted in the Fig.7I An alternative configuration architecture is presented in which the logic engine 714 may include a data conversion module 741 that is configured and capable of receiving and / or extracting data 7150 and converting the data into identified events 715. Fig.7I , depicts an alternative embodiment of the present invention, which differs from Figure 7H In this configuration, building block 716 is omitted from the system architecture. Instead, this embodiment utilizes only identified events 715, which transform the data into identified events 715 through intermediate processing steps.

[0295] 4. PGH App 704:

[0296] According to an embodiment, PGH App 704 is a software application that is configured and capable of creating a PGH game 738 based on received input including highlight attributes 714' and highlight video 763", and outputting PGH attributes 735 and PGH timestamp 763', and also using, for example, a user interface 7360 including an information feed (Feed) 736 to manage a PGH platform on which PGH 738 can be discovered, executed, shared, etc.

[0297] The PGH App 704 includes a user interface including an information feed 736 and a PGH builder 734. The PGH builder 734 is configured to receive a highlight video 763" and highlight attributes 714' including one or more of a goal and / or zero or more constraints and / or zero or more end conditions and / or one or more PGH end criteria 1222 and / or one or more scoring parameters. The creator may use the highlight attributes 714' and the corresponding highlight video 763" and select a subset of the timeline of the captured highlights (e.g., select a starting point (e.g., a start timestamp) and an ending point (e.g., an end timestamp) of the captured highlights that may be a subset of the captured highlights). For example, in a captured highlight of 2 minutes in length, the starting point may be 10.5 seconds from the start of the highlight and the ending point may be 1 minute 12.2 seconds from the start of the highlight to create the PGH timestamp 763'. In addition, the creator may use the highlight attributes 714' (the highlight attributes 714' is based on the identified highlights processed by his own gameplay) events and / or building blocks) to select goals and / or constraints and / or scoring parameters and / or ending PGH criteria 1222 and other PGH attributes 735 (e.g., the name of the PGH, description, thumbnail "preview" image, tags, etc.) for generating the PGH attributes 735, which specifically relate to the video clips in the base game 705 (e.g., based on the selected PGH starting point of the highlight video 763", so that the highlight attributes 714 or building blocks all use the same timeline of the highlights, so that the creator can use the timeline of the highlight video 763" to scroll through the video and select the exact starting point he wants to select) in order to create the PGH attributes 735.

[0298] In operation, when a user plays the base game 705, the event module 709 extracts events from the game (e.g., from the game client 701) to the PGH server 703. Events include, for example, the state or action of one or more characters or the state or action of the game in the base game 705.

[0299] For example, the base game 705 may be an NBA computer game, and an "event" may be an action performed by one or more NBA players in the game. Events may be divided into multiple "event categories", such as "state events" and "action events".

[0300] "State events" are properties of an entity during the base game. Examples of "state" could be, for example, the position of a player in a computer game, or the health of the player.

[0301] An "action event" is an action and / or movement performed by a player during gameplay, such as a jump, an NBA player shooting a basketball, etc.

[0302] The identified events 715 are transmitted, e.g., in real time or near real time, along with the video 717 of the captured game, to one or more processors 712 in the PGH server 703. The one or more processors 712 include a video processor 763 and a logic engine 714. At the PGH server 703, the video processor 763 is configured and capable of processing the captured video 717 and generating processed videos, including, e.g., preview thumbnail videos and preview videos. Fig. 10D An example of a thumbnail video is shown in , which displays a PGH thumbnail 1050, allowing the user to easily select one or more highlights using the PGH thumbnail 1050. It should be emphasized that the video processor is also configured and capable of processing video clips and / or frames of the captured video 717.

[0303] Building blocks 716 are logic rules created based on translating identified events 715 (such as state 723' and action 724' events in base game 705) into logic phrases that can be understood by a PGH player or PGH creator.

[0304] According to an embodiment, each of the building blocks 716 is formed by aggregating one or more identified events 715. The aggregation function may be of the same type or different types of identified events 715. For example, in a fighting game, an "air kick" building block may be composed of an identified action "jump" in the base game and then an identified action "kick" within a specific time range.

[0305] As an example of aggregating the same type of events, a player's X degree movement in the game may be aggregated into a single Y degree movement that combines all of the individual movements. Similarly, if the player moves through a full 360 degrees in position, that movement may produce a "rotation" building block, according to an embodiment.

[0306] It should be noted that in some cases, the aggregation function may produce the same building blocks 715 as the original recognized event 715. In such instances, the aggregation function acts as an identity function that leaves the recognized event 715 unchanged. This means that the generated building blocks will be identical to the original event recorded in the game.

[0307] According to an embodiment, a user (e.g., a player or creator) may also activate "highlight" actions associated with one or more selected scenarios of gameplay of the base game 705. As the user plays the game, the selected "highlights" are transmitted along with the game events to one or more processors 712 in the PGH server 703, e.g., in real time.

[0308] As an illustration, within the context of a streamed NBA video game event, the event module 709 is used to identify specific in-game actions and states, such as "run," "pass," and "dribble," "position," "weapon." The term "highlight" relates to, for example, a specific segment of an NBA game lasting, for example, 20 seconds, in which a player successfully completes 20 consecutive passes without being intercepted by an opposing player.

[0309] For example, a newly created "goal" in an NBA game could be:

[0310] "When a PGH player's playerPosition equals the creator's playerPosition at the end of their highlight, they win the PGH."

[0311] This "goal" relates to a newly formed rule, which for the sake of this example we may name "Quick Run from A to B" in relation to the base NBA game. Based on this "goal", the player now has a new goal, which is not one of the goals of the NBA base game (e.g., base game 705), in which the player must move from point A (the start of the PGH) to point B (the original end point of the creator's PGH) in the NBA game.

[0312] The "PGH end criteria" may be, for example, a 10-second time limit, and the "end condition" may be, for example, the end of the NBA game of the original game (i.e., when there is no time remaining on the original game timeline, such as when there are 0 minutes and 0 seconds left on the clock of the fourth quarter of an NBA game).

[0313] The newly created "constraint" formula could be (in a non-limiting example): In an NBA game, a constraint could be to keep the ball in the hands of the same player, and not allow the ball to stay in the hands of other players (either from that player's team or the opposing team). This new "constraint" (which is not part of the base game) could be related to the original actions and / or states that the PGH creator made when he played the game, or to constraints that can be derived from those actions and / or states.

[0314] According to an embodiment, these goals, constraints, end conditions 1224 and PGH end criteria 1222 are created based on events automatically and / or autonomously identified in the NBA base game to create the above-mentioned goals and constraints. It should be emphasized that such new goals and constraints are never part of the rules of the NBA base game, and they can be created, for example, based on events that occur during the gameplay of the NBA base game.

[0315] Advantageously, as in Fig. 7A and further in FIG. 7B to FIG. 7EThe system architecture presented in the other figures of the present invention includes using a streaming module and method for transmitting recorded data of gameplay (e.g., captured video 717) and identified events (e.g., identified events 715), and one or more game engines and processors located in, for example, a cloud server (e.g., PGH server 703). Therefore, the creation of PGH is more configurable and can be used to create PGH for any type of game. Because the architecture according to the embodiment includes a streaming module and a transmission module, in some embodiments, it eliminates the need for a client SDK (such as Figure 7C The necessity of retaining, analyzing and storing data within the PGH Client SDK798) shown in.

[0316] Figure 7B The block diagram shown in the previous Fig. 7A All basic components and functions are depicted in the Figure 7B An alternative configuration architecture is presented in which the processor 708 includes a create input module 7080 located in, for example, the game client device 701.

[0317] Specifically, in this configuration, the event module 709 and the video module 706 are omitted from the system architecture. Instead, this embodiment utilizes the create input module 7080 to generate data for creating the PGH 738.

[0318] According to an embodiment, the creation input module 7080 is configured and capable of generating and transmitting and / or extracting data 7150 to the PGH server 703. The creation input module 7080 accepts various types of input data from users or creators, such as text, audio recordings, video clips, and gameplay data. It processes this data and transmits it to the PGH server 703 for further analysis and possible PGH creation. The creation input module 7080 can process input provided by users, as well as autonomously extract data, including events, from ongoing gameplay.

[0319] In one embodiment, the data 7150 generated by the creation input module 7080 is received by the logic engine 714 within the PGH server 703. In some cases, the logic engine 714 can convert the data 7150 into recognized events 715 and / or building blocks, such as Figure 7H and Fig.7I. The conversion process involves extracting key elements from the user-provided data and gameplay information and converting them into discrete, actionable events that can be used as the basis for the PGH data object 1200 and enable the creation and restoration of the PGH. By converting a wide variety of input data into a standardized format of recognized events and / or building blocks, the logic engine 714 enables the PGH creation system to work using a consistent and manageable data format (e.g., the PGH data object 1200).

[0320] According to an embodiment, a method, device and system for creating one or more additional PGH computer games based on one or more PGH computer games are provided. Therefore, an unlimited number of PGH computer games can be created based on each one or more PGH games created from a base game. The PGH rules and attributes of each one or more PGHs are different from each other. Additional PGH computer games can be created as shown in the present invention.

[0321] According to an embodiment, a method, device, and system for creating two or more PGH computer games based on a single highlight in one or more highlights is provided. For example, multiple starting points (e.g., start timestamps) and associated multiple ending points can be selected in each highlight. In some cases, based on each pair of selected starting points and ending points, a new PGH can be created.

[0322] Figure 7C A flow chart of a method 750 for generating a PGH based on one or more captured scenarios (e.g., “highlights”) of historical gameplay of a single-player or multiplayer computer game is shown according to an embodiment. The system 700 may be used to implement the method 750. However, according to embodiments, the method 750 may also be implemented by systems or processors having other configurations.

[0323] According to an embodiment, as shown in flowchart 750, one or more PGHs may be created separately for each captured highlight, wherein each created PGH may be created separately and independently of one another using different PGH attributes 735. For example, assuming that a highlight is captured during gameplay, multiple PGHs may be created from the same highlight, the multiple PGHs having independent PGH attributes 735, such as different goals, constraints, scoring parameters, starting points, end points, etc. For example, in the case of a highlight captured from an NBA game, two PGHs may be created from the same highlight, the goal of the first PGH being to score 5 points in the PGH, and the goal of the second PGH being to pass the ball 10 times between the players on your team. In another example, assuming that a 2-minute highlight is captured, a first PGH having PGH attributes 735 with a start time of 0:05 and an end time of 0:35 may be created, and a second PGH having PGH attributes 735 with a start time of 1:10 and an end time of 1:58 may be created.

[0324] According to some embodiments, it is possible to use, for example Fig.7D , Figure 7F , Figure 7G and Fig.13 Other methods shown in create one or more PGHs individually for each captured bright spot.

[0325] Optionally, in a cloud-based architecture, prior to step 751, for example in the case of streaming the base game 705, as described below with reference to Figure 8C Extract and decompose assets from the base game as explained in the . "Assets" refer to the various elements that make up the game environment, such as graphics, 3D models, textures, sound effects, music, animations, etc. These assets are the basic components that game developers use to create the visual, auditory (and optional sensory) experience within the game.

[0326] At step 751, the creator or player starts playing the base game 705. According to an embodiment, once the creator or player starts playing the base game 705, an automatic command is triggered to instruct the launcher 702 to start the game. At the same time, the authentication process between the launcher 702, the game client device 701 and the PGH server 703 is initiated.

[0327] Optionally, in a cloud-based architecture, graphical elements associated with the base game 705 are extracted and collected into a structured format prior to step 751. The graphical elements may be elements describing a scene, such as a mesh, texture, map, audio effect, video excerpt, etc., and the structured format may be a file, a file part, a JSON file format, a YML file format, etc., which describes the graphical element itself or a collection of graphical elements or metadata attributes of the graphical elements to be used by the game or PGH.

[0328] refer to Figure 7J and Figure 7L A detailed description of the extraction process for this step is illustrated.

[0329] At step 752, data related to the base game (e.g., data 7150) is received, for example, at a server (such as PGH server 703). In some cases, the data may be received from an external source, including one or more of: a game client device (such as game client device 701), a server device (such as PGH server 703). The data may include one or more of: events of the base game, text (such as text including a description of the base game or text descriptions of highlights), video gameplay of the base game, audio (such as audio including an auditory description of the base game), images (such as images including a graphic description of the base game or highlights), and other videos describing the game (such as video gameplay including a commentator or other videos of visual descriptions of the base game).

[0330] At step 753, the data is transmitted (eg, continuously streamed) to a logic engine, such as logic engine 714 included in a processor located in a server.

[0331] For example, the data may include identified events 715 that are continuously transmitted (eg, streamed) in a continuous loop to a server such as the PGH server 703 as a player or creator plays the base game 705 .

[0332] According to one embodiment, as a player or creator plays the base game 705, data (e.g., identified events 715) is continuously transmitted (e.g., streamed) to the logic engine 714 in a continuous loop, such as in real time or near real time.

[0333] In some cases, the identified events 715 may be transmitted to other locations in a system (such as system 700), for example, to local and remote storage units, such as storage device 713 and / or a local or remote cloud server.

[0334] According to an embodiment, the data of the game (e.g., the identified events 715, which may include data for the entire game or data within a predefined time range of the gameplay, and optionally including the captured video 717) can be continuously uploaded to the PGH's server throughout the gameplay session. This allows the user to create a PGH based on any portion of the uploaded gameplay data without the need to manually capture specific highlights during the game.

[0335] At step 754, the data (e.g., identified events 715, text of the underlying game, audio, images, video recordings, and other videos describing the game) is processed (e.g., converted), e.g., using a data conversion module, to produce identified events 715. According to an embodiment, the data is processed using a logic engine 714 located, for example, in a server such as the PGH server 703.

[0336] Alternatively or additionally, at step 754, events 715 in the base game are received and / or automatically identified by the event module 709 (e.g., during gameplay). The identified events 715 may include, for example, "actions" (such as "running" / "jumping") performed by one or more characters in the base game and / or "states" of the player (such as attributes of the player's "health", "position", "equipment", "weapons", "property", etc.).

[0337] In some cases, each "event" is numbered with an ID number and added to e.g. Fig. 9A 910. The event list 910 for each game includes an event name 912, an event type 914, and a value type 916. These details may be present in a specified list, such as in a game management page or game configuration settings, to allow for different goal and scoring parameters to be constructed.

[0338] At step 755, as described above with reference to Fig. 7A As explained, the identified events 715 are processed to produce building blocks 716. According to some embodiments, the identified events 715 are processed using a logic engine 714 located, for example, in a server such as the PGH server 703.

[0339] Optionally, in some embodiments, at step 757, the recorded video of the gameplay (e.g., captured video 717) is transmitted (e.g., streamed, e.g., in real time, or near real time, or after highlights are captured) to one or more processors 712 in the PGH server. Fig. 7A As shown in , captured video 717 of the base game 705 is streamed from the video module 706 in the game client device 701 to the video processor 763 in the PGH server 703.

[0340] At step 758, one or more "highlights" in the base game 705 are captured by the player / creator or automatically captured by the system (e.g., using processor 712) and transmitted, for example, from server 703 to PGH App 704. For example, Fig. 7A As shown in , highlight video 763 ″ is captured by video module 706 and transmitted from video processor 763 to PGH builder 734.

[0341] According to an embodiment, one or more highlights correspond to selected starting and ending points in the computer base game. In some embodiments, one or more highlights correspond to specific time intervals during gameplay in the base game that the player or creator wishes to use as the basis for creating PGH 738.

[0342] According to one embodiment, a user can capture a "highlight" by clicking a selected key or mouse button that is defined as, for example, a "highlight click" during gameplay. The system can capture predefined time intervals before and after the click, for example, 120 seconds before the click and 10 seconds after the click, thereby capturing 130 seconds of highlights. Note that each predefined time interval (before the "click" and after the click) is independent and can be different from each other, and the predefined time interval after the click is optional, for example, only the time before the click is used (e.g., a highlight can consist of, for example, 120 seconds before the click and 0 seconds after the click). Specifically, if Fig. 10A As shown in , text prompt 1008 may provide the player with: "Press Alt+R to capture a playable moment" in connection with "Highlight" herein, which corresponds to instructing the user to press a specific key combination using his keyboard in order to capture a highlight. It is important to note that the system or user may capture multiple highlights during base game video gameplay, and each highlight may have a different duration and / or other characteristics.

[0343] According to some embodiments, each of the captured highlights is then received by the PGH server for further processing. For example, if the base game 705 is Fig. 10A For example, in the racing computer game shown in , a potential highlight may be a 30 second interval in which the player successfully maintains a speed of 160 km / h without crashing. The player or the system may then choose to create a PGH based on that particular highlight.

[0344] At step 759, the building blocks are repeatedly processed using, for example, a logic engine 714 to generate highlight attributes 714', which include the following highlight parameters: for example, possible / potential goals and / or constraints and / or end conditions 1224 and / or PGH end criteria 1222 and / or scoring parameters related to the captured highlight.

[0345] As described above, the building blocks are used to generate all possible combinations of potential highlight attributes (such as goals, constraints, and scores) for use by the PGH creator or player to generate the PGH. In this intermediate step, the calculated potential / possible parameters (such as goals, constraints, and scores) are used as base parameters, which are further used in the following steps once the creator or system selects a specific game interval in the captured highlight.

[0346] According to an embodiment, possible goals, constraints, PGH end criteria 1222, end conditions 1224, and scoring parameters are based on the identified events 715 from the captured "highlights". Specifically, the identified events 715 are streamed to the PGH server 703 and processed by the logic engine 714 to create building blocks 716. These building blocks 716 are then further analyzed by the logic engine 714 to generate highlight attributes 714', which include, for example, the goals, constraints, PGH end criteria, end conditions, and scoring parameters suggested for the PGH.

[0347] According to one embodiment, the highlight attributes 714' are transmitted from the PGH server 703 to the PGH App 704 and displayed on the App user interface (UI) 7360. For example, Fig. 10C As shown in , in the example base game, during PGH creation, possible attributes may be displayed, including the following attributes: Objective 1010: "Deal 1933 damage" and "Kill 6 enemies"; Constraint 1012: "Reload more than 1 time"; Score parameter 1014: "Headshot: 100 points per headshot"; Possible PGH end criterion 1222: "Duration: 17s" (i.e., 17 seconds), wherein the PGH end criterion is calculated, for example, by the selected starting point 1032 and ending point 1034 of the PGH (for example, by subtracting the starting point 1032 from the ending point 1034), or, for example, in the case of a turn-based game, the starting number of rounds (e.g., 35) is subtracted from the ending number of rounds (e.g., 61), resulting in 26 rounds in this example, thereby forming the PGH end criterion.

[0348] At step 760, the starting point and the ending point of the PGH highlight are selected in the captured highlights to generate highlight attributes 714', based on which the PGH will be formed. The selected highlights can be based on a time constraint or a number of rounds or an end condition or a combination thereof. For example, the PGH highlight corresponds to and / or includes a starting point and an ending point selected in one of the one or more highlights. For example, in a turn-based or step-oriented computer game (such as chess), a starting (e.g., start) point and an ending (e.g., end) point within the sequence of the game are selected.

[0349] According to other embodiments, two timestamps are selected in the highlights, the first timestamp is used as the start time point of the PGH, and the second timestamp is used as the end time point of the PGH. For example, the captured highlights can be a two-minute long highlight video clip transmitted from the logic engine 714 to the builder 734, including possible highlight attributes of the target (12 kills), constraints, and scores. The selected timestamps can be the start time - 0:30, the end time: 1:32, for generating a 62-second PGH.

[0350] At step 761, based on the building blocks and / or the identified events associated with the selected PGH highlight start and end points and / or timestamps, a PGH attribute 735 including one or more parameters, such as a goal and / or constraint and / or scoring and / or ending PGH criteria 1222 and / or ending condition 1224 and / or a start point and / or end point, is generated. Specifically, at this step, the building blocks 716 are processed, for example, by the logic engine 714 to generate the PGH attribute 735, which includes one or more parameters, such as a goal, constraint and scoring parameter that matches the start and end points and / or time interval of the selected PGH highlight.

[0351] In accordance with an embodiment, steps 760 and 761 may be repeated in a loop to enable the system or creator to select and change (e.g., based on two selected timestamps) the starting and ending points and / or time period duration that serve as the basis for generating the PGH, and on this basis, calculate the PGH attribute 735 (e.g., if a 2 minute highlight was captured in which 10 kills were made, 9 kills were made within the first minute of the highlight, and 1 kill was made within the last minute, and the user selected a starting point of 0 minutes and 0 seconds (the beginning of the captured highlight) and an ending point of 1 minute and 0 seconds, then the target may be updated from 10 kills for the entire selected highlight to 9 kills within the selected first minute of the highlight).

[0352] like Fig. 10CAs shown in , the creator can scroll left and right through the video display 1030, and can move the corresponding time stamps 1032 and 1034 to the left and right to produce the final PGH video 775, and accordingly, for example, simultaneously, the PGH attributes 735 are updated according to the selected final PGH video 775. Similarly, in a turn-based game (such as chess), the starting point can be, for example, a specific turn with all its related events, and the ending point can be the maximum number of turns allowed (e.g., 10 turns).

[0353] An example of a PGH including a newly created target is in Fig. 9B and includes the following objectives:

[0354] "The player will need to kill the enemy without taking any damage"; or

[0355] "The car will be able to travel at speeds in excess of 150km / h without crashing."

[0356] It is important to emphasize that highlight attributes 714' or PGH attributes 735 include new objectives, constraints, scoring parameters, end conditions that are not included in the base game, but are now created for the first time based on the identified events 715 in the base game and based on the captured "highlights" (e.g., highlight video 763").

[0357] Optionally, at step 763, once the PGH start point and end point (e.g., timestamp 763' and / or start point and end point) of the PGH highlight are selected, the highlight video 763" is edited based on the selected PGH timestamp 763' and / or start point and end point to generate a final PGH video. Specifically, Fig. 7A As shown in , the selected PGH timestamp is transmitted from the PGH builder 734 to the video processor, which cuts and creates the final PGH video.

[0358] At step 764, one or more PGH computer games are created based on the PGH attributes 735, for example using the PGH publisher 733, wherein each PGH computer game includes PGH rules. The PGH rules are associated with the PGH attributes 735 and enable the one or more PGH computer games to be played.

[0359] According to another embodiment, at step 764, one or more PGHs are generated based on the PGH attributes 735, such as at the logic engine 714, according to an embodiment.

[0360] In some cases, the created PGH is configured and displayed on the user's PGH App GUI or at any local or remote display, such as on the PGH App 704 or game client device 701.

[0361] According to one embodiment, the building blocks and / or the identified events are saved in memory, such as on the storage device 713 of the PGH server, for future use after a highlight is selected. In the event that a highlight is selected and created, the building blocks will be used to calculate the PGH attributes 735, and the identified events will be used to resume the base game, so both are saved in the server's storage device.

[0362] Fig.7D Flowchart 7501 of a method according to an embodiment is shown for generating a PGH based on one or more captured scenarios (e.g., "highlights") of historical gameplay of a single-player or multiplayer computer game. System 7000 may be used to implement method 7501. However, according to embodiments, method 7501 may also be implemented by systems or processors having other configurations.

[0363] Fig.7D The flowchart 7501 is included in the previous Figure 7C All the basic steps and functions are described in Fig.7D An alternative configuration architecture and method is presented in which the logic engine 714 uses only the identified events to generate the PGH, and does not require the identified events to be converted into building blocks. Therefore, in this configuration, the building blocks 716 are omitted from the system architecture, such as Fig.7I As shown, and accordingly, not executed Figure 7C The step 755 includes processing the identified events to generate building blocks.

[0364] Instead, the embodiment utilizes only the identified events 715 , which are converted into the identified events 715 through an intermediate processing step.

[0365] Specifically, refer to Fig.7D , depicting a different Figure 7C The subsequent alternative steps of the present invention of the flow chart shown in .

[0366] Following step 758, at step 7590, the identified events are processed to generate highlight attributes including possible goals, constraints, and scoring parameters respectively associated with each of the one or more highlight events.

[0367] Accordingly, after step 760, at step 7610, a PGH attribute including one or more parameters including a goal and / or a constraint and / or a score is generated based on the identified events associated with the selected PGH highlight start and end points.

[0368] Reference now Fig. 7E , Fig. 7E is a high-level block diagram of an exemplary system 785 for supporting loading and running (e.g., playing) a PGH created based on one or more scenarios of historical gameplay in a base game. The PGH may be 7A to 7D PGH 738 created from base game 705 as shown in .

[0369] Fig. 7E include Fig. 7A , while also showing the supplementary elements necessary to manage data transfer between system modules during the gameplay process of the PGH. It should be emphasized that the separate figures for creating and playing the PGH are provided only for simplicity and to provide a clear and concise representation of the block modules. Therefore, it should be recognized that Fig. 7A and Fig. 7E The modules and components depicted in the may be integrated and combined into a unified system.

[0370] According to an embodiment, the game client device 701 includes one or more processors 708, which include an event module 709. During the play of the PGH, the event module is configured and capable of identifying events 715 in the PGH (e.g., PGH 738) and continuously transmitting (e.g., streaming) the identified events 715 to the PGH server 703, for example, in real time or near real time. The events 715 may include, for example, the "actions" and / or "states" of the characters in the PGH (e.g., as described above in Fig. 7A and Figure 7B (as shown in the creation of PGH 738).

[0371] According to an embodiment, the PGH server 703 includes one or more processors 712 including a logic engine 714 and a management module 778 .

[0372] During the play of the PGH, according to an embodiment, the logic engine 714 is configured to receive identified events 715 from the event module 709 and process the events 715 to generate building blocks 716. Based on the building blocks 716, the PGH rules 719 are determined.

[0373] Specifically, the logic engine 714 is configured and capable of processing PGH rules 719 involving one or more goals and / or constraints and / or end PGH criteria and / or end conditions created by a user or received from the system, as described in reference Fig. 7A , Figure 7B and Figure 7H The PGH rule 719 is a logical formula (eg, a numerical rule) derived from the goal and / or constraint and / or end PGH criterion and / or end condition.

[0374] The logic engine 714 is responsible for receiving the identified events or receiving data 7150 to process them into the identified events, possibly processing the identified events into building blocks, and determining whether the goals and / or constraints and / or end PGH criteria and / or end conditions are achieved based on the identified events and / or building blocks, and further calculating the score of the PGH run during and after the PGH run ends.

[0375] For example, during the PGH run, logic engine 714 receives the identified event and processes it to generate building block 716 of "three kills", while the goal of PGH 738 is "five kills". Therefore, logic engine 714 recognizes that the PGH is still not over and two more kills are needed to reach the goal.

[0376] Additionally, according to an embodiment, during the play of the PGH, the logic engine 714 is configured to generate a PGH state 777 during the play of the PGH, for example, in real time or near real time, which PGH state 777 includes, for example, the state of objectives and / or constraints (e.g., in a goal of 3 kills, 1 out of 3 kills was achieved) and / or the state of ending PGH criteria and / or ending conditions.

[0377] In operation, during the play of the PGH, the logic engine 714 continuously transmits the PGH state 777 to the management module 778 in the PGH server 703. The PGH state includes one or more of the following: a target state 12260, a constraint state 12280, a score state 7120 (summing the score parameters 1220 based on their appearance in the PGH up to the calculation time), an end condition state 12240, and an end PGH criteria state 12220. For example, if Figure 10G As shown in , the PGH state may include a target state 1041 , a constraint state 1042 , and a score state 7120 .

[0378] The management module 778 is configured and capable of managing and controlling server events 779 related to playing PGH.

[0379] In some embodiments, the management module 778 includes a media manager 771 and an event manager 749 for generating and transmitting server events 779.

[0380] The media manager 771 is configured and capable of generating server events 779. The server events 779 include a PGH state and additional data on top of the PGH state. For example, the additional data includes multimedia elements such as text, audio, graphic elements, images, or videos to be included in the PGH, or a combination of text, audio, graphic elements, images, or videos, such as 3D graphic elements based on the identified events 715 and / or PGH states 777. For example, the multimedia elements may include presenting a 3D advertisement to a PGH player in a PGH game while the user is playing the PGH game, the 3D advertisement featuring, among other things, an advertisement page on a building in the PGH game and / or text and / or a live audio stream including recommendations and tips for the PGH player.

[0381] The event manager 749 is configured and capable of transmitting, for example, in real time or near real time, server events 779 including, for example, PGH status 777, such as goal status, constraint status, scoring parameters, end PGH criteria status, etc., such as Figure 10G as shown in .

[0382] According to an embodiment, PGH results 7502 are calculated based on the identified events and / or building blocks, and in some embodiments, PGH results 7502 can be stored in storage device 713 and later transmitted to PGH App. PGH results 7502 include final PGH results (e.g., final PGH state 777 calculated at the end of PGH).

[0383] Figure 7F A method for loading and running a PGH computer game (such as Fig. 7A 738) created in the PGH 738. System 700 or system 710 or system 720 or system 730 may be used to implement method 7500. However, according to an embodiment, method 7500 may also be implemented by a system or processor having other configurations.

[0384] At step 7900, events from the base game are restored and loaded using data object 1200. According to an embodiment, the restoration process includes one or more of the following steps: returning the PGH to a previous state or condition included in the base game and associated with the PGH timestamp 763 or associated with the start point and end point of the PGH. Restoration includes reloading saved game events, restoring player progress and state, restoring the state of other players, restoring the state of the game environment, and enabling restarting gameplay from the PGH starting point (on the base game), so that the player can seamlessly start playing the PGH from a selected starting point, thereby ensuring continuity and preserving their gaming experience.

[0385] At step 790, method 7500 begins playing the PGH by initializing the game engine and loading necessary resources.

[0386] At step 791, for example, during gameplay, events 715 are automatically, for example, continuously, identified by the event module 709. The identified events 715 may include, for example, "actions" (such as "running" / "jumping") performed by one or more characters in the PGH and / or "states" of the player (such as attributes of the player's "health", "position", "equipment", "weapons", "property", etc.).

[0387] It should be emphasized that, according to one embodiment, the step of restoring an event in the base game (step 7900) so as to start the PGH in the same "state" as before is a one-time process, used only for the restoration process. Step 791 is an ongoing process, in which events are identified throughout the game and continuously transmitted (e.g., streamed) for processing.

[0388] At step 792, while the player or creator plays the PGH 738, the identified events 715 are continuously transmitted (eg, streamed) to a server (such as the PGH server 703) in a continuous loop.

[0389] According to one embodiment, as a player or creator plays the base game 705, the identified events 715 are continuously transmitted (e.g., streamed) to the logic engine 714 in a continuous loop, such as in real time or near real time.

[0390] In some cases, the identified events 715 may be transmitted to other locations in a system (such as system 785), for example, to local and remote storage units, such as storage device 713 and / or a local or remote cloud server.

[0391] At step 793, the identified events 715 are processed to generate building blocks 716, and scoring parameters are calculated based on the building blocks. According to an embodiment, the identified events 715 are processed using a logic engine 714 located, for example, in a server such as the PGH server 703.

[0392] At step 795, the building blocks are processed to determine whether PGH attribute parameters (eg, goals and / or constraints and / or end conditions 1224 and / or PGH end criteria 1222) are obtained based on the PGH rules.

[0393] At step 797, a PGH status 777 is generated. According to an embodiment, the PGH status 777 includes the status of the objective and / or constraints and / or PGH end criteria (e.g., 1 of 3 kills achieved in a 3 kill objective, 12 seconds elapsed in a 30 second PGH duration).

[0394] At step 798, the PGH status 777 is transmitted to the management module to provide a server event 779 based on the PGH status and / or the identified event.

[0395] At step 799, server events are transmitted from the PGH server to the game client device.

[0396] At step 796, a PGH result 7502 is calculated based on the identified events and / or building blocks and the PGH result 7502 is transmitted to the PGH App.

[0397] Figure 7G A method for loading and running a PGH computer game (such as Figure 7B 738) created in the system 700 or the system 710 or the system 720 or the system 730 or the system 785 can be used to implement the method 7560. However, according to an embodiment, the method 7560 can also be implemented by a system or processor with other configurations.

[0398] Figure 7G Method 7560 is included in the previous Figure 7F All the basic steps and functions are described in Figure 7G An alternative configuration architecture and method is presented in which the logic engine 714 only uses the identified events to load and run (e.g., play) the PGH, and does not require the identified events to be converted into building blocks. Therefore, in this configuration, the building blocks 716 are omitted from the system architecture and method, such as Fig.7I As shown, and accordingly, not executed Figure 7F The step 793 includes processing the identified events to generate building blocks.

[0399] Instead, this embodiment utilizes only the identified events 715 and calculates the scoring parameters based on the identified events 715 .

[0400] Specifically, refer to Figure 7G , depicting a different Figure 7F The subsequent alternative steps of the present invention of the flow chart shown in .

[0401] After step 792, at step 7930, the scoring parameters are calculated based on the identified events. At step 7950, it is determined whether PGH attribute parameters (e.g., goals and / or constraints and / or end PGH criteria and / or end conditions) are obtained based on the PGH rules according to the identified events. At step 7970, a PGH state (e.g., scoring parameter state, goal and / or constraint state) is generated.

[0402] A PGH result is calculated 7502 based on the identified events and the PGH result is transmitted to the PGH App.

[0403] Figure 7J A detailed block diagram of a system 710 configured and capable of creating a PGH 738 based on one or more scenarios of historical gameplay of a single player configuration is shown, according to an embodiment. Figure 7J The system 710 provides Fig. 7A The system 700 and Figure 7B A detailed description of system 7000 is provided in FIG.

[0404] Although Fig. 7A and Figure 7B Some components shown may not be in Figure 7J However, it should be understood that unless otherwise expressly stated, Figure 7J The configuration may include one or more of the elements from the previous figures. In turn, Figure 7J Can include Fig. 7A , Figure 7B , Fig. 7E , Figure 7H and Fig.7I Additional or alternative elements not depicted. Figure 7J The configurations shown in are intended to be illustrative rather than restrictive, and should not be construed to exclude any potential elements or arrangements within the scope of the invention.

[0405] According to an embodiment, the game module 707 includes a game client device 701. The game client device 701 is used to enable a user to play an original game (e.g., a base game) and use one or more processors (such as processor 712) to process the original game, for example, in real time (or near real time), to identify one or more events 715 in the base game 705.

[0406] According to one embodiment, the game client device 701 includes an asset publisher 711 , a base game 705 , and a PGH client software development kit (SDK) 798 .

[0407] According to an embodiment, the base game 705 is a proprietary software game. This game is called the original game or base game, which constitutes the actual game, such as shooting games, racing games, turn-based games (such as chess), NBA games, etc. Generally, as is recognized in the art, the base game 705 is developed by a game studio.

[0408] According to an embodiment, the base game 705 is in electronic communication with the asset publisher 711 and the PGH client SDK 798 .

[0409] The asset publisher 711 is configured and capable of acquiring the base game 705, collecting game elements, such as game graphic elements and source code files associated with the game, and converting these elements into a structured format (e.g., JSON file format / YML file format). The asset publisher 711 further publishes the assets to Fig. 7E The asset distributor 7860 shown in .

[0410] According to an embodiment, the PGH client SDK 798 includes an automatic synchronizer module 721 that communicates with an action streamer 722 , an events state streamer 723 , a video module 706 , a PGH controller 725 , and a PGH front end 726 .

[0411] The automatic synchronizer module 721 is configured and capable of communicating with one or more game engines (e.g., Unity, Unreal Engine), for example in the case of a multiplayer game, to extract data (e.g., transformation data, vertex position data, material data, etc.) from the game engine 718 and transmit the data to the action streamer 722 and the state streamer 723. The synchronization includes elements such as player position, player health, enemy position, etc.

[0412] The action streamer 722 is configured and capable of identifying action events 724 ′ in the base game 705 and transmitting the action events 724 ′ to the PGH server 703 .

[0413] According to an embodiment, the state streamer module 723 is configured and capable of identifying state events 723' in the base game, and transmitting the state of the identified game entities to the PGH server 703 (specifically, to the data streamer 727).

[0414] According to some embodiments, the state streamer module 723 transmits state events after an optional discretization process, for example, for a given player's position, the state streamer module 723 does not send all continuous positions of the player, but transmits several discretized samples.

[0415] According to an embodiment, the video module 706 is configured and capable of recording frames of the base game 705 and / or the game, and transmitting them to the PGH server 703. For example, the module may record frames of the game at a specific rate (e.g., 30 frames per second) into a specific file format (e.g., a png file format), save the frames as a video file (and optionally compress them into, for example, an mp4 file format), and then transmit the created video file to the PGH server.

[0416] The PGH controller module 725 is configured and capable of receiving input actions (i.e., input from a player device, such as keyboard strokes, mouse movements, joystick inputs, etc.) from the PGH player module 729, and controlling base game actions when playing the PGH by passing the base game actions for execution in the base game 705.

[0417] The PGH front end 726 is responsible for receiving display information from the PGH server 703 and presenting the display information to the PGH player on top of the base game and PGH. The information received can be divided into three main types: 1. Pre-game data: Before starting the PGH, this module displays relevant data such as the goals and / or constraints of the PGH and / or the end PGH criteria. For example, the goal status (e.g., number of kills) and the end PGH criteria status (e.g., time limit), such as Fig.10F 2. In-game data: During gameplay of the PGH, this module provides real-time updates including PGH status 777 to let players know their progress. For example, Figure 10G 7502). The PGH front end 726 is not limited to these specific types of information; it can display a variety of other information to the player / creator, such as data received from server events 779 (e.g., media generated using 771).

[0418] The PGH server 703 may be, for example, a physical server or a cloud-based server of a suitable type including one or more processors 712 and storage devices 713 .

[0419] The processor 708 and / or the processor 712 may be a suitable hardware-based electronic device with data processing capabilities, such as a general-purpose processor, a digital signal processor (DSP), a specialized application-specific integrated circuit (ASIC), one or more cores in a multi-core processor, etc. The processor may also be composed of, for example, multiple processors, multiple ASICs, virtual processors, combinations thereof, etc.

[0420] Storage device 713 may be, for example, a suitable type of volatile and / or non-volatile storage device, and may include, for example, a single physical memory component or multiple physical memory components. Storage device 713 may also include virtual memory. Storage device 713 may be configured, for example, to store various data used in computing.

[0421] According to one embodiment, the PGH server 703 is a backend application that can be hosted, for example, on a data center (such as a private or public data center). The PGH server 703 receives data streams of action 724' and state 723' from the base game 705 via the PGH client SDK 798, the data streams including, for example, recognized events (such as state and / or action events) from the base game and video frames from the video module 706 of the base game 705, and uses one or more processors to analyze the output data from the action streamer 722 and the state streamer 723 to implement the services required for creating, sharing and playing PGH games (e.g., single-player games or multiplayer games).

[0422] According to an embodiment, the PGH server 703 includes a data streamer 727 , a media server module 728 , a PGH player module 729 , a data and media bus 7300 , a PGH manager 731 , and a PGH logic engine module 714 .

[0423] The data streamer module 727 receives events 724' from the action streamer 722 and also receives events 723' from the state streamer 723, and processes them and stores them for use in creating and playing PGH games. The processing of the received data streams includes calculating scores and goals when playing PGH games.

[0424] The media server 728 receives the captured video 717 of the base game 705 from the video module 706. "Gameplay" is defined as the specific way in which, for example, a game player interacts with the game and the mechanics and rules of the game.

[0425] The media server 728 is also configured and capable of processing "game play", publishing it and storing it to create a PGH game. This processing includes cutting relevant scenes, adding watermarks to the files as needed, and converting the files to different media formats.

[0426] The PGH player 729 can also be used to orchestrate the flow of a PGH game (e.g., a single-player or multiplayer game). Specifically, the PGH player 729 receives the created PGH game 738 from the PGH manager 731. In operation, when a player requests to play PGH, the PGH player 729 sends the created PGH game 738 to be played by the PGH controller 725 using the PGH front end 726, and accordingly, the PGH logic engine 714 controls the execution of the PGH game 738. The PGH logic engine 714 obtains the identified event 715 from the game client device 701, and uses the identified event 715, or builds a building block 716 from the identified event. It then uses the identified event or building block to calculate the score state 7120 based on the score parameters, and sends it to the PGH rules 719 to calculate the target state 12260, the constraint state 12280, and the end PGH standard state 12220 (and which parts of the standard have been achieved). The PGH state 777 includes the PGH score / score state 7120, the target state 12260, the constraint state 12280, the end PGH criteria state 12220, and the end condition state 12240. The logic engine sends the building blocks 716 and / or the identified events and the PGH state 777 to the management module 778.

[0427] The data and media bus 7300 is a technology component that enables real-time sharing of data and media between different components of the PGH server, for example, real-time sharing of events (such as actions 724 ′ and states 723 ′) and captured video 717 of the base game 705 .

[0428] The PGH manager 731 is a repository, such as a centralized storage device, for managing and storing PGH games and further enabling extraction and search of PGH games.

[0429] The PGH logic engine 714 is the heart and brain of the system 710. Specifically, the PGH logic engine 714 is a rule engine that is configured and capable of creating and running PGH games in real time based on one or more defined PGH goals. According to an embodiment, the generated PGH goals can be created while playing, for example, a base game. The PGH logic engine 714 is also configured to verify whether one or more objectives (e.g., goals) created from the PGH building blocks 716 have been achieved and calculate the score of the PGH game run.

[0430] According to an embodiment, the PGH building block 716 is a logic rule. The logic rule is created based on translating game events (such as states 723' and actions 724' in the base game 705) into logic phrases that can be understood by PGH players or PGH creators. For example, in a fighting computer game, an "air kick" building block can be composed of a "jump" action and a subsequent "kick" action within a specific time range (e.g., <= 0.2 seconds from the jump action), and the aforementioned building block is considered valid only when the kick action occurs within the determined time range. The logic phrase can be, for example, Fig. 9B The Boolean logic phrase shown in .

[0431] According to an embodiment, the PGH App 704 is an application, such as a software application that enables the creation of PGHs and uses a system (such as the system 700 or the systems 720 and 730 or the system 100) to manage a PGH platform on which the PGHs can be discovered, executed, shared, promoted, etc. The PGH App 704 is configured to communicate with the PGH server 703, the launcher 702, and the game 707. In some cases, users can download the PGH App 704 to their devices (such as mobile devices) to create and manage PGH games.

[0432] In some cases, the PGH App 704 includes the following modules: a PGH launcher 732 , a PGH builder 734 , a game logic configuration 7130 , and an information feed module 736 .

[0433] The PGH launcher module 732 is a software application designed to facilitate user interaction with and user participation in PGH games by providing discovery and gameplay functionality. The PGH launcher module 732 receives as input a user's request to launch a particular PGH game and transmits as output the necessary data and commands for initializing and starting the PGH game.

[0434] The PGH builder module 734 is an editor module that implements the creation of PGH games.

[0435] The game logic configuration module 7130 enables the creator to configure the PGH properties 735.

[0436] The information feed module 736 is a module within the PGH App 704. The information feed module 736 receives data about available PGH games from the PGH Manager 731 and presents the data in a browsable information feed format within the user interface (UI) of the app, as well as a link to play the PGH within the game client module 701. The data may include information such as title, description, thumbnail, creator name, creation date, popularity metrics (e.g., number of plays, likes, shares), and tags associated with each PGH game. In this way, players can, for example, view information and attributes about different playable PGH games that may be from different base games (e.g., an information feed may contain PGHs created from 2 or more different base games). In addition, the information feed module 736 enables two or more users to search for PGHs together (e.g., using the PGH Manager 731) and then provide a link to play it together.

[0437] Figure 7K A detailed block diagram of a system 720 configured and capable of creating a PGH based on one or more scenarios of historical gameplay of a multi-player configuration is shown in accordance with an embodiment. Figure 7K include Fig. 7A Elements of system 700 as well as additional additional elements for a multi-person configuration system.

[0438] Figure 7K Additional or alternative elements not depicted in other figures may be included. Figure 7K The configurations shown in are intended to be illustrative rather than restrictive, and should not be construed to exclude any potential elements or arrangements within the scope of the invention.

[0439] Specifically, according to an embodiment, the system 720 includes the following additional modules:

[0440] Game Server 765:

[0441] In some computer games (generally multiplayer games), for example, a game server, such as game server 765, is implemented using a client-server approach. In this approach, most game events and game states are managed on the server side. According to some embodiments, game server 765 is responsible for hosting and managing multiplayer sessions of base game 705. In the client-server model, game server 765 acts as a central authority, processing and verifying game states and player actions to ensure synchronization and fairness between all connected players. For example, in a multiplayer first-person shooter game, game server 765 will track player positions, manage game flow, and verify hit detection to ensure that all players experience the same gameplay environment. Game server 765 also facilitates communication between players, such as forwarding chat messages or coordinating matchmaking. By handling these key tasks, game server 765 supports the creation and playing of PGHs in multiplayer games.

[0442] According to an embodiment, the game server 765 includes the following modules: a basic game server 766 and a PGH server SDK 767 .

[0443] The base game server 766 is a game server that can be built by a game studio, and is used to host and run a multiplayer version of the base game 705. The base game server 766 contains game-specific logic, rules, and mechanisms that define a multiplayer experience. It is responsible for managing game sessions, processing player input, and updating game states in real time. For example, in a multiplayer racing game, the base game server 766 will handle tasks such as track selection, player positioning, collision detection, and race event triggering. It ensures that all players connected to the same multiplayer session experience the game consistently and simultaneously. The base game server 766 works in conjunction with other components of the PGH server SDK 767 (such as an action streamer 768 and a state streamer 769) to enable the creation and play of PGHs within the multiplayer environment of the base game 705.

[0444] The PGH server SDK 767 is used to integrate the PGH function into the game server 765 of a multi-player game, and may include the following modules: an action streamer 768 , a state streamer 769 , and a PGH controller 770 .

[0445] Action Streamer 768: This module is responsible for extracting player actions from the base game 705 and streaming them to the PGH Server 703. Its functionality is similar to that of the Action Streamer 722 in the PGH Client SDK 798.

[0446] State Streamer 769: This module is responsible for extracting game state information from the base game 705 and streaming it to the PGH Server 703. Its functionality is similar to that of the State Streamer module 723 in the PGH Client SDK 798.

[0447] PGH Controller 770: This module receives input actions from the PGH Player Module 729 and controls the basic game actions when playing PGH. Its functions are similar to those of the PGH Controller 725 in the PGH Client SDK 798. To facilitate a multiplayer environment, the PGH Manager 731 communicates with the PGH Controller 770 and Opponents 762.

[0448] These modules work together to enable the creation and playback of PGHs in multiplayer games by facilitating communications between the Game Server 765 and the PGH Server 703.

[0449] The opponent 762 module is responsible for managing the behavior, interactions, and decision-making of computer-controlled opponents within a multiplayer environment. This module ensures that the opponent provides a challenging and engaging experience for the player while also maintaining balanced and fair gameplay. The opponent 762 module includes the game client 701, which is a component that enables the opponent to interact seamlessly with the game world and other players. The game client 701 handles rendering, input processing, and local game logic for the opponent, allowing them to perceive and react to the game state in real time. By incorporating the game client 701 into the opponent 762 module, the system ensures that the opponent's actions and behaviors are smoothly integrated into the overall multiplayer experience.

[0450] To facilitate efficient communication and coordination, the opponent 762 module communicates directly with the PGH manager 731. The PGH manager 731 sends input to the opponent 762 module, providing it with the necessary information and parameters for controlling the opponent's behavior and decision-making process. The input can include data such as player position, game state updates, and specific instructions about the opponent's actions. In return, the opponent 762 module sends output back to the PGH manager 731, informing it of the opponent's current state, actions taken, and any relevant updates. This two-way communication channel allows the opponent's behavior to be seamlessly integrated into the overall game flow and enables the creation of compelling and challenging PGHs in multiplayer scenarios.

[0451] In some embodiments, the opponent 762 module is located external to the game server 765.

[0452] According to an embodiment, the system 720 also includes a non-player character (NPC) control (Control) 772. In this solution, for example, NPCs can replace real user opponents in multiplayer games. The NPC control 772 includes an NPC controller module 774 and an NPC configuration module 776.

[0453] According to an embodiment, the NPC controller module 774 is configured and capable of interacting with a PGH player in real time while playing a PGH game and controlling the actions of an opponent replaced by an NPC.

[0454] According to an embodiment, NPC configuration 776 is used to configure the logic and behavior of NPCs in a specific game (e.g., base game 705). For example, the logic and behavior may include rules for the time and location of the NPC in which scenarios it may appear in the scene, and the attributes that the NPC has, such as aiming accuracy, directional ability, hiding ability, scripts, etc. The data and media bus 7300 sends information about the game structure, such as event types and maps, so that the NPC behavior of each game is pre-processed according to the received data.

[0455] According to an embodiment, the system 720 also includes a PGH client 7800 for streaming a game or a portion of a game object / file, possibly from the PGH server 703 .

[0456] The PGH client 7800 includes the following modules: an asset renderer 781 , an asset cache 783 , a game controller 787 , and a game engine 718 .

[0457] The asset renderer 781 is configured and able to use the game engine 718 to render the next frame on the player's own computer's GPU.

[0458] The asset cache 783 is configured to retrieve in-game graphical elements / assets from the asset distributor 7860 and cache them on the PGH client 7800 .

[0459] According to an embodiment, the game controller 787 is configured to send user input from a player's device (e.g., keyboard, mouse, controller, joystick, and other devices).

[0460] The game engine 718 is a software framework designed for creating and developing games, and is also configured to render the next frame and display it to the player, as shown in FIG. Fig.8D shown.

[0461] Figure 7L It shows that according to the embodiment Figure 7KA block diagram 730 of a subset of the system 720 is configured and capable of publishing and distributing one or more assets of a base game and a PGH based on one or more scenarios of historical gameplay in a single player / multiplayer configuration.

[0462] Figure 7M A flow chart of a method 780 of asset extraction and decomposition is shown according to an embodiment.

[0463] At step 782, the base game is uploaded to a game library (e.g., game library 789) along with its source code and all files describing its assets and graphical elements. This step also includes extracting all assets using the uploaded source code and files. The extraction process includes collecting all relevant graphical elements and saving them in a structured format. The specific graphical elements are indicated above.

[0464] At step 784, some or each graphical element is evaluated to determine whether it can be decomposed into smaller pieces. This involves the following two key checks:

[0465] At step 786, it is evaluated whether the graphical elements can be reassembled together after the decomposition so that their reassembled state will be the same as or very close to their original state before the decomposition (within the defined matching criteria).

[0466] At step 788, the graphic element is measured by comparing it to certain rules and thresholds to determine whether the graphic element is large enough to be resolved.

[0467] Finally, at step 790, the graphical elements are stored in a data repository configured for efficient retrieval and transmission.

[0468] Figure 8C As another flow example of method 780 , a flow chart of a method 820 of extracting and decomposing assets in a base game and / or PGH is shown according to an embodiment.

[0469] Reference now Fig. 8A , Fig. 8A A flowchart 800 of a method for creating a PGH based on one or more scenarios of historical gameplay in a multiplayer or single-player configuration according to an embodiment is shown. System 700 or system 710 or system 720 may be used to implement method 800. However, method 800 may also be implemented by systems or processors having other configurations. The method 800 has been previously presented and described in detail in the previous figures and the related detailed description according to the embodiments. Fig. 8A Some steps in .

[0470] Step “a. Start game” includes initiating the PGH game creation process by sending a “start command” from the creator 799 to the launcher module 702 .

[0471] Step “b. Launch” includes launching the base game 705 play by sending a command from the launcher 702 to the game module 707 to start the base game 705 .

[0472] Step “c. Initialization” includes initializing and controlling the startup steps by creating a handshake between the PGH Client SDK 798 and the PGH Server 703 , authenticating the user on the PGH Server 703 and initializing the session.

[0473] Step “d. Session” includes running an authorized handshake between the game module 707 and the PGH server 703 to allow information (such as unique identifiers of the client and server, request and response messages, and unique and random values ​​to ensure the freshness and integrity of the messages) to be exchanged between the game 707 and the PGH server 703.

[0474] Step "e. Play the game" includes starting to play the actual game (e.g., base game 705), where rendered frames of the game are continuously displayed to the creator 799, for example on his device (e.g., a mobile device or a personal computer). Fig. 10A An example of this step is shown, where we can see an example of the game starting to load.

[0475] Step "f. Game state" includes streaming / transmitting one or more characteristic state events of the game's entities during the game to the PGH server. Examples of such characteristic states include the position, health, etc. of all entities in the game.

[0476] Step "g. Game Actions" includes streaming / transmitting one or more operations (eg, actions) performed by the game player character during the game (eg, base game) to the PGH server 703. Examples of such actions include: jumping, shooting, etc. of entities in the game.

[0477] Step "h. Capture highlights" includes operating a highlight action by selecting and capturing one or more "highlights" in the game, for example during gameplay. Specifically, the highlight action includes selecting a scene or frame segment or interval in the game, such as 1 second, 2 seconds, 3 seconds, 4 seconds, 5 seconds, 10 seconds, 20 seconds or more seconds from the game. In some cases, the highlight action is operated by the creator 799 by pressing a specific combination of one or more preset keys + mouse clicks, or any other selected key combination for capturing highlights on the game (for example, the key combination can be pressing the keyboard key ALT and the keyboard key S at the same time, which makes it the key combination ALT+S). Fig. 10A An example of a preset key combination as it would appear to the player is shown in .

[0478] Step "i. Tag highlights" includes sending characteristics of the captured highlights from the game 707 to the PGH server 703, including characteristics such as the timestamp of the highlight created and related events in the highlight. Fig. 10B An example of this step is shown in , showing a specific frame of a saved highlight from the game.

[0479] Step "j. Media" includes recording of frames, video and audio of a game 707 (eg, base game 705) and transmitting the game to a PGH server.

[0480] Step “k. Highlight Data” includes transmitting highlight data from the PGH Server 703 to the PGH App 704. The highlight data includes characteristics of the captured highlights (e.g., player and game states and actions) and a record of frames, video, and audio of the game within a predefined time interval prior to the selected timestamp of the highlight, and sends them to the PGH App 704.

[0481] Step "1. Screen" includes displaying the highlight data on a user interface along with a list of possible goals, constraints, end PGH criteria, end conditions, and scoring parameters based on the identified events and / or building blocks. In some cases, the highlight data is transmitted to the PGH App along with the list of possible goals and scoring parameters and can be displayed on the user's screen. Fig. 10C and Fig. 10D An example of this step is shown in .

[0482] Step "m. Configuration" includes the selection of PGH attributes for the PGH game by the creator 799. The PGH game creation includes combining and processing received data including the starting point and the ending point, selected characteristics of the PGH (e.g., goals, constraints, ending PGH criteria, ending conditions, and scoring parameters) to generate the PGH attributes in the PGH server 703.

[0483] Step "n. PGH" includes sending the configured PGH game from the PGH App 704 to the PGH server 703, and creating the PGH according to the "m. configuration step". Fig.10E An example of the end of this step is shown in .

[0484] Figure 8B A method for playing a PGH (such as Fig. 8A800. The method 810 is a time flow diagram of a method 810 for creating a PGH (or a PGH created based on one or more scenarios of historical gameplay in a multiplayer or single player configuration) as shown in the previous figure. In some cases, the method 810 can be activated after activating the method 800. The system 700, 710, 720 or one or more processors can be used to implement the method 810. However, the method 810 can also be implemented by systems or processors with other configurations.

[0485] Step "o. Discovery" includes exposing a user (e.g., player 801) to one or more PGHs, such as Fig. 8A In some cases, the PGH may be displayed in the PGH App 704.

[0486] Step "p.URL" includes providing the player with a link to a shareable link. It should be emphasized that other methods may be used to share the PGH.

[0487] Step “q. Start PGH” includes sending a command from the player 801 to the launcher 702 to start playing PGH, and accordingly, in step “r. Start”, PGH is started, for example at the game module 707. Fig.10F An example of this step is shown in .

[0488] Step "s. state + action" includes identifying events, such as states and actions of entities in the PGH or of the game, according to an embodiment. For example, an event (as explained with reference to the aforementioned figures) may be or may include characteristics of an entity in and during a PGH game, and a set of actions performed by a player or other game entity (such as an NPC or environmental element) during a PGH game. Actions include behaviors or activities performed by a player, NPC, or environmental element during gameplay, and states may include other attributes of an entity, such as in a shooting game, it may consist of health status, weapon status, clothing, etc. The identified events may be streamed from the game module 707 to the PGH server 703, for example, in real time.

[0489] Step "t. score" includes computing / calculating and / or processing the scoring parameters in the PGH, for example, in real time, based on one or more scoring formulas (such as predefined scoring formulas according to an embodiment of the present invention) to generate a score state 7120 (e.g., a PGH score). For example, the scoring formula may have a scoring parameter "number of kills", where the formula is simply the actual number of kills (e.g., 10 kills produce a result of 10 points), or each kill may obtain its score, such as 100 points per kill. For example, the calculated PGH score is transmitted from the PGH server 703 to the PGH game 707 in real time, and the calculated PGH score is updated accordingly in each calculation cycle (e.g., each frame of the base game or every 20 milliseconds), so that each score contributes to the final cumulative score. Figure 10G An example of this step is shown in , where the current cumulative score (e.g., score status / PGH score 7120) is 4000, where, for example, each kill can add 5000 points to the cumulative score and each shot can deduct 200 points from the cumulative score, resulting in a current score of 1*5000-5*200=4000 (in this example, for the calculation of the current score, 1 kill adds 5000 points and each of the 5 shots subtracts 200 points).

[0490] Step "u. Play Results" comprises sending the PGH results (eg calculated in real time) at the end of each score calculation cycle. Fig.11 An example of this step is shown in .

[0491] Figure 8C Extraction and decomposition of base games and / or PGHs (such as Fig. 8A 800 and / or method 810. In some cases, method 820 may be activated after and / or simultaneously with execution of method 800 and / or method 810. System 700, system 710, system 720, or system 730, or one or more processors, may be used to implement method 820. However, method 820 may also be implemented by systems or processors having other configurations.

[0492] Step "a. Upload" includes importing the executable files of his game (e.g., base game 705) and / or the source code of the game by the game developer and combining all files into the game library 789. The game library 789 can be located at the PGH server 703 or elsewhere.

[0493] Step "b. Extracting and decomposing assets" includes retrieving game assets using, for example, the game's source code, files, and file structures, and then decomposing them into small parts for efficient data transfer. Decomposition occurs when it is possible to reassemble the game assets back to their original form or very close to their original form (reaching a threshold) and when the assets are marked as suitable for decomposition. According to an embodiment, the assets are saved to the asset repository (Repository) 7910 component.

[0494] According to an embodiment, the "asset release" process operates as follows:

[0495] When the server detects the player's intent to start a PGH - whether through explicit initiation or using a predictive model - it sends the necessary graphical elements to the client to render the start area of ​​the PGH. These elements include decomposed graphical elements, and the level of detail (LOD) of these elements is customized based on various factors, such as the type of element, its role in the game, its distance from the player, network capacity and performance, player preferences, and other predefined settings. This method controls the level of detail of the game when it is rendered.

[0496] Before transmitting these elements, the server checks if the client already has them cached locally to avoid redundant transmissions. The client then fetches any missing elements needed for rendering, then renders and displays the next frame to the player. In a continuous loop, the client sends its current position, viewpoint, state, and any player input back to the server. The server processes this information to determine the next set of graphical elements to send, which can be scheduled using a single-threaded or multi-threaded priority queue.

[0497] After receiving these elements, the client caches them locally and uses them to render subsequent frames, adapting to the player's position, viewpoint, state, and input.

[0498] Fig.8D 830 according to an embodiment of the invention is a flow chart showing a method 830 of publishing assets in a base game and / or PGH. The method 830 includes publishing extracted assets such as Figure 8C In some cases, method 830 may be activated after and / or simultaneously with the execution of method 820 and / or method 810. System 700, system 710, system 720, or system 730, or one or more processors, may be used to implement method 830. However, method 830 may also be implemented by systems or processors having other configurations.

[0499] Step "c. Start Game" includes a player according to an embodiment launching a base game 705 for the purpose of participating in the gameplay.

[0500] Step "d. Prepare the game" includes requesting the PGH server 703 to set up an instance of the game in order to play the game according to an embodiment. Specifically, setting up an instance of the game to be played generally refers to preparing and configuring the game environment or session before actually starting to play. This process involves various tasks related to the game type and platform, for example, it may involve the following steps:

[0501] Game Settings: Adjust in-game settings such as graphics quality, sound preferences, and control configuration to suit your personal preferences.

[0502] Game Mode or Difficulty: Select the desired game mode or difficulty level (if applicable). Some games offer different modes, such as story mode, multiplayer mode, or specific challenge modes.

[0503] Character or Avatar Selection: If the game involves playing a specific character or creating an avatar, choose or customize your character before entering the game world.

[0504] Level or Map Selection: Select a specific level, map, or scenario that the game will play in. This is common in games that have different stages or locations.

[0505] Multiplayer Settings: Configure multiplayer settings, including inviting friends, joining a server, or setting up a private game lobby.

[0506] Step "e. Loading the game" includes launching the PGH server 703 according to an embodiment, which will host an instance of the game for the particular player.

[0507] Step "f. Start Game" includes launching the base game 705 using the game executable file uploaded in "step a." on the server loaded in the previous step e. according to an embodiment.

[0508] Step "g. Assets to be published" includes sending graphical elements to be used to render the first frame of the game start according to an embodiment, including, for example, graphics, sounds, music, characters, textures, and code, which together create the environment and experience of the game.

[0509] Step "h. Assets" includes rendering the first frame of the game according to an embodiment using various elements, including graphics, sounds, music, characters, meshes, textures, and code, etc., which together create the environment and experience of the game.

[0510] Step “i. Render screen” includes sending a command to the GPU of the PGH Client 7800 according to an embodiment to render the next frame based on the player's position and view frustum and available assets in the PGH Client.

[0511] The step "j. frame loop" includes repeatedly updating and displaying in a continuous loop to obtain the next image on the screen according to an embodiment.

[0512] Step "k. (optional) User Action" includes sending input to the player 801 if there is some input within the time period of the frame cycle according to an embodiment.

[0513] Step "1. (Optional) User Action" includes sending input to player 801 if there is some input within the time period of the frame cycle according to an embodiment.

[0514] Step "m. Assets to be published" includes sending game elements from the game 707 to the PGH server 703. According to an embodiment, these game elements are used to render the next frame of the game, including graphics, sounds, music, characters, meshes, textures, and code, which together create the environment and experience of the game.

[0515] Step "n. Assets" includes rendering the next frame using various elements according to an embodiment, including graphics, sounds, music, characters, textures, and code, which together create the environment and experience of the game.

[0516] Step 'o. Render screen' includes sending a command to the GPU of the PGH Client 7800 according to an embodiment to render the next frame based on the player's position and view frustum and the available assets in the PGH Client.

[0517] The step "p. next frame" comprises, according to an embodiment, returning to the frame loop (j.).

[0518] Reference now Fig.12 , Fig.12 An example data structure of a PGH data object 1200 according to some embodiments is shown. The PGH data object includes one or more of the following: metadata 1202, PGH rules 719 and scoring parameters 1220, states 723' and actions 724'. The PGH rules 719 include one or more of the following: goals, constraints, end PGH criteria 1222, end PGH conditions.

[0519] The PGH rules 719 are used and are based on goals and / or constraints and / or end PGH criteria 1222 and / or end conditions. In some embodiments, the PGH rules 719 are evaluated every frame or every predefined time interval (such as every 20 milliseconds). The PGH rules consist of a formula that checks whether the PGH ends: in the case of the PGH ending, it generates whether the PGH ends with a victory, a defeat, or another state of the player, and in addition, it calculates the state of the goals and / or constraints and / or end PGH criteria 1222 and / or end conditions (1224). For example, the formula can check whether a goal is achieved, and in the case of reaching the goal, the PGH rule outputs that the PGH ends with a victory of the player, in the case of reaching the constraint, the PGH rule outputs that the PGH ends with a defeat of the player, and so on.

[0520] Goal 1226 is one or more objectives that a PGH player needs to accomplish in a PGH game in order to win in the PGH. Fig. 9B , presenting a screenshot including a list of objectives 920 including objective names 922 and formulas 924 that need to be achieved to complete the objective. Specifically, the first objective name 922 listed is "Kills" and the associated formula is "When the PGH player's kills equal the creator's kills in their highlight," meaning that the player's objective is to have the same number of kills as the creator's kill count. Objectives may relate to objectives that are not included in the objectives of the base game and / or are different from the objectives of the base game.

[0521] Constraints 1228 are one or more conditions that, if met, cause the player to lose the PGH. Fig. 9C , presenting a screenshot including a constraint list 930 including constraint names 932 and formulas 934 that need to be fulfilled to lose the game. Specifically, the first constraint name 932 listed is "do not take damage" and the associated formula is "when the damage taken by the PGH player is greater than the damage taken by the creator", which means that if the player's damage level is greater than the creator's damage level, then the constraint will be fulfilled and the player will lose the PGH game. Other constraints may involve constraints that are not included in the base game and / or are different from the constraints in the base game.

[0522] The end PGH conditions 1224 include one or more such conditions, if the conditions are met, the PGH game ends, where either the player wins the PGH game or the player loses the PGH, or there may be no pre-defined PGH victory or defeat. Fig.9E An example of a possible end condition 1224 is shown in , which shows an example of an end condition list 990 .

[0523] The end PGH criteria 1222 include one or more conditions that, if met, end the PGH, where either the player wins the PGH game, or the player loses the PGH, or there may be no predefined PGH win or loss. Examples of possible end PGH criteria 1222 are a time limit (e.g., a player has 30 seconds to reach a goal), a number of turns (e.g., in a turn-based game, such as a chess game, a user has 20 turns to reach a goal), a mixture of a number of turns and a time limit (e.g., in a chess game, you have 5 turns and a maximum of 120 seconds to reach one or more goals).

[0524] Score parameters 1220 refer to a set of predefined conditions or rules that determine how a player's score is calculated and updated during a PGH game. These conditions act as triggers, and when a specific condition is met or reached, the player's score is either increased (positive score) or decreased (negative score). The score can be cumulative, which means that each time a new condition is met, the corresponding score value is added to the player's current cumulative score, or the corresponding score value is subtracted from the player's current cumulative score.

[0525] Simply put, score parameters are a list of rules that define how points are awarded or deducted based on certain events or actions that occur during gameplay. These rules can be, for example, predetermined and continuously update the player's score by adding or subtracting points when different conditions are met.

[0526] Scores can be positive or negative, allowing for both reward and penalty schemes. For example, positive scores can be awarded for completing a level, achieving a certain goal, reaching a certain state, or performing a certain action, while negative scores can be deducted, for example, for reaching a certain state, performing a certain action, meeting a constraint, for each round or time period that passes, and so on.

[0527] The specific scoring parameters and their associated score values ​​may vary depending on the game. Fig.9D An example of a score parameter list 940 is shown, which may list different scenarios or events - score names 942, descriptions 944, and corresponding positive or negative scores 946 that will be applied when these conditions are met. For example, the score name may be "Ability used", the description is "Every time you use your special ability, you lose points", and the score is defined as negative, such as Fig. 10D As shown in , under the scoring parameters, each time an ability is used, using the ability may result in a 100 point deduction (in the example shown, it is marked as -100 points).

[0528] It is emphasized that in many cases the PGH rules 719 and scoring parameters are not included in the base game and / or are different from any scoring or rules included in the base game.

[0529] Metadata refers to elements related to the UI and user experience when scrolling through the PGH information feed 736 using, for example, the PGH App 704. Typically, metadata is not directly related to the game actions, rules of the PGH, or gameplay.

[0530] The metadata 1202 includes one or more of the following details: name - such as the name of the PGH, description - such as adding a text description when an element in the PGH is displayed, such as adding the text "Castle" when a picture of a castle is displayed, creator, video - supports adding a webcam to enable the creator to add commentary in real time, tags - such as adding text in actions such as "shooting", audio - enables the creator to add, for example, a voice-over during the PGH game, or thumbnails.

[0531] As described above, state 723' and action 724' are used to create, restore, and play PGH 738. State 723' includes "game state" related to the data details of the game (such as the map mapping of the game, the starting point of the game) and "player state" related to the player's data (such as the player's position in the game, ammunition, clothing). The game state can include game information, such as a falling "bomb" in a scenario in the base game, which is not specifically related to the player's actions in the base game. "Game actions" can be related to a scenario in the base game, such as a situation where the "bridge" in the game explodes once the player crosses the bridge, so the scenario is stored and can be used to create a PGH.

[0532] These data relate to the player and imprisoned and unimprisoned NPC players. For example, state 723' may include data information related to the state of an imprisoned NPC player (which is related to the state of the player in the base game). Accordingly, actions 724' include game actions and player actions. For example, where the base game includes movement actions for the player and / or NPC player, these movements are restored and included in the PGH.

[0533] Fig.13 A method for loading and running a PGH computer game (such as Fig. 7A , Figure 7B and Figure 7C738) created in the PGH 738. System 700 or system 710 or system 720 or system 730 or system 785 may be used to implement method 1300. However, according to an embodiment, method 1300 may also be implemented by a system or processor having other configurations.

[0534] At step 1310, events from the base game are restored and loaded. According to an embodiment, the restoration process includes referring to Figure 7F One or more steps described. At step 1320, the system begins playing the PGH by initializing the game engine and loading the necessary resources. At step 1330, video or other signals of the base game are captured. These signals can provide information for understanding events and building blocks within the PGH. One such method involves analyzing video frames of the PGH using techniques such as neural networks. By processing and understanding the visual content and context of each frame, the system can identify and extract identified events and / or building blocks. This video analysis method enables the system to gain deep insight into the game elements, player actions, and game state of the PGH, rather than relying solely on the game's internal data.

[0535] According to an embodiment, another method for obtaining input from the PGH is by analyzing brain signals, such as by using techniques like neural networks. By monitoring and interpreting these physiological signals, the system can infer the player's intentions, emotions, and reactions during gameplay, and further infer gameplay elements, player actions, and game states. This information can be used to extract identified events and / or building blocks, and can also be combined with video analysis or used alone.

[0536] At step 1340, the captured video or other signal is transmitted (eg, streamed) to a server (such as a PGH server). Such transmission allows for centralized processing and analysis of the captured data.

[0537] At step 1350, the video is processed using a video analysis processor, and alternatively or additionally, the signal is processed using a signal analysis processor. These processors are designed to process specific data types and perform the required analysis. The video analysis processor applies computer vision techniques, machine learning algorithms and other related methods (including neural network methods) to understand the video content and context and extract events and / or building blocks. Similarly, the signal analysis processor employs signal processing techniques, pattern recognition and machine learning methods (including neural networks) to interpret brain signals and extract identified events and / or building blocks.

[0538] At step 1360, based on the analyzed video or analyzed signal, it is determined whether PGH attribute parameters (e.g., target and / or constraint and / or end PGH criteria and / or end condition) are obtained based on the PGH rules, and as described above with reference to Fig. 7E and Figure 7F Scoring parameters are calculated as explained above. At step 1370, a PGH state 777 (e.g., scoring parameter state, state of objectives and / or constraints) is generated as described with reference to the aforementioned figures. At step 1380, the PGH state is transmitted to the management module, and server events are provided based on the PGH state and / or the identified events, as described with reference to the aforementioned figures. At step 1390, the server events are transmitted from the PGH server to the game client module. At step 1395, a PGH result is calculated based on the identified events, and the PGH result is transmitted to, for example, the PGH App.

[0539] The method according to the embodiment may be performed by a client device (such as game client device 701 ) that runs a game based on the method and data described above.

[0540] According to some embodiments, a non-transitory computer-readable storage medium having stored thereon instructions that, when executed by a computing system, cause the computing system to perform a method for creating or running one or more playable gameplay highlights (PGH) computer games from a computer base game is provided.

[0541] In the patent application, it must be clarified that the various embodiments and elements described in the drawings may have a relationship or equivalence with each other and may be different in naming. In addition, some elements present in one embodiment may not exist in another embodiment for the purpose of clarity and simplicity only. It should be understood that such omissions will not invalidate the scope or nature of the present invention. For example, the PDS server 195 can be equivalent to the PGH server 703, and the processing circuit 110A and the processing circuit 110B can be equivalent to the game client device 701 and / or the launcher module 702 and the PGH App 704.

[0542] According to some embodiments, one or more processors (such as processor 708 and / or processor 712) may be and / or may be included in a processing circuit configured to execute several functional modules according to computer-readable instructions implemented on a non-transitory computer-readable storage medium. Such functional modules are hereinafter referred to as being included in the processing circuit.

[0543] According to some embodiments, the present disclosure provides a computer control system programmed to implement the methods of the present disclosure, such as methods 750 , 7500 , 7501 , 7560 , and 1300 . Fig.14A computer system 1401 suitable for incorporating methods, systems, and devices according to some embodiments of the present disclosure is shown. The computer system 1401 can process various aspects of the information of the present disclosure, such as questions and answers, responses, statistical analysis. The computer system 1401 can be a user's electronic device or a computer system located remotely relative to the electronic device. The electronic device can be a mobile electronic device.

[0544] The computer system 1401 includes a central processing unit (CPU, also referred to herein as a "processor" and "computer processor") 1405, which may be a single-core or multi-core processor or more than one processor for parallel processing. The computer system 1401 also includes a memory or memory location 1410 (e.g., random access memory, read-only memory, flash memory), an electronic storage unit 1415 (e.g., a hard disk), a communication interface 1420 (e.g., a network adapter) for communicating with one or more other systems, and peripherals 1425 such as cache, other memory, data storage devices, and / or electronic display adapters. The memory 1410, the storage unit 1415, the interface 1420, and the peripherals 1425 communicate with the CPU 1405 via a communication bus (solid lines) such as a motherboard. The storage unit 1415 may be a data storage unit (or data repository) for storing data. The computer system 1401 may be operably coupled to a computer network ("network") 1430 by means of the communication interface 1420. The network 1430 may be the Internet, the internet and / or an extranet, or an intranet and / or an extranet communicating with the Internet. In some cases, the network 1430 is a telecommunications and / or data network. The network 1430 may include one or more computer servers, which may support distributed computing, such as cloud computing. In some cases, with the aid of the computer system 1401, the network 1430 may implement a peer-to-peer network, which may enable devices coupled to the computer system 1401 to operate as clients or servers.

[0545] The CPU 1405 may execute a series of machine-readable instructions, which may be embodied in a program or software. The instructions may be stored in a memory location, such as the memory 1410. The instructions may be directed to the CPU 1405, which may then program or otherwise configure the CPU 1405 to implement the methods of the present disclosure. Examples of operations performed by the CPU 1405 may include reading, decoding, executing, and writing back.

[0546] CPU 1405 may be part of a circuit, such as an integrated circuit. One or more other components of system 1401 may be included in the circuit. In some cases, the circuit is an application specific integrated circuit (ASIC).

[0547] Storage unit 1415 can store files, such as drivers, libraries, and saved programs. Storage unit 1415 can store user data, such as user preferences and user programs. In some cases, computer system 1401 may include one or more additional data storage units that are external to computer system 1401, such as located on a remote server that communicates with computer system 1401 via an intranet or the Internet.

[0548] Computer system 1401 can communicate with one or more remote computer systems via network 1430. For example, computer system 1401 can communicate with a remote computer system of a user (e.g., a parent). Examples of remote computer systems and mobile communication devices include personal computers (e.g., portable PCs), tablet or tablet PCs (e.g., iPad, Galaxy Tab), phones, smartphones (e.g. iPhone, Android-enabled devices, ), personal digital assistants, wearable medical devices (e.g., Fitbits), or medical device monitors (e.g., epilepsy monitors). Users can access computer system 1401 using network 1430.

[0549] The methods as described herein may be implemented by means of machine (e.g., computer processor) executable code stored on an electronic storage location of the computer system 1401, such as the memory 1410 or the electronic storage unit 1415. The machine executable code or machine readable code may be provided in the form of software. During use, the code may be executed by the processor 1405. In some cases, the code may be retrieved from the storage unit 1415 and stored on the memory 1410 for rapid access by the processor 1405. In some cases, the electronic storage unit 1415 may be excluded and the machine executable instructions may be stored in the memory 1410.

[0550] The code may be precompiled and configured for use with a machine having a processor suitable for executing the code, or may be compiled during runtime. The code may be provided in a programming language that may be selected so that the code can be executed in a precompiled or as-compiled manner.

[0551] Aspects of the systems and methods provided herein (such as the game client device 701) can be embodied programmatically. Aspects of the technology can be considered as "products" or "articles of manufacture" in the form of machine (or processor) executable code and / or related data, which are usually carried out or embodied in a machine-readable medium. The machine executable code can be stored on an electronic storage unit such as a memory (e.g., a read-only memory, a random access memory, a flash memory) or a hard disk. "Storage" type media can include any or all tangible memories of a computer, a processor, etc., or their related modules, such as a variety of semiconductor memories, tape drives, disk drives, etc., which can provide non-temporary storage for software programming at any time. All or part of the software can sometimes communicate via the Internet or more other telecommunications networks. For example, such communications can enable software to be loaded from one computer or processor to another computer or processor, for example, from a management server or host to a computer platform of an application server. Therefore, another type of medium capable of carrying software elements includes optical waves, radio waves, and electromagnetic waves such as those used through physical interfaces between local devices, through wired and optical fiber landline networks, and on various air links. Physical elements that carry such waves, such as wired or wireless links, optical links, etc., can also be considered media that carry software. As used herein, unless restricted to non-transitory, tangible "storage" media, terms such as computer or machine "readable media" refer to any medium that participates in providing instructions to a processor for execution.

[0552] Thus, machine-readable media (such as computer executable code) may take a variety of forms, including but not limited to tangible storage media, carrier media, or physical transmission media. Non-volatile storage media include (for example, optical or magnetic disks (such as any storage device in any computer, etc.)) such as may be used to implement databases, etc. as shown in the accompanying drawings. Volatile storage media include dynamic memory, such as the main memory of such a computer platform. Tangible transmission media include coaxial cables; copper wire and optical fiber, including the wires that make up the bus within a computer system. Carrier transmission media may take the form of electrical or electromagnetic signals, or acoustic or light waves, such as those generated during radio frequency (RF) and infrared (IR) data communications. Thus, common forms of computer-readable media include, for example: a floppy disk, a flexible disk, a hard disk, a magnetic tape, any other magnetic medium, a CD-ROM, a DVD or DVD-ROM, any other optical medium, a punched card paper tape, any other physical storage medium with a punched pattern, a RAM, a ROM, a PROM and an EPROM, a FLASH-EPROM, any other memory chip or cartridge, a carrier wave that transmits data or instructions, a cable or link that transmits such a carrier wave, or any other medium from which a computer can read programming code and / or data. Many of these forms of computer-readable media can participate in transmitting one or more sequences of one or more instructions to a processor for execution.

[0553] Computer system 1401 may include or communicate with electronic display 1435 including user interface (UI) 1440 for providing, for example, questions and answers, analysis results, recommendations. Examples of UI include, but are not limited to, graphical user interfaces (GUIs) and web-based user interfaces.

[0554] The methods and systems of the present disclosure may be implemented by one or more algorithms and instructions provided by one or more processors disclosed herein. The algorithms may be implemented by software after being executed by the central processor 1405. The algorithms may be, for example, random forests, graphical models, support vector machines, or other algorithms.

[0555] Although the above steps illustrate a method according to an example system, those of ordinary skill in the art will recognize many variations based on the teachings described herein. These steps can be completed in a different order. Steps can be added or deleted. Some steps can include sub-steps. Many steps can be repeated as often as is beneficial to the platform.

[0556] Each of the examples described herein may be combined with one or more other examples. In addition, one or more components of one or more examples may be combined with other examples.

[0557] Although the detailed description contains many details, these should not be construed as limiting the scope of the present disclosure, but should only be construed as illustrating different examples and aspects of the present disclosure. It should be understood that the scope of the present disclosure includes other embodiments not discussed in detail above. Various other modifications, changes and variations that are obvious to those skilled in the art may be made in the arrangement, operation and details of the methods and equipment of the present disclosure provided herein without departing from the spirit and scope of the present invention as described herein.

[0558] Although preferred embodiments of the present disclosure have been shown and described herein, it will be apparent to those skilled in the art that such embodiments are provided by way of example only. Many variations, changes, and alternatives will be apparent to those skilled in the art without departing from the scope of the present disclosure. It should be understood that various alternatives to the embodiments of the present disclosure described herein may be adopted without departing from the scope of the present invention. Therefore, the scope of the present invention should be limited only by the scope of the appended claims and their equivalents.

[0559] Although certain elements are depicted in one or more drawings, it should be understood that not every element may be included in every drawing. The drawings are intended to be illustrative rather than limiting, and elements from one drawing may or may not be present in other drawings. However, it should be understood that the present invention is not limited to the specific elements or configurations shown in the drawings, and additional or alternative elements and configurations may be included within the scope of the present invention.

[0560] It should be understood that the present invention is not limited in its application to the details set forth in the description contained herein or shown in the accompanying drawings. The present invention can have other embodiments and can be practiced or performed in various ways. Therefore, it should be understood that the wording and terminology used herein are for descriptive purposes and should not be considered as limiting. Therefore, it will be appreciated by those skilled in the art that the concepts upon which the present disclosure is based can be easily utilized as a basis for designing other structures, methods and systems for performing several purposes of the subject matter of the present disclosure.

[0561] It should also be understood that the system according to the present invention can be implemented at least in part on a suitably programmed computer. Likewise, the present invention contemplates a computer program that is readable by a computer for performing the method of the present invention. The present invention also contemplates a non-transitory computer-readable memory that tangibly embodies an instruction program executable by a computer for performing the method of the present invention.

[0562] Unless otherwise specifically stated, as will be apparent from the following discussion, it should be understood that throughout the specification discussion, terms such as "processing," "computing," "comparing," "determining," "calculating," "receiving," "providing," "obtaining," "detecting," etc., are used to refer to the actions and / or processes of a computer that manipulates data and / or transforms data into other data, the data being represented as physical (such as electronic) quantities and / or the data representing physical objects. The term "computer" should be broadly interpreted to cover any type of hardware-based electronic device with data processing capabilities, including, as non-limiting examples, the processors, mitigation units, and inspection units disclosed herein in this application.

[0563] Although the various features of the present invention have been described using specific embodiments, it is deemed within the purview of one of ordinary skill in the art to mix and match the features in other embodiments not depicted in the drawings.

[0564] It should be understood that the phraseology or terminology employed herein is for the purpose of description rather than limitation. The devices, materials and steps for performing the various disclosed functions may take various alternative forms without departing from the invention.

[0565] It will be easily understood by those skilled in the art that various modifications and changes may be applied to the embodiments of the present invention as described above without departing from its scope as defined in and by the appended claims.

[0566] The present invention application provides the following contents:

[0567] Clause 1. A computer-implemented method for creating one or more playable highlight gameplay (PGH) computer games from a computer base game, the method comprising:

[0568] receiving data related to the computer base game using a logic engine, wherein the data includes one or more of: events of the computer base game, text, audio, images, video recordings, other videos describing the computer base game, and wherein the logic engine is included in a processor located in a server;

[0569] processing the data to generate the events, and processing the events by the logic engine to generate building blocks, or processing the data by the logic engine to generate building blocks;

[0570] capturing one or more bright spots in the computer base game, wherein each of the one or more bright spots corresponds to a selected starting point and an ending point in the computer base game;

[0571] Processing the building blocks by the logic engine to generate highlight attribute parameters, the highlight attribute parameters comprising one or more of: possible goals, possible constraints, possible PGH end criteria, possible end conditions, and possible scoring parameters respectively associated with each of the one or more highlights;

[0572] selecting a PGH bright spot in each of the one or more bright spots, wherein the PGH bright spot corresponds to a selected starting point and an ending point in one of the one or more bright spots;

[0573] processing, by the logic engine, the building blocks associated with the selected PGH highlights to generate PGH attributes, the PGH attributes comprising one or more of: goals, constraints, PGH end criteria, end conditions and scoring parameters, the selected start point and end point;

[0574] The one or more PGH computer games are created based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, the PGH rules being related to the PGH attributes and used to configure how the one or more PGH computer games are played.

[0575] Clause 2. The computer-implemented method of clause 1, comprising loading and running the one or more PGH computer games, the loading and running comprising:

[0576] resuming said event associated with said computer base game;

[0577] continuously identifying said events in said one or more PGH computer games;

[0578] continuously streaming the identified events from the gaming client device to the logic engine;

[0579] continuously processing the identified events using the logic engine to generate the building blocks;

[0580] continuously processing the building blocks using the logic engine to determine whether the PGH attribute parameters are obtained based on the PGH rules; and

[0581] When the PGH attribute parameters have been obtained, play of the one or more PGH computer games is ended.

[0582] Clause 3. The computer-implemented method of clause 2, comprising:

[0583] Generating a PGH state for each of the one or more PGH computer games, wherein the PGH state comprises:

[0584] calculating one or more of: a scoring parameter, a status of the goal, a status of the constraint; a status of the PGH end criterion; and

[0585] transmitting the PGH status to a management module included in the server; and

[0586] Server events are provided based on one or more of: the PGH state, the building blocks.

[0587] Clause 4. The computer-implemented method of clause 3, comprising:

[0588] transmitting the server event from the server to the game client device; and

[0589] The server event is displayed on a display.

[0590] Clause 5. The computer-implemented method of clause 4, comprising:

[0591] calculating a PGH outcome for each of the one or more PGH computer games based on the event;

[0592] transmitting the PGH results to a PGH App; and

[0593] The server event is displayed on a display of the game client device.

[0594] Clause 6. The computer-implemented method of clause 1, comprising:

[0595] The one or more highlights are selected by clicking one or more keys during gameplay of the base game.

[0596] Clause 7. The computer-implemented method of clause 1, wherein the processing comprises:

[0597] Converting one or more of the following into the event: text, audio, images, video recording, other video of the base game.

[0598] Clause 8. The computer-implemented method of clause 1, comprising:

[0599] Events in the computer base game are identified using an event module, wherein the event module is included in a processor in a game client device.

[0600] Clause 9. The computer-implemented method of clause 1, wherein selecting a PGH highlight comprises:

[0601] A time stamp start point is selected and a time stamp end point is selected in the computer base game.

[0602] Clause 10. The computer-implemented method of clause 1, comprising:

[0603] transmitting video of the computer base game captured by a video module in a game client device to the server;

[0604] transmitting the one or more highlights from the server to a PGH App;

[0605] editing the video based on the selected PGH timestamp to generate a final PGH video; and

[0606] The one or more PGH computer games are created based on the PGH attributes and the final PGH video.

[0607] Clause 11. The computer-implemented method of clause 2, comprising:

[0608] One or more additional PGH computer games are created from the one or more PGH computer games.

[0609] Clause 12. The computer-implemented method of clause 1, comprising:

[0610] Two or more PGH computer games are created based on a single highlight among the one or more highlights.

[0611] Clause 13. The computer-implemented method of Clause 1, wherein the event comprises an action or state of a character in the computer base game.

[0612] Clause 14. The computer-implemented method of Clause 1, wherein each of the building blocks is formed by aggregating one or more of the events.

[0613] Clause 15. The computer-implemented method of Clause 14, wherein the aggregate function combines two or more events of the same type or events of different types.

[0614] Clause 16. The computer-implemented method of Clause 1, wherein the PGH attributes are selected by a creator of the PGH computer game or automatically selected by the logic engine.

[0615] Clause 17. The computer-implemented method of Clause 1, wherein the PGH attributes further include one or more of the following:

[0616] The PGH's name, description, thumbnail "preview" image and tags for said PGH computer game.

[0617] Clause 18. The computer-implemented method of Clause 1, wherein the character is a player character (PC) or a non-player character (NPC).

[0618] Clause 19. A computer-implemented method according to clause 1, wherein generative artificial intelligence (AI) algorithms and models are used to create the objectives or the constraints or the PGH end criteria or the end conditions or the scoring parameters.

[0619] Clause 20. The computer-implemented method of Clause 1, wherein the game client device is included in the server.

[0620] Clause 21. The computer-implemented method of Clause 1, comprising loading and running the one or more PGH computer games, the loading and running comprising:

[0621] resuming said event from said base game;

[0622] capturing video or other signal of said base game;

[0623] transmitting the captured video or other signal to the server;

[0624] Processing the video using a video analysis processor, or processing the signal using a signal analysis processor;

[0625] determining whether the PGH attribute parameters are obtained based on the PGH rules and the analyzed video or the analyzed signal; and

[0626] The scoring parameter is calculated.

[0627] Clause 22. A computer-implemented method for creating one or more playable highlight gameplay (PGH) computer games from a computer base game, the method comprising:

[0628] receiving data related to the computer base game using a logic engine, wherein the data includes one or more of: events of the base game, text, audio, images, video recordings, other videos describing the computer base game, and wherein the logic engine is included in a processor located in a server;

[0629] Processing the data using the logic engine to generate the event;

[0630] capturing one or more bright spots in the computer base game, wherein each of the one or more bright spots corresponds to a selected starting point and an ending point in the computer base game;

[0631] The event is processed by the logic engine to generate highlight attribute parameters, the highlight attribute parameters including one or more of the following: possible goals, possible constraints, possible PGH end criteria, possible end conditions, and possible scoring parameters respectively associated with each of the one or more highlights;

[0632] selecting a PGH bright spot in each of the one or more bright spots, wherein the PGH bright spot corresponds to a selected starting point and an ending point in one of the one or more bright spots;

[0633] processing, by the logic engine, the events associated with the selected PGH highlights to generate PGH attributes, the PGH attributes comprising one or more of: goals, constraints, PGH end criteria, end conditions, and scoring parameters;

[0634] The one or more PGH computer games are created based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, the PGH rules being related to the PGH attributes and used to configure how the one or more PGH computer games are played.

[0635] Clause 23. The computer-implemented method of Clause 22, comprising loading and running the one or more PGH computer games, the loading and running comprising:

[0636] resuming said event associated with said base game;

[0637] continuously identifying said events in said one or more PGH computer games;

[0638] continuously streaming the identified events from the gaming client device to the logic engine;

[0639] continuously processing the identified events using the logic engine to generate building blocks;

[0640] continuously processing the building blocks using the logic engine to determine whether the PGH attribute parameters are obtained based on the PGH rules; and

[0641] When the PGH attribute parameters have been obtained, play of the one or more PGH computer games is ended.

[0642] Clause 24. The computer-implemented method of clause 23, comprising:

[0643] generating a PGH state for each of the one or more PGH computer games, wherein generating the PGH state comprises:

[0644] calculating one or more of: a scoring parameter, a status of the goal, a status of the constraint; a status of the PGH end criterion; and

[0645] transmitting the PGH status to a management module included in the server; and

[0646] Server events are provided based on one or more of: the PGH state, the building blocks.

[0647] Clause 25. The computer-implemented method of clause 24, comprising:

[0648] transmitting the server events from the PGH server to a gaming client device; and

[0649] The server event is displayed on a display.

[0650] Clause 26. The computer-implemented method of clause 24, comprising:

[0651] calculating a PGH outcome for each of the one or more PGH computer games based on the identified event;

[0652] transmitting the PGH results to a PGH App; and

[0653] The server event is displayed on a display of the game client device.

[0654] Clause 27. The computer-implemented method of clause 22, comprising:

[0655] The one or more highlight points are selected by clicking one or more keys during gameplay of the computer base game.

[0656] Clause 28. The computer-implemented method of clause 22, comprising:

[0657] Events in the computer base game are identified using an event module, wherein the event module is included in a processor in a game client device.

[0658] Clause 29. The computer-implemented method of clause 22, wherein selecting a PGH highlight comprises:

[0659] A time stamp start point is selected and a time stamp end point is selected in the computer base game.

[0660] Clause 30. The computer-implemented method of clause 22, comprising:

[0661] transmitting video of the computer base game captured by a video module in the game client device to the server;

[0662] transmitting the one or more highlights from the server to a PGH App;

[0663] editing the video based on the selected PGH timestamp to generate a final PGH video; and

[0664] The one or more PGH computer games are created based on the PGH attributes and the final PGH video.

[0665] Clause 31. The computer-implemented method of clause 23, comprising:

[0666] One or more additional PGH computer games are created from the one or more PGH computer games.

[0667] Clause 32. The computer-implemented method of clause 24, comprising:

[0668] Two or more PGH computer games are created based on a single highlight among the one or more highlights.

[0669] Clause 33. The computer-implemented method of Clause 22, wherein the identified event comprises an action or state of a character in the computer base game.

[0670] Clause 34. The computer-implemented method of Clause 22, wherein each of the building blocks is formed by aggregating one or more of the events.

[0671] Clause 35. The computer-implemented method of Clause 34, wherein the aggregate function combines the one or more events of the same type or of different types.

[0672] Clause 36. The computer-implemented method of Clause 22, wherein PGH attributes are selected by a creator of the PGH computer game or automatically selected by the logic engine.

[0673] Clause 37. The computer-implemented method of Clause 22, wherein the PGH attributes further include one or more of the following:

[0674] The PGH's name, description, thumbnail "preview" image and tags for said PGH computer game.

[0675] Clause 38. The computer-implemented method of Clause 33, wherein the character is a player character (PC) or a non-player character (NPC).

[0676] Clause 39. A computer-implemented method according to clause 22, wherein generative artificial intelligence (AI) algorithms and models are used to create the objectives or the constraints or the PGH end criteria or the end conditions or the scoring parameters.

[0677] Clause 40. The computer-implemented method of Clause 22, wherein the game client device is included in the server.

[0678] Clause 41. The computer-implemented method of Clause 22, comprising loading and running the one or more PGH computer games, the loading and running comprising:

[0679] Resuming an event from said base game;

[0680] capturing video or other signal of said base game;

[0681] transmitting the captured video or other signal to the server;

[0682] Processing the video using a video analysis processor, or processing the signal using a signal analysis processor;

[0683] determining whether the PGH attribute parameters are obtained based on the PGH rules and the analyzed video or the analyzed signal; and

[0684] The scoring parameter is calculated.

[0685] Clause 42. A method of loading and running one or more playable gameplay highlights (PGH) computer games created based on a computer base game, the method being performed by a game client device, the method comprising:

[0686] resuming events associated with said computer base game;

[0687] continuously identifying said events in said one or more PGH computer games;

[0688] continuously streaming the identified events from the game client device to a logic engine;

[0689] continuously processing the identified events using the logic engine to generate building blocks;

[0690] continuously processing the building blocks using the logic engine to determine whether the PGH attribute parameters are obtained based on the PGH rules; and

[0691] When the PGH attribute parameters have been obtained, play of the one or more PGH computer games is ended.

[0692] Clause 43. The method according to clause 42, comprising:

[0693] generating a PGH state for each of the one or more PGH computer games, wherein generating the PGH state comprises:

[0694] Calculating one or more of the following: scoring parameters, status of objectives, status of constraints; status of PGH end criteria;

[0695] transmitting the PGH status to a management module included in the server; and

[0696] Server events are provided based on one or more of: the PGH state, the building blocks.

[0697] Clause 44. The method according to clause 43, comprising:

[0698] transmitting the server event from the PGH server to the game client device; and

[0699] The server event is displayed on a display.

[0700] Clause 45. The method according to clause 44, comprising:

[0701] calculating a PGH outcome for each of the one or more PGH computer games based on the identified event;

[0702] transmitting the PGH results to a PGH App; and

[0703] The server event is displayed on a display of the game client device.

[0704] Clause 46. The method according to clause 42, comprising:

[0705] Events in the computer base game are identified using an event module, wherein the event module is included in a processor in a game client device.

[0706] Clause 47. The method according to clause 42, comprising:

[0707] One or more additional PGH computer games are created from the one or more PGH computer games.

[0708] Clause 48. The method of clause 42, wherein the identified event comprises an action or state of a character in the computer base game.

[0709] Clause 49. The method of clause 42, wherein each of the building blocks is formed by aggregating one or more of the events.

[0710] Clause 50. The method of Clause 49, wherein the aggregate function combines the one or more events of the same type or of different types.

[0711] Clause 51. The method of Clause 42, wherein the PGH attributes are selected by a creator of the PGH computer game or automatically selected by the logic engine.

[0712] Clause 52. The method of clause 51, wherein the PGH attributes further include one or more of the following:

[0713] The PGH's name, description, thumbnail "preview" image and tags for said PGH computer game.

[0714] Clause 53. A method according to clause 43, wherein generative artificial intelligence (AI) algorithms and models are used to create the objectives or constraints or PGH end criteria or end conditions or scoring parameters.

[0715] Clause 54. The method of Clause 42, wherein the game client device is included in the server.

[0716] Clause 55. The method of clause 42, comprising loading and running the one or more PGH computer games, the loading and running comprising:

[0717] resuming said event from said computer base game;

[0718] capturing video or other signal of said base game;

[0719] transmitting the captured video or other signal to the server;

[0720] Processing the video using a video analysis processor, or processing the signal using a signal analysis processor;

[0721] determining whether the PGH attribute parameters have been obtained based on the PGH rules and the analyzed video or the analyzed signal; and

[0722] The scoring parameter is calculated.

[0723] Clause 56. A system for creating one or more playable highlight gameplay (PGH) computer games from a computer base game, the system comprising:

[0724] A game client device comprising a processing circuit, the processing circuit comprising one or more processors, the one or more processors comprising an event module configured to communicate with a PGH server, the PGH server comprising:

[0725] a storage unit for storing the PGH computer game, and one or more server processors, wherein the server processor comprises a video processor, a logic engine and a PGH publisher, wherein the logic engine is configured and capable of:

[0726] receiving data related to the computer base game, wherein the data includes one or more of: events of the base game, text, audio, images, video recordings, other videos describing the base game;

[0727] processing the data to generate the event;

[0728] processing the events to generate building blocks, or processing the data to generate building blocks;

[0729] capturing one or more highlights in the computer base game, wherein each of the captured one or more highlights corresponds to a selected starting point and an ending point in the computer base game;

[0730] Processing the building blocks by the logic engine to generate highlight attribute parameters, the highlight attribute parameters comprising one or more of: possible goals, possible constraints, possible PGH end criteria, possible end conditions, and possible scoring parameters respectively associated with each of the one or more highlights;

[0731] selecting a PGH bright spot in each of the one or more bright spots, wherein the PGH bright spot corresponds to a selected starting point and an ending point in one of the one or more bright spots;

[0732] processing, by the logic engine, the building blocks associated with the selected PGH highlight to generate PGH attributes, the PGH attributes comprising one or more of: a goal, a constraint, a PGH end criterion, an end condition, and a scoring parameter;

[0733] The one or more PGH computer games are created based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, the PGH rules being related to the PGH attributes and used to configure how the one or more PGH computer games are played.

[0734] Clause 57. The system of clause 56, wherein the one or more processors are further configured and capable of:

[0735] Loading and running the one or more PGH computer games, the loading and running comprising:

[0736] resuming said event associated with said base game;

[0737] continuously identifying said events in said one or more PGH computer games;

[0738] continuously streaming the identified events from the gaming client device to the logic engine;

[0739] continuously processing the identified events using the logic engine to generate the building blocks;

[0740] continuously processing the building blocks using the logic engine to determine whether the PGH attribute parameters have been obtained based on the PGH rules; and

[0741] When the PGH attribute parameters have been obtained, play of the one or more PGH computer games is ended.

[0742] Clause 58. The system of clause 56, wherein the one or more processors are further configured and capable of:

[0743] Generating a PGH state for each of the one or more PGH computer games, wherein generating the PGH state comprises:

[0744] calculating one or more of: a scoring parameter, a status of the goal, a status of the constraint; a status of the PGH end criterion; and

[0745] transmitting the PGH status to a management module included in the server; and

[0746] Server events are provided based on one or more of: the PGH state, the building blocks.

[0747] Clause 59. The system of clause 57, wherein the one or more processors are further configured and capable of:

[0748] resuming said event from said base game;

[0749] capturing video or other signal of said base game;

[0750] transmitting the captured video or other signal to the server;

[0751] Processing the video using a video analysis processor, or processing the signal using a signal analysis processor;

[0752] determining whether the PGH attribute parameters are obtained based on the PGH rules and the analyzed video or the analyzed signal; and

[0753] The scoring parameter is calculated.

[0754] Clause 60. A non-transitory computer-readable medium containing program instructions for creating one or more playable highlight gameplay (PGH) computer games from a computer base game, wherein execution of the program instructions by one or more processors of a computer system causes the one or more processors to perform a method comprising the steps of:

[0755] receiving events or data related to the computer base game using a logic engine, wherein the logic engine is included in a processor located in a server;

[0756] Processing the events by the logic engine to generate building blocks, or processing the data by the logic engine to generate building blocks;

[0757] capturing one or more highlights in the computer base game, wherein each of the captured one or more highlights corresponds to a selected starting point and an ending point in the computer base game;

[0758] Processing the building blocks by the logic engine to generate highlight attribute parameters, the highlight attribute parameters comprising one or more of: possible goals, possible constraints, possible PGH end criteria, possible end conditions, and possible scoring parameters respectively associated with each of the one or more highlights;

[0759] selecting a PGH bright spot in each of the one or more bright spots, wherein the PGH bright spot corresponds to a selected starting point and an ending point in one of the one or more bright spots;

[0760] processing, by the logic engine, the building blocks associated with the selected PGH highlights to generate PGH attributes, the PGH attributes comprising one or more of: goals, constraints, PGH end criteria, end conditions and scoring parameters, the selected start point and end point;

[0761] The one or more PGH computer games are created based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, the PGH rules being related to the PGH attributes and used to configure how the one or more PGH computer games are played.

Claims

1. A computer-implemented method for creating one or more playable highlight gameplay (PGH) computer games from a computer base game, the method comprising: receiving data related to the computer base game using a logic engine, wherein the data includes one or more of: events of the computer base game, text, audio, images, video recordings, other videos describing the computer base game, and wherein the logic engine is included in a processor located in a server; processing the data to generate the events, and processing the events by the logic engine to generate building blocks, or processing the data by the logic engine to generate building blocks; capturing one or more bright spots in the computer base game, wherein each of the one or more bright spots corresponds to a selected starting point and an ending point in the computer base game; Processing the building blocks by the logic engine to generate highlight attribute parameters, the highlight attribute parameters comprising one or more of: possible goals, possible constraints, possible PGH end criteria, possible end conditions, and possible scoring parameters respectively associated with each of the one or more highlights; selecting a PGH bright spot in each of the one or more bright spots, wherein the PGH bright spot corresponds to a selected starting point and an ending point in one of the one or more bright spots; processing, by the logic engine, the building blocks associated with the selected PGH highlights to generate PGH attributes, the PGH attributes comprising one or more of: goals, constraints, PGH end criteria, end conditions and scoring parameters, the selected start point and end point; The one or more PGH computer games are created based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, the PGH rules being related to the PGH attributes and used to configure how the one or more PGH computer games are played.

2. A computer-implemented method for creating one or more playable highlight gameplay (PGH) computer games from a computer base game, the method comprising: receiving data related to the computer base game using a logic engine, wherein the data includes one or more of: events of the base game, text, audio, images, video recordings, other videos describing the computer base game, and wherein the logic engine is included in a processor located in a server; Processing the data using the logic engine to generate the event; capturing one or more bright spots in the computer base game, wherein each of the one or more bright spots corresponds to a selected starting point and an ending point in the computer base game; The event is processed by the logic engine to generate highlight attribute parameters, the highlight attribute parameters including one or more of the following: possible goals, possible constraints, possible PGH end criteria, possible end conditions, and possible scoring parameters respectively associated with each of the one or more highlights; selecting a PGH bright spot in each of the one or more bright spots, wherein the PGH bright spot corresponds to a selected starting point and an ending point in one of the one or more bright spots; processing, by the logic engine, the events associated with the selected PGH highlights to generate PGH attributes, the PGH attributes comprising one or more of: goals, constraints, PGH end criteria, end conditions, and scoring parameters; The one or more PGH computer games are created based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, the PGH rules being related to the PGH attributes and used to configure how the one or more PGH computer games are played.

3. A method of loading and running one or more playable Gameplay Highlights (PGH) computer games created based on a computer base game, the method being performed by a game client device, the method comprising: resuming events associated with said computer base game; continuously identifying said events in said one or more PGH computer games; continuously streaming the identified events from the game client device to a logic engine; continuously processing the identified events using the logic engine to generate building blocks; continuously processing the building blocks using the logic engine to determine whether the PGH attribute parameters are obtained based on the PGH rules; and When the PGH attribute parameters have been obtained, play of the one or more PGH computer games is ended.

4. A system for creating one or more playable highlight gameplay (PGH) computer games from a computer base game, the system comprising: A game client device comprising a processing circuit, the processing circuit comprising one or more processors, the one or more processors comprising an event module configured to communicate with a PGH server, the PGH server comprising: a storage unit for storing the PGH computer game, and one or more server processors, wherein the server processor comprises a video processor, a logic engine and a PGH publisher, wherein the logic engine is configured and capable of: receiving data related to the computer base game, wherein the data includes one or more of: events of the base game, text, audio, images, video recordings, other videos describing the base game; processing the data to generate the event; processing the events to generate building blocks, or processing the data to generate building blocks; capturing one or more highlights in the computer base game, wherein each of the captured one or more highlights corresponds to a selected starting point and an ending point in the computer base game; Processing the building blocks by the logic engine to generate highlight attribute parameters, the highlight attribute parameters comprising one or more of: possible goals, possible constraints, possible PGH end criteria, possible end conditions, and possible scoring parameters respectively associated with each of the one or more highlights; selecting a PGH bright spot in each of the one or more bright spots, wherein the PGH bright spot corresponds to a selected starting point and an ending point in one of the one or more bright spots; processing, by the logic engine, the building blocks associated with the selected PGH highlight to generate PGH attributes, the PGH attributes comprising one or more of: a goal, a constraint, a PGH end criterion, an end condition, and a scoring parameter; The one or more PGH computer games are created based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, the PGH rules being related to the PGH attributes and used to configure how the one or more PGH computer games are played.

5. A non-transitory computer readable medium comprising program instructions for creating one or more playable gameplay highlights (PGH) computer games from a computer base game, wherein execution of the program instructions by one or more processors of a computer system causes the one or more processors to perform a method comprising the steps of: receiving events or data related to the computer base game using a logic engine, wherein the logic engine is included in a processor located in a server; Processing the events by the logic engine to generate building blocks, or processing the data by the logic engine to generate building blocks; capturing one or more highlights in the computer base game, wherein each of the captured one or more highlights corresponds to a selected starting point and an ending point in the computer base game; Processing the building blocks by the logic engine to generate highlight attribute parameters, the highlight attribute parameters comprising one or more of: possible goals, possible constraints, possible PGH end criteria, possible end conditions, and possible scoring parameters respectively associated with each of the one or more highlights; selecting a PGH bright spot in each of the one or more bright spots, wherein the PGH bright spot corresponds to a selected starting point and an ending point in one of the one or more bright spots; processing, by the logic engine, the building blocks associated with the selected PGH highlights to generate PGH attributes, the PGH attributes comprising one or more of: goals, constraints, PGH end criteria, end conditions and scoring parameters, the selected start point and end point; The one or more PGH computer games are created based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, the PGH rules being related to the PGH attributes and used to configure how the one or more PGH computer games are played.

Images