Game function development system and method based on natural language instructions

Abstract

The application discloses a game function development system and method based on natural language instructions, and relates to the technical field of game development.The system comprises a project code library analysis module, a development instruction receiving and analysis module, a function disintegration and code generation module, an automatic integration and debugging module, and a development report generation module.A code dependency relationship graph and API interface are constructed by the project code library analysis module to provide an accurate basis for subsequent development.The development instruction receiving and analysis module converts natural language requirements into structured information to achieve efficient understanding of requirements.The function disintegration and code generation module disassembles requirements and calls a specific engine programming large model to generate standard code, thereby reducing manual coding.The automatic integration and debugging module automatically inserts code and carries out testing according to the graph to quickly identify and repair problems, reduce dependence on professional programmers, shorten the function development cycle to improve efficiency, and reduce compatibility errors caused by manual operation.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of game development, in particular to a game function development system and method based on natural language instructions. BACKGROUND

[0002] Game is an interactive digital product that combines computer science, art design, psychology and other multidisciplinary knowledge. It builds a virtual world through code, simulates real or fictional scenes relying on graphics rendering, physics engine, artificial intelligence technology, and formulates specific rules to guide users to participate (such as battle, puzzle solving, socializing, etc.). From the early text adventure game to today's open-world 3A masterpiece, game has evolved from a simple entertainment tool to a comprehensive carrier integrating entertainment, education, socialization and cultural dissemination. It can provide immersive experience to release stress, cultivate team consciousness through collaborative tasks, and even deliver cultural knowledge through historical theme scenes. It is an important field in the digital age to meet human spiritual needs and promote technological innovation.

[0003] Game function development is a core technical link to support the realization of the above values of game. It refers to the process of designing, coding, integrating and optimizing the functional modules (such as character skill system, task scenario logic, UI interaction interface, multiplayer online mechanism, etc.) that constitute the game in the whole life cycle from game initiation to iteration. Its essence is to transform product requirements into executable code through creative work: for example, designing new skills for characters requires writing damage calculation logic, associating animation effects and cooling mechanism; updating the task system requires configuring scenario branches, reward mechanisms and NPC interaction rules. The significance of game function development lies in that it is the key to the vitality of the game. Through continuous iteration of new functions, the game can respond to player needs, adapt to market changes, and gradually evolve from the initial version to a mature product, while promoting innovation breakthroughs in underlying technologies such as game engine technology and artificial intelligence applications.

[0004] In existing game function development, new functions need to rely on programmers to manually complete code writing, debugging and integration. First, manually design code logic according to requirements, then write corresponding code fragments one by one, then manually insert them into existing code library and debug compatibility, and finally verify function effectiveness through manual testing. However, this existing method has the problems of low development efficiency and high dependence on manpower when developing game functions, and is prone to compatibility errors in the process of writing and integrating, which seriously affects the iteration progress and quality of game projects. Therefore, it is of great significance to develop a game function development system and method based on natural language instructions. SUMMARY

[0005] The purpose of the present application is to make up for the shortcomings of the prior art, and provide a game function development system and method based on natural language instructions, which can solve the problem of low development efficiency, high manpower dependence and easy introduction of compatibility errors caused by the need for programmers to manually write, debug and integrate code for new functions in the iteration of existing game projects.

[0006] To solve the above technical problems, the present application provides the following technical solutions: a game function development system and method based on natural language instructions, which comprises: a project code library analysis module, a development instruction receiving and analysis module, a function decomposition and code generation module, an automatic integration and debugging module, and a development report generation module.

[0007] The project code library analysis module is used to perform static and dynamic analysis on the existing code library of a target game project, construct a code dependency graph, and identify the API interface and data structure of the core function module.

[0008] The development instruction receiving and analysis module is used to receive the new function requirements in the form of natural language input by the developer, and analyze the requirements.

[0009] The function decomposition and code generation module is used to decompose the analyzed high-level function requirements into specific programming tasks, and call a programming large model for a specific game engine to generate function code segments that meet the project code specifications.

[0010] The automatic integration and debugging module is used to automatically insert the generated code segments into the correct position of the code library, simulate the compilation and running environment, perform automatic unit testing and regression testing, identify and preliminarily repair potential bugs and compatibility conflicts.

[0011] The development report generation module is used to output a development report containing new function code, test results and integration instructions for the developer to confirm and merge.

[0012] Further, the project code library analysis module, when performing static analysis, specifically includes syntax checking, structure analysis, comment extraction and code style recognition of the code, and when performing dynamic analysis, tracks the function call chain, data input / output relationship and memory occupancy changes during code runtime to construct a multi-dimensional code dependency graph, wherein the module dependency strength calculation uses the formula: Wherein, is the dependency strength of module and module . the number of the frequency of occurrence of the interaction behavior (such as function call, data transmission) of the same type, the number of the weight of the interaction behavior of the same type, , the code size (in terms of the number of functions) of the module , ,

[0013] Further, when the development instruction receiving and parsing module parses the natural language requirement, a pre-trained natural language understanding model is used to extract the function subject, function type, parameter threshold, and associated object information, and convert them into structured data containing entity-attribute-relation. The confidence level of key information extraction is calculated using: wherein, is the extraction confidence of the key information, is the output score of the model for the information, is the total number of candidate information, is the context association length (in words) of the information in the instruction, is the context influence coefficient.

[0014] Further, when the function deconstruction and code generation module deconstructs the high-level function requirement, it refers to the pre-set game function componentization disassembly rule library, maps the requirement to an atomic programming task, and the generated code segment contains standardized annotations and version control identifiers.

[0015] Further, before inserting the code segment, the automatic integration and debugging module performs conflict prediction based on the code dependency graph, and when determining the insertion position, it preferentially selects a low-coupling code region. The unit test covers the input boundary value, abnormal scenario, and normal function flow, wherein the code insertion adaptation degree evaluation formula is: wherein, is the code insertion adaptation degree of the position, is the module coupling degree of the position, is the relevance score of the position and the requirement function, is the code modification history frequency of the position, , , are weight coefficients and .

[0016] Further, the regression test of the automatic integration and debugging module includes call link detection of existing core function modules. When the detection shows that the call frequency of the new code to the original API interface exceeds the pre-set threshold, compatibility deep checking is triggered.

[0017] Further, in the report output by the development report generation module, the new function code is classified and displayed according to function modules, the test result includes test case coverage, bug repair rate and compatibility conflict position identification, and the integration description clearly indicates the code insertion path and the influence range of the associated module.

[0018] The game function development method based on natural language instructions is suitable for the game function development system based on natural language instructions, and comprises the following steps:

[0019] Performing static and dynamic analysis on the existing code library of the target game project, constructing a code dependency graph, and identifying the API interface and data structure of the core function module;

[0020] Receiving a new function requirement in the form of natural language and parsing;

[0021] Disassembling the parsed high-level function requirement into specific programming tasks, calling a programming large model for a specific game engine to generate a function code segment conforming to the project code specification;

[0022] Automatically inserting the code segment into the correct position of the code library, simulating the compilation and running environment, performing automated testing and repairing potential problems;

[0023] Outputting a development report containing new function code, test results and integration description for developers to confirm and merge.

[0024] Further, when performing automated testing, first, unit test the generated code segment, then, select the affected original function module for regression test in combination with the code dependency graph, repair the identified bugs and compatibility conflicts according to the severity level, preferentially repair blocking errors, and record non-blocking errors for subsequent processing by the developer.

[0025] Compared with the prior art, the game function development system and method based on natural language instructions have the following beneficial effects:

[0026] The code dependency graph constructed by the project code library analysis module and the identified API interface provide an accurate basis for subsequent development, the development instruction receiving and parsing module converts natural language requirements into structured information, realizes efficient understanding of requirements, the function disassembly and code generation module disassembles requirements and calls a specific engine programming large model to generate standard code, reduces manual coding, the automatic integration and debugging module automatically inserts codes and carries out automated testing according to the graph, quickly identifies and repairs problems, through the series of technical solutions, the dependence on professional programmers is reduced, the function development cycle is shortened to improve efficiency, compatibility errors caused by manual operation are reduced, and the stability of game project iteration is ensured.

[0027] Additional advantages, objects, and features of the application will be apparent to those skilled in the art upon examination of the following detailed description, it being understood that each of the foregoing general statements are intended to be illustrative only and not limiting of the scope of the present application. BRIEF DESCRIPTION OF DRAWINGS

[0028] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the following will briefly introduce the drawings needed to be used in the embodiments or prior art description. Obviously, the drawings in the following description are only some embodiments of the present application, and for those skilled in the art, other drawings can also be obtained from these drawings without creative labor.

[0029] Figure 1 Structure diagram of the game function development system based on natural language instructions;

[0030] Figure 2 Flowchart of the game function development method based on natural language instructions. DETAILED DESCRIPTION

[0031] In order to further illustrate the technical means and effects adopted by the present application to achieve the predetermined invention purposes, the specific embodiments, structures, features and effects according to the present application will be described in detail below in combination with the drawings and preferred embodiments.

[0032] The game function development system based on natural language instructions disclosed by the present application aims to reduce the dependence of game function development on professional programmers through automatic and intelligent technical means, improve the development efficiency and reduce compatibility errors, see Figure 1 The system specifically includes the following modules:

[0033] The project code library analysis module is mainly responsible for comprehensive analysis of the existing code library of the target game project, specifically covering static analysis and dynamic analysis; during static analysis, syntax checking, structure analysis, comment extraction and code style recognition of the code are carried out, so as to deeply understand the static characteristics of the code; during dynamic analysis, the function call chain, data input and output relationship and memory occupation change in the code running process are tracked, a multi-dimensional code dependency graph is constructed in combination with the static analysis result, and the API interface and data structure of the core function module are identified, laying a precise foundation for subsequent development work.

[0034] The core function of the development instruction receiving and parsing module is to receive the new function requirements input by the developer in natural language form and parse the requirements. During the parsing process, a pre-trained natural language understanding model is used to extract key information such as function subject, function type, parameter threshold, and associated objects from the natural language requirements. The extracted information is converted into structured data containing entity-attribute-relationship, realizing efficient and accurate understanding of the developer's requirements.

[0035] The function deconstruction and code generation module is committed to converting the parsed high-level function requirements into executable code snippets. The specific operations are as follows: referring to the pre-set game function componentization disassembly rule library, the parsed high-level function requirements are deconstructed into specific, atomic programming tasks; calling a programming large model oriented to a specific game engine, generating function code snippets that meet the project code specifications according to the deconstructed programming tasks, and the generated code snippets contain standardized comments and version control identifiers, facilitating subsequent management and maintenance.

[0036] The automatic integration and debugging module is responsible for smoothly integrating the generated code snippets into the existing code library and debugging to ensure the stability of the functions. Specifically, before inserting the code snippets, conflict prediction is performed according to the code dependency graph to determine the insertion position, and low-coupling code areas are preferentially selected to reduce conflict risks; after automatically inserting the generated code snippets into the correct position of the code library, the simulation of the compilation and running environment is performed, and automatic unit testing and regression testing are executed; among them, the unit testing covers input boundary values, abnormal scenarios, and normal function processes; the regression testing includes the detection of the calling link of the existing core function modules, and when the calling frequency of the new code to the original API interface exceeds the pre-set threshold, compatibility deep checking is triggered; potential bugs and compatibility conflicts are identified and preliminarily repaired, and the repair is prioritized according to the severity, with blocking errors being repaired first and non-blocking errors being recorded for subsequent processing by the developer.

[0037] The main function of the development report generation module is to output the development report to provide clear and comprehensive development information for the developer, including: new function code, classified display by function module; test results, including test case coverage, bug repair rate, and compatibility conflict position identification; integration instructions, specifying the code insertion path and the influence range of associated modules.

[0038] Through the cooperative work of the above modules, the system realizes the full-process automatic processing from natural language requirement input to function code generation, integration, debugging, and report output, effectively improving the efficiency and quality of game function development.

[0039] Embodiment One

[0040] This embodiment applies to the development of new features in a massively multiplayer online role-playing game (MMORPG). It completes the entire development process of new skill functions based on natural language commands input by the developer. Through the system and method of this invention, the process from natural language requirements to integrable code is automated, eliminating the need for developers to manually write large amounts of code and efficiently completing the development and integration of new features. See [link to related documentation]. Figure 1 and Figure 2 The specific implementation process of this embodiment is as follows:

[0041] The project codebase parsing module performs syntax checks on the existing codebase of the target game project to ensure that the code conforms to the syntax specifications specified by the project; it analyzes the code hierarchy of the core modules through structural analysis; it extracts functional descriptions from the comments of each module; it identifies code style and determines the specifications for variable naming, function comments, etc.; it runs the game and simulates the execution flow of existing functions to trace the function call chain; it records data input and output relationships; and it monitors changes in memory usage to determine the peak memory range of the core modules during high-frequency calls.

[0042] A code dependency graph is constructed and API interfaces are identified. Combining static and dynamic analysis results, a multi-dimensional dependency graph is built, where the dependency strength between modules is determined by the formula... Calculate, where The frequency of interactions between modules. As the weight of this type of interaction behavior, and The number of functions in each module is counted; the core API interfaces and key data structures are also identified.

[0043] The development instruction receiving and parsing module receives new feature requirements in natural language form from developers. The parsing process uses a pre-trained natural language understanding model to extract key information, including the main function, function type, parameter thresholds, and associated objects.

[0044] Calculate the confidence score for key information extraction using the formula. ,in The model outputs a score for this information. The total number of candidate messages. The length of the context associated with this information in the instruction. The context influence coefficient is used to ultimately transform the extracted information into structured data containing entity-attribute-relationship.

[0045] The function deconstruction and code generation module refers to a preset game function componentization disassembly rule library, maps the parsed high-level function requirement to an atomic-level programming task, calls a programming large model oriented to a specific game engine, generates a function code segment conforming to a project code specification according to the deconstructed programming task, and the generated code segment contains standardized comments and version control identifiers.

[0046] The automatic integration and debugging module performs conflict prediction according to a code dependency graph, and evaluates the insertion position adaptation degree by a formula , wherein is the module coupling degree of the position, is the relevance score of the position and the demand function, is the code modification history frequency of the position, is a weight coefficient, and , determines that the low coupling degree code region is preferentially selected when inserting the position.

[0047] The simulation compilation and running environment performs automatic unit testing on the generated code segment, covers input boundary values, abnormal scenarios and normal function processes, selects affected original function modules for regression testing in combination with the code dependency graph, and the regression testing includes call link detection of the existing core function modules. When it is detected that the call frequency of the new code to the original API interface exceeds a preset threshold, a compatibility deep check is triggered.

[0048] Potential bugs and compatibility conflicts are identified and preliminarily repaired, and are repaired according to severity classification, with blocking errors being preferentially repaired, and non-blocking errors being recorded for subsequent processing by the developer.

[0049] The development report generation module outputs a development report, wherein the new function code is classified and displayed according to function modules; the test results include test case coverage, bug repair rate and compatibility conflict position identification; the integration explanation clearly indicates the code insertion path and the influence range of the associated modules, for confirmation and merging by the developer.

[0050] In summary, through the cooperative work of each module, the embodiment completely realizes the full-process automation from natural language instructions to new skill function development, the dependency graph constructed by the project code library parsing module and the API interface identification provide an accurate basis for development, the development instruction receiving and parsing module realizes efficient conversion of natural language requirements, the function deconstruction and code generation module greatly reduces the amount of manual coding, the automatic integration and debugging module effectively reduces the compatibility error rate, and the development report generation module provides a clear integration basis. The overall process significantly shortens the development cycle, reduces the dependence on professional programmers, and ensures the stable iteration of game projects.

[0051] Embodiment Two

[0052] The embodiment is applied to a task system iteration scene of an open world adventure game, and based on a natural language instruction input by a developer, development and integration of a new branch task function are completed. Through the system and method, automatic coding and integration of task logic are realized, manual coding cost is reduced, and compatibility conflicts between a task system and a plot, a prop, and an NPC system are avoided. Referring to Figure 1 and Figure 2 , a specific implementation process of the embodiment is as follows:

[0053] A project code library analysis module performs syntax checking on a code library of a target open world game, ensures that the code conforms to project syntax specifications, performs structural analysis to sort code levels of core modules such as a task system, a plot dialogue system, a prop management system, and an NPC attribute system, extracts key information in code comments, identifies code styles to determine constant naming, function naming, and other specifications, runs the game and simulates an execution process of an existing branch task, traces a function call chain, records data input and output relationships, and monitors memory occupation changes to determine a memory stability range of the task system when multiple tasks are running simultaneously.

[0054] A dependency relationship graph is constructed, and API interfaces are identified. Based on static and dynamic analysis results, a multi-dimensional code dependency relationship graph is constructed. A dependency strength between modules is calculated according to a formula , wherein is a frequency of occurrence of an interaction behavior between the modules, is a weight of the interaction behavior, and are respectively numbers of functions of the two modules; and core API interfaces and key data structures are identified.

[0055] A development instruction receiving and analysis module receives a new branch task demand instruction in a natural language form input by a developer, extracts key information including a function subject, a function type, a parameter threshold, and a related object by using a pre-trained natural language understanding model.

[0056] A key information extraction confidence is calculated according to a formula , wherein is an output score of the model for the information, is a total number of candidate information, is a context association length of the information in the instruction, is a context influence coefficient, and finally the extracted information is converted into structured data including entities-attributes-relations.

[0057] The function deconstruction and code generation module refers to the game function componentization disassembly rule library, decomposes the new branch task demand into atomic level programming tasks, including task registration, scene triggering, target detection, progress updating, reward issuing, state saving, etc., calls the programming large model facing the specific game engine, and generates code segments conforming to the project specification. All code segments contain standardized comments and version control identifiers.

[0058] The automatic integration and debugging module determines the insertion position according to the code dependency graph, and the formula evaluates the position adaptation degree, wherein is the coupling degree of the module at the position, is the relevance score of the position and the demand function, is the code modification history frequency of the position, , , is the weight coefficient, and , determines the insertion position, and preferentially selects the code region with low coupling degree, high relevance and low modification frequency.

[0059] The simulation running environment executes unit testing, covers input boundary values, abnormal scenes and normal function processes; combined with the dependency graph, regression testing is performed on the affected related systems, and the regression testing includes call link detection of existing core function modules. When it is detected that the call frequency of the new code to the original API interface exceeds the preset threshold, compatibility deep checking is triggered.

[0060] Identify and preliminarily repair potential bugs and compatibility conflicts, repair according to severity, prioritize blocking errors, and record non-blocking errors for developers to handle later.

[0061] The development report generation module outputs the development report, and the new function code is classified and displayed according to the function module; the test results include test case coverage, bug repair rate and compatibility conflict position identification; the integration explanation clearly shows the code insertion path and the influence range of the associated module, for the developer to confirm and merge.

[0062] In summary, through the cooperative operation of the modules of the system, the whole process of automatic development of the new branch task from natural language demand to integrable code is realized. The dependency graph constructed by the project code library analysis module provides accurate reference for task logic integration. The development instruction receiving and analysis module efficiently converts natural language demand. The function deconstruction and code generation module greatly reduces manual coding work. The automatic integration and debugging module effectively controls the compatibility error rate. The development report generation module provides clear integration basis. The overall process significantly improves the iteration efficiency of the game task system, reduces the dependence on professional developers, and ensures the development quality.

[0063] The above merely describes the preferred embodiments of the present application, and is not intended to limit the present application in any form. Although the present application has been disclosed with the preferred embodiments as above, it is not intended to limit the present application. Any person skilled in the art can make some changes or modifications to the above disclosed technical content to obtain equivalent embodiments with equivalent changes, as long as the changes or modifications do not deviate from the technical solution of the present application. Any modification, change, equivalent change and modification of the above embodiments made according to the technical essence of the present application still belong to the scope of the technical solution of the present application.

Claims

1. A game function development system based on natural language instructions, characterized by, The system comprises a project code library parsing module, a development instruction receiving and parsing module, a function deconstruction and code generation module, an automated integration and debugging module, and a development report generation module. The project code library parsing module is configured to perform static and dynamic analysis on an existing code library of a target game project, construct a code dependency graph, and identify API interfaces and data structures of core function modules. The development instruction receiving and parsing module is configured to receive a new function requirement in natural language form input by a developer, and parse the requirement. The function deconstruction and code generation module is configured to deconstruct the parsed high-level function requirement into specific programming tasks, and call a programming large model for a specific game engine to generate a function code segment conforming to a project code specification. The automatic integration and debugging module is used for automatically inserting the generated code segment into a correct position of a code library, simulating a compilation and running environment, performing automatic unit testing and regression testing, identifying and preliminarily repairing potential bugs and compatibility conflicts, and performing conflict prediction according to a code dependency graph before the code segment is inserted, and preferentially selecting a low-coupling code region when a position is determined, and performing unit testing to cover input boundary values, abnormal scenarios and normal function processes, wherein a code insertion adaptation degree evaluation formula is as follows: wherein, is a code insertion adaptation degree of the position , is a module coupling degree of the position, is a correlation score of the position and a demand function, is a code modification history frequency of the position, , , is a weight coefficient and ; The development report generation module is configured to output a development report containing a new function code, test results, and integration instructions for confirmation and merging by the developer.

2. The natural language instruction based game function development system according to claim 1, characterized by, The project codebase parsing module performs static analysis, including syntax checking, structural analysis, comment extraction, and code style recognition. During dynamic analysis, it tracks function call chains, data input / output relationships, and memory usage changes during runtime to construct a multi-dimensional code dependency graph. The formula for calculating inter-module dependency strength is as follows: ,in, For module With modules Dependence strength, For the first Frequency of occurrence of interactive behaviors For the first Weights of interactive behaviors , Modules , The code size is calculated using the denominator for normalization.

3. The natural language instruction based game function development system according to claim 1, characterized by, The development instruction receiving and analyzing module analyzes natural language requirements by using a pre-trained natural language understanding model to extract key information, including a function subject, a function type, a parameter threshold, and a related object, and converts the key information into structured data containing entity-attribute-relation. The confidence level of key information extraction is calculated using: wherein, is the extraction confidence level of the th key information, is the output score of the model for the information, is the total number of candidate information, is the context association length of the information in the instruction, is the context influence coefficient.

4. The natural language instruction based game function development system according to claim 1, characterized by, When deconstructing the high-level function requirement, the function deconstruction and code generation module refers to a preset game function componentization disassembly rule library, maps the requirement to atomic-level programming tasks, and generates a code segment containing standardized annotations and version control identifiers.

5. The natural language instruction based game function development system according to claim 1, characterized by, The regression test of the automated integration and debugging module includes detection of a calling link of an existing core function module, and when the calling frequency of the new code to the original API interface exceeds a preset threshold, triggering a compatibility deep check.

6. The natural language instruction based game function development system according to claim 1, wherein In the report output by the development report generation module, the new function code is classified and displayed according to function modules, the test results include test case coverage, bug fixing rate, and compatibility conflict position identifier, and the integration instructions clearly indicate the code insertion path and the influence range of associated modules.

7. The method for developing a game function based on a natural language instruction according to any one of claims 1 to 6, wherein The method comprises the following steps: Performing static and dynamic analysis on an existing code library of a target game project, constructing a code dependency graph, and identifying API interfaces and data structures of core function modules; Receiving a new function requirement in natural language form and parsing; Deconstructing the parsed high-level function requirement into specific programming tasks, and calling a programming large model for a specific game engine to generate a function code segment conforming to a project code specification; Automatically inserting the code segment into the correct position of the code library, simulating a compilation and running environment, performing automated testing and fixing potential problems; Outputting a development report containing a new function code, test results, and integration instructions for confirmation and merging by the developer. 8.The natural language instruction based game function development method of claim 7, wherein, When performing automated testing, first perform unit testing on the generated code segment, then select the affected original function modules according to the code dependency graph for regression testing, and fix the identified bugs and compatibility conflicts according to the severity, with priority given to fixing blocking errors, and non-blocking errors are recorded for subsequent processing by the developer.

Images