A game battle data editing system, method and medium

Abstract

The application relates to a game battle data editing system, method and medium, wherein the system comprises a node packaging module, which is used for packaging battle parameters into a function template, and the function template is reused through a function template parameter and a reference mechanism; a real-time compiling module, which is connected with the node packaging module and is used for compiling editing data in the node editing module in real time through data conversion rules; a cooperation module, which is used for simultaneously editing the function template by multiple users and determining node editing operations corresponding to the users according to unique user identification codes; and a cross-scene interaction module, which is used for migrating the function template to scenes with different battle logics. The modules work cooperatively to form a complete solution from logic design to cross-scene deployment, shorten the development cycle of the battle logic, and solve the problem of low game battle data editing efficiency in related technologies.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of games, in particular to a game battle data editing system, method and medium. BACKGROUND

[0002] In the field of game development, the editing and implementation of battle systems usually rely on directly writing code in programming languages (such as C++, Lua or C#) or configuring through fixed templates.

[0003] At present, in common game skill editing, the entire project needs to be recompiled after modifying the logic, which seriously affects the development efficiency.

[0004] Therefore, it is urgent to provide an efficient game battle data editing method to solve the above problems. SUMMARY

[0005] The embodiments of the present application provide a game battle data editing system, method and medium to at least solve the problem of low game battle data editing efficiency in related technologies.

[0006] In a first aspect, the embodiments of the present application provide a game battle data editing system, which comprises:

[0007] A node packaging module is configured to package battle parameters into a function template, and reuse the function template according to function template parameters and a reference mechanism.

[0008] A collaboration module is configured to edit the function template by multiple users, and determine node editing operations of the users according to unique user identification codes.

[0009] A cross-scene interaction module is configured to migrate the function template to scenes with different battle logics.

[0010] A real-time compiling module is connected to the node packaging module, and is configured to compile editing data in the node packaging module in real time through data conversion rules.

[0011] In an embodiment, when reusing the function template according to function template parameters and a reference mechanism, the node packaging module is further configured to:

[0012] Generate parameter values of custom parameters in the function template through a natural language processing model, wherein the natural language processing model generates parameter values meeting requirements based on parameter type constraints predefined by the function template, according to received natural language descriptions or historical configuration data.

[0013] Call the function template generating parameter values through a node identifier to reuse the function template, wherein when calling, battle parameters in the function template are transmitted to a target function template.

[0014] In an embodiment, the node packaging module is further configured to:

[0015] parsing the natural language description through a natural language processing engine to obtain parameter requirements according to the received natural language description;

[0016] performing type matching and validity checking on the parameter requirements according to the parameter type constraints predefined in the function template;

[0017] generating parameter values meeting the parameter type constraints through a parameter generator based on the parameter requirements after type matching and checking;

[0018] Alternatively,

[0019] training a parameter configuration mode library through a machine learning model based on historical configuration data;

[0020] retrieving matching parameter values from the parameter configuration mode library according to the identifier of the current function template and the parameter type constraints predefined in the function template.

[0021] In an embodiment, the editing data is table data, and the real-time compiling module is further configured to:

[0022] convert the table data of the function template into structured binary data through data serialization or deserialization processing,

[0023] in response to receiving an editing instruction of the current node packaging module, real-time compiling the binary data, wherein if the object of the editing instruction is consistent with the object in the original binary data, modifying the properties or connection relationships of the object according to the editing instruction.

[0024] In an embodiment, in the collaboration module, the node editing operation corresponding to the user is determined through the user unique identification code, and the collaboration module is further configured to:

[0025] extracting a user local network address to generate a user unique identification code;

[0026] using the user unique identification code and an auto-incrementing serial number as a node identifier, wherein the auto-incrementing serial number is a numerical sequence that is incremented by a fixed step;

[0027] recording the node editing operation corresponding to the node identifier, and determining the node editing operation corresponding to the user based on the user unique identification code.

[0028] In one embodiment, when migrating the functional template to scenarios with different combat logics in the cross-scene interaction module, it is further used for:

[0029] The table data of the functional template is converted into binary data and temporarily stored through a data caching mechanism;

[0030] The binary data is migrated to the target scenario, and automatically adapted according to the configuration specifications of the target scenario through preset data mapping rules, including parameter name conversion, logical rule replacement, and resource path correction.

[0031] In one embodiment, the system further includes a node debugging module for breakpoint debugging of running functional templates; wherein, the node debugging module includes:

[0032] A breakpoint setting unit is used to set unconditional breakpoints and conditional breakpoints on the function template, wherein the conditional breakpoints are configured based on the triggering conditions of runtime variable values.

[0033] A multi-threaded capture unit is used to capture breakpoint-triggered events in the C++ multi-threaded combat logic runtime environment.

[0034] The status monitoring unit is used to freeze the game thread and display the current node parameters, variable status and logic flow when the breakpoint is triggered;

[0035] The modification unit is used to modify node parameters or logical relationships while the node is paused at a breakpoint.

[0036] In one embodiment, the system further includes a logic visualization module for real-time display of the execution flow and state changes of functional modules, wherein the logic visualization module includes:

[0037] The status feedback unit is used to display the parameter input values, output values, and execution status of each functional module in real time;

[0038] Logical annotation units allow users to add visual annotation markers to nodes.

[0039] Secondly, embodiments of this application provide a method for editing game combat data, applied to the aforementioned system, the method comprising:

[0040] Combat parameters are encapsulated into functional templates, and the functional templates are reused based on the functional template parameters and referencing mechanism.

[0041] The function template is edited by multiple users, and the node editing operation corresponding to the user is determined based on the user's unique identifier.

[0042] migrate the function template to a scene with different battle logic;

[0043] compile the edited data in the function template in real time through a data conversion rule.

[0044] In a third aspect, an embodiment of the present application provides a computer device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, and the processor implements the game battle data editing system according to the first aspect.

[0045] In a fourth aspect, an embodiment of the present application provides a computer readable storage medium, having a computer program stored thereon, and the program is executable on a processor to implement the game battle data editing system according to the first aspect.

[0046] The game battle data editing system, method and medium provided by the embodiment of the present application have at least the following technical effects.

[0047] The battle parameter is standardized and packaged into a reusable function template through the node packaging module, and the parameter expansion and reference mechanism are matched, so that the development efficiency of the battle logic is effectively improved, and the technical threshold is reduced. The real-time compiling module realizes the instant compiling of the edited data based on the data conversion rule, so that the compiling waiting time in the traditional development is saved, and the "what you see is what you get" development experience is realized. The collaboration module uses the unique identification code to accurately track the multi-user editing behavior, so that the team collaboration conflict is reduced, and the problem positioning efficiency is improved. The cross-scene interaction module breaks the scene barrier through the standardized migration mechanism, improves the reuse rate of the function template, and significantly reduces the repeated development cost. The modules work together to form a complete solution from logic design to cross-scene deployment, shorten the development cycle of the battle logic, and solve the problem of low game battle data editing efficiency in related technologies.

[0048] Details of one or more embodiments of the present application are presented in the following drawings and description to make other features, objects and advantages of the present application more apparent. BRIEF DESCRIPTION OF DRAWINGS

[0049] The drawings described herein are used to provide further understanding of the present application, and form a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application, and do not constitute an improper limitation on the present application. In the drawings:

[0050] Figure 1 is a system structure block diagram of game battle data editing according to an exemplary embodiment;

[0051] Figure 2 is a schematic diagram of a packaged function template according to an exemplary embodiment;

[0052] Figure 3 is a flow chart of a game battle data editing method according to an exemplary embodiment;

[0053] Figure 4 is a structural block diagram of an electronic device according to an exemplary embodiment. DETAILED DESCRIPTION

[0054] For the purpose of making the objects, technical solutions and advantages of the present application clearer, the present application is described and explained below in connection with the drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application and should not be used to limit the present application. Based on the embodiments provided in the present application, all other embodiments obtained by those of ordinary skill in the art without creative effort belong to the scope of protection of the present application.

[0055] Obviously, the drawings in the following description are only some examples or embodiments of the present application, and for those of ordinary skill in the art, the present application can be applied to other similar scenarios without creative effort based on these drawings. In addition, it can be understood that although the efforts made in this development process can be complex and lengthy, for those of ordinary skill in the art related to the content disclosed in the present application, some design, manufacture or production changes based on the technical content disclosed in the present application are only routine technical means, and should not be understood as insufficient disclosure of the content disclosed in the present application.

[0056] In the present application, "embodiments" means that the specific features, structures or characteristics described in connection with the embodiments can be included in at least one embodiment of the present application. The phrase appears at various places in the specification does not necessarily all refer to the same embodiment, nor is it necessarily independent or alternative embodiments to other embodiments. It is explicitly and implicitly understood by those of ordinary skill in the art that the embodiments described in the present application can be combined with other embodiments without conflict.

[0057] Unless otherwise defined, technical terms and scientific terms used in the present application shall have the same meaning as commonly understood by one of ordinary skill in the art to which this application pertains. The terms "a", "an", "one", "this", and similar referents in the context of describing the application are to be construed to be open-ended, referring to one or more than one, unless otherwise noted. The terms "including", "comprising", "having" and variations thereof in this application are meant to encompass the items listed thereafter, and any equivalent thereof, without limitation. The terms "connected", "coupled", and similar referents in the context of this application are to be construed as possibly having some form of physical and / or electrical connection, without limitation, unless otherwise noted. The term "multiple" means two or more. The term "and / or" includes combinations thereof, and / or any of the items listed. The term "first", "second", "third", and the like in the context of this application are used for clarity, and do not necessarily have a specific ordering other than that which is inherent in a particular context. The term "plurality" means two or more.

[0058] In this document, the term "techniques" can refer to techniques, methods, procedures, and / or other processes that can be implemented in hardware, firmware, software, and / or combinations thereof. The term "techniques" can also refer to techniques, methods, procedures, and / or other processes that can be implemented in hardware, firmware, software, and / or combinations thereof.

[0059] Function Template: In the context of game battle data editing, it refers to encapsulating battle logic (such as damage calculation, displacement control, special effect triggering, etc.) as reusable standardized nodes.

[0060] Function Template Parameter: Adding or modifying input / output parameters (such as adding a "critical hit damage multiplier" field) to a function template, and supporting type constraints (integer, floating point, etc.) and default value configuration.

[0061] Reference Mechanism: Function templates directly call other function templates. The referenced template (such as "burn effect") can receive parameters passed through by the main template and return the execution result.

[0062] Auto-incrementing Serial Number: Node ID generation rule, based on editor IP suffix (such as 192.168.1.100 taking 100) to splice 6-bit auto-incrementing numbers (such as 100000001, 100000002), to ensure global uniqueness of the node.

[0063] Data caching mechanism: In the compilation process, the loaded table data (such as skill configuration table) is cached in memory. If the data is modified, only the difference is updated instead of reloading the entire data.

[0064] Breakpoint debugging: Simulate code debugging function in visual editing, allow to pause execution at specific node (unconditional breakpoint), or trigger pause according to variable value (conditional breakpoint, such as "interrupt when damage>1000").

[0065] In a first aspect, the embodiments of the present application provide a game battle data editing system, method and medium, Figure 1 is a system structure block diagram of game battle data editing according to an exemplary embodiment, as Figure 1 shown, the system comprises:

[0066] The node packaging module 110 is used for packaging the battle parameters into a function template, and reusing the function template through a function template parameter and a reference mechanism.

[0067] The collaboration module 120 is used for editing the function template by multiple users, and determining the node editing operation of the user according to a unique identification code of the user.

[0068] The cross-scene interaction module 130 is used for migrating the function template to a scene with different battle logic.

[0069] The real-time compilation module 140 is connected with the node packaging module 110, and is used for compiling the editing data in the node packaging module 110 in real time through a data conversion rule.

[0070] In summary, the embodiments of the present application provide a game battle data editing system. The node packaging module 110 standardizes and packages the battle parameters into reusable function templates, and effectively improves the development efficiency of battle logic and reduces the technical threshold by cooperating with parameter expansion and reference mechanism. The real-time compilation module 140 realizes instant compilation of editing data based on a data conversion rule, saves the compilation waiting time in traditional development, and realizes the development experience of "what you see is what you get". The collaboration module 120 accurately tracks the multi-user editing behavior by using a unique identification code, reduces the team collaboration conflict, and improves the problem positioning efficiency. The cross-scene interaction module 130 breaks the scene barrier through a standardized migration mechanism, improves the reuse rate of the function template, and significantly reduces the repeated development cost. The modules work together to form a complete solution from logic design to cross-scene deployment, shorten the development cycle of battle logic, and solve the problem of low efficiency of related technical game battle data editing.

[0071] In an embodiment, the node packaging module 110, when reusing the function template through the function template parameter and the reference mechanism, is also used for:

[0072] generate parameter values of the custom parameters in the function template through a natural language processing model, wherein the natural language processing model generates the parameter values meeting requirements based on parameter type constraints predefined by the function template according to the received natural language description or historical configuration data.

[0073] invoke the function template generating the parameter values through a node identifier to reuse the function template, wherein the battle parameters in the function template are transparently passed to a target function template when the function template is invoked.

[0074] Optionally, first, a user describes a configuration requirement in natural language (such as “create a skill capable of causing high-range fire damage”) or identifies similar historical configuration data as input; then, a built-in natural language processing model performs semantic analysis and intent recognition on the input, extracts core concepts (such as “high damage”, “fire”, and “range”), and maps the concepts to battle parameter labels understandable by the system. Next, the system strictly follows parameter type constraints predefined by the target function template (for example, the “damage value” parameter is constrained to be of the floating-point type, and the “damage type” parameter is constrained to be of the enumeration type containing options such as “fire” and “ice”), performs compliance checking and quantitative conversion on the analyzed parameter intent, and finally generates a set of specific parameter values meeting all type and range requirements (such as quantifying “high damage” to 500.0 points, mapping “fire” to the enumeration value Fire, and activating the “range effect” identifier). After the parameters are generated, the system locates and invokes the function template with completed configuration through a unique node identifier, and in the reuse process, ensures that all battle parameters (including the newly generated parameters) in the template are completely and accurately transparently passed to the target logical context through a reference mechanism.

[0075] By introducing the intelligent parameter generation mechanism, the technical threshold and operation cost of function template configuration are significantly reduced, enabling designers to express design intent in a more intuitive and efficient manner, thereby greatly improving the editing efficiency of battle data. More importantly, by forcibly constraining natural language descriptions within a predefined type and rule system, this process improves ease of use while fundamentally ensuring the structural validity of generated parameters, enhancing the reliability and robustness of the entire battle data system.

[0076] In an embodiment, the node encapsulation module is further configured to:

[0077] According to the received natural language description, the natural language description is parsed by a natural language processing engine to obtain parameter requirements. According to the parameter type constraint predefined in the function template, the parameter requirements are type matched and legally verified.

[0078] Through the parameter generator, based on the type matched and verified parameter requirements, parameter values conforming to the parameter type constraint are generated. Or,

[0079] Based on historical configuration data, a parameter configuration mode library is obtained by machine learning model training.

[0080] According to the identifier of the current function template and the parameter type constraint predefined in the function template, the matching parameter value is retrieved from the parameter configuration mode library.

[0081] Optionally, when receiving a natural language description (such as "a powerful single attack that can knock back the enemy"), the natural language processing engine will first perform semantic role labeling and keyword extraction to convert the ambiguous description into structured "parameter requirements" (such as {effect: knock back, strength: powerful, target: single}). Then, the system will strictly match and verify the legality of this requirement with the parameter type constraint of the target function template, for example, confirming that "strength" can be mapped to a floating-point damage coefficient parameter, and the generated value is within the preset [1.0, 10.0] range; The "knock back" effect is checked whether the Boolean type knock back parameter exists. After verification, the parameter generator will generate the final compliant parameter value according to the mapping rule (such as quantifying "powerful" as damage coefficient = 7.5). Or the system will continuously collect historical configuration data, train through a machine learning model (such as clustering or sequence model), and build a parameter configuration mode library that records the common combinations and value rules of various parameters under different function template identifiers. When configuring parameters for the current template, the system will use its identifier as an index to retrieve the historical verified high-frequency or optimal parameter values from the mode library as recommendations.

[0082] Through the natural language analysis path, the direct description is converted into precise machine instructions, greatly improving the ease of use and efficiency of configuration; and the path based on historical data learning integrates collective experience and data rules, so that parameter configuration is no longer isolated creation, but intelligent recommendation based on historical best practices, significantly improving the quality and rationality of the configuration scheme.

[0083] In addition, the function template parameter and reference mechanism reuse function template can also be customized. Specifically, it includes:

[0084] Customizing function template parameters for function templates includes parameter customization, parameter type constraint configuration, and default parameter configuration. Among them:

[0085] The parameter self-defined configuration includes self-defined changes of the battle parameters;

[0086] The parameter type constraint configuration includes forcedly specifying a data type for each parameter, including integer type, floating point type, Boolean type and enumeration type;

[0087] The default parameter configuration includes setting an initial default value for each parameter and automatically loading when the node is instantiated.

[0088] The function template is called after the configuration function template parameters through the node identifier to reuse the function template, wherein the battle parameters in the function template are transparently passed to the target function template when called.

[0089] Optionally, Figure 2 is a schematic diagram of a packaging function template according to an exemplary embodiment, as Figure 2 shown, the external only needs to fill in the relevant displacement parameters, that is, the displacement effect can be realized. Specifically, based on dynamic modification of node parameters, the battle elements (damage calculation, special effect triggering, etc.) are packaged as a dragable function node (function module), and node reference is supported, editor internal encapsulation function is provided, and the general function encapsulation and reuse efficiency is greatly improved, the development efficiency is improved, and the planner can encapsulate templates for rapid iterative development. The node configuration function template parameter supports configuration of self-defined parameters (supporting parameter self-defined extension, supporting parameter type constraint, supporting default value configuration, etc.). In addition to the effect node, the condition node, the screening node and the like support parameter extension template encapsulation function. For example:

[0090] The displacement calculation logic is packaged as a displacement function template, and the displacement function template includes speed, distance and direction parameters.

[0091] The damage calculation logic is packaged as a damage function template, and the damage function template includes a basic damage value, a critical hit rate and a damage type parameter.

[0092] The special effect triggering logic is packaged as a special effect function template, and the special effect function template includes a special effect resource and a triggering condition parameter.

[0093] The parameter self-defined configuration allows to add or modify the battle parameters of the function template (such as adding a "knockback distance" field), so that the planner can quickly adapt to diversified skill requirements without the intervention of programmers to modify the underlying code. The parameter type constraint configuration forcibly limits the data type of the parameter (such as "damage value" must be a floating-point type), which avoids runtime exceptions caused by type errors from the design stage and reduces debugging costs. The default parameter configuration automatically loads preset values (such as "crit rate default 30%") when the node is instantiated, which greatly reduces the workload of repeated parameter input and improves editing efficiency. Through the node identifier call and parameter transmission mechanism, the reused function template (such as the displacement template) can directly inherit the parameter values of the calling party (such as "speed = 10 m / s"), realizing the plug-and-play of logic, and the document test data shows that the skill development cycle is greatly shortened.

[0094] In an embodiment, in the cooperation module 120, when determining the node editing operation corresponding to the user through the user unique identifier code, it is also used for:

[0095] Extracting the user's local network address to generate a user unique identifier code.

[0096] The user unique identifier code and the self-incrementing serial number are used as the node identifier, and the self-incrementing serial number is a digital sequence that is incremented by a fixed step.

[0097] Recording the node editing operation corresponding to the node identifier, and determining the node editing operation corresponding to the user based on the user unique identifier code.

[0098] Optionally, the editor's local IP identity is used for automatic allocation of the node ID. The editor node is divided into effect nodes, condition nodes, etc. The starting bit number is set according to the possible number of node extensions. For example, the local editor's IP is 192.168.211.XXX, and the effect node SkillEffectConfig is created. The node ID is XXX000000. Each newly added ID can be incremented, such as XXX000001, XXX000002, etc. The corresponding responsible person can be located through the node prefix, and the self-incrementing mechanism effectively solves the problem of automatic allocation of the ID. The dual identity of the IP and the self-incrementing serial number improves the way of quickly locating and tracing the responsibility of logical problems, and in combination with the SVN version management tool, the responsible person can be quickly located, and the efficiency of repairing problems is improved.

[0099] In an embodiment, in the cross-scene interaction module 130, when migrating the function template to a scene with different battle logic, it is also used for:

[0100] The table data of the function template is converted into binary data through a data caching mechanism and temporarily stored;

[0101] The binary data is migrated to a target scene, and the binary data is automatically adapted according to a configuration specification of the target scene through a preset data mapping rule, including parameter name conversion, logic rule replacement and resource path correction.

[0102] Optionally, the clipboard-based node migration technology supports JSON serialization / deserialization. Similar functions are quickly migrated, and repeated development is avoided.

[0103] Through the data caching mechanism, the table data of the function template is converted into an efficient binary format (such as ProtocolBuffer) for temporary storage, reducing memory occupation and improving read / write speed. When migrating across scenes, the binary data is automatically adapted to the requirements of the target scene through a preset data mapping rule, combined with the clipboard migration technology, and through JSON serialization / deserialization (such as copying a node to generate {"type":"damage","value":100}) to achieve quick reuse of similar functions, avoid repeated development, and significantly reduce development costs.

[0104] In an embodiment, the system further includes a node debugging module for breakpoint debugging of a running function template; wherein the node debugging module includes:

[0105] A breakpoint setting unit for setting unconditional breakpoints and conditional breakpoints on the function template, the conditional breakpoints being configured based on trigger conditions of runtime variable values;

[0106] A multi-threaded capture unit for capturing breakpoint trigger events in a C++ multi-threaded battle logic runtime environment;

[0107] A state monitoring unit for freezing game threads and displaying current node parameters, variable states and logic flow when a breakpoint is triggered;

[0108] A modification unit for modifying node parameters or logic relationships in a breakpoint pause state.

[0109] Optionally, based on the C++ battle logic multi-threaded running mechanism, the editor node breakpoint debugging function is supported, and the conditional breakpoint is supported, so that planners and others can also use similar program code debugging functions, providing more detailed debugging test acceptance means.

[0110] The node debugging module provides debugging capabilities for the function template. The breakpoint setting unit supports unconditional breakpoints (such as fixed in the damage calculation node) and conditional breakpoints based on runtime variables (such as "interrupt when critical hit damage > 5000"). This allows planners to control the debugging logic as precisely as programmers. The multi-threaded capture unit captures cross-thread breakpoint events in real time by hooking the execution flow of the C++ multi-threaded battle system (such as physical threads and special effect threads). This solves the pain point of traditional visualization tools that cannot debug multi-threaded logic. The state monitoring unit freezes the game state when the breakpoint is triggered and displays the parameter values (such as the current damage value = 3250), variable states, and logic flow (highlighted execution path) in three dimensions. This helps developers understand the execution context of complex skills intuitively. The modification unit directly modifies variable values (such as adjusting the damage value from 3250 to 4000) or node connection relationships (such as removing the "knockback" effect) in the paused state. The modifications are immediately verified when the game continues running.

[0111] In an embodiment, the system further includes a logic visualization module for real-time display of the execution flow and state changes of the function modules. The logic visualization module includes:

[0112] A state feedback unit for real-time display of parameter input values, output values, and execution states of each function module.

[0113] A logic annotation unit that allows users to add visual annotation tags to nodes.

[0114] Optionally, based on the node-based editing method, the logic flow is visualized, breaking the program logic black box, making it easier for planners and others to quickly understand the logic mechanism and make quick modifications and verifications.

[0115] The logic visualization module enables visual debugging and collaboration of battle logic. The state feedback unit displays key data streams (such as input parameter damage value = 150 and output result actual damage = 225) and execution states (such as "cooling down / ready") in real time. This is presented intuitively through floating panels or highlighted connections, allowing planners to directly understand the value calculation process. The logic annotation unit allows users to add rich text annotations (such as "this critical hit rate is affected by character level") to nodes and supports keyword search (such as searching for all nodes containing "critical hit" annotations).

[0116] In an embodiment, the editing data is table data. In the real-time compilation module 140, when compiling the editing data in the node encapsulation module 110 in real time through data conversion rules, it is also used for:

[0117] Convert the table data of the function template into structured binary data through data serialization or deserialization processing.

[0118] In response to receiving the editing instruction of the current node encapsulation module 110, the real-time compiling binary data, wherein if the object of the editing instruction is consistent with the object in the original binary data, then the attribute or connection relationship of the object is modified according to the editing instruction.

[0119] Optionally, based on the logic data PB structure serialization / deserialization function, the edited data takes effect immediately without restarting the game client. This greatly avoids repeated verification efficiency and real-time modification verification. The editor edits the data in the form of a table. In addition to the "object <-> binary byte stream", if the table data already exists, only the existing object data is modified, ensuring the normal call of the logic cache table data object and saving memory.

[0120] The serialization / deserialization of binary data through table data converts the editing data of the function template into an efficient structured format, which reduces the data volume while improving the read / write speed. When receiving the editing instruction, the consistency of the data object is intelligently judged. If the edited object already exists in the binary cache (such as the damage value field of "fireball technique"), only the specific attribute of the object is updated incrementally, and other cache data in memory remains unchanged. This optimization reduces memory usage and avoids performance jitter caused by full data reloading.

[0121] In an embodiment, the system is based on the project engine Unity, integrating running, editor, adjustment, and testing in one. The editor data Json record is easy to view and modify, and the editing data is pb data, which is convenient for serialization and deserialization, i.e. supporting real-time dynamic modification of game data to ensure real-time testing. The editing logic flow is node-based, improving the readability of the logic flow and design. Data editing relies on the Odin plug-in, which is integrated with the Unity display editor, making it easy to modify data.

[0122] In summary, the embodiment of the present application provides a game battle data editing system. Through the node encapsulation module 110, the battle parameters are standardized and encapsulated into reusable function templates, which effectively improves the development efficiency of battle logic and reduces the technical threshold. The real-time compiling module 140 realizes the instant compiling of editing data based on data conversion rules, saving the compiling waiting time in traditional development and realizing the "what you see is what you get" development experience. The collaboration module 120 uses a unique identification code to accurately track multi-user editing behavior, reducing team collaboration conflicts and improving problem positioning efficiency. The cross-scene interaction module 130 breaks down the scene barriers through a standardized migration mechanism, improves the reuse rate of the verification function template, and significantly reduces the cost of repeated development. The modules work together to form a complete solution from logic design to cross-scene deployment, shortening the development cycle of battle logic.

[0123] In a second aspect, the embodiments of the present application provide a game battle data editing method. Figure 3 is a flowchart of a game battle data editing method according to an exemplary embodiment. As shown in Figure 3 the method comprises:

[0124] Step S301, encapsulating the battle parameters into a function template, and reusing the function template through a function template parameter and a reference mechanism.

[0125] Step S302, editing the function template by multiple users, and determining a node editing operation of a user according to a unique identification code of the user.

[0126] Step S303, migrating the function template to a scene of different battle logic.

[0127] Step S304, compiling the editing data in the function template in real time through a data conversion rule.

[0128] In an embodiment, the specific workflow is as follows:

[0129] 1. The editing data of the editing system is table data.

[0130] 2. The editing system saves the data in a json format (containing table data).

[0131] 3. The game running data is bytes data.

[0132] 4. Data flow: editor operation of an editing personnel - saving as json data - uploading SVN - Jenkins automatically exporting the table data in the json to Excel - Jenkins automatically exporting the Excel data to game running time data bytes data.

[0133] In addition to the configuration of the editing system, the Excel data also needs to retain the planning editing operation. Therefore, the whole set of processes is retained. In addition, the editor Json data storage advantage facilitates SVN blame for checking responsibility and viewing modification content diff.

[0134] In summary, the embodiment of the present application provides a game battle data editing method. By standardizing and encapsulating battle parameters into reusable function templates, cooperating with parameter expansion and reference mechanism, the development efficiency of battle logic is effectively improved, and the technical threshold is reduced. Real-time compilation based on data conversion rules realizes instant compilation of edited data, saves the compilation waiting time in traditional development, and realizes the "what you see is what you get" development experience. Adopting unique identification code to accurately track multi-user editing behavior reduces team collaboration conflicts and improves problem positioning efficiency. Cross-scene interaction breaks the scene barrier through standardized migration mechanism, improves the reuse rate of function templates, significantly reduces the cost of repeated development, and shortens the development cycle of battle logic. The problem of low game battle data editing efficiency in related technologies is solved.

[0135] It should be noted that the game battle data editing system provided by the embodiment is used to implement the above-mentioned embodiments, and the description of which has been made. As used above, the terms "module", "unit", "sub-unit", and the like can be a combination of software and / or hardware that implements a predetermined function. Although the above embodiment describes the device preferably implemented in software, the implementation of hardware, or a combination of software and hardware is also possible and conceived.

[0136] In a third aspect, the embodiment of the present application provides an electronic device, Figure 4 is a block diagram of an electronic device according to an exemplary embodiment. As Figure 4 indicated, the electronic device can include a processor 41 and a memory 42 storing computer program instructions.

[0137] Specifically, the above-mentioned processor 41 can include a central processing unit (CPU), or a specific integrated circuit (Application Specific Integrated Circuit, ASIC), or can be configured as one or more integrated circuits that implement one or more embodiments of the present application.

[0138] The memory 42 can include a mass storage for data or instructions. By way of example and not limitation, the memory 42 can include a Hard Disk Drive (HDD), floppy disk drive, a Solid State Drive (SSD), flash memory, a Compact Disc Read Only Memory (CDROM), a Digital Versatile Disk (DVD), a magnetic tape, or a Universal Serial Bus (USB) drive, or a combination of two or more of these. The memory 42 can be removable and / or non-removable (or fixed) as appropriate. The memory 42 can be internal or external as appropriate. In particular embodiments, the memory 42 is a Non-Volatile memory. In particular embodiments, the memory 42 includes a Read-Only Memory (ROM) and a Random-Access Memory (RAM). The ROM can be a mask-programmed ROM, a Programmable ROM (PROM), an Erasable PROM (EPROM), an Electrically EPROM (EEPROM), an Electrically Alterable ROM (EAROM), or a FLASH, or a combination of two or more of these, as appropriate. The RAM can be a Static Random-Access Memory (SRAM) or a Dynamic Random-Access Memory (DRAM), which can be a Fast Page Mode Dynamic Random-Access Memory (FPMDRAM), an Extended Data Output Dynamic Random-Access Memory (EDODRAM), a Synchronous Dynamic Random-Access Memory (SDRAM), or the like, as appropriate.

[0139] The memory 42 can be used to store or buffer various data files required for processing and / or communication, and possible computer program instructions executed by the processor 41.

[0140] The processor 41 reads and executes the computer program instructions stored in the memory 42 to implement any of the game battle data editing methods in the above embodiments.

[0141] In an embodiment, a game battle data editing device can further include a communication interface 43 and a bus 40. Wherein, as shown in the figure, the processor 41, the memory 42, and the communication interface 43 are connected through the bus 40 and complete communication with each other. Figure 4

[0142] The communication interface 43 is used to realize the communication between various modules, devices, units and / or equipment in the embodiments of the present application. The communication interface 43 can also realize data communication with other components, such as external devices, image / data acquisition devices, databases, external storage, and image / data processing workstations, etc.

[0143] ​Bus 40 includes hardware, software, or both, to couple various components of a game battle data editing apparatus to each other. Bus 40 includes, but is not limited to, at least one of the following: a data bus, an address bus, a control bus, an expansion bus, a local bus. By way of example and not limitation, bus 40 can include an Accelerated Graphics Port (AGP) or other graphics bus, an Extended Industry Standard Architecture (EISA) bus, a Front Side Bus (FSB), a Hyper Transport (HT) interconnect, an Industry Standard Architecture (ISA) bus, an InfiniBand interconnect, a Low Pin Count (LPC) bus, a memory bus, a MicroChannel Architecture (MCA) bus, a Peripheral Component Interconnect (PCI) bus, a PCI-Express (PCI-X) bus, a Serial Advanced Technology Attachment (SATA) bus, a Video Electronics Standards Association Local (VLB) bus, or another suitable bus or combination of two or more of these. Where appropriate, bus 40 can include one or more buses. Although this application describes and illustrates a particular bus, this application contemplates any suitable bus or interconnect.

[0144] In a fourth aspect, an embodiment of the present application provides a computer readable storage medium, having stored thereon a program, wherein the program is executed by a processor to implement the game battle data editing method according to the first aspect.

[0145] More specifically, the computer readable storage medium can include, but is not limited to, a portable disc, a hard disk, a random access memory, a read-only memory, an erasable programmable read-only memory, an optical storage device, a magnetic storage device, or any suitable combination of the above.

[0146] In possible implementation manners, the present application can also be implemented in the form of a program product, which comprises program codes for causing a terminal device to execute steps of a game battle data editing method provided by the first aspect when the program product is run on the terminal device.

[0147] The program code for executing the present application can be written in any combination of one or more programming languages, and can be executed completely on a user device, partially on a user device, as a stand-alone software package, partially on a user device and partially on a remote device, or completely on a remote device.

[0148] The technical features of the above-described embodiments can be combined in any manner. To make the description concise, not all possible combinations of the technical features in the above-described embodiments are described, but it should be considered that any combination of the technical features is within the scope of the present disclosure as long as the combination does not result in contradictions.

[0149] The above-described embodiments only express several implementation manners of the present application, and the description is relatively specific and detailed, but it should not be understood as a limitation on the patent scope of the present application. It should be noted that, for those skilled in the art, several modifications and improvements can be made without departing from the concept of the present application, and these are all within the protection scope of the present application. Therefore, the patent protection scope of the present application should be subject to the appended claims.

Claims

1. A game combat data editing system, characterized in that, The system includes: The node encapsulation module is used to encapsulate combat parameters into functional templates, and reuse the functional templates according to the functional template parameters and referencing mechanism; The collaboration module is used to enable multiple users to edit the function template and determine the node editing operation corresponding to each user based on the user's unique identifier. The cross-scene interaction module migrates the functional templates to scenes with different combat logics; A real-time compilation module, connected to the node encapsulation module, is used to compile the edited data in the node encapsulation module in real time according to data conversion rules; The node encapsulation module, when the natural language processing model generates parameter values ​​that meet the requirements based on the received natural language description or historical configuration data and the parameter type constraints predefined in the functional template, is further used for: When the natural language processing model receives a natural language description, it parses the natural language description through the natural language processing engine to obtain the parameter requirements based on the received natural language description. Based on the predefined parameter type constraints in the functional template, the parameter requirements are subjected to type matching and validity verification. The parameter generator generates parameter values ​​that conform to the parameter type constraints based on the parameter requirements after type matching and verification. or, When the natural language processing model receives historical configuration data, it obtains a parameter configuration pattern library by training a machine learning model based on the historical configuration data. Based on the identifier of the current function template and the parameter type constraints predefined by the function template, retrieve matching parameter values ​​from the parameter configuration pattern library.

2. The game combat data editing system according to claim 1, characterized in that, The node encapsulation module, when reusing the function template according to the function template parameters and referencing mechanism, is further configured to: The parameter values ​​of the custom parameters in the function template are generated using a natural language processing model; wherein, the natural language processing model generates the required parameter values ​​based on the received natural language description or historical configuration data and the parameter type constraints predefined in the function template. The function template for generating parameter values ​​is invoked through a node identifier to reuse the function template, wherein, during the invocation, the combat parameters in the function template are passed through to the target function template.

3. The game combat data editing system according to claim 1, characterized in that, The edited data is tabular data. The real-time compilation module, while compiling the edited data in the node encapsulation module in real-time according to data conversion rules, is also used for: The tabular data of the functional template is converted into structured binary data through data serialization or deserialization. In response to receiving the editing instruction from the current node encapsulation module, the binary data is compiled in real time. If the object of the editing instruction is the same as the object in the original binary data, the attributes or connection relationships of the binary data object are modified.

4. The game combat data editing system according to claim 1, characterized in that, The collaboration module, when determining the node editing operation corresponding to the user through the user's unique identifier, is further used for: Extract the user's local network address to generate a unique user identifier; The user's unique identifier and the auto-incrementing sequence number are used as node identifiers, where the auto-incrementing sequence number is a numerical sequence that increments by a fixed step size. Record the node editing operation corresponding to the node identifier, and determine the node editing operation corresponding to the user based on the user's unique identifier.

5. A game combat data editing system according to claim 1, characterized in that, The cross-scene interaction module, when migrating the functional template to scenes with different combat logics, is also used for: The table data of the functional template is converted into binary data and temporarily stored through a data caching mechanism; The binary data is migrated to the target scenario, and automatically adapted according to the configuration specifications of the target scenario through preset data mapping rules, including parameter name conversion, logical rule replacement, and resource path correction.

6. A game combat data editing system according to claim 1, characterized in that, The system also includes a node debugging module for breakpoint debugging of running functional templates; wherein, the node debugging module includes: A breakpoint setting unit is used to set unconditional breakpoints and conditional breakpoints on the function template, wherein the conditional breakpoints are configured based on the triggering conditions of runtime variable values. A multi-threaded capture unit is used to capture breakpoint-triggered events in the C++ multi-threaded combat logic runtime environment. The status monitoring unit is used to freeze the game thread and display the current node parameters, variable status and logic flow when the breakpoint is triggered; The modification unit is used to modify node parameters or logical relationships while the node is paused at a breakpoint.

7. A game combat data editing system according to claim 1, characterized in that, The system also includes a logic visualization module for real-time display of the execution flow and state changes of functional modules, wherein the logic visualization module includes: The status feedback unit is used to display the parameter input values, output values, and execution status of each functional module in real time; Logical annotation units allow users to add visual annotation markers to nodes.

8. A method for editing game combat data, characterized in that, Applied to the system of any one of claims 1-7, the method comprises: Combat parameters are encapsulated into functional templates, and the functional templates are reused based on the functional template parameters and referencing mechanism. The function template is edited by multiple users, and the node editing operation corresponding to the user is determined based on the user's unique identifier. The aforementioned functional templates will be migrated to scenarios with different combat logics; The edited data in the functional template is compiled in real time using data transformation rules; Based on the received natural language description or historical configuration data, and according to the parameter type constraints predefined in the functional template, parameter values ​​that meet the requirements are generated, including: When the natural language processing model receives a natural language description, it parses the natural language description through the natural language processing engine to obtain the parameter requirements based on the received natural language description. Based on the predefined parameter type constraints in the functional template, the parameter requirements are subjected to type matching and validity verification. The parameter generator generates parameter values ​​that conform to the parameter type constraints based on the parameter requirements after type matching and verification. or, When the natural language processing model receives historical configuration data, it obtains a parameter configuration pattern library by training a machine learning model based on the historical configuration data. Based on the identifier of the current function template and the parameter type constraints predefined by the function template, retrieve matching parameter values ​​from the parameter configuration pattern library.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the program is executed by the processor, it implements a game battle data editing system as described in any one of claims 1 to 7.

Images