A game task flow editing system, method, device and medium

Abstract

The application relates to a game task flow editing system, method, device and medium, wherein the system comprises a task logic construction module, which is used for defining a task flow structure through a task node in a graphical interface, configuring attribute and scene position information of the task node, establishing association between task nodes, and generating task logic describing the task flow. A task path switching module is used for evaluating a task execution state according to a preset condition, selecting a task path based on an evaluation result, and triggering path change of an associated task through a preconfigured task behavior when the task path is switched. A cooperative processing module is used for editing the task logic construction module through multiple users, and determining a task logic editing operation corresponding to a user according to a user unique identification code, so as to solve the problem of low game task flow editing efficiency in the prior art.

Description

Technical Field

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

[0002] Currently, traditional game task development mainly relies on programmers manually writing script code (such as C#, Lua, etc.) to edit task flow. This is inefficient and requires a high level of technical expertise from designers. Specifically, designers need to master programming languages ​​to design task logic. Each modification to the task flow requires repeated submission to programmers for code writing, compilation, and testing, which prolongs the development cycle and reduces the efficiency of task flow editing.

[0003] Therefore, there is an urgent need to provide an efficient game task flow editing system to solve the above problems. Summary of the Invention

[0004] This application provides a game task flow editing system, method, device, and medium to at least solve the problem of low efficiency in game task flow editing in related technologies.

[0005] In a first aspect, embodiments of this application provide a game task flow editing system, the system comprising:

[0006] The task logic construction module is used to define the task flow structure through task nodes in the graphical interface, configure the attributes and scene location information of the task nodes, establish the association between task nodes, and generate task logic that describes the task flow.

[0007] The task path switching module is used to evaluate the task execution status according to preset conditions, select the task path based on the evaluation result, and trigger the path change of the associated task through pre-configured task behavior when the task path is switched.

[0008] The collaborative processing module is used to construct the task logic module through multi-user editing and to determine the task logic editing operation corresponding to each user based on the user's unique identifier.

[0009] In one embodiment, the task logic construction module, when defining the task flow structure through task nodes in the graphical interface, configuring the attributes and scene location information of the task nodes, establishing associations between task nodes, and generating task logic describing the task flow, is used for:

[0010] Connect different task nodes using a visual drag-and-drop operation to generate a task flowchart;

[0011] Configure attribute data for each task node, the attribute data including task type identifier, priority parameter and reward configuration information;

[0012] By associating the location information of the task nodes with the game scene, scene task nodes are generated;

[0013] Based on the task flowchart, the attribute data, and the scene task nodes, task logic describing the task flow is generated.

[0014] In one embodiment, the task logic construction module, when generating a task flowchart by connecting different task nodes through a visual drag-and-drop operation, is further configured to:

[0015] Respond to mouse press events, record the initial drag start coordinates, and update the temporary position of the task node by tracking the mouse displacement in real time;

[0016] Based on the mouse release position, it is determined whether it is in a valid connection area. When a valid connection is detected, a connection relationship is established between the source task node and the target task node, and the jump target identifier is written into the node attribute.

[0017] According to the preset dead loop detection algorithm, the connection relationship is verified to be closed. When an unclosed loop is detected, a warning is triggered and the abnormal task node is marked. When a closed loop is detected, a task flowchart is obtained, and the connection relationship between the task nodes is converted into a structured document through a data serialization tool.

[0018] In one embodiment, the task path switching module, after evaluating the task execution status according to preset conditions and selecting a task path based on the evaluation result, when the task path is switched and a path change of associated tasks is triggered by a pre-configured task behavior, is used to:

[0019] Based on preset condition judgment rules, monitor the execution status of game tasks in real time and assess whether the current task execution conditions are met;

[0020] Based on the evaluation results, the subsequent task path is determined by parsing the jump attribute value of the task node. When the conditions are met, the preset first task path is selected; when the conditions are not met, the backup second task path is selected or the task is terminated.

[0021] When switching paths, the path change of associated tasks is triggered by calling an interface based on predefined behavior configuration data.

[0022] In one embodiment, the task path switching module, when switching paths, triggers a path change for associated tasks by calling an interface based on predefined behavior configuration data, and is further configured to:

[0023] Based on predefined behavior configuration data, the triggered task behavior type and associated parameters are determined by parsing the behavior parameters in XML format;

[0024] Based on the behavior type and the associated parameters, the corresponding task flow operation is executed by calling the task management interface provided by the game engine. Specifically, when the behavior type is to start a task, the specified task flow is activated through the interface according to the configured target task ID; when the behavior type is to update the status, the game's global variables are modified through the interface.

[0025] After the API call, modify the attribute values ​​of the current task and change the task path according to the jump instructions in the behavior configuration.

[0026] In one embodiment, the collaborative processing module, when editing the task logic construction module by multiple users and determining the task logic editing operation corresponding to the user based on the user's unique identifier, is further configured to:

[0027] Extract the user's local network address to generate a unique user identifier;

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

[0029] Record the node editing operation corresponding to the node identifier, and determine the task logic editing operation corresponding to the user based on the user's unique identifier.

[0030] In one embodiment, the system further includes:

[0031] The real-time preview module is used for real-time rendering of task logic;

[0032] The error diagnosis module is used to highlight disconnected task nodes and looping paths during the preview process.

[0033] Secondly, embodiments of this application provide a method for editing game task flow, the method comprising:

[0034] The task state unit and the relationship between task nodes are defined by graphical nodes, and the attributes of the task nodes and the location information of the task node scene are configured to generate task logic that describes the task process.

[0035] The task execution status is evaluated according to preset conditions, and a task path is selected based on the evaluation results. When the task path is switched, the path change of the associated task is triggered by the pre-configured task behavior.

[0036] The task logic construction module is edited by multiple users, and the task logic editing operation corresponding to each user is determined based on the user's unique identifier.

[0037] 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 task flow editing system as described in the first aspect above.

[0038] 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 task flow editing system as described in the first aspect above.

[0039] The game task flow editing system, method, device, and medium provided in this application embodiment have at least the following technical effects.

[0040] The task logic construction module defines the task flow structure through task nodes in a graphical interface, configures the attributes and scene location information of the task nodes, establishes associations between task nodes, generates task logic describing the task flow, and enables graphical node drag-and-drop and association establishment. This allows non-programmers to intuitively and efficiently build complex task flows, significantly lowering the development threshold and improving logic construction efficiency. The task path switching module evaluates the task execution status based on preset conditions, selects a task path based on the evaluation results, and triggers path changes for associated tasks when the task path switches, achieving adaptive task flow transitions and reducing manual coding errors. The collaborative processing module allows multiple users to edit the task logic construction module and determines the corresponding task logic editing operation for each user based on their unique identifier. It supports parallel editing and operation traceability by multiple users based on their unique identifier, effectively breaking down functional barriers, reducing communication costs, ensuring version consistency, and shortening the overall development iteration cycle. These three modules work together to solve the problem of low efficiency in game task flow editing in related technologies.

[0041] 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

[0042] 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:

[0043] Figure 1 This is a system structure block diagram illustrating a game task flow editing method according to an exemplary embodiment;

[0044] Figure 2 This is a schematic diagram illustrating a task flow according to an exemplary embodiment;

[0045] Figure 3 This is a flowchart illustrating a game task flow editing method according to an exemplary embodiment;

[0046] Figure 4 This is a structural block diagram of an electronic device according to an exemplary embodiment. Detailed Implementation

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

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

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

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

[0051] With the rapid development of online games, quest systems have become an important part of game content, directly affecting player experience and game playability. Traditional game quest development mainly relies on programmers manually writing script code (such as C#, Lua, etc.) to implement quest logic, which requires a high technical threshold from designers and is inefficient in debugging and iteration. In addition, existing visual quest editing tools (such as Unity Playmaker and RPG Maker event system) only support simple process splicing, which is difficult to meet the needs of modern games for complex quest logic (such as nested multi-quests, dynamic variable interaction, conditional branching, and network synchronization mechanisms).

[0052] Currently, the main problems facing game task development include: low development efficiency, high cross-functional collaboration costs, and difficulty in implementing complex task logic. Existing technical solutions have the following shortcomings: 1) The code scripting method is unfriendly to non-technical personnel and easily introduces logical errors; 2) Visualization tools lack support for complex task trees and dynamic interactions; 3) Frequent communication between programmers and designers is required, resulting in long version iteration cycles; 4) It is difficult to preview task effects in real time and lacks flexible support for modern game requirements such as multi-task parallel triggering and global state synchronization. These problems severely restrict the development efficiency and flexibility of game task systems, urgently requiring a more efficient and accessible visual task editing system.

[0053] Based on the above, embodiments of this application provide a game task flow editing system, method, device, and medium.

[0054] 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:

[0055] Task node: A visual entity (such as a graphic block) that represents a logical unit in the task flow in the graphical editing interface. It can contain multiple task behaviors (such as dialogue and reward distribution).

[0056] Task flowchart: A graphical representation of task logic generated by connecting task nodes with directed edges, which intuitively displays the task execution path, conditional branches, and state transitions.

[0057] Task logic: A set of rules governing event triggering conditions, execution order, and results in the task flow, including state transitions, condition judgments, and behavior-driven processes.

[0058] Scene task node: A task node that is bound to a specific game scene (such as a map or level) and represents a logical unit triggered in that scene.

[0059] Infinite loop detection algorithm: An algorithm used to analyze the jump path of task nodes in real time, identify closed loop logic, and prevent the task process from getting stuck.

[0060] Game engine: The core runtime framework for game development (such as Unity and Unreal Engine), responsible for executing game logic, rendering visuals, and handling interactions.

[0061] Auto-incrementing serial number: A unique, incrementing number automatically assigned to each task node (e.g., Node_001, Node_002) for node identification and serialization.

[0062] Behavior configuration data: A collection of task behavior rules stored in XML format, containing task behavior types, associated parameters, and execution logic, used to drive the game engine's interface calls.

[0063] Jump Instruction: A preset path change instruction in the task node properties, which includes the target node identifier and execution conditions, and is used to dynamically modify the task path.

[0064] In a first aspect, embodiments of this application provide a game task flow editing system, method, and medium. Figure 1 This is a system structure block diagram illustrating a game task flow editing method according to an exemplary embodiment, such as... Figure 1 As shown, the system includes:

[0065] The task logic construction module 110 is used to define task state units and the relationships between task nodes through graphical nodes, configure task node attributes and scene location information of task nodes, and generate task logic that describes the task process.

[0066] The task path switching module 120 is used to evaluate the task execution status according to preset conditions, select the task path based on the evaluation results, and trigger the path change of related tasks through pre-configured task behaviors when the task path is switched.

[0067] The collaborative processing module 130 constructs a multi-user task logic editing module and determines the corresponding task logic editing operation for each user based on the user's unique identifier.

[0068] In summary, this application provides a game task flow editing system. The task logic construction module defines the task flow structure through task nodes in a graphical interface, configures the attributes and scene location information of task nodes, establishes associations between task nodes, and generates task logic describing the task flow. The task path switching module evaluates the task execution status based on preset conditions, selects a task path based on the evaluation results, and triggers path changes for associated tasks through pre-configured task behaviors when a task path is switched. The collaborative processing module allows multiple users to edit the task logic construction module and determines the corresponding task logic editing operation for each user based on their unique identifier, thus solving the problem of low efficiency in game task flow editing in related technologies.

[0069] In one embodiment, in the task logic construction module, when defining task state units and the relationships between task nodes through graphical nodes, configuring task node attributes and the location information of task node scenarios, and generating task logic describing the task flow, the module is used for:

[0070] Connect different task nodes through a visual drag-and-drop interface to generate a task flowchart. Figure 2 This is a schematic diagram of a task flow according to an exemplary embodiment, specifically including the following steps:

[0071] Step S201: Respond to the mouse press event, record the initial drag start coordinates, and update the temporary position of the task node by tracking the mouse displacement in real time.

[0072] Optionally, the system captures the initial screen coordinates (DragStart) when the mouse is pressed by listening to the MouseDown event, and calculates the displacement vector (e.delta) in real time in the MouseDrag event, dynamically updates the temporary bounding box (newDragRect) of the dragged task node, and refreshes the visual position of the node in real time in the UI thread.

[0073] Step S202: Determine whether the area is in a valid connection region based on the mouse release position. When a valid connection is detected, establish a connection relationship between the source task node and the target task node, and write the jump target identifier into the node attribute.

[0074] Optionally, when a mouse release event (MouseUp) is triggered, the system checks whether the mouse release position collides with a valid connection area of ​​the target task node (such as a valid added rectangle area at the node's edge). If a collision is valid, the system calls the state to add an edge card, creates a directed edge from the source node to the target node, and assigns the target node's identifier (ID) to the source node's jump attribute. Here, the edge card represents an executable step in the task flow (such as a dialogue, reward, conditional judgment, etc.). It is responsible for instantiating a new step card within the target task node after the user performs a drag-and-drop connection operation and establishing its logical association with the source state node.

[0075] Step S203: According to the preset dead loop detection algorithm, verify whether the connection relationship is closed. When an unclosed loop is detected, trigger a warning and mark the abnormal task node. When a closed loop is detected, obtain the task flowchart and convert the connection relationship between task nodes into a structured document using a data serialization tool.

[0076] Optionally, the system recursively traverses the jump chain using an infinite loop detection method, checking for paths pointing to itself or undefined nodes. If a closed loop is found, the current node's display title attribute is marked as "infinite loop," and a warning icon is displayed on the interface. If the verification passes, the node relationships are serialized into an Extensible Markup Language (XML) document based on an XML document object, completing the generation and persistence of the flowchart. The infinite loop detection method refers to traversing the jump relationships between task nodes (i.e., the paths formed by the jump attribute) to check if there is a node sequence that ultimately jumps back to a node in the sequence, causing the task flow to be unable to advance and thus getting stuck in a loop.

[0077] Configure attribute data for each task node. The attribute data includes task type identifier, priority parameters, and reward configuration information.

[0078] Optionally, when a user selects a task node in the graphical interface, the system loads editable fields corresponding to that node type in the editor's property panel area. For task type identifiers, predefined enumeration options (such as main quests, side quests, and daily quests) are provided via dropdown selection boxes (like Unity's Popup control). For priority parameters, a numerical value is received via an integer input box, which determines the task's sorting order in the task list. Reward configuration information is managed through a dynamic list interface, where users can click the "+" sign to add multiple reward entries. Each entry contains a reward type (such as item, currency, or experience) and specific parameters (such as item ID and quantity). Ultimately, these configurations are serialized into a nested XML structure.

[0079] Associate task nodes with the location information of the game scene to generate scene task nodes.

[0080] Optionally, after selecting a specific task node in the editor, users can enter this interface to create or specify an "Atmosphere Group" (a collection of scene elements related to the task). By clicking the "+" button to add an NPC entry to the group, the system will generate an NPC proxy object at the default or specified location in the game scene. Users can directly drag the green positioning circle on the NPC object in the scene view, and its three-dimensional coordinates (X, Y, Z) and rotation orientation will be reflected in real time in the input boxes of the configuration panel. In addition, the panel provides checkboxes for setting special states. These spatial transformation data and state parameters are bound to the task node ID and serialized in real time into structured data in XML format. The NPC entry then becomes a scene-based instance of this task node, thereby generating a scene task node.

[0081] Based on flowcharts, attribute data, and scenario task nodes, task logic describing the task flow is generated.

[0082] Optionally, flowcharts, attribute data, and scenario task nodes can be integrated to generate task logic that describes the task flow.

[0083] The task logic construction module integrates graphical drag-and-drop editing (generating flowcharts), structured attribute configuration (defining types, priorities, and rewards), and scenario-based spatial positioning (binding NPC coordinates). This allows non-technical personnel to intuitively construct complete task solutions that combine behavioral logic, rule parameters, and spatial information within a unified visual environment, significantly lowering the technical barrier to game task design. Simultaneously, this module generates all the aforementioned design elements into a machine-readable structured task logic document, realizing the transformation from visual design to executable data and solving the problem of low efficiency in game task flow editing in related technologies.

[0084] In one embodiment, the task path switching module, after evaluating the task execution status according to preset conditions and selecting a task path based on the evaluation result, when the task path switches and triggers a path change for associated tasks through pre-configured task behaviors, is used to:

[0085] Based on preset condition judgment rules, monitor the execution status of game tasks in real time and assess whether the current task execution conditions are met;

[0086] Based on the evaluation results, the subsequent task path is determined by parsing the jump attribute value of the task node. When the conditions are met, the preset first task path is selected; when the conditions are not met, the backup second task path is selected or the task is terminated.

[0087] When switching paths, the path change of associated tasks is triggered by calling an interface based on predefined behavior configuration data.

[0088] Optionally, when the game progresses to a node requiring judgment, it will perform a Boolean evaluation based on preset judgment rules (such as "player level ≥ 10" and "possessing item ID = 101") and real-time query the game's running status (such as player attributes and inventory data). Based on the evaluation result, the module will read the jump attribute value of the current task node. If the condition is met, it will jump to the first task path specified by the attribute (the next status node ID); otherwise, it may jump to a backup node or mark it as terminated. During path switching, related actions in the predefined behavior configuration data will be executed synchronously. This involves activating new task flows by calling specific interfaces provided by the game engine or indirectly affecting the path conditions of other tasks by modifying global variables, thereby achieving coordinated path changes for related tasks.

[0089] The task path switching module enables the task system to dynamically respond based on the player's actual game progress and behavior through real-time condition evaluation and multi-path selection, breaking away from the rigid mode of linear scripts and greatly enhancing the game's flexibility and playability.

[0090] In one embodiment, the task path switching module, when switching paths, triggers a path change for associated tasks by calling an interface based on predefined behavior configuration data, and is further configured to:

[0091] Based on predefined behavior configuration data, the triggered task behavior type and associated parameters are determined by parsing the behavior parameters in XML format;

[0092] Based on the behavior type and associated parameters, the corresponding task flow operation is executed by calling the task management interface provided by the game engine. Specifically, when the behavior type is to start a task, the specified task flow is activated through the interface according to the configured target task ID; when the behavior type is to update the status, the game's global variables are modified through the interface.

[0093] After the API call, modify the attribute values ​​of the current task and change the task path according to the jump instructions in the behavior configuration.

[0094] Optionally, predefined XML-formatted behavior configuration data is first loaded, and the behavior type (such as starting a task or updating status) and associated parameters (such as the target task ID or global variable name) are extracted using an XML parser. The game engine's task management interface is then called based on the behavior type: when the behavior type is "starting a task," the target task ID is passed as a parameter to the interface, activating the specified task flow and writing its path information to the engine's scheduling queue. When the behavior type is "updating status," global variables (such as player level) are modified through the interface, triggering the engine to automatically update the task path. After the interface call is complete, the jump instruction in the behavior configuration is read, the target node ID is written to the attribute field of the current task, the task path attribute is dynamically modified, and finally, a path change command is sent through the engine's task scheduling interface to achieve real-time path switching for associated tasks.

[0095] By using XML configuration to drive interface calls, task paths are automatically switched, avoiding the tedious process of traditional manual coding. Real-time interaction based on the game engine's standard interface ensures that path changes take effect immediately and maintain logical consistency, significantly improving task design efficiency. At the same time, the pre-configured jump indicator mechanism supports dynamic path adjustments in complex scenarios, effectively resolving logical conflicts when multiple tasks are linked, and providing flexible and reliable dynamic execution guarantees for game task design.

[0096] In one embodiment, the collaborative processing module, when determining the task logic editing operation corresponding to a user based on the user's unique identifier by using the multi-user task logic construction module, is further configured to:

[0097] Extract the user's local network address to generate a unique user identifier;

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

[0099] Record the node editing operations corresponding to the node identifier, and determine the corresponding task logic editing operations for the user based on the user's unique identifier.

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

[0101] In one embodiment, the system further includes:

[0102] The real-time preview module is used for real-time rendering of task logic.

[0103] Optionally, when a user modifies the task flow, the system will monitor changes in the task logic data in real time and immediately synchronize the latest task flow diagram data (including node connections, conditional branches, and behavior configurations) to a built-in, lightweight game scene simulator. This simulator will load the same characters, NPCs, and scene resources as the official game environment and drive a virtual player character to execute the flow according to the current task logic, dynamically rendering the complete process of task progression. For example, when the virtual player walks in front of a specific NPC, the interface will automatically pop up the configured dialogue content, and when the conditions are met, the task status indicator light will highlight the next jump path.

[0104] By simulating the effects of task execution in real time, abstract node connections are transformed into concrete game visuals, allowing planners to intuitively verify the rationality and smoothness of task logic, greatly reducing design errors caused by misunderstandings.

[0105] The error diagnosis module is used to highlight unconnected nodes and looping paths during the preview process.

[0106] Optionally, during static testing, disconnected task nodes are automatically marked (e.g., isolated nodes are displayed as red warning icons). During simulation, loop jump paths are tracked, and floating warning boxes indicate the risk of infinite loops. An error location function is provided; double-clicking a warning message automatically jumps to the problem node editing interface.

[0107] In summary, this application provides a game task flow editing system. The task logic construction module defines the task flow structure through task nodes in a graphical interface, configures the attributes and scene location information of task nodes, establishes associations between task nodes, and generates task logic describing the task flow. The task path switching module evaluates the task execution status based on preset conditions, selects a task path based on the evaluation results, and triggers path changes for associated tasks through pre-configured task behaviors when a task path is switched. The collaborative processing module allows multiple users to edit the task logic construction module and determines the corresponding task logic editing operation for each user based on their unique identifier, thus solving the problem of low efficiency in game task flow editing in related technologies.

[0108] Secondly, embodiments of this application provide a method for editing game task flow. Figure 3 This is a flowchart illustrating a game task flow editing method according to an exemplary embodiment. For example... Figure 3 As shown, the method includes:

[0109] Step S301: Define the task flow structure through the task nodes in the graphical interface, configure the attributes and scene location information of the task nodes, establish the association between the task nodes, and generate the task logic describing the task flow.

[0110] Step S302: Evaluate the task execution status according to preset conditions, select a task path based on the evaluation results, and trigger the path change of associated tasks through pre-configured task behaviors when the task path is switched.

[0111] Step S303: Construct a multi-user task logic editing module and determine the task logic editing operation corresponding to the user based on the user's unique identifier code.

[0112] In summary, this application provides a method for editing game task flows. It defines task state units and relationships between task nodes using graphical nodes, and configures task node attributes and scene location information to generate task logic describing the task flow. This allows non-technical personnel to intuitively build complex task logic, lowering the development threshold while ensuring accurate matching of task elements with the game scene, enhancing the immersive experience of task design. The method evaluates the task execution status based on preset conditions, selects a task path based on the evaluation results, and triggers path changes for associated tasks through pre-configured task behaviors when the task path changes. This achieves intelligent and adaptive control of the task flow, reduces manual coding errors, and significantly improves debugging efficiency and logic accuracy. A multi-user task logic editing module is used, and the user's unique identifier determines the corresponding task logic editing operation. This solves the problem of low efficiency in game task flow editing in related technologies.

[0113] It should be noted that the game task flow 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, the terms "module," "unit," "subunit," etc., 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.

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

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

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

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

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

[0119] In one embodiment, a game task flow 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.

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

[0121] Bus 40 includes hardware, software, or both, that couples together components of a game mission flow 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.

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

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

[0124] 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 the game task flow editing method provided in the first aspect.

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

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

[0127] 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 quest flow editing system, characterized in that, The system includes: The task logic construction module is used to define the task flow structure through task nodes in the graphical interface, configure the attributes and scene location information of the task nodes, establish the association between the task nodes, and generate task logic that describes the task flow. The task path switching module is used to evaluate the task execution status according to preset conditions, select a task path based on the evaluation result, and trigger a path change for associated tasks through pre-configured task behaviors when the task path switches. The task path switching module, when switching paths, triggers a path change for associated tasks by calling an interface based on predefined behavior configuration data. It is also used to: determine the triggered task behavior type and associated parameters by parsing XML-formatted behavior parameters based on the predefined behavior configuration data; execute the corresponding task flow operation by calling the task management interface provided by the game engine based on the behavior type and the associated parameters; wherein, when the behavior type is "start task," the specified task flow is activated through the interface according to the configured target task ID; when the behavior type is "update state," the game's global variables are modified through the interface; after the interface call, the attribute values ​​of the current task are modified according to the jump indication in the behavior configuration, and the task path is changed. The collaborative processing module is used to construct the task logic module through multi-user editing and to determine the task logic editing operation corresponding to each user based on the user's unique identifier.

2. The game task flow editing system according to claim 1, characterized in that, The task logic construction module, when defining the task flow structure through task nodes in the graphical interface, configuring the attributes and scene location information of the task nodes, establishing the association between task nodes, and generating task logic describing the task flow, is used for: Connect different task nodes using a visual drag-and-drop operation to generate a task flowchart; Configure attribute data for each task node, the attribute data including task type identifier, priority parameter and reward configuration information; By associating the location information of the task nodes with the game scene, scene task nodes are generated; Based on the task flowchart, the attribute data, and the scene task nodes, task logic describing the task flow is generated.

3. The game task flow editing system according to claim 2, characterized in that, The task logic construction module, when generating a task flowchart by connecting different task nodes through a visual drag-and-drop operation, is also used for: Respond to mouse press events, record the initial drag start coordinates, and update the temporary position of the task node by tracking the mouse displacement in real time; Based on the mouse release position, it is determined whether it is in a valid connection area. When a valid connection is detected, a connection relationship is established between the source task node and the target task node, and the jump target identifier is written into the node attribute. According to the preset dead loop detection algorithm, the connection relationship is verified to be closed. When an unclosed loop is detected, a warning is triggered and the abnormal task node is marked. When a closed loop is detected, a task flowchart is obtained, and the connection relationship between the task nodes is converted into a structured document through a data serialization tool.

4. The game task flow editing system according to claim 1, characterized in that, The task path switching module, after evaluating the task execution status according to preset conditions and selecting a task path based on the evaluation results, when the task path is switched, triggers a path change for associated tasks through pre-configured task behaviors, and is used for: Based on preset condition judgment rules, monitor the execution status of game tasks in real time and assess whether the current task execution conditions are met; Based on the evaluation results, the subsequent task path is determined by parsing the jump attribute value of the task node. When the conditions are met, the preset first task path is selected; when the conditions are not met, the backup second task path is selected or the task is terminated. When switching paths, the path change of associated tasks is triggered by calling an interface based on predefined behavior configuration data.

5. A game task flow editing system according to claim 1, characterized in that, The collaborative processing module, when using multi-user editing of the task logic construction module and determining the task logic editing operation corresponding to a user based on the user's unique identifier, is further configured to: 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 task logic editing operation corresponding to the user based on the user's unique identifier.

6. The game task flow editing system according to claim 1, characterized in that, The system also includes: The real-time preview module is used for real-time rendering of task logic; The error diagnosis module is used to highlight disconnected task nodes and looping paths during the preview process.

7. A method for editing game quest flow, characterized in that, The method is applied to the system according to any one of claims 1 to 6, and the method includes: The task flow structure is defined by task nodes in the graphical interface, the attributes and scene location information of the task nodes are configured, the association between task nodes is established, and the task logic describing the task flow is generated. The task execution status is evaluated according to preset conditions, and a task path is selected based on the evaluation results. When the task path is switched, the path change of the associated task is triggered by the pre-configured task behavior. The task logic construction module is edited by multiple users, and the task logic editing operation corresponding to each user is determined based on the user's unique identifier.

8. An electronic device, characterized in that, The system includes a memory and a processor, a computer program stored in the memory and executable on the processor, wherein the processor, when executing the computer program, implements a game task flow editing system as described in any one of claims 1 to 6.

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 task flow editing system as described in any one of claims 1 to 6.

Images