Intelligent processing method and system of game module

Abstract

The application provides a smart processing method and system of a game module. The method comprises: parsing a game setting file to generate an original internal data logic template and an interface content template; in response to an agent execution instruction, performing legality verification on actual data in an agent execution instruction execution process according to the original internal data logic template, and performing consistency verification on interface performance according to the interface content template; obtaining memory feedback data and interface feedback data after execution of the agent execution instruction, and performing comparison and verification with the original internal data logic template and the interface content template respectively; and outputting an execution result of the agent execution instruction according to the comparison and verification result. The application realizes double cross verification of memory data and interface implementation, solves the problem of dependence on a manufacturer bottom interface, and improves the accuracy and reliability of smart processing of the game module.

Description

Technical Field

[0001] This invention relates to the field of game development technology, and in particular to intelligent processing methods and systems for game modules. Background Technology

[0002] The current agent-based game module processing methods all rely on low-level interfaces provided by manufacturers. Agents can only function effectively when manufacturers open their raw interfaces. Meanwhile, related agent-aiding tools (such as OpenClaw and Antigravity) primarily focus on code writing assistance, lacking agent executors for the actual execution process of game modules, making it difficult to complete specific in-game tasks. Furthermore, these solutions typically determine success solely through interface feedback, neglecting actual changes in internal game memory data. Since the correctness of game logic is reflected in both the interface and changes in memory data, relying solely on interface feedback can easily lead to inaccurate judgments and incorrect test results. Summary of the Invention

[0003] The technical problem to be solved by this invention is to provide an intelligent processing method and system for game modules, which can realize dual verification of memory data and interface feedback, thereby improving the accuracy of game module testing.

[0004] To solve the above-mentioned technical problems, the technical solution adopted by the present invention is as follows: A method for intelligent processing of game modules, characterized by comprising: Parse the game settings file to generate the original internal data logic template and interface content template; In response to the intelligent agent's execution command, the legality of the actual data during the execution of the intelligent agent's execution command is verified according to the original internal data logic template, and the consistency of the interface performance is verified according to the interface content template. Obtain the memory feedback data and interface feedback data after the intelligent agent executes the instruction, and compare and verify them with the original internal data logic template and the interface content template, respectively. Based on the comparison and verification results, the execution results are output.

[0005] To solve the above-mentioned technical problems, another technical solution adopted by the present invention is as follows: An intelligent processing system for a game module includes a memory, a processor, and a computer program stored in the memory and executable on the processor. The system is characterized in that the processor executes the computer program to implement the various steps of the aforementioned intelligent processing method for a game module.

[0006] The beneficial effects of this invention are as follows: By parsing the game setting file to generate original internal data logic templates and interface content templates, the game settings are structured, providing a recognizable execution basis for the intelligent agent. This solves the problem of relying on the manufacturer's underlying interface to achieve intelligent agent operation in related technologies, thus lowering the access threshold. During the execution of instructions by the intelligent agent, verification is performed based on the original internal data logic templates and interface content templates, enabling real-time monitoring of the execution process. Furthermore, memory feedback data and interface feedback data after failure are obtained and compared with the two templates respectively, forming a dual-protection mechanism. This solution can simultaneously perform cross-verification of memory and interface, accurately identifying false verification success situations such as successful interface display but unchanged memory data. Finally, the execution result is output based on the comparison and verification results, providing a complete execution loop for the intelligent agent. This effectively avoids misjudgments caused by single-dimensional verification, improving the accuracy and reliability of intelligent processing in the game module. Attached Figure Description

[0007] Figure 1 This is a flowchart illustrating an intelligent processing method for a game module according to an embodiment of the present invention; Figure 2 This is a schematic diagram of the game content creation process according to an embodiment of the present invention; Figure 3 This is a schematic diagram of an AI Agent execution template construction process according to an embodiment of the present invention; Figure 4 This is a schematic diagram of an intelligent processing system for a game module according to an embodiment of the present invention. Detailed Implementation

[0008] To explain in detail the technical content, objectives, and effects of the present invention, the following description is provided in conjunction with the embodiments and accompanying drawings.

[0009] In existing technologies, agent-assisted tools such as OpenClaw and Antigravity primarily focus on code writing assistance, lacking agent executors specifically designed for the actual execution process of game modules, making it difficult to complete specific in-game tasks. Furthermore, related solutions typically determine the success of agent instruction execution solely through interface feedback such as pop-up prompts and interface changes, neglecting actual changes in internal game memory data. Since the correctness of game logic is reflected both in interface presentation and in real changes in memory data, relying solely on interface feedback can easily lead to false verification results—the interface displays success while memory data remains unchanged—resulting in inaccurate test results that fail to accurately reflect the execution status of agent instructions.

[0010] To at least address the aforementioned issues, the game's configuration file is parsed to construct original internal data logic templates and interface content templates. When the agent receives a task, during task execution, the internal data templates are used to check the validity of the actual data, while the interface content templates are used to check the consistency of the interface presentation. After the task is completed, memory feedback data and interface feedback data are acquired and compared with the two templates respectively. Finally, based on the verification results, the success or failure of the task is output. This approach achieves dual cross-verification of memory data and interface display, providing the agent with complete execution capabilities without relying on the manufacturer's underlying interfaces. It also solves the problem of false verification and misjudgment caused by relying solely on interface feedback in existing technologies, improving the accuracy and reliability of the game module's intelligent processing.

[0011] The following describes in detail an intelligent processing method for a game module according to the present invention. Please refer to [link / reference]. Figure 1 The method 100 includes steps 110 to 140.

[0012] Step 110: Parse the game settings file to generate the original internal data logic template and interface content template.

[0013] For example, the system reads the game settings file, extracts the change rules and value ranges of each data object in the module, and constructs the original internal data logic template; at the same time, it extracts the display rules of pop-up content, icon status, etc. in the interface interaction and constructs the interface content template.

[0014] Step 120: In response to the agent's execution instruction, perform legality verification on the actual data during the execution of the agent's execution instruction based on the original internal data logic template, and perform consistency verification on the interface presentation based on the interface content template.

[0015] For example, after receiving the instruction "Purchase 10 healing potions," the agent is required to complete operations such as selecting items, entering quantities, confirming purchase, deducting gold coins, and adding items in the shop module. During execution, the system monitors in real time the changes in the gold coin value in memory from 1000 to 900 and the item quantity from 0 to 10, comparing them with the preset "gold coins deducted by 100" and "potions added by 10" in the internal data logic template to verify the legality of the data changes; at the same time, it monitors whether a "purchase successful" prompt pops up on the interface, whether the purchase button turns gray, and whether the inventory quantity is displayed as 10, comparing them with the preset expected performance in the interface content template to verify whether the interface display is consistent.

[0016] Step 130: Obtain the memory feedback data and interface feedback data after the intelligent agent executes the instructions, and compare and verify them with the original internal data logic template and interface content template, respectively.

[0017] For example, after the instruction is executed, the system obtains the final data state in memory as memory feedback data and compares it with the internal data logic template; at the same time, it obtains the final display state on the interface as interface feedback data and compares it with the interface content template.

[0018] Step 140: Based on the comparison and verification results, output the execution results of the intelligent agent's execution instructions.

[0019] For example, if the memory feedback data matches the internal data logic template and the interface feedback data matches the interface content template, the system outputs "execution successful"; otherwise, it outputs "execution failed" and can output corresponding exception information based on the failure type.

[0020] As described above, by parsing the game setting file to generate original internal data logic templates and interface content templates, the game settings are structured, providing a recognizable execution basis for the intelligent agent. This solves the problem of relying on the manufacturer's underlying interface to achieve intelligent agent operation in related technologies, lowering the access threshold. During the execution of instructions by the intelligent agent, verification is performed based on the original internal data logic templates and interface content templates, enabling real-time monitoring of the execution process. Furthermore, the memory feedback data and interface feedback data after execution are obtained and compared with the two templates respectively, forming a dual-protection mechanism. This solution can simultaneously perform cross-verification of memory and interface, accurately identifying false verification scenarios such as successful interface display but unchanged memory data. Finally, the execution result is output based on the comparison and verification results, providing a complete execution loop for the intelligent agent, effectively avoiding misjudgments caused by single-dimensional verification, and improving the accuracy and reliability of intelligent processing in the game module.

[0021] In one alternative implementation, step 110 includes steps 111 and 112.

[0022] Step 111: Parse the game setting file, obtain the module content data of the target game module, perform structured processing on the module content data, and obtain the original internal data logic template.

[0023] For example, the system reads the character attribute configuration file of the game, extracts data objects such as health points, gold coins, and experience points, establishes the relationship between each data object, such as "the amount of gold coins reduced when purchasing an item corresponds to the item price", and "the quantity of an item decreases by one when using an item", and stores it using a binary tree or key-value pair data structure to form a standardized internal data logic template that can be recognized and compared by the intelligent agent.

[0024] Step 112: Obtain the design data of the target game module, format and store the design data, and extract the interaction performance information from the design data to obtain the interface content template.

[0025] For example, the system reads the game interface's design configuration file, extracts the pop-up text content when a purchase is successful, the changing state of the backpack icon, the rules for enabling and disabling buttons, and other interactive information, and stores it in a formatted dictionary or structured document to form an interface content template for verifying whether the interface display is correct.

[0026] As described above, by structuring the module content data, the original game settings are transformed into a standardized data structure that the intelligent agent can recognize, providing a quantifiable comparison benchmark for subsequent legality verification. Furthermore, by formatting and storing the design data and extracting interaction performance information, a standardized comparison basis is provided for interface consistency verification. These two templates, while independent, work collaboratively to form a dual verification foundation for the intelligent agent's execution instructions, ensuring that subsequent verification steps have both internal logic to rely on and external performance to verify.

[0027] In one optional implementation, step 120 verifies the legality of the actual data during the execution of instructions by the agent based on the original internal data logic template, including steps 121 and 122.

[0028] Step 121: Obtain the internal memory data generated during the execution of instructions by the intelligent agent, and compare the internal memory data with the pre-stored structured processing results in the original internal data logic template.

[0029] For example, when an agent executes the instruction to "purchase healing potions", the system reads the change data of gold coins and the change data of item quantity from memory in real time, and compares them item by item with the preset "gold coins decrease by 100" and "item quantity increase by 1" in the original internal data logic template to determine whether the actual change meets expectations.

[0030] Step 122: If the comparison matches, the validity check is deemed to have passed; otherwise, the validity check is deemed to have failed.

[0031] For example, if the amount of gold coins in memory decreases by 100 while the number of items increases by 1, the validity check is considered to have passed, indicating that the internal data logic is correct; if the amount of gold coins decreases is inconsistent or the number of items does not change, the validity check is considered to have failed, indicating that there is an internal data anomaly in the instruction execution.

[0032] As described above, by acquiring real-time memory data during instruction execution and comparing it with the pre-stored structured processing results in the template, dynamic monitoring of the agent's instruction execution process is achieved, enabling timely detection of whether changes in memory data conform to preset logic. By clearly determining whether the legality verification passes or fails based on the comparison results, an internal dimension judgment basis is provided for subsequent dual comparison verification. This mechanism eliminates reliance on feedback from the manufacturer's interface for internal data logic verification, instead relying on a self-constructed structured template, thus improving the independence and accuracy of the verification. In one optional implementation, step 120 performs a consistency check on the interface presentation based on the interface content template, including steps 123 and 124.

[0033] Step 123: Obtain the interface display data generated during the execution of instructions by the intelligent agent, and compare the interface display data with the interaction performance information pre-stored in the interface content template.

[0034] For example, when the agent executes the command "purchase healing potion", the system captures the interface display data such as pop-up prompts, button state changes, and backpack icon refresh from the interface layer in real time, and compares them item by item with the preset "display purchase success pop-up", "purchase button turns gray", and "the number of items in the backpack increases accordingly" in the interface content template to determine whether the actual performance of the interface meets expectations.

[0035] Step 124: If the comparison is consistent, the consistency check is considered passed; otherwise, the consistency check is considered failed.

[0036] For example, if the interface displays a "Purchase Successful" message, the purchase button becomes unavailable, and the number of item icons in the backpack increases correctly, the consistency check is considered to have passed, indicating that the interface is behaving correctly. If the interface displays success but the number of items in the backpack does not change, or the pop-up content does not match expectations, the consistency check is considered to have failed, indicating that there is an abnormality in the interface behavior during command execution.

[0037] As described above, by acquiring real-time interface display data during instruction execution and comparing it with pre-stored interaction performance information in the template, real-time monitoring of the agent's instruction execution process at the appearance level is achieved, enabling timely detection of whether the interface display conforms to preset rules. By clearly determining whether the consistency check passes or fails based on the comparison results, an external dimension of judgment is provided for subsequent dual comparison checks. This mechanism allows interface performance verification to move beyond simple pop-up window judgments, instead relying on a self-constructed interaction performance template, achieving refined verification of the interface display content and effectively avoiding the uncertainty caused by subjective visual judgment alone.

[0038] In one optional implementation, step 130 compares and verifies the original internal data logic template and the interface content template, respectively, including step 131.

[0039] Step 131: Obtain the verification results of the legality verification and the consistency verification. When the legality verification passes and the consistency verification passes, the verification result is determined to be a successful comparison verification; otherwise, the verification result is a failed comparison verification.

[0040] For example, when the agent executes the "purchase healing potion" command, the system obtains the validity check result output in step 122 (e.g., "validity check passed") and the consistency check result output in step 124 (e.g., "consistency check passed"). Since both are passed, the final check result is determined to be a successful comparison check, indicating that the command was executed correctly in both internal data logic and interface presentation. If the validity check result is a failure (e.g., incorrect deduction of gold coins), or the consistency check result is a failure (e.g., the pop-up content does not match expectations), the check result is determined to be a failed comparison check, indicating an anomaly in the command execution. As described above, by comprehensively considering the results of both legality and consistency checks, the final comparison check is deemed successful only if both are simultaneously satisfied; otherwise, it is deemed unsuccessful. This achieves a comprehensive evaluation of the agent's instruction execution results. This mechanism differs from traditional solutions that rely on a single dimension (such as an interface pop-up) for judgment, effectively avoiding misjudgments caused by one-sided situations such as "the interface displays success but the memory data remains unchanged." Instruction execution is only considered successful when both internal data logic and external interface performance meet expectations, thus providing a reliable double guarantee for subsequent output of execution results and improving the rigor and accuracy of the judgment.

[0041] In one alternative implementation, step 140 includes step 141.

[0042] Step 141: When the memory feedback data passes the validity check and the interface feedback data passes the consistency check, the execution result is output as execution success; otherwise, the execution result is output as execution failure.

[0043] For example, when an agent executes the command "purchase healing potion," if the validity check passes (e.g., 100 gold coins are deducted from memory and the item quantity increases by 1) and the consistency check passes (e.g., a "purchase successful" pop-up appears on the screen and the item quantity is displayed correctly in the inventory), the system outputs "execution successful" and can trigger subsequent tasks or provide feedback to the user. If the validity check fails (e.g., the amount of gold coins deducted is incorrect) or the consistency check fails (e.g., the pop-up does not appear), the system outputs "execution failed," and can include a failure reason identifier, such as "insufficient gold coins," "item does not exist," or "interface response timed out," so that the agent or user can take appropriate action.

[0044] As described above, by using the final results of legality and consistency checks as the output basis, the instruction is considered successfully executed only if both pass; otherwise, it is considered a failure. This provides the agent with clear and explicit feedback on the execution result. This mechanism allows the agent to accurately determine whether the instruction has truly been executed successfully, avoiding the drawback of traditional solutions where the interface displays success and mistakenly concludes that the instruction has been completed. Furthermore, the failure reason identifier output when execution fails provides a valid basis for subsequent exception handling, instruction retry, or user prompts, forming a complete closed loop for agent instruction execution.

[0045] In an alternative implementation, the method further includes steps 150 and 151.

[0046] Step 150: Create natural language event types for the game module, obtain the preset logical information of the target game module and extract the logical structure, bind the natural language event types with the logical structure, and generate a set of natural language events.

[0047] For example, create a natural language event type called "Purchase Items" for the "Mall Purchase" module, obtain the module's preset logical information such as "Check if there are enough coins before purchasing", "Deduct the corresponding coins and add the corresponding items after purchasing", and "Purchase success prompt pops up on the interface", obtain the logical structure through training or rule extraction, bind the "Purchase Items" event type with the above logical structure, and generate a set of natural language events containing the mapping relationship between event types and logical structures.

[0048] Step 151: In response to natural language input, determine whether the natural language input matches the set of natural language events. If it matches, generate the execution instruction of the target intelligent agent corresponding to the natural language event.

[0049] For example, if a user inputs the natural language command "Buy me 10 healing potions," the system performs semantic analysis on the input, extracting the keywords "buy," "healing potion," and "10," and matching them with event types in the natural language event set. Since the "buy item" event type is matched, the system automatically generates the corresponding target agent to execute instructions based on the bound logical structure, such as "Execute the purchase operation, the item is a healing potion, the quantity is 10, check if there are enough gold coins, and update the memory and interface after completion."

[0050] As described above, by structuring the preset logical information of the game module and binding it with natural language event types, a mapping bridge from natural language to executable instructions is constructed. Through semantic matching of natural language input, corresponding execution instructions for the target intelligent agent are automatically generated, enabling users to interact with the game module in a convenient way using natural language. This mechanism allows users to trigger the intelligent agent to perform corresponding operations simply by inputting everyday language commands, without needing to understand the details of the underlying interface calls. This significantly lowers the barrier to entry for intelligent processing in the game module, while ensuring that the generated instructions have a complete logical structure and verification basis. In one alternative implementation, after step 110 generates the original internal data logic template, steps 1101 and 1102 are also included.

[0051] Step 1101: Obtain the flow content of the target game module, construct execution condition information based on the flow content, and associate the execution condition information with the original internal data logic template.

[0052] For example, for the "Mall Purchase" module, we obtain its process content, such as "you must first select an item, then confirm the purchase, and finally complete the payment and delivery." Based on this process content, we construct execution condition information, including sequential constraints such as "the item selection operation must be performed before the purchase confirmation" and "the payment operation must be performed before delivery." We then associate this execution condition information with the original internal data logic template to form a data logic structure with process constraints.

[0053] In step 1102, during the legality verification, the execution order of the intelligent agent's execution instructions is also verified according to the execution condition information to see if it meets the preset conditions.

[0054] For example, when an agent receives the instruction to "purchase healing potion," the legality verification process not only checks the legality of changes in memory data but also verifies the correctness of the instruction execution order based on the execution condition information. If the agent performs the deduction operation first but does not record the item selection operation, it is determined that the execution order does not meet the preset conditions, the legality verification fails, and the message "Execution order abnormal: deduction performed without item selection" is displayed.

[0055] As described above, by acquiring the flow content of the game module and constructing execution condition information, the flow constraints are associated with the original internal data logic template. This ensures that the template includes not only data logic relationships but also execution order constraints. By simultaneously verifying whether the execution order conforms to preset conditions during legality checks, a standardized check of the agent's instruction execution flow is achieved. This mechanism can effectively detect logical problems such as incorrect ordering and missing preconditions during instruction execution, further enriching the dimensions of legality checks and improving the rigor and reliability of the agent's execution process.

[0056] In one alternative implementation, step 120 further includes step 1201 before the agent executes the instruction.

[0057] Step 1201: Generate a set of interfaces for the agent to call. When an execution instruction is received from the agent, the corresponding operation is executed by calling the set of interfaces.

[0058] For example, the system pre-encapsulates the underlying functions of the game module, such as "check gold coin quantity" and "deduct gold coins," generating a corresponding set of interfaces for the agent to call. When the agent receives the execution instruction to "purchase healing potions," the system sequentially calls interfaces such as "check if gold coins are sufficient" and "deduct 100 gold coins" from the interface set according to the instruction logic to complete the entire purchase operation. Each interface call returns a corresponding execution status code; 0 for success and a corresponding error code for failure, such as "1" indicating insufficient gold coins and "2" indicating the item does not exist.

[0059] As described above, by pre-generating a set of interfaces for the agent to call, the underlying functions of the game module are abstracted into standardized calling interfaces, providing reusable functional units for the execution of agent instructions. When an agent executes an instruction, the system completes the specific operation by sequentially calling the relevant interfaces in the interface set, thus decoupling the instruction logic from the underlying implementation. This mechanism allows the agent to complete the task without needing to concern itself with the specific implementation details of the underlying functions; it only needs to call the corresponding interfaces according to the instruction logic, reducing the complexity of the agent and improving the reusability and maintainability of the interfaces. Furthermore, the status codes returned by the interfaces provide a reliable data source for subsequent legality checks and result judgments.

[0060] Please refer to Figure 2 This invention can apply the above-mentioned solution to intelligent processing scenarios in game modules, particularly to automated game testing and intelligent agent-assisted operation scenarios that require combining internal data logic verification and interface performance verification. This includes steps S201 to S206.

[0061] S201. Obtain the identification information, configuration parameters, and operating rules of the target game module, and extract specific settings such as module title, function description, and data field definitions as the raw input for subsequent processing. This is equivalent to step 110 above.

[0062] S202. Decompose the obtained settings and establish the relationships between various data objects, such as "purchase operation corresponds to gold coin deduction" and "use of props corresponds to reduction in item quantity". Store the data using a binary tree or chart data structure and establish searchable tags to obtain the original internal data logic template. This is equivalent to step 111 above.

[0063] S203. Obtain the presentation layer information and interaction type of the target game module, such as "trading module," "movement module," "dialogue module," and "combat module." Different types of modules correspond to different verification rules and verification focuses. For example, trading modules focus on verifying the correctness of data additions and subtractions, while movement modules focus on verifying the legality of coordinate changes. Simultaneously, identify the data change rules and interface response rules involved in the module's interaction process to provide a type basis for subsequent dual verification. This is equivalent to the operation of obtaining module information and identifying module types in step 112 above.

[0064] S204. Read the planning or design data file corresponding to the game module. This file stores the module's parameters and rules in the form of a dictionary, table, or structured document. Parse the parameters, extracting them in the order of data structure, data type, and data value, using a binary tree to represent the parameter data storage structure. Simultaneously, obtain text content such as pop-up prompts and error messages from the interface interaction, as well as interface change information such as button states, icon refreshes, and panel pop-ups. Format and store this information to obtain the interface content template. This is equivalent to the operation in step 112 above: obtaining planning data, parsing and setting parameters, and extracting interactive performance information to obtain the interface content template.

[0065] S205. Based on the generated original internal data logic template and interface content template, create specific verification content and execution logic. Encapsulate the underlying functional interfaces, write script files for the agent to call, and generate an interface set including data query interfaces, operation execution interfaces, status feedback interfaces, etc. Simultaneously, design the interactive page logic during the agent's command execution process, including the command input parsing method, the execution progress display method, and the execution result feedback method. This is equivalent to step 1201 above.

[0066] S206. Perform functional testing on the generated templates, interfaces, and scripts to verify the correctness of the legality and consistency checks, ensuring that the dual comparison mechanism can accurately identify abnormal situations, such as whether it can correctly determine failure when the test interface displays success but the memory data does not change. Based on the test results, optimize the performance of the verification logic and interface calls to reduce the time overhead and resource consumption during the verification process, and improve the response speed of the intelligent agent's instruction execution and the system throughput. This is equivalent to steps 120 to 140 above.

[0067] Through the above steps, the present invention is based on Figure 2The game content creation process shown first involves parsing the game setting file and constructing it into a raw internal data logic template. Next, module information and design data are processed into interface content templates. Then, the underlying interfaces are encapsulated to generate an intelligent agent call set. Finally, the dual verification mechanism is verified and optimized, forming a complete pre-execution preparation chain for intelligent agents. This process lays the data and calling foundation for subsequent intelligent agent instruction execution, process dual verification, result dual comparison, and execution result output.

[0068] Please refer to Figure 3 Furthermore, the present invention can also be applied to the construction of AI Agent execution templates, particularly to the automated processing of game modules that require standardized execution processes and logical constraints for intelligent agents. This includes steps S301 to S304.

[0069] S301. Obtain the identification information, configuration parameters, and operating rules of the target game module, and extract specific settings such as module title, function description, data field definition, and operation type as raw materials for subsequent decomposition and relationship establishment. This is equivalent to obtaining the basic information and settings of the target game module in step 110.

[0070] S302. Decompose the obtained settings and establish the relationships between various data objects, such as "purchase operation corresponds to gold coin deduction" and "attack operation corresponds to health reduction". Store the data using a binary tree or chart data structure, and create a searchable label for each data object or data relationship to obtain the original internal data logic template. This is equivalent to step 111.

[0071] S303. Obtain the execution flow information of the target game module, and extract the specific flow requirements, such as "select items before purchasing" and "verify sufficient gold coins before confirming purchase," to provide the flow data foundation and node conditions for subsequent construction of the execution flow tree. This is equivalent to the operation in step 1101 of constructing execution condition information and associating it with the original internal data logic template.

[0072] S304. Construct an execution flow tree based on the obtained module flow content. The nodes of this flow tree represent execution steps or conditional judgments, and the edges represent the flow relationships between steps. Associate the execution flow tree with the original internal data logic template to form a data execution tree with execution conditions. This is equivalent to the operation in step 1101 of constructing execution condition information and associating it with the original internal data logic template.

[0073] Through the above steps, this invention obtains game modules and their settings, establishes relationships between data objects, and forms an original internal data logic template. By obtaining module flows and their contents, it constructs an execution flow tree and associates it with the data template, forming a data execution tree with execution constraints. This template provides standardized execution flows and logical constraints for the intelligent agent, enabling it to follow preset execution orders and preconditions when executing instructions. This effectively avoids logical problems such as incorrect execution order and missing preconditions, improving the standardization and success rate of the intelligent agent's execution.

[0074] Please refer to Figure 4 The present invention also provides an intelligent processing system 400 for a game module, including a memory 401, a processor 402, and a computer program stored in the memory 401 and executable on the processor 402. When the processor executes the computer program, it implements the various steps of the intelligent processing method for a game module as described above.

[0075] In summary, this invention provides an intelligent processing method and system for game modules. By parsing game setting files to construct original internal data logic templates and interface content templates, and combining process verification and result comparison of intelligent agent execution instructions, cross-verification of memory data and interface performance in game module processing is achieved.

[0076] The system first parses the game setting file to obtain the module content data and design data of the target game module. The module content data is then structured, establishing relationships between data objects, stored using binary trees or graph data structures, and tagged with searchable labels to obtain the original internal data logic template. The design data is formatted and stored, extracting the setting text content and interface change information to obtain the interface content template. This dual-template construction mechanism transforms unstructured game settings into structured standards recognizable by the intelligent agent, providing a quantifiable execution basis for subsequent dual verification. This solves the problem of existing technologies relying on manufacturer-level interfaces for intelligent agent operation, lowering the barrier to entry.

[0077] During the execution of instructions by the intelligent agent, the system simultaneously performs legality checks on the actual data based on the original internal data logic template, and consistency checks on the interface presentation based on the interface content template. It acquires internal memory data generated during instruction execution and compares it with the pre-stored structured processing results in the template to verify whether data changes conform to preset logic; simultaneously, it acquires the interface display data and compares it with the pre-stored interactive performance information in the template to verify whether the interface display is correct. This achieves real-time monitoring of the intelligent agent's instruction execution process, enabling timely detection of anomalies during execution.

[0078] After the instruction is executed, the system obtains memory feedback data and interface feedback data, and compares and verifies them with the original internal data logic template and interface content template, respectively. This dual guarantee mechanism forms a cross-verification of the execution result, which can accurately identify the false verification situation where the interface displays successfully but the memory data does not change, effectively avoiding misjudgment caused by single-dimensional verification.

[0079] This invention solves the technical problems of relying on the manufacturer's underlying interface to realize intelligent agent operation and relying solely on interface feedback, which leads to false verification and misjudgment. It improves the accuracy and reliability of intelligent processing of game modules and provides a complete technical solution for game automated testing and intelligent agent-assisted operation.

[0080] The above description is merely an embodiment of the present invention and does not limit the patent scope of the present invention. Any equivalent modifications made based on the content of the present invention specification and drawings, or direct or indirect applications in related technical fields, are similarly included within the patent protection scope of the present invention.

Claims

1. An intelligent processing method for a game module, characterized in that, include: Parse the game settings file to generate the original internal data logic template and interface content template; In response to the intelligent agent's execution command, the legality of the actual data during the execution of the intelligent agent's execution command is verified according to the original internal data logic template, and the consistency of the interface performance is verified according to the interface content template. Obtain the memory feedback data and interface feedback data after the intelligent agent executes the instruction, and compare and verify them with the original internal data logic template and the interface content template, respectively. Based on the comparison and verification results, the execution result of the instructions executed by the intelligent agent is output.

2. The intelligent processing method for a game module according to claim 1, characterized in that, The process of parsing the game settings file generates original internal data logic templates and interface content templates, including: Parse the game setting file to obtain the module content data of the target game module, perform structured processing on the module content data, and obtain the original internal data logic template; The design data of the target game module is obtained, the design data is formatted and stored, and interactive performance information is extracted from the design data to obtain the interface content template.

3. The intelligent processing method for a game module according to claim 1, characterized in that, The step of validating the actual data during the execution of instructions by the intelligent agent based on the original internal data logic template includes: The internal memory data generated during the execution of instructions by the intelligent agent is obtained, and the internal memory data is compared with the structured processing results pre-stored in the original internal data logic template; If the comparison matches, the validity check is considered passed; otherwise, the validity check is considered failed.

4. The intelligent processing method for a game module according to claim 1, characterized in that, The step of performing consistency verification on the interface presentation based on the interface content template includes: The interface display data generated during the execution of the instructions by the intelligent agent is obtained, and the interface display data is compared with the interaction performance information pre-stored in the interface content template. If the comparison is consistent, the consistency check is considered passed; otherwise, the consistency check is considered failed.

5. The intelligent processing method for a game module according to claim 1, characterized in that, The comparison and verification with the original internal data logic template and the interface content template respectively includes: Obtain the verification results of the legality check and the consistency check. When the legality check passes and the consistency check passes, the verification result is determined to be a successful comparison check; otherwise, the verification result is a failed comparison check.

6. The intelligent processing method for a game module according to claim 1, characterized in that, The step of outputting the execution result based on the comparison and verification results includes: When the memory feedback data passes the validity check and the interface feedback data passes the consistency check, the execution result is output as successful; otherwise, the execution result is output as failed.

7. The intelligent processing method for a game module according to claim 1, characterized in that, Also includes: A natural language event type is created for the game module, the preset logical information of the target game module is obtained and the structure is extracted to obtain the logical structure, the natural language event type is bound to the logical structure, and a natural language event set is generated. In response to natural language input, it is determined whether the natural language input matches the set of natural language events. If it does, an execution instruction for the target intelligent agent corresponding to the natural language event is generated.

8. The intelligent processing method for a game module according to claim 1, characterized in that, After generating the original internal data logic template, the process also includes: Obtain the flow content of the target game module, construct execution condition information based on the flow content, and associate the execution condition information with the original internal data logic template; During the legality verification, the execution order of the intelligent agent's execution instructions is also verified according to the execution condition information to see if it meets the preset conditions.

9. The intelligent processing method for a game module according to claim 1, characterized in that, The response prior to the agent executing the instruction also includes: A set of interfaces is generated for the intelligent agent to call. When the intelligent agent executes an instruction, the corresponding operation is performed by calling the set of interfaces.

10. An intelligent processing system for a game module, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements each step of the intelligent processing method for a game module according to any one of claims 1 to 9.

Images