Game editing method, game editing device, program product, and electronic device

Abstract

The present disclosure provides a game editing method, a game editing device, a program product and an electronic device, and relates to the technical field of computers and games. The method comprises: in a game editing stage, displaying a graphical programming interface in a graphical user interface; the graphical programming interface provides a programming graphical control, and the programming graphical control is configured to generate a corresponding programming graph in response to a first editing instruction; in response to a second editing instruction for a first trigger in the graphical programming interface, setting a first temporary variable in the first trigger; the first trigger is composed of one or more programming graphs; the first temporary variable is configured to take effect only for the first trigger; in a game running stage, in response to triggering the first trigger, executing game logic corresponding to the first trigger according to related variables of the first trigger; the related variables of the first trigger include the first temporary variable. The present disclosure enriches the variable types in the UGC editor, which is conducive to improving the editing effect.

Description

Technical Field

[0001] This disclosure relates to the field of computer and game technology, and more particularly to a game editing method, game editing device, computer program product, and electronic device. Background Technology

[0002] With the development of computer technology, some games offer UGC (User Generated Content) editors, allowing users to customize and edit game maps or gameplay. However, current UGC editors have relatively limited variable types, restricting the game logic that users can edit and affecting the editing results. Summary of the Invention

[0003] This disclosure provides a game editing method, game editing device, computer program product, and electronic device to at least partially solve the problem of relatively limited variable types in UGC editors.

[0004] According to a first aspect of this disclosure, a game editing method is provided, the method comprising: in a game editing phase, displaying a graphical programming interface in a graphical user interface; the graphical programming interface providing at least one programming graphical control configured to generate a corresponding programming graphical control in the graphical programming interface in response to a first editing instruction; in response to a second editing instruction targeting a first trigger in the graphical programming interface, setting a first temporary variable in the first trigger; the first trigger comprising one or more programming graphical controls; the first temporary variable being configured to be effective only for the first trigger; in a game running phase, in response to triggering the first trigger, executing game logic corresponding to the first trigger according to related variables of the first trigger; the related variables of the first trigger including the first temporary variable.

[0005] According to a second aspect of this disclosure, a game editing apparatus is provided, the apparatus comprising: a graphical programming interface display module configured to display a graphical programming interface in a graphical user interface during a game editing phase; the graphical programming interface providing at least one programming graphical control configured to generate a corresponding programming graphical object in the graphical programming interface in response to a first editing instruction; a variable setting module configured to set a first temporary variable in the first trigger in response to a second editing instruction targeting a first trigger in the graphical programming interface; the first trigger comprising one or more programming graphical objects; the first temporary variable configured to be effective only for the first trigger; and a trigger execution module configured to execute game logic corresponding to the first trigger in response to triggering the first trigger during a game running phase; the related variables of the first trigger include the first temporary variable.

[0006] According to a third aspect of this disclosure, a computer program product is provided, including a computer program that, when executed by a processor, implements the method of the first aspect described above and possible implementations thereof.

[0007] According to a fourth aspect of this disclosure, an electronic device is provided, comprising: a processor; and a memory for storing executable instructions of the processor; wherein the processor is configured to perform the method of the first aspect and possible implementations thereof by executing the executable instructions.

[0008] The technical solution disclosed herein has the following beneficial effects:

[0009] Users can set temporary variables within the game's graphical programming interface. These temporary variables only apply to the trigger they belong to, unlike regular global variables, thus enriching the variable types available in the UGC editor. Users can more easily edit local logic and use temporary variables to achieve data segregation within that local logic, preventing it from affecting other logic and improving editing flexibility. Furthermore, temporary variables from different triggers will not overwrite each other, reducing variable conflicts and editing errors, and ultimately improving the editing experience. Attached Figure Description

[0010] Figure 1 This illustration shows a system architecture diagram of one of the exemplary embodiments.

[0011] Figure 2 A flowchart illustrating a game editing method in this exemplary embodiment is shown;

[0012] Figure 3 A schematic diagram of a graphical programming interface in this exemplary embodiment is shown;

[0013] Figure 4 This illustrates a flowchart of setting a first temporary variable in this exemplary embodiment;

[0014] Figure 5 A schematic diagram showing a temporary variable setting interface in this exemplary embodiment is provided.

[0015] Figure 6 A schematic diagram of a first temporary variable in this exemplary embodiment is shown;

[0016] Figure 7 The following is a flowchart illustrating the execution of a first trigger and a second trigger in this exemplary embodiment;

[0017] Figure 8 This diagram illustrates the structure of a game editing device according to this exemplary embodiment.

[0018] Figure 9 A schematic diagram of the structure of an electronic device in this exemplary embodiment is shown. Detailed Implementation

[0019] Exemplary embodiments of this disclosure will be described more fully below with reference to the accompanying drawings.

[0020] The accompanying drawings are schematic illustrations of this disclosure and are not necessarily drawn to scale. Some block diagrams shown in the drawings may be functional entities and do not necessarily correspond to physically or logically independent entities. These functional entities may be implemented in software, in hardware modules or integrated circuits, or in networks, processors, or microcontrollers. Implementations can be carried out in various forms and should not be construed as limited to the examples set forth herein. The features, structures, or characteristics described in this disclosure can be combined in any suitable manner in one or more embodiments. Numerous specific details are provided in the following description to give a thorough description of embodiments of this disclosure. However, those skilled in the art will recognize that one or more specific details may be omitted when implementing the technical solutions of this disclosure, or other methods, components, apparatuses, steps, etc., may be used to replace one or more specific details.

[0021] The inventors have discovered that the variable types in UGC editors are relatively limited, typically being global variables. This makes it difficult for users to achieve data closure for local logic when editing game logic using a UGC editor. For example, variables set in a certain local logic can affect other logic and are prone to data overwriting, thus affecting the editing effect.

[0022] In view of one or more of the above-mentioned problems, an exemplary embodiment of this disclosure provides a game editing method.

[0023] Figure 1 A system architecture diagram of the operating environment of this exemplary embodiment is shown. This system architecture may include a terminal device 110 and a server 120. The terminal device 110 may be a mobile phone, tablet computer, personal computer, smart wearable device, game console, etc. An application, such as a game program, is installed on the terminal device 110. The terminal device 110 has a display function and can display a graphical user interface, which may include the operating system interface or the application interface. The server 120 generally refers to the backend system providing game or editing services in this exemplary embodiment; it may be a single server or a cluster of multiple servers. In one embodiment, a game server program is deployed on the server 120 to perform server-side game data processing. The terminal device 110 and the server 120 can be connected via a wired or wireless communication link for data transmission. The method in this exemplary embodiment can be executed by any one or more of the terminal device 110 and the server 120.

[0024] In one implementation, the above method can be implemented and executed based on a cloud interaction system. The cloud interaction system can be based on the aforementioned system architecture. Various cloud applications, such as cloud gaming, can run under the cloud interaction system. Taking cloud gaming as an example, cloud gaming refers to a gaming method based on cloud computing. In the cloud gaming operating mode, the game program's execution and the game screen presentation are separated. The storage and execution of in-game control and interaction methods are completed on the cloud gaming server (such as the aforementioned server 120). The cloud gaming client (such as the aforementioned terminal device 110) is used for data reception, transmission, and game screen presentation. For example, the cloud gaming client can be a display device with data transmission capabilities located close to the user, such as a mobile terminal, television, computer, or PDA; while the cloud gaming server in the cloud performs information processing. When playing or editing a game, the user operates the cloud gaming client to send operation commands to the cloud gaming server. The cloud gaming server runs the game according to the operation commands, encodes and compresses game screen data, returns it to the cloud gaming client via the network, and finally decodes and outputs the game screen through the cloud gaming client.

[0025] In one implementation, the game map (or scene) edited by the terminal device 110 can be uploaded to the server 120 for saving. For example, during the editing process, the currently edited game map can be automatically saved at regular intervals, or saved based on a manual save operation performed by the user, or automatically saved when exiting editing. When saving the game map, the terminal device 110 can upload the game map data to the server 120 for storage.

[0026] In one implementation, server 120 can maintain a game map pool, such as by deploying a database on the server side to store game maps. In response to a command to publish a game map on terminal device 110, server 120 can add game map data to the game map pool, allowing other players to download the game map data from the pool and use the game map to play. This enables rapid UGC functionality.

[0027] In one implementation, the above method can be implemented by the terminal device 110 without deploying the server 120. For example, in a standalone game or editing environment, a standalone application can be installed on the terminal device 110 to execute the above method.

[0028] Figure 2 The diagram illustrates a schematic flow of a game editing method, which may include the following steps:

[0029] Step S210: During the game editing stage, a graphical programming interface is displayed in the graphical user interface; the graphical programming interface provides at least one programming graphical control, which is configured to generate a corresponding programming graphic in the graphical programming interface in response to the first editing command;

[0030] Step S220: In response to a second editing instruction for a first trigger in the graphical programming interface, a first temporary variable is set in the first trigger; the first trigger consists of one or more programming graphics; the first temporary variable is configured to be effective only for the first trigger;

[0031] Step S230: During the game running phase, the first trigger is triggered in response, and the game logic corresponding to the first trigger is executed according to the relevant variables of the first trigger; the relevant variables of the first trigger include the first temporary variable.

[0032] based on Figure 2 The method shown allows users to set temporary variables within the game's graphical programming interface. These temporary variables only apply to their respective triggers, unlike regular global variables, thus enriching the variable types available in the UGC editor. Users can more easily edit local logic and achieve data closure for that local logic through temporary variables, preventing impact on other logic and improving editing flexibility. Furthermore, temporary variables from different triggers do not overwrite each other, reducing variable conflicts and editing errors, and ultimately improving the editing experience.

[0033] The following is about Figure 2 Each step is explained in detail.

[0034] refer to Figure 2In step S210, during the game editing phase, a graphical programming interface is displayed in the graphical user interface; the graphical programming interface provides at least one programming graphical control, which is configured to generate a corresponding programming graphic in the graphical programming interface in response to a first editing instruction.

[0035] This exemplary implementation divides the game process into at least two stages: a game editing stage, which is the stage where the user uses the editing function to edit content such as the game map; and a game running stage, which is the stage where the user plays the game, and can use the content edited in the game editing stage to play the game, such as the user playing the game on the edited game map.

[0036] This exemplary embodiment provides editing functionality through an application. The application can be a game program with built-in editing features. When running the game program, the user can select specific options to access the editing interface and use the editing functions. In another embodiment, the application can be an editing program, which is not a game program but provides editing functionality without allowing gameplay. For example, the editing program can be an accompanying editing program for a game program, which can run independently of the game program, or it can be an independent editing program that is universally applicable to different games, such as DCC (Digital Content Creation) software, game engines, etc. When running the editing program, the user can use the editing functions.

[0037] A graphical programming interface (GUI) is an interface for editing game logic using programming graphics. The GUI provides programming graphic controls, which are configured to generate corresponding programming graphics in response to the first editing command. Figure 3 A schematic diagram of a graphical programming interface is shown. (Reference) Figure 3As shown, the graphical programming interface provides corresponding graphical controls 301 according to different categories such as events, actions, controls, conditions, values, and variables. Each category can offer more detailed graphical controls 301; for example, under the event category, it provides graphical controls 301 for different events such as "game initialization," "game end," "timer expires," "receiving a custom event," and "specified component clicked." Users can drag the graphical controls 301 onto the graphical programming interface. This dragging operation generates the first editing command, triggering the generation of the corresponding programming graphic in the graphical programming interface. For example, dragging the "game initialization" graphical control 301 onto the graphical programming interface triggers the generation of the "game initialization" programming graphic. Alternatively, the first editing command can be implemented through other operations, such as clicking the graphical control 301 and then clicking a location in the graphical programming interface to trigger the generation of the corresponding programming graphic at that location.

[0038] Developers can pre-configure corresponding code for programming graphical controls. For example, the code for event-type programming graphical controls can be a statement describing the event; the code for action-type controls can be an instruction function; and the code for conditional-type controls can be a conditional statement. Furthermore, visual information can be pre-configured for the programming graphical controls, including the shape and color of the graphical graphic, as well as text describing the code logic. In this case, the programming graphic generated by the control possesses the visual information of the control and corresponds to the configured code, making it easy for users to edit.

[0039] Different types of programming graphics can have different shapes or colors. Users can combine programming graphics in the graphical programming interface; graphics with matching shapes can be joined together, thus ensuring the logical order of the code. Visual information such as text within the programming graphics helps users understand the logic after the graphics are combined. The program combines the code corresponding to the combined graphics to form a piece of code that implements the game logic. Therefore, the graphical programming interface provides a graphical programming method, allowing users to edit game logic through visual graphic combinations, without requiring professional computer programming knowledge, greatly reducing the barrier to entry and difficulty of programming.

[0040] Continue to refer to Figure 2 In step S220, in response to a second editing instruction for a first trigger in the graphical programming interface, a first temporary variable is set in the first trigger; the first trigger consists of one or more programming graphics; the first temporary variable is configured to be effective only for the first trigger.

[0041] A trigger is essentially a piece of code that indicates when a specific condition is met (such as the occurrence of a specific event or the arrival of a specific time), the program is instructed to execute a corresponding command. In a graphical programming interface, a trigger can be presented as a combination of one or more programming graphics. For example, a trigger may include a programming graphic for an event and a programming graphic for an action, indicating that the action will be executed when the event is detected. Temporary variables are variables that are only effective within the trigger.

[0042] In this exemplary embodiment, the first trigger is a trigger edited by the user through a second editing command, and can be any trigger in the graphical programming interface. The second editing command is an instruction to set a temporary variable for the first trigger. The temporary variable set by the user for the first trigger through the second editing command is called the first temporary variable, which only applies to the first trigger. In one embodiment, the first temporary variable cannot be used by other triggers; for example, when the user edits other triggers, they cannot select the first temporary variable, that is, they cannot set the variable used in other triggers as the first temporary variable.

[0043] In one implementation, the second editing instruction includes a temporary variable trigger instruction and a temporary variable selection instruction. (See reference) Figure 4 As shown, the above response to the second editing instruction of the first trigger in the graphical programming interface, setting the first temporary variable in the first trigger, may include the following steps S410 and S420:

[0044] Step S410: In response to the temporary variable triggering instruction, display the temporary variable of the second trigger; the first trigger is a sub-trigger of the second trigger.

[0045] In this system, different triggers can form a parent-child relationship. For example, if a first trigger is part of a second trigger, then the first trigger is a child trigger of the second trigger, and the second trigger is the parent trigger of the first trigger. In one implementation, the second trigger includes a second condition and a second instruction. The second trigger is configured to execute the second instruction in response to triggering the second condition; the second instruction includes registering the first trigger. That is, the instruction triggered by the second trigger includes the instruction to register the first trigger, making the first trigger a child trigger of the second trigger, and the second trigger a parent trigger of the first trigger.

[0046] When setting temporary variables for child triggers, at least some information from the temporary variables of their parent triggers can be used. For example, a temporary variable from the parent trigger can be added to the child trigger and used as a temporary variable for the child trigger. Alternatively, a temporary variable related to the temporary variable of the parent trigger can be set in the child trigger, such as the child trigger's temporary variable having the same variable type, variable name, or inheriting other information from the parent trigger's temporary variable.

[0047] A temporary variable trigger command is an operation command that initiates the addition of a temporary variable. For example, if the programming graphics of the first trigger have a first variable control, a temporary variable trigger command targeting the first variable control can display the temporary variable of the second trigger. Of course, the temporary variable trigger command can also be implemented through methods other than the first variable control. Responding to the temporary variable trigger command and displaying the temporary variable of the second trigger indicates that when setting a temporary variable for the first trigger, the user can choose to use the information from the temporary variable of the second trigger.

[0048] refer to Figure 3 As shown, each trigger in the graphical programming interface is equipped with a first variable control 302, which allows users to set temporary variables for the corresponding trigger.

[0049] In one implementation, in response to a temporary variable triggering command, a temporary variable setting interface is displayed, which includes the temporary variable of the second trigger. Figure 5 A schematic diagram of the temporary variable setting interface is shown. This interface displays the temporary variable 501 of the second trigger and can be categorized by variable type. This allows users to clearly see which types of temporary variables the second trigger has, facilitating further selection.

[0050] Step S420: In response to the temporary variable selection instruction, determine the second temporary variable from the temporary variables of the second trigger, and set the first temporary variable in the first trigger according to the second temporary variable.

[0051] When displaying temporary variables for the second trigger, the user can select from them. Based on the user's selection command, the selected temporary variable is called the second temporary variable, and the first temporary variable is set in the first trigger according to the second temporary variable. As mentioned earlier, based on the relationship that the first trigger is a child trigger of the second trigger, the first and second temporary variables can be the same variable. Alternatively, the first and second temporary variables can be different variables, but at least some of their information is the same; for example, a first temporary variable with the same variable type and name as the second temporary variable can be set in the first trigger. Figure 6A schematic diagram is shown of the first temporary variable 601 set according to the second temporary variable. If the user... Figure 5 If you select "Boolean variable a" as the second temporary variable in the temporary variable settings interface shown, you can set "Boolean variable a" with the same variable type and name, which is the first temporary variable 601.

[0052] Therefore, when setting temporary variables, the relevant information of the temporary variables of the parent trigger can be reused, which helps to improve editing efficiency and reduce system overhead.

[0053] In one implementation, the second editing instruction includes a temporary variable triggering instruction and a temporary variable creation instruction. The response to the second editing instruction in response to the first trigger in the graphical programming interface, setting the first temporary variable in the first trigger, may include the following steps:

[0054] Responding to the temporary variable trigger command, the second variable control is displayed;

[0055] In response to a temporary variable creation instruction for the second variable control, a new first temporary variable is created in the first trigger.

[0056] The temporary variable trigger command is an operation command that initiates the addition of a temporary variable. The second variable control is a control used to create the new temporary variable. In one implementation, in response to the temporary variable trigger command, a temporary variable setting interface is displayed, which includes the second variable control. The user can trigger the temporary variable creation command through the second variable control to create a new temporary variable for the first trigger, which will then serve as the first temporary variable.

[0057] In one implementation, the second variable control includes a variable type control and a variable creation control; in response to a temporary variable creation instruction for the second variable control, a new first temporary variable is created in the first trigger, including:

[0058] Respond to the selection command for the variable type control to determine the target variable type;

[0059] In response to a trigger command that creates a control for a variable, a first temporary variable of the target variable type is created in the first trigger.

[0060] For example, variable types include, but are not limited to, integers, real numbers, booleans, strings, players (player-type variables generally refer to one or more specific players), vectors, etc. Users can select from these types using the variable type control to determine the target variable type, and then use the variable creation control to determine the creation of a new temporary variable under the target variable type. This provides a way to set temporary variables independently of the parent trigger.

[0061] refer to Figure 5The temporary variable setting interface shown displays both the temporary variable 501 of the second trigger and provides a variable type control 502 and a variable creation control 503. Users can select the second temporary variable using the temporary variable selection command for temporary variable 501, and the program sets the first temporary variable for the first trigger based on the second temporary variable. Users can also select the target variable type using the variable type control 502. For example, if the user selects the "integer" control, the target variable type is determined to be integer, and the variable creation control 503 triggers the creation of a new first temporary variable of the target variable type in the first trigger. For instance, if the user selects the "integer" control and clicks the variable creation control 503, a new first temporary variable of integer type is created. This allows users to freely choose between these two methods to set temporary variables in the temporary variable setting interface, improving the freedom and flexibility of editing.

[0062] In one implementation, the game editing method may further include the following steps:

[0063] When the first temporary variable is set in the first trigger according to the second temporary variable, an inheritance identifier is displayed in the programming graph of the first temporary variable; the inheritance identifier indicates that the first temporary variable inherits the information of the temporary variable of the parent trigger of the first trigger.

[0064] Specifically, for temporary variables of child triggers set based on temporary variables of the parent trigger, an inheritance flag can be displayed to indicate that the temporary variable inherits information from the temporary variable of the parent trigger. For example, see [reference]. Figure 6 The diagram shown illustrates the first temporary variable 601, with the inheritance identifier 6011 displayed in the programming graphics. For completely newly created temporary variables, the inheritance identifier may not be displayed. This makes it easier for users to distinguish between them.

[0065] Since temporary variables only apply to the trigger they belong to, temporary variables from different triggers are isolated from each other. Therefore, temporary variables from different triggers can be given the same name. Although they have the same name, they represent different temporary variables in different triggers, and the program can distinguish between different temporary variables in different triggers by using the trigger identifier and the temporary variable name. This reduces the likelihood of naming conflicts when users name temporary variables, improving the readability of the programming graphics.

[0066] In one implementation, the game editing method may further include at least one of the following steps:

[0067] Responding to the third editing command in the graphical programming interface, a global variable is set; the global variable is configured to apply to all triggers.

[0068] In response to the fourth edit command in the first trigger group in the graphical programming interface, a local variable is set in the first trigger group; the first trigger group includes one or more independent triggers; the local variable is configured to take effect only for the triggers in the first trigger group.

[0069] The third editing command is used to set global variables. After creating a global variable, it can be used in any trigger. For example, if a user creates a global variable x when editing trigger T1, the global variable x can be used when editing the first trigger, without requiring a parent-child relationship between the first trigger and trigger T1.

[0070] A trigger group is essentially a collection of triggers. In the graphical programming interface, users can set up different canvases, which can be understood as independent programming environments. Triggers within a canvas form a trigger group. Different triggers within a trigger group can be independent of each other; there is no parent-child relationship between triggers. Local variables are variables that only apply to triggers within a trigger group. The fourth editing command is used to set local variables. The first trigger group can be any trigger group in the graphical programming interface, such as the trigger group corresponding to the canvas currently being edited by the user. Local variables set by the user for the first trigger group using the fourth editing command can be used by any trigger within the first trigger group. For example, if the user creates a local variable y when editing trigger T2, the local variable y can be used when editing other triggers in the same trigger group as trigger T2.

[0071] As can be seen from the above, in addition to temporary variables, users can also use global or local variables in the UGC editor. By using different types of variables, the flexibility and convenience of editing for users are improved.

[0072] Continue to refer to Figure 2 In step S230, during the game running phase, the first trigger is triggered in response, and the game logic corresponding to the first trigger is executed according to the relevant variables of the first trigger; the relevant variables of the first trigger include the first temporary variable.

[0073] Based on the foregoing, the first trigger is represented in the graphical programming interface as a visual combination of programming graphics, corresponding to specific code. During game execution, this code can be run to implement the game logic corresponding to the first trigger. The related variables of the first trigger refer to the variables used by the first trigger, including the first temporary variable, and may also include other variables, such as global variables.

[0074] In one implementation, the first trigger includes a first condition and a first instruction. For example, refer to... Figure 3As shown, the first trigger may include the programming graphics in the second to fourth rows, the first condition is "after 1.00 seconds", and the first instruction is "start AA action".

[0075] The above response triggers a first trigger, and the game logic corresponding to the first trigger is executed based on the relevant variables of the first trigger. This can include: triggering a first condition, registering a first temporary variable, and executing a first instruction based on the relevant variables including the first temporary variable. For example, if the first instruction involves the first temporary variable, when the first condition is triggered, the first temporary variable is registered, and the first instruction is executed based on the first temporary variable and other relevant variables.

[0076] In one implementation, the game editing method may further include the following steps:

[0077] After the game logic corresponding to the first trigger is executed, the first temporary variable is cleared.

[0078] Since the first temporary variable only applies to the first trigger, it is no longer needed after the game logic corresponding to the first trigger is executed. Therefore, the first temporary variable can be cleared without affecting the execution of other game logic, and variable redundancy can be reduced, saving system resources.

[0079] In one implementation, after clearing the first temporary variable, the game editing method may further include the following steps:

[0080] In response to the next triggering of the first trigger, re-register the first temporary variable, and execute the game logic corresponding to the first trigger based on the relevant variables of the first trigger.

[0081] The first trigger may be configured to trigger multiple times, such as a periodic trigger condition. Each time the first trigger is triggered, a first temporary variable can be registered, the corresponding game logic executed, and the first temporary variable cleared after execution. This reduces variable redundancy during periods when the first trigger is not executed, saving system resources.

[0082] In one implementation, if the first temporary variable is a temporary variable set based on the second temporary variable in the second trigger, the game editing method may further include the following steps during the game execution phase:

[0083] Register the first temporary variable, and determine the value of the first temporary variable based on the value of the second temporary variable.

[0084] In other words, the first temporary variable can inherit the value of the corresponding second temporary variable from the parent trigger. For example, registering the first temporary variable and determining its value based on the value of the second temporary variable can include: registering the first temporary variable at the first moment of registering the first trigger, and determining its initial value based on the value of the second temporary variable at that moment. For instance, when executing the second instruction in the second trigger, the first trigger and the first temporary variable are registered, and at the first moment of registration, the current value of the second temporary variable is assigned to the first temporary variable as its initial value. That is, when registering the first temporary variable, the first and second temporary variables have the same value. Afterwards, the first and second temporary variables are treated as two different temporary variables, and their values ​​are no longer related; if the value of the second temporary variable changes, the value of the first temporary variable does not change.

[0085] Figure 7 The execution flow of the second trigger and the first trigger is illustrated. In the second trigger's flow, it listens for whether the second condition is triggered. If the second condition is triggered, a second temporary variable is registered, and the second instruction is executed. After the second trigger's flow ends, the second temporary variable is cleared. Additionally, during the execution of the second instruction, the first trigger is registered; the first trigger is a child trigger of the second trigger. A first temporary variable is also registered, inheriting the value of the second temporary variable. When the first condition is detected, the first instruction is executed. After the first trigger's flow ends, the first temporary variable is cleared.

[0086] In one implementation, the game editing method may further include the following steps:

[0087] If the response adds the first programming pattern from the third trigger to the first trigger, and the third temporary variable included in the first programming pattern is the same as the second temporary variable, then the third temporary variable is merged with the first temporary variable determined based on the second temporary variable; the third trigger and the second trigger are independent of each other.

[0088] Adding the first programming pattern from the third trigger to the first trigger means moving or copying the first programming pattern into the first trigger to make it part of the first trigger, such as serving as the first condition or first instruction in the first trigger. The first programming pattern originally includes a third temporary variable, which is a temporary variable within the third trigger. The third trigger and the second trigger are independent of each other; that is, there is no parent-child relationship between the third and second triggers. Therefore, the third temporary variable in the third trigger and the second temporary variable in the second trigger are two independent temporary variables. If the two temporary variables are the same (meaning they have the same variable type and name), then the third temporary variable is merged with the first temporary variable determined based on the second temporary variable (the first and second temporary variables can also be the same). For example, the first temporary variable can overwrite the third temporary variable, that is, the third temporary variable in the first programming pattern added to the first trigger is converted into the first temporary variable. In this way, the first trigger will not contain the temporary variable from the third trigger, ensuring the independence of temporary variables within their respective triggers.

[0089] In one implementation, the game editing method may further include the following steps:

[0090] The response separates the second programming pattern in the first trigger from the first trigger, and determines the fourth temporary variable in the fourth trigger based on the first temporary variable included in the second programming pattern; the fourth trigger is the trigger to which the second programming pattern belongs after it is separated from the first trigger.

[0091] The second programming pattern is the programming pattern in the first trigger that involves the first temporary variable. The second programming pattern can be separated from the first trigger to form a new fourth trigger, or it can be separated and added to an existing fourth trigger. The first temporary variable originally included in the second programming pattern is a temporary variable that only applies to the first trigger and cannot be used in the fourth trigger. Therefore, the first temporary variable in the separated second programming pattern can be converted into a fourth temporary variable in the fourth trigger. For example, the first temporary variable can be converted into a fourth temporary variable with the same variable type and name.

[0092] In one implementation, when the first trigger is a sub-trigger of the second trigger, it is permissible to separate the second programming pattern in the first trigger from the first trigger.

[0093] In one implementation, during the game editing phase, a graphical programming interface is displayed in the graphical user interface, including:

[0094] During the game editing stage, the game editing scene corresponding to the target game map is displayed in the graphical user interface;

[0095] Responding to programming trigger commands in the game editing scene, a graphical programming interface is displayed.

[0096] The target game map is the game map currently being edited by the user. It can be any game map, such as a newly created map, a pre-set map in the program, or a map previously edited by the user or edited by another user. The game editing scene is a scene formed by loading the target game map in edit mode. In the game editing scene, the user can edit scene components, the scene environment, and other content. Within the game editing scene, the user can trigger commands to enter a graphical programming interface. For example, a graphical programming option may be provided in the relevant settings interface of the game editing scene; clicking an option will trigger the display of the graphical programming interface. Game logic, such as triggers, edited in the graphical programming interface will take effect on the target game map. Of course, this game logic can also be reused in other game maps through sharing or other methods.

[0097] In one implementation, the above response triggers a first trigger, and the game logic corresponding to the first trigger is executed according to the relevant variables of the first trigger, which may include the following steps:

[0098] During the game's execution phase, the game scene corresponding to the target game map is displayed in the graphical user interface;

[0099] The response triggers the first trigger in the game's runtime scenario, and executes the game logic corresponding to the first trigger based on the relevant variables of the first trigger.

[0100] The game execution scene is a scene formed by loading the target game map in the execution mode, and it corresponds to the game editing scene. Within the game execution scene, the first trigger is executed; for example, when the first condition is triggered, the first instruction is executed, implementing the game logic corresponding to the first trigger.

[0101] Exemplary embodiments of this disclosure also provide a game editing apparatus. (See reference...) Figure 8 As shown, the game editing device 800 may include the following program modules:

[0102] The graphical programming interface display module 810 is configured to display a graphical programming interface in a graphical user interface during the game editing stage; the graphical programming interface provides at least one programming graphical control, which is configured to generate a corresponding programming graphic in the graphical programming interface in response to a first editing command;

[0103] The variable setting module 820 is configured to, in response to a second editing instruction for a first trigger in the graphical programming interface, set a first temporary variable in the first trigger; the first trigger consists of one or more programming graphics; the first temporary variable is configured to be effective only for the first trigger;

[0104] The trigger execution module 830 is configured to respond to the trigger during the game running phase, and execute the game logic corresponding to the trigger according to the relevant variables of the trigger; the relevant variables of the trigger include the first temporary variable.

[0105] In one implementation, the second editing instruction includes a temporary variable triggering instruction and a temporary variable selection instruction; the response to the second editing instruction for the first trigger in the graphical programming interface, setting a first temporary variable in the first trigger, includes: responding to the temporary variable triggering instruction, displaying the temporary variable of the second trigger; the first trigger is a sub-trigger of the second trigger; responding to the temporary variable selection instruction, determining a second temporary variable from the temporary variables of the second trigger, and setting the first temporary variable in the first trigger according to the second temporary variable.

[0106] In one implementation, a first variable control is provided in the programming graph of the first trigger; the step of responding to a temporary variable triggering instruction and displaying the temporary variable of the second trigger includes: responding to a temporary variable triggering instruction for the first variable control and displaying the temporary variable of the second trigger.

[0107] In one implementation, setting the first temporary variable in the first trigger according to the second temporary variable includes: setting a first temporary variable in the first trigger that has the same variable type and the same variable name as the second temporary variable.

[0108] In one implementation, the trigger execution module 830 is further configured to: register the first temporary variable during the game running phase, and determine the value of the first temporary variable based on the value of the second temporary variable.

[0109] In one implementation, registering the first temporary variable and determining the value of the first temporary variable based on the value of the second temporary variable includes: registering the first temporary variable at a first moment when registering the first trigger, and determining the initial value of the first temporary variable based on the value of the second temporary variable at the first moment.

[0110] In one embodiment, the variable setting module 820 is further configured to: when a first temporary variable is set in the first trigger according to the second temporary variable, display an inheritance identifier in the programming graph of the first temporary variable; the inheritance identifier indicates that the first temporary variable inherits information of the temporary variable of the parent trigger of the first trigger.

[0111] In one implementation, the second trigger includes a second condition and a second instruction, the second trigger being configured to execute the second instruction in response to triggering the second condition; the second instruction includes registering the first trigger.

[0112] In one implementation, the variable setting module 820 is further configured to: in response to adding a first programming pattern from a third trigger to the first trigger, and the third temporary variable included in the first programming pattern being the same as the second temporary variable, merge the third temporary variable with the first temporary variable determined based on the second temporary variable; the third trigger and the second trigger are independent of each other.

[0113] In one implementation, merging the third temporary variable with the first temporary variable determined based on the second temporary variable includes: covering the third temporary variable with the first temporary variable.

[0114] In one implementation, the variable setting module 820 is further configured to: in response to separating the second programming pattern in the first trigger from the first trigger, determine a fourth temporary variable in the fourth trigger based on the first temporary variable included in the second programming pattern; the fourth trigger is the trigger to which the second programming pattern belongs after being separated from the first trigger.

[0115] In one implementation, the second editing instruction includes a temporary variable triggering instruction and a temporary variable creation instruction; the response to the second editing instruction for the first trigger in the graphical programming interface, setting a first temporary variable in the first trigger, includes: responding to the temporary variable triggering instruction and displaying a second variable control; responding to the temporary variable creation instruction for the second variable control and creating a new first temporary variable in the first trigger.

[0116] In one implementation, the second variable control includes a variable type control and a variable creation control; the step of creating a new first temporary variable in the first trigger in response to a temporary variable creation instruction for the second variable control includes: determining a target variable type in response to a selection instruction for the variable type control; and creating a first temporary variable of the target variable type in the first trigger in response to a trigger instruction for the variable creation control.

[0117] In one implementation, the first trigger includes a first condition and a first instruction; the response triggers the first trigger, and the game logic corresponding to the first trigger is executed according to the relevant variables of the first trigger, including:

[0118] In response to the first condition being triggered, the first temporary variable is registered, and the first instruction is executed based on the relevant variables including the first temporary variable.

[0119] In one implementation, the trigger execution module 830 is further configured to clear the first temporary variable after the game logic corresponding to the first trigger has been executed.

[0120] In one implementation, the trigger execution module 830 is further configured to: after clearing the first temporary variable, in response to the next triggering of the first trigger, re-register the first temporary variable, and execute the game logic corresponding to the first trigger according to the relevant variables of the first trigger.

[0121] In one embodiment, displaying a graphical programming interface in the graphical user interface during the game editing stage includes: displaying a game editing scene corresponding to the target game map in the graphical user interface during the game editing stage; and displaying the graphical programming interface in response to a programming trigger command in the game editing scene.

[0122] In one implementation, the step of responding to the triggering of the first trigger and executing the game logic corresponding to the first trigger according to the relevant variables of the first trigger during the game running phase includes: displaying the game running scene corresponding to the target game map in the graphical user interface during the game running phase; responding to the triggering of the first trigger in the game running scene and executing the game logic corresponding to the first trigger according to the relevant variables of the first trigger.

[0123] In one implementation, the variable setting module 820 is further configured to perform at least one of the following steps: in response to a third editing instruction in the graphical programming interface, setting a global variable; the global variable being configured to apply to all triggers; in response to a fourth editing instruction in the graphical programming interface for a first trigger group, setting a local variable in the first trigger group; the first trigger group comprising one or more independent triggers; the local variable being configured to apply only to triggers in the first trigger group.

[0124] The specific details of each part of the above-mentioned device have been described in detail in the method section of the implementation plan. For any undisclosed details, please refer to the implementation plan of the method section, and therefore will not be repeated here.

[0125] It should be noted that although several modules or units for the device used to perform actions have been mentioned in the detailed description above, this division is not mandatory. In fact, according to exemplary embodiments of this disclosure, the features and functions of two or more modules or units described above can be embodied in one module or unit. Conversely, the features and functions of one module or unit described above can be further divided and embodied by multiple modules or units.

[0126] Exemplary embodiments of this disclosure also provide a computer program product. The computer program product includes a computer program that, when executed by a processor, implements the methods described above.

[0127] In one embodiment, the computer program product can be a tangible product containing a computer program, such as a computer-readable storage medium storing the computer program. The readable storage medium can be a storage medium based on electrical, magnetic, optical, electromagnetic, infrared, or other signals, including but not limited to: random access memory (RAM), read-only memory (ROM), magnetic tape, floppy disk, flash memory, hard disk drive (HDD), solid-state drive (SSD), etc. For example, the computer program product can be implemented as a non-volatile storage medium storing the computer program, such as read-only memory, NAND flash memory, etc.

[0128] In one implementation, the computer program product can be an intangible product containing a computer program. For example, the computer program product can be implemented as a virtual digital product, such as an executable file, installation package, or other digital file storing the computer program.

[0129] Computer program code can be written in one or more programming languages. Examples of programming languages ​​include C, Java, and C++. Program code can execute entirely on the user's computing device, partially on the user's computing device, or as a standalone software package. It can also execute partially on the user's computing device and partially on a remote computing device, or entirely on a remote computing device or server. In cases involving remote computing devices, the remote computing device can be connected to the user's computing device via any type of network, such as a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computing device (e.g., via an internet connection provided by a mobile network operator).

[0130] Computer programs can be carried or transmitted via signals such as electricity, magnetism, light, electromagnetic radiation, and infrared rays. Electronic devices can convert signals carrying computer programs into digital signals, thereby running the computer programs. When a computer program runs on an electronic device, its code is used to cause the electronic device to execute (more specifically, the processor of the electronic device to execute) the method steps of various exemplary embodiments of this disclosure, such as the following steps: Step S210, in the game editing stage, a graphical programming interface is displayed in the graphical user interface; the graphical programming interface provides at least one programming graphic control, which is configured to generate a corresponding programming graphic in the graphical programming interface in response to a first editing instruction; Step S220, in response to a second editing instruction for a first trigger in the graphical programming interface, a first temporary variable is set in the first trigger; the first trigger consists of one or more programming graphics; the first temporary variable is configured to be effective only for the first trigger; Step S230, in the game running stage, in response to triggering the first trigger, the game logic corresponding to the first trigger is executed according to the relevant variables of the first trigger; the relevant variables of the first trigger include the first temporary variable.

[0131] Implementing the above methods and steps through a computer program allows users to set temporary variables within the game's graphical programming interface. These temporary variables only apply to their respective triggers, unlike regular global variables, thus enriching the variable types available in the UGC editor. Users can more easily edit local logic and achieve data closure for that local logic through temporary variables, preventing impact on other logic and improving editing flexibility. Furthermore, temporary variables from different triggers do not overwrite data, reducing variable conflicts and editing errors, and ultimately improving the editing experience.

[0132] Exemplary embodiments of this disclosure also provide an electronic device. The electronic device may include a processor and a memory. The memory stores executable instructions for the processor, such as a computer program. The processor executes the executable instructions to perform the method steps of various exemplary embodiments of this disclosure. Furthermore, the electronic device may also include a display for displaying a graphical user interface.

[0133] The following is for reference. Figure 9 The electronic device is illustrated by way of a general-purpose computing device. It should be understood that... Figure 9 The electronic device 900 shown is merely an example and should not be construed as limiting the functionality and scope of use of the embodiments disclosed herein.

[0134] like Figure 9 As shown, the electronic device 900 may include: a processor 910, a memory 920, a bus 930, an I / O (input / output) interface 940, a network adapter 950, and a display 960.

[0135] The memory 920 may include volatile memory, such as RAM 921 and cache unit 922, and may also include non-volatile memory, such as ROM 923. The memory 920 may also include one or more program modules 924, including but not limited to: an operating system, one or more application programs, other program modules, and program data. Each or some combination of these examples may include an implementation of a network environment. For example, program module 924 may include the modules described above.

[0136] The processor 910 may include one or more processing units, such as an AP (Application Processor), a modem processor, a GPU (Graphics Processing Unit), an ISP (Image Signal Processor), a controller, an encoder, a decoder, a DSP (Digital Signal Processor), a baseband processor, and / or an NPU (Neural-Network Processing Unit).

[0137] The processor 910 can be used to execute executable instructions stored in the memory 920, such as performing the following steps: Step S210, in the game editing stage, a graphical programming interface is displayed in the graphical user interface; the graphical programming interface provides at least one programming graphical control, which is configured to generate a corresponding programming graphic in the graphical programming interface in response to a first editing instruction; Step S220, in response to a second editing instruction for a first trigger in the graphical programming interface, a first temporary variable is set in the first trigger; the first trigger consists of one or more programming graphics; the first temporary variable is configured to be effective only for the first trigger; Step S230, in the game running stage, in response to triggering the first trigger, the game logic corresponding to the first trigger is executed according to the relevant variables of the first trigger; the relevant variables of the first trigger include the first temporary variable.

[0138] By executing the above steps through processor 910, users can set temporary variables within the game's graphical programming interface. These temporary variables only apply to their respective triggers, unlike regular global variables, thus enriching the variable types available in the UGC editor. Users can more easily edit local logic and achieve data closure for that local logic through temporary variables, preventing impact on other logic and improving editing flexibility. Furthermore, temporary variables from different triggers will not overwrite data, reducing variable conflicts and editing errors, and ultimately improving the editing experience.

[0139] Bus 930 is used to connect different components of electronic device 900 and may include data bus, address bus and control bus.

[0140] Electronic device 900 can communicate with one or more external devices 1000 (such as keyboard, mouse, external controller, etc.) through I / O interface 940.

[0141] Electronic device 900 can communicate with one or more networks via network adapter 950. For example, network adapter 950 can provide mobile communication solutions such as 3G / 4G / 5G, or wireless communication solutions such as wireless LAN, Bluetooth, and near-field communication. Network adapter 950 can communicate with other modules of electronic device 900 via bus 930.

[0142] Electronic device 900 can display a graphical user interface, such as a graphical programming interface, through display 960.

[0143] although Figure 9 As not shown in the diagram, other hardware and / or software modules may also be configured in the electronic device 900, including but not limited to: microcode, device drivers, redundant processors, external disk drive arrays, RAID systems, tape drives, and data backup storage systems.

[0144] As can be seen from the above, the technical solutions disclosed herein can be implemented as methods, apparatus, systems, computer program products, storage media, electronic devices, etc. Those skilled in the art will understand that various aspects of this disclosure can be specifically implemented in the following forms: a completely hardware implementation, a completely software implementation (including firmware, microcode, etc.), or a combination of hardware and software implementations, which may be referred to as "circuit," "module," or "system," respectively.

[0145] It should be understood that this disclosure is not limited to the specific methods, steps, or structures described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope. Those skilled in the art will readily conceive of other embodiments based on the specific implementations provided in this disclosure. Therefore, the specific implementations provided in this disclosure are merely exemplary, and the scope and spirit of this disclosure are indicated by the claims, and should cover any variations, uses, or adaptations of this disclosure that follow the general principles of this disclosure and include common knowledge or customary technical means in the art not disclosed in this disclosure.

Claims

1. A game editing method, characterized in that, The method includes: During the game editing phase, a graphical programming interface is displayed in the graphical user interface; the graphical programming interface provides at least one programming graphical control, which is configured to generate a corresponding programming graphic in the graphical programming interface in response to a first editing command; In response to a second editing instruction for a first trigger in the graphical programming interface, a first temporary variable is set in the first trigger; the first trigger consists of one or more programming graphics; the first temporary variable is configured to be effective only for the first trigger; During the game's execution phase, the first trigger is activated in response, and the game logic corresponding to the first trigger is executed according to the relevant variables of the first trigger; the relevant variables of the first trigger include the first temporary variable. The second editing instruction includes a temporary variable triggering instruction and a temporary variable selection instruction; the response to the second editing instruction for the first trigger in the graphical programming interface, setting a first temporary variable in the first trigger, includes: responding to the temporary variable triggering instruction and displaying the temporary variable of the second trigger; the first trigger is a sub-trigger of the second trigger; responding to the temporary variable selection instruction and determining a second temporary variable from the temporary variables of the second trigger, and setting the first temporary variable in the first trigger according to the second temporary variable; the first temporary variable uses at least a portion of the information of the second temporary variable; Alternatively, the second editing instruction includes a temporary variable triggering instruction and a temporary variable creation instruction; the response to the second editing instruction for the first trigger in the graphical programming interface, setting a first temporary variable in the first trigger, includes: responding to the temporary variable triggering instruction and displaying a second variable control; responding to the temporary variable creation instruction for the second variable control and creating a new first temporary variable in the first trigger; The second variable control includes a variable type control and a variable creation control; the step of responding to a temporary variable creation instruction for the second variable control and creating a new first temporary variable in the first trigger includes: responding to a selection instruction for the variable type control and determining a target variable type; and responding to a trigger instruction for the variable creation control and creating a new first temporary variable of the target variable type in the first trigger.

2. The method according to claim 1, characterized in that, The programming graph of the first trigger includes a first variable control; the step of responding to a temporary variable triggering instruction and displaying the temporary variable of the second trigger includes: In response to the temporary variable trigger command for the first variable control, the temporary variable of the second trigger is displayed.

3. The method according to claim 1, characterized in that, The step of setting the first temporary variable in the first trigger according to the second temporary variable includes: In the first trigger, a first temporary variable with the same variable type and name as the second temporary variable is set.

4. The method according to claim 1, characterized in that, During the game's runtime phase, the method further includes: Register the first temporary variable, and determine the value of the first temporary variable based on the value of the second temporary variable.

5. The method according to claim 4, characterized in that, Registering the first temporary variable and determining the value of the first temporary variable based on the value of the second temporary variable includes: At the first moment of registering the first trigger, the first temporary variable is registered, and the initial value of the first temporary variable is determined based on the value of the second temporary variable at the first moment.

6. The method according to claim 1, characterized in that, The method further includes: When a first temporary variable is set in the first trigger according to the second temporary variable, an inheritance identifier is displayed in the programming graph of the first temporary variable; the inheritance identifier indicates that the first temporary variable inherits information from the temporary variable of the parent trigger of the first trigger.

7. The method according to claim 1, characterized in that, The second trigger includes a second condition and a second instruction, the second trigger being configured to execute the second instruction in response to triggering the second condition; the second instruction includes registering the first trigger.

8. The method according to claim 1, characterized in that, The method further includes: If the response adds the first programming pattern from the third trigger to the first trigger, and the third temporary variable included in the first programming pattern is the same as the second temporary variable, then the third temporary variable is merged with the first temporary variable determined according to the second temporary variable; the third trigger and the second trigger are independent of each other.

9. The method according to claim 8, characterized in that, The step of merging the third temporary variable with the first temporary variable determined based on the second temporary variable includes: The first temporary variable overwrites the third temporary variable.

10. The method according to claim 1, characterized in that, The method further includes: The response separates the second programming pattern in the first trigger from the first trigger, and determines the fourth temporary variable in the fourth trigger based on the first temporary variable included in the second programming pattern; the fourth trigger is the trigger to which the second programming pattern belongs after it is separated from the first trigger.

11. The method according to claim 1, characterized in that, The first trigger includes a first condition and a first instruction; the response triggers the first trigger, and executes the game logic corresponding to the first trigger according to the relevant variables of the first trigger, including: In response to the first condition being triggered, the first temporary variable is registered, and the first instruction is executed based on the relevant variables including the first temporary variable.

12. The method according to claim 1, characterized in that, The method further includes: After the game logic corresponding to the first trigger is executed, the first temporary variable is cleared.

13. The method according to claim 12, characterized in that, After clearing the first temporary variable, the method further includes: In response to the next triggering of the first trigger, the first temporary variable is re-registered, and the game logic corresponding to the first trigger is executed according to the relevant variables of the first trigger.

14. The method according to claim 1, characterized in that, The process of displaying a graphical programming interface in the graphical user interface during the game editing stage includes: During the game editing stage, the game editing scene corresponding to the target game map is displayed in the graphical user interface; In response to programming trigger commands in the game editing scene, the graphical programming interface is displayed.

15. The method according to claim 14, characterized in that, During the game execution phase, in response to the triggering of the first trigger, the game logic corresponding to the first trigger is executed according to the relevant variables of the first trigger, including: During the game's execution phase, the game scene corresponding to the target game map is displayed in the graphical user interface; The response triggers the first trigger in the game running scenario, and executes the game logic corresponding to the first trigger according to the relevant variables of the first trigger.

16. The method according to claim 1, characterized in that, The method further includes at least one of the following steps: In response to a third editing command in the graphical programming interface, a global variable is set; the global variable is configured to apply to all triggers. In response to a fourth edit command in the graphical programming interface for the first trigger group, a local variable is set in the first trigger group; the first trigger group includes one or more independent triggers; the local variable is configured to apply only to the triggers in the first trigger group.

17. A game editing device, characterized in that, The device includes: A graphical programming interface display module is configured to display a graphical programming interface in a graphical user interface during the game editing stage; the graphical programming interface provides at least one programming graphical control, which is configured to generate a corresponding programming graphic in the graphical programming interface in response to a first editing command; A variable setting module is configured to, in response to a second editing instruction for a first trigger in the graphical programming interface, set a first temporary variable in the first trigger; the first trigger consists of one or more programming graphics; the first temporary variable is configured to be effective only for the first trigger; The trigger execution module is configured to respond to the trigger during the game running phase, and execute the game logic corresponding to the first trigger based on the relevant variables of the first trigger; the relevant variables of the first trigger include the first temporary variable. The second editing instruction includes a temporary variable triggering instruction and a temporary variable selection instruction; the response to the second editing instruction for the first trigger in the graphical programming interface, setting a first temporary variable in the first trigger, includes: responding to the temporary variable triggering instruction and displaying the temporary variable of the second trigger; the first trigger is a sub-trigger of the second trigger; responding to the temporary variable selection instruction and determining a second temporary variable from the temporary variables of the second trigger, and setting the first temporary variable in the first trigger according to the second temporary variable; the first temporary variable uses at least a portion of the information of the second temporary variable; Alternatively, the second editing instruction includes a temporary variable triggering instruction and a temporary variable creation instruction; the response to the second editing instruction for the first trigger in the graphical programming interface, setting a first temporary variable in the first trigger, includes: responding to the temporary variable triggering instruction and displaying a second variable control; responding to the temporary variable creation instruction for the second variable control and creating a new first temporary variable in the first trigger; The second variable control includes a variable type control and a variable creation control; the step of responding to a temporary variable creation instruction for the second variable control and creating a new first temporary variable in the first trigger includes: responding to a selection instruction for the variable type control and determining a target variable type; and responding to a trigger instruction for the variable creation control and creating a new first temporary variable of the target variable type in the first trigger.

18. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the method according to any one of claims 1 to 16.

19. An electronic device, characterized in that, include: processor; Memory for storing the executable instructions of the processor; The processor is configured to execute the method of any one of claims 1 to 16 by executing the executable instructions.

Images