CN112090079A - Game task running method and device, computer equipment and storage medium - Google Patents
Game task running method and device, computer equipment and storage medium Download PDFInfo
- Publication number
- CN112090079A CN112090079A CN202010879751.0A CN202010879751A CN112090079A CN 112090079 A CN112090079 A CN 112090079A CN 202010879751 A CN202010879751 A CN 202010879751A CN 112090079 A CN112090079 A CN 112090079A
- Authority
- CN
- China
- Prior art keywords
- task
- game
- node
- template
- player
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- A—HUMAN NECESSITIES
- A63—SPORTS; GAMES; AMUSEMENTS
- A63F—CARD, BOARD, OR ROULETTE GAMES; INDOOR GAMES USING SMALL MOVING PLAYING BODIES; VIDEO GAMES; GAMES NOT OTHERWISE PROVIDED FOR
- A63F13/00—Video games, i.e. games using an electronically generated display having two or more dimensions
- A63F13/60—Generating or modifying game content before or while executing the game program, e.g. authoring tools specially adapted for game development or game-integrated level editor
Landscapes
- Engineering & Computer Science (AREA)
- Multimedia (AREA)
- Stored Programmes (AREA)
Abstract
The application relates to a game task running method and device, computer equipment and a storage medium. The method comprises the following steps: when a game starting instruction is triggered, detecting whether a task instance of a game task is created or not according to a task identifier of the game task needing to be run in a game; monitoring a trigger event of a running instruction of the game task when a task instance of the game task is created; when the running instruction of the game task is triggered by a game player, task data currently held by the game player in the game task is acquired from a data cache region according to the player identification of the game player; and running the created task instance according to the task data to obtain a game task running result corresponding to the game player. By adopting the method, the data volume redundancy of the task instance can be reduced, and the game running efficiency is improved.
Description
Technical Field
The present application relates to the field of computer technologies, and in particular, to a method and an apparatus for running a game task, a computer device, and a storage medium.
Background
With the development of computer technology, game software development technology is developed, and game projects can be developed by using the game software development technology, in the game projects, various tasks are set for the characters controlled by players in order to improve interestingness, and the types and the number of the tasks are rapidly increased along with version iteration, so that various task types are rapidly and conveniently increased as a key problem to be solved by developers.
And the types of the tasks are increased, the required created objects are increased, each task needs to create a plurality of task instances for the same task because of different game players, if the players A and B have the same task, one task instance is created for each of the players A and B, and when the game runs, the players respectively detect and execute the corresponding task instances to calculate the task execution progress.
Therefore, the same mission can be created repeatedly for each player, and the amount of mission instance data is redundant, resulting in inefficient game execution.
Disclosure of Invention
In view of the above, it is necessary to provide a game task execution method, device, computer device, and storage medium capable of improving game execution efficiency.
A game task execution method, the method comprising:
when a game starting instruction is triggered, detecting whether a task instance of a game task is created or not according to a task identifier of the game task needing to be run in a game;
monitoring a trigger event of a running instruction of the game task when a task instance of the game task is created;
when the running instruction of the game task is triggered by a game player, task data currently held by the game player in the game task is acquired from a data cache region according to the player identification of the game player;
and running the created task instance according to the task data to obtain a game task running result corresponding to the game player.
A game task execution apparatus, the apparatus comprising:
the task instance detection module is used for detecting whether a task instance of a game task is created or not according to a task identifier of the game task needing to be run in the game when a game starting instruction is triggered;
the event monitoring module is used for monitoring a trigger event of an operation instruction of the game task when a task instance of the game task is created;
the task data acquisition module is used for acquiring task data currently held by a game player in the game task from a data cache region according to a player identifier of the game player when an operation instruction of the game task is triggered by the game player;
and the running module is used for running the created task instance according to the task data to obtain a game task running result corresponding to the game player.
A computer device comprising a memory storing a computer program and a processor implementing the steps of the method when executing the computer program.
A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the steps of the method.
According to the game task running method, the game task running device, the computer equipment and the storage medium, when a game starting instruction is triggered, whether a task instance of a game task is created or not is detected according to a task identifier of the game task needing to be run in a game; monitoring a trigger event of a running instruction of the game task when a task instance of the game task is created; when the running instruction of the game task is triggered by a game player, task data currently held by the game player in the game task is acquired from a data cache region according to the player identification of the game player; the created task instances are operated according to the task data, and the game task operation result corresponding to the game player is obtained, so that the game task operation result is obtained without creating the task instances for each game player triggering the execution instruction of the game task, the data volume redundancy of the task instances is reduced, and the game operation efficiency is improved.
Drawings
FIG. 1 is a diagram of an application environment for a method of executing a game task according to an embodiment;
FIG. 2 is a schematic flow chart diagram illustrating a method for executing a game task according to one embodiment;
FIG. 3 is a diagram illustrating a process for constructing a game task class in a method for executing a game task according to an embodiment;
FIG. 4 is a game task logic diagram that constructs a game task class in one embodiment;
FIG. 5 is a block diagram that illustrates serializing a resource package for a game task in one embodiment;
FIG. 6 is a framework diagram that illustrates the construction of a game task to the execution of a game task in one embodiment;
FIG. 7 is an interface diagram of an assembly game task in one embodiment;
FIG. 8 is an interface diagram that illustrates a list of task node template names in the task resource editor, according to an embodiment;
FIG. 9 is a diagram of a task instance runtime framework in one embodiment;
FIG. 10 is a block diagram showing the construction of a game task execution device according to an embodiment;
FIG. 11 is a diagram illustrating an internal structure of a computer device in one embodiment.
Detailed Description
In order to make the objects, technical solutions and advantages of the present application more apparent, the present application is described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the present application and are not intended to limit the present application.
The game task running method provided by the application can be applied to the application environment shown in FIG. 1. Wherein the terminal 102 communicates with the server 104 via a network. When a game player triggers a game starting instruction of the server 104 through the terminal 102, the server 104 detects whether a task instance of a game task is created according to a task identifier of the game task needing to be run in a game; monitoring a trigger event of a running instruction of the game task when a task instance of the game task is created; when the running instruction of the game task is triggered by a game player, task data currently held by the game player in the game task is acquired from the data cache region according to the player identification of the game player; and running the created task instance according to the task data to obtain a game task running result corresponding to the game player.
The game task running method provided by the application can also be applied to the terminal 102, when a game player triggers a game starting instruction through the terminal 102, whether a task instance of a game task is established or not is detected according to a task identifier of the game task needing to be run in a game, and when the task instance of the game task is established, a triggering event of the running instruction of the game task is monitored; when the running instruction of the game task is triggered by a game player, task data currently held by the game player in the game task is acquired from the data cache region according to the player identification of the game player; and running the created task instance according to the task data to obtain a game task running result corresponding to the game player.
The terminal 102 may be, but not limited to, various personal computers, notebook computers, smart phone tablet computers, and portable wearable devices, and the server 104 may be implemented by an independent server or a server cluster formed by a plurality of servers.
In one embodiment, as shown in fig. 2, a game task execution method is provided, which is described by taking the method as an example applied to the server in fig. 1, and includes the following steps:
step S220, when the game start instruction is triggered, detecting whether a task instance of the game task is created according to a task identifier of the game task that needs to be executed in the game.
The game starting instruction is an instruction triggered by the terminal when the game player starts the game, and comprises the following steps: the game player opens the game APP to enter a game home page, selects a game mode, and triggers a game starting instruction to enter the game when clicking starts. The game tasks to be run in the game are tasks that can be executed by the game player in the game process, and corresponding rewards can be obtained after the game tasks are completed, such as: eliminating 10 players in map X results in 1000 coins. The task identifier is information for identifying a game task, such as: a number of game tasks, a game task name, etc. A task instance is an object after a game task class of a game task is instantiated. Through the task identification, the created task instances can be identified, and whether the task instances of the game task corresponding to the task identification exist in the created task instances is determined.
In step S240, when the task instance of the game task has been created, a trigger event of the execution instruction of the game task is monitored.
The task instance of the created game task may be a task instance of a game task that needs to be executed in the created game when the game start instruction is first triggered. When a game player triggering a game starting instruction firstly instantiates a game task class of a game task needing to be run in a game, creates a task instance of the game task, and appoints a storage area as task data stored in the game task by the game player. The execution instruction of the game task is an instruction for controlling the task manager of the server to execute a task instance of the game task. The trigger event for monitoring the execution instructions of the game task may be a listening by an event manager in the server, assuming: and when the game player is in the game, the elimination of the player in the map X can trigger the running instruction of the game mission.
Step S260, when the running instruction of the game mission is triggered by the game player, the mission data currently held by the game player in the game mission is obtained from the data buffer area according to the player identification of the game player.
The game player is a user who participates in the game, plays a controllable role in the game world, operates the characters to complete the game or has a target determined by the user. Player identification is information that identifies a game player in the game world, such as: player nicknames, game account numbers, and the like. The data buffer is a storage area for storing task data held by the game player in the game task. The mission data is data such as the completion of a mission when a game player performs the game mission, for example: collecting the number of gold coins, the number of killing monsters and the like.
Step S280, the created task instance is operated according to the task data, and a game task operation result corresponding to the game player is obtained.
And the game task running result is an interface for displaying the game task execution condition of the game player after the task instance is run according to the task data.
In the game task running method, when a game starting instruction is triggered, whether a task instance of a game task is created or not is detected according to a task identifier of the game task needing to be run in a game; monitoring a trigger event of a running instruction of the game task when a task instance of the game task is created; when the running instruction of the game task is triggered by a game player, task data currently held by the game player in the game task is acquired from a data cache region according to the player identification of the game player; the created task instances are operated according to the task data, and the game task operation result corresponding to the game player is obtained, so that the game task operation result is obtained without creating the task instances for each game player triggering the execution instruction of the game task, the data volume redundancy of the task instances is reduced, and the game operation efficiency is improved.
In one embodiment, the game task execution method further includes: when the task instance of the game task is not created, acquiring a corresponding game task class according to the task identifier; instantiating a game task class, creating a task instance of a game task, and distributing a data cache region; and adding a task blackboard of the game player in the data buffer area, and recording task data of the game player.
The game task class is a game task program formed by each task node class or/and task condition class in the game task. Instantiation refers to the process of creating an object with a class in object-oriented programming, referred to as instantiation. The data buffer area is a storage area for storing task data held by each game player in the game task, and when a new game player executes the game task, a task blackboard is added in the data buffer area and is a data blackboard used for recording the task data of the game player. Each game player executing the game task corresponds to one task blackboard, and the task blackboard of each game player is used for recording task data of each game player. The task data of the game player is recorded through the task blackboard, the task manager of the server sequentially obtains the task data held by the game player when receiving the running instruction of the game task, and the task instance logic is run.
In one embodiment, referring to fig. 3, the game task class of the game task is constructed by the following steps:
step S420, the node icon of each task node template is obtained and displayed in the task resource editor.
The task node template is a class template in which each task condition class or execution node class in the game task is atomized, and is an independent class with moderate node logic function granularity. Such as: the number of gold coins acquired by the player is more than 100, wherein the data comparison function with the numerical value 100 can be abstracted as an atomization operation, if data comparison logic appears in other tasks, the data can be directly multiplexed, and the compared numerical value can be changed. The class of execution nodes may be a C + + class or a blueprint class. The node icon is an icon for representing the task node template in the presentation interface of the task resource editor. The task resource editor is an editor for game development in a game Engine, such as a fantasy 4 game Engine (Unreal Engine 4).
In one embodiment, the obtaining of the node icon of each task node template and displaying in the task resource editor includes: acquiring a node identifier carried in the instruction according to the task node template, and searching the task node template from a game engine database; when a task node template exists in a game engine database, acquiring a node icon of the task node template and displaying the node icon in a task resource editor; when the task node template does not exist in the game engine database, creating the task node template according to the function of the task node template; and the node icon of the acquired task node template is displayed in the task resource editor.
The node identifier is information for marking a task node template, such as: the task node template number, the task node template name and the like. The game engine database is a database in the game engine for storing task node templates. The task node template creating step may be to newly write a task node template according to the function of the task node template, and set a node identifier and a node icon for the task node template. Shown below is the code logic of a task node template written for an atomic class of execution nodes:
in one embodiment, after the step of creating the task node template according to the function of the task node template, the method further includes: and adding the created task node template into a game engine database.
And when the task node template with the same function is needed next time, the task node template can be directly obtained from the game engine database.
Step S440, according to the displayed node icon of each task node template, defining the task parameters and the inter-node association parameters of each task node template.
According to the displayed node icons of the task node templates, developers can operate the node icons through the terminal, and set task parameters and node correlation parameters of the task node templates. The task parameters are task condition classes corresponding to the task node templates or parameter values required for executing the execution node classes, such as: the task node template with the data comparison function needs to be set with a specific comparison value. The inter-node association parameters are parameters for defining association relationships among task node templates, such as: and the task node template A and the task node template B are in a front-back relationship, namely the task node template B is executed after the task node template A is executed, and the like.
In one embodiment, defining task parameters and inter-node association parameters of each task node template according to displayed node icons of each task node template includes: triggering a task node template editing instruction carrying a node identifier according to the displayed node icon of each task node template; displaying a parameter panel of the task node template according to the node identification; and defining task parameters and inter-node association parameters of the task node template based on the data input by the parameter panel.
The method comprises the steps that a developer clicks or selects a node icon of a task parameter and/or an inter-node correlation parameter needing to define a task node template according to a node icon of each task node template displayed in a task resource editor of a terminal, and a task node template editing instruction carrying a node identifier is triggered. And acquiring a parameter panel corresponding to the task node template according to the node identification, wherein a user can select a certain parameter in the parameter panel or input the parameter in the input field, and the data input by the parameter panel can be the parameter selected in the parameter panel and/or the parameter input in the input field. The task parameters defining the task node template and the inter-node association parameters defining the task node template may have a parameter panel respectively, such as: when the developer defines the task parameters of the task node template, the triggered task node template editing instruction is used for defining the task parameters, and when the developer defines the inter-node association parameters of the task node template, the triggered task node template editing instruction is used for defining the inter-node association parameters.
And step S460, performing logic association on the node icons of the task node templates according to the association parameters among the nodes to obtain a game task logic diagram.
The game task logic diagram can visually see the association relationship among the task node templates, such as the game task logic diagram shown in fig. 4, and whether the task node template of the teammate, the task node template compared with the distance of other people and the task node template in the designated time after landing are in the and relationship.
In one embodiment, after the step of performing logical association on the node icons of each task node template according to the inter-node association parameters to obtain the game task logical graph, the method further includes: when a debugging instruction is received, debugging and running are carried out according to the execution logic of the game task logic diagram; displaying the execution state in the running window according to the execution state of the task node corresponding to each node icon; obtaining debugging data according to operation, marking the node icons with problems, and displaying the debugging data and the marked node icons with problems; and adjusting the task node template corresponding to the marked node icon.
During the debugging operation process, the incidence relation among one or more node icons can be disconnected, and the debugging data of the debugging operation can be checked. The executing logic of the game task logic diagram is debugged and operated in the task resource editor, and the node icon with the problem is marked and can be used for quickly positioning the problem. And displaying the node icons of the problems of the execution state, the debugging data and the mark, and improving the debugging efficiency in the development period.
And step S480, serializing according to the task parameters of the task node templates and the game task logic diagram to obtain a game task resource package of the game task class.
The serialization is a process of converting task parameters of each task node template, each node identifier, and logic association of each task node template and each node identifier into a form capable of being stored or transmitted. The game task resource package comprises data such as task parameters of each task node template, each node identifier, logic association of each task node template and each node identifier and the like. The task instance of the game task can be obtained by instantiating the data in the game task resource package.
In one embodiment, serializing according to task parameters of each task node template and a game task logic diagram to obtain a game task resource package of a game task class, including: acquiring node identifications corresponding to node icons according to the game task logic diagram; determining the logic association of each node identifier according to the logic association of each node icon; and packaging the task parameters of each task node template, each node identifier, each task node template and the logic association of each node identifier to obtain a game task resource package of a game task class.
In the framework of obtaining a game task resource package of a game task class in a serialized manner as shown in fig. 5, a task resource editor includes task resource editor data and data required during operation to form a task resource, and when a game task resource package is packaged, the task resource editor data shown in fig. 5 is not packaged, as follows: node icon data, caption, etc., only packaging data needed at runtime, as shown in FIG. 5: according to an iterative storage main flow tree and two iterative storage sub-trees formed by the task node templates, task parameters of the task node templates and other data, the task resource editor organizes the flow tree to obtain data required in running and packages the data to obtain a game task resource package of a game task class. By only packaging the data required by the runtime to execute under the actual runtime environment, the task resource editor data is only used during development, which can save the actual version space.
Different task types are assembled by directly selecting task condition classes and/or task node templates of execution node classes required in game tasks from the task resource editor, the node reusability is high, the repeated development amount is greatly reduced, new tasks can be efficiently and quickly made, the development efficiency is greatly submitted, and the method has good portability and can be applied to different UE4 game projects in a portable mode.
In one embodiment, when a game task identical to a task execution flow in a game task logic diagram needs to be developed, the game task logic diagram is obtained through a task derivation instruction and displayed, and task parameters of each task node template are modified based on the displayed game task logic diagram.
The method comprises the steps that a base class task resource is selected in a task resource editor of a developer, after loading, a flow chart cannot be modified, only task parameters can be edited, only differentiated data is stored during storage, a task instance is created through the base class task resource during creation of the task instance, and the difference parameters are modified to serve as a derived task instance. The method can greatly reduce the repeated development amount, can efficiently and quickly make new tasks, greatly submits the development efficiency, has better portability, and can be transplanted and applied to different UE4 game items.
The present application further provides a scenario in which a game task is edited by a task resource editor in an editor (UE4 editor) of the illusion 4 game engine (i.e., as shown in fig. 6, an offline behavior is formed, a game task is assembled by task node templates corresponding to a plurality of task condition classes or execution node classes, and the edited game task is serialized into a game task resource package, as shown in fig. 6, an online behavior is formed, as shown in fig. 6, a trigger event is monitored by an event manager of the server, and when a game player triggers a running instruction to run the game task, a task manager in the game module of the server runs a task execution stream included in a task instance of the game task, where the scenario application is specifically implemented as follows:
a developer opens a task resource editor by double clicking through a newly-built task resource of an illusion 4 game engine to assemble a game task, as shown in fig. 7, an interface for assembling the game task in the task resource editor is used, node icons of task node templates are displayed in the task resource editor, when the task parameter of each task node template needs to be defined, the task node template is selected, when the task node template which is compared with the distance of other people is selected, a parameter panel of the task node template which is compared with the distance of other people is displayed on the right side of the interface, and the developer can input corresponding parameter values. When a task node template needs to be added, a developer can click right in a task resource editor to display a list of selectable task node template names as shown in fig. 8, select a task node template needing to be added in the list, add the task node template into the task resource editor to display, trigger a task node template editing instruction for defining association parameters between nodes according to execution logic between the added task node template and the task node template of the task resource editor already displayed, and connect the added task node template with the task node template in the task resource editor already displayed. After the game tasks are assembled in the task resource editor, the game tasks are serialized into game task resource packages which are used as game task classes needed when the game tasks are run in the server.
When a game player enters a game and triggers a game starting instruction, detecting whether a task instance of a game task is created or not according to a task identifier of the game task needing to be run in the game; when a task instance of a game task is created, an event manager of the server monitors a trigger event of an operation instruction of the game task, and when it is monitored that the operation instruction of the game task is triggered by a game player, as shown in a task instance operation frame diagram of fig. 9, the task manager determines a task blackboard corresponding to the game player from a data cache region according to a player identifier, acquires task data recorded in the current task blackboard, and operates the created task instance to acquire a game task operation result corresponding to the game player.
Different task types are assembled by directly selecting task condition classes and/or task node templates of execution node classes required in game tasks from the task resource editor, the node reusability is high, the repeated development amount is greatly reduced, new tasks can be efficiently and quickly made, the development efficiency is greatly submitted, and the method has good portability and can be applied to different UE4 game projects in a portable mode. Only one task instance exists in the same game task, and the task data and the task execution logic are separated through the task blackboard, so that repeated creation of the same task is reduced, and data redundancy is reduced.
It should be understood that although the various steps in the flow charts of fig. 2-3 are shown in order as indicated by the arrows, the steps are not necessarily performed in order as indicated by the arrows. The steps are not performed in the exact order shown and described, and may be performed in other orders, unless explicitly stated otherwise. Moreover, at least some of the steps in fig. 2-3 may include multiple steps or multiple stages, which are not necessarily performed at the same time, but may be performed at different times, which are not necessarily performed in sequence, but may be performed in turn or alternately with other steps or at least some of the other steps.
In one embodiment, as shown in fig. 10, there is provided a game task execution apparatus, which may be a part of a computer device using a software module or a hardware module, or a combination of the two, and specifically includes: a task instance detection module 310, an event listening module 320, a task data acquisition module 330, and an execution module 340, wherein:
the task instance detection module 310 is configured to detect whether a task instance of a game task is created according to a task identifier of a game task that needs to be executed in a game when a game start instruction is triggered;
the event monitoring module 320 is configured to monitor a trigger event of an execution instruction of the game task when a task instance of the game task is created;
the task data obtaining module 330 is configured to, when the running instruction of the game task is triggered by the game player, obtain task data currently held by the game player in the game task from the data cache area according to the player identifier of the game player;
and the running module 340 is configured to run the created task instance according to the task data to obtain a game task running result corresponding to the game player.
In one embodiment, the game task execution device further includes: the instantiation module is used for acquiring a corresponding game task class according to the task identifier when the task instance of the game task is not created; instantiating a game task class, creating a task instance of a game task, and distributing a data cache region; and adding a task blackboard of the game player in the data buffer area, and recording task data of the game player.
In one embodiment, the game task execution device further includes: the game task construction module is used for acquiring node icons of each task node template and displaying the node icons in the task resource editor; defining task parameters and inter-node association parameters of each task node template according to the displayed node icon of each task node template; carrying out logic association on node icons of each task node template according to the association parameters among the nodes to obtain a game task logic diagram; and serializing according to the task parameters of each task node template and the game task logic diagram to obtain a game task resource package of the game task class.
In one embodiment, the game task construction module is further configured to: triggering a task node template editing instruction carrying a node identifier according to the displayed node icon of each task node template; displaying a parameter panel of the task node template according to the node identification; and defining task parameters and inter-node association parameters of the task node template based on the data input by the parameter panel.
In one embodiment, the game task construction module is further configured to: acquiring a node identifier carried in the instruction according to the task node template, and searching the task node template from a game engine database; when a task node template exists in a game engine database, acquiring a node icon of the task node template and displaying the node icon in a task resource editor; when the task node template does not exist in the game engine database, creating the task node template according to the function of the task node template; and the node icon of the acquired task node template is displayed in the task resource editor.
In one embodiment, the game task construction module is further configured to: and adding the created task node template into a game engine database.
In one embodiment, the game task construction module is further configured to: acquiring node identifications corresponding to node icons according to the game task logic diagram; determining the logic association of each node identifier according to the logic association of each node icon; and packaging the task parameters of each task node template, each node identifier, each task node template and the logic association of each node identifier to obtain a game task resource package of a game task class.
For the specific definition of the game task execution device, reference may be made to the above definition of the game task execution method, which is not described herein again. The respective modules in the above game task execution apparatus may be wholly or partially implemented by software, hardware, and a combination thereof. The modules can be embedded in a hardware form or independent from a processor in the computer device, and can also be stored in a memory in the computer device in a software form, so that the processor can call and execute operations corresponding to the modules.
In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as shown in fig. 11. The computer device includes a processor, a memory, and a network interface connected by a system bus. Wherein the processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device comprises a nonvolatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program, and a database. The internal memory provides an environment for the operation of an operating system and computer programs in the non-volatile storage medium. The database of the computer device is used for storing task data. The network interface of the computer device is used for communicating with an external terminal through a network connection. The computer program is executed by a processor to implement a game task execution method.
Those skilled in the art will appreciate that the architecture shown in fig. 11 is merely a block diagram of some of the structures associated with the disclosed aspects and is not intended to limit the computing devices to which the disclosed aspects apply, as particular computing devices may include more or less components than those shown, or may combine certain components, or have a different arrangement of components.
In one embodiment, a computer device is further provided, which includes a memory and a processor, the memory stores a computer program, and the processor implements the steps of the above method embodiments when executing the computer program.
In an embodiment, a computer-readable storage medium is provided, in which a computer program is stored which, when being executed by a processor, carries out the steps of the above-mentioned method embodiments.
In one embodiment, a computer program product or computer program is provided that includes computer instructions stored in a computer-readable storage medium. The computer instructions are read by a processor of a computer device from a computer-readable storage medium, and the computer instructions are executed by the processor to cause the computer device to perform the steps in the above-mentioned method embodiments.
It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by hardware instructions of a computer program, which can be stored in a non-volatile computer-readable storage medium, and when executed, can include the processes of the embodiments of the methods described above. Any reference to memory, storage, database or other medium used in the embodiments provided herein can include at least one of non-volatile and volatile memory. Non-volatile Memory may include Read-Only Memory (ROM), magnetic tape, floppy disk, flash Memory, optical storage, or the like. Volatile Memory can include Random Access Memory (RAM) or external cache Memory. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM), for example.
The technical features of the above embodiments can be arbitrarily combined, and for the sake of brevity, all possible combinations of the technical features in the above embodiments are not described, but should be considered as the scope of the present specification as long as there is no contradiction between the combinations of the technical features.
The above-mentioned embodiments only express several embodiments of the present application, and the description thereof is more specific and detailed, but not construed as limiting the scope of the invention. It should be noted that, for a person skilled in the art, several variations and modifications can be made without departing from the concept of the present application, which falls within the scope of protection of the present application. Therefore, the protection scope of the present patent shall be subject to the appended claims.
Claims (10)
1. A method of game task execution, the method comprising:
when a game starting instruction is triggered, detecting whether a task instance of a game task is created or not according to a task identifier of the game task needing to be run in a game;
monitoring a trigger event of a running instruction of the game task when a task instance of the game task is created;
when the running instruction of the game task is triggered by a game player, task data currently held by the game player in the game task is acquired from a data cache region according to the player identification of the game player;
and running the created task instance according to the task data to obtain a game task running result corresponding to the game player.
2. The method of claim 1, further comprising:
when the task instance of the game task is not created, acquiring a corresponding game task class according to the task identifier;
instantiating the game task class, creating a task instance of the game task, and distributing a data cache region;
and adding a task blackboard of the game player in the data buffer area, and recording task data of the game player.
3. The method of claim 2, wherein the game task class of the game task is constructed in a manner that includes:
acquiring node icons of each task node template and displaying the node icons in a task resource editor;
defining task parameters and inter-node association parameters of each task node template according to the displayed node icon of each task node template;
performing logic association on the node icons of the task node templates according to the inter-node association parameters to obtain a game task logic diagram;
and serializing according to the task parameters of the task node templates and the game task logic diagram to obtain a game task resource package of a game task class.
4. The method according to claim 3, wherein the defining task parameters and inter-node association parameters of each task node template according to the displayed node icon of each task node template comprises:
triggering a task node template editing instruction carrying a node identifier according to the displayed node icon of each task node template;
displaying a parameter panel of the task node template according to the node identification;
and defining the task parameters and the inter-node association parameters of the task node template based on the data input by the parameter panel.
5. The method according to claim 3, wherein the obtaining of the node icon of each task node template is displayed in a task resource editor, and comprises:
acquiring a node identifier carried in the instruction according to the task node template, and searching the task node template from a game engine database;
when the task node template exists in the game engine database, acquiring a node icon of the task node template and displaying the node icon in a task resource editor;
when the task node template does not exist in the game engine database, creating the task node template according to the function of the task node template;
and acquiring the node icon of the task node template and displaying the node icon in a task resource editor.
6. The method of claim 5, wherein the step of creating the task node template according to the function of the task node template is further followed by:
and adding the created task node template into the game engine database.
7. The method of claim 3, wherein the serializing according to the task parameters of each task node template and the game task logic diagram to obtain the game task resource package of the game task class comprises:
acquiring a node identifier corresponding to each node icon according to the game task logic diagram;
determining the logic association of each node identifier according to the logic association of each node icon;
and packaging the task parameters of each task node template, each node identifier, each task node template and the logic association of each node identifier to obtain a game task resource package of a game task class.
8. A game task execution apparatus, characterized in that the apparatus comprises:
the task instance detection module is used for detecting whether a task instance of a game task is created or not according to a task identifier of the game task needing to be run in the game when a game starting instruction is triggered;
the event monitoring module is used for monitoring a trigger event of an operation instruction of the game task when a task instance of the game task is created;
the task data acquisition module is used for acquiring task data currently held by a game player in the game task from a data cache region according to a player identifier of the game player when an operation instruction of the game task is triggered by the game player;
and the running module is used for running the created task instance according to the task data to obtain a game task running result corresponding to the game player.
9. A computer device comprising a memory and a processor, the memory storing a computer program, characterized in that the processor, when executing the computer program, implements the steps of the method of any of claims 1 to 7.
10. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the steps of the method according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010879751.0A CN112090079B (en) | 2020-08-27 | 2020-08-27 | Game task running method and device, computer equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010879751.0A CN112090079B (en) | 2020-08-27 | 2020-08-27 | Game task running method and device, computer equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112090079A true CN112090079A (en) | 2020-12-18 |
| CN112090079B CN112090079B (en) | 2022-05-06 |
Family
ID=73758041
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010879751.0A Active CN112090079B (en) | 2020-08-27 | 2020-08-27 | Game task running method and device, computer equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112090079B (en) |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112604284A (en) * | 2020-12-29 | 2021-04-06 | 北京冰封互娱科技有限公司 | Task execution method, device and equipment of game and computer readable storage medium |
| CN113413588A (en) * | 2021-06-16 | 2021-09-21 | 网易（杭州）网络有限公司 | Game task processing method and device, electronic equipment and storage medium |
| CN113797542A (en) * | 2021-09-29 | 2021-12-17 | 上海完美时空软件有限公司 | Method and device for generating task data, storage medium and electronic device |
| CN113836011A (en) * | 2021-09-16 | 2021-12-24 | 网易（杭州）网络有限公司 | Task list processing method and device, storage medium and electronic equipment |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105719126A (en) * | 2016-01-22 | 2016-06-29 | 上海晶赞科技发展有限公司 | System and method for internet big data task scheduling based on life cycle model |
| US20190046882A1 (en) * | 2013-04-15 | 2019-02-14 | Kabam, Inc. | Dynamic item obtain rate based on player progression, action, and other in-game behavior |
| CN111359216A (en) * | 2020-02-13 | 2020-07-03 | 网易（杭州）网络有限公司 | Game information processing method and device, electronic equipment and storage medium |
| CN111400070A (en) * | 2020-03-24 | 2020-07-10 | 广州华多网络科技有限公司 | Terminal equipment and cross-process interface calling implementation and execution method thereof |
-
2020
- 2020-08-27 CN CN202010879751.0A patent/CN112090079B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20190046882A1 (en) * | 2013-04-15 | 2019-02-14 | Kabam, Inc. | Dynamic item obtain rate based on player progression, action, and other in-game behavior |
| CN105719126A (en) * | 2016-01-22 | 2016-06-29 | 上海晶赞科技发展有限公司 | System and method for internet big data task scheduling based on life cycle model |
| CN111359216A (en) * | 2020-02-13 | 2020-07-03 | 网易（杭州）网络有限公司 | Game information processing method and device, electronic equipment and storage medium |
| CN111400070A (en) * | 2020-03-24 | 2020-07-10 | 广州华多网络科技有限公司 | Terminal equipment and cross-process interface calling implementation and execution method thereof |
Cited By (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112604284A (en) * | 2020-12-29 | 2021-04-06 | 北京冰封互娱科技有限公司 | Task execution method, device and equipment of game and computer readable storage medium |
| CN112604284B (en) * | 2020-12-29 | 2024-04-16 | 北京冰封互娱科技有限公司 | Game task execution method, device, equipment and computer readable storage medium |
| CN113413588A (en) * | 2021-06-16 | 2021-09-21 | 网易（杭州）网络有限公司 | Game task processing method and device, electronic equipment and storage medium |
| CN113413588B (en) * | 2021-06-16 | 2024-03-15 | 网易（杭州）网络有限公司 | Game task processing method and device, electronic equipment and storage medium |
| CN113836011A (en) * | 2021-09-16 | 2021-12-24 | 网易（杭州）网络有限公司 | Task list processing method and device, storage medium and electronic equipment |
| CN113836011B (en) * | 2021-09-16 | 2024-02-23 | 网易（杭州）网络有限公司 | Task list processing method and device, storage medium and electronic equipment |
| CN113797542A (en) * | 2021-09-29 | 2021-12-17 | 上海完美时空软件有限公司 | Method and device for generating task data, storage medium and electronic device |
| CN113797542B (en) * | 2021-09-29 | 2024-04-23 | 上海完美时空软件有限公司 | Task data generation method and device, storage medium and electronic device |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112090079B (en) | 2022-05-06 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN112090079B (en) | Game task running method and device, computer equipment and storage medium | |
| US5535389A (en) | Business process objects with associated attributes such as version identifier | |
| US5475843A (en) | System and methods for improved program testing | |
| CN102667730B (en) | Design time debugging | |
| US7398514B2 (en) | Test automation stack layering | |
| US7685609B1 (en) | Using a distributed form object model to facilitate form event processing | |
| US7636897B2 (en) | System and method for property-based focus navigation in a user interface | |
| CN110244942B (en) | Page generation method, device and system | |
| US8065659B1 (en) | Method and apparatus for executing scripts within a web browser | |
| CN111522552B (en) | Sub-application generation method and device, computer equipment and storage medium | |
| CN103092751B (en) | Web application performance test system based on customer behavior model in cloud environment | |
| US20050268280A1 (en) | Encapsulating changes to a software application | |
| CN114979029B (en) | Control method, device, equipment and storage medium of virtual robot | |
| CN107391219A (en) | Function Compilation Method and device | |
| Netti et al. | FINJ: A fault injection tool for HPC systems | |
| CN113018870A (en) | Data processing method and device and computer readable storage medium | |
| CN111111201B (en) | Skill creation method, device, server and medium based on game | |
| CN115794213A (en) | Configurable object management method, device and equipment based on embedded system | |
| CN114661284A (en) | Game editing method, game running method, game editing device and computer equipment | |
| JP7231347B2 (en) | Method and system for calling event-based package module | |
| Uchiya et al. | Interactive design method of agent system for symbiotic computing | |
| CN110622146B (en) | Programmable synthesis mechanism for device factor graph | |
| Pettit IV et al. | Modeling behavioral design patterns of concurrent objects | |
| CN113296758A (en) | Front-end component library construction method and device and storage medium | |
| CN114764296A (en) | Machine learning model training method and device, electronic equipment and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |