JP7817711B2 - Method and system for creating a game, method for executing a game, and non-transitory computer-readable medium - Google Patents

Description

The subject matter of this disclosure relates to electronic games, and more particularly to implementing a system for creating and playing new games.

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.

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 the data to result in 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 end point in the computer-based game; and capturing the building blocks by the logic engine to result in highlight attribute parameters. processing, 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, 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, and the selected start point and end point; and creating the one or more PGH computer games based on the PGH attributes, wherein each of the PGH computer games includes PGH rules, the PGH rules being associated with the PGH attributes and for configuring play of the one or more PGH computer games.

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

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 exit criteria status; transmitting 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.

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.

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.

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

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.

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.

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

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

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

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

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

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

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

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

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.

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

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

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

In one embodiment, loading and running the one or more PGH computer games includes recovering events from a base game, capturing video or other signals of the base game, transmitting the captured video or other signals to a server, processing the video using a video analysis processor or processing the 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.

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 yield 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 yield highlight attribute parameters, the highlight attribute parameters the PGH attributes 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.

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

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 exit criteria status; transmitting 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.

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.

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, transmitting the PGH results to a PGH application (PGH app), and displaying the server events on a display of the game client device.

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.

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.

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.

In one embodiment, the method includes transmitting video of a computer-based game captured by a video module in the game client device to a server, transmitting the one or more highlights from the server to a PGH application (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.

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

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

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

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

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

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

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.

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

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

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

In one embodiment, the method includes loading and executing the one or more PGH computer games, where the loading and executing includes recovering events from a base game, capturing video or other signals of the base game, transmitting the captured video or other signals to a server, processing the video using a video analysis processor or processing the 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.

According to a third aspect of the present invention, there is provided a method executed by a game client device for loading and executing one or more playable 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 the identified events (e.g., continuously) using the logic engine to yield building blocks; processing the building blocks (e.g., continuously) using the logic engine to determine whether PGH attribute parameters have been obtained based on PGH rules; and terminating play of the one or more PGH computer games when PGH attribute parameters have been obtained.

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 exit criteria status; transmitting 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.

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.

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, transmitting the PGH results to a PGH application (PGH app), and displaying the server events on a display of the game client device.

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.

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

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

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

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

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

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.

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

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

In one embodiment, loading and executing the one or more PGH computer games includes recovering 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.

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 having a processing circuit with one or more processors, the one or more processors including an event module configured to communicate with a PGH server; the PGH server having a storage unit for storing the PGH computer game; and one or more server processors, the server processor including 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, and other video describing the base game; processing the data to result in events; processing the events to result in building blocks, or processing the events to result in building blocks; and 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 termination criteria, a possible termination 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 the one or more highlights; and selecting the selected PGH highlight to generate PGH attributes. A system is provided, comprising a game client device configured and enabled to: process, for example, iteratively, the building blocks associated with a light by the logic engine, where the PGH attributes include one or more of an objective, constraints, PGH termination criteria, termination conditions, and scoring parameters; and create the one or more PGH computer games based on the PGH attributes, where each of the PGH computer games includes PGH rules, the PGH rules being related to the PGH attributes and for configuring play of the one or more PGH computer games.

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.

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; transmitting 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.

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.

According to a fifth aspect of the present invention, there is provided a non-transitory computer-readable medium including program instructions for creating one or more playable 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 yield building blocks, or process data with the logic engine to yield 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 yield highlight attribute parameters, wherein the highlights the PGH 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.

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

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. FIG. 1B is a logical block diagram of an exemplary gaming system that supports the creation of a PGH that allows a player to re-experience past gameplay scenarios, according to some embodiments of the present invention. FIG. 1C is a logical block diagram of an exemplary gaming system that supports PGH playback, allowing players to re-experience past gameplay scenarios, in accordance with some embodiments of the present invention. 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. FIG. 3 is a flow diagram of an exemplary method for creating a PGH that allows a player to re-experience a past gameplay scenario, according to some embodiments of the present invention. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. FIG. 7D is a flowchart of a method for creating a PGH based on one or more scenarios of past gameplay, including receiving identified events or processing data to result in identified events, according to an embodiment. 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. 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. 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. 7H illustrates a detailed block diagram illustration of the processor of FIG. 7A, according to an embodiment. 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. 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. 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. 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. FIG. 7M is a flowchart of a method for asset extraction and decomposition, according to an embodiment. 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. 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. 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. FIG. 8D is a flowchart of a method for publishing assets in a base game and/or PGH, according to an embodiment. FIG. 9A illustrates an example of an event list, according to an embodiment. FIG. 9B illustrates an example of a target list, according to an embodiment. FIG. 9C illustrates an example of a constraint list, according to an embodiment. FIG. 9D illustrates an example of a score parameter list, according to an embodiment. FIG. 9E illustrates an example of an exit condition list, according to an embodiment. FIG. 10A illustrates example screenshots of a game and a PGH, according to an embodiment. FIG. 10B illustrates example screenshots of a game and a PGH, according to an embodiment. FIG. 10C illustrates example screenshots of a game and a PGH, according to an embodiment. FIG. 10D illustrates example screenshots of a game and a PGH, according to an embodiment. FIG. 10E illustrates example screenshots of a game and a PGH, according to an embodiment. FIG. 10F illustrates example screenshots of a game and a PGH, according to an embodiment. FIG. 10G illustrates example screenshots of a game and a PGH, according to an embodiment. FIG. 11 illustrates example screenshots of a game and PGH including objectives and PGH outcome status, according to an embodiment. FIG. 12 is a diagram illustrating an exemplary data structure of a PGH data object, according to some embodiments. FIG. 13 is a flowchart of a method for loading and running a PGH computer game, according to an embodiment. FIG. 14 illustrates a computer system suitable for integration with methods, systems, and devices according to embodiments.

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.

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.

As used herein, like letters refer to like elements.

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 created PGH primarily relates to the objects in the original game. For example, if the computer-based game is an NBA or racing computer game, the original and the PGH will share some characters, since both share the NBA and racing game titles and include characters such as basketball players and racing cars, respectively. However, the generated PGH includes 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.

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

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.

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 into, for example, building blocks or any type of data, for example by analyzing events within the game, and creating a new game (e.g., a PGH) whose rules and gameplay differ from those of the original game based on identifying various events.

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," for example, by selecting a specific snapshot of the original game state at a selected starting point in the original game and identifying triggers to in-game events. Mini-games are generated using scripts based on the snapshots and triggers, extracting limited sections of the game to provide shorter, self-contained experiences.

Another key difference between the present invention and the prior art is the intended player experience. PGHs generated by this method aim 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.

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 expand the original gameplay, while the prior art condenses games into bite-sized experiences.

Thus, while prior art computer game rules, such as mini-game rules, are equivalent to the rules of the base game, the rules of a 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 match. 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.

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

Embodiments of the presently disclosed subject matter are not described with reference to any particular programming language. It will be appreciated that a variety of programming languages may be used to implement the teachings of the presently disclosed subject matter as described herein.

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 them to "relive" these sequences based on these game sequences. These PGHs can then be shared, for example, on social media, and may achieve viral popularity of their own.

Some embodiments of the subject matter of this disclosure provide systems and methods that allow 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."

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 according to 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 enhances 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, PGHs help studios increase user lifetime value by facilitating in-game discovery and encouraging players to explore more items, levels, characters, and DLC.

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

Before proceeding with a detailed description of the present invention, it may be useful to provide definitions of certain terms that will be used below.

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

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

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.

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 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, physics properties, behavior scripts, interaction capabilities, and gameplay-specific characteristics.

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.

The terms "Playable Gameplay Highlight (PGH)" or "PGH" or "PGH (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 (e.g., objectives and/or constraints and/or exit conditions and/or PGH exit criteria) along with scoring parameters that were not part of the rules of the base game.

As used herein and throughout the specification and claims, the terms "original game" or "game" or "base game" or "computer game" or "computer-based game" 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.

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.

The term "player" as used throughout this specification and the claims should be understood to include users who play the base game or PGH.

The term "Highlight" or "Highlights," as used herein and throughout the specification and claims, should be understood to encompass a selected timestamp or time interval 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.

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" might be, for example, a player's position or the health of a player in a computer game.

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.

The terms "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.

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

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.

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.

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.

The terms "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.

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.

As used herein and throughout the specification and claims, "Score" or "Scores" or "Scoring Parameter" or "Scoring Parameters" or "Score Parameters" should be understood to encompass a list of conditions that, if reached, will result in a player receiving a score. Scores may be 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 Figure 9D.

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. An example of a possible end condition is shown in Figure 9E.

The terms "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, result in the PGH ending without a predetermined win or loss. 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 combination 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).

The terms "PGH building blocks" or "building block" or "building block" or "data building block" as used herein and throughout the specification and claims should be understood to encompass expressions 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."

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

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) delivered continuously, one or more packets at a time, and typically intended for immediate processing or playback.

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.

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

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

The terms "graphic element" or "graphic elements" or "graphic assets" or "assets" as used throughout this specification and the 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 metalness maps, roughness maps, and irradiance 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 interactions; 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.

Attention is now directed to FIG. 6, which illustrates a flowchart 600 of an exemplary sequence by which a user plays a game, creates a derivative PGH, and shares it with other users, in accordance with some embodiments of the subject matter described herein.

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

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 + g). Note that, in some embodiments, the initial user may alternatively utilize some type of suitable 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.

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

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, and can involve intermediate entities, etc.

In another embodiment, the entire game data is constantly uploaded to the PGH server during gameplay, allowing the user to select specific highlights and later turn them into PGHs.

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 (e.g., a 45-second gameplay sequence from a 15-minute game session) to be included in the PGH. 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 protagonist to a particular point on the game terrain, etc.).

The server may then create a data object that enables the play of the PGH (650) and make this data object available to other users. As a non-limiting example, the server may 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.

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 with the PGH.

According to another embodiment, as shown in detail in FIGS. 7A-7F and 8A-8D, a secondary user can click on a link, such as a PGH link, which loads the 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 a PGH on top of the base game.

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 the following:

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 in the PGH play as in the original game, based on the data contained in the PGH data object.

ii) Recreating event-triggered reactions 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 it, 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.

iii) Caged/Uncaged NPCs: For robust PGH behavior, it may be desirable for NPCs in the PGH to repeat all or some of their behavior in the original game for a specific duration of the PGH, and then behave according to their NPC characteristics after that time. NPCs on a 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."

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.

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.

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

In some embodiments, caged/uncaged NPCs are not the only ones 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 makes different choices, the initial user and gameplay will behave differently (a specific example is caged/uncaged NPCs).

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 allows a gamer to play a PGH based on a past gameplay scenario, in accordance with some embodiments of the subject matter of this disclosure.

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

A gaming system 100A capable of creating a PGH may include a processing circuit 110A, which may include a processor 120A and memory 130A.

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

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.

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.

Storage 160 may be any suitable type of volatile or non-volatile storage, such as a hard disk, solid state drive, etc.

The processing circuitry 110A may 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 may include, for example, a gaming engine 150, a tracker module 105, and game-specific logic 140.

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

- 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 virtual objects, and managing virtual objects.

The gaming engine 150 may be, for example, a commercial gaming engine such as Unreal (trademark) or Unity (trademark).

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

The gaming engine 150 may implement changes to the game state in response to, for example:

Pseudo-randomly generated events, such as enemies appearing pseudo-randomly 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.

The 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 the gaming engine 150 and peripherals such as the game display/audio system 180 and the game controller 170. The game-specific logic 140 may interact with the gaming engine 150 via an API.

In some examples, the game-specific logic 140 initially provisions the gaming engine 150 with an initial game scenario. As a non-limiting example, in a racing game, the game-specific logic 140 may initially provision the 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. The game-specific logic 140 may perform the provisioning of the initial game scenario via an API of the gaming engine 150.

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:

a) data read by the game-specific logic 140 from the gaming engine 150 that describes the current properties of virtual objects and 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 the virtual objects and the associated game state programmed for a particular game.

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

The tracker module 105 can write tracking data into, for example, the following two groupings:

a) a grouping containing data describing initialization data; and b) a grouping containing data describing subsequent changes to virtual objects and game state events.

Data describing subsequent changes to virtual objects and game state events may include data (e.g., timestamps) indicating when the changes occurred in the game.

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

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.

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.

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.

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.

The processing circuitry 110B may 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 may include, for example, a PGH creation module 145 and regamification logic 135.

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 FIG. 3. An exemplary format of a PGH data segment is shown below with reference to FIG. 4.

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

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

In some embodiments, the PGH creation module 145 may 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 placed 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.

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.

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

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

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

This data can describe the virtual object sufficiently to allow the replayer to configure the virtual object with the appropriate time offset into the gaming engine.

As a non-limiting example, while processing the uploaded tracking data 155, 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. As a more specific example, in some embodiments, the PGH creation module 145 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.

In some embodiments, the PGH creation module 145 may further write data to the PGH indicating event-based modifications. For example, the PGH creation module 145 may write data indicating one or more virtual objects to be added to the game, or one or more changes to already defined virtual objects in response to specific events that trigger the game (e.g., in response to actions by the protagonist). Data indicating these virtual objects may be a derivative of the uploaded tracking data 155 and may be written to the PGH data segment 115 in a tracking data format or a different data format.

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

As a non-limiting example, while processing the uploaded tracking data 155, the PGH creation module 145 can evaluate which virtual object initializations and modifications are due to the protagonist's actions or due to other game events, and which virtual object initializations and modifications are spontaneous, i.e., not due to the causal sequence of other virtual objects. As a more specific example, in some embodiments, the PGH creation module 145 can examine tracking data from the uploaded tracking data 155 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.

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

In some embodiments, the PGH creation module 145 may 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).

The virtual object release criterion is an event whereby, upon the occurrence of the event, the replayer ceases 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 may be a time offset into the PGH.

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 the road, and the unmirrored behavior may be for the car to accelerate around that particular turn.

Attention is now directed to FIG. 1B, which is a block diagram of a variation of a system for creating a PGH data segment (PDS), in accordance with some embodiments of the subject matter of this disclosure. In FIG. 1B, the PGH creation functionality is divided between a PGH creation module 145A (located within a tracker module of gaming system 100A) and a PGH creation module 145B (located within a PDS server). Here, the PGH creation modules may be divided in any suitable manner. For example, in some embodiments, PGH creation module 145A may prepare time-based and event-based modification data, and PGH creation module 145B may continue to receive user-selected scoring parameters and prepare regamification data.

Attention is now directed to FIG. 1C, which is a block diagram of an exemplary gaming system that supports playing a PGH utilizing PGH data segments (PDS) based on past gameplay scenarios, in accordance with some embodiments of the subject matter of this disclosure.

A PGH player utilizing system 100B of FIG. 1C can download PGH segments 165, for example, from PDS server 195. PDS replay module 185 can then provide a PGH utilizing PGH segments 165. A detailed description of an exemplary method for providing a PGH from PGH segments 165 is provided below with reference to FIG. 4.

Attention is now directed to FIG. 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 FIG. 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; these still frames may be images that were included in the uploaded tracking data 155 (after being placed in the tracking data 125 by the tracker module 105) and subsequently extracted by the PDS server 195.

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.

Attention is now directed to Figure 3, which illustrates a flow diagram 300 of an exemplary method for creating a PGH data segment, in accordance with some embodiments of the subject matter of this disclosure.

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

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

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

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

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

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 game termination, such as the number of enemies killed.

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

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.

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.

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

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

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

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

The processing circuitry 110B (e.g., PGH creation module 145) of the PDS server 195 can make the PDS 115 available for access (e.g., download) to allow others to play the PGH.

Attention is now directed to Figure 4, which illustrates an exemplary data structure of a PGH data segment, in accordance with some embodiments of the subject matter of this disclosure.

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 supporting PGH play should instantiate at the start of the PGH.

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

Each new 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 a time offset in the PGH (as indicated by the associated time descriptor).

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 the associated time descriptor).

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

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 gaming system enabled for PGH play should apply to the corresponding already-instantiated virtual object in response to an event in the PGH (as indicated by an associated event descriptor).

The PGH data segment 400 may include regamification data 440, which may include game-ending criteria 445A and scoring parameters 445B. The game-ending criteria 445A may include data indicating when a gaming system supporting 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 may include data indicating what a gaming system supporting PGH play should track and display as a measure of success in the PGH (e.g., number of enemies killed, protagonist strength, etc.).

Attention is now directed to Figures 5A-5E, which illustrate a flow diagram 500 of an exemplary method for providing a PGH from PGH data segments, in accordance with some embodiments of the subject matter of this disclosure.

The methods shown in Figures 5A-5E can be performed, for example, by a gaming system 100B that supports PGH play, or by the systems shown in Figures 7C, 7D, and 7E.

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

The processing circuit 110A (e.g., the PDS replay module 185) can then control the gaming engine 150 to instantiate the initial virtual object shown in the PDS 165.

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

The processing circuit 110A (e.g., the PDS replay module 185) can initiate play of the PGH (540), for example, by appropriately controlling the gaming engine 150.

After a certain time interval, processing circuit 110A (e.g., PDS replay module 185) can 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) can 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).

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.

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

More specifically, in such an embodiment, processing circuit 110A (e.g., PDS replay module 185) only evaluates 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.

Processing circuitry 110A (e.g., PDS replay module 185) can continuously evaluate whether new game events occurring during the PGH match event descriptors in the event-based data of PDS 165 (570). If a match is found, processing circuitry 110A (e.g., PDS replay module 185) can 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 of PDS 165 (580).

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

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

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.

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

1. Game Client Device 701
2. Launcher Module 702
3. PGH server 703
4. PGH App 704

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, e.g., in real time (or near real time), to identify one or more "events" within the original game.

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

The game client device 701 may be any type of device, such as a smartphone, personal computer (PC), virtual reality (VR) device/glasses, tablet, smartwatch, etc.

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 PGHs based on or in connection with one or more scenarios of past gameplay of the original game.

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.

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 a PGH (e.g., when playing a PGH) and continuously stream the identified events 715 to the PGH server 703, e.g., in real time. The events 715 may include, for example, the "actions" and/or "states" of characters in the base game 705.

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 therein, 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 video or video segments).

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.

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.

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.

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 needed for game development, testing, and deployment.

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

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

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.

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

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 formulas (e.g., aggregation functions) applied to one or more types of events. For example, in a shooter game, the identified events may consist of "kill" events in the PGH, and one of the building blocks may be the number of kills in the PGH. In this example, the identified events may consist of all kill events, and the formula may be a count function over all kill events within the identified events, resulting in several kill building blocks. Another example is a shooter game in which building blocks may consist of more than one event type, and the identified events may consist of all "jump" events, and also all "kill" events. A possible building block in this game may be an "air kill," which means killing an enemy in the game while the user is jumping. In this case, the building block verifies whether a kill was made by the player while the player was jumping. Based on the building block 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.

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 transformation, 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 event is used as is without any modifications or calculations applied to it during the building block creation process. In this case, the raw event itself serves as the building block for generating the highlight attributes.

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 the 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, to be 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 might be to kill 10 enemies within one 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.

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 wishes 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; 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.

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 to publish the PGH 738. In some cases, the published PGH 738 may be stored in storage 713. Publishing includes generating a digital representation of the PGH, including a PGH data object 1200, as shown in FIG. 12, for example. 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 be relative 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).

Figure 7H shows a detailed block diagram illustration of the processor 712 of Figure 7A, according to an embodiment. As described above, in some cases, the logic engine 714 is configured and enabled to receive and/or extract identified events 715, for example from the event module 705, process and analyze the 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.

Alternatively or additionally, the 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 the logic engine 714. In some embodiments, the data 7150 may be converted based on a known conversion module; for example, if the data conversion module 741 receives a text description of a key moment in the 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 the event module 709. Similarly, if the input data is audio commentary describing a particular gameplay sequence, the 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 simply 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.

According to an embodiment, the data conversion module 741 may be located outside the logic engine (e.g., in a separate external processor within the server).

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.

According to some embodiments, the PGH logic engine 714 uses building blocks 716 to calculate a PGH score 7120 based on scoring parameters, feeds them to PGH rules 719, and calculates a PGH status 777, including an objective status 12260, a constraint status 12280, and an ending 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, ending PGH criteria 1222, and ending conditions 1224.

The embodiment shown in FIG. 7I incorporates all of the essential components and functionality shown previously in FIG. 7H. However, FIG. 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 FIG. 7I, an alternative embodiment of the present invention is shown that differs from the embodiment shown in FIG. 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.

4. PGH App 704:
According to an embodiment, the PGH app 704 is a software application configured and enabled to create PGH games 738 based on received inputs 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 PGHs 738 can be discovered, played, shared, etc., for example.

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 a 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 specifically related to a video segment of the base game 705 (e.g., a selected starting point for 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).

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) and sends them 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.

For example, the base game 705 may be a 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."

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

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.

The identified events 715 are transmitted, e.g., in real time or near real time, along with the 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. Within 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.

Building blocks 716 are logic rules created based on converting 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.

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.

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

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. This means that the resulting building block is equivalent to the original event recorded in the game.

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

Illustratively, within the context of a streamed NBA video game event, specific in-game actions and states such as "running," "passing," "dribbling," "positioning," and "weapons" are identified using the event module 709. The term "highlight" may, for example, 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.

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

This "objective" relates to a newly formed rule that, for the purposes of this example, can be called an "A to B speed run" in relation to the base NBA game. According to this "objective," the player now has a new objective that was not one of the objectives in 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.

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

The newly created "constraint" expression 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 prevent the ball from going 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 taken by the PGH creator while playing the game, or to constraints that can be derived from these actions and/or states.

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 these new objectives and constraints were never part of the rules of the NBA base game, and that they can be created based on events that occurred during gameplay of the NBA base game, for example.

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 gameplay (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, PGH creation is more configurable and can be used to create PGHs 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.

The block diagram shown in FIG. 7B incorporates all of the essential components and functionality shown previously in FIG. 7A. However, FIG. 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.

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

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.

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 FIGS. 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 PGH creation and PGH reconstruction. 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, e.g., PGH data objects 1200.

According to embodiments, methods, devices, and systems 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 one or more PGH games each created from a base game. The PGH rules and attributes of each of the one or more PGHs are different from one another. The additional PGH computer games can be created as exemplified by the present invention.

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.

Figure 7C shows a flowchart of a method 750 for generating a PGH based on one or more captured scenarios of past gameplay (e.g., "highlights") of a single-player or multiplayer computer game, according to an embodiment. System 700 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.

According to an embodiment, as shown in flowchart 750, one or more PGHs may be created separately for each captured highlight, with each PGH created separately and independently of the others using different PGH attributes 735. For example, if a highlight is captured during gameplay, multiple PGHs may be created from the same highlight using 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 may 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 may be created using PGH attributes 735 with a start time of 0:05 and an end time of 0:35, and a second PGH may be created using PGH attributes 735 with a start time of 1:10 and an end time of 1:58.

In some embodiments, one or more PGHs can be created separately for each captured highlight using other methods, such as those shown in Figures 7D, 7F, 7G, and 13.

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 FIG. 8C. "Assets" refer to the various elements that make up the game environment, such as graphics, 3D models, textures, sound effects, music, animations, etc. These assets are the essential building blocks used by game developers to create the visual, auditory (and optionally sensory) experience within the game.

In step 751, the 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 instructing 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.

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.

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

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, or a server device, such as PGH server 703. The data may include one or more of the following: 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 narrated video gameplay of the base game.

In step 753, the data is transmitted to a logic engine, such as logic engine 714, included in a processor located on the server, for example, for continuous streaming.

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.

According to one embodiment, data (e.g., identified events 715) is continuously transmitted (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.

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.

According to an embodiment, 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) can be continuously uploaded to the PGH server throughout a gameplay session. This allows 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.

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

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 gameplay. The identified events 715 may include, for example, "actions" performed by one or more characters in the base game, such as "running"/"jumping," and/or player "states," such as attributes of the player, such as their "health," "position," "clothing," "weapons," "items," etc.

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

In step 755, the identified events 715 are processed to yield building blocks 716, as described above with reference to FIG. 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.

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

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 transmitted, 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 transmitted from the video processor 763 to the PGH builder 734.

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

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 the base game, and each highlight may have various durations and/or other properties.

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.

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.

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 have been selected by the creator or system.

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.

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, possible attributes may be displayed during PGH creation, 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"; and possible PGH end criteria 1222: "Time duration: 17s" (i.e., 17 seconds), where this PGH end 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 end criteria.

In step 760, a PGH highlight start point and an end point are selected in the captured highlight to generate highlight attributes 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 and end points 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 a termination (e.g., end) point within the game sequence are selected.

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.

In step 761, PGH attributes 735 are generated, including one or more parameters such as objectives, constraints, scoring, and/or termination PGH criteria 1222 and/or termination conditions 1224 and/or start and/or end points, 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 yield PGH attributes 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.

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, with 9 kills in the first minute of the highlight and 1 additional 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).

As shown in FIG. 10C, the creator can scroll the video display 1030 left or right, moving the respective timestamps 1032 and 1034 left or 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).

An example of a PGH containing newly created objectives is shown in Figure 9B, which includes the following objectives:

"The player must kill the enemy without taking damage"; or "The car must travel over 150 km/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.

Optionally, in step 763, PGH start and end points (e.g., timestamp 763' and/or start and end points) for the PGH highlight are selected, and 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.

In step 764, one or more PGH computer games are created based on the PGH attributes 735, e.g., using a 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.

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 the embodiment.

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 game client device 701.

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.

Figure 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 multiplayer 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.

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

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

Specifically, referring to Figure 7D, the following alternative steps of the present invention are shown, which differ from the flowchart shown in Figure 7C:

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.

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

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

Figure 7E encompasses all of the components depicted in Figure 7A, while further illustrating the supplementary 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 the 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.

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 transmit (e.g., stream) the identified events 715 to the PGH server 703 on an ongoing basis, e.g., in real time or near real time. The events 715 may include, for example, the "actions" and/or "states" of characters in the PGH (e.g., as illustrated above in Figures 7A and 7B with respect to the creation of PGH 738).

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

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

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 termination PGH criteria and/or termination 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 termination PGH criteria and/or termination conditions.

The logic engine 714 is responsible for receiving the identified events or receiving data 7150 and processing it into identified events, processing 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 execution both during the execution of the PGH and after the PGH execution has ended.

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 the PGH is not yet finished and requires two more kills to reach its goal.

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

In operation, while a PGH is playing, the logic engine 714 continuously sends PGH status 777 to the management module 778 in the PGH server 703. The PGH status includes one or more of the objective status 12260, constraint status 12280, score status 7120 (which sums the scoring parameters 1220 based on their appearance in the PGH up to the time of the calculation), exit condition status 12240, and end PGH criteria status 12220. For example, as shown in FIG. 10G, the PGH status may include the status of the objective 1041, constraints 1042, and score status 7120.

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

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

The media manager 771 is configured and enabled to generate server events 779. The server events 779 include the 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 the PGH, such as 3D graphic elements, 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 containing recommendations and advice for the PGH player, and/or live audio streaming, etc., presented to the PGH player within the PGH game while the user is playing the PGH game.

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

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 the storage device 713 and later transmitted to the PGH app. The PGH results 7502 include final PGH results (e.g., the final PGH status 777 calculated at the end of the PGH).

Figure 7F shows a flowchart of a method 7500 for loading and running a PGH computer game, such as PGH 738 created in Figure 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.

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 gameplay to resume from the PGH start point (on the base game) so that players can seamlessly begin playing the PGH from a selected start point, ensuring continuity and preserving the game experience.

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

In step 791, events 715 in the base game are automatically identified by the event module 709, e.g., continuously, e.g., during gameplay. The identified events 715 may include, for example, "actions" performed by one or more characters in the PGH, such as "running"/"jumping," and/or player "states," such as attributes of the player, such as their "health," "position," "clothing," "weapons," "items," etc.

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 (process 7900) is a one-time process for the restoration process only. Process 791 is an ongoing process in which events are identified throughout the game and continuously transmitted (e.g., streamed) for processing.

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

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.

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.

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.

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

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 of 3 kills has been achieved).

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.

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

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

Figure 7G shows a flowchart of a method 7560 for loading and running a PGH computer game, such as PGH 738 created in Figure 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.

Method 7560 of FIG. 7G incorporates all of the essential steps and functions shown previously in FIG. 7F. However, FIG. 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 having to convert the identified events into building blocks. Thus, in this configuration, building blocks 716 are omitted from the system architecture and method as presented in FIG. 7I, and therefore step 793 of FIG. 7F, which involves processing identified events to yield building blocks, is not performed.

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

Specifically, referring to Figure 7G, the following alternative steps of the present invention are shown, which differ from the flowchart shown in Figure 7F:

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

PGH results 7502 are calculated based on the identified events and the PGH results are sent to the PGH app.

Figure 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 Figure 7J provides a detailed description of the system 700 shown in Figure 7A and the system 7000 of Figure 7B.

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 7I. The configuration shown in Figure 7J is intended to be illustrative, not limiting, and should not be construed as excluding any potential elements or configurations within the scope of the present invention.

According to an embodiment, the game module 707 comprises a game client device 701. The game client device 701 enables 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 within the base game 705.

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.

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

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

The asset publisher 711 is configured and enabled to obtain the base game 705, collect in-game elements, such as game graphic 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.

According to an embodiment, the PGH client SDK 798 includes 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.

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.

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.

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

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.

According to an embodiment, the video module 706 is configured and enabled to record frames of the base game 705 and/or 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 mp4 file format), and then transmit the created video file to the PGH server.

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.

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. Received information can be categorized into three main types: 1. Pre-Game Data: Before starting a PGH, the module displays relevant data, such as the PGH's objectives and/or constraints and/or end-PGH criteria. For example, objective status (e.g., number of kills) and end-PGH criteria status (e.g., time limit), as shown in information 1015 of FIG. 10F. 2. In-Game Data: During gameplay of a PGH, the module provides real-time updates, including PGH Status 777, thereby keeping the player informed of their progress. For example, Objective Status 1041, Constraint Status 1042, and Score Status 7120 are shown in FIG. 10G. 3. Post-Game Data: After completing a 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 a variety of other information to the player/creator, such as data received from server events 779 (e.g., media generated using 771).

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.

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 within a multi-core processor, etc. A processor may also be comprised of, for example, multiple processors, multiple ASICs, virtual processors, combinations thereof, etc.

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. Storage device 713 may also include virtual memory. Storage device 713 may be configured to store, for example, various data used in operations.

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 the 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 the base game's video module 706, 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).

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

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.

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.

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

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, the PGH Player 729 sends the created PGH game 738 to be played by the PGH Controller 725 using the PGH Front 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, constraint status 12280, and ending PGH criteria status 12220 (and which of the criteria have been reached). The PGH status 777 includes the PGH score/score status 7120, objective status 12260, constraint status 12280, ending PGH criteria status 12220, and ending condition status 12240. The logic engine sends both the building blocks 716 and/or identified events and the PGH status 777 to the management module 778.

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.

The PGH manager 731 is a repository such as centralized storage for managing and storing PGH games and enabling retrieval and search of PGH games.

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

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 may 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 may be, for example, Boolean logic phrases, such as those shown in FIG. 9B.

According to an embodiment, the 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. The PGH app 704 is configured to communicate with the PGH server 703, the launcher 702, and the games 707. In some cases, users can download the PGH app 704 onto their devices, such as mobile devices, to create and manage PGH games.

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.

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.

The PGH Builder Module 734 is an editor module that enables the creation of PGH games.

The game logic configuration module 7130 allows the creator to configure PGH attributes 735.

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 PGHs within the game client device 701. This data may 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, a player can see information and attributes about different PGH games available to play, perhaps from different base games (e.g., a feed may include PGHs created from two or more different base games). Additionally, the feed module 736 allows two or more users to search for PGHs together, for example, using the PGH manager 731, and then provide links to play them together.

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

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

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

Game server 765:
In some computer games (typically multiplayer games), a game server, such as 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.

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

The base game server 766 is a game server that may be built by a game studio and is used to host and run the multiplayer version of the base game 705. The base game server 766 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.

The PGH Server SDK 767 is used to integrate PGH functionality into a multiplayer game's game server 765 and may include the following modules: Action Streamer 768, State Streamer 769, and PGH Controller 770.

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 in the PGH client SDK 798.

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 in the PGH Client SDK 798.

PGH Controller 770: This module receives input actions from the PGH Player module 729 and controls the basic game actions while playing the PGH. This module functions similarly to the PGH Controller 725 of the PGH Client SDK 798. To facilitate a multiplayer environment, the PGH Manager 731 communicates with the PGH Controller 770 and with the opponents 762.

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.

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

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

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

According to an embodiment, the system 720 further includes non-player character (NPC) control 772. In this scenario, for example, NPCs may replace real user opponents in a multiplayer game. The NPC control 772 includes an NPC controller module 774 and an NPC configuration module 776.

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.

NPC Configuration 776, according to an embodiment, is used to configure the logic and behavior of NPCs in a particular game (e.g., Base Game 705). For example, the logic and behavior may consist of rules for when and where NPCs appear in the scene and under what scenarios, as well as attributes that NPCs have, such as aiming accuracy, orientation ability, stealth ability, scripts, etc. Data & Media Bus 7300 transmits 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.

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.

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.

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

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

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

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.

Figure 7L illustrates a subset block diagram 730 of the system 720 of Figure 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 shows a flowchart of a method 780 for asset extraction and decomposition, according to an embodiment.

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. The specific graphical elements are specified above.

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

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

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

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

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

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 multiplayer or single-player configuration, according to an embodiment. System 700, 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 in FIG. 8A have been previously presented and described in detail according to embodiments in previous figures and in the associated detailed description.

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.

Step "b. Launch" includes initiating 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.

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.

Step "d. Session" involves 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).

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.

Step "f. Game State" includes streaming/transmitting one or more characteristic state events of 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.

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.

Step "h. Capture Highlight" involves activating a highlight action, for example, by selecting and capturing a "highlight" or "highlights" within the game during gameplay. Specifically, a highlight action involves selecting a scene or frame segment or interval within the game, such as 1, 2, 3, 4, 5, 10, 20 seconds, or more, from the game. 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 within the game (e.g., the key combination may be pressing the ALT keyboard key simultaneously with the S keyboard key, thereby creating an ALT + S key combination). An example of a preset key combination as it may be displayed to the player is shown in FIG. 10A.

Step "i. Mark Highlight" involves sending the captured highlight's properties, 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.

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

Step "k. Highlight Data" involves 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 from a predetermined time interval prior to the selected timestamp of the highlight, and sends it to the PGH app 744.

Step "l. Screen" involves 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.

Step "m. Configuration" involves the selection by the creator 799 of PGH attributes for 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, end PGH criteria, exit conditions, and score parameters), to generate PGH attributes within the PGH server 703.

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 "m. Configuration Step." An example of the completion of this step is shown in Figure 10E.

FIG. 8B shows 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.

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 FIG. 8A. In some cases, the PGHs may be displayed in the PGH app 704.

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.

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

Step "s. State + Action" involves identifying events, such as state and actions, of entities or games 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 the player or other game entities, such as NPCs or environmental elements. 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.

The process "t.Score" involves computing/calculating and/or processing scoring parameters for 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 provide a score status 7120 (e.g., 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 score is 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 current score calculation).

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

FIG. 8C illustrates a flowchart of a method 820 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. In some cases, method 820 may be activated after and/or simultaneously with the execution of methods 800 and/or 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.

Step "a. Upload" involves the game developer importing the executable files and/or source code of the game developer's 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.

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 a form very close to it (up to a threshold), and when the assets are marked as suitable for decomposition. According to an embodiment, the assets are stored in the asset repository 7910 component.

According to an embodiment, the "Asset Publication" process operates as follows:

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 approach controls the level of detail of the game as it is rendered.

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

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.

Figure 8D shows 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 shown in Figure 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.

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

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

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

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 specific challenge modes.

Character or Avatar Selection: If the game involves playing as a specific character or creating an avatar, select or customize your character before entering the game world.

Level or Map Selection: Select the specific level, map, or scenario in which the game will take place. This is common in games with different stages or locations.

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

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

In one 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.

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, which together create the game environment and experience.

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's environment and experience.

Step "i. Render Screen" involves, 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.

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

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

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

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.

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.

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.

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

Reference is now made to FIG. 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.

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 at a predetermined time interval (e.g., every 20 msec). The PGH rules consist of an expression that checks whether the PGH has ended, and if so, whether the PGH 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 expression may check whether one of the objectives has been obtained; 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.

Objective 1226 is one or more goals that a PGH player must achieve in the PGH game to ensure victory in the PGH. An example of a possible objective is shown in FIG. 9B, which presents a screenshot including an objective list 920 containing 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 highlight," meaning that the player's objective must be to make the same number of kills as the creator. The objective may relate to goals that were not included in and/or are different from the base game's objectives.

Constraints 1228 are one or more conditions that, if met, will cause the player to lose 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 in order for the game to be lost. 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 base game's constraints.

The end 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 PGH win or loss. An example of a possible end condition 1224 is shown in FIG. 9E, which illustrates an example end condition list 990.

The termination PGH criteria 1222 include one or more conditions that, if reached, ensure the player wins the PGH game, result in the player losing the PGH, or in some cases, result in the PGH ending without a predetermined win or loss. Examples of possible termination PGH criteria 1222 are a time limit (e.g., the 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, the user has 20 turns to reach one of the objectives), or a combination 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).

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 (positive score) or decreases (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.

Put 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 gameplay. These rules may be predetermined, for example, and the player's score is continuously updated by adding or subtracting points when different conditions are met.

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, passing a turn or time period, etc.

Specific score parameters and their associated point values may vary depending on the game. FIG. 9D shows an example 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," with this scoring defined as negative; for example, using an ability may result in a deduction of 100 points each time the ability is used, as shown in FIG. 10D under score parameters (in the illustrated example, this is marked as -100 points).

It is emphasized that in many cases, PGH Rules 719 and scoring parameters are not included in the base game and/or differ from the scoring or rules that were included in the base game.

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, metadata is not directly related to the actions played, the rules of the PGH, or gameplay.

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; an author; a video - allowing the author to add a webcam so that comments can be added in real time; tags - for example adding text with the "shoot" action; an audio - allowing the author to add, for example, a voiceover during the PGH game; or a thumbnail.

State 723' and actions 724' are used to create, restore, and play PGH 738 as described above. 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, and clothing. 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. "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; thus, this scenario may be stored and used to create a PGH.

Data relates to both the player and caged and uncaged NPC players. For example, state 723' may include data information relating 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.

Figure 13 shows a flowchart of a method 1300 for loading and running a PGH computer game, such as PGH 738 created in Figures 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.

At 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. At step 1320, the system begins play of the PGH by initializing the game engine and loading necessary resources. At step 1330, video or other signals of the base game are captured. These signals can provide information for understanding the events and building blocks within the PGH. One such method involves analyzing video frames of the PGH using techniques such as neural networks. By processing and understanding the visual content and context of each frame, the system can identify and extract identified events and/or building blocks. This video analysis 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.

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

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

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. Video analytics processors apply computer vision techniques, machine learning algorithms, and other related methods, including neural network methods, to understand video content and context and extract events and/or building blocks. Similarly, signal analytics processors use signal processing techniques, pattern recognition, and machine learning methods, including neural networks, to interpret brain signals and extract identified events and/or building blocks.

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 server events are provided based on the PGH status and/or the identified events, as described with reference to the previous figures. In step 1390, the server events are sent from the PGH server to the game client module. In step 1395, PGH results are calculated based on the identified events, and the PGH results are sent, for example, to a PGH app.

Methods according to embodiments may be performed by a client device, such as a game client device 701, that executes a game based on the methods and data described above in this specification.

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

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 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 invention. For example, PDS server 195 may be equivalent to PGH server 703, and processing circuit 110A and processing circuit 110B may be equivalent to game client device 701 and/or launcher module 702 and PGH app 704.

According to some embodiments, one or more processors, such as processor 708 and/or processor 712, may be and/or may be included in processing circuitry 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 circuitry.

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.

The computer system 1401 includes a central processing unit (CPU, herein referred to as "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 operate as clients or servers, with the aid of computer system 1401.

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 memory 1410. The instructions may be directed to CPU 1405, which may then program or otherwise configure CPU 1405 to implement the methods of the present disclosure. Examples of operations performed by CPU 1405 may include fetch, decode, execute, and writeback.

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

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

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.

The methods described herein may be implemented by machine (e.g., a computer processor) executable code stored in an electronic storage location of 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. In use, the code may be executed by processor 1405. In some cases, the code may be retrieved from storage unit 1415 and stored in memory 1410 for easy access by processor 1405. In some circumstances, electronic storage unit 1415 may be omitted, and machine-executable instructions may be stored in memory 1410.

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 can be selected to allow the code to be executed in a pre-compiled or as-compiled manner.

Aspects of the systems and methods provided herein, such as the game client device 701, may be embodied in programming. Various aspects of the present technology may be considered "products" or "articles 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 may be stored in an electronic storage unit, such as memory (e.g., read-only memory, random-access memory, flash memory) or a hard disk. "Storage"-type media may include tangible memory of a computer, processor, or the like, or any or all of associated modules, such as various semiconductor memories, tape drives, disk drives, etc., which may 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 may, for example, enable loading of the software from one computer or processor to another, such as 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, terms such as computer or machine "readable medium" refer to any medium that participates in providing instructions to a processor for execution, unless limited to non-transitory, tangible "storage" media.

Accordingly, machine-readable media such as computer-executable code can take many forms, including, but not limited to, tangible storage media, carrier wave media, or physical transmission media. Non-volatile storage media include 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, floppy disks, flexible disks, hard disks, magnetic tape, any other magnetic media, CD-ROMs, DVDs or DVD-ROMs, any other optical media, punched card paper tape, any other physical storage media with patterns of holes, RAM, ROM, PROMs and EPROMs, FLASH-EPROMs, any other memory chips or cartridges, carrier waves carrying data or instructions, cables or links carrying such carrier waves, 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.

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.

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.

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.

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.

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

While preferred embodiments of the present disclosure have been shown and described herein, it will be obvious 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 to be 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 only by the scope of the appended claims, along with the scope of equivalents thereto.

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 specific elements or configurations shown in the figures, and that additional or alternative elements and configurations may be included within the scope of the invention.

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

It will also be understood that a system according to the present invention may be implemented, at least in part, on a suitably programmed computer. Similarly, the present invention contemplates a computer program readable by a computer for performing 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 perform the method of the present invention.

Unless otherwise indicated, and as will become apparent from the following description, 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, where said data is represented as a physical quantity such as electrons and/or where said data represents a physical object. 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 example, the processors, mitigation units, and inspection units disclosed in this application.

While various features of the present invention have been described in terms of specific embodiments, those skilled in the art will appreciate that they may be mixed and matched with other embodiments not shown in the figures.

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

Those skilled in the art will readily appreciate that various modifications and variations 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.

CROSS-REFERENCE This application claims priority to U.S. Patent Application Publication No. 18/660,841, filed May 10, 2024, and 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, and entitled "USER-GENERATED REPLAYABLE GAMING CONTENT UTILIZING REGAMIFICATION DATA," each of which is incorporated herein by reference in its entirety.

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 (57)

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: 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;
10. The computer-implemented method of claim 1 , comprising: generating, comprising: providing a server event based on one or more of the PGH status, the building blocks. sending the server event from the server to the game client device;
and displaying the server events on a display. 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);
and displaying the server events on a display of the game client device . The computer-implemented method of claim 1 , comprising: selecting the one or more highlights by clicking one or more keys during gameplay of the computer-based game. The processing comprises:
The computer-implemented method of claim 1 , comprising: converting the one or more of text, audio, images, video recordings of the computer-based game, and other videos into the events. 10. The computer-implemented method of claim 1, comprising: 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. said selecting a PGH highlight;
The computer-implemented method of claim 1 , comprising: selecting a timestamp start point and selecting a timestamp end point in the computer-based game. 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;
and 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: creating one or more additional PGH computer games from the one or more PGH computer games. The computer-implemented method of claim 1 , comprising: creating two or more PGH computer games based on a single highlight of the one or more highlights. The computer-implemented method of claim 1, wherein the event includes an action or state of a character in the computer-based game. The computer-implemented method of claim 1, wherein each of the building blocks is formed by aggregating one or more of the events. 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. The computer-implemented method of claim 1, wherein the PGH attributes are selected by a creator of the PGH computer game or automatically selected by the logic engine. PGH attribute is
The computer-implemented method of claim 1 , further comprising one or more of a PGH name, a description, a thumbnail "preview" image of the PGH computer game, and tags. The computer-implemented method of claim 1, wherein the characters in the computer-based game are player characters (PCs) or non-player characters (NPCs). The computer-implemented method of claim 1, wherein the objectives, constraints, PGH termination criteria, termination conditions, or scoring parameters are created using generative artificial intelligence (AI) algorithms and models. The computer-implemented method of claim 1, wherein a game client device is included in the server. 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;
and calculating the scoring parameter. 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: 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;
22. The computer-implemented method of claim 21 , comprising: generating, comprising: providing a server event based on one or more of the PGH status, the building blocks. sending the server event from the PGH server to the game client device;
and displaying the server events on a display. 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);
and displaying the server events on a display of the game client device. 22. The computer-implemented method of claim 21 , comprising 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 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. said selecting a PGH highlight;
22. The computer-implemented method of claim 21 , comprising: selecting a timestamp start point and selecting a timestamp end point in the computer-based game. 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;
and 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: creating one or more additional PGH computer games from the one or more PGH computer games. 23. The computer-implemented method of claim 22 , comprising: creating two or more PGH computer games based on a single highlight of the one or more highlights. 22. The computer-implemented method of claim 21 , wherein the identified events include actions or states of characters in the computer-based game. 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. The computer-implemented method of claim 32 , wherein an aggregation function combines the one or more events of the same type or different types. 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. PGH attribute is
22. The computer-implemented method of claim 21 , further comprising one or more of a PGH name, a description, a thumbnail "preview" image of the PGH computer game, and tags. 32. The computer-implemented method of claim 31 , wherein the character is a player character (PC) or a non-player character (NPC). 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. 22. The computer-implemented method of claim 21 , wherein a game client device is included in the server. 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;
and calculating the scoring parameter. 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;
and ending play of the one or more PGH computer games when the PGH attribute parameters have been obtained. 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;
41. The method of claim 40 , comprising: generating, including providing a server event based on one or more of the PGH status, the building blocks. sending the server event from a PGH server to the game client device;
and displaying the server events on a display. 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);
and displaying the server events on a display of the game client device. 41. The method of claim 40 , comprising 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: creating one or more additional PGH computer games from the one or more PGH computer games. 41. The method of claim 40 , wherein the identified event comprises an action or state of a character in the computer-based game. 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. The method of claim 47 , wherein an aggregation function combines the one or more events of the same type or different types. 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. PGH attribute is
50. The method of claim 49 , further comprising one or more of: a PGH name, a description, a thumbnail "preview" image of the PGH computer game, and tags. 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. 41. The method of claim 40 , wherein the game client device is included in a server. 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;
and calculating a scoring parameter. 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 ;
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. 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;
and providing a server event based on one or more of the PGH status, the building block. 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;
55. The system of claim 54 , further configured and enabled to: 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: