CN120001047A

CN120001047A - User-generated replayable game content leveraging regamification data

Info

Publication number: CN120001047A
Application number: CN202411628769.8A
Authority: CN
Inventors: 阿萨夫·加齐特; 奥代德·莱文杰; 约阿夫·皮普克维奇; 齐夫·莱文
Original assignee: Ludeo Co
Current assignee: Ludeo Co
Priority date: 2023-11-14
Filing date: 2024-11-14
Publication date: 2025-05-16
Also published as: JP2025080783A

Abstract

The present application relates to user-generated re-playable game content utilizing re-gamification data. A method includes receiving data related to a computer base game using a logic engine, processing the data generating events, processing the events or data generating building blocks by the logic engine, capturing one or more highlights in the computer base game, wherein each captured highlight corresponds to a selected starting point and ending point in the computer base game, processing the building blocks by the logic engine to generate a highlight attribute parameter, selecting a PGH highlight in each of the highlights, wherein the PGH highlight corresponds to the selected starting point and ending point in one of the highlights, repeatedly processing the building blocks related to the selected PGH highlights by the logic engine to generate PGH attributes, and creating one or more PGH computer games based on the PGH attributes, wherein each of the PGH computer games includes PGH rules that are related to the PGH attributes and are used to configure play of the one or more PGH computer games.

Description

User-generated re-playable game content utilizing re-gamified data

Cross reference

The present application claims priority from U.S. application Ser. No. 18/660,841, entitled "USER-GENERATED REPLAYABLE GAMING CONTENT UTILIZING REGAMIFICATION DATA", filed on 5 months 10 of 2024, which claims priority from U.S. provisional application Ser. No. 63/598,654, filed on 11 months 14 of 2023, entitled "USER-GENERATED REPLAYABLE GAMING CONTENT UTILIZING REGAMIFICATION DATA", each of which is incorporated herein by reference in its entirety.

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

Technical Field

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

Background

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

Summary of The Invention

According to a first aspect of the present invention there is provided a computer implemented method for creating one or more Playable game play highlights (Playable GAMEPLAY HIGHLIGHTS, PGH) from a computer base game, the method comprising receiving data relating to the computer base game using a logic engine, wherein the data comprises one or more of an event, text, audio, image, video recording, other video describing the computer base game of the computer base game, and wherein the logic engine is included in a processor located in a server, processing the data to generate the event, and processing the event by the logic engine to generate a building base block, or processing the data by the logic engine to generate a building base block, capturing one or more highlights in the computer base game, wherein each of the one or more highlights corresponds to a selected starting point and ending point in the computer base game, processing the building base game by the logic engine to generate the building base block, processing the one or more highlights by the logic engine to a selected one or more pgbase parameters, and a selected one or more PGH-score may be generated by a selected one or more pgpoint, respectively, and a h-score may be generated by a selected one or more pgpoint-or more pgf the h-score may be generated by the logic engine, the PGH attributes including one or more of a goal, a constraint, a PGH ending criteria, an ending condition and a scoring parameter, the selected starting point and ending point, and creating the one or more PGH computer games based on the PGH attributes, wherein each of the PGH computer games includes a PGH rule associated with the PGH attributes and used to configure play of the one or more PGH computer games.

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

In an embodiment, the method includes generating a PGH status for each of the one or more PGH computer games, wherein the generating the PGH status includes calculating one or more of a scoring parameter, a status of a goal, a status of a constraint, a status of a PGH ending standard, and transmitting the PGH status to a management module included in the server, and providing a server event based on one or more of the PGH status, the building blocks.

In an 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 an embodiment, the method includes calculating a PGH result for each of the one or more PGH computer games based on the event, transmitting the PGH result to a PGH application, and displaying the server event on a display of the game client device.

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

In an embodiment, the method includes converting one or more of text, audio, images, video recordings of a base game, other videos into an event.

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

In an embodiment, the method includes selecting a timestamp starting point and selecting a timestamp ending point in the computer base game.

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

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

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

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

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

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

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

In an embodiment, the PGH attributes further comprise one or more of a name, description of the PGH, a thumbnail "preview" image of the PGH computer game, and a label.

In an embodiment, the character is a Player Character (PC) or a non-player character (NPC).

In an embodiment, a generative Artificial Intelligence (AI) algorithm and model are used to create a target or constraint or PGH ending standard or ending condition or scoring parameter.

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

In an embodiment, loading and running the one or more PGH computer games includes recovering an event from the 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 analytics processor or processing the signals using a signal analytics processor, determining whether PGH attribute parameters were 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 game play highlights (PGH) computer games from a computer base game, the method comprising receiving data relating to the computer base game using a logic engine, wherein the data comprises one or more of an event, text, audio, image, video recording, other video describing the computer base game of the base game, and wherein the logic engine is included in a processor located in a server; processing data using the logic engine to generate events, capturing one or more highlights in the computer base game, wherein each of the one or more highlights corresponds to a selected starting point and ending point in the computer base game, processing events by the logic engine to generate a highlight attribute parameter comprising one or more of a possible target, a possible constraint, a possible PGH ending criterion, a possible ending condition, and a possible scoring parameter associated with each of the one or more highlights, respectively, processing the events by the logic engine to generate PGH attributes comprising one or more of a target, a constraint, a PGH ending criterion, a possible ending condition, and a possible scoring parameter associated with each of the one or more highlights, selecting a PGH in each of the one or more highlights, wherein the PGH highlights correspond to a selected starting point and ending point in one of the one or more highlights, processing the events associated with the selected PGH by the logic engine to generate PGH attributes comprising one or more of a target, a constraint, a PGH ending criterion, a PGH ending condition, and a scoring parameter, creating a PGH game based on one or more of the PGH game rules, the PGH rules are associated with the PGH attributes and are used to configure play of the one or more PGH computer games.

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

In an 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 an embodiment, the method includes calculating a PGH result for each of the one or more PGH computer games based on the identified event, transmitting the PGH result to a PGH application (PGH App), and displaying the server event on a display of the game client device.

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

In an embodiment, the method includes selecting a PGH highlight includes selecting a timestamp starting point and selecting a timestamp ending point in the computer base game.

In an embodiment, the method includes transmitting video of a computer base game captured by a video module in the game client device to a server, transmitting the one or more highlights from the server to a PGH application (PGH App), editing the video based on the selected PGH timestamp 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 an embodiment, the identified event comprises an action or state of a character in the computer base game.

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

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

In an embodiment, the method includes loading and running the one or more PGH computer games, the loading and running including recovering an event from the 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 analytics processor or processing the signals using a signal analytics processor, determining whether PGH attribute parameters are 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 performed by a game client device for loading and running one or more playable game play highlights (PGHs) created based on a computer base game, the method comprising recovering events related to the computer base game, identifying events in the one or more PGH computer games (e.g. continuously), streaming the identified events from the game client device (e.g. continuously) to a logic engine, processing the identified events using the logic engine (e.g. continuously) to generate building blocks, processing the building blocks using the logic engine (e.g. continuously) to determine whether PGH attribute parameters are obtained based on PGH rules, and ending play of the one or more PGH computer games when PGH attribute parameters have been obtained.

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

In an embodiment, loading and running the one or more PGH computer games includes recovering an event from the 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 analytics processor or processing the signals using a signal analytics 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 game play highlights (PGH) computer games from a computer base game, the system comprising a game client device comprising processing circuitry including one or more processors, the one or more processors including an event module configured to communicate with a PGH server, the PGH server including a storage unit for storing the PGH computer games and one or more server processors, wherein the server processors include a video processor, a logic engine and a PGH publisher, wherein the logic engine is configured and capable of receiving data relating to the computer base game, wherein the data includes one or more of events, text, audio, images, video recordings of a base game, other videos describing a base game; processing data to generate an event, processing an event to generate a building block, or processing data to generate a building block, capturing one or more highlights in the computer base game, wherein each of the captured one or more highlights corresponds to a selected starting point and ending point in the computer base game, processing, by the logic engine, the building block to generate a highlight attribute parameter comprising one or more of a possible target, a possible constraint, a possible PGH ending criterion, a possible ending condition, and a possible scoring parameter respectively associated with each of the one or more highlights, selecting a PGH highlight in each of the one or more highlights, wherein the PGH highlight corresponds to a selected starting point and ending point in one of the one or more highlights, repeatedly processing, by the logic engine, the building blocks associated with the selected PGH highlight to generate PGH attributes including one or more of a goal, a constraint, a PGH ending criteria, an ending condition, and a scoring parameter, creating the one or more PGH computer games based on the PGH attributes, wherein each of the PGH computer games includes a PGH rule associated with the PGH attributes and used to configure play of the one or more PGH computer games.

In an embodiment, the one or more processors are further configured and capable of loading and running the one or more PGH computer games, the loading and running comprising recovering events related to 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 generate the building blocks, continuously processing the building blocks using the logic engine to determine whether PGH attribute parameters have been obtained based on PGH rules, and ending play of the one or more PGH computer games when PGH attribute parameters have been obtained.

In an embodiment, the one or more processors are further configured and capable of generating a PGH state for each of the one or more PGH computer games, wherein generating the PGH state includes calculating one or more of a scoring parameter, a state of a goal, a state of a constraint, a state of a PGH ending standard, and transmitting the PGH state to a management module included in the server, and providing a server event based on one or more of the PGH state, the building blocks.

In an embodiment, the one or more processors are further configured and capable of recovering an event from the 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 are obtained based on PGH rules and the analyzed video or analyzed signals, and calculating scoring parameters.

According to a fifth aspect of the present invention there is provided a non-transitory computer readable medium containing program instructions for creating one or more playable game play highlights (PGHs) computer games from a computer base game, wherein execution of the program instructions by one or more processors of a computer system causes the one or more processors to perform a method comprising receiving events or data relating to the computer base game using a logic engine, wherein the logic engine is included in a processor located in a server; processing events by the logic engine to produce a building block, or processing data by the logic engine to produce a building block, capturing one or more highlights in the computer base game, wherein each of the captured one or more highlights corresponds to a selected starting point and ending point in the computer base game, processing building blocks by the logic engine to produce a highlight attribute parameter comprising one or more of a possible target, a possible constraint, a possible end criterion, a possible end condition, and a possible scoring parameter associated with each of the one or more highlights, respectively, processing the building block associated with the selected PGH by the logic engine to produce a highlight attribute parameter comprising one or more of a PGH end criterion, a possible end condition, and a possible scoring parameter, selecting a PGH in each of the one or more highlights, wherein the PGH highlights correspond to the selected starting point and ending point in one of the one or more highlights, processing the building block associated with the PGH selected PGH by the logic engine (e.g., repeatedly) to produce a PGH attribute comprising one or more of the attributes of the PGH end criterion, the PGH attribute, and the PGH attribute comprising one or more of the target, the PGH end criterion, creating the one or more PGH computer games based on PGH attributes, wherein each of the PGH computer games includes PGH rules associated with the PGH attributes and used to configure play of the one or more PGH computer games.

Brief Description of Drawings

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

FIGS. 1A and 1B illustrate logical block diagrams of an example gaming system that can be used to create a PGH that enables players to re-experience a scenario of historical gameplay, according to some embodiments of the invention;

FIG. 1C illustrates a logical block diagram of an example gaming system that can be used to play back a PGH that enables a player to re-experience a scenario of historical gameplay, according to some embodiments of the invention;

FIG. 2 illustrates an example user interface of a system for creating a PGH that enables players to re-experience a scenario of historical gameplay, according to some embodiments of the invention;

FIG. 3 is a flowchart of an example method of creating a PGH that enables players to re-experience a scenario of historical gameplay, according to some embodiments of the invention;

FIG. 4 illustrates an example data structure of PGH data objects that enable players to re-experience a scenario of historical gameplay, according to some embodiments of the invention;

5A-5E are flowcharts of example methods of playing back a PGH that enables a player to re-experience a scenario of historical gameplay, according to some embodiments of the invention;

FIG. 6 is a flowchart of an example scenario of initial user creation and secondary user play (secondary user play) of a PGH that enables a player to re-experience a scenario of historical gameplay, according to some embodiments of the invention;

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

FIG. 7B is a high-level block diagram of an alternative system configured and capable of creating a PGH based on one or more aspects of historical gameplay in a base game, the alternative system including a create input module (Creation Input Module), according to some embodiments of the invention;

FIG. 7C illustrates a flowchart of a method for creating a PGH using building blocks based on one or more aspects of historical gameplay, according to an embodiment;

FIG. 7D illustrates a flowchart of a method for creating a PGH based on one or more aspects of historical gameplay, the method including receiving identified events or processing data to produce the identified events, in accordance with an embodiment;

FIG. 7E depicts a high-level block diagram of an exemplary system for supporting loading and running PGH created based on one or more aspects of historical gameplay in a base game, in accordance with an embodiment;

FIG. 7F illustrates 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 illustrates 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;

FIG. 7H illustrates a detailed block diagram depiction of the processor of FIG. 7A, in accordance with an embodiment;

FIG. 7I presents an alternative configuration architecture in accordance with an embodiment in which a logic engine may include a data conversion module configured and operable to receive and/or extract data and convert the data to identified events;

FIG. 7J illustrates a detailed block diagram of FIGS. 7A and 7B configured and capable of creating a PGH based on one or more aspects of historical gameplay configured by a single player, in accordance with an embodiment;

FIG. 7K illustrates a detailed block diagram of a system configured and capable of creating a PGH based on one or more aspects of historical gameplay of a multiplayer player configuration, in accordance with an embodiment;

FIG. 7L illustrates a sub-set block diagram of FIG. 7K configured and capable of publishing and distributing one or more assets of a base game and PGH based on one or more aspects of single/multi-player configured historical gameplay, in accordance with an embodiment;

FIG. 7M illustrates a flow diagram of a method of asset extraction and decomposition according to an embodiment;

FIG. 8A illustrates a flowchart of a method for creating a PGH based on one or more aspects of historical gameplay of a single-player configuration, in accordance with an embodiment;

FIG. 8B illustrates a time flow diagram of a method for playing a PGH (such as the created PGH shown in FIG. 8A) created based on one or more aspects of historical gameplay of a multiplayer or single player configuration, according to an embodiment;

FIG. 8C illustrates a flowchart of a method of extracting and decomposing assets in a base game and/or PGH (such as the created PGH shown in FIG. 8A), according to an embodiment;

FIG. 8D illustrates a flowchart of a method for publishing assets in a base game and/or PGH, according to an embodiment;

fig. 9A to 9E show examples of an event list, a target list, a constraint list, a score parameter list, and an end condition list according to an embodiment;

10A-10G illustrate examples of screen shots of games and PGH according to embodiments;

FIG. 11 illustrates an example of a screen shot of a game and PGH, including the status of a target and PGH results, according to an embodiment;

FIG. 12 illustrates an example data structure of a PGH data object according to some embodiments;

FIG. 13 shows a flowchart of a method for loading and running a PGH computer game, according to an embodiment, and

FIG. 14 illustrates a computer system suitable for incorporation with methods, systems, and devices according to embodiments.

Detailed description of the invention

In the following detailed description, numerous specific details are set forth in order to provide a thorough understanding of the 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 disclosed subject matter.

Embodiments disclosed herein may be combined in one or more of a variety of ways to provide a method for creating and running one or more Playable Gameplay Highlights (PGHs) computer games from a computer base game.

As used herein, like characters represent like elements.

According to an embodiment, the present invention is configured to receive a base/original computer game (e.g., computer base game 705) with historical rules and create a new game, which is defined herein as PGH. The generated PGH may be associated with and/or inspired by and/or based on the base/original computer game. However, it is emphasized that the relationship between the computer base game and the newly formed PGH relates mainly to the theme in the original game. For example, where the computer base game is a NBA or racing computer game, both the original game and the PGH will share the titles of the NBA and racing games, which will include characters such as basketball players and racing, respectively, so the original game and PGH will share some characters. However, the generated PGH includes new rules, targets and/or constraints not contained in the original game, and thus cannot be played according to these rules in the underlying computer game.

Briefly, PGH games gain inspiration from the subject matter or theme of the original game, but they introduce new game play mechanisms, goals and limitations that bring about a different experience than the original game.

As described herein, the new rule may be created by a user and/or automatically created by the system. In some cases, new rules may be created using, for example, the generative AI method and system, such as using a language model (e.g., ilama 2) to convert, for example, a user's free text input into structured rules and/or targets and/or scoring parameters.

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

In particular, analyzing events in a game includes analyzing gameplay data and identifying important events, and processing events, for example, on a server to create PGH building blocks. These building blocks are then used to develop new targets, constraints, and rules to enhance the original gameplay experience. In contrast, the prior art creates games such as "mini games" by selecting a particular snapshot of the original game state at a selected starting point within the original game and identifying the trigger of an in-game event (in-GAME EVENTS). Mini-games are generated using a snapshot and trigger based script, extracting a limited portion of the game to provide a shorter, independent experience.

Another key distinction between the present invention and the prior art is the intended player experience. PGH generated by this method is intended to allow players to re-experience exciting moments in the original game while introducing new elements such as targets, constraints and scoring mechanisms. This approach enhances the original game play by adding new challenges and rewards. Prior art solutions, such as mini-games, do not introduce new elements, but rather provide a reduced version of the original gameplay starting from a predetermined point.

In addition, the present invention differs from the prior art in its technical approach and in the type of player experience that it provides. The present invention emphasizes the use of new targets and scoring parameters to record, analyze and enhance gameplay highlights, while the prior art focuses on extracting specific schemes from saved game states to create a shorter, independent mini-game experience, but not a new game experience. The method, apparatus and system of the present invention adds new elements to extend the original game play, while the prior art has reduced the game to a very short (bit-sized) experience.

Thus, while the computer game rules of the prior art (such as mini-game rules) are equivalent to the rules of the base game, the rules in the PGH may include one or more targets that are never part of the base game. For example, in a digital basketball game (e.g., an NBA computer game), in a single-player game setting, a player selects an existing NBA team and competes with an AI or another player. The player's goal is to score over the opponent team and by doing so win the game. PGH created from a particular highlight of an NBA game may have the goal that players make more than X passes (e.g., 10) between their teammates within a particular time frame, shoot a score from a distance at least equal to the score distance of the highlight of the PGH creator, or rob a team of opponents within a particular time frame.

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

In addition, 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, some moments in the game have received global attention, the degree of which may be comparable to the attention to great moments in the olympic games or professional sports. Some embodiments of the presently disclosed subject matter provide systems and methods for enabling gamers to identify interesting or exciting sequences in their gameplay, and then generate sharable "PGHs" based on these game sequences so that these sequences can be "re-experienced". These PGHs may then be shared, for example, on social media, and potentially obtain their own viral transmissions.

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

In addition, PGH is created to address several key challenges in the gaming industry. First, it aims to solve the game discoverability problem, which becomes more and more difficult due to the dramatic number of game releases on various platforms. Only 2023, stem sees 14,532 game releases, while mobile app stores have over 100,000 new games. PGH enables the gaming community to promote and market games through natural, user-generated content, which allows even smaller workshops to gain popularity without having to rely solely on traditional marketing methods.

Second, PGH according to embodiments enables gamers to capture their optimal game moments and convert those moments into playable highlights that can be shared across social media platforms. PGH not only enhances the gaming experience of communities, but also serves as a powerful marketing tool for game studios, developers and publishers. By integrating PGH SDKs, workshops can enable their communities to expose games, create presentations (demos), and provide early access rights to media while focusing on optimizing the gaming experience. In addition, PGH helps a studio promote the life-long value of its users by facilitating in-game discovery and encouraging players to explore more items, levels, roles, and DLCs.

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

Before setting forth the detailed description of the invention, it may be useful to set forth definitions of certain terms to be used hereinafter.

The term "tracking data (TRACKING DATA)" as used herein and throughout the specification and claims should be understood to encompass data describing the complete play of a game by an initial user (e.g., a first person shooter game). The term refers to details of the game state and player actions that are recorded during a game play session (gameplay session) to capture and reproduce.

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 a particular point in time or interval relative to the start of PGH. These changes are independent of any particular in-game event or player action, but occur automatically at predetermined times. For example, a new enemy character is generated at the 15 th second mark of the PGH.

The term "event-based data" refers to changes or modifications to the state of a game that are triggered by a particular in-game event or player action. These changes occur dynamically in response to certain conditions being met or certain actions being taken by a player or other gaming entity. For example, when a player enters a certain area of the game world, the behavior of the enemy character is changed.

The term "virtual object" as used herein and throughout the specification and claims should be understood to encompass any different element or entity within the game world that has its own characteristics and behaviors. Examples of virtual objects include, but are not limited to, characters (player characters and non-player characters), items (e.g., weapons, power-props, collectibles), vehicles, buildings, and interactive elements of a gaming environment. Each virtual object is defined by a dataset describing its various attributes, such as visual appearance, animation, physical properties, behavioral scripts, interactivity, and game-play specific properties.

The term "creator" as used herein and throughout the specification and claims should be understood to encompass individuals responsible for conception, design, and creation of elements of a computer game, including but not limited to, concepts, rules, mechanisms, checkpoints, environments, roles, and other assets of the game. Note that some of the above elements may be created automatically by an algorithm, by the original game developer and/or mechanism, or in collaboration with other creators.

The term "Playable Gameplay Highlight (PGH)" or "PGH Games" as used herein and throughout the specification and claims should be understood to encompass playable content created by a gamer, for example, from a history of computer Games or from his own original gameplay. According to an embodiment, the created playable content may be played by any one or more users as if they were the original gamer at that particular gameplay moment. Such playable content is time-limited, consistent with the length of the original gameplay. Each PGH includes targets and/or constraints and/or scoring parameters and/or ending conditions 1224 and/or ending PGH criteria 1222 set by the creator or by an algorithm (e.g., an Artificial Intelligence (AI) algorithm) or by a mixture of both (e.g., multiple targets, some targets created by the creator and some targets created by the algorithm) based on the creator's gameplay, and a scoring system to evaluate each player's performance according to the set scoring parameters. In some embodiments, the PGH includes rules that are never part of the rules of the base game (e.g., target and/or constraint and/or end conditions and/or PGH end criteria) and scoring parameters.

The term "original game" or "base game" or "computer base game" as used herein and throughout the specification and claims should be understood to encompass the first or source computer game played by the original or initial game player. The computer game or PGH may be all kinds of computerized games such as two-dimensional and three-dimensional games, first and third person games, single/multiplayer games, racing, shooting or round-robin (e.g. chess) games, virtual Reality (VR)/Augmented Reality (AR) games, scoring/non-scoring games, board games, racing games, tournament games, adventure games, prize games, etc. The term "game" also includes non-competitive virtual "experiences," such as VR/AR concerts or VR/AR exploration of virtual territories, and the like.

The terms "gameplay (gameplay)" or "gameplay (gameplays)" or "gameplay (game play)" or "gameplay (GAME PLAYS)" as used herein and throughout the specification and claims should be understood to encompass the manner in which players interact with a game, including the states, actions, rules, mechanisms, and structures that a game exhibits, as well as the actions and states of players for making progress in a game, as well as the actions and states of other players (e.g., NPC players or other players in a multiplayer game). Gameplay refers to the overall data attributes that allow game play, including the design, flow, and player's participation in the system and content of the game (including other players' participation). It involves challenges faced by players, selections they make, actions they take, and feedback and rewards they receive due to interactions with the game world.

The term "player" as used herein and throughout the specification and claims should be understood to encompass users playing a base game or PGH.

The term "Highlight" or "highlights (HIGHLIGHTS)" as used herein and throughout the specification and claims should be understood to encompass selected time stamps or time intervals during gameplay of a computer game in which a player wants to create a PGH. An example of a "highlight" may be a 20 second duration in an NBA computer game in which no other player has successfully taken the ball from the player's hand.

The term "state" as used herein and throughout the specification and claims should be understood to encompass the nature of the entity during play. Examples of "states" may be, for example, player positions or player vital values in a computer game.

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

The term "Event" or Events (Events) or "identified Events (IDENTIFIED EVENT)" or "identified Events (IDENTIFIED EVENTS)" as used herein and throughout the specification and claims should be understood to encompass the actions and states of a player and/or the actions or states of a game.

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

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

The term "URL" (uniform resource locator) as used herein and throughout the specification and claims should be understood to encompass a sharable link to a particular PGH.

The term "Rule" or "Rules" or "PGH Rules" as used herein and throughout the specification and claims should be understood to encompass boolean formulas/clauses including logical operations based on boolean conditions, for example, from PGH. In particular, a rule may be defined as a logical paragraph, such as one or more binary logical paragraphs associated with a selected played computer game piece that includes a PGH (such as a PGH building block). The rules may be based on the generated "targets" and/or "constraints" and/or "end conditions" and/or "end PGH criteria 1222". Examples of such rules are shown in fig. 9B, 9C, and 9E.

The term "Objective" or "objectives (Objectives)" as used herein and throughout the specification and claims should be understood to encompass one or more purposes that a PGH player needs to accomplish in a PGH game in order to win. An example of a possible target is shown in fig. 9B.

The term "Constraint" or "Constraints" as used herein and throughout the specification and claims should be understood to encompass one or more such conditions, if reached, the player inputs PGH. An example of a possible constraint is shown in fig. 9C.

As used herein and throughout the specification and claims, the term "Score" or "Scores" or "scoring Parameters (Scoring Parameter)" or "scoring Parameters (Scoring Parameters)" or "scoring Parameters (Score Parameters)" should be understood to encompass a list of conditions that, if reached, a player obtains a Score. The score may be positive or negative and cumulative such that each time a new condition is reached, the score is updated positively (i.e., by adding the score to the cumulative score) or negatively (i.e., by subtracting the score from the cumulative score). An example of possible scoring parameters is shown in fig. 9D.

The term "End Condition" or "End Conditions" as used herein and throughout the specification and claims should be understood to encompass Conditions, if reached, in which either the player wins the PGH game or the player loses the PGH, or there may be no predefined PGH win or loss. An example of a possible end condition is shown in fig. 9E.

The terms "ending PGH standard (END PGH CRITERIA)" or "PGH ending standard (End of PGH CRITERIA)" as used herein and throughout the specification and claims should be understood to encompass conditions, if reached, in which either the player wins the PGH game or the player loses the PGH, or there may be no predefined PGH wins or losses. Examples of possible ending PGH criteria 1222 are time limit (e.g., player has 30 seconds to reach a goal), number of rounds (e.g., in chess game the user has 20 rounds to reach a goal), mix of rounds and time limit (e.g., in chess game you have 5 rounds and 120 seconds to reach a goal).

The term "PGH building blocks" or "data building blocks" as used herein and throughout the specification and claims should be understood to encompass formulas formed based on identified events such as "actions" and/or "states" to create one or more "targets" and/or one or more "constraints" and/or one or more "end conditions" and/or one or more "end PGH standards 1222.

The terms "non-transitory memory" and "non-transitory storage medium" as used herein should be construed broadly to encompass any volatile or non-volatile computer memory suitable for use with the presently disclosed subject matter.

The term "stream" as used herein and throughout the specification and claims should be understood to encompass digital data (such as audio or video material) that is transmitted one or more data packets at a time in succession and is generally 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 of streaming data or accessing data that is streamed, a process or an instance.

The term "re-played player (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 herein and throughout the specification and claims should be understood to encompass data required to play PGH.

The term "graphic element (GRAPHIC ELEMENT)" or "graphic elements (GRAPHIC ELEMENTS)" or "graphic asset" or "asset" as used herein and throughout the specification and claims should be understood to encompass visual components within a game such as characters, environments, objects, user interface elements, special effects, animations, textures and artistic styles. Examples of graphical elements include, but are not limited to, grids; a set of comprehensive textures such as albedo, normal mapping, height mapping, occlusion, detail masking and baking illumination mapping, support for other texture mapping such as metal mapping, roughness mapping and emission mapping, secondary mapping including detail albedo and secondary normal mapping, UV mapping for texture coordinates, colorants and materials defining visual appearance and ray interactions, animation equipment with key frames and curves for movement, collimators for physical interactions, physical states for dynamics and kinematics, real-time lighting elements with shadow mapping and global illumination, reflective probes and screen space reflection for precise reflection, particle systems for special effects, sound assets for visual enhancement such as halo (bloom), motion blur, depth of field, tone mapping and color grading, AI navigation grids for spatial audio effects, level of detail (Level of detail, d) systems for performance optimization, occlusion rejection and view efficiency improvement, and lookout control systems for overall lookout and rendering interaction forces.

Turning now to fig. 6, fig. 6 illustrates a flow chart 600 of an example sequence of a user playing a game, creating a derived PGH, and sharing the derived PGH with other users in accordance with some embodiments of the presently described subject matter.

The initial user may play 610 a computer-based game (e.g., on a personal computer, smart phone, tablet, dedicated gaming device, etc.).

While playing the game, the initial user may perform an action that "captures" (620) the completed gameplay. As non-limiting examples, the initial user may click (via, for example, an input device) on a "PGH capture icon" that is part of the user interface of the game, or press a combination key on the keyboard (e.g., the Alt key + "g" key on the keyboard). Note that alternatively, in some embodiments, the initial user may utilize some suitable interface to begin the "capture" (620) process during or after gameplay. Alternatively, the capture process may be triggered automatically, for example by an algorithm (e.g., an Artificial Intelligence (AI) algorithm) that gives an automatic score of the shareability of gameplay or the likelihood that a particular gameplay is suitable for creating a PGH therefrom.

In some cases, the PGH may be generated and "captured" (620) at the time of game play, e.g., before game completion.

The device of the initial user may then make the data of the completed gameplay available to the PGH creation server (630). Note that the transfer of gameplay data to the PGH creation server may be performed concurrently with or after gameplay, may involve intermediate entities, and so on.

According to another embodiment, the data of the entire game is uploaded to the server of the PGH all the time during gameplay so that the user can select a specific highlight to change it to the PGH at a later time.

The server may then present 640 a User Interface (UI) to the initial user. The presented user interface may enable the initial user to select a particular clip/highlight of the completed gameplay or completed game to be included in the PGH (e.g., a 45 second gameplay sequence from a 15 minute gameplay session). The presented user interface may also enable the initial user to select a particular purpose for the PGH (e.g., kill a number of enemies, move the main angle to a particular point on the game terrain, etc.).

Next, the server may create (650) a data object that allows for playing the PGH, and may make this data object available to other users. As a non-limiting example, a server may maintain a web page that enables a user to peruse such data objects and then access particular objects to play the corresponding PGH. In some cases, a link is provided to the created data object. In some cases, data objects may be shared using known sharing methods, such as through shared links (such as hyperlinked addresses to addresses) and the like.

Such a "secondary" user may then access the newly created PGH (e.g., via download, streaming, loading, etc.), then play (660) the PGH and perform his or her own original game play on the PGH.

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

As will be described in detail below, in some embodiments, certain techniques are utilized to enable a secondary user to experience an original game scenario as experienced by an original user, while ensuring that the progress of the game actually conforms to the original game rules, game physics, and the like. In some embodiments, these techniques include:

(i) The time-based events in the original game are reproduced in the PGH. For example, if new enemies are present at a particular time in the initial user's gameplay, or if existing enemies spontaneously take actions, the PGH system may replicate these enemies actions at the same time offset in PGH play as in the original game based on the data included in the PGH data object.

(Ii) The event-triggered reactions in the original game are reproduced in the PGH. For example, if the enemy changes its location and counter-hits in response to an initial user firing a weapon to the enemy, the PGH system may replicate the enemy's behavior based on data included in the PGH data object in response to a principal angle controlled by a secondary user firing the weapon to the particular enemy.

Iii) In order to obtain robust PGH behavior, it may be desirable for the NPC in the PGH to repeat all or some of the behavior in the original game for a duration of the PGH, and then perform after that time based on its NPC characteristics. NPCs on PGH that behave according to the original game play are referred to herein as "caged NPCs," while NPCs that behave according to their characteristics and/or other factors are referred to herein as "uncapped NPCs.

In some embodiments, the PGH data object may include data indicating whether the initial state of the NPC is trapped or uncapped. In some embodiments, the PGH data object may also include data indicating that the NPC should transition from its initial state (e.g., trapped) to another state (e.g., uncapped) in response to a particular event.

For example, data in the PGH data object may indicate that a particular NPC should transition from trapped to uncapped at some time into the PGH or in response to a particular event in the PGH.

In some cases, not only the trapped/uncapped NPC changes behavior based on the behavior of the secondary user. The present claims are broader in this regard and refer to any behavior of a game. This means that if the secondary user would select a similar selection to the primary user, then the general behavior of the gameplay highlights would be similar (not identical), but if the secondary user is changing things and selecting a different selection from the primary user, then the gameplay would behave differently (the particular example is a trapped/uncapped NPC).

According to some embodiments, not only the trapped/uncapped NPC changes behavior based on the behavior of the secondary user. For example, if the secondary user would select a similar selection to the primary user, then the general behavior of the gameplay highlights would be similar (e.g., not identical), but if the secondary user is changing things and selecting a different selection from the primary user, then the gameplay would behave differently (the particular example being a trapped/uncapped NPC).

Focusing on fig. 1A, fig. 1A is a block diagram of an example system 100 for creating PGH Data Segments (PDS) that enable gamers to play PGHs based on a scheme of historical gameplay, according to some embodiments of the presently disclosed subject matter.

The gaming system 100A supporting PGH creation may be a gaming device, such as Sony ^Tm Playstation^Tm、Microsoft^Tm Xbox^Tm, or the like. Alternatively, the gaming system 100A supporting PGH creation may be a programmable device, such as a Personal Computer (PC), smart phone, tablet, or the like. Alternatively, the gaming system 100A supporting PGH creation may be another suitable platform.

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

The gaming system 100A supporting PGH creation may be operably connected to, for example, various peripheral devices (such as game-related peripheral devices). Such peripheral devices may include, for example, a game display/audio system 180 and a game controller 170. The peripheral devices may also include virtual reality/augmented reality headphones (headsets) or other kinds of games or other peripheral devices.

Processor 120A may be a suitable hardware-based electronic device having data processing capabilities, such as a general purpose processor, a Digital Signal Processor (DSP), a specialized Application Specific Integrated Circuit (ASIC), one or more cores in a multi-core processor, or the like. Processor 120A may also be comprised of, for example, multiple processors, multiple ASICs, virtual processors, combinations thereof, and the like.

Memory 130A may be, for example, a suitable variety 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. The memory 130A may be configured to store various data used in the computation, for example.

The storage 160 may be a suitable kind of volatile or non-volatile storage, such as a hard disk, solid state drive, or the like.

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

Game engine 150 may be a software module that implements general-purpose game functions, such as:

managing devices such as the game display/audio system 180 and the game controller 170, including receiving inputs from (and sending outputs to) such devices.

Implementing virtual objects (such as game terrain, obstacles, etc.) used and displayed in the game.

-Providing an Application Programming Interface (API) for provisioning virtual objects, determining a current state of virtual objects, managing virtual objects.

For example, game engine 150 may be a commercial game engine, such as Unreal ^TM、Unity^TM or the like.

Game engine 150 may include various sub-modules that implement "bullet physics", "vehicle motion", etc., to enable ongoing changes in game state to occur autonomously within game engine 150.

Game engine 150 may implement game state method changes in response to, for example, the following:

■ Pseudo-randomly generated events, such as enemies that occur pseudo-randomly in a first person shooter game;

■ A game controller device event, such as a user pressing a game controller device button to fire a weapon;

■ Characteristics of the virtual object-for example, a moving vehicle may have continuously updated positions within the game terrain.

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

In some examples, game-specific logic 140 initially supplies an initial game scenario to game engine 150. By way of non-limiting example, in a racing game, game-specific logic 140 may initially provision game engine 150 with virtual objects including tracks having a particular topology, first-person player cars having locations on the tracks, non-player cars having particular appearance and movement characteristics, and the like. Game-specific logic 140 may perform provisioning of the initial game scheme via an API of game engine 150.

Game-specific logic 140 may include tracker module 105. The tracker module 105 may write tracking data to the storage. The tracking data may include data indicating, for example:

a) Data read from game engine 150 by game-specific logic 140 describing the current characteristics of the virtual object and the associated game state;

b) Data written by game engine 150 (or to be written by game engine 150) to game-specific logic 140 describing the current characteristics of the virtual object and the associated game state, as programmed for the particular game.

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

The tracker module 105 may write the tracking data in, for example, 2 packets:

a) A packet containing data describing initialization data, and

B) Packets containing data describing the virtual object and subsequent changes to the game state event.

The data describing the subsequent changes to the virtual object and the game state event may include data (e.g., a timestamp) indicating when the change occurred in the game.

The data describing the virtual object and subsequent changes to the game state event may include, for example, images (e.g., screen shots) or video clips indicating the game event at the time of the change/event.

Game-specific logic 140 may include upload module 115. The upload module 115 may upload, for example, the tracking data 125 to, for example, the PDS server 195 via, for example, the network link 190.

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

Processor 120B may be a suitable hardware-based electronic device having data processing capabilities, such as a general purpose processor, a Digital Signal Processor (DSP), a specialized Application Specific Integrated Circuit (ASIC), one or more cores in a multi-core processor, or the like. Processor 120B may also be comprised of, for example, multiple processors, multiple ASICs, virtual processors, combinations thereof, and the like.

Memory 130B may be, for example, a suitable variety of volatile and/or nonvolatile 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 the computation.

The processing circuitry 110B may be configured to execute several functional modules according to computer readable instructions embodied on a non-transitory computer readable storage medium. Such functional modules are hereinafter referred to as being comprised in a processing circuit. These modules may include, for example, PGH creation module 145 and re-gamification (regamification) logic 135.

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

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

As a non-limiting example, the tracking data may include data describing the complete play of a game (e.g., a first person shooter game) by an initial user. There may be multiple scenarios with many different types of enemies and targets, different terrains and different purposes within the complete play of a game.

In some embodiments, PGH creation module 145 may present a web-based interface to the initial user, allowing him or her to select a particular scheme within a longer game that will form the basis of PGH. For example, a selected scenario may involve a principal angle requiring killing of a particular number of enemies located at a particular location in a particular terrain. In some such embodiments, the web-based interface displays still images or video clips (included in the uploaded tracking data 155) to aid the user in selecting the scheme.

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

In some embodiments, PGH creation module 145 may create PGH data segment 165. In some such embodiments, PGH creation module 145 writes data indicating one or more virtual objects that are part of the initial state of the selected clip (i.e., that exist when the re-played user begins playing the game). The data may be derivative of the uploaded trace data 155 and may be written to the PGH data segment 165 in a trace data format or in a different data format. The data may describe the virtual object in a manner sufficient to enable the re-played player to configure the virtual object into the game engine.

In some embodiments, PGH creation module 145 may also write data to the PGH indicating the time-based modification. For example, 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 or deletions from an already defined virtual object. The data indicating these virtual objects may be derivative data of the uploaded trace data 155 and may be written to the PGH data segment 165 in a trace data format or in a different data format.

The time-based modified data may be accompanied by an explicit time stamp indicating the time offset in the PGH at which the modification should occur. In some embodiments, the time stamp is implicit (e.g., each time-based modification may represent a change that occurs at 10ms intervals).

The data may describe the virtual object in a manner sufficient to enable the re-played player to configure the virtual object into the game engine at the appropriate time offset.

By way of non-limiting example, PGH creation module 145 may detect virtual object initialization and modification that occurs after the game part for creating PGH begins when processing the uploaded tracking data 155. As a more specific example, in some embodiments, PGH creation module 145 may examine tracking data from uploaded tracking data 155 that indicates that a new enemy suddenly appears from a new visible topographical feature (such as a building). The PGH creation module 145 may then create a time-based modification to the PGH accordingly to create a new virtual object corresponding to the new enemy.

In some embodiments, PGH creation module 145 may also write data to the PGH indicating the event-based modification. For example, PGH creation module 145 may write data indicating one or more virtual objects to be added to the game, or data indicating one or more changes to virtual objects that have been defined, in response to a particular event occurring in the game (e.g., in response to a principal's behavior). The data indicating these virtual objects may be derivative data of the uploaded trace data 155 and may be written to the PGH data segment 165 in a trace data format or in a different data format.

The data may describe the virtual object in a manner sufficient to enable a re-played player to configure the virtual object into the game engine in response to the indicated event.

By way of non-limiting example, the PGH creation module 145, in processing the uploaded tracking data 155, may evaluate which virtual object initialization and modifications are due to actions of the principal angle or to other game events, and which virtual object initialization and modifications are spontaneous, i.e., not generated by causal sequences of other virtual objects. As a more specific example, in some embodiments, PGH creation module 145 may examine tracking data from uploaded tracking data 155 that indicates that a stationary non-player character (NPC) becomes active in response to a projectile hit by a principal angle (e.g., by attacking the principal angle). The PGH creation module 145 may then determine that the NPC behavior is a behavior that is responsive to the principal angle and create an event-based modification to the PGH accordingly.

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

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

The virtual object release criteria is an event that causes a re-played player to stop his ongoing control of the game engine when the event occurs to replicate the virtual object behavior of the game played by the original user. Thereafter, the re-played player may perform different actions on the object depending on the game situation. In some examples, the virtual object release criteria may be a time offset into the PGH.

As a non-limiting example, in a racing game, there may be NPC car virtual objects. The PGH creation module 145 may configure the PDS such that at some time offset from play of the PGH by the re-played player, the car no longer reflects the behavior of the NPC car virtual object in the game played by the original player, but instead follows a different behavior. For example, the original behavior of the NPC may be that the NPC car virtual object decelerates before a certain turn in the road, and the non-mirrored behavior may be that the car accelerates in that particular turn.

Attention is drawn to fig. 1B, which is a block diagram of an example variation of a system for creating PGH Data Segments (PDS) in accordance with some embodiments of the presently disclosed subject matter. In fig. 1B, the PGH creation function is divided by PGH creation module 145A (located in a tracker module of gaming system 100A) and PGH creation module 145B (located in a PDS server). In this case, the PGH creation module may be divided in any suitable manner. For example, in some embodiments, PGH creation module 145A may prepare time-based modification data and event-based modification data, while PGH creation module 145B may continue to receive user-selected scoring parameters and prepare the re-gamification data.

Focusing on FIG. 1C, FIG. 1C is a block diagram of an example gaming system that supports playing PGH using PGH Data Segments (PDS) based schemes of historical gameplay, according to some embodiments of the presently disclosed subject matter.

PGH players using system 100B of fig. 1C may download PGH data segments 165, for example, from PDS server 195. PDS replay module 185 may then utilize PGH data segment 165 to provide PGH. A detailed description of an example method of providing PGH from PGH data segments 165 is presented below with reference to fig. 4.

Attention is drawn to fig. 2, fig. 2 is an example user interface presented to an initial player of a game in accordance with some embodiments of the presently disclosed subject matter. The screen shown in fig. 2 includes a selection interface element (210) that enables the initial user to select a time range from the original game that will be the basis for PGH. The interface also shows still frames of gameplay, which may be images that are included in the uploaded tracking data 155 (after placement in the tracking data 125 by the tracker module 105) and then extracted at the PDS server 195.

The screen shown in fig. 2 also includes a scoring parameters interface element (220) that enables the initial user to specify scoring parameters for the PGH and an end of game criteria interface element (230), which may also be referred to as a "destination," that enables the initial user to specify what conditions the PGH should complete based on.

Turning now to fig. 3, fig. 3 illustrates a flow chart 300 of an example method of creating PGH data segments in accordance with some embodiments of the presently disclosed subject matter.

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

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

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

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

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

In some embodiments, the initial user may select PGH ending criteria from the user interface. For example, the user may designate a time offset in the original game as ending, or the user may select criteria for ending the game, such as the number of kills enemies.

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

In some embodiments, the initial user may select one or more scoring parameters from the 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 of the PDS server 195 (e.g., PGH creation module 145) determines the scoring parameters via different mechanisms (e.g., using scoring parameters of a single suitable game). For example, if it is a racing game, the system may automatically set the scoring parameters to the time of a turn. In the case of a first person shooter game, the scoring parameters may be automatically set to kill the number of enemies.

Processing circuitry 110B of PDS server 195 (e.g., PGH creation module 145) may then write 340 the initial virtual object data to PGH Data Segment (PDS) 165.

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

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

Processing circuitry 110B of PDS server 195 (e.g., PGH creation module 145) may write (370) the re-gamification data (e.g., game end criteria/targets, constraints, PGH end criteria, end conditions, scoring parameters) to PDS165.

Processing circuitry 110B of PDS server 195 (e.g., PGH creation module 145) may make PDS165 available for access (e.g., download) to enable others to play PGHs.

Attention is now drawn to fig. 4, fig. 4 illustrates an example data structure of PGH data segments, according to some embodiments of the presently disclosed subject matter.

PGH data segment 400 may include initial virtual object data 410, which initial virtual object data 410 may in turn include zero or more virtual object descriptors 415A, 415B. Each virtual object descriptor may be a data packet that represents a set of virtual object parameters that a game system supporting PGH play should instantiate at the beginning of PGH.

PGH data segment 400 may include time-based data 420, which time-based data 420 may in turn 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 temporal descriptor may be associated with one or more new virtual object descriptors (e.g., new virtual object descriptor 425C) and/or one or more changed virtual object descriptors (e.g., changed virtual object descriptor 425B).

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

Each changed virtual object descriptor may include an identifier of the virtual object that has been instantiated, and may be a data packet that represents a set of virtual object parameters that the gaming system supporting PGH play should apply to the corresponding virtual object that has been instantiated 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 event-based data 430 may in turn include zero or more event descriptors (e.g., event descriptors 435A-435C). Each event descriptor may relate to a virtual object within the PGH and may describe events that may occur within the PGH (e.g., death of an enemy, arrival of a principal angle at a target destination, etc.). Each event descriptor may be associated with one or more new virtual object descriptors (e.g., new virtual object descriptor 425C) and/or one or more changed virtual object descriptors (e.g., changed virtual object descriptor 425B).

As previously described, each changed virtual object descriptor may include an identifier of the virtual object that has been instantiated, and may be a data packet that indicates that a game system supporting PGH play should be applied to a set of virtual object parameters of the corresponding virtual object that has been instantiated in response to an event in the PGH (as indicated by the associated event descriptor).

PGH data segment 400 may include re-gamification data 440, which re-gamification data 440 may in turn include end-of-game criteria 445A and scoring parameters 445B. The game end criteria 445A may include data indicating when a game system supporting PGH play should end PGH (e.g., at a particular time, after a particular objective is completed (such as the principal angle reaching a point in the terrain or killing a number of enemies) (or a combination of such criteria)). Scoring parameters 445B may include data (e.g., number of enemies killed, strength of principal angle, etc.) indicating what content a gaming system supporting PGH play should track and display as a measure of success in PGH.

Attention is now drawn to fig. 5A-5E, which fig. 5A-5E illustrate a flowchart 500 of an example method of providing PGH from PGH data segments, according to some embodiments of the presently disclosed subject matter.

The methods shown in fig. 5A to 5E may be performed, for example, by the game system 100B supporting PGH play or by the systems shown in fig. 7C, 7D, 7E.

Processing circuitry 110A (e.g., PDS replay module 185) may receive 510 PDS165.

Processing circuitry 110A (e.g., PDS replay module 185) may then control game engine 150 to instantiate 520 the initial virtual object indicated in PDS 165.

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

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

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

In some embodiments, processing circuitry 110A (e.g., PDS replay module 185) evaluates the time-based data and only controls game engine 150 to instantiate new virtual objects or modify existing virtual objects that are not game keyfigures or are not controlled by keyfigures. In such an embodiment, processing circuitry 110A (e.g., PDS replay module 185) filters out the principal and principal controlled objects simply because the PGH behavior of the principal of the game is controlled by the game player and not by the events of the history game (although the events of the history game may still be used for comparison purposes). In some other embodiments, virtual objects that are or are controlled by the game master are not present in PDS 165.

Similarly, in some embodiments, a non-player character (NPC) may initially operate in a mode described above as a "trapped mode". In this state, the NPC may behave as if it were in the original historical game played by the original player. In such an embodiment, the NPC begins to exhibit a change in its behavior when a trigger (i.e., an event that the system has selected to create) occurs—for example, the NPC may exhibit behavior forward (forward) based on an artificial intelligence decision tree (rather than behavior in a historical game).

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

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

Processing circuitry 110A (e.g., PDS replay module 185) may continuously evaluate whether the new game event matches (585) the scoring parameters of the re-gamification data of PDS 165. If so, processing circuitry 110A (e.g., PDS replay module 185) may control (588) game engine 150 to display the updated scoring information.

Processing circuitry 110A (e.g., PDS replay module 185) may continuously evaluate (590) whether the game ending criteria are met. If so, processing circuitry 110A (e.g., PDS replay module 185) may end (595) the game. Otherwise, game play may continue, e.g., processing circuitry 110A (e.g., PDS replay module 185) may return to again evaluate 550 whether the PGH time offset matches 550A time descriptor in the time-based data.

Referring now to fig. 7A, fig. 7A is a high-level block diagram of an example system 700 according to some embodiments of the invention, the system 700 configured and capable of creating PGHs based on one or more schemes of historical gameplay in a base game.

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

1. Game client device 701

2. A starter Module (starter Module) 702

Pgh server 703

4.PGH App 704

1. Game client device 701:

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

According to some embodiments, the game client device 701 may be hosted in a server, such as a video streaming server (video STREAMING SERVER).

The game client device 701 may be any type of device such as a smart phone, personal Computer (PC), virtual Reality (VR) device/glasses, tablet, smart watch, etc.

The original game (e.g., base game 705) may be any game that the user (e.g., gamer) wants to play, and further can be used to create and play PGHs that are based on or related to one or more aspects of the original game's historical gameplay.

According to an embodiment, the game client device 701 includes one or more processors 708, the one or more processors 708 including an event module 709 and a video module 706 or in communication with the event module 709 and the video module 706.

Event module 709 is configured and capable of identifying events 715 in base game 705 (e.g., where a new PGH is created) and/or in PGH (e.g., where PGH is played), and streaming identified events 715 to PGH server 703 continuously (e.g., in real time). Event 715 may include, for example, a "action" and/or "status" of a character in base game 705.

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

2. The initiator module 702:

According to an embodiment, the initiator module 702 is a software platform configured and capable of hosting, publishing and executing PGH 738 and/or base games 705 (such as microsoft games, sony games, etc.).

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

Pgh server 703:

According to embodiments, PGH server 703 may be any type of server, such as a back-end application that may be hosted, for example, on a data center (such as a private or public data center).

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

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

According to an embodiment, 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 local or external device or system (such as an external server or external device).

According to one embodiment, the architecture of system 700 includes a separation between a logic engine process and a video creation process. Logic engine 714 includes receiving identified events in base game 705 to generate, for example, building blocks 716 (as shown in fig. 7E), which building blocks 716 are further converted to highlight attributes (such as targets and/or constraints and/or scoring parameters in the game), while video creation includes cutting and editing selected segments from base game 705 and further building/restoring selected segments. The highlight attribute is added and synchronized to the top of the selected clip video to produce PGH attribute 735 for PGH publisher 733 and PGH timestamp 763' for video processor 763.

According to some embodiments, logic engine 714 is configured and capable of receiving and/or extracting identified events 715 from event module 709, processing and analyzing the identified events 715, and generating building blocks 716 using logic rules and/or mathematical formulas (e.g., aggregation functions) applied to one or more types of events. For example, during a shooting game, the identified event may consist of a "kill" event within the PGH, and one of the building blocks may be the number of clicks in the PGH. In this example, the identified event consists of all of the kill events, and the mathematical formula may be a count function over all of the kill events within the identified event, producing a kill number building block. Another example is a shooting game, where a building block may consist of more than one event type, the identified event may consist of all "jump" events and additionally all "click" events. One possible building block in the game may be "over the air," which refers to the killing of an enemy within the game while the user is jumping. In this case, the building block verifies whether the player has made a click while he jumps. Based on building block 716, logic engine 714 is further configured to generate a highlight attribute 714', which highlight attribute 714' is transmitted to PGH App 704 for creating PGH 738. The highlight attribute 714' includes parameters including, for example, possible targets to be used to play PGH and configure PGH rules, constraints, end conditions 1224, PGH end criteria 1222, and scoring parameters.

In some cases, build base 716 may be identical to identified event 715. This means that no mathematical formulas or aggregations are applied to the identified events 715 to create building blocks 716. Alternatively, building block 716 is a direct copy of identified event 715 without any modifications. For example, in a racing game, one of the identified events is "complete one turn (Lap Completed)", which is triggered each time the player completes one turn around the track. If no aggregation or mathematical formulas are applied to this event, the corresponding building block 716 may also simply be "complete in one turn". Thus, in this case, if the identified event is "complete round," the resulting building block will be identical: "complete round. Logic engine 714 may then directly use these building blocks 716 without any transformation to generate potential targets and/or constraints and/or scoring parameters and/or end conditions 1224 and/or PGH end criteria 1222 for the PGH. For example, the potential target may simply be "Complete a Lap". Thus, when building block 716 is the same as identified event 715, this means that the events are used as they are, without any modifications or calculations applied to these events during the building block creation step. In this case, the original event itself serves as the base component for generating the highlight attribute.

According to an embodiment, logic engine 714 uses building block 716 to calculate and generate PGH parameters at intermediate steps that will be included in PGH 738 and will be used in playing PGH generated in the future. In particular, building block 716 is used as raw material for computing PGH parameters including, for example, one or more of targets, constraints, end conditions 1224, PGH end criteria 1222, and scores to be used to play PGH 738. The building blocks are used to generate all possible combinations (or subsets of combinations) of potential targets (included in the transmitted highlight attribute 714'), constraints, end conditions 1224, PGH end criteria 1222, and scores for use by PGH creators or players to generate PGHs. For example, the highlight of the captured base game includes "10 hits" of an enemy over a period of one minute, the identified event is "hit", and building block 716 will be used to generate various possibilities for the target, constraints, end conditions 1224, PGH end criteria 1222, and scoring parameters from the "10 hits" in the highlight. Thus, once the creator selects a time period, e.g., a 30 second segment, from the highlight, the goal, constraints, end conditions 1224, PGH end criteria 1222, and score are updated accordingly. More specifically, in this example, assume that the first 30 seconds of a bright spot includes 8 out of 10 shots, and the last 30 seconds includes 2 shots again, totaling 10 shots within 1 minute. The potential initial target for the highlight may be 10 enemies to be knocked over a period of one minute and after the first 30 seconds of user selection (where the start time of the highlight is 0 seconds and the end time is 30 seconds, 8 knocks have occurred in the original highlight within this first 30 seconds), the potential target is updated from the first 30 seconds of event and building blocks, in this particular example the potential target is updated to knocked 8 persons, and also the possible constraints, end conditions 1224, PGH end criteria 1222 and scoring parameters are updated, respectively.

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

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

Fig. 7H shows a detailed block diagram illustration of the processor 712 of fig. 7A, according to an embodiment. As described above, in some cases, logic engine 714 is configured and capable of, for example, receiving and/or extracting identified events 715 from event module 709, processing and analyzing the identified events 715, and generating building blocks 716 using logic rules and/or mathematical formulas (e.g., aggregation functions) applied to one or more types of events.

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

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

The data 7150 may include one or more of events, text, audio, images, video recordings of the base game, other videos describing the base game.

According to some embodiments, PGH logic engine 714 uses building blocks 716 to calculate PGH scores 7120 based on scoring parameters and sends them to PGH rules 719 to calculate PGH states 777, PGH states 777 including target state 12260, constraint state 12280, and end PGH criteria state 12220 (e.g., which parts of the criteria are reached). PGH state 777 is calculated based on one or more of goal 1226, constraint 1228, end PGH criteria 1222, and end conditions 1224.

The embodiment shown in fig. 7I contains all of the basic components and functions previously depicted in fig. 7H. However, fig. 7I presents an alternative configuration architecture in which the logic engine 714 may include a data conversion module 741 configured and capable of receiving and/or extracting data 7150 and converting the data into identified events 715. Referring to fig. 7I, an alternative embodiment of the present invention is depicted, which differs from the embodiment shown in fig. 7H. In this configuration, building block 716 is omitted from the system architecture. Alternatively, this embodiment utilizes only identified events 715, which convert the data to identified events 715 through intermediate processing steps.

4. PGH App 704:

According to an embodiment, PGH App 704 is a software application configured and capable of creating PGH game 738 based on received inputs including highlight attribute 714 'and highlight video 763", and outputting PGH attribute 735 and PGH timestamp 763', and also managing PGH platforms on which PGH 738 may be found, executed, shared, etc. using, for example, user interface 7360 including information Feed (Feed) 736.

PGH App 704 includes a user interface including information feed 736 and PGH builder 734.PGH builder 734 is configured to receive a highlight video 763 "and a highlight attribute 714', the highlight video 763" and the highlight attribute 714' comprising one or more of a target and/or zero or more constraints and/or zero or more end conditions and/or one or more PGH end criteria 1222 and/or one or more scoring parameters. The creator may use the highlight attribute 714' and the corresponding highlight video 763″ and select a subset of the timeline of captured highlights (e.g., select a starting point (e.g., start timestamp) and an ending point (e.g., end timestamp) of captured highlights that may be a subset of captured highlights). For example, in a captured bright spot of length 2 minutes, the starting point may be 10.5 seconds from the beginning of the bright spot, and the ending point may be 1 minute 12.2 seconds from the beginning of the bright spot, so as to create PGH timestamp 763'. In addition, the creator may use the highlight attribute 714 '(the highlight attribute 714' to select a target and/or constraint and/or scoring parameter and/or end PGH criteria 1222 based on the identified event and/or building block that resulted from processing his own game play of the highlight) and other PGH attributes 735 (e.g., name, description, thumbnail "preview" image, label, etc. of PGH) for generating PGH attributes 735, which specifically relate to video clips in the base game 705 (e.g., based on the selected PGH starting point of the highlight video 763 "such that either the highlight attribute 714 or the building block uses the same timeline of the highlight such that the creator may use the timeline of the highlight video 763" to scroll through the video and select the exact starting point he wants to select) in order to create PGH attributes 735.

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

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

A "state event" is a characteristic of an entity during a base game. Examples of "states" may be, for example, player positions or player vital values in a computer game.

An "action event" is an operation and/or movement performed by a player during a game, such as a jump, NBA player shooting, etc.

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

Building block 716 is a logical rule created based on translating identified events 715, such as state 723 'and action 724' events in base game 705, into logical phrases that may be understood by a PGH player or PGH creator.

According to an embodiment, each of the building blocks 716 is formed by aggregating one or more identified events 715. The aggregate function combinations may have the same type or different types of identified events 715. For example, in a combat game, an "air kick" building block may consist of an identified action "jump" in the base game and a next identified action "kick" within a particular time frame.

As an example of aggregating the same type of event, X-degree movements of a player that may be included in a game are aggregated into a single Y-degree movement that combines all individual movements. Similarly, if a player moves through a full 360 degrees in place, the movement may produce a "rotating" building block, according to an embodiment.

It should be noted that in some cases, the aggregation function may produce the same building block 715 as the originally identified event 715. In such an instance, the aggregate function acts as an identity function that leaves the identified event 715 unchanged. This means that the building blocks produced will be equivalent to the original events recorded in the game.

According to an embodiment, a user (e.g., player or creator) may also activate a "highlight" action associated with one or more selected aspects of gameplay of base game 705. As the user plays the game, the selected "highlights" are transmitted, for example, in real-time, along with the game event to one or more processors 712 in the PGH server 703.

Illustratively, within the context of a streaming NBA video game event, event module 709 is used to identify specific in-game actions and states, such as "run", "pass" and "dribbling", "location", "weapon". The term "highlight" relates to a specific segment lasting for example 20 seconds in, for example, an NBA game, wherein the player successfully completes 20 consecutive passes without interception by the opponent's player.

For example, a newly created "target" in an NBA game may be:

"when the player position (playerPosition) of the PGH player equals the player position of the creator at the end of their highlight they will win PGH".

This "goal" refers to a newly formed rule, which for this example we can name "fast run from A to B" in connection with the underlying NBA game. From this "goal," the player now has a new goal, which is not one of the goals of the NBA base game (e.g., base game 705), in which the player must move from point A (the beginning of the PGH) to point B (the original ending point of the creator's PGH) in the NBA game.

The "PGH ending criteria" may be a time limit of, for example, 10 seconds, and the "ending condition" may be, for example, the end of the NBA game for the original game (i.e., when the original game timeline has no time remaining, for example, when the clock for the fourth section of the NBA game has 0 minutes and 0 seconds remaining).

The newly created "constraint" formula may be (in a non-limiting example) that in an NBA game, the constraint may be to leave the ball in the same player's hand, but not to allow the ball to be left in the other player's hand (whether from that player's team or the opponent's team). This new "constraint" (which is not part of the underlying game) may be related to the original actions and/or states that the PGH creator made while he was playing the game, or to constraints that may be derived from these actions and/or states.

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

Advantageously, the system architecture as presented in fig. 7A and further in fig. 7B-7E and other figures in the present disclosure includes streaming modules and methods using recorded data (e.g., captured video 717) and identified events (e.g., identified events 715) for transmitting gameplay, and one or more game engines and processors located, for example, in a cloud server (e.g., PGH server 703). Thus, the creation of PGHs is more configurable and can be used to create PGHs for any type of game. Because the architecture according to embodiments includes a streaming module and a transport module, in some embodiments it eliminates the necessity to retain, analyze, and store data within a client SDK (such as PGH client SDK798 shown in fig. 7C).

The block diagram shown in fig. 7B contains all of the basic components and functions depicted in fig. 7A above. However, fig. 7B presents an alternative configuration architecture, wherein the processor 708 includes a create input module 7080 located, for example, in the game client device 701.

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

According to an embodiment, the creation input module 7080 is configured and capable of generating and transmitting and/or extracting data 7150 to the PGH server 703. The creation input module 7080 accepts various types of input data from a user or creator, such as text, audio recordings, video clips, and gameplay data. It processes this data and transmits it to PGH server 703 for further analysis and possible PGH creation. The create input module 7080 may process user-provided input and autonomously extract data including events from ongoing gameplay.

In one embodiment, the data 7150 generated by the create input module 7080 is received by a logic engine 714 within the PGH server 703. In some cases, logic engine 714 may convert data 7150 into identified events 715 and/or building blocks, as shown in fig. 7H and 7I. The conversion process involves extracting key elements from user-provided data and gameplay information and converting them into discrete, actionable events that can be used as the basis for PGH data object 1200 and enable PGH creation and PGH restoration. By converting the wide variety of input data into standardized formats of identified events and/or building blocks, logic engine 714 enables the PGH creation system to operate using consistent and manageable data formats (e.g., PGH data object 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 unlimited number of PGH computer games may be created from each one or more PGH games created from the base game. PGH rules and attributes of each of the one or more PGHs are different from each other. Additional PGH computer games may be created as shown in 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, a plurality of starting points (e.g., start time stamps) and an associated plurality of ending points may be selected in each highlight. In some cases, a new PGH may be created based on each pair of selected start and end points.

Fig. 7C shows a flow diagram of a method 750 according to an embodiment, the method 750 for generating PGH based on one or more captured versions (e.g., "highlights") of historical gameplay of a single or multiplayer computer game. System 700 may be used to implement method 750. However, according to embodiments, method 750 may also be implemented by a system or processor having other configurations.

According to an embodiment, as shown in flow chart 750, one or more PGHs may be created separately for each captured bright spot, wherein each created PGH may be created separately and independently of each other using different PGH attributes 735. For example, assuming highlights are captured during gameplay, multiple PGHs may be created from the same highlight, with PGH attributes 735 that are independent of each other, such as different targets, constraints, scoring parameters, starting points, ending points, and so forth. For example, in the case of highlights captured from NBA games, two PGHs may be created from the same highlight, the first PGH targeting 5 points in the PGH and the second PGH targeting 10 passes between players of your team. In another example, assuming a2 minute highlight is captured, a first PGH may be created having PGH attributes 735 with a start time of 0:05 and an end time of 0:35, and a second PGH may be created having PGH attributes 735 with a start time of 1:10 and an end time of 1:58.

According to some embodiments, one or more PGHs may be created separately for each captured bright spot using other methods such as shown in fig. 7D, 7F, 7G, and 13.

Optionally, in a cloud-based architecture, assets from the base game are extracted and decomposed as explained below with reference to fig. 8C, prior to step 751, for example in the case of streaming the base game 705. "asset" refers to various elements that make up a gaming environment, such as graphics, 3D models, textures, sound effects, music, animations, and the like. These assets are the basic components used by game developers to create visual, auditory (and optionally sensory) experiences within a game.

At step 751, the creator or player begins playing the base game 705. According to an embodiment, once the creator or player begins playing the base game 705, an automatic command is triggered instructing the initiator 702 to begin the game. At the same time, an authentication process between the initiator 702, the game client device 701, and the PGH server 703 is initiated.

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

A detailed description of the extraction process of this step is described with reference to fig. 7J and 7L.

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

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

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

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

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

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

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

Alternatively or additionally, at step 754, an event 715 in the base game is received and/or automatically identified by event module 709 (e.g., during gameplay). Identified event 715 may include, for example, "actions" (such as "running"/"jumping") and/or "status" of the player (such as "vital value", "location", "equipment", "weapon", "property", etc. attributes of the player) performed by one or more characters in the base game.

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

At step 755, identified event 715 is processed to generate build base block 716, as explained above with reference to FIG. 7A. According to some embodiments, the identified event 715 is processed using, for example, a logic engine 714 located in a server (such as PGH server 703).

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

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

According to an embodiment, the one or more highlights correspond to selected start and end points in the computer base game. In some embodiments, the one or more bright spots correspond to particular time intervals during gameplay in a base game that the player or creator wishes to use as a basis for creating PGH 738.

According to one embodiment, a user may capture a "highlight" by clicking a selected key or mouse button defined as, for example, "highlight click (HIGHLIGHT CLICK)" during gameplay. The system may capture a predefined time interval before and after the click, for example 120 seconds before the click and 10 seconds after the click, capturing a 130 second highlight. Note that each predefined time interval ("before and after clicking") is independent and may be different from each other, and that the predefined time interval after clicking is optional, e.g., only using the time before clicking (e.g., the highlight may consist of, e.g., 120 seconds before clicking and 0 seconds after clicking). Specifically, as shown in FIG. 10A, a text prompt 1008 may provide a player with a "press Alt+R" associated herein with a "highlight" to capture a playable time "that corresponds to instructing the user to press a particular combination key using his keyboard to capture the highlight. It is important to note that the system or user may capture multiple highlights during base game video game play, and each highlight may have a different duration and/or other characteristics.

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

At step 759, the build base block is repeatedly processed, e.g., using logic engine 714, to produce a highlight attribute 714', which highlight attribute 714' includes highlight parameters, e.g., possible/potential targets and/or constraints and/or end conditions 1224 and/or PGH end 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 targets, constraints, and scores) for use by the PGH creator or player in generating the PGH. In this intermediate step, calculated potential/possible parameters (such as goals, constraints, and scores) are used as base parameters that are further used in the next step once the creator or system selects a particular game interval in the captured highlights.

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

According to one embodiment, the highlight attribute 714' is transmitted 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, during PGH creation, possible attributes may be displayed including the attributes of goal 1010 of "causing 1933 injuries" and "killing 6 enemies", constraint 1012 of "reloading more than 1 time", score parameter 1014 of "pop-head 100 minutes each time", possible PGH ending criteria 1222 of "duration: 17s" (i.e., 17 seconds), where the PGH ending criteria may be calculated, for example, by the selected starting point 1032 and ending point 1034 of the PGH (e.g., by subtracting starting point 1032 from ending point 1034), or, for example, in the case of a round-making game, subtracting the starting round number (e.g., 35) from the ending round number (e.g., 61), in this example, 26 rounds are generated, such that the PGH ending criteria may be formed.

At step 760, a starting point and an ending point of the PGH bright point are selected among the captured bright points to generate a bright point attribute 714', based on which PGH is to be formed. The selected bright spots may be based on time constraints or number of rounds or end conditions or a combination thereof. For example, PGH bright points correspond to and/or include selected starting and ending points in one of the one or more bright points. For example, in a turn-by-turn or step-oriented computer game (such as chess), a start (e.g., start) point and a stop (e.g., end) point within a sequence of games are selected.

According to other embodiments, two timestamps are selected in the highlight, the first timestamp being used as a starting point in time for the PGH and the second timestamp being used as an ending point in time for the PGH. For example, the captured highlight may be a two minute long highlight video clip transmitted from logic engine 714 to builder 734, including target (12 shots), constraint, scored possible highlight attributes. The selected time stamp may be a start time of 0:30, an end time of 1:32 for generating a 62 second PGH.

At step 761, based on the building blocks and/or identified events associated with the selected PGH highlight start and end points and/or timestamps, PGH attributes 735 are generated that include one or more parameters, such as targets and/or constraints and/or scores and/or end PGH criteria 1222 and/or end conditions 1224 and/or start and/or end points. Specifically, at this step, the build base block 716 is processed, e.g., by the logic engine 714, to generate PGH attributes 735, the PGH attributes 735 including one or more parameters including, e.g., targets, constraints, and scoring parameters that match the starting and ending points and/or time intervals of the selected PGH spot.

According to an embodiment, steps 760 and 761 may be repeated in a loop to enable the system or creator to select and change the start and end points and/or time period durations that are the basis for generating PGH (e.g., based on two selected timestamps), and based on this, calculate PGH attributes 735 (e.g., if a 2 minute bright spot is captured, with 10 shots made, with 9 shots made in the first minute of the bright spot, with 1 more shot made in the last minute, and the user selects the start point 0 minute 0 second (the start of the captured bright spot) and the end point 1 minute 0 second), the target may be updated from 10 shots of the entire selected bright spot to 9 shots within the selected first minute of the bright spot.

As shown in fig. 10C, the creator may scroll left and right through the video display 1030 and may move the respective timestamps 1032 and 1034 to the left and right to generate the final PGH video 775, and correspondingly, e.g., simultaneously, update the PGH attributes 735 in accordance with the selected final PGH video 775. Similarly, in a turn-based game (e.g., chess), the starting point may be, for example, a particular turn with all of its associated events, and the ending point may be the maximum number of turns allowed (e.g., 10 turns).

An example of a PGH that includes newly created targets is shown in fig. 9B, and includes the following targets:

"the player will need to hit the enemy without any injury"; or alternatively

"The car will run at a speed exceeding 150km/h without crashing".

It is emphasized that the highlight attribute 714' or PGH attribute 735 includes new targets, constraints, scoring parameters, ending conditions that are not included in the base game, but are now created for the first time based on the identified event 715 in the base game and from the captured "highlight" (e.g., highlight video 763 ").

Optionally, at step 763, once PGH start and end points (e.g., time stamps 763 'and/or start and end points) for PGH highlights are selected, highlight video 763″ is edited based on the selected PGH time stamps 763' and/or start and end points to generate a final PGH video. Specifically, as shown in fig. 7A, the selected PGH time stamp is transmitted from PGH builder 734 to a video processor, which cuts and creates the final PGH video.

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

According to another embodiment, at step 764, one or more PGHs are generated, e.g., at logic engine 714, based on PGH attributes 735, according to an embodiment.

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

According to one embodiment, the build base blocks and/or identified events are saved on memory, for example on storage device 713 of the PGH server, for future use after a highlight is selected. In the event that a highlight is selected and created, the build base block will be used to calculate the PGH attribute 735 and the identified event will be used to resume the base game, so both are saved in the storage of the server.

Fig. 7D illustrates a flow diagram 7501 of a method for generating PGH based on one or more captured versions (e.g., "highlights") of historical gameplay of a single or multi-person computer game, according to an embodiment. System 7000 may be used to implement method 7501. However, according to embodiments, the method 7501 may also be implemented by a system or processor having other configurations.

The flowchart 7501 of fig. 7D contains all the basic steps and functions depicted in fig. 7C above. However, FIG. 7D presents an alternative configuration architecture and method in which logic engine 714 uses only identified events to generate PGH and does not need to translate the identified events into building blocks. Thus, in such a configuration, the build base block 716 is omitted from the system architecture as shown in FIG. 7I, and accordingly, step 755 in FIG. 7C, which includes processing the identified events to generate the build base block, is not performed.

Alternatively, this embodiment utilizes only identified events 715, which convert the data to identified events 715 through intermediate processing steps.

In particular, referring to fig. 7D, a subsequent alternative step of the present invention is depicted that differs from the flowchart shown in fig. 7C.

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

Accordingly, following step 760, at step 7610, PGH attributes including one or more parameters including targets and/or constraints and/or scores are generated based on the identified events associated with the selected PGH bright point start and end points.

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

Fig. 7E includes all of the constituent elements described in fig. 7A, while also showing additional elements necessary to manage data transfer between system modules during the gameplay process of the PGH. It is emphasized that the separate figures for creating and playing PGH are provided for simplicity only and to provide a clear and concise representation of the block module (block modules). Thus, it should be appreciated that the modules and elements depicted in fig. 7A and 7E may be integrated and consolidated into a unified system.

According to an embodiment, the game client device 701 includes one or more processors 708, the processor 708 including an event module 709. During play of the PGH, the event module is configured and capable of identifying events 715 in the PGH (e.g., PGH 738) and continuously transmitting (e.g., streaming) the identified events 715 to the PGH server 703, e.g., in real time or near real time. Event 715 may include, for example, an "action" and/or "status" of a character in the PGH (e.g., as shown above in fig. 7A and 7B with respect to the creation of PGH 738).

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

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

In particular, logic engine 714 is configured and capable of processing PGH rules 719 relating to one or more targets and/or constraints and/or end PGH criteria and/or end conditions created by or received from a system by a user, as shown with reference to fig. 7A, 7B, and 7H. PGH rules 719 are logical formulas (e.g., numerical rules) derived from the target and/or constraint and/or end PGH criteria and/or end conditions.

Logic engine 714 is responsible for receiving the identified event or receiving data 7150 to process it into an identified event, possibly processing the identified event into a building block, and determining whether a goal and/or constraint and/or end PGH criteria and/or end condition is obtained based on the identified event and/or building block, and further calculating a score of PGH operation during PGH operation and after PGH operation ends.

For example, during PGH operation, logic engine 714 receives the identified event and processes it to produce a building block 716 of "triple-hit", while PGH 738 targets "five-hit". Thus, logic engine 714 recognizes that PGH has not yet ended and that two shots are also required to reach the target.

Further, according to an embodiment, during play of the PGH, the logic engine 714 is configured to generate PGH states 777 during play of the PGH, e.g., in real time or near real time, the PGH states 777 including, e.g., a state of a target and/or constraint (e.g., 1 out of 3 shots out of a target of 3 shots) and/or a state of ending PGH criteria and/or ending conditions.

In operation, during play of the PGH, logic engine 714 continuously transmits PGH state 777 to management module 778 in PGH server 703. The PGH states include one or more of a target state 12260, a constraint state 12280, a score state 7120 (the score parameters 1220 are summed based on the occurrence of the score parameters 1220 in the PGH until the computation time), an end condition state 12240, and an end PGH criteria state 12220. For example, as shown in fig. 10G, PGH states may include a target state 1041, a constraint state 1042, and a score state 7120.

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

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

The media manager 771 is configured and capable of generating server events 779. Server event 779 includes PGH state and additional data at the top of PGH state. For example, the additional data includes multimedia elements, such as text, audio, graphical elements, images, or video to be included in the PGH, or a combination of text, audio, graphical elements, images, or video, such as 3D graphical elements based on the identified event 715 and/or PGH status 777. For example, the multimedia elements may include presenting 3D advertisements to PGH players in PGH games while the user plays the PGH game, the 3D advertisements featuring advertising pages on buildings in the PGH game and/or text and/or live audio streams including recommendations and cues to the PGH players, and the like.

The event manager 749 is configured and capable of transmitting, e.g., in real-time or near real-time, a server event 779, the server event 779 including, e.g., PGH status 777, such as target status, constraint status, scoring parameters, ending PGH standard status, etc., as shown, e.g., in fig. 10G.

According to embodiments, PGH results 7502 are calculated based on the identified events and/or building blocks, and in some embodiments PGH results 7502 may be stored in storage device 713 for later transmission to PGH App. PGH result 7502 includes final PGH results (e.g., final PGH state 777 calculated at the end of PGH).

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

At step 7900, events from the base game are restored and loaded using data object 1200. According to an embodiment, the recovery process includes one or more of returning the PGH to a previous state or condition included in the base game and associated with the PGH timestamp 763 or with the starting and ending points of the PGH. Restoring includes reloading saved game events, restoring player progress and status, restoring status of other players, restoring status of game environment, and enabling restart of game play from PGH starting point (on base game) so that players can seamlessly begin playing PGH from selected starting point, thereby ensuring continuity and preserving their game experience.

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

At step 791, event 715 is automatically identified, e.g., continuously, by event module 709, e.g., during gameplay. Identified event 715 may include, for example, "actions" (such as "running"/"jumping") and/or "status" of the player (such as "vital value", "location", "equipment", "weapon", "property", etc. attributes of the player) performed by one or more characters in the PGH.

It is emphasized that according to one embodiment, the step of recovering an event (step 7900) in the base game to initiate PGH in the same "state" as before is a one-time process, used only for the recovery process. Step 791 is a continuous process in which events are identified throughout the game and continuously transmitted (e.g., streamed) for processing.

At step 792, identified event 715 is continuously transmitted (e.g., streamed) to a server (such as PGH server 703) in a continuous loop as the player or creator plays PGH 738.

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

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

At step 793, the identified event 715 is processed to generate a building block 716, and scoring parameters are calculated based on the building block. According to an embodiment, the identified event 715 is processed using, for example, a logic engine 714 located in a server (such as PGH server 703).

At step 795, the build base block is processed to determine whether PGH attribute parameters (e.g., target and/or constraint and/or end conditions 1224 and/or PGH end criteria 1222) are obtained based on the PGH rules.

At step 797, PGH state 777 is generated. According to an embodiment, PGH state 777 includes a state of the target and/or constraint and/or PGH ending criteria (e.g., 1 out of 3 shots are achieved in a target of 3 shots, 12 seconds elapsed in 30 seconds of PGH duration).

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

At step 799, a server event is transmitted from the PGH server to the game client device.

At step 796, PGH results 7502 are calculated based on the identified events and/or building blocks, and PGH results 7502 are transmitted to PGH App.

Fig. 7G illustrates a flowchart of a method 7560 for loading and running a PGH computer game (such as PGH 738 created in fig. 7B), according to an embodiment. System 700 or system 710 or system 720 or system 730 or system 785 may be used to implement method 7560. However, according to embodiments, the method 7560 may also be implemented by a system or processor having other configurations.

The method 7560 of fig. 7G includes all of the basic steps and functions previously depicted in fig. 7F. However, FIG. 7G presents an alternative configuration architecture and method in which logic engine 714 loads and runs (e.g., plays) the PGH using only the identified events, and does not need to translate the identified events into building blocks. Thus, in such a configuration, the build base 716 is omitted from the system architecture and method, as shown in FIG. 7I, and accordingly, step 793 in FIG. 7F is not performed, which includes processing the identified events to generate the build base.

Alternatively, the embodiment utilizes only the identified event 715 and calculates scoring parameters based on the identified event 715.

In particular, referring to fig. 7G, a subsequent alternative step of the present invention is depicted that differs from the flowchart shown in fig. 7F.

After step 792, at step 7930, scoring parameters are calculated based on the identified events. At step 7950, it is determined whether PGH attribute parameters (e.g., target and/or constraint and/or end PGH criteria and/or end conditions) are obtained based on the PGH rules according to the identified event. At step 7970, PGH states (e.g., scoring parameter states, states of targets and/or constraints) are generated.

A PGH result 7502 is calculated based on the identified event and transmitted to the PGH App.

Fig. 7J illustrates a detailed block diagram of a system 710 according to an embodiment, the system 710 configured and capable of creating PGH 738 based on one or more aspects of a single person configured historical gameplay. System 710 in FIG. 7J provides a detailed description of system 700 shown in FIG. 7A and system 7000 in FIG. 7B.

While certain elements shown in fig. 7A and 7B may not be explicitly shown in fig. 7J, it should be understood that the configuration of fig. 7J may include one or more of the elements from previous figures unless explicitly stated otherwise. Conversely, fig. 7J may include additional or alternative elements not depicted in fig. 7A, 7B, 7E, 7H, and 7I. The configuration shown in fig. 7J is intended to be illustrative and not limiting and should not be construed as excluding any potential elements or arrangements within the scope of the invention.

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

According to one embodiment, 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 is called a primary game or a base game, and constitutes an actual game, such as a shooting game, a racing game, a round game (e.g., chess), an NBA game, or the like. Typically, the base game 705 is developed by a game studio, as is well known 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 capable of capturing the base game 705, collecting elements in the game, such as graphical elements and source code files of the game associated with the game, and converting these elements into a structured format (e.g., JSON file format/YML file format). The asset publisher 711 further publishes the asset to an asset distributor 7860 as shown in FIG. 7E.

According to an embodiment, the PGH client SDK 798 includes an auto-synchronizer module 721, which auto-synchronizer module 721 communicates with an action streamer (Action Streamer) 722, an event state streamer (EVENTS STATE STREAMER) 723, a video module 706, a PGH controller 725, and a PGH front end (front) 726.

The auto-synchronizer module 721 is configured and capable of communicating with one or more game engines (e.g., unity, unreal engines), for example, in the case of a multiplayer game, to extract data (e.g., transformation data, vertex position data, material data, etc.) from the game engines 718 and transmit the data to the action streamer 722 and the state streamer 723. The synchronization includes elements such as player position, player vital value, enemy position, and the like.

The action streamer 722 is configured and operable to identify action events 724 'in the base game 705 and to communicate the action events 724' to the PGH server 703.

According to an embodiment, the status streamer module 723 is configured and capable of identifying status events 723' in the base game and delivering the identified status of the game entity to the PGH server 703 (specifically, to the data streamer 727).

According to some embodiments, the state streamer module 723 transmits state events after the optional discretization process, such as for a given player's position, the state streamer module 723 does not send all of the player's contiguous positions, but transmits several discretized samples.

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

PGH controller module 725 is configured and capable of receiving input actions (i.e., inputs from player devices such as keyboard strokes, mouse movements, joystick inputs, etc.) from PGH player module 729, and controlling the base game actions while playing PGH by communicating the base game actions for execution in base game 705.

PGH front end 726 is responsible for receiving display information from PGH server 703 and presenting the display information to PGH players at the top of the base game and PGH. The information received can be divided into three main types 1. Pre-game data-before starting the PGH, the module displays relevant data such as the goals and/or constraints of the PGH and/or ending PGH criteria. For example, a target state (e.g., number of clicks) and an end PGH standard state (e.g., time limit), as shown by information 1015 in fig. 10F. 2. In-game data this module provides real-time updates including PGH status 777 during gameplay of the PGH to let players know their progress. For example, a target state 1041, a constraint state 1042, and a scoring state 7120 are shown in fig. 10G. 3. Post-game data after PGH is completed, the module presents information indicating whether the goal was successfully achieved (e.g., PGH results 7502). PGH front end 726 is not limited to these particular types of information, and may display various other information to the player/creator, such as data received from server event 779 (e.g., media generated using 771).

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

Processor 708 and/or processor 712 may be suitable hardware-based electronic devices having data processing capabilities, such as a general purpose processor, a Digital Signal Processor (DSP), a special Application Specific Integrated Circuit (ASIC), one or more cores in a multi-core processor, or the like. A processor may also be comprised of, for example, multiple processors, multiple ASICs, virtual processors, combinations thereof, and the like.

The storage device 713 may be, for example, a suitable kind of volatile and/or non-volatile storage and may include, for example, a single physical memory component or multiple physical memory components. Storage 713 may also include virtual memory. The storage device 713 may be configured to store various data used in the computation, for example.

According to one embodiment, PGH server 703 is a back-end application that may be hosted, for example, on a data center (such as a private or public data center). PGH server 703 receives a data stream of actions 724 'and states 723' from base game 705 via PGH client SDK 798, the data stream including, for example, identified events (e.g., state and/or action events) from the base game and video frames from video module 706 of base game 705, and analyzes output data from action streamer 722 and state streamer 723 using one or more processors to enable services required to create, share, and play the PGH game (e.g., a single-player or multiplayer game).

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

The data streamer module 727 receives events 724 'from the action streamer 722 and also receives events 723' from the state streamer 723, and processes them and stores them for creating and playing PGH games. Processing the received data stream includes calculating a score and a goal when playing the PGH game.

The media server 728 receives the captured video 717 of the base game 705 from the video module 706. "gameplay" is defined as, for example, a particular manner in which a gamer interacts with a game and the mechanisms and rules of the game.

The media server 728 is also configured and capable of handling "gameplay", publishing it and storing it to create PGH games. The process includes cropping the relevant scenes and watermarking the file and transforming the file into a different media format as needed.

PGH player 729 may also be used to schedule a PGH game (e.g., a single or multiplayer game). Specifically, PGH player 729 receives created PGH game 738 from PGH manager 731. In operation, when a player requests to play PGH, PGH player 729 sends created PGH game 738 for play by PGH controller 725 using PGH front end 726, and PGH logic engine 714 controls execution of PGH game 738 accordingly. PGH logic engine 714 obtains identified event 715 from game client device 701 and constructs building block 716 using or from identified event 715. It then uses the identified event or building block to calculate a score state 7120 based on the score parameters and sends it to the PGH rules 719 to calculate a target state 12260, a constraint state 12280, and an end PGH criteria state 12220 (and which parts of the criteria are reached). PGH states 777 include PGH score/score state 7120, goal state 12260, constraint state 12280, end PGH criteria state 12220, and end conditions state 12240. The logic engine sends the build base block 716 and/or the identified events and PGH status 777 to the management module 778.

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

PGH manager 731 is a repository, such as a centralized storage device, for managing and storing PGH games and further enabling extraction and searching of PGH games.

PGH logic engine 714 is the heart and brain of system 710. Specifically, PGH logic engine 714 is a rules engine configured and capable of creating and running PGH games in real-time based on one or more PGH targets defined. According to an embodiment, the generated PGH target may be created when playing, for example, a base game. PGH logic engine 714 is further configured to verify that one or more objectives (e.g., targets) created from PGH building blocks 716 are achieved and calculate a score for PGH game play.

According to an embodiment, PGH building block 716 is a logical rule. The logic rules are created based on translating game events (such as states 723 'and actions 724' in base game 705) into logic phrases that can be understood by the PGH player or PGH creator. For example, in a combat computer game, an "air kicking" building block may consist of both a "jump" action and a "kicking" action followed within a certain time range (e.g., distance jump action < = 0.2 seconds), and the aforementioned building blocks are considered valid only when the kicking action occurs within the determined time range. The logic phrase may be, for example, a boolean logic phrase as shown in fig. 9B.

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

In some cases, PGH App 704 includes a PGH launcher 732, a PGH builder 734, a game logic configuration 7130, and an information feed module 736.

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

PGH builder module 734 is an editor module that implements PGH game creation.

The game logic configuration module 7130 enables a creator to configure PGH attributes 735.

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

FIG. 7K illustrates a detailed block diagram of a system 720 configured and capable of creating a PGH based on one or more aspects of historical gameplay of a multiplayer configuration, according to an embodiment. Fig. 7K includes elements of the system 700 of fig. 7A, as well as additional elements for a multi-person configuration system.

Fig. 7K may include additional or alternative elements not depicted in other figures. The configuration shown in fig. 7K is intended to be illustrative and not limiting and should not be construed as excluding any potential elements or arrangements within the scope of the 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, for example, using a client server approach. In this approach, most game events and game states are managed at the server side. According to some embodiments, game server 765 is responsible for hosting and managing multiplayer sessions of base game 705. In the client-server model, the game server 765 acts as a central authority, processing and verifying game status and player actions to ensure synchronization and fairness among all connected players. For example, in a multi-player first-person shooter game, the game server 765 will track player positions, manage game flows, and verify hit detection to ensure that all players experience the same gameplay environment. The game server 765 also facilitates communication between players, such as forwarding chat messages or coordinating pairs (matchmaking). By handling these critical tasks, the game server 765 supports the creation and play of PGHs in multiplayer games.

According to an embodiment, the game server 765 includes a base game server 766, 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 multiple versions of the base game 705. The base game server 766 contains game-specific logic, rules, and mechanisms that define a multiplayer experience. It is responsible for managing game sessions, processing player input, and updating game status in real time. For example, in a multi-player racing game, the base game server 766 will handle tasks such as track selection, player positioning, collision detection, and event triggering. It ensures that all players connected to the same multiplayer session experience the game consistently and simultaneously. The base game server 766 works in conjunction with other components of the PGH server SDK 767, such as the action streamer 768 and the state streamer 769, to enable PGH to be created and played within the multiplayer environment of the base game 705.

The PGH server SDK 767 is used to integrate PGH functions into the game server 765 of the multiplayer game, and may include an action streamer 768, a status streamer 769, and a PGH controller 770.

Action streamer 768, which is responsible for extracting player actions from base game 705 and streaming them to PGH server 703. Its function is similar to that of action streamer 722 in PGH client SDK 798.

The state streamer 769, which is responsible for extracting game state information from the base game 705 and streaming it to the PGH server 703. Its function is similar to that of the state streamer module 723 in the PGH client SDK 798.

PGH controller 770, which receives input actions from PGH player module 729 and controls base game actions when playing PGH. Its function is similar to that of PGH controller 725 in PGH client SDK 798. To facilitate a multi-person environment, PGH manager 731 communicates with PGH controller 770 and adversaries (Opponents) 762.

These modules work together to enable the creation and replay (playback) of PGHs in a multiplayer game 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 processes of computer-controlled opponents within a multiplayer environment. This module ensures that opponents provide a challenging and attractive experience for players while also maintaining balanced and fair game play. The opponent 762 module includes a game client 701, which game client 701 is a component that enables an opponent to interact seamlessly with the game world and other players. Game client 701 renders, inputs processes, and local game logic for opponent processes, allowing them to perceive and react to game states in real-time. By incorporating the game client 701 into the opponent 762 module, the system ensures that opponent actions and behaviors are smoothly integrated into the overall multi-person experience.

To facilitate efficient communication coordination, the adversary 762 module communicates directly with the PGH manager 731. PGH manager 731 sends the inputs to adversary 762 module, which is provided with the necessary information and parameters to control adversaries' behavior and decision process. The input may include data such as player position, game status updates, and specific instructions regarding opponent actions. In return, the adversary 762 module sends the output back to the PGH manager 731 informing it of the current state of the adversary, the actions taken, and any related updates. Such a two-way communication channel allows seamless integration of opponent's behavior into the overall game flow and enables creation of attractive and challenging PGHs in a multi-person scenario.

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

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

According to an embodiment, the NPC controller module 774 is configured and capable of interacting in real-time with PGH players and controlling actions of opponents replaced with NPCs while playing PGH games.

According to an embodiment, the NPC configuration 776 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 include rules of at what schemes the NPC may appear at the time and place in the scene, as well as attributes that the NPC has, such as targeting accuracy, targeting capabilities, hiding capabilities, scripts, etc. The data and media bus 7300 transmits information about the game structure, such as event type and map, so that NPC behavior of each game is preprocessed according to the received data.

According to an embodiment, the system 720 further comprises a PGH client 7800 for streaming a game or a part of a game object/file, possibly from the PGH server 703.

PGH client 7800 includes an asset renderer 781, an asset cache (cache) 783, a game controller 787, and a game engine 718.

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

Asset cache 783 is configured to retrieve graphical elements/assets in a game from asset distributor 7860 and cache them on PGH client 7800.

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

Game engine 718 is a software framework designed to create and develop games and is also configured to render the next frame and display it to the player, as shown with reference to fig. 8D.

Fig. 7L illustrates a subset block diagram 730 of the system 720 of fig. 7K configured and capable of publishing and distributing one or more assets of a base game and PGH based on one or more scenarios of single/multi-person configured historical gameplay, according to an embodiment.

FIG. 7M illustrates a flowchart of a method 780 of asset extraction and decomposition according to an embodiment.

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

At step 784, some or each graphical element is evaluated to determine if it can be broken down into smaller pieces. This involves two key checks:

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

At step 788, the graphical element is measured by comparing the graphical element to certain rules and thresholds to confirm whether the graphical element is large enough to decompose.

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

FIG. 8C illustrates another flow example of a method 780, showing a flow diagram of a method 820 of extracting and decomposing assets in a base game and/or PGH, according to an embodiment.

Referring now to fig. 8A, fig. 8A illustrates a flowchart 800 of a method for creating a PGH based on one or more aspects of historical gameplay of a multiplayer or single player configuration, according to an embodiment. Either system 700 or system 710 or system 720 may be used to implement method 800. However, method 800 may also be implemented by a system or processor having other configurations. Some of the steps in fig. 8A have been previously presented and described in detail in the preceding figures and associated detailed description according to embodiments.

Step "a. Begin game" includes initiating the PGH game creation process by sending a "start command" from creator 799 to starter module 702.

Step "b. initiating" includes initiating base game 705 play by sending a command from initiator 702 to game module 707 to begin base game 705.

Step "c. initializing" includes initializing and controlling a startup step by creating a handshake between the PGH client SDK 798 and the PGH server 703, authenticating a user on the PGH server 703, and initializing a session.

Step "d. session" includes running an authorized handshake between the game module 707 and the PGH server 703 to allow information (such as unique identifiers of clients and servers, request and response messages, and unique and random values to ensure freshness and integrity of messages) to be exchanged between the game 707 and PGH server 703.

Step "e. play" includes starting to play the actual game (e.g., base game 705), wherein rendered frames of the game are continuously displayed to creator 799, for example, on his device (e.g., mobile device or personal computer). Fig. 10A shows an example of this step, where we can see an example of the game start loading.

Step "f. Game state" includes streaming/transmitting one or more characteristic state events of the entity playing during the game to the PGH server. Examples of such characteristic states include the location, vital values, etc. of all entities in the game.

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

Capturing highlights includes operating the highlight action by selecting and capturing one or more "highlights" in the game during, for example, gameplay. Specifically, the highlight action includes selecting a scene or frame segment or interval in the game, such as 1 second, 2 seconds, 3 seconds, 4 seconds, 5 seconds, 10 seconds, 20 seconds, or more from the game. In some cases, the highlight action is operated by creator 799 by pressing a specific combination of a preset key or keys + mouse click, or any other selected combination key for capturing highlights on the game (e.g., the combination key may be pressing keyboard key ALT and keyboard key S simultaneously, which makes it a combination key ALT + S). An example of a preset combination key when it can be displayed to a player is shown in fig. 10A.

Step "i. marking the highlight" includes transmitting characteristics of the captured highlight, including characteristics such as a timestamp of the created highlight and related events in the highlight, from the game 707 to the PGH server 703. An example of this step is shown in fig. 10B, which shows a specific frame of saved in-game highlights.

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

Step "k. highlight data" includes transmitting the highlight data from PGH server 703 to PGH App 704. The highlight data includes characteristics of captured highlights (e.g., status and actions of player and game) and recordings of frames, video and audio of the game within a predefined time interval before the selected timestamp of the highlight and sends them to PGH App 704.

Step "l. screen" includes displaying highlight data along with a list of possible targets, constraints, ending PGH criteria, ending conditions, and scoring parameters on the user interface based on the identified events and/or building blocks. In some cases, highlight data is transmitted to the PGH App along with a list of possible targets and scoring parameters, and may be displayed on the user's screen. An example of this step is shown in fig. 10C and 10D.

Step "m. configuration" includes the creator 799 selection of PGH attributes for the PGH game. The PGH game creation includes combining and processing received data including start and end points, selected characteristics of the PGH (e.g., targets, constraints, end PGH criteria, end conditions, and scoring parameters) to generate PGH attributes in the PGH server 703.

The step "n.pgh" includes transmitting the configured PGH game from the PGH App 704 to the PGH server 703, and creating the PGH according to the "m.configuration step". An example of the end of this step is shown in fig. 10E.

Fig. 8B illustrates a time flow diagram of a method 810 for playing a PGH (such as the created PGH shown in fig. 8A or previous figures) created based on one or more aspects of historical gameplay configured by multiple persons or a single person, according to an embodiment. In some cases, method 810 may be activated after activating method 800. The system 700, 710, 720 or one or more processors may be used to implement the method 810. However, method 810 may also be implemented by a system or processor having other configurations.

Step "o. discovery" includes exposing a user (e.g., player 801) to one or more PGHs, such as the PGHs created at step m of fig. 8A. In some cases, PGH may be displayed in PGH App 704.

Step "p.url" includes providing the player with a link to the sharable link. It should be emphasized that other methods may be used to share PGH.

Step "q. Start PGH" includes sending a command from player 801 to initiator 702 to start playing PGH, and accordingly, in step "r. Initiate", PGH is initiated, for example, at game module 707. An example of this step is shown in fig. 10F.

Step "s. state+action" includes identifying an event, such as a state and action of an entity in the PGH or a game, according to an embodiment. For example, an event (as explained with reference to the preceding figures) may be or may include a characteristic of the PGH game and an entity during the PGH game, as well as a set of actions performed by a player or other gaming entity (such as an NPC or environmental element) during the PGH game. The actions include actions or activities performed by the player, NPC, or environmental element during gameplay, and the status may include other attributes of the entity, such as in a shooting game, it may be composed of a vital value status, weapon status, clothing, etc. The identified events are streamed from the gaming module 707 to the PGH server 703, for example, in real time.

The step "t. score" includes calculating (computer)/calculating (computing) and/or processing scoring parameters in the PGH, e.g., in real time, based on one or more scoring formulas, such as predefined scoring formulas according to embodiments of the invention, to produce a scoring state 7120 (e.g., PGH score). For example, the scoring formula may have a scoring parameter "number of shots" where the formula is simply the actual number of shots (e.g., 10 shots produce a10 point result), or each shot may obtain its score, such as 100 points per shot. The calculated PGH scores are transmitted, for example, from the PGH server 703 to the PGH game 707 in real time, and updated accordingly in each calculation cycle (e.g., each frame or 20 milliseconds of the base game) such that each score contributes to the final cumulative score. An example of this step is shown in fig. 10G, where the current cumulative score (e.g., score status/PGH score 7120) is 4000, where, for example, 5000 points may be added to the cumulative score per shot, and 200 points may be subtracted from the cumulative score per shot, resulting in a current score of 1 x 5000-5 x 200 = 4000 (in this example, 1 shot is increased by 5000 points, and each of 5 shots is subtracted by 200 points for the calculation of the current score).

Step "u. Play Results (playresults)" includes sending PGH Results (e.g., calculated in real time) at the end of each score calculation cycle. An example of this step is shown in fig. 11.

FIG. 8C illustrates a flowchart of a method 820 of extracting and decomposing assets 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 concurrently with performing method 800 and/or method 810. System 700, system 710, system 720, or system 730, or one or more processors may be used to implement method 820. However, method 820 may also be implemented by a system or processor having other configurations.

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

Extracting and decomposing assets includes retrieving game assets using, for example, source code, files, and file structures of the game, and then decomposing them into small parts for efficient data transfer. When it is possible to reorganize the game asset back to its original form or very close to its original form (up to a threshold), and when the asset is marked as suitable for decomposition, the decomposition occurs. According to an embodiment, the asset is saved to an asset Repository (Repository) 7910 component.

According to an embodiment, the "asset publishing" process operates as follows:

When the server detects the player's intention to start the PGH, whether by explicit launch or using a predictive model, it sends the necessary graphical elements to the client to render the start area of the PGH. These elements include decomposed graphical elements, and the level of detail (LOD) of these elements is customized based on various factors such as the type of element, its role in the game, its distance from the player, network capacity and performance, player preferences, and other predefined settings. This approach controls the level of detail of the game at the time of rendering.

Before transmitting these elements, the server checks whether the client has cached them locally to avoid redundant transmissions. The client then obtains any missing elements that are needed for rendering, then renders and displays the next frame to the player. In a continuous loop, the client sends its current location, view point (viewpoint), status, and any player inputs back to the server. The server processes this information to determine the next set of graphical elements to send, which may be scheduled using a single-threaded or multi-threaded priority queue.

Upon receiving these elements, the client caches them locally and uses them to render subsequent frames to accommodate the player's position, viewpoint, status, and input.

FIG. 8D illustrates a flowchart of a method 830 of publishing assets in a base game and/or PGH, according to an embodiment. Method 830 includes publishing the extracted asset, such as the asset shown in FIG. 8C, according to an embodiment. In some cases, method 830 may be activated after and/or concurrently with execution of method 820 and/or method 810. System 700, system 710, system 720, or system 730, or one or more processors may be used to implement method 830. However, method 830 may also be implemented by a system or processor having other configurations.

Step "c. start game" includes players according to embodiments starting a base game 705 for the purpose of participating in gameplay.

Step "d. Preparing a game" includes requesting an instance of a setup game from PGH server 703 for playing the game according to the embodiment. In particular, setting up an instance of a game to be played generally refers to preparing and configuring a game environment or session prior to actually starting play. The process involves various tasks related to the game type and platform, which may involve, for example, the following steps:

game settings-in-game settings (in-GAME SETTINGS) such as graphics quality, sound preferences, and control configuration are adjusted to suit personal preferences.

Game mode or level of difficulty, if applicable, a desired game mode or level of difficulty is selected. Some games offer different modes, such as a accident mode, a multiplayer mode, or a specific challenge mode.

Role or Avatar (Avatar) selection-if the game involves playing a particular role or creating an Avatar, the role is selected or customized before entering the game world.

The level or map selection selects a particular level, map or scheme at which the game is to be played. This is common in games with different stages or positions.

Multi-person settings configuration multi-person settings including inviting friends, joining a server, or setting up a private gaming lobby.

Step "e. load game" includes launching PGH server 703 according to an embodiment, PGH server 703 will host an instance of the game for a particular player.

Step "f. Starting the game" includes starting the base game 705 using the game executable uploaded in "step a." on the server loaded in step e. Above, according to an embodiment.

The step "g. The asset to be released" includes, according to an embodiment, graphical elements including, for example, graphics, sound, music, characters, textures, codes, etc., that send a first frame to be used to render the start of the game, which elements together create the environment and experience of the game.

Step "h. Assets" includes rendering a first frame in a game using various elements including graphics, sound, music, characters, grids, textures, codes, etc., which together create the environment and experience of the game, according to an embodiment.

Step "i. render screen" includes sending a command to the GPU of PGH client 7800 to render the next frame according to the player's position and view cone and available assets in the PGH client, according to an embodiment.

Step "j. Frame cycling" includes repeatedly updating and displaying in a continuous cycling fashion to obtain the next image on the screen according to an embodiment.

Step "k" (optional) user action "includes sending input to player 801 if there is some input within a period of a frame cycle according to an embodiment.

Step "l. (optional) user action" includes sending input to player 801 if there is some input within a period of a frame cycle according to an embodiment.

Step "m. the asset to be published" includes sending a game element from the game 707 to the PGH server 703. According to an embodiment, these game elements are used to render the next frame of the game, including graphics, sound, music, characters, grids, textures, and code, which together create the environment and experience of the game.

The step "n. asset" includes rendering the next frame using various elements including graphics, sound, music, characters, textures, and code, which together create the environment and experience of the game, according to an embodiment.

Step "o. render screen" includes sending a command to the GPU of PGH client 7800 to render the next frame according to the player's position and view cone and available assets in the PGH client, according to an embodiment.

Step "p. next frame" includes returning to frame loop (j.) according to an embodiment.

Referring now to fig. 12, fig. 12 illustrates an example 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'. PGH rules 719 include one or more of a goal, constraint, end PGH criteria 1222, end PGH conditions.

PGH rules 719 are used, and PGH rules 719 are based on target and/or constraint and/or end PGH criteria 1222 and/or end conditions. In some embodiments, PGH rules 719 are evaluated every frame or every predefined time interval (such as every 20 milliseconds). The PGH rules consist of formulas that check whether PGH ends, in which case it generates whether PGH ends with player's win, lose or other status, and in addition, it calculates the status of the goals and/or constraints and/or end PGH criteria 1222 and/or end conditions (1224). For example, the formula may check whether a goal is achieved, and in the case where the goal is reached, the PGH rule output PGH ends with the player's win, in the case where the constraint is reached, the PGH rule output PGH ends with the player's failure, and so on.

The goal 1226 is one or more purposes that the PGH player needs to accomplish in the PGH game in order to achieve a win in the PGH. An example of a possible target is shown in FIG. 9B, presenting a screen shot that includes a target list 920, the target list 920 including a destination name 922 and a formula 924 that are needed to complete the target. Specifically, the first listed destination name 922 is "kill", and the related formula is "when the PGH player's kill equals the creator's kill in his highlight", which means that the player's purpose is to have to make the same number of clicks as the creator's number of clicks. The target may relate to a purpose that is not included in and/or different from the purpose of the base game.

Constraint 1228 is one or more conditions that, if reached, the player loses PGH. An example of a possible constraint is shown in fig. 9C, presenting a screen shot comprising a constraint list 930, the constraint list 930 comprising constraint names 932 and formulas 934 that are required to be fulfilled by the infusion game. Specifically, the first listed constraint name 932 is "not injured", and the related formula is "when the PGH player is injured more than the creator, which means that if the player's injury level is greater than the creator's injury level, the constraint will be fulfilled and the player will lose the PGH game. Other constraints may relate to constraints that are not included in the base game and/or that are different from constraints in the base game.

Ending PGH condition 1224 includes one or more conditions that, if reached, end the PGH game, wherein either the player wins the PGH game, or the player loses PGH, or there may be no predefined PGH wins or fails. An example of a possible end condition 1224 is shown in fig. 9E, showing an example of an end condition list 990.

Ending PGH criteria 1222 includes one or more conditions that, if reached, end PGH, wherein either the player wins the PGH game or the player loses PGH, or there may be no predefined PGH wins or fails. Examples of possible ending PGH criteria 1222 are time limit (e.g., player has 30 seconds to reach a goal), number of rounds (e.g., in a round-making game, such as a chess game, the user has 20 rounds to reach a goal), a mix of rounds and time limit (e.g., in a chess game, you have 5 rounds and at most 120 seconds to reach one or more goals).

Score parameter 1220 refers to a set of predefined conditions or rules that determine how the player's score is calculated and updated during the PGH game. These conditions act as triggers, and when a particular condition is met or reached, the player's score either increases (positive score) or decreases (negative score). The score may be accumulated, meaning that each time a new condition is met, the corresponding score value is added to or subtracted from the player's current accumulated score.

Briefly, the scoring parameter is a list of rules defining how points are awarded or deducted based on certain events or actions occurring during gameplay. These rules may be predetermined, for example, and the player's score is continuously updated by adding or subtracting points as different conditions are met.

The score may be positive or negative, allowing both rewards and penalties. For example, positive scores may be awarded for completing a checkpoint, achieving a particular goal, achieving a particular state, or performing a particular action, while negative scores may be deducted for achieving a particular state, performing a particular action, achieving a constraint, for each pass or time period, and so forth.

The particular scoring parameters and their associated scoring values may vary depending on the game. Fig. 9D shows an example of a score parameter list 940, possibly listing different schemes or events-score names 942, descriptions 944, and corresponding positive or negative scores 946 to be applied when these conditions are met. For example, the score name may be "capability use (Ability used)", the description is "lose score each time you use your special capability", and the score is defined as negative, e.g., under the score parameter, each time capability is used, the capability use may result in a deduction of 100 points (in the example shown, it is labeled-100 points).

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

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

Metadata 1202 includes one or more of a name, e.g., a name of a PGH, a description, e.g., adding a text description when displaying an element in a PGH, e.g., adding a text "castle" when displaying a picture of a castle, a creator, a video, support adding webcam to enable the creator to add comments in real-time, a tag, e.g., adding text in a "shoot" action, audio, enable the creator to add, e.g., a voice-over, or a thumbnail during a PGH game.

As described above, states 723 'and actions 724' are used to create, restore, and play PGH 738. The state 723' includes a "game state" (such as map mapping of a game, starting point of a game) related to data details of the game, and a "player state" (such as position of a player in a game, ammunition, clothing) related to data of the player. The game state may include game information such as a dropped "bomb" in a scenario in the base game that is not specifically related to the player's actions in the base game. The "game action" may be related to a scenario in the base game, such as where the "bridge" in the game explodes once the player passes through the bridge, so that the scenario is stored and may be used to create a PGH.

These data relate to players and trapped and uncapped NPC players. For example, the status 723' may include data information related to the status of the caged NPC player (which relates to the status of players in the base game). Accordingly, actions 724' include game actions and player actions. For example, where the base game includes movement actions of the player and/or NPC player, these movements are restored and included in the PGH.

Fig. 13 illustrates a flowchart of a method 1300 for loading and running a PGH computer game (such as PGH 738 created in fig. 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 1300. However, according to embodiments, method 1300 may also be implemented by a system or processor having other configurations.

At step 1310, events from the base game are restored and loaded. According to an embodiment, the recovery process includes one or more of the steps described with reference to fig. 7F. At step 1320, the system begins playing the PGH by initializing the game engine and loading the necessary resources. At step 1330, video or other signals of the base game are captured. These signals may provide information for understanding events and building blocks within the PGH. One such method involves analyzing video frames of 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 analytics approach enables the system to learn deep about the game elements, player actions, and game states of the PGH, rather than relying solely on internal data of the game.

According to an embodiment, another method for obtaining input from a PGH is by analyzing brain signals, for example by using neural network-like techniques. By monitoring and interpreting these physiological signals, the system can infer a player's intent, emotion, and response during gameplay, and further infer gameplay elements, player actions, and game status. Such information may be used to extract identified events and/or building blocks, and may also be used in combination with video analytics or alone.

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

At step 1350, the video is processed using the video analytics processor, alternatively or additionally, the signal is processed using the signal analytics processor. These processors are designed to process specific data types and perform the required analysis. The video analytics processor applies 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 analysis processors employ signal processing techniques, pattern recognition and machine learning methods (including neural networks) to interpret brain signals and extract identified events and/or building blocks.

At step 1360, it is determined whether PGH attribute parameters (e.g., target and/or constraint and/or end PGH criteria and/or end conditions) are obtained based on PGH rules from the analyzed video or analyzed signal, and scoring parameters are calculated as explained above with reference to fig. 7E and 7F. At step 1370, PGH states 777 (e.g., states of scoring parameters, targets, and/or constraints) are generated as described with reference to the previous figures. At step 1380, the PGH status is transmitted to the management module and server events are provided based on the PGH status and/or identified events, as described with reference to the previous figures. At step 1390, a server event is transmitted from the PGH server to the game client module. At step 1395, PGH results are calculated based on the identified events and transmitted to, for example, PGH App.

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

According to some embodiments, a non-transitory computer-readable storage medium is provided having instructions stored thereon that, when executed by a computing system, cause the computing system to perform a method for creating or running one or more Playable Gameplay Highlights (PGHs) computer games from a computer base game.

In the patent application, it must be clarified that the various embodiments and elements depicted in the drawings may have a relationship or equivalence to each other, possibly different in naming. In addition, some elements present in one embodiment may not be present in another embodiment for clarity and simplicity only. It should be understood that such omissions do not materially obscure the scope or nature of the invention. For example, PDS server 195 may be equivalent to PGH server 703, and processing circuits 110A and 110B may be equivalent to game client device 701 and/or starter 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 a processing circuit configured to execute several functional modules according to computer-readable instructions implemented on a non-transitory computer-readable storage medium. Such functional modules are hereinafter referred to as being comprised in a processing circuit.

According to some embodiments, the present disclosure provides a computer control system programmed to implement the methods of the present disclosure, such as methods 750, 7500, 7501, 7560, and 1300. FIG. 14 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 may process various aspects of the information of the present disclosure, such as questions and answers, responses, statistical analysis. The computer system 1401 may be a user's electronic device or a computer system that is remote from the electronic device. The electronic device may be a mobile electronic device.

The computer system 1401 includes a central processing unit (CPU, also referred to herein as a "processor" and a "computer processor") 1405, which may be a single or multi-core processor or more than one processor 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 electronic display adapters. The memory 1410, the storage unit 1415, the interface 1420, and the peripheral devices 1425 communicate with the CPU 1405 through a communication bus (solid line) such as a motherboard (motherboard). The storage unit 1415 may be a data storage unit (or data repository) for storing data. The computer system 1401 may be operatively coupled to a computer network ("network") 1430 by way of a communication interface 1420. The network 1430 may be the Internet (Internet), an Internet (intranet), and/or an extranet, or an intranet and/or an extranet in communication with the Internet. In some cases, network 1430 is a telecommunications and/or data network. Network 1430 may include one or more computer servers, which may support distributed computing, such as cloud computing. In some cases, with the aid of the computer system 1401, the network 1430 may implement a peer-to-peer network (peer-to-peer network), which may enable devices coupled to the computer system 1401 to operate as clients or servers.

The CPU 1405 may execute a series of machine-readable instructions, which may be embodied in a program or software. The instructions may be stored in a memory location, such as memory 1410. 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 the CPU 1405 may include read, decode, execute, and write back.

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

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

The computer system 1401 may communicate with one or more remote computer systems over a network 1430. For example, the computer system 1401 may communicate with a remote computer system of a user (e.g., a parent). Examples of remote computer systems and mobile communication devices include personal computers (e.g., portable PCs), tablet or tablet PCs (e.g.,iPad、Galaxy Tab), phone, smart phone (e.g.,IPhone, android supporting device,) A personal digital assistant, a wearable medical device (e.g., fitbits), or a medical device monitor (e.g., an epileptic monitor). A user may access the computer system 1401 using the network 1430.

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

The code may be pre-compiled and configured for use with a machine having a processor adapted to execute the code, or may be compiled during run-time. The code may be provided in the form of a programming language that is selectable to enable execution of the code in a precompiled or as-compiled (as-compiled) manner.

Aspects of the systems and methods provided herein, such as game client device 701, may be programmatically embodied. Aspects of the technology may be considered an "article" or "article (articles of manufacture)" of manufacture in the form of machine (or processor) executable code and/or associated data, typically embodied or carried out by a machine readable medium. The machine executable code may be stored on an electronic storage unit such as a memory (e.g., read only memory, random access memory, flash memory) or hard disk. The "storage" media may include any or all of the tangible memory of a computer, processor, etc., or related modules thereof, such as various semiconductor memories, tape drives, disk drives, etc., which may provide non-transitory storage for software programming at any time. All or part of the software may sometimes communicate over the internet or over a variety of other telecommunications networks. For example, such communication may cause software to be loaded from one computer or processor to another computer or processor, e.g., from a management server or host to a computer platform of an application server. Thus, another type of medium capable of carrying software elements includes light, electrical and electromagnetic waves, such as those used across physical interfaces between local devices, through wired and fiber-optic landline networks, and over various air links. Physical elements carrying such waves, such as wired or wireless links, optical links, etc., may also be considered to be media carrying software. As used herein, unless limited to a non-transitory, tangible "storage" medium, terms such as computer or machine "readable medium" refer to any medium that participates in providing instructions to a processor for execution.

Accordingly, a machine-readable medium (such as computer-executable code) may take many forms, including but not limited to, tangible storage media, carrier wave media, or physical transmission media. Nonvolatile storage media includes, for example, optical or magnetic disks (such as any storage devices in any computer or the like) such as may be used to implement a database or the like as shown in the accompanying drawings. Volatile storage media include dynamic memory, such as the main memory of a computer platform. Tangible transmission media include coaxial cables, copper wire and fiber optics, including the wires that comprise a bus within a computer system. Carrier wave transmission media can take the form of electrical or electromagnetic signals, or acoustic or light waves, such as those generated during Radio Frequency (RF) and Infrared (IR) data communications. Thus, common forms of computer-readable media include, for example, a floppy disk (floppy disk), a flexible disk (flexibledisk), hard disk, magnetic tape, any other magnetic medium, a CD-ROM, DVD, or DVD-ROM, any other optical medium, punch cards paper tape, any other physical storage medium with punch patterns, RAM, ROM, PROM and EPROM, a FLASH-EPROM, any other memory chip or cartridge, a carrier wave transporting data or instructions, a cable or link transporting such a carrier wave, or any other medium from which a computer can read programming code and/or data. Many of these forms of computer readable media may be involved in carrying one or more sequences of one or more instructions to a processor for execution.

The computer system 1401 may include an electronic display 1435 or be in communication with the electronic display 1435, the electronic display 1435 including a User Interface (UI) 1440 for providing, for example, questions and answers, analysis results, 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 utilizing instructions provided by one or more processors disclosed herein. The algorithm may be implemented in software after execution by the central processor 1405. The algorithm may be, for example, a random forest, a graphical model, a support vector machine, or other algorithm.

Although the steps described above illustrate methods according to the exemplary systems, one of ordinary skill in the art will recognize many variations based on the teachings described herein. These steps may be accomplished in a different order. Steps may be added or deleted. Some steps may include sub-steps. Many steps may be repeated as often as is beneficial to the platform.

Each of the examples as described herein may be combined with one or more other examples. Further, one or more components of one or more examples may be combined with other examples.

While the detailed description contains many specifics, these should not be construed as limiting the scope of the disclosure, but merely as illustrating different examples and aspects of the disclosure. It should be understood that the scope of the 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. Many variations, changes, and alternatives will be apparent to those skilled in the art without departing from the scope of the disclosure. It should be understood that various alternatives to the embodiments of the disclosure described herein may be employed without departing from the scope of the invention. Accordingly, the scope of the invention should be limited only by the scope of the following claims and equivalents thereof.

Although certain elements are depicted in one or more figures, it will be understood that not every element may be included in every figure. The drawings are intended to be illustrative, not limiting, and elements from one drawing may or may not be present in other drawings. It should be understood, however, that the invention is not limited to the particular elements or configurations shown in the drawings, and that additional or alternative elements and configurations may be included within the scope of the invention.

It is to be understood that the invention is not limited in its application to the details set forth in the description or illustrated in the drawings. The invention is capable of other embodiments and of being practiced or of being carried out in various ways. Accordingly, it is to be understood that the phraseology and terminology employed herein is for the purpose of description and should not be regarded as limiting. Thus, those skilled in the art will appreciate that the conception upon which this disclosure is based may readily be utilized as a basis for the designing of other structures, methods and systems for carrying out the several purposes of the presently disclosed subject matter.

It should also be appreciated that a system in accordance with the present invention may be at least partially implemented on a suitably programmed computer. Likewise, the invention contemplates a computer program being readable by a computer for executing the method of the invention. The present invention also contemplates a non-transitory computer readable memory tangibly embodying a program of instructions executable by a computer for executing the method of the present invention.

Unless specifically stated otherwise, as apparent from the following discussions, it is appreciated that throughout the specification discussions utilizing terms such as "processing," "computing," "comparing," "determining," "calculating," "receiving," "providing," "obtaining," "detecting," or the like, refer to the action and/or processes of a computer that manipulates and/or transforms data into other data represented as physical (such as electronic) quantities and/or as physical objects. The term "computer" should be construed broadly to cover any type of hardware-based electronic device having data processing capabilities, including, as non-limiting examples, the processors, mitigation units, and inspection units disclosed herein in the present disclosure.

Although various features of the invention have been described with respect to specific embodiments. Other embodiments of the mixing and matching features not depicted in the drawings are considered to be within the purview of one of ordinary skill in the art.

It is to be understood that the phraseology or terminology employed herein is for the purpose of description and not of limitation. The means, materials, and steps for performing the 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 changes may be applied to the embodiments of the invention as described above without departing from its scope in and defined by the appended claims.

The present application provides the following:

Clause 1. A computer-implemented method for creating one or more Playable Gameplay Highlights (PGH) computer games from a computer base game, the method comprising:

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

processing the data to generate the event and processing the event by the logic engine to generate a building block or processing the data by the logic engine to generate a building block;

Capturing one or more highlights in the computer base game, wherein each of the one or more highlights corresponds to a selected start point and an end point in the computer base game;

Processing, by the logic engine, the building blocks to generate highlight attribute parameters including one or more of a possible target, a possible constraint, a possible PGH ending criterion, a possible ending condition, and a possible scoring parameter associated with each of the one or more highlights, respectively;

Selecting a PGH bright spot in each of the one or more bright spots, wherein the PGH bright spot corresponds to a selected starting point and ending point in one of the one or more bright spots;

Processing, by the logic engine, the building blocks associated with the selected PGH highlight to generate PGH attributes including one or more of a goal, a constraint, a PGH ending criterion, an ending condition and a scoring parameter, the selected starting point and ending point;

Creating the one or more PGH computer games based on the PGH attributes, wherein each of the PGH computer games includes PGH rules associated with the PGH attributes and used to configure play of the one or more PGH computer games.

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

Restoring the event associated with the computer base game;

continuously identifying the event in the one or more PGH computer games;

Continuously streaming the identified events from the game client device to the logic engine;

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

continuously processing the building blocks using the logic engine to determine whether the PGH attribute parameters were obtained based on the PGH rules, and

Ending play of the one or more PGH computer games when the PGH attribute parameters have been obtained.

Clause 3 the computer-implemented method of clause 2, comprising:

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

Calculating one or more of a scoring parameter, a state of the target, a state of the constraint, a state of the PGH ending standard, and

Transmitting the PGH status to a management module included in the server, and

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

Clause 4 the computer-implemented method of clause 3, comprising:

transmitting the server event from the server to the game client device, and

The server event is displayed on a display.

Clause 5 the computer-implemented method of clause 4, comprising:

Calculating a PGH result for each of the one or more PGH computer games based on the event;

Transmitting the PGH results to a PGH application (PGH App), and

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

Clause 6 the computer-implemented method of clause 1, comprising:

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

Clause 7 the computer-implemented method of clause 1, wherein the processing comprises:

One or more of text, audio, images, video recordings, other video of the base game are converted to the event.

Clause 8 the computer-implemented method of clause 1, comprising:

An event module is used to identify an event in the computer base game, wherein the event module is included in a processor in a game client device.

Clause 9. The computer-implemented method of clause 1, wherein the selecting the PGH bright spot comprises:

a time stamp start point and a time stamp end point are selected in the computer base game.

Clause 10 the computer-implemented method of clause 1, comprising:

Transmitting video of the computer base game captured by a video module in a game client device to the server;

transmitting the one or more bright spots from the server to a PGH application (PGH App);

editing the video based on the selected PGH timestamp to generate a final PGH video, and

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

Clause 11 the computer-implemented method of clause 2, comprising:

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

Clause 12 the computer-implemented method of clause 1, comprising:

two or more PGH computer games are created based on a single highlight of the one or more highlights.

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

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

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

Clause 16 the computer-implemented method of clause 1, wherein the PGH attribute is selected by a creator of the PGH computer game or is automatically selected by the logic engine.

Clause 17 the computer-implemented method of clause 1, wherein the PGH attributes further comprise one or more of:

The name, description, thumbnail "preview" image and label of the PGH computer game.

Clause 18 the computer-implemented method of clause 1, wherein the character is a Player Character (PC) or a non-player character (NPC).

Clause 19 the computer-implemented method of clause 1, wherein the goal or the constraint or the PGH ending standard or the ending condition or the scoring parameter is created using a generative Artificial Intelligence (AI) algorithm and model.

Clause 20 the computer-implemented method of clause 1, wherein the game client device is included in the server.

Clause 21 the computer-implemented method of clause 1, comprising loading and running the one or more PGH computer games, the loading and running comprising:

Recovering the event from the base game;

Capturing video or other signals of the base game;

Transmitting the captured video or other signals to the server;

Processing the video using a video analysis processor or processing the signal using a signal analysis processor;

Determining whether the PGH attribute parameter is obtained based on the PGH rule and the analyzed video or the analyzed signal, and

The scoring parameters are calculated.

Clause 22, a computer-implemented method for creating one or more Playable Gameplay Highlights (PGH) computer games from a computer base game, the method comprising:

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

processing the data using the logic engine to generate the event;

Processing, by the logic engine, the event to generate a highlight attribute parameter comprising one or more of a possible target, a possible constraint, a possible PGH ending criterion, a possible ending condition, and a possible scoring parameter associated with each of the one or more highlights, respectively;

processing, by the logic engine, the event related to the selected PGH highlight to generate PGH attributes including one or more of a goal, a constraint, a PGH ending criterion, an ending condition, and a scoring parameter;

Clause 23 the computer-implemented method of clause 22, comprising loading and running the one or more PGH computer games, the loading and running comprising:

Restoring the event associated with the base game;

continuously identifying the event in the one or more PGH computer games;

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

Clause 24 the computer-implemented method of clause 23, comprising:

generating a PGH state for each of the one or more PGH computer games, wherein the generating the PGH state includes:

Transmitting the PGH status to a management module included in the server, and

Clause 25 the computer-implemented method of clause 24, comprising:

transmitting the server event from the PGH server to a game client device, and

The server event is displayed on a display.

Clause 26 the computer-implemented method of clause 24, comprising:

calculating PGH results 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

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

Clause 27 the computer-implemented method of clause 22, comprising:

the one or more highlights are selected by clicking one or more keys during gameplay of the computer base game.

Clause 28 the computer-implemented method of clause 22, comprising:

Clause 29 the computer-implemented method of clause 22, wherein the selecting the PGH bright spot comprises:

Clause 30 the computer-implemented method of clause 22, comprising:

Transmitting video of the computer base game captured by a video module in the game client device to the server;

Clause 31 the computer-implemented method of clause 23, comprising:

Clause 32 the computer-implemented method of clause 24, comprising:

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

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

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

Clause 36 the computer-implemented method of clause 22, wherein the PGH attribute is selected by a creator of the PGH computer game or automatically selected by the logic engine.

Clause 37 the computer-implemented method of clause 22, wherein the PGH attributes further comprise one or more of:

Clause 38 the computer-implemented method of clause 33, wherein the character is a Player Character (PC) or a non-player character (NPC).

Clause 39 the computer-implemented method of clause 22, wherein the goal or the constraint or the PGH ending standard or the ending condition or the scoring parameter is created using a generative Artificial Intelligence (AI) algorithm and model.

Clause 40 the computer-implemented method of clause 22, wherein the game client device is included in the server.

Clause 41 the computer-implemented method of clause 22, comprising loading and running the one or more PGH computer games, the loading and running comprising:

Recovering an event from the base game;

Capturing video or other signals of the base game;

Transmitting the captured video or other signals to the server;

The scoring parameters are calculated.

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

restoring an event associated with the computer base game;

continuously identifying the event in the one or more PGH computer games;

Continuously streaming the identified events from the game client device to a logic engine;

Clause 43 the method of clause 42, comprising:

Calculating one or more of scoring parameters, states of targets, states of constraints, states of PGH ending criteria;

Transmitting the PGH status to a management module included in the server, and

Clause 44 the method of clause 43, comprising:

Transmitting the server event from the PGH server to the game client device, and

The server event is displayed on a display.

Clause 45 the method of clause 44, comprising:

Transmitting the PGH results to a PGH application (PGH App), and

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

Clause 46 the method of clause 42, comprising:

Clause 47 the method of clause 42, comprising:

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

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

Clause 50 the method of clause 49, wherein the aggregation function combines the one or more events of the same type or different types.

Clause 51. The method of clause 42, wherein the PGH attribute is selected by the creator of the PGH computer game or automatically by the logic engine.

Clause 52. The method of clause 51, wherein the PGH attributes further comprise one or more of:

Clause 53 the method of clause 43, wherein the goal or constraint or PGH ending standard or ending condition or scoring parameter is created using a generative Artificial Intelligence (AI) algorithm and model.

Clause 54 the method of clause 42, wherein the game client device is included in the server.

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

recovering the event from the computer base game;

Capturing video or other signals of the base game;

Transmitting the captured video or other signals to the server;

determining whether the PGH attribute parameter has been obtained based on the PGH rule and the analyzed video or the analyzed signal, and

The scoring parameters are calculated.

Clause 56 a system for creating one or more Playable Gameplay Highlights (PGH) computer games from a computer base game, the system comprising:

a game client device comprising processing circuitry, the processing circuitry comprising one or more processors, the one or more processors include an event module configured to communicate with a PGH server, the PGH server including:

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

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

processing the data to generate the event;

processing the event to generate a building block, or processing the data to generate a building block;

capturing one or more highlights in the computer base game, wherein each of the captured one or more highlights corresponds to a selected start point and an end point in the computer base game;

Processing, by the logic engine, the building blocks associated with the selected PGH highlight to generate PGH attributes including one or more of a goal, a constraint, a PGH ending criterion, an ending condition, and a scoring parameter;

Clause 57 the system of clause 56, wherein the one or more processors are further configured and capable:

loading and running the one or more PGH computer games, the loading and running comprising:

Restoring the event associated with the base game;

continuously identifying the event in the one or more PGH computer games;

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

The system of clause 56, wherein the one or more processors are further configured and capable:

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

Transmitting the PGH status to a management module included in the server, and

Clause 59 the system of clause 57, wherein the one or more processors are further configured and capable:

Recovering the event from the base game;

Capturing video or other signals of the base game;

Transmitting the captured video or other signals to the server;

The scoring parameters are calculated.

Clause 60, a non-transitory computer-readable medium containing program instructions for creating one or more Playable Gameplay Highlights (PGH) computer games from a computer base game, wherein execution of the program instructions by one or more processors of a computer system causes the one or more processors to perform a method comprising:

receiving, using a logic engine, an event or data related to the computer base game, wherein the logic engine is included in a processor located in a server;

Processing the event by the logic engine to produce a building block or processing the data by the logic engine to produce a building block;

Claims

1. A computer-implemented method for creating one or more Playable Gameplay Highlights (PGHs) computer games from a computer base game, the method comprising:

2. A computer-implemented method for creating one or more Playable Gameplay Highlights (PGHs) computer games from a computer base game, the method comprising:

processing the data using the logic engine to generate the event;

3. A method of loading and running one or more playable game play highlights (PGHs) computer games created based on a computer base game, the method being performed by a game client device, the method comprising:

restoring an event associated with the computer base game;

continuously identifying the event in the one or more PGH computer games;

4. A system for creating one or more Playable Gameplay Highlights (PGHs) computer games from a computer base game, the system comprising:

processing the data to generate the event;

5. A non-transitory computer-readable medium containing program instructions for creating one or more Playable Gameplay Highlights (PGHs) computer games from a computer base game, wherein execution of the program instructions by one or more processors of a computer system causes the one or more processors to perform a method comprising: