Game combat data editing system and method and medium

Abstract

The invention relates to a game combat data editing system and method and a medium, and the system comprises a node packaging module which is used for packaging a combat parameter into a function template, and multiplexing the function template through a function template parameter and a reference mechanism. And the real-time compiling module is connected with the node packaging module and is used for compiling the editing data in the node editing module in real time according to the data conversion rule. And the collaboration module is used for simultaneously editing the function templates through multiple users and determining node editing operation corresponding to the users according to the unique identification codes of the users. And the cross-scene interaction module is used for migrating the function template to scenes of different combat logics. All the modules work cooperatively to form a complete solution from logic design to cross-scene deployment, and the development period of combat logic is shortened. The problem of low game combat data editing efficiency in related technologies is solved.

Description

Technical Field

[0001] This application relates to the field of game technology, and in particular to a game battle data editing system, method and medium. Background Technology

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

[0003] Currently, in common game skill editing, modifying the logic requires recompiling the entire project, which seriously affects development efficiency.

[0004] Therefore, there is an urgent need to provide an efficient method for editing game combat data to solve the above problems. Summary of the Invention

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

[0006] In a first aspect, embodiments of this application provide a game combat data editing system, the system comprising: 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 the 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 transformation rules.

[0007] In one embodiment, the node encapsulation module, when reusing the function template according to the function template parameters and the 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.

[0008] In one embodiment, 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 by the functional template, is further configured to: Based on the received natural language description, the natural language processing engine parses the natural language description to obtain the parameter requirements; 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, Based on historical configuration data, a parameter configuration pattern library is obtained through machine learning model training. 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.

[0009] In one embodiment, the edited data is tabular data, and the real-time compilation module, when compiling the edited data in the node encapsulation module in real time according to data conversion rules, is further configured to: By performing data serialization or deserialization, the tabular data of the functional template is converted into structured binary data. 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 object are modified according to the editing instruction.

[0010] In one embodiment, when determining the node editing operation corresponding to the user through the user's unique identifier in the collaboration module, it 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.

[0011] 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: 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.

[0012] In one embodiment, the system further 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.

[0013] 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: 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.

[0014] Secondly, embodiments of this application provide a method for editing game combat data, applied to the aforementioned system, the method comprising: 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.

[0015] Thirdly, embodiments of this application provide a computer device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement a game battle data editing system as described in the first aspect above.

[0016] Fourthly, embodiments of this application provide a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements a game battle data editing system as described in the first aspect above.

[0017] The game battle data editing system, method, and medium provided in this application embodiment have at least the following technical effects.

[0018] The node encapsulation module standardizes and encapsulates combat parameters into reusable functional templates. Combined with parameter expansion and referencing mechanisms, this effectively improves the efficiency of combat logic development while lowering the technical barrier. The real-time compilation module, based on data transformation rules, enables instant compilation of edited data, eliminating compilation waiting time in traditional development and achieving a "what you see is what you get" development experience. The collaboration module uses unique identifiers to accurately track multi-user editing behavior, reducing team collaboration conflicts and improving problem localization efficiency. The cross-scene interaction module breaks down scene barriers through a standardized migration mechanism, increasing the reusability of verification functional templates and significantly reducing repetitive development costs. These modules work together to form a complete solution from logic design to cross-scene deployment, shortening the combat logic development cycle. This addresses the issue of low efficiency in editing game combat data related to this technology.

[0019] Details of one or more embodiments of this application are set forth in the following drawings and description to make other features, objects and advantages of this application more readily apparent. Attached Figure Description

[0020] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings: Figure 1 This is a system architecture block diagram illustrating game combat data editing according to an exemplary embodiment; Figure 2 This is a schematic diagram illustrating an encapsulation function template according to an exemplary embodiment; Figure 3 This is a flowchart illustrating a method for editing game battle data according to an exemplary embodiment; Figure 4 This is a structural block diagram of an electronic device according to an exemplary embodiment. Detailed Implementation

[0021] To make the objectives, technical solutions, and advantages of this application clearer, the application is described and illustrated below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application. All other embodiments obtained by those skilled in the art based on the embodiments provided in this application without inventive effort are within the scope of protection of this application.

[0022] Obviously, the accompanying drawings described below are merely some examples or embodiments of this application. Those skilled in the art can apply this application to other similar scenarios based on these drawings without any inventive effort. Furthermore, it is understood that although the efforts made in this development process may be complex and lengthy, for those skilled in the art related to the content disclosed in this application, any changes to design, manufacturing, or production based on the technical content disclosed in this application are merely conventional technical means and should not be construed as insufficient disclosure of the content of this application.

[0023] In this application, the reference to "embodiment" means that a specific feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of this application. The appearance of this phrase in various places in the specification does not necessarily refer to the same embodiment, nor is it a separate or alternative embodiment that is mutually exclusive with other embodiments. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described in this application may be combined with other embodiments without conflict.

[0024] Unless otherwise defined, the technical or scientific terms used in this application shall have the ordinary meaning understood by one of ordinary skill in the art to which this application pertains. The terms “a,” “an,” “an,” “the,” and similar words used in this application do not indicate quantity limitation and may indicate singular or plural. The terms “comprising,” “including,” “having,” and any variations thereof used in this application are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or device that includes a series of steps or modules (units) is not limited to the listed steps or units, but may also include steps or units not listed, or may include other steps or units inherent to these processes, methods, products, or devices. The terms “connected,” “linked,” “coupled,” and similar words used in this application are not limited to physical or mechanical connections, but may include electrical connections, whether direct or indirect. “Multiple” used in this application refers to two or more. “And / or” describes the relationship between related objects, indicating that three relationships may exist; for example, “A and / or B” can represent: A alone, A and B simultaneously, and B alone. The character " / " generally indicates that the preceding and following objects are in an "or" relationship. The terms "first," "second," and "third" used in this application are merely to distinguish similar objects and do not represent a specific ordering of the objects.

[0025] In this document, it should be understood that the terms used may be technical means used to implement part of the present invention or other summary technical terms. For example, the terms may include: Functional templates: In the game's combat data editing, this refers to encapsulating combat logic (such as damage calculation, displacement control, and special effect triggering) into reusable standardized nodes.

[0026] Function template parameters: Add or modify input / output parameters in the function template (such as adding a "critical hit damage multiplier" field), and support type constraints (integer, floating point, etc.) and default value configuration.

[0027] Reference mechanism: Functional templates can directly call other functional templates. The referenced template (such as "burning effect") can receive parameters passed through by the main template and return the execution result.

[0028] Auto-incrementing serial number: The node ID generation rule is based on the editor's IP suffix (e.g., 192.168.1.100 takes 100) and concatenated with a 6-digit auto-incrementing number (e.g., 100000001, 100000002) to ensure the global uniqueness of the node.

[0029] Data caching mechanism: During compilation, loaded table data (such as skill configuration tables) is cached in memory. If the data is modified, only the differences are updated instead of a full reload.

[0030] Breakpoint debugging: Simulates code debugging functionality in the visual editor, allowing execution to pause at a specific node (unconditional breakpoint), or to pause based on variable values ​​(conditional breakpoint, such as "interrupt when damage > 1000").

[0031] In a first aspect, embodiments of this application provide a game combat data editing system, method, and medium. Figure 1 This is a system architecture block diagram illustrating game combat data editing according to an exemplary embodiment, such as... Figure 1 As shown, the system includes: The node encapsulation module 110 is used to encapsulate combat parameters into functional templates, and reuse functional templates through functional template parameters and a referencing mechanism.

[0032] The collaboration module 120 is used to determine the node editing operation corresponding to a user by using a multi-user editing function template and based on the user's unique identifier code.

[0033] The cross-scene interaction module 130 migrates functional templates to scenes with different combat logics.

[0034] The real-time compilation module 140 is connected to the node encapsulation module 110 and is used to compile the edited data in the node encapsulation module 110 in real time according to the data transformation rules.

[0035] In summary, this application provides a game combat data editing system. The node encapsulation module 110 standardizes and encapsulates combat parameters into reusable functional templates. Combined with parameter expansion and referencing mechanisms, this effectively improves the efficiency of combat logic development while lowering the technical threshold. The real-time compilation module 140, based on data conversion rules, enables instant compilation of edited data, eliminating the compilation waiting time in traditional development and achieving a "what you see is what you get" development experience. The collaboration module 120 uses unique identifiers to accurately track multi-user editing behavior, reducing team collaboration conflicts and improving problem localization efficiency. The cross-scene interaction module 130 breaks down scene barriers through a standardized migration mechanism, improving the reusability of verification functional templates and significantly reducing repetitive development costs. The collaborative work of these modules forms a complete solution from logic design to cross-scene deployment, shortening the development cycle of combat logic. This solves the problem of low efficiency in game combat data editing in related technologies.

[0036] In one embodiment, the node encapsulation module 110, when reusing a function template through function template parameters and a referencing mechanism, is further configured to: The natural language processing model generates parameter values ​​for the custom parameters in the functional template; wherein, 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.

[0037] 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.

[0038] Optionally, the system first receives user configuration requests described in natural language (e.g., "create a skill that deals high fire area damage") or similar historical configuration data as input. Then, the built-in natural language processing model performs semantic parsing and intent recognition on this input, extracting core concepts (e.g., "high damage," "fire," "area") and mapping these concepts to combat parameter labels that the system can understand. Next, the system strictly adheres to the parameter type constraints predefined by the target function template (e.g., the "damage value" parameter is constrained to floating-point, and the "damage type" is constrained to an enumeration containing options such as "fire" and "frost"), performing compliance verification and quantification of the parsed parameter intent. Finally, it generates a set of specific parameter values ​​that meet all type and range requirements (e.g., quantizing "high damage" to 500.0 points, mapping "fire" to the enumeration value "Fire," and activating the "area effect" flag). After the parameters are generated, the system locates and calls the configured function template through a unique node identifier. During the reuse process, the referencing mechanism ensures that all combat parameters (including newly generated parameters) in the template can be completely and accurately transmitted to the target logical context.

[0039] By introducing an intelligent parameter generation mechanism, the technical threshold and operational costs of configuring functional templates are significantly reduced, enabling planners to express their design intentions in a more intuitive and efficient manner, thereby greatly improving the efficiency of combat data editing. More importantly, by forcibly constraining natural language descriptions within a predefined type and rule system, this process improves usability while fundamentally ensuring the structural validity of generated parameters, enhancing the reliability and robustness of the entire combat data system.

[0040] In one embodiment, 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 by the functional template, is further configured to: Based on the received natural language description, the natural language processing engine parses the description to obtain parameter requirements. Then, according to the predefined parameter type constraints in the functional template, the parameter requirements are subjected to type matching and validity verification.

[0041] The parameter generator generates parameter values ​​that conform to the parameter type constraints based on the parameter requirements after type matching and validation. Alternatively, Based on historical configuration data, a parameter configuration pattern library is obtained through machine learning model training. 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.

[0042] Optionally, when a natural language description (such as "a powerful single-target attack that can knock back enemies") is received, the natural language processing engine first performs semantic role labeling and keyword extraction to transform the vague description into a structured "parameter requirement" (such as {effect: knockback, strength: powerful, target: single target}). Subsequently, the system rigorously matches and validates this requirement against the parameter type constraints of the target function template. For example, it confirms that "strength" can be mapped to a floating-point damage coefficient parameter, and that the generated value is within the preset range of [1.0, 10.0]; the "knockback" effect is validated by checking if a boolean knockback parameter exists. After validation, the parameter generator generates the final compliant parameter value according to mapping rules (such as quantifying "powerful" as a damage coefficient = 7.5). Alternatively, the system continuously collects historical configuration data and trains it using machine learning models (such as clustering or sequence models) to build a parameter configuration pattern library. This library records common combinations and value patterns of various parameters under different function template identifiers. When it is necessary to configure parameters for the current template, the system uses its identifier as an index and, in combination with the type constraints of the current parameters, retrieves historically validated high-frequency or optimal parameter values ​​from the pattern library as recommendations.

[0043] By using natural language parsing to convert straightforward descriptions into precise machine instructions, the ease of use and efficiency of configuration are greatly improved. Meanwhile, the path based on learning from historical data incorporates collective experience and data patterns, making parameter configuration no longer an isolated creation, but an intelligent recommendation based on historical best practices, which significantly improves the quality and rationality of configuration solutions.

[0044] In addition, you can customize the configuration parameters of the function template and the referencing mechanism to reuse function templates. Specifically, this includes: The function template can be customized with parameters, including custom parameter configuration, parameter type constraint configuration, and default parameter configuration. Among these: Customizable parameter configuration includes the ability to modify combat parameters. The parameter type constraint configuration includes forcing the specification of a data type for each parameter, including integer, floating-point, boolean, and enumeration types; The default parameter configuration includes setting initial default values ​​for each parameter, which are automatically loaded when the node is instantiated.

[0045] The function template is invoked by the node identifier after configuring the function template parameters, so as to reuse the function template. When invoked, the combat parameters in the function template are passed through to the target function template.

[0046] Optionally, Figure 2 This is a schematic diagram of an encapsulation function template according to an exemplary embodiment, such as... Figure 2 As shown, only the relevant displacement parameters need to be filled in externally to achieve the displacement effect. Specifically, based on the dynamic modification of node parameters, combat elements (damage calculation, effect triggering, etc.) are encapsulated into draggable functional nodes (functional modules), and node referencing is supported. Internal encapsulation functionality is provided within the editor, greatly improving the efficiency of general function encapsulation and reuse, increasing development efficiency, and allowing designers to quickly iterate and develop using encapsulated templates. Node configuration template parameters support custom parameter configuration (supporting parameter customization extension, parameter type constraints, default value configuration, etc.). In addition to effect nodes, condition nodes, filter nodes, etc., also support parameter extension template encapsulation functionality. For example: The displacement calculation logic is encapsulated into a displacement function template, which contains velocity, distance, and direction parameters.

[0047] The damage calculation logic is encapsulated into a damage function template, which includes base damage value, critical hit rate, and damage type parameters.

[0048] The special effects triggering logic is encapsulated into a special effects function template, which contains special effects resources and trigger condition parameters.

[0049] Customizable parameter configuration allows for the addition, deletion, or modification of combat parameters in functional templates (such as adding a "knockback distance" field), enabling designers to quickly adapt to diverse skill requirements without requiring programmer intervention to modify the underlying code. Parameter type constraint configuration enforces restrictions on parameter data types (such as "damage value" must be floating-point), avoiding runtime exceptions caused by incorrect types from the design stage and reducing debugging costs. Default parameter configurations automatically load preset values ​​when nodes are instantiated (such as "critical hit rate default 30%"), significantly reducing the workload of repetitive parameter input and improving editing efficiency. Through node identifier calls and parameter pass-through mechanisms, reusable functional templates (such as displacement templates) can directly inherit parameter values ​​from the caller (such as "speed = 10m / s"), achieving plug-and-play logic, as demonstrated by documented test data. Skill development cycles are significantly shortened.

[0050] In one embodiment, when determining the node editing operation corresponding to a user through the user's unique identifier in the collaboration module 120, it is further used for: Extract the user's local network address to generate a unique user identifier.

[0051] The user's unique identifier and the auto-incrementing sequence number are used as node identifiers. The auto-incrementing sequence number is a numerical sequence that increments by a fixed step size.

[0052] 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.

[0053] Optionally, the local IP address of the editor is used as the identifier, and the node ID is automatically assigned and incremented. Editor nodes are divided into effect nodes, condition nodes, etc., and the starting digits for each type of node are set according to the number of nodes that can be expanded. For example, if the local editor's IP is 192.168.211.XXX, and they create an effect node SkillEffectConfig, then the node ID is XXX000000. Each new ID can increment automatically, such as XXX000001, XXX000002, etc. The responsible person can be located through the node prefix, and the auto-incrementing mechanism effectively solves the problem of automatic ID assignment. Using a dual identifier of IP and auto-incrementing sequence number, the editing lock granularity is accurate to a single node. This improves the method of quickly assigning responsibility for logical problems and, combined with SVN version control tools, allows for rapid identification of the responsible person, improving the efficiency of problem fixing.

[0054] In one embodiment, when migrating a function template to a scene with different combat logic in the cross-scene interaction module 130, it is further 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 to the binary data 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.

[0055] Optionally, the clipboard-based node migration technology supports JSON serialization / deserialization. Similar functionalities can be migrated quickly, avoiding reinventing the wheel.

[0056] By using a data caching mechanism, the tabular data of the functional templates is converted into an efficient binary format (such as ProtocolBuffer) for temporary storage, reducing memory consumption and improving read and write speeds. During cross-scenario migration, the binary data automatically adapts to the target scenario requirements through preset data mapping rules. Combined with clipboard migration technology, JSON serialization / deserialization (such as generating {"type":"damage","value":100} by copying nodes enables the rapid reuse of similar functions, avoiding redundant development and significantly reducing development costs.

[0057] In one embodiment, the system further includes a node debugging module for breakpoint debugging of running functional templates; wherein, the node debugging module includes: The breakpoint setting unit is used to set unconditional breakpoints and conditional breakpoints on the function template. 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.

[0058] Optionally, based on the multi-threaded execution mechanism of C++ combat logic, it supports the function of debugging nodes in the editor and supports conditional breakpoints, allowing designers and others to use similar program code debugging functions, providing more detailed debugging, testing and acceptance methods.

[0059] The node debugging module provides debugging capabilities for functional templates. The breakpoint setting unit supports unconditional breakpoints (such as fixing the breakpoint at the damage calculation node) and conditional breakpoints based on runtime variables (such as "break when critical damage > 5000"), allowing designers to precisely control the debugging logic like programmers. The multi-threaded capture unit hooks into the execution flow of the C++ multi-threaded combat system (such as the physical thread and the effects thread) to capture cross-thread breakpoint events in real time, solving the pain point of traditional visualization tools being unable to debug multi-threaded logic. The status monitoring unit freezes the game state when a breakpoint is triggered and displays parameter values ​​(such as current damage = 3250), variable states, and logical flow (highlighted execution path) in a 3D visualization, helping developers intuitively understand the execution logic of complex skills. The modification unit allows for hot modification of variable values ​​(such as adjusting the damage value from 3250 to 4000) or node connection relationships (such as removing the "knockback" effect) directly while the game is paused, and the game resumes immediately after modification for verification.

[0060] In one embodiment, the system further includes a logic visualization module for displaying the execution flow and state changes of functional modules in real time, 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.

[0061] Optionally, based on a node-based editing method, the logical flow is visualized, breaking the black box of program logic and making it easier for designers to quickly understand the logical mechanism and quickly modify and verify it.

[0062] The logic visualization module enables visualized debugging and collaboration of combat logic. The status feedback unit displays key data flows of functional modules in real time (e.g., input parameter damage value = 150, output result actual damage = 225) and execution status (e.g., "Cooling down / Ready"), presented intuitively through a floating panel or highlighted lines, allowing designers to directly understand the numerical calculation process. The logic annotation unit allows users to add rich text annotations to nodes (e.g., "Critical hit rate is affected by character level here") and supports keyword search (e.g., searching for all nodes containing the annotation "critical hit").

[0063] In one embodiment, the edited data is tabular data. In the real-time compilation module 140, when compiling the edited data in the node encapsulation module 110 in real-time according to data conversion rules, it is also used for: The tabular data of the functional template is converted into structured binary data through data serialization or deserialization.

[0064] In response to receiving the editing instruction from the current node encapsulation module 110, binary data is compiled in real time. If the object of the editing instruction is consistent with the object in the original binary data, the attributes or connection relationships of the object are modified according to the editing instruction.

[0065] Optionally, based on the logical data PB structure serialization / deserialization function, edits take effect immediately without restarting the game client. This greatly reduces the efficiency of repeated verification and allows for real-time modification and verification. All data edited in the editor is tabular data. In addition to "object <-> binary byte stream," the serialization / deserialization process includes a feature that, if the table data already exists, only modifies the existing object, ensuring normal access to the logically cached table data object and saving memory.

[0066] By serializing / deserializing tabular data into binary data, the edit data of functional templates is converted into an efficient structured format, reducing data size while improving read and write speed. When an edit command is received, the system intelligently determines the consistency of the data object—if the object to be edited already exists in the binary cache (such as the damage value field of "Fireball"), only the specific attributes of that object are incrementally updated, keeping other cached data in memory unchanged. This optimization reduces memory usage and avoids performance fluctuations caused by reloading the entire dataset.

[0067] In one embodiment, the system is based on the Unity project engine and integrates runtime, editor, adjustment, and testing. The editor's data is recorded in JSON format for easy viewing and modification. Edited data is in power-batch format, facilitating serialization and deserialization, thus supporting dynamic modification of game data at runtime and ensuring real-time testing. The editing logic flow follows a node-based approach, improving the readability of the logic flow and design. Data editing relies on the Odin plugin, integrated with the Unity display editor for easy data modification.

[0068] In summary, this application provides a game combat data editing system. The node encapsulation module 110 standardizes and encapsulates combat parameters into reusable functional templates. Combined with parameter expansion and referencing mechanisms, this effectively improves the efficiency of combat logic development while lowering the technical barrier. The real-time compilation module 140, based on data conversion rules, enables instant compilation of edited data, eliminating the compilation waiting time in traditional development and achieving a "what you see is what you get" development experience. The collaboration module 120 uses unique identifiers to accurately track multi-user editing behavior, reducing team collaboration conflicts and improving problem localization efficiency. The cross-scene interaction module 130 breaks down scene barriers through a standardized migration mechanism, increasing the reusability of verification functional templates and significantly reducing repetitive development costs. The collaborative work of these modules forms a complete solution from logic design to cross-scene deployment, shortening the development cycle of combat logic.

[0069] Secondly, embodiments of this application provide a method for editing game battle data. Figure 3 This is a flowchart illustrating a method for editing game battle data according to an exemplary embodiment. Figure 3 As shown, the method includes: Step S301: Encapsulate the combat parameters into functional templates and reuse the functional templates through functional template parameters and referencing mechanisms.

[0070] Step S302: Using the multi-user editing function template and based on the user's unique identifier, determine the node editing operation corresponding to the user.

[0071] Step S303: Migrate the functional template to scenarios with different combat logics.

[0072] Step S304: Compile the edited data in the function template in real time through data transformation rules.

[0073] In one embodiment, the specific workflow is as follows: 1. The data edited in the editing system is tabular data.

[0074] 2. Edit the system to save data in JSON format (which includes table data).

[0075] 3. Game runtime data is in bytes.

[0076] 4. Data flow: Editor operates in the editor - saves as JSON data - uploads to SVN - Jenkins automatically exports the JSON table data to Excel - Jenkins automatically exports the Excel data as game runtime data (bytes).

[0077] Besides the system configuration, the Excel data also needs to retain the planning and editing operations. Therefore, the entire workflow is preserved. Additionally, the editor's JSON data storage advantage facilitates SVN blame assignment and viewing the diff of changes, etc.

[0078] In summary, this application provides a method for editing game combat data. By standardizing and encapsulating combat parameters into reusable functional templates, coupled with parameter expansion and referencing mechanisms, the efficiency of combat logic development is effectively improved while lowering the technical threshold. Real-time compilation, based on data transformation rules, enables instant compilation of edited data, eliminating the compilation waiting time in traditional development and achieving a "what you see is what you get" development experience. Unique identifiers are used to accurately track multi-user editing behavior, reducing team collaboration conflicts and improving problem localization efficiency. Cross-scene interaction breaks down scene barriers through a standardized migration mechanism, improving the reusability of verification functional templates, significantly reducing repetitive development costs, and shortening the development cycle of combat logic. This solves the problem of low efficiency in editing game combat data in related technologies.

[0079] It should be noted that the game combat data editing system provided in this embodiment is used to implement the above-described embodiments, and details already described will not be repeated. As used above, terms such as "module," "unit," and "subunit" can refer to a combination of software and / or hardware that performs a predetermined function. Although the apparatus described in the above embodiments is preferably implemented in software, hardware implementation, or a combination of software and hardware, is also possible and contemplated.

[0080] Thirdly, embodiments of this application provide an electronic device, Figure 4 This is a block diagram illustrating an electronic device according to an exemplary embodiment. (e.g.) Figure 4 As shown, the electronic device may include a processor 41 and a memory 42 storing computer program instructions.

[0081] Specifically, the processor 41 may include a central processing unit (CPU), an application specific integrated circuit (ASIC), or one or more integrated circuits that can be configured to implement the embodiments of this application.

[0082] The memory 42 may include a large-capacity memory for data or instructions. For example, and not limitingly, the memory 42 may include a hard disk drive (HDD), a floppy disk drive, a solid-state drive (SSD), flash memory, an optical disk drive, a magneto-optical disk drive, magnetic tape, or a Universal Serial Bus (USB) drive, or a combination of two or more of these. Where appropriate, the memory 42 may include removable or non-removable (or fixed) media. Where appropriate, the memory 42 may be internal or external to a data processing device. In a particular embodiment, the memory 42 is non-volatile memory. In a particular embodiment, the memory 42 includes read-only memory (ROM) and random access memory (RAM). Where appropriate, the ROM may be a mask-programmed ROM, a programmable read-only memory (PROM), an erasable programmable read-only memory (EPROM), an electrically erasable programmable read-only memory (EEPROM), an electrically alterable read-only memory (EAROM), or flash memory, or a combination of two or more of these. Where appropriate, the RAM can be Static Random-Access Memory (SRAM) or Dynamic Random-Access Memory (DRAM). DRAM can be Fast Page Mode Dynamic Random-Access Memory (FPMDRAM), Extended Data Out Dynamic Random-Access Memory (EDODRAM), Synchronous Dynamic Random-Access Memory (SDRAM), etc.

[0083] The memory 42 can be used to store or cache various data files that need to be processed and / or used for communication, as well as possible computer program instructions executed by the processor 41.

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

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

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

[0087] Bus 40 includes hardware, software, or both, that couples together components of a game combat data editing device. Bus 40 includes, but is not limited to, at least one of the following: Data Bus, Address Bus, Control Bus, Expansion Bus, and Local Bus. For example, and not as a limitation, bus 40 may 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 Bus (VLB) bus, or other suitable buses, or a combination of two or more of these. Where appropriate, bus 40 may include one or more buses. Although specific buses are described and illustrated in the embodiments of this application, this application considers any suitable bus or interconnection.

[0088] Fourthly, embodiments of this application provide a computer-readable storage medium storing a program thereon, which, when executed by a processor, implements a game battle data editing method provided in the first aspect.

[0089] The readable storage medium may be more specifically adopted, including but not limited to: portable disk, hard disk, random access memory, read-only memory, erasable programmable read-only memory, optical storage device, magnetic storage device, or any suitable combination thereof.

[0090] In a possible implementation, the present invention can also be implemented as a program product comprising program code, which, when the program product is run on a terminal device, causes the terminal device to perform steps implementing a game battle data editing method provided in the first aspect.

[0091] The program code for executing the present invention can be written in any combination of one or more programming languages. The program code can be executed entirely on the user device, partially on the user device, as a standalone software package, partially on the user device and partially on a remote device, or entirely on a remote device.

[0092] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0093] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are relatively specific and detailed, they should not be construed as limiting the scope of the invention patent. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this patent application should be determined by 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 transformation rules.

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 2, characterized in that, 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: Based on the received natural language description, the natural language processing engine parses the natural language description to obtain the parameter requirements; 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, Based on historical configuration data, a parameter configuration pattern library is obtained through machine learning model training. 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.

4. 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.

5. A 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.

6. 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.

7. 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.

8. 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.

9. A method for editing game combat data, characterized in that, Applied to the system of any one of claims 1-8, 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.

10. 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 8.

Images