Game editing information processing method and device, electronic equipment and storage medium

Abstract

The invention provides an information processing method and device for game editing, electronic equipment and a storage medium, and relates to the technical field of visual programming. The method comprises the following steps: in a game editing stage, displaying a graphical programming interface in a graphical user interface; in response to the breakpoint creation instruction, controlling to add a breakpoint identifier at a target programming graph corresponding to the breakpoint creation instruction; responding to the operation instruction, controlling to display a game operation scene in a graphical user interface, and controlling to operate a code combination; when responding to the code combination running to the code position corresponding to the breakpoint identifier, controlling to suspend the game running scene, and controlling to suspend the running of the code combination; a debugging interface is displayed on the graphical user interface, the debugging interface comprises a programming graph group and a debugging control, and the debugging control is configured to control and debug the code combination corresponding to the programming graph group. According to the method, breakpoint insertion is carried out through the visual programming interface, real-time dynamic code debugging in the code running process is achieved, and the code debugging efficiency is improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of visual programming, in particular to an information processing method and device for game editing, an electronic device and a storage medium. BACKGROUND

[0002] In a UGC (User-Generated Content) visual programming system, it is often necessary to dynamically observe the runtime state to determine whether the execution flow meets the expectations, and to directly capture and troubleshoot problems on site when an exception occurs. Debugging is an indispensable part of the programming process, which is used to verify whether the program logic is correct and troubleshoot runtime exceptions.

[0003] In the current debugging method, the program outputs some key variables or states of the runtime to a log file during the running process, and the user checks the log to troubleshoot exceptions after the entire program running is completed.

[0004] The above method lacks real-time performance, resulting in low debugging efficiency and inability to accurately locate the root cause of the exception. SUMMARY

[0005] The present application aims to overcome the deficiencies in the prior art, and provides an information processing method and device for game editing, an electronic device and a storage medium, so as to facilitate dynamic and real-time code debugging during code running, and improve the accuracy of debugging positioning and the debugging efficiency.

[0006] To achieve the above-mentioned purpose, the technical solutions adopted by the embodiments of the present application are as follows:

[0007] In a first aspect, the embodiments of the present application provide an information processing method for game editing, comprising:

[0008] In the game editing stage, a graphical programming interface is displayed in a graphical user interface; wherein the graphical programming interface comprises a programming graph group composed of one or more programming graphs; each programming graph corresponds to a piece of code, and the programming graph group corresponds to a code combination formed by the codes corresponding to the one or more programming graphs;

[0009] In response to a breakpoint creation instruction, a breakpoint identifier is added at a target programming graph corresponding to the breakpoint creation instruction;

[0010] In response to a running instruction, a game running scene is displayed in the graphical user interface, and the code combination is run;

[0011] In response to the code combination running to a code position corresponding to the breakpoint identifier, the game running scene is paused, and the running of the code combination is also paused.

[0012] displaying a debugging interface on the graphical user interface, the debugging interface including the programming graphical group and debugging controls configured to control debugging the code combination corresponding to the programming graphical group.

[0013] In a second aspect, the embodiments of the present application further provide an information processing apparatus for game editing, comprising a display module, a control module and a debugging module.

[0014] The display module is configured to display a graphical programming interface in a graphical user interface during a game editing stage; wherein the graphical programming interface includes a programming graphical group composed of one or more programming graphics; each programming graphic corresponds to a piece of code, and the programming graphical group corresponds to a code combination formed by the codes corresponding to the one or more programming graphics.

[0015] The control module is configured to, in response to a breakpoint creation instruction, control adding a breakpoint identifier at a target programming graphic corresponding to the breakpoint creation instruction.

[0016] The control module is configured to, in response to a running instruction, control displaying a game running scene in the graphical user interface and running the code combination.

[0017] The control module is configured to, in response to the code combination running to a code position corresponding to the breakpoint identifier, control pausing the game running scene and pausing running the code combination.

[0018] The debugging module is configured to display a debugging interface on the graphical user interface, the debugging interface including the programming graphical group and debugging controls configured to control debugging the code combination corresponding to the programming graphical group.

[0019] In a third aspect, the embodiments of the present application provide an electronic device, comprising a processor, a storage medium and a bus, the storage medium storing machine readable instructions executable by the processor, the processor and the storage medium communicating through the bus when the electronic device is running, the processor executing the machine readable instructions to perform the information processing method for game editing provided in the first aspect.

[0020] In a fourth aspect, the embodiments of the present application provide a computer readable storage medium, the storage medium storing a computer program, the computer program being executed by a processor to perform the information processing method for game editing provided in the first aspect.

[0021] The present application has the following beneficial effects:

[0022] The application provides a game editing information processing method and device, electronic equipment and a storage medium. The method comprises the following steps: in a game editing stage, displaying a graphical programming interface in a graphical user interface; in response to a breakpoint creation instruction, adding a breakpoint identifier at a target programming graph corresponding to the breakpoint creation instruction; in response to a running instruction, displaying a game running scene in the graphical user interface and controlling the running of a code combination; in response to the code combination running to a code position corresponding to the breakpoint identifier, pausing the game running scene and pausing the running of the code combination; displaying a debugging interface on the graphical user interface, wherein the debugging interface comprises a programming graph group and a debugging control, and the debugging control is configured to control the debugging of the code combination corresponding to the programming graph group. The method can pause the game code running process to the code position corresponding to the programming graph in real time and dynamically by inserting the breakpoint identifier in the graphical programming interface, thereby realizing accurate positioning of the debugging, and the debugging control in the debugging interface can be used to debug the code corresponding to the paused programming graph, thereby realizing real-time and dynamic code debugging during the code running process and improving the code debugging efficiency.

[0023] Secondly, the application provides a single-step debugging mode, in which the user can quickly locate the problem without repeatedly running the entire program.

[0024] In addition, the breakpoint insertion in the graphical programming interface can intuitively display the breakpoint setting and the breakpoint display state, so that the programming graph corresponding to the currently paused game running scene can be located in real time during the code running process, and the current value of the programming graph is displayed, so that the user can understand the current paused code state without checking complex logs.

[0025] Finally, the object instance viewing function is provided, so that the user can quickly and accurately locate the game object to be debugged from multiple same game objects, thereby improving the debugging accuracy. BRIEF DESCRIPTION OF DRAWINGS

[0026] In order to more clearly illustrate the technical solutions of the embodiments of the application, the following will briefly introduce the drawings needed to be used in the embodiments. It should be understood that the following drawings only show some embodiments of the application, and therefore should not be regarded as a limitation on the scope. For those skilled in the art, other related drawings can also be obtained without creative labor.

[0027] Figure 1 A flowchart of a game editing information processing method provided by the embodiments of the application;

[0028] Figure 2 A schematic diagram of a graphical programming interface provided by the embodiments of the application;

[0029] Figure 3 A flowchart of another information processing method for game editing provided by an embodiment of the present application;

[0030] Figure 4 A flowchart of another information processing method for game editing provided in an embodiment of the present application;

[0031] Figure 5 A schematic diagram of another graphical programming interface provided in an embodiment of the present application;

[0032] Figure 6 A flowchart of another information processing method for game editing provided in an embodiment of the present application;

[0033] Figure 7 A schematic diagram of another graphical programming interface provided in an embodiment of the present application;

[0034] Figure 8 A schematic diagram of another graphical programming interface provided in an embodiment of the present application;

[0035] Figure 9 A flowchart of another information processing method for game editing provided by an embodiment of the present application;

[0036] Figure 10 A schematic diagram of another graphical programming interface provided in an embodiment of the present application;

[0037] Figure 11 A flowchart of another information processing method for game editing provided by an embodiment of the present application;

[0038] Figure 12 A schematic diagram of another graphical programming interface provided in an embodiment of the present application;

[0039] Figure 13 A flowchart of another information processing method for game editing provided in an embodiment of the present application;

[0040] Figure 14 A flowchart of another information processing method for game editing provided by an embodiment of the present application;

[0041] Figure 15 A schematic diagram of a page for adding breakpoints in batches provided in an embodiment of the present application;

[0042] Figure 16 A schematic diagram of adding breakpoints in batches provided in an embodiment of the present application;

[0043] Figure 17 A flowchart of another information processing method for game editing provided in an embodiment of the present application;

[0044] Figure 18 A classification display schematic diagram of a programmed graph and a trigger provided for an embodiment of the present application;

[0045] Figure 19 A debugging interface schematic diagram provided for an embodiment of the present application;

[0046] Figure 20 A flowchart of another information processing method of game editing provided for an embodiment of the present application;

[0047] Figure 21 A flowchart of another information processing method of game editing provided for an embodiment of the present application;

[0048] Figure 22 A user interaction schematic diagram provided for an embodiment of the present application;

[0049] Figure 23 A flowchart of another information processing method of game editing provided for an embodiment of the present application;

[0050] Figure 24 A flowchart of another information processing method of game editing provided for an embodiment of the present application;

[0051] Figure 25 Another user interaction schematic diagram provided for an embodiment of the present application;

[0052] Figure 26 Another breakpoint batch adding page schematic diagram provided for an embodiment of the present application;

[0053] Figure 27 A flowchart of another information processing method of game editing provided for an embodiment of the present application;

[0054] Figure 28 An object instance viewing interaction schematic diagram provided for an embodiment of the present application;

[0055] Figure 29 Another object instance viewing interaction schematic diagram provided for an embodiment of the present application;

[0056] Figure 30 A flowchart of another information processing method of game editing provided for an embodiment of the present application;

[0057] Figure 31 A flowchart of another information processing method of game editing provided for an embodiment of the present application;

[0058] Figure 32 A schematic diagram of an information processing device of game editing provided for an embodiment of the present application;

[0059] Figure 33 FIG. 1 is a structural schematic diagram of an electronic device according to an embodiment of the present application. DETAILED DESCRIPTION

[0060] In order to make the objectives, technical solutions and advantages of the embodiments of the present application clearer, the technical solutions in the embodiments of the present application will be described clearly and completely below with reference to the drawings in the embodiments of the present application. It should be understood that the drawings in the present application serve only the purpose of description and illustration, and do not serve to limit the scope of protection of the present application. In addition, it should be understood that the schematic drawings are not drawn according to the actual proportions. The flowcharts used in the present application show the operations implemented according to some embodiments of the present application. It should be understood that the operations of the flowcharts can not be implemented in sequence, and the steps without logical contextual relationship can be reversed in sequence or implemented simultaneously. In addition, one or more other operations can be added to the flowcharts or one or more operations can be removed from the flowcharts under the guidance of the content of the present application.

[0061] In addition, the described embodiments are only some of the embodiments of the present application, not all the embodiments. The components of the embodiments of the present application described and shown in the drawings herein can be arranged and designed in various different configurations. Therefore, the following detailed description of the embodiments of the present application provided in the drawings is not intended to limit the scope of the claimed present application, but only represents selected embodiments of the present application. Based on the embodiments of the present application, all other embodiments obtained by those skilled in the art without creative labor fall within the scope of protection of the present application.

[0062] It should be noted that the term "comprising" will be used in the embodiments of the present application to indicate the presence of the features declared thereafter, but does not exclude the addition of other features.

[0063] In a UGC (User Generated Content, user-generated content) visual programming system, it is often necessary to dynamically observe the runtime state to determine whether the execution flow meets the expectations, and to directly capture and troubleshoot problems on site when an exception occurs.

[0064] Debugging is an indispensable part of the programming process, used to verify whether the program logic is correct and to troubleshoot runtime exceptions. However, the debugging function of the existing UGC visual programming system is usually simple and cannot meet the needs of dynamic observation and real-time analysis.

[0065] In the existing UGC visual programming system, debugging mainly relies on the following methods:

[0066] 1. Run-after result verification: After designing the program, the user judges whether the logic is correct by running the entire program and observing the final output result. For example, in a game map editor, the user needs to repeatedly test the map to verify the script effect.

[0067] 2. Log output: Some systems support outputting key variables or states to a log file during program execution, and the user needs to view the log after the program ends to analyze the problem.

[0068] 3. Manual modification and retry: When the program logic is found to be abnormal, the user needs to modify the programming graph combination, re-run the program and verify the result again.

[0069] The workflow of these solutions is usually: the user builds logic by dragging programming graphs, the system maps the programming graphs to the underlying executable code, and runs to generate results or logs. The user judges whether the program meets the expectations according to the results.

[0070] The existing debugging methods have the following significant defects:

[0071] 1. Lack of real-time: Users cannot dynamically observe variables or logic states during program execution, and can only indirectly analyze through post-run results or logs, resulting in low debugging efficiency.

[0072] 2. Repetitive work: Users need to repeatedly run the program and test it to verify the effect, especially in complex logic, locating problems requires multiple modifications and retries, which takes a long time.

[0073] 3. Difficulty in troubleshooting: When the program has an exception, there is a lack of on-site capture mechanism, and it is difficult for users to quickly locate the root cause of the problem, for example, it is difficult to determine whether a variable is modified unexpectedly at a specific step.

[0074] 4. Poor user experience: For non-professional programming users, the existing debugging method is complex and not intuitive, increasing the learning and use cost.

[0075] The reason for these defects is that the existing system lacks real-time pause and state observation mechanism, and cannot support users to accurately debug at any position of program execution.

[0076] Based on this, the scheme provides an information processing method for game editing. In the game programming stage, a breakpoint identifier is added to the programming graph based on user interaction in the graphical programming interface, so that during the game running process, the current game screen can be dynamically paused based on the added breakpoint identifier, and the programming graph corresponding to the current paused game screen in the graphical programming interface is paused, the precise positioning of the programming graph is realized, then through the displayed debugging interface, the paused programming graph can be debugged to realize dynamic and precise debugging of the game running program during the game running process, and the debugging efficiency and accuracy are improved.

[0077] Figure 1 A flowchart of an information processing method for game editing provided by the embodiments of the present application is shown in FIG. Figure 1 The method can include:

[0078] S101, in the game editing stage, a graphical programming interface is displayed in the graphical user interface.

[0079] The graphical programming interface includes a programming graph group composed of one or more programming graphs. Each programming graph corresponds to a piece of code, and the programming graph group corresponds to a code combination formed by one or more pieces of code corresponding to the programming graphs.

[0080] In game editing, programming is performed using programming graphs, which is a way of achieving logic design by visualizing modules (similar to "building blocks"). This reduces the threshold for game creation without the need to write traditional code. This mode is widely used in game development tools, UGC game editors, and educational programming games.

[0081] The essence of programming using programming graphs is to encapsulate code logic as visual modules (such as conditional judgment, loop, variable assignment, etc.). Users complete logic building by dragging and connecting programming graphs (i.e., building blocks), and the system automatically converts them into executable code.

[0082] The present scheme is based on this programming mode for game editing, and based on this, the debugging of the game running program is realized.

[0083] Optionally, in the game editing stage, a graphical programming interface can be displayed in the graphical user interface. The graphical programming interface is an interface provided to users for programming based on programming graphs. Users can complete the construction of game logic by dragging and connecting programming graphs in the graphical programming interface.

[0084] Each programming graph corresponds to a piece of code, and one or more programming graphs can form a programming graph group, and the programming graph group corresponds to a code combination composed of one or more pieces of code.

[0085] Figure 2A schematic diagram of a graphical programming interface provided in an embodiment of the present application is shown as follows: Figure 2 As shown, the middle area of ​​the interface displays a code combination consisting of one or more programming graphics. Combined with the panel content in the right area, it can be seen that programming graphics have different types, corresponding to different functions. By combining programming graphics with different functions, a code combination can be formed. Among them, programming graphics can be connected to each other or nested within each other. For example, an action-type programming graphic is nested within a control-type programming graphic, and a variable-type programming graphic is nested within an action-type programming graphic.

[0086] like Figure 2 The panel shown on the right side schematically shows several different types of programming graphics and the graphic shapes corresponding to each type of programming graphics.

[0087] S102 : In response to a breakpoint creation instruction, controlling the addition of a breakpoint identifier at a target programming graph corresponding to the breakpoint creation instruction.

[0088] By triggering a breakpoint creation command, you can add breakpoint markers to one or more programming graphics displayed in the graphical programming interface. Since the programming graphics correspond to the game running code, based on the breakpoint markers, you can control the game running code to pause when it reaches the code location corresponding to the breakpoint marker during the game running process, pausing the game running screen and the programming graphics in the graphical programming interface, facilitating real-time code debugging during the game running process.

[0089] S103. In response to the running instruction, control the display of the game running scene in the graphical user interface and control the running code combination.

[0090] After the breakpoint identifier is added, by triggering the run instruction, the game running scene can be displayed in the graphical user interface, and the running code combination can be controlled. The running code combination can be used to dynamically update the game running scene in real time, thereby displaying the running game screen.

[0091] S104: In response to the code combination running to the code position corresponding to the breakpoint identifier, controlling to pause the game running scene and controlling to pause the running of the code combination.

[0092] When the code combination runs to the code position corresponding to the breakpoint identifier, that is, when the programming graphic in the graphical programming interface runs to the programming graphic position where the breakpoint identifier is located, the code combination can be paused and the game running scene can be controlled to be paused. At this time, the game running scene displays the game screen corresponding to when the code combination is paused.

[0093] S105, display a debugging interface on the graphical user interface, the debugging interface including the programming graphical group and a debugging control, the debugging control being configured to control debugging of the code combination corresponding to the programming graphical group.

[0094] When the game running scene and the code combination are paused, the debugging interface is displayed on the graphical user interface, the debugging interface including the programming graphical group displayed in the graphical programming interface and the debugging control, and the debugging control being used to control debugging of the code combination corresponding to the programming graphical group.

[0095] It is worth noting that the debugging interface can be a separate interface independent of the graphical programming interface and the game running scene. That is, the debugging interface is realized through an additional interface. Of course, the debugging control can also be added to the graphical programming interface to obtain the debugging interface. Alternatively, the debugging control and the programming graphical group can also be added to the game running scene to obtain the debugging interface.

[0096] The embodiment does not limit the implementation of the debugging interface.

[0097] In summary, the information processing method for game editing provided in the embodiment includes: in a game editing stage, displaying a graphical programming interface in a graphical user interface; in response to a breakpoint creation instruction, adding a breakpoint identifier at a target programming graphical corresponding to the breakpoint creation instruction; in response to a running instruction, displaying a game running scene in the graphical user interface and controlling running of a code combination; in response to the code combination running to a code position corresponding to the breakpoint identifier, pausing the game running scene and pausing running of the code combination; and displaying a debugging interface on the graphical user interface, the debugging interface including the programming graphical group and a debugging control, the debugging control being configured to control debugging of the code combination corresponding to the programming graphical group. Through the method, the breakpoint identifier is inserted in the programming graphical in the graphical programming interface, and the game code running process can be paused at the code position corresponding to the programming graphical in real time and dynamically, precise positioning of debugging is realized; based on the debugging control in the debugging interface, the code corresponding to the paused programming graphical can be debugged, real-time and dynamic code debugging in the code running process is realized, and the code debugging efficiency is improved.

[0098] Figure 3 Another flowchart of the information processing method for game editing provided in the embodiment is shown in the figure; optionally, before the step of adding the breakpoint identifier at the target programming graphical corresponding to the breakpoint creation instruction in step S102, the step further includes:

[0099] S201, determine a candidate programming graphical.

[0100] The candidate programming graph can be determined from all programming graphs in the graphical programming interface, and the candidate programming graph can be multiple. The user can select the candidate programming graph from all programming graphs through operation.

[0101] In S202, if the type of the candidate programming graph is the preset type, the candidate programming graph is taken as the target programming graph.

[0102] Since not all types of programming graphs can add breakpoint identifiers, generally, only the event, action, control, condition, and the like types of programming graphs can add breakpoint identifiers, and the value and variable types of programming graphs cannot add breakpoint identifiers. Therefore, based on the candidate programming graph determined by the user, it is necessary to first judge whether the type of the candidate programming graph is the preset type, that is, the set types that can insert breakpoint identifiers. The preset type includes but is not limited to the event, action, control, condition, and the like types.

[0103] When the type of the candidate programming graph is the preset type, the candidate programming graph can be taken as the target programming graph to insert the breakpoint.

[0104] Figure 4 Another flowchart of the information processing method for game editing provided by the embodiment of the present application is provided. Optionally, the method further includes:

[0105] In S301, if the type of the candidate programming graph is the preset type, the display of the breakpoint creation control is controlled.

[0106] In some embodiments, when the type of the candidate programming graph is the preset type, the breakpoint creation control can be displayed in the graphical programming interface. The breakpoint creation control is used to provide an entry for the user to add the breakpoint identifier.

[0107] Figure 5 Another schematic diagram of the graphical programming interface provided by the embodiment of the present application is provided, as shown in (a) of FIG. 7. When the type of the candidate programming graph is the preset type, the breakpoint creation control can be displayed at the bottom of the graphical programming interface. Here, the breakpoint creation control also refers to the breakpoint creation control described above. Figure 5

[0108] In S302, in response to the triggering operation on the breakpoint creation control, the breakpoint creation instruction is triggered.

[0109] The user can trigger the breakpoint creation instruction by clicking the breakpoint creation control. The breakpoint creation instruction indicates that the breakpoint identifier is added to the candidate programming graph, that is, the determined target programming graph.

[0110] ​Of course, in some embodiments, based on the selected candidate programming graph, if the type of the candidate programming graph is a preset type, the user can also double-click the candidate programming graph to trigger the breakpoint creation instruction, that is, the implementation can be diversified.

[0111] Optionally, in step S102, the control of adding the breakpoint identifier at the target programming graph corresponding to the breakpoint creation instruction can include: adding the breakpoint identifier at a preset position of the target programming graph.

[0112] In some embodiments, according to the breakpoint creation instruction, the breakpoint identifier can be added at a preset position of the target programming graph indicated by the breakpoint creation instruction.

[0113] After clicking the breakpoint adding control as shown in (a) of FIG. 10, Figure 5 the interface as shown in (b) of FIG. 10 can be jumped to, that is, the breakpoint identifier is added at the preset position of the target programming graph. Figure 5 As shown in (b) of FIG. 10, the breakpoint identifier can be added at the left end of the line where the target graph programming is located, and for the target programming graph nested in other programming graphs, the breakpoint identifier can also be added at the left end of the line where the target programming graph is located. For example, the action type programming graph nested in the control type programming graph in the figure is to add the generated breakpoint identifier at the left end of the line where the control type programming graph is located, that is, when the blue programming graph nested in the purple programming graph in the figure is added with the breakpoint identifier, although the breakpoint identifier is added at the edge of the outer purple programming graph, the breakpoint identifier is added for the corresponding line of the blue programming graph nested in the purple programming graph.

[0114] Figure 5 Optionally, the breakpoint identifier can be represented by a red arrow-like graph as shown in (b) of FIG. 10, and in actual application, other graphs can also be used to represent the breakpoint identifier.

[0115] Another flowchart of the information processing method for game editing provided by the embodiments of the present application; optionally, in step S102, the control of adding the breakpoint identifier at the target programming graph corresponding to the breakpoint creation instruction can include:

[0116] Figure 6 S401, adding an initial breakpoint identifier at a preset position of the target programming graph.

[0117] In some embodiments, the conditions of the generated breakpoint for the target programming graph can also be edited. The purpose of the condition editing is to edit the conditions for the breakpoint to take effect. For the breakpoint whose condition is edited, when the code runs to the breakpoint, the breakpoint will only take effect and the code will stop running when the condition is met.

[0118] In some embodiments, the conditions of the generated breakpoint for the target programming graph can also be edited. The purpose of the condition editing is to edit the conditions for the breakpoint to take effect. For the breakpoint whose condition is edited, when the code runs to the breakpoint, the breakpoint will only take effect and the code will stop running when the condition is met. ​

[0119] The breakpoint identifier generated for the target programming graph in the above manner can be taken as an initial breakpoint identifier.

[0120] S402, in response to the confirmation operation of the initial breakpoint identifier, determining a breakpoint to be edited.

[0121] If the user wants to conditionally edit the breakpoint of the target programming graph, the user can select the initial breakpoint identifier corresponding to the target programming graph, and determine the breakpoint corresponding to the target programming graph as the breakpoint to be edited.

[0122] S403, in response to the conditional editing operation, generating a breakpoint pause condition of the breakpoint to be edited, and updating the initial breakpoint identifier as a breakpoint identifier.

[0123] The breakpoint identifier indicates that the breakpoint is a conditional breakpoint.

[0124] Figure 7 Another graphical programming interface provided by an embodiment of the present application is shown in FIG. 10. As shown in (a) of FIG. 10, for the selected breakpoint to be edited, the initial breakpoint identifier of the breakpoint to be edited is triggered, and then the interface shown in (b) of FIG. 10 can be switched to. The initial breakpoint identifier is distinguished from other breakpoint identifiers and highlighted, indicating that the breakpoint to be edited is currently in an editing state, and the target programming graph corresponding to the breakpoint to be edited can be highlighted in the graphical programming interface. Figure 7 Figure 7 Meanwhile, as shown in the interface in (b) of FIG. 10, the setting condition control can be displayed in the operation bar at the bottom of the graphical programming interface. By triggering the setting condition control, the breakpoint to be edited can be conditionally edited to generate a breakpoint pause condition of the breakpoint to be edited, and the initial breakpoint identifier is updated as a breakpoint identifier.

[0125] Figure 7

[0126] In the scenario of conditional editing, the initial breakpoint identifier is updated as a breakpoint identifier, and the generated breakpoint identifier is a conditional breakpoint identifier.

[0127] Figure 8 Another graphical programming interface provided by an embodiment of the present application is shown in FIG. 10. As shown in (a) of FIG. 10, for the selected breakpoint to be edited, the initial breakpoint identifier of the breakpoint to be edited is triggered, and then the interface shown in (b) of FIG. 10 can be switched to. The initial breakpoint identifier is distinguished from other breakpoint identifiers and highlighted, indicating that the breakpoint to be edited is currently in an editing state, and the target programming graph corresponding to the breakpoint to be edited can be highlighted in the graphical programming interface. Figure 8 Figure 8 As can be seen, the display form of the breakpoint identifier subjected to conditional editing is different from that of the breakpoint identifier not subjected to conditional editing, so as to effectively distinguish whether the breakpoint is a conditional breakpoint.

[0128] As can be seen, the display form of the breakpoint identifier subjected to conditional editing is different from that of the breakpoint identifier not subjected to conditional editing, so as to effectively distinguish whether the breakpoint is a conditional breakpoint.

[0129] Figure 9 ​​​​Another flowchart of a game editing information processing method provided by an embodiment of the present application is shown in FIG. 6. Optionally, in step S403, in response to the condition editing operation, a breakpoint pause condition of the breakpoint to be edited is generated, including:

[0130] S501, in response to a condition editing operation, a condition editing area and a creation panel are displayed near the target programming graph.

[0131] The creation panel includes relevant programming graphs and parameter information for condition editing.

[0132] Based on the determined breakpoint to be edited, the condition editing area can be displayed near the target programming graph corresponding to the breakpoint to be edited, and the creation panel can be displayed in the graphical programming interface.

[0133] Figure 10 Another graphical programming interface provided by an embodiment of the present application is shown in FIG. 6. As shown in (a) of FIG. 6, for the breakpoint to be edited, the setting condition control is triggered, and the interface shown in (b) of FIG. 6 can be jumped to. The condition editing area can be displayed below the target programming graph where the breakpoint to be edited is located, and the creation panel can be expanded on the right side of the graphical programming interface. Some optional programming graphs are displayed in the creation panel. Figure 10 Figure 10

[0134] S502, in response to the editing operation on the programming graph in the creation panel, the breakpoint pause condition of the breakpoint to be edited is generated in the condition editing area.

[0135] The user can trigger the condition editing of the breakpoint to be edited by creating the programming graph in the code, so as to generate the breakpoint pause condition of the breakpoint to be edited in the condition editing area displayed below the target programming graph.

[0136] For the breakpoint that has been conditionally edited, in the subsequent process of running the code combination, when the breakpoint is reached, it can be first judged whether the pause condition of the breakpoint is met. If met, the code combination is stopped at the breakpoint. If not met, the breakpoint is considered invalid, and the code combination continues to run until the next breakpoint is encountered.

[0137] Figure 11 Another flowchart of a game editing information processing method provided by an embodiment of the present application is shown in FIG. 6. Optionally, in step S502, in response to the editing operation on the programming graph in the creation panel, the breakpoint pause condition of the breakpoint to be edited is generated in the condition editing area, including:

[0138] S601, in response to the triggering operation on each programming graph corresponding to the breakpoint pause condition in the creation panel, each programming graph is dragged into the condition editing area.

[0139] ​​In some embodiments, a programming graph corresponding to the condition to be edited can be selected from the creation panel, and the selected programming graph can be dragged into the condition editing area.

[0140] For example, the required programming graph is clicked from the creation panel, and then the programming graph is dragged or moved into the condition editing area.

[0141] S602, in response to the editing operation on each programming graph in the condition editing area, the editing result of each programming graph is taken as the breakpoint pause condition of the breakpoint to be edited.

[0142] The editing operation is performed on each programming graph dragged into the condition editing area, and the editing result is obtained. The editing result is a code combination corresponding to the condition, so the editing result is taken as the breakpoint pause condition.

[0143] Figure 12 Another schematic diagram of a graphical programming interface provided by an embodiment of the present application is provided. By selecting, dragging, and editing the programming graph in the creation panel shown in (a) in Figure 12 After the condition editing, the editing result shown in (b) in Figure 12 The editing result is the connection result of each programming graph dragged in, and the code combination corresponding to the editing result is the breakpoint pause condition of the breakpoint to be edited.

[0144] In some embodiments, after the creation panel is expanded, if the user does not want to perform the condition editing of the breakpoint, any blank can be clicked. At this time, the creation panel is closed, the target programming graph can be deselected, but the selected breakpoint to be edited can be highlighted. The blank is clicked again, the highlight of the breakpoint to be edited is removed, that is, the selected breakpoint to be edited is deselected. At this time, the initial breakpoint identifier returns to the normal breakpoint identifier display state.

[0145] Optionally, after the breakpoint pause condition of the breakpoint to be edited is generated, the creation panel can be automatically closed.

[0146] Of course, for the condition breakpoint that has been edited, the breakpoint can be selected again, the creation panel can be opened again, and the user can modify the edited condition through the programming graphs in the creation panel.

[0147] Figure 13 Another flowchart of the information processing method for game editing provided by an embodiment of the present application is provided. Optionally, in step S102, in response to the breakpoint creation instruction, the breakpoint identifier is added at the target programming graph corresponding to the breakpoint creation instruction, including:

[0148] S701, in response to a breakpoint batch creation instruction, displaying a breakpoint addition identifier at a preset position of each preset type of programming graph in the graphical programming interface.

[0149] In some embodiments, the scheme also supports batch creation of breakpoints. Through a breakpoint batch creation instruction, a breakpoint addition identifier can be displayed at a preset position of each preset type of programming graph in the graphical programming interface, to indicate that each programming graph with the displayed breakpoint addition identifier can simultaneously undergo batch addition of breakpoints.

[0150] S702, in response to a confirmation operation on the breakpoint addition identifiers corresponding to the multiple selectable programming graphs of each preset type of programming graph, generating and displaying a breakpoint identifier at the breakpoint addition identifier of each selectable programming graph.

[0151] The user can select the selectable programming graphs that need to be batch processed from the programming graphs with the displayed breakpoint addition identifiers according to needs, and click the breakpoint addition identifiers of the selectable programming graphs in turn, so as to generate and display a breakpoint identifier on the left side of each selectable programming graph.

[0152] Figure 14 Another flowchart of an information processing method for game editing provided by an embodiment of the present application is shown. In step S701, in response to a breakpoint batch creation instruction, a breakpoint addition identifier is displayed at a preset position of each preset type of programming graph in the graphical programming interface, including:

[0153] S801, in response to a trigger operation on a breakpoint debugging control in the graphical programming interface, displaying a breakpoint batch addition page.

[0154] A breakpoint debugging tab can be added in the running log, and the breakpoint batch addition page can be triggered by the breakpoint debugging tab.

[0155] Figure 15 A schematic diagram of a breakpoint batch addition page provided by an embodiment of the present application is shown. After clicking a running log control in the graphical programming interface, the running log interface can be jumped to, and after clicking a breakpoint debugging control in the running log interface, the breakpoint batch addition page shown on the right can be displayed.

[0156] By default, the switch for shortcut breakpoint addition in the breakpoint batch addition page is not turned on. When the user needs to perform batch addition of breakpoints, the switch for shortcut breakpoint addition can be triggered to be turned on, so as to perform batch addition of breakpoints.

[0157] S802, in response to a trigger operation on a shortcut breakpoint addition control in the breakpoint batch addition page, displaying a breakpoint addition identifier at a preset position of each preset type of programming graph in the graphical programming interface, and displaying a prompt message.

[0158] The prompt information is used to prompt the user to add the breakpoint identifier to the programming graph of the preset type by triggering the breakpoint identifier.

[0159] Figure 16 A schematic diagram of batch adding of breakpoints is provided for the embodiments of the present application. After clicking on the switch for shortcut adding of breakpoints as shown in (a) of Figure 16 , the interface as shown in (b) of Figure 16 is jumped to, that is, the graphical programming interface is jumped back to, and the breakpoint identifier that can be added is displayed on the left side of all programming graphs of the preset type in the graphical programming interface. The programming graphs that have the breakpoint identifier that can be added can be added with the breakpoint at the same time.

[0160] In addition, after the switch for shortcut adding of breakpoints is turned on, the prompt information is also displayed in the interface as shown in (a) of Figure 16 to prompt the user that the batch adding of the breakpoints to the programming graphs can be completed by clicking on the breakpoint identifier that can be added corresponding to each programming graph in (b) of Figure 16 .

[0161] Optionally, by clicking on the closing control behind the shortcut adding of the breakpoints in (b) of 16, the batch adding of the breakpoints mode can be exited. Alternatively, the switch for shortcut adding of the breakpoints can also be turned off in the interface as shown in (a) of Figure 16 , and the batch adding of the breakpoints mode can also be exited.

[0162] Optionally, after the breakpoint identifier is generated and displayed at the breakpoint identifier that can be added of each selectable programming graph in step S702, the method further includes: according to the belonging relationship between each selectable programming graph and the trigger, the selectable programming graphs are classified and displayed on the breakpoint batch adding page.

[0163] In some embodiments, for each selectable programming graph to which the breakpoint identifier is batch added, the selectable programming graphs can be classified and displayed on the breakpoint batch adding page according to the belonging relationship between each selectable programming graph and the trigger.

[0164] The trigger defines the execution timing of the programming graph, and the programming graph defines the content to be executed. Generally, one trigger can contain multiple programming graphs, and triggers with similar conditions can be combined into one trigger group. By classifying and displaying each selectable programming graph to which the breakpoint is added through the trigger, the debugging and management of each selectable programming graph can be facilitated.

[0165] Figure 16 A flowchart of another information processing method for game editing provided for the embodiments of the present application; in the above steps, according to the belonging relationship between each selectable programming graph and the trigger, the selectable programming graphs are classified and displayed on the breakpoint batch adding page, which includes:

[0166] S901, display at least one trigger group in the breakpoint batch adding page.

[0167] Figure 17 A classification display schematic diagram of programming graphics and triggers is provided for the embodiments of the present application. As shown in the figure, multiple trigger groups can be displayed in the breakpoint batch adding page, and only two trigger groups are shown here. Figure 18

[0168] S902, determine the trigger group to which each optional programming graphic belongs according to the belonging relationship of each optional programming graphic and trigger.

[0169] The belonging relationship of programming graphics and triggers can be directly obtained, and based on the belonging relationship, each optional programming graphic can be classified into the trigger group.

[0170] S903, display each optional programming graphic under the trigger group to which it belongs, and display the jump control corresponding to each optional programming graphic.

[0171] As shown in the figure, while displaying the optional programming graphics under the trigger group, the jump control behind the optional programming graphic can also be displayed, and through the jump control, the position of the optional programming graphic in the graphical programming interface can be quickly and accurately jumped to. Figure 18

[0172] It is worth noting that when displaying the optional programming graphics under the trigger group, the text description information corresponding to the optional programming graphics is displayed,

[0173] Optionally, it further includes: in response to the triggering operation of the jump control, jumping to the position of the optional programming graphic corresponding to the jump control in the graphical programming interface.

[0174] After clicking the jump control behind a certain optional programming graphic under the trigger group as shown in the figure, the position of the optional programming graphic in the graphical programming interface can be jumped to. Figure 18

[0175] Optionally, it further includes: in response to the disabling operation of the breakpoint identifier, updating the state of the breakpoint identifier to the disabled state and keeping the breakpoint identifier displayed.

[0176] In some embodiments, as shown in the figure, Figure 18 ​​​As shown in (b) in FIG. 11, after adding the breakpoint, the disabled breakpoint control can also be displayed in the bottom operation bar of the graphical programming interface. After selecting a breakpoint identifier, the disabled breakpoint control can be clicked to update the state of the selected breakpoint identifier to the disabled state, indicating that the breakpoint indicated by the breakpoint identifier is not available, but the breakpoint identifier can still be displayed. That is, the breakpoint is retained but not effective. At this time, the disabled breakpoint control can be updated to the enabled breakpoint control. The user can click the enabled breakpoint control again to restore the effectiveness of the breakpoint when the user wants to restore the breakpoint.

[0177] Optionally, in step S104, in response to the code combination running to the code position corresponding to the breakpoint identifier, the game running scene is controlled to be paused, and the code combination is controlled to be paused, including: in response to the code combination running to the code position corresponding to the breakpoint identifier, the code combination is controlled to be paused; and according to the mapping relationship between the currently paused code combination and the game running scene, the game running scene is controlled to be paused.

[0178] In some embodiments, since the code combination composed of the programming graphs corresponds to the game running code, and running the game running code can control the change of the game running scene, when the code combination runs to the code position corresponding to the breakpoint identifier, the code combination can be paused, and according to the mapping relationship between the currently paused code combination and the game running scene, the game running scene can be controlled to be paused. The game screen when the game running scene is paused is the game screen corresponding to the game running code corresponding to the paused code combination.

[0179] Optionally, in step S104, in response to the code combination running to the code position corresponding to the breakpoint identifier, the game running scene is controlled to be paused, and the code combination is controlled to be paused, including: in response to the code combination running to the code position corresponding to the breakpoint identifier, according to the breakpoint pause condition corresponding to the breakpoint identifier, the game running scene is controlled to be paused, and the code combination is controlled to be paused.

[0180] In some embodiments, if the breakpoint to which the code combination runs is a conditional breakpoint, the code combination can be controlled to be paused and the game running scene can be controlled according to the pause condition set for the conditional breakpoint.

[0181] Optionally, according to the breakpoint pause condition corresponding to the breakpoint identifier, the game running scene is controlled to be paused, and the code combination is controlled to be paused, including: if the current value of the at least one programming graph corresponding to the breakpoint identifier satisfies the breakpoint pause condition, the code combination is controlled to be paused; and according to the mapping relationship between the currently paused code combination and the game running scene, the game running scene is controlled to be paused.

[0182] In an implementable manner, since there is a nested relationship between the programming graphics, the breakpoint identifier can correspond to programming graphics that can include programming graphics of multiple value types and programming graphics of variable types. When the current value of at least one programming graphic in the programming graphics corresponding to the breakpoint identifier satisfies the breakpoint pause condition, the running code combination can be controlled to pause, and the game running scene can be controlled to pause.

[0183] Optionally, the game running scene can be switched to by clicking a trial control in the graphical programming interface. By running the programming graphics in the graphical programming interface, the game running scene can be controlled to run in real time, and a game screen corresponding to the currently running programming graphic can be displayed.

[0184] Optionally, in step S105, the debugging interface is displayed on the graphical user interface, including: displaying the debugging interface according to the currently paused game running scene and the graphical programming interface.

[0185] In some embodiments, the debugging interface can be displayed in combination with the currently paused game running scene and the graphical programming interface.

[0186] In other embodiments, the debugging interface can also be displayed independently without being based on the currently paused game running scene and the graphical programming interface.

[0187] Optionally, the debugging interface is displayed according to the currently paused game running scene and the graphical programming interface, including: floating and displaying the graphical programming interface in the currently paused game running scene, and displaying the debugging control in the graphical programming interface.

[0188] Figure 7 A debugging interface provided by an embodiment of the present application is shown in the following figure. When the running code combination is paused, the game running scene is also paused, Figure 19 The game screen when the game running scene is paused is displayed, and the graphical programming interface can also be displayed in the form of a floating window in the upper left corner of the game running scene. Since the display size of the floating window is limited, the graphical programming interface cannot be displayed in its entirety, and only part of the graphical programming interface is displayed.

[0189] In addition, an operation bar can also be displayed at the bottom of the game running scene, and the debugging control can be displayed in the operation bar. The debugging control can be used to debug the code corresponding to the currently paused programming graphic.

[0190] Figure 19 Another flowchart of a game editing information processing method provided by an embodiment of the present application is shown in the following figure. Optionally, the method further includes:

[0191] S1001, determine the pause programming graph to which the current pause is according to the correspondence between the current paused code combination and the programming graph.

[0192] Since the programming graph is corresponding to the code combination, according to the current paused code combination, the pause programming graph to which the current pause is in the graphical programming interface can be determined.

[0193] S1002, suspend and display the graphical programming interface in the current paused game running scene, and highlight the pause programming graph in the graphical programming interface.

[0194] As shown in Figure 20 , the pause programming graph to which the current pause is can be highlighted in the suspended and displayed graphical programming interface. Figure 19 In the embodiment, the pause programming graph and other programming graphs are distinguished in the form of highlighting. It should be noted that the highlighting here can be reflected in highlighting the border of the pause programming graph, for example, the green border in the figure is highlighted.

[0195] By highlighting the pause programming graph in the graphical programming interface, the user can quickly locate the programming graph position corresponding to the current code to be debugged.

[0196] Figure 19 Another flowchart of the information processing method of the game editing provided by the embodiment of the present application; the method further comprises:

[0197] S1101, in response to the triggering operation of the graphical programming interface, full-screen display the graphical programming interface, and suspend and display the current paused game running scene in the graphical programming interface.

[0198] Figure 21 A user interaction diagram provided by the embodiment of the present application, the user clicks the suspended and displayed graphical programming interface in the interface of (a) in Figure 22 , then can jump to the interface shown in (b) in Figure 22 , at this time, the graphical programming interface is full-screen displayed, and the current paused game running scene is suspended and displayed in the upper left corner of the graphical programming interface.

[0199] S1102, in response to the triggering operation of the debugging control, debug the programming graph in the programming graph region corresponding to the pause programming graph, and in the process of debugging, track and display the programming graph being debugged.

[0200] The user can debug the programming graphics in the programming graphics area corresponding to the paused programming graphics by triggering the debug control in the graphical programming interface. The programming graphics area corresponding to the paused programming graphics may refer to the area containing the paused programming graphics and the programming graphics nested in the paused programming graphics. Figure 22 As shown in (b), the code corresponding to the highlighted blue programming graphic and the entire red programming graphic nested within the blue programming graphic can be debugged.

[0201] During the debugging process, as the debugging continues, the current programming graphics being debugged will be tracked and displayed in the graphical programming interface, so that the user can accurately grasp the programming graphics position corresponding to the code currently being debugged.

[0202] Optionally, the debugging control includes: a single-step debugging control.

[0203] like Figure 22 As shown in (b) in FIG. 8 , the debugging control may include a single-step debugging control.

[0204] Figure 22 A flowchart of another information processing method for game editing provided by an embodiment of the present application is provided. In step S1102, in response to a triggering operation of a debug control, the programming graphics in the programming graphics area corresponding to the paused programming graphics are debugged, including:

[0205] S1201 , in response to a triggering operation of a single-step debugging control, debugging each programming graphic in the programming graphic area one by one, starting from the beginning of the programming graphic area.

[0206] Clicking the single-step debugging control will enter the single-step debugging mode. In this mode, you can debug each programming graphic in the programming graphic area step by step, starting from the beginning of the programming graphic area where you paused. The program will automatically pause after each step.

[0207] S1202. During the debugging process, according to the function of the programming graphic currently being debugged, the currently paused game running scene displayed in suspension is controlled to change accordingly.

[0208] During the debugging process, you can determine whether the currently paused game running scene will change based on the function of the programming graphic currently being debugged. If there will be a change, while debugging the programming graphic, you can control the currently paused game running scene displayed in suspension to make corresponding changes.

[0209] If the currently debugged programming graphics will not cause any changes to the game running scene, the currently paused game running scene displayed in the floating state remains unchanged.

[0210] Optionally, the debugging control further comprises a re-run control.

[0211] In step S1102, in response to a triggering operation of the debugging control, debugging is performed on the programming graph in the programming graph region corresponding to the paused programming graph, including: in response to a triggering operation of the re-run control, re-starting running the code combination, and when the code combination runs to the code position corresponding to the breakpoint identifier, controlling the game running scene to be paused and controlling the running code combination to be paused.

[0212] The user can trigger the code combination to re-run by clicking the re-run control, that is, the code combination is re-run from the beginning, and when running to the code position corresponding to the breakpoint identifier, the running code combination is controlled to be paused and the game running scene is controlled to be paused according to the above method.

[0213] Optionally, the debugging control comprises a continue running control.

[0214] Figure 23 Another flowchart of the information processing method for game editing provided by the embodiment of the application is provided; in step S1102, in response to a triggering operation of the debugging control, debugging is performed on the programming graph in the programming graph region corresponding to the paused programming graph, including:

[0215] S1301, in response to a triggering operation of the continue running control, the debugging interface is closed.

[0216] The user can close the debugging interface by clicking the continue running control, that is, exit the debugging mode.

[0217] S1302, continue running the code combination from the paused running code combination, and display the game running scene in the process of running the code combination.

[0218] At this time, the code combination will continue to run backward from the paused running code combination, and the dynamic game running scene is displayed in real time in the process of running the code combination, that is, the game running scene recovers from the pause mode to the running state. Until running to the next breakpoint, pause again; or until the code combination is completely run.

[0219] Optionally, in step S1002, the graphical programming interface is suspended and displayed in the currently paused game running scene, including: the graphical programming interface is suspended and displayed in the currently paused game running scene, and the debugging control and the description information corresponding to the paused programming graph are displayed in the currently paused game running scene.

[0220] Continue as Figure 24As shown, while the graphical programming interface is displayed in a floating manner in the currently paused game running scene, the debugging control can also be displayed in the bottom operation bar of the currently paused game running scene. At the same time, the description information can be displayed at the top of the currently paused game running scene, and the description information describes the text description information corresponding to the currently paused pause programming graphic.

[0221] Due to the limited size of the text display box, when the text description information is long, it can be displayed in thumbnail form. Click it to view the full text description information.

[0222] Optionally, the method further includes: in response to a triggering operation of a debugging control in a currently paused game running scene, debugging a programming graphic area corresponding to the paused programming graphic.

[0223] Players can also trigger code debugging through the debugging controls displayed in the currently paused game running scene. The debugging methods of each debugging control are the same as the debugging methods in the graphical programming interface mentioned above, so they will not be repeated here.

[0224] Optionally, in response to a triggering operation of a debug control in a currently paused game running scene, the programming graphic area corresponding to the paused programming graphic is debugged, including: in response to a triggering operation of a debug control in a currently paused game running scene, the programming graphic area corresponding to the paused programming graphic is debugged, and during the debugging process, according to the function of the programming graphic currently being debugged, the currently paused game running scene is controlled to produce corresponding changes.

[0225] Similar to the above process, during debugging based on the debugging controls in the game running scene, if the function corresponding to the programming graphics currently being debugged will cause changes to the game running scene, then the currently paused game running scene will also produce corresponding changes, so that users can intuitively feel the debugging effect.

[0226] Optionally, the graphical programming interface further displays a monitoring list, in which at least one programming graphic to be monitored set by the user and the current value of the programming graphic to be monitored are displayed.

[0227] like Figure 19 As shown in (b), a monitoring list is also displayed in the right panel of the graphical programming interface. The monitoring list displays the programming graphics to be monitored set by the user and the current value of the programming graphics to be monitored. The user can set one or more programming graphics to be monitored.

[0228] Optionally, the method further includes: in response to a confirmation operation on a specified programming graphic in the graphical programming interface, if the specified programming graphic exists in the monitoring list, highlighting the specified programming graphic in the monitoring list.

[0229] When any designated programming graphic is selected in the user graphical programming interface, if the designated programming graphic exists in the monitoring list, the designated programming graphic in the monitoring list can be highlighted.

[0230] Continue as Figure 22 As shown in (b) of the figure, the right panel of the graphical programming interface also displays a View Selected Object Value control. After enabling View Selected Object Value, the selected programming shape and its current value are displayed below the View Selected Object Value control for any programming shape selected by the user. For example, the currently selected programming shape is a variable type programming shape, and its current value is 3.

[0231] Figure 22 This is another user interaction diagram of an embodiment of the present application, such as Figure 25 As shown in (a) in FIG, an information search bar is also displayed in the right panel of the graphical programming interface. The method further includes: responding to search information of the programming graphic to be searched input in the information search bar, displaying the current value of the programming graphic to be searched.

[0232] By entering the variable or expression to be searched in the search bar, the searched programming graphics and the current value of the programming graphics can be displayed below the search bar. For example, the currently searched programming graphics is a variable type programming graphics, and its variable value is 111.

[0233] exist Figure 25 Click the collapse button on the right panel in (a) to jump to the following Figure 25 The interface shown in (b) in the figure.

[0234] Optionally, in step S1101, after the graphical programming interface is displayed in full screen, the method further includes: in response to an exit operation on the graphical programming interface, floatingly displaying the graphical programming interface in the currently paused game running scene.

[0235] In some embodiments, by clicking Figure 25 In (b) of the graphical programming interface, click the exit control in the upper left corner to switch to Figure 22 The interface shown in (a) in the figure, that is, the graphical programming interface is again suspended and displayed in the currently paused game running scene.

[0236] Optionally, in step S1002, after the graphical programming interface is displayed in a suspended manner in the currently paused game running scene, the method further includes: in response to an exit operation on the currently paused game running scene, exiting the debugging interface and restoring to the initial graphical programming interface.

[0237] In some embodiments,Figure 22 Under the interface shown in (a) in the above figure, by clicking the exit control in the upper left corner of the game running scene, the user can return to the graphical programming interface as shown in (b) in the above figure, and the user can re-add breakpoints. Figure 22

[0238] Another schematic diagram of a breakpoint batch adding page provided by an embodiment of the present application is shown in (a) in the above figure. As shown in (b) in the above figure, the left side of the graphical programming interface also displays a running log control. By clicking the running log control, the user can jump to the interface as shown in (c) in the above figure, that is, the currently paused programming graph in the breakpoint batch adding page is highlighted. By clicking the close control in the upper right corner, the user can close the breakpoint batch adding page. Figure 2 Figure 26 Figure 22 Figure 26

[0239] Figure 26 A flowchart of another information processing method of game editing provided by an embodiment of the present application is shown in the above figure. The method further includes:

[0240] S1401, in response to an object instance viewing operation, a plurality of object instances are displayed.

[0241] The present solution also provides an instance viewing function during game running. By selecting an object instance and displaying a game object corresponding to the object instance in a scene, the object instance that needs to be debugged can be quickly determined from a game running scene.

[0242] This is because the same game object is realized by editing only one programming graph. For example, when there are a plurality of ball objects in a game running scene, the plurality of ball objects are realized by one programming graph. To accurately debug a specified ball object, the instance viewing operation is needed to quickly locate the ball object to be debugged.

[0243] The object instances of the game objects can be created during the running of the game running scene.

[0244] Since different game objects have corresponding instances, the object instances of the game objects to be viewed need to be determined from the plurality of game objects.

[0245] In response to the object instance viewing operation, the plurality of object instances can be displayed in a debugging interface.

[0246] S1402, in response to a selection operation on a target object instance in the at least one object instance, a game running scene corresponding to the target object instance is displayed in an instance window. The game running scene displays an actual position of a game object corresponding to the target object instance in the game running scene. ​​​​​

[0247] When the user can select the target object instance to be viewed from the displayed multiple object instances, the game running scene corresponding to the target object instance can be displayed in the instance window, and the actual position of the game object corresponding to the target object instance in the game running scene is displayed in the game running scene. That is, the game object corresponding to the target object instance in the game picture is displayed in the instance window. By displaying the actual position of the target object instance in the game running scene in the instance window, the user can quickly determine whether the currently selected object instance is the object instance corresponding to the game object to be debugged, so as to quickly lock the game object to be debugged.

[0248] S1403, in response to the confirmation operation on the target object instance, jump to the debugging interface to debug the programming graph corresponding to the target object instance.

[0249] After the user views the instance window, if the user thinks that the game object displayed in the instance window is the game object to be debugged, the user can click the target object instance, so as to jump to the debugging interface to debug the programming graph corresponding to the target object instance, so as to realize the debugging of the game object corresponding to the target object instance.

[0250] Figure 27 An object instance viewing interaction schematic diagram provided by an embodiment of the present application is shown in FIG. 10. Figure 28 As shown in (a) of FIG. 10, in response to the viewing operation on the object instance, multiple object instances can be displayed in the upper information bar of the debugging interface. Here, the debugging interface refers to the debugging interface in which the graphical programming interface is located.

[0251] After the information bar is clicked, the interface shown in (b) of FIG. 10 can be jumped to, and multiple object instances are displayed in the graphical programming interface. Figure 28

[0252] Another object instance viewing interaction schematic diagram provided by an embodiment of the present application is shown in FIG. 11. Figure 28 As shown in (a) of FIG. 11, the user can select any object instance from the multiple object instances displayed in (a) of FIG. 11, and the graphical programming interface in (a) of FIG. 11 displays the object instance 1. Figure 29 Figure 29 As shown in (a) of FIG. 11, the object instance 1 is selected, and after the object instance 1 is clicked, the interface shown in (b) of FIG. 11 can be jumped to. Figure 29 As shown in (b) of FIG. 11, the left side of the interface displays an instance window, and the instance window displays the game running scene corresponding to the object instance 1, and the game running scene includes the game object corresponding to the object instance 1.

[0253] When the user views the game object as the game object to be debugged, the user can click the object instance 1. Figure 29 ​Click the confirmation control in (b) to jump to the debugging interface, and highlight the programming graph corresponding to object instance 1 in the debugging interface, and debug the programming graph through the debugging control to debug the game object corresponding to object instance 1.

[0254] Figure 29 A flowchart of another method for processing game editing information provided by an embodiment of the present application; optionally, in step S1401, in response to an object instance viewing operation, multiple object instances are displayed, including:

[0255] S1501: In response to an object instance viewing operation, identify a programming graphic being debugged.

[0256] In one implementation, the object instance can be determined by automatic identification. After the object instance viewing mode is turned on, during the code debugging process, it can be automatically identified whether the programming graphic corresponding to the code currently being debugged is bound to an object instance.

[0257] S1502: If the programming graphic being debugged corresponds to an object instance, multiple object instances corresponding to the programming graphic being debugged are displayed in the debugging interface.

[0258] If the programming graph being debugged is bound to an object instance, you can jump to Figure 30 The interface shown in (a) in the figure displays multiple object instances corresponding to the programming graph in thumbnail form in the debugging interface.

[0259] Figure 28 A flowchart of another method for processing game editing information provided by an embodiment of the present application; optionally, in step S1401, in response to an object instance viewing operation, displaying at least one object instance includes:

[0260] S1601: In response to a triggering operation of an instance control, a target object is selected from a plurality of candidate objects.

[0261] In another implementation, the user can also view the object instance through the instance control. Figure 31 In the leftmost panel of (a), click the instance control located between the exit control and the run log control to select the object instance you want to view.

[0262] After clicking the instance control, Figure 25 As shown in (a) in the figure, the display status of the instance control will be updated to the display graphics corresponding to the selected game object. This is just an illustration. In actual applications, if the selected object is a tree, the graphics displayed here can be the graphics of the tree.

[0263] S1602, display the plurality of object instances corresponding to the target object in the debugging interface.

[0264] Similarly, after selecting the object to be viewed, an interface as shown in (a) of Figure 28 may be displayed to display the plurality of object instances corresponding to the programming graph in a thumbnail manner in the debugging interface.

[0265] After that, the object instance viewing and game object debugging can be performed according to the interaction modes of Figure 28 and Figure 28 .

[0266] To sum up, the game editing information processing method provided in this embodiment includes: in a game editing stage, displaying a graphical programming interface in a graphical user interface; in response to a breakpoint creation instruction, controlling to add a breakpoint identifier at a target programming graph corresponding to the breakpoint creation instruction; in response to a running instruction, controlling to display a game running scene in the graphical user interface and controlling to run a code combination; in response to the code combination running to a code position corresponding to the breakpoint identifier, controlling to pause the game running scene and controlling to pause the running code combination; displaying a debugging interface on the graphical user interface, the debugging interface including a programming graph group and a debugging control, the debugging control being configured to control a code combination corresponding to the debugging programming graph group. This method can control the game code to be paused at a code position corresponding to a programming graph in real time during the running of the game code by inserting a breakpoint identifier in the graphical programming interface, so as to realize accurate positioning of debugging; based on the debugging control in the debugging interface, the code corresponding to the paused programming graph can be debugged, so as to realize real-time dynamic code debugging during the running of the code and improve the code debugging efficiency.

[0267] Secondly, the present scheme provides a single-step debugging mode, in which the user can quickly locate the problem without repeatedly running the entire program.

[0268] In addition, by inserting a breakpoint in the graphical programming interface, the breakpoint setting and the breakpoint display state can be intuitively displayed, so that the programming graph corresponding to the currently paused game running scene can be located in real time during the running of the code, and by displaying the current value of the programming graph, the user can understand the current paused code state without viewing complex logs.

[0269] Finally, by providing the object instance viewing function, the user can quickly and accurately locate the game object to be debugged from a plurality of same game objects, thereby improving the accuracy of debugging.

[0270] The following describes the device, equipment, storage medium, etc. for executing the game editing information processing method provided in the present application. The specific implementation process and technical effects are described above, and will not be described again here.

[0271] Figure 29 A schematic diagram of an information processing device for game editing is provided for the embodiments of the present application. The functions implemented by the information processing device correspond to the steps performed by the above method. The device can be understood as the above server, or the processor of the server, or a component independent of the above server or processor, which implements the functions of the present application under the control of the server, such as Figure 32 As shown in the figure, the device can include a display module 100, a control module 200, and a debugging module 300.

[0272] The display module 100 is configured to display a graphical programming interface in a graphical user interface during a game editing stage. The graphical programming interface includes a programming graph group composed of one or more programming graphs. Each programming graph corresponds to a piece of code, and the programming graph group corresponds to a code combination formed by the codes corresponding to the one or more programming graphs.

[0273] The control module 200 is configured to control the addition of a breakpoint identifier at a target programming graph corresponding to a breakpoint creation instruction in response to the breakpoint creation instruction.

[0274] The control module 200 is configured to control the display of a game running scene in the graphical user interface and control the running of the code combination in response to a running instruction.

[0275] The control module 200 is configured to control the pausing of the game running scene and control the pausing of the running of the code combination in response to the running of the code combination to a code position corresponding to the breakpoint identifier.

[0276] The debugging module 300 is configured to display a debugging interface on the graphical user interface. The debugging interface includes the programming graph group and a debugging control. The debugging control is configured to control the code combination corresponding to the debugging programming graph group.

[0277] Optionally, the device further includes a determination module.

[0278] The determination module is configured to determine a candidate programming graph.

[0279] If the type of the candidate programming graph is a preset type, the candidate programming graph is taken as a target programming graph.

[0280] Optionally, the control module 200 is further configured to control the display of a breakpoint creation control if the type of the candidate programming graph is the preset type.

[0281] In response to a triggering operation on the breakpoint creation control, the control module 200 is configured to control the triggering of a breakpoint creation instruction.

[0282] Optionally, the control module 200 is specifically configured to add the breakpoint identifier at a preset position of the target programming graph.

[0283] Optionally, the control module 200 is specifically configured to add an initial breakpoint identifier at a preset position of the target programming graph;

[0284] In response to the confirmation operation of the initial breakpoint identifier, a breakpoint to be edited is determined;

[0285] In response to the condition editing operation, a breakpoint pause condition of the breakpoint to be edited is generated, and the initial breakpoint identifier is updated to a breakpoint identifier; the breakpoint identifier indicates that the breakpoint is a conditional breakpoint.

[0286] Optionally, the control module 200 is specifically configured to, in response to the condition editing operation, display a condition editing area and a creation panel in the vicinity of the target programming graph, the creation panel containing related programming graphs and parameter information for performing the condition editing;

[0287] In response to the editing operation on the programming graphs in the creation panel, a breakpoint pause condition of the breakpoint to be edited is generated in the condition editing area.

[0288] Optionally, the control module 200 is specifically configured to, in response to the triggering operation on each programming graph corresponding to the breakpoint pause condition in the creation panel, drag each programming graph to the condition editing area;

[0289] In response to the editing operation on each programming graph in the condition editing area, an editing result of each programming graph is taken as the breakpoint pause condition of the breakpoint to be edited.

[0290] Optionally, the control module 200 is specifically configured to, in response to a breakpoint batch creation instruction, display an addable breakpoint identifier at a preset position of each programming graph of a preset type in the graphical programming interface;

[0291] In response to the confirmation operation on the addable breakpoint identifiers corresponding to a plurality of selectable programming graphs of each preset type of programming graph, a breakpoint identifier is generated and displayed at the addable breakpoint identifier of each selectable programming graph.

[0292] Optionally, the control module 200 is specifically configured to, in response to the triggering operation on a breakpoint debugging control in the graphical programming interface, display a breakpoint batch addition page;

[0293] In response to the triggering operation on a shortcut breakpoint adding control in the breakpoint batch addition page, an addable breakpoint identifier is displayed at a preset position of each programming graph of a preset type in the graphical programming interface, and a prompt information is displayed, the prompt information being used to prompt a user to add a breakpoint identifier to the programming graph of the preset type by triggering the addable breakpoint identifier.

[0294] Optionally, the display module 100 is further configured to display each selectable programming graph in the breakpoint batch addition page according to a belonging relationship between each selectable programming graph and a trigger.

[0295] Optionally, the display module 100 is specifically configured to display at least one trigger group in the breakpoint batch adding page;

[0296] According to the relationship between each optional programming pattern and the trigger, determine the trigger group to which each optional programming pattern belongs;

[0297] Display each optional programming graphic under the corresponding trigger group, and display the jump control corresponding to each optional programming graphic.

[0298] Optionally, the control module 200 is further configured to respond to a triggering operation of the jump control and jump to a position of an optional programming graphic corresponding to the jump control in the graphical programming interface.

[0299] Optionally, the control module 200 is further configured to respond to a disabling operation on the breakpoint marker, update the state of the breakpoint marker to a disabled state, and keep displaying the breakpoint marker.

[0300] Optionally, the control module is specifically used to control the suspension of the code combination in response to the code position corresponding to the breakpoint identifier when the code combination runs to the code position; and control the suspension of the game running scene according to the mapping relationship between the currently suspended code combination and the game running scene.

[0301] Optionally, the control module 200 is specifically configured to control the suspension of the game running scene and the suspension of the running of the code combination according to the breakpoint suspension condition corresponding to the breakpoint identifier in response to the code combination running to the code position corresponding to the breakpoint identifier.

[0302] Optionally, the control module 200 is specifically used to control the suspension of the running code combination if the current value of at least one programming graphic corresponding to the breakpoint identifier meets the breakpoint suspension condition; and control the suspension of the game running scene according to the mapping relationship between the currently suspended code combination and the game running scene.

[0303] Optionally, the debugging module 300 is specifically configured to display a debugging interface based on the currently paused game running scene and the graphical programming interface.

[0304] Optionally, the debugging module 300 is specifically configured to suspend and display a graphical programming interface in the currently paused game running scene, and to display debugging controls in the graphical programming interface.

[0305] Optionally, the debugging module 300 is further configured to determine the currently paused programming graph based on the correspondence between the currently paused code combination and the programming graph;

[0306] A graphical programming interface is displayed in a suspended state in the currently paused game running scene, and a pause programming graphic is highlighted in the graphical programming interface.

[0307] Optionally, the debugging module 300 is further configured to, in response to a triggering operation of the graphical programming interface, full-screen display the graphical programming interface, and display the current paused game running scene in suspension in the graphical programming interface.

[0308] In response to a triggering operation of the debugging control, the programming graph in the programming graph region corresponding to the paused programming graph is debugged, and in the process of debugging, the programming graph being currently debugged is tracked and displayed.

[0309] Optionally, the debugging control comprises a single-step debugging control.

[0310] The debugging module 300 is specifically configured to, in response to a triggering operation of the single-step debugging control, debug the programming graphs in the programming graph region one by one from the starting end of the programming graph region.

[0311] In the process of debugging, according to the function of the programming graph being currently debugged, the current paused game running scene displayed in suspension is controlled to produce corresponding changes.

[0312] Optionally, the debugging control comprises a re-run control.

[0313] The debugging module 300 is specifically configured to, in response to a triggering operation of the re-run control, re-start running the code combination, and when the code combination runs to the code position corresponding to the breakpoint identifier, control the paused game running scene and control the paused running code combination.

[0314] Optionally, the debugging control comprises a continue running control.

[0315] The debugging module 300 is specifically configured to, in response to a triggering operation of the continue running control, close the debugging interface.

[0316] The code combination is continued to run from the paused running code combination, and the game running scene is displayed in the process of running the code combination.

[0317] Optionally, the debugging module 300 is specifically configured to display the graphical programming interface in suspension in the current paused game running scene, and display the debugging control and the description information corresponding to the paused programming graph in the current paused game running scene.

[0318] Optionally, the debugging module 300 is further configured to, in response to a triggering operation of the debugging control in the current paused game running scene, debug the programming graph region corresponding to the paused programming graph.

[0319] Optionally, the debugging module 300 is specifically configured to, in response to a triggering operation of a debugging control in the current paused game running scene, debug the programming graph region corresponding to the paused programming graph, and in the process of debugging, control the current paused game running scene to produce a corresponding change according to the function of the programming graph being debugged.

[0320] Optionally, the graphical programming interface also displays a listening list, and the listening list displays at least one to-be-listened programming graph set by the user and a current value of the to-be-listened programming graph.

[0321] Optionally, the display module 100 is further configured to, in response to a confirmation operation of a specified programming graph in the graphical programming interface, highlight the specified programming graph in the listening list if the specified programming graph exists in the listening list.

[0322] Optionally, the graphical programming interface also displays an information search bar.

[0323] The display module 100 is further configured to display a current value of the to-be-searched programming graph in response to search information of the to-be-searched programming graph input in the information search bar.

[0324] Optionally, the debugging module 300 is further configured to, in response to an exit operation of the graphical programming interface, suspend the display of the graphical programming interface in the current paused game running scene.

[0325] Optionally, the debugging module 300 is further configured to, in response to an exit operation of the current paused game running scene, exit the debugging interface and return to the initial graphical programming interface.

[0326] Optionally, the debugging module 300 is further configured to, in response to an object instance viewing operation, display a plurality of object instances.

[0327] In response to a selection operation of a target object instance in the plurality of object instances, the display module 100 displays a game running scene corresponding to the target object instance in the instance window, and the game running scene displays an actual position of a game object corresponding to the target object instance in the game running scene.

[0328] In response to a confirmation operation of the target object instance, the debugging module 300 jumps to the debugging interface to debug a programming graph corresponding to the target object instance.

[0329] Optionally, the debugging module 300 is specifically configured to, in response to an object instance viewing operation, identify a programming graph being debugged.

[0330] If the programming graph being debugged corresponds to an object instance, the debugging module 300 displays a plurality of object instances corresponding to the programming graph being debugged in the debugging interface.

[0331] Optionally, the debugging module 300 is specifically configured to select the target object from the plurality of candidate objects in response to a triggering operation of the instance control;

[0332] The plurality of object instances corresponding to the target object are displayed in the debugging interface.

[0333] The above modules can be one or more integrated circuits configured to implement the above methods, for example, one or more application specific integrated circuits (ASICs), or one or more digital signal processors (DSPs), or one or more field programmable gate arrays (FPGAs), etc. For another example, when a certain module above is implemented in the form of a processing element scheduling program code, the processing element can be a general-purpose processor, such as a central processing unit (CPU) or other processor that can invoke program code. For another example, these modules can be integrated together to implement in the form of a system on a chip (SOC).

[0334] The above modules can be connected or communicate with each other via wired connection or wireless connection. The wired connection can include metal cable, optical cable, hybrid cable, etc., or any combination thereof. The wireless connection can include connection in the form of LAN, WAN, Bluetooth, ZigBee, or NFC, etc., or any combination thereof. Two or more modules can be combined into a single module, and any one module can be divided into two or more units. It can be clearly understood by those skilled in the art that, for the convenience and brevity of description, the specific working process of the system and device described above can refer to the corresponding process in the method embodiment, which will not be described herein.

[0335] Figure 32 Figure 33 A structural schematic diagram of an electronic device provided by the embodiment of the present application includes a processor 801, a storage medium 802, and a bus 803. The storage medium 802 stores machine readable instructions executable by the processor 801. When the electronic device runs a game editing information processing method as in the embodiment, the processor 801 and the storage medium 802 communicate through the bus 803. The processor 801 executes the machine readable instructions to perform the following steps:

[0336] In the game editing stage, a graphical programming interface is displayed in a graphical user interface; wherein the graphical programming interface comprises a programming graph group composed of one or more programming graphs; each programming graph corresponds to a piece of code, and the programming graph group corresponds to a code combination formed by the codes corresponding to the one or more programming graphs;

[0337] In response to a breakpoint creation instruction, a breakpoint identifier is added at a target programming graph corresponding to the breakpoint creation instruction;

[0338] In response to a running instruction, a game running scene is displayed in the graphical user interface, and the code combination is run;

[0339] In response to the code combination running to a code position corresponding to the breakpoint identifier, the game running scene is paused, and the code combination is paused;

[0340] A debugging interface is displayed on the graphical user interface, the debugging interface comprising the programming graph group and a debugging control configured to control the code combination corresponding to the debugging programming graph group.

[0341] In an implementable embodiment, before executing the step of, in response to the breakpoint creation instruction, adding the breakpoint identifier at the target programming graph corresponding to the breakpoint creation instruction, the processor 801 is further configured to determine a candidate programming graph;

[0342] If the type of the candidate programming graph is a preset type, the candidate programming graph is taken as the target programming graph.

[0343] In an implementable embodiment, the processor 801 is further configured to, if the type of the candidate programming graph is the preset type, control the breakpoint creation control to be displayed;

[0344] In response to a triggering operation on the breakpoint creation control, the breakpoint creation instruction is triggered.

[0345] In an implementable embodiment, when executing the step of adding the breakpoint identifier at the target programming graph corresponding to the breakpoint creation instruction, the processor 801 is specifically configured to add the breakpoint identifier at a preset position of the target programming graph.

[0346] In an implementable embodiment, when executing the step of adding the breakpoint identifier at the target programming graph corresponding to the breakpoint creation instruction, the processor 801 is specifically configured to add an initial breakpoint identifier at a preset position of the target programming graph.

[0347] In response to a confirmation operation on the initial breakpoint identifier, a to-be-edited breakpoint is determined.

[0348] In response to a condition editing operation, a breakpoint pause condition of the to-be-edited breakpoint is generated, and the initial breakpoint identifier is updated to a breakpoint identifier; the breakpoint identifier indicates that the breakpoint is a conditional breakpoint.

[0349] In an implementation, the processor 801, in response to the execution of the breakpoint pause condition editing operation, generates the breakpoint pause condition of the breakpoint to be edited, specifically for: in response to the breakpoint pause condition editing operation, displaying a condition editing area and a creation panel in the vicinity of the target programming graph, the creation panel containing the relevant programming graph and parameter information for condition editing;

[0350] In response to the editing operation on the programming graph in the creation panel, the condition editing area generates the breakpoint pause condition of the breakpoint to be edited.

[0351] In an implementation, the processor 801, in response to the execution of the breakpoint pause condition editing operation, generates the breakpoint pause condition of the breakpoint to be edited, specifically for: in response to the editing operation on each programming graph in the creation panel corresponding to the breakpoint pause condition, dragging each programming graph to the condition editing area;

[0352] In response to the editing operation on each programming graph in the condition editing area, the editing result of each programming graph is taken as the breakpoint pause condition of the breakpoint to be edited.

[0353] In an implementation, the processor 801, in response to the execution of the breakpoint creation instruction, controls the addition of the breakpoint identifier at the target programming graph corresponding to the breakpoint creation instruction, specifically for: in response to the breakpoint batch creation instruction, displaying the breakpoint identifier that can be added at the preset position of each programming graph of a preset type in the graphical programming interface;

[0354] In response to the confirmation operation on the breakpoint identifier that can be added corresponding to each selectable programming graph of each preset type of programming graph, the breakpoint identifier is generated and displayed at the breakpoint identifier that can be added of each selectable programming graph.

[0355] In an implementation, the processor 801, in response to the execution of the breakpoint batch creation instruction, displays the breakpoint identifier that can be added at the preset position of each programming graph of a preset type in the graphical programming interface, specifically for: in response to the triggering operation on the breakpoint debugging control in the graphical programming interface, displaying a breakpoint batch addition page;

[0356] In response to the triggering operation on the shortcut breakpoint adding control in the breakpoint batch addition page, the breakpoint identifier that can be added is displayed at the preset position of each programming graph of a preset type in the graphical programming interface, and a prompt information is displayed, prompting the user to add the breakpoint identifier for the programming graph of the preset type by triggering the breakpoint identifier that can be added.

[0357] In an implementable implementation, the processor 801 is further configured to, after generating and displaying the breakpoint identifier at the addable breakpoint identifier of each optional programming graph, according to the belonging relationship between each optional programming graph and the trigger, classify and display each optional programming graph on the breakpoint batch adding page.

[0358] In an implementable implementation, the processor 801 is further configured to, after generating and displaying the breakpoint identifier at the addable breakpoint identifier of each optional programming graph, according to the belonging relationship between each optional programming graph and the trigger, classify and display each optional programming graph on the breakpoint batch adding page.

[0359] According to the belonging relationship between each optional programming graph and the trigger, determine the trigger group to which each optional programming graph belongs;

[0360] Display each optional programming graph under the trigger group to which it belongs, and display the jump control corresponding to each optional programming graph.

[0361] In an implementable implementation, the processor 801 is further configured to, in response to the triggering operation of the jump control, jump to the position of the optional programming graph corresponding to the jump control in the graphical programming interface.

[0362] In an implementable implementation, the processor 801 is further configured to, in response to the disabling operation of the breakpoint identifier, update the state of the breakpoint identifier to the disabled state and keep displaying the breakpoint identifier.

[0363] In an implementable implementation, the processor 801 is further configured to, in response to the code combination running to the code position corresponding to the breakpoint identifier, control the pause of the game running scenario and the pause of the running code combination, specifically configured to, in response to the code combination running to the code position corresponding to the breakpoint identifier, control the pause of the running code combination; and according to the mapping relationship between the currently paused code combination and the game running scenario, control the pause of the game running scenario.

[0364] In an implementable implementation, the processor 801 is further configured to, in response to the code combination running to the code position corresponding to the breakpoint identifier, control the pause of the game running scenario and the pause of the running code combination, specifically configured to, in response to the code combination running to the code position corresponding to the breakpoint identifier, according to the breakpoint pause condition corresponding to the breakpoint identifier, control the pause of the game running scenario and the pause of the running code combination.

[0365] In an implementable implementation, the processor 801, when executing the step of pausing the game running scene according to the breakpoint pause condition corresponding to the breakpoint identification, and controlling the pause of the running code combination, specifically controls the pause of the running code combination if the current value of the at least one programming graph corresponding to the breakpoint identification satisfies the breakpoint pause condition, and controls the pause of the game running scene according to the mapping relationship between the currently paused code combination and the game running scene.

[0366] In an implementable implementation, the processor 801, when executing the step of displaying the debugging interface on the graphical user interface, specifically displays the debugging interface according to the currently paused game running scene and the graphical programming interface.

[0367] In an implementable implementation, the processor 801, when executing the step of displaying the debugging interface according to the currently paused game running scene and the graphical programming interface, specifically displays the graphical programming interface in the currently paused game running scene, and highlights the paused programming graph in the graphical programming interface.

[0368] In an implementable implementation, the processor 801 further executes the step of determining the paused programming graph according to the corresponding relationship between the currently paused code combination and the programming graph.

[0369] In an implementable implementation, the processor 801 further executes the step of displaying the currently paused game running scene in the graphical programming interface.

[0370] In an implementable implementation, the processor 801 further executes the step of, in response to the triggering operation of the graphical programming interface, displaying the graphical programming interface in full screen, and displaying the currently paused game running scene in the graphical programming interface.

[0371] In an implementable implementation, the processor 801 further executes the step of, in response to the triggering operation of the debugging control, debugging the programming graph in the programming graph region corresponding to the paused programming graph, and displaying the currently debugging programming graph in the process of debugging.

[0372] In an implementable implementation, the debugging control includes a single-step debugging control. In response to the triggering operation of the debugging control, the processor 801 specifically executes the step of, in response to the triggering operation of the single-step debugging control, debugging the programming graphs in the programming graph region from the start end of the programming graph region.

[0373] In an implementable implementation, in the process of debugging, the processor 801 controls the currently paused game running scene displayed in the graphical programming interface to produce corresponding changes according to the function of the currently debugging programming graph.

[0374] In an implementation, the debugging control includes a re-run control; and the processor 801, in response to the triggering operation of the debugging control, is specifically configured to: in response to the triggering operation of the re-run control, re-start running the code combination, and control the game running scene to be paused and the running code combination to be paused when the code combination runs to the code position corresponding to the breakpoint identifier.

[0375] In an implementation, the debugging control includes a continue running control; and the processor 801, in response to the triggering operation of the debugging control, is specifically configured to: in response to the triggering operation of the continue running control, close the debugging interface.

[0376] In an implementation, the debugging control includes a continue running control; and the processor 801, in response to the triggering operation of the debugging control, is specifically configured to: in response to the triggering operation of the continue running control, close the debugging interface.

[0377] In an implementation, the processor 801, in response to the triggering operation of the debugging control, is specifically configured to: in response to the triggering operation of the debugging control, display the debugging control and the description information corresponding to the paused programming graph in the current paused game running scene.

[0378] In an implementation, the processor 801 is further configured to: in response to the triggering operation of the debugging control in the current paused game running scene, debug the programming graph region corresponding to the paused programming graph.

[0379] In an implementation, the processor 801, in response to the triggering operation of the debugging control in the current paused game running scene, is specifically configured to: in response to the triggering operation of the debugging control in the current paused game running scene, debug the programming graph region corresponding to the paused programming graph, and in the process of debugging, control the current paused game running scene to produce a corresponding change according to the function of the programming graph being currently debugged.

[0380] In an implementation, the processor 801 is further configured to: the graphical programming interface further displays a listening list, and the listening list displays at least one to-be-listened programming graph and the current value of the to-be-listened programming graph set by the user.

[0381] In an implementable implementation, the processor 801 is further configured to perform: in response to a confirmation operation on the specified programming graph in the graphical programming interface, if the specified programming graph exists in the listening list, highlighting the specified programming graph in the listening list.

[0382] In an implementable implementation, the graphical programming interface further displays an information search bar; the processor 801 is further configured to perform: in response to search information of a to-be-searched programming graph input in the information search bar, displaying the current value of the to-be-searched programming graph.

[0383] In an implementable implementation, after the processor 801 performs the full-screen display of the graphical programming interface, the processor 801 is further configured to: in response to an exit operation on the graphical programming interface, floating the graphical programming interface to the currently paused game running scene.

[0384] In an implementable implementation, after the processor 801 performs the floating display of the graphical programming interface in the currently paused game running scene, the processor 801 is further configured to: in response to an exit operation on the currently paused game running scene, exiting the debugging interface and returning to the initial graphical programming interface.

[0385] In an implementable implementation, the processor 801 is further configured to perform: in response to an object instance viewing operation, displaying a plurality of object instances;

[0386] In response to a selection operation on a target object instance in the plurality of object instances, displaying a game running scene corresponding to the target object instance in the instance window, and the game running scene displays an actual position of a game object corresponding to the target object instance in the game running scene;

[0387] In response to a confirmation operation on the target object instance, jumping to a debugging interface to debug a programming graph corresponding to the target object instance.

[0388] In an implementable implementation, when the processor 801 performs the displaying of the plurality of object instances in response to the object instance viewing operation, the processor 801 is specifically configured to: in response to the object instance viewing operation, identifying a programming graph being debugged;

[0389] If the programming graph being debugged corresponds to object instances, displaying a plurality of object instances corresponding to the programming graph being debugged in the debugging interface.

[0390] In an implementable implementation, when the processor 801 performs the displaying of the plurality of object instances in response to the object instance viewing operation, the processor 801 is specifically configured to: in response to a triggering operation of an instance control, selecting a target object from a plurality of candidate objects;

[0391] Displaying a plurality of object instances corresponding to the target object in the debugging interface.

[0392] The storage medium 802 stores program codes which, when executed by the processor 801, cause the processor 801 to perform various steps of the information processing method of game editing according to various exemplary embodiments of the present application described in the "Exemplary Method" section of the present specification.

[0393] The processor 801 can be a general-purpose processor, such as a central processing unit (CPU), a digital signal processor (DSP), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA) or other programmable logic device, a discrete gate or transistor logic, a discrete hardware component, and can implement or execute the methods, steps and logical block diagrams disclosed in the embodiments of the present application. The general-purpose processor can be a microprocessor or any conventional processor, etc. The steps of the methods disclosed in conjunction with the embodiments of the present application can be directly embodied as a hardware processor for execution, or a combination of hardware and software modules in the processor for execution.

[0394] The storage medium 802 is a non-volatile computer readable storage medium, which can be used to store non-volatile software programs, non-volatile computer executable programs and modules. The storage medium can include at least one type of storage medium, such as flash memory, hard disk, multimedia card, card type memory, random access memory (RAM), static random access memory (SRAM), programmable read only memory (PROM), read only memory (ROM), electrically erasable programmable read only memory (EEPROM), magnetic storage, magnetic disk, optical disk, etc. The storage medium is any other medium capable of carrying or storing desired program codes in the form of instructions or data structures and accessible by a computer, but is not limited thereto. The storage medium 802 in the embodiments of the present application can also be a circuit or any other device capable of realizing a storage function, for storing program instructions and / or data.

[0395] Optionally, the embodiment of the present application further provides a computer readable storage medium, and the computer readable storage medium stores a computer program. The computer program is executed by a processor to perform the following steps:

[0396] In the game editing stage, a graphical programming interface is displayed in the graphical user interface; wherein the graphical programming interface comprises a programming graph group composed of one or more programming graphs; each programming graph corresponds to a piece of code, and the programming graph group corresponds to a code combination formed by the codes corresponding to the one or more programming graphs;

[0397] In response to the breakpoint creation instruction, a breakpoint identifier is added at a target programming graph corresponding to the breakpoint creation instruction;

[0398] In response to the running instruction, a game running scene is displayed in the graphical user interface, and the code combination is controlled to run;

[0399] In response to the code combination running to a code position corresponding to the breakpoint identifier, the game running scene is controlled to be paused, and the code combination is controlled to be paused;

[0400] A debugging interface is displayed on the graphical user interface, and the debugging interface comprises the programming graph group and a debugging control. The debugging control is configured to control a code combination corresponding to the debugging programming graph group.

[0401] In a feasible implementation, before the processor 801 performs the step of, in response to the breakpoint creation instruction, controlling a breakpoint identifier to be added at a target programming graph corresponding to the breakpoint creation instruction, the processor 801 is further configured to determine a candidate programming graph;

[0402] If the type of the candidate programming graph is a preset type, the candidate programming graph is taken as the target programming graph.

[0403] In a feasible implementation, the processor 801 is further configured to, if the type of the candidate programming graph is the preset type, control the breakpoint creation control to be displayed;

[0404] In response to a triggering operation on the breakpoint creation control, the breakpoint creation instruction is triggered.

[0405] In a feasible implementation, when the processor 801 performs the step of controlling a breakpoint identifier to be added at a target programming graph corresponding to the breakpoint creation instruction, the processor 801 is specifically configured to add the breakpoint identifier at a preset position of the target programming graph.

[0406] In a feasible implementation, when the processor 801 performs the step of controlling a breakpoint identifier to be added at a target programming graph corresponding to the breakpoint creation instruction, the processor 801 is specifically configured to add an initial breakpoint identifier at a preset position of the target programming graph.

[0407] In response to the confirmation operation of the initial breakpoint identifier, determine the breakpoint to be edited;

[0408] In response to the condition editing operation, generate the breakpoint pause condition of the breakpoint to be edited, and update the initial breakpoint identifier to the breakpoint identifier; the breakpoint identifier indicates that the breakpoint is a conditional breakpoint.

[0409] In one possible implementation, when the processor 801 performs the operation of generating the breakpoint pause condition of the breakpoint to be edited in response to the condition editing operation, the processor 801 specifically performs the operation of: in response to the condition editing operation, displaying a condition editing area and a creation panel in the vicinity of the target programming graph, the creation panel including the related programming graphs and parameter information for performing the condition editing;

[0410] In response to the editing operation on the programming graphs in the creation panel, generate the breakpoint pause condition of the breakpoint to be edited in the condition editing area.

[0411] In one possible implementation, when the processor 801 performs the operation of generating the breakpoint pause condition of the breakpoint to be edited in the condition editing area in response to the editing operation on the programming graphs in the creation panel, the processor 801 specifically performs the operation of: in response to the triggering operation on each programming graph corresponding to the breakpoint pause condition in the creation panel, dragging each programming graph to the condition editing area.

[0412] In response to the editing operation on each programming graph in the condition editing area, take the editing result of each programming graph as the breakpoint pause condition of the breakpoint to be edited.

[0413] In one possible implementation, when the processor 801 performs the operation of controlling the addition of the breakpoint identifier at the target programming graph corresponding to the breakpoint creation instruction in response to the breakpoint creation instruction, the processor 801 specifically performs the operation of: in response to the breakpoint batch creation instruction, displaying the breakpoint identifiers that can be added at the preset positions of each programming graph of a preset type in the graphical programming interface.

[0414] In response to the confirmation operation on the breakpoint identifiers that can be added corresponding to a plurality of selectable programming graphs of each preset type, generate and display the breakpoint identifiers at the breakpoint identifiers that can be added of each selectable programming graph.

[0415] In one possible implementation, when the processor 801 performs the operation of displaying the breakpoint identifiers that can be added at the preset positions of each programming graph of a preset type in the graphical programming interface in response to the breakpoint batch creation instruction, the processor 801 specifically performs the operation of: in response to the triggering operation on the breakpoint debugging control in the graphical programming interface, displaying a breakpoint batch addition page.

[0416] In response to a triggering operation on the shortcut breakpoint adding control in the breakpoint batch adding page, a breakpoint adding mark is displayed at a preset position of each preset type of programming graph in the graphical programming interface, and a prompt information is displayed, the prompt information being used to prompt the user to add the breakpoint adding mark to the programming graph of the preset type by triggering the breakpoint adding mark.

[0417] In an implementable embodiment, after the processor 801 executes the generation and display of the breakpoint marks at the breakpoint adding marks of each optional programming graph, the processor 801 is further configured to: according to the belonging relationship between each optional programming graph and the trigger, display each optional programming graph in the breakpoint batch adding page in categories.

[0418] In an implementable embodiment, when the processor 801 executes the display of each optional programming graph in the breakpoint batch adding page in categories according to the belonging relationship between each optional programming graph and the trigger, the processor 801 is specifically configured to: display at least one trigger group in the breakpoint batch adding page.

[0419] According to the belonging relationship between each optional programming graph and the trigger, determine the trigger group to which each optional programming graph belongs;

[0420] Display each optional programming graph under the trigger group to which the optional programming graph belongs, and display the jump control corresponding to each optional programming graph.

[0421] In an implementable embodiment, the processor 801 is further configured to: in response to a triggering operation on the jump control, jump to the position of the optional programming graph corresponding to the jump control in the graphical programming interface.

[0422] In an implementable embodiment, the processor 801 is further configured to: in response to a disabling operation on the breakpoint mark, update the state of the breakpoint mark to a disabled state, and keep displaying the breakpoint mark.

[0423] In an implementable embodiment, when the processor 801 executes the control of pausing the game running scenario and the control of pausing the running of the code combination in response to the running of the code combination to the code position corresponding to the breakpoint mark, the processor 801 is specifically configured to: in response to the running of the code combination to the code position corresponding to the breakpoint mark, control the pause of the running of the code combination; and according to the mapping relationship between the currently paused code combination and the game running scenario, control the pause of the game running scenario.

[0424] In an implementable embodiment, when the processor 801 executes the control of pausing the game running scenario and the control of pausing the running of the code combination in response to the running of the code combination to the code position corresponding to the breakpoint mark, the processor 801 is specifically configured to: in response to the running of the code combination to the code position corresponding to the breakpoint mark, according to the breakpoint pause condition corresponding to the breakpoint mark, control the pause of the game running scenario and the pause of the running of the code combination.

[0425] In an implementation, the processor 801, when executing the step of pausing the game running scenario according to the breakpoint pause condition corresponding to the breakpoint identification, and controlling the pause of the running code combination, specifically controls the pause of the running code combination if the current value of the at least one programming graph corresponding to the breakpoint identification satisfies the breakpoint pause condition, and controls the pause of the game running scenario according to the mapping relationship between the currently paused code combination and the game running scenario.

[0426] In an implementation, the processor 801, when executing the step of displaying the debugging interface on the graphical user interface, specifically displays the debugging interface according to the currently paused game running scenario and the graphical programming interface.

[0427] In an implementation, the processor 801, when executing the step of displaying the debugging interface according to the currently paused game running scenario and the graphical programming interface, specifically displays the graphical programming interface in the currently paused game running scenario, and highlights the paused programming graph in the graphical programming interface.

[0428] In an implementation, the processor 801 further executes the step of determining the paused programming graph according to the corresponding relationship between the currently paused code combination and the programming graph.

[0429] In an implementation, the processor 801, when executing the step of displaying the debugging interface according to the currently paused game running scenario and the graphical programming interface, specifically displays the graphical programming interface in the currently paused game running scenario, and highlights the paused programming graph in the graphical programming interface.

[0430] In an implementation, the processor 801 further executes the step of, in response to a triggering operation of the graphical programming interface, displaying the graphical programming interface in full screen, and displaying the currently paused game running scenario in the graphical programming interface.

[0431] In an implementation, the processor 801, when executing the step of, in response to a triggering operation of the debugging control, debugging the programming graphs in the programming graph region corresponding to the paused programming graph, specifically debugs the programming graphs in the programming graph region from the start of the programming graph region according to a triggering operation of a single-step debugging control.

[0432] In an implementation, the debugging control includes a single-step debugging control. In an implementation, the processor 801, when executing the step of, in response to a triggering operation of the debugging control, debugging the programming graphs in the programming graph region corresponding to the paused programming graph, specifically debugs the programming graphs in the programming graph region from the start of the programming graph region according to a triggering operation of a single-step debugging control.

[0433] In an implementation, the processor 801, when executing the step of, in response to a triggering operation of the debugging control, debugging the programming graphs in the programming graph region corresponding to the paused programming graph, specifically debugs the programming graphs in the programming graph region from the start of the programming graph region according to a triggering operation of a single-step debugging control.

[0434] In an implementation, the debugging control includes a re-run control. When performing the debugging of the programming graph in the programming graph region corresponding to the paused programming graph in response to the triggering operation of the debugging control, the processor 801 is specifically configured to: in response to the triggering operation of the re-run control, re-start running the code combination, and control the game running scene to be paused and the running code combination to be paused when the code combination runs to the code position corresponding to the breakpoint.

[0435] In an implementation, the debugging control includes a continue running control. When performing the debugging of the programming graph in the programming graph region corresponding to the paused programming graph in response to the triggering operation of the debugging control, the processor 801 is specifically configured to: in response to the triggering operation of the continue running control, close the debugging interface.

[0436] Continuing running the code combination from the paused running code combination, and displaying the game running scene in the process of running the code combination.

[0437] In an implementation, when performing the floating display of the graphical programming interface in the currently paused game running scene, the processor 801 is specifically configured to: float the graphical programming interface in the currently paused game running scene, and display the debugging control and the description information corresponding to the paused programming graph in the currently paused game running scene.

[0438] In an implementation, the processor 801 is further configured to perform: in response to the triggering operation of the debugging control in the currently paused game running scene, debugging the programming graph region corresponding to the paused programming graph.

[0439] In an implementation, when performing the debugging of the programming graph in the programming graph region corresponding to the paused programming graph in response to the triggering operation of the debugging control in the currently paused game running scene, the processor 801 is specifically configured to: in response to the triggering operation of the debugging control in the currently paused game running scene, debug the programming graph region corresponding to the paused programming graph, and in the process of debugging, control the currently paused game running scene to produce a corresponding change according to the function of the currently debugging programming graph.

[0440] In an implementation, the processor 801 is further configured to perform: the graphical programming interface further displays a listening list, and the listening list displays at least one to-be-listened programming graph and the current value of the to-be-listened programming graph set by the user.

[0441] In an implementable implementation, the processor 801 is further configured to perform: in response to a confirmation operation on the specified programming graph in the graphical programming interface, if the specified programming graph exists in the listening list, highlighting the specified programming graph in the listening list.

[0442] In an implementable implementation, the graphical programming interface further displays an information search bar; the processor 801 is further configured to perform: in response to search information of a to-be-searched programming graph input in the information search bar, displaying a current value of the to-be-searched programming graph.

[0443] In an implementable implementation, after the processor 801 performs the full-screen display of the graphical programming interface, the processor 801 is further configured to: in response to an exit operation on the graphical programming interface, floating the graphical programming interface to the currently paused game running scene.

[0444] In an implementable implementation, after the processor 801 performs the floating display of the graphical programming interface in the currently paused game running scene, the processor 801 is further configured to: in response to an exit operation on the currently paused game running scene, exiting the debugging interface and returning to the initial graphical programming interface.

[0445] In an implementable implementation, the processor 801 is further configured to perform: in response to an object instance viewing operation, displaying a plurality of object instances;

[0446] In response to a selection operation on a target object instance in the plurality of object instances, displaying a game running scene corresponding to the target object instance in the instance window, and the game running scene displays an actual position of a game object corresponding to the target object instance in the game running scene;

[0447] In response to a confirmation operation on the target object instance, jumping to a debugging interface to debug a programming graph corresponding to the target object instance.

[0448] In an implementable implementation, when the processor 801 performs the displaying of the plurality of object instances in response to the object instance viewing operation, the processor 801 is specifically configured to: in response to the object instance viewing operation, identifying a programming graph being debugged;

[0449] If the programming graph being debugged corresponds to an object instance, displaying a plurality of object instances corresponding to the programming graph being debugged in the debugging interface.

[0450] In an implementable implementation, when the processor 801 performs the displaying of the plurality of object instances in response to the object instance viewing operation, the processor 801 is specifically configured to: in response to a triggering operation of an instance control, selecting a target object from a plurality of candidate objects;

[0451] Displaying a plurality of object instances corresponding to the target object in the debugging interface.

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

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

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

[0455] The above-mentioned integrated unit implemented in the form of a software functional unit can be stored in a computer-readable storage medium. The above-mentioned software functional unit is stored in a storage medium and includes a number of instructions for causing a computer device (which can be a personal computer, server, or network device, etc.) or a processor (English: processor) to perform some steps of the method described in each embodiment of the present application. The aforementioned storage medium includes: a USB flash drive, a mobile hard disk, a read-only memory (English: Read-Only Memory, abbreviated: ROM), a random access memory (English: Random Access Memory, abbreviated: RAM), a disk or an optical disk, and other media that can store program code.

Claims

1. A method for processing information for game editing, characterized in that: include: During the game editing phase, a graphical programming interface is displayed in a graphical user interface; wherein the graphical programming interface includes a programming graphic group consisting of one or more programming graphics; each programming graphic corresponds to a section of code, and the programming graphic group corresponds to a code combination formed by the codes corresponding to the one or more programming graphics; In response to a breakpoint creation instruction, controlling to add a breakpoint identifier at a target programming graph corresponding to the breakpoint creation instruction; In response to the running instruction, controlling the display of the game running scene in the graphical user interface, and controlling the running of the code combination; In response to the code combination running to the code position corresponding to the breakpoint identifier, controlling the game running scene to be paused, and controlling the code combination to be paused; A debugging interface is displayed on the graphical user interface, wherein the debugging interface includes the programming graphic group and a debugging control, and the debugging control is configured to control debugging of a code combination corresponding to the programming graphic group.

2. The method according to claim 1, characterized in that The step of controlling, in response to a breakpoint creation instruction, adding a breakpoint identifier to a target programming graph corresponding to the breakpoint creation instruction, further comprises: determining candidate programming graphs; If the type of the candidate programming pattern is a preset type, the candidate programming pattern is used as a target programming pattern.

3. The method according to claim 2, characterized in that The method further comprises: If the type of the candidate programming graph is a preset type, controlling the display of a breakpoint creation control; In response to a triggering operation on the breakpoint creation control, the breakpoint creation instruction is triggered.

4. The method according to claim 1, wherein The controlling step of adding a breakpoint identifier at a target programming graph corresponding to the breakpoint creation instruction includes: The breakpoint mark is added at a preset position of the target programming graph.

5. The method according to claim 1, wherein The controlling step of adding a breakpoint identifier at a target programming graph corresponding to the breakpoint creation instruction includes: Adding an initial breakpoint mark at a preset position of the target programming graph; In response to a confirmation operation of the initial breakpoint identifier, determining a breakpoint to be edited; In response to a conditional editing operation, a breakpoint pause condition of the breakpoint to be edited is generated, and the initial breakpoint identifier is updated to the breakpoint identifier; the breakpoint identifier indicates that the breakpoint is a conditional breakpoint.

6. The method according to claim 5, characterized in that The response condition editing operation generates a breakpoint pause condition for the breakpoint to be edited, including: In response to a conditional editing operation, a conditional editing area and a creation panel are displayed near the target programming graphic, wherein the creation panel contains relevant programming graphics and parameter information for conditional editing; In response to an editing operation on the programming graphic in the creation panel, a breakpoint pause condition of the breakpoint to be edited is generated in the condition editing area.

7. The method according to claim 6, characterized in that In response to the editing operation of the programming graphic in the creation panel, generating the breakpoint pause condition of the breakpoint to be edited in the conditional editing area includes: In response to a triggering operation on each programming graphic corresponding to the breakpoint pause condition in the creation panel, dragging each programming graphic into the condition editing area; In response to an editing operation on each programming graph in the conditional editing area, the editing result of each programming graph is used as a breakpoint pause condition for the breakpoint to be edited.

8. The method according to claim 1, characterized in that In response to a breakpoint creation instruction, controlling to add a breakpoint identifier at a target programming graph corresponding to the breakpoint creation instruction includes: In response to a breakpoint batch creation instruction, a breakpoint identifier is displayed at a preset position of each preset type of programming graphic in the graphical programming interface; In response to a confirmation operation on the addable breakpoint identifiers corresponding to a plurality of selectable programming graphics in each preset type of programming graphics, a breakpoint identifier is generated and displayed at the addable breakpoint identifier of each selectable programming graphic.

9. The method according to claim 8, characterized in that The responding breakpoint batch creation instruction displays an addable breakpoint marker at a preset position of each preset type of programming graphic in the graphical programming interface, including: In response to a triggering operation on a breakpoint debugging control in the graphical programming interface, a breakpoint batch adding page is displayed; In response to triggering the quick add breakpoint control in the breakpoint batch adding page, an addable breakpoint identifier is displayed at the preset position of each preset type of programming graphic in the graphical programming interface, and prompt information is displayed, wherein the prompt information is used to prompt the user to add a breakpoint identifier to the preset type of programming graphic by triggering the addable breakpoint identifier.

10. The method according to claim 8, characterized in that After generating and displaying the breakpoint identifier at the addable breakpoint identifier of each optional programming graphic, the method further includes: According to the relationship between each optional programming graphic and the trigger, each optional programming graphic is categorized and displayed on the breakpoint batch adding page.

11. The method according to claim 10, characterized in that According to the relationship between the optional programming graphics and the trigger, the optional programming graphics are displayed in a classified manner on the page of batch adding at the breakpoint, including: Displaying at least one trigger group in the breakpoint batch adding page; According to the relationship between each optional programming pattern and the trigger, determine the trigger group to which each optional programming pattern belongs; Display each optional programming graphic under the corresponding trigger group, and display the jump control corresponding to each optional programming graphic.

12. The method according to claim 11, characterized in that Also includes: In response to the triggering operation of the jump control, jump to the position of the optional programming graphic corresponding to the jump control in the graphical programming interface.

13. The method according to claim 1, wherein Also includes: In response to a disabling operation on the breakpoint marker, the state of the breakpoint marker is updated to a disabled state, and the breakpoint marker remains displayed.

14. The method according to claim 1, wherein In response to the code combination running to the code position corresponding to the breakpoint identifier, controlling to pause the game running scene and controlling to pause the running of the code combination, including: In response to the code combination running to the code position corresponding to the breakpoint identifier, the code combination is controlled to be paused; and according to the mapping relationship between the currently paused code combination and the game running scene, the game running scene is controlled to be paused.

15. The method according to claim 1, wherein In response to the code combination running to the code position corresponding to the breakpoint identifier, controlling to pause the game running scene and controlling to pause the running of the code combination, including: In response to the code combination running to the code position corresponding to the breakpoint identifier, according to the breakpoint pause condition corresponding to the breakpoint identifier, the game running scene is controlled to be paused, and the running of the code combination is controlled to be paused.

16. The method according to claim 15, characterized in that The controlling the pause of the game running scene according to the breakpoint pause condition corresponding to the breakpoint identifier, and controlling the pause of the running of the code combination, includes: If the current value of at least one programming graphic corresponding to the breakpoint identifier meets the breakpoint pause condition, the code combination is controlled to be paused; and according to the mapping relationship between the currently paused code combination and the game running scene, the game running scene is controlled to be paused.

17. The method according to claim 1, wherein The step of displaying a debugging interface on the graphical user interface includes: The debugging interface is displayed according to the currently paused game running scene and the graphical programming interface.

18. The method according to claim 17, characterized in that The step of displaying the debugging interface according to the currently paused game running scene and the graphical programming interface includes: The graphical programming interface is displayed in a suspended manner in the currently paused game running scene, and debugging controls are displayed in the graphical programming interface.

19. The method according to claim 17, wherein Also includes: Determine the pause programming graph to which the current pause is to be applied based on the correspondence between the currently paused code combination and the programming graph; The graphical programming interface is displayed in a suspended manner in the currently paused game running scene, and the pause programming graphic is highlighted in the graphical programming interface.

20. The method according to claim 19, characterized in that Also includes: In response to a triggering operation of the graphical programming interface, the graphical programming interface is displayed in full screen, and the currently paused game running scene is displayed in a suspended manner in the graphical programming interface; In response to the triggering operation of the debugging control, the programming graphics in the programming graphics area corresponding to the paused programming graphics are debugged, and during the debugging process, the programming graphics currently being debugged are tracked and displayed.

21. The method according to claim 20, characterized in that The debugging control includes: a single-step debugging control; in response to the triggering operation of the debugging control, debugging the programming graphics in the programming graphics area corresponding to the paused programming graphics, including: In response to a triggering operation of the single-step debugging control, debugging each programming graphic in the programming graphic area one by one starting from the starting end of the programming graphic area; During the debugging process, the currently paused game running scene displayed in suspension is controlled to change accordingly according to the function of the programming graphic currently being debugged.

22. The method according to claim 20, characterized in that The debugging control includes: a re-running control; in response to the triggering operation of the debugging control, debugging the programming graphics in the programming graphics area corresponding to the paused programming graphics, including: In response to the triggering operation of the re-run control, the code combination is restarted, and when the code combination runs to the code position corresponding to the breakpoint identifier, the game running scene is controlled to be paused, and the running of the code combination is controlled to be paused.

23. The method according to claim 20, characterized in that The debugging control includes: a continuing operation control; in response to the triggering operation of the debugging control, debugging the programming graphics in the programming graphics area corresponding to the paused programming graphics, including: In response to the triggering operation of the continue running control, closing the debugging interface; The code combination is continued to be run from the code combination where the running is paused, and the game running scene is displayed during the running of the code combination.

24. The method according to claim 19, wherein The suspending and displaying the graphical programming interface in the currently paused game running scene includes: The graphical programming interface is displayed in a suspended manner in the currently paused game running scene, and debugging controls and description information corresponding to the pause programming graphics are displayed in the currently paused game running scene.

25. The method according to claim 24, characterized in that Also includes: In response to a triggering operation on a debugging control in the currently paused game running scene, debugging is performed on a programming graphic area corresponding to the paused programming graphic.

26. The method according to claim 24, characterized in that The step of debugging the programming graphic area corresponding to the paused programming graphic in response to the triggering operation of the debugging control in the currently paused game running scene includes: In response to the triggering operation of the debugging control in the currently paused game running scene, the programming graphic area corresponding to the paused programming graphic is debugged, and during the debugging process, the currently paused game running scene is controlled to produce corresponding changes according to the function of the programming graphic currently being debugged.

27. The method according to claim 18, wherein The graphical programming interface further displays a monitoring list, wherein the monitoring list displays at least one programming graphic to be monitored set by the user and the current value of the programming graphic to be monitored.

28. The method according to claim 27, characterized in that Also includes: In response to a confirmation operation on a designated programming graphic in the graphical programming interface, if the designated programming graphic exists in the monitoring list, the designated programming graphic in the monitoring list is highlighted.

29. The method according to claim 18, wherein The graphical programming interface also displays an information search bar; the method further includes: In response to the search information of the programming pattern to be searched input in the information search bar, the current value of the programming pattern to be searched is displayed.

30. The method according to claim 20, wherein After the full-screen display of the graphical programming interface, the method further includes: In response to an exit operation on the graphical programming interface, the graphical programming interface is suspended and displayed in the currently paused game running scene.

31. The method according to claim 18, wherein After the graphical programming interface is displayed in a suspended manner in the currently paused game running scene, the method further includes: In response to an exit operation on the currently paused game running scene, the debugging interface is exited and restored to the initial graphical programming interface.

32. The method according to claim 1, wherein Also includes: In response to an object instance viewing operation, displaying a plurality of object instances; In response to a selection operation on a target object instance from among the multiple object instances, displaying a game running scene corresponding to the target object instance in an instance window, wherein the game running scene displays an actual position of the game object corresponding to the target object instance in the game running scene; In response to a confirmation operation on the target object instance, the program jumps to the debugging interface to debug the programming graph corresponding to the target object instance.

33. The method according to claim 32, characterized in that In response to the object instance viewing operation, displaying multiple object instances includes: In response to the object instance viewing operation, identifying the programming graph being debugged; If the programming graphic being debugged corresponds to an object instance, multiple object instances corresponding to the programming graphic being debugged are displayed in the debugging interface.

34. The method according to claim 32, wherein In response to the object instance viewing operation, displaying multiple object instances includes: In response to a triggering operation of the instance control, a target object is selected from a plurality of candidate objects; Multiple object instances corresponding to the target object are displayed in the debugging interface.

35. An information processing device for game editing, characterized in that: include: Display module, control module and debugging module; The display module is configured to display a graphical programming interface in a graphical user interface during a game editing phase; wherein the graphical programming interface includes a programming graphic group consisting of one or more programming graphics; each programming graphic corresponds to a section of code, and the programming graphic group corresponds to a code combination formed by the codes corresponding to the one or more programming graphics; The control module is configured to control, in response to a breakpoint creation instruction, adding a breakpoint identifier at a target programming graph corresponding to the breakpoint creation instruction; The control module is configured to control the display of a game running scene in the graphical user interface and the running of the code combination in response to a running instruction; The control module is configured to control the game running scene to be paused and the running of the code combination to be paused in response to the code combination running to the code position corresponding to the breakpoint identifier; The debugging module is used to display a debugging interface on the graphical user interface. The debugging interface includes the programming graphic group and a debugging control. The debugging control is configured to control the debugging of a code combination corresponding to the programming graphic group.

36. An electronic device, characterized in that: include: A processor, a storage medium and a bus, wherein the storage medium stores program instructions executable by the processor. When the electronic device is running, the processor and the storage medium communicate through the bus, and the processor executes the program instructions to perform the information processing method for game editing as described in any one of claims 1 to 34.

37. A computer-readable storage medium, characterized in that The storage medium stores a computer program, which, when executed by a processor, executes the information processing method for game editing according to any one of claims 1 to 34.

Images