A game generation method, apparatus, device, storage medium, and program product.

Abstract

This application discloses a game generation method, apparatus, device, storage medium, and program product. The method includes: acquiring game generation requirements; parsing the game generation requirements through an orchestration agent among multiple agents to obtain a game generation task set including M generation tasks; determining a target game engine; creating N tool call requests for the M generation tasks and sending the N tool call requests to a server; acquiring P general generation commands created by the server based on P first tool call requests, mapping the P general generation commands to obtain P tool execution commands applicable to the target game engine, acquiring the request results obtained by the server based on Q second tool call requests, and calling the corresponding engine tools to process the tasks according to the P tool execution commands and the Q request results to obtain game development data. Using this application, a fully automated closed-loop game development process can be achieved.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a game generation method, apparatus, device, storage medium, and program product. Background Technology

[0002] With the rapid iteration of digital technology, computer graphics, and internet technology, the gaming industry has developed into a comprehensive industry integrating technology research and development, content creation, and user interaction, becoming an important part of the digital economy. Game development, as a core link supporting industry development, has formed a relatively mature technology system after years of development. This system covers multiple sub-fields such as game engines, graphics rendering, program development, art design, audio processing, and testing optimization, capable of meeting the development needs of different types and scenarios of games and providing players with rich and diverse gaming experiences. In the traditional game development technology system, game engines serve as the core supporting carrier, with mainstream products such as Unity (a unified engine, a type of game engine), Unreal Engine, and Godot (an open-source engine) emerging. These engines adapt to different development needs, including 2D, 3D, and cross-platform compatibility, providing core functions such as visual editing, physics engine integration, and rendering pipeline optimization. Currently, traditional game development technologies have matured and can reliably support the development of various products, including large-scale AAA titles, small and medium-sized casual games, and mobile games. However, traditional game development requires collaboration among multiple roles such as planners, programmers, and artists. Limited by the development model, this results in high production costs, long cycles, and low development efficiency, making it difficult to meet users' growing demands for personalized and immersive games. In recent years, the breakthrough development of Artificial Intelligence (AI) technology has injected new vitality into the game development industry. AI game development has gradually become a core direction for industry technological upgrading. Its essence is the deep integration of AI technology with traditional game development technologies to achieve goals such as optimizing game development processes, intelligent content generation, and upgrading interactive experiences, driving the transformation of game development from "human-led" to "human-machine collaboration" and even "AI-assisted leadership." In the application of AI game development technology, generative AI occupies a core position, enabling automated or semi-automated generation of concepts, original artwork, story writing, level generation, and NPC dialogue, significantly shortening development cycles and reducing development costs. However, the integration of AI with the game development process is insufficient, and collaborative efficiency needs to be improved. Currently, the application of AI technology in game development is mostly focused on assisting development in a single stage, such as game code generation. Related solutions usually adopt a chain of "game requirements - code generation - manual import into the engine or manual debugging", or use the method of "preset template / keyword - trigger / script generation" to reduce the workload of development. Summary of the Invention

[0003] This application provides a game generation method, apparatus, device, storage medium, and program product, which can achieve a fully automated closed-loop game development process through the collaboration of multiple intelligent agents.

[0004] This application provides a game generation method, which includes: Obtain game generation requirements in natural language format; The game generation requirements are analyzed by the orchestration agent among multiple agents to obtain a set of game generation tasks; the set of game generation tasks includes M generation tasks; M is a positive integer. By orchestrating intelligent agents and game generation requirements, a target game engine is identified from one or more game engines associated with the engine agent among multiple intelligent agents. The target game engine has registered engine tools for implementing each generation task. The engine tools are obtained by abstracting and integrating the operation functions provided by the target game engine, and the engine tools are used to simulate the execution of operation functions. By orchestrating intelligent agents into M generation tasks, N tool call requests are created and sent to the server. A tool call request is determined by a subtask in a generation task and a target tool identifier corresponding to that subtask. N is a positive integer greater than or equal to M. A target tool identifier is used to represent an engine tool. The system retrieves P general generation commands created by the server based on P first tool call requests. The engine agent maps these P general generation commands to obtain P tool execution commands applicable to the target game engine. It also retrieves the request results obtained by the server based on Q second tool call requests. Based on the P tool execution commands and the Q request results, the system calls the corresponding engine tools from the target game engine to process the tasks, obtaining game development data. This game development data includes game scene data, game scripts, game assets, game editing status, and resource summaries. The N tool call requests include P first tool call requests and Q second tool call requests, where P and Q are positive integers, and the sum of P and Q is N.

[0005] One embodiment of this application provides a game generation apparatus, the apparatus comprising: The requirement elicitation module is used to obtain game generation requirements in natural language format. The task generation module is used to parse the game generation requirements through the orchestration agent among multiple agents to obtain a set of game generation tasks; the set of game generation tasks includes M generation tasks; M is a positive integer. The engine determination module is used to determine the target game engine for the game generation requirements from one or more game engines associated with the engine agent among multiple agents by orchestrating intelligent agents and game generation requirements. The target game engine has registered engine tools for implementing each generation task. The engine tools are obtained by abstracting and integrating the operation functions provided by the target game engine, and the engine tools are used to simulate the execution of operation functions. The request creation module is used to create N tool invocation requests for M generation tasks by orchestrating an intelligent agent, and send the N tool invocation requests to the server. A tool invocation request is determined by a subtask in a generation task and a target tool identifier corresponding to that subtask. N is a positive integer greater than or equal to M. A target tool identifier is used to represent an engine tool. The game generation module is used to obtain P general generation commands created by the server based on P first tool call requests. The engine agent maps these P general generation commands to obtain P tool execution commands applicable to the target game engine. It also obtains the request results from the server based on Q second tool call requests. Based on the P tool execution commands and the Q request results, it calls the corresponding engine tools from the target game engine to process the tasks and obtain game development data. This game development data includes game scene data, game scripts, game assets, game editing status, and resource summaries. The N tool call requests include P first tool call requests and Q second tool call requests, where P and Q are positive integers, and the sum of P and Q is N.

[0006] In one alternative implementation, when the requirement retrieval module retrieves game generation requirements in natural language format, it specifically performs the following operations: Obtain the initial game generation requirement sent by the business object, parse the initial game generation requirement, and obtain the generation information gap for the game generation target in the initial game generation requirement; Based on the generated information gaps, generate text of the questions to be clarified; Displays the text of the question to be clarified, responds to supplementary input for the text of the question to be clarified, and retrieves supplementary information for the text of the question to be clarified; The initial game generation requirements and supplementary information are structured to obtain game generation requirements in natural language format.

[0007] In one optional implementation, the game generation requirements in natural language format include game objectives, game steps, and game acceptance criteria. The task generation module, through an orchestration agent among multiple agents, parses the game generation requirements to obtain a set of game generation tasks. Specifically, the task generation module performs the following operations: By using the orchestration agent among multiple agents, the game objective, game steps and game acceptance conditions are logically transformed to obtain S game development dimensions corresponding to the game generation requirements, where S is a positive integer. Functional identification is performed on the S game development dimensions to determine the task priority corresponding to each game development dimension and the dependencies between each game development dimension; Each of the S game development dimensions is broken down into tasks, resulting in M ​​generation tasks. Based on the task priority corresponding to each game development dimension and the dependencies between each game development dimension, the M generation tasks are combined to obtain a game generation task set.

[0008] In one alternative implementation, the engine determination module is used to determine the target game engine for the game generation requirements from one or more game engines associated with an engine agent among multiple agents by orchestrating agents and game generation requirements. Specifically, the engine determination module is used to perform the following operations: By orchestrating intelligent agents, engine adaptation requirements are analyzed to obtain engine adaptation requirements for game generation. Based on engine adaptation requirements, a match is made among one or more game engines associated with the engine agent in multiple agents, and the matched game engine is determined as the target game engine. Alternatively, obtain the engine call history corresponding to one or more game engines, and determine the game engine corresponding to the candidate engine adaptation requirements recorded in the engine call history as the target game engine; candidate engine adaptation requirements refer to historical engine adaptation requirements in the engine call history that are similar to the engine adaptation requirements.

[0009] In one alternative implementation, the game generation device further includes a tool registration module, which is specifically used to perform the following operations: Functional identification of the target game engine is performed to determine the smallest operational unit corresponding to each operational function of the target game engine used for game development; The operation function implemented by each smallest operation unit is encapsulated to obtain the tool code corresponding to each operation function; a tool code includes the operation logic parameters corresponding to an operation function; The tool code corresponding to each operation function is registered to the target game engine to obtain the target game engine containing engine tools for implementing each generation task; one engine tool registered in the target game engine is used to implement a subtask in a generation task according to an operation logic parameter.

[0010] In one alternative implementation, when the request creation module creates N tool invocation requests for M generation tasks through an orchestration agent, the request creation module specifically performs the following operations: Each of the M generated tasks is broken down into one or more subtasks corresponding to each generated task; the sum of the number of one or more subtasks corresponding to each generated task is N. Determine the target tool identifier for each subtask, and for each subtask and its corresponding target tool identifier, create a tool invocation request for each subtask.

[0011] In one alternative implementation, the N subtasks include subtask A. i , where i is a positive integer less than or equal to N; when the request creation module is used to determine the target tool identifier corresponding to each subtask, the request creation module is specifically used to perform the following operations: The system orchestrates intelligent agents to send registered tool query requests to the server, enabling the server to generate a general tool list based on these requests. The general tool list includes multiple candidate engine tools registered in the target game engine for performing different generation tasks. Obtain the list of general-purpose tools returned by the server through subtask A. i Match among multiple candidate engine tools in the general tool list, and identify the tool identifier of the matched candidate engine tool as subtask A. i The corresponding target tool identifier.

[0012] In one alternative implementation, the P first tool call requests are tool call requests whose tool type identifier indicates an engine command type, determined by the server from N tool call requests; the Q second tool call requests are tool call requests whose tool type identifier indicates a server command type, determined by the server from N tool call requests. The tool type identifier is determined by the server by searching within the engine tool set based on the target tool identifier in the tool invocation request; The Q request results are obtained by the server processing the task based on the processing function of the engine tool corresponding to the target tool identifier in the Q second tool call requests, and the request parameters in the Q second tool call requests.

[0013] In one optional implementation, the server is further configured to create P general generation commands based on P first tool call requests, and sequentially write the P general generation commands into a command execution queue; the game generation module is configured to obtain the P general generation commands created by the server based on the P first tool call requests, and map the P general generation commands to the engine agent to obtain P tool execution commands suitable for the target game engine. Specifically, the game generation module is configured to perform the following operations: The engine agent retrieves general generation commands sequentially from the server's command execution queue. When the general generation command B is retrieved from the command execution queue j At that time, through the adaptation layer in the engine intelligence agent, the general generation command B is... j The general parameter set is obtained by parsing; j is a positive integer less than or equal to P; The mapping table in the adaptation layer, which is used to target the game engine, maps each general parameter in the general parameter set to an engine-recognizable parameter, thus obtaining the engine parameter set; the mapping table is used to indicate the correspondence between the general parameters and the engine-recognizable parameters. Based on the data calling format of the target game engine, the engine-recognizable parameters in the engine parameter set are encapsulated to obtain the general generation command B. j The corresponding tool execution command; general generation command B j The corresponding tool execution commands are applicable to the target game engine.

[0014] In one alternative implementation, the P tool execution commands include tool execution command C. j j is a positive integer less than or equal to P; the tool executes command C. j For commands used to create entities; Q request results include tool execution commands C j The associated list of entities to be created; the game generation module is used to call the corresponding engine tools from the target game engine to perform task processing based on P tool execution commands and Q request results, and to obtain game development data. Specifically, the game generation module performs the following operations: Enter the locations of entities to be created from the list of locations to be created into the tool and execute command C. j The entity location field in the code provides the command to be executed by the update tool. Call the tool to execute command C from the target game engine. j The corresponding engine tool executes the command C through the tool. jThe corresponding engine tools and update tools execute commands to create entities at the locations indicated in the list of entities to be created, thus obtaining game entity data; the game entity data is used to compose game development data.

[0015] In one alternative implementation, the multiple agents further include a review agent and a test agent; the game generation apparatus also includes a game testing module, which is specifically used to perform the following operations: The game development data is tested and verified by reviewing intelligent agents; the testing and verification includes verifying the rationality of object requirements, the integrity of parameters, and the consistency of assets. If at least one of the object requirement rationality verification, parameter integrity verification, and asset consistency verification fails, the game generation requirements will be replanned by the orchestration agent among multiple agents to obtain a new set of game generation tasks until the object requirement rationality verification, parameter integrity verification, and asset consistency verification of the new game development data all pass. If the object requirement rationality verification, parameter integrity verification, and asset consistency verification all pass, then the test agent will run the target game indicated by the game development data based on the game development data. If the target game runs normally, the game development data is materialized and written to disk to obtain the corresponding materialized file for the target game; the materialized file is used to generate the executable program for the target game.

[0016] In one optional implementation, the game testing module is used to materialize and write game development data to disk. When obtaining the materialized file corresponding to the target game, the game testing module is specifically used to perform the following operations: Create a standard directory structure; the standard directory structure includes a scene file directory, a script file directory, a resource file directory, an editor state directory, and a context injection directory; The game scene data in the game development data is serialized to obtain structured game scene data, and the structured game scene data is stored in the scene file directory; Based on the script type of each game script in the game development data, each game script is stored in the corresponding subdirectory of the script file directory; The game assets in the game development data are classified according to resource type to obtain classified sub-assets. The classified sub-assets are then stored in the corresponding sub-directories of the resource file directory. Store the game editing state from the game development data to the editor state directory; The resource summary in the game development data is stored in the context injection directory. The scene file directory, script file directory, resource file directory, editor state directory and context injection directory in the standard directory structure are identified as the materialized files corresponding to the target game.

[0017] One embodiment of this application provides a computer device, including a processor, a memory, and an input / output interface; The processor is connected to a memory and an input / output interface, respectively. The input / output interface is used to receive and output data, the memory is used to store computer programs, and the processor is used to call the computer programs so that the computer device containing the processor executes the method in one aspect of the embodiments of this application.

[0018] One aspect of this application provides a computer-readable storage medium storing a computer program adapted to be loaded and executed by a processor, so that a computer device having the processor performs the method of one aspect of this application.

[0019] One aspect of this application provides a computer program product or computer program, which includes computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the methods provided in various optional embodiments of this application. In other words, when the computer instructions are executed by the processor, they implement the methods provided in various optional embodiments of this application.

[0020] Implementing the embodiments of this application will have the following beneficial effects: In this embodiment, game generation requirements in natural language format are obtained; the game generation requirements are parsed by an orchestration agent among multiple agents to obtain a set of game generation tasks; the set of game generation tasks includes M generation tasks; M is a positive integer; based on the orchestration agent and the game generation requirements, a target game engine is determined from one or more game engines associated with an engine agent among the multiple agents; the target game engine has registered engine tools for implementing each generation task, and the engine tools are obtained by abstracting and integrating the operation functions provided by the target game engine, and the engine tools are used to simulate the execution of operation functions; the orchestration agent creates N tool call requests for the M generation tasks, and sends the N tool call requests to the server; a tool call request is based on a subtask in a generation task and the subtask's... The target tool is identified by a corresponding target tool identifier; N is a positive integer greater than or equal to M; a target tool identifier is used to represent an engine tool; obtain P general generation commands created by the server based on P first tool call requests, map the P general generation commands to the engine agent to obtain P tool execution commands applicable to the target game engine, obtain the request results obtained by the server based on Q second tool call requests, and call the engine tools corresponding to the P tool execution commands from the target game engine for task processing according to the P tool execution commands and the Q request results to obtain game development data; game development data includes game scene data, game scripts, game material resources, game editing status and resource summary; N tool call requests include P first tool call requests and Q second tool call requests, where P and Q are both positive integers and the sum of P and Q is N. Through the above process, the game generation requirements are structured and analyzed by the orchestration agent, automatically broken down into M generation tasks, and further generated into N tool call requests. This achieves a fully automated closed-loop game development process of "requirements → tasks → tool calls → engine execution → data output," including code generation and game resource or art generation, thereby reducing the manual costs of game development. Furthermore, through the command mapping capability of the engine agent, P general generation commands generated by the server are accurately converted into P tool execution commands suitable for the target game engine, and the registered engine tools within the engine are directly called for execution. This reduces the compatibility barriers between the AI-generated game results (i.e., game development data) and the game engine, significantly reducing the cost and time wasted in game deployment. Innovatively, the underlying operation functions of the game engine are abstracted and integrated into standardized engine tools, which are registered in the target game engine. This achieves a decoupled design where "the agent calls tools, rather than directly calling the game engine's underlying interface." This allows the agent to call standardized engine tools without needing to adapt to the underlying logic of different engines, reducing the adaptation costs between the agent and multiple engines. Attached Figure Description

[0021] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0022] Figure 1 This is a network interaction architecture diagram provided in an embodiment of this application; Figure 2 This is a scenario illustration of a game generation method provided in an embodiment of this application. Figure 1 ; Figure 3 This is a flowchart illustrating a game generation method provided in an embodiment of this application. Figure 1 ; Figure 4 This is a flowchart illustrating a game generation method provided in an embodiment of this application. Figure 2 ; Figure 5 This is a scenario illustration of a game generation method provided in an embodiment of this application. Figure 2 ; Figure 6 This is a flowchart illustrating a game generation method provided in an embodiment of this application. Figure 3 ; Figure 7 This is a scenario illustration of a game generation method provided in an embodiment of this application. Figure 3 ; Figure 8 This is a flowchart illustrating a game generation method provided in an embodiment of this application. Figure 4 ; Figure 9 This is a flowchart illustrating a game generation method provided in an embodiment of this application. Figure 5 ; Figure 10 This is a schematic diagram of a game generation device provided in an embodiment of this application; Figure 11 This is a schematic diagram of the structure of a computer device provided in an embodiment of this application. Detailed Implementation

[0023] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of this application.

[0024] If this application requires the collection of object data (such as user data), a prompt interface or pop-up window will be displayed before and during the collection process. This prompt interface or pop-up window is used to inform the user that certain data is being collected. The data acquisition steps will only begin after the user confirms the prompt interface or pop-up window; otherwise, the process will end. Furthermore, the acquired user data will be used in reasonable and legal scenarios or for legitimate purposes. Optionally, in scenarios where user data needs to be used but user authorization has not been obtained, authorization can be requested from the user, and the user data can only be used after authorization is granted.

[0025] It is understood that, in the specific embodiments of this application, the user data involved requires user permission or consent when the following embodiments of this application are applied to specific products or technologies, and the collection, use and processing of the relevant data must comply with the relevant laws, regulations and standards of the relevant regions.

[0026] In the embodiments of this application, please refer to Figure 1 , Figure 1 This is a network interaction architecture diagram provided in an embodiment of this application, such as... Figure 1 As shown, the system includes a server 101 and a cluster of service devices. The cluster of service devices may include service devices 102a, 102b, 102c, ..., 102n. Communication connections can exist between the service devices in the cluster; for example, there is a communication connection between service devices 102a and 102b, and between service devices 102a and 102c. Simultaneously, any service device in the cluster can have a communication connection with the server 101; for example, there is a communication connection between service device 102a and server 101. Optionally, the communication connection between service device 102a and any other service device (e.g., service device 102b) can be achieved through a communication connection between service device 102a and server 101, and a communication connection between server 101 and service device 102b. The communication connection method is not limited; it can be established directly or indirectly through wired communication, wireless communication, or other methods. This application does not impose any restrictions on this method.

[0027] It should be understood that, such as Figure 1 Each business device and server 101 in the shown business device cluster can be equipped with multiple agents (including systems with multiple agents). When the multiple agents are running on each business device and server 101, each business device can interact with the aforementioned... Figure 1The servers 101 shown interact with each other, enabling them to receive tool call requests from each business device and collaborate with each business device to generate games based on the game generation requirements sent by users within the business devices. The multi-agent (or multiple agents) system can be an intelligent system composed of two or more agents with different responsibilities that collaboratively complete the game engineering generation task. An agent is an intelligent system driven by a large language model, possessing four core capabilities: autonomous perception, planning and decision-making, tool use, and memory evolution. It can simulate human thinking and action patterns, autonomously understand target requirements, decompose tasks, execute operations, and dynamically adjust its behavioral logic based on environmental feedback, ultimately automating the completion of complex tasks. The large language model can be a data-trained intelligent model whose core capability is understanding the semantics and grammatical rules of human language and generating text that conforms to linguistic logic, such as a mixed-model or a generative pre-trained transformer (GPT); or, an agent can be a comprehensive intelligent system composed of a large language model and other functional auxiliary models (such as text parsing models). Its form can be either software (such as a smart assistant) or hardware (such as a service robot), and there are no restrictions here.

[0028] The game generation method mentioned in this application can be jointly executed by any one business device in the business device cluster and server 101. The following description uses the example of any one business device (business device 102a) in the business device cluster and server 101 jointly executing the method. Business device 102a can provide an interactive window (such as a smart conversation page) for users through a multi-agent system. Users (or objects) using business device 102a can send game generation requests to the multi-agent system through this interactive window. Business device 102a can parse the game generation requests through the orchestration agent in the multi-agent system to obtain a set of game generation tasks. Furthermore, through the orchestration agent and the game generation requests, the target game engine can be determined from one or more game engines associated with the engine agent in the multi-agent system. Here, the orchestration agent refers to the agent in the multi-agent system used to obtain game generation requests and orchestrate generation tasks. A game engine refers to a software platform used for loading game scenes, executing scripts, rendering, physics, input, and resource management. Game engines include, but are not limited to, PlayCanvas, Unity, Unreal Engine, and Godot.

[0029] Furthermore, business device 102a can orchestrate an intelligent agent to create N tool call requests for M generation tasks, and send these N tool call requests to server 101. Upon receiving the tool call requests, server 101 can perform splitting processing on each request, resulting in P first tool call requests and Q second tool call requests. Server 101 can create P general generation commands for the P first tool call requests and obtain the corresponding request results based on the Q second tool call requests. Business device 102a can sequentially request the general generation commands or request results from server 101 for task processing, thereby obtaining game development data. This game development data is used to generate the target game indicated by the game generation requirements sent by the user.

[0030] It is understood that the business equipment and server mentioned in the embodiments of this application can also be a type of computer equipment. Specifically, the business equipment mentioned above can be an electronic device, including but not limited to mobile phones, tablets, desktop computers, laptops, handheld computers, in-vehicle devices, augmented reality / virtual reality (AR / VR) devices, head-mounted displays, smart TVs, wearable devices, and other mobile internet devices (MIDs) with network access capabilities, and those equipped with multi-agent systems and game engines. Figure 1 As shown, the service device can be a mobile phone (as shown in service device 102a), a desktop computer (as shown in service device 102b), a tablet computer (as shown in service device 102c), and a laptop computer (as shown in service device 102n), etc. Figure 1 Only a portion of the devices are listed. The servers mentioned above can be standalone physical servers, server clusters consisting of multiple physical servers, or distributed systems.

[0031] For details, please see Figure 2 , Figure 2 This is a scenario illustration of a game generation method provided in an embodiment of this application. Figure 1 The game generation method can be executed jointly by business devices and servers. The business devices can be, for example, […]. Figure 1 Any one of the service devices in the service device cluster shown can be a server such as Figure 1 Server 101 is shown. (As shown) Figure 2 As shown, taking business device 102b and server 101 as examples, both business device 102b and server 101 can be equipped with multiple intelligent agents, and business device 102b and server 101 can communicate with each other.

[0032] In this embodiment, the service device 102b can provide a smart conversation page to the user (i.e., the service object) using the service device 102b through multiple agents 201. In other words, the smart conversation page is the interaction window between the service object and the multiple agents 201. Figure 2 As shown in the intelligent conversation page 202, the business object can input and send an initial game generation requirement 202a. The business device 102b can obtain this initial game generation requirement 202a through the multi-agent 201. The initial game generation requirement 202a can be text describing the core requirements of the game that the business object needs to generate. For example, it can include the core gameplay, theme, etc. An optional initial game generation requirement 202a can be expressed as "Make a casual ancient-style fantasy game, focusing on idle gameplay and character collection, suitable for office workers, with minimal complex operations."

[0033] Furthermore, business device 102b can parse the initial game generation requirement 202a through the orchestration agent in multi-agent 201 to obtain the generation information gap for the game generation target in the initial game generation requirement 202a. The generation information gap indicates game generation elements that the business object has not specified. Game generation elements can refer to the core elements that need to be covered during game development, including but not limited to game type, gameplay rules, control method, number of levels, difficulty curve, and resource style. For example, if the game development required by the business object needs to specify information such as game type, gameplay rules, control method, number of levels, difficulty curve, and resource style, but the initial game generation requirement 202a sent by the business object only includes information on elements such as game type, gameplay rules, and resource style, then the generation information gap could be elements such as control method, number of levels, and difficulty curve. Furthermore, business device 102b can generate a question text 203a to be clarified based on the generation information gap. It can be understood that the question text 203a to be clarified can be a query text generated by the orchestration agent based on the generation information gap to inquire about the business object. If the information gap is "control method, number of levels, difficulty curve", it means that the orchestration agent currently does not know the control method, the number of levels, and the difficulty curve of the game to be generated. The question text 203a to be clarified can be expressed as "Please supplement the control method, number of levels, difficulty curve, etc. of the game you want to generate", or it can be expressed as "What is the control method of the game you want, how many levels do you need to set in the game, and is the game difficulty set to easy or hard?"

[0034] Business device 102b can display the text 203a of the question to be clarified on the intelligent conversation page 203 through multiple agents 201. When the business object sees the text 203a of the question to be clarified on the intelligent conversation page 203, it can supplement the information of the text 203a of the question to be clarified and send supplementary information 203b of the text 203a of the question to be clarified to the intelligent conversation page 203. Then, business device 102b can perform structured processing on the initial game generation requirement 202a and the supplementary information 203b through the orchestration agent to obtain the game generation requirement 204 in natural language format.

[0035] It should be noted that game generation requirement 204 can be structured. That is, according to the core logic framework of game development and generation, the game generation elements of all dimensions of game development are standardized, systematic, and refined, resulting in a complete, clear, unambiguous, and directly implementable set of game generation instructions. Its core is to transform the vague and scattered subjective requirements of business objects into structured information that conforms to the logic of AI game generation and covers the core elements of game generation, so as to provide a unified and clear execution basis for AI to accurately generate games.

[0036] Furthermore, the service device 102b can parse the game generation requirement 204 through the orchestration agent in the multi-agent 201 to obtain a game generation task set 205. This set includes M generation tasks, where M is a positive integer. The service device 102b can then use the orchestration agent and the game generation requirement 204 to determine the target game engine 207 from one or more game engines associated with the engine agent in the multi-agent 201. The target game engine 207 has registered engine tools for implementing the M generation tasks. These engine tools are obtained by abstracting and integrating the operational functions provided by the target game engine, and they are used to simulate the execution of these operational functions.

[0037] Business device 102b can create N tool call requests 206 for M generation tasks through an orchestration agent, and send the N tool call requests 206 to server 101. A tool call request is determined by a subtask within a generation task and a target tool identifier corresponding to that subtask; N is a positive integer greater than or equal to M; a target tool identifier is used to represent an engine tool.

[0038] Taking a tool call request as an example, when server 101 receives the tool call request, it can perform traffic splitting. If the tool call request is processed by the target game engine 207 in business device 102b, server 101 can identify it as the first tool call request; if the tool call request is processed by server 101, server 101 can identify it as the second tool call request. In other words, server 101 can split N tool call requests 206 into P first tool call requests 206a and Q second tool call requests 206b. The N tool call requests 206 include P first tool call requests 206a and Q second tool call requests 206b, where P and Q are positive integers, and the sum of P and Q is N.

[0039] Furthermore, server 101 can create P general generation commands 208 based on P first tool call requests 206a, and write the P general generation commands 208 sequentially into command execution queue 210. Server 101 can process tasks based on Q second tool call requests 206b, and obtain Q request results 209.

[0040] Furthermore, business device 102b can sequentially retrieve general generation commands from the command execution queue 210 of server 101 through the target game engine 207 for processing. Business device 102b can map each of the P general generation commands to obtain P tool execution commands suitable for the target game engine through the engine agent, obtain the request results obtained by the server based on Q second tool call requests, and, based on the P tool execution commands and Q request results, call the engine tools corresponding to the P tool execution commands from the target game engine for task processing to obtain game development data 211. The game development data includes game scene data, game scripts, game material resources, game editing status, and resource summaries.

[0041] Business device 102b can materialize and write game development data 211 to disk through multiple agents 201, obtaining a materialized file 212a for the target game based on game generation requirement 204. Business device 102a can display this materialized file 212a on the smart conversation page 212, so that business objects know that the game development task for game generation requirement 204 has been completed.

[0042] Through the above process, the game generation requirements are structured and analyzed by the orchestration agent, automatically broken down into M generation tasks, and further generated into N tool call requests. This achieves a fully automated closed-loop game development process of "requirements → tasks → tool calls → engine execution → data output," including code generation and game resource or art generation, thereby reducing the manual costs of game development. Furthermore, through the command mapping capability of the engine agent, P general generation commands generated by the server are accurately converted into P tool execution commands suitable for the target game engine, and the registered engine tools within the engine are directly called for execution. This reduces the compatibility barriers between the AI-generated game results (i.e., game development data) and the game engine, significantly reducing the cost and time wasted in game deployment. Innovatively, the underlying operation functions of the game engine are abstracted and integrated into standardized engine tools, which are registered in the target game engine. This achieves a decoupled design where "the agent calls tools, rather than directly calling the game engine's underlying interface." This allows the agent to call standardized engine tools without needing to adapt to the underlying logic of different engines, reducing the adaptation costs between the agent and multiple engines.

[0043] Further, please see Figure 3 , Figure 3 This is a flowchart illustrating a game generation method provided in an embodiment of this application. Figure 1 The game generation method can be executed jointly by a business device and a server; the business device and the server can be the same device or different devices. The business device can be, for example... Figure 1 Any one of the service devices in the service device cluster shown can be a server such as Figure 1 The server 101 shown. The game generation method may include at least the following steps S301-S305: Step S301: Obtain game generation requirements in natural language format.

[0044] In this embodiment, the service device can acquire game generation requirements in natural language format. These game generation requirements can refer to a set of specific requirements and constraints provided to multiple intelligent agents to guide the automatic generation of game content. Specifically, they are a complete, clear, unambiguous, and directly applicable set of game generation instructions formed after standardizing, systematizing, and refining the game generation elements across all dimensions of game development according to the core logical framework of game development and generation.

[0045] Specifically, the business device can obtain the initial game generation requirements sent by the business object, and then perform a completeness check on the initial game generation requirements. If the initial game generation requirements are found to satisfy all the game generation elements, that is, there are no gaps in the generation information for the game generation goals in the initial game generation requirements, the business device can use the orchestration agent among multiple intelligent agents to decompose the initial game generation requirements according to each game generation element, resulting in game generation requirements in natural language format. It can be understood that the game generation requirements are text expressed in a structured manner according to each game generation element. Game generation elements can refer to the core elements that need to be covered during game development, including but not limited to game type, gameplay rules, control methods, number of levels, difficulty curve, resource style, etc.

[0046] Optionally, if the initial game generation requirement is detected to be unsatisfactory in terms of various game generation elements, i.e., there is a gap in the generation information for the game generation objective in the initial game generation requirement, the service device can parse the initial game generation requirement to obtain the gap in the generation information for the game generation objective. Based on the gap in the generation information, it can generate a text for clarification. Further, the service device can send this text for clarification to a service object, i.e., display the text for clarification on the intelligent conversation page provided by multiple intelligent agents. The service object can supplement its input based on the text for clarification, and the service device can respond to the supplementary input operation for the text for clarification and obtain supplementary information for the text for clarification. Further, the service device can perform structured processing on the initial game generation requirement and the supplementary information to obtain a game generation requirement in natural language format. The generation information gap is used to indicate the missing or unclear game generation elements in the initial game production requirement. The text for clarification can be a query text that inquires about the unclear game generation elements. In other words, after multiple agents analyze the initial game generation requirements, they may discover that some game generation elements were not mentioned in the initial requirements. In this case, the multiple agents can treat the unmentioned game generation elements as gaps in the generation information and request the business objects to supplement the unmentioned game generation elements.

[0047] Optionally, the number of generated information gaps can be multiple, meaning there can be multiple game-generated elements not mentioned by the business object, such as "gameplay rules, control methods, number of levels, and difficulty curve." In this case, the business device generates multiple question texts to be clarified based on these multiple generated information gaps. The business device can prioritize these question texts according to their importance, resulting in a sorted list of question texts to be clarified, which are then displayed sequentially according to priority. Optionally, each clarification interaction can display one question text until supplementary information corresponding to that question text is obtained, before continuing to display the next question text. Optionally, the process of the business device interacting with the business object through an orchestration agent to clarify the issue can also be a multi-iterative process. For example, after displaying a text of an issue to be clarified, the business object provides supplementary input based on the text. The business device responds to the supplementary input operation for the text to be clarified and obtains the initial supplementary information for the text to be clarified. If the business device still cannot clarify the corresponding generation information gap after parsing the initial supplementary information through the orchestration agent, it can update the text to be clarified through the orchestration agent to obtain an updated clarified text. This process continues until the business device responds to the supplementary input operation for the updated clarified text and obtains the supplementary information for the updated clarified text, which clarifies the corresponding generation information gap.

[0048] This step allows for the clarification of game generation requirements in a natural language conversational manner, without relying on preset requirement templates or keywords. This reduces communication costs, minimizes misunderstandings about game generation requirements, and improves game development efficiency.

[0049] Step S302: The game generation requirements are parsed by the orchestration agent among multiple agents to obtain a set of game generation tasks; the set of game generation tasks includes M generation tasks; M is a positive integer.

[0050] In this embodiment, multiple agents (or multi-agent systems) can be an intelligent system in which two or more agents with different responsibilities collaborate to complete game engineering generation tasks. These multiple agents may include an orchestration agent. The orchestration agent can act as the "brain" among the multiple agents, performing tasks such as requirement understanding, task decomposition, and task orchestration. Task orchestration and task decomposition can refer to structuring game generation requirements into a development plan (i.e., a set of game generation tasks) and breaking it down into sub-tasks.

[0051] Business devices can use orchestration agents to parse game generation requirements, resulting in a set of game generation tasks. Specifically, business devices can access a game design knowledge base and map game generation requirements to predefined game development dimensions. This game design knowledge base can be a structured, machine-readable domain knowledge storage system, storing core concepts, rules, patterns, constraints, and historical experience data from the game design domain. During requirement parsing by the orchestration agent, this knowledge base serves as a foundational reference framework for semantic understanding, dimension mapping, and task decomposition. Game development dimensions are relatively independent development concerns or functional modules defined from a game design perspective; each dimension represents a specific aspect of the game generation requirement. In the requirement parsing process of the orchestration agent, dimensions are an intermediate abstraction layer for task decomposition, used to transform macro-level requirements into manageable development units. For example, if one requirement in the game generation is a puzzle game, the corresponding game development dimensions could include interaction systems, item usage logic, puzzle design, etc.

[0052] In other words, the orchestration agent here obtains the game development dimensions mapped to the game generation requirements, and thus knows what functions, game designs, and resources are needed to develop the target game indicated by the game generation requirements. It can be understood that there are multiple game development dimensions. Furthermore, the business device can decompose these multiple game development dimensions into a set of game generation tasks, including M generation tasks, where M is a positive integer. It can be understood that these generation tasks are used to instruct what needs to be done to develop the target game. In other words, the process from game generation requirements to game development dimensions and then to generation tasks is a process from determining what kind of game needs to be generated, to identifying the functions, game designs, and resources required to generate such a game, and finally to how to specifically implement the functions, game designs, and generation resources.

[0053] Step S303: By orchestrating the intelligent agents and game generation requirements, a target game engine for the game generation requirements is determined from one or more game engines associated with the engine intelligent agent among the multiple intelligent agents; the target game engine has registered engine tools for implementing each generation task. The engine tools are obtained by abstracting and integrating the operation functions provided by the target game engine, and the engine tools are used to simulate the execution of operation functions.

[0054] In this embodiment, the multiple intelligent agents also include an engine intelligent agent, which is used to associate with one or more game engines and invoke the game engines to generate the game. The business device can orchestrate the intelligent agents and game generation requirements to determine the target game engine for the game generation requirements from among the one or more game engines associated with the engine intelligent agent. Specifically, the game development process of a game can invoke a specific game engine for game generation; that is, the business device can select a game engine that meets the game generation requirements from among the one or more game engines associated with the engine intelligent agent, based on the game generation requirements, as the target game engine for those requirements.

[0055] The process of determining the target game engine may include, but is not limited to, hard constraint filtering and soft constraint scoring. Specifically, the business device can obtain one or more game engines associated with the engine agent among multiple agents. These one or more game engines constitute the currently available game engines (referred to here as the initial candidate engine set). Further, the business device can use an orchestration agent to further parse the game generation requirements and obtain the hard constraints on the game engines indicated by the game generation requirements. Further still, the business device can filter the initial candidate engine set based on the hard constraints on the game engines to obtain an updated candidate engine set that satisfies the hard constraints, that is, removing game engines that do not meet the hard constraints from the initial candidate engine set.

[0056] Hard constraints can be requirements that the game engine must meet, such as supported target platforms and the game dimension type of the target game. Target platforms include, but are not limited to, mobile and PC platforms, and game dimension types include, but are not limited to, two-dimensional (2D) and three-dimensional (3D) games. For example, when the game generation requirement specifies the generation of a 3D game for mobile devices, the hard constraints for the game engine could be that it supports mobile devices and can generate 3D games. The business device can eliminate game engines that do not support mobile devices and cannot generate 3D games from the initial candidate engine set, resulting in an updated candidate engine set. In other words, each game engine in the updated candidate engine set can now generate 3D games that can run on mobile devices.

[0057] Furthermore, the business equipment can use an orchestration agent to perform soft constraint scoring on the remaining game engines in the updated candidate engine set, obtaining a matching value for each game engine. The game engine with the highest matching value can then be identified as the target game engine for the game generation requirements. The soft constraint scoring may include, but is not limited to, technical feasibility (i.e., whether the game engine supports the specific functions in the game generation requirements), functional coverage (i.e., whether it supports all the functions to be implemented as indicated by the game generation requirements), performance prediction (i.e., predicting the performance of the game engine based on the complexity of the game generation requirements), and resource consumption (i.e., development and runtime resource requirements). The matching value can be a quantitative indicator used to measure the degree of fit between the game engine and the game generation requirements, and the matching value can be the weighted sum of the scores from each scoring dimension in the soft constraint scoring.

[0058] Step S304: By orchestrating the intelligent agent into M generation tasks, N tool call requests are created and sent to the server; a tool call request is determined by a subtask in a generation task and a target tool identifier corresponding to that subtask; N is a positive integer greater than or equal to M; a target tool identifier is used to represent an engine tool.

[0059] In this embodiment, the service device can further decompose the M generation tasks using an orchestration agent to obtain one or more subtasks corresponding to each generation task. It is understood that a subtask can be the smallest task unit in the game development process of the target game indicated by the game generation requirements. The sum of the number of one or more subtasks corresponding to each generation task is N.

[0060] Furthermore, the business device can determine the target tool identifier for each subtask based on its corresponding task content. A tool invocation request is determined by a subtask within a generated task and its corresponding target tool identifier; N is a positive integer greater than or equal to M; a target tool identifier represents an engine tool, meaning it indicates a unique engine tool within the target game engine. The target tool identifier can be the tool name of the engine tool, or it can be a unique identifier created for the engine tool—there are no restrictions here. The business device can create a tool invocation request for each subtask and its corresponding target tool identifier. The tool invocation request may include, but is not limited to, the target tool identifier and request parameters (or task input parameters, indicating the execution parameters required to invoke the engine tool corresponding to the target tool identifier). The request originates from the task content of the subtask. The tool invocation request can indicate which engine tool needs to be invoked for task processing and the required request parameters for task processing.

[0061] Furthermore, the business device can send N tool call requests to the server. The server can use middleware services to distribute these N tool call requests accordingly, resulting in P first tool call requests processed by the target game engine and Q second tool call requests processed by the server. The server can create P general generation commands based on the P first tool call requests and write these P general generation commands sequentially into a command execution queue. The server can directly process the Q second tool call requests and obtain the request results corresponding to each of the Q second tool call requests.

[0062] Step S305: Obtain P general generation commands created by the server based on P first tool call requests. Map the P general generation commands to the engine agent to obtain P tool execution commands applicable to the target game engine. Obtain the request results obtained by the server based on Q second tool call requests. Based on the P tool execution commands and Q request results, call the engine tools corresponding to the P tool execution commands from the target game engine to perform task processing and obtain game development data. The game development data includes game scene data, game scripts, game material resources, game editing status, and resource summary. The N tool call requests include P first tool call requests and Q second tool call requests, where P and Q are positive integers, and the sum of P and Q is N.

[0063] In this embodiment, the service device can sequentially retrieve each of the P general generation commands from the server's command execution queue, according to the writing order of those commands. It then maps each general generation command to an engine agent to obtain P tool execution commands suitable for the target game engine. Further, the service device can obtain the request results corresponding to Q second tool call requests from the server. Based on the task dependencies between N subtasks, and according to the P tool execution commands and the Q request results, it can call the engine tools corresponding to the P tool execution commands from the target game engine to perform task processing and obtain game development data.

[0064] It's important to note that the process of a business device processing P general generation commands through the target game engine associated with the engine agent does not begin only after acquiring all P general generation commands. Instead, upon acquiring a general generation command, it maps it to a tool execution command, invoking the corresponding engine tool for task processing. It's important to note that when a business device's processing of a general generation command depends on the result of a second tool call request, it must wait for the server to process that second tool call request and obtain the result. After obtaining the result from the server, it can then combine the result with the general generation command (or the corresponding tool execution command) to process the task until all N sub-tasks are completed, resulting in the game development data.

[0065] Game development data refers to the entire collection of data generated, used, and managed throughout the game development process. This includes, but is not limited to, game scene data, game scripts, game assets, game editing status, and resource summaries. The target game can be obtained by converting game development data into an executable program. The N tool call requests include P first tool call requests and Q second tool call requests, where P and Q are positive integers, and the sum of P and Q is N.

[0066] Game scene data describes the structure and layout information of specific scenes or levels in the game world of the target game developed to meet game generation requirements. This may include, but is not limited to, scene geometry (such as terrain, buildings, and obstacle locations), object hierarchy and coordinate transformations (such as position, rotation, and scaling), scene lighting settings (such as light source position, type, and parameters), initial camera position and viewpoint, trigger areas, navigation meshes (NavMesh), and connections between scenes (teleport points, loading areas), etc. Game scripts refer to program code that controls game logic, behavior, and interactions. This may include, but is not limited to, game setup scripts (Gameplay scripts, such as character control, combat systems, and physics interactions), interface scripts (UI scripts, such as interface logic, menu interactions, and HUD updates), system scripts (such as save / load, network synchronization, and audio management), and utility scripts (such as editor extensions, automated processes, and resource processing), etc. Game asset resources refer to all original multimedia content and data files used in the game, including but not limited to art assets, audio assets, and animation assets. Game editing state refers to temporary or persistent state information generated by the target game engine during game development, which may include, but is not limited to, view state, selection and operation state, etc. Resource summary refers to metadata information describing the attributes of the resource itself, which can be used for resource management, retrieval, and optimization.

[0067] Through the above process, the game generation requirements are structured and analyzed by the orchestration agent, automatically broken down into M generation tasks, and further generated into N tool call requests. This achieves a fully automated closed-loop game development process of "requirements → tasks → tool calls → engine execution → data output," including code generation and game resource or art generation, thereby reducing the manual costs of game development. Furthermore, through the command mapping capability of the engine agent, P general generation commands generated by the server are accurately converted into P tool execution commands suitable for the target game engine, and the registered engine tools within the engine are directly called for execution. This reduces the compatibility barriers between the AI-generated game results (i.e., game development data) and the game engine, significantly reducing the cost and time wasted in game deployment. Innovatively, the underlying operation functions of the game engine are abstracted and integrated into standardized engine tools, which are registered in the target game engine. This achieves a decoupled design where "the agent calls tools, rather than directly calling the game engine's underlying interface." This allows the agent to call standardized engine tools without needing to adapt to the underlying logic of different engines, reducing the adaptation costs between the agent and multiple engines.

[0068] Further, please see Figure 4 , Figure 4 This is a flowchart illustrating a game generation method provided in an embodiment of this application. Figure 2The game generation method can be executed jointly by a business device and a server; the business device and the server can be the same device or different devices. The business device can be, for example... Figure 1 Any one of the service devices in the service device cluster shown can be a server such as Figure 1 The server 101 shown. The game generation method may include at least the following steps S401-S406: Step S401: Obtain game generation requirements in natural language format; determine the target game engine for the game generation requirements; create N tool call requests for the game generation requirements and send the N tool call requests to the server.

[0069] In this embodiment, the service device can acquire game generation requirements in natural language format. The game generation requirements can be parsed by an orchestration agent among multiple agents to obtain a set of game generation tasks. This set includes M generation tasks, where M is a positive integer. Based on the orchestration agent and the game generation requirements, a target game engine can be determined from one or more game engines associated with an engine agent among the multiple agents. The target game engine has registered engine tools for implementing each generation task. These engine tools are obtained by abstracting and integrating the operational functions provided by the target game engine, and they are used to simulate the execution of these operational functions. Furthermore, the orchestration agent can create N tool call requests for the M generation tasks and send these N tool call requests to the server.

[0070] Specifically, the detailed implementation process for business devices to acquire game generation requirements with natural language formats can be found in [reference needed]. Figure 3 The specific process described in step S301 of the embodiments will not be repeated here.

[0071] In one embodiment, game generation requirements in natural language format may include game objectives, game steps, and game acceptance criteria. The specific implementation process of the business device parsing the game generation requirements through an orchestration agent among multiple agents to obtain a set of game generation tasks can be as follows: The business device can use the orchestration agent among multiple agents to logically transform the game objectives, game steps, and game acceptance criteria to obtain S game development dimensions corresponding to the game generation requirements; perform functional identification on the S game development dimensions to determine the task priority corresponding to each game development dimension and the dependencies between each game development dimension; decompose the S game development dimensions into M generation tasks; and combine the M generation tasks according to the task priority corresponding to each game development dimension and the dependencies between each game development dimension to obtain a set of game generation tasks. Here, S is a positive integer. More specifically, the process by which the business equipment logically transforms game objectives, game steps, and game acceptance conditions can be as follows: It acquires a game design knowledge base, and based on preset logical transformation relationships within the knowledge base, or logical transformation relationships indicated by historical experience data, maps the game objectives, game steps, and game acceptance conditions to obtain S game development dimensions corresponding to the game generation requirements. For example, if one game objective in the game generation requirements is "search for items," it can be mapped to three game development dimensions: an item system, a pickup logic, and a task instruction system. Furthermore, the business equipment can perform functional identification on the S game development dimensions, determining the task priority for each dimension and the dependencies between them based on their core functions. For instance, the task priority of "core gameplay mechanics" can be higher than that of "art detailing." The dependencies between game development dimensions can be established by, for example, the game mechanics dimension depending on a pre-established game system framework. The business device can break down and subdivide the S game development dimensions into M generation tasks that can be implemented. Then, based on the task priority of each game development dimension and the dependencies between them, the M generation tasks can be combined to obtain a game generation task set. This game generation task set can be represented as a task list (e.g., JSON format) or as a directed acyclic graph; there are no restrictions here. The game generation task set includes M generation tasks; M is a positive integer.

[0072] This process automates the planning of game development tasks, resulting in a set of game generation tasks. It eliminates the need for manual requirements analysis and task breakdown, thereby improving game development efficiency.

[0073] In one embodiment, the specific implementation process by which the service device determines the target game engine for the game generation requirements may be as follows: by orchestrating intelligent agents, the game generation requirements are analyzed for engine adaptation to obtain the engine adaptation requirements for the game generation requirements; based on the engine adaptation requirements, one or more game engines associated with the engine intelligent agent among multiple intelligent agents are matched, and the matched game engine is determined as the target game engine.

[0074] Specifically, business devices can use orchestration agents to identify key features for game engine selection within game generation requirements. These key features may include, but are not limited to, game type (e.g., casual games, open-world games), technical keywords (2D, 3D, online), performance metrics (e.g., image quality, frame rate), and platform requirements (PC, mobile). These key features can then be converted into quantifiable technical indicators, resulting in engine adaptation requirements. Engine adaptation requirements can be seen as an intermediate representation mapping game generation requirements (e.g., gameplay, functionality, performance) to the technical specifications and constraints that a game engine must meet. Essentially, it acts as a "translation layer" between game generation requirements and game engine capabilities, used to determine whether a particular game engine is suitable for developing the target game indicated by the game generation requirements. The orchestration agent can input the engine adaptation requirements into the engine agent, which can then obtain one or more associated game engines and match them against those engines. The matched game engine is then identified as the target game engine.

[0075] It should be noted that if multiple game engines that meet the engine adaptation requirements are matched, the engine agent can detect the matching values ​​between the matched game engines and the engine adaptation requirements, and determine the game engine with the highest matching value as the target game engine. Alternatively, it can obtain the selection parameters corresponding to each of the matched game engines, and determine the target game engine based on the selection parameters. These selection parameters include, but are not limited to, the game engine's historical usage rate and historical development success rate. For example, if the matched game engines include game engine A (historical usage rate of 80%) and game engine B (historical usage rate of 90%), then game engine B can be determined as the target game engine.

[0076] Optionally, the specific implementation process for the business device to determine the target game engine for the game generation requirement can also be as follows: Obtain the engine call history corresponding to one or more game engines, and determine the game engine corresponding to the candidate engine adaptation requirement recorded in the engine call history as the target game engine. Here, candidate engine adaptation requirements refer to historical engine adaptation requirements in the engine call history that are similar to the target engine adaptation requirement. That is, the business device can perform similarity processing on the engine adaptation requirement and the candidate engine adaptation requirements recorded in the engine call history to obtain the similarity between the engine adaptation requirement and the candidate engine adaptation requirements, and determine the game engine corresponding to the candidate engine adaptation requirement with the highest similarity as the target game engine.

[0077] It should be noted that the target game engine has registered engine tools for implementing each generated task. The engine tools are obtained by abstracting and integrating the operation functions provided by the target game engine, and the engine tools are used to simulate the execution of operation functions.

[0078] This process selects a suitable game engine as the target game engine for subsequent game development tasks, thereby enabling intelligent matching and adaptation of game engines, reducing the threshold for technology selection, improving development efficiency, and avoiding resource waste.

[0079] In one embodiment, both the business device and the server can register engine tools in the target game engine. Optionally, when the business device and the server are the same device, the business device can perform functional identification on the target game engine to determine the smallest operational unit corresponding to each operation function used by the target game engine for game development. The smallest operational unit can refer to an indivisible basic functional unit in the target game engine, and each smallest operational unit can be used to implement a specific, atomic operation function, such as deleting an entity, creating an entity, adding a component, executing a script, or creating an asset. Further, the business device can encapsulate the operation function implemented by each smallest operational unit to obtain tool code corresponding to each operation function. A tool code includes operation logic parameters corresponding to an operation function. A tool code may include, but is not limited to, a tool name (or tool identifier), an operation function description, input parameter definitions, output parameter definitions, and operation logic parameters.

[0080] Furthermore, the business device can define a registration interface. Through this interface, the tool code corresponding to each operation function is registered with the target game engine, resulting in a target game engine containing engine tools used to implement each generation task. Each registered engine tool in the target game engine is used to implement a subtask within a generation task based on an operation logic parameter. It should be noted that the target game engine may include a tool manager, which can manage the engine tools registered with it.

[0081] It should be noted that the engine tools registered in the target game engine can be classified into two categories, including but not limited to: engine command tools, which correspond to the engine tools identified as engine command type mentioned in step S402 below. These are tools called and executed by the target game engine, and can include, but are not limited to, entity operation tools (such as entity creation tools, entity deletion tools, entity update tools, etc.), component operation tools (such as component addition tools, component removal tools, etc.), script operation tools (such as script mounting tools, script execution tools, etc.), asset operation tools (such as asset creation tools, material application tools, etc.), selection / viewport tools (such as setting selected items tools, setting viewport tracks, etc.), scene / history tools (such as saving scene tools, updating scene settings tools, etc.), screenshot / debugging tools (such as screenshot tools, obtaining console log tools, etc.), and playback control tools (such as playback tools, switching playback tools, etc.).

[0082] Another type can be server-side directly executable tools, which are engine tools identified as server command type by the tool type identifier mentioned in step S402 below. That is, engine tools that are directly executed by the server can include, but are not limited to, tools for obtaining scene structure, tools for finding entities, tools for generating code, and tools for generating script templates.

[0083] This process breaks down engine functionality into the smallest operational units and encapsulates them into tool code. This allows developers (in this case, multiple intelligent agents) to call engine tool functions through parameterization for game development without delving into the underlying APIs, thus lowering the technical barrier to entry. Furthermore, the engine tool is flexibly extensible, supporting rapid registration and integration with different game engines (Unity, Unreal, etc.). This means the engine tool can be registered with different game engines, and different game engines can be selected during the engine selection process, thereby enhancing the industry versatility of this solution.

[0084] In one embodiment, the specific implementation process of a business device creating N tool invocation requests for M generation tasks by orchestrating an intelligent agent can be as follows: The business device can decompose the M generation tasks into one or more subtasks corresponding to each generation task. The sum of the number of one or more subtasks corresponding to each generation task is N; each subtask can be executed by a corresponding engine tool from the target game engine. The business device can determine the engine tool used to execute the corresponding subtask based on its task content, and determine the tool identifier of the corresponding engine tool as the target tool identifier for each subtask. Then, for each subtask and its corresponding target tool identifier, a tool invocation request can be created for each subtask.

[0085] Specifically, the N subtasks include subtask A. i Let i be a positive integer less than or equal to N. The business device can generate a registered tool query request through an orchestration agent and send it to the server. Upon receiving the registered tool query request, the server can determine the currently usable candidate engine tools (i.e., multiple candidate engine tools registered in the target game engine) based on the request, compile these into a general tool list, and return this list to the business device's orchestration agent. This general tool list includes multiple candidate engine tools registered in the target game engine for performing different generation tasks. The business device can obtain the general tool list returned by the server through the orchestration agent and execute it via subtask A. i Match among multiple candidate engine tools in the general tool list, and identify the tool identifier of the matched candidate engine tool as subtask A. i The corresponding target tool identifier.

[0086] In step S402, the server splits the N tool call requests into P first tool call requests and Q second tool call requests; it creates P general generation commands based on the P first tool call requests and writes the P general generation commands into the command execution queue; it processes the Q second tool call requests to obtain Q request results.

[0087] In this embodiment, when the server receives any one of N tool call requests, it can perform traffic distribution processing on the tool call request through middleware services. It should be noted that the server can store an engine tool set (such as EDITOR_COMMAND_TOOLS), which is used to indicate the engine tools that the game engine needs to execute. That is, if the engine tool set contains an engine tool corresponding to the target tool identifier indicated by the tool call request, then the tool type identifier of the engine tool corresponding to the target tool identifier indicated by the tool call request can be considered as an engine command type, meaning it can be executed by the target game engine. Specifically, the server can parse the tool call request to obtain the target tool identifier and request parameters. It can search for the target tool identifier in the engine tool set, thus determining that the engine tool corresponding to the target tool identifier indicated by the tool call request is an engine command type, meaning it can be executed by the target game engine. The server can then identify this tool call request as the first tool call request. If the target tool identifier is not found in the engine tool set, the engine tool corresponding to the target tool identifier indicated by the tool call request is determined to be a server command type, meaning it can be executed by the server. The server can then identify this tool call request as a second tool call request. The middleware service, acting as the management center for command routing and scheduling, can perform tool call command routing processing, create general generation commands based on the first tool call command, and manage the commands.

[0088] Based on the above process, the server can divide N tool call requests into P first tool call requests and Q second tool call requests. That is, the P first tool call requests are those whose tool type identifiers indicate they are engine command type requests, determined by the server from the N tool call requests; the Q second tool call requests are those whose tool type identifiers indicate they are server command type requests, determined by the server from the N tool call requests. The tool type identifier is determined by the server by searching within the engine tool set based on the target tool identifier in the tool call request.

[0089] Furthermore, the server can obtain the processing function of the engine tool corresponding to the target tool identifier in the second tool call request. Based on the processing function and the request parameters in the second tool call request, the server performs task processing to obtain the request result corresponding to the second tool call request. The server can create general generation commands for each of the P first tool call requests, resulting in P general generation commands. Then, according to the dependencies between the subtasks corresponding to the P first tool call requests, the server can sequentially write the P general generation commands into the command execution queue.

[0090] An optional representation of a generic generation command could be “{ "id": "cmd_20260127_143053_d4e5f6", "type": "setTransform", "payload": { "entityId": "entity_abc123", "space": "local", "position": [5, 0, 3], "rotation": [0, 45, 0], "scale": [1,1, 1], "mode": "set"}, "createdAt": 1706345679123}”. The general generation command indicates a set transformation command, where "id" is used to indicate the unique identifier of the set transformation command, which is "cmd_20260127_143053_d4e5f6"; "type" indicates the command type, corresponding to the tool name of the engine tool, or the target tool identifier, indicating that an engine tool named "setTransform (set transformation attribute)" is being called; "payload" indicates the command parameters, the structure of which depends on "type"; and "createdAt" indicates the timestamp of the set transformation command, which can be used for sorting and timeout judgment.

[0091] Step S403: Obtain P general generation commands created by the server based on P first tool call requests. Map the P general generation commands to the engine agent to obtain P tool execution commands applicable to the target game engine. Obtain the request results obtained by the server based on Q second tool call requests. Based on the P tool execution commands and Q request results, call the engine tools corresponding to the P tool execution commands from the target game engine to perform task processing and obtain game development data.

[0092] In this embodiment of the application, the service device can sequentially obtain general generation commands from the server's command execution queue through the engine agent; when a general generation command B is obtained from the command execution queue... j At that time, the general generation command B can be adapted through the adaptation layer in the engine agent. j This is mapped to a tool execution command that the target game engine can recognize. Here, j is a positive integer less than or equal to P. Specifically, the business device can use the adaptation layer in the engine's intelligent agent to generate the general command B. j The process involves parsing to obtain a set of general parameters. Each general parameter in this set can be derived from the general command B through an adaptation layer. jThe parsed parameters are standardized and independent of the target game engine, serving as an intermediate representation layer connecting different game engines. The engine agent can use the mapping table for the target game engine in the adaptation layer to map each general parameter in the general parameter set to an engine-recognizable parameter, thus obtaining the engine parameter set. The mapping table indicates the correspondence between general parameters and engine-recognizable parameters. The engine-recognizable parameters in the engine parameter set can be parameter formats that a specific game engine (i.e., the target game engine) can directly understand and process after being transformed by the mapping table; they represent the concrete implementation of general parameters in the target game engine. Furthermore, the business device can use the engine agent to encapsulate the engine-recognizable parameters in the engine parameter set according to the target game engine's data calling format, obtaining the general generation command B. j The corresponding tool execution command. The data call format is a format in which engine-recognizable parameters are encapsulated according to the target game engine's Application Programming Interface (API) calling convention; the general generation command B... j The corresponding tool execution command is applicable to the target game engine, meaning the target game engine can recognize and process the general generation command B. j The corresponding tool execution command. Here, the adaptation layer can refer to the component layer that maps "engine-independent tool / command protocols" (such as general generation commands) to specific engine-executable operations (such as tool execution commands).

[0093] This process, through a three-step closed loop of "general command parsing → general parameter mapping → engine format encapsulation," utilizes an adaptation layer and a dedicated mapping table to transform the server-output general generation commands (engine-independent and standardized in format) into tool execution commands that can be directly recognized and executed by the target game engine (such as Unity or Unreal). Compared to the inefficient model of existing technologies that involve "AI generating general content, followed by manual compatibility checks, parameter format modifications, and adaptation to engine calling specifications," this process technically reduces the compatibility barriers between AI-generated results and game engines. The generated tool execution commands can run directly within the target engine. Furthermore, the general generation commands always maintain a standardized format, eliminating the need to adjust the server's generation logic for different game engines. This significantly reduces the adaptation cost for multiple game engines, enabling rapid integration with different types and versions of game engines, thus enhancing the solution's industry versatility and scalability.

[0094] Furthermore, the business device can obtain the request results corresponding to Q second tool call requests from the server. Based on P tool execution commands and Q request results, it calls the corresponding engine tools from the target game engine to perform task processing and obtain game development data. This game development data includes game scene data, game scripts, game asset resources, game editing status, and resource summaries.

[0095] In one embodiment, the P tool execution commands include tool execution command C. j j is a positive integer less than or equal to P; the tool executes command C. j For commands used to create entities; Q request results include tool execution commands C j The associated list of entities to be created. Based on P tool execution commands and Q request results, the business device calls the corresponding engine tools from the target game engine to process the tasks and obtain game development data. The specific implementation process can be as follows: The business device, through the engine agent, inputs the locations of entities to be created from the list of entities to be created into the tool execution command C. j The entity location field in the code provides the update tool execution command; this allows the tool to be invoked from the target game engine to execute the command. j The corresponding engine tool executes the command C through the tool. j The corresponding engine tools and update tools execute commands to create entities at the locations indicated in the list of entities to be created, thus obtaining game entity data. This game entity data is used to compose the game development data; that is, it is a portion of the game development data. In other words, when a subtask corresponding to a tool execution command has a data dependency with a subtask corresponding to a second tool call request, it is necessary to wait for the server to complete processing the second call request and for the engine agent to obtain the returned request result from the server. Only then can the corresponding request result be used as the input parameter for the task execution command, and the corresponding engine tool be called to execute the command, obtaining the final command execution result (such as the game entity data mentioned above).

[0096] When all P tool commands have been executed, the server can obtain a complete project snapshot from the game development environment, thus acquiring the game development data corresponding to the game generation requirements. This project snapshot describes the current project status of the game development process and may include structured serialized data of the project / scene / asset (e.g., snapshot files), used for rapid recovery, auditing, and incremental disk storage. The project snapshot can be automatically saved, for example, triggered by a timer, such as saving a snapshot every 10 minutes. Saving the project status after all P tool commands have been executed results in a new project snapshot, which can be a complete snapshot of the project, i.e., the game development data mentioned above.

[0097] It should be noted that after the engine agent pulls a general generation command from the command execution queue of the middleware service on the server, it uses the general generation command B... j For example, middleware services can generate general command B. j The delivery timestamp (i.e., deliveredAt) is used to indicate the generic generation command B. j Successfully delivered to the execution end (i.e., the engine agent), thus ensuring the generic generation command B j It is reliably delivered to the game engine for execution. The engine agent executes the general generation command B. j After mapping the commands to the tool and invoking the target game engine for execution, the target game engine can return the command execution result to the middleware service for status feedback. At this time, the middleware service can record the general generation command B. j The acknowledgment time (i.e., ackedAt). The command execution result can include success / failure status, error messages (such as failure), and execution result data (such as the game entity data mentioned above). The middleware service can record the generic generation command B. j The middleware service monitors the execution status of generic generation commands and provides feedback. When a timeout occurs (i.e., no command execution result is returned for an extended period), the middleware service can clean up the timed-out generic generation commands and trigger a retry mechanism, thereby maintaining the health of the command execution queue and preventing command blocking. If the execution result of a generic generation command needs to be returned to the orchestration agent, the middleware service can send the command execution result back to the orchestration agent upon receiving it from the target game engine.

[0098] This process, which executes commands within the engine (i.e., tool execution commands) and generates receipts carrying success / failure information and execution data (such as console output, resource IDs, and preview image paths), provides a closed-loop signal for automated verification and replanning. This reduces the problem of "generating only text code that cannot be runnable" in existing game development processes, thereby improving the executability of the generated results.

[0099] Optionally, the multiple intelligent agents may also include a review intelligent agent and a testing intelligent agent. After obtaining the game development data, the business device can test and verify the game development data through the review intelligent agent.

[0100] Step S404: Check whether the test verification of the game development data has passed.

[0101] In this embodiment, the testing and verification may include, but is not limited to, verification of the reasonableness of object requirements, verification of parameter integrity, and verification of asset consistency. The business device can review whether the testing and verification of the game development data performed by the intelligent agent passes. If at least one of the object requirement reasonableness verification, parameter integrity verification, and asset consistency verification fails, i.e., the testing and verification of the game development data fails, the process can proceed to step S405; if all three verifications pass, i.e., the testing and verification of the game development data passes, the process can proceed to step S406.

[0102] Step S405: Through the orchestration agent among multiple agents, the game generation requirements are replanned to obtain a new set of game generation tasks, until the test and verification of the new game development data are passed.

[0103] In this embodiment, when the testing and verification of game development data fails, multiple agents can perform failure analysis on the game development data to determine the reasons for the failure. Furthermore, the orchestration agent among these agents can replan based on the game generation requirements and the reasons for the failure, resulting in a new set of game generation tasks. This replanning process may include, but is not limited to, adjusting the task steps and supplementing resources within the game generation task set. Then, the orchestration agent can create tool invocation requests for each generation task in the new game generation task set until the testing and verification of the new game development data passes.

[0104] Step S406: Through the testing agent, the target game indicated by the game development data is run according to the game development data; if the target game runs normally, the game development data is materialized and written to disk to obtain the materialized file corresponding to the target game.

[0105] In this embodiment, the service device can use a testing agent to run the target game indicated by the game development data. If the target game runs abnormally, the service device can perform anomaly analysis on the game development data to determine the cause of the anomaly. Then, appropriate processing can be performed based on the cause of the anomaly until the game runs normally. If the target game runs normally, the service device can materialize and write the game development data to disk to obtain a materialized file corresponding to the target game. This materialized file is used to generate an executable program for the target game. Whether the target game runs normally can be determined based on running conditions. Running conditions refer to a set of conditions used to determine whether the game-generated data is usable. These conditions may include, but are not limited to, engine startup, no fatal errors in critical scripts, scene loading, execution of critical interactions, and metrics such as frame rate, memory usage, and loading time. In other words, when the target game runs, if it meets the content indicated by the running conditions, such as engine startup, no fatal errors, scene loading, and execution of critical interactions, the target game can be considered to be running normally. When the target game runs, if it does not meet any one of the running conditions (engine startup, no fatal errors, scene loading, and execution of critical interactions), the target game can be considered to be running abnormally.

[0106] Through this process, multiple agents collaborate to automatically complete task planning, game generation, game verification, game testing, and materialization on disk, thereby improving game development efficiency. Furthermore, verification by reviewing agents reduces irrelevant modifications and redundant generation, thus mitigating illusions during the game development process.

[0107] Materialization can refer to writing game scene data, game scripts, game assets, game editing status, and resource summaries from the project snapshot (i.e., the game development data mentioned above) into persistent, maintainable, and version-controllable file structures (such as scenes / xx.scene.json, scripts / xx.js, assets / index.json, etc.), i.e., materialized files.

[0108] Specifically, the business device can create a standard directory structure. This standard directory structure includes a scene file directory, a script file directory, a resource file directory, an editor state directory, and a context injection directory. The business device can serialize the game scene data in the game development data to obtain structured game scene data, and store this structured game scene data in the scene file directory. This structured game scene data can be in JSON format and may include, but is not limited to, scene metadata (scene identifier, name, version, creation time, etc.), attribute configurations (background color, physical parameters, camera settings, etc.), an entity list (all game objects in the scene), and dependencies (resources and scripts that the scene depends on).

[0109] The business equipment can store each game script in a corresponding subdirectory of the script file directory based on the script type of each game script among multiple game scripts in the game development data. Script types can include, but are not limited to, entity scripts, system scripts, and utility scripts. Specifically, the script content (such as JavaScript code) of each game script can be written to a script file (e.g., the filename can be in the format "script_name.js"), and the corresponding script file can be stored in the corresponding subdirectory of the script file directory according to the script type of each game script.

[0110] The application equipment can categorize game assets from game development data according to resource type, resulting in categorized sub-resources. These categorized sub-resources are then stored in corresponding subdirectories within the resource file directory. Specifically, resource types can include, but are not limited to, image resources, audio resources, and model resources. The application equipment can also convert the categorized sub-resources into binary resources, storing different types of binary resources in their respective subdirectories within the resource file directory. For example, binary resources corresponding to image resources are stored in the image resource subdirectory within the resource file directory; binary resources corresponding to audio resources are stored in the audio resource subdirectory within the resource file directory.

[0111] The business device can store the game editing state from the game development data to the editor state directory. This game editing state can be used to record the editor window layout, selected objects, and other states. The business device can also store resource summaries from the game development data to the context injection directory. The scene file directory, script file directory, resource file directory, editor state directory, and context injection directory in the standard directory structure are identified as the materialized files corresponding to the target game. The resource summary can be descriptive information about resources, or a structured metadata report on project resource usage, rather than resource data. The resource summary can include statistics, dependencies, performance metrics, configuration data, etc., stored in formats such as JSON. It can be used for toolchain integration, orchestration agent context injection, etc., and is one of the standard output products of the materialization disk disposal process.

[0112] It should be noted that an auditable chain can be formed by using a command execution queue, execution result receipts, and materialized data storage on disk. This enables the reproduction and playback of game development data, improving the reliability and traceability of game development data (i.e., generated results). Furthermore, by storing and materializing project snapshots on disk, these snapshots can be used for rapid recovery and for storing the generated results into a maintainable project file structure (i.e., materialized files), thereby supporting version control.

[0113] Through the above process, the game generation requirements are structured and analyzed by the orchestration agent, automatically broken down into M generation tasks, and further generated into N tool call requests. This achieves a fully automated closed-loop game development process of "requirements → tasks → tool calls → engine execution → data output," including code generation and game resource or art generation, thereby reducing the manual costs of game development. Furthermore, through the command mapping capability of the engine agent, P general generation commands generated by the server are accurately converted into P tool execution commands suitable for the target game engine, and the registered engine tools within the engine are directly called for execution. This reduces the compatibility barriers between the AI-generated game results (i.e., game development data) and the game engine, significantly reducing the cost and time wasted in game deployment. Innovatively, the underlying operation functions of the game engine are abstracted and integrated into standardized engine tools, which are registered in the target game engine. This achieves a decoupled design where "the agent calls tools, rather than directly calling the game engine's underlying interface." This allows the agent to call standardized engine tools without needing to adapt to the underlying logic of different engines, reducing the adaptation costs between the agent and multiple engines. Furthermore, multiple intelligent agents can work together to automatically complete task planning, game generation, game verification, game testing, and materialization on disk during the game development process, thereby improving game development efficiency.

[0114] Please see also Figure 5 , Figure 5 This is a scenario illustration of a game generation method provided in an embodiment of this application. Figure 2 This game generation method can be executed jointly by business devices and servers. For example... Figure 5 As shown, the user-side business object (the business object using the business device) can send initial game generation requirements to multiple agents. The orchestration agent among these agents can then create a tool invocation request based on the initial game generation requirements and send it to the server's middleware service. The business device can then determine the target game engine for the game generation requirements from one or more game engines associated with the engine agent among the multiple agents, based on the orchestration agent and the game generation requirements. The specific implementation process can be found above. Figure 4 The specific details of step S401 in the embodiments will not be repeated here.

[0115] Furthermore, the middleware service can manage the routing of received tool call requests. Tool call requests with a tool type identifier indicating a server command type are executed directly by the server using the corresponding server command type engine tool to obtain the requested result. For tool call requests with a tool type identifier indicating an engine command type, the middleware service creates a generic generation command and writes it to the command execution queue. The specific implementation process of this step can be found above. Figure 4The specific description of step S402 in the embodiment will not be repeated here. The engine agent among the multiple agents can poll / receive commands from the command execution queue, retrieve general-generated commands for processing, and execute the tool execution commands converted from the general-generated commands by calling the engine tool to obtain the command execution results. These results can then be returned to the middleware service of the server (i.e., command receipt). The specific implementation process of this step can be found above. Figure 4 The specific details of step S403 in the embodiments will not be repeated here.

[0116] Furthermore, the server can generate a project snapshot based on the obtained command execution results and record it in the project workspace. Once all tool call requests have been processed, the resulting project snapshot can be identified as game development data. This game development data can include game scene data, game scripts, game assets, game editing status, and resource summaries. The business devices can then materialize and write the game development data to disk, obtaining materialized files. These materialized files are readable by the business objects and can be used for version management and review. The materialized files can include a scene file directory, a script file directory, a resource file directory, an editor status directory, and a context injection directory. Specifically, the scene file directory stores the game scene data from the game development data; the script file directory stores the game scripts; the resource file directory stores the game assets; the editor status directory stores the game editing status; and the context injection directory stores the resource summaries.

[0117] Please see also Figure 6 , Figure 6 This is a flowchart illustrating a game generation method provided in an embodiment of this application. Figure 3 This game generation method can be executed jointly by business devices and servers. It describes the requirement completion process for obtaining game generation requirements in natural language format. The game generation method may include at least the following steps S601-S605: Step S601: The business object inputs the initial game generation requirements.

[0118] In this embodiment, the service device is equipped with multiple intelligent agents, and the service object can send initial game generation requests to these agents. An optional implementation of this step can be found in [reference needed]. Figure 2 The embodiment describes the process by which the business object inputs and sends the initial game generation requirement 202a in the smart session page 202.

[0119] Step S602: Perform requirement analysis and generate information gap identification.

[0120] In this embodiment, the orchestration agent among multiple agents can parse the initial game generation requirements to obtain the generation information gaps for the game generation goals in the initial game generation requirements. The specific implementation process of this step can be found above. Figure 3 The specific details of step S301 in the embodiments will not be repeated here.

[0121] Step S603: Generate the text of the issue to be clarified.

[0122] In this embodiment, the service device can generate text of a question to be clarified based on the generated information gap through an orchestrated intelligent agent. This text is then displayed so that the service object can see it. An optional method for displaying the text of the question to be clarified can be found in [reference needed]. Figure 2 The process mentioned in the embodiment is to display the text 203a of the question to be clarified on the smart conversation page 203 through multiple agents 201.

[0123] Step S604: The business object inputs supplementary information.

[0124] In this embodiment, after obtaining the text of the question to be clarified, the business object can supplement it with corresponding supplementary information based on the text. The business device can respond to the supplementary input operation of the business object on the text of the question to be clarified and obtain the supplementary information on the text of the question to be clarified.

[0125] It should be noted that steps S603 to S604 can be iterated multiple times until the supplementary information sent by the business object can fully supplement the complete game generation requirements needed to generate the target game.

[0126] Step S605: Perform requirement structuring.

[0127] In this embodiment of the application, the service device can perform structured processing on the initial game generation requirements and supplementary information to obtain game generation requirements in natural language format.

[0128] Through the above process, a full-chain technology upgrade of game generation requirements has been achieved, from "fuzzy input → structured parsing → gap filling → standardized output". This can improve the completeness of game generation requirements, thereby reducing communication costs, improving the accuracy of game generation, reducing rework in game generation, and saving resource consumption in the game generation process.

[0129] Please see also Figure 7 , Figure 7 This is a scenario illustration of a game generation method provided in an embodiment of this application. Figure 3This game generation method can be executed jointly by business devices and servers, illustrating the process of middleware services in the server routing tool call requests. For example... Figure 7 As shown, after the orchestration agent determines the target game engine for the target game indicated by the game generation requirements, the target game engine can register (or declare) the engine tools that the target game engine can use with the server's unified tool protocol layer.

[0130] Furthermore, the orchestration agent can send a registered tool query request to the unified tool protocol layer and obtain a general tool list returned by the unified tool protocol layer (that is, multiple candidate engine tools registered in the target game engine for performing different generation tasks). Further, the orchestration agent can create N tool invocation requests for the M generation tasks in the game generation task set. Specifically, the orchestration agent can decompose each of the M generation tasks, obtaining one or more subtasks corresponding to each generation task; it can determine the target tool identifier for each subtask, and for each subtask and its corresponding target tool identifier, create a tool invocation request for each subtask. When creating the tool invocation request for each subtask, it can create the request according to the format specified by the unified tool protocol. The unified tool protocol is a set of standard specifications implemented by the unified tool protocol layer, which may include interface definitions, data formats, invocation rules, etc., specifying the format that must be followed when invoking the corresponding engine tools.

[0131] Furthermore, the orchestration agent can send the created tool call request to the server's middleware service. The middleware service then distributes the tool call request. When the engine tool indicated by the tool call request is a server command type engine tool, the server can directly execute the tool call request and obtain the requested result. When the engine tool indicated by the tool call request is an engine command type engine tool, the server can create a generic generation command for the tool call request through the middleware service and write the generic generation command into the command execution queue. Further, the computer device can use the engine agent to call the target game engine, which then pulls the generic generation command from the command execution queue for command processing. For a detailed implementation of this process, please refer to [link to relevant documentation]. Figure 4 The specific descriptions of steps S402-S403 in the embodiments will not be repeated here.

[0132] Please see also Figure 8 , Figure 8 This is a flowchart illustrating a game generation method provided in an embodiment of this application. Figure 4This game generation method can be jointly executed by business devices and servers, and describes the processing of tool call requests corresponding to engine tools of server command types. The game generation method may include at least the following steps S801-S808: Step S801: Send a tool call request.

[0133] In this embodiment of the application, the orchestration agent can create a corresponding tool call request based on the subtask and send the tool call request to the middleware service of the server.

[0134] Step S802: Construct a general generation command and write it into the command execution queue.

[0135] In this embodiment, the middleware service can perform traffic routing after receiving a tool invocation request from the orchestration agent. Here, we will directly use a tool invocation request corresponding to an engine tool of the server command type as an example. The middleware service creates a generic generation command for this tool invocation request. The generic generation command may include a command identifier (ID), command type (type), command parameters (payload), and command creation timestamp (createdAt).

[0136] Furthermore, the middleware service can write this generic generation command to the command execution queue.

[0137] Step S803: Retrieve the general generation command.

[0138] In this embodiment of the application, the target game engine can pull general generation commands from the command execution queue of the server.

[0139] Step S804: Return the general generation command and mark the command delivery timestamp.

[0140] In this embodiment of the application, when the target game engine needs to retrieve the generic generation command, the middleware service can return the generic generation command to the target game engine and mark the returned generic generation command with a command delivery timestamp (such as deliveredAt). The command delivery timestamp can be used to indicate that the generic generation command has been successfully sent to the target game engine.

[0141] Step S805: Execute the general generation command.

[0142] In this embodiment, after obtaining the general generation command, the target game engine can execute it. Specifically, the general generation command can be mapped to obtain a tool execution command suitable for the target game engine. Based on the tool execution command, the engine tool corresponding to the tool execution command is called from the target game engine to perform task processing and obtain the command execution result. The command execution result can be a successful execution result, an error execution result, or specific execution data.

[0143] Step S806: Return the command execution result.

[0144] In this embodiment of the application, the target game engine can return the command execution result to the middleware service.

[0145] Step S807: Mark the receipt time. If the command execution times out, clean up the command.

[0146] In this embodiment, when the target game engine can return the command execution result to the middleware service, the middleware service can mark the acknowledgment time (e.g., ackedAt) for the general generation command. If the target game engine does not return the command execution result for the general generation command to the middleware service for a long time, i.e., execution timeout, the middleware service can clean up the general generation command in the command execution queue. Optionally, the server can use an error feedback mechanism through an orchestration agent, which can then determine whether to re-execute the cleaned-up general generation command.

[0147] Step S808: Return execution data.

[0148] In this embodiment, for general generation commands that require returning execution data to the orchestration agent, the middleware service can return the command execution result (such as execution data) to the orchestration agent. One possible type of execution data is a screenshot file path, i.e., the engine tool (such as a screenshot tool) corresponding to the command executed by the target game engine performs screenshot processing to obtain screenshot data. The middleware service can return the screenshot storage location (i.e., the screenshot file path) corresponding to this screenshot data to the orchestration agent, instead of returning the screenshot data itself to the orchestration agent.

[0149] Please see also Figure 9 , Figure 9 This is a flowchart illustrating a game generation method provided in an embodiment of this application. Figure 5 This game generation method can be executed jointly by business devices and servers, and is used to illustrate the game verification process. The game generation method may include at least the following steps S901-S905: Step S901: Execute the command using the execution tool.

[0150] In this embodiment of the application, the server calls the corresponding engine tool to perform task processing according to the second tool call request and obtains the request result. After the target game engine calls the corresponding engine tool according to the first tool call request (actually the tool execution command corresponding to the first tool call request) and executes the command, game development data can be obtained.

[0151] Step S902: Test and verify the game development data and run the test.

[0152] In this embodiment, the multiple intelligent agents also include a review intelligent agent and a testing intelligent agent. The business device can use the review intelligent agent to test and verify the game development data. The testing and verification includes verifying the reasonableness of object requirements, the integrity of parameters, and the consistency of assets. If at least one of these verifications fails, the process proceeds to step S904.

[0153] If the object requirement rationality verification, parameter integrity verification, and asset consistency verification all pass, then the test agent runs the target game indicated by the game development data, based on the game development data. If the target game runs normally, then proceed to step S903.

[0154] Step S903: Perform physical materialization on the disk.

[0155] In this embodiment, the service device can materialize and write game development data to disk to obtain materialized files corresponding to the target game, that is, to store game scene data, game scripts, game material resources, game editing status and resource summaries in the game development data in separate directories.

[0156] Step S904: Perform replanning.

[0157] In this embodiment, the service device can use an orchestration agent among multiple agents to perform failure analysis on game development data and obtain the reasons for generation failures. Then, based on the game generation requirements and the reasons for generation failures, the game generation task set can be replanned (e.g., adjusting task steps or supplementing resources) to obtain a new game generation task set. Further, the new game generation task set can be processed to obtain new game development data, which is then re-verified until the object requirement rationality verification, parameter integrity verification, and asset consistency verification of the obtained new game development data all pass.

[0158] Step S905: Perform physical materialization on the disk.

[0159] In this embodiment of the application, after the object requirement rationality verification, parameter integrity verification and asset consistency verification of the new game development data have all passed, the business device can materialize the new game development data and write it to disk to obtain the materialized file corresponding to the target game.

[0160] It should be noted that this solution uses a complete technical chain of "multi-agent + unified tool protocol + command feedback + snapshot disk + verification closed loop" to ensure that game development data (i.e. agent generation results) can run stably within the game engine and can be audited and replayed.

[0161] It's important to note that this solution can be applied to game development from scratch, as well as to incremental iterations of existing games. For example, it can be used to generate a 2D rule-based game (such as avoidance / jumping / classification) from scratch. Multiple agents can automatically create scene entities, scripts, and basic assets through the game engine to generate the game, rather than just generating code or logic fragments. After the agents are reviewed and tested for verification, the game can be materialized and placed on a disk to obtain the corresponding 2D rule-based game. This solution can also be used for incremental iterations of existing game projects (such as adding items, adjusting physics parameters, replacing materials / textures, adding UI, etc.). Multiple agents, under the constraints of the engine's state context, only modify relevant entities / assets and automatically verify regressions, thus completing the update and iteration of existing game projects.

[0162] It should be noted that this solution can also perform cross-engine game generation, such as developing the same game generation requirements on different game engines and generating corresponding game projects. Simply select different game engines as the target game engines during game engine adaptation. The adaptation layer can map unified tool call requests to the APIs of different game engines, thereby enabling the reuse of the same multi-agent process across game engines. This allows for game development on different game engines based on the same game generation requirements.

[0163] It should be noted that, in addition to the orchestration agent (which can be extended to two separate agents, such as the development architecture agent and the development engineer agent), engine agent, review agent, and testing agent mentioned above, multiple intelligent agents can also be extended to include asset generation agents and retrieval agents. The asset generation agent can be used to perform asset generation tasks during game development, while the retrieval agent can be used to perform retrieval tasks during game development, such as retrieving image resources and audio resources as needed during game development.

[0164] Further, please see Figure 10 , Figure 10This is a schematic diagram of a game generation device provided in an embodiment of this application. The game generation device 1000 can be a computer program (including program code, etc.) running on a business device; for example, the game generation device 1000 can be an application software. The game generation device 1000 can be used to execute corresponding steps in the method provided in the embodiment of this application. Figure 10 As shown, the game generation device 1000 can be used in the business devices of the various embodiments mentioned in this application. Specifically, the game generation device 1000 may include: a tool registration module 11, a requirement acquisition module 12, a task generation module 13, an engine determination module 14, a request creation module 15, a game generation module 16, and a game testing module 17.

[0165] Requirement acquisition module 12 is used to acquire game generation requirements in natural language format; Task generation module 13 is used to parse the game generation requirements through the orchestration agent among multiple agents to obtain a set of game generation tasks; the set of game generation tasks includes M generation tasks; M is a positive integer; Engine determination module 14 is used to determine the target game engine for the game generation requirements from one or more game engines associated with the engine agent among multiple agents by orchestrating intelligent agents and game generation requirements; the target game engine has registered engine tools for implementing each generation task, the engine tools are obtained by abstracting and integrating the operation functions provided by the target game engine, and the engine tools are used to simulate the execution of operation functions. Request creation module 15 is used to create N tool call requests for M generation tasks by orchestrating intelligent agents, and send the N tool call requests to the server; a tool call request is determined by a subtask in a generation task and a target tool identifier corresponding to that subtask; N is a positive integer greater than or equal to M; a target tool identifier is used to represent an engine tool; The game generation module 16 is used to obtain P general generation commands created by the server based on P first tool call requests, map the P general generation commands to obtain P tool execution commands applicable to the target game engine through the engine agent, obtain the request results obtained by the server based on Q second tool call requests, and, based on the P tool execution commands and Q request results, call the engine tools corresponding to the P tool execution commands from the target game engine to perform task processing and obtain game development data. The game development data includes game scene data, game scripts, game material resources, game editing status, and resource summary. The N tool call requests include P first tool call requests and Q second tool call requests, where P and Q are both positive integers, and the sum of P and Q is N.

[0166] In one alternative implementation, when the requirement acquisition module 12 acquires game generation requirements in natural language format, the requirement acquisition module 12 is specifically used to perform the following operations: Obtain the initial game generation requirement sent by the business object, parse the initial game generation requirement, and obtain the generation information gap for the game generation target in the initial game generation requirement; Based on the generated information gaps, generate text of the questions to be clarified; Displays the text of the question to be clarified, responds to supplementary input for the text of the question to be clarified, and retrieves supplementary information for the text of the question to be clarified; The initial game generation requirements and supplementary information are structured to obtain game generation requirements in natural language format.

[0167] In one optional implementation, the game generation requirements in natural language format include game objectives, game steps, and game acceptance conditions; the task generation module 13 is used to parse the game generation requirements through an orchestration agent among multiple agents to obtain a set of game generation tasks. Specifically, the task generation module 13 is used to perform the following operations: By using the orchestration agent among multiple agents, the game objective, game steps and game acceptance conditions are logically transformed to obtain S game development dimensions corresponding to the game generation requirements, where S is a positive integer. Functional identification is performed on the S game development dimensions to determine the task priority corresponding to each game development dimension and the dependencies between each game development dimension; Each of the S game development dimensions is broken down into tasks, resulting in M ​​generation tasks. Based on the task priority corresponding to each game development dimension and the dependencies between each game development dimension, the M generation tasks are combined to obtain a game generation task set.

[0168] In one alternative implementation, when engine determination module 14 determines the target game engine for the game generation requirements from one or more game engines associated with an engine agent among multiple agents by orchestrating agents and game generation requirements, engine determination module 14 is specifically used to perform the following operations: By orchestrating intelligent agents, engine adaptation requirements are analyzed to obtain engine adaptation requirements for game generation. Based on engine adaptation requirements, a match is made among one or more game engines associated with the engine agent in multiple agents, and the matched game engine is determined as the target game engine. Alternatively, obtain the engine call history corresponding to one or more game engines, and determine the game engine corresponding to the candidate engine adaptation requirements recorded in the engine call history as the target game engine; candidate engine adaptation requirements refer to historical engine adaptation requirements in the engine call history that are similar to the engine adaptation requirements.

[0169] In an alternative implementation, the game generation device 1000 further includes a tool registration module 11, which is specifically used to perform the following operations: Functional identification of the target game engine is performed to determine the smallest operational unit corresponding to each operational function of the target game engine used for game development; The operation function implemented by each smallest operation unit is encapsulated to obtain the tool code corresponding to each operation function; a tool code includes the operation logic parameters corresponding to an operation function; The tool code corresponding to each operation function is registered to the target game engine to obtain the target game engine containing engine tools for implementing each generation task; one engine tool registered in the target game engine is used to implement a subtask in a generation task according to an operation logic parameter.

[0170] In one alternative implementation, when the request creation module 15 creates N tool invocation requests for M generation tasks through an orchestration agent, the request creation module 15 is specifically used to perform the following operations: Each of the M generated tasks is broken down into one or more subtasks corresponding to each generated task; the sum of the number of one or more subtasks corresponding to each generated task is N. Determine the target tool identifier for each subtask, and for each subtask and its corresponding target tool identifier, create a tool invocation request for each subtask.

[0171] In one alternative implementation, the N subtasks include subtask A. i , where i is a positive integer less than or equal to N; when requesting the creation module 15 to determine the target tool identifier corresponding to each subtask, the request creation module 15 is specifically used to perform the following operations: The system orchestrates intelligent agents to send registered tool query requests to the server, enabling the server to generate a general tool list based on these requests. The general tool list includes multiple candidate engine tools registered in the target game engine for performing different generation tasks. Obtain the list of general-purpose tools returned by the server through subtask A. iMatch among multiple candidate engine tools in the general tool list, and identify the tool identifier of the matched candidate engine tool as subtask A. i The corresponding target tool identifier.

[0172] In one alternative implementation, the P first tool call requests are tool call requests whose tool type identifier indicates an engine command type, determined by the server from N tool call requests; the Q second tool call requests are tool call requests whose tool type identifier indicates a server command type, determined by the server from N tool call requests. The tool type identifier is determined by the server by searching within the engine tool set based on the target tool identifier in the tool invocation request; The Q request results are obtained by the server processing the task based on the processing function of the engine tool corresponding to the target tool identifier in the Q second tool call requests, and the request parameters in the Q second tool call requests.

[0173] In one optional implementation, the server is further configured to create P general generation commands based on P first tool call requests, and sequentially write the P general generation commands into a command execution queue; the game generation module 16 is configured to obtain the P general generation commands created by the server based on the P first tool call requests, and map the P general generation commands to the engine agent to obtain P tool execution commands suitable for the target game engine. Specifically, the game generation module 16 is configured to perform the following operations: The engine agent retrieves general generation commands sequentially from the server's command execution queue. When the general generation command B is retrieved from the command execution queue j At that time, through the adaptation layer in the engine intelligence agent, the general generation command B is... j The general parameter set is obtained by parsing; j is a positive integer less than or equal to P; The mapping table in the adaptation layer, which is used to target the game engine, maps each general parameter in the general parameter set to an engine-recognizable parameter, thus obtaining the engine parameter set; the mapping table is used to indicate the correspondence between the general parameters and the engine-recognizable parameters. Based on the data calling format of the target game engine, the engine-recognizable parameters in the engine parameter set are encapsulated to obtain the general generation command B. j The corresponding tool execution command; general generation command B j The corresponding tool execution commands are applicable to the target game engine.

[0174] In one alternative implementation, the P tool execution commands include tool execution command C. jj is a positive integer less than or equal to P; the tool executes command C. j For commands used to create entities; Q request results include tool execution commands C j The associated list of entities to be created; when the game generation module 16 is used to process the tasks by calling the corresponding engine tools from the target game engine based on the P tool execution commands and Q request results, and obtaining game development data, the game generation module 16 is specifically used to perform the following operations: Enter the locations of entities to be created from the list of locations to be created into the tool and execute command C. j The entity location field in the code provides the command to be executed by the update tool. Call the tool to execute command C from the target game engine. j The corresponding engine tool executes the command C through the tool. j The corresponding engine tools and update tools execute commands to create entities at the locations indicated in the list of entities to be created, thus obtaining game entity data; the game entity data is used to compose game development data.

[0175] In one alternative implementation, the multiple agents further include a review agent and a test agent; the game generation device 1000 also includes a game testing module 17, which is specifically used to perform the following operations: The game development data is tested and verified by reviewing intelligent agents; the testing and verification includes verifying the rationality of object requirements, the integrity of parameters, and the consistency of assets. If at least one of the object requirement rationality verification, parameter integrity verification, and asset consistency verification fails, the game generation requirements will be replanned by the orchestration agent among multiple agents to obtain a new set of game generation tasks until the object requirement rationality verification, parameter integrity verification, and asset consistency verification of the new game development data all pass. If the object requirement rationality verification, parameter integrity verification, and asset consistency verification all pass, then the test agent will run the target game indicated by the game development data based on the game development data. If the target game runs normally, the game development data is materialized and written to disk to obtain the corresponding materialized file for the target game; the materialized file is used to generate the executable program for the target game.

[0176] In one optional implementation, the game testing module 17 is used to materialize and write the game development data to disk. When obtaining the materialized file corresponding to the target game, the game testing module 17 is specifically used to perform the following operations: Create a standard directory structure; the standard directory structure includes a scene file directory, a script file directory, a resource file directory, an editor state directory, and a context injection directory; The game scene data in the game development data is serialized to obtain structured game scene data, and the structured game scene data is stored in the scene file directory; Based on the script type of each game script in the game development data, each game script is stored in the corresponding subdirectory of the script file directory; The game assets in the game development data are classified according to resource type to obtain classified sub-assets. The classified sub-assets are then stored in the corresponding sub-directories of the resource file directory. Store the game editing state from the game development data to the editor state directory; The resource summary in the game development data is stored in the context injection directory. The scene file directory, script file directory, resource file directory, editor state directory and context injection directory in the standard directory structure are identified as the materialized files corresponding to the target game.

[0177] Through the above process, the game generation requirements are structured and analyzed by the orchestration agent, automatically broken down into M generation tasks, and further generated into N tool call requests. This achieves a fully automated closed-loop game development process of "requirements → tasks → tool calls → engine execution → data output," including code generation and game resource or art generation, thereby reducing the manual costs of game development. Furthermore, through the command mapping capability of the engine agent, P general generation commands generated by the server are accurately converted into P tool execution commands suitable for the target game engine, and the registered engine tools within the engine are directly called for execution. This reduces the compatibility barriers between the AI-generated game results (i.e., game development data) and the game engine, significantly reducing the cost and time wasted in game deployment. Innovatively, the underlying operation functions of the game engine are abstracted and integrated into standardized engine tools, which are registered in the target game engine. This achieves a decoupled design where "the agent calls tools, rather than directly calling the game engine's underlying interface." This allows the agent to call standardized engine tools without needing to adapt to the underlying logic of different engines, reducing the adaptation costs between the agent and multiple engines. Furthermore, multiple intelligent agents can work together to automatically complete task planning, game generation, game verification, game testing, and materialization on disk during the game development process, thereby improving game development efficiency.

[0178] Please see Figure 11 , Figure 11 This is a schematic diagram of the structure of a computer device provided in an embodiment of this application. Figure 11As shown, the computer device 1100 in this embodiment may include a processor 1101, a network interface 1104, and a memory 1105. Furthermore, the computer device 1100 may also include a user interface 1103 and at least one communication bus 1102. The communication bus 1102 is used to enable communication between these components. The user interface 1103 may include a display screen and a keyboard; optionally, the user interface 1103 may also include a standard wired interface or a wireless interface. The network interface 1104 may optionally include a standard wired interface or a wireless interface (such as a Wi-Fi interface). The memory 1105 may be high-speed RAM or non-volatile memory, such as at least one disk storage device. Optionally, the memory 1105 may also be at least one storage device located remotely from the processor 1101. Figure 11 As shown, the memory 1105, which is a computer-readable storage medium, may include an operating system, a network communication module, a user interface module, and a device control application.

[0179] Network interface 1104 provides network communication elements; user interface 1103 is mainly used to provide an input interface for users; and processor 1101 can be used to call the device control application stored in memory 1105 to perform the following operations: Obtain game generation requirements in natural language format; The game generation requirements are analyzed by the orchestration agent among multiple agents to obtain a set of game generation tasks; the set of game generation tasks includes M generation tasks; M is a positive integer. By orchestrating intelligent agents and game generation requirements, a target game engine is identified from one or more game engines associated with the engine agent among multiple intelligent agents. The target game engine has registered engine tools for implementing each generation task. The engine tools are obtained by abstracting and integrating the operation functions provided by the target game engine, and the engine tools are used to simulate the execution of operation functions. By orchestrating intelligent agents into M generation tasks, N tool call requests are created and sent to the server. A tool call request is determined by a subtask in a generation task and a target tool identifier corresponding to that subtask. N is a positive integer greater than or equal to M. A target tool identifier is used to represent an engine tool. The system retrieves P general generation commands created by the server based on P first tool call requests. The engine agent maps these P general generation commands to obtain P tool execution commands applicable to the target game engine. It also retrieves the request results obtained by the server based on Q second tool call requests. Based on the P tool execution commands and the Q request results, the system calls the corresponding engine tools from the target game engine to process the tasks, obtaining game development data. This game development data includes game scene data, game scripts, game assets, game editing status, and resource summaries. The N tool call requests include P first tool call requests and Q second tool call requests, where P and Q are positive integers, and the sum of P and Q is N.

[0180] Furthermore, it should be noted that embodiments of this application also provide a computer-readable storage medium storing a computer program adapted to be loaded and executed by the processor. Figure 3 or Figure 4 For details on the methods provided in each step, please refer to the document. Figure 3 or Figure 4 The implementation methods provided for each step are not repeated here. Furthermore, the beneficial effects of using the same method are also not repeated. For technical details not disclosed in the computer-readable storage medium embodiments involved in this application, please refer to the description of the method embodiments of this application. As an example, a computer program may be deployed to execute on a single computer device, or on multiple computer devices located in one location, or on multiple computer devices distributed across multiple locations and interconnected via a communication network.

[0181] The computer-readable storage medium can be the apparatus provided in any of the foregoing embodiments or the internal storage unit of the computer device, such as the hard disk or memory of the computer device. The computer-readable storage medium can also be an external storage device of the computer device, such as a plug-in hard disk, smart media card (SMC), secure digital (SD) card, flash card, etc., provided on the computer device. Furthermore, the computer-readable storage medium can include both internal storage units and external storage devices of the computer device. The computer-readable storage medium is used to store the computer program and other programs and data required by the computer device. The computer-readable storage medium can also be used to temporarily store data that has been output or will be output.

[0182] This application also provides a computer program product or computer program, which includes computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform... Figure 3 or Figure 4 The methods provided are among the various optional methods available in the code, so they will not be elaborated upon here.

[0183] The terms "first," "second," etc., in the specification, claims, and drawings of this application are used to distinguish different objects, not to describe a specific order. Furthermore, the term "comprising," and any variations thereof, are intended to cover non-exclusive inclusion. For example, a process, method, apparatus, product, or device that includes a series of steps or units is not limited to the listed steps or modules, but may optionally include steps or modules not listed, or may optionally include other step units inherent to these processes, methods, apparatuses, products, or devices.

[0184] In the embodiments of this application, the terms "module" or "unit" refer to a computer program or part of a computer program that has a predetermined function and works with other related parts to achieve a predetermined goal, and can be implemented wholly or partially using software, hardware (such as processing circuitry or memory), or a combination thereof. Similarly, a processor (or multiple processors or memory) can be used to implement one or more modules or units. Furthermore, each module or unit can be part of an overall module or unit that includes the functionality of that module or unit.

[0185] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of each example have been generally described in terms of functionality. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this application.

[0186] The methods and related apparatus provided in this application are described with reference to the method flowcharts and / or structural diagrams provided in this application. Specifically, each block of the method flowchart and / or structural diagram, as well as combinations of blocks in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable device to create a machine, such that the instructions, which execute via the processor of the computer or other programmable device, generate instructions for implementing the process. Figure 1 A schematic diagram of one or more processes and / or structures. Figure 1 The computer program instructions may be stored in a computer-readable storage medium that can direct a computer or other programmable device to function in a particular manner, causing the instructions stored in the computer-readable storage medium to produce an article of manufacture including the instruction means, or to be transmitted via a computer-readable storage medium. The computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired (e.g., coaxial cable, fiber optic, digital line (DSL)) or wireless (e.g., infrared, wireless, microwave, etc.). The instruction means is implemented in the process. Figure 1 A schematic diagram of one or more processes and / or structures. Figure 1 The functions specified in one or more boxes. These computer program instructions may also be loaded onto a computer or other programmable device to cause a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable device for implementing the process. Figure 1 A process or multiple processes and / or structures illustrate the steps of the functions specified in one or more boxes.

[0187] The steps in the method of this application embodiment can be adjusted, combined, or deleted according to actual needs.

[0188] The modules in the device of this application embodiment can be merged, divided, and deleted according to actual needs.

[0189] The above-disclosed embodiments are merely preferred embodiments of this application and should not be construed as limiting the scope of this application. Therefore, any equivalent variations made in accordance with the claims of this application shall still fall within the scope of this application.

Claims

1. A game generation method, characterized in that, The method includes: Obtain game generation requirements in natural language format; The game generation requirements are parsed by an orchestration agent among multiple agents to obtain a set of game generation tasks; the set of game generation tasks includes M generation tasks; M is a positive integer. Based on the orchestration agent and the game generation requirements, a target game engine is determined from one or more game engines associated with the engine agent among the multiple agents, for the game generation requirements; the target game engine has registered engine tools for implementing each generation task, the engine tools are obtained by abstracting and integrating the operation functions provided by the target game engine, and the engine tools are used to simulate the execution of the operation functions; The orchestration agent creates N tool call requests for the M generation tasks and sends the N tool call requests to the server. A tool call request is determined by a subtask in a generation task and a target tool identifier corresponding to that subtask. N is a positive integer greater than or equal to M. A target tool identifier is used to represent an engine tool. The system obtains P general generation commands created by the server based on P first tool call requests. The engine agent maps these P general generation commands to obtain P tool execution commands applicable to the target game engine. The system also obtains the request results obtained by the server based on Q second tool call requests. Based on the P tool execution commands and the Q request results, the system calls the engine tools corresponding to the P tool execution commands from the target game engine to perform task processing, thereby obtaining game development data. The game development data includes game scene data, game scripts, game material resources, game editing status, and resource summaries. The N tool call requests include the P first tool call requests and the Q second tool call requests, where P and Q are positive integers, and the sum of P and Q is N.

2. The method according to claim 1, characterized in that, The process of obtaining game generation requirements in natural language format includes: Obtain the initial game generation requirement sent by the business object, parse the initial game generation requirement, and obtain the generation information gap for the game generation target in the initial game generation requirement; Based on the generated information gap, generate text of the questions to be clarified; Display the text of the question to be clarified, respond to supplementary input operations for the text of the question to be clarified, and obtain supplementary information for the text of the question to be clarified; The initial game generation requirements and the supplementary information are structured to obtain game generation requirements in natural language format.

3. The method according to claim 1, characterized in that, The game generation requirements with natural language format include game objectives, game steps, and game acceptance criteria. The process involves using an orchestration agent among multiple agents to parse the game generation requirements, resulting in a set of game generation tasks, including: By using an orchestration agent among multiple agents, the game objective, the game steps, and the game acceptance conditions are logically transformed to obtain S game development dimensions corresponding to the game generation requirements; S is a positive integer. Functional identification is performed on the S game development dimensions to determine the task priority corresponding to each game development dimension and the dependency relationship between each game development dimension; Each of the S game development dimensions is broken down into tasks, resulting in M ​​generation tasks; Based on the task priority corresponding to each game development dimension and the dependency relationship between each game development dimension, the M generation tasks are combined to obtain a game generation task set.

4. The method according to claim 1, characterized in that, The step of determining the target game engine for the game generation requirements from one or more game engines associated with the engine agent among the plurality of agents, based on the orchestration agent and the game generation requirements, includes: The orchestration agent performs engine adaptation analysis on the game generation requirements to obtain engine adaptation requirements for the game generation requirements. Based on the engine adaptation requirements, a match is made among one or more game engines associated with the engine agent in the plurality of agents, and the matched game engine is determined as the target game engine. Alternatively, obtain the engine call history corresponding to the one or more game engines respectively, and determine the game engine corresponding to the candidate engine adaptation requirements recorded in the engine call history as the target game engine; the candidate engine adaptation requirements refer to the historical engine adaptation requirements in the engine call history that are similar to the engine adaptation requirements.

5. The method according to claim 1, characterized in that, The method further includes: The target game engine is functionally identified to determine the smallest operational unit corresponding to each operational function of the target game engine used for game development; The operation function implemented by each smallest operation unit is encapsulated to obtain the tool code corresponding to each operation function; a tool code includes the operation logic parameters corresponding to an operation function; The tool code corresponding to each operation function is registered to the target game engine to obtain a target game engine containing engine tools for implementing each generated task; one engine tool registered in the target game engine is used to implement a subtask in a generated task according to an operation logic parameter.

6. The method according to claim 1, characterized in that, The process of creating N tool invocation requests for the M generation tasks through the orchestration agent includes: The M generation tasks are each broken down into one or more subtasks corresponding to each generation task; the sum of the number of one or more subtasks corresponding to each generation task is N. Determine the target tool identifier for each subtask, and for each subtask and its corresponding target tool identifier, create a tool invocation request for each subtask.

7. The method according to claim 6, characterized in that, N subtasks, including subtask A i , where i is a positive integer less than or equal to N; The step of determining the target tool identifier corresponding to each subtask includes: The orchestration agent sends a registered tool query request to the server, so that the server generates a general tool list based on the registered tool query request; the general tool list includes multiple candidate engine tools registered in the target game engine for performing different generation tasks; Obtain the list of general tools returned by the server, through subtask A. i Matching is performed among multiple candidate engine tools in the general tool list, and the tool identifier of the matched candidate engine tool is determined as the subtask A. i The corresponding target tool identifier.

8. The method according to claim 1, characterized in that, The P first tool call requests are tool call requests whose tool type identifier indicates that they are of the engine command type, determined by the server from N tool call requests. The Q second tool call requests are tool call requests whose tool type identifier indicates that they are of the server command type, determined by the server from among the N tool call requests. The tool type identifier is determined by the server by searching within the engine tool set based on the target tool identifier in the tool call request; The Q request results are obtained by the server processing the task based on the processing function of the engine tool corresponding to the target tool identifier in the Q second tool call requests and the request parameters in the Q second tool call requests.

9. The method according to claim 8, characterized in that, The server is also used to create P general generation commands based on the P first tool call requests, and write the P general generation commands into the command execution queue in sequence; The step of obtaining P general generation commands created by the server based on P first tool call requests, and mapping the P general generation commands to the engine agent to obtain P tool execution commands suitable for the target game engine, includes: The engine agent sequentially retrieves general generation commands from the command execution queue of the server; When the general generation command B is retrieved from the command execution queue j At that time, through the adaptation layer in the engine agent, the general generation command B is... j The general parameter set is obtained by parsing; j is a positive integer less than or equal to P; The mapping table for the target game engine in the adaptation layer maps each general parameter in the general parameter set to an engine-recognizable parameter, thus obtaining the engine parameter set; the mapping table is used to indicate the correspondence between the general parameters and the engine-recognizable parameters. According to the data calling format of the target game engine, the engine-recognizable parameters in the engine parameter set are encapsulated to obtain the general generation command B. j The corresponding tool execution command; the general generation command B j The corresponding tool execution commands are applicable to the target game engine.

10. The method according to claim 1, characterized in that, The P tool execution commands include tool execution command C. j j is a positive integer less than or equal to P; the tool executes command C. j For commands used to create entities; Q request results include the tool executing command C j The associated list of entities to be created; Based on the P tool execution commands and Q request results, the engine tools corresponding to the P tool execution commands are invoked from the target game engine to perform task processing and obtain game development data, including: Input the locations of entities to be created from the list of locations to be created into the tool and execute command C. j The entity location field in the code provides the command to be executed by the update tool. The tool is invoked from the target game engine to execute command C. j The corresponding engine tool executes command C through the tool. j The corresponding engine tools and the update tools execute commands to create entities at the locations indicated in the list of entities to be created, thereby obtaining game entity data; the game entity data is used to compose the game development data.

11. The method according to claim 1, characterized in that, The plurality of agents further includes a review agent and a test agent, and the method further includes: The review agent performs tests and verifications on the game development data; the tests and verifications include verification of the rationality of object requirements, verification of parameter integrity, and verification of asset consistency. If at least one of the object requirement rationality verification, parameter integrity verification, and asset consistency verification fails, the game generation requirements will be replanned by the orchestration agent among multiple agents to obtain a new set of game generation tasks until the object requirement rationality verification, parameter integrity verification, and asset consistency verification of the new game development data all pass. If the object requirement rationality verification, parameter integrity verification, and asset consistency verification all pass, then the target game indicated by the game development data will be run through the test agent based on the game development data. If the target game runs normally, the game development data is materialized and stored on disk to obtain the materialized file corresponding to the target game; the materialized file is used to generate the executable program of the target game.

12. The method according to claim 11, characterized in that, The process of materializing and storing the game development data on disk to obtain the materialized file corresponding to the target game includes: Create a standard directory structure; the standard directory structure includes a scene file directory, a script file directory, a resource file directory, an editor state directory, and a context injection directory; The game scene data in the game development data is serialized to obtain structured game scene data, and the structured game scene data is stored in the scene file directory; Based on the script type of each game script in the game development data, each game script is stored in the corresponding subdirectory of the script file directory; The game assets in the game development data are classified according to resource type to obtain classified sub-assets, and the classified sub-assets are stored in the corresponding sub-directories of the resource file directory. Store the game editing status from the game development data to the editor status directory; The resource summary in the game development data is stored in the context injection directory, and the scene file directory, script file directory, resource file directory, editor state directory and context injection directory in the standard directory structure are identified as the materialized files corresponding to the target game.

13. A game generation device, characterized in that, The device includes: The requirement elicitation module is used to obtain game generation requirements in natural language format. The task generation module is used to parse the game generation requirements through an orchestration agent among multiple agents to obtain a set of game generation tasks; the set of game generation tasks includes M generation tasks; M is a positive integer. An engine determination module is used to determine, based on the orchestration agent and the game generation requirements, a target game engine for the game generation requirements from one or more game engines associated with the engine agent among the plurality of agents; the target game engine has registered engine tools for implementing each generation task, the engine tools are obtained by abstracting and integrating the operation functions provided by the target game engine, and the engine tools are used to simulate the execution of the operation functions; The request creation module is used to create N tool invocation requests for the M generation tasks through the orchestration agent, and send the N tool invocation requests to the server; a tool invocation request is determined by a subtask in a generation task and a target tool identifier corresponding to the subtask; N is a positive integer greater than or equal to M; a target tool identifier is used to characterize an engine tool; The game generation module is used to obtain P general generation commands created by the server based on P first tool call requests, map the P general generation commands to obtain P tool execution commands applicable to the target game engine through the engine agent, obtain the request results obtained by the server based on Q second tool call requests, and, according to the P tool execution commands and Q request results, call the engine tools corresponding to the P tool execution commands from the target game engine to perform task processing and obtain game development data. The game development data includes game scene data, game scripts, game material resources, game editing status, and resource summaries. The N tool call requests include the P first tool call requests and the Q second tool call requests, where P and Q are positive integers and the sum of P and Q is N.

14. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the method of any one of claims 1 to 12.

15. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program adapted to be loaded and executed by a processor to cause a computer device having the processor to perform the method of any one of claims 1 to 12.

16. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the method of any one of claims 1 to 12.

Images