Method and system for level change in a game streaming system

Abstract

The game streaming system (100) concurrently executes different instances (111, 112) of a game program (109), each instance employing a different set of hardware resources, including different local memory (432, 433), such as hardware resources of different servers (102, 103) or different GPUs. Based on a game state, the game streaming system streams rendered frames from a first set of hardware resources associated with a game level to a client device in which the rendered frames depict a portion of a virtual environment. In response to an indication from the game program of a change in game level to a new game level, the game streaming system transmits a player state (108) to another set of hardware resources and begins streaming rendered frames from the other set of hardware resources to the client device.

Description

Technical Field Background Technology

[0001] Video game systems, such as game consoles or personal computers, allow users to interact with a virtual environment generated by the game program. Users interact with the game program via a game controller or other input device, and in response to user input, the game program modifies the game state associated with the game. Based on the game content, the game program changes aspects of the virtual environment displayed to the user. Therefore, by changing a series of inputs that alter the game state, the user plays the game associated with the game program.

[0002] To generate and display virtual environments for users, game programs utilize game assets, such as stored graphical objects, textures, and sound files. To quickly access these assets and thus provide a satisfactory user experience, game programs typically store the necessary assets in relatively fast memory, such as Dynamic Random Access Memory (DRAM). However, many game programs implement large virtual environments where all the game assets associated with the entire virtual environment cannot be stored in relatively fast memory. Such game programs often employ a "leveling" approach, where the virtual environment is divided into relatively discrete levels or worlds. The game program stores the entire set of assets associated with the virtual environment in relatively slow memory, such as one or more disk drives, while only loading those assets associated with the level the user is currently interacting with into fast memory.

[0003] In response to a user changing their level (i.e., the user providing game input indicating they want to switch game levels), the game program transfers the game assets associated with the new level (the level being switched to) from slow memory to fast memory. However, this transfer process can take a relatively long time, requiring the game program to pause the game flow, such as by displaying a "loading screen" to the user while the transfer is taking place. This interruption in the game flow negatively impacts the user's gaming experience. Attached Figure Description

[0004] This disclosure can be better understood by referring to the accompanying drawings, and many of its features and advantages will be apparent to those skilled in the art. The same reference numerals are used in different drawings to denote similar or identical items.

[0005] Figure 1 This is a block diagram of a game streaming system that transmits player state information between concurrently running game instances in response to a change in game level, according to some embodiments.

[0006] Figure 2 The illustration shows the transmission of player status information in response to changes in game level, according to some embodiments. Figure 1A block diagram of an example game streaming system.

[0007] Figure 3 Based on some embodiments and Figure 1 A diagram showing the player status information associated with the game program in the game streaming system.

[0008] Figure 4 The illustration shows, according to some embodiments, the preloading of assets associated with different game levels onto different servers. Figure 1 A block diagram of an example game streaming system.

[0009] Figure 5 This is a flowchart of a game streaming system that transmits player state information between concurrently running game instances in response to changes in game level, according to some embodiments. Detailed Implementation

[0010] Figures 1 to 5 The illustration depicts techniques for improving user experience during level switching in a game streaming system, according to some embodiments. The game streaming system executes different instances of a game program simultaneously, each instance employing a different set of hardware resources, including different local memories, such as hardware resources from different servers or different GPUs. Each game instance loads resources for a different game level into its corresponding local memory. Based on the game state indicating a given game level, the game streaming system streams rendered frames from a first set of hardware resources associated with the game level to a client device, where the rendered frames depict a portion of a virtual environment. In response to an indication from the game program that the game level has changed to a new game level, the game streaming system transfers the player state to a second set of hardware resources associated with the new game level and begins streaming rendered frames from the second set of hardware resources to the client device. Therefore, the game streaming system reduces or eliminates the amount of time the game stream is interrupted, thereby improving the user experience.

[0011] To further illustrate this by example, in some embodiments, the game streaming system includes two servers, designated Server A and Server B for illustrative purposes, with instances of a game program running concurrently at each of Server A and Server B. Each of Servers A and B loads assets for different game levels, designated respectively as Level A and Level B, into local DRAM memory, allowing rapid access to these assets to render frames for streaming. A user on a client device (e.g., a computer or video streaming device) initiates the game and initially accesses Level A. Therefore, the game streaming system uses the game instance running at Server A to generate rendered frames representing the virtual environment associated with Level A based on assets stored in Server A's local memory, and streams these rendered frames from Server A to the client device. Furthermore, Server A maintains player state information representing information about the user's interactions with the game during the current game session.

[0012] In response to a user interaction requesting a level change to level B, the game streaming system transmits the player's state to server B. The game instance on server B begins generating rendered frames representing the virtual environment associated with level B based on assets stored in server B's local memory, and streams these rendered frames from server B to the client device. Changes in the source of the rendered frames in the game streaming system are synchronized from server A to server B, making changes on the server transparent to the user on the client device. Furthermore, because server B has already preloaded the assets associated with level B into the corresponding local memory, server B can begin generating rendered frames associated with level B relatively quickly. Conversely, conventional systems must load assets for each new level from a relatively slow data storage device (e.g., a hard drive), requiring the user to pause interaction with the game while assets are being loaded from the data storage device. Therefore, by transmitting the player's state to different game instances with preloaded level assets, the game streaming system reduces the time associated with changing game levels, thereby improving the user experience.

[0013] Figure 1 The illustration shows a game streaming system 100 according to some embodiments, which is generally configured to stream rendered game content from a server set 101 to a client device 104 and to transfer player state information between concurrently running game instances in response to a change in game level.

[0014] In the depicted example, server set 101 and client device 104 communicate via network 110, which is a packet-switched network or other network typically configured to transmit data (including video data) via one or more routers, servers, communication towers (e.g., cellular communication towers), or any combination thereof. Therefore, in various embodiments, network 110 is a wide area network (e.g., the Internet), a local area network, or any combination thereof.

[0015] Server set 101 and client device 104 are typically configured to jointly implement a streaming game session, wherein interactive game content is streamed from server set 101 to client device 104. Server set 101 includes multiple servers, such as servers 102 and 103 illustrated. Each of servers 102 and 103 can be any type of computer device that implements the functionality further described herein, such as a rack server, a cluster server (i.e., server devices implemented in a cluster of server devices), a mobile server device, or a combination thereof. Client device 104 can be any computer device capable of displaying video frames to a user and receiving user input, and therefore can be a desktop or laptop computer, a digital media player (e.g., a streaming media player), a game console, a smartphone, a tablet computer, etc.

[0016] To support the streaming of game content to client device 104 during a streaming game session, each of servers 102 and 103 includes multiple processing units, such as a central processing unit (CPU) and a graphics processing unit (GPU). A CPU is a processing unit that is typically configured to execute a general-purpose set of instructions organized as a computer program to perform tasks on behalf of the server. Examples of such computer programs include operating systems, virtual machines, data security programs (e.g., data encryption / decryption programs), web pages, database programs, etc.

[0017] A GPU is a processing unit that is typically configured to perform operations associated with graphics and vector processing based on commands received from a CPU. For example, during the execution of one or more general-purpose programs, the CPU generates commands for generating and manipulating graphics models for display and provides these commands to the GPU. In response, the GPU executes these commands by performing one or more corresponding graphics operations, thereby manipulating the graphics models to generate one or more frames for display. In some embodiments, the frames generated by the GPU are rendered frames ready to be displayed on a display device.

[0018] To support the reception and display of streamed game content, client device 104 includes a CPU and a GPU (not shown). Each of these modules is similar to its counterpart in servers 102 and 103. Therefore, for example, the CPU of client device 104 is typically configured to execute general-purpose instructions on behalf of client device 104, such as executing one or more of an operating system, web browser, etc. It should be understood that in some embodiments, client device 104 typically has relatively less computing power compared to servers 102 and 103. Therefore, game streaming system 100 utilizes the computing power of servers 102 and 103 to stream game content to client device 104, where the quality of this game content is higher than what could be generated by client device 104 alone.

[0019] In operation, client device 104 initiates a game streaming session in response to a user requesting a game session via a computer program (not shown) executing at client device 104 (such as via a web browser, a dedicated game streaming program, a video streaming service program, etc.). In response to the user's request, the client device sends a game session request to server 102 via network 110. In response, server 102 initiates the execution of game program 109. In some embodiments, server 102 is configured to execute any of the game program libraries, and the request provided by client device 104 indicates a specific game program to be executed.

[0020] To support reduced interruptions in the game stream, in response to a game session request, each of servers 102 and 103 initiates the execution of a separate instance of the game program 109 (designated as instances 111 and 112, respectively). In some embodiments, each of instances 111 and 112 includes the same instructions for the game program 109 to be executed, but uses different game assets to implement different game levels, as further described herein. Specifically, in the illustrated example, it is assumed that each of servers 102 and 103 is designated to use different game assets (e.g., different graphics objects, textures, audio files, etc.) to implement different game levels.

[0021] In response to the user initiating game program 109, each of servers 102 and 103 respectively initiates instances 111 and 112, and loads the corresponding game-level assets from the data storage device into local storage. Figure 1(Not shown in the image), the asset can be accessed relatively quickly in local storage. Each of instances 111 and 112 determines an initial game level associated with the game program used for the current game session. In some embodiments, the initial game level may be a fixed game level. In other embodiments, the initial game level may be indicated by the user or by stored game state information (e.g., a saved file). The server associated with the initial game level executes the corresponding game instance to generate a set of frames for streaming to client device 104. Another server may enter a paused state to await the transmission of player state information, as described further below. For illustrative purposes, it is assumed that server 102 is associated with the initial game level.

[0022] During execution, instance 111 maintains a set of data called the game state, which represents the conditions or state of the game. The user of client device 104 provides input data using an input device. The input device can be a keyboard, game controller, microphone, or other input devices, or any combination thereof. Client device 104 communicates the input data to instance 111 via network 110. In response to the input data, instance 111 modifies the game state according to the rules of the specific game implemented by game program 109.

[0023] Based on the game state and according to the rules of the implemented game, instance 111 uses the CPU and GPU of server 102 to generate rendered frames that represent visual game information such as a virtual environment, game board, selection screen, head-up display (HUD), or any combination thereof. Server 102 provides these rendered frames (designated as streaming frames 115) to network 110 for communication with client device 104. Client device 104 receives at least a subset of streaming frames 115 and uses the GPU to display the received frames at a display (not shown). Thus, client device 104 displays visual game information to a user, who, in response, provides further input data using a game controller or other input device, resulting in further changes to the game state maintained by game program 109 and corresponding changes to the frames of frame stream 115. In this way, the user of client device 104 interacts with game program 109 to play the game executed at server 102.

[0024] When a user plays the game, instance 111 maintains a data structure (e.g., a data file) for a specified player state 108, which represents an aspect of the game state uniquely associated with the current game session, the user of client device 104, or any combination thereof. Player state 108 can therefore represent a player's score, the progress or status of a game character, game items collected or modified by the user, the status of non-player characters associated with the game, or any combination thereof.

[0025] While playing the game, a user on a client device can interact with the game instance 111 in one or more ways that indicate changes to the game level associated with the game program 109. In some embodiments, different levels are determined by the designer or programmer of the game program 109 and are therefore identified by the program itself in response to game level change instructions. Examples of game level change instructions include the user selecting a specific game level via an input device, indicating the progress of a game character (e.g., the game character moving to a new or different part of the virtual environment), etc.

[0026] In some embodiments, instance 111 indicates a game level change when it determines that a new or different game asset will be loaded into local memory. For example, instance 111 may maintain a manifest of the game assets required to generate streaming frame 115 and may update the manifest based on the game state. Instance 111 may recognize a level change in response to determining that a game asset listed in the manifest is not stored in local memory.

[0027] Out of Figure 1 For the purposes of this example, it is assumed that a game level change indicates a change in the level associated with server 103. Therefore, in response to recognizing a level change, game instance 111 transmits player state 108 to server 103. In some embodiments, game instance 111 transmits player state 108 by communicating player state 108 to server 103 via a network (e.g., network 110 or a local area network connecting server set 101). In some embodiments, game instance 111 provides an indication of a level change accompanying player state 108. Furthermore, game instance 111 may provide client device 104 with the following commands or other indications: user input associated with game program 109 will be directed to server 103; and client device 104 will receive streaming frames associated with game program 109 from server 103.

[0028] In response to receiving player state 108, instance 112 initiates game execution. Specifically, in a manner similar to that described above for server 102, instance 112 maintains the game state and modifies it based on input data provided by client device 104, where the input data is based on user interaction with the input device. Based on the game state and according to the rules of the implemented game, instance 112 uses the CPU and GPU of server 103 to generate rendered frames using game assets stored in the corresponding local memory, and provides these rendered frames (designated as streaming frames 116) to network 110 for communication with client device 104. Client device 104 receives at least a subset of streaming frames 116 and uses the GPU to display the received frames on a monitor. Thus, game instance 112 at server 103 continues the game session previously executed by game instance 111 at server 102.

[0029] Game instance 112 uses the transmitted player state 108 to continue the game session, and specifically uses the transmitted player state to maintain the overall game state and generate streaming frames 116. This ensures that changes in the server executing game program 109 are invisible to the user of client device 104. In other words, transmitting player state 108 allows instances 111 and 112 to jointly execute game program 109 as if game program 109 were executing on a single server or other set of hardware resources. Each of instances 111 and 112 uses the hardware resources of the corresponding server (servers 102 and 103, respectively) to implement the corresponding game level, but changes in the specific hardware resources executing game program 109 are invisible to the user of client device 104.

[0030] It should be understood that Figure 1The game streaming system 100 is an example, and in other embodiments, system 100 may include additional servers in server set 101. For example, in some embodiments, game program 109 may implement N different game levels, and server set 101 includes N different servers, each assigned to implement a different one of the N game levels. In response to recognizing a change in game level from a first level to a second level, the server implementing the first level may identify and select a server associated with the second level and transmit player state 108 to the second server. The second server executes an instance of game program 109 to implement the second level based on the transmitted player state. In response to recognizing a change in game level from the second level to a third level, the second server transmits player state to the server associated with the third level. In this way, game streaming system 100 can transmit player state 108 between servers in set 101 to implement different game levels, thereby reducing level loading time and improving the user's gaming experience.

[0031] In other embodiments, a single server may implement more than one game level, but includes multiple sets of hardware resources, each assigned to implement a different game level. For example, in some embodiments, a single server includes N GPUs, each assigned to generate frames associated with a different level among the N levels associated with the game program. In response to a level change indicated by game program 109, the server changes the GPU generating the frames to be assigned to the GPU of the new level.

[0032] In some embodiments, server 103 preloads assets for the corresponding game level into local memory before receiving player state 108, thereby enabling faster rendering of streamed frames 116. For illustration, to generate streamed frames 116 for a given game level, server 103 employs game assets, such as data structures representing game objects, textures, etc. The specific assets required to render one or more streamed frames 116 may vary based on player state 108. By preloading assets for one level into local memory before receiving player state 108, server 103 reduces the loading time of those assets and can quickly initiate rendering using the preloaded assets in response to receiving player state 108 from server 102, thereby improving the user experience.

[0033] Figure 2 The illustration shows the transmission of player state 108 according to some embodiments. Figure 1An example of a game streaming system 100 is shown. In the depicted example, server 102 executes instance 111 of game program 109 to implement game level 220. Specifically, instance 111 implements game level 220 by generating streaming frames 115 based on a game state modified as received from user input from client device 104 and based on game assets associated with game level 220. For example, in some embodiments, the game state indicates specific assets required to generate the streaming frames, such as assets representing portions of the virtual environment visible or perceptible to game characters (e.g., graphical objects and textures visible to game characters). Instance 111 uses these assets to generate frames to visually represent a portion of the virtual world, and provides the frame to client device 104 via streaming frame 115.

[0034] In response to a specified user interaction with the game, instance 111 determines a level change instruction 225. In some embodiments, the level change instruction 225 is any user input or a series of user inputs instructing the game program 109 to change the game level. For example, in some embodiments, the level change instruction 225 is user input or a series of user inputs instructing the user to select from a list of game levels presented to the user by instance 111. In other embodiments, the level change instruction is user input or a series of user inputs indicating that the game character has exited part of the virtual environment associated with game level 220 and has entered a different part of the virtual environment associated with a different game level designated as game level 222.

[0035] In response to level change instruction 225, instance 111 initiates a level change by transmitting player state 118 to instance 112 executing at server 103. Furthermore, instance 111 provides client device 104 with an instruction that subsequent user input will be directed to server 103, and an instruction that subsequent streaming frames associated with game 109 will be received from server 103. For example, in some cases, a client program (not shown) executing at client device 104 provides an interface to game program 109, including the network address (referred to as the "target server address") of the server storing the instance of game program 109 executing the current game level. The client program uses this network address to redirect user input received at client device 104 and to redirect received streaming frames for display. In response to level change instruction 225, instance 111 provides the network address of server 103 to the client program, which stores the received address as the target server address.

[0036] Instance 112 receives player state 118 from server 102 and, in response, begins using the received player state 118 to implement game level 222. In some embodiments, instance 112 employs a patching technique to incorporate the received player state 118. For example, in some embodiments, instance 111 provides player state 118 as a binary code file, and instance 112 inserts the binary code of player state 118 at a designated location in instance 112, thereby allowing player state 118 to be used to generate streaming frames according to the rules implemented by game program 109. In other embodiments, instance 112 includes a pointer to a memory location where player state 118 is intended to be stored, and instance 112 incorporates player state 118 by storing the received player state 118 at the designated memory location.

[0037] In some embodiments, the game streaming system 100 reduces the amount of player state information transmitted between servers or other hardware resources by transmitting only changes in player state relative to a stored base state. According to some embodiments, in Figure 3 An example is illustrated in the figure. In the depicted example, player state 108 includes a base state 328 and state update information 329. The base state 328 includes player state information representing the player's basic state, which is not modified by a specific instance of game program 109. For example, in some embodiments, when a user terminates a game session of game program 109, the currently executing instance of game program 109 (e.g., instance 111) stores the current player state as base state 328.

[0038] In response to a user subsequently initiating another game session at client device 104, each server in set 101 preloads the corresponding game instance, along with the game-level resources to be implemented on the server, into local storage. Additionally, each server in set 101 preloads basic state 328 into local storage.

[0039] While an instance of game program 109 is executing, including generating rendered frames for streaming, the instance recognizes changes to player state 108 and stores information indicating these changes as state update information 329. Examples of these changes include changes to player scores, changes to aspects of the player character associated with the user (e.g., changes to the player character's equipment, attributes, and traits, changes to the player character's appearance makeup), etc.

[0040] In response to recognizing a level change, the executing instance only transmits state update information 329, instead of the entire player state 108. For example, refer again... Figure 2In response to the level change instruction 225, instance 111 transmits state update information 329 to instance 112, omitting the base state 328, as this base state information has already been preloaded into the local storage of server 103. By transmitting only the state update information 329, instead of the entire player state 108 with base state 328, game streaming system 100 reduces communication overhead between servers in set 101 and can further reduce level loading time.

[0041] In response to receiving status update information 328, instance 112 accesses basic status information 328 in local storage and modifies basic status information 328 to reflect the changes indicated by status update information. Player status information 108 at server 103 is thus updated to reflect the changes in player status that occur while instance 111 is implementing game level 220.

[0042] Figure 4 This is a block diagram illustrating servers 102 and 103 preloading assets for corresponding game levels according to some embodiments. In the depicted embodiments, each of servers 102 and 103 has access to a data storage device 428 storing game assets for game program 109. Data storage device 428 is assumed to be a relatively large data storage device with relatively slow access. For example, in some embodiments, data storage device 428 is one or more non-volatile memory (NVM) devices, such as one or more hard disk drives, one or more flash drives, etc., or any combination thereof. In the depicted embodiments, each of servers 102 and 103 has access to the same data storage device 428, but in other embodiments, each of servers 102 and 103 includes a separate data storage device.

[0043] Each of servers 102 and 103 includes local memory designated as memory 432 and memory 433, respectively. Local memories 432 and 433 each include less total storage space than data storage device 428, but are assumed to be accessed relatively quickly. Thus, for example, in some embodiments, local memories 432 and 433 are dynamic random access memory (DRAM), which can be accessed faster than the NVM device of data storage device 428.

[0044] In response to a user initiating a game session with game program 109 on client device 104, each of servers 102 and 103 initiates the execution of a corresponding game instance (instances 111 and 112, respectively). Each instance 111 and 112 retrieves game assets from data storage device 428 to implement the game level assigned to the server. Therefore, instance 111 loads game asset 430 from data storage device 428 into memory 432. During the implementation of game level 220, instance 111 accesses game asset 430 stored in memory 432 to generate streaming frame 115. Similarly, instance 112 loads game asset 431 from data storage device 428 into memory 433. During the implementation of game level 221, instance 112 accesses game asset 431 stored in memory 433 to generate streaming frame 116.

[0045] In some embodiments, each of instances 111 and 112 preloads game assets 430 and 431 into memory 432 and memory 433, respectively, before implementing the corresponding game level (e.g., before client device 104 requests a frame from the corresponding server or before generating a frame for streaming to client device 104). For example, instance 112 may preload player state 108 into memory 433 before implementing game level 221, for example, by loading player state 108 at the same time as or before instance 111 implements game level 220. By preloading player state 108, instance 112 can quickly implement game level 221 in response to receiving player state 108, thereby reducing interruptions in the game stream associated with level changes.

[0046] Figure 5 The illustration shows a flowchart of a method 500 for transferring player state from one instance of a game program to another instance of a game program according to some embodiments. For purposes of description, reference is made to... Figure 1 Method 500 is described using an example implementation of the game streaming system 100. At block 502, a user of client device 104 initiates a game session by entering a specified input or input sequence on client device 104. In response, client device 104 sends a game initiation request to a specified server in the set of servers 101 via network 110. For the purposes of this example, it is assumed that client device 104 sends a game initiation request to server 102.

[0047] In response to a game initiation request, the operating system of server 102 initiates the execution of instance 111 of game program 109. In response to this initiation, instance 111 sends requests to other servers in set 101, causing these other servers to initiate the execution of their own instances of game program 109. For example, instance 111 sends a request to server 103, which in turn initiates the execution of instance 112 of game program 109. Each request sent by instance 111 indicates the game level to be implemented by the corresponding instance. At block 502, each executing instance loads the assets of the assigned level from data storage device 428 into the local memory of the corresponding server.

[0048] At box 504, the game instance for the initial level of the current game session implements the initial level by generating rendered frames for streaming in response to user input and the game state as described above. The game instance uses assets stored in the server's local memory to implement the level. At box 506, during the implementation of the current level, the server maintains the player state 108, including making any modifications to the player state required by the rules of the game implemented by the game program 109.

[0049] At box 508, the server implementing the current level determines whether it has received an indication of a level change, for example, through user input on client device 104 that would cause the indicated level to change. If no indication of a level change has been received, the method flow returns to box 504, and the server continues implementing the current level of game program 109.

[0050] In response to the level change instruction at box 508, the method flow moves to box 510, and the current server determines the target level indicated by the level change (i.e., the level to be implemented as a result of the level change). The current server identifies the server assigned to implement the target level (referred to as the target server for the purposes of description) and sends player state 108 to that target server. The target server prepares the received player state for implementing the target level, for example, by patching the received player state to the game instance, by storing the player state at a specified memory address, etc. The method returns to box 510, and the instance of the target server implements the target level using the received player state and the game assets stored in the target server's local memory.

[0051] In a first aspect, a method may include: executing a first instance of a game program based on a player state to generate a first set of rendered frames for streaming to a client device; preloading a first set of game assets associated with the game program for use by a second instance of the game program; transmitting at least a portion of the player state to the second instance of the game program in response to an instruction for a change in the game level of the game program; and executing the second instance of the game program based on the preloaded first assets and based on the transmitted portion of the player state to generate a second set of rendered frames for streaming to the client device.

[0052] In one embodiment of the first aspect, the player state includes a base state and a change to the base state, the change to the base state being based on executing a first instance of the game program. In a particular embodiment, the method includes transmitting at least a portion of the player state, including transmitting the change to the base state and omitting the base state from the transmission. In a more specific embodiment, the method includes loading the base state at a second instance of the game program in response to the indication of a game level change. In yet another particular embodiment, the method includes loading the base state at a second instance of the game program before the indication of a game level change.

[0053] In another embodiment of the first aspect, the method includes executing the second game instance by preloading the first game asset set from a data storage device to a first memory; and executing the first game instance by loading a second game asset set from the data storage device to a second memory, the second game asset set being different from the first game asset set. In a particular embodiment, the method includes loading the second game asset set by preloading the second game asset set. In another embodiment, the method includes executing a first instance of the game program by generating the first set of rendered frames at a first graphics processing unit (GPU); and executing a second instance of the game program by generating the second set of rendered frames at a second GPU different from the first GPU. In yet another embodiment, the method includes executing a first instance of the game program by generating the first set of rendered frames at a first server; and executing a second instance of the game program by generating the second set of rendered frames at a second server different from the first server.

[0054] In a second aspect, a method may include: while executing a first instance of a game program to generate a first set of rendered frames for streaming to a client device, identifying a first change in a player state associated with the game program; in response to an indication of a first game level change for the game program, transmitting a first change file indicating the first change identified in the player state to a second instance of the game program; and executing the second instance of the game program based on the transmitted first change file to generate a second set of rendered frames for streaming to the client device.

[0055] In one embodiment of the second aspect, the method includes identifying a second change in the player state while executing a second instance of the game program; transmitting a second change file indicating the second change identified in the player state to a third instance of the game program in response to an indication of a second game level change for the game program; and executing the third instance of the game program based on the transmitted second change file to generate a third set of rendering frames for streaming to the client device.

[0056] In a third aspect, a non-transitory computer-readable medium may include implementing a set of executable instructions for manipulating at least one processor to: execute a first instance of a game program based on a player state to generate a first set of rendered frames for streaming to a client device; preload a first set of game assets associated with the game program for use by a second instance of the game program; transmit at least a portion of the player state to the second instance of the game program in response to an instruction for a change in the game level of the game program; and execute the second instance of the game program based on the preloaded first assets and based on the transmitted portion of the player state to generate a second set of rendered frames for streaming to the client device.

[0057] In one embodiment of the third aspect, the computer-readable medium includes the player state comprising a base state and a change to the base state, the change to the base state being based on execution of a first instance of the game program. In a particular embodiment, the computer-readable medium includes transmitting at least a portion of the player state comprising transmitting a change to the base state and omitting the base state from the transmission. In a more particular embodiment, the computer-readable medium including the set of executable instructions further includes instructions for loading the base state at a second instance of the game program in response to the indication of a game level change. In yet another embodiment, the computer-readable medium including the set of executable instructions further includes instructions for loading the base state at a second instance of the game program prior to the indication of a game level change.

[0058] In another embodiment of the third aspect, the computer-readable medium includes: executing the second game instance including preloading the first game asset set from a data storage device to a first memory; and executing the first game instance including loading a second game asset set from the data storage device to a second memory, the second game asset set being different from the first game asset set. In a particular embodiment, the computer-readable medium including loading the second game asset set includes preloading the second game asset set. In another embodiment, the computer-readable medium including executing a first instance of the game program includes generating the first set of rendered frames at a first graphics processing unit (GPU); and executing a second instance of the game program includes generating the second set of rendered frames at a second GPU different from the first GPU. In yet another embodiment, the computer-readable medium including executing a first instance of the game program includes generating the first set of rendered frames at a first server; and executing a second instance of the game program includes generating a second set of rendered frames at a second server different from the first server.

[0059] In a first aspect, a method may include: executing a first instance of a game program based on a player state to generate a first set of rendered frames for streaming to a client device; preloading a first set of game assets associated with the game program for use by a second instance of the game program; transmitting at least a portion of the player state to the second instance of the game program in response to an instruction for a change in the game level of the game program; and executing the second instance of the game program based on the preloaded first assets and based on the transmitted portion of the player state to generate a second set of rendered frames for streaming to the client device.

[0060] In one embodiment of the first aspect, the player state includes a base state and a change to the base state, the change to the base state being based on executing a first instance of the game program. In a particular embodiment, the method includes transmitting at least a portion of the player state, including transmitting the change to the base state and omitting the base state from the transmission. In a more specific embodiment, the method includes loading the base state at a second instance of the game program in response to the indication of a game level change. In yet another particular embodiment, the method includes loading the base state at a second instance of the game program before the indication of a game level change.

[0061] In another embodiment of the first aspect, the method includes executing the second game instance by preloading the first game asset set from a data storage device to a first memory; and executing the first game instance by loading a second game asset set from the data storage device to a second memory, the second game asset set being different from the first game asset set. In a particular embodiment, the method includes loading the second game asset set by preloading the second game asset set. In another embodiment, the method includes executing a first instance of the game program by generating the first set of rendered frames at a first graphics processing unit (GPU); and executing a second instance of the game program by generating the second set of rendered frames at a second GPU different from the first GPU. In yet another embodiment, the method includes executing a first instance of the game program by generating the first set of rendered frames at a first server; and executing a second instance of the game program by generating the second set of rendered frames at a second server different from the first server.

[0062] In a second aspect, a method may include: while executing a first instance of a game program to generate a first set of rendered frames for streaming to a client device, identifying a first change in a player state associated with the game program; in response to an indication of a first game level change for the game program, transmitting a first change file indicating the first change identified in the player state to a second instance of the game program; and executing the second instance of the game program based on the transmitted first change file to generate a second set of rendered frames for streaming to the client device.

[0063] In one embodiment of the second aspect, the method includes identifying a second change in the player state while executing a second instance of the game program; transmitting a second change file indicating the second change identified in the player state to a third instance of the game program in response to an indication of a second game level change for the game program; and executing the third instance of the game program based on the transmitted second change file to generate a third set of rendering frames for streaming to the client device.

[0064] In a third aspect, a non-transitory computer-readable medium may include implementing a set of executable instructions for manipulating at least one processor to: execute a first instance of a game program based on a player state to generate a first set of rendered frames for streaming to a client device; preload a first set of game assets associated with the game program for use by a second instance of the game program; transmit at least a portion of the player state to the second instance of the game program in response to an instruction for a change in the game level of the game program; and execute the second instance of the game program based on the preloaded first assets and based on the transmitted portion of the player state to generate a second set of rendered frames for streaming to the client device.

[0065] In one embodiment of the third aspect, the computer-readable medium includes the player state comprising a base state and a change to the base state, the change to the base state being based on execution of a first instance of the game program. In a particular embodiment, the computer-readable medium includes transmitting at least a portion of the player state comprising transmitting a change to the base state and omitting the base state from the transmission. In a more particular embodiment, the computer-readable medium including the set of executable instructions further includes instructions for loading the base state at a second instance of the game program in response to the indication of a game level change. In yet another embodiment, the computer-readable medium including the set of executable instructions further includes instructions for loading the base state at a second instance of the game program prior to the indication of a game level change.

[0066] In another embodiment of the third aspect, the computer-readable medium includes: executing the second game instance including preloading the first game asset set from a data storage device to a first memory; and executing the first game instance including loading a second game asset set from the data storage device to a second memory, the second game asset set being different from the first game asset set. In a particular embodiment, the computer-readable medium including loading the second game asset set includes preloading the second game asset set. In another embodiment, the computer-readable medium including executing a first instance of the game program includes generating the first set of rendered frames at a first graphics processing unit (GPU); and executing a second instance of the game program includes generating the second set of rendered frames at a second GPU different from the first GPU. In yet another embodiment, the computer-readable medium including executing a first instance of the game program includes generating the first set of rendered frames at a first server; and executing a second instance of the game program includes generating a second set of rendered frames at a second server different from the first server.

[0067] In some embodiments, certain aspects of the above-described technology may be implemented by one or more processors of a processing system executing software. The software includes one or more sets of executable instructions stored or otherwise tangibly contained on a non-transitory computer-readable storage medium. The software may include instructions and certain data that, when executed by the one or more processors, manipulate the one or more processors to perform one or more aspects of the above-described technology. The non-transitory computer-readable storage medium may include, for example, disk or optical disk storage devices, solid-state storage devices such as flash memory, cache, random access memory (RAM), or one or more other non-volatile storage devices. The executable instructions stored on the non-transitory computer-readable storage medium may be source code, assembly language code, object code, or other instruction formats that are interpreted or otherwise executable by one or more processors.

[0068] Computer-readable storage media can include any storage medium or combination of storage media that is accessible to a computer system during use to provide instructions and / or data to the computer system. Such storage media can include, but is not limited to, optical media (e.g., optical discs (CDs), digital versatile discs (DVDs), Blu-ray discs), magnetic media (e.g., floppy disks, magnetic tapes, or hard disk drives), volatile memory (e.g., random access memory (RAM) or cache), non-volatile memory (e.g., read-only memory (ROM) or flash memory), or microelectromechanical systems (MEMS) based storage media. Computer-readable storage media can be embedded in a computing system (e.g., system RAM or ROM), permanently attached to a computing system (e.g., magnetic hard disk drives), removably attached to a computing system (e.g., optical discs or flash memory based on Universal Serial Bus (USB)), or coupled to a computer system via a wired or wireless network (e.g., network accessible memory (NAS)).

[0069] Note that, in addition to those described, not all activities or elements described in the general description above are required, a particular activity or device may not be necessary, and one or more additional activities or included elements may be performed. Furthermore, the order in which the activities are listed is not necessarily the order in which they are performed. Moreover, these concepts have been described with reference to specific embodiments. However, those skilled in the art will understand that various modifications and changes can be made without departing from the scope of this disclosure as set forth in the appended claims. Therefore, the specification and drawings are to be considered illustrative rather than restrictive, and all such modifications are intended to be included within the scope of this disclosure.

[0070] The benefits, other advantages, and solutions to the problems have been described above in conjunction with specific embodiments. However, the benefits, advantages, solutions to the problems, and any features that may lead to or make any benefit, advantage, or solution appear or become more significant should not be construed as key, essential, or necessary features of any or all claims. Furthermore, the specific embodiments disclosed above are merely illustrative, as the disclosed subject matter can be modified and practiced in different but equivalent ways, as will be apparent to those skilled in the art who benefit from the teachings herein. The details of the structures or designs shown herein are not limiting, except as described in the appended claims. Therefore, it is apparent that the specific embodiments disclosed above can be changed or modified, and all such changes are considered to be within the scope of the disclosed subject matter. Therefore, the protection sought herein is set forth in the appended claims.

Claims

1. A method for level change in a game streaming system, comprising: executing a first instance of a game program based on a player state to generate a first set of rendered frames for streaming to a client device, the player state indicating a base state of a player prior to modification from executing the first instance and indicating changes to the base state of the player from executing the first instance; preloading a first set of game assets associated with the game program and the base state of the player for use by a second instance of the game program; in response to an indication of a game level change for the game program, transmitting at least a portion of the player state indicating changes to the base state from executing the first instance to the second instance of the game program; and executing the second instance of the game program based on the preloaded first set of game assets and based on the transmitted portion of the player state to generate a second set of rendered frames for streaming to the client device. Transmitting the at least the portion of the player state includes transmitting changes to the base state of the player from executing the first instance and omitting the base state of the player from the transmission.

2. The method of claim 1, wherein, Preloading the base state of the player for use by the second instance of the game program is in response to the indication of the game level change.

3. The method of claim 2, wherein, Preloading the base state of the player for use by the second instance of the game program is prior to the indication of the game level change.

4. The method of claim 2, wherein, 5. The method of claim 1, wherein: executing the second instance includes preloading the first set of game assets from a data store to a first memory; and executing the first instance includes loading a second set of game assets from the data store to a second memory, the second set of game assets being different than the first set of game assets. Loading the second set of game assets includes preloading the second set of game assets.

7. The method of claim 1, wherein:

6. The method of claim 5, wherein, executing the first instance of the game program includes generating the first set of rendered frames at a first graphics processing unit; and executing the second instance of the game program includes generating the second set of rendered frames at a second graphics processing unit different than the first graphics processing unit.

8. The method of claim 1, wherein: executing the first instance of the game program includes generating the first set of rendered frames at a first server; and executing the second instance of the game program includes generating the second set of rendered frames at a second server different than the first server.

9. A method for level change in a game streaming system, comprising: identifying changes to a base state of a player based on executing a first instance of a game program to generate a first set of rendered frames for streaming to a client device, wherein the base state of the player represents a state that is unmodified by executing the first instance; ​ ​ ​ ​ preloading the base state of the player for use by a second instance of the game program; in response to an indication of a first game level change for the game program, transmitting a first change file indicating an identified first change in the base state of the player to a second instance of the game program; and executing the second instance of the game program based on the transmitted first change file to generate a second set of rendered frames for streaming to the client device.

10. The method of claim 9, further comprising: while executing the second instance of the game program, identifying a second change in the base state of the player; in response to an indication of a second game level change for the game program, transmitting a second change file indicating the identified second change in the base state of the player to a third instance of the game program; and executing the third instance of the game program based on the transmitted second change file to generate a third set of rendered frames for streaming to the client device.

11. A non-transitory computer-readable medium containing a set of executable instructions for manipulating at least one processor to: execute a first instance of a game program based on a player state to generate a first set of rendered frames for streaming to a client device, the player state indicating a base state of a player prior to modification due to the first instance of the game program and indicating changes to the base state of the player from executing the first instance; preloading a first set of game assets associated with the game program and the base state of the player for use by a second instance of the game program; in response to an indication of a game level change for the game program, transmitting at least a portion of the player state to a second instance of the game program; and execute the second instance of the game program based on the preloaded first set of game assets and based on the transmitted portion of the player state to generate a second set of rendered frames for streaming to the client device.

12. The computer readable medium of claim 11, wherein, transmitting the at least a portion of the player state includes transmitting changes to the base state of the player from executing the first instance and omitting the base state of the player from the transmission.

13. The computer readable medium of claim 12, wherein, the set of executable instructions further includes instructions for: preloading the base state at the second instance of the game program in response to the indication of the game level change.

14. The computer readable medium of claim 12, wherein, the set of executable instructions further includes instructions for: preloading the base state at the second instance of the game program prior to the indication of the game level change.

15. The computer-readable medium of claim 11, wherein: executing the second instance includes preloading the first set of game assets from a data store to a first memory; and executing the first instance includes loading a second set of game assets from the data store to a second memory, the second set of game assets being different than the first set of game assets. ​ 16. The computer readable medium of claim 15, wherein, Loading the second set of game assets includes preloading the second set of game assets.

17. The computer-readable medium of claim 11, wherein: executing the first instance of the game program includes generating the first set of rendered frames at a first graphics processing unit; and executing the second instance of the game program includes generating the second set of rendered frames at a second graphics processing unit different from the first graphics processing unit.

18. The computer-readable medium of claim 11, wherein: executing the first instance of the game program includes generating the first set of rendered frames at a first server; and executing the second instance of the game program includes generating the second set of rendered frames at a second server different from the first server.

Images