CN111905372B

CN111905372B - Game trigger creation method, game running method and device

Info

Publication number: CN111905372B
Application number: CN202010821306.9A
Authority: CN
Inventors: 张华雄
Original assignee: Netease Hangzhou Network Co Ltd
Current assignee: Netease Hangzhou Network Co Ltd
Priority date: 2020-08-14
Filing date: 2020-08-14
Publication date: 2023-11-24
Anticipated expiration: 2040-08-14
Also published as: CN111905372A

Abstract

The present application relates to the field of game technologies, and in particular, to a method for creating a game trigger, a method for running a game, and a device for running the game. The method for creating the game trigger is applied to the mobile terminal, responds to the triggering operation of creating the dynamic trigger on the editing interface of the static trigger, creates a first dynamic trigger under the static trigger based on the identification and the instance content of the dynamic trigger input by a user, calls the instance content of the created first dynamic trigger according to the identification of the first dynamic trigger, and creates a second dynamic trigger under the static trigger based on the called instance content. Based on the above manner, through customizing the identification of the local variable type in the process of creating the first dynamic trigger and assigning the instance content of the first dynamic trigger to the local variable, the first dynamic trigger can be accurately invoked, and the efficiency of editing game logic of a user can be improved.

Description

Game trigger creation method, game running method and device

Technical Field

The present application relates to the field of game technologies, and in particular, to a method for creating a game trigger, a method for running a game, and a device for running the game.

Background

The game editor is a tool capable of making games, and has a lower upper threshold than a game engine, and can cover a wider user plane. In game editors, a game logic creation tool, i.e., a visual script, is typically configured for customizing game logic, and the visual script is typically presented in the form of a trigger.

In contrast to units, triggers are a more complex object, and such complex object is limited by the man-machine interaction mode of the visual script, so that the current visual script does not provide a method for acquiring the complex object, and thus, it is difficult for a user to perform additional operations on the created instance content after the complex object is created.

Disclosure of Invention

In view of this, the embodiments of the present application at least provide a method for creating a game trigger, a method for running a game, and a device thereof, which can accurately call a first dynamic trigger, and can improve the efficiency of editing game logic for a user.

The application mainly comprises the following aspects:

in a first aspect, an embodiment of the present application provides a method for creating a game trigger, which is applied to a mobile terminal, where the method includes:

Responding to the triggering operation of creating a dynamic trigger on an editing interface of a static trigger, and creating a first dynamic trigger under the static trigger based on the identification and the instance content of the dynamic trigger input by a user on the editing interface;

and responding to the triggering operation of calling the first dynamic trigger input by a user on the editing interface, calling the created instance content of the first dynamic trigger according to the identification of the first dynamic trigger, and creating a second dynamic trigger under the static trigger based on the called instance content.

In one possible implementation manner, if the triggering operation of creating the dynamic trigger is a triggering operation of creating a key corresponding to the action; the response creates a triggering operation of a dynamic trigger on an editing interface of a static trigger, and creates a first dynamic trigger under the static trigger based on an identification and instance content of the dynamic trigger input by a user on the editing interface, comprising:

responding to the triggering operation of a key corresponding to the creation action on the editing interface of the static trigger, and jumping to an action setting interface;

responding to the selection operation of the action type corresponding to the creation of the dynamic trigger on the action setting interface, and creating the first dynamic trigger without instance content based on the identification of the dynamic trigger input by the user on the action setting interface;

Based on instance content of the first dynamic trigger entered by a user on the editing interface, the first dynamic trigger under the static trigger is created to contain instance content.

In one possible implementation, the instance content includes events, conditions, and actions; generating the instance content according to the following steps:

responding to the triggering operation of the identification of the dynamic trigger input by a user on the editing interface, and generating event nodes, condition nodes and action nodes of the first dynamic trigger on the editing interface;

and adding events, conditions and actions to the first dynamic trigger in response to editing operations aiming at the event node, the condition node and the action node, and generating instance content of the first dynamic trigger.

In one possible implementation manner, the responding to the editing operation of the event node, the condition node and the action node adds an event, a condition and an action to the first dynamic trigger, and generates instance content of the first dynamic trigger, which includes:

and responding to editing operations aiming at the event node, the condition node and the action node, generating event sub-nodes corresponding to each event in the event node, generating condition sub-nodes corresponding to each condition in the condition node and generating action sub-nodes corresponding to each action in the action node.

In a possible implementation manner, the event child node comprises event type, specific event and event description of the event; the condition child node comprises a condition type, a specific condition and a condition description of the condition; the action child node comprises action types, specific actions and action descriptions of actions.

In one possible implementation manner, if the triggering operation of creating the dynamic trigger is a triggering operation of creating a key corresponding to the function; the response creates a triggering operation of a dynamic trigger on an editing interface of a static trigger, and creates a first dynamic trigger under the static trigger based on an identification and instance content of the dynamic trigger input by a user on the editing interface, comprising:

responding to the triggering operation of creating a key corresponding to a function on an editing interface of the static trigger, and generating a function node for creating the first dynamic trigger which does not contain instance content on the editing interface based on the identification of the dynamic trigger input by a user on an action setting interface;

creating the first dynamic trigger containing instance content under the static trigger based on the instance content of the first dynamic trigger input by a user through a function node of the editing interface.

In one possible implementation, the creating the first dynamic trigger containing instance content under the static trigger based on the instance content of the first dynamic trigger input by a user through a function node of the editing interface includes:

responding to clicking operation aiming at the function node, and jumping to a configuration interface of the first dynamic trigger; the configuration interface comprises an event array, a condition array and an action array;

in response to an add operation for the event array, the condition array, the action array, adding an event within the event array, adding a condition within the condition array, and adding an action within the action array.

In one possible embodiment, the creating method further includes:

in response to a removal operation for the event array, the condition array, the action array, removing an event within the event array, removing a condition within the condition array, and removing an action within the action array.

In a second aspect, an embodiment of the present application further provides a game running method, applied to a mobile terminal, where the game running method includes:

When an event corresponding to a static trigger is detected to be triggered in the game running process, executing a first action corresponding to the static trigger;

upon detecting that the first action is performed, initiating a dynamic trigger associated with the first action;

and executing a second action corresponding to the dynamic trigger when the event corresponding to the dynamic trigger is detected to be triggered.

In a third aspect, an embodiment of the present application further provides a device for creating a game trigger, which is applied to a mobile terminal, where the calling device includes:

the first creating module is used for responding to the triggering operation of creating the dynamic trigger on the editing interface of the static trigger and creating a first dynamic trigger under the static trigger based on the identification and the instance content of the dynamic trigger input by a user on the editing interface;

and the second creating module is used for responding to the triggering operation of calling the first dynamic trigger input by a user on the editing interface, calling the created instance content of the first dynamic trigger according to the identification of the first dynamic trigger, and creating a second dynamic trigger under the static trigger based on the called instance content.

In one possible implementation manner, if the triggering operation of creating the dynamic trigger is a triggering operation of creating a key corresponding to the action; the first creation module includes:

the jump unit is used for responding to the trigger operation of the key corresponding to the creation action on the editing interface of the static trigger and jumping to the action setting interface;

the first creating unit is used for responding to the selection operation of the action type corresponding to the creation of the dynamic trigger on the action setting interface and creating the first dynamic trigger without instance content based on the identification of the dynamic trigger input by the user on the action setting interface;

and the second creating unit is used for creating the first dynamic trigger containing instance contents under the static trigger based on the instance contents of the first dynamic trigger input by a user on the editing interface.

In one possible implementation, the instance content includes events, conditions, and actions; the first creation module is further configured to generate the instance content according to the following steps:

In a possible implementation manner, the first creating module is specifically configured to generate the instance content of the first dynamic trigger according to the following steps:

In one possible implementation manner, if the triggering operation of creating the dynamic trigger is a triggering operation of creating a key corresponding to the function; the first creation module includes:

A third creating unit, configured to respond to a triggering operation of creating a key corresponding to a function on an editing interface of the static trigger, and generate, on the editing interface, a function node for creating the first dynamic trigger that does not include instance content based on an identifier of the dynamic trigger input by a user on an action setting interface;

and a fourth creating unit, configured to create, based on the instance content of the first dynamic trigger input by the user through the function node of the editing interface, the first dynamic trigger containing the instance content under the static trigger.

In a possible implementation manner, the fourth creating unit is configured to create the first dynamic trigger according to the following steps:

In a possible implementation manner, the fourth creating unit is further configured to:

In a fourth aspect, an embodiment of the present application further provides a game running device, applied to a mobile terminal, where the game running device includes:

the first control module is used for executing a first action corresponding to the static trigger when detecting that an event corresponding to the static trigger is triggered in the game running process;

a starting module, configured to, when detecting that the first action is performed, start a dynamic trigger associated with the first action;

and the second control module is used for executing a second action corresponding to the dynamic trigger when detecting that the event corresponding to the dynamic trigger is triggered.

In a fifth aspect, an embodiment of the present application further provides an electronic device, including: a processor, a memory and a bus, the memory storing machine readable instructions executable by the processor, the processor and the memory communicating via the bus when the electronic device is running, the machine readable instructions when executed by the processor performing the method of creating a game trigger as described in the first aspect or any of the possible implementations of the first aspect, or performing the steps of the method of game play as described in the second aspect.

In a sixth aspect, an embodiment of the present application further provides a computer readable storage medium, where a computer program is stored, where the computer program is executed by a processor to perform the method for creating a game trigger as described in the first aspect or any possible implementation manner of the first aspect, or perform the steps of the method for executing a game as described in the second aspect.

According to the method for creating the game trigger, the local variable is customized in the process of creating the first dynamic trigger, and the first dynamic trigger is assigned to the identification of the local variable type, so that compared with the situation that the created dynamic trigger instance cannot be operated in subsequent editing in the prior art, the first dynamic trigger can be accurately invoked, and further the second dynamic trigger is created based on the created trigger instance, and the efficiency of editing game logic of a user can be improved.

Further, in the game running method provided by the embodiment of the application, when the event corresponding to the static trigger is detected to be triggered in the game running process, the first action corresponding to the static trigger is executed,

When the first action is detected to be executed, a dynamic trigger associated with the first action is started, and when an event corresponding to the dynamic trigger is detected to be triggered, a second action corresponding to the dynamic trigger is executed. In this way, during the game running process, the game logic corresponding to the dynamic trigger can be accurately executed.

In order to make the above objects, features and advantages of the present application more comprehensible, preferred embodiments accompanied with figures are described in detail below.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are needed in the embodiments will be briefly described below, it being understood that the following drawings only illustrate some embodiments of the present application and therefore should not be considered as limiting the scope, and other related drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.

FIG. 1 is a flow chart of a method for creating a game trigger according to an embodiment of the present application;

FIG. 2 shows a schematic diagram of an action setup interface;

FIG. 3 shows a schematic diagram of an editing interface for a static trigger;

FIG. 4 shows a schematic diagram of another action setup interface;

FIG. 5 shows a schematic diagram of a configuration interface;

FIG. 6 is a flow chart of a game play method provided by an embodiment of the present application;

FIG. 7 shows a schematic diagram of yet another action setup interface;

FIG. 8 is a schematic diagram of a game trigger creation apparatus according to an embodiment of the present application;

FIG. 9 is a schematic diagram showing a structure of a game running apparatus according to an embodiment of the present application;

fig. 10 shows a schematic structural diagram of an electronic device according to an embodiment of the present application.

Detailed Description

For the purpose of making the objects, technical solutions and advantages of the embodiments of the present application more apparent, the technical solutions of the embodiments of the present application will be clearly and completely described with reference to the accompanying drawings in the embodiments of the present application, and it should be understood that the drawings in the present application are for the purpose of illustration and description only and are not intended to limit the scope of the present application. In addition, it should be understood that the schematic drawings are not drawn to scale. A flowchart, as used in this disclosure, illustrates operations implemented according to some embodiments of the present application. It should be appreciated that the operations of the flow diagrams may be implemented out of order and that steps without logical context may be performed in reverse order or concurrently. Moreover, one or more other operations may be added to or removed from the flow diagrams by those skilled in the art under the direction of the present disclosure.

In addition, the described embodiments are only some, but not all, embodiments of the application. The components of the embodiments of the present application generally described and illustrated in the figures herein may be arranged and designed in a wide variety of different configurations. Thus, the following detailed description of the embodiments of the application, as presented in the figures, is not intended to limit the scope of the application, as claimed, but is merely representative of selected embodiments of the application. All other embodiments, which can be made by a person skilled in the art based on embodiments of the application without making any inventive effort, fall within the scope of the application.

In order to enable those skilled in the art to make and use the present disclosure, the following embodiments are provided in connection with a particular application scenario "creation of a game trigger", and it will be apparent to those skilled in the art that the general principles defined herein may be applied to other embodiments and application scenarios without departing from the spirit and scope of the present disclosure.

The method, the device, the electronic equipment or the computer readable storage medium can be applied to any scene requiring to create the game trigger, the embodiment of the application does not limit the specific application scene, and any scheme using the method, the game running method and the device for creating the game trigger provided by the embodiment of the application is within the protection scope of the application.

It is noted that before the present application proposes, the trigger is a more complex object than the unit, and the complex object is limited by the man-machine interaction manner of the visual script, so the current visual script does not provide a method for acquiring the complex object, and thus it is difficult for a user to perform additional operations on the created instance content after the complex object is created.

In response to the above problem, the embodiment of the application creates a triggering operation of a dynamic trigger on an editing interface of the static trigger, creates a first dynamic trigger under the static trigger based on the identification and the instance content of the dynamic trigger input by a user, calls the instance content of the created first dynamic trigger according to the identification of the first dynamic trigger, and creates a second dynamic trigger under the static trigger based on the called instance content. Based on the above manner, through customizing the identification of the local variable type in the process of creating the first dynamic trigger and assigning the instance content of the first dynamic trigger to the local variable, the first dynamic trigger can be accurately invoked, and the efficiency of editing game logic of a user can be improved.

In order to facilitate understanding of the present application, the following detailed description of the technical solution provided by the present application is provided in connection with specific embodiments.

Fig. 1 is a flowchart of a method for creating a game trigger according to an embodiment of the present application. As shown in fig. 1, the method for creating a game trigger provided by the embodiment of the application is applied to a mobile terminal, and includes the following steps:

s101: and responding to the triggering operation of creating the dynamic trigger on the editing interface of the static trigger, and creating a first dynamic trigger under the static trigger based on the identification and the instance content of the dynamic trigger input by a user on the editing interface.

In a specific implementation, the creation of the dynamic trigger depends on the static trigger, so after the static trigger is established, a user can trigger a trigger operation of creating the dynamic trigger on an editing interface of the static trigger, and create a first dynamic trigger under the static trigger according to the identification and the instance content of the dynamic trigger input by the user on the editing interface so as to complete the creation of the first dynamic trigger. Here, the triggering operation of creating the dynamic trigger may be the triggering operation of the key corresponding to the creating action, that is, the creating of the dynamic trigger is implemented through the action key, and the triggering operation of creating the dynamic trigger may also be the triggering operation of the key corresponding to the creating function, that is, the creating of the dynamic trigger is implemented through the function.

It should be noted that, the triggers are used to manage game rules, game logic, game flows, and the like, and game play methods of map copies can be highly customized, and each map includes any number of triggers. Here, the triggers are classified into static triggers and dynamic triggers, the static triggers being created at the time of game initialization. During game play, triggers are typically created at map initialization, so events are typically registered at map initialization. However, situations are sometimes encountered in which it is necessary to register an event at the time of non-game initialization. For example, a unit is created during the game play and a listening event of "arbitrary unit enters its range" is registered for this unit, in which case a function of dynamically creating a trigger is required, i.e., the dynamic trigger is created during the game play.

Here, each trigger consists of an identification of the trigger and instance content, where the identification corresponding to the dynamic trigger is a local variable, where the parameters of the local variable use the value of the variable, rather than a reference to the variable; example content includes events, conditions, and actions.

It should be noted that, during game running, when an event corresponding to a static trigger triggers, a trigger copy (trigger version) is created, each trigger copy evaluates a condition and is executed independently, local variables are independent from each other in each trigger copy, the same-name local variables in each trigger copy do not affect each other, the local variables perform snapshot when the trigger is created, and the parameters of the local variables use the values of the variables instead of the references of the variables. For example, in the case of setting a "unit" local-unit=canine_1 ", the" arbitrary unit "in the event enters a circular range with a radius of 10.0 around the (local-unit), the" local-unit "in the event plays dead, the play rate is 1.0 times of the original action, and the standby action is returned after the play is completed. In order to complete the assignment process after the dynamic trigger is created, a variable name is added in the action of creating the trigger, namely, the identification of the dynamic trigger, and a user must input a variable name when editing the action, so that after the dynamic trigger is created, the instance content of the dynamic trigger is assigned to a local variable, and because the local variable originally has a mechanism for recording the trigger version, namely, the local variable can record the version information of the trigger copy triggered by the static trigger, the dynamic trigger can be accurately invoked under the concurrent condition.

Here, multiple disparate dynamic triggers may be created under one static trigger, and some dynamic triggers with the same instance content may be created.

Here, a description will be given of a process of creating a static trigger, specifically, a user operates a mobile terminal to enter a game mode editing interface, clicks a "trigger" button on the game mode editing interface, can enter a static trigger creation interface, and creates a static trigger by clicking a "new" button in the creation interface.

Further, the triggering operation of creating the dynamic trigger may be in various manners, the first manner being: the triggering operation of creating the dynamic trigger can be the triggering operation of the key corresponding to the creating action, namely, the creating of the dynamic trigger is realized through the action key; the second mode is as follows: the triggering operation of creating the dynamic trigger can also be the triggering operation of the key corresponding to the creation function, namely, the creation of the dynamic trigger is realized through the function.

Here, the first mode is described, if the triggering operation of creating the dynamic trigger is the triggering operation of the key corresponding to the creating action; in step S101, the triggering operation of creating a dynamic trigger on the editing interface of the static trigger in response to the user input on the editing interface, and creating a first dynamic trigger under the static trigger based on the identification and the instance content of the dynamic trigger, including the following steps:

Step a1: and responding to the triggering operation of the key corresponding to the creation action on the editing interface of the static trigger, and jumping to the action setting interface.

Step a2: responding to the selection operation of the action type corresponding to the creation of the dynamic trigger on the action setting interface, and creating the first dynamic trigger without instance content based on the identification of the dynamic trigger input by the user on the action setting interface;

step a3: based on instance content of the first dynamic trigger entered by a user on the editing interface, the first dynamic trigger under the static trigger is created to contain instance content.

In a specific implementation, in the process of creating the first dynamic trigger, firstly, a user needs to click a key corresponding to a creation action on an editing interface of the static trigger, jump to an action setting interface, finish preliminary creation of the first dynamic trigger on the action setting interface, fig. 2 is a schematic diagram of the action setting interface, as shown in fig. 2, on the action setting interface, the user needs to select an action type as the trigger, select a specific action as the trigger creation and assign a specific action, here, multiple action types and specific actions can be selected by the user, when the user clicks an area corresponding to the action type or the specific action, contents corresponding to the action type or contents corresponding to the specific action can be displayed in a list, after the selection is finished, an action description is automatically generated on the action setting interface, the action description is the trigger creation, and assigns a content of a user-defined variable name (first dynamic trigger name) to a local variable name (dynamic trigger name) in the action setting interface, and the user can manually input the content of the user-defined variable name (dynamic trigger name) on the static trigger setting interface, namely, when the user can display the static trigger is the static trigger on the editing interface, the dynamic trigger is free of the dynamic trigger is displayed on the first trigger editing interface, and the dynamic trigger is displayed on the first trigger editing interface after the dynamic trigger is finished, the dynamic trigger is edited.

Note that the content on the underline in fig. 2, 3, 4, 5, and 7 is the content that needs to be filled by the user, and for this reason, the content of the underline is not additionally marked and described.

Here, a trigger is a complex object that performs a series of actions when a condition is met after some event has been triggered. And creating a trigger, which is one of actions executable by the trigger, wherein the action in the created trigger refers to the action which is executed when the created trigger instance is triggered by an event. According to the method and the device, the problem that the complex object is difficult to assign after being created in the visual script can be solved by setting the local variable (the identifier of the first dynamic trigger) for the first dynamic trigger, and the user can acquire the instance content of the created object through the variable in the subsequent action node only by editing one variable name, so that the efficiency of editing game logic of the user can be improved.

FIG. 3 is a schematic diagram of an editing interface of a static trigger after a first dynamic trigger is created, as shown in FIG. 3, the static trigger is trigger 1, an event (arbitrary unit) enters a monster_1 as a center, a circular range with a radius of 30.0 is an event corresponding to the trigger 1, an action (system prompt is sent to the player 1), and a display 111 is an action corresponding to the trigger 1); under the action, "create trigger, and assign the trigger in the local variable (local-trigger)" as the first dynamic trigger, where "trigger" is the variable name of the local variable, i.e. the identifier of the first dynamic trigger, and the event, condition, and action under the first dynamic trigger are the content corresponding to the first dynamic trigger. After game logic is edited, a game is started, when the game is run, if an event corresponding to the trigger 1 is triggered, an action corresponding to the trigger 1 is executed, after the action corresponding to the trigger 1 is executed, a first dynamic trigger is generated, and when the event of the first dynamic trigger is triggered, the action corresponding to the first dynamic trigger is executed.

It should be noted that, some components such as buttons, scroll bars, selection boxes, input boxes, drop-down list boxes and the like may be included in the graphical user interface, where the editing interface and the action setting interface are both image user interfaces.

Further, the instance content includes events, conditions, and actions; generating the instance content according to the following steps: responding to the triggering operation of the identification of the dynamic trigger input by a user on the editing interface, and generating event nodes, condition nodes and action nodes of the first dynamic trigger on the editing interface; and adding events, conditions and actions to the first dynamic trigger in response to editing operations aiming at the event node, the condition node and the action node, and generating instance content of the first dynamic trigger.

In a specific implementation, a user can manually input a user-defined variable name (identification of a first dynamic trigger), after the user inputs the identification of the dynamic trigger in the action description, the user jumps back to the editing interface of the static trigger, at this time, the first dynamic trigger without instance content is displayed on the editing interface of the static trigger, that is, the instance content of the first dynamic trigger displayed on the editing interface is empty, event nodes, condition nodes and action nodes of the first dynamic trigger are generated on the editing interface, no content exists in the nodes, and the user can edit the event nodes, the condition nodes and the action nodes of the first dynamic trigger according to actual needs, so that events, conditions and actions are added for the first dynamic trigger, that is, after the user edits the instance content (event, condition and action) on the editing interface of the static trigger, the creation of the first dynamic trigger containing the instance content under the static trigger is completed.

As shown in fig. 3, the event corresponding to the first dynamic trigger is "2.0 seconds elapsed during the game time", the first dynamic trigger is a set condition, the action corresponding to the first dynamic trigger is "send a system prompt to the player 1, 2 seconds elapsed during the display time", and when the game time reaches 2 seconds during the game running, that is, when the event corresponding to the first dynamic trigger is triggered, the action corresponding to the first dynamic trigger is executed, that is, 2 seconds elapsed during the display time.

It should be noted that, a trigger includes an event, a condition, and an action, where the event is used to determine when the trigger is executed; whether a trigger execution condition is added or not can be selected, and trigger action can be executed when an event is triggered only when the condition is met; a list of actions to be performed when an event triggers, a condition is established. Here, the event determines when the current trigger will be executed, in general cases, an event needs to be added to the trigger to ensure the execution of the trigger, after the event is added to the trigger, one or more conditions may be optionally added to the trigger, or no condition may be optionally added, after the event is triggered, the trigger will execute the action list only when all conditions are met, if no condition is added to the trigger, the action list will be executed immediately after the event is triggered, if any condition needs to be met to execute the actions, these conditions need to be added to "or", when the event is triggered and the conditions are met, the trigger will sequentially execute all actions from top to bottom, most of the actions are executed immediately and completed, and the next action will be executed after the actions are completed, so that the action list is continuously executed in the execution process: "execute, complete, execute …".

Further, the following describes the process of adding events, conditions and actions to the first dynamic trigger, specifically, generating instance content of the first dynamic trigger in response to editing operations for the event node, the condition node and the action node, including:

The event child node comprises event types, specific events and event descriptions of the events; the condition child node comprises a condition type, a specific condition and a condition description of the condition; the action child node comprises action types, specific actions and action descriptions of actions.

In specific implementation, the trigger is a complex object, the editing of the node cannot be completed through simple parameter transmission, and the user must edit the event node, the condition node and the action node of the trigger object to be created in the form of child nodes, wherein the event child nodes comprise event types, specific events and event descriptions of the event; the condition child node comprises a condition type, a specific condition and a condition description of the condition; the action child node comprises action types, specific actions and action descriptions of actions. The editing process for the first dynamic trigger is as follows, the user needs to click the plus button on the right side of the 3 options of event, all conditions are established, action, and add the event, condition and action for the newly built first dynamic trigger. For example, to create the trigger shown in fig. 3, an event for monitoring the game time needs to be added first, the event is "2.0 seconds elapsed during the game time", the event adding process is to select a plus button on the right of "event" on the editing interface, enter the event setting interface, select the event type as time, the specific event is a time-one time timer, and the time describes that the game time is 2.0 seconds elapsed, wherein the time "2.0" needs to be filled by the user; the action is "display time elapsed 2.0 seconds", the action is added by selecting the plus button on the right of "action" on the editing interface, entering the action setting interface, selecting the action type to be display, specifically the action is display-system prompt, the action is described as player 1 sending system prompt, display time elapsed 2.0 seconds, wherein the display content "time elapsed 2.0 seconds", and "player 1" needs user filling.

Here, the second mode is described, if the triggering operation of creating the dynamic trigger is the triggering operation of the key corresponding to the creation function; in step S101, the triggering operation of creating a dynamic trigger on the editing interface of the static trigger in response to the user input on the editing interface, and creating a first dynamic trigger under the static trigger based on the identification and the instance content of the dynamic trigger, including the following steps:

step b1: and responding to the triggering operation of creating a key corresponding to a function on an editing interface of the static trigger, and generating a function node for creating the first dynamic trigger which does not contain instance content on the editing interface based on the identification of the dynamic trigger input by a user on an action setting interface.

Step b2: creating the first dynamic trigger containing instance content under the static trigger based on the instance content of the first dynamic trigger input by a user through a function node of the editing interface.

In particular implementations, a function node is invoked that returns a trigger instance, the function of which is to create a trigger and return the created trigger instance to enable creation of the first dynamic trigger.

Here, a function node of the first dynamic trigger is created such as:

fx [ trigger ] local-trigger = create 1 event as an event array, condition as a condition array, action as a trigger for an action array.

Further, after the first dynamic trigger is created, editing operation needs to be performed on the created first dynamic trigger, specifically, the creating, based on the instance content of the first dynamic trigger input by the user through the function node of the editing interface, the first dynamic trigger containing instance content under the static trigger includes:

In a specific implementation, in the process that the user uses the function node, the created trigger is defined in a form of directly inputting an array, as shown in fig. 5 below, the configuration interface comprises an event array, a condition array and an action array, the user receives the return value of the function node through a local variable, so that a complex trigger can be created, assignment of the first dynamic trigger is completed, and then the local variable is called through the variable name of the local variable, so that the first dynamic trigger is called.

Here, the process of editing the event array, the condition array and the action array is described, the event array in fig. 5 is clicked, the event setting interface is entered, the user can select the event type as a variable, select a specific event as an array variable adding object, and the event is described as adding an event a at the end of the event array, wherein the event a is the content added by the user; clicking the condition array in fig. 5, entering a condition setting interface, wherein a user can select a condition type as a variable, select a specific condition to add an object to the variable of the condition array, and the condition is described as adding a condition B at the end of the condition array, wherein the condition B is content added by the user; clicking on the action array in fig. 5, entering the action setting interface, the user may select the action type as a variable, select a specific action to add an object to the array variable, and the action is described as adding an action C at the end of the action array, where "action C is the content added by the user".

Further, the removing operation may be performed on the events in the event array, the conditions in the condition array, and the actions of the action array, specifically, removing the events in the event array, removing the conditions in the condition array, and removing the actions in the action array in response to the removing operation for the event array, the condition array, and the action array. Here, the event may be removed at the event setting interface, the condition may be removed at the condition setting interface, and the action may be removed at the action setting interface.

Here, the trigger is complex because when we define a trigger in a man-machine interaction manner through the visual script, we have to define the event, condition and action of the trigger in the form of child nodes, in order to solve the problem that it is difficult to complete assignment in the node editing manner after the complex object is created, it is also possible to use to define the corresponding parameters of the child nodes in the parent node directly in the form of an array.

S102: and responding to the triggering operation of calling the first dynamic trigger input by a user on the editing interface, calling the created instance content of the first dynamic trigger according to the identification of the first dynamic trigger, and creating a second dynamic trigger under the static trigger based on the called instance content.

In a specific implementation, when the user wants to reuse part of the instance content in the first dynamic trigger, the user can directly perform the reading operation of the identifier of the first dynamic trigger through the action setting interface, and further, create a second dynamic trigger under the static trigger by using the instance content of the first dynamic trigger, where the second dynamic trigger is a trigger with modified instance content of the first dynamic trigger, and the modified content includes, but is not limited to, modification of an event, a condition, and an action.

As shown in fig. 3, "disregard event and condition direct action of running trigger (local trigger)" is by identifying "local trigger" call to the first dynamic trigger created above. Fig. 4 is a schematic diagram of an action setting interface, through which a call to a first dynamic trigger is completed, for example, the call is completed, that is, the setting of "no-view event and condition direct operation trigger (local-trigger)" is completed, an action type selection trigger, a specific action selection operation trigger, and an identification of the first dynamic trigger to be called, that is, a target name of a local variable corresponding to the first dynamic trigger, for example, a trigger, is filled in an action description.

In one example, a call to a local variable using the target name, such as "direct close trigger".

It should be noted that, the creation scenario of the game trigger provided by the application is suitable for a game player to create a static trigger by using a game editor, and want to create a first dynamic trigger under the static trigger, and call the instance content of the created first dynamic trigger, so as to create another second dynamic trigger by using the instance content of the newly created first dynamic trigger, so that direct call of the dynamic trigger instance by the variable name of the local variable can be realized, repeated editing of the dynamic trigger is not needed for many times, the efficiency of editing game logic of a user can be improved, and the local variable has version information of the trigger version of the static trigger, so that the action of each dynamic trigger can be ensured to be accurately executed under the condition of large concurrency, and the dynamic triggers under different trigger versions can be operated independently without mutual influence.

In the embodiment of the application, the triggering operation of the dynamic trigger is created on the editing interface of the static trigger, the first dynamic trigger under the static trigger is created based on the identification and the instance content of the dynamic trigger input by a user, the instance content of the created first dynamic trigger is called according to the identification of the first dynamic trigger, and the second dynamic trigger under the static trigger is created based on the called instance content. Based on the above manner, through customizing the identification of the local variable type in the process of creating the first dynamic trigger and assigning the instance content of the first dynamic trigger to the local variable, the first dynamic trigger can be accurately invoked, and the efficiency of editing game logic of a user can be improved.

Fig. 6 is a flowchart of a game running method according to an embodiment of the present application. As shown in fig. 6, the game running method provided by the embodiment of the application is applied to a mobile terminal, and comprises the following steps:

s601: and executing a first action corresponding to the static trigger when the event corresponding to the static trigger is detected to be triggered in the game running process.

In a specific implementation, after editing game logic, a user clicks a saved work to run a game, and in the process of running the game, if an event corresponding to a static trigger is detected to be triggered, the static trigger is triggered, and a first action corresponding to the static trigger is executed, where a first virtual unit in the static trigger can be controlled to execute the first action.

S602: upon detecting that the first action is performed, a dynamic trigger associated with the first action is initiated.

In a specific implementation, if the game logic is executed when the game logic edits the first action, the dynamic trigger associated with the first action is started, where execution of the first action may be understood as an event of starting the dynamic trigger, and further, during the game running, when the first action is detected to be executed, the dynamic trigger associated with the first action is started.

S603: and executing a second action corresponding to the dynamic trigger when the event corresponding to the dynamic trigger is detected to be triggered.

In particular, during game running, if the dynamic trigger is started, when an event corresponding to the dynamic trigger is detected to be triggered, a second action corresponding to the dynamic trigger is executed, where the dynamic trigger may be called for multiple times during game logic editing, and therefore, each time the event of the called dynamic trigger is detected to be triggered, the action corresponding to the dynamic trigger is executed.

In one example, fig. 7 shows an editing interface of the trigger 1, the trigger 1 is a static trigger, the trigger (local-trigger) is a dynamic trigger, the trigger (local-a) is a dynamic trigger, when the arbitrary unit is detected to enter the circular range of the radius of the monster_1 as the center, if the arbitrary unit is detected to enter the monster_1 during game operation, the trigger 1 is triggered, the action of sending a system prompt to the player 1 is executed, the display 111 is displayed, after the display 111 is detected, the trigger (local-trigger) is generated, and when the dog_1 is detected to enter the circular range of the radius of the monster_1 as the center, the trigger (local-trigger) is triggered, the physical injury of 999999 points is caused to the monster_1 is executed, at this time, the trigger (local-trigger) is turned off, and when the dog_1 is detected to enter the circular range of the radius of the monster_1 as the center, the local-trigger is turned on again (local-trigger) of 20.0.

It should be noted that, during game running, each time the static trigger is triggered, trigger copies (trigger versions) are generated, each trigger copy may be independently run without influence, for example, an event of the static trigger is "arbitrary unit" entering the map area, when 2 units of unit_0 and unit_1 enter the map area at the same time, the 2 units trigger the event, so 2 independent trigger copies are created, the 2 copies respectively correspond to the trigger copies of unit_0 and unit_1, which are independently executed and do not influence each other, the dynamic trigger under the static trigger assigns a variable name of a local variable to the dynamic trigger, and assigns an instance of the dynamic trigger to the local variable.

Based on the same application conception, the embodiment of the application also provides a device for creating the game trigger corresponding to the method for creating the game trigger provided by the embodiment, and because the principle of solving the problem by the device in the embodiment of the application is similar to that of creating the game trigger of the embodiment of the application, the implementation of the device can refer to the implementation of the method, and the repetition is omitted.

Fig. 8 is a schematic structural diagram of a game trigger creation apparatus 800 according to an embodiment of the present application, where, as shown in fig. 8, the game trigger creation apparatus 800 includes:

a first creating module 810, configured to respond to a triggering operation of creating a dynamic trigger on an editing interface of a static trigger, and create a first dynamic trigger under the static trigger based on an identifier and instance content of the dynamic trigger input by a user on the editing interface;

and the second creating module 820 is configured to respond to a triggering operation of calling the first dynamic trigger input by a user on the editing interface, call the created instance content of the first dynamic trigger according to the identifier of the first dynamic trigger, and create a second dynamic trigger under the static trigger based on the called instance content.

In one possible implementation manner, if the triggering operation of creating the dynamic trigger is a triggering operation of creating a key corresponding to the action; the first creation module 810 includes:

a jump unit 811, configured to jump to the action setting interface in response to a triggering operation of a key corresponding to the creation of an action on the editing interface of the static trigger;

a first creating unit 812, configured to respond to a selection operation on the action setting interface for creating an action type corresponding to a dynamic trigger, and create the first dynamic trigger without instance content based on an identifier of the dynamic trigger input by a user on the action setting interface;

the second creating unit 813 is configured to create the first dynamic trigger containing instance contents under the static trigger based on the instance contents of the first dynamic trigger input by the user on the editing interface.

In one possible implementation, the instance content includes events, conditions, and actions; the first creation module 810 is further configured to generate the instance content according to the following steps:

In a possible implementation manner, the first creating module 810 is specifically configured to generate the instance content of the first dynamic trigger according to the following steps:

In one possible implementation manner, if the triggering operation of creating the dynamic trigger is a triggering operation of creating a key corresponding to the function; the first creation module 810 includes:

A third creating unit 814, configured to respond to a triggering operation of creating a key corresponding to a function on an editing interface of the static trigger, and generate, on the editing interface, a function node for creating the first dynamic trigger that does not include instance content, based on an identification of the dynamic trigger input by a user on an action setting interface;

a fourth creating unit 815, configured to create, based on the instance content of the first dynamic trigger input by the user through the function node of the editing interface, the first dynamic trigger including the instance content under the static trigger.

In a possible implementation manner, the fourth creating unit 815 is configured to create the first dynamic trigger according to the following steps:

In a possible implementation manner, the fourth creating unit 815 is further configured to:

Based on the same application conception, the embodiment of the application also provides a game running device corresponding to the game running method provided by the embodiment, and because the principle of solving the problem of the device in the embodiment of the application is similar to that of the game running method of the embodiment of the application, the implementation of the device can be referred to the implementation of the method, and the repetition is omitted.

Fig. 9 shows a schematic structural diagram of a game running device 900 according to an embodiment of the present application, and as shown in fig. 9, the game running device 900 includes:

a first control module 910, configured to execute a first action corresponding to a static trigger when an event corresponding to the static trigger is detected to be triggered during a game running process;

a starting module 920, configured to, when it is detected that the first action is performed, start a dynamic trigger associated with the first action;

and a second control module 930, configured to execute a second action corresponding to the dynamic trigger when detecting that the event corresponding to the dynamic trigger is triggered.

Based on the same application concept, referring to fig. 10, a schematic structural diagram of an electronic device 1000 according to an embodiment of the present application includes: a processor 1100, a memory 1200 and a bus 1300, said memory 1200 storing machine readable instructions executable by said processor 1100, said processor 1100 and said memory 1200 communicating via said bus 1300 when the electronic device 1000 is running, said machine readable instructions being executed by said processor 1100 to perform the steps of the method of creating a game trigger as described in any of the above embodiments or to perform the steps of the method of game play as described in any of the above embodiments.

In particular, the machine readable instructions, when executed by the processor 1100, may perform the following:

Based on the same application concept, the embodiment of the present application further provides a computer readable storage medium, on which a computer program is stored, which when executed by a processor, performs the steps of the method for creating a game trigger provided in the above embodiment, or performs the steps of the method for executing a game provided in the above embodiment.

Specifically, the storage medium can be a general storage medium, such as a mobile disk, a hard disk, and the like, when a computer program on the storage medium is executed, the method for creating the game trigger or the method for executing the game can be executed, and the first dynamic trigger can be accurately invoked by customizing the identification of the type of the local variable in the process of creating the first dynamic trigger and assigning the instance content of the first dynamic trigger to the local variable, so that the efficiency of editing game logic of a user can be improved.

It will be clear to those skilled in the art that, for convenience and brevity of description, specific working procedures of the above-described system and apparatus may refer to corresponding procedures in the foregoing method embodiments, which are not described herein again. In the several embodiments provided in the present application, it should be understood that the disclosed system, apparatus and method may be implemented in other manners. The above-described apparatus embodiments are merely illustrative, for example, the division of the units is merely a logical function division, and there may be other manners of division in actual implementation, and for example, multiple units or components may be combined or integrated into another system, or some features may be omitted, or not performed. Alternatively, the coupling or direct coupling or communication connection shown or discussed with each other may be through some communication interface, device or unit indirect coupling or communication connection, which may be in electrical, mechanical or other form.

The units described as separate units may or may not be physically separate, and units shown as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

In addition, each functional unit in the embodiments of the present application may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit.

The functions, if implemented in the form of software functional units and sold or used as a stand-alone product, may be stored in a non-volatile computer readable storage medium executable by a processor. Based on this understanding, the technical solution of the present application may be embodied essentially or in a part contributing to the prior art or in a part of the technical solution in the form of a software product stored in a storage medium, comprising several instructions for causing a computer device (which may be a personal computer, a server, a network device, etc.) to perform all or part of the steps of the method according to the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a random access Memory (Random Access Memory, RAM), a magnetic disk, or an optical disk, or other various media capable of storing program codes.

The foregoing is merely illustrative of the present application, and the present application is not limited thereto, and any person skilled in the art will readily appreciate variations or alternatives within the scope of the present application. Therefore, the protection scope of the application is subject to the protection scope of the claims.

Claims

1. A method for creating a game trigger, applied to a mobile terminal, the method comprising:

2. The method according to claim 1, wherein if the trigger operation of creating the dynamic trigger is a trigger operation of a key corresponding to the creation action; the response creates a triggering operation of a dynamic trigger on an editing interface of a static trigger, and creates a first dynamic trigger under the static trigger based on an identification and instance content of the dynamic trigger input by a user on the editing interface, comprising:

3. The creation method according to claim 2, wherein the instance content includes events, conditions, and actions; generating the instance content according to the following steps:

4. A method of creating as claimed in claim 3, wherein said generating instance content of said first dynamic trigger in response to an edit operation for said event node, said condition node, said action node by adding events, conditions and actions to said first dynamic trigger comprises:

5. The creation method according to claim 4, wherein the event child node includes event type, specific event, event description of event; the condition child node comprises a condition type, a specific condition and a condition description of the condition; the action child node comprises action types, specific actions and action descriptions of actions.

6. The method according to claim 1, wherein if the trigger operation of creating the dynamic trigger is a trigger operation of a key corresponding to the creation function; the response creates a triggering operation of a dynamic trigger on an editing interface of a static trigger, and creates a first dynamic trigger under the static trigger based on an identification and instance content of the dynamic trigger input by a user on the editing interface, comprising:

7. The creation method according to claim 6, wherein the creating the first dynamic trigger containing instance contents under the static trigger based on the instance contents of the first dynamic trigger input by a user through a function node of the editing interface comprises:

8. The creation method according to claim 7, characterized in that the creation method further comprises:

9. A game play method, applied to a mobile terminal, comprising:

upon detecting that the first action is performed, initiating a dynamic trigger associated with the first action; the dynamic trigger is created by the method for creating a game trigger according to any one of claims 1 to 8;

10. A creation apparatus of a game trigger, applied to a mobile terminal, comprising:

11. A game play apparatus, applied to a mobile terminal, comprising:

a starting module, configured to, when detecting that the first action is performed, start a dynamic trigger associated with the first action; the dynamic trigger is a dynamic trigger created by the game trigger creation device according to claim 10;

12. An electronic device, comprising: a processor, a memory and a bus, said memory storing machine readable instructions executable by said processor, said processor and said memory communicating via said bus when the electronic device is running, said machine readable instructions when executed by said processor performing the method of creating a game trigger according to any one of claims 1 to 8 or the steps of the method of game execution according to claim 9.

13. A computer-readable storage medium, on which a computer program is stored which, when being executed by a processor, performs the method of creating a game trigger according to any one of claims 1 to 8, or performs the steps of the game play method according to claim 9.