Mobile game resource dynamic loading optimization method, terminal equipment and system

Abstract

The invention provides a mobile game resource dynamic loading optimization method, terminal equipment and a mobile game resource dynamic loading optimization system. According to the method, player behavior characteristics and the space-time correlation degree between player behaviors are analyzed in real time through a double-engine analysis network, and then the player behaviors are predicted from different time scales through a lightweight micro neural network so as to obtain game resources needing to be loaded under the different time scales. And finally, different management strategies are adopted to carry out elastic loading and time-sharing management on the game resources in combination with game resource types, so that under the condition of occupying a small amount of memory resources, the loading speed of the mobile phone game resources is greatly improved, and the smoothness of game operation is ensured. In conclusion, the technical problem of game lagging caused by too long loading time can be solved without loading game resources in a large range and occupying memory resources.

Description

Technical Field

[0001] The embodiments of this application relate to the field of artificial intelligence, and more specifically, the embodiments of this application relate to a method, terminal device, and system for dynamically loading and optimizing mobile game resources. Background Technology

[0002] Currently, mobile games often experience long loading times during resource loading, leading to game lag.

[0003] During the loading phase, taking the first login as an example, if the resources in the initial package (such as the main interface and core models) are not preloaded, it will cause users to wait for a long time. For example, due to the limitations of the main package and the total limit of sub-packages, a large number of resources need to be loaded remotely, and network fluctuations will further aggravate the delay.

[0004] In related technologies, to reduce lag, a large amount of resources (such as textures for an entire chapter) are often preloaded. If the player does not enter the target scene, this will result in wasted memory. Furthermore, preloaded resources (especially high-resolution models / textures) will occupy memory for a long time. If the device's total memory is small, background applications will compete with game resources for memory, easily triggering the system's forced memory reclamation process, causing the game to crash and affecting operational smoothness. Especially in weak network environments, blindly preloading game resources (such as 4K textures) may exhaust bandwidth, actually slowing down the loading progress of critical resources (character animations).

[0005] Clearly, existing technical solutions cannot adequately address the issue of game lag caused by excessively long loading times. Therefore, there is an urgent need to design a completely new technical solution to solve these problems. Summary of the Invention

[0006] In this context, the embodiments of this application aim to provide a method, terminal device, and system for dynamically loading mobile game resources, which can solve the technical problem of game lag caused by excessively long loading times and improve the loading speed of mobile game resources.

[0007] In a first aspect of the embodiments of this application, a method for optimizing dynamic loading of mobile game resources is provided, comprising: Real-time collection of player behavior data; the player behavior data includes at least: player operation information, player location, player movement trajectory, and time spent in the level; A dual-engine analysis network pre-deployed in the mobile phone is used to analyze player behavior characteristics and / or spatiotemporal correlation in the player behavior data in real time; Using a micro neural network pre-deployed in the mobile phone, the player's resource needs are predicted in a time-sharing manner based on the player's behavioral characteristics and / or the spatiotemporal correlation, so as to obtain pre-loaded time-sharing game resources; wherein, the time-sharing game resources are divided into the following categories according to the prediction period: short-term scene resources located in the predicted movement direction under the short-term prediction dimension, medium-term scene resources located within a preset distance around the player's current position under the medium-term prediction dimension, and plot node resources with a trigger probability higher than a set probability threshold under the long-term prediction dimension. Based on the predicted period length and game resource type, the time-sharing game resources are classified into temperature attributes, and loaded into the isolation cache according to the temperature attributes; different temperature attributes are matched with different management strategies in the dynamic unloading mechanism. A dynamic unloading mechanism is used to manage time-sharing game resources with different temperature attributes in the isolation buffer. In response to players' real-time actions, time-sharing game resources in the isolated cache are loaded elastically.

[0008] In a second aspect of the embodiments of this application, a mobile game resource dynamic loading optimization system is provided, comprising: The data acquisition unit is used to collect player behavior data in real time; the player behavior data includes at least: player operation information, player location, player movement trajectory, and level dwell time; The analysis unit is used to analyze the player behavior characteristics and / or spatiotemporal correlation in the player behavior data in real time using a dual-engine analysis network pre-deployed in the mobile phone. The prediction unit is used to use a micro neural network pre-deployed in the mobile phone to predict the player's resource needs in a time-sharing manner based on the player's behavior characteristics and / or the spatiotemporal correlation, so as to obtain pre-loaded time-sharing game resources; wherein, the time-sharing game resources are divided into the following according to the prediction period: short-term scene resources located in the predicted movement direction under the short-term prediction dimension, medium-term scene resources located within a preset distance around the player's current position under the medium-term prediction dimension, and plot node resources with a trigger probability higher than a set probability threshold under the long-term prediction dimension. The storage unit is used to classify the temperature attributes of the time-sharing game resources according to the prediction period length and the game resource type, and load them into the isolation cache according to the temperature attributes; different temperature attributes are matched with different management strategies in the dynamic unloading mechanism. The management unit is used to manage time-sharing game resources with different temperature attributes in the isolation buffer using a dynamic unloading mechanism; The loading unit is used to elastically load time-sharing game resources in the isolated cache in response to the player's real-time actions.

[0009] In a third aspect of the embodiments of this application, a terminal device is provided, the terminal device comprising: at least one processor, a memory, and an input / output unit; wherein the memory is used to store a computer program, and the processor is used to invoke the computer program stored in the memory to execute the mobile game resource dynamic loading optimization method described in any one aspect.

[0010] In a fourth aspect of the embodiments of this application, a computer-readable storage medium is provided, which includes instructions that, when executed on a computer, cause the computer to perform the mobile game resource dynamic loading optimization method described in any one of the first aspects.

[0011] In a fifth aspect of the embodiments of this application, a computer program product is provided, including a computer program that, when executed by a processor, implements the mobile game resource dynamic loading optimization method described in any one of the first aspects.

[0012] According to the mobile game resource dynamic loading optimization method, terminal device, and system implemented in this application, player behavior data is collected in real time. The player behavior data includes at least: player operation information, player location, player movement trajectory, and level dwell time. Furthermore, a dual-engine analysis network pre-deployed in the mobile phone is used to analyze player behavior characteristics and / or spatiotemporal correlation in the player behavior data in real time. A micro-neural network pre-deployed in the mobile phone is used to predict player resource needs in a time-sharing manner based on the player behavior characteristics and / or the spatiotemporal correlation, thereby obtaining pre-loaded time-sharing game resources. The time-sharing game resources are categorized according to the prediction period length: short-term scene resources located in the predicted movement direction under the short-term prediction dimension; medium-term scene resources located within a preset distance around the player's current position under the medium-term prediction dimension; and story node resources with a trigger probability higher than a set probability threshold under the long-term prediction dimension. Next, based on the prediction period length and game resource type, the time-sharing game resources are classified by temperature attributes and loaded into an isolated cache area according to these temperature attributes. Different temperature attributes are matched with different management strategies in the dynamic unloading mechanism. Finally, a dynamic unloading mechanism is adopted to manage time-sharing game resources with different temperature attributes in the isolation buffer; in response to the player's real-time operation behavior, the time-sharing game resources in the isolation buffer are elastically loaded.

[0013] This application's implementation method utilizes a dual-engine analysis network to analyze player behavior characteristics and the spatiotemporal correlations between player behaviors in real time. It then employs a lightweight micro-neural network to predict player behavior at different time scales, thereby obtaining the game resources required for loading at each time scale. Finally, it combines different management strategies based on game resource types to perform elastic loading and time-sharing management of game resources. This significantly improves the loading speed of mobile game resources while consuming minimal memory resources, ensuring smooth game operation. In summary, this application's implementation method solves the technical problem of game lag caused by excessively long loading times without requiring large-scale loading of game resources that consume significant memory resources. Attached Figure Description

[0014] Figure 1 A flowchart illustrating a method for optimizing dynamic loading of mobile game resources according to an embodiment of this application; Figure 2 This is a schematic diagram of the structure of a mobile game resource dynamic loading optimization method, terminal device, and system provided in an embodiment of this application; Figure 3 A schematic diagram of the structure of a medium according to an embodiment of this application is shown. Detailed Implementation

[0015] The following is for reference. Figure 1 , Figure 1 This is a flowchart illustrating a method for dynamically loading and optimizing mobile game resources according to an embodiment of this application. It should be noted that the implementation methods of this application can be applied to any applicable presentation creation scenario.

[0016] Figure 1 The flowchart of a mobile game resource dynamic loading optimization method provided in an embodiment of this application, as shown, includes: Step S101: Collect player behavior data in real time.

[0017] In this embodiment of the application, the player behavior data includes at least: player operation information, player location, player movement trajectory, and level dwell time.

[0018] Player action information refers to all interactive signals generated during gameplay, including discrete actions (such as skill button clicks and menu opening actions) and continuous actions (such as joystick movement and screen swipe angles). For example, in MOBA games, a player may trigger 3-5 skill release and movement command combinations per second.

[0019] In step S101, player operation information is primarily acquired through code embedding in the game client. When the player performs various operations, the program captures and records the specific parameters of these operations in real time. Alternatively, step S101 can employ system-level listening, directly capturing raw signals such as touch screen coordinates, key codes, and pressure values ​​through operating system input event interfaces (such as Android's InputEvent or iOS's GameController framework). In other examples, step S101 uses a game engine (Unity / Unreal) to encapsulate an operation abstraction layer, converting raw signals into semantic instructions ("Attack A", "Sprint Displacement"), and distributing them to the logic module via the event bus. Alternatively, step S101 can also employ a frequency statistics algorithm. Based on a sliding time window (e.g., a 5-second window), the operation density per unit time (times / second) is statistically analyzed to detect high-frequency operation burst intervals.

[0020] Player operation information can reveal players' operating habits and preferences, such as determining which operation method a player prefers, thereby optimizing the game's interface and interaction logic to improve the player experience. It can also be used to analyze player errors in specific game scenarios, providing a basis for adjusting game difficulty. In particular, in this embodiment, player operation information can be used for behavioral pattern recognition. For example, continuously clicking skill buttons (>8 times / second) is marked as "combat state," triggering preloading of melee character models. Alternatively, player operation information can also be used to predict resource needs. For example, opening the inventory triggers equipment icon resource loading, and high-definition special effects resources are preloaded before releasing ultimate skills.

[0021] The player's location refers to the specific coordinates or area where the player character is currently situated in the game's virtual world, such as a specific coordinate point on a map or a specific scene location within a level. Specifically, in step S101, the game engine's built-in coordinate system can be used. As the player character moves within the game scene, the system updates and records its location coordinates in real time. For example, three-dimensional coordinates (x, y, z) data based on the game world coordinate system are typically output in real time by the character controller. For instance, in open-world games, the player's location is accurate to the map grid coordinates (e.g., area G-7), while also including altitude information (surface / flying / underwater).

[0022] In this application, spatial relationship modeling can be achieved based on the player's location. For example, when a player approaches a portal (<50 meters), target map resources are preloaded. Scene priority can also be implemented. For example, when resources are scarce, scene resources within 50 meters of the character are loaded first, while distant scene resources beyond 500 meters are delayed.

[0023] A player's movement trajectory is the path data traversed by a player character as they move from one location to another during gameplay. This information records the player's route, speed, and changes in direction. In practical applications, the movement trajectory is a spatiotemporal sequence composed of consecutive location points, containing spatiotemporal features such as displacement vectors (e.g., moving 2.4 meters per second), direction angles (35 degrees northeast), and path curvature (degree of turning abruptly).

[0024] In step S101, coordinate points can be recorded every 100 milliseconds, and device jitter errors can be eliminated using a Kalman filter algorithm. Further, in step S101, a vector synthesis engine is used to calculate the velocity vector (unit: m / s) and rate of change of acceleration based on adjacent coordinate points. Alternatively, in step S101, path semantic annotation can be further employed. Combining map semantic information, the movement trajectory is divided into behavioral patterns such as "straight-line sprint" and "tactical maneuvering." Thus, by continuously tracking changes in the player's position, a series of consecutive position coordinates are connected in chronological order to form a complete movement trajectory record.

[0025] The player movement trajectory described in this application can help analyze player exploration behavior in the game, such as whether the player's route in a level is reasonable, whether they are prone to getting lost in certain areas, and thus optimize the level map design to guide players to play the game more smoothly. Simultaneously, it can also be used to detect whether players are exploiting game loopholes for abnormal movement, maintaining the fairness of the game. Specifically, player movement trajectory can be used for short-term direction prediction. During a continuous 10-second straight-line movement, terrain resources within a fan-shaped area along the movement direction are preloaded. Player movement trajectory can serve as a basis for behavioral decisions. When detecting high-frequency backtracking paths (such as patrol behavior), the mid-term scene loading radius is expanded.

[0026] Level dwell time refers to the length of time a player spends in a specific level of the game. It is the time difference between when the player enters the level and when they leave or complete the level's objective. Essentially, level dwell time records the non-moving duration of a player within a specific game logic area (such as a dungeon entrance or near a shop NPC). The timer's activation conditions include: character speed consistently <0.1 m / s, no combat command output, and being within an interactive trigger area. In step S101, time triggers can be set at the level's entrance and exit. The timer starts when the player triggers an entrance event and stops when they trigger an exit event, thus obtaining the dwell time data.

[0027] The duration of time spent in a level can be used to predict content depth. For example, if a player spends more than 8 minutes in the starting area, advanced tutorial videos can be preloaded. It can also be used for plot point decisions. For instance, if a player spends more than 120 seconds near a key NPC, the loading priority of subsequent plot animations can be increased. Furthermore, it can be used to trigger resource recycling. For example, resources specific to that area can be automatically unloaded 5 minutes after leaving the level.

[0028] Step S102: Using a dual-engine analysis network pre-deployed in the mobile phone, the player behavior characteristics and / or spatiotemporal correlation in the player behavior data are analyzed in real time.

[0029] As an optional embodiment, in step S102, a dual-engine analysis network pre-deployed in the mobile phone is used to analyze the player behavior characteristics and / or spatiotemporal correlation in the player behavior data in real time, including: using a behavior trajectory analysis engine to analyze the operation density and movement trend in the player behavior data in real time to obtain the player behavior characteristics; using a scene semantic parsing engine, combined with the game map topology, to calculate the topological distance between the player's current location and each game scene based on the player behavior data to obtain the spatiotemporal correlation between the player and each game scene.

[0030] In this embodiment of the application, the player behavior characteristics include at least: player operation type, player operation density, local operation hotspots, and player movement direction.

[0031] Specifically, player action type refers to the player's specific interactive actions (such as clicking buttons, swiping the screen, and releasing skills), obtained by listening to system input events or the game engine's event bus, and used to identify the player's immediate intentions (e.g., continuous clicking of skill buttons is marked as "combat state"). Action density is the number of actions per unit of time (e.g., 3 clicks per second), calculated by sliding a time window, reflecting the activity level of the player's behavior (high-density actions may indicate an upcoming combat scene). Local action hotspots are areas where the player frequently interacts within a short period (e.g., equipment icons in the upper left corner of the inventory interface), determined by statistically analyzing the frequency of coordinate points, and used to predict the specific content the player is about to interact with (e.g., preloading high-definition icon resources when opening the equipment interface). Movement direction is calculated from the vector difference between adjacent displacement coordinates (e.g., 30 degrees northeast), extracted after eliminating device jitter errors through Kalman filtering, and used to predict the player's short-term movement path (e.g., preloading northern scene resources when continuously moving north).

[0032] The essence of spatiotemporal correlation is a quantitative indicator of the spatial relevance between a player's location and the scene. It reflects the proximity between the two by calculating the topological distance (e.g., the path weight from the player's current location to the "Forest Dungeon" is 5) through a scene semantic parsing engine. Its acquisition relies on the game map's topological structure data (including scene coordinates, connected paths, and weight parameters), combined with the player's real-time location coordinates, and calculated through message passing in a graph neural network. The role of spatiotemporal correlation is to provide spatial basis for mid-term resource preloading (e.g., scenes with a correlation > 0.7 are marked as "nearby scenes," triggering the preloading of their basic resources), and to improve the accuracy of resource prediction by combining it with player behavior characteristics (e.g., high operation density + high correlation scenes) (e.g., when players frequently operate in nearby Boss scenes, Boss battle-specific special effects resources are loaded first).

[0033] In the above embodiments, the dual-engine analysis network is the core module for realizing the correlation analysis between player behavior and scene. Through the collaborative work of the behavior trajectory analysis engine and the scene semantic parsing engine, it provides key inputs for subsequent resource time-sharing prediction.

[0034] In principle, the core function of the behavior trajectory analysis engine is to extract player behavior features from player behavior data, including operation type, operation density, local operation hotspots, and movement direction. The engine's model structure employs a lightweight temporal processing architecture, typically consisting of a sliding window segmentation module, a multi-dimensional feature extraction layer, and a dynamic pattern recognition layer. The sliding window segments continuous player behavior data (such as operation sequences and displacement coordinates) into segments of fixed duration (e.g., 2 seconds). The multi-dimensional feature extraction layer captures the temporal patterns of operation frequency (e.g., fluctuations in the number of clicks per second) through convolutional operations and calculates the directional stability of displacement (e.g., the angular variance of five consecutive displacements) through vector analysis. The dynamic pattern recognition layer classifies the current segment based on preset behavior templates (e.g., "straight-line sprint" or "tactical loitering") and outputs the operation type determination result (e.g., "skill release" or "movement and turning"). The construction process requires first collecting a large number of player behavior logs (including operation type, coordinates, timestamps, etc.), removing outliers (such as interference from accidental screen touches) through data cleaning, and then using transfer learning technology to fine-tune the pre-trained model on a small sample of device data. Finally, it is deployed as a lightweight model that only occupies a single-core CPU resource.

[0035] In principle, the core function of the scene semantic parsing engine is to calculate the spatiotemporal correlation between the player's current location and various game scenes by combining the game map's topology structure. This is a comprehensive measure of the spatial distance and logical connection between the player and the scene. The engine's model structure is based on a Graph Neural Network (GNN), abstracting the game map as a weighted graph: nodes represent key scenes (such as the main city, dungeon entrance, and boss points), and edge weights are determined by actual travel time (e.g., 1 for plains, 2.5 for mountains) and scene priority (e.g., 0.9 for main quest areas, 0.6 for resource gathering areas). The model uses a message passing mechanism to compare the player's current location coordinates with the spatial coordinates of each node, calculates the topological distance (i.e., the sum of path weights), and dynamically adjusts the correlation value based on the real-time state of the scene (e.g., increased weight for areas where quest progress is incomplete). Its construction requires first converting the game map into graph-structured data, obtaining the coordinates and attribute information of each scene through the game engine interface, then using historical player behavior data (e.g., the distribution of frequently visited scenes) to train the edge weight parameters of the graph network, and finally deploying it as a lightweight inference model that supports real-time queries.

[0036] The dual-engine analysis network focuses on the dynamic details of players' short-term behavior (such as operation type and movement direction) through the behavior trajectory analysis engine, and focuses on the spatial relationship between players and the scene (such as topological distance and correlation) through the scene semantic parsing engine. Together, they construct a spatiotemporal profile of player behavior, providing multi-dimensional input features for subsequent time-sharing prediction models, and ultimately achieving more accurate and dynamic resource preloading.

[0037] As an optional embodiment, in the above steps, the operation density and movement trend in the player behavior data are analyzed in real time through a behavior trajectory analysis engine to obtain the player behavior characteristics. This includes: extracting the number of events triggered per second from the player behavior data to obtain the unit operation density corresponding to a unit duration; extracting the sampled coordinates of the player's position from the player behavior data every 0.5 seconds, and converting the extracted sampled coordinates into a unit movement direction vector corresponding to a unit duration; constructing a behavior feature vector matrix from the unit operation density and unit movement direction vector corresponding to a unit duration; determining the player's current behavior pattern based on the data distribution pattern in the behavior feature vector matrix, and predicting the player behavior characteristics based on the behavior pattern.

[0038] In the steps described above, the behavior trajectory analysis engine is a lightweight model designed specifically for real-time analysis of player behavior characteristics on mobile devices. Its core function is to achieve accurate profiling of short-term player behavior through dynamic capture of operation density and movement direction. The engine's model structure adopts a layered pipeline architecture, which consists of a data preprocessing layer, a feature extraction layer, and a pattern recognition layer, from raw data input to behavior pattern output.

[0039] For example, in the aforementioned behavior trajectory analysis engine, the data preprocessing layer is responsible for converting raw behavior data into computable numerical signals. The raw input includes touchscreen event logs (such as timestamps and coordinates of clicks and swipes) and device positioning data (such as location coordinates collected by GPS or inertial sensors). The preprocessing layer first performs time alignment on this data. With a sampling interval of 0.5 seconds, operation events and location information are extracted synchronously to ensure the temporal consistency of subsequent features. For example, the number of touchscreen event triggers (operation density) is counted every 0.5 seconds, and the location coordinates at that time point are recorded.

[0040] The feature extraction layer is the core module of the behavior trajectory analysis engine. It performs multi-dimensional feature calculations based on preprocessed time-series data. Operation density is calculated using a sliding window statistical method: with a window length of 1 second, the total number of touch events within the window is counted to obtain the operation density value per unit time (1 second) (times / second). The generation of the movement direction vector is achieved through the coordinate difference method: the position coordinates of two consecutive 0.5-second sampling points are taken, such as the first coordinate at time t and the second coordinate collected at time t plus 0.5 seconds. The displacement vector of the second coordinate relative to the first coordinate is calculated, and then normalized (divided by the displacement magnitude) to obtain the unit movement direction vector (the direction angle is calculated using the arctangent function). These features are integrated into a behavior feature vector matrix, with each row corresponding to a time window (e.g., 1 second), and the columns representing the operation density value and the x and y components of the direction vector, forming a three-dimensional feature representation of "time-density-direction".

[0041] The pattern recognition layer determines the player's current behavior pattern based on the data distribution pattern of the feature vector matrix. This layer employs a lightweight classification algorithm (such as a decision tree or a small neural network) to learn the feature distribution patterns corresponding to different behavior patterns through training data. For example, a pattern with high operation density (>5 times / second) and frequent changes in direction vectors (large angular variance) is labeled as "combat operation". A pattern with low operation density (<2 times / second) and stable direction vectors (small angular variance) is labeled as "movement and walking"; a pattern with low operation density but periodic changes in direction vectors (such as turning 90 degrees every 2 seconds) is labeled as "exploration and wandering". The model outputs the best-matching behavior pattern by comparing the current feature vector with the similarity of each pattern in the training set (such as Euclidean distance or cosine similarity).

[0042] The construction process of the behavior trajectory analysis engine is divided into three stages: data acquisition, model training, and deployment optimization. In the data acquisition stage, a large amount of raw player behavior data (including operation events, location coordinates, and corresponding behavior labels such as "combat" and "movement") is collected through the game engine interface or system event monitoring, and outliers (such as accidental screen clicks) are filtered out. In the model training stage, labeled data is used to train the classification algorithm, adjusting model parameters to minimize classification error (such as the cross-entropy loss function). Simultaneously, feature extraction strategies are optimized through feature importance analysis (such as calculating the contribution of each feature to the classification result) (e.g., retaining the angle of the direction vector instead of its components). In the deployment optimization stage, the trained model is lightweighted. Redundant neurons are removed through pruning, and parameters are quantized (e.g., converting floating-point numbers to 8-bit integers) to reduce computational load, ensuring that the time for a single feature extraction and pattern recognition on a mobile CPU is less than 10ms, meeting real-time requirements.

[0043] In practical applications, one example shows that the behavior trajectory analysis engine can employ a parallel spatiotemporal dual-branch network. The spatial flow uses a CNN to extract spatial distribution features of position coordinates (e.g., heatmap clustering), while the temporal flow uses a Transformer encoder to capture the temporal dependencies of operation events (e.g., the periodicity of skill release intervals). Finally, a cross-modal attention mechanism fuses the spatiotemporal features, suitable for scenarios requiring simultaneous analysis of spatial clustering and behavioral rhythm (e.g., dungeon raiding behavior in MMORPGs). Furthermore, artificial rule constraints are introduced into the Transformer architecture to establish a rule-attention network. Threshold triggering mechanisms are set for key indicators such as operation density and movement direction. For example, when the operation density exceeds a preset threshold, the attention mechanism is forced to focus on features of the relevant time step, enhancing the model's sensitivity to sudden combat behaviors.

[0044] In another example, the behavior trajectory analysis engine can be implemented using a combination of Hidden Markov Models (HMMs) and reinforcement learning. For instance, an HMM-based state transition model is constructed to define behavioral states (such as "combat preparation" or "moving"), and the state transition probabilities are dynamically adjusted through reinforcement learning. For example, when a player is detected continuously clicking skill keys (operation density > 10 times / second), the HMM automatically switches the state to "combat breakout" and triggers a resource preloading strategy. Furthermore, the player's trajectory is treated as a continuous-time function, and the differential dynamics of position changes are modeled using Neural ODE. For example, by modeling the derivative of the movement direction vector, the curvature of the path the player is about to turn can be predicted, thus anticipating scene switching needs. This model is particularly suitable for processing fine-grained trajectory data with high-frequency sampling (e.g., 100ms / time). This model has advantages in dynamic environment adaptability and decision interpretability.

[0045] Through this layered architecture, the behavior trajectory analysis engine can efficiently process continuous player behavior data, transform discrete operation events and location information into understandable behavioral features, and output the player's current behavior pattern through pattern recognition, providing key short-term behavioral basis for subsequent resource preloading (such as the preloading of melee weapon models triggered by the "combat operation" mode).

[0046] As an optional embodiment, in the above steps, the topological distance between the player's current location and each game scene is calculated based on the player behavior data using a scene semantic parsing engine and the game map topology, in order to obtain the spatiotemporal correlation between the player and each game scene, including: The game map topology is converted into a weighted graph structure, where each game scene is a node and the actual topological distance between game scenes is the edge weight. Sampling coordinates of the player's location are extracted from the player behavior data every 0.5 seconds, and these coordinates are projected onto the weighted graph structure to obtain the player's current hotspot activity area. The topological distance from the hotspot activity area to the nodes of each game scene is calculated. The reciprocal of the topological distance from the hotspot activity area to the nodes of each game scene is multiplied by the scene classification coefficient of each game scene to obtain the spatiotemporal correlation between the player and each game scene.

[0047] The scene classifications must include at least: main quest areas, resource gathering areas, and hidden areas. The scene classification coefficients must include at least: a priority coefficient of 0.9 for main quest areas, a priority coefficient of 0.6 for resource gathering areas, and a priority coefficient of 0.3 for hidden areas.

[0048] Specifically, the scene semantic parsing engine is the core module of the game resource dynamic loading system. It constructs a spatiotemporal relationship model between players and scenes by integrating the game map's topological structure with real-time player location data. The engine's model structure adopts a layered processing architecture, including a map abstraction layer, a position projection layer, a distance calculation layer, and a relationship generation layer. The map abstraction layer is responsible for converting the discrete scenes of the game map into graph-structured data. Each scene acts as a node in the graph, and the edge weights between nodes are determined by the topological distance of the actual travel path (such as path length and terrain complexity). The position projection layer uses spatial indexing algorithms (such as KD-trees or grid partitioning) to map the player's real-time sampled coordinates to the nearest node or region in the graph structure, forming hotspot activity area markers. The distance calculation layer calculates the topological distance from hotspot areas to each scene node based on the shortest path algorithm of the graph (such as Dijkstra's algorithm or an improved A* algorithm), and then performs weighted processing based on scene classification coefficients (0.9 for main quest areas, 0.6 for resource collection areas, and 0.3 for hidden areas) to finally generate a spatiotemporal relationship matrix.

[0049] In an optional example of the above steps, the hotspot region where the player is located at time t is calculated. To each game scene node Topological distance Represented as: .in, From the player's current hot activity area to game scene nodes The topological distance. Let j be the j-th node in the set of game scene nodes. For directed edges in a weighted graph The weight represents the hotspot area. To the game scene The shortest path length (calculated using the A* algorithm).

[0050] In game resource preloading, this formula is used to dynamically calculate the spatial correlation strength between the player and each scene. For example, if the player is currently located in a combat scene node... Then the distance to other scenes is... For example, the distance to the resource area is 80 meters, and the distance to the hidden area is 150 meters. Alternatively, if the player moves to the resource area node... The distance to the resource zone A value of 0 triggers high-priority loading of resources for that scenario.

[0051] Furthermore, define the scene priority coefficient. ∈ {0.9, 0.6, 0.3} (corresponding to the main storyline / resources / hidden areas respectively), spatiotemporal correlation The calculation is as follows: ;in, Avoid division by zero. Scenario priority coefficient. Reflecting strategic value weight, Represents topological distance The reciprocal of this reflects the spatial proximity decay effect. Next, the spatiotemporal correlation of all scenes is considered. After performing Softmax normalization, the final association degree distribution is obtained, namely: ;in, This is the temperature coefficient. This step ensures that the correlation degree conforms to the probability distribution characteristics, facilitating subsequent resource scheduling decisions. Here, Parameters are adjusted to smooth the probability distribution and prevent numerical instability in extreme scenarios. A distance penalty term is constructed using a reciprocal function, causing the correlation to decrease superlinearly with increasing distance, consistent with the attention focus diffusion pattern in player behavior psychology. This enables non-linear enhancement of the relevance of scene types. For example, even if the main quest area is far away, its relevance may still be higher than that of nearby hidden areas. This represents the spatiotemporal correlation between various scenarios. Based on the above formula, according to... Allocate rendering resources, such as the probability of correlation between combat scenes. The value is 0.6, in which case 60% of the rendering pipeline is allocated; the probability of hidden scene correlation is also considered. The value is 0.05, meaning only 5% of resources are reserved in this case. The allocation strategy here can be determined based on the actual situation.

[0052] For example, the core algorithm of the scene semantic parsing engine is based on a fusion architecture of graph neural networks (GNN) and attention mechanisms. GNN models the topological relationships between scenes, aggregating features of adjacent nodes (such as scene type and priority coefficients) through a message passing mechanism, and dynamically updating node representations. The attention mechanism dynamically weights the topological distance between different scenes. For example, when a player approaches the main quest area, its corresponding attention weight is amplified due to its high priority coefficient (0.9), thereby increasing the scene's contribution to the correlation calculation. The model construction process consists of three stages: First, map topological data (scene coordinates, path connections) is extracted through the game engine interface to construct an initial graph structure and store it as an adjacency matrix. Second, the accuracy of the position projection module is trained using historical player behavior data to optimize the mapping error from coordinates to graph nodes. Finally, a dynamic adjustment strategy for scene classification coefficients is adjusted through reinforcement learning. For example, when players frequently explore hidden areas, the correlation weight of that type of scene is automatically increased to adapt to the exploration behavior.

[0053] From a model principle perspective, the calculation of spatiotemporal relevance integrates spatial topological features and semantic priority. When a player is in a hotspot area, the engine calculates the topological distance from that area to all scene nodes using a graph shortest path algorithm, forming a basic distance vector. Subsequently, scene classification coefficients are used as adjustment factors to nonlinearly transform the distance vector. The distance values ​​of high-priority scenes (such as the main quest area) are compressed (using a reciprocal operation), while the distance values ​​of low-priority scenes are amplified, thus reflecting the strategic importance of scenes in the relevance calculation. For example, the topological distance of 5 in the main quest area, after being adjusted by a coefficient of 0.9, contributes 1 / 5 × 0.9 = 0.18 to the relevance, while the relevance contribution of the same distance in the hidden area is only 0.06. This design allows the engine to prioritize preloading high-value scene resources that the player is likely to visit.

[0054] In terms of construction, the engine adopts a modular development strategy. The map abstraction module extracts scene topology through the navigation mesh system of Unity or Unreal Engine, discretizes continuous terrain into traversable area nodes, and pre-calculates the shortest path weights between nodes based on the A* algorithm. The location projection module integrates spatial partitioning algorithms (such as Voronoi diagrams or quadtrees) to achieve rapid scene attribution determination of player coordinates, and its accuracy can be dynamically adjusted by introducing LOD (Level of Detail) technology. Sub-meter level partitioning is used in densely built areas, while ten-meter level partitioning is used in open areas to balance computational overhead. The correlation calculation module implements a graph convolutional network (GCN) based on the PyTorch Geometric framework, aggregating scene features through multi-layer graph convolution, and finally outputting the correlation vector between the player and each scene. During deployment, TensorRT is used for model quantization, converting floating-point operations to INT8 format, ensuring that the accuracy loss is less than 1%, and controlling the single calculation latency to within 20ms to meet the real-time requirements of mobile devices.

[0055] In the scene semantic parsing engine, firstly, the static topological structure of traditional game maps is transformed into a dynamic graph model, supporting dynamic adjustment of scene weights at runtime (such as increasing the priority coefficient of dungeon entrances in real time based on player behavior). Secondly, a hybrid distance metric mechanism is introduced, which weights and fuses Euclidean distance and topological path distance, considering both physical spatial proximity and logical passage cost. Finally, through a configurable scene classification coefficient system, resource loading strategies are deeply integrated with gameplay, such as automatically increasing the relevance weight of battlefield areas in PvP mode.

[0056] Optionally, the dual-engine analysis network can further achieve real-time performance and lightweight design through hierarchical optimization and an algorithm-hardware co-engineering architecture. Regarding real-time performance, the behavior trajectory analysis engine employs a sliding window segmentation strategy, cutting continuous behavior data into short 500-millisecond segments, retaining only key frame features (such as operation density peaks and direction abrupt changes) to reduce redundant computation. The scene semantic parsing engine uses spatial indexing acceleration techniques (such as quadtree partitioning) to reduce map node query complexity from linear to logarithmic levels, ensuring topological distance calculation is completed within 2 milliseconds. The dual engines use an asynchronous pipeline architecture to process data streams in parallel; behavior feature extraction and topological distance calculation pass intermediate results through shared memory, avoiding serial waiting delays. At the hardware level, a lightweight CUDA kernel is deployed using a mobile GPU / dedicated AI chip to accelerate convolution operations and graph matrix multiplication, increasing computational utilization to over 80%. Simultaneously, dedicated channels are allocated to critical data using 5G network slicing technology, ensuring end-to-end transmission latency is less than 10 milliseconds.

[0057] To address the characteristics of mobile devices, the dual engines underwent multi-dimensional lightweight transformations. In terms of model architecture, in some examples, the behavior engine adopted the TSN-Tiny time-series model instead of the traditional time-series model, reducing the number of parameters through event-driven processing. Alternatively, the scene engine introduced a graph attention mechanism (GAT) to dynamically allocate node computation weights, allocating higher resources to high-frequency access scenes (such as the main city) and using approximate calculations for less frequent scenes. Regarding energy management, the computation granularity was dynamically adjusted based on device battery status and temperature sensor data. When the battery level was below 20%, the number of graph convolutional layers in the scene engine was limited, retaining only the computation of first-level neighbor nodes. The Android JobScheduler API was used to preload the historical behavior pattern library when the screen was off, reducing real-time computation pressure. Furthermore, optionally, differential coding and Huffman coding compression techniques were used for data stream processing, reducing data volume, and differential privacy technology was used to add noise to prevent trajectory leakage. The instruction set was optimized on the CPU, with matrix multiplication and normalization operations vectorized, improving instruction-level parallelism. Combined with the Vulkan computing API, the GPU computing power was directly invoked, bypassing the graphics rendering pipeline, thus reducing memory bandwidth usage.

[0058] In some practical examples, a lightweight inference engine (TensorFlow Lite) is deployed at the terminal layer, retaining only core modules (such as behavioral feature extraction and topology calculation), with model loading memory usage controlled within 150MB. At the edge layer, a medium-sized model (medium-scale GNN) is deployed on CDN nodes to handle some scene correlation calculations, reducing terminal load. A full-version dual-engine model runs in the cloud for training and policy updates, with encrypted parameter aggregation achieved through a federated learning framework. The dynamic loading mechanism is based on Split APK technology, downloading functional modules on demand; for example, open-world games prioritize loading scene parsing modules, while MMORPGs focus on behavioral analysis modules. Updates employ a differential distribution strategy, compressing model parameter change packages to within 1MB, and reducing bandwidth consumption in conjunction with the differential update mechanism.

[0059] Step S103: Using a micro neural network pre-deployed in the mobile phone, the player's resource needs are predicted in a time-sharing manner based on the player's behavioral characteristics and / or the spatiotemporal correlation, so as to obtain pre-loaded time-sharing game resources.

[0060] In this embodiment of the application, the time-sharing game resources are divided into the following categories according to the prediction period: short-term scene resources located in the predicted movement direction under the short-term prediction dimension, medium-term scene resources located within a preset distance around the player's current position under the medium-term prediction dimension, and plot node resources with a trigger probability higher than a set probability threshold under the long-term prediction dimension.

[0061] It is understood that in this embodiment, the allocation of time-sharing game resources is based on the temporal continuity of player behavior and the spatial distribution characteristics of the scene. By predicting resource needs within different time spans, dynamic preloading and optimized scheduling of game content are achieved. The short-term prediction dimension focuses on scene resources in the player's current movement direction. For example, when the player is moving north, the system prioritizes preloading terrain, buildings, and quest item resources along the northern path to ensure that the player arrives at the target area within 10-30 seconds without waiting for loading. The medium-term prediction dimension covers scene resources within a radius of 50-100 meters around the player's current location, including resources related to potentially triggered side quests, hidden storylines, or combat events. These resources are typically accessed within 1-3 minutes. The long-term prediction dimension targets storyline node resources. For example, based on characteristics such as the player's historical task completion rate and character growth curve, it predicts the main storyline climax or large dungeon entrance that may be triggered in the next 5-10 minutes. These resources need to be loaded 30 seconds to 2 minutes in advance.

[0062] In step S103, the acquisition of time-sharing resources relies on the multi-level feature fusion mechanism of the micro-neural network. The input layer receives two types of core data: first, player behavior characteristics, including time-series data such as operation frequency (e.g., skill release interval, camera rotation speed), movement direction change rate, and scene dwell time within the past 30 seconds; second, a spatiotemporal correlation matrix, composed of priority coefficients of each scene generated by the scene semantic parsing engine and topological distance weighted values. The hidden layer of the network dynamically allocates weights through an attention mechanism. For example, when the player continuously moves towards the resource collection area, the short-term prediction module strengthens the weight of resources collected at the collection points along the path, while the long-term prediction module reduces the loading priority of story nodes in hidden areas based on the scene classification coefficient. The output layer generates three types of resource demand probability distributions. The system selects the set of resources that need to be preloaded based on probability thresholds and achieves a dynamic balance between bandwidth and computing power through a differential loading strategy (e.g., prioritizing the loading of high-probability short-term resources and delaying the loading of low-probability long-term resources).

[0063] Clearly, the core function of time-sharing game resources lies in optimizing the balance between player experience and system resource consumption. Short-term resource preloading can eliminate visual stuttering during scene transitions. For example, when players approach the boundary of a new map, terrain meshes and lighting data of adjacent areas are preloaded to ensure smooth movement. Mid-term resource preloading predicts player exploration paths and pre-caches resources for potential interactive events (such as treasure chests and destructible objects), reducing real-time computational pressure. Long-term resource preloading is based on player behavior pattern analysis. For example, for players who frequently participate in PvP battles, the system preloads battlefield maps, skill effects, and respawn point resources to ensure resources are ready when large-scale team battles break out. In some application tests, this mechanism can shorten scene loading times and reduce peak memory usage in open-world games. Furthermore, by dynamically adjusting the preloading range (such as reducing the mid-term resource cache radius on low-end devices), it adapts to diverse hardware conditions while maintaining a good user experience.

[0064] As an optional embodiment, in step S103, a micro neural network pre-deployed in the mobile phone is used to predict the player's resource needs in a time-sharing manner based on the player's behavioral characteristics and / or the spatiotemporal correlation, so as to obtain pre-loaded time-sharing game resources, including the following steps: A feature extraction layer is used to convert the player operation density in the player behavior features into heat indexes corresponding to each operation type; and the spatiotemporal correlation between players and each game scene is converted into scene weight coefficients for each game scene. A short-term prediction layer based on the lightweight temporal convolutional network TCN-Lite is used to adaptively capture the direction change pattern based on the player movement direction in the player behavior features and the heat index, so as to predict the short-term movement direction within the next 5 seconds; and to search for the game scene node that is in the short-term movement direction and can be reached within 5 seconds to obtain the short-term scene block number within 5 seconds. A mid-term prediction layer based on the spatiotemporal graph neural network STGNN-Micro is used. Based on the player's current position in the player's behavior features and the scene weight coefficient, combined with the short-term movement direction in the next 5 seconds, the movement probability weight from the player's current position to the surrounding scene blocks in the next 30 seconds is calculated. The three scene blocks with the highest movement probability weights are used as mid-term scene block codes. A long-term prediction layer based on a lightweight Transformer encoder is used to predict the probability of a player triggering a game side quest consecutively within the next 2 minutes based on the player operation type, player operation density, local operation hotspots, and game tasks completed within 5 minutes in the player behavior characteristics. Game side quests with a trigger probability higher than 5 within the next 2 minutes are designated as key plot nodes. The short-term scene resources are defined by the short-term movement direction and short-term scene block number within the next 5 seconds; the medium-term scene resources are defined by the medium-term scene block code within the next 30 seconds; and the game resources required for key plot nodes within the next 2 minutes are defined as plot node resources.

[0065] In step S103, the micro-neural network achieves time-sharing prediction of player resource needs through a hierarchical feature processing and prediction mechanism. Assuming the micro-neural network adopts a serial architecture, consisting of a feature extraction layer, a short-term prediction layer, a medium-term prediction layer, and a long-term prediction layer, the outputs of each layer are weighted and fused to generate a time-sharing game resource list.

[0066] Based on the above assumptions, the feature extraction layer first compresses the dimensionality of player behavior features, converting the operation density into heat indices corresponding to six types of operations (such as skill release, camera rotation, movement acceleration, etc.). Each index reflects the intensity distribution of the operation within a time window. For example, the skill release heat index is calculated by using a sliding window to count the trigger frequency of each skill within the last 10 seconds, and then normalized by the Sigmoid function to form a 6-dimensional vector. The spatiotemporal correlation is then calculated by weighting the scene classification coefficients (main quest 0.9, resource 0.6, hidden 0.3) with the inverse of the topological distance to generate priority weights for each scene. For example, the weight of the main quest area 20 meters away from the player is 0.9 / 20=0.045, while the weight of the hidden area at the same distance is 0.3 / 20=0.015.

[0067] The short-term prediction layer is built on TCN-Lite (Lightweight Temporal Convolutional Network), and its core improvement lies in the adoption of a depthwise separable causal convolution stacking structure. Traditional TCNs use dilated causal convolutions to expand the receptive field, but the number of parameters increases exponentially with the number of layers. This application replaces standard convolutions with depthwise separable convolutions and changes the channel shuffling operation to point-by-point addition, reducing the number of parameters to 1 / 3 of the original model while maintaining a 32-layer stack. After inputting player movement direction data (converted to a 3D direction vector by quaternions) and heat index, the network dynamically adjusts the importance of features in each direction through an adaptive gating mechanism. For example, when the player continues to move due north and the skill heat index suddenly increases, the network strengthens the weight of the north-direction feature channel and suppresses interference from other directions, ultimately outputting the probability distribution of movement directions within the next 5 seconds. The output of this layer is processed by non-maximum suppression to filter out the movement path with the highest probability and retrieve the scene node numbers reachable within 5 seconds on the path.

[0068] The mid-term prediction layer relies on a lightweight spatiotemporal graph neural network (STGNN-Micro), whose innovation lies in dynamic graph construction and a sparse attention mechanism. The network takes the player's current position coordinates and scene weight coefficients as input to construct a local spatiotemporal graph: nodes include the player's current scene and scenes within a 50-meter radius, with edge weights dynamically calculated based on spatiotemporal correlation and movement probability. For example, when the player moves towards a resource area, the edge weights of adjacent resource scenes are increased to 1.5 times their original value. Graph convolution employs a graph attention mechanism (GAT), but reduces the number of multi-head attention heads from 8 to 2 and introduces an edge pruning strategy. Only the top 20% of edges with the highest weights are retained for computation. In this way, the network only needs to process about 50 effective nodes within a 30-second prediction period, instead of the 200 required by traditional models, reducing computation by 75%. Finally, the three scenes with the highest movement probability are output as the mid-term resource loading targets.

[0069] The long-term prediction layer uses a lightweight Transformer encoder, focusing on optimizing positional encoding and the multi-head attention mechanism. Traditional Transformer positional encoding uses a sine function, but player paths in mobile game scenarios have spatial continuity. This application uses relative positional encoding, recording only the change in movement direction within adjacent 5 seconds. The multi-head attention mechanism reduces the number of heads from 12 to 4 and adopts a sparse query mode: attention is calculated only for side quests corresponding to high-frequency actions in the player's historical operations (e.g., melee attack trigger rate > 30%). Input data includes quest completion records within 5 minutes, operation type distribution (e.g., healing skills account for 25%), and local operation hotspots (e.g., a certain area with a click density of 5 times / second). The network predicts the probability of side quest triggering within the next 2 minutes using an autoregressive approach. For example, if a player frequently uses healing skills in a desert map and is currently near an oasis, the system determines that there is a 72% probability of triggering the "Water Source Conquest" side quest and includes this story node resource in the pre-loading list.

[0070] Compared to related technologies, the improvements in this application's embodiments are reflected in three aspects: First, the hierarchical prediction mechanism avoids the performance loss of a single model handling tasks with multiple time spans. Traditional single-model solutions need to process predictions of 5 seconds to 10 minutes simultaneously, leading to computational redundancy. This application optimizes feature extraction efficiency for each time period through dedicated sub-networks. Second, lightweight modifications are implemented across all levels. For example, TCN-Lite's depthwise separable convolutions reduce the number of parameters, STGNN-Micro's dynamic graph pruning reduces graph computation overhead, and Transformer's sparse attention reduces memory usage. Finally, hardware adaptation optimization significantly improves mobile performance. For example, by utilizing Android's RenderThread to offload graph convolution operations to the GPU, combined with INT8 quantization, the model inference speed reaches 120 FPS.

[0071] Step S104: Based on the predicted period length and game resource type, the time-sharing game resources are classified by temperature attribute, and loaded into the isolation cache according to the temperature attribute. Furthermore, different temperature attributes are matched with different management strategies in the dynamic unloading mechanism.

[0072] Step S105: A dynamic unloading mechanism is used to manage time-sharing game resources with different temperature attributes in the isolation buffer.

[0073] Step S106: In response to the player's real-time operation behavior, elastically load the time-sharing game resources in the isolated cache area.

[0074] In this embodiment, the temperature attribute of time-sharing game resources is dynamically classified based on the timeliness and importance of resource access, and is divided into high temperature attribute (short-term resource), medium temperature attribute (medium-term resource) and low temperature attribute (long-term resource).

[0075] Specifically, the high-temperature attribute corresponds to resources that need to be used immediately within the next 5 seconds, such as terrain meshes, building models, and interactive props in the player's current movement direction. These have the highest loading priority and must be pre-loaded within 20ms to ensure smooth movement. The medium-temperature attribute covers scene resources that may be triggered within the next 30 seconds, such as side quest props, destructible objects, and hidden story trigger points within a 50-meter radius of the player. These resources use a progressive loading strategy, prioritizing core interactive components. The low-temperature attribute is associated with high-value story node resources (such as main quest climax scenes and large dungeon entrances) that have a probability of triggering within the next 2 minutes. Its loading strategy focuses on bandwidth reservation and resource integrity verification, allowing loading to be delayed until 30 seconds before the player's action is triggered.

[0076] Compared to traditional static grading based on fixed time thresholds (such as only distinguishing between "near / medium / far" distance), this application dynamically adjusts the temperature threshold through a dual dimension of prediction period and resource type. For example, when players are moving at high speed, the prediction period for mid-range resources is shortened to 20 seconds, while it is extended to 40 seconds when exploring at low speed, making resource allocation more in line with actual behavior patterns. In addition, the temperature attribute can be superimposed with scene semantic weights (such as automatically upgrading main quest resources to the high-temperature attribute), breaking through the limitations of traditional purely distance-driven grading.

[0077] In this embodiment, the dynamic unloading mechanism implements differentiated resource management based on temperature attributes. Specifically, high-temperature resources are subject to a strong retention strategy, prohibiting unnecessary unloading. Low-frequency resources are only evicted using the LRU (Least Recently Used) algorithm when memory usage exceeds 90%. Medium-temperature resources employ an elastic replacement strategy, dynamically adjusting cache weights based on resource access frequency and prediction confidence. For example, resources in frequently accessed collection areas are prioritized for retention, while resources in hidden areas with low-confidence predictions can be temporarily unloaded. Low-temperature resources are subject to an on-demand loading strategy, triggering loading only when player behavior closely matches predictions, and releasing memory through differential release techniques (such as releasing non-critical story branch resources). Compared to traditional global LRU or FIFO unloading strategies, this mechanism introduces a temperature-aware hybrid eviction algorithm. Under memory pressure, low-confidence resources in low-temperature attributes are prioritized for eviction, while high-priority resources in high-temperature attributes are retained, improving memory utilization and reducing lag. For example, when a player moves from a resource collection area to a combat area, the system immediately unloads medium-temperature resources related to collection tools while retaining high-temperature resources for combat skill effects, ensuring the continuity of behavior switching.

[0078] In this embodiment, elastic loading refers to dynamically adjusting the preloading range and priority based on the player's real-time operations. Its core lies in a closed-loop mechanism of prediction and feedback. When a player changes direction, the system predicts a new path based on historical trajectory and recalculates the short-term resource loading queue. For example, when changing from north to east, the loading task for the original northern scene is immediately terminated, and resources for the eastern path are preloaded instead. In practical applications, incremental resource replacement technology updates only resource requests for the changed path segment, avoiding bandwidth waste caused by full reloading. Compared to traditional static preloading schemes (such as fixed-radius loading), elastic loading dynamically expands the loading area based on player operation hotspots (such as frequently turning points). For example, when a player repeatedly explores a certain area, the mid-term resource cache radius is automatically expanded to 80 meters. Experimental data shows that in open-world games, this mechanism reduces peak memory usage, shortens scene switching latency from 1.2 seconds to 0.4 seconds, and reduces critical resource loading conflicts through a priority inheritance mechanism (such as temporarily increasing skill resource loading priority during combat), thus improving player response speed.

[0079] As an optional embodiment, in step S104, the temperature attributes of the time-sharing game resources are classified according to the prediction period length and the game resource type, and then loaded into the isolation cache according to the temperature attributes, including: According to the game resource type, each game resource in the short-term scene resources, the mid-term scene resources, and the plot node resources is marked as recyclable or non-recyclable; the correlation between each game resource in the short-term scene resources, the mid-term scene resources, and the plot node resources and the current game progress is determined; the temperature attribute of game resources with a correlation greater than a set core resource threshold is determined as hot resources, the temperature attribute of game resources marked as recyclable is determined as warm resources, and the temperature attribute of game resources not used within 5 minutes is determined as cold resources.

[0080] Specifically, in step S104, the temperature attribute classification of time-sharing game resources is achieved through a multi-dimensional dynamic evaluation mechanism. First, the system establishes basic classification rules based on resource type. Short-term scene resources (such as terrain grids on the player's movement path) are marked as recyclable by default because they are only effective for a limited time; mid-term scene resources (such as side quest items within 50 meters) are judged for recyclability according to preset rules, for example, one-time consumable items are marked as recyclable, while reusable scene components are marked as non-recyclable. Story node resources (such as the climax scene of the main storyline) are non-recyclable by default. Second, the correlation strength between resources and the current game progress is quantified through a correlation calculation model. This model integrates the player's historical behavior data (such as the task completion rate and item usage frequency in the last 5 minutes) and real-time status (such as the current map area and character growth stage) to generate a correlation score in the range of 0-1. For example, when a player frequently uses healing skills in the desert map and the main storyline progress reaches 70%, the system determines that the correlation of the "Oasis Supply Station" story node is 0.85, and anything exceeding the threshold of 5 is marked as a hot resource.

[0081] Therefore, compared to traditional solutions that prioritize resources based solely on time or distance, step S104 can further introduce a dynamic reclaimable marking mechanism. For example, temporary combat effect resources can be released from memory immediately after the effect finishes playing, avoiding resource waste caused by traditional static caching strategies. Simultaneously, the correlation-driven temperature grading breaks through the limitations of traditional fixed thresholds. For instance, when players explore hidden areas, even if the resource prediction cycle for that area is short, it is still classified as a hot resource for priority loading due to its high correlation. Experimental data shows that in open-world games, this mechanism reduces peak memory usage by 28% and scene switching latency from 1.2 seconds to 0.4 seconds. Furthermore, the isolated cache adopts a hot-cold tiered storage architecture. Hot resources reside in high-speed memory areas, warm resources are loaded to intermediate cache layers on demand, and cold resources are compressed and stored in low-speed storage areas, improving data reading efficiency compared to traditional uniform allocation strategies. By dynamically adjusting the capacity ratio of each layer (e.g., expanding the hot layer to 70% in combat scenes), the system maximizes resource utilization while ensuring a smooth user experience.

[0082] As an optional embodiment, in step S105, a dynamic unloading mechanism is used to manage time-sharing game resources with different temperature attributes in the isolation buffer, including: Associate hot resources with corresponding game progress nodes and set them to be non-uninstallable; if no player operation information related to warm resources is detected within the next 30 seconds, the warm resources are reclaimed from the isolation buffer to release the corresponding buffer space; set an observation period for cold resources, and if no player operation information related to cold resources is detected within the observation period, the cold resources are deleted to release the corresponding buffer space.

[0083] In step S105, the dynamic unloading mechanism implements resource management through hierarchical marking and an adaptive recycling strategy. The system adds a temperature attribute tag (hot / warm / cold) to each resource instance and establishes a resource-progress node mapping table. For example, skill effect resources (hot resources) in the main storyline battle scene are bound to the current task node to ensure they reside in the high-speed cache. For warm resources (such as surrounding environment props), the system starts a 30-second countdown timer. When the countdown reaches zero and no player interaction (such as clicking or approaching) is detected, the resource recycling process is triggered: first, the resource reference count is checked; if it is zero, memory is released; otherwise, it is downgraded to a cold resource and the observation period is extended. Cold resources (such as low-frequency side quests) adopt a two-stage observation mechanism. The initial observation period is 5 minutes; if there is no operation during this period, it is marked as pending deletion. After entering the second observation period (1 minute), release is confirmed to avoid accidental deletion of potentially related resources.

[0084] Compared to traditional static unloading strategies (such as global reclamation triggered by a fixed memory threshold), this application firstly breaks through the single time dimension in its temperature-aware reclamation triggering condition. For example, when a player continuously explores a new area, the system automatically extends the observation period for warm resources to 60 seconds to prevent lag caused by frequent loading. Secondly, the resource state transition mechanism supports dynamic adjustment. When warm resources are temporarily accessed (such as when a player returns to the original area), the timer is immediately reset and the priority is increased to avoid repeated loading overhead. Finally, the cold resource double verification mechanism reduces the false deletion rate through a secondary observation period, thereby reducing the false deletion rate and improving memory reclamation efficiency. At the same time, asynchronous reclamation threads (such as Android's WorkManager) prevent the main thread from blocking, reducing frame rate fluctuations.

[0085] As an optional embodiment, in step S106, in response to the player's real-time operation behavior, the time-sharing game resources in the isolated cache are elastically loaded, including: The system collects environmental status parameters of the mobile phone in real time; these parameters include at least: available memory value, real-time network bandwidth, and device temperature. Based on these environmental status parameters and the player's behavioral characteristics, the system adaptively adjusts the number of parallel rendering pipelines used for game resource rendering and the amount of computing resources available to each pipeline. If the player enters the target game scene, or triggers a set gameplay type or set operation type, the pre-loaded game resources in the isolation cache are synchronously injected into the parallel rendering pipeline to accelerate the rendering efficiency of the game resources. If the player does not enter the target game scene, or triggers a set gameplay type or set operation type within a first preset time period, the isolation cache is cleared, and the time-sharing game resources are reloaded.

[0086] In step S106, the elastic loading mechanism achieves efficient resource scheduling by dynamically sensing environmental conditions and player behavior. The system first establishes an environmental parameter monitoring module to collect real-time data on available mobile memory (accurate to ±50MB), real-time network bandwidth (distinguishing between Wi-Fi / 5G / 4G network types), and device temperature (monitored using both core temperature and battery temperature). For example, when the device temperature exceeds 45°C, the system automatically reduces the number of parallel rendering pipelines from the default 8 to 4 to prevent GPU overheating and frequency throttling. Simultaneously, based on player behavior feature analysis (such as movement speed >1.5m / s or skill release frequency >5 times / second within the last 3 seconds), the system dynamically adjusts the rendering resource allocation strategy: in high-speed movement scenes, 70% of computing resources are prioritized for short-term scene resource rendering pipelines, and texture streaming compression technology is enabled to reduce bandwidth consumption.

[0087] In practical applications, compared to traditional static rendering pipeline allocation schemes (such as Unity's default fixed 4-way pipeline), this mechanism achieves three breakthroughs: First, the environment-adaptive pipeline dynamic scaling enables intelligent adjustment of the number of pipelines from 0 to 12 on mobile devices, reducing peak memory usage and improving GPU utilization compared to fixed pipeline strategies. Second, the behavior-driven resource injection mechanism shortens resource loading latency during game scene transitions by predicting player action hotspots (such as preloading the scene within 50 meters to the north when continuously moving north). Finally, the dual-trigger condition cache management avoids resource waste caused by accidental player touches in traditional solutions. Experimental data shows that this strategy reduces invalid resource loading in open-world games.

[0088] Understandably, the implementation of elastic loading involves three core technical modules: the environment-aware engine uses a differential sampling algorithm to update parameters and trigger resource scheduling decisions every 100ms; the rendering pipeline dynamic orchestrator generates the optimal pipeline configuration based on device performance profiles (such as the maximum number of parallel tasks supported by an Adreno 730 GPU); and the resource injection synchronization mechanism achieves zero-wait resource transfer through dual buffer queues (a pre-loading queue and a rendering queue). For example, when a player triggers a combat action, the system immediately injects the skill effect resources (pre-decompressed into memory) from the isolation buffer into the high-priority rendering pipeline, while pausing the rendering of non-combat-related mid-game scene resources to ensure a stable combat frame rate of 60FPS. This mechanism reduces memory usage and frame rate fluctuations on low-end devices, while maintaining image quality consistency through intelligent degradation strategies (such as using texture LOD2 instead of LOD0 when network bandwidth is <10Mbps).

[0089] In an optional embodiment of step S106 above, further optionally, the number of parallel rendering pipelines used for game resource rendering and the amount of computing resources available for the rendering pipelines are adaptively adjusted according to the environmental state parameters and the player behavior characteristics. This includes: using a TCN spatiotemporal convolutional network to predict the expected operating state of the mobile phone within a preset time period based on the environmental state parameters, and using a lightweight LSTM to predict the player's behavior change trend within the preset time period based on the player behavior characteristics. Wherein, if the expected operating state remains consistent within the preset time period, the higher the player's operation density, the higher the player's movement intensity, the higher the complexity of the behavior pattern, and the more parallel rendering pipelines and computing resources are allocated to the player; the behavior pattern includes at least one of: combat mode, exploration mode, and story selection mode.

[0090] In an optional embodiment of step S106, the adaptive rendering resource allocation mechanism achieves dynamic resource scheduling through dual-model collaborative prediction. First, an environment state prediction module is constructed, employing an improved TCN (Spatiotemporal Convolutional Network) to perform temporal modeling of parameters such as available memory, network bandwidth, and device temperature. This module captures long-term dependencies of environmental parameters by expanding causal convolutional layers (Dilation=1, 2, 4), such as the correlation between memory usage fluctuations and GPU temperature rise rates over 30 consecutive seconds. Simultaneously, a behavior prediction module deploys a lightweight LSTM network, constructing a multi-dimensional behavior feature vector based on player operation density (e.g., skill release frequency > 5 times / second), movement intensity (speed > 1.5m / s duration), and behavior pattern labels (combat / exploration / story). For example, when a player frequently switches perspectives in a combat scene and the skill release interval is less than 0.3 seconds, the LSTM strengthens the weights of combat behavior features through an attention mechanism.

[0091] Compared to traditional static resource allocation schemes, this mechanism achieves breakthroughs in three aspects: First, prediction-driven dynamic scaling allows the number of rendering pipelines to be adjusted in real time according to environmental conditions and behavioral complexity. For example, when TCN predicts that the device temperature will be below 45°C within the next 10 seconds and LSTM determines that the player has entered a high-intensity combat mode, the system will dynamically expand the parallel rendering pipeline from the default 8 lanes to 12 lanes and allocate 70% of GPU computing resources to short-term scene resource rendering. Second, the multimodal feature fusion strategy breaks through the limitations of single indicators. For example, when the device has 200MB of memory remaining but sufficient network bandwidth (5G network), priority is given to loading story node resources rather than texture compression.

[0092] In an optional embodiment of step S106 above, the game resources preloaded in the isolation buffer are further optionally injected into the parallel rendering pipeline synchronously, including: real-time detection of fragmented computing resources in the mobile phone; using a multi-level LOD nesting method, the game resources preloaded in the isolation buffer are adaptively divided into elastic slices according to the data processing characteristics of the fragmented computing resources; different precision model parameters and / or texture layer-level parameters are determined according to the player's real-time behavior and the pre-configured screen importance; and the elastic slices are injected into the matching parallel rendering pipeline according to the different precision model parameters and / or texture layer-level parameters.

[0093] In an optional embodiment of step S106, the resource dynamic injection mechanism achieves efficient rendering through fine-grained resource adaptation and intelligent pipeline scheduling. The system first establishes a fragmented computing resource detection module to monitor CPU / GPU idle periods (such as rendering gaps or periods of low physics computation load) in real time, and uses asynchronous threads to preprocess isolated cache resources. For example, when it detects that the GPU has 5ms of idle time after frame rendering, it immediately starts texture compression or mesh simplification tasks to avoid performance loss in the main thread. Subsequently, a multi-level LOD nesting partitioning technique is adopted to adaptively generate flexible slices based on the data characteristics of the resources (such as model polygon count, texture resolution, and dynamic interaction frequency): high-polygon character models are split into basic geometry (LOD0), detail parts (LOD1), and special effects components (LOD2), while terrain resources are divided into block-based LOD levels according to view distance.

[0094] Here, the resource parameter adaptation layer dynamically adjusts precision parameters based on player behavior characteristics and a hierarchy strategy of visual importance. For example, when a player enters combat, the system increases the LOD level of melee weapon models to level 3 and enables PBR materials, while reducing the texture sampling rate of background vegetation to 25%. In exploration scenes, the system adjusts in the opposite way, prioritizing ambient occlusion and global illumination accuracy. This mechanism achieves intelligent matching of resources and pipelines through a priority inheritance algorithm: high-priority combat effect resources are injected into high-computing-power parallel pipelines (such as dedicated pipelines supporting ray tracing), while low-priority UI resources are allocated to low-power pipelines, ensuring maximum resource utilization.

[0095] Compared to traditional fixed LOD and static pipeline allocation schemes, the above steps can use dynamic resource slicing technology to allow the same resource to exhibit differentiated precision on different devices. For example, the first device loads a complete LOD3 character model, while the second device automatically downgrades to LOD1. Compared to a uniform LOD strategy, this reduces memory usage. Secondly, behavior-driven parameter adaptation breaks through the limitations of traditional distance-driven LOD. For example, when the player moves at high speed, the precision of distant building materials is actively reduced to free up bandwidth, reducing game frame rate fluctuations. Finally, elastic pipeline scheduling uses real-time load balancing technology to dynamically allocate rendering tasks to different performance pipelines. Experimental data shows that this solution improves GPU utilization on low-end devices while reducing rendering latency to less than 0.3 seconds.

[0096] In this embodiment, a dual-engine analysis network is used to analyze player behavior characteristics and the spatiotemporal correlation between player behaviors in real time. A lightweight micro-neural network is then employed to predict player behavior at different time scales to obtain the game resources required for loading at those scales. Finally, different management strategies are used based on the game resource type to elastically load and manage game resources in a time-sharing manner. This significantly improves the loading speed of mobile game resources while consuming minimal memory resources, ensuring smooth game operation. In summary, this embodiment solves the technical problem of game lag caused by excessively long loading times without requiring large-scale loading of game resources that consume significant memory resources.

[0097] After introducing the methods of exemplary embodiments of this application, the following references are made. Figure 2This application describes an exemplary embodiment of a mobile game resource dynamic loading optimization system. The system includes: a data acquisition unit for real-time acquisition of player behavior data; the player behavior data includes at least: player operation information, player location, player movement trajectory, and level dwell time; an analysis unit for real-time analysis of player behavior characteristics and / or spatiotemporal correlation in the player behavior data using a pre-deployed dual-engine analysis network in the mobile phone; and a prediction unit for time-sharing prediction of player resource needs based on the player behavior characteristics and / or the spatiotemporal correlation using a pre-deployed micro-neural network in the mobile phone, to obtain pre-loaded time-sharing game resources; wherein the time-sharing game resources are allocated according to the prediction period. The length is divided into: short-term scene resources located in the predicted movement direction under the short-term prediction dimension; medium-term scene resources located within a preset distance around the player's current position under the medium-term prediction dimension; and plot node resources with a trigger probability higher than a set probability threshold under the long-term prediction dimension. A storage unit is used to classify the time-sharing game resources according to the prediction period length and game resource type, and load them into an isolated cache according to their temperature attributes. Different temperature attributes are matched with different management strategies in the dynamic unloading mechanism. A management unit is used to manage time-sharing game resources with different temperature attributes in the isolated cache using the dynamic unloading mechanism. A loading unit is used to elastically load time-sharing game resources in the isolated cache in response to the player's real-time operation. The above system can implement the steps described in the above method implementation, and the specific implementation methods of each step will not be repeated here.

[0098] After introducing the methods and systems of exemplary embodiments of this application, the following describes a terminal device of an exemplary embodiment of this application. This terminal device is used to collect player behavior data in real time. The player behavior data includes at least: player operation information, player location, player movement trajectory, and level dwell time. A dual-engine analysis network pre-deployed in the mobile phone is used to analyze player behavior characteristics and / or spatiotemporal correlation in the player behavior data in real time. A micro-neural network pre-deployed in the mobile phone is used to predict player resource needs in a time-sharing manner based on the player behavior characteristics and / or the spatiotemporal correlation, so as to obtain pre-loaded time-sharing game resources. The time-sharing game resources... The resources are categorized according to the prediction period length: short-term scene resources located in the predicted movement direction under the short-term prediction dimension; medium-term scene resources located within a preset distance around the player's current position under the medium-term prediction dimension; and story node resources with a trigger probability higher than a set probability threshold under the long-term prediction dimension. Based on the prediction period length and game resource type, the time-sharing game resources are classified by temperature attributes and loaded into an isolated cache according to these attributes. Different temperature attributes are matched with different management strategies in the dynamic unloading mechanism. The dynamic unloading mechanism manages the time-sharing game resources with different temperature attributes in the isolated cache. In response to the player's real-time actions, the time-sharing game resources in the isolated cache are elastically loaded. The aforementioned terminal device can implement the steps described in the above method implementation, and the specific implementation methods of each step will not be repeated here.

[0099] After introducing the methods, systems, and terminal devices of exemplary embodiments of this application, the following references will be made. Figure 3 The computer-readable storage medium of exemplary embodiments of this application will be described, please refer to... Figure 3 The computer-readable storage medium shown is an optical disc 30, on which a computer program (i.e., a program product) is stored. When the computer program is run by a processor, it implements the steps described in the above method embodiments. The specific implementation methods of each step will not be repeated here.

[0100] It should be noted that examples of the computer-readable storage medium may also include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory, or other optical and magnetic storage media, which will not be elaborated here. The above-described embodiments are merely specific implementations of this application, used to illustrate the technical solutions of this application, and are not intended to limit it. The scope of protection of this application is not limited thereto. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that any person skilled in the art can still modify or easily conceive of changes to the technical solutions described in the foregoing embodiments within the scope of the technology disclosed in this application, or make equivalent substitutions for some of the technical features; and these modifications, changes, or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application, and should all be covered within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. A method for optimizing dynamic loading of mobile game resources, characterized in that, The method includes: Real-time collection of player behavior data; the player behavior data includes at least: player operation information, player location, player movement trajectory, and time spent in the level; A dual-engine analysis network pre-deployed in the mobile phone is used to analyze player behavior characteristics and / or spatiotemporal correlation in the player behavior data in real time; Using a micro neural network pre-deployed in the mobile phone, the player's resource needs are predicted in a time-sharing manner based on the player's behavioral characteristics and / or the spatiotemporal correlation, so as to obtain pre-loaded time-sharing game resources; wherein, the time-sharing game resources are divided into the following categories according to the prediction period: short-term scene resources located in the predicted movement direction under the short-term prediction dimension, medium-term scene resources located within a preset distance around the player's current position under the medium-term prediction dimension, and plot node resources with a trigger probability higher than a set probability threshold under the long-term prediction dimension. Based on the predicted period length and game resource type, the time-sharing game resources are classified into temperature attributes, and loaded into the isolation cache according to the temperature attributes; different temperature attributes are matched with different management strategies in the dynamic unloading mechanism. A dynamic unloading mechanism is used to manage time-sharing game resources with different temperature attributes in the isolation buffer. In response to players' real-time actions, time-sharing game resources in the isolated cache are loaded elastically.

2. The method for optimizing dynamic loading of mobile game resources according to claim 1, characterized in that, The method employs a pre-deployed dual-engine analysis network in the mobile phone to analyze player behavior characteristics and / or spatiotemporal correlation in the player behavior data in real time, including: The behavior trajectory analysis engine analyzes the operation density and movement trend in the player behavior data in real time to obtain the player behavior characteristics; the player behavior characteristics include at least: player operation type, player operation density, local operation hotspots, and player movement direction. By using a scene semantic parsing engine and combining it with the game map topology, the topological distance between the player's current location and each game scene is calculated based on the player's behavior data, so as to obtain the spatiotemporal correlation between the player and each game scene.

3. The method for optimizing dynamic loading of mobile game resources according to claim 2, characterized in that, The process involves using a behavior trajectory analysis engine to analyze the operation density and movement trends in the player's behavior data in real time to obtain the player's behavior characteristics, including: Extract the number of events triggered per second from the player behavior data to obtain the unit operation density corresponding to a unit duration; The player's location is sampled from the player behavior data every 0.5 seconds, and the extracted sampled coordinates are converted into a unit movement direction vector corresponding to a unit time duration. Construct a behavior feature vector matrix by combining the unit operation density and unit movement direction vector corresponding to the unit duration; Based on the data distribution pattern in the behavioral feature vector matrix, the player's current behavioral pattern is determined, and the player's behavioral characteristics are predicted based on the behavioral pattern.

4. The method for optimizing dynamic loading of mobile game resources according to claim 2, characterized in that, The process involves using a scene semantic parsing engine, combined with the game map topology, to calculate the topological distance between the player's current location and various game scenes based on the player's behavior data, in order to obtain the spatiotemporal correlation between the player and each game scene. This includes: The game map topology is converted into a weighted graph structure, where each game scene is a node and the actual topological distance between each game scene is the edge weight. The sampled coordinates of the player's location are extracted from the player behavior data every 0.5 seconds, and the sampled coordinates are projected onto the weighted graph structure to obtain the hotspot activity area where the player is currently located. Calculate the topological distance between the hot activity areas and the nodes where each game scene is located; The spatiotemporal correlation between players and each game scene is obtained by multiplying the reciprocal of the topological distance between the hot activity area and the node where each game scene is located by the scene classification coefficient of each game scene. The scene classification includes at least the following: main quest area, resource collection area, and hidden area; the scene classification coefficients include at least the following: the priority coefficient for the main quest area is 0.9, the priority coefficient for the resource collection area is 0.6, and the priority coefficient for the hidden area is 0.

3.

5. The method for optimizing dynamic loading of mobile game resources according to claim 1, characterized in that, The method employs a pre-deployed micro-neural network in the mobile phone to predict player resource needs in a time-sharing manner based on player behavior characteristics and / or spatiotemporal correlation, in order to obtain pre-loaded time-sharing game resources, including: A feature extraction layer is used to convert the player operation density in the player behavior features into heat indexes corresponding to each operation type; and the spatiotemporal correlation between players and each game scene is converted into scene weight coefficients for each game scene. A short-term prediction layer based on the lightweight temporal convolutional network TCN-Lite is used to adaptively capture the direction change pattern based on the player movement direction in the player behavior features and the heat index, so as to predict the short-term movement direction within the next 5 seconds; and to search for the game scene node that is in the short-term movement direction and can be reached within 5 seconds to obtain the short-term scene block number within 5 seconds. A mid-term prediction layer based on the spatiotemporal graph neural network STGNN-Micro is used. Based on the player's current position in the player's behavior features and the scene weight coefficient, combined with the short-term movement direction in the next 5 seconds, the movement probability weight from the player's current position to the surrounding scene blocks in the next 30 seconds is calculated. The three scene blocks with the highest movement probability weights are used as mid-term scene block codes. A long-term prediction layer based on a lightweight Transformer encoder is used to predict the probability of a player triggering a game side quest consecutively within the next 2 minutes based on the player operation type, player operation density, local operation hotspots, and game tasks completed within 5 minutes in the player behavior characteristics. Game side quests with a trigger probability higher than 5 within the next 2 minutes are designated as key plot nodes. The short-term scene resources are defined by the short-term movement direction and short-term scene block number within the next 5 seconds; the medium-term scene resources are defined by the medium-term scene block code within the next 30 seconds; and the game resources required for key plot nodes within the next 2 minutes are defined as plot node resources.

6. The method for optimizing dynamic loading of mobile game resources according to claim 1, characterized in that, The step of classifying the time-sharing game resources by temperature attribute based on the prediction period length and game resource type, and loading them into the isolation cache according to temperature attribute classification, includes: According to the game resource type, each game resource in the short-term scene resources, the mid-term scene resources, and the plot node resources is marked as recyclable or non-recyclable. The correlation between each game resource in the short-term scene resources, the mid-term scene resources, and the plot node resources and the current game progress; Game resources with a correlation greater than the set core resource threshold are identified as hot resources, game resources marked as recyclable are identified as warm resources, and game resources that have not been used within 5 minutes are identified as cold resources. The method of managing time-sharing game resources with different temperature attributes in the isolation buffer using a dynamic unloading mechanism includes: Associate the hot resource with the corresponding game progress node and set it to be unremovable; If no player action information related to warm resources is detected within the next 30 seconds, the warm resources will be reclaimed from the isolation buffer to release the corresponding buffer space. Set an observation period for cold resources. If no player action information related to the cold resource is detected during the observation period, the cold resource will be deleted to free up the corresponding buffer space.

7. The method for optimizing dynamic loading of mobile game resources according to claim 1, characterized in that, The elastic loading of time-sharing game resources in the isolated cache in response to the player's real-time actions includes: Real-time acquisition of environmental status parameters of the mobile phone; the environmental status parameters include at least: available memory value, real-time network bandwidth, and device temperature; Based on the environmental state parameters and the player behavior characteristics, the number of parallel rendering pipelines used for game resource rendering and the amount of computing resources available for the rendering pipelines are adaptively adjusted. If a player enters the target game scene, or triggers a set gameplay type or set operation type, the preloaded game resources in the isolation cache will be synchronously injected into the parallel rendering pipeline to accelerate the rendering efficiency of game resources. If the player does not enter the target game scene, or if the player triggers the set gameplay type and set operation type within the first preset time period, the isolation cache area will be cleared and the time-sharing game resources will be reloaded.

8. The method for optimizing dynamic loading of mobile game resources according to claim 7, characterized in that, The step of adaptively adjusting the number of parallel rendering pipelines and the amount of computing resources available for each rendering pipeline based on the environmental state parameters and player behavior characteristics includes: The TCN spatiotemporal convolutional network is used to predict the expected operating state of the mobile phone within a preset time period based on the environmental state parameters, and a lightweight LSTM is used to predict the trend of player behavior changes within a preset time period based on the player behavior characteristics. Among them, if the expected running state is consistent within the preset time, the greater the player operation density, the higher the player movement intensity, the higher the complexity of the behavior pattern, the more parallel rendering pipelines and computing resources are allocated to the player; the behavior pattern includes at least one of the following: combat mode, exploration mode, and story selection mode; The step of synchronously injecting preloaded game resources from the isolation cache into the parallel rendering pipeline includes: Real-time detection of fragmented computing resources in mobile phones; A multi-level LOD nesting approach is adopted to adaptively divide the preloaded game resources in the isolation cache into elastic slices according to the data processing characteristics of the fragmented computing resources. Based on the player's real-time behavior and the pre-configured importance of the scene, determine the model parameters and / or texture-level parameters of different precision; The elastic slices are injected into matching parallel rendering pipelines according to different precision model parameters and / or texture layer-level parameters.

9. A mobile game resource dynamic loading optimization system, characterized in that, The system includes: The data acquisition unit is used to collect player behavior data in real time; the player behavior data includes at least: player operation information, player location, player movement trajectory, and level dwell time; The analysis unit is used to analyze the player behavior characteristics and / or spatiotemporal correlation in the player behavior data in real time using a dual-engine analysis network pre-deployed in the mobile phone. The prediction unit is used to use a micro neural network pre-deployed in the mobile phone to predict the player's resource needs in a time-sharing manner based on the player's behavior characteristics and / or the spatiotemporal correlation, so as to obtain pre-loaded time-sharing game resources; wherein, the time-sharing game resources are divided into the following according to the prediction period: short-term scene resources located in the predicted movement direction under the short-term prediction dimension, medium-term scene resources located within a preset distance around the player's current position under the medium-term prediction dimension, and plot node resources with a trigger probability higher than a set probability threshold under the long-term prediction dimension. The storage unit is used to classify the temperature attributes of the time-sharing game resources according to the prediction period length and the game resource type, and load them into the isolation cache according to the temperature attributes; different temperature attributes are matched with different management strategies in the dynamic unloading mechanism. The management unit is used to manage time-sharing game resources with different temperature attributes in the isolation buffer using a dynamic unloading mechanism; The loading unit is used to elastically load time-sharing game resources in the isolated cache in response to the player's real-time actions.

10. A terminal device, characterized in that, The terminal device includes: at least one processor, a memory, and an input / output unit; wherein the memory is used to store a computer program, and the processor is used to call the computer program stored in the memory to execute the mobile game resource dynamic loading optimization method according to any one of claims 1 to 8.

Images