Game Application Function Store for Runtime Update Delivery
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The existing review process for updating applications, particularly game applications, is time-consuming and costly, delaying the delivery of new features and bug fixes to users, as it requires precompiled machine code approval from application marketplace providers.
Innovation Solution
Implementing a hybrid approach that uses both precompiled machine code and interpreted scripting language, allowing for rapid distribution of updates during runtime without prior approval, and converting script-based updates to binary patches to recover performance debt.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If precompiled machine code is used for application updates, then application speed and quality are maintained, but the review process increases time and cost to deliver updates
Solution Approach 1:
The application is segmented into two distinct code types: precompiled machine code for performance-critical functions and interpreted scripting language for other functions. This segmentation allows different update paths for different parts of the application, enabling rapid updates for script portions without compromising the speed of compiled portions.
Solution Approach 2:
The patent changes the parameter of code compilation state from binary (compiled or uncompiled) to a spectrum where functions can be dynamically switched between compiled and interpreted states. This allows the system to optimize for either speed or update flexibility depending on the specific function and update scenario.
2Reliability
If precompiled machine code updates are submitted through the review process, then application quality is ensured, but resources are consumed and update frequency is reduced
Solution Approach 1:
Updates are segmented into two categories: script-based updates that bypass the review process and can be deployed immediately, and binary patch updates that go through review for quality assurance. This segmentation enables multiple updates per day without overwhelming the review process or sacrificing quality for critical functions.
Solution Approach 2:
The patent applies partial compilation where only the necessary portions of the application are compiled at any given time. Script-based updates provide sufficient functionality for many updates without requiring full compilation and review, while binary patches provide compiled quality assurance for critical updates.
3Speed
If interpreted scripting language is used for updates, then update speed is improved, but performance degradation occurs
Solution Approach 1:
The application functions are segmented into those that require high performance (compiled) and those that can tolerate interpreted execution speed. This segmentation allows the system to achieve rapid updates through script-based deployment while maintaining performance for critical functions through selective compilation.
Solution Approach 2:
The system dynamically adjusts the compilation state of functions based on performance requirements and update needs. Functions can be switched between interpreted and compiled states, allowing the application to optimize for either update speed or execution performance depending on the current scenario.
4Ease of operation
If frequent updates are delivered, then user experience is improved with new features and bug fixes, but the review process cost and time increase
Solution Approach 1:
The update delivery system is segmented into two parallel channels: a rapid script-based channel for frequent, low-risk updates and a traditional binary patch channel for less frequent, high-impact updates. This segmentation enables the delivery of multiple updates per day to improve user experience without overwhelming the review process.
Solution Approach 2:
The patent introduces an intermediary mechanism where script-based updates serve as a bridge between developers and users for rapid iteration, while binary patches serve as the formal quality-assured updates. This intermediary system allows frequent updates to reach users without requiring each one to undergo the full review process.
Data Source
AI summary
The present disclosure provides a system and method for updating a game application during runtime of a game application. The game application is executed on a client computing device using application code that includes a function store. During runtime of the game application, a function asset is received and stored in the function store. The function asset includes either precompiled code or code written in a scripting language and includes a version identifier. To execute a particular game function of the game application, the function asset is identified from other function assets in the function store based at least in part on its version identifier, and the game function is executed using the function asset.