Game asset intelligent management and script analysis method and system based on multi-modal large language model

Abstract

The invention discloses a game asset intelligent management and script analysis method and system based on a multi-modal large language model, and relates to the technical field of artificial intelligence and game development tools. The method comprises the following steps: constructing an AI Agent workflow framework based on a state machine, and supporting a ReAct reasoning mode to realize a thinking-action-observation cycle decision; a three-layer asset naming check and renaming algorithm is realized; an intelligent asset arrangement function is realized; a resource perception map generation function supporting multi-modal input is realized; a visual script intelligent analysis and generation function is realized; a resource specification checking function is realized; and a three-layer data storage and synchronization mechanism is realized. According to the method, the efficiency and accuracy of asset management, map generation and script analysis in the game development process are improved by utilizing the semantic understanding ability of the large language model and the multi-modal understanding ability of the visual language model.

Description

Technical Field

[0001] This invention relates to the fields of artificial intelligence, game development tools, natural language processing, and computer vision, specifically to a method and system for intelligent management and script analysis of game assets based on a multimodal large language model. Background Technology

[0002] As game development projects continue to expand in scale, the number of assets in game engines (such as Unreal Engine and Unity) is growing rapidly, posing the following technical challenges to development teams: Limitations of asset naming checks: Existing asset naming check tools only support rule-based matching, such as checking whether the prefix conforms to the specification (e.g., static meshes use the SM_ prefix). However, these tools cannot identify semantic errors, including spelling errors (e.g., "Plyer" should be "Player"), meaningless names (e.g., "XX", "Asdf", "Test123"), and naming inconsistencies (e.g., using different naming styles for the same type of assets).

[0003] Efficiency issues in asset organization: Large-scale game projects typically contain tens of thousands of asset files. Asset organization relies on manual classification, which leads to problems such as low efficiency, inconsistent standards, and difficulty in maintenance.

[0004] The map generation tool lacks flexibility: existing map generation tools mainly use template filling or procedural generation methods, which cannot generate maps based on natural language descriptions. The generated results do not match the actual assets of the project, lack the ability to perceive the project asset library, and do not support multimodal input.

[0005] The lack of visual script analysis and generation: Visual scripting systems for game engines (such as Unreal Engine's Blueprints and Unity's Visual Scripting) are widely used in game logic development, but existing tools can only check for syntax errors and cannot perform semantic analysis of node naming conventions, rationality assessment of connection logic, quantitative analysis of script complexity, intelligent generation of refactoring suggestions, or automatic generation of visual scripts based on natural language descriptions.

[0006] The intelligent nature of resource specification checks is insufficient: game resources need to meet specific technical specifications to ensure performance. Although existing tools can check in batches, the rules are fixed, the repair suggestions are mechanical, and there is a lack of semantic understanding. Summary of the Invention

[0007] The technical problem this invention aims to solve is: how to utilize the semantic understanding capabilities of large language models and the multimodal understanding capabilities of visual language models to provide intelligent auxiliary functions for game development, including asset naming checks, asset organization, multimodal map generation, visual script analysis, and resource specification checks.

[0008] To address the aforementioned technical problems, this invention provides an intelligent auxiliary method for game development based on a large language model, comprising the following steps: Step 1: Construct a unified AI Agent workflow framework. A state machine-based workflow framework is adopted to manage the execution flow of various intelligent auxiliary tasks. This framework uses a directed graph structure to define task nodes and transition conditions, supporting multiple agent reasoning modes, including the ReAct (Reasoning and Acting) mode, enabling cyclical reasoning of thinking-action-observation. The framework has the following features: support for conditional branching, dynamically adjusting the execution path based on intermediate results; support for state tracking, recording the complete task execution process; and support for streaming feedback, pushing execution progress to the client in real time.

[0009] Step Two: Implement a three-layer asset naming check and renaming algorithm. The first layer is rule-based checking, including prefix checking, format checking, and length checking. The second layer is semantic checking, which uses a large language model to perform spelling checks, meaning checks, and consistency checks. The third layer is automatic renaming execution, which generates suggested names that conform to the specifications based on the check results. It supports single asset renaming and batch renaming, automatically updates all files referencing the asset, records the renaming history, and supports undo operations.

[0010] Step 3: Implement intelligent asset organization. Extract metadata such as asset name, type, and path; call the large language model to analyze the asset's purpose and infer its appropriate directory; generate an organization plan containing the target path and the reason for organization; adopt a batch processing mechanism to control the input length of a single request within the limits of the large language model's context window; return the batch processing results in real time through a streaming interface; and execute the actual move operation after waiting for user confirmation.

[0011] Step 4: Implement resource-aware map generation functionality. Query the project asset database to obtain a list of existing assets; group assets by category; receive user input, supporting multiple input modalities (natural language description, reference image input, video input, mixed input); construct prompts containing available resource information; call a large language model or visual language model to generate a map layout scheme; verify the asset paths referenced in the scheme; and perform intelligent replacement for non-existent assets. The intelligent replacement algorithm includes: filtering candidate assets based on asset category; calculating the semantic similarity between candidate assets and target assets; and selecting the asset with the highest similarity as the replacement.

[0012] Step 5: Implement intelligent analysis and generation of visual scripts. Parse the visual script file to extract node and connection information; call a large language model to analyze node naming conventions; analyze the rationality of connection logic and detect potential logical errors; calculate script complexity metrics, including the number of nodes, nesting depth, and cyclomatic complexity; generate refactoring suggestions and identify repetitive logic that can be extracted into independent modules; support automatic generation and modification of visual scripts, including generating nodes and connections based on natural language descriptions and automatically repairing detected logical errors.

[0013] Step Six: Implement intelligent resource specification checking function. Read the technical parameters of the resource, including texture size, texture format, model face count, and LOD settings; check whether the parameters comply with preset specifications; call the large language model to analyze the resource usage and generate intelligent repair suggestions; support batch checking and automatic repair.

[0014] Step 7: Implement the rule merging strategy. The cloud server stores the default rule set; the local server stores user-defined rules; during the execution of checks, local rules are merged with cloud rules; local rules have higher priority than cloud rules, and rules of the same type are subject to local rules.

[0015] Step 8: Implement a three-tiered data storage and synchronization mechanism. A layered storage architecture is adopted to achieve efficient data caching and incremental synchronization. The game engine plugin layer uses memory caching and local file storage; the local server layer uses a lightweight relational database; and the cloud server layer uses a relational database to store complete data. The synchronization mechanism includes: incremental synchronization, synchronizing only changed data; conflict resolution, using a timestamp comparison strategy, with the latest modification taking precedence; and offline support, with local caching supporting offline operation and automatic synchronization upon reconnection.

[0016] The beneficial effects of this invention include: improving the accuracy of naming checks, with a three-layer checking algorithm that can identify semantic errors that rule checks cannot detect; improving asset organization efficiency by automatically analyzing asset usage and generating organization plans; increasing map generation flexibility by supporting natural language and multimodal input, and constraining the use of only assets actually existing in the project; filling the gap in visual script analysis by providing functions such as naming checks, logical analysis, complexity calculation, and refactoring suggestions; improving resource inspection efficiency by combining rule checks and intelligent analysis to generate repair suggestions; and supporting offline work and incremental synchronization, with a three-layer architecture ensuring data consistency. Attached Figure Description

[0017] Figure 1 This is a diagram of the overall system architecture of the present invention.

[0018] Figure 2 This is a flowchart of the three-layer naming check and renaming process of the present invention.

[0019] Figure 3 This is a flowchart of the intelligent asset organization process of the present invention.

[0020] Figure 4 This is a flowchart of the resource-aware map generation process of the present invention.

[0021] Figure 5 This is a flowchart of the visualization script analysis process of the present invention.

[0022] Figure 6 This is a schematic diagram of the AI ​​Agent state machine workflow of the present invention.

[0023] Figure 7 This is a flowchart of the three-layer data storage and synchronization process of the present invention.

[0024] Figure 8 This is a flowchart of the multimodal map generation process of the present invention. Detailed Implementation

[0025] The present invention will now be described in further detail with reference to the accompanying drawings and specific embodiments.

[0026] like Figure 1 As shown, the intelligent auxiliary system for game development provided by this invention includes three main modules: a game engine plugin module, a local server module, and a cloud server module.

[0027] Game Engine Plugin Module: Responsible for event listening, user interface, and communication with the local server. This module is integrated into the game engine editor, listening for events such as asset creation, modification, and deletion, providing a user interface, and communicating with the local server via HTTP protocol.

[0028] Local server module: Responsible for rule management, request forwarding, and cache management. This module runs on the developer's local computer, stores user-defined rules, forwards requests from the game engine plugin to the cloud server, and caches frequently used data to improve response speed.

[0029] The cloud server module includes an AI Agent workflow framework, a large language model interface, a visual language model interface, an asset database, and a multimodal parsing module. Deployed in the cloud, this module provides core intelligent analysis capabilities.

[0030] like Figure 2 As shown, the three-layer asset naming check and renaming process includes: the first layer is rule checking, which verifies whether the naming prefix, format, and length conform to the specifications; the second layer is semantic checking, which calls a large language model to identify spelling errors, meaningless names, and naming inconsistencies; the third layer is automatic renaming, which generates suggested names that conform to the specifications, supports single and batch renaming, automatically updates references, and records history.

[0031] like Figure 3As shown, the intelligent asset organization process includes: extracting asset metadata; calling a large language model to analyze the asset's purpose; generating an organization plan; adopting a batch processing mechanism; returning results through a streaming interface; and executing the move operation after waiting for user confirmation.

[0032] like Figure 4 As shown, the resource-aware map generation process includes: querying the project asset database; grouping assets by category; receiving user input (supporting multimodal input); constructing prompt words; calling a large language model or visual language model to generate a solution; verifying asset paths; and performing intelligent replacement for non-existent assets.

[0033] like Figure 5 As shown, the visual script analysis process includes: parsing the script file; extracting node and connection information; calling the large language model to analyze naming conventions; analyzing connection logic; calculating complexity metrics; generating refactoring suggestions; and supporting automatic generation and modification.

[0034] like Figure 6 As shown, the AI ​​Agent state machine workflow includes: defining task nodes and transition conditions; supporting ReAct reasoning mode (think-act-observe loop); supporting conditional branching; supporting state tracking; and supporting streaming feedback.

[0035] like Figure 7 As shown, the three-layer data storage and synchronization mechanism includes: the game engine plugin layer uses memory caching and local files; the local server layer uses a lightweight relational database; and the cloud server layer uses a relational database. It adopts an incremental synchronization strategy, supports conflict resolution, and supports offline operation.

[0036] like Figure 8 As shown, the multimodal map generation process includes: receiving multimodal input (natural language, images, videos, and hybrid inputs); analyzing images and videos using a visual language model; extracting scene elements and layout features; generating a map solution by combining the project asset library; and performing intelligent asset replacement.

[0037] Example 1: Asset Naming Check and Renaming. A developer creates a static mesh asset in Unreal Engine named "Plyer_Model". The system automatically triggers a naming check: the first-level rule check passes (prefix correct); the second-level semantic check finds a spelling error ("Plyer" should be "Player"); the third-level automatic renaming generates a suggested name "SM_Player_Model"; after the developer confirms, the system automatically renames the asset and updates all blueprints and materials referencing that asset.

[0038] Example 2: Intelligent Asset Organization. The project contains 5,000 asset files scattered across multiple directories. The developer initiates the asset organization function, and the system processes assets in batches (100 per batch), calling a large language model to analyze the purpose of each asset and generate an organization plan (e.g., moving "Tree_01" to the "Environment / Nature / Trees" directory). The progress is displayed in real time through a streaming interface, and the move operation is executed after the developer confirms.

[0039] Example 3: Multimodal Map Generation. Developers upload a reference image of a forest scene and enter the text description "Generate a forest scene containing trees, rocks, and a stream." The system analyzes the image using a visual language model, extracting scene elements (tree type, rock distribution, water flow characteristics), and combines this with existing tree, rock, and water assets in the project asset library to generate a map layout scheme. It then performs intelligent replacement of assets appearing in the image but not in the project (e.g., replacing the pine tree in the image with "Oak_Tree" from the project), ultimately generating a map that conforms to the project asset library.

[0040] Example 4: Visual Script Analysis. The developer created a complex blueprint containing 200 nodes. The system analyzes the blueprint and finds non-standard node naming (e.g., "Function1", "Temp"), potential errors in the connection logic (e.g., unhandled null pointers), computational complexity metrics (cyclomatic complexity of 15, refactoring recommended), and identified duplicate logic (3 identical computational logics can be extracted into independent functions). It generates refactoring suggestions and supports automatic execution.

[0041] Example 5: Resource Specification Check. The project contains 1000 texture resources. The system batch checks these textures and finds that 50 textures have sizes that do not conform to the specifications (they should be powers of 2), and 20 textures have incorrect formats (they should use compressed formats). The system calls a large language model to analyze the use of the resources and generates intelligent repair suggestions (e.g., adjust UI textures to 1024x1024, convert scene textures to BC7 compressed format), supporting batch automatic repair.

[0042] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A method for intelligent management and script analysis of game assets based on a multimodal large language model, characterized in that... Includes the following steps: A state machine-based AI Agent workflow framework is constructed. The workflow framework uses a directed graph structure to define task nodes and transition conditions, supporting intelligent auxiliary tasks in game development. It receives asset, script, or resource data from the game engine; it calls the corresponding AI Agent to perform intelligent analysis based on the task type. The AI ​​Agent adopts a reasoning-action-observation loop mode to achieve autonomous decision-making and task execution; it returns the analysis progress and results in real time through a streaming interface; it supports the merging of local custom rules and cloud default rules, with local rules having higher priority than cloud rules.

2. The method according to claim 1, characterized in that, The AI ​​Agent adopts the ReAct reasoning mode, which includes: a thinking phase, analyzing the current task status and available tools; an action phase, selecting and executing specific operations; an observation phase, obtaining the operation results and updating the status; and a loop of thinking-action-observation process until the task is completed.

3. The method according to claim 1, characterized in that, The intelligent auxiliary tasks include asset naming checks and renaming, specifically including: performing a first-level rule check to verify naming prefixes and format specifications; performing a second-level semantic check to call a large language model to identify spelling errors and meaningless names; performing a third-level automatic renaming to generate suggested names that conform to the specifications based on the check results; supporting single asset renaming and batch renaming operations; automatically updating all files that reference the asset, including blueprints, materials, and levels; recording renaming history and supporting undo operations.

4. The method according to claim 1, characterized in that, The intelligent assisted task includes intelligent asset organization, specifically including: calling a large language model to analyze asset names and types, and inferring asset uses; generating an organization plan that includes target paths and reasons for organization; and using a batch processing mechanism to control the input length of a single request within the limits of the large language model's context window.

5. The method according to claim 1, characterized in that, The intelligent assistance task includes map generation, specifically including: querying the project asset database to obtain a list of existing assets; receiving map requests described in natural language by the user; calling a large language model to generate a map layout scheme, constraining the use of only existing assets; and performing intelligent replacement on assets that do not exist in the scheme, wherein the intelligent replacement selects the most matching alternative asset from the project asset library based on asset category and semantic similarity.

6. The method according to claim 5, characterized in that, The map generation also supports multimodal input, including: receiving reference images, videos, or sketches as input; analyzing the multimodal input through a visual language model to extract scene elements and layout features; and generating a map scheme by combining natural language descriptions and multimodal analysis results.

7. The method according to claim 1, characterized in that, The intelligent auxiliary task includes visual script analysis, specifically: extracting node and connection information from the visual script; calling a large language model to analyze node naming conventions and the rationality of connection logic; calculating script complexity indicators, including the number of nodes, nesting depth, and cyclomatic complexity; generating refactoring suggestions and identifying repetitive logic that can be extracted into independent modules.

8. The method according to claim 7, characterized in that, It also includes the automatic generation and modification of visualization scripts, specifically including: automatically generating visualization script nodes and connections based on natural language descriptions; automatically performing refactoring operations to extract repetitive logic into independent functions; batch modifying node names to conform to specifications; and automatically fixing detected logical errors.

9. The method according to claim 1, characterized in that, The intelligent auxiliary task includes resource specification checks, specifically including: reading the technical parameters of the resources, including texture size, texture format, model face count, and LOD settings; analyzing based on preset specifications and large language models to identify resources that do not conform to the specifications; and generating automatic repair suggestions or performing batch repairs.

10. The method according to claim 1, characterized in that, It also includes a three-layer data storage and synchronization mechanism: the game engine plugin layer uses memory caching and local files to store the current session data; the local server layer uses a lightweight relational database to store asset metadata and inspection history; the cloud server layer uses a relational database to store complete project data; and it adopts an incremental synchronization strategy, only synchronizing changed data, and supports offline working mode.

11. A game development intelligent auxiliary system for implementing the method of any one of claims 1-10, characterized in that... include: The game engine plugin module is responsible for event listening, user interaction, and communication with the local server. The local server module is responsible for rule management, request forwarding, and cache management, and establishes communication connections with the game engine plugin module and the cloud server module respectively. The cloud server module includes a state machine-based AI Agent workflow framework, a large language model interface, a visual language model interface, an asset database, and a multimodal parsing module. The multimodal parsing module is responsible for receiving multimodal input, analyzing images, videos, and sketches through the visual language model, and extracting scene elements and layout features.

12. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the method described in any one of claims 1-10.

13. An electronic device, characterized in that... include: processor; A memory for storing a computer program; wherein, when the processor executes the computer program, it implements the method according to any one of claims 1-10.

Images