Method and system for creating a game, method for executing a 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 this disclosure relates to electronic games, and more particularly to implementing a system for creating and playing new games. [Background technology]

[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,476 B2, entitled "Method for creating a mini-game," presents a method for creating a video mini-game based on a legacy game title using snapshot technology. This method creates a game based on a snapshot of the legacy game, providing a small slice of entertainment for players who do not want to play the entire legacy game. Summary of the Invention [Means for solving the problem]

[0003] According to a first aspect of the present invention, there is provided a computer-implemented method for creating one or more playable gameplay highlight (PGH) computer games from a computer-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, and other video describing the computer-based game, the logic engine being included in a processor located on a server; receiving; processing the data to result in events, either 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; and capturing highlight attribute parameters to result in highlight attribute parameters. processing the building blocks by the logic engine, wherein the highlight attribute parameters include 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 one or more highlights; selecting a PGH highlight in each one of one or more highlights, wherein the PGH highlight corresponds to a selected start point and an end point in one of the one or more highlights; processing, e.g., iteratively, by the logic engine, the building blocks associated with the selected PGH highlight to generate PGH attributes, wherein the PGH attributes include one or more of an objective, a constraint, a PGH exit criteria, an exit condition, and a scoring parameter, the selected start point, and an end point; creating the one or more PGH computer games based on PGH attributes, wherein each of the PGH computer games includes a PGH rule, wherein the PGH rule is associated with the PGH attribute;and creating a game for playing the one or more PGH computer games.

[0004] In one embodiment, the method includes restoring events associated with the computer-based game, continuously identifying events in the one or more PGH computer games, continuously streaming the identified events from a game client device to a logic engine, continuously 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 PGH rules, and terminating play of the one or more PGH computer games when PGH attribute parameters have been obtained.

[0005] In one embodiment, the method includes generating a PGH status for each of the one or more PGH computer games, the PGH status including calculating one or more of scoring parameters, objective status, constraint status, and PGH termination criteria status; sending the PGH status to a management module included in the server; and providing server events based on one or more of the PGH status and building blocks.

[0006] In one embodiment, the method includes transmitting a server event from a server to a 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 event, 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 footage of the base game, and other video into events.

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

[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 video of a computer-based game captured by a video module in a 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 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 highlight of the one or more highlights.

[0015] In one embodiment, an event comprises 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 said events.

[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, PGH attributes are selected by the creator of a PGH computer game or automatically by the logic engine.

[0019] In one embodiment, the PGH attributes further include one or more of the following for the PGH: a description, a thumbnail "preview" image of the PGH computer game, and tags.

[0020] In one embodiment, the characters are player characters (PCs) or non-player characters (NPCs).

[0021] In one embodiment, the objectives or constraints or PGH exit criteria or exit conditions or scoring parameters are created using generative artificial intelligence (AI) algorithms and models.

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

[0023] In one embodiment, loading and running the one or more PGH computer games includes restoring events from a base game, capturing video or other signals of the base game, transmitting the captured video or other signals to a server, processing the video using a video analysis processor or processing the signals using a signal analysis processor, determining whether PGH attribute parameters have been obtained based on PGH rules and the analyzed video or analyzed signals, 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 gameplay highlight (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, and other video 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 events; capturing one or more highlights in the computer-based game, each of the one or more highlights corresponding to a selected start point and end point in the computer-based game; and processing the events with the logic engine to result in highlight attribute parameters, the highlight attribute parameters the PGH highlights include 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 an end point in one of the one or more highlights; processing the events associated with the selected PGH highlight by the logic engine to result in PGH attributes, the PGH attributes including one or more of an objective, a constraint, a PGH exit criteria, an exit condition, and a scoring parameter; and 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 associated with the PGH attributes and for configuring play of the one or more PGH computer games.

[0025] In one embodiment, the method includes restoring events associated with the base game, continuously identifying events in the one or more PGH computer games, continuously streaming the identified events from a game client device to a logic engine, continuously 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 PGH rules, and ending play of the one or more PGH computer games when 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, wherein generating the PGH status includes calculating one or more of scoring parameters, objective status, constraint status, and PGH termination criteria status; sending the PGH status to a management module included in the server; and providing server events based on one or more of the PGH status, building blocks, etc.

[0027] In one embodiment, the method includes transmitting a server event from a PGH server to a 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 events 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 the computer-based game.

[0030] In one embodiment, the method includes 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, the method including selecting a PGH highlight includes selecting a timestamp start point and selecting a timestamp end point in the computer-based game.

[0032] In one embodiment, the method includes sending video of a computer-based game captured by a video module in 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 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 highlight of the one or more highlights.

[0035] In one embodiment, the identified events include actions or states of characters 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 said events.

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

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

[0039] In one embodiment, the PGH attributes further include one or more of the PGH's name, description, thumbnail "preview" image of the PGH computer game, and tags.

[0040] In one embodiment, the characters are player characters (PCs) or non-player characters (NPCs).

[0041] In one embodiment, the objectives or constraints or PGH exit criteria or exit conditions or scoring parameters are created using generative artificial intelligence (AI) algorithms and models.

[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, wherein the loading and executing includes restoring events from a base game, capturing video or other signals of the base game, transmitting the captured video or other signals to a server, processing the video using a video analysis processor or processing the signals using a signal analysis processor, determining whether PGH attribute parameters have been obtained based on PGH rules and the analyzed video or analyzed signals, 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 running one or more playable gameplay highlight (PGH) computer games created based on a computer-based game, the method including: restoring events associated with the computer-based game; identifying events (e.g., continuously) in the one or more PGH computer games; streaming the identified events (e.g., continuously) from the game client device to a logic engine; processing (e.g., continuously) the identified events using the logic engine to yield building blocks; processing (e.g., continuously) the building blocks using the logic engine to determine whether PGH attribute parameters have been obtained based on PGH rules; and ending play of the one or more PGH computer games when PGH attribute parameters have been obtained.

[0045] In one embodiment, the method includes generating a PGH status for each of the one or more PGH computer games, wherein generating the PGH status includes calculating one or more of scoring parameters, objective status, constraint status, and PGH termination criteria status; sending the PGH status to a management module included in the server; and providing server events based on one or more of the PGH status, building blocks, etc.

[0046] In one embodiment, the method includes transmitting a server event from a PGH server to a 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 events, sending the PGH result to a PGH application (PGH app), and displaying the server events 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, the event module being included in a processor within a 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 events include actions or states of characters 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 said events.

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

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

[0054] In one embodiment, the PGH attributes further include one or more of the PGH's name, description, thumbnail "preview" image of the PGH computer game, and tags.

[0055] In one embodiment, the objectives or constraints or PGH exit criteria or exit conditions or scoring parameters are created using generative artificial intelligence (AI) algorithms and models.

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

[0057] In one embodiment, loading and executing the one or more PGH computer games includes restoring events from a computer base game, capturing video or other signals of the base game, transmitting the captured video or other signals to a server, processing the video using a video analysis processor or processing the signals using a signal analysis processor, determining whether PGH attribute parameters have been obtained based on PGH rules and the analyzed video or analyzed signals, and calculating scoring parameters.

[0058] According to a fourth aspect of the present invention, there is provided a system for creating one or more playable gameplay highlight (PGH) computer games from a computer-based game, the system comprising: a game client device comprising a processing circuit with 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 processor comprising a video processor, a logic engine, and a PGH publisher, the logic engine receiving data related to the computer-based game, the data including one or more of events, text, audio, images, video recordings of the base game, other video describing the base game, processing the data to produce events, processing the events to produce building blocks, or processing the events to produce building blocks, and generating one or more high-quality gameplay highlights in the computer-based game. capturing a light, wherein each of the one or more captured highlights corresponds 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, wherein the highlight attribute parameters include one or more of a possible objective, a possible constraint, a possible PGH exit criterion, 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, wherein the PGH highlight corresponds to the selected start point and an end point in one of the one or more highlights; and processing, e.g., iteratively, by the logic engine, the building blocks associated with the selected PGH highlight to generate PGH attributes, wherein the PGH attribute includes one or more of an objective, a constraint, a PGH exit criterion, an exit condition, and a scoring parameter;A system is provided, comprising a game client device configured and enabled to: create the one or more PGH computer games based on PGH attributes, each of the PGH computer games including PGH rules, the PGH rules associated with the PGH attributes and for configuring play of the one or more PGH computer games.

[0059] In one embodiment, the one or more processors are further configured and enabled to load and execute the one or more PGH computer games, wherein the loading and executing includes restoring events associated with the base game; continuously identifying events in the one or more PGH computer games; continuously streaming the identified events from a game client device to a logic engine; continuously 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 PGH rules; and terminating play of the one or more PGH computer games when PGH attribute parameters have been obtained.

[0060] In one embodiment, the one or more processors are further configured and enabled to generate a PGH status for each of the one or more PGH computer games, wherein generating the PGH status includes calculating one or more of scoring parameters, objective status, constraint status, and PGH termination criteria status, sending the PGH status to a management module included in the server, and providing server events based on one or more of the PGH status and building blocks.

[0061] In one embodiment, the one or more processors are further configured and enabled to recover events from the 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 PGH attribute parameters have been obtained based on the PGH rules and the analyzed video or analyzed signals, and calculate scoring parameters.

[0062] According to a fifth aspect of the present invention, there is provided 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: 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; process the events with the logic engine to result in building blocks, or process data with the logic engine to result in building blocks; 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 end point in the computer-based game; and process the building blocks with the logic engine to result in highlight attribute parameters. processing the highlight attribute parameters, wherein the highlight attribute parameters include 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 an end point in one of the one or more highlights; processing, e.g., iteratively, 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 an objective, a constraint, a PGH exit criteria, an exit condition, and a scoring parameter, the selected start point, and an end point; and 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 associated with the PGH attributes and for configuring play of the one or more PGH computer games.and creating a method for

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

[0064] [Figure 1A] FIG. 1A is a logical block diagram of an exemplary gaming system that supports the creation of a PGH that allows players to re-experience past gameplay scenarios, according to some embodiments of the present invention. [Figure 1B] FIG. 1B is a logical block diagram of an exemplary gaming system that supports the creation of a PGH that allows players to re-experience past gameplay scenarios, according to some embodiments of the present invention. [Figure 1C] FIG. 1C is a logical block diagram of an exemplary gaming system that supports playback of a PGH to allow players to re-experience past gameplay scenarios, according to some embodiments of the present invention. [Figure 2] FIG. 2 illustrates an exemplary user interface of a system for creating a PGH that allows players to re-experience past gameplay scenarios, according to some embodiments of the present invention. [Figure 3] FIG. 3 is a flow diagram of an exemplary method for creating a PGH that allows a player to re-experience past gameplay scenarios, according to some embodiments of the present invention. [Figure 4] FIG. 4 is a diagram illustrating an exemplary data structure of a PGH data object that allows a player to re-experience a past gameplay scenario, according to some embodiments of the present invention. [Figure 5A] FIG. 5A is a flow diagram of an exemplary method for playback of a PGH that allows a player to re-experience a past gameplay scenario, according to some embodiments of the present invention. [Figure 5B]FIG. 5B is a flow diagram of an exemplary method for playback of a PGH that allows a player to re-experience a past gameplay scenario, according to some embodiments of the present invention. [Figure 5C] FIG. 5C is a flow diagram of an exemplary method for playback of a PGH that allows a player to re-experience a past gameplay scenario, according to some embodiments of the present invention. [Figure 5D] FIG. 5D is a flow diagram of an exemplary method for playback of a PGH that allows a player to re-experience a past gameplay scenario, according to some embodiments of the present invention. [Figure 5E] FIG. 5E is a flow diagram of an exemplary method for playback of a PGH that allows a player to re-experience a past gameplay scenario, according to some embodiments of the present invention. [Figure 6] FIG. 6 is a flow diagram of an exemplary scenario of initial user creation and secondary user play of a PGH that allows players to re-experience past gameplay scenarios, according to some embodiments of the present invention. [Figure 7A] FIG. 7A is a high-level block diagram of an exemplary system configured and enabled to create a PGH based on one or more scenarios of past gameplay in a computer-based game using building blocks, according to some embodiments of the present invention. [Figure 7B] FIG. 7B is a high-level block diagram of an alternative system configured and enabled to create a PGH based on one or more scenarios of past gameplay in a base game with a creation input module, according to some embodiments of the present invention. [Figure 7C] FIG. 7C is a flowchart of a method for creating a PGH based on one or more scenarios of past gameplay using building blocks, according to an embodiment. [Figure 7D]FIG. 7D is a flowchart of a method for creating a PGH based on one or more scenarios of past gameplay, including receiving an identified event or processing data to result in an identified event, according to an embodiment. [Figure 7E] FIG. 7E is a high-level block diagram of an exemplary system for enabling the loading and execution of a PGH created based on one or more scenarios of past gameplay in a base game, according to an embodiment. [Figure 7F] FIG. 7F is a flowchart of a method for loading and running a PGH computer game, such as the PGH created in FIG. 7A, according to an embodiment. [Figure 7G] FIG. 7G is a flowchart of a method for loading and running a PGH computer game, such as the PGH created in FIG. 7B, according to an embodiment. [Figure 7H] FIG. 7H illustrates a detailed block diagram illustration of the processor of FIG. 7A, according to an embodiment. [Figure 7I] FIG. 7I presents an alternative configuration architecture in which the logic engine may include a data transformation module configured and enabled to receive and / or extract data and transform this data into identified events, according to an embodiment. [Figure 7J] FIG. 7J is a detailed block diagram of FIGS. 7A and 7B configured and enabled to create a PGH based on one or more scenarios of past gameplay in a single-player configuration, according to an embodiment. [Figure 7K] FIG. 7K is a detailed block diagram of a system configured and enabled to create a PGH based on one or more scenarios of past gameplay in a multiplayer configuration, according to an embodiment. [Figure 7L]FIG. 7L is a block diagram of a subset of FIG. 7K configured and enabled to publish and distribute one or more assets of a base game and a PGH based on one or more scenarios of past gameplay in a single-player / multiplayer configuration, according to an embodiment. [Figure 7M] FIG. 7M is a flowchart of a method for asset extraction and decomposition, according to an embodiment. [Figure 8A] FIG. 8A is a flowchart 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. [Figure 8B] FIG. 8B is a time flowchart of a method for playing a PGH, such as the created PGH shown in FIG. 8A, created based on one or more scenarios of past gameplay in a multiplayer or single-player configuration, according to an embodiment. [Figure 8C] FIG. 8C is a flowchart of a method for asset extraction and decomposition in a base game and / or PGH, such as the created PGH shown in FIG. 8A, according to an embodiment. [Figure 8D] FIG. 8D is a flowchart of a method for publishing assets in a base game and / or PGH, according to an embodiment. [Figure 9A] FIG. 9A illustrates an example of an event list, according to an embodiment. [Figure 9B] FIG. 9B illustrates an example of a target list, according to an embodiment. [Figure 9C] FIG. 9C illustrates an example of a constraint list, according to an embodiment. [Figure 9D] FIG. 9D illustrates an example of a score parameter list, according to an embodiment. [Figure 9E] FIG. 9E illustrates an example of an exit condition list, according to an embodiment. [Figure 10A] FIG. 10A illustrates example screenshots of a game and a PGH, according to an embodiment. [Figure 10B]FIG. 10B illustrates example screenshots of a game and a PGH, according to an embodiment. [Figure 10C] FIG. 10C illustrates example screenshots of a game and a PGH, according to an embodiment. [Figure 10D] FIG. 10D illustrates example screenshots of a game and a PGH, according to an embodiment. [Figure 10E] FIG. 10E illustrates example screenshots of a game and a PGH, according to an embodiment. [Figure 10F] FIG. 10F illustrates example screenshots of a game and a PGH, according to an embodiment. [Figure 10G] FIG. 10G illustrates example screenshots of a game and a PGH, according to an embodiment. [Figure 11] FIG. 11 illustrates example screenshots of a game and PGH including objectives and PGH outcome status, according to an embodiment. [Figure 12] FIG. 12 is a diagram illustrating an exemplary data structure of a PGH data object, according to some embodiments. [Figure 13] FIG. 13 is a flowchart of a method for loading and running a PGH computer game, according to an embodiment. [Figure 14] FIG. 14 illustrates a computer system suitable for integration with methods, systems, and devices according to embodiments. DETAILED DESCRIPTION OF THE INVENTION

[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 running one or more playable gameplay highlight (PGH) computer games from a computer-based game.

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

[0068] According to one embodiment, the present invention is configured to receive a base / original computer game (e.g., computer-based game 705) with past rules and create a new game, defined herein as a PGH. The generated PGH may be related to, inspired 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 primarily relates 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 will share some characters because they share the titles NBA and Racing Game and include characters such as basketball players and racing cars, respectively. However, the generated PGH will include new rules, objectives, and / or constraints that were not included in the original game and therefore could not be played according to these rules in the base computer game.

[0069] Put more simply, a PGH game is inspired by the theme or subject matter of the original game, but introduces new gameplay mechanics, goals, and restrictions that make it a different experience from the original game.

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

[0071] One difference between the present invention and the prior art is the approach to creating new playable content from a game. The present invention, according to an embodiment, involves breaking down an original game, e.g., into building blocks or any type of data, e.g., by analyzing events in the game, and creating a new game (e.g., a PGH) whose rules and gameplay differ from the original game based on identifying various events.

[0072] Specifically, analyzing in-game events involves analyzing gameplay data to identify significant 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, prior art techniques create games, such as "mini-games," by, for example, selecting specific snapshots of the original game state at selected starting points in the original game and identifying triggers to in-game events. Mini-games are generated using scripts based on the snapshots and triggers to extract limited sections of the game to provide shorter, self-contained experiences.

[0073] Another key 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 re-experience exciting moments from the original game while introducing new elements such as objectives, constraints, and scoring mechanisms. This approach enhances the original gameplay by adding fresh challenges and rewards. Prior art solutions, such as mini-games, do not introduce new elements but instead provide a condensed version of the original gameplay starting from a predetermined point.

[0074] Furthermore, the present invention differs from the prior art in its technical approach and the type of player experience it provides. The present invention focuses on recording, analyzing, and enhancing gameplay highlights using new objectives and scoring parameters, while the prior art focuses on extracting specific scenarios from saved game states to create shorter, self-contained mini-game experiences, but nothing new. The methods, devices, and systems of the present invention add new elements to enhance the original gameplay, while the prior art condenses games into bite-sized experiences.

[0075] Thus, while prior art computer game rules, such as mini-game rules, are equivalent to the rules of the base game, the rules of the PGH may 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, by doing so, win the game. A PGH created from a particular highlight of an NBA game may have objectives for players to make more than X passes (e.g., 10) between their teammates within a particular time frame, to make a shot from a distance at least equal to the distance of the score in the PGH creator's highlight, or to steal the ball from the opposing team within a particular time frame.

[0076] Operations according to the teachings herein may be performed by a specially constructed computer for the desired purpose, or by a general-purpose computer specially configured for the desired purpose by a computer program stored on a non-transitory computer-readable storage medium.

[0077] Embodiments of the presently disclosed subject matter are not described with reference to any particular programming language, although it will be appreciated that a variety of programming languages ​​can be used to implement the teachings of the presently disclosed subject matter as described herein.

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

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

[0080] Furthermore, PGH was created to address several key challenges 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 mobile app stores had over 100,000 new games. PGH enables the gaming community to promote and market games through organic user-generated content, allowing even smaller studios to gain visibility without relying solely on traditional marketing methods. Second, PGH, in embodiments, allows gamers to capture their best gaming moments and transform them into playable highlights that can be shared across social media platforms. PGH not only improves the gaming experience for the community, but also serves as a powerful marketing tool for game studios, developers, and publishers. By integrating the PGH SDK, studios can empower their communities to showcase their games, create demos, and provide early access to the press while focusing on optimizing the gaming experience. Additionally, PGH helps studios increase user lifetime value 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 may be applied to a wide variety of games and virtual experiences, as described in more detail below.

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

[0083] The term "tracking data," as used herein and throughout the specification and claims, should be understood to encompass data describing the complete play of a game (e.g., a first-person shooter game) by an initial user. This term refers to detailed information recorded during a gameplay session to capture and replay the game state and player actions.

[0084] The term "time-based data," as used herein and throughout the specification and claims, should be understood to encompass changes or modifications to the game state that are triggered at specific times or intervals relative to the start of the PGH. These changes are not dependent on any particular in-game event or player action, but rather occur automatically at predetermined times. For example, spawning a new enemy character at the 15-second mark of the 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 a player or other game entity. For example, changing the behavior of an enemy character when a player enters a particular area of ​​the game world.

[0086] The term "virtual object," as used herein and throughout the specification and claims, should be understood to encompass any distinct element or entity within a 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-ups, 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, animations, physical properties, behavior scripts, interaction capabilities, and gameplay-specific characteristics.

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

[0088] The term "Playable Gameplay Highlights (PGH)" or "PGH" or "PGHs" or "PGH Game" or "PGH Games" as used herein and throughout the specification and claims should be understood to encompass playable content created, for example, by a gamer from their own original gameplay or past gameplay of a computer game. According to embodiments, 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 gameplay. This playable content is time-constrained and matches the length of the original gameplay. Each PGH includes objectives and / or constraints and / or scoring parameters and / or exit conditions 1224 and / or exit PGH criteria 1222 set by the creator or by an algorithm, such as an artificial intelligence (AI) algorithm, or a mixture of the two (e.g., multiple objectives, some created by the creator and some created by an algorithm), based on the creator's gameplay, and includes a scoring system that evaluates each player's performance according to the set scoring parameters. In some embodiments, the PGH includes rules (eg, objectives and / or constraints and / or exit conditions and / or PGH exit criteria) along with scoring parameters that were never part of the rules of the base game.

[0089] The terms "original game" or "game" or "base game" or "computer game" or "computer-based game" as used herein and throughout the specification and claims should be understood to encompass the first or source computer game played by the original or initial game player. A computer game or PGH can be any type of computerized game, such as 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 / unscored games, board games, competitive games, tournament games, wagering games, prize games, etc. The term "game" also includes non-competitive virtual "experiences," such as a VR / AR music concert or VR / AR exploration of a virtual area.

[0090] The terms "gameplay" or "gameplays" or "gameplay" or "game plays" as used herein and throughout the specification and claims should be understood to encompass the ways in which a player interacts with a game, including the states, actions, rules, mechanics, and structure presented by the game, as well as the player's actions and states used to progress through 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 game to be played, encompassing the player's interaction with the game's systems and content, including the game's design, flow, and 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 interacting with the game world.

[0091] The term "player" as used herein and throughout the specification and claims should be understood to encompass users who play the base game or the PGH.

[0092] The term "Highlight" or "Highlights," as used herein and throughout the specification and claims, should be understood to encompass selected timestamps or time intervals during gameplay of a computer game for which a player wishes to create a PGH. An example of a "Highlight" might be a 20-second duration in an NBA computer game during which no other player was able to steal the ball from that player.

[0093] The term "state" as used herein and throughout the specification and claims should be understood to encompass characteristics of entities in a game. An example of a "state" may be, for example, a player position or the health of a player in a computer game.

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

[0095] The term "Event" or "Events" or "Identified Event" or "Identified Events" as used herein and throughout the specification and claims should be understood to encompass player actions and states and / or game actions or states.

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

[0097] The term "structure" as used herein and throughout the specification and claims should be understood to encompass properties that define a PGH, such as objectives, score parameters, start and end points, thumbnails, titles, etc.

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

[0099] The terms "rule" or "rules" or "PGH rules" as used herein and throughout the specification and claims should be understood to encompass Boolean expressions / terms including logical operations based on Boolean conditions from a PGH, for example. Specifically, a rule can be defined as a logical path, such as one or more binary logical paths, associated with a selected and played computer game segment that includes a PGH, such as a PGH building block. A rule can be based on generated "objectives" and / or "constraints" and / or "exit conditions" and / or "exit PGH criteria 1222." Examples of such rules are shown in Figures 9B, 9C, and 9E.

[0100] The term "Objective" or "Objectives" as used herein and throughout the specification and claims should be understood to encompass one or more goals that a PGH player must achieve to ensure victory in a PGH game. An example of a possible objective is shown in Figure 9B.

[0101] The term "Constraint" or "Constraints" as used herein and throughout the specification and claims should be understood to encompass one or more conditions that, if reached, cause a player to lose the PGH. An example of a possible constraint is shown in Figure 9C.

[0102] "Score" or "Scores" or "Scoring Parameter" or "Scoring Parameters" or "Score Parameters" as used herein and throughout the specification and claims should be understood to encompass a list of conditions that, if reached, will result in a player receiving a score. Scores may be either positive or negative and are cumulative such that each time a new condition is reached, the score is updated either positively (i.e., by adding a score to the accumulated score) or negatively (i.e., by subtracting a score from the accumulated score). An example of a possible scoring parameter is shown in FIG. 9D.

[0103] The term "End Condition" or "End Conditions," as used herein and throughout the specification and claims, should be understood to encompass conditions that, if reached, ensure a player wins the PGH game, result in a player losing the PGH, or, in some cases, result in the PGH ending without a predetermined win or loss of the PGH. An example of a possible end condition is shown in Figure 9E.

[0104] The term "End PGH Criteria" or "End of PGH Criteria," as used herein and throughout the specification and claims, should be understood to encompass conditions that, if reached, ensure a player wins the PGH game, result in a player losing the PGH, or in some cases, the PGH ends without a predetermined win or loss of the PGH. Examples of possible end PGH criteria 1222 are a time limit (e.g., a player has 30 seconds to reach one of the objectives), a number of turns (e.g., in a chess game, a user has 20 turns to reach one of the objectives), or a mixture of a number of turns and a time limit (e.g., in a chess game, a user has 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 herein and throughout the specification and claims should be understood to encompass formulas formed based on identified events such as "actions" and / or "states" to create one or more "objectives" and / or one or more "Constraints" and / or one or more "End Conditions" and / or one or more "End PGH Criteria 1222".

[0106] As used herein, the terms "non-transitory memory" and "non-transitory storage medium" should be constructed expansively to encompass any volatile or non-volatile computer memory suitable for the subject matter of this disclosure.

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

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

[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 claims should be understood to encompass data necessary to play the PGH.

[0111] The terms "graphic element" or "graphic elements" or "graphic assets" or "assets" as used herein and throughout the specification and claims should 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 graphical elements include, but are not limited to, meshes; a comprehensive set of textures such as albedo, normal maps, height maps, occlusion, detail masks, and bakelite maps; support for additional texture maps such as metallicity 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 interaction; animation rigs with keyframes and curves for movement; colliders for physical interaction; physical states for dynamics and kinematics; real-time lighting elements with shadow maps and global lighting; reflection probes and screen space reflections for accurate reflections; particle systems for special effects; post-processing effects for visual enhancement such as bloom, motion blur, depth of field, tone mapping, and color grading; sound assets for spatial audio effects; AI navigation meshes for character pathfinding; a level of detail (LOD) system for performance optimization; occlusion culling and frustum culling systems for rendering efficiency; and comprehensive scripting capabilities to control game logic and interactions.

[0112] Attention is now directed to FIG. 6, which illustrates a flowchart 600 of an exemplary sequence for a user to play a game, create a derivative PGH, and share it with other users, in accordance with some embodiments of the subject matter described herein.

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

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

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

[0116] The initial user's device can then make the completed gameplay data available to the PGH creation server 630. Note that the transfer of gameplay data to the PGH creation server can occur simultaneously with or subsequent to gameplay, can involve intermediate entities, etc.

[0117] According to another embodiment, the entire game data is constantly uploaded to the PGH's servers during gameplay so that the user can select specific highlights and later turn them into PGHs.

[0118] The server may then present a user interface (UI) to the initial user (640). The presented user interface may allow the initial user to select completed gameplay or a particular segment / highlight of the completed game to be included in the PGH (e.g., a 45-second gameplay sequence from a 15-minute game session). The presented user interface may also allow the initial user to select a particular goal for the PGH (e.g., killing a particular number of enemies, moving the main character to a particular point on the game terrain, etc.).

[0119] The server can then create (650) a data object that enables the playing of the PGH and make this data object available to other users. As a non-limiting example, the server can maintain a web page that allows users to review such data objects and then access specific objects to play the respective PGH. In some cases, links to the created data objects are provided. In some cases, the data objects may be shared using known sharing methods, such as sharing links, such as address hyperlink addresses, and similar means.

[0120] Such "secondary" users can then access (e.g., by downloading, streaming, loading, etc.) the newly created PGH and then play (660) the PGH, performing their own original game actions on the PGH.

[0121] According to another embodiment, as shown in detail in Figures 7A-7F and 8A-8D, a secondary user can click on a link, such as a PGH link, which loads a corresponding game and then sends 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 (e.g., via a browser) to run the PGH or by opening a dedicated app (e.g., a PGH app) to run the PGH; for example, the dedicated app can be cloud-based, or it can open a base game on the secondary user's device and then open the PGH on top of the base game.

[0122] As described in more detail below, in some embodiments, certain techniques are utilized to allow a secondary user to experience the original game scenario experienced by the initial user while ensuring that the game progression actually conforms to the original game rules, game physics, etc. In some embodiments, these techniques include:

[0123] i) Recreating time-based events from the original game in the PGH. For example, if a new enemy appears or an existing enemy takes an action of its own accord at a particular time in the initial user's gameplay, the PGH system can replicate these enemy actions at the same time offset of the PGH play as in the original game based on the data contained in the PGH data object.

[0124] ii) Recreating event-triggered responses from the original game in the PGH. For example, if an enemy changes its position and fires back in response to an initial user firing a weapon at an enemy, the PGH system can replicate the enemy's behavior in response to a protagonist controlled by a secondary user firing a weapon at a particular 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 in the PGH to repeat all or some of the behavior in the original game for a certain duration of the PGH, and then behave according to their NPC characteristics after that time. NPCs on the PGH that behave according to their original game behavior are referred to herein as "caged NPCs," and NPCs that behave according to their characteristics and / or other factors are referred to herein as "uncaged NPCs."

[0126] In some embodiments, the PGH data object may include data indicating whether the NPC's initial state is caged or uncaged. In some embodiments, the PGH data object may 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 particular event.

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

[0128] In some cases, it's not just caged / uncaged NPCs that change their behavior according to the secondary user's behavior. The claim is broader than this and refers to any behavior in the game. This means that if the secondary user makes similar choices as the initial user, the overall behavior of the gameplay highlights will be similar (but not identical), but if the secondary user changes things up and chooses different choices than the initial user, the gameplay will behave differently (a concrete example would be caged / uncaged NPCs).

[0129] According to some embodiments, it is not just caged / uncaged NPCs that change their behavior according to the secondary user's behavior. For example, if the secondary user makes similar choices as the initial user, the overall behavior of the gameplay highlights will be similar (e.g., not identical), but if the secondary user changes things up and chooses different choices, the initial user and gameplay will behave differently (a specific example is caged / uncaged NPCs).

[0130] Attention is now directed 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 past gameplay scenario, in accordance with some embodiments of the subject matter of this disclosure.

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

[0132] The PGH creation enabled gaming system 100A can include processing circuitry 110A, which can include a processor 120A and a memory 130A.

[0133] The PGH creation-enabled gaming system 100A may, for example, be operatively connected to a variety of peripherals (e.g., gaming-related peripheral devices). Such peripherals may include, for example, a gaming display / audio system 180 and a gaming controller 170. Peripherals may also include virtual reality / augmented reality headsets or other types of gaming or other peripherals.

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

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

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

[0137] Processing circuitry 110A can be configured to execute several functional modules in accordance with computer-readable instructions embodied on a non-transitory computer-readable storage medium. Such functional modules are hereinafter referred to as being included in the processing circuitry. These modules can include, for example, gaming engine 150, tracker module 105, and game-specific logic 140.

[0138] The gaming engine 150 may be a software module that implements general game functions such as, for example:

[0139] Managing devices such as the game display / audio system 180 and game controller 170, including receiving input from (and sending output to) such devices -Implementing virtual objects used and displayed in the game (e.g., game terrain, obstacles, etc.). -Providing an application programming interface (API) for provisioning virtual objects, determining the current state of the virtual objects, and managing the virtual objects.

[0140] The gaming engine 150 may be, for example, a commercial gaming engine such as Unreal™, Unity™, or the like.

[0141] The gaming engine 150 may include various sub-modules that implement "bullet physics," "vehicle motion," etc., allowing ongoing changes to the game state to occur autonomously within the gaming engine 150.

[0142] Gaming engine 150 may implement game state changes in response to, for example:

[0143] Pseudo-randomly generated events, such as pseudo-randomly appearing enemies in a first-person shooter game Game controller device events, such as a user pressing a game controller device button to fire a weapon Virtual object properties - for example, a moving vehicle can have a continuously updated position within the game terrain

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

[0145] In some examples, game-specific logic 140 initially provisions an initial game scenario into gaming engine 150. As a non-limiting example, in a racing game, game-specific logic 140 may initially provision gaming engine 150 with virtual objects including a race track with a particular topology, a first-person player car with a position on the race track, non-player cars with particular appearance and movement characteristics, etc. Game-specific logic 140 may perform the provisioning of the initial game scenario via an API of gaming engine 150.

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

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

[0148] The tracker module 105 can write 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, the numerous virtual object characteristics that describe a car (e.g., color, wheel style, height, etc.) can be represented by three bits that identify one of eight car models implemented in a racing game.

[0149] The tracker module 105 may write the tracking data into, for example, the following two groupings:

[0150] a) a grouping containing data describing initialization data, and b) A grouping containing data describing subsequent changes to virtual objects and game state events.

[0151] The data describing subsequent changes to virtual objects and game state events may include data (e.g., timestamps) that indicate when the changes occurred in the game.

[0152] The data describing the subsequent changes to the virtual object and game state events may include, for example, images (e.g., screenshots) or video segments showing the game events at the time of the changes / events.

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

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

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

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

[0157] The processing circuit 110B can be configured to execute several functional modules in accordance with computer-readable instructions embodied 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, a PGH creation module 145 and a regamification logic 135.

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

[0159] The regamification logic 135 may be a software module that receives (eg, via a user interface, such as a web-based user interface) data indicative of the scoring parameters of the PGH and / or the game-ending criteria of the PGH.

[0160] As a non-limiting example, tracking data may include data describing a complete play of a game (e.g., a first-person shooter game) by an initial user. Within a complete play of the game, there may be several scenarios with different types of enemies and targets, different terrain, and different objectives.

[0161] In some embodiments, the PGH creation module 145 can present the initial user with a web-based interface that allows him or her to select a particular scenario within a longer game that will form the basis of the PGH. For example, the selected scenario may include a protagonist that must kill a specific number of enemies located in specific positions on specific terrain. In some such embodiments, the web-based interface displays still images or video segments (contained in the uploaded tracking data 155) to help the user select a scenario.

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

[0163] In some embodiments, the PGH creation module 145 can create the 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 beginning of the user's play of the game replaying). This data can be a derivative of the uploaded tracking data 155 and can be written to the PGH data segment 115 in a tracking data format or a different data format. This data can describe the virtual objects sufficiently to allow a replayer to configure the virtual objects in the gaming engine.

[0164] In some embodiments, the PGH creation module 145 can further write data to the PGH indicating time-based modifications. 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 changes 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 a tracking data format or a different data format.

[0165] The time-based correction data may be accompanied by an explicit timestamp indicating the time offset in the PGH when the correction should occur, or in some embodiments, the timestamp is implicit (e.g., each time-based correction may represent a change occurring at 10 ms intervals).

[0166] This data can describe the virtual object sufficiently to allow the replayer to compose the virtual object at the appropriate time offset into the gaming engine.

[0167] As a non-limiting example, the PGH creation module 145 may detect virtual object initializations and modifications that occur after the start of the portion of the game being used to create the PGH while processing the uploaded tracking data 155. As a more specific example, the PGH creation module 145, in some embodiments, may examine tracking data from the uploaded tracking data 155 that indicates the sudden appearance of a new enemy from a newly visible terrain feature, such as a building. Accordingly, the PGH creation module 145 may then create time-based modifications to the PGH to create a new virtual object corresponding to the new enemy.

[0168] In some embodiments, the PGH creation module 145 can further write data to the PGH indicating event-based modifications. 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 changes to already defined virtual objects in response to specific events that trigger the game (e.g., in response to actions by 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 a tracking data format or a different data format.

[0169] This data can describe the virtual object sufficiently to allow the replayer to configure the virtual object in the gaming engine in response to the indicated event.

[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 attributable to the protagonist's actions or to other game events, and which virtual object initializations and modifications are spontaneous, i.e., not attributable 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 that indicates that a stationary non-player character (NPC) becomes active (e.g., by attacking the protagonist) in response to being struck by a projectile fired by the protagonist. The PGH creation module 145 can then determine that the NPC behavior is responsive to the protagonist's behavior and create event-based modifications to the PGH accordingly.

[0171] In some embodiments, the PGH creation module 145 can further write data indicative of the regamification data to the PGH. For example, the PGH creation module 145 can write data indicative of scoring parameters and / or game termination criteria to the PDS.

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

[0173] The virtual object release criterion is an event whereby, upon occurrence of the event, the replayer stops ongoing control of the gaming engine to replicate the virtual object behavior of the game played by the initial user. The replayer can then implement different behaviors on the object as appropriate for the game. In some examples, the virtual object release criterion can be a time offset into the PGH.

[0174] As a non-limiting example, in a racing game, there may be a virtual object of an NPC car. The PGH creation module 145 can configure the PDS so that, at a particular time offset into the replayer's play of the PGH, the car no longer mirrors the behavior of the virtual object of the NPC car in the game played by the initial player, but rather follows a different behavior. For example, the original behavior of the NPC may be for the virtual object of the NPC car to slow down before a particular turn in a road, and the non-mirrored behavior may be for the car to accelerate around that particular 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 this disclosure. In FIG. 1B, the PGH creation function is split between a PGH creation module 145A (disposed within the tracker module of gaming system 100A) and a PGH creation module 145B (disposed 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 scoring parameters selected by the user and prepare replayification 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 game play according to some embodiments of the subject matter of this 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. Next, a PDS replay module 185 can use the PGH segment 165 to provide a PGH. A detailed description of an exemplary method of providing a PGH from the PGH segment 165 is shown below with reference to FIG. 4.

[0178] Attention is now directed to Figure 2, an exemplary user interface presented to an initial player of a game, according to some embodiments of the subject matter of this disclosure. The screen shown in Figure 2 includes a selection interface element (210) that allows the initial user to select a time range from the original game on which the PGH is based. This interface also shows still frames of gameplay, which may be images that were included in the uploaded tracking data 155 (after being placed in tracking data 125 by tracker module 105) and subsequently extracted by PDS server 195.

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

[0180] Attention is now directed to FIG. 3, which illustrates a flow diagram 300 of an exemplary method for creating a PGH data segment, in accordance with some embodiments of the presently disclosed subject matter.

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

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

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

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

[0185] In some other embodiments, the processing circuitry 110B of the PDS server 195 (e.g., the PGH creation module 145) 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 PGH termination criteria from a user interface. For example, the user can specify a time offset in the original game as the termination, or the user can select criteria for the game's termination, such as the number of enemies killed.

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

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

[0189] In some other embodiments, the processing circuitry 110B (e.g., PGH creation module 145) of the PDS server 195 determines the scoring parameters through a different mechanism (e.g., utilizing scoring parameters appropriate for a single game). For example, if it is a racing game, the system may automatically set the scoring parameter to lap time. If it is a first-person shooter game, the scoring parameter may automatically be set to the number of enemy kills.

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

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

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

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

[0194] The processing circuitry 110B (eg, PGH creation module 145) of the PDS server 195 may make the PDS 115 available for access (eg, download) to enable others to play the PGH.

[0195] Attention is now directed to FIG. 4, which illustrates an exemplary data structure of a PGH data segment, in accordance with some embodiments of the presently disclosed subject matter.

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

[0197] The PGH data segment 400 can include time-based data 420, which can include zero or more time descriptors (e.g., time descriptors 425A-425D in FIG. 4). Each time descriptor can describe a time offset of the 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 may be a grouping of data that indicates a group of virtual object parameters that a PGH play-enabled gaming system should instantiate at a time offset in the PGH (as indicated by an associated time descriptor).

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

[0200] The PGH data segment 400 can include event-based data 430, which can include zero or more event descriptors (e.g., event descriptors 435A-435C). Each event descriptor can refer to a virtual object within the PGH and describe an event that can occur within the PGH (e.g., an enemy death, a 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 previously described, each modified virtual object descriptor may include an identifier of an already-instantiated virtual object and may be a grouping of data indicating a group of virtual object parameters that a PGH play-enabled gaming system should apply to the corresponding already-instantiated virtual object in response to an event in the PGH (as indicated by an associated event descriptor).

[0202] The PGH data segment 400 can include regamification data 440, which can include game-ending criteria 445A and scoring parameters 445B. The game-ending criteria 445A can include data indicating when a gaming system enabled for PGH play should end the PGH (e.g., after a specific goal is achieved, such as the protagonist reaching a certain point in the terrain at a specific time or killing a specific number of enemies (or a combination of such criteria)). The scoring parameters 445B can include data indicating what a gaming system enabled for PGH play should track and display as a measure of success in the PGH (e.g., number of enemies killed, protagonist strength, etc.).

[0203] Attention is now directed to FIGS. 5A-5E, which illustrate a flow diagram 500 of an exemplary method for providing a PGH from a PGH data segment, in accordance with some embodiments of the presently disclosed subject matter.

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

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

[0206] Processing circuitry 110A (e.g., PDS replay module 185) may then control gaming engine 150 to instantiate the initial virtual objects shown in PDS 165.

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

[0208] Processing circuitry 110A (e.g., PDS replay module 185) may initiate play of the PGH (540), for example, by appropriately controlling gaming engine 150.

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

[0210] In some embodiments, processing circuitry 110A (e.g., PDS replay module 185) evaluates time-based data and only controls gaming engine 150 to instantiate new virtual objects or modify existing virtual objects that are not the game protagonist or controlled by the game protagonist. In such embodiments, processing circuitry 110A (e.g., PDS replay module 185) excludes the game protagonist and objects controlled by the protagonist simply because the game protagonist's PGH behavior is controlled by the game player and not by past game events (although past game events may still be used for comparison purposes). In some other embodiments, virtual objects that are the game protagonist or controlled by the game protagonist are not present in PDS 165.

[0211] Similarly, in some embodiments, non-player characters (NPCs) may initially operate in what was previously described as a "caged mode." In this state, the NPCs may behave as they did in the original, previous game played by the initial player. In such embodiments, upon the occurrence of a trigger (i.e., an event that the system chooses to create), the NPCs may begin to exhibit changes in their behavior; for example, the NPCs may exhibit future behavior according to an artificial intelligence decision tree (rather than their behavior in the previous game).

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

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

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

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

[0216] Reference is now made to FIG. 7A, which is a high-level block diagram of an exemplary system 700 configured and enabled to create a PGH based on one or more scenarios of past gameplay in a base game, in accordance with some embodiments of the present invention.

[0217] According to one embodiment, the 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., a base game 705) or a PGH and process the original game or PGH using one or more processors 708, for example, in real time (or near real time), to identify one or more "events" within the original game.

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

[0221] The gaming 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., base game 705) may be any game that a user (e.g., gamer) wants to play and, further, wants to be able to create and play a PGH based on or in connection with 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 are in communication with an event module 709 and a video module 706 .

[0224] The event module 709 is configured 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 a PGH) and continuously, e.g., in real time, stream the identified events 715 to the PGH server 703. The events 715 may include, for example, the "actions" and / or "states" of characters in the base game 705.

[0225] The game client device 701 further comprises a video module 706 configured and enabled to record the base game 705 and / or a view of the game (e.g., the game and all content layers displayed thereon, e.g., the current score of the game, the time remaining, 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 segments).

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

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

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

[0229] Private data centers are typically owned and operated by the gaming company itself. They are used to host gaming servers, store player data, and manage game content. Private data centers offer greater control and security over sensitive 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 that are widely used in the gaming industry.

[0231] The PGH server 703, according to an embodiment, comprises one or more processors 712 and one or more storage devices 713. The one or more processors 712 comprise a logic engine 714, a video processor 763, and a PGH publisher 733.

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

[0233] According to one embodiment, the architecture of system 700 includes a separation between the logic engine process and the video creation process. The logic engine 714 includes receiving identified events in the base game 705 to result in building blocks 716 (as shown in FIG. 7E) that are further converted into highlight attributes, such as objectives and / or constraints and / or scoring parameters in the game, and the video creation includes cutting and editing selected segments from the base game 705 and further building / reconstructing the selected segments. The highlight attributes are added and synchronized onto the selected segment videos 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 identified events 715 from the event module 705, process and analyze the identified events 715, and generate building blocks 716 using logic rules and / or mathematical formulas (e.g., aggregation functions) applied to one or more types of events. For example, in a shooter game, the identified events can consist of “kill” events in the PGH, and one of the building blocks can be the number of kills in the PGH. In this example, the identified events consist of all kill events, and the mathematical formula can be a count function over all kill events in the identified events, resulting in several kill building blocks. Another example is a shooter game in which the building blocks can consist of more than one event type, and the identified events can consist of all “jump” events and also 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 a 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 app 704 to create the PGH 738. The highlight attributes 714′ include parameters, including, for example, possible objectives, constraints, exit conditions 1224, PGH exit criteria 1222, and scoring parameters, used to play the PGH and configure the PGH rules.

[0235] In some cases, the building block 716 may be identical to the identified event 715. This means that no mathematical formulas or aggregations are 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 716 without any modifications. For example, in a racing game, one of the identified events may be "Lap Complete," which is triggered each time a player completes a lap around the race track. If no aggregation or mathematical formulas are applied to this event, the corresponding building block 716 may simply be "Lap Complete." Thus, in this case, if the identified event is "Lap Complete," the resulting building block will be identical, i.e., "Lap Complete." The logic engine 714 can then use these building blocks 716 directly, without any transformations, to generate potential objectives and / or constraints and / or scoring parameters and / or exit conditions 1224 and / or PGH exit criteria 1222 for the PGH. For example, a potential objective may simply be "Complete a Lap." Therefore, if a building block 716 is identical to an identified event 715, it means that the events are used as is without any modifications or calculations applied to them during the building block creation process. In this case, the raw events themselves serve as the building blocks for generating highlight attributes.

[0236] According to an embodiment, the building blocks 716 are used by the logic engine 714 in an intermediate step to calculate and generate PGH parameters to be included in the PGH 738 and used during play of a future generated PGH. Specifically, the building blocks 716 are used as raw materials for calculating PGH parameters including, for example, one or more of the objective, constraints, exit conditions 1224, PGH exit criteria 1222, and scoring used to play the PGH 738. The building blocks are used to generate all possible combinations (or a subset of combinations) of potential objectives, constraints, exit conditions 1224, PGH exit criteria 1222, and scoring (included in the submitted highlight attributes 714′) to be used by the PGH creator or player to generate the PGH. For example, a captured highlight from the base game may include "10 kills" of enemies within one minute, with the identified event being "kill," and building blocks 716 may be used to generate various possibilities for the objectives, constraints, exit conditions 1224, PGH exit criteria 1222, and scoring parameters based on the "10 kills" in the highlight. Thus, when the creator selects a time segment from the highlight, e.g., a 30-second segment, the objectives, constraints, exit conditions 1224, PGH exit criteria 1222, and scoring are updated accordingly. More specifically, in this example, the first 30 seconds of the highlight may include 8 of the 10 kills, and the last 30 seconds may include 2 more kills, for a total amount of 10 kills per minute. A potential initial objective for this highlight may be to kill 10 enemies within 1 minute, and after the user selects the first 30 seconds (the highlight's start time is 0 seconds and end time is 30 seconds, where 8 kills occurred in the original highlight), the potential objective is updated according to the events and building blocks of the first 30 seconds, in this example to kill 8 people, and the possible constraints, exit conditions 1224, PGH exit criteria 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 and process the video to result in a highlight video 763″ that is sent to the PGH app 704. The video processor 763 is further configured to receive selected PGH timestamps 763′ of time intervals during 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 video from the highlight video based on the timestamps 763′ to create a 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), creating a 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 attributes 735 from the PGH app 704 and the final PGH video 775 from the video processor 763 and publish the PGH 738. In some cases, the published PGH 738 may be stored in the storage 713. Publishing includes generating a digital representation of the PGH, including 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 the selected start and end points of the PGH attributes, where the PGH publisher 733 further extracts events based on the start and end points of the PGH attributes (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 may correspond to timestamps for the highlight (e.g., for a 2:00 minute highlight, the start point may be 0:12 and the end point may be 1:01, which corresponds to 0 minutes 12 seconds from the beginning of the highlight to 1 minute 1 second from the beginning of the highlight), or alternatively, the start and end points may correspond to turn numbers in a turn-based game (e.g., the start point may be at turn #34 and the end point may be turn #78).

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

[0240] Alternatively or additionally, logic engine 714 may include a data conversion module 741 configured and enabled to receive and / or extract data 7150 and convert that data into identified events 715 and / or building blocks 716. 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 logic engine 714. In some embodiments, data 7150 may be converted based on a known conversion module; for example, if data conversion module 741 receives a text description of a key moment in a game, it analyzes the text and extracts relevant events, such as player actions or changes in the game state. These extracted events are then converted into a format that is the same as / close to the identified events 715 typically generated by event module 709. Similarly, if the input data is audio commentary describing a particular gameplay sequence, data conversion module 741 processes the audio, transcribes the relevant portions, and converts that information into distinct identified events 715 that capture key aspects of the gameplay being described. By normalizing the input data into identified events 715, the data transformation module 741 allows the system to create PGH data objects 1200 and recover PGHs from a wider variety of input sources than just raw gameplay data. Another example of a known transformation module is a neural network (e.g., a deep neural network), which receives as input data 7150, which can be either one type or a combination of two or more types, and computes a representation of this (i.e., the last layer of the neural network or an aggregation function based on running the data input on a neural network function) to transform the representation into identified events 715 and / or building blocks 716 as output.

[0241] According to an embodiment, the data transformation module 741 may be located external to the logic engine (eg, in a separate external processor within the server).

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

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

[0244] The embodiment shown in Figure 7I incorporates all of the essential components and functionality shown previously in Figure 7H. However, Figure 7I presents an alternative configuration architecture in which logic engine 714 may include data transformation module 741 configured and enabled to receive and / or extract data 7150 and transform this data into identified events 715. Referring to Figure 7I, an alternative embodiment of the present invention is shown that differs from the embodiment shown in Figure 7H. In this configuration, building block 716 is omitted from the system architecture. Instead, this embodiment utilizes only identified events 715 by transforming the data into identified events 716 through intermediate processing steps.

[0245] 4. PGH App 704: According to an embodiment, the PGH app 704 is a software application configured and enabled to create a PGH game 738 based on received input including highlight attributes 714′ and highlight videos 763″, output PGH attributes 735 and PGH timestamps 763′, and further manage the PGH platform using a user interface 7360 including a feed 736 from which the PGH 738 can be discovered, played, shared, etc., for example.

[0246] The PGH app 704 includes a user interface that includes a feed 736 and a PGH builder 734. The PGH builder 734 is configured to receive a highlight video 763″ and highlight attributes 714′ that include one or more of an objective and / or zero or more constraints and / or zero or more exit conditions and / or one or more PGH exit criteria 1222 and / or one or more scoring parameters. A creator can use the highlight attributes 714′ along with the corresponding highlight video 763″ to select a subset of the timeline of the captured highlights (e.g., select a start point (e.g., a start timestamp) and an end point (e.g., an end timestamp) of the captured highlights, which may be a subset of the captured highlights). For example, for a captured highlight having a length of two minutes, the start point may be 10.5 seconds from the beginning of the highlight and the end point may be 1 minute 12.2 seconds from the beginning of the highlight to create the PGH timestamp 763′. Additionally, the creator can select objectives and / or constraints and / or scoring parameters and / or ending PGH criteria 1222 along with other PGH attributes 735 (e.g., PGH name, description, thumbnail “preview” image, tags, etc.) to create PGH attributes 735 using highlight attributes 714′ based on the creator's processed identified events and / or building blocks of the highlight's gameplay, and generate PGH attributes 735 that are specifically related to a video segment of the base game 705 (e.g., a selected starting point of a PGH based on the highlight video 763″ such that both use the same timeline of the highlight so that the creator can use the timeline of the highlight video 763″ to scroll through the video and select the exact starting point they want to select).

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

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

[0249] A "state event" is a property of an entity in the base game. An example of a "state" might be, for example, a player position, or a player's health in a computer game.

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

[0251] The identified events 715 are transmitted, for example, in real time or near real time, along with a video 717 capturing the game to one or more processors 712 within the PGH server 703. 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 and generate, for example, a preview thumbnail video and processed video including the preview video. An example of a thumbnail video is shown in FIG. 10D , which illustrates a PGH thumbnail 1050 that allows a 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] Building blocks 716 are logic rules created based on translating identified events 715 (such as state 723' and action 724' events in the base game 705) into logical phrases that can be understood by a PGH player or PGH creator.

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

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

[0255] Note that in some cases, the aggregation function may result in a building block 715 that is identical to the original identified event 715. In such cases, the aggregation function acts as a discriminant function, leaving the identified event 715 unchanged, which 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 creator) can also activate "highlight" actions associated with one or more selected scenarios of gameplay of the base game 705. The selected "highlights" along with game events are transmitted to one or more processors 712 within the PGH server 703, e.g., in real time, as the user plays the game.

[0257] Illustratively, within the context of a streamed NBA video game event, specific in-game actions and states such as "running," "passing," and "dribbling," "positioning," "weapons," etc. are identified using the event module 709. The term "highlight" may refer to a particular segment in an NBA game, lasting, for example, 20 seconds, in which a player successfully completes 20 consecutive passes without being intercepted by an opposing player.

[0258] For example, the newly created "objective" in the NBA game is "A PGH player wins a PGH when the PGH player's playerPosition is equal to the creator's playerPosition at the end of the highlight." It could be.

[0259] This "objective" relates to a newly formed rule that, for the purposes of this example, can be called an "A to B speedrun" 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): the player must travel from point A (the beginning of the PGH) to point B (the original end point of the creator's PGH) in the NBA game.

[0260] The "PGH Exit Criteria" may be, for example, a 10-second time limit, and the "Exit Condition" may be, for example, the end of the NBA game of the original game (i.e., when there is no time left in the original game timeline, e.g., when the clock in the fourth quarter of an NBA game reaches 0:00 minutes left to play).

[0261] The newly created "constraint" formula may be (as a non-limiting example) the following: In an NBA game, the constraint may be to keep the ball in the same player's hand and not allow the ball to get into the hands of other players (either from the player's team or the opposing team). This new "constraint" (which was not part of the base game) may be related to the original actions and / or states that the PGH creator took while playing the game, or to constraints that can be derived from these actions and / or states.

[0262] These objectives, constraints, exit conditions 1224 and PGH exit criteria 1222, according to an embodiment, are created based on automatically and / or autonomously identified events in the NBA base game to create the above-mentioned objectives and constraints. It should be emphasized that the new objectives and constraints were never part of the rules of the NBA base game, and they can be created based on events that occurred during gameplay of the NBA base game, for example.

[0263] Advantageously, the system architecture as presented in FIG. 7A and further in FIGS. 7B-7E and other figures of the present invention includes a streaming module and method for transmitting recorded data of game play (e.g., captured video 717) and identified events (e.g., identified events 715) using one or more game engines and processors located, for example, on a cloud server (e.g., PGH server 703). As a result, the creation of a PGH is more configurable and can be used to create a PGH for any type of game. Because the architecture, according to an embodiment, includes a streaming and transmission module, the architecture, in some embodiments, eliminates the need to maintain, 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 Figure 7B incorporates all of the essential components and functionality shown previously in Figure 7A. However, Figure 7B presents an alternative configuration architecture in which the processor 708 includes a creation input module 7080 located, for example, on the game client device 701.

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

[0266] According to an embodiment, the creation input module 7080 is configured and enabled to generate and transmit and / or extract data 7150 to the PGH server 703. The creation input module 7080 receives various types of input data from users or creators, such as text, audio recordings, video clips, and gameplay data. The creation input module processes this data and transmits it to the PGH server 703 for further analysis and possible PGH creation. In addition to processing user-provided input, the creation input module 7080 can autonomously extract data from ongoing gameplay, including events.

[0267] In one embodiment, the data 7150 generated by the creation input module 7080 is received by a logic engine 714 within the PGH server 703. In some cases, the logic engine 714 may convert the data 7150 into identified events 715 and / or building blocks, as shown in Figures 7H and 7I. This conversion process involves extracting key elements from the user-provided data and gameplay information and converting them into distinct, actionable events that can be used as the basis for PGH data objects 1200, enabling the creation and restoration of PGHs. By converting the diverse 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, manageable data format, such as the PGH data objects 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 embodiments, methods, devices, and systems are provided for creating two or more PGH computer games based on a single highlight of one or more highlights. For example, multiple start points (e.g., start timestamps) and associated multiple end points can be selected for each highlight. In some cases, a new PGH may be created based on each pair of selected start and end points.

[0270] 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 multi-player computer game, according to an embodiment. System 700 may be used to implement method 750. However, method 750 may also be implemented by systems or processors 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 captured highlight, where each PGH can be created separately and independently of one another using different PGH attributes 735. For example, if a highlight is captured during gameplay, multiple PGHs can be created from the same highlight using different independent PGH attributes 735, such as different objectives, constraints, scoring parameters, start points, and end points. For example, for a highlight captured from an NBA game, two PGHs can be created from the same highlight, with one PGH having the objective of scoring five points in the PGH and the second having the objective of passing the ball 10 times between players on the player'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, other methods may be used, such as those shown in Figures 7D, 7F, and 7G and 13, to create one or more PGHs separately for each of the captured highlights.

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

[0274] In step 751, a creator or player begins playing the base game 705. According to an embodiment, when the creator or player begins 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 begins.

[0275] Optionally, in the cloud-based architecture prior to step 751, graphical elements associated with the base game 705 are extracted and collected into a structured format. The graphical elements may be elements that describe a scene, such as meshes, textures, maps, audio effects, video snippets, etc., and the structured format may be files, file portions, JSON file format, YML file format, etc. that describe either the graphical elements themselves or a collection of graphical elements or metadata attributes of the graphical elements to be used by the game or PGH.

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

[0277] In step 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, a server device, such as PGH server 703. The data may include one or more of: text, such as text including a text description of events, a description or highlights of the base game, audio, such as video gameplay of the base game, audio including an auditory description of the base game, images, such as images including a pictorial description of the base game or highlights, and other video describing the game, e.g., other video including a visual description of the base game or a narrator's video gameplay.

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

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

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

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

[0282] According to embodiments, game data (e.g., identified events 715, which may include data for the entire game or data within a predetermined time frame of gameplay, and optionally captured video 717) may be continuously uploaded to a PGH server throughout a gameplay session, allowing a user to create a PGH based on any portion of the uploaded gameplay data without having to manually capture specific highlights during the game.

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

[0284] Alternatively or additionally, in step 754, events 715 in the base game are received and / or automatically identified by the event module 709, e.g., during game play. The identified events 715 may include, for example, "actions" performed by one or more characters in the base game, such as "run" / "jump," and / or player "states," such as attributes of the player's "health," "position," "clothing," "weapons," "items," etc.

[0285] In some cases, each "event" is numbered with an ID number and added to an "event list," as shown in Figure 9A. The event list 910 for each game includes an event name 912, an event type 914, and a value type 916. These details may be in a designated list, for example, on the game management page or in the game configuration settings, to allow for the configuration of different objectives and score parameters.

[0286] In step 755, the identified events 715 are processed to result in building blocks 716, as described above with reference to Figure 7A. According to some embodiments, the identified events 715 are processed using a logic engine 714 located on a server, such as the PGH server 703.

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

[0288] In step 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, a 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, the one or more highlights correspond to selected start and end points in a computer-based game. In some embodiments, the one or more highlights correspond to particular time intervals during gameplay in the 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" may be captured by a user by, for example, clicking a selected key or mouse button defined as a "highlight click" during gameplay. The system may capture predetermined time intervals before and after the click, e.g., 120 seconds before and 10 seconds after the click, thereby capturing a 130-second highlight. Note that each predetermined time interval (before and after the "click") is independent and may differ from one another, and that a predetermined time interval after the click is optional; for example, only the time before the click is used (e.g., a highlight may consist of, for example, 120 seconds before and 0 seconds after the click). Specifically, as shown in FIG. 10A , a text prompt 1008, related to a "highlight" herein, may present the player with "Press Alt+R to capture a playable moment," which corresponds to instructing the user to press a specific key combination using a keyword to capture a highlight. It is important to note that the system or user may capture multiple highlights during video gameplay of a base game, and each highlight may have various durations and / or other properties.

[0291] According to some embodiments, each of the captured highlights is then received by a 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 might be a 30-second interval in which the player successfully maintained a speed of 160 km / h without crashing. The player or the system can then choose to create a PGH based on this particular highlight.

[0292] In step 759, the building blocks are processed, e.g., iteratively, using, e.g., the logic engine 714, to yield highlight attributes 714' including, e.g., highlight parameters of possible / potential objectives and / or constraints and / or exit conditions 1224 and / or PGH exit criteria 1222 and / or scoring parameters associated with the captured highlight.

[0293] As described above, the building blocks are 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 the PGH. In this intermediate step, the calculated potential / possible parameters such as objectives, constraints, and scoring are used as base parameters that are further used in the following steps once the specific game intervals of the captured highlights are selected by the creator or system.

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

[0295] According to one embodiment, the highlight attributes 714' are sent from the PGH server 703 to the PGH app 704 and 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: objective 1010: "Deal 1933 damage" and "Kill 6 enemies"; constraint 1012: "Perform more than 1 reload"; score parameter 1014: "Headshot: 100 points per headshot"; possible PGH exit criteria 1222: "Time duration: 17s" (i.e., 17 seconds), where this PGH exit criteria may be 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, for example, in the case of a turn game, the start turn number (e.g., 35) may be subtracted from the end turn number (e.g., 61), resulting in 26 turns in this example, to form the PGH exit criteria.

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

[0297] According to another embodiment, two timestamps are selected for the highlight, with the first timestamp being used as the start of the PGH and the second timestamp being used as the end of the PGH. For example, the captured highlight may 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 may be a start time of -0:30 and an end time of 1:32 to generate a 62-second PGH.

[0298] In step 761, a PGH attribute 735 including one or more parameters, such as objectives and / or constraints and / or scoring and / or termination PGH criteria 1222 and / or termination conditions 1224 and / or start and / or end points, is generated based on the building blocks and / or identified events associated with the selected PGH highlight start and end points and / or timestamps. Specifically, in this step, the building blocks 716 are processed, for example, by the logic engine 714, to result in a PGH attribute 735 including one or more parameters, including, for example, objectives, constraints and scoring parameters, that match the start and end points and / or time intervals 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 creator to select and modify start and end points and / or time segment durations (e.g., based on two selected timestamps) as the basis for generating the PGH, based on which PGH attributes 735 are calculated (e.g., if a two-minute highlight was captured with 10 kills, where 9 kills were made in the first minute of the highlight and 1 more kill in the last minute, and the user selected a start point of 0:00 (the beginning of the captured highlight) and an end point of 1:00, the objective may be updated from 10 kills throughout the selected highlight to 9 kills up to the first selected minute of the highlight).

[0300] 10C, the creator can scroll the video display 1030 left and right, moving the respective timestamps 1032 and 1034 left and right to result in the final PGH video 775, and accordingly, e.g., simultaneously, the PGH attributes 735 are updated according to the selected final PGH video 775. Similarly, in a turn-based game (e.g., chess), the starting point may be, e.g., a particular turn with all of the associated events, and the ending point may be the maximum number of turns allowed (e.g., 10 turns).

[0301] An example of a PGH with newly created objectives is shown in Figure 9B and includes the following objectives:

[0302] "The player must kill the enemy without taking damage"; or "Cars can travel over 150km / h without crashing." It should be emphasized that the highlight attributes 714' or PGH attributes 735 include new objectives, constraints, scoring parameters, and exit conditions not included in the base game, and are created here for the first time according to captured "highlights" (e.g., highlight video 763") based on identified events 715 within the base game.

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

[0304] In step 764, one or more PGH computer games are created based on the PGH attributes 735, e.g., using the PGH publisher 733, where each PGH computer game includes PGH rules that are associated with the PGH attributes 735 and enable play of the one or more PGH computer games.

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

[0306] In some cases, the created PGH is configured and displayed in 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, the building blocks and / or identified events are stored in memory, for example, on the PGH server's storage device 713, 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 therefore both are stored in the server's storage.

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

[0309] Flowchart 7501 of Figure 7D incorporates all of the essential steps and functions shown previously in Figure 7C. However, Figure 7D presents an alternative configuration architecture and method in which logic engine 714 uses only identified events to generate the PGH and does not need to translate the identified events into building blocks. Thus, in this configuration, building block 716 is omitted from the system architecture as presented in Figure 7I, and therefore step 755 of Figure 7C, which involves processing identified events to result in building blocks, is not performed.

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

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

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

[0313] Thus, following step 760, in step 7610, a PGH attribute is generated that includes 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] Reference is now made to Figure 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 may be a PGH 738 created from a base game 705 as shown in Figures 7A-7D.

[0315] Figure 7E encompasses all of the components depicted in Figure 7A, while further illustrating the supplemental elements necessary to manage data transmission between system modules during gameplay of the PGH. It is emphasized that the separate diagrams for creating and playing a PGH are provided solely for the sake of simplicity and to provide a clear and concise representation of the block modules. Thus, it should be appreciated that the modules and elements depicted in Figures 7A and 7E could 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 that include an event module 709. During PGH play, the event module is configured and enabled to identify events 715 in the PGH (e.g., PGH 738) and continuously, e.g., in real time or near real time, transmit (e.g., stream) the identified events 715 to the PGH server 703. The events 715 may include, for example, the "actions" and / or "states" of characters in the PGH (e.g., as illustrated above in FIGS. 7A and 7B with respect to the creation of the PGH 738).

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

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

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

[0320] The logic engine 714 is responsible for receiving the identified events or receiving data 7150 and processing it into identified events, processing the potentially identified events into building blocks, determining whether the objectives and / or constraints and / or termination PGH criteria and / or termination conditions have been obtained based on the identified events and / or building blocks, and further calculating a score for the PGH run both during the PGH run and after the PGH run has ended.

[0321] For example, during PGH execution, logic engine 714 receives identified events and processes them to result in building block 716 of "3 kills," while the goal of PGH 738 is "5 kills." Therefore, logic engine 714 identifies that PGH is not yet finished and requires two more kills to reach the goal.

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

[0323] In operation, during PGH play, logic engine 714 continuously sends PGH status 777 to management module 778 in PGH server 703. PGH status includes one or more of objective status 12260, constraint status 12280, score status 7120 (which sums scoring parameters 1220 based on their appearance in the PGH up to the time of calculation), exit condition status 12240, and exit PGH criteria status 12220. For example, as shown in FIG. 10G, PGH status may include the status of objective 1041, constraints 1042, and 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 sending server events 779 .

[0326] The media manager 771 is configured and enabled to generate a server event 779. The server event 779 includes a PGH status and additional data on the PGH status. For example, the additional data includes multimedia elements such as text, audio, graphic elements, images, or video, or a combination of text, audio, graphic elements, images, or video, to be included in a PGH, such as a 3D graphic element, based on the identified event 715 and / or PGH status 777. For example, the multimedia elements may include 3D advertisements featuring advertising pages on buildings in the PGH game, and / or text including recommendations and advice to PGH players, and / or live audio streaming, etc., presented to a PGH player in 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, for example, in real time or near real time, including PGH status 777, such as objective status, constraint status, scoring parameters, and termination PGH criteria status, as shown in FIG. 10G.

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

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

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

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

[0332] In step 791, events 715 in the base game are automatically identified, e.g., continuously, by the event module 709, e.g., during game play. The identified events 715 may include, e.g., "actions" performed by one or more characters in the PGH, such as "run" / "jump," and / or player "states," such as attributes of the player, such as "health," "position," "clothing," "weapons," "items," etc.

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

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

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

[0336] In some cases, the identified events 715 may be sent elsewhere in 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 step 793, the identified events 715 are processed to yield building blocks 716 and to calculate scoring parameters based on the building blocks. According to an embodiment, the identified events 715 are processed using a logic engine 714 located on a server, such as the PGH server 703.

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

[0339] In step 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 termination criteria (e.g., for a 3 kill objective, 12 seconds of the 30 second PGH duration have elapsed and 1 kill out of 3 kills has been achieved).

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

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

[0342] In step 796, PGH results 7502 are calculated based on the identified events and / or building blocks and sent to the PGH app.

[0343] 7G shows a flowchart of a method 7560 for loading and running a PGH computer game, such as PGH 738 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 systems or processors having other configurations, according to an embodiment.

[0344] Method 7560 of Figure 7G incorporates all of the essential steps and functions shown previously in Figure 7F. However, Figure 7G presents an alternative configuration architecture and method in which logic engine 714 uses only identified events to load and execute (e.g., play) the PGH, without needing to translate the identified events into building blocks. Thus, in this configuration, building blocks 716 are omitted from the system architecture and method as presented in Figure 7I, and therefore step 793 of Figure 7F, which involves processing identified events to yield building blocks, is not performed.

[0345] Instead, embodiments utilize only the identified events 715 and calculate scoring parameters based on the identified events 715 .

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

[0347] Following step 792, scoring parameters are calculated based on the identified events at step 7930. Based on the identified events, it is determined whether PGH attribute parameters (e.g., objectives and / or constraints and / or exit PGH criteria and / or exit conditions) have been obtained based on the PGH rules at step 7950. At step 7970, a PGH status (e.g., scoring parameter status, objective and / or constraint status) is generated.

[0348] A PGH result 7502 is calculated based on the identified event and the PGH result is sent to the PGH app.

[0349] 7J illustrates 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 Figures 7A and 7B may not be explicitly shown in Figure 7J, it should be understood that the configuration of Figure 7J may include one or more of the elements from previous figures unless otherwise noted. Conversely, Figure 7J may include additional or alternative elements not shown in Figures 7A, 7B, 7E, 7H, and 71. The configuration shown in Figure 7J is intended to be illustrative and not limiting, and should not be construed to exclude any potential elements or configurations within the scope of the invention.

[0351] According to an embodiment, the game module 707 comprises a game client device 701. The game client device 701 allows a user to play an original game (e.g., a base game) and is used to process the original game, e.g., in real time (or near real time), using one or more processors, such as processor 712, to identify one or more events 715 in 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. A game, also referred to as an original game or base game, constitutes an actual game exemplified by genres such as shooter games, racing games, turn-based games such as chess, NBA games, etc. 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 game graphical elements and source code files associated with the game, and convert these elements into a structured format (e.g., JSON file format / YML file format). The asset publisher 711 further publishes the assets to the asset distributor 7860, as shown in FIG. 7E.

[0356] According to an embodiment, the PGH Client SDK 798 comprises an auto-synchronizer module 721 in communication with an action streamer 722 , an event state streamer 723 , a video module 706 , a PGH controller 725 and a PGH front end 726 .

[0357] The auto-synchronizer module 721 is configured and enabled to communicate with one or more game engines (e.g., Unity, Unreal Engine) to extract data from the game engine 718 (e.g., transformation data, vertex position data, material data, etc.) and send it to the action streamer 722 and state streamer 723, for example in the case of a multiplayer game. Synchronization includes factors such as player position, player health, enemy position, etc.

[0358] The action streamer 722 is configured and enabled to identify action events 724 ′ in the base game 705 and transmit 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 transmit 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, e.g., for a given player position, optionally following a discretization process, 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 transmit them to the PGH server 703. For example, the module may record frames of the game at a particular rate (e.g., 30 frames per second) to a particular file format (e.g., png file format), save the frames to a video file (and optionally compress it, for example, to an mp4 file format), and then transmit the created video file to the PGH server.

[0362] The PGH controller module 725 is configured and enabled to receive input actions (i.e., input from a player's device, such as keyboard keystrokes, mouse movements, joystick input, etc.) from the PGH player module 729 and control those base game actions while playing the PGH by passing those base game actions to be performed 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 PGH player on the base game and PGH. The received information can be categorized into three main types: 1. Pre-Game Data: Before starting the PGH, the module displays relevant data such as the PGH objectives and / or constraints and / or end-PGH criteria. For example, as shown in information 1015 in FIG. 10F, the objective status (e.g., number of kills) and the end-PGH criteria status (e.g., time limit). 2. In-Game Data: During gameplay of the PGH, the module provides real-time updates, including the PGH Status 777, thereby keeping the player informed of their progress. For example, the Objective Status 1041, Constraint Status 1042, and Score Status 7120 are shown in FIG. 10G. 3. Post-Game Data: After completing the PGH, the module presents information (e.g., PGH Results 7502) indicating whether the objectives were successfully achieved. The PGH Front 726 is not limited to these particular 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 may be, for example, a physical or cloud-based server of any suitable type including one or more processors 712 and storage devices 713 .

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

[0366] The storage device 713 may be, for example, any suitable type of volatile and / or non-volatile storage and may include, for example, a single physical memory component or multiple physical memory components. The storage device 713 may also include virtual memory. The storage device 713 may 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 may be hosted in a data center, such as a private or public data center. The PGH Server 703 receives action 724′ and state 723′ data streams from the base game 705 via a PGH Client SDK 798, which may include identified events (e.g., state and / or action events) from the base game along with video frames from a video module 706 of the base game 705, and analyzes the output data from the action streamer 722 and state streamer 723 using one or more processors to implement the services necessary to create, share, and play PGH games (e.g., single player or multiplayer).

[0368] According to an embodiment, the PGH server 703 comprises 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 events 723' from the state streamer 723, processes them, and stores them for creating and playing the PGH game. Processing the received data streams includes calculating scores and objectives while playing the PGH game.

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

[0371] The media server 728 is further configured and enabled to process the "gameplay," publish it, and store it to create a PGH game, including cutting relevant scenes and watermarking the file as needed and converting it to different media formats.

[0372] The PGH player 729 may also be used to coordinate the flow of a PGH game (e.g., single-player or multi-player). Specifically, the PGH player 729 receives a created PGH game 738 from the PGH manager 731. In operation, when a player requests to play a PGH game, the PGH player 729 sends the created PGH game 738 to be played by the PGH controller 725 using the PGH front end 726, and the PGH logic engine 714 controls the execution of the PGH game 738. The PGH logic engine 714 obtains identified events 715 from the game client device 701 and uses the identified events 715 or constructs building blocks 716 from the identified events. The PGH logic engine 714 then uses either the identified events or building blocks to calculate a score status 7120 based on the scoring parameters and sends it to the PGH rules 719 to calculate the objective status 12260, the constraint status 12280, and the exit PGH criteria status 12220 (and which of the criteria have been reached). The PGH status 777 includes the PGH score / score status 7120, the objective status 12260, the constraint status 12280, the exit PGH criteria status 12220, and the exit condition status 12240. The logic engine sends both the building blocks 716 and / or the identified events 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 between different components of the PGH server, such as the real-time sharing of base game 705 events (e.g., actions 724′ and states 723′) and captured video 717.

[0374] The PGH manager 731 is a repository, such as a centralized storage, for managing and storing PGH games and for enabling retrieval and searching 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 a rules engine configured and enabled to create and execute a PGH game in real time based on defined PGH objective(s). The generated PGH objectives may be created, for example, while playing the 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 the PGH building blocks 716 have been achieved and to calculate a score for the PGH game execution.

[0376] According to an embodiment, the PGH building blocks 716 are logic rules. The logic rules are created based on converting game events, such as state 723' and action 724' events in the base game 705, into logic phrases that can be understood by a PGH player or PGH creator. For example, in a fighting computer game, an "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 determined time frame. The logic phrases can be, for example, Boolean logic phrases as shown in FIG. 9B.

[0377] According to an embodiment, PGH app 704 is an application, such as a software application, that enables the creation of PGHs and manages a PGH platform using a system, such as system 700 or systems 720 and 730 or system 100, where PGHs can be discovered, run, shared, promoted, etc. PGH app 704 is configured to communicate with PGH server 703, launcher 702, and games 707. In some cases, users can download PGH app 704 onto their devices, such as mobile devices, to create and manage PGH games.

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

[0379] The PGH launcher module 732 is a software application designed to facilitate user interaction with and engagement within or with PGH games by providing functionality for discovery and gameplay. The PGH launcher module 732 receives as input a user request to launch a particular PGH game and sends 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 allows 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 about available PGH games from the PGH manager 731 and presents this data in a viewable feed format within the app's user interface (UI), along with links to play the PGH games within the game client device 701. This data can include information such as title, description, thumbnail image, creator name, creation date, popularity metrics (e.g., number of plays, likes, shares), and tags associated with each PGH game. In this way, players can see information and attributes about different PGH games available to play, perhaps from different base games (e.g., a feed can include PGHs created from two or more different base games). Additionally, the feed module 736 allows two or more users to search for PGH games together, for example, using the PGH manager 731, and then provide links to play them together.

[0383] 7K illustrates a detailed block diagram of a system 720 configured and enabled to create a PGH based on one or more scenarios of past gameplay for a multi-player configuration, according to an embodiment. FIG. 7K includes elements of the system 700 of FIG. 7A, as well as additional elements for a multi-player configuration system.

[0384] Figure 7K may include additional or alternative elements not shown in other figures. The configuration shown in Figure 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 invention.

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

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

[0387] The game server 765, according to an embodiment, comprises the following modules: a base game server 766, a PGH server SDK 767.

[0388] The base game server 766 is a game server that may be built by a game studio and is used to host and run a multiplayer version of the base game 705. The base game server 766 contains the game-specific logic, rules, and mechanics that define the multiplayer experience. The base game server 766 is responsible for managing the game session, processing player input, and updating the game state in real time. For example, in a multiplayer racing game, the base game server 766 handles tasks such as track selection, player positioning, collision detection, and race event triggering. 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 works in conjunction with other components of the PGH server SDK 767, such as the action streamer 768 and state streamer 769, to enable the creation and play of PGHs 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: Action Streamer 768 , State Streamer 769 , and 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 similarly to the PGH Controller 725 of the PGH Client SDK 798. To facilitate a multi-player environment, the PGH Manager 731 communicates with the PGH Controller 770 and with the opponents 762.

[0393] These modules work together to enable the creation and playback of PGHs in multiplayer games 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 process of computer-controlled opponents within a multiplayer environment. This module ensures that the opponents provide a challenging and engaging experience for players while maintaining balanced and fair gameplay. The opponent 762 module comprises a game client 701, a component that allows the opponent to seamlessly interact with the game world and other players. The game client 701 handles the opponent's rendering, input processing, and local game logic, allowing the opponent to perceive and react to the game state in real time. By incorporating the game client 701 within the opponent 762 module, the system ensures that the opponent's actions and behavior 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 input to the opponent 762 module, providing it with the information and parameters necessary to control the opponent's behavior and decision-making process. This input may include data such as player positions, game state updates, and specific instructions for the opponent's actions. In exchange, the opponent 762 module sends output back to the PGH Manager 731, informing the PGH Manager 731 of the opponent's current status, actions taken, and any relevant updates. This two-way communication channel allows for the seamless integration of opponent behavior into the overall game flow, enabling the creation of engaging and challenging PGHs in multiplayer scenarios.

[0396] In some embodiments, the opponent 762 module is located external to 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, an NPC may 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] The NPC controller module 774, according to an embodiment, is configured and enabled to interact with the PGH player in real time while playing the PGH game and to control the actions of opponents replaced by NPCs.

[0399] According to an embodiment, the NPC configuration 776 is used to configure the logic and behavior of NPCs in a particular game (e.g., the base game 705). For example, the logic and behavior may consist of rules for when and where an NPC appears in the scene and under what scenario, as well as attributes the NPC has, such as aiming accuracy, orientation ability, stealth ability, scripts, etc. The data & media bus 7300 sends information about the structure of the game, such as event types and maps, so that the NPC behavior for each game can be pre-processed according to the received data.

[0400] According to an embodiment, the system 720 further includes a PGH client 7800 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: 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 use the game engine 718 to render the next frame on the GPU of the player's own computer.

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

[0404] Game controller 787, according to an embodiment, is configured to send user input from a player's device (eg, keyboard, mouse, controller, joystick, and other equipment).

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

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

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

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

[0409] In step 784, some or all of the graphical elements are evaluated to determine if they can be broken down into smaller pieces. This involves two important checks:

[0410] In step 786, after decomposition, it is assessed whether the graphic element can be put back together such that its reassembled state is identical to, or closely resembles (within defined matching criteria) its original state before it was decomposed.

[0411] In step 788, the graphic elements are measured by comparing them to certain rules and thresholds to see if they are large enough for resolution.

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

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

[0414] Reference is now made to FIG. 8A , which illustrates a flowchart 800 of a method for creating a PGH based on one or more scenarios of past gameplay in a multi-player 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 systems or processors having other configurations. Some steps of FIG. 8A have been previously presented and described in detail, according to embodiments, in previous figures and in the associated detailed description.

[0415] The step “a. Start Game” involves initiating the PGH game creation process by sending a “launch command” from the creator 799 to the launcher module 702 .

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

[0417] Step "c.init" involves initializing and controlling the startup process by creating a handshake between the PGH client SDK 798 and the PGH server 703, on which the user is authenticated and the session is initialized.

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

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

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

[0421] Step "g. Game Actions" includes streaming / transmitting one or more actions (e.g., actions) performed by a game player character during a game (e.g., base game) to the PGH server 703. Examples of such actions include jumping, shooting, etc. of an entity in the game.

[0422] Step "h. Capture Highlights" includes activating a highlight action, for example, by selecting and capturing a "highlight" or "highlights" in the game during gameplay. Specifically, a highlight action includes selecting a scene or frame segment or interval from the game, such as 1, 2, 3, 4, 5, 10, 20 seconds, or more. In some cases, the highlight action is activated by the creator 799 pressing a specific preset key combination or key + mouse click or any other selected key combination to capture a highlight in the game (e.g., the key combination may be pressing the ALT keyboard key simultaneously with the S keyboard key, thereby making the key combination ALT+S). Examples of preset key combinations as they may be displayed to the player are shown in FIG. 10A.

[0423] The step "i. Mark Highlight" involves sending properties of the captured highlight, including characteristics such as the timestamp of the created highlight, along with the highlight's associated event, from the game 707 to the PGH server 703. An example of this step is shown in Figure 10B, which shows a particular frame of a highlight in a saved game.

[0424] Step "j. Media" involves transmitting frames, video and audio recordings of the game 707 (e.g., of the base game 705), and the game to the PGH server.

[0425] Step "k. Highlight Data" includes sending highlight data from the PGH Server 703 to the PGH App 704. The highlight data includes properties of the captured highlight (e.g., player and game state and actions), along with game frame, video, and audio recordings for a predetermined time interval prior to the selected timestamp of the highlight, and sends it to the PGH App 744.

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

[0427] Step "m. Configure" involves the selection by the creator 799 of PGH attributes of the PGH game. This creation of the PGH game involves combining and processing received data including start and end points, selected properties of the PGH (e.g., objectives, constraints, exit PGH criteria, exit conditions, and score parameters) to generate PGH attributes in the PGH server 703.

[0428] The step "n.PGH" includes sending the configured PGH game from the PGH app 704 to the PGH server 703 and creating the PGH according to the "m.Configuration step." An example of the completion of this step is shown in Figure 10E.

[0429] 8B illustrates a time flow diagram 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. In some cases, method 810 may be activated according to activation method 800. Systems 700, 710, 720, or one or more processors may be used to perform method 810. However, method 810 may also be performed by systems or processors having other configurations.

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

[0431] The step "p.URL" involves providing the player with a link to the shareable link. It should be emphasized that other methods can be used to share the PGH.

[0432] The step "q.Start PGH" involves sending a command from the player 801 to the launcher 702 to start playing the PGH, so that in the step "r.Launch", the 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 and action of an entity or game in the PGH, according to an embodiment. For example, an event (as described with reference to the previous figure) may be or include a property of an entity within and in the PGH game, along with a set of actions performed during the PGH game by a player or other game entity, such as an NPC or environmental element. Actions encompass behaviors or activities performed by a player, NPC, or environmental element during gameplay, and state may include other attributes of an entity, for example, in a shooter game, and may consist of health status, weapon status, clothing, etc. The identified events are streamed from the game module 707 to the PGH server 703, for example, in real time.

[0434] The step "t.Score" includes computing / calculating and / or processing scoring parameters of the PGH, e.g., in real time, based on one or more scoring formulas, such as predetermined scoring formulas according to embodiments of the present invention, to result in a score status 7120 (e.g., a PGH score). For example, the scoring formula may have a scoring parameter of "number of kills," where the formula is simply the actual number of kills (e.g., 10 kills results in a score of 10), or each kill may earn its score, such as 100 points per kill. The calculated PGH scores are transmitted, e.g., in real time, from the PGH server 703 to the PGH game 707, and updated accordingly in each calculation loop (e.g., each frame of the base game or every 20 milliseconds) so that each score contributes to the final cumulative score. An example of this process is shown in FIG. 10G, where the current accumulated score (e.g., Score Status / PGH Score 7120) is 4000, and, for example, each kill can add 5000 points to the accumulated score and each shot can subtract 200 points from the accumulated score, resulting in a current score of 1*5000-5*200=4000 (in this example, one kill added 3000 points and five shots each subtracted 200 points to the calculation of the current score).

[0435] The step "u.Play Results" involves sending the PGH results calculated, for example, in real time, at the end of each score calculation loop. An example of this step is shown in FIG.

[0436] 8C illustrates a flowchart of a method 820 of asset extraction and decomposition in a base game and / or PGH, such as the created PGH illustrated in FIG. 8A, according to an embodiment. In some cases, method 820 may be activated after and / or simultaneously with the execution of method 800 and / or method 810. System 700, system 710, system 720, or system 730, or one or more processors, may be used to perform method 820. However, method 820 may also be performed by systems or processors having other configurations.

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

[0438] Step "b. Extract and Decompose Assets" involves using, for example, the game's source code, files, and file structure to obtain game assets and then decompose them into smaller parts for efficient data transmission. Decomposition occurs when it is possible to reconstruct the game assets back into their original form or very close to it (up to a threshold), and when the assets have been marked as suitable for decomposition. According to an embodiment, the assets are stored in the asset repository 7910 component.

[0439] According to an embodiment, the "Publish Assets" process operates as follows.

[0440] When the server detects the player's intent to start a PGH, either by explicit initiation or using a predictive model, it sends the necessary graphical elements to the client to render the starting area of ​​the PGH. These elements include decomposed graphical 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, its distance from the player, network capacity and performance, player preferences, and other predetermined settings. This technique controls the level of detail of the game as it is rendered.

[0441] Before sending these elements, the server checks whether the client has them cached locally to avoid redundant transfers. The client then retrieves any missing elements needed for rendering, and then renders and displays the next frame to the player. In a continuous loop, the client sends its current position, viewpoint, state, and any player input back to the server. The server processes this information to determine the next set of graphical elements to send, which can be 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 to the player's position, viewpoint, state, and input.

[0443] 8D illustrates a flowchart of a method 830 for publishing assets in a base game and / or PGH, according to an embodiment. Method 830 includes publishing extracted assets, such as the assets illustrated in FIG. 8C, according to an embodiment. In some cases, method 830 may be activated after and / or simultaneously with performing method 820 and / or method 810. System 700, system 710, system 720, or system 730, or one or more processors, may be used to perform method 830. However, method 830 may also be performed by systems or processors having other configurations.

[0444] Step "c. Start Game" involves, according to an embodiment, launching the base game 705 by a player for the purpose of engaging in gameplay.

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

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

[0447] Game Mode or Difficulty: If applicable, select the desired game mode or difficulty level. 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 particular character or creating an avatar, select or customize your character before entering the game world.

[0449] Level or Map Selection: Selecting the particular level, map, or scenario the game will take place in. This is common in games with different stages or locations.

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

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

[0452] According to an embodiment, step "f. Start Game" involves launching 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. Publish Assets" involves, according to an embodiment, sending the graphical elements used to render the first frame of the game, including, for example, graphics, sounds, music, characters, textures, and code that together create the game environment and experience.

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

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

[0456] Step "j. Frame Loop" involves repeatedly updating and displaying the next image on the screen in a continuous cycle, according to an embodiment.

[0457] Step "k. (Optionally present) User Action" includes, according to an embodiment, sending the input of the player 801 if there is any input within the time period of the frame loop.

[0458] Step "l. (Optionally present) User Action" includes, according to an embodiment, sending the input of the player 801 if there is any input within the time period of the frame loop.

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

[0460] Step "n. Assets" involves using various elements to render the next frame, including graphics, sounds, music, characters, textures, and code that together create the game environment and experience, according to an embodiment.

[0461] Step "o. Render screen" includes, according to an embodiment, sending a command to the GPU of the PGH client 7800 to render the next frame according to the player's position and view frustum, and the assets available at the PGH client.

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

[0463] Reference is now made to Figure 12, which illustrates an exemplary data structure of a PGH data object 1200, according to some embodiments. The PGH data object includes one or more of metadata 1202, PGH rules 719 and scoring parameters 1220, states 723', and actions 724'. The PGH rules 719 include one or more of the following: objectives, constraints, exit PGH criteria 1222, and exit PGH conditions.

[0464] PGH rules 719 are used, which are based on objectives and / or constraints and / or termination PGH criteria 1222 and / or termination conditions. In some embodiments, the PGH rules 719 are evaluated every frame or every predetermined time interval (e.g., every 20 msec). The PGH rules consist of a formula that checks whether the PGH has ended, and if so, results in whether the PGH has ended with a win, a player loss, or some other status, and further calculates the status of the objectives and / or constraints and / or termination PGH criteria 1222 and / or termination conditions (1224). For example, the formula may check whether one of the objectives has been obtained, and if the objective has been reached, the PGH rule outputs that the PGH will end with a player win; if the constraint has been reached, the PGH rule outputs that the PGH will end with a player loss, etc.

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

[0466] Constraints 1228 are one or more conditions that, if met, will result in the player losing the PGH. An example of a possible constraint is shown in FIG. 9C , which presents a screenshot including a constraint list 930 containing constraint names 932 and expressions 934 that must be met to lose the game. Specifically, the first listed constraint name 932 is "take no damage," and the associated expression is "when PGH player's damage taken is greater than creator's damage," meaning that if 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 relate to constraints that were not included in and / or are different from the constraints of the base game.

[0467] The ending PGH condition 1224 includes one or more conditions that, if reached, ensure a player wins the PGH game, result in a player losing the PGH, or in some cases, result in the PGH game ending without a predetermined win or loss. An example of a possible ending condition 1224 is shown in FIG. 9E, which illustrates an example of an ending condition list 990.

[0468] The termination PGH criteria 1222 include one or more conditions that, if reached, ensure the player wins the PGH game, or the player loses the PGH, or in some cases the PGH ends without a predetermined win or loss of the PGH. Examples of possible termination PGH criteria 1222 are a time limit (e.g., a player has 30 seconds to reach one of the objectives), a number of turns (e.g., in a turn-based game such as a chess game, a user has 20 turns to reach one of the objectives), or a mixture of a number of turns and a 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 objectives).

[0469] Scoring parameters 1220 refer to a set of predetermined conditions or rules that determine how a player's score is calculated and updated during a PGH game. These conditions act as triggers; when a particular condition is met or reached, the player's score either increases (a positive score) or decreases (a negative score). Scores may be cumulative, meaning that each time a new condition is met, a corresponding score value is added to or subtracted from the player's current accumulated score.

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

[0471] Scores can be positive or negative, allowing for both reward and penalty scenarios: for example, a positive score may be awarded for completing a level, achieving a particular objective, reaching a particular state, or performing a particular action, while a negative score may be deducted, for example, for reaching a particular state, performing a particular action, reaching a constraint, each time a turn or time period passes, etc.

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

[0473] It is emphasized that in many cases, the PGH Rules 719 and scoring parameters are not included in the base game and / or are different from 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 actions played, the rules of the PGH, or 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 a text description when an element in the PGH is shown, for example adding the text "castle" when a picture of a castle is shown, a creator, a video - allowing the creator to add a webcam so that comments can be added in real time, tags - for example adding text with a "shoot" action, audio - allowing the creator to add for example a voice over during the PGH game, or a thumbnail.

[0476] The state 723' and actions 724' are used to create, restore, and play the PGH 738 as described above. The state 723' includes "game state," which relates to game data details such as the game's mapping, the game's starting point, and "player state," which relates to player data such as the player's position in the game, ammunition, clothing, etc. The game state may include game information that is not specifically related to player actions in the base game, such as a "bomb" that drops in the base game scenario. A "game action" may relate to a scenario in the base game, such as when a "bridge" in the game is blown up when a player crosses it, and thus this scenario may be stored and used to create the PGH.

[0477] Data relates to both players and caged and uncaged NPC players. For example, state 723' may include data information related to the state of a caged NPC player relative 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 player and / or NPC player movement actions, these movements are restored and included in the PGH.

[0478] 13 illustrates a flowchart of a method 1300 for loading and running a PGH computer game, such as PGH 738 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 systems or processors having other configurations, according to an embodiment.

[0479] In step 1310, events from the base game are restored and loaded. The restoration process, according to an embodiment, includes one or more of the steps illustrated with respect to FIG. 7F. In step 1320, the system begins play of the PGH by initializing the game engine and loading necessary resources. In step 1330, video or other signals of the base game are captured. These signals can provide information for understanding events and building blocks within the PGH. One such method 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 identified events and / or building blocks. This video analysis approach allows the system to gain insight into the gameplay elements, player actions, and game state of the PGH without relying solely on the game's internal data.

[0480] Another method for obtaining input from the PGH, according to embodiments, is through the analysis of brain signals, for example by using techniques such as neural networks. By monitoring and interpreting these physiological signals, the system can infer a player's intentions, emotions, and reactions during gameplay, as well as infer gameplay elements, player actions, and game states. This information can be used to extract identified events and / or building blocks, and can be combined with video analysis or used alone.

[0481] In step 1340, the captured video or other signal is transmitted (e.g., streamed) to a server, such as a PGH server, which allows for centralized processing and analysis of the captured data.

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

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

[0484] Methods according to embodiments may be performed by a client device, such as game client device 701, that executes a game based on the methods and data described herein above.

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

[0486] In this patent application, it is essential to clarify that the various embodiments and elements depicted in the drawings have relationships or equivalences with one another and that the nomenclature may potentially differ. Furthermore, some elements present in one embodiment may not be present in another embodiment solely for purposes of clarity and simplicity. It should be understood that such omissions do not invalidate the scope or essence of the present invention. For example, the PDS server 195 may be equivalent to the PGH server 703, and the processing circuit 110A and the processing circuit 110B may be equivalent to the game client device 701 and / or the launcher module 702 and the PGH app 704.

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

[0488] According to some embodiments, the present disclosure provides a computerized control system programmed to implement methods of the present disclosure, such as methods 750, 7500, 7501, 7560, and 1300. FIG. 14 illustrates 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 questions and answers, responses, statistical analysis, etc. The computer system 1401 can be a user's electronic device or a computer system located remotely relative to the electronic device. The electronic device can be a mobile electronic device.

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

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

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

[0492] The storage unit 1415 may store files such as drivers, libraries, and saved programs. The storage unit 1415 may store user data, such as user preferences and user programs. The computer system 1401 may optionally include one or more additional data storage units external to the computer system 1401, such as located on a remote server in communication with the computer system 1401 via an intranet or the Internet.

[0493] Computer system 1401 can communicate with one or more remote computer systems via network 1430. For example, computer system 1401 can communicate with a user's (e.g., a parent's) remote computer system. 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), phones, smartphones (e.g., Apple® iPhone®, Android®-enabled devices, Blackberry®), personal digital assistants, wearable medical devices (e.g., Fitbits), or medical device monitors (e.g., seizure monitors). A user can access computer system 1401 using network 1430.

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

[0495] The code may be pre-compiled and configured for use on a machine, which may have a processor adapted to execute the code, or may be compiled during run-time. The code may be provided in a programming language that may be selected to allow 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 gaming client device 701, can be embodied in programming. Various aspects of the present technology can be considered a "product" or "article of manufacture," typically 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 storage unit, such as memory (e.g., read-only memory, random-access memory, flash memory) or a hard disk. A "storage" type medium can include any or all of the tangible memory of a computer, processor, or the like, or associated modules, such as various semiconductor memories, tape drives, disk drives, etc., which can provide non-transitory storage for software programming at any time. All or portions of the software may sometimes be communicated via the Internet or various other telecommunications networks. Such communication can, for example, enable loading of the software from one computer or processor to another, for example, from an administrative server or host computer to the computer platform of an application server. Thus, other types of media that may carry software elements include light waves, radio waves, and electromagnetic waves, such as those used across physical interfaces between local devices, through wired and optical terrestrial networks, and over various air links. Physical elements that carry such waves, such as wired or wireless links, optical links, etc., may also be considered software-bearing media. As used herein, unless limited to non-transitory, tangible "storage" media, terms such as computer or machine "readable medium" refer to any medium that participates in providing instructions to a processor for execution.

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

[0498] The computer system 1401 may include or communicate with an electronic display 1435 that includes a user interface (UI) 1440 for providing, for example, questions and answers, analysis results, and 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 may be implemented by one or more algorithms and by instructions provided using one or more processors as disclosed herein. The algorithms may be implemented by software when executed by the central processing unit 1405. The algorithms may be, for example, random forests, graphical models, support vector machines, or others.

[0500] The above steps illustrate an example system method, but one skilled in the art will recognize many variations based on the teachings provided herein. These steps may be completed in a different order. Steps may be added or removed. Some of the steps may include substeps. Many of the steps may be repeated as often as is beneficial to the platform.

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

[0502] While the detailed description contains many details, these should not be construed as limiting the scope of the disclosure, but merely as illustrating different examples and aspects of the disclosure. It should be understood that the scope of the disclosure includes other embodiments not discussed in detail above. Various other modifications, changes, and variations, which will be apparent to those skilled in the art, can be made in the arrangement, operation, and details of the methods and apparatus of the disclosure provided herein without departing from the spirit and scope of the invention as described herein.

[0503] While preferred embodiments of the present disclosure have been shown and described herein, it will be apparent to those skilled in the art that such embodiments are provided by way of example only. Numerous variations, changes, and substitutions will be apparent to those skilled in the art without departing from the scope of the present disclosure. It is understood that various alternatives 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 solely by the scope of the appended claims and their equivalents.

[0504] While a particular element is shown in one or more figures, it is understood that not all elements may be included in every figure. The figures are intended to be illustrative and not limiting, and elements from one figure may or may not be present in another figure. However, it should be understood that the invention is not limited to the particular elements or configurations shown in the figures, and that additional or alternative elements and configurations may be included within the scope of the invention.

[0505] It is to be understood that the present invention is not limited in its application to the details set forth in the description contained herein or illustrated in the drawings. The present invention is capable of other embodiments and of being practiced and carried out in various ways. Accordingly, it is to be understood that the phraseology and terminology used herein is for the purpose of description and should not be regarded as limiting. Those skilled in the art will therefore appreciate that the conception underlying the present disclosure may readily be utilized as a basis for the designing of other structures, methods, and systems for carrying out some of the purposes of the subject matter of the present disclosure.

[0506] It will also be appreciated that the system according to the present invention may be implemented, at least in part, on a suitably programmed computer. Likewise, the present invention contemplates a computer program readable by a computer for carrying out 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 to carry out the method of the present invention.

[0507] Unless otherwise indicated, and as will be apparent from the description that follows, throughout this specification, descriptions utilizing terms such as "processing," "computing," "comparing," "determining," "calculating," "receiving," "providing," "obtaining," "detecting," and the like, are understood to refer to computer actions and / or processes that manipulate and / or transform data into other data, said data being represented as physical quantities such as electrons and / or said data representing physical objects. The term "computer" should be interpreted broadly to encompass any type of hardware-based electronic device having data processing capabilities, including, by way of non-limiting examples, the processors, mitigation units, and inspection units disclosed in this application.

[0508] Although various features of the present invention have been described in terms of specific embodiments, it is contemplated that those skilled in the art may mix and match the features in other embodiments not shown in the figures.

[0509] It is to be understood that the phraseology or terminology used herein is for the purpose of description and not of limitation, and that the means, materials, and steps for carrying out various disclosed functions may take a variety of alternative forms without departing from the invention.

[0510] Those skilled in the art will readily appreciate that various modifications and changes can be made to the embodiments of the invention described above without departing from the scope of the invention as defined in 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 November 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 herein incorporated by reference to the same extent as if each individual publication, patent, or patent application was specifically and individually indicated to be incorporated by reference.

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 video 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 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 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, 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; loading and executing said one or more PGH computer games; said loading and executing Reconstructing the events associated with the computer-based game; continuously identifying said events in said 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 yield the building blocks; continuously processing the building blocks using the logic engine to determine if PGH attribute parameters have been obtained based on the PGH rules; ending said play of said one or more PGH computer games when said PGH attribute parameters have been obtained; 11. A computer-implemented method comprising:

2. generating a PGH status for each of the one or more PGH computer games, wherein the PGH status comprises: calculating one or more of a scoring parameter, a status of the objective, 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 1 , comprising:

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

4. calculating a PGH outcome for each of the one or more PGH computer games based on the event; 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 3 , comprising:

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

6. The processing comprises: Converting the one or more of text, audio, images, video recordings of the computer-based game, and other videos into the event. The computer-implemented method of claim 1 , comprising:

7. 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:

8. 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:

9. transmitting video of the computer-based game captured by a video module within 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 the 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:

10. creating one or more additional PGH computer games from said one or more PGH computer games; The computer-implemented method of claim 1 , comprising:

11. 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:

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

13. 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.

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

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

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

17. 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).

18. 10. 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.

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

20. loading and executing the one or more PGH computer games, wherein the loading and executing includes: recovering the events from the computer-based game; capturing a video or other signal of said computer-based game; transmitting the captured video or other signal to the server; and 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 the PGH rules and the analyzed video or analyzed signal; calculating said scoring parameters; The computer-implemented method of claim 1 , comprising:

21. 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 video 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 produce 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 one of 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; loading and executing said one or more PGH computer games; said loading and executing Reconstructing the events associated with the computer-based game; continuously identifying said events in said 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 yield building blocks; continuously processing the building blocks using the logic engine to determine if PGH attribute parameters have been obtained based on the PGH rules; ending said play of said one or more PGH computer games when said PGH attribute parameters have been obtained; 11. A computer-implemented method comprising:

22. generating a PGH status for each of the one or more PGH computer games, wherein said generating a PGH status comprises: calculating one or more of a scoring parameter, a status of the objective, 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 22. The computer-implemented method of claim 21, comprising:

23. sending the server event from the PGH server to the game client device; displaying the server events on a display; 23. The computer-implemented method of claim 22, comprising:

24. 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; 23. The computer-implemented method of claim 22, comprising:

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

26. 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.

22. The computer-implemented method of claim 21, comprising:

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

28. transmitting video of the computer-based game captured by a video module within 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 the 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; 22. The computer-implemented method of claim 21, comprising:

29. creating one or more additional PGH computer games from said one or more PGH computer games; 22. The computer-implemented method of claim 21, comprising:

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

31. 22. The computer-implemented method of claim 21, wherein the identified events include actions or states of characters in the computer-based game.

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

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

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

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

36. 32. The computer-implemented method of claim 31, wherein the character is a player character (PC) or a non-player character (NPC).

37. 22. The computer-implemented method of claim 21, 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.

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

39. loading and executing the one or more PGH computer games, wherein the loading and executing includes: recovering events from said computer-based game; capturing a video or other signal of said computer-based game; transmitting the captured video or other signal to the server; and 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 the PGH rules and the analyzed video or analyzed signal; calculating said scoring parameters; 22. The computer-implemented method of claim 21, comprising:

40. 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, comprising: Reconstructing events associated with the computer-based game; continuously identifying said events in said one or more PGH computer games; continuously streaming the identified events from the game client device to a logic engine; continuously processing the identified events using the logic engine to yield building blocks; continuously processing the building blocks using the logic engine to determine whether PGH attribute parameters, which are parameters of PGH attributes 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 PGH computer games, have been obtained based on PGH rules for configuring play of the one or more PGH computer games; ending play of the one or more PGH computer games when the PGH attribute parameters are obtained; A method comprising:

41. generating a PGH status for each of the one or more PGH computer games, wherein said generating a PGH status comprises: Calculating one or more of scoring parameters, objective status, constraint status, and PGH termination criteria status; sending the 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 41. The method of claim 40, comprising:

42. sending the server event from a PGH server to the game client device; displaying the server events on a display; 42. The method of claim 41, comprising:

43. 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; 43. The method of claim 42, comprising:

44. 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; 41. The method of claim 40, comprising:

45. creating one or more additional PGH computer games from said one or more PGH computer games; 41. The method of claim 40, comprising:

46. 41. The method of claim 40, wherein the identified event comprises an action or state of a character in the computer-based game.

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

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

49. 41. The method of claim 40, wherein PGH attributes are selected by a creator of the PGH computer game or automatically by the logic engine.

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

51. 42. The method of claim 41, 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.

52. 41. The method of claim 40, wherein the game client device is included in a server.

53. loading and executing the one or more PGH computer games, wherein the loading and executing includes: recovering the events from the computer-based game; capturing a video or other signal of said computer-based game; transmitting the captured video or other signal to a server; processing the captured video using a video analysis processor or processing the 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 analyzed signal; Calculating the scoring parameters 41. The method of claim 40, comprising:

54. 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 a 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 produce the event; processing the events to yield building blocks or processing the data to yield 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 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 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, 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 game client device configured and enabled to the one or more processors: further configured and enabled to load and execute the one or more PGH computer games, said loading and executing comprising: Reconstructing the events associated with the computer-based game; continuously identifying said events in said 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 yield the building blocks; continuously processing the building blocks using the logic engine to determine if PGH attribute parameters have been obtained based on the PGH rules; ending said play of said one or more PGH computer games when said PGH attribute parameters have been obtained; Including, the system.

55. the one or more processors: 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 objective, a status of the constraints, a status of the PGH termination criteria; sending the 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; 55. The system of claim 54, comprising:

56. the one or more processors: recovering the events from the computer-based game; capturing a video or other signal of said computer-based 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 the PGH attribute parameters have been obtained based on the PGH rules and the analyzed video or analyzed signal; calculating said scoring parameters; 55. The system of claim 54, further configured and enabled to:

57. 1. A non-transitory computer-readable medium containing 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 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 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, 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; loading and executing said one or more PGH computer games; said loading and executing Reconstructing the events associated with the computer-based game; continuously identifying said events in said 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 yield the building blocks; continuously processing the building blocks using the logic engine to determine if PGH attribute parameters have been obtained based on the PGH rules; ending said play of said one or more PGH computer games when said PGH attribute parameters have been obtained; A non-transitory computer-readable medium for performing a method comprising:

Images