Method and system for creating game, method for executing game, and non-transitory computer readable medium

Abstract

To provide replayable gaming content generated by a user that utilizing regamification data.SOLUTION: Data related to a game are received, highlights are captured in the game, each of the highlights corresponds to a starting point and an ending point selected in the game, a PGH (Playable Gameplay Highlight) in each of the highlights is selected, the PGH corresponds to a starting point and an ending point selected in one of the highlights, and repeats processing the building block related to a PGH highlight selected for generating PGH attributes, and creates a PGH game on the basis of the PGH attributes, each of the PGH games includes a PGH rule, and the PGH rule is related to the PGH attributes, and configures play of the PGH game.SELECTED DRAWING: Figure 7A

Description

Technical Field

[0001] The subject matter of the present disclosure relates to electronic games, and more particularly, to the implementation of a system for creating and playing new games.

Background Art

[0002] 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" presents a method for creating video mini-games based on legacy game titles using snapshot technology. This method creates games based on snapshots of legacy games and provides a small cut of entertainment to players who do not want to play the entire legacy game.

Summary of the Invention

Means for Solving the Problems

[0003] According to a first aspect of the present invention, there is provided a computer-implemented method for creating one or more playable game play highlights (PGH) computer games from a computer-based game, the method comprising receiving data related to the computer-based game using a logic engine, the data including one or more of events, text, audio, images, video recordings of the computer-based game, other videos depicting the computer-based game, the logic engine being included in a processor located on a server; processing the data to cause an event, and processing the event by the logic engine to cause a building block or processing the event by the logic engine to cause a building block; capturing one or more highlights in the computer-based game, each of the one or more highlights corresponding to a selected start point and an end point in the computer-based game; processing the building block by the logic engine to provide highlight attribute parameters, the highlight attribute parameters including one or more of possible objectives, possible constraints, possible PGH end criteria, possible end conditions, and possible scoring parameters, each related to each of the one or more highlights; selecting a PGH highlight in each of the one or more highlights, the PGH highlight corresponding to a selected start point and an end point in one of the one or more highlights; processing the building block related to the selected PGH highlight by the logic engine, for example, by iterative processing, to generate PGH attributes, the PGH attributes including objectives, constraints, PGH end criteria, end conditions, and scoring parameters, one or more of the selected start point and the end point; creating the one or more PGH computer games based on the PGH attributes, each of the PGH computer games including PGH rules, the PGH rules being related to the PGH attributes,including creating for constituting the play of the one or more PGH computer games.

[0004] In one embodiment, the method includes restoring events related to the computer-based 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 provide 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 ending the play of the one or more PGH computer games when the PGH attribute parameters are obtained.

[0005] In one embodiment, the method includes generating a PGH status for each of the one or more PGH computer games, where generating the PGH status includes calculating one or more of a scoring parameter, a target status, a constraint status, and a PGH end criterion status, sending the PGH status to a management module included in the server, and providing a server event based on one or more of the PGH status and the building blocks.

[0006] In one embodiment, the method includes sending a server event from the server to the game client device and displaying the server event on a display.

[0007] In one embodiment, the method includes calculating a PGH result for each of the one or more PGH computer games based on the events, sending the PGH result to a PGH application, and displaying the server event on a display of the game client device.

[0008] In one embodiment, the method includes selecting the one or more highlights by clicking one or more keys during gameplay of the base game.

[0009] In one embodiment, the method includes converting one or more of text, audio, images, video recordings of the base game, other videos into events.

[0010] In one embodiment, the method is identifying events in the computer-based game using an event module, the event module being included in a processor within the game client device.

[0011] In one embodiment, the method includes selecting a timestamp start point and selecting a timestamp end point in the computer-based game.

[0012] In one embodiment, the method includes sending a video of the computer-based game captured by a video module within the game client device to a server, sending the one or more highlights from the server to a PGH application (PGH app), editing the video based on selected PGH timestamps 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.

[0013] In one embodiment, the method includes creating one or more additional PGH computer games from the one or more PGH computer games.

[0014] In one embodiment, the method includes creating two or more PGH computer games based on a single one of the one or more highlights.

[0015] In one embodiment, the event includes an action or state of a character in the computer-based game.

[0016] In one embodiment, each building block of the building blocks is formed by aggregating one or more events of the event.

[0017] In one embodiment, the aggregation function combines two or more events of the same type or events of different types.

[0018] In one embodiment, the PGH attribute is selected by the creator of the PGH computer game or automatically selected by the logic engine.

[0019] In one embodiment, the PGH attribute further includes one or more of an explanation about the PGH, a thumbnail "preview" image of the PGH computer game, and a tag.

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

[0021] In one embodiment, the objective or constraint or PGH end criterion or end condition or scoring parameter is created using a generative artificial intelligence (AI) algorithm and model.

[0022] In one embodiment, the game client device is included in the server.

[0023] In one embodiment, it is the loading and execution of the one or more PGH computer games, and the loading and execution include restoring events from a base game, capturing a video or other signal of the base game, transmitting the captured video or other signal 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 the analyzed signal, and calculating scoring parameters.

[0024] According to a second aspect of the present invention, there is provided a computer-implemented method for creating one or more playable game play highlights (PGH) computer games from a computer-based game, the method comprising receiving data related to the computer-based game using a logic engine, the data including one or more of events, text, audio, images, video recordings of the base game, and other videos depicting the computer-based game, the logic engine being included in a processor located on a server; processing the data using the logic engine to bring about an event; capturing one or more highlights in the computer-based game, each of the one or more highlights corresponding to a selected start point and an end point in the computer-based game; processing the event by the logic engine to bring about highlight attribute parameters, the highlight attribute parameters including one or more of possible objectives, possible constraints, possible PGH end criteria, possible end conditions, and possible scoring parameters, each related to each one of the one or more highlights; selecting a PGH highlight in each one of the one or more highlights, the PGH highlight corresponding to a selected start point and an end point in one of the one or more highlights; processing the event related to the selected PGH highlight by the logic engine to bring about PGH attributes, the PGH attributes including one or more of an objective, a constraint, a PGH end criteria, an end condition, and a scoring parameter; creating the one or more PGH computer games based on the PGH attributes, each of the PGH computer games including PGH rules, the PGH rules being related to the PGH attributes and for configuring the play of the one or more PGH computer games.

[0025] In one embodiment, the method includes restoring 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 provide 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 play of the one or more PGH computer games when the PGH attribute parameters have been obtained.

[0026] In one embodiment, the method includes generating a PGH status for each of the one or more PGH computer games, where generating the PGH status includes calculating one or more of a scoring parameter, a target status, a constraint status, a PGH end criterion status, sending the PGH status to a management module included in the server, and providing a server event based on one or more of the PGH status and the building blocks.

[0027] In one embodiment, the method includes sending a server event from the PGH server to the game client device and displaying the server event on a display.

[0028] In one embodiment, the method includes calculating a PGH result for each of the one or more PGH computer games based on the identified events, sending the PGH result to a PGH application (PGH app), and displaying the server event on a display of the game client device.

[0029] In one embodiment, the method includes selecting the one or more highlights by clicking one or more keys during gameplay of a computer-based game.

[0030] In one embodiment, the method is identifying an event in the computer-based game using an event module, the event module being included in a processor within a game client device.

[0031] In one embodiment, a method including selecting a PGH highlight includes selecting a timestamp start point and a timestamp end point in the computer-based game.

[0032] In one embodiment, the method includes transmitting a video of the computer-based game captured by a video module within the 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 selected PGH timestamps 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.

[0033] In one embodiment, the method includes creating one or more additional PGH computer games from the one or more PGH computer games.

[0034] In one embodiment, the method includes creating two or more PGH computer games based on a single one of the one or more highlights.

[0035] In one embodiment, the identified event includes an action or state of a character in the computer-based game.

[0036] In one embodiment, each building block of the building blocks is formed by aggregating one or more events of the event.

[0037] In one embodiment, the aggregation function combines one or more events of the same type or different types.

[0038] In one embodiment, the PGH attribute is automatically selected by the creator of the PGH computer game or by the logic engine.

[0039] In one embodiment, the PGH attribute further includes one or more of the name of the PGH, the description, the thumbnail "preview" image of the PGH computer game, and the tag.

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

[0041] In one embodiment, the objective or constraint or PGH end criterion or end condition or scoring parameter is created using a generative artificial intelligence (AI) algorithm and model.

[0042] In one embodiment, the game client device is included in the server.

[0043] In one embodiment, the method includes loading and executing the one or more PGH computer games, and the loading and executing includes restoring events from the base game, capturing video or other signals of the base game, transmitting the captured video or other signals to the 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 the PGH rules and the analyzed video or analyzed signal, and calculating scoring parameters.

[0044] According to a third aspect of the present invention, there is provided a method executed by a game client device for loading and executing one or more playable game play highlights (PGH) computer games created based on a computer-based game, the method comprising restoring an event related to the computer-based game, identifying an event (e.g., continuously) in the one or more PGH computer games, streaming the identified event (e.g., continuously) from the game client device to a logic engine, processing the identified event (e.g., continuously) using the logic engine to provide building blocks, processing the building blocks (e.g., continuously) using the logic engine to determine whether PGH attribute parameters have been obtained based on PGH rules, and ending the play of the one or more PGH computer games when the PGH attribute parameters have been obtained.

[0045] In one embodiment, the method comprises generating a PGH status for each of the one or more PGH computer games, generating the PGH status comprising calculating one or more of a scoring parameter, a target status, a constraint status, a PGH end criterion status, transmitting the PGH status to a management module included in the server, and providing a server event based on one or more of the PGH status, the building blocks.

[0046] In one embodiment, the method comprises transmitting a server event from a PGH server to the game client device and displaying the server event on a display.

[0047] In one embodiment, the method includes 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.

[0048] In one embodiment, the method includes identifying an event in the computer-based game using an event module, where the event module is included in a processor within the game client device.

[0049] In one embodiment, the method includes creating one or more additional PGH computer games from the one or more PGH computer games.

[0050] In one embodiment, the identified event includes an action or state of a character in the computer-based game.

[0051] In one embodiment, each building block of the building blocks is formed by aggregating one or more events of the event.

[0052] In one embodiment, the aggregation function combines one or more events of the same type or different types.

[0053] In one embodiment, the PGH attribute is automatically selected by the creator of the PGH computer game or by the logic engine.

[0054] In one embodiment, the PGH attribute further includes one or more of a name of the PGH, a description, a thumbnail "preview" image of the PGH computer game, and a tag.

[0055] In one embodiment, the objective or constraint or PGH end criterion or end condition or scoring parameter is created using a generative artificial intelligence (AI) algorithm and model.

[0056] In one embodiment, the game client device is included in the server.

[0057] In one embodiment, it is to load and execute the one or more PGH computer games, and the loading and execution includes restoring events from a computer-based game, capturing video or other signals of the base game, transmitting the captured video or other signals to the 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.

[0058] According to a fourth aspect of the present invention, a system for creating one or more playable game play highlights (PGH) computer games from a computer-based game, the system comprising a game client device comprising a processing circuit having 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, the server processors comprising a video processor, a logic engine, and a PGH publisher, the logic engine being configured to receive data related to the computer-based game, the data including one or more of events, text, audio, images, a video recording of the base game, and other videos describing the base game; process the data to cause an event; process the event to cause a building block or process the event to cause a building block; capture one or more highlights in the computer-based game, each of the one or more captured highlights corresponding to a selected start point and an end point in the computer-based game; process the building block by the logic engine to provide highlight attribute parameters, the highlight attribute parameters including one or more of possible objectives, possible constraints, possible PGH end criteria, possible end conditions, and possible scoring parameters each associated with each of the one or more highlights; select a PGH highlight in each of the one or more highlights, the PGH highlight corresponding to a selected start point and an end point in one of the one or more highlights; process the building block associated with the selected PGH highlight by the logic engine, for example by iterative processing, to generate PGH attributes, the PGH attributes including one or more of objectives, constraints, PGH end criteria, end conditions, and scoring parameters.Creating the one or more PGH computer games based on PGH attributes, each of the PGH computer games including PGH rules, the PGH rules being related to the PGH attributes and for configuring play of the one or more PGH computer games, and a game client device configured to be enabled to perform the creating is provided.

[0059] In one embodiment, the one or more processors are further configured to be enabled to load and execute the one or more PGH computer games, the loading and executing including restoring 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 provide 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 ending play of the one or more PGH computer games when the PGH attribute parameters are obtained.

[0060] In one embodiment, the one or more processors are further configured to be enabled to generate a PGH status for each of the one or more PGH computer games, the generating the PGH status including calculating one or more of a scoring parameter, a status of a goal, a status of a constraint, a status of PGH end criteria, transmitting the PGH status to a management module included in the server, and providing a server event based on one or more of the PGH status and the building blocks.

[0061] In one embodiment, one or more processors are further configured and enabled to restore an event from a base game, capture video or other signals of the base game, transmit the captured video or other signals to a server, process the video using a video analysis processor or process the signals using a signal analysis processor, determine whether a PGH attribute parameter has been obtained based on PGH rules and the analyzed video or the analyzed signals, and calculate a scoring parameter.

[0062] According to a fifth aspect of the present invention, there is provided a non-transitory computer-readable medium including program instructions for creating one or more playable game play highlights (PGHs) from a computer-based game, the execution of the program instructions by one or more processors of a computer system causing the one or more processors to receive events or data related to the computer-based game using a logic engine, the logic engine being included in a processor located on a server; processing an event by the logic engine to provide building blocks, or processing data by the logic engine to provide building blocks; capturing one or more highlights in the computer-based game, each of the one or more captured highlights corresponding to a selected start point and an end point in the computer-based game; processing the building blocks by the logic engine to provide highlight attribute parameters, the highlight attribute parameters including one or more of possible objectives, 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 highlight for each of the one or more highlights, the PGH highlight corresponding to a selected start point and an end point in one of the one or more highlights; processing, by the logic engine, the building blocks associated with the selected PGH highlight to generate PGH attributes, for example by iterative processing, the PGH attributes including objectives, constraints, PGH end criteria, end conditions, and scoring parameters, and one or more of the selected start point and end point; creating the one or more PGH computer games based on the PGH attributes, each of the PGH computer games including PGH rules, the PGH rules being related to the PGH attributes and for configuring play of the one or more PGH computer games.Cause a method including creating to be executed.

[0063] To understand the present invention and see how it can actually be implemented, embodiments will be described by way of non-limiting examples with reference to the accompanying drawings.

Brief Description of the Drawings

[0064]

Figure 1A

Figure 1B

Figure 1C

Figure 2

Figure 3

Figure 4

Figure 5A

Figure 5B

Figure 5C

Figure 5D

Figure 5E

Figure 6

Figure 7A

Figure 7B

Figure 7C

Figure 7D

Figure 7E

Figure 7F

Figure 7G

Figure 7H

Figure 7I

Figure 7J

Figure 7K

Figure 7L

Figure 7M

Figure 8A

Figure 8B

Figure 8C

Figure 8D

Figure 9A

Figure 9B

Figure 9C

Figure 9D

Figure 9E

Figure 10A

Figure 10B

Figure 10C

Figure 10D

Figure 10E

Figure 10F

Figure 10G

Figure 11

Figure 12

Figure 13

Figure 14

[0065] In the following detailed description, numerous specific details are set forth in order to provide a thorough understanding of the present invention. However, it will be understood by those skilled in the art that the subject matter of the present disclosure may be practiced without these specific details. In other instances, well-known methods, procedures, components, and circuits have not been described in detail so as not to obscure the subject matter of the present disclosure.

[0066] The embodiments disclosed herein can be combined in one or more of many ways to provide a method for creating and executing one or more playable game play highlights (PGH) computer games from a computer-based game.

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

[0068] According to one embodiment, the present invention is configured to receive a base / original computer game having past rules (e.g., computer-based game 705) and create a new game defined herein as a PGH. The generated PGH may be related to, triggered by, and / or based on the base / original computer game. However, it is emphasized that the relationship between the computer-based game and the newly formed PGH is mainly related to the objects in the original game. For example, if the computer-based game is an NBA or racing computer game, both the original and the PGH share the titles of the NBA and racing games, and since these include characters such as basketball players and racing cars respectively, they will share some characters. However, the generated PGH includes new rules, objectives, and / or constraints that are not included in the original game, and thus could not be played according to these rules in the base computer game.

[0069] More simply stated, the PGH game draws inspiration from the theme or subject of the original game, but introduces a new gameplay mechanism, goals, and limitations that make it a different experience from the original game.

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

[0071] One difference between the present invention and the prior art lies in the approach to creating new playable content from a game. According to embodiments, the present invention involves, for example, decomposing an original game into, for example, building blocks or any type of data by analyzing events within the game, and creating a new game (e.g., PGH) with rules and gameplay that are different from the original game based on identifying various events.

[0072] Specifically, analyzing events within the game includes analyzing gameplay data to identify important events and processing the events, for example, on a server, to create PGH building blocks. These building blocks are then used to develop new objectives, constraints, and rules to enhance the original gameplay experience. In contrast, the prior art creates games, such as "mini - games," by, for example, 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 the snapshot and triggers, extracting limited sections of the game to provide a shorter self - contained experience.

[0073] Another important difference between the present invention and the prior art is the intended player experience. The PGH generated by this method aims to allow players to relive exciting moments from the original game while introducing new elements such as objectives, constraints, and scoring mechanisms. This approach improves the original gameplay by adding fresh challenges and rewards. Prior art solutions such as mini - games do not introduce new elements and instead provide a condensed version of the original gameplay starting from a given point.

[0074] Furthermore, the present invention differs from the prior art in its technical approach and the type of player experience it offers. The present invention focuses on recording, analyzing, and improving gameplay highlights using new objectives and scoring parameters, while the prior art focuses on extracting specific scenarios from saved game states to create something that, while a shorter self - contained mini - game experience, is not new. 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 bite - sized experiences.

[0075] Thus, while the rules of prior art computer games such as mini - game rules are equivalent to the rules of the base game, the rules of PGH can include one or more objectives that were not 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 competes against either an AI or another player. The player's objective is to score more points than the opposing team and win the game by doing so. A PGH created from a specific highlight of an NBA game can aim for the player to make more than X (e.g., 10) passes among their teammates within a specific time frame, take a shot from a distance at least equal to the distance of the highlight's score by the PGH creator, or steal the ball from the opposing team within a specific time frame.

[0076] The operations in accordance with the teachings of this specification can be performed by a computer specially constructed for the desired purpose or by a general-purpose computer specially configured for the desired purpose by a computer program stored in a non-transitory computer-readable storage medium.

[0077] Embodiments of the subject matter of this disclosure are not described with reference to any particular programming language. It will be understood that various programming languages may be used to implement the teachings of the subject matter of this disclosure described herein.

[0078] In recent years, certain moments in games have received worldwide attention, such that they can be compared to the significant moments in the Olympics or professional sports. Some embodiments of the subject matter of this disclosure provide systems and methods for enabling a gamer to identify notable or exciting sequences in their gameplay and then generate shareable "PGHs" that enable these sequences to be "relived" based on these game sequences. These PGHs can then be shared, for example, on social media and may achieve their own popularity spread.

[0079] Some embodiments of the subject matter of this disclosure provide systems and methods for enabling a gamer to create an infinite number of new games with new rules not included in the base game from a computer-based game with just a single "click".

[0080] Furthermore, PGH was created to address several important issues in the gaming industry. First, PGH aims to solve the problem of game discoverability, which has become increasingly difficult due to the overwhelming number of game releases across various platforms. In 2023 alone, Steam saw 14,532 game releases, while the mobile app stores had over 1 million new games. PGH enables the gaming community to promote and market games through organic user-generated content, allowing smaller studios to gain visibility without relying solely on traditional marketing methods. Second, PGH according to embodiments enables gamers to capture moments of their best games and convert them into playable highlights that can be shared across social media platforms. PGH not only enhances the community's gaming experience but also functions as a powerful marketing tool for game studios, developers, and publishers. By integrating the PGH SDK, studios can empower the community to showcase games, create demos, and provide early access to the press while focusing on optimizing the gaming experience. Additionally, PGH helps studios increase the lifetime value of users by facilitating in-game discovery and encouraging players to explore more items, levels, characters, and DLC.

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

[0082] Before describing the detailed description of the invention, it may be useful to set forth definitions of certain terms used herein.

[0083] The term "tracking data" as used throughout this specification, the specification and the claims, should be understood to encompass data that describes a complete playthrough of a game (e.g., a first-person shooting game) by an initial user. This term refers to the detailed information recorded during a gameplay session to capture and reproduce the game state and the player's actions.

[0084] The term "time-based data" as used throughout this specification, the specification and the claims, should be understood to encompass changes or modifications to the game state that are triggered at specific points in time or intervals relative to the start of PGH. These changes do not depend on any specific in-game event or player action, but rather are automatically made at a predetermined time. For example, spawning a new enemy character at the 15-second mark of PGH.

[0085] 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 are made dynamically in response to specific conditions being met, or specific actions being taken by the player or other game entities. For example, changing the behavior of an enemy character when the player enters a specific area of the game world.

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

[0087] As used throughout this specification and the specification and claims, the term "creator" should be understood to include an individual responsible for the invention, design, and creation of elements of a computer game, including but not limited to the concept, rules, mechanisms, levels, environments, characters, and other assets of the game. Note that some of the foregoing elements can be created automatically by an algorithm, by the original game developer and / or mechanism, or in collaboration with other creators.

[0088] As used throughout this specification and the specification and claims, the term "playable game play highlight (PGH)" or "PGH" or "PGH (PGHs)" or "PGH game (PGH Game)" or "PGH game (PGH Games)" should be understood to include playable content created, for example, by a gamer from their own original game play or past game play of a computer game. According to an embodiment, the created playable content can be played by any one or more users as if they were the original gamer at that particular moment of game play. This playable content has time constraints and matches the length of the original game play. Each PGH includes objectives and / or constraints and / or scoring parameters and / or end conditions 1224 and / or end PGH criteria 1222 set by the creator, by an algorithm, such as an artificial intelligence (AI) algorithm, or a combination of the two (e.g., multiple objectives, some created by the creator and some by the algorithm), and includes a scoring system for evaluating each player's performance according to the set scoring parameters. In some embodiments, the PGH includes rules (e.g., objectives and / or constraints and / or end conditions and / or PGH end criteria) that were not part of the rules of the base game, along with the scoring parameters.

[0089] The terms "original game" or "game" or "base game" or "computer game" or "computer-based game" as used throughout this specification and the specification and claims are to be understood to include the first or source computer game played by an original or initial gamer. A computer game or PGH can be any kind of computerized game, e.g., two-dimensional 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 / non-scored games, board games, competitive games, tournament games, gambling games, prize games, etc. The term "game" also includes non-competitive virtual "experiences" such as VR / AR music concerts or VR / AR exploration of virtual areas.

[0090] The terms "gameplay" or "gameplays" or "gameplay" or "game plays" as used throughout this specification and the specification and claims are to be understood to include the ways in which a player interacts with a game, including the states, actions, rules, mechanisms, and structures presented by the game, as well as the actions and states of the player used to progress the game, along with 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 enable the playing of a game, including the game's design, flow, and the player's engagement with the game's systems and content, including the involvement of other players. It includes the challenges the player faces, the choices the player makes, the actions the player takes, and the feedback and rewards the player receives as a result of the interaction with the game world.

[0091] As used throughout this specification, as well as the specification and claims, the term "player" should be understood to include a user who plays the base game or PGH.

[0092] As used throughout this specification, as well as the specification and claims, the term "Highlight" or "Highlights" should be understood to include a selected timestamp or time interval during the gameplay of a computer game that a player wishes to create a PGH for. An example of a "Highlight" could be a 20 - second duration in an NBA computer game where no other player was able to steal the ball from that player.

[0093] As used throughout this specification, as well as the specification and claims, the term "state" should be understood to include the characteristics of an entity in the game. Examples of "states" could be, for example, player position, or the health state of a player in a computer game.

[0094] As used throughout this specification, as well as the specification and claims, the term "action" should be understood to include actions and / or movements performed by a player during the game, such as jumping, shooting, etc.

[0095] As used throughout this specification, as well as the specification and claims, the term "Event" or "Events" or "Identified Event" or "Identified Events" should be understood to include a player's actions and states, and / or the actions or states of the game.

[0096] As used throughout this specification, as well as the specification and claims, the term "media" should be understood to include the frames, videos, and audio recordings of a computer game.

[0097] As used throughout this specification, as well as in the specification and claims, the term "configuration" should be understood to include properties that define a PGH, such as an objective, a score parameter, a starting point and an ending point, a thumbnail, a title, etc.

[0098] As used throughout this specification, as well as in the specification and claims, the term "URL" (Uniform Resource Locator) should be understood to include a sharable link to a specific PGH.

[0099] As used throughout this specification, as well as in the specification and claims, the term "Rule" or "Rules" or "PGH Rules" should be understood to include a Boolean expression / term that includes, for example, a logical operation based on a Boolean condition from a PGH. Specifically, a rule can be defined as a logical path, such as one or more binary logical paths related to a selected and played computer game segment that includes a PGH, such as a PGH building block. A rule can be based on a generated "objective" and / or "constraint" and / or "ending condition" and / or "ending PGH criterion 1222". Examples of such rules are shown in FIGS. 9B, 9C, and 9E.

[0100] As used throughout this specification, as well as in the specification and claims, the term "Objective" or "Objectives" should be understood to include one or more goals that a PGH player needs to achieve in order to secure a victory in a PGH game. An example of a possible objective is shown in FIG. 9B.

[0101] As used throughout this specification, as well as in the specification and claims, the term "Constraint" or "Constraints" should be understood to include one or more conditions such that when the conditions are reached, the player loses the PGH. An example of a possible constraint is shown in FIG. 9C.

[0102] As used throughout this specification, as well as the specification and claims, the terms "Score" or "Scores" or "Scoring Parameter" or "Scoring Parameters" or "Score Parameters" are to be understood to include a list of conditions under which a player can earn a score if the conditions are met. The score can be either positive or negative, and is cumulative such that each time a new condition is met, the score is updated either positively (i.e., by adding the score to the accumulated score) or negatively (i.e., by subtracting the score from the accumulated score). An example of possible scoring parameters is shown in FIG. 9D.

[0103] As used throughout this specification, as well as the specification and claims, the term "End Condition" or "End Conditions" is to be understood to include conditions under which, if met, a player is ensured a win in the PGH game, a player loses to PGH, or in some cases PGH ends without a defined win or loss for PGH. An example of possible end conditions is shown in FIG. 9E.

[0104] As used throughout this specification, as well as the specification and claims, the term "End PGH Criteria" or "End of PGH Criteria" is to be understood to include conditions under which, if met, a player is ensured a win in the PGH game, a player loses to PGH, or in some cases PGH ends without a defined win or loss for PGH. Examples of possible End PGH Criteria 1222 are time limits (e.g., a player has 30 seconds to reach one of the objectives), number of turns (e.g., in a chess game, a user has 20 turns to reach one of the objectives), or a combination of number of turns and time limit (e.g., in a chess game, there are 5 turns and 120 seconds to reach one of the objectives).

[0105] The terms "PGH building blocks" or "building block" or "building blocks" or "data building block" as used throughout this specification and the specification and claims, should be understood to encompass formulas formed based on identified events such as "actions" and / or "states" for creating one or more "objectives" and / or one or more "Constraints" and / or one or more "End Conditions" and / or one or more "End PGH Criteriaria 1222".

[0106] The terms "non-transitory memory" and "non-transitory storage medium" as used herein should be construed expansively to cover any volatile or non-volatile computer memory suitable for the subject matter of this disclosure.

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

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

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

[0110] The term "PGH data object" or "data object" as used throughout this specification and the specification and claims should be understood to encompass the data necessary to play PGH.

[0111] As used throughout this specification, the terms "graphic element", "graphic elements", "graphic assets", or "assets" are to be understood to encompass visual components within a game such as characters, environments, objects, user interface elements, special effects, animations, textures, and art styles. Examples of graphic elements include meshes; a comprehensive set of textures such as albedo, normal maps, height maps, occlusion, detail masks, and bake light maps; support for additional texture maps such as metallic maps, roughness maps, and emissive maps; secondary maps including detailed albedo and secondary normal maps; UV maps for texture coordinates; shaders and materials that define visual appearance and light interactions; animation rigs with keyframes and curves for movement; colliders for physical interactions; physical states for dynamics and kinematics; real-time lighting elements with shadow maps and global illumination; reflection probes and screen space reflection for accurate reflections; particle systems for special effects; post-processing effects for visual enhancements 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 (LOD) systems for performance optimization; occlusion culling and frustum culling systems for rendering efficiency; and a comprehensive scripting function for controlling game logic and interactions, but are not limited thereto.

[0112] Now, referring to FIG. 6, which shows a flowchart 600 of an exemplary sequence in which a user plays a game, creates a derivative PGH, and shares it with other users, in accordance with some embodiments of the subject matter described herein.

[0113] Early users can play computer-based games (e.g., on a personal computer, smartphone, tablet, dedicated gaming device, etc.) (610).

[0114] While playing the game, the early user can perform an action to "capture" the completed gameplay (620). As a non-limiting example, the early user can click on a "PGH capture icon" that is part of the game's user interface (e.g., via an input device), or press a key combination (e.g., the Alt button on the keyboard + the "g" button on the keyboard). Alternatively, it should be noted that in some embodiments, the early user can utilize some kind of appropriate interface to initiate the "capture" (620) process during or after gameplay. Alternatively, the process of capturing can be automatically triggered, for example, by an algorithm (e.g., an artificial intelligence (AI) algorithm) that gives an automatic score regarding the shareability of the gameplay or the likelihood that a particular gameplay is suitable for creating a PGH.

[0115] In some cases, while playing the game, for example, before the game is completed, a PGH can be generated and "captured" (620).

[0116] Next, the early user's device can make the data of the completed gameplay available to the PGH creation server (630). It should be noted that the transfer of gameplay data to the PGH creation server can be done simultaneously with or subsequent to the gameplay and can include intermediate entities, etc.

[0117] According to another embodiment, the entire data of the game is always uploaded to the PGH server during gameplay so that the user can select a specific highlight and later change it into a PGH.

[0118] Next, the server can present a user interface (UI) to the initial user (640). The presented user interface can enable the initial user to select a specific segment / highlight of the completed gameplay or completed game that will be included in the PGH (e.g., a 45-second gameplay sequence from a 15-minute game session). The presented user interface can also enable the initial user to select a specific goal of the PGH (e.g., killing a specific number of enemies, moving the protagonist to a specific point on the game terrain, etc.).

[0119] Next, the server can create a data object that enables the play of the PGH (650) and can make this data object available to other users. As a non-limiting example, the server can maintain a web page that enables users to review such data objects and then access specific objects to play their respective PGHs. 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 sharing a link such as an address hyperlink address and similar means.

[0120] Such a "secondary" user can then access the newly created PGH (e.g., by download, streaming, loading, etc.) and then play the PGH (660) and perform their own original game actions within this PGH.

[0121] According to another embodiment, as shown in detail in FIGS. 7A-7F and FIGS. 8A-8D, a secondary user can click on a link such as a PGH link to load the corresponding game and then send a request to a server (e.g., a PGH server) to load the corresponding PGH. This can occur either by sending a request to the cloud to execute the PGH (e.g., via a browser), or by opening a dedicated app (e.g., a PGH app) to execute the PGH. For example, the dedicated app can be cloud-based, or the base game can be opened on the secondary user's device and then the PGH can be opened on top of the base game.

[0122] As will be described in detail below, in some embodiments, specific techniques are utilized to enable a secondary user to experience the original game scenario experienced by an initial user while ensuring that the game play actually conforms to the original game rules, game physics, etc. In some embodiments, these techniques include the following.

[0123] i) Replicating time-based events from the original game in the PGH. For example, if at a specific time during the initial user's game play, a new enemy appeared or an existing enemy took an action spontaneously, the PGH system can replicate the actions of these enemies at the same PGH play time offset as in the original game based on the data contained in the PGH data object.

[0124] ii) Replicating event-triggered reactions from the original game in the PGH. For example, if in response to the initial user firing a weapon at an enemy and the enemy changing its position and firing back, the PGH system can replicate the enemy's behavior in response to the protagonist controlled by the secondary user firing a weapon at a specific enemy based on the data contained in the PGH data object.

[0125] iii) Caged / Uncaged NPCs: For robust PGH behavior, it may be desirable for NPCs within a PGH to repeat all or some of the behavior within the original game for a specified duration of the PGH and then behave according to their NPC characteristics after that time. An NPC on a PGH that behaves according to the original game behavior is referred to herein as a "caged NPC", and an NPC that behaves according to its characteristics and / or other factors is referred to herein as an "uncaged NPC".

[0126] In some embodiments, the PGH data object can include data indicating whether the initial state of the NPC is caged or uncaged. In some embodiments, the PGH data object can further include data indicating that the NPC should transition from its initial state (e.g., caged) to another state (e.g., uncaged) in response to a specific event.

[0127] For example, the data within the PGH data object can indicate to the PGH, or in response to a specific event within the PGH, that a particular NPC should transition from caged to uncaged at a specific time.

[0128] In some cases, it is not only the caged / uncaged NPCs that change their behavior according to the behavior of the secondary user. The claims are broader and refer to any behavior of the game. This means that when the secondary user selects the same options as the primary user, the overall behavior of the gameplay highlights will be similar (not identical), but when the secondary user changes things and selects different options from the primary user, the gameplay will behave differently (a specific example is the caged / uncaged NPC).

[0129] According to some embodiments, it is not only the caged / uncaged NPCs that change their behavior according to the behavior of the secondary user. For example, when the secondary user selects the same options as the primary user, the overall behavior of the gameplay highlights will be the same (e.g., not identical), but when the secondary user changes things and selects different options, the primary user and the gameplay will behave differently (a specific example is the caged / uncaged NPCs).

[0130] Refer to FIG. 1A, which is a block diagram of an exemplary system 100 for creating a PGH data segment (PDS) that enables a gamer to play a PGH based on a scenario of past gameplay according to some embodiments of the subject matter of the present disclosure.

[0131] The gaming system 100A compatible with playable creation can be a gaming device such as Sony (trademark) Playstation (trademark), Microsoft (trademark) Xbox (trademark). Alternatively, the gaming system 100A compatible with PGH creation can be a programmable device such as a personal computer (PC), smartphone, tablet, etc. Alternatively, the gaming system 100A compatible with PGH creation can be another suitable platform.

[0132] The gaming system 100A compatible with PGH creation can include a processing circuit 110A, and the processing circuit 110A can include a processor 120A and a memory 130A.

[0133] The gaming system 100A compatible with PGH creation can be operably connected to various peripheral devices (such as game-related peripheral devices), for example. Such peripheral devices can include, for example, a game display / audio system 180 and a game controller 170. The peripheral devices can also include a virtual reality / augmented reality headset, or other types of games or other peripheral devices.

[0134] Processor 120A can be a suitable hardware-based electronic device having data processing capabilities such as, for example, a general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC) dedicated for specific use, one or more cores within a multi-core processor, etc. Processor 120A can also be composed of, for example, a plurality of processors, a plurality of ASICs, virtual processors, combinations thereof, and the like.

[0135] Memory 130A can be, for example, a suitable type of volatile and / or non-volatile storage, and can include, for example, a single physical memory component or a plurality of physical memory components. Memory 130A can also include virtual memory. Memory 130A can be configured to store various data used for operations, for example.

[0136] Storage 160 can be a suitable type of volatile or non-volatile storage such as, for example, a hard disk, a solid state drive, and the like.

[0137] Processing circuit 110A can 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 can include, for example, gaming engine 150, tracker module 105, and game-specific logic 140.

[0138] Gaming engine 150 can be a software module that implements general gaming functions such as, for example, the following.

[0139] - Managing devices such as game display / audio system 180 and game controller 170, including receiving inputs from (and sending outputs to) such devices. - Implementing virtual objects used and displayed in the game (such as, for example, the terrain of the game, obstacles, etc.). - Provision a virtual object, determine the current state of the virtual object, and provide an application programming interface (API) for managing the virtual object.

[0140] The gaming engine 150 can be, for example, a commercial gaming engine such as Unreal (trademark), Unity (trademark), etc.

[0141] The gaming engine 150 can include various sub-modules that implement "bullet physics", "vehicle movement", etc., which enables changes during the progress of the game state to be autonomously performed within the gaming engine 150.

[0142] The gaming engine 150 can implement, for example, changes to the game state in response to the following.

[0143] · Pseudo-random generation events such as enemies that appear pseudo-randomly in a first-person shooter game · Game controller device events such as the user pressing a game controller device button to fire a weapon · Characteristics of virtual objects - for example, a moving vehicle can have a continuously updated position within the game terrain

[0144] The game-specific logic 140 can be a software module that cooperates with the gaming engine 150 and peripheral devices such as the game display / audio system 180 and the game controller 170 to implement an actual game (such as a first-person shooter game, a racing game, a turn-based game such as chess, etc.). The game-specific logic 140 can interact with the gaming engine 150 via the API.

[0145] In some examples, the game-specific logic 140 provisions an initial game scenario to the gaming engine 150 first. As a non-limiting example, in a racing game, the game-specific logic 140 can first provision the gaming engine 150 with virtual objects including a race track having a specific topology, a first-person player vehicle having a position on the race track, non-player vehicles having specific appearance and movement characteristics, and the like. The game-specific logic 140 can execute the provisioning of the initial game scenario via the API of the gaming engine 150.

[0146] The game-specific logic 140 can include a tracker module 105. The tracker module 105 can write tracking data to storage. The tracking data can include, for example, data indicating the following.

[0147] a) Data read by the game-specific logic 140 from the gaming engine 150 that describes the current characteristics of the virtual object and the associated game state. b) Data (or data to be written) written by the gaming engine 150 to the game-specific logic 140 that describes the current characteristics of the virtual object and the associated game state, programmed for a specific game.

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

[0149] The tracker module 105 can write the tracking data to, for example, the following two groupings.

[0150] a) Grouping including data that describes initialization data, and b) Grouping including data that describes subsequent changes to virtual objects and game state events.

[0151] Data that describes subsequent changes to virtual objects and game state events can include data (such as a timestamp) indicating when the change occurred within the game.

[0152] Data that describes subsequent changes to virtual objects and game state events can include, for example, an image (such as a screenshot) or video segment indicating a game event at the time of the change / event.

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

[0154] The PDS server 195 can be a suitable type of physical or cloud-based server including, for example, a processing circuit 110B. The processing circuit 110B can include a processor 120B and a memory 130B.

[0155] The processor 120B can be a suitable hardware-based electronic device having data processing capabilities such as, for example, a general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC) dedicated to a specific use, one or more cores within a multi-core processor, etc. The processor 120B can also be composed of, for example, a plurality of processors, a plurality of ASICs, virtual processors, combinations thereof, etc.

[0156] Memory 130B can be, for example, an appropriate type of volatile and / or non-volatile storage, and can include, for example, a single physical memory component or multiple physical memory components. Memory 130B can also include virtual memory. Memory 130B can be configured to store various data used in operations, for example.

[0157] Processing circuit 110B can 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 can include, for example, PGH creation module 145 and re-gamefication logic 135.

[0158] PGH creation module 145 can be a software module that accesses the uploaded tracking data 155, presents (for example) a user interface (for example, a web-based user interface) to the user, and then uses the tracking data and (optionally) user input to construct (i.e., set creation parameters, for example, refer to 330) a PGH data segment. A flowchart of an exemplary method for outputting a PDS is shown below with reference to FIG. 3. An exemplary format of the PGH data segment is shown below with reference to FIG. 4.

[0159] Re-gamefication logic 135 can be a software module that receives data indicating the scoring parameters of the PGH and / or the game end criteria of the PGH (via a user interface such as, for example, a web-based user interface).

[0160] As a non-limiting example, the tracking data can include data describing a complete play of a game (for example, a first-person shooting game) by an initial user. Within the complete play of the game, there can be several scenarios with different types of enemies and targets, different terrains, and different goals.

[0161] In some embodiments, the PGH creation module 145 can present a web-based interface to allow an initial user to select a particular scenario within a longer in-game scenario that constitutes the basis of the PGH. For example, the selected scenario may include a protagonist who needs to kill a particular number of enemies placed in a particular position on a particular terrain. In some such embodiments, the web-based interface displays still images or video segments (included in the uploaded tracking data 155) to assist the user in selecting a scenario.

[0162] In some such embodiments, the re-gamefication logic 135 can then provide the PGH creation module 145 with several possible game-specific scoring parameters (e.g., the time to kill all enemies, the number of enemies killed within 30 seconds, etc.) and receive the initial user's selection.

[0163] In some embodiments, the PGH creation module 145 can create a PGH data segment 115. In some such embodiments, the PGH creation module 145 writes data indicating one or more virtual objects that are part of the initial state of the selected segment (i.e., the virtual objects exist at the start of the play of the user replaying the game). This data can be a derivative of the uploaded tracking data 155 and can be written to the PGH data segment 115 in the tracking data format or a different data format. This data can describe the virtual objects well enough to allow the player to configure the virtual objects to the gaming engine.

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

[0165] The data for time-based modifications can be accompanied by an explicit timestamp indicating the time offset in the PGH when the modification is to be made. In some embodiments, the timestamp is implicit (e.g., each time-based modification can represent a change occurring at 10 ms intervals).

[0166] This data can describe the virtual objects such that it is sufficient for the player to configure the virtual objects in the gaming engine with the appropriate time offset.

[0167] As a non-limiting example, while processing the uploaded tracking data 155, the PGH creation module 145 can detect the initialization and modification of virtual objects that occur after the start of the portion of the game being used to create the PGH. As a more specific example, in some embodiments, the PGH creation module 145 can examine tracking data from the uploaded tracking data 155 indicating the sudden appearance of new enemies from newly visible terrain features such as buildings. Thus, the PGH creation module 145 can then create a time-based modification to the PGH to create new virtual objects corresponding to the new enemies.

[0168] In some embodiments, the PGH creation module 145 can further write data indicating event-based modifications to the PGH. For example, the PGH creation module 145 can write data indicating one or more virtual objects to be added to the game, or one or more modifications to already-defined virtual objects in response to a specific event that causes the game to occur (e.g., in response to the behavior of the protagonist). The data indicating these virtual objects can be a derivative of the uploaded tracking data 155 and can be written to the PGH data segment 115 in the tracking data format or a different data format.

[0169] This data can describe the virtual objects such that it is sufficient to enable the player to configure the virtual objects in the gaming engine in response to the events shown.

[0170] As a non-limiting example, while processing the uploaded tracking data 155, the PGH creation module 145 can evaluate which virtual object initializations and modifications are due to the actions of the protagonist or other game events, and which virtual object initializations and modifications are spontaneous, i.e., not due to the 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 indicating 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 behavior of the protagonist and, accordingly, create an event-based modification to the PGH.

[0171] In some embodiments, the PGH creation module 145 can further write data indicating re-gamefication data to the PGH. For example, the PGH creation module 145 can write data indicating scoring parameters and / or game end criteria to the PDS.

[0172] In some embodiments, the PGH creation module 145 can write data indicating virtual object release criteria associated with a specific virtual object (e.g., within initialization data, time-based data, or event-based data) to the PDS.

[0173] The virtual object release criteria are events, such that upon the occurrence of an event, the player stops the ongoing control of the gaming engine to reproduce the virtual object behavior of the game played by the initial user. The player can then perform different behaviors on the object as appropriate for the game. In some examples, the virtual object release criteria can be a time offset to the PGH.

[0174] As a non-limiting example, in a racing game, there may be virtual objects of NPC cars. The PGH creation module 145 can configure the PDS such that at a specific time offset to the play of the PGH by the player, the virtual object of the NPC car in the game played by the initial player no longer mirrors the behavior, but rather follows a different behavior. For example, the original behavior of the NPC can be that the virtual object of the NPC car decelerates before a specific turn on the road, and the non-mirrored behavior can be that the car accelerates at that specific turn.

[0175] Refer to FIG. 1B, which is a block diagram of a variation of a system for creating a PGH data segment (PDS) according to some embodiments of the subject matter of the present disclosure. In FIG. 1B, the PGH creation function is split between a PGH creation module 145A (located within the tracker module of gaming system 100A) and a PGH creation module 145B (located within the PDS server). In this case, the PGH creation module can be split in any suitable way. For example, in some embodiments, the PGH creation module 145A can prepare time-based correction data and event-based correction data, and the PGH creation module 145B can continue to receive the scoring parameters selected by the user and prepare the replayfication data.

[0176] Refer to FIG. 1C, which is a block diagram of an exemplary gaming system corresponding to playing a PGH using a PGH data segment (PDS) based on a scenario of past gameplay according to some embodiments of the subject matter of the present disclosure.

[0177] A PGH player using the system 100B of FIG. 1C can, for example, download a PGH segment 165 from a PDS server 195. The PDS replay module 185 can then use the PGH segment 165 to provide the PGH. A detailed description of an exemplary method of providing the PGH from the PGH segment 165 is shown below with reference to FIG. 4.

[0178] Refer to FIG. 2, which is an exemplary user interface presented to an initial player of a game according to some embodiments of the subject matter of the present disclosure. The screen shown in FIG. 2 includes a selection interface element (210) that enables an initial user to select a time range from the original game on which PGH is based. This interface also shows still frames of the game play, and these still frames can be the images included in the uploaded tracking data 155 (after being placed in the tracking data 125 by the tracker module 105), and are then extracted by the PDS server 195.

[0179] The screen shown in FIG. 2 further includes a scoring parameter interface element (220) that enables an initial user to specify the scoring parameters of PGH, and a game end criterion interface element (230), which may also be referred to as a "goal", that enables an initial user to specify the conditions under which PGH should be completed.

[0180] Now, refer to FIG. 3, which is a flowchart 300 of an exemplary method for creating a PGH data segment according to some embodiments of the subject matter of the present disclosure.

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

[0182] Next, the processing circuit 110B of the PDS server 195 (e.g., the PGH creation module 145) can present an initial player with a user interface (such as a web-based interface or a protocol-based interface, etc.) that enables the user to specify the parameters for creating PGH from the uploaded tracking data 155 (320).

[0183] The processing circuit 110B (e.g., PGH creation module 145) of the PDS server 195 can receive (or determine) the start time, end criteria, and one or more scoring parameters of the PGH (330).

[0184] In some embodiments, the initial user can select the start time (e.g., the time offset in the original game that functions as the starting point of the PGH) from the user interface.

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

[0186] In some embodiments, the initial user can select the PGH end criteria from the user interface. For example, the user can specify the 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.

[0187] In some other embodiments, the processing circuit 110B (e.g., PGH creation module 145) of the PDS server 195 determines the game end criteria via a different mechanism (e.g., using the end of the uploaded tracking data 155).

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

[0189] In some other embodiments, the processing circuit 110B of the PDS server 195 (e.g., the PGH creation module 145) determines the scoring parameters via a different mechanism (e.g., using scoring parameters suitable for a single game). For example, in the case of a racing game, the system may automatically set the scoring parameters to lap times. In the case of a first-person shooter game, the scoring parameters may be automatically set to the number of enemy kills.

[0190] The processing circuit 110B of the PDS server 195 (e.g., the PGH creation module 145) can then write the initial virtual object data to the PGH data segment (PDS) 115 (340).

[0191] The processing circuit 110B of the PDS server 195 (e.g., the PGH creation module 145) can write time-based data including new and / or modified virtual objects to the PDS 115 (350).

[0192] The processing circuit 110B of the PDS server 195 (e.g., the PGH creation module 145) can write event-based data including trigger events, new and / or modified virtual objects to the PDS 115 (360).

[0193] The processing circuit 110B of the PDS server 195 (e.g., the PGH creation module 145) can write re-gamefication data (e.g., game end criteria / objectives, constraints, PGH end criteria, end conditions, scoring parameters) to the PDS 115 (370).

[0194] The processing circuit 110B of the PDS server 195 (e.g., the PGH creation module 145) can make the PDS 115 available for access (e.g., download) and enable others to play the PGH.

[0195] Now, pay attention to FIG. 4 showing an exemplary data structure of a PGH data segment according to some embodiments of the subject matter of the present disclosure.

[0196] The PGH data segment 400 can include initial virtual object data 410, and the initial virtual object data can include zero or more virtual object descriptors 415A, 415B,..., 415n. Each virtual object descriptor can be a grouping of data indicating a group of virtual object parameters that a gaming system corresponding to PGH play should instantiate at the start of PGH.

[0197] The PGH data segment 400 can include time-based data 420, and the time-based data 420 can include zero or more time descriptors (e.g., time descriptors 425A - 425D in FIG. 4). Each time descriptor can describe the time offset of PGH. Each time descriptor can be associated with one or more new virtual object descriptors (e.g., new virtual object descriptor 425C) and / or one or more modified virtual object descriptors (e.g., modified virtual object descriptor 425B).

[0198] Each new virtual object descriptor can be a grouping of data indicating a group of virtual object parameters that a gaming system corresponding to PGH play should instantiate at the time offset in PGH (as indicated by the associated time descriptor).

[0199] Each modified virtual object descriptor can include an identifier of an already instantiated virtual object, and can be a grouping of data indicating a group of virtual object parameters that a gaming system corresponding to PGH play should apply to the corresponding already instantiated virtual object at the time offset in PGH (as indicated by the associated time descriptor).

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

[0201] As described above, each modified virtual object descriptor can include an identifier of an already instantiated virtual object, and can be a grouping of data that indicates a group of virtual object parameters to be applied to the corresponding already instantiated virtual object in response to an event in the PGH (as indicated by the relevant event descriptor) by a gaming system corresponding to PGH play.

[0202] The PGH data segment 400 can include re-gamefication data 440, and the re-gamefication data 440 can include game end criteria 445A and scoring parameters 445B. The game end criteria 445A can include data that indicates when a gaming system corresponding to PGH play should end the PGH (e.g., at a specific time, after achieving a specific goal such as the protagonist reaching a certain point within the terrain or killing a specific number of enemies (or a combination of such criteria)). The scoring parameters 445B can include data that indicates what a gaming system corresponding to PGH play should track and display as a measure of success in the PGH (e.g., the number of enemies killed, the strength of the protagonist, etc.).

[0203] Now, turn attention to FIGS. 5A-5E, which show a flow diagram 500 of an exemplary method for providing PGH from a PGH data segment, according to some embodiments of the subject matter of the present disclosure.

[0204] The method shown in FIGS. 5A-5E can be executed, for example, by a gaming system 100B corresponding to PGH play or by the systems shown in FIGS. 7C, 7D, and 7E.

[0205] The processing circuit 110A (e.g., the PDS replay module 185) can receive the PDS 165 (510).

[0206] Next, the processing circuit 110A (e.g., the PDS replay module 185) can control the gaming engine 150 to instantiate the initial virtual objects shown in the PDS 165.

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

[0208] The processing circuit 110A (e.g., the PDS replay module 185) can start playing the PGH, for example, by appropriately controlling the gaming engine 150 (540).

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

[0210] In some embodiments, the processing circuit 110A (e.g., the PDS replay module 185) simply controls the gaming engine 150 to evaluate time-based data and 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) simply excludes the protagonist and the objects controlled by the protagonist (although past game events can still be used for comparison purposes) because the PGH behavior of the game protagonist is controlled by the game player rather than by past game events. In some other embodiments, virtual objects that are the game protagonist or are controlled by the game protagonist do not exist in the PDS 165.

[0211] Similarly, in some embodiments, a non-player character (NPC) can initially operate as described above in "caged mode". In this state, the NPC can behave as it did in the original past game played by the initial player. In such embodiments, when a trigger (i.e., an event selected by the system to create) occurs, the NPC begins to show a change in its behavior. For example, the NPC can show future behavior according to an artificial intelligence decision tree (rather than its behavior in past games).

[0212] More specifically, in such an embodiment, the processing circuit 110A (e.g., the PDS replay module 185) only controls the gaming engine 150 to evaluate time-based data and instantiate new virtual objects or modify these objects when the existing virtual objects are not associated with the virtual object release criteria that have been achieved. As described above, the achievement of the virtual object release criteria indicates that the corresponding virtual object (e.g., an NPC, etc.) should no longer mirror its behavior in past games, but rather operate according to different (e.g., game-specific) characteristics.

[0213] The processing circuit 110A (e.g., the PDS replay module 185) can continuously evaluate whether a new game event occurring during the PGH matches an event descriptor of the event-based data of the PDS 165 (570). If a match is found, the processing circuit 110A (e.g., the PDS replay module 185) can control the gaming engine 150 to instantiate a new virtual object or modify an existing virtual object according to the new or modified virtual object data associated with the corresponding event-based data of the PDS 165 (580).

[0214] The processing circuit 110A (e.g., the PDS replay module 185) can continuously evaluate whether a new game event matches the scoring parameters of the regamingfication data of the PDS 165 (585). If so, the processing circuit 110A (e.g., the PDS replay module 185) can control the gaming engine 150 to display the updated scoring information (588).

[0215] The processing circuit 110A (e.g., the PDS replay module 185) can continuously evaluate whether the game end criteria are met (590). If so, the processing circuit 110A (e.g., the PDS replay module 185) can end the game (595). Otherwise, the game play can continue. For example, the processing circuit 110A (e.g., the PDS replay module 185) can go back and re-evaluate whether the PGH time offset matches the time descriptor of the time-based data (550) (550).

[0216] Referring now to FIG. 7A, a high-level block diagram of an exemplary system 700 configured and operative to create a PGH based on one or more scenarios of past game play in a base game, according to some embodiments of the present invention.

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

[0218] 1. Game client device 701 2. Launcher module 702 3. PGH server 703 4. PGH app 704

[0219] 1. Game client device 701: According to an embodiment, the game client device 701 relates to a device or software configured to enable a user (e.g., a player or creator) to play an original game (e.g., base game 705) or a PGH and process the original game or PGH using, for example, one or more processors 708 in real time (or near real time) to identify one or more "events" within the original game.

[0220] According to some embodiments, the game client device 701 can be hosted on a server such as a video streaming server.

[0221] 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, a smartwatch, etc.

[0222] The original game (e.g., the base game 705) can be any game that a user (e.g., a gamer) wants to play and further wants to create and play a PGH based on or related to one or more scenarios of past gameplay of the original game.

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

[0224] The event module 709 is configured to and enabled to identify events 715 in the base game 705 (e.g., when creating a new PGH) and / or in the PGH (e.g., when playing the PGH) and continuously stream the identified events 715 to the PGH server 703, for example, in real time. The events 715 can include, for example, the "actions" and / or "states" of the characters in the base game 705.

[0225] The game client device 701 further includes a video module 706 that is configured to and enabled to record the base game 705 and / or the view of the game (e.g., the game and all content layers displayed thereon, such as the current score of the game, the remaining time, etc.) and transmit it to the PGH server 703 either as raw data or after processing the data (e.g., after combining frames into a video or video segment).

[0226] 2. Launcher module 702: According to an embodiment, the launcher module 702 is configured to host, publish, and execute a base game 705 such as PGH738 and / or Microsoft games, SONY games, etc., and is an enabled software platform.

[0227] 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 in a cloud gaming platform.

[0228] 3. PGH Server 703: According to an embodiment, the PGH server 703 can be any type of server, such as a backend application that can be hosted in a data center, for example, a private or public data center.

[0229] Private data centers are typically owned and operated by the game company itself. They are used to host gaming servers, store player data, and manage game content. Private data centers provide better control and security for confidential game data, including player profiles, game statistics, and in-game transactions. They also provide the infrastructure necessary for game development, testing, and deployment.

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

[0231] 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.

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

[0233] According to one embodiment, the architecture of the system 700 includes a separation between a logic engine process and a video creation process. The logic engine 714 receives events identified in the base game 705 to provide building blocks 716 (such as shown in FIG. 7E) that are further transformed into highlight attributes such as, for example, objectives and / or constraints and / or scoring parameters in a game. Video creation includes cutting and editing segments selected from the base game 705 and further constructing / restoring the selected segments. The highlight attributes are added on top of the selected segment video and synchronized to provide PGH attributes 735 to the PGH publisher 733 and PGH timestamps 763' to the video processor 763.

[0234] According to some embodiments, the logic engine 714 is configured and enabled to receive and / or extract the identified event 715 from the event module 705, process and analyze the identified event 715, and generate building blocks 716 using logical rules and / or mathematical formulas (e.g., aggregation functions) applied to one or more types of events. For example, during a shooting game, the identified event can consist of "kill" events within the PGH, and one of the building blocks can be the number of kills in the PGH. In this example, the identified event consists of all kill events, and the mathematical formula can be a count function over all kill events within the identified event, thereby resulting in several kill building blocks. Another example is a shooting game where the building block can consist of two or more event types, and the identified event can consist of all "jump" events and further all "kill" events. A possible building block in this game can be an "air kill" which means killing an enemy in the game while the user is jumping. In this case, the building block verifies whether a kill was made by the player while the player was jumping. Based on the building blocks 716, the logic engine 714 is further configured to generate highlight attributes 714' that are sent to the PGH application 704 to create the PGH 738. The highlight attributes 714' include parameters such as possible objectives, constraints, end conditions 1224, PGH end criteria 1222, and scoring parameters used, for example, to play the PGH and configure the PGH rules.

[0235] In some cases, the building block 716 can be identical to the identified event 715. This means that no formula or aggregation is applied to the identified event 715 to create the building block 716. Instead, the building block 716 is a direct copy of the identified event 715 without modification. For example, in a racing game, one of the identified events is "lap completed" which is triggered every time a player completes a lap around the race track. If no aggregation or formula is applied to this event, the corresponding building block 716 can simply be "lap completed". Therefore, in this case, if the identified event is "lap completed", the resulting building block will be the same, i.e., "lap completed". The logic engine 714 can then directly use these building blocks 716 without conversion to generate the potential goals and / or constraints and / or scoring parameters and / or end conditions 1224 and / or PGH end criteria 1222 of the PGH. For example, the potential goal can simply be "complete a lap". Thus, when the building block 716 is identical to the identified event 715, it means that the events are used as they are without any modification or calculation applied to them during the building block creation process. In this case, the raw events themselves function as the building blocks for generating highlight attributes.

[0236] According to an embodiment, building block 716 is used by logic engine 714 in an intermediate process for calculating and generating PGH parameters that are included in and used by PGH 738 while playing a future-generated PGH. Specifically, building block 716 is used as a raw material for calculating PGH parameters that include, for example, one or more of the purpose, constraints, end condition 1224, PGH end criterion 1222, and scoring used for playing PGH 738. The building block is used to generate all possible combinations (or subsets of combinations) of potential purposes, constraints, end condition 1224, PGH end criterion 1222, and scoring (included in the transmitted highlight attribute 714') that will be used by the PGH creator or player to generate the PGH. For example, the captured highlight of the base game includes "10 kills" of enemies within one minute, the identified event is "kill", and building block 716 is used to generate various possibilities of purpose, constraints, end condition 1224, PGH end criterion 1222, and scoring parameters based on the "10 kills" in the highlight. Thus, when the creator selects a time segment, for example, a 30-second segment, from the highlight, the purpose, constraints, end condition 1224, PGH end criterion 1222, and scoring are updated accordingly. More specifically, in this example, assume that the first 30 seconds of the highlight include 8 out of 10 kills, the last 30 seconds include an additional 2 kills, and the total for one minute is 10 kills. A potential initial purpose for this highlight could be to kill 10 enemies within one minute. After the user selects the first 30 seconds (the start time of the highlight is 0 seconds and the end time is 30 seconds, where 8 kills occurred in the original highlight), the potential purpose is updated according to the events and building blocks of the first 30 seconds and, in this specific example, becomes to kill 8 people, and the possible constraints, end condition 1224, PGH end criterion 1222, and scoring parameters are also updated respectively.

[0237] According to an embodiment, the video processor 763 is configured and enabled to receive the captured video 717, process the video, and result in a highlight video 763” that is sent to the PGH application 704. The video processor 763 is further configured to receive selected PGH timestamps 763’ at intervals during the gameplay of the base game for which the creator or player wants to create a PGH 738. The video processor 763 edits (e.g., cuts) a relevant subset of the video from the highlight video based on the timestamps 763’ to create the final PGH video 775. For example, the timestamps 763’ may include a first timestamp = 30 seconds and a second timestamp = 65 seconds, and based on these timestamps, the video processor cuts the video starting at the first timestamp (30 seconds) and ending at the second timestamp (65 seconds), creates the final PGH video 775 with a total duration of 35 seconds, and sends the final PGH video 775 to the PGH publisher 733.

[0238] The PGH publisher 733 is configured and enabled to receive the PGH attribute 735 from the PGH app 704 and the final PGH video 775 from the video processor 763 and publish the PGH 738. Optionally, the published PGH 738 may be stored in the storage 713. Publishing includes generating a digital representation of the PGH that includes, for example, a PGH data object 1200 as shown in FIG. 12. In some embodiments, the PGH publisher 733 creates the PGH data object 1200 based on selected start and end points of the PGH attribute, where the PGH publisher 733 further extracts events based on the start and end points of the PGH attribute (e.g., uses only events associated with the period between the start and end points) and stores them in the PGH data object 1200 to enable restoration of the PGH. For example, the start and end points can correspond to timestamps for highlights (e.g., for a highlight at 2:00, the start point can be 0:12 and the end point can be 1:01, which corresponds to 0 minutes 12 seconds from the start of the highlight to 1 minute 1 second from the start of the highlight), or alternatively, the start and end points can be for the number of turns in a turn-based game (e.g., the start point can be at turn #34 and the end point can be at turn #78).

[0239] FIG. 7H shows a detailed block diagram illustration of the processor 712 of FIG. 7A, according to an embodiment. As described above, optionally, the logic engine 714 is configured and enabled to receive and / or extract the identified event 715, for example, from the event module 705, process and analyze the identified event 715, and generate the building block 716 using logic rules and / or mathematical formulas (e.g., aggregation functions) applied to one or more types of events.

[0240] Alternatively or additionally, the logic engine 714 is configured to receive and / or extract data 7150 and convert that data into identified events 715 and / or building blocks 716, and may include an enabled data conversion module 741. The data conversion module is configured and enabled to convert this diverse input data into a standardized format of identified events 715 and / or building blocks 716 that 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 significant moment in the game, it analyzes the text and extracts relevant events such as the player's actions or changes in the game state. These extracted events are then typically converted into the same / near format as the identified events 715 generated by the event module 709. Similarly, if the input data is an audio commentary that describes a particular game play sequence, the data conversion module 741 processes the audio, notes the relevant parts, and converts that information into separate identified events 715 that capture the important aspects of the described game play. By standardizing the input data into identified events 715, the data conversion module 741 enables the system to create PGH data objects 1200 and recover PGH from a more diverse set of input sources beyond just raw game play data. Another example of a known conversion module is a neural network (e.g., a deep neural network), which receives as input data 7150 that can be either of one type or a combination of two or more types, and as output calculates this representation (i.e., the last layer or aggregation function of the neural network based on performing the data input on the neural network function) to convert the representation into identified events 715 and / or building blocks 716.

[0241] According to an embodiment, the data conversion module 741 can be arranged outside the logic engine (e.g., in another external processor within the server).

[0242] The data 7150 can include one or more of the following, namely, events, text, audio, images, video recordings of the base game, and other videos depicting the base game.

[0243] According to some embodiments, the PGH logic engine 714 uses building blocks 716 to calculate PGH scores 7120 based on scoring parameters, and sends them to the PGH rules 719 to calculate a PGH status 777 including a target status 12260, a constraint status 12280, and an end PGH criterion status 12220 (e.g., which of the criteria have been reached). The PGH status 777 is calculated based on one or more of a target 1226, a constraint 1228, an end PGH criterion 1222, and an end condition 1224.

[0244] The embodiment shown in FIG. 7I incorporates all the essential components and functions shown in the previous FIG. 7H. However, FIG. 7I presents an alternative configuration architecture that can include an enabled data conversion module 741 configured such that the logic engine 714 receives and / or extracts data 7150 and converts this data into identified events 715. Referring to FIG. 7I, an alternative embodiment of the present invention different from the embodiment shown in FIG. 7H is shown. In this configuration, the building blocks 716 are omitted from the system architecture. Instead, this embodiment utilizes only the identified events 715 by converting the data into identified events 716 through an intermediate processing step.

[0245] 4. PGH Application 704: According to an embodiment, the PGH application 704 creates a PGH game 738 based on received input including a highlight attribute 714' and a highlight video 763", outputs a PGH attribute 735 and a PGH timestamp 763', and is configured to further manage the PGH platform using a user interface 7360 including a feed 736 that can, for example, discover, execute, share, etc., the PGH 738, and is an enabled software application.

[0246] The PGH application 704 comprises a user interface comprising a 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 purpose 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 can use the highlight attributes 714’ together with the corresponding highlight video 763” to select a subset of the timeline of the captured highlight (e.g., select a start point (e.g., start timestamp) and an end point (e.g., end timestamp) of the captured highlight which can be a subset of the captured highlight). For example, in a captured highlight having a length of two minutes, for creating a PGH timestamp 763’, the start point can be 10.5 seconds from the start of the highlight and the end point can be 1 minute 12.2 seconds from the start of the highlight. Additionally, the creator can use the highlight attributes 714’ based on the processed identified events and / or building blocks of the highlight’s own gameplay to select, together with other PGH attributes 735 (e.g., PGH name, description, thumbnail “preview” image, tags, etc.), a purpose and / or a constraint and / or a scoring parameter and / or an end PGH criterion 1222 to create PGH attributes 735 and generate PGH attributes 735 that are particularly relevant to a selected start point of the PGH based on the highlight video 763” (e.g., the creator can use the timeline of the highlight video 763” so that both use the same timeline of the highlight, to scroll the video and select the exact start point the creator wants to select).

[0247] During operation, when the user plays the base game 705, the event module 709 extracts events from the game (e.g., from the game client 701) and sends them to the PGH server 703. The events include, for example, the state or action of one or more characters in the base game 705 or the state or action of the game.

[0248] For example, the base game 705 could be an NBA computer game, and the "events" could be actions performed by one or more NBA players within the game. The events can be divided into several "event categories" such as "state events" and "action events".

[0249] A "state event" is a characteristic of an entity within the base game. Examples of "states" could be, for example, player position or the health state of a player in a computer game.

[0250] An "action event" is an action and / or movement performed by a player during the game, such as a jump or a shoot by an NBA player.

[0251] The identified events 715 are sent, along with the video 717 that captures the game, to one or more processors 712 within the PGH server 703, for example, in real time or near real time. The one or more processors 712 include a video processor 763 and a logic engine 714. In the PGH server 703, the video processor 763 is configured and enabled to process the captured video 717 to generate, for example, preview thumbnail videos and processed videos including preview videos. An example of a thumbnail video is shown in FIG. 10D showing the PGH thumbnail 1050 that enables the user to easily select one or more highlights using the PGH thumbnail 1050. It is emphasized that the video processor is also configured and enabled to process video segments and / or frames of the captured video 717.

[0252] The building block 716 is a logic rule created based on converting the identified event 715 (such as the state 723' and action 724' events within the base game 705) into a logical statement that can be understood by a PGH player or PGH creator.

[0253] According to an embodiment, each building block of the building block 716 is formed by aggregating one or more identified events 715. The aggregation function combines the identified events 715, which can be of the same type or different types. For example, in a fighting game, a "flying kick" building block can consist of an action identified as "jump" followed by an action identified as "kick" within a specific time frame of the base game.

[0254] As an example of aggregating events of the same type, a game can include a mechanism that aggregates the player's movement of X degrees into a single movement of Y degrees that combines all the individual movements. Similarly, when a player moves completely 360 degrees around a given position, according to an embodiment, this movement can result in a "spin" building block.

[0255] Note that in some cases, the aggregation function can result in the same building block 715 as the original identified event 715. In such cases, the aggregation function functions as an identification function and leaves the identified event 715 unchanged. This means that the resulting building block is equivalent to the original event recorded in the game.

[0256] According to an embodiment, a user (e.g., a player or a creator) can also activate a "highlight" action related to one or more selected scenarios of the gameplay of the base game 705. The selected "highlight" is transmitted to one or more processors 712 in the PGH server 703, along with the game event, when the user plays the game, e.g., in real time.

[0257] By way of example, within the context of a streamed NBA video game event, specific in-game actions and states such as "run", "pass", and "dribble", "position", "weapon", etc. are identified using the event module 709. The term "highlight" relates, for example, to a specific segment in an NBA game that lasts, e.g., 20 seconds, where the player successfully completes 20 consecutive passes without being intercepted by an opposing player.

[0258] For example, a newly created "objective" in an NBA game is "When the playerPosition of the PGH player is equal to the playerPosition of the creator at the end of the highlight, the PGH player wins against PGH" and can be.

[0259] This "objective" relates to a newly formed rule, which, for the purposes of this example, can be called a "speed run from A to B" in relation to the basic NBA game. According to this "objective", the player now has a new objective that was not one of the objectives of the NBA base game (e.g., base game 705), and 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.

[0260] The "PGH end criterion" can be, for example, a 10 - second time limit, and the "end condition" can be, for example, the end of the original game, the NBA game (i.e., when there is no time left on the original game timeline, for example, when the clock in the 4th quarter of the NBA game reaches 0:00 left for play).

[0261] The newly created "constraint" formula can be (in non - limiting examples) the following. In an NBA game, the constraint can be to keep the ball in the hands of the same player and prevent the ball from getting into the hands of other players (from either the player's team or the opposing team). This new "constraint" (not part of the base game) can be related to the original actions and / or states made by the PGH creator during the game play or to constraints derivable from these actions and / or states.

[0262] These objectives, constraints, end condition 1224, and PGH end criterion 1222 according to the embodiment are created based on automatically and / or autonomously identified events in the NBA - based game for creating the above - mentioned objectives and constraints. It should be emphasized that these new objectives and constraints have never been part of the rules of the NBA - based game and they can be created based on events occurring during the game play of the NBA - based game, for example.

[0263] Advantageously, the system architectures as presented in FIG. 7A and further FIGS. 7B - 7E and other figures of the present invention include using a streaming module and method for transmitting recorded data of game play (e.g., captured video 717) and identified events (e.g., identified event 715), and one or more game engines and processors disposed, for example, in a cloud server (e.g., PGH server 703). As a result, the creation of PGH is more configurable and can be used to create PGH for any type of game. The architecture includes, according to an embodiment, a streaming and transmission module, so this architecture eliminates, in some embodiments, the need to hold, analyze, and store data within a client SDK such as PGH client SDK 798 as shown in FIG. 7C.

[0264] The block diagram shown in FIG. 7B incorporates all the essential components and functions shown in the previous FIG. 7A. However, FIG. 7B presents an alternative configuration architecture where the processor 708 comprises a creation input module 7080 disposed, for example, in the game client device 701.

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

[0266] According to an embodiment, the creation input module 7080 is configured and enabled to generate data 7150 and send and / or extract it to the PGH server 703. The creation input module 7080 receives various types of input data from a user or creator, such as text, audio recordings, video clips, and game play data. The creation input module processes this data and sends the data to the PGH server 703 for further analysis and possible PGH creation. The creation input module 7080 can not only process user-provided input, but also autonomously extract data from ongoing game play including events.

[0267] 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 identified events 715 and / or building blocks, as shown in FIGS. 7H and 7I. This conversion process involves extracting important elements from user-provided data and game play information and converting them into separate actionable events that can be used as the basis for PGH data objects 1200, enabling the creation and restoration of PGH. By converting various input data into a standardized format of identified events and / or building blocks, the logic engine 714 enables the PGH creation system to operate with a consistent and manageable data format, such as the PGH data object 1200.

[0268] According to an embodiment, a method, device, and system are provided for creating one or more additional PGH computer games from one or more PGH computer games. Thus, an infinite number of PGH computer games can be created from 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. The additional PGH computer games can be created as exemplified in the present invention.

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

[0270] FIG. 7C shows a flowchart of a method 750 for generating a PGH based on one or more captured scenarios of past gameplay (e.g., “highlights”) of a single-player or multiplayer computer game according to an embodiment. System 700 can be used to implement method 750. However, method 750 may also be implemented by a system or processor having other configurations according to an embodiment.

[0271] According to an embodiment, as shown in flowchart 750, one or more PGHs can be created separately for each of the captured highlights, where each of the created PGHs can be created separately and independently of each other using different PGH attributes 735. For example, if a highlight is captured during gameplay, multiple PGHs can be created from the same highlight using independent PGH attributes 735 such as different purposes, constraints, scoring parameters, starting points, ending points, etc. For example, in the case of a highlight captured from an NBA game, two PGHs can be created from the same highlight, the first PGH being aimed at scoring 5 points in the PGH, and the second PGH being aimed at passing the ball 10 times between players of one's own team. In another example, if a two-minute highlight is captured, a first PGH can be created using PGH attributes 735 with a start time of 0:05 and an end time of 0:35, and a second PGH can be created using PGH attributes 735 with a start time of 1:10 and an end time of 1:58.

[0272] According to some embodiments, one or more PGHs can be created separately for each of the captured highlights using other methods such as those shown in FIGS. 7D, 7F, 7G, and 13, for example.

[0273] Optionally, in a cloud-based architecture, before step 751, when streaming the base game 705, for example, assets from the base game are extracted and disassembled as described below with reference to FIG. 8C. "Assets" refer to various elements that make up the game environment, such as graphics, 3D models, textures, sound effects, music, animations, etc. These assets are essential components used by game developers to create visual, auditory (and optionally sensory) experiences within the game.

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

[0275] Optionally, in a cloud-based architecture before step 751, graphic elements associated with the base game 705 are extracted and collected in a structured format. Graphic elements can be elements that describe a scene, such as meshes, textures, maps, audio effects, video excerpts, etc., and the structured format can be a file, a file portion, a JSON file format, a YML file format, etc., that describes either the graphic elements themselves or a set of metadata attributes of the graphic elements or graphic elements to be used by the game or PGH.

[0276] A detailed description of the extraction process for this step is shown with reference to FIGS. 7J and 7L.

[0277] In operation 752, data related to the base game (e.g., data 7150) is received 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 and a server device such as PGH server 703. The data may include one or more of text such as text including an event of the base game, an explanation of the base game, or a text description of a highlight, audio such as audio including an auditory explanation of the base game, an image such as an image including an image description of the base game or a highlight, and other video explaining the game, such as other video including a visual explanation of the base game or a narrator's video game play.

[0278] In operation 753, the data is sent to a logic engine such as logic engine 714 included in a processor located at the server and is, for example, continuously streamed.

[0279] For example, the data may include identified events 715 that are continuously sent (e.g., streamed) to a server such as PGH server 703 in an ongoing loop when a player or creator plays the base game 705.

[0280] According to one embodiment, the data (e.g., identified events 715) is continuously sent (e.g., streamed) to the logic engine 714 in an ongoing loop when a player or creator plays the base game 705, for example, in real time or near real time.

[0281] In some cases, the identified events 715 may be sent to other locations within the system such as system 700, for example, to a storage 713 and / or local and remote storage units such as a local or remote cloud server.

[0282] According to an embodiment, game data (e.g., identified events 715 that may include all of the game data or data within a predetermined time frame of game play, and optionally captured video 717) can be continuously uploaded to the server of PGH through a game play session. Thereby, the user can create a PGH based on any part of the uploaded game play data without having to manually capture specific highlights during the game.

[0283] In step 754, data (e.g., identified events 715, text, audio, images, video recordings of the base game, and other videos that describe the game) is processed (e.g., transformed) using, for example, a data conversion module to result in the identified events 715. According to an embodiment, the data is processed using a logic engine 714 disposed on a server such as, for example, PGH server 703.

[0284] Alternatively or additionally, in step 754, during game play for example, events 715 in the base game are received and / or automatically identified by event module 709. The identified events 715 can include, for example, "actions" performed by one or more characters in the base game such as "run" / "jump" and / or the "state" of the player such as "health status", "position", "clothing", "weapon", "items held", etc.

[0285] In some cases, as shown in FIG. 9A, each "event" is numbered with an ID number and added to an "event list". The event list 910 for each game includes an event name 912, an event type 914, and a value type 916. These details can exist in a specified list, such as a game management page or game configuration settings, to enable different purposes and the construction of score parameters.

[0286] In operation 755, as described above with reference to FIG. 7A, the identified event 715 that results in building block 716 is processed. According to some embodiments, the identified event 715 is processed using a logic engine 714 located on a server such as, for example, PGH server 703.

[0287] Optionally, in some embodiments, in operation 757, the recorded video of the gameplay (e.g., the captured video 717) is sent to one or more processors 712 within the PGH server (e.g., in real time, or near real time, or streamed after the highlight is captured). For example, as shown in FIG. 7A, the captured video 717 of the base game 705 is streamed from the video module 706 within the game client device 701 to the video processor 763 within the PGH server 703.

[0288] In operation 758, one or more "highlights" in the base game 705 are captured either by the player / creator or automatically by the system (e.g., using the processor 712) and sent, for example, from the server 703 to the PGH app 704. For example, as shown in FIG. 7A, the highlight video 763” is captured by the video module 706 and sent from the video processor 763 to the PGH builder 734.

[0289] According to embodiments, one or more highlights correspond to selected start and end points in a computer-based game. In some embodiments, one or more highlights correspond to specific time intervals during gameplay in a base game that a player or creator desires to use as a basis for creating a PGH 738.

[0290] According to one embodiment, a "highlight" can be captured by a user by clicking on a selected key or mouse button defined, for example, as a "highlight click" during gameplay. The system can capture a predetermined time interval before and after the click, for example, 120 seconds before and 10 seconds after the click, thereby capturing a 130 - second highlight. Each predetermined time interval (before the "click" and after the "click") is independent and may be different from each other. The predetermined time interval after the click may or may not exist as desired. For example, only the time before the click may be used (e.g., the highlight may consist of, for example, 120 seconds before the click and 0 seconds after the click). Specifically, as shown in FIG. 10A, the text prompt 1008 can present to the player "press Alt + R to capture playable moments related to 'highlight'" herein, which corresponds to instructing the user to press a specific combination of keys using keywords to capture the highlight. It is important to note that the system or the user can capture multiple highlights during the video game play of the base game, and each highlight can have various durations and / or other properties.

[0291] According to some embodiments, each highlight of the captured highlights is then received by the PGH server for further processing. For example, if the base game 705 is the racing car computer game shown in FIG. 10A, a potential highlight could be a 30 - second interval during which the player successfully maintained a speed of 160 km / h without colliding. The player or the system can then choose to create a PGH based on this specific highlight.

[0292] In Project 759, the building block is iteratively processed, for example, using a logic engine 714, to yield a highlight attribute 714' that includes, for example, potential / possible objectives and / or constraints and / or end conditions 1224 and / or PGH end criteria 1222 and / or highlight parameters of a scoring parameter related to a captured highlight.

[0293] As described above, the building block is used to generate all possible combinations of potential highlight attributes such as objectives, constraints, and scoring that will be used by the PGH creator or player to generate a PGH. In this intermediate step, the calculated potential / possible parameters such as objectives, constraints, and scoring are used as base parameters, which are further used in the following steps when a particular game interval of the captured highlight is selected by the creator or the system.

[0294] According to an embodiment, the possible objectives, constraints, PGH end criteria 1222, end conditions 1224, and scoring parameters are based on the identified events 715 from the captured "highlight". 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 a highlight attribute 714' that includes, for example, proposed objectives, constraints, PGH end criteria, end conditions, and scoring parameters of the PGH.

[0295] According to one embodiment, the highlight attribute 714' is sent from the PGH server 703 to the PGH app 704 and is displayed on the app user interface (UI) 7360. For example, as shown in FIG. 10C, in an exemplary base game, during PGH creation, possible attributes may be displayed including: Objectives 1010: "Address 1933 damage" and "Kill 6 enemies"; Constraints 1012: "Perform more than 1 reload"; Score parameter 1014: "Headshot: 100 points per headshot"; Possible PGH end criteria 1222: "Time duration: 17s" (i.e., 17 seconds), where this PGH end criteria is calculated, for example, by the selected start point 1032 and end point 1034 of the PGH (e.g., by subtracting the start point 1032 from the end point 1034), or in the case of a turn-based game, by subtracting the starting turn number (e.g., 35) from the ending turn number (e.g., 61), which in this example results in 26 turns and can form the PGH end criteria.

[0296] In step 760, select the start and end points of the PGH highlight in the captured highlight to generate the highlight attribute 714' for which the PGH is formed. The selected highlight may be based on a time constraint or the number of turns or an end condition or a combination thereof. For example, the PGH highlight corresponds to and / or includes the selected start and end points in one of the one or more highlights. For example, in a turn-based or step-oriented computer game such as chess, the initiation (e.g., start) and termination (e.g., end) points within the game sequence are selected.

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

[0298] In step 761, based on the selected PGH highlight start and end points and / or timestamps and the associated building blocks and / or identified events, a PGH attribute 735 is generated that includes one or more parameters such as the objective and / or constraints and / or scoring and / or end PGH criteria 1222 and / or end conditions 1224 and / or start point and / or end point. Specifically, in this step, the building block 716 is processed, for example, by the logic engine 714, to yield a PGH attribute 735 that includes one or more parameters, such as objectives, constraints, and scoring parameters that match the start and end points and / or time interval of the selected PGH highlight.

[0299] According to an embodiment, steps 760 and 761 may be repeated in a loop to allow the system or the creator to select and change the start and end points and / or the time segment duration (e.g., based on two selected timestamps) as a basis for generating the PGH, and based on this, the PGH attribute 735 is calculated (e.g., a two-minute highlight with 10 kills is captured where 9 kills are made in the first minute of the highlight and an additional 1 kill is made in the last minute, and if the user selects a start point of 0:00 (the start of the captured highlight) and an end point of 1:00, the objective can be updated from 10 kills for the entire selected highlight to 9 kills up to the first minute selected in the highlight).

[0300] As shown in FIG. 10C, the creator can scroll the video display 1030 left and right, move the respective timestamps 1032 and 1034 left and right to bring about the final PGH video 775, and accordingly, for example simultaneously, the PGH attribute 735 is updated according to the selected final PGH video 775. Similarly, in a turn-based game (e.g., chess), the starting point can be, for example, a specific turn having all of the relevant events, and the ending point can be the maximum number of allowed turns (e.g., 10 turns).

[0301] An example of PGH including the newly created objectives is shown in FIG. 9B and includes the following objectives.

[0302] "The player needs to kill the enemy without taking damage"; or "The car needs to travel at a speed exceeding 150 km / h without colliding". The highlight attribute 714' or the PGH attribute 735 includes new objectives, constraints, scoring parameters, end conditions not included in the base game, and is created for the first time here according to the captured "highlight" (e.g., highlight video 763") based on the identified event 715 within the base game. It should be emphasized that it is created according to the captured "highlight" (e.g., highlight video 763") based on the identified event 715 within the base game.

[0303] Optionally, in step 763, when the PGH start point and end point of the PGH highlight (e.g., timestamp 763' and / or start point and end point) are selected, the highlight video 763" is edited based on the selected PGH timestamp 763' and / or start point and end point to generate the final PGH video. Specifically, as shown in FIG. 7A, the selected PGH timestamp is sent from the PGH builder 734 to the video processor, and the video processor cuts and creates the final PGH video.

[0304] In operation 764, based on the PGH attributes 735, one or more PGH computer games are created, for example using the PGH publisher 733, where each of the PGH computer games includes PGH rules. These PGH rules are related to the PGH attributes 735 and enable the play of the one or more PGH computer games.

[0305] According to another embodiment, in operation 764, according to the embodiment, one or more PGHs are generated based on the PGH attributes 735, for example in the logic engine 714.

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

[0307] According to one embodiment, building blocks and / or identified events are stored in a memory, such as the storage device 713 of the PGH server, for future use after a highlight is selected. When a highlight is selected and created, the building blocks are used to calculate the PGH attributes 735 and the identified events are used to restore the base game, and thus both are stored in the server's storage.

[0308] FIG. 7D shows a flowchart 7501 of a method for generating a PGH based on one or more captured scenarios of past game play (e.g., "highlights") of a single-player or multiplayer computer game according to an embodiment. The system 7000 can be used to implement the method 7501. However, the method 7501 may also be implemented by other systems or processors having other configurations according to the embodiment.

[0309] The flowchart 7501 of FIG. 7D incorporates all of the essential steps and functions shown in the previous FIG. 7C. However, FIG. 7D presents an alternative configuration architecture and method that uses only the events identified for the logical engine 714 to generate the PGH and does not require converting the identified events into building blocks. Thus, in this configuration, the building blocks 716 are omitted from the system architecture as presented in FIG. 7I, and thus step 755 of FIG. 7C, which includes processing the events identified to yield the building blocks, is not executed.

[0310] Instead, this embodiment utilizes only the identified events 715 by converting the data into the identified events 716 by an intermediate processing step.

[0311] Specifically, referring to FIG. 7D, the following alternative steps of the present invention, which are different from the flowchart shown in FIG. 7C, are shown.

[0312] Following step 758, in step 7590, the identified events are processed to yield highlight attributes that include the possible objectives, constraints, and scoring parameters associated with each one of the one or more highlights.

[0313] Thus, following step 760, in step 7610, PGH attributes are generated that include one or more parameters including objectives and / or constraints and / or scoring, based on the identified events associated with the selected PGH highlight start and end points.

[0314] Now refer to FIG. 7E, which is a high-level block diagram of an exemplary system 785 for enabling the loading and execution (e.g., playing) of a PGH created based on one or more scenarios of past gameplay in a base game. The PGH can be the PGH 738 created from the base game 705 as shown in FIGS. 7A - 7D.

[0315] FIG. 7E includes all of the components depicted in FIG. 7A while further showing supplementary elements necessary to manage data transmission between system modules during the gameplay of PGH. It is emphasized that the separate figures for the creation and play of PGH were provided merely for simplicity and to provide a clear and concise representation of the block modules. Thus, it should be recognized that the modules and elements shown in FIGS. 7A and 7E may potentially be integrated and incorporated into a unified system.

[0316] According to an embodiment, the game client device 701 includes one or more processors 708 having an event module 709. During PGH play, the event module is configured and enabled to identify an event 715 in the PGH (e.g., PGH 738) and continuously transmit (e.g., stream) the identified event 715 to the PGH server 703, for example, in real time or near real time. The event 715 may include, for example, the “action” and / or “state” of a character in the PGH (as illustrated above in FIGS. 7A and 7B with respect to the creation of, e.g., PGH 738).

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

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

[0319] Specifically, as described with reference to FIGS. 7A, 7B, and 7H, the logic engine 714 is configured and enabled to process PGH rules 719 related to one or more objectives and / or constraints and / or end PGH criteria and / or end conditions created or received by the user from the system. The PGH rules 719 are logical formulas (such as numerical rules) derived from the objectives and / or constraints and / or end PGH criteria and / or end conditions.

[0320] The logic engine 714 either receives the identified events or receives the data 7150, processes it into the identified events, potentially processes the identified events into building blocks, determines whether the objectives and / or constraints and / or end PGH criteria and / or end conditions have been obtained based on the identified events and / or building blocks, and further calculates the score of the PGH execution both during and after the PGH execution is completed.

[0321] For example, during the PGH execution, the logic engine 714 receives the identified events, processes them to result in a building block 716 of "3 kills", while the objective of the PGH 738 is "5 kills". Therefore, the logic engine 714 identifies that the PGH has not yet ended and that 2 more kills are required to reach the objective.

[0322] Furthermore, according to an embodiment, during the PGH play, the logic engine 714 is configured to generate a PGH status 777 including the status of the objectives and / or constraints (e.g., for the objective of 3 kills, 1 kill out of 3 has been achieved) and / or end PGH criteria and / or end conditions during the PGH play, for example, in real time or near real time.

[0323] In operation, during PGH play, the logic engine 714 continuously sends the PGH status 777 to the management module 778 within the PGH server 703. The PGH status includes one or more of a target status 12260, a constraint status 12280, a score status 7120 (summarizing the scoring parameters 1220 based on their appearance in the PGH up to the time of calculation), an end condition status 12240, and an end PGH criterion status 12220. For example, as shown in FIG. 10G, the PGH status may include the status of a target 1041, a constraint 1042, and the score status 7120.

[0324] The management module 778 is configured and enabled to manage and control server events 779 related to PGH play.

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

[0326] The media manager 771 is configured and enabled to generate the server events 779. The server events 779 include the PGH status and additional data on top of the PGH status. For example, the additional data may include text, audio, graphic elements, images or videos, or a combination of text, audio, graphic elements, images or videos such as 3D graphic elements based on the identified events 715 and / or the PGH status 777 that will be included in the PGH. For example, the multimedia elements may include a 3D advertisement featuring an advertisement page on a building within the PGH game, and / or text containing recommendations and advice to the PGH player, and / or live audio streaming, etc. presented to the PGH player within the PGH game while the user is playing the PGH game.

[0327] The event manager 749 is configured and enabled to send server events 779, including PGH status 777 such as, for example, target status, constraint status, scoring parameters, end PGH criteria status, etc., as shown in, for example, FIG. 10G, in real time or near real time.

[0328] According to an embodiment, the PGH result 7502 is calculated based on the identified events and / or building blocks and, in some embodiments, is stored in the storage device 713 and can be sent to the PGH application later. The PGH result 7502 includes the final PGH result (e.g., the final PGH status 777 calculated at the end of the PGH).

[0329] FIG. 7F shows a flowchart of a method 7500 for loading and executing a PGH computer game, such as the PGH 738 created in FIG. 7A, according to an embodiment. The system 700, or the system 710, or the system 720 or the system 730 can be used to implement the method 7500. However, the method 7500 may also be implemented by a system or a processor having other configurations according to an embodiment.

[0330] In step 7900, events from the base game are restored and loaded using the data object 1200. The restoration process includes, according to an embodiment, one or more of the following steps: returning the PGH to a previous state or condition included in the base game and related to either the PGH timestamp 763 or the start and end points of the PGH. Restoration includes reloading the saved game events, restoring the player's progress and state, restoring the states of other players, restoring the state of the game environment, enabling the game play to resume seamlessly from the PGH start point (on the base game) so that the player can start the PGH play from the selected start point, ensuring continuity, and maintaining the game experience.

[0331] In operation 790, method 7500 starts the play of the PGH by initializing the game engine and loading the necessary resources.

[0332] In operation 791, during game play for example, events 715 in the base game are automatically identified by event module 709, for example continuously. The identified events 715 can include, for example, "actions" performed by one or more characters in the PGH such as "run" / "jump" and / or the "state" of the player such as attributes of the player's "health", "position", "clothing", "weapon", "items", etc.

[0333] According to one embodiment, it is emphasized that the step of restoring events in the base game (step 7900) to start the PGH in the same "state" as before is a one-time process for the restoration process only. Operation 791 is an ongoing process where events are identified throughout the game and continuously sent (for example, streamed) for processing.

[0334] In operation 792, the identified events 715 are continuously sent (for example, streamed) to a server such as PGH server 703 in an ongoing loop when the player or creator plays the PGH 738.

[0335] According to one embodiment, the identified events 715 are continuously sent (for example, streamed) to logic engine 714 in an ongoing loop, for example in real time or near real time, when the player or creator plays the base game 705.

[0336] In some cases, the identified events 715 may be sent to other locations within the system such as system 785, for example to local and remote storage units such as storage 713 and / or local or remote cloud servers.

[0337] In process 793, the identified event 715 results in a building block 716 and is processed to calculate scoring parameters based on the building block. According to an embodiment, the identified event 715 is processed using a logic engine 714 disposed on a server such as, for example, PGH server 703.

[0338] In process 795, the building block is processed to determine whether PGH attribute parameters (e.g., objectives and / or constraints and / or end conditions 1224 and / or PGH end criteria 1222) have been obtained based on PGH rules.

[0339] In process 797, a PGH status 777 is generated. According to an embodiment, the PGH status 777 includes the status of the objectives and / or constraints and / or PGH end criteria (e.g., in the case of a 3-kilometer objective, 1 kilometer out of 3 kilometers has been achieved with 12 seconds out of 30 seconds of PGH duration elapsed).

[0340] In process 798, the PGH status 777 is sent to a management module to provide a server event 779 based on the PGH status and / or the identified event.

[0341] In process 799, the server event is sent from the PGH server to a game client device.

[0342] In process 796, a PGH result 7502 is calculated based on the identified event and / or the building block and sent to a PGH application.

[0343] Figure 7G shows a flowchart of a method 7560 for loading and executing a PGH computer game, such as PGH738 created in FIG. 7B, according to an embodiment. System 700, or system 710, or system 720 or system 730, or system 785 may be used to implement method 7500. However, method 7560 may also be implemented by a system or processor having other configurations, according to an embodiment.

[0344] The method 7560 of FIG. 7G incorporates all of the essential steps and functions shown in the previous FIG. 7F. However, FIG. 7G presents an alternative configuration architecture and method in which the logic engine 714 uses only the identified events for loading and executing (e.g., playing) the PGH and does not need to convert the identified events into building blocks. Thus, in this configuration, the building blocks 716 are omitted from the system architecture and method as presented in FIG. 7I, and thus step 793 of FIG. 7F, which includes processing the identified events to yield the building blocks, is not executed.

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

[0346] Specifically, referring to FIG. 7G, the following alternative steps of the present invention, which are different from the flowchart shown in FIG. 7F, are shown.

[0347] Following step 792, in step 7930, scoring parameters are calculated based on the identified events. In step 7950, it is determined whether PGH attribute parameters (e.g., objectives and / or constraints and / or end PGH criteria and / or end conditions) are obtained based on the identified events according to the PGH rules. In step 7970, a PGH status (e.g., a scoring parameter status, an objective and / or constraint status) is generated.

[0348] The PGH result 7502 is calculated based on the identified event, and the PGH result is sent to the PGH application.

[0349] FIG. 7J shows a detailed block diagram of a system 710 configured and enabled to create a PGH 738 based on one or more scenarios of past gameplay in a single-player configuration according to an embodiment. The system 710 of FIG. 7J provides a detailed description of the system 700 shown in FIG. 7A and the system 7000 of FIG. 7B.

[0350] Although certain elements shown in FIGS. 7A and 7B may not be explicitly shown in FIG. 7J, it should be understood that the configuration of FIG. 7J may include one or more of the elements from the previous figures, unless otherwise specified. Conversely, FIG. 7J may include additional or alternative elements not shown in FIGS. 7A, 7B, 7E, 7H, and 7I. The configuration shown in FIG. 7J is intended to be exemplary and not limiting, and should not be construed as excluding any potential element or configuration within the scope of the present invention.

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

[0352] 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.

[0353] According to an embodiment, the base game 705 is a proprietary software game. The game, referred to as the original game or base game, constitutes an actual game exemplified by genres such as shooter games, racing games, turn-based games like chess, and NBA games. Typically, the base game 705 is developed by a game studio as is recognized in the art.

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

[0355] The asset publisher 711 is configured and enabled to obtain the base game 705, collect in-game elements such as graphic elements of the game and source code files associated with the game, and convert these elements into a structured format (e.g., JSON file format / YML file format). As shown in FIG. 7E, the asset publisher 711 further publishes the assets to an asset distributor 7860.

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

[0357] The automatic synchronizer module 721 is configured and enabled to communicate with one or more game engines (e.g., Unity, Unreal Engine) to extract data (e.g., transformation data, vertex position data, material data, etc.) from the game engine 718 and send it to the action streamer 722 and the state streamer 723. Elements such as player position, player health status, and enemy position are included in the synchronization.

[0358] The action streamer 722 is configured and enabled to identify action events 724' in the base game 705 and send the action events 724' to the PGH server 703.

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

[0360] According to some embodiments, instead of sending all consecutive positions of a player, the state streamer module 723 sends state events for a given player's position, optionally following a discretization process that may exist, and the state streamer module 723 sends several discretized samples.

[0361] According to an embodiment, the video module 706 is configured and enabled to record the base game 705 and / or frames of the game and send them to the PGH server 703. For example, the module can record frames of the game at a specific rate (e.g., 30 frames per second) in a specific file format (e.g., png file format), save the frames in a video file (optionally compress it to, for example, mp4 file format), and then send the created video file to the PGH server.

[0362] The PGH controller module 725 is configured and enabled to receive input actions (i.e., inputs from the player's device such as keyboard key strokes, mouse movements, joystick inputs, etc.) from the PGH player module 729 and control those basic game actions while playing PGH by passing the basic game actions to be executed in the base game 705.

[0363] The PGH Front 726 is responsible for receiving display information from the PGH Server 703 and presenting it to the base game and PGH players on top of PGH. The received information can be classified into three main types: 1. Pre-game data: Before starting PGH, the module displays relevant data such as the purpose and / or constraints and / or end PGH criteria of PGH. For example, as shown in the information 1015 of FIG. 10F, the target status (e.g., kill count) and the end PGH criteria status (e.g., time limit). 2. In-game data: During the gameplay of PGH, the module provides real-time updates including the PGH status 777, thereby continuously notifying the player about its progress. For example, the target status 1041, constraint status 1042, and score status 7120 are shown in FIG. 10G. 3. Post-game data: After completing PGH, the module presents information indicating whether the goal has been successfully achieved (e.g., PGH result 7502). The PGH Front 726 is not limited to these specific types of information, and the PGH Front 726 can display various other information to the player / creator, such as data received from server events 779 (e.g., media generated using 771).

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

[0365] The processor 708 and / or 712 can be a suitable hardware-based electronic device having data processing capabilities such as, for example, a general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC) dedicated to a specific purpose, or one or more cores within a multi-core processor. The processor can also be composed of, for example, multiple processors, multiple ASICs, virtual processors, combinations thereof, and the like.

[0366] The memory device 713 can be, for example, an appropriate type of volatile and / or non-volatile storage, and can include, for example, a single physical memory component or a plurality of physical memory components. The memory device 713 can also include virtual memory. The memory device 713 can be configured to store, for example, various data used in operations.

[0367] According to one embodiment, the PGH server 703 is a backend application that can be hosted in a data center such as, for example, a private or public data center. The PGH server 703 uses one or more processors to analyze the output data from the action streamer 722 and the state streamer 723 to implement the services necessary to create, share, and play a PGH game (e.g., single player or multiplayer), receiving a data stream of actions 724' and states 723' from the base game 705 via the PGH client SDK 798 that includes, for example, video frames from the video module 706 of the base game 705 and identified events (e.g., state and / or action events) from the base game.

[0368] 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 & media bus 7300, a PGH manager 731, and a PGH logic engine module 714.

[0369] The data streamer module 727 receives events 724' from the action streamer 722 and also receives events 723' from the state streamer 723, processes them, and stores them for creating and playing a PGH game. Processing of the received data stream includes calculating scores and goals while playing the PGH game.

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

[0371] Media server 728 is further configured and enabled to process, publish, and store "gameplay" to create a PGH game. Processing includes cutting relevant scenes and, if necessary, watermarking the file and converting it to different media formats.

[0372] The PGH player 729 can also be used to adjust the flow of a PGH game (e.g., single-player or multi-player). Specifically, the PGH player 729 receives the PGH game 738 created from the PGH manager 731. During operation, when a player requests to play PGH, the PGH player 729 sends the PGH game 738 created to be played by the PGH controller 725 using the PGH front 726. Each of the PGH logic engines 714 controls the execution of the PGH game 738. The PGH logic engine 714 obtains the event 715 identified from the game client device 701 and uses the identified event 715 or constructs building blocks 716 from the identified event. Next, the PGH logic engine 714 calculates the score status 7120 based on the scoring parameters using either the identified event or the building blocks and sends it to the PGH rules 719 to calculate the target status 12260, the constraint status 12280, and the end PGH criterion status 12220 (and which of the criteria have been reached). The PGH status 777 includes the PGH score / score status 7120, the target status 12260, the constraint status 12280, the end PGH criterion status 12220, and the end condition status 12240. The logic engine sends both the building blocks 716 and / or the identified event and the PGH status 777 to the management module 778.

[0373] The data & media bus 7300 is a technical component that enables real-time sharing of data and media among different components of the PGH server, e.g., real-time sharing of events (e.g., actions 724' and states 723') of the base game 705 and the captured video 717.

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

[0375] The PGH logic engine 714 is the heart and brain of the system 710. Specifically, the PGH logic engine 714 is configured to create and execute PGH games in real time based on defined PGH objective(s), and is an enabled rules engine. The generated PGH objective may be created, for example, while playing a base game according to an embodiment. The PGH logic engine 714 is further configured to verify whether one or more goals (e.g., objectives) created from PGH building blocks 716 have been achieved and to calculate a score for PGH game execution.

[0376] According to an embodiment, the PGH building blocks 716 are logical rules. The logical rules are created based on converting game events, such as state 723' and action 724' events in the base game 705, into logical sentences that can be understood by a PGH player or a PGH creator. For example, in a fighting computer game, a "mid-air kick" building block can consist of both a "jump" action followed by a "kick" action within a specific time frame (e.g., 0.2 seconds or less from the jump action) and the aforementioned building block that is considered valid only if the kick action occurs within the time frame in which the kick action is determined. The logical sentences can be, for example, Boolean logical sentences as shown in FIG. 9B.

[0377] According to an embodiment, the PGH app 704 is an application, such as a software application that enables the creation of PGH and manages the PGH platform using a system such as the system 700 or systems 720 and 730 or system 100, where PGH 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, a user can download the PGH app 704 onto their device, such as a mobile device, to create and manage PGH games.

[0378] In some cases, the PGH app 704 includes the following modules, namely, the PGH launcher 732, the PGH builder 734, the game logic configuration 7130, and the feed module 736.

[0379] The PGH launcher module 732 is a software application designed to facilitate user interaction with the PGH game and participation within or with the PGH game by providing functions for discovery and gameplay. The PGH launcher module 732 receives a user's request to launch a specific PGH game as input and transmits, as output, the data and commands necessary to initialize and start the PGH game.

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

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

[0382] The Feed Module 736 is a module within the PGH App 704. The Feed Module 736 receives data regarding PGH games available from the PGH Manager 731 and presents this data in a feed format viewable within the user interface (UI) of the app, along with links for playing PGH within the game client device 701. This data can include information such as titles, descriptions, thumbnail images, author names, creation dates, popularity metrics (e.g., play counts, likes, shares), and tags associated with each PGH game. In this way, players can view information and attributes regarding different PGH games that are available for play, perhaps from different base games (e.g., the feed can include PGHs created from two or more different base games). Additionally, the Feed Module 736 enables, for example using the PGH Manager 731, two or more users to search for PGH together and then provides links for them to play it together.

[0383] FIG. 7K shows a detailed block diagram of a system 720 configured and enabled to create PGH based on one or more scenarios of past game play in a multiplayer player configuration, according to an embodiment. FIG. 7K includes elements of the system 700 of FIG. 7A and additional elements for a multiplayer configuration system.

[0384] FIG. 7K may include additional or alternative elements not shown in other figures. The configuration shown in FIG. 7K is intended to be exemplary and not limiting, and should not be construed as excluding any potential elements or configurations within the scope of the present invention.

[0385] Specifically, according to an embodiment, the system 720 includes the following additional modules.

[0386] Game Server 765: In some computer games (usually multiplayer games), a game server such as game server 765 is implemented using, for example, the client-server approach. In this approach, most of the game events and game states are managed on the server side. According to some embodiments, game server 765 is responsible for hosting and managing the multiplayer sessions of base game 705. In the client-server model, game server 765 functions as a central authority for processing and verifying game states and player actions to ensure synchronization and fairness among all connected players. For example, in a multiplayer first-person shooter game, game server 765 tracks player positions, manages the game flow, and verifies hit detection to ensure that all players experience the same gameplay environment. Game server 765 also facilitates communication among players, such as relaying chat messages or coordinating matchmaking. By handling these important tasks, game server 765 enables the creation and play of PGH in multiplayer games.

[0387] According to an embodiment, game server 765 comprises the following modules, namely, base game server 766, PGH server SDK 767.

[0388] The base game server 766 is a game server that can be built by a game studio and is used to host and run the multiplayer version of the base game 705. The base game server 766 includes game-specific logic, rules, and mechanisms that define the multiplayer experience. The base game server 766 is responsible for managing game sessions, processing player inputs, and updating the game state in real time. For example, in a multiplayer racing game, the base game server 766 processes tasks such as track selection, player positioning, collision detection, and race event triggers. The base game server 766 ensures that all players connected to the same multiplayer session experience the game consistently and simultaneously. The base game server 766 operates in cooperation with other components of the PGH server SDK 767, such as the action streamer 768 and the state streamer 769, to enable the creation and play of PGH within the multiplayer environment of the base game 705.

[0389] The PGH server SDK 767 is used to integrate PGH functionality into the game server 765 of a multiplayer game and may include the following modules, namely the action streamer 768, the state streamer 769, and the PGH controller 770.

[0390] Action streamer 768: This module is responsible for extracting and streaming player actions from the base game 705 to the PGH server 703. This module functions similarly to the action streamer 722 of the PGH client SDK 798.

[0391] State streamer 769: This module is responsible for extracting and streaming game state information from the base game 705 to the PGH server 703. This module functions similarly to the state streamer module 723 of the PGH client SDK 798.

[0392] PGH Controller 770: This module receives input actions from the PGH Player Module 729 and controls the basic game actions while playing PGH. This module functions in the same way as the PGH Controller 725 of the PGH Client SDK 798. To facilitate the multiplayer environment, the PGH Manager 731 communicates with the PGH Controller 770 and the opponent 762.

[0393] These modules cooperate to enable the creation and playback of PGH in a multiplayer game by facilitating communication between the game server 765 and the PGH server 703.

[0394] The Opponent 762 module is responsible for managing the behavior, interactions, and decision-making processes of the computer-controlled opponent within the multiplayer environment. This module ensures that the opponent provides a challenging and engaging experience for the player while maintaining a 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 processes the opponent's rendering, input, and local game logic, enabling the opponent to perceive and react to the game state in real time. By integrating the game client 701 within the Opponent 762 module, the system ensures that the actions and behavior of the opponent are smoothly integrated into the overall multiplayer experience.

[0395] To facilitate efficient communication and coordination, the opponent 762 module communicates directly with the PGH manager 731. The PGH manager 731 sends inputs to the opponent 762 module and provides the opponent 762 module with the information and parameters necessary to control the opponent's behavior and decision-making process. This input may include data such as player position, updates to the game state, and specific instructions for the opponent's actions. In return, the opponent 762 module sends outputs back to the PGH manager 731, notifying the PGH manager 731 about the opponent's current status, actions taken, and any relevant updates. This two-way communication channel enables seamless integration of the opponent's behavior throughout the game flow and enables the creation of engaging and challenging PGHs in a multiplayer scenario.

[0396] In some embodiments, the opponent 762 module is located outside the game server 765.

[0397] According to an embodiment, the system 720 further includes non-player character (NPC) control 772. In this scenario, for example, the NPC can replace a real user's opponent in a multiplayer game. The NPC control 772 includes an NPC controller module 774 and an NPC configuration module 776.

[0398] According to an embodiment, the NPC controller module 774 is configured and enabled to interact with the PGH player in real time while playing the PGH game and control the actions of the opponent replaced by the NPC.

[0399] The NPC composition 776 is used, according to an embodiment, to configure the logic and behavior of NPCs in a specific game (e.g., the base game 705). For example, the logic and behavior can consist of rules regarding when and where an NPC appears in its scene and under which scenario, and attributes that the NPC has, such as aiming accuracy, orientation ability, stealth ability, scripts, etc. The data & media bus 7300 sends information regarding the structure of the game, such as event types and maps, so that the NPC behavior of each game is preprocessed according to the received data.

[0400] According to an embodiment, the system 720 further includes a PGH client 7800 that is used for possible streaming of some of the games or game objects / files from the PGH server 703.

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

[0402] The asset renderer 781 is configured and enabled to render the next frame on the GPU of the player's own computer using the game engine 718.

[0403] The asset cache 783 is configured to obtain graphic elements / assets within the game from an asset distributor 7860 and cache them on the PGH client 7800.

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

[0405] The game engine 718 is a software framework designed for game creation and development, and as shown with reference to FIG. 8D, is further configured to render the following frames and display them to the player.

[0406] FIG. 7L shows a subset block diagram 730 of the system 720 of FIG. 7K configured and enabled to publish and distribute one or more assets of the base game and PGH based on one or more scenarios of past game play in a single player / multiplayer configuration, according to an embodiment.

[0407] FIG. 7M shows a flowchart of a method 780 for asset extraction and decomposition, according to an embodiment.

[0408] In 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 graphic elements. This step also includes extracting all assets using the uploaded source code and files. This extraction process includes collecting all relevant graphic elements and storing them in a structured format. Specific graphic elements are specified above.

[0409] In step 784, some or all of the graphic elements are evaluated to determine whether they can be broken down into smaller pieces. This includes the following two important checks.

[0410] In step 786, after decomposition, it is assessed whether the graphic elements can be restored such that their reassembled state is the same as the original state before decomposition or approximates it (within defined criteria of match).

[0411] In operation 788, the graphic elements are measured by comparing the graphic elements to specific rules and thresholds to determine if the graphic elements are large enough for decomposition.

[0412] Finally, in operation 790, the graphic elements are stored in a data repository configured for efficient retrieval and transmission.

[0413] Another flow example of method 780 is shown in FIG. 8C which is a flowchart of a method 820 for extraction and decomposition of assets in a base game and / or PGH according to an embodiment.

[0414] Refer now to FIG. 8A which shows a flowchart 800 of a method for creating a PGH based on one or more scenarios of past gameplay in a multiplayer or single player configuration according to an embodiment. System 700 or system 710 or system 720 may be used to implement method 800. However, method 800 may also be implemented by a system or processor having other configurations. Some operations of FIG. 8A have been previously presented and described in detail in accordance with embodiments in previous figures and related detailed descriptions.

[0415] Operation “a. Start game” includes starting the PGH game creation process by sending a “launch command” from creator 799 to launcher module 702.

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

[0417] Operation “c. Init” includes initializing and controlling the launch operation by creating a handshake between PGH client SDK 798 and PGH server 703 on top of which the user is authenticated and the session is initialized.

[0418] Step "d. Session" involves operating an authorized handshake between the game module 707 and the PGH server 703 to enable the exchange of information (such as unique identifiers of the client and the server, request and response messages, and unique and random values for ensuring message freshness and integrity) between the game 707 and the PGH server 703.

[0419] Step "e. Play Game" involves starting the play of the actual game (e.g., the base game 705), where the rendered frames of the game are continuously displayed to the creator 799 on, for example, the creator's device (e.g., a mobile device or a personal computer). An example of this step is shown in FIG. 10A, where an example of the game start load can be seen.

[0420] Step "f. Game State" involves streaming / sending one or more characteristic state events of the game entities during the game to the PGH server. Examples of such characteristic states include the positions, health states, etc. of all entities within the game.

[0421] Step "g. Game Action" involves streaming / sending one or more actions (e.g., actions) performed by the game player character during the game (e.g., the base game) to the PGH server 703. Examples of such actions include jumps, shootings, etc. of entities within the game.

[0422] The process "h. Capture Highlights" includes operating the highlight action by, for example, selecting and capturing "highlight" or "highlights" in the game during gameplay. Specifically, the highlight action includes selecting a scene or frame segment or interval in the game, such as 1, 2, 3, 4, 5, 10, 20 seconds or more from the game. In some cases, the highlight action is operated by the creator 799 pressing a specific combination of preset keys or key + mouse click or any other selected combination of keys to capture the highlight on the game (for example, the combination of keys may be pressing the ALT keyboard key simultaneously with the S keyboard key, whereby the combination of keys becomes the ALT+S key combination). An example of a combination of preset keys that can be displayed to the player is shown in FIG. 10A.

[0423] The process "i. Mark Highlights" includes sending the properties of the captured highlights, including characteristics such as the timestamp of the created highlights, along with the related events of the highlights, from the game 707 to the PGH server 703. An example of this process is shown in FIG. 10B, which shows a specific frame of the highlights in the saved game.

[0424] The process "j. Media" includes recording frames, videos, and audios of the game 707 (for example, of the base game 705), and sending the game to the PGH server.

[0425] The process "k. Highlight Data" includes sending highlight data from the PGH server 703 to the PGH app 704. The highlight data includes the properties of the captured highlights (for example, the state and actions of the player and the game), along with the recorded frames, videos, and audios of the game at a predetermined time interval before the selected timestamp of the highlights, and sends it to the PGH app 744.

[0426] Step "l. Screen" involves displaying highlight data along with a list of possible objectives, constraints, end PGH criteria, end conditions, and score parameters on the user interface based on the identified events and / or building blocks. Optionally, the highlight data may be sent to the PGH app along with the list of possible objectives and score parameters and displayed on the user's screen. Examples of this step are shown in FIGS. 10C and 10D.

[0427] Step "m. Configuration" involves a selection by the creator 799 of the PGH attributes of the PGH game. Creation of this PGH game involves processing by combining received data including a start point and an end point, selected properties of the PGH (e.g., objectives, constraints, end PGH criteria, end conditions, and score parameters) to generate PGH attributes within the PGH server 703.

[0428] Step "n. PGH" involves 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". An example of the end of this step is shown in FIG. 10E.

[0429] FIG. 8B shows a time flow chart of a method 810 for playing a PGH such as the created PGH shown in FIG. 8A or the previous figure, created based on one or more scenarios of past gameplay in a multiplayer or single-player configuration according to an embodiment. Optionally, the method 810 may be activated according to the activation method 800. To implement the method 810, the systems 700, 710, 720 or one or more processors may be used. However, the method 810 may also be implemented by a system or processor having other configurations.

[0430] Step "o. Discovery" involves exposing a user (e.g., player 801) to one or more PGHs such as the PGH created in step.m of FIG. 8A. Optionally, the PGH may be displayed in the PGH app 704.

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

[0432] Step "q.Start PGH" includes sending a command from the player 801 to the launcher 702 to start playing PGH, and thus in step "r.Launch", PGH is launched, for example, in the game module 707. An example of this step is shown in FIG. 10F.

[0433] Step "s.State + Action" includes identifying events such as the state of entities or the game and actions in PGH according to the embodiment. For example, the events (as described with reference to the previous figures) may be or include the characteristics of entities within and during the PGH game, along with a set of actions performed during the PGH game by other game entities such as the player or an NPC or environmental elements. Actions include the behaviors or activities performed by the player, NPC, or environmental elements during gameplay, and the state can include, for example, other attributes of the entity in a shooting game, and can consist of a health status, a weapon status, clothing, etc. The identified events are streamed, for example, in real time, from the game module 707 to the PGH server 703.

[0434] Engineering "t. Score" involves computing / calculating and / or processing, e.g., in real time, PGH scoring parameters based on one or more scoring formulas, such as a predetermined scoring formula according to an embodiment of the present invention, to yield a score status 7120 (e.g., PGH score). For example, the scoring formula can have a scoring parameter of "number of kills", and the formula can simply be the actual number of kills (e.g., 10 kills results in a score of 10), or each kill can obtain its score, such as 100 points per kill. The calculated PGH score is transmitted, e.g., in real time, from a PGH server 703 to a PGH game 707, and is accordingly updated in each calculation loop (e.g., each frame of the base game or every 20 milliseconds) such that each score contributes to the final cumulative score. An example of this process is shown in FIG. 10G, where the current cumulative score (e.g., score status / PGH score 7120) is 4000. For example, each kill can add 5000 points to the cumulative score, and each shot can subtract 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 3000 points and 5 shots each subtract 200 points).

[0435] Engineering "u. Play the results" involves sending, e.g., in real time, the PGH results calculated at the end of each score calculation loop. An example of this process is shown in FIG. 11.

[0436] FIG. 8C shows a flowchart of a method 820 for extracting and disassembling assets in a base game such as the created PGH shown in FIG. 8A and / or in the PGH according to an embodiment. In some cases, method 820 may be activated after and / or simultaneously while executing method 800 and / or method 810. To implement method 820, system 700, system 710, system 720 or system 730, or one or more processors may be used. However, method 820 may also be implemented by a system or processor having other configurations.

[0437] Step "a. Upload" involves the game developer importing the executable file of the game developer's game (e.g., base game 705) and / or the source code of the game, along with all the files that make up the game, into the game library 789. The game library 789 can be located on the PGH server 703 or elsewhere.

[0438] Step "b. Extract and disassemble assets" involves using, for example, the source code, files, and file structures of the game to obtain game assets and then break them into smaller parts for efficient data transmission. Disassembly is performed when the game assets can be reconfigured back to their original form or a form very close to it (up to a threshold) and when the assets are marked as suitable for disassembly. According to an embodiment, the assets are stored in the asset repository 7910 component.

[0439] According to an embodiment, the "Asset Publishing" process operates as follows.

[0440] When the server detects the player's intention to start PGH, either by an explicit start or using a prediction model, it sends the necessary graphic elements to the client and renders the start area of PGH. These elements include decomposed graphic elements and are adjusted to a level of detail (LOD) based on various factors such as the type of element, its role in the game, the distance from the player, network capacity and performance, the player's preferences, and other predetermined settings. This approach controls the level of detail of the game when it is rendered.

[0441] Before sending these elements, the server checks whether the client has cached them locally to avoid redundant transfers. The client then fetches the missing elements required for rendering and subsequently renders the next frame for display to the player. In a continuous loop, the client sends back its current position, viewpoint, state, and any player input to the server. The server processes this information and determines the next set of graphic elements to send, which can be dispatched using either a single-threaded or multi-threaded priority queue.

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

[0443] FIG. 8D shows a flowchart of a method 830 for publishing an asset in a base game and / or PGH according to an embodiment. The method 830 includes publishing an extracted asset, such as the asset shown in FIG. 8C, according to an embodiment. In some cases, the method 830 may be activated after and / or simultaneously while executing the method 820 and / or the method 810. To implement the method 830, the system 700, the system 710, the system 720, or the system 730, or one or more processors may be used. However, the method 830 may also be implemented by a system or a processor having other configurations.

[0444] Step "c. Start the game" includes, according to an embodiment, starting the base game 705 by a player for the purpose of participating in gameplay.

[0445] Step "d. Prepare the game" includes, according to an embodiment, requesting from the PGH server 703 to set up an instance of the game to play the game. Specifically, setting up an instance of the game to play generally refers to preparing and configuring the game environment or session before actually starting to play. This process includes various tasks depending on the type and platform of the game and may include, for example, the following steps.

[0446] Game settings: Adjust in-game settings such as graphics quality, sound preferences, and control configurations to suit an individual's preferences.

[0447] Game mode or difficulty: Select the desired game mode or difficulty level if applicable. Some games offer different modes such as story mode, multiplayer, or a specific challenge mode.

[0448] Character or avatar selection: If the game involves playing as a specific character or creating an avatar, select or customize the character before entering the game world.

[0449] Level or Map Selection: Select the specific level, map, or scenario in which the game will be played. This is common in games that have different stages or locations.

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

[0451] Step "e. Load Game" includes, according to an embodiment, starting the PGH server 703 that hosts an instance of the game for a specific player.

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

[0453] Step "g. Assets to Publish" includes, according to an embodiment, sending the graphic elements used to render the first frame at the start of the game, which together create the game's environment and experience, including, for example, graphics, sound, music, characters, textures, and code.

[0454] Step "h. Assets" includes, according to an embodiment, using various elements to render the first frame of the game, which together create the game's environment and experience, including graphics, sound, music, characters, meshes, textures, and code.

[0455] Step "i. Render Screen" includes, according to an embodiment, sending commands to the GPU of the PGH client 7800 to render the next frame according to the player's position and frustum, and the assets available in the PGH client.

[0456] According to an embodiment, step "j. frame loop" includes repeatedly updating and displaying the next image on the screen in a continuous cycle.

[0457] According to an embodiment, step "k. (optionally existing) user action" includes sending the input of player 801 when there is any input within the time period of the frame loop.

[0458] According to an embodiment, step "l. (optionally existing) user action" includes sending the input of player 801 when there is any input within the time period of the frame loop.

[0459] Step "m. assets to publish" includes sending game elements from game 707 to PGH server 703. These game elements are used, according to an embodiment, to render the next frame of the game, including graphics, sound, music, characters, meshes, textures, and code that together create the game's environment and experience.

[0460] According to an embodiment, step "n. assets" includes using various elements to render the next frame, including graphics, sound, music, characters, textures, and code that together create the game's environment and experience.

[0461] According to an embodiment, step "o. render the screen" includes sending commands to the GPU of PGH client 7800 to render the next frame according to the player's position and frustum, and the assets available in the PGH client.

[0462] According to an embodiment, step "p. next frame" includes returning to the frame loop (j.).

[0463] Refer to FIG. 12, which shows an exemplary data structure of the PGH data object 1200 according to some embodiments. The PGH data object includes one or more of metadata 1202, PGH rules 719, scoring parameters 1220, status 723', and action 724'. The PGH rules 719 include, hereinafter, i.e., one or more of objectives, constraints, end PGH criteria 1222, and end PGH conditions.

[0464] The PGH rules 719 are used, which are based on objectives and / or constraints and / or end PGH criteria 1222 and / or end conditions. In some embodiments, the PGH rules 719 are evaluated per frame or per a predetermined time interval (e.g., every 20 msec). The PGH rules consist of an expression that checks whether the PGH has ended. If the PGH has ended, it results in whether the PGH ended in victory, the player lost, or ended in another status, and further calculates the status of the objectives and / or constraints and / or end PGH criteria 1222 and / or end conditions (1224). For example, the expression may check whether one of the objectives has been achieved. If the objective has been reached, the PGH rules output that the PGH ends in the player's victory. If the constraint has been reached, the PGH rules output that the PGH ends in the player's defeat, etc.

[0465] The objectives 1226 are one or more goals that the PGH player needs to achieve in the PGH game to ensure victory in the PGH. An example of a possible objective is shown in FIG. 9B, presenting a screenshot including an objective list 920 that includes a goal name 922 and an expression 924 that needs to be achieved to achieve the objective. Specifically, the first-listed goal name 922 is "kill", and the related expression is "when the PGH player's kill is equal to the creator's kill in the highlight", which means that the player's goal must be to make the same number of kills as the creator. The objectives may be related to goals not included in and / or different from the base game's goals.

[0466] Constraint 1228 is one or more conditions under which the player loses to PGH when the conditions are met. An example of a possible constraint is shown in FIG. 9C, presenting a screenshot including a constraint list 930 that includes a constraint name 932 and an expression 934 that needs to be achieved to lose the game. Specifically, the first-listed constraint name 932 is "Receive no damage", and the related expression is "When the damage received by the PGH player is greater than the damage received by the creator", which means that when the player's damage level is greater than the creator's damage level, the constraint is met and the player loses the PGH game. Other constraints may be related to constraints not included in and / or different from the base game constraints.

[0467] The end PGH condition 1224 includes one or more conditions under which, when the conditions are met, the player either secures a victory in the PGH game, the player loses to PGH, or in some cases the PGH game ends without a predetermined win or loss for PGH. An example of a possible end condition 1224 is shown in FIG. 9E, showing an example of an end condition list 990.

[0468] The end PGH criterion 1222 includes one or more conditions under which, when the conditions are met, the player either secures a victory in the PGH game, the player loses to PGH, or in some cases PGH ends without a predetermined win or loss. Examples of possible end PGH criteria 1222 are a time limit (e.g., the player has 30 seconds to reach one of the goals), the number of turns (e.g., in a turn-based game such as chess, the user has 20 turns to reach one of the goals), a mix of the number of turns and time limit (e.g., in a chess game, there are 5 turns and a maximum of 120 seconds to reach one or more of the goals).

[0469] The scoring parameter 1220 refers to a set of predetermined conditions or rules that determine how a player's score is calculated and updated during the PGH game. These conditions function as triggers, and when a specific condition is met or reached, the player's score either increases (positive score) or decreases (negative score). The score can be cumulative, meaning that each time a new condition is met, the corresponding score value is added to or subtracted from the player's current accumulated score.

[0470] Put more simply, the score parameters are a list of rules that define how points are awarded or deducted based on specific events or actions that occur during gameplay. These rules may be predetermined, for example, and the player's score is continuously updated by adding or subtracting points when different conditions are met.

[0471] The score can be positive or negative, enabling both reward scenarios and penalty scenarios. For example, a positive score can be awarded for completing a level, achieving a specific goal, reaching a specific state, or performing a specific action, while a negative score can be deducted, for example, for reaching a specific state, performing a specific action, reaching a constraint, or for each passing turn or time period.

[0472] The specific score parameters and their associated point values can vary depending on the game. FIG. 9D shows an example of a score parameter list 940, which may enumerate various scenario or event score names 942, descriptions 944, along with the corresponding positive or negative scores 946 that are applied when these conditions are met. For example, the score name could be "Ability Use", the description could be "Lose points each time a special ability is used", and this scoring is defined as negative. For example, as shown in FIG. 10D under the score parameter, using an ability could result in a deduction of 100 points each time the ability is used (in the illustrated example, this is marked as -100 points).

[0473] It is emphasized that often, the PGH rules 719 and the scoring parameters are not included in the base game and / or are different from the scoring or rules that were included in the base game.

[0474] Metadata refers to elements related to the UI and user experience, for example, while scrolling through the PGH feed 736 using the PGH app 704. Typically, the metadata is not directly related to the action of playing, the PGH rules, or the gameplay.

[0475] The metadata 1202 includes one or more of the following details: a name such as the name of the PGH, a description - for example, adding a text description when an element within the PGH is shown, such as the text "castle" when a photo of a castle is shown, the creator, a video - enabling the addition of a webcam so that the creator can add comments in real - time, tags - for example, adding text for a "shooting" action, an audio - enabling the creator to add, for example, a voice - over during the PGH game, or a thumbnail.

[0476] State 723’ and action 724’ are used to create, restore, and play the PGH738 as described above. State 723’ includes a “game state” regarding game data details such as game mapping and the starting point of the game, and a “player state” regarding player data such as the player's position, ammunition, and clothing in the game. The game state may include game information not particularly related to the actions of the players in the base game, such as “bombs” that fall into the scenario of the base game. “Game action” may be related to the scenario of the base game, such as when the “bridge” in the game is detonated when the player crosses the bridge, and thus this scenario can be memorized and used to create the PGH.

[0477] The data is related to both the player and the caged and uncaged NPC players. For example, state 723’ may include data information related to the state of the caged NPC player related to the state of the player in the base game. Thus, action 724’ includes game actions and player actions. For example, if the base game includes movement actions of the player and / or NPC players, these movements are restored and included in the PGH.

[0478] FIG. 13 shows a flowchart of a method 1300 for loading and executing a PGH computer game such as the PGH738 created in FIGS. 7A, 7B, and 7C according to an embodiment. System 700, or system 710, or system 720 or system 730, or system 785 may be used to implement method 7500. However, method 1300 may also be implemented by a system or processor having other configurations according to an embodiment.

[0479] In operation 1310, events from the base game are restored and loaded. The restoration process includes, according to an embodiment, one or more of the operations shown with respect to FIG. 7F. In operation 1320, the system starts play of the PGH by initializing the game engine and loading the necessary resources. In operation 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 way includes 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 the identified events and / or building blocks. This video analysis approach enables the system to gain insights into the game play elements, player actions, and game state of the PGH without relying solely on the internal data of the game.

[0480] Another way to obtain input from the PGH is, according to an embodiment, via analysis of brain signals by using techniques such as, for example, neural networks. By monitoring and interpreting these physiological signals, the system can infer the player's intent, emotions, and reactions during game play, and further infer game play elements, player actions, and game state. This information can be used to extract the identified events and / or building blocks, and can be combined with video analysis or used alone.

[0481] In operation 1340, the captured video or other signals are transmitted (e.g., streamed) to a server such as the PGH server. This transmission enables centralized processing and analysis of the captured data.

[0482] In Project 1350, videos are processed using a video analysis processor and, alternatively or additionally, signals are processed using a signal analysis processor. These processors are designed to process specific data types and perform the necessary analysis. The video analysis processor applies other relevant methods, including computer vision techniques, machine learning algorithms, and neural network methods, to understand video content and context and extract events and / or building blocks. Similarly, the signal analysis processor uses machine learning methods, including signal processing techniques, pattern recognition, and neural networks, to interpret brain signals and extract identified events and / or building blocks.

[0483] In Project 1360, based on the analyzed video or analyzed signal, it is determined whether PGH attribute parameters (e.g., objectives and / or constraints and / or end PGH criteria and / or end conditions) are obtained based on PGH rules, and scoring parameters are calculated as described hereinabove with respect to FIGS. 7E and 7F. In Project 1370, a PGH status 777 (e.g., a scoring parameter status, an objective and / or constraint status) is generated as described with reference to the previous figures. In Project 1380, the PGH status is sent to a management module, and a server event is provided based on that PGH status and / or the identified event as described with reference to the previous figures. In Project 1390, the server event is sent from the PGH server to the game client module. In Project 1395, a PGH result is calculated based on the identified event, and that PGH result is sent, for example, to a PGH application.

[0484] The method according to an embodiment can be executed by a client device, such as a game client device 701, that executes a game based on the methods and data described hereinabove.

[0485] According to some embodiments, when executed by a computing system, a non-transitory computer-readable storage medium storing instructions for causing the computing system to execute a method for creating or executing one or more playable game play highlights (PGHs) computer games from a computer-based game is provided.

[0486] In this patent application, it is essential to clarify that the various embodiments and elements described in the drawings are related to or equivalent to each other, and the nomenclature may potentially be different. Further, some elements present in one embodiment may not be present in another embodiment, merely for purposes of clarity and simplification. It should be understood that such omissions do not invalidate the scope or essence of the present invention. For example, PDS server 195 may be equivalent to PGH server 703, and processing circuits 110A and 110B may be equivalent to game client device 701 and / or launcher module 702 and PGH app 704.

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

[0488] 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. 14 shows a computer system 1401 suitable for incorporation with methods, systems, and devices according to some embodiments of the present disclosure. The computer system 1401 can process various aspects of the information of the present disclosure, such as, for example, questions and answers, responses, statistical analysis, etc. The computer system 1401 can be a user's electronic device or a computer system located remotely from the electronic device. The electronic device can be a mobile electronic device.

[0489] The computer system 1401 includes a central processing unit (CPU, herein referred to as "processor" and "computer processor") 1405, which can be a single-core or multi-core processor, or multiple processors 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., hard disk), a communication interface 1420 (e.g., network adapter) for communicating with one or more other systems, and peripheral devices 1425 such as a cache, other memory, data storage, and / or an electronic display adapter. The memory 1410, storage unit 1415, interface 1420, and peripheral devices 1425 communicate with the CPU 1405 via a communication bus (solid line), such as a motherboard. The storage unit 1415 can be a data storage unit (or data repository) for storing data. The computer system 1401 can be operably coupled to a computer network ("network") 1430 with the aid of the communication interface 1420. The network 1430 can be the Internet, the Internet and / or an extranet, or an intranet and / or an extranet communicating with the Internet. The network 1430 can be, in some cases, a telecommunications and / or data network. The network 1430 can include one or more computer servers that can enable distributed computing, such as cloud computing. The network 1430 can, in some cases, implement a peer-to-peer network that can enable devices coupled to the computer system 1401 to operate as clients or servers with the aid of the computer system 1401.

[0490] CPU 1405 can execute a series of machine-readable instructions that can be embodied in a program or software. The instructions can be stored at a memory location such as memory 1410. The instructions can be targeted at CPU 1405, and these instructions can then program or otherwise configure CPU 1405 to implement the method of the present disclosure. Examples of operations performed by CPU 1405 can include fetch, decode, execute, and write-back.

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

[0492] 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. The computer system 1401 can include one or more additional data storage units external to the computer system 1401, such as being located on a remote server that communicates with the computer system 1401 via an intranet or the Internet in some cases.

[0493] The computer system 1401 can communicate with one or more remote computer systems via the network 1430. For example, the 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), slate or tablet PCs (e.g., Apple® iPad®, Samsung® Galaxy Tab), telephones, smartphones (e.g., Apple® iPhone®, Android®-compatible devices, Blackberry®), personal digital assistants, wearable medical devices (e.g., Fitbits), or medical device monitors (e.g., seizure monitors). A user can access the computer system 1401 using the network 1430.

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

[0495] The code can be pre-compiled and configured for use on a machine, can have a processor adapted to execute the code, or can be compiled during runtime. The code can be supplied in a programming language selected to enable the code to be executed in a pre-compiled or as-compiled manner.

[0496] Aspects of the systems and methods provided herein, such as the game client device 701, can be embodied in programming. Various aspects of the technology can typically be considered a "product" or "manufacture" in the form of machine (or processor) executable code and / or associated data carried on or embodied in some type of machine-readable medium. The machine executable code can be stored in an electronic memory unit such as a memory (e.g., read-only memory, random access memory, flash memory) or a hard disk. A "memory" type of medium can include any or all of tangible memories such as computers, processors, or associated modules such as various semiconductor memories, tape drives, disk drives, etc., which can provide non-transitory storage at any time for software programming. All or part of the software may sometimes be communicated via the Internet or various other telecommunications networks. Such communication can, for example, enable the loading of software from one computer or processor to another, such as from an administrative server or host computer to an application server computer platform. Thus, another type of medium that can carry software elements includes light waves, radio waves, and electromagnetic waves such as those used over wired and optical terrestrial networks, as well as over various air links, across a physical interface between local devices. 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, the term computer or machine "readable medium" refers to any medium involved in providing instructions to a processor for execution, unless limited to non-transitory and tangible "memory" media.

[0497] Thus, machine-readable media such as computer-executable code can take many forms including, but not limited to, tangible storage media, carrier wave media, or physical transmission media. Non-volatile storage media includes, for example, optical or magnetic disks, such as any of the storage devices of any computer, which can be used to implement, for example, a database shown in the drawings. Volatile storage media includes dynamic memory, such as the main memory of such a computer platform. Tangible transmission media includes copper wire and optical fiber, including coaxial cable, wire with a bus within a computer system. Carrier wave transmission media can 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, floppy (registered trademark) disk, flexible disk, hard disk, magnetic tape, any other magnetic media, CD-ROM, DVD or DVD-ROM, any other optical media, punch card paper tape, any other physical storage media with patterns of holes, RAM, ROM, PROM and EPROM, FLASH-EPROM, any other memory chip or cartridge, carrier wave that carries data or instructions, cable or link that carries such carrier wave, or any other media from which a computer can read programming code and / or data. Many of these forms of computer-readable media can be involved in carrying one or more sequences of one or more instructions to a processor for execution.

[0498] Computer system 1401 can include, or be communicable with, for example, an electronic display 1435 having a user interface (UI) 1440 for providing questions and answers, analysis results, recommendations. Examples of UIs include, but are not limited to, graphical user interfaces (GUIs) and web-based user interfaces.

[0499] The methods and systems of the present disclosure can be implemented by one or more algorithms and by instructions provided using one or more processors as disclosed herein. The algorithms can be implemented by software when executed by a central processing unit 1405. The algorithms can be, for example, random forest, graphical model, support vector machine or others.

[0500] The above steps illustrate a method of a system by way of example, and those skilled in the art will recognize many variations based on the teachings described herein. These steps may be completed in a different order. Steps may be added or deleted. Some of the steps may include sub-steps. Many of the steps may be repeated frequently as if beneficial to the platform.

[0501] Each of the examples described herein can be combined with one or more other examples. Further, one or more components of one or more examples can be combined with other examples.

[0502] The detailed description includes many details, but these should not be construed as limiting the scope of the present disclosure, but rather should be construed as merely exemplifying 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 will be apparent to those skilled in the art in the arrangement, operation and details of the methods and apparatuses of the present disclosure provided herein without departing from the spirit and scope of the invention described herein.

[0503] Preferred embodiments of the present disclosure have been shown and described herein, but it will be apparent to those skilled in the art that such embodiments are provided by way of example only. Without departing from the scope of the present disclosure, numerous variations, modifications, and substitutions will be apparent to those skilled in the art. It should be understood that various alternative forms to the embodiments of the present disclosure described herein may be employed without departing from the scope of the invention. Accordingly, the scope of the present invention is to be defined only by the scope of the appended claims and their equivalents.

[0504] It is understood that while certain elements are shown in one or more of the figures, not all elements may be included in each figure. The figures are intended to be illustrative and not limiting, and elements from one figure may or may not be present in other figures. However, it should be understood that the present invention is not limited to the specific elements or configurations shown in the figures, and additional or alternative elements and configurations may be included within the scope of the present invention.

[0505] It should be understood that the present invention is not limited in its application to the details described in the present specification or shown in the drawings. The present invention is capable of other embodiments and of being practiced and carried out in various ways. Accordingly, it should be understood that the expressions and terms used herein are for the purpose of description and should not be regarded as limiting. Thus, those skilled in the art will understand that the underlying concepts of the present disclosure can be readily utilized as a basis for designing other structures, methods, and systems for carrying out some of the objectives of the subject matter of the present disclosure.

[0506] 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. Similarly, the present invention contemplates a computer program readable by a computer for executing the method of the present invention. The present invention further contemplates a non-transitory computer-readable memory tangibly embodying a program of instructions executable by a computer for executing the method of the present invention.

[0507] Unless otherwise specified, as will be apparent from the following description, throughout this specification, descriptions using terms such as "processing", "computing", "comparing", "determining", "calculating", "receiving", "providing", "acquiring", "detecting", etc. refer to actions and / or processes of a computer that manipulate data and / or transform it into other data, where the data is represented as a physical quantity such as electricity and / or the data represents a physical object. The term "computer" should be broadly construed to encompass, by way of non-limiting example, any type of hardware-based electronic device having data processing capabilities, including the processors, reduction units, and inspection units disclosed in this application.

[0508] Although various features of the present invention have been described in specific embodiments, those skilled in the art may contemplate mixing and adapting the features in other embodiments not shown in the figures.

[0509] It should be understood that the expressions or terms used in this specification are for illustrative purposes and not restrictive. Means, materials, and steps for performing the various disclosed functions can take various alternative forms without departing from the present invention.

[0510] Those skilled in the art will readily understand that various modifications and changes can be applied to the above-described embodiments of the present invention without departing from the scope of the present invention as defined in the appended claims and by the appended claims.

[0511] Cross-reference This application claims priority to U.S. Patent Application Publication No. 18 / 660,841, filed May 10, 2024, entitled "USER-GENERATED REPLAYABLE GAMING CONTENT UTILIZING REGAMIFICATION DATA", which claims priority to U.S. Provisional Patent Application No. 63 / 598,654, filed Nov. 14, 2023, entitled "USER-GENERATED REPLAYABLE GAMING CONTENT UTILIZING REGAMIFICATION DATA", each of which is incorporated herein by reference in its entirety.

[0512] Incorporation by reference All publications, patents, and patent applications mentioned in this specification are incorporated herein 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.

Claims

1. 1. A computer-implemented method for creating one or more playable gameplay highlight (PGH) computer games from a computer-based game, comprising: receiving data related to the computer based game using a logic engine, the data including one or more of events, text, audio, images, video recordings of the computer based game, and other videos describing the computer based game, the logic engine being included in a processor located on a server; processing the data to result in the events, processing the events by the logic engine to result in building blocks, or processing the events by the logic engine to result in building blocks; capturing one or more highlights in the computer-based game, each of the one or more highlights corresponding to a selected start point and an end point in the computer-based game; processing the building blocks by the logic engine to yield highlight attribute parameters, the highlight attribute parameters including one or more of possible objectives, possible constraints, possible PGH exit criteria, possible exit conditions, and possible scoring parameters respectively associated with each one of the one or more highlights; selecting a PGH highlight in each one of the one or more highlights, the PGH highlight corresponding to a selected start point and end point in the one or more highlights; processing, by the logic engine, the building blocks associated with the selected PGH highlight to generate PGH attributes, the PGH attributes including one or more of objectives, constraints, PGH exit criteria, exit conditions and scoring parameters, the selected start point and end point; creating the one or more PGH computer games based on the PGH attributes, each of the PGH computer games including PGH rules, the PGH rules relating to the PGH attributes and for configuring play of the one or more PGH computer games; 4. A computer-implemented method comprising:

2. loading and executing the one or more PGH computer games, said loading and executing comprising: Reconstructing the events associated with the computer-based game; and continually identifying said events in said one or more PGH computer games; continuously streaming the identified events from a game client device to the logic engine; continually processing the identified events using the logic engine to yield the building blocks; continuously processing the building blocks using the logic engine to determine whether PGH attribute parameters have been obtained based on the PGH rules; ending said playing of said one or more PGH computer games when said PGH attribute parameters have been obtained; The computer-implemented method of claim 1 , comprising:

3. generating a PGH status for each of the one or more PGH computer games, the PGH status comprising: Calculating one or more of a scoring parameter, a status of the objectives, a status of the constraints, a status of the PGH termination criteria; sending the PGH status to a management module included in the server; providing a server event based on one or more of the PGH status, the building blocks; Including, generating The computer-implemented method of claim 2 , comprising:

4. transmitting the server event from the server to the game client device; Displaying the server events on a display. The computer-implemented method of claim 3 , comprising:

5. calculating a PGH outcome for each of the one or more PGH computer games based on the events; Sending the PGH result to a PGH application (PGH app); displaying the server events on a display of the game client device; The computer-implemented method of claim 4 , comprising:

6. selecting said one or more highlights by clicking one or more keys during gameplay of said computer-based game; The computer-implemented method of claim 1 , comprising:

7. The processing comprises: Converting said one or more of text, audio, images, video recordings of said computer-based games, and other videos into said events. The computer-implemented method of claim 1 , comprising:

8. identifying the event in the computer-based game using an event module, the event module being included in a processor within a game client device; The computer-implemented method of claim 1 , comprising:

9. said selecting a PGH highlight; selecting a timestamp start point and selecting a timestamp end point in the computer-based game; The computer-implemented method of claim 1 , comprising:

10. transmitting video of the computer based game captured by a video module in a game client device to the server; transmitting the one or more highlights from the server to a PGH application (PGH app); editing the video based on selected PGH timestamps to generate a final PGH video; creating the one or more PGH computer games based on the PGH attributes and the final PGH video; The computer-implemented method of claim 1 , comprising:

11. Creating one or more additional PGH computer games from said one or more PGH computer games. The computer-implemented method of claim 2 , comprising:

12. creating two or more PGH computer games based on a single highlight of said one or more highlights; The computer-implemented method of claim 1 , comprising:

13. The computer-implemented method of claim 1 , wherein the events include actions or states of a character in the computer-based game.

14. The computer-implemented method of claim 1 , wherein each building block of the building blocks is formed by aggregating one or more events of the events.

15. The computer-implemented method of claim 14 , wherein the aggregation function combines two or more events of the same type or events of different types.

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

17. PGH attribute is The name of the PGH, a description, a thumbnail "preview" image of said PGH computer game, and tags The computer-implemented method of claim 1 , further comprising one or more of:

18. The computer-implemented method of claim 1 , wherein a character in the computer-based game is a player character (PC) or a non-player character (NPC).

19. 2. The computer-implemented method of claim 1, wherein the objectives or constraints or PGH exit criteria or exit conditions or scoring parameters are created using generative artificial intelligence (AI) algorithms and models.

20. The computer-implemented method of claim 1 , wherein a game client device is included in the server.

21. loading and executing the one or more PGH computer games, said loading and executing comprising: recovering the events from the computer-based game; capturing a video or other signal of said computer-based game; and transmitting the captured video or other signal to the server; and processing said video using a video analysis processor or processing said signal using a signal analysis processor; determining whether a PGH attribute parameter is obtained based on the PGH rule and the analyzed video or the analyzed signal; calculating said scoring parameters; The computer-implemented method of claim 1 , comprising:

22. 1. A computer-implemented method for creating one or more playable gameplay highlight (PGH) computer games from a computer-based game, comprising: receiving data related to the computer based game using a logic engine, the data including one or more of events, text, audio, images, video recordings of the computer based game, and other videos describing the computer based game, the logic engine being included in a processor located on a server; processing the data using the logic engine to result in the event; capturing one or more highlights in the computer-based game, each of the one or more highlights corresponding to a selected start point and an end point in the computer-based game; processing the event by the logic engine to yield highlight attribute parameters, the highlight attribute parameters including one or more of a possible objective, a possible constraint, a possible PGH exit criteria, a possible exit condition, and a possible scoring parameter respectively associated with each one of the one or more highlights; selecting a PGH highlight in each one of the one or more highlights, the PGH highlight corresponding to a selected start point and end point in the one or more highlights; processing, by the logic engine, the events associated with the selected PGH highlight to yield PGH attributes, the PGH attributes including one or more of objectives, constraints, PGH exit criteria, exit conditions, and scoring parameters; creating the one or more PGH computer games based on the PGH attributes, each of the PGH computer games including PGH rules, the PGH rules relating to the PGH attributes and for configuring play of the one or more PGH computer games; 4. A computer-implemented method comprising:

23. loading and executing the one or more PGH computer games, said loading and executing comprising: Reconstructing the events associated with the computer-based game; and continually identifying said events in said one or more PGH computer games; continuously streaming the identified events from a game client device to the logic engine; continually processing the identified events using the logic engine to yield building blocks; continuously processing the building blocks using the logic engine to determine whether PGH attribute parameters have been obtained based on the PGH rules; ending said playing of said one or more PGH computer games when said PGH attribute parameters have been obtained; 23. The computer-implemented method of claim 22, comprising:

24. generating a PGH status for each of the one or more PGH computer games, said generating a PGH status comprising: Calculating one or more of a scoring parameter, a status of the objectives, a status of the constraints, a status of the PGH termination criteria; sending the PGH status to a management module included in the server; providing a server event based on one or more of the PGH status, the building blocks; Including, generating 24. The computer-implemented method of claim 23, comprising:

25. transmitting said server event from the PGH server to the game client device; Displaying the server events on a display.

25. The computer-implemented method of claim 24, comprising:

26. calculating a PGH outcome for each of the one or more PGH computer games based on the identified events; Sending the PGH result to a PGH application (PGH app); displaying the server events on a display of the game client device; 25. The computer-implemented method of claim 24, comprising:

27. selecting said one or more highlights by clicking one or more keys during gameplay of said computer-based game; 23. The computer-implemented method of claim 22, comprising:

28. identifying an event in the computer-based game using an event module, the event module being included in a processor within a game client device; 23. The computer-implemented method of claim 22, comprising:

29. said selecting a PGH highlight; selecting a timestamp start point and selecting a timestamp end point in the computer-based game; 23. The computer-implemented method of claim 22, comprising:

30. transmitting video of the computer based game captured by a video module in a game client device to the server; transmitting the one or more highlights from the server to a PGH application (PGH app); editing the video based on selected PGH timestamps to generate a final PGH video; creating the one or more PGH computer games based on the PGH attributes and the final PGH video; 23. The computer-implemented method of claim 22, comprising:

31. Creating one or more additional PGH computer games from said one or more PGH computer games.

24. The computer-implemented method of claim 23, comprising:

32. creating two or more PGH computer games based on a single highlight of said one or more highlights; 25. The computer-implemented method of claim 24, comprising:

33. 23. The computer-implemented method of claim 22, wherein the identified events include actions or states of a character in the computer-based game.

34. 23. The computer-implemented method of claim 22, wherein each building block of the building blocks is formed by aggregating one or more events of the events.

35. 35. The computer-implemented method of claim 34, wherein an aggregation function combines the one or more events of the same type or different types.

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

37. PGH attribute is The name of the PGH, a description, a thumbnail "preview" image of said PGH computer game, and tags 23. The computer-implemented method of claim 22, further comprising one or more of:

38. 34. The computer-implemented method of claim 33, wherein the character is a player character (PC) or a non-player character (NPC).

39. 23. The computer-implemented method of claim 22, wherein the objectives or constraints or PGH exit criteria or exit conditions or scoring parameters are created using generative artificial intelligence (AI) algorithms and models.

40. 23. The computer-implemented method of claim 22, wherein a game client device is included in the server.

41. loading and executing the one or more PGH computer games, said loading and executing comprising: recovering events from said computer-based game; capturing a video or other signal of said computer-based game; and transmitting the captured video or other signal to the server; and processing said video using a video analysis processor or processing said signal using a signal analysis processor; determining whether a PGH attribute parameter is obtained based on the PGH rule and the analyzed video or the analyzed signal; calculating said scoring parameters; 23. The computer-implemented method of claim 22, comprising:

42. 1. A method performed by a game client device for loading and executing one or more playable gameplay highlight (PGH) computer games created based on a computer-based game, the method comprising: Reconstructing events associated with the computer-based game; and continually 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; continually processing the identified events using the logic engine to yield building blocks; continuously processing the building blocks using the logic engine to determine whether PGH attribute parameters have been obtained based on PGH rules; ending play of the one or more PGH computer games when the PGH attribute parameters are obtained; A method comprising:

43. generating a PGH status for each of the one or more PGH computer games, said generating a PGH status comprising: Calculating one or more of a scoring parameter, a status of an objective, a status of a constraint, a status of a PGH termination criteria; sending said PGH status to a management module included in a server; providing a server event based on one or more of the PGH status, the building blocks; Including, generating 43. The method of claim 42, comprising:

44. transmitting the server event from a PGH server to the game client device; Displaying the server events on a display.

44. The method of claim 43, comprising:

45. calculating a PGH outcome for each of the one or more PGH computer games based on the identified events; Sending the PGH result to a PGH application (PGH app); displaying the server events on a display of the game client device; 45. The method of claim 44, comprising:

46. identifying the event in the computer-based game using an event module, the event module being included in a processor within a game client device; 43. The method of claim 42, comprising:

47. Creating one or more additional PGH computer games from said one or more PGH computer games.

43. The method of claim 42, comprising:

48. 43. The method of claim 42, wherein the identified events include actions or states of a character in the computer-based game.

49. The method of claim 42 , wherein each building block of the building blocks is formed by aggregating one or more events of the events.

50. 50. The method of claim 49, wherein an aggregation function combines the one or more events of the same type or different types.

51. 43. The method of claim 42, wherein PGH attributes are selected by a creator of the PGH computer game or automatically by the logic engine.

52. PGH attribute is The name of the PGH, a description, a thumbnail "preview" image of said PGH computer game, and tags 52. The method of claim 51, further comprising one or more of:

53. 44. The method of claim 43, wherein the objectives or constraints or PGH exit criteria or exit conditions or scoring parameters are created using generative artificial intelligence (AI) algorithms and models.

54. 43. The method of claim 42, wherein the game client device is included in a server.

55. loading and executing the one or more PGH computer games, said loading and executing comprising: recovering the events from the computer-based game; capturing a video or other signal of said computer-based game; and transmitting the captured video or other signal to a server; and processing said video using a video analysis processor or processing said signal using a signal analysis processor; determining whether the PGH attribute parameters have been obtained based on the PGH rules and the analyzed video or the analyzed signal; Calculating the scoring parameters; 43. The method of claim 42, comprising:

56. 1. A system for creating one or more playable gameplay highlight (PGH) computer games from a computer-based game, comprising:

1. A game client device comprising a 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 said PGH computer game; and one or more server processors, said server processor comprising a video processor, a logic engine and a PGH publisher, said logic engine comprising: receiving data related to the computer based game, the data including one or more of events, text, audio, images, video recordings of the computer based game, and other videos describing the computer based game; processing the data to result in the event; and processing the events to result in building blocks or processing the data to result in building blocks; capturing one or more highlights in the computer-based game, each of the one or more captured highlights corresponding to a selected start point and an end point in the computer-based game; processing the building blocks by the logic engine to yield highlight attribute parameters, the highlight attribute parameters including one or more of possible objectives, possible constraints, possible PGH exit criteria, possible exit conditions, and possible scoring parameters respectively associated with each one of the one or more highlights; selecting a PGH highlight in each one of the one or more highlights, the PGH highlight corresponding to a selected start point and end point in the one or more highlights; processing, by the logic engine, the building blocks associated with the selected PGH highlight to generate PGH attributes, the PGH attributes including one or more of objectives, constraints, PGH exit criteria, exit conditions, and scoring parameters; creating the one or more PGH computer games based on the PGH attributes, each of the PGH computer games including PGH rules, the PGH rules relating to the PGH attributes and for configuring play of the one or more PGH computer games; A system comprising a game client device configured and enabled to:

57. the one or more processors: and further configured and enabled to load and execute said one or more PGH computer games, said loading and executing comprising: Reconstructing the events associated with the computer-based game; and continually identifying said events in said one or more PGH computer games; continuously streaming the identified events from a game client device to the logic engine; continually processing the identified events using the logic engine to yield the building blocks; continuously processing the building blocks using the logic engine to determine whether PGH attribute parameters have been obtained based on the PGH rules; ending said playing of said one or more PGH computer games when said PGH attribute parameters have been obtained; 57. The system of claim 56, comprising:

58. the one or more processors: and further configured and enabled to generate a PGH status for each of the one or more PGH computer games, wherein generating the PGH status comprises: Calculating one or more of a scoring parameter, a status of the objectives, a status of the constraints, a status of the PGH termination criteria; sending said PGH status to a management module included in a server; providing a server event based on one or more of the PGH status, the building blocks; 57. The system of claim 56, comprising:

59. the one or more processors: recovering the events from the computer-based game; capturing a video or other signal of said computer-based game; and transmitting the captured video or other signal to a server; and processing said video using a video analysis processor or processing said signal using a signal analysis processor; determining whether the PGH attribute parameters have been obtained based on the PGH rules and the analyzed video or the analyzed signal; calculating said scoring parameters; 58. The system of claim 57, further configured and enabled to:

60. 1. A non-transitory computer-readable medium comprising program instructions for creating one or more playable gameplay highlight (PGH) computer games from a computer-based game, wherein execution of the program instructions by one or more processors of a computer system causes the one or more processors to: receiving events or data related to the computer based game using a logic engine, the logic engine being included in a processor located on a server; processing the events by the logic engine to result in building blocks or processing the data by the logic engine to result in building blocks; capturing one or more highlights in the computer-based game, each of the one or more captured highlights corresponding to a selected start point and an end point in the computer-based game; processing the building blocks by the logic engine to yield highlight attribute parameters, the highlight attribute parameters including one or more of possible objectives, possible constraints, possible PGH exit criteria, possible exit conditions, and possible scoring parameters respectively associated with each one of the one or more highlights; selecting a PGH highlight in each one of the one or more highlights, the PGH highlight corresponding to a selected start point and end point in the one or more highlights; processing, by the logic engine, the building blocks associated with the selected PGH highlight to generate PGH attributes, the PGH attributes including one or more of objectives, constraints, PGH exit criteria, exit conditions and scoring parameters, the selected start point and end point; creating the one or more PGH computer games based on the PGH attributes, each of the PGH computer games including PGH rules, the PGH rules relating to the PGH attributes and for configuring play of the one or more PGH computer games; A non-transitory computer readable medium for carrying out a method comprising:

Images