Graph Node Server Protocol for Networked Game State Synchronization
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing client-server interaction methods face challenges in efficiently managing networked graphical and audio applications, particularly in multi-client deployments, where bandwidth-intensive video streaming and network latency lead to delays and complexity in custom client-server protocols, making rapid prototyping and error management difficult.
Innovation Solution
A method involving a server that executes a graph of connected nodes encoding the application's state, behavior, and displays, with clients receiving updates and synchronizing using synchronization packets, allowing for efficient transmission and prediction of application states, even with unpredictable client actions.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If a thin client approach is used where the server sends video streams to each client, then implementation simplicity is improved, but bandwidth consumption increases significantly
Solution Approach 1:
The patent extracts only the essential application state data from the complete display stream, transmitting minimal updates (e.g., individual pixel changes, object position changes) rather than entire video frames. This selective extraction reduces bandwidth consumption while maintaining implementation simplicity through a standardized protocol.
Solution Approach 2:
The system changes the transmission parameter from continuous video streams to discrete state updates. By transmitting only changed elements (delta updates) rather than complete frames, the bandwidth requirement is dramatically reduced while the server continues to run any application, maintaining ease of implementation.
2Ease of manufacture
If video streaming is used to transmit application display to clients, then implementation simplicity is improved, but network latency causes delays in displaying input events
Solution Approach 1:
The patent extracts and transmits only the essential state changes needed to update the display, rather than waiting for complete video frame rendering. By sending minimal update packets (e.g., 'pixel at position X,Y changed to color Z'), the system reduces network latency while maintaining implementation simplicity through a lightweight protocol.
Solution Approach 2:
The server prepares and transmits state updates immediately when changes occur, before the complete display frame is rendered. This preliminary transmission of essential data reduces perceived latency, as clients can begin updating their displays before receiving complete frame information, while the server continues to run any application without modification.
3Loss of energy
If a custom client-server protocol is programmed for each application, then bandwidth efficiency is improved, but device complexity increases
Solution Approach 1:
The patent creates a universal protocol that works with any application running on the server. The standardized update mechanism (transmitting minimal state changes) is application-agnostic, allowing the same protocol to efficiently support different applications without requiring custom development, thus reducing complexity while maintaining bandwidth efficiency.
Solution Approach 2:
The system uses a standardized template for state updates that can be copied and applied across different applications. Rather than developing unique protocols for each application, the same update structure (position, color, size parameters) is reused universally, reducing development complexity while achieving bandwidth efficiency through consistent minimal updates.
4Ease of operation
If multiple users interact simultaneously with a networked application using video streaming, then ease of use is improved, but it becomes difficult for users to see different views of the same application
Solution Approach 1:
The patent enables each client to receive and display only the portion of the application state relevant to their view. The server tracks which pixels or objects are visible to each client and transmits updates only for those specific regions. This allows multiple users to simultaneously interact with the application while each sees their own customized view (e.g., different map areas in a game), maintaining ease of multi-user operation while enabling view customization.
Data Source
AI summary
Client server interaction for networked graphical and/or audio applications is described, for example, for networked games. A graph of connected nodes at a server encodes a state, a behavior and a plurality of graphical and/or audio displays of an application. For example, the application may be a game and the plurality of displays may be displays of client computers participating in the game. In various examples, client computers are connected to the server over a communications network and each client executes a copy of at least part of the graph of connected nodes received from the server so that different clients can have different displays. In examples, update commands are generated and sent to clients on the basis of changes to the graph of connected nodes at the server. In examples, events occurring at a client update a prediction copy of a client graph of connected nodes.