Game tool processing method and device and related product

Abstract

The invention discloses a game tool processing method and device and a related product. The method comprises the following steps: acquiring a to-be-processed session text of a target object; determining a tool processing intention of the target object based on the to-be-processed session text; if the tool processing intention is game tool development, obtaining a tool development document as a target tool document; if the tool processing intention is to arrange a plurality of game tools, obtaining a tool arrangement document as a target tool document; and based on the to-be-processed session text, the target tool document and the simulated dialogue text, generating a reply text corresponding to the to-be-processed session text. Thus, for the unified code logic in the target tool document, the limitation of the game tool type can be broken through, the reply text including the tool code can be simulated and generated according to the generation mode that the simulation dialogue text includes the simulation tool code, manual operation is not needed, and the efficiency is improved. Zero code development or zero code arrangement of different types of game tools can be realized.

Description

Technical Field

[0001] The present application relates to the field of tool processing technology, and in particular to a method and device for processing game tools and related products. Background Art

[0002] With the rapid development of computer technology, gaming tools have gradually emerged as an important component of game development support. In the early stages of game development, simple auxiliary tools were created to improve development efficiency. Later, with the continuous advancement of technology, these tools gradually evolved into powerful gaming tools. Currently, to enhance development convenience, low-code / no-code development solutions for gaming tools have emerged.

[0003] Game tools can include different types of tools such as Unreal Engine (UE) tools and Internet (web) tools. Web tools can be based on technology stacks such as HyperText Markup Language (HTML), Cascading Style Sheets (CSS) and interpreted scripting language JavaScript, and can achieve zero-code tool development through low-code platforms such as Wuji 2.0 and open source front-end low-code framework amis. At present, UE tools are usually developed based on UE game engines, and require the use of UE game engine components and programming capabilities, and zero-code development cannot be achieved. At the same time, the arrangement of multiple game tools requires manual graphical drag and drop and manual code configuration, which also requires high programming skills from users. In these cases, non-developers cannot complete tool development or tool arrangement independently, which easily increases labor costs and workload, thereby affecting the processing efficiency of game tools.

[0004] Therefore, how to achieve zero-code development or zero-code orchestration for different types of game tools, reduce labor costs and workload, and thus improve the processing efficiency of game tools has become a problem that needs to be solved urgently. Summary of the Invention

[0005] The embodiments of the present application provide a method, device, and related products for processing game tools, with the aim of achieving zero-code development or zero-code editing of different types of game tools, saving labor costs and workload, and improving the processing efficiency of game tools.

[0006] A first aspect of the present application provides a method for processing a game tool, the method comprising:

[0007] Get the target object's conversation text to be processed;

[0008] Determining the target object's tool processing intention based on the conversation text to be processed; the tool processing intention includes developing a game tool or arranging multiple game tools;

[0009] If the tool processing intention is to develop a game tool, obtaining a tool development document as a target tool document; the tool development document includes a plurality of preconfigured first attribute fields in the code, a definition of each preconfigured first attribute field, and preconfigured action execution logic;

[0010] If the tool processing intention is to compile multiple game tools, a tool compilation document is obtained as the target tool document; the tool compilation document includes multiple preconfigured second attribute fields, a definition of each preconfigured second attribute field, and a preconfigured tool execution method;

[0011] Based on the conversation text to be processed, the target tool document and the simulated dialogue text, a reply text corresponding to the conversation text to be processed is generated; the reply text includes a tool code for realizing the tool processing intention; the simulated dialogue text is generated based on the target tool document, the simulated dialogue text includes a simulated conversation text and a simulated reply text, and the simulated reply text includes a simulated tool code.

[0012] A second aspect of the present application provides a device for processing a game tool, the device comprising:

[0013] A text acquisition module is used to obtain the conversation text to be processed by the target object;

[0014] An intention determination module, configured to determine the target object's tool processing intention based on the conversation text to be processed; the tool processing intention includes developing a game tool or arranging multiple game tools;

[0015] A first document acquisition module is configured to acquire a tool development document as a target tool document if the tool processing intention is to develop a game tool; the tool development document includes a plurality of preconfigured first attribute fields in the code, a definition of each preconfigured first attribute field, and preconfigured action execution logic;

[0016] a second document acquisition module configured to acquire a tool arrangement document as the target tool document if the tool processing intention is to arrange multiple game tools; the tool arrangement document comprising a plurality of preconfigured second attribute fields, a definition of each preconfigured second attribute field, and a preconfigured tool execution method;

[0017] A reply text generation module is used to generate a reply text corresponding to the conversation text to be processed based on the conversation text to be processed, the target tool document and the simulated conversation text; the reply text includes a tool code for realizing the tool processing intention; the simulated conversation text is generated based on the target tool document, the simulated conversation text includes a simulated conversation text and a simulated reply text, and the simulated reply text includes a simulated tool code.

[0018] A third aspect of the present application provides a gaming tool processing device, the device comprising a processor and a memory:

[0019] The memory is used to store a computer program and transmit the computer program to the processor;

[0020] The processor is configured to execute the steps of the method for processing the gaming tool provided in the first aspect according to the instructions in the computer program.

[0021] A fourth aspect of the present application provides a computer-readable storage medium for storing a computer program, which, when executed by a processing device of a game tool, implements the steps of the processing method of the game tool provided in the first aspect.

[0022] A fifth aspect of the present application provides a computer program product, comprising a computer program, which, when executed by a processing device of a game tool, implements the steps of the game tool processing method provided in the first aspect.

[0023] It can be seen from the above technical solutions that the embodiments of the present application have the following advantages:

[0024] In the processing method of the game tool, the target object's conversation text to be processed is first obtained; based on the conversation text to be processed, the target object's tool processing intention is determined, wherein the tool processing intention may include that the target object needs to develop a game tool or that the target object needs to compile multiple game tools; in the case where the tool processing intention is to develop a game tool, a tool development document can be obtained as a target tool document, and the tool development document includes multiple preconfigured first attribute fields in the code, the definition of each preconfigured first attribute field, and preconfigured action running logic; in the case where the tool processing intention is to compile multiple game tools, a tool compilation document is obtained as a target tool document, and the tool compilation document includes multiple preconfigured second attribute fields, the definition of each preconfigured second attribute field, and a preconfigured tool execution method; then, based on the conversation text to be processed, the target tool document, and the simulated conversation text, a reply text corresponding to the conversation text to be processed is generated, and the reply text includes a tool code for realizing the tool processing intention, and the simulated conversation text is generated based on the target tool document, and the simulated conversation text includes simulated conversation text and simulated reply text, and the simulated reply text includes simulated tool code.

[0025] Since the tool code is generated based on the target tool document, for developing game tools, the tool development document includes multiple preconfigured first attribute fields in the code, the definition of each preconfigured first attribute field, and the preconfigured action running logic, indicating that it includes a uniformly designed code logic, so it can break through the limitations of game tool types and realize the development of different types of game tools; for orchestrating multiple game tools, the tool orchestration document includes multiple preconfigured second attribute fields, the definition of each preconfigured second attribute field, and the preconfigured tool execution method, which also indicates that it includes a uniformly designed code logic, so it can also break through the limitations of game tool types and realize the orchestration of different types of game tools.

[0026] At the same time, according to the method of generating the simulation tool code included in the simulated conversation text, the reply text including the tool code can be simulated and generated based on the conversation text to be processed and the target tool document, without the need for manual configuration of code or manual dragging, and can achieve zero-code development or zero-code editing of game tools. Therefore, this application can achieve zero-code development or zero-code editing for different types of game tools, saving labor costs and workload, improving the development and editing efficiency of game tools, and thus improving the efficiency of using game tools. BRIEF DESCRIPTION OF THE DRAWINGS

[0027] Figure 1a This is a schematic diagram of a configuration page in the related art;

[0028] Figure 1b A schematic diagram of another configuration page in the related art;

[0029] Figure 1c A schematic diagram of a game engine blueprint page in the related art;

[0030] Figure 2 A scene architecture diagram of a method for processing a gaming tool provided in an embodiment of the present application;

[0031] Figure 3 A flowchart of a method for processing a game tool provided in an embodiment of the present application;

[0032] Figure 4 A schematic diagram of a tool development document provided in an embodiment of the present application;

[0033] Figure 5 A schematic diagram of a tool for arranging documents provided in an embodiment of the present application;

[0034] Figure 6 A schematic diagram of a simulation tool code provided in an embodiment of the present application;

[0035] Figure 7 A schematic diagram of another simulation tool code provided in an embodiment of the present application;

[0036] Figure 8 A code diagram for creating an object model provided in an embodiment of the present application;

[0037] Figure 9 A code diagram of adding target action execution logic provided in an embodiment of the present application;

[0038] Figure 10 A schematic diagram of implementing user interface updates through an object proxy model provided in an embodiment of the present application;

[0039] Figure 11a A schematic diagram of a user interface update provided in an embodiment of the present application;

[0040] Figure 11b A schematic diagram of another user interface update provided in an embodiment of the present application;

[0041] Figure 12 A framework diagram for driving user interface updates based on field values ​​provided in an embodiment of the present application;

[0042] Figure 13 A schematic diagram of a simulated conversation text provided in an embodiment of the present application;

[0043] Figure 14 A schematic diagram of a method for processing a gaming tool provided in an embodiment of the present application;

[0044] Figure 15 A schematic diagram of a user interface of an intelligent assistant provided in an embodiment of the present application;

[0045] Figure 16 This is an architectural diagram of a method for processing a gaming tool provided in an embodiment of the present application;

[0046] Figure 17 A schematic structural diagram of a processing device for a gaming tool provided in an embodiment of the present application;

[0047] Figure 18 A schematic diagram of the structure of the server in the embodiment of the present application;

[0048] Figure 19 This is a structural diagram of a terminal device in an embodiment of the present application. DETAILED DESCRIPTION

[0049] In related technologies, web tools can be developed through the low-code platform Wuji 2.0, such as Figure 1a As shown in the figure, this is a schematic diagram of a configuration page in the related art. Through this configuration page, users can use very little code or even no code to develop web tools. They can also develop text tools through amis, such as Figure 1b As shown in FIG, this figure is a schematic diagram of another configuration page in the related art, such as Figure 1b As shown in the figure, manual work can achieve the page effect on the left by configuring very little code on the right, thereby realizing the development of web tools. UE tools can be developed through the UE engine, such as Figure 1c As shown in the figure, this is a schematic diagram of a game engine blueprint page in the related art. Users can drag and drop components and configure codes through the blueprint page, and can use less code to implement UE tool development.

[0050] In related technologies, it is also possible to Figure 1b The configuration page shown implements the orchestration of web tools, with code configuration on the right and graphical drag-and-drop on the left. This means that the orchestration of game tools also requires manual drag-and-drop, code configuration, and other operations. Furthermore, if different types of game tools need to be orchestrated, an interface must be established between low-code platforms like Wuji 2.0 and Amis and the UE game engine, allowing the developed web tools and UE tools to be orchestrated into a single tool chain.

[0051] The above situation shows that low-code or even zero-code development of web tools can be achieved through low-code platforms in relevant technologies. However, the code logic of web tools and UE tools is different. Therefore, zero-code development of UE tools cannot be achieved through low-code platforms such as Wuji 2.0. The code orchestration steps are also cumbersome and require developers and other professionals to configure the code. It is difficult for non-professionals such as planners and artists to complete the development and orchestration of game tools alone. In other words, these situations are likely to increase labor costs and workload, thereby affecting the processing efficiency of game tools.

[0052] Therefore, how to achieve zero-code development or zero-code orchestration for different types of game tools, reduce labor costs and workload, and improve the processing efficiency of game tools has become an urgent problem to be solved.

[0053] In view of the above problems, this application provides a method, device and related products for processing game tools, with the aim of achieving zero-code development or zero-code editing of different types of game tools, saving labor costs and workload, and improving the processing efficiency of game tools. In the technical solution provided in the present application, a conversation text to be processed of a target object is obtained; based on the conversation text to be processed, a tool processing intention of the target object is determined; the tool processing intention includes developing a game tool or arranging multiple game tools; in one case, if the tool processing intention is to develop a game tool, a tool development document is obtained as a target tool document; the tool development document includes multiple preconfigured first attribute fields in the code, the definition of each preconfigured first attribute field, and preconfigured action running logic; in another case, if the tool processing intention is to arrange multiple game tools, a tool arrangement document is obtained as a target tool document; the tool arrangement document includes multiple preconfigured second attribute fields, the definition of each preconfigured second attribute field, and a preconfigured tool execution method, and based on the conversation text to be processed, the target tool document, and the simulated conversation text, a reply text corresponding to the conversation text to be processed is generated; the reply text includes a tool code for realizing the tool processing intention; the simulated conversation text is generated based on the target tool document, the simulated conversation text includes simulated conversation text and simulated reply text, and the simulated reply text includes simulated tool code.

[0054] In this way, by simulating the way the simulated reply text in the simulated dialogue text replies to the simulated conversation text, the present application can generate corresponding reply text based on the conversation text to be processed provided by the target object. The simulated dialogue text is generated based on the target tool document and includes the simulation tool code. Therefore, the reply text generated by the simulation can include the tool code for implementing the tool processing intention of the target object, without the need for manual code configuration. At the same time, the target tool document includes a uniformly designed code logic that can break through the type restrictions of the game tool and realize the development or arrangement of different types of game tools. Therefore, the game tool processing method provided by the present application can achieve zero-code development or zero-code arrangement for different types of game tools, which can reduce labor costs and workload, thereby improving the processing efficiency of the game tool.

[0055] Next, the execution subject of the method for processing the game tool provided in the embodiment of the present application is introduced.

[0056] The execution subject of the processing method of the game tool provided in the embodiment of the present application can be a terminal device. The terminal device can execute the processing method of the game tool, for example, the terminal device can obtain the conversation text to be processed of the target object, etc. As an example, the terminal device can specifically include but is not limited to a mobile phone, a desktop computer, a tablet computer, a laptop computer, a handheld computer, an intelligent voice interaction device, a smart home appliance, a car terminal, an aircraft, etc. The execution subject of the processing method of the game tool provided in the embodiment of the present application can also be a server, for example, the server determines the tool processing intention of the target object based on the conversation text to be processed.

[0057] In addition, the processing method for the gaming tool provided in the embodiments of the present application can also be executed collaboratively by a terminal device and a server. The terminal and the server can be connected directly or indirectly via wired or wireless communication, which is not limited in this application. Therefore, the embodiments of this application do not limit the implementation subject of the technical solution of this application.

[0058] Figure 2 This is a scene architecture diagram of a method for processing a game tool provided in an embodiment of the present application. Figure 2 It includes servers and various forms of terminal devices. Figure 2 The server shown can be a standalone physical server, a server cluster composed of multiple physical servers, or a distributed system. Furthermore, the server can also be a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communications, middleware services, domain name services, security services, CDN, and big data and artificial intelligence platforms.

[0059] The processing method for gaming tools provided in this application relates to the field of artificial intelligence. Artificial Intelligence (AI) is the theory, method, technology, and application system that uses digital computers or machines controlled by digital computers to simulate, extend, and expand human intelligence, perceive the environment, acquire knowledge, and use knowledge to achieve optimal results. In other words, AI is a comprehensive technology in computer science that attempts to understand the essence of intelligence and produce new intelligent machines that can respond in a manner similar to human intelligence. AI is the study of the design principles and implementation methods of various intelligent machines, enabling them to have the capabilities of perception, reasoning, and decision-making.

[0060] Artificial intelligence (AI) technology is a comprehensive discipline encompassing a wide range of fields, encompassing both hardware and software technologies. Foundational AI technologies generally include sensors, specialized AI chips, cloud computing, distributed storage, big data processing, pre-trained models, operating / interaction systems, and mechatronics. Pre-trained models, also known as large models or basic models, can be fine-tuned and widely applied to downstream tasks across various AI disciplines. AI software technologies primarily encompass computer vision, speech processing, natural language processing, and machine learning / deep learning.

[0061] The document translation method provided in this application primarily involves natural language processing and machine learning. Natural language processing (NLP) is a key area of ​​research in both computer science and artificial intelligence. It studies various theories and methods that enable effective communication between humans and computers using natural language. Natural language processing involves natural language, the language people use daily, and is closely related to linguistics. It also involves computer science and mathematics. It is a science that integrates linguistics, computer science, and mathematics. Therefore, research in this field involves natural language, the language people use daily, and is closely related to linguistics. Pre-training models, a key technology for model training in the field of artificial intelligence, are derived from large language models (Large Language Models) in the NLP field. After fine-tuning, large language models can be widely applied to downstream tasks. Natural language processing technologies typically include text processing, semantic understanding, machine translation, robotic question-answering, knowledge graphs, and other technologies.

[0062] Machine learning (ML) is a multidisciplinary field that encompasses probability theory, statistics, approximation theory, convex analysis, and algorithmic complexity theory. It specifically studies how computers simulate or implement human learning behaviors to acquire new knowledge or skills and reorganize existing knowledge structures to continuously improve their performance. Machine learning is the core of artificial intelligence and the fundamental way to make computers intelligent. Its applications span all areas of AI. Machine learning and deep learning typically include techniques such as artificial neural networks, belief networks, reinforcement learning, transfer learning, inductive learning, and self-learning. Pretrained models are the latest development in deep learning, integrating these techniques.

[0063] Next, from the perspective of the terminal device, the processing method of the game tool provided in the embodiment of the present application is specifically introduced.

[0064] See also Figure 3 , which is a flow chart of a method for processing a game tool provided by an embodiment of the present application. Figure 3 As shown, the processing method of the game tool may include the following steps:

[0065] S301: Obtain the conversation text to be processed of the target object.

[0066] In the embodiments of this application, a target object refers to any object that has a processing requirement for a game tool (a target object may also be referred to as a user). For example, it may be a planner who needs to develop a game tool, a developer who needs to compose multiple game tools, or an artist who needs to execute a specific game tool, although this application does not limit this.

[0067] Conversation text refers to the text generated by the target object during the communication process. The conversation text to be processed refers to the text that has been collected or received by the terminal device but has not yet been analyzed, processed or responded to. In some embodiments, the conversation text to be processed may include questions, requests, feedback, comments or other forms of information exchange from the target object. Exemplarily, the conversation text to be processed may be "perform operations in the following order: 1. Run the local resource processing tool 1; 2. Call the compilation tool 2 at the same time; 3. After steps 1 and 2 are completed, call the packaging tool 3 to generate the client", and this application does not limit this.

[0068] In some embodiments, the terminal device may provide a conversation page for the user, where the conversation page includes an input box, in which the user may input conversation text, and the terminal device may then obtain the conversation text to be processed of the target object.

[0069] S302: Determine the tool processing intention of the target object based on the conversation text to be processed.

[0070] In an embodiment of the present application, a tool processing intent refers to a goal that the target object expects to achieve or a specific task that the target object wants to complete for a game tool. In some embodiments, the tool processing intent includes developing a game tool, indicating that the target object needs to develop a game tool to implement a specific function, such as developing a warehouse cleaning tool to clean up unnecessary or redundant game resources; the tool processing intent may also include arranging multiple game tools, indicating that the user needs to combine the functions of these game tools, arrange these tools into a tool chain, and package them into a complete workflow. For example, a local image processing tool and a compilation tool can be called in parallel, and then the packaging tool can be called to generate a client, which can provide image processing functions for the target object.

[0071] In one possible implementation, multiple options may be provided to the user, including a tool development control and a tool arrangement control. Accordingly, the user's tool processing intent may be determined based on the conversation text to be processed and in response to the user's triggering operation. For example, in response to the user's triggering operation on the tool development control and based on the conversation text to be processed, it may be determined that the user's tool processing intent is to develop game tools.

[0072] In one possible implementation, a deep learning model such as a large language model can also be used to predict the conversation text to be processed using the trained deep learning model to determine the tool processing intention of the target object. This application does not limit this.

[0073] S303: If the tool processing intention is to develop a game tool, a tool development document is obtained as a target tool document.

[0074] In the embodiments of the present application, a target tool document refers to a document used to implement the tool processing intent of a target object, and includes content related to the tool processing intent of the target object. A tool development document includes content related to developing a game tool. Therefore, when it is determined that the tool processing intent of the target object is to develop a game tool, the tool development document is obtained as the target tool document, facilitating the subsequent implementation of the intention to develop the game tool based on this document.

[0075] In some embodiments, the tool development document includes a plurality of preconfigured first attribute fields in the code, a definition of each preconfigured first attribute field, and preconfigured action execution logic. The preconfigured first attribute fields refer to attribute fields preconfigured based on the development of the game tool, and the definition of the preconfigured first attribute fields refers to descriptions and provisions of the configured attribute fields, which are used to define and describe data attributes, providing a standardized way to describe data to ensure data consistency and accuracy.

[0076] As an implementation method, the preconfigured first attribute field may include model, label, type, string, and number, etc., wherein the definition of each preconfigured first attribute field may include model is the definition of the object model, label is the field name, type is the data type of the field, string is the string data type, and number refers to the numeric data type. This application does not limit this.

[0077] The preconfigured action execution logic refers to a predefined series of instructions that can describe how the action is executed and is used to execute the function of the game tool based on the preconfigured first attribute field.

[0078] As an implementation, the preconfigured action execution logic may include a preconfigured action field and an action associated with the preconfigured action field. For example, the preconfigured action execution logic may include: a branch switch refers to executing different operations based on different conditions; a jump link refers to jumping from one page of the user interface to another; and an execution tool toolExecute refers to calling a game tool to execute a task. This application does not limit this.

[0079] For example, see Figure 4 , which is a schematic diagram of a tool development document provided in an embodiment of the present application. Figure 4 As shown, the tool development document includes multiple pre-configured first attribute fields and the definition of each pre-configured first attribute field, etc. Specific descriptions can be found in the above examples, which will not be repeated here.

[0080] S304: If the tool processing intention is to compile multiple game tools, a tool compilation document is obtained as a target tool document.

[0081] In this embodiment of the present application, the tool arrangement document includes content related to the arrangement of multiple game tools. Therefore, when it is determined that the tool processing intent of the target object is to arrange multiple game tools, the tool arrangement document is obtained as the target tool document, so that the intention of arranging multiple game tools can be realized based on the document.

[0082] In some embodiments, a tool arrangement document may include a plurality of preconfigured second attribute fields, a definition of each preconfigured second attribute field, and a preconfigured tool execution method. The preconfigured tool execution method is used to implement the arrangement of the game tool based on the preconfigured second attribute fields; the preconfigured second attribute fields are attribute fields preconfigured based on the arrangement of the game tool; and the definition of the preconfigured second attribute field refers to a description and specification of the configured attribute fields, which is used to define and describe data attributes, providing a standardized way to describe data to ensure data consistency and accuracy.

[0083] As an implementation method, the preconfigured second attribute field may include actions, toolId, params, string, and condition, etc., wherein the definition of each preconfigured second attribute field may include: actions refers to multiple game tools that need to be executed; toolId refers to the identification ID of the game tool; params refers to the input parameters of the game tool; condition refers to the triggering conditions for executing the game tool, which is not limited in this application.

[0084] As an embodiment, the preconfigured tool execution mode may include a preconfigured execution field and a tool execution mode associated with the preconfigured execution field. For example, the preconfigured tool execution mode may include a mode mode for implementing different tool execution modes; sequential execution seq means that at least two game tools are executed according to a pre-set order, that is, mode = seq, indicating that the tool execution mode of the game tools is sequential execution; parallel means that at least two game tools are executed simultaneously, that is, mode = parallel, indicating that the tool execution mode of the game tools is parallel execution. This application does not limit this.

[0085] For example, see Figure 5 , which is a schematic diagram of a tool for arranging documents provided by an embodiment of the present application. Figure 5 As shown, the tool development document includes multiple pre-configured second attribute fields, the definition of each pre-configured second attribute field, and the pre-configured tool execution method. Specific instructions can be found in the above example and will not be repeated here.

[0086] Furthermore, in some embodiments, command line parameter transmission, pipe communication, socket communication, and other data transmission between multiple local game tools can be implemented by orchestrating multiple game tools. Offline scheduled execution of remote game tools and unattended automatic triggering can also be implemented. This application does not limit this.

[0087] S305: Generate a reply text corresponding to the conversation text to be processed based on the conversation text to be processed, the target tool document, and the simulated conversation text.

[0088] In the embodiments of the present application, the reply text refers to the text that replies to the conversation text to be processed, and is used to solve the needs raised in the conversation text (that is, to realize the tool processing intention of the target object). In some embodiments, the conversation text includes a tool code for realizing the tool processing intention. For example, when the tool processing intention is to develop a game tool, the tool code can realize the functions of the developed game tool; and for example, when the tool processing intention is to arrange multiple game tools, the tool code can realize the functions of the arranged multiple game tools.

[0089] Simulated conversation text refers to a series of fictitious conversations, which may include simulated conversation text and simulated response text. Simulated conversation text simulates the conversation text presented by the target user, while simulated response text simulates the response text that a terminal device can provide based on the simulated conversation text. It is used to simulate real conversation scenarios, helping the terminal device learn how to understand the target user's pending response text and generate appropriate and natural response text. For example, the simulated conversation text may be manually written based on the target tool documentation, but this application does not limit this.

[0090] In some embodiments, the simulated conversation text includes simulated conversation text and simulated reply text, and the simulated reply text includes a simulated tool code. Therefore, the terminal device can generate a reply text including a tool code based on the way the simulated reply text in the simulated conversation text replies to the simulated conversation text, so as to realize the tool processing intention of the target object.

[0091] As an implementation method, see Figure 6 , which is a schematic diagram of a simulation tool code provided by an embodiment of the present application. Figure 6 As shown, the figure includes simulation tool codes of simulation dialogue texts generated based on tool development documents, which are used to simulate dialogue scenarios of real game development tools.

[0092] As an implementation method, see Figure 7 , which is a schematic diagram of another simulation tool code provided by an embodiment of the present application. Figure 7 As shown, the figure includes simulation tool codes for simulated dialogue texts generated based on tool arrangement documents, which are used to simulate real dialogue scenarios of arranging multiple games.

[0093] In a possible implementation of the present application, when the target tool document is a tool development document, the step of generating the tool code may include:

[0094] A1: Determine the target field and target action execution logic for implementing the game tool function from the conversation text to be processed.

[0095] In an embodiment of the present application, the target field refers to the field to be created (also referred to as an object), and the target action running logic refers to the action with running logic required to implement the function of the game tool to be developed. For example, it can be multiple actions combined and sorted according to the running logic.

[0096] For example, the conversation text to be processed includes: developing a warehouse cleaning tool, including two fields, cleaning directory dir and cleaning level level, using these two fields to run "clean.bat --dir= <dir>--level= <level>", it can be determined that the target fields include dir and level, and the target action operation logic is to open the project and execute the warehouse cleanup tool based on dir and level.

[0097] A2: Create an object model that includes the target fields based on the target fields, tool development documentation, and simulation tool code.

[0098] In the embodiment of the present application, the object model refers to a model used to describe field properties and action operation logic. The created and defined object model can be used to implement the functions of the game tool.

[0099] In some embodiments, when the target tool document is a tool development document, the simulation tool code is the simulated tool development code. By simulating the simulation tool code to create an object model based on the tool development document, an object model including the target field can also be created based on the tool development document and the target field.

[0100] Exemplarily, based on the above example, an object model model can be created according to the definition of the target field and the pre-configured first attribute field in the tool development document and the pre-configured first attribute field of each pre-configured field. The field name "cleaning directory" is defined for the target field dir through label, and the field name "cleaning level" is defined for the target field level through label. The field types of these two fields are defined through type. This application does not limit this.

[0101] In a possible implementation of the present application, A2 may specifically include: creating target fields, life cycle stages of target fields, and triggering events of life cycle stages based on target fields, tool development documents, and simulation tool codes to obtain an object model.

[0102] In this embodiment of the present application, the lifecycle phase of a target field refers to the different stages that a field goes through from its creation to its eventual abandonment or replacement. A triggering event for a lifecycle phase refers to an event that is automatically triggered when the field is in that lifecycle phase, such as automatically calling a function.

[0103] In some embodiments, multiple life cycle stage triggers of a field can be predefined and stored in a tool development document, such as Figure 4 As shown. Exemplarily, it may include the following eight life cycle stages: beforeInit before initialization, afterInit after initialization, beforeDestory before uninstallation, afterDestory after uninstallation, onClick (this stage occurs when a click event occurs in the user interface), onFocus (this stage occurs when an interface element in the user interface is selected by the mouse), onBlur (this stage occurs when the mouse moves away from an interface element in the user interface after it is selected by the mouse), and onChange (the value of the field changes).

[0104] As an implementation method, see Figure 8 , which is a code diagram of creating an object model provided by an embodiment of the present application. Figure 8 As shown in the example, create the object model model. Use the label field "version" to define the field name, and the label field "level" to define the field name. Use the type field to define the field types as string and number, respectively. Use the trigger field to define the field lifecycle phase as beforeInit. The action function "paramCheck" is automatically called during this phase.

[0105] In this way, based on the preconfigured first attribute field in the code, the definition of the preconfigured first attribute field, and the multiple life cycle stages of the predefined fields, the structure and attributes of the data can be standardized, that is, using a unified code logic for different types of game tools can break through different types of limitations.

[0106] A3: Based on the tool development documentation and simulation tool code, add target action operation logic to the object model to obtain the tool code.

[0107] In some embodiments, by simulating the way in which the simulation tool code adds action execution logic tools to the object model based on the tool development document, target action execution logic can be added to the object model including the target field based on the tool development document to obtain the tool code.

[0108] As an implementation method, the preconfigured action execution logic may include different types of action execution logic, such as conditional selection, user interface interaction, and built-in logic.

[0109] Among them, the action running logic of conditional selection can include: branch switch, which is used to perform different operations according to different conditions; loop loop is used to repeat execution until the pre-set termination condition is met; break is used together with the loop to exit the loop early during the loop execution process; parallel is used to process multiple tasks simultaneously.

[0110] The action operation logic of the user interface interaction may include: jump link refers to the user interface jumping from one page to another; pop-up modal refers to a window covering the page displayed on the user interface; notification notify refers to information displayed in a specific area of ​​the user interface (such as the status bar, notification center, etc.), or a message box floating in the user interface; drawer refers to a panel that slides in or out from the edge of the user interface to display additional functions or information; confirmation refers to a dialog box that requires the target object to verify or confirm its operation. The action operation logic of the above-mentioned user interface interaction can pre-set the interaction method between the target object and the user interface. When the target object performs the corresponding interaction in the user interface, these action operation logics can be implemented in response to the operation of the target object.

[0111] The action running logic of the built-in logic may include: executing the tool toolExecute means calling the game tool to execute the task; the scheduled task timeSchedule means setting and executing a periodic task or a one-time task, which is automatically triggered and executed at the scheduled time; opening the project projectOpen means loading and initializing a project.

[0112] In addition, in some embodiments, the tool development document may also include a preconfigured first attribute field: actionType, which is used to indicate the preconfigured action field corresponding to the running logic of the added action, for example: actionType = switch, indicating that the action running logic of the branch is added; data is used to represent the value of the preconfigured action field required for the action to be executed; hook represents the hook function, which can extend the execution of the additional action running logic in scenarios such as beforeAction before the execution of the action running logic, afterAction after the execution, onSuccess if the execution is successful, and onError if the execution fails.

[0113] For example, based on the above example, when the target action operation logic refers to opening the project and executing the warehouse cleaning tool based on dir and level, the project directory can be opened by adding the built-in logic action operation logic projectOpen; and the tool can be executed based on the values ​​of the two fields dir and level through toolExecute.

[0114] As an implementation method, see Figure 9 , which is a code diagram of adding target action operation logic provided by the embodiment of the present application. Figure 9 As shown, the figure is combined with Figure 8 The target action running logic added to the created object model is the action function "paramCheck" that is automatically called when the target field is in the pre-initialization stage. This action function is the target action running logic added to the object model. Figure 9 As shown, before the action is executed, the toolExecute command is called as a hook to run the ParameterCheckTool tool. The tool's execution result is stored in the model.isValid field. Next, a switch statement is executed based on the value of this field. If the value of this field is true, a "check passed" notification is displayed; if the value of this field is false, an error message is displayed: "check failed."

[0115] In this way, compared with the related art, UE tools are developed based on the UE engine framework, and web tools are developed based on the browser framework. The code interfaces and operation logic of the two frameworks are different, which requires writing two sets of codes to develop UE tools and Web tools with the same functions, that is, one framework can only develop one type of game tool. This application is based on the pre-configured content related to code logic in the tool development document, that is, the field defines the data, and the action defines the operation logic. By combining the two, the data and the logic of processing data are decoupled, so that complex tool processing intentions can be decomposed into simple fields and actions, and different types of game tools such as UE tools and web tools can be developed, which can break through different types of restrictions. Based on the tool development document and the simulation tool code, the tool code for realizing the tool processing intention of developing game tools can be simulated and generated without manual code configuration. Therefore, zero-code development can be achieved for different types of game tools.

[0116] In a possible implementation of the present application, when the target tool document is a tool arrangement document, the step of generating the tool code may include:

[0117] B1: Determine multiple game tools to be arranged and execution modes of the multiple game tools to be arranged from the conversation text to be processed.

[0118] In the embodiment of the present application, the execution mode refers to the execution order of the game tools, which may include a parallel execution mode of simultaneous execution or a sequential execution mode of successive execution.

[0119] For example, the conversation text to be processed is: "Perform operations in the following order: 1. Run local resource processing tool 1; 2. Call compilation tool 2 at the same time; 3. After steps 1 and 2 are completed, call packaging tool 3 to generate the client." It can be determined that the multiple game tools to be compiled are local resource processing tool 1, calling compilation tool 2 and packaging tool 3, and the execution method is to first execute local resource processing tool 1 and calling compilation tool 2 in parallel, and then execute packaging tool 3 sequentially after the parallel execution is completed.

[0120] B2: Based on the execution methods, tool documents and simulation tool codes of the multiple game tools to be choreographed, determine the execution order of each game tool to be choreographed among the multiple game tools to be choreographed, and determine the output field of the first game tool as the input field of the second game tool to obtain the tool code.

[0121] In the embodiment of the present application, the execution order of the first game tool is before the execution order of the second game tool, and the execution order of the first game tool is adjacent to the execution order of the second game tool.

[0122] Exemplarily, based on the above example, the execution order of the local resource processing tool 1 and the calling compilation tool 2 is simultaneous execution (i.e., parallel execution), and the execution order of the packaging tool 3 is after the execution of the local resource processing tool 1 and the calling compilation tool 2, that is, the local resource processing tool 1 and the calling compilation tool 2 are executed first, and then the packaging tool 3 is executed in sequence, and the output fields output by the local resource processing tool 1 (i.e., the first game tool) and the calling compilation tool 2 (i.e., the first game tool) are used as the input fields of the packaging tool 3 (i.e., the second game tool).

[0123] In this way, based on the tool arrangement document and the simulation tool code, the tool code for realizing the tool processing intention of arranging multiple game tools can be simulated and generated without manual dragging, nor manual understanding of the arrangement logic of the game tools and manual dragging and other tedious operation steps. The tool code can be automatically generated based on the conversation text to be processed of the target object, and the tool arrangement document also includes a unified code logic, so zero-code arrangement can be achieved for different types of game tools.

[0124] It should be understood that the development of UE tools and web tools in related technologies is based on different code logic, indicating that their corresponding interface generation logic is also different. The two have different event systems, so the solution based on triggering events to drive the object model is no longer applicable. In order to display automated user interface interaction to the target object, this application can be based on data-driven user interface rendering, that is, the user interface can be changed by changing the value of the field.

[0125] In a possible implementation of the present application, the processing method of the game tool may also include: first creating a user interface including interface elements. For example, the interface elements may include input controls, navigation controls, information controls, interactive elements, layout elements, etc.; then binding the fields in the tool code to the interface elements; when executing the tool code, the fields in the tool code can be detected; when the value of the field changes, the interface elements are updated based on the changed value of the field.

[0126] As an example, Field 1 can be bound to Control 1 in the user interface. During the execution of the tool code, each time the value of Field 1 changes, Control 1 in the user interface is updated. For example, Control 1 is a text box, and the value of Field 1 is an initial string. The text box initially displays the initial string. When Field 1 is updated to a new string, the content displayed in the text box is also updated to the new string.

[0127] In this way, the fields are bound to the interface elements in the user interface, and the user interface is rendered in a data-driven manner. Based on the binding relationship, the user interface can be quickly updated and rendered by detecting changes in the field values, eliminating the need for manual design of the user interface and development of the user interface by front-end developers, further saving labor costs and workload, and improving the development efficiency of the front-end user interface corresponding to the game tool.

[0128] In a possible implementation of the present application, a field may include multiple fields, and an interface element may also include multiple interface elements that are bound one-to-one to multiple fields. Accordingly, the above-mentioned step of "detecting fields in tool code" may include: first creating an object proxy model, and adding field dependency detection action running logic and dependency field update events to the object proxy model; then detecting the field dependency relationship of multiple fields in the tool code through the object proxy model.

[0129] Among them, the object proxy model is used to take over the reading (get()) and modification (set()) of the value of the field in the object model. In an embodiment of the present application, additional action operation logic can be added through the object proxy model to detect the dependency relationship of the fields in the tool code. The triggering condition of the above-mentioned dependent field update event is: there is a target field whose value changes in the tool code and the target field has a dependent field with a dependency relationship. When the value of the target field changes, the values ​​of the dependent fields with a dependency relationship with it will be triggered and updated through the trigger.

[0130] For example, the field dependency relationship may be that field 1 is a subfield of field 2, which means that field 2 can contain field 1, and field 1 is part of field 2. Therefore, when the value of field 1 changes, the value of field 2 must also change accordingly to ensure data consistency.

[0131] Accordingly, the above-mentioned "responding to a change in the value of a field, updating the interface elements based on the changed value of the field" may include: first responding to a change in the value of a target field among multiple fields, determining the dependent fields that have a dependency relationship with the target field through field dependencies, and triggering a dependent field update event to update the value of the dependent field; then, based on the changed value of the target field, updating the interface elements in the user interface that are bound to the target field; and based on the changed value of the dependent field, updating the interface elements in the user interface that are bound to the dependent field.

[0132] Among them, the target field has an interface element bound to it, and the dependent field also has an interface element bound to it. Therefore, based on their corresponding changed values, the interface elements bound to the target field and the interface elements bound to the dependent field in the user interface can be updated.

[0133] As an example, see Figure 10 , which is a schematic diagram of implementing user interface update through object proxy model provided by an embodiment of the present application. Figure 10 As shown, first create an object proxy model based on the object model, generate a proxy object (that is, a proxy field) to take over the reading or modification of the original object (the field in the code), and inject the action running logic of the field dependency detection and the action running logic of the trigger into the object proxy model to realize the change of the value of the target field. When the dependent field is detected, the dependent field update event is triggered by the trigger to update the value of the dependent field, and the UI is further updated based on the changed value of the target field and the changed value of the dependent field.

[0134] As an example, see Figure 11a , which is a schematic diagram of a user interface update provided by an embodiment of the present application. Figure 11a As shown, the target object does not need manual operation, and the user interface can be automatically rendered from user interface 1 to user interface 2 based on the value change of the field in the code.

[0135] See also Figure 11b , which is a schematic diagram of another user interface update provided by an embodiment of the present application. Figure 11b As shown, the target object does not need manual operation, and the user interface can be automatically rendered from user interface 3 to user interface 4 based on the value change of the field in the code.

[0136] As an example, see Figure 12 , which is a framework diagram of a field value-driven user interface update provided by an embodiment of the present application. Figure 12 As shown, the terminal device may include a user interface (UI) interaction layer and a platform framework layer. In the platform framework layer, a unified code logic, such as a JavaScript framework, is used to realize the intercommunication of different types of game tools. Among them, Python (a programming language), Unreal Engine native code UE Native Code and JavaScript (another programming language) are respectively used to indicate the code logic of different types of game tools. This application can be developed for different types of game tools through the JavaScript framework, breaking this limitation. That is, the two technology stack development modes of JavaScript and Python based on scripting tools, as well as the python and Linux (indicating an operating system) command line development modes corresponding to UE engine tools and version control tools (Subversion, SVN) tools can realize zero-code development and zero-code orchestration of game tools.

[0137] At the UI interaction layer, game tools can be broken down into simple objects and actions. For example, an object (also known as a field) is input into a game tool, and the logic corresponding to actions 1, 2, and 3 is run, resulting in the tool outputting an object. By binding fields to interface elements, the corresponding tool UI can be presented to the user. The UI interaction layer and the platform framework layer interact via the JavaScript framework's Application Programming Interface (API).

[0138] In this way, there is no need to understand the interaction logic of the user interface. The automatic rendering of the user interface can be achieved through the change of the field value in the tool code. That is, the change of the field value affects the user interface in a data-driven manner, and the action is only responsible for interacting with the platform framework layer, eliminating the development of the front-end user interface and further improving the user experience of the target object.

[0139] In a possible implementation of the present application, the above S305 may specifically include: inputting the conversation text to be processed, the target tool document, and the simulated conversation text as prompt words into the large language model to generate a reply text.

[0140] Among them, the Large Language Model (LLM) is an inference and prediction model that can complete and subsequently create text content based on prompt words. When implementing the dialogue function, the tool processing intention proposed by the target object can be used as a prompt word for subsequent completion and creation to generate a reply text and realize the tool processing intention of the target object.

[0141] This large language model is fine-tuned based on multiple conversation texts, so it can generate logical and semantically coherent response texts.

[0142] In some embodiments, the reply text may include a tool code and prompt text regarding the processing result of the tool processing intent. For example, the reply text may include the following: "OK, the tool code has been automatically generated for you," which notifies the target user that their tool processing intent has been fulfilled. The reply text may also include the following: "Sorry, please re-enter your request," which notifies the target user that their tool processing intent has not been fulfilled and that they need to re-enter the conversation text.

[0143] In an embodiment of the present application, the conversation text to be processed, the target tool document and the simulated conversation text are used as prompt words, wherein the target tool document and the simulated conversation text can be used as pre-prompt words. The target object inputs the conversation text to be processed once, and then inputs it and the pre-prompt words as prompt words to the large language model, so that the large language model can perform simulation based on the simulated conversation text and generate a reply text that meets the tool processing intention of the target object.

[0144] In some embodiments, comparative testing has shown that the development speed of a game tool 1 in related art is 2 to 3 days, while the game tool processing method provided in the embodiments of the present application can develop the game tool 1 in 5 to 10 minutes. In related art, it takes 20 minutes to compile multiple game tools to update a game, while the present application can compile multiple game tools to update a game in just 1 minute.

[0145] This allows large language models to understand and generate complex natural language text, eliminating the need for manual code configuration. Simply inputting natural language text (i.e., the conversational text to be processed) allows for zero-code development and orchestration of game tools, significantly improving processing efficiency. Furthermore, any user, including professionals like developers and non-professionals like planners and artists, can independently develop and orchestrate game tools.

[0146] As an implementation method, see Figure 13 , which is a schematic diagram of a simulated conversation text provided by an embodiment of the present application. Figure 13 Part (a) in the example is a simulated conversation text 1 generated based on the tool development documentation. Figure 13 Part (b) is a simulated conversation text 2 generated based on the tool arrangement document (also known as the tool platform usage document). Figure 13 Part (c) is the current schema data, which is used to indicate that the large language model has been trained. Next, the corresponding reply text can be generated based on the conversation text to be processed, or it can be used as part of the pre-prompt word.

[0147] In an embodiment of the present application, the generated tool code may be a specific type of code such as schema, and the present application does not limit this.

[0148] In addition, in some embodiments, as the number of conversations between the target object and the terminal device increases, LLM can also add historical conversations to the prompt words, further effectively improving the accuracy of the reply text generated by LLM.

[0149] It should be understood that the tool processing intent of the target object may also include executing a developed game tool. Therefore, in one possible embodiment of the present application, the tool processing intent may also include executing the target game tool. Accordingly, before S305, the game tool processing method may further include: if the tool processing intent is to execute the target game tool, obtaining a tool arrangement document as the target tool document.

[0150] Based on the above introduction, the tool arrangement document includes a pre-configured tool execution mode. In some embodiments, the pre-configured tool execution mode may include executing the target game tool alone.

[0151] As an implementation method, the reply text may include the tool operation code of the target game tool, and may also include relevant prompt text such as the target game tool is successfully executed and its function has been realized, etc. This application does not limit this.

[0152] For example, the conversation text to be processed may include: "Execute the warehouse cleaning tool to clean up unnecessary game resources." The reply text, in addition to including the tool operation code for the target game tool, may also include: "The warehouse cleaning tool has been executed and unnecessary game resources have been cleaned up." This application does not limit the content of the conversation text to be processed and the reply text.

[0153] In this way, the game tool processing method provided in this application can generate corresponding reply texts according to the different tool processing requirements of the target object, that is, it can meet the diverse tool processing requirements of the target object and further enhance the target object's usage experience.

[0154] As an implementation method, see Figure 14 , which is a schematic diagram of a processing method for a gaming tool provided in an embodiment of the present application. In this embodiment of the present application, an intelligent assistant is presented to a target object in the form of an application. The target object can interact with the intelligent assistant through a user interface, input conversation text, and receive reply text from the intelligent assistant. This can be understood as the intelligent assistant based on the large language model generating corresponding reply text based on the target object's conversation text to be processed.

[0155] like Figure 14 As shown, the user enables the intelligent assistant to obtain the conversation text to be processed through voice input or text input, and the intelligent assistant determines the tool processing intention of the target object based on the conversation text to be processed. If the intelligent assistant determines that the tool processing intention is to develop game tools, the tool development function set is obtained as a pre-prompt word, which includes a tool development document and a simulated dialogue generated based on it; if the intelligent assistant determines that the tool processing intention is to orchestrate multiple game tools, the tool orchestration function set is obtained as a pre-prompt word, which includes a tool orchestration document and a simulated dialogue generated based on it; the pre-prompt word and the conversation text to be processed are input into the LLM. If the current function cannot be met, that is, the LLM cannot generate a reply text and cannot meet the tool processing requirements of the target object, the text related to the tool processing requirements can be predicted by the LLM and displayed to the target object to intelligently guide the target object's reply. By finely decomposing the tool processing requirements of the target object, the target object is guided to input a conversation text that can successfully identify its tool processing requirements.

[0156] If the current functionality is met, meaning the LLM can generate a reply, the tool platform executes the corresponding operation. The LLM generates the corresponding reply based on the conversation text to be processed, achieving data output. If the reply includes code, the LLM parses the data: the output data schema represents the code extracted from the reply for subsequent code execution. Specifically, the LLM generates reply text based on a pre-prompt word library that accurately matches the pre-prompt words corresponding to the user's needs, intelligently selecting the pre-prompt words mentioned above. If the reply does not include code, this step is not required. Finally, the UI rendering engine detects data changes in the code field values ​​and automatically renders the interface for visual output.

[0157] As an example, see Figure 15 , which is a schematic diagram of a user interface of an intelligent assistant provided in an embodiment of the present application. Figure 15 As shown in (a) in the figure, it is the interface of the tool development intelligent assistant, which can realize the zero-code development of game tools. Figure 15 (b) shows the interface of the tool orchestration intelligent assistant, which enables zero-code orchestration of multiple game tools. In both interfaces, the right side shows the conversation text to be processed by the target user, and the left side shows the reply text generated by the intelligent assistant.

[0158] Based on the above introduction, the embodiment of the present application can be Figure 16 The processing method of the game tool is implemented by referring to the architectural diagram of the processing method of the game tool shown in FIG16. In combination with FIG16, it can include three parts: intelligent arrangement, intelligent development, and offline processing of prompt words. The terminal device can include a UI interaction layer, a platform framework layer, and a data layer.

[0159] The UI interaction layer is used to generate reply text including schema code, as well as rendering updates of the user interface. It mainly uses the conversation text to be processed entered by the user (that is, the target object) to realize intent recognition (that is, determine the tool processing intention of the target object) through the intelligent assistant, and then uses the large language model LLM and the schema parser called by the intelligent assistant for intelligent arrangement and intelligent development. The schema renderer can also detect value changes of fields in the code and update the UI for user viewing. In addition, multiple game tools of different types can be arranged to form a tool chain. When executing the tool chain, the schema renderer can also detect value changes of fields in the code and update the UI.

[0160] The platform framework layer includes the tool platform runtime (which intelligently orchestrates and executes multiple game tools), a prompt word selector (used to determine corresponding pre-prompt words based on tool processing intent), tool storage (used to store game tools developed through intelligent development), and a prompt word project (used to extract text such as tool development documents and tool orchestration documents from the data layer and perform accuracy testing on the extracted text using test cases). The platform framework layer connects the UI interaction layer to the data layer. At the same time, the prompt word project uses offline processing, based on the tool development documents and tool orchestration documents included in the tool platform knowledge base. It can extract and perform accuracy testing to generate pre-prompt words and store them in the data layer. After the UI interaction layer recognizes user intent, it can select the corresponding pre-prompt words by calling the prompt word selector of the platform framework layer and input them into the LLM model to generate reply text corresponding to the conversation text to be processed.

[0161] The data layer is responsible for the persistent storage of various data on the tool platform, including developed game tools, tool operation data, LLM prompt word data, and the tool platform knowledge base (including tool development documents and tool orchestration documents).

[0162] In addition, script execution, native tools and third-party capabilities represent different types of game tools, and multi-party empowerment means that the processing method of game tools provided in this application can break the different types of restrictions of game tools and realize the intelligent arrangement of different types of game tools.

[0163] Based on the method for processing the game tool provided in the above embodiment, the present application also provides a corresponding device for processing the game tool. The following is a detailed introduction to the device for processing the game tool provided in the embodiment of the present application.

[0164] See also Figure 17 , which is a structural diagram of a processing device for a game tool provided in an embodiment of the present application. Figure 17 As shown, the processing device 1700 of the game tool may specifically include:

[0165] The text acquisition module 1710 is used to acquire the conversation text to be processed of the target object;

[0166] Intention determination module 1720, for determining the target object's tool processing intention based on the conversation text to be processed; the tool processing intention includes developing a game tool or arranging multiple game tools;

[0167] A first document acquisition module 1730 is configured to acquire a tool development document as a target tool document if the tool processing intention is to develop a game tool; the tool development document includes a plurality of preconfigured first attribute fields in the code, a definition of each preconfigured first attribute field, and preconfigured action execution logic;

[0168] A second document acquisition module 1740 is configured to acquire a tool arrangement document as a target tool document if the tool processing intention is to arrange multiple game tools; the tool arrangement document includes multiple preconfigured second attribute fields, a definition of each preconfigured second attribute field, and a preconfigured tool execution method;

[0169] The reply text generation module 1750 is used to generate a reply text corresponding to the conversation text to be processed based on the conversation text to be processed, the target tool document and the simulated conversation text; the reply text includes a tool code for realizing the tool processing intention; the simulated conversation text is generated based on the target tool document, the simulated conversation text includes a simulated conversation text and a simulated reply text, and the simulated reply text includes a simulated tool code.

[0170] As an implementation method, the target tool document is a tool development document, and the tool code can be generated by the following units:

[0171] A first determining unit is used to determine a target field and a target action operation logic for implementing a game tool function from the conversation text to be processed;

[0172] A model creation unit, configured to create an object model including a target field based on the target field, the tool development document, and the simulation tool code;

[0173] The logic adding unit is used to add target action running logic to the object model based on the tool development document and simulation tool code to obtain the tool code.

[0174] As an implementation method, the model creation unit may be specifically used to:

[0175] Based on the target fields, tool development documents and simulation tool codes, the target fields, life cycle stages of the target fields and triggering events of the life cycle stages are created to obtain an object model.

[0176] As an implementation method, the target tool document is a tool arrangement document, and the tool code can be generated by the following units:

[0177] A second determining unit is configured to determine a plurality of game tools to be arranged and execution modes of the plurality of game tools to be arranged from the conversation text to be processed;

[0178] The third determination unit is used to determine the execution order of each game tool to be arranged among the multiple game tools to be arranged based on the execution methods, tool documents and simulation tool codes of the multiple game tools to be arranged, and determine the output field of the first game tool as the input field of the second game tool to obtain the tool code; the execution order of the first game tool is before the execution order of the second game tool, and the execution order of the first game tool is adjacent to the execution order of the second game tool.

[0179] As an embodiment, the processing device 1700 of the game tool may further include:

[0180] An interface creation module, used for creating a user interface including interface elements;

[0181] Binding module, used to bind fields in tool code to interface elements;

[0182] A field detection module is used to execute tool codes and detect fields in the tool codes;

[0183] The element update module is used to update the interface elements based on the changed value of the field in response to the change of the value of the field.

[0184] As an implementation method, the field includes multiple fields, the interface element includes multiple interface elements, and the multiple fields are bound to the multiple interface elements one by one; the field detection module may specifically include:

[0185] Create and add units to create object proxy models and add field dependency detection action execution logic and dependent field update events to the object proxy models. The triggering condition for the dependent field update event is that there is a target field with a changed value in the tool code and the target field has a dependent field with a dependency relationship.

[0186] A detection unit, configured to detect field dependencies of multiple fields in the tool code through an object proxy model;

[0187] Accordingly, the element update module may specifically include:

[0188] a value updating unit, configured to, in response to a change in the value of a target field among the multiple fields, determine a dependent field having a dependency relationship with the target field through a field dependency relationship, trigger a dependent field update event, and update the value of the dependent field;

[0189] The element update unit is used to update the interface elements bound to the target field in the user interface based on the changed value of the target field; and to update the interface elements bound to the dependent field in the user interface based on the changed value of the dependent field.

[0190] As an implementation, the reply text generation module 1750 may be specifically configured to:

[0191] The conversation text to be processed, the target tool document, and the simulated conversation text are input as prompt words into the large language model to generate a response text; the response text includes the tool code and prompt text about the processing results of the tool's processing intention; the large language model is fine-tuned based on multiple conversation texts.

[0192] As an embodiment, the tool processing intention further includes executing the target game tool. The processing device 1700 of the game tool may further include:

[0193] The third document acquisition module is used to acquire the tool arrangement document as the target tool document if the tool processing intention is to execute the target game tool.

[0194] Next, the structures of the processing devices of the gaming tools will be introduced in terms of server form and terminal device form respectively.

[0195] An embodiment of the present application provides a processing device for a gaming tool, which may be a server. Figure 18 : This is a schematic diagram of a server structure provided by an embodiment of the present application. The server 900 may have relatively large differences due to different configurations or performances, and may include one or more central processing units (CPUs) 922 (for example, one or more processors) and memories 932, and one or more storage media 930 (for example, one or more mass storage devices) for storing application programs 942 or data 944. Among them, the memories 932 and the storage media 930 can be temporary storage or permanent storage. The program stored in the storage medium 930 may include one or more modules (not shown in the figure), and each module may include a series of instruction operations on the server. Furthermore, the central processing unit 922 can be configured to communicate with the storage medium 930 to execute a series of instruction operations in the storage medium 930 on the server 900.

[0196] The server 900 may also include one or more power supplies 926, one or more wired or wireless network interfaces 950, one or more input and output interfaces 958, and / or one or more operating systems 941, such as Windows Server 2003 or Windows Server 2003R. TM , Mac OS X TM , Unix TM ,Linux TM , FreeBSD TM etc.

[0197] The CPU 922 is configured to execute the following steps:

[0198] Get the target object's conversation text to be processed;

[0199] Determining the target object's tool processing intention based on the conversation text to be processed; the tool processing intention includes developing a game tool or arranging multiple game tools;

[0200] If the tool processing intention is to develop a game tool, obtaining a tool development document as a target tool document; the tool development document includes a plurality of preconfigured first attribute fields in the code, a definition of each preconfigured first attribute field, and preconfigured action execution logic;

[0201] If the tool processing intention is to compile multiple game tools, a tool compilation document is obtained as the target tool document; the tool compilation document includes multiple preconfigured second attribute fields, a definition of each preconfigured second attribute field, and a preconfigured tool execution method;

[0202] Based on the conversation text to be processed, the target tool document and the simulated dialogue text, a reply text corresponding to the conversation text to be processed is generated; the reply text includes a tool code for realizing the tool processing intention; the simulated dialogue text is generated based on the target tool document, the simulated dialogue text includes a simulated conversation text and a simulated reply text, and the simulated reply text includes a simulated tool code.

[0203] The embodiment of the present application also provides another processing device for a game tool, which can be a terminal device. Figure 19 For the sake of convenience, only the parts related to the embodiment of the present application are shown. For specific technical details not disclosed, please refer to the method part of the embodiment of the present application. Take the terminal device as a mobile phone as an example:

[0204] Figure 19 The block diagram shows a partial structure of the mobile phone provided by the embodiment of the present application. Figure 19 The mobile phone includes components such as a radio frequency (RF) circuit 1010, a memory 1020, an input unit 1030, a display unit 1040, a sensor 1050, an audio circuit 1060, a wireless fidelity (WiFi) module 1070, a processor 1080, and a power supply 1090. Those skilled in the art will appreciate that Figure 19 The mobile phone structure shown in the figure does not constitute a limitation to the mobile phone, and may include more or fewer components than shown in the figure, or combine certain components, or arrange the components differently.

[0205] The following combination Figure 19 A detailed introduction to the various components of a mobile phone:

[0206] RF circuitry 1010 can be used to receive and transmit signals during information transmission or calls. Specifically, it receives downlink information from the base station and transmits it to processor 1080 for processing. It also transmits uplink data to the base station. Typically, RF circuitry 1010 includes, but is not limited to, an antenna, at least one amplifier, a transceiver, a coupler, a low-noise amplifier (LNA), a duplexer, and more. RF circuitry 1010 can also communicate with the network and other devices via wireless communications. The above-mentioned wireless communications may use any communication standard or protocol, including but not limited to Global System of Mobile Communications (Global System of Mobile communication, English abbreviation: GSM), General Packet Radio Service (English full name: General Packet Radio Service, GPRS), Code Division Multiple Access (English full name: Code Division Multiple Access, English abbreviation: CDMA), Wideband Code Division Multiple Access (English full name: Wideband Code Division Multiple Access, English abbreviation: WCDMA), Long Term Evolution (English full name: Long Term Evolution, English abbreviation: LTE), email, Short Messaging Service (English full name: Short Messaging Service, SMS), etc.

[0207] The memory 1020 can be used to store software programs and modules. The processor 1080 executes the various functional applications and data processing of the mobile phone by running the software programs and modules stored in the memory 1020. The memory 1020 may mainly include a program storage area and a data storage area. The program storage area may store an operating system and at least one application required for a function (such as a sound playback function, an image playback function, etc.); the data storage area may store data created based on the use of the mobile phone (such as audio data, a phone book, etc.). In addition, the memory 1020 may include high-speed random access memory and may also include non-volatile memory, such as at least one disk storage device, a flash memory device, or other volatile solid-state memory device.

[0208] The input unit 1030 can be used to receive input digital or character information, and to generate key signal input related to the user settings and function control of the mobile phone. Specifically, the input unit 1030 may include a touch panel 1031 and other input devices 1032. The touch panel 1031, also known as a touch screen, can collect user touch operations on or near it (such as operations performed by the user using any suitable object or accessory such as a finger, stylus, etc. on or near the touch panel 1031) and drive the corresponding connection device according to a pre-set program. Optionally, the touch panel 1031 may include two parts: a touch detection device and a touch controller. Among them, the touch detection device detects the user's touch direction and detects the signal caused by the touch operation, and transmits the signal to the touch controller; the touch controller receives the touch information from the touch detection device and converts it into touch point coordinates, which are then sent to the processor 1080. It can also receive commands sent by the processor 1080 and execute them. In addition, the touch panel 1031 can be implemented using various types such as resistive, capacitive, infrared and surface acoustic wave. In addition to the touch panel 1031, the input unit 1030 may further include other input devices 1032. Specifically, the other input devices 1032 may include, but are not limited to, one or more of a physical keyboard, function keys (such as volume control keys, switch keys, etc.), a trackball, a mouse, and a joystick.

[0209] The display unit 1040 can be used to display information input by the user or information provided to the user and various menus of the mobile phone. The display unit 1040 may include a display panel 1041. Optionally, the display panel 1041 may be configured in the form of a liquid crystal display (English full name: Liquid Crystal Display, English abbreviation: LCD), an organic light-emitting diode (English full name: Organic Light-Emitting Diode, English abbreviation: OLED), etc. Further, the touch panel 1031 may cover the display panel 1041. When the touch panel 1031 detects a touch operation on or near it, it is transmitted to the processor 1080 to determine the type of touch event. Subsequently, the processor 1080 provides corresponding visual output on the display panel 1041 according to the type of touch event. Although in Figure 19 In the embodiment, the touch panel 1031 and the display panel 1041 are used as two independent components to realize the input and output functions of the mobile phone, but in some embodiments, the touch panel 1031 and the display panel 1041 can be integrated to realize the input and output functions of the mobile phone.

[0210] The mobile phone may also include at least one sensor 1050, such as a light sensor, a motion sensor, and other sensors. Specifically, the light sensor may include an ambient light sensor and a proximity sensor, wherein the ambient light sensor may adjust the brightness of the display panel 1041 according to the brightness of the ambient light, and the proximity sensor may turn off the display panel 1041 and / or the backlight when the mobile phone is moved to the ear. As a type of motion sensor, the accelerometer sensor can detect the magnitude of acceleration in all directions (generally three axes), and can detect the magnitude and direction of gravity when stationary. It can be used for applications that identify the posture of the mobile phone (such as horizontal and vertical screen switching, related games, magnetometer posture calibration), vibration recognition related functions (such as pedometer, tapping), etc.; as for other sensors that the mobile phone can also be configured with, such as gyroscopes, barometers, hygrometers, thermometers, infrared sensors, etc., they will not be described here.

[0211] Audio circuit 1060, speaker 1061, and microphone 1062 provide an audio interface between the user and the phone. Audio circuit 1060 converts received audio data into electrical signals and transmits them to speaker 1061, which then converts them into sound signals for output. Microphone 1062, on the other hand, converts collected sound signals into electrical signals, which are then received by audio circuit 1060 and converted into audio data. The audio data is then processed by processor 1080 and transmitted to, for example, another phone via RF circuit 1010, or stored in memory 1020 for further processing.

[0212] WiFi is a short-range wireless transmission technology. The mobile phone can help users send and receive emails, browse the web and access streaming media through the WiFi module 1070. It provides users with wireless broadband Internet access. Figure 19 A WiFi module 1070 is shown, but it is understandable that it is not an essential component of the mobile phone and can be omitted as needed without changing the essence of the invention.

[0213] Processor 1080 is the control center of the phone, connecting all parts of the phone using various interfaces and circuits. By running or executing software programs and / or modules stored in memory 1020 and accessing data stored in memory 1020, it executes various phone functions and processes data, thereby collecting data and information about the phone as a whole. Optionally, processor 1080 may include one or more processing units; preferably, processor 1080 may integrate an application processor and a modem processor, where the application processor primarily handles the operating system, user interface, and application programs, while the modem processor primarily handles wireless communications. It is understood that the modem processor may not be integrated into processor 1080.

[0214] The mobile phone also includes a power supply 1090 (such as a battery) for supplying power to various components. Preferably, the power supply can be logically connected to the processor 1080 through a power management system, thereby managing charging, discharging, and power consumption through the power management system.

[0215] Although not shown, the mobile phone may also include a camera, a Bluetooth module, etc., which will not be described in detail here.

[0216] In the embodiment of the present application, the processor 1080 included in the mobile phone also has the following functions:

[0217] Get the target object's conversation text to be processed;

[0218] Determining the target object's tool processing intention based on the conversation text to be processed; the tool processing intention includes developing a game tool or arranging multiple game tools;

[0219] If the tool processing intention is to develop a game tool, obtaining a tool development document as a target tool document; the tool development document includes a plurality of preconfigured first attribute fields in the code, a definition of each preconfigured first attribute field, and preconfigured action execution logic;

[0220] If the tool processing intention is to compile multiple game tools, a tool compilation document is obtained as the target tool document; the tool compilation document includes multiple preconfigured second attribute fields, a definition of each preconfigured second attribute field, and a preconfigured tool execution method;

[0221] Based on the conversation text to be processed, the target tool document and the simulated dialogue text, a reply text corresponding to the conversation text to be processed is generated; the reply text includes a tool code for realizing the tool processing intention; the simulated dialogue text is generated based on the target tool document, the simulated dialogue text includes a simulated conversation text and a simulated reply text, and the simulated reply text includes a simulated tool code.

[0222] An embodiment of the present application also provides a computer-readable storage medium for storing a computer program. When the computer program runs on a processing device of a game tool, the processing device of the game tool executes any one of the implementation methods of a game tool described in the aforementioned embodiments.

[0223] An embodiment of the present application also provides a computer program product including a computer program, which, when run on a processing device of a game tool, enables the processing device of the game tool to execute any one of the implementation methods of a game tool described in the aforementioned embodiments.

[0224] Those skilled in the art will clearly understand that, for the convenience and brevity of description, the specific working processes of the above-described systems and devices can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0225] In the several embodiments provided in this application, it should be understood that the disclosed systems and methods can be implemented in other ways. For example, the system embodiments described above are merely illustrative. For example, the division of the system is merely a logical function division. In actual implementation, there may be other division methods, such as multiple systems can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be an indirect coupling or communication connection through some interface, device or unit, which can be electrical, mechanical or other forms.

[0226] The systems described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed across multiple network units. Some or all of these units may be selected to achieve the objectives of this embodiment as needed.

[0227] In addition, the functional units in the various embodiments of the present application may be integrated into a single processing unit, or each unit may exist physically separately, or two or more units may be integrated into a single unit. The aforementioned integrated units may be implemented in the form of hardware or software functional units.

[0228] If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application is essentially or the part that contributes to the prior art or all or part of the technical solution can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes several instructions for enabling a computer device (which can be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the method described in each embodiment of the present application. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (English full name: Read-Only Memory, English abbreviation: ROM), random access memory (English full name: Random Access Memory, English abbreviation: RAM), disk or optical disk and other media that can store computer programs.

[0229] In the embodiments of the present application, the term "module" or "unit" refers to a computer program or a part of a computer program that has a predetermined function and works together with other related parts to achieve a predetermined goal, and can be implemented in whole or in part by using software, hardware (such as processing circuits or memories), or a combination thereof. Similarly, a processor (or multiple processors or memories) can be used to implement one or more modules or units. In addition, each module or unit can be part of an overall module or unit that includes the functions of the module or unit.

[0230] The above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present application.< / level> < / dir>

Claims

1. A method for processing game tools, characterized in that: include: Get the target object's conversation text to be processed; Determining the tool processing intention of the target object based on the conversation text to be processed; The tool processing intention includes developing a game tool or arranging multiple game tools; If the tool processing intention is to develop a game tool, obtaining a tool development document as a target tool document; The tool development document includes a plurality of preconfigured first attribute fields in the code, a definition of each preconfigured first attribute field, and preconfigured action execution logic; If the tool processing intention is to compile multiple game tools, a tool compilation document is obtained as the target tool document; the tool compilation document includes multiple preconfigured second attribute fields, a definition of each preconfigured second attribute field, and a preconfigured tool execution method; Generate a reply text corresponding to the conversation text to be processed based on the conversation text to be processed, the target tool document and the simulated conversation text; The reply text includes a tool code for realizing the tool processing intention; the simulated dialogue text is generated based on the target tool document, the simulated dialogue text includes a simulated conversation text and a simulated reply text, and the simulated reply text includes a simulated tool code.

2. The method according to claim 1, characterized in that The target tool document is the tool development document; the step of generating the tool code includes: Determining a target field and target action operation logic for implementing a game tool function from the conversation text to be processed; Creating an object model including the target field based on the target field, the tool development document and the simulation tool code; Based on the tool development document and the simulation tool code, the target action running logic is added to the object model to obtain the tool code.

3. The method according to claim 2, characterized in that The step of creating an object model including the target field based on the target field, the tool development document, and the simulation tool code includes: Based on the target field, the tool development document and the simulation tool code, the target field, the life cycle stage of the target field and the triggering event of the life cycle stage are created to obtain the object model.

4. The method according to claim 1, wherein The target tool document is the tool arrangement document; The steps of generating the tool code include: Determining a plurality of game tools to be arranged and execution modes of the plurality of game tools to be arranged from the conversation text to be processed; Based on the execution methods of the multiple game tools to be arranged, the tool documents and the simulation tool code, among the multiple game tools to be arranged, the execution order of each game tool to be arranged is determined, and the output field of the first game tool is determined to be the input field of the second game tool to obtain the tool code; the execution order of the first game tool is before the execution order of the second game tool, and the execution order of the first game tool is adjacent to the execution order of the second game tool.

5. The method according to claim 1, wherein Also includes: Create user interfaces including interface elements; Binding the fields in the tool code to the interface elements; executing the tool code and detecting fields in the tool code; In response to a change in the value of the field, the interface element is updated based on the changed value of the field.

6. The method according to claim 5, characterized in that The field includes a plurality of fields, the interface element includes a plurality of interface elements, and the plurality of fields are bound to the plurality of interface elements one by one; The detecting of the fields in the tool code includes: Create an object proxy model, and add field dependency detection action execution logic and dependency field update events to the object proxy model; the triggering condition of the dependency field update event is that there is a target field whose value has changed in the tool code and the target field has a dependent field with a dependency relationship; Detecting field dependencies of multiple fields in the tool code through the object proxy model; In response to a change in the value of the field, updating the interface element based on the changed value of the field includes: In response to a change in the value of a target field among the multiple fields, determining a dependent field having a dependency relationship with the target field through the field dependency relationship, triggering the dependent field update event, and updating the value of the dependent field; Based on the changed value of the target field, the interface element in the user interface that is bound to the target field is updated; and based on the changed value of the dependent field, the interface element in the user interface that is bound to the dependent field is updated.

7. The method according to any one of claims 1 to 6, characterized in that The step of generating a reply text corresponding to the conversation text to be processed based on the conversation text to be processed, the target tool document, and the simulated conversation text includes: The conversation text to be processed, the target tool document, and the simulated conversation text are input as prompt words into a large language model to generate the reply text; the reply text includes the tool code and prompt text about the processing result of the tool processing intention; the large language model is obtained by fine-tuning based on multiple conversation texts.

8. The method according to any one of claims 1 to 6, characterized in that The tool processing intention further includes executing a target game tool. Before generating a reply text corresponding to the conversation text to be processed based on the conversation text to be processed, the target tool document, and the simulated conversation text, the method further includes: If the tool processing intention is to execute a target game tool, the tool arrangement document is obtained as the target tool document.

9. A device for processing game tools, characterized in that: include: A text acquisition module is used to obtain the conversation text to be processed by the target object; an intention determination module, configured to determine the tool processing intention of the target object based on the conversation text to be processed; The tool processing intention includes developing a game tool or arranging multiple game tools; A first document acquisition module is configured to acquire a tool development document as a target tool document if the tool processing intention is to develop a game tool; the tool development document includes a plurality of preconfigured first attribute fields in the code, a definition of each preconfigured first attribute field, and preconfigured action execution logic; a second document acquisition module configured to acquire a tool arrangement document as the target tool document if the tool processing intention is to arrange multiple game tools; the tool arrangement document comprising a plurality of preconfigured second attribute fields, a definition of each preconfigured second attribute field, and a preconfigured tool execution method; A reply text generation module, configured to generate a reply text corresponding to the conversation text to be processed based on the conversation text to be processed, the target tool document, and the simulated conversation text; The reply text includes a tool code for realizing the tool processing intention; the simulated dialogue text is generated based on the target tool document, the simulated dialogue text includes a simulated conversation text and a simulated reply text, and the simulated reply text includes a simulated tool code.

10. A processing device for a game tool, characterized in that: The device includes a processor and a memory: The memory is used to store a computer program and transmit the computer program to the processor; The processor is configured to execute the steps of the method for processing a game tool according to any one of claims 1 to 8 according to instructions in the computer program.

11. A computer-readable storage medium, characterized in that The computer-readable storage medium is used to store a computer program, and when the computer program is executed by a processing device of a game tool, the steps of the processing method of the game tool according to any one of claims 1 to 8 are implemented.

12. A computer program product, characterized in that The invention comprises a computer program, which implements the steps of the processing method of the game tool according to any one of claims 1 to 8 when the computer program is executed by a processing device of the game tool.

Images