Virtual task configuration method and device, storage medium and electronic device

Abstract

The application discloses a virtual task configuration method and device, a storage medium and an electronic device. The method comprises the following steps: in response to a configuration request triggered by a preset virtual task, a first task stage and a second task stage are acquired; a first random pool of the first task stage and a second random pool of the second task stage are determined from at least two event random pools; a first task event is randomly selected from the first random pool, and the first task event is determined as a task event corresponding to the first task stage; a second task event is randomly selected from the second random pool, and the second task event is determined as a task event corresponding to the second task stage; and the preset virtual task is configured based on the first task event and the second task event. The application solves the technical problem that the configuration of the virtual task is too homogeneous.

Description

Technical Field

[0001] This application relates to the field of computers, and more specifically, to a method, apparatus, storage medium, and electronic device for configuring virtual tasks. Background Technology

[0002] In the configuration of virtual tasks, the triggered events and task flows are basically fixed. For example, when configuring virtual tasks in batches, a fixed event flow can be directly applied.

[0003] This homogenized configuration approach not only limits the differentiation between virtual tasks but also makes it difficult to meet users' personalized needs due to its overly rigid and singular product performance. Therefore, there is a problem of excessive homogenization in virtual task configurations.

[0004] There is currently no effective solution to the above problems. Summary of the Invention

[0005] This application provides a method, apparatus, storage medium, and electronic device for configuring virtual tasks, in order to at least solve the technical problem of overly homogeneous configuration of virtual tasks.

[0006] According to one aspect of the embodiments of this application, a method for configuring a virtual task is provided, comprising: in response to a configuration request triggered by a preset virtual task, obtaining a first task stage and a second task stage, wherein the first task stage and the second task stage are used to form a task flow of the preset virtual task; determining a first random pool for the first task stage and a second random pool for the second task stage from at least two event random pools, wherein random items in the event random pools are task events, and the task events are events triggered in the task stage; randomly selecting a first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage; randomly selecting a second task event from the second random pool and determining the second task event as the task event corresponding to the second task stage; and configuring the preset virtual task based on the first task event and the second task event.

[0007] According to another aspect of the embodiments of this application, a configuration apparatus for a virtual task is also provided, comprising: a first acquisition unit, configured to acquire a first task stage and a second task stage in response to a configuration request triggered by a preset virtual task, wherein the first task stage and the second task stage are used to form a task flow of the preset virtual task; a first determination unit, configured to determine a first random pool of the first task stage and a second random pool of the second task stage from at least two event random pools, wherein random items in the event random pools are task events, and the task events are events triggered in the task stage; a first randomization unit, configured to randomly select a first task event from the first random pool and determine the first task event as the task event corresponding to the first task stage; a second randomization unit, configured to randomly select a second task event from the second random pool and determine the second task event as the task event corresponding to the second task stage; and a configuration unit, configured to configure the preset virtual task based on the first task event and the second task event.

[0008] As an optional solution, the above apparatus further includes: a second acquisition unit, configured to acquire multiple initial event random pools before randomly selecting a first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage; a testing unit, configured to perform conflict testing on the task events in the multiple initial event random pools before randomly selecting the first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage, and obtain test results, wherein the test results are used to indicate the conflict situation between at least two task events in the multiple initial event random pools; and a coordination unit, configured to, based on the test results, perform conflict coordination on the task events in the multiple initial event random pools that have the aforementioned conflict situation before randomly selecting the first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage, and obtain coordinated task events, wherein the at least two event random pools include the coordinated task events and task events that do not have the aforementioned conflict situation.

[0009] As an optional solution, the aforementioned testing unit includes: a first testing module, configured to perform conflict testing on multiple task events corresponding to the first task stage in the multiple initial event random pools to obtain a first result, wherein the test result includes the first result; a second testing module, configured to perform conflict testing on multiple task events corresponding to the second task stage in the multiple initial event random pools to obtain a second result, wherein the test result includes the second result; the aforementioned coordination unit includes: a first coordination module, configured to perform conflict coordination on task events with conflicting conditions in the multiple task events of the first task stage based on the first result, to obtain coordinated task events for the first task stage, wherein the first random pool includes coordinated task events for the first task stage and task events without conflicting conditions in the first task stage; a second coordination module, configured to perform conflict coordination on task events with conflicting conditions in the multiple task events of the second task stage based on the second result, to obtain coordinated task events for the second task stage, wherein the second random pool includes coordinated task events for the second task stage and task events without conflicting conditions in the second task stage.

[0010] As an optional solution, the above-mentioned device further includes: a marking unit, used to mark the first event and the second event with mutual exclusion tags when the test results indicate that there are mutually exclusive first events and second events in the multiple initial event random pools, in the process of conflict coordination of task events with the above-mentioned conflict based on the above-mentioned test results to obtain coordinated task events. The task events with the above-mentioned mutual exclusion tags are prohibited from being configured in the same virtual task.

[0011] As an optional solution, the above-mentioned device further includes: a second determining unit, configured to, during the process of randomly selecting a first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage, determine a third random pool that meets the task level from at least two object random pools, provided that the task level corresponding to the preset virtual task is obtained, wherein the random items in the object random pool are task objects, and the task objects are virtual objects that interact during the virtual task; and a third randomizing unit, configured to, during the process of randomly selecting a first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage, randomly select a virtual task object from the third random pool and determine the virtual task object as the task object that triggers the first task event.

[0012] As an optional solution, the aforementioned third random unit includes: a first random module, used to randomly select a first non-player character from the third random pool when the third random pool is a random pool that meets the first task level, and to determine the first non-player character as the virtual character that triggers the first task event; and a second random module, used to randomly select a second non-player character from the third random pool when the third random pool is a random pool that meets the second task level, and to determine the second non-player character as the virtual character that triggers the second task event, wherein the second task level is higher than the first task level, and the interaction difficulty of the second virtual character is higher than the interaction difficulty of the first virtual character.

[0013] As an optional solution, the second determining unit includes: a first determining module, used to determine the third random pool from the at least two object random pools when the preset virtual task needs to be completed in conjunction with virtual clues and the clue level of the virtual clues is obtained, wherein the third random pool is a random pool that conforms to the clue level, and the task level includes the clue level.

[0014] As an optional solution, the above-mentioned device further includes: a second determining module, used to determine, in the case where the virtual clue is a special clue composed of a first clue fragment and a second clue fragment, the random pool for the first clue index stage and the random pool for the second clue index stage from the at least two event random pools during the process of determining the first random pool for the first task stage and the second random pool for the second task stage from the at least two event random pools, wherein the first clue index stage is the task stage for obtaining the first clue fragment and the second clue index stage is the task stage for obtaining the second clue fragment.

[0015] As an optional solution, the above-mentioned device further includes: a third acquisition unit, configured to acquire the task container of the preset virtual task before acquiring the first task stage and the second task stage in response to the configuration request triggered by the preset virtual task; and a fourth acquisition unit, configured to acquire multiple data prefabs in response to a setting request for the task container before acquiring the first task stage and the second task stage in response to the configuration request triggered by the preset virtual task, and place the multiple data prefabs in the task container, wherein the data prefabs are used to provide game data for the preset virtual task, and the game data includes... The system includes: a task event data binding unit, configured to bind the task container to the gameplay blueprint of each virtual task before obtaining the first task stage and the second task stage in response to the configuration request triggered by the preset virtual task, wherein the gameplay blueprint is used to provide execution logic for the preset virtual task, and the execution logic includes the logic of the task event; and an arrangement unit, configured to arrange the configured task container in a virtual scene before obtaining the first task stage and the second task stage in response to the configuration request triggered by the preset virtual task, wherein the virtual scene is a scene in which the preset virtual task is allowed to execute.

[0016] As an optional solution, the above-mentioned device further includes: a first adjustment unit, configured to adjust the data prefab placed in the task container in response to a first adjustment request triggered on the task container after the task container has been arranged in the virtual scene; or, a second adjustment unit, configured to adjust the gameplay blueprint bound to the task container in response to a second adjustment request triggered on the task container after the task container has been arranged in the virtual scene.

[0017] As an optional solution, the above-mentioned apparatus further includes: a first allocation unit, configured to assign a first weight to each task event in the first random pool according to the task characteristics of the preset virtual task before randomly selecting a first task event from the first random pool, wherein the first weight is used to increase the probability that a task event matching the task characteristics of the preset virtual task is randomly selected from the first random pool; the first random unit includes: a third random module, configured to randomly select the first task event from the first random pool using the first weight; the apparatus further includes: a second allocation unit, configured to assign a second weight to each task event in the second random pool according to the task characteristics of the preset virtual task before randomly selecting a second task event from the second random pool, wherein the second weight is used to increase the probability that a task event matching the task characteristics of the preset virtual task is randomly selected from the second random pool; the second random unit includes: a fourth random module, configured to randomly select the second task event from the second random pool using the second weight.

[0018] According to another aspect of the embodiments of this application, a computer program product or computer program is provided, which includes computer instructions stored in a computer-readable storage medium. A processor of an electronic device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the electronic device to perform the configuration method for the virtual task described above.

[0019] According to another aspect of the embodiments of this application, an electronic device is also provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the configuration method for the virtual task described above through the computer program.

[0020] In this embodiment, in response to a configuration request triggered by a preset virtual task, a first task stage and a second task stage are obtained, wherein the first task stage and the second task stage are used to form the task flow of the preset virtual task; a first random pool for the first task stage and a second random pool for the second task stage are determined from at least two event random pools, wherein the random items in the event random pools are task events, and the task events are events triggered in the task stage; a first task event is randomly selected from the first random pool and determined as the task event corresponding to the first task stage; a second task event is randomly selected from the second random pool and determined as the task event corresponding to the second task stage; and the preset virtual task is configured based on the first task event and the second task event.

[0021] This embodiment divides the virtual task into independent task stages (such as the first and second stages) and assigns an independent event random pool to each stage, making the event triggering mechanisms independent of each stage. Furthermore, task events are randomly selected from the event random pools of each stage. The uncertainty of random selection ensures that the same task triggers different events in different configured instances.

[0022] At the same time, it is worth noting that if all the 'random logic' is opened up, there may be abnormal situations such as conflicts and irrationality.

[0023] Furthermore, in this embodiment, different random pools are used for different stages to address this abnormal situation. The random events in each random pool are independent and do not interfere with each other. In this way, conflicting events will not be assigned to the same random pool, thereby avoiding conflicts and unreasonable situations between random events.

[0024] By introducing an event random pool, dynamic selection mechanism, and flexible binding strategy, the fixed pattern of event triggering and task flow is broken, thereby improving the technical effect of differentiating and personalizing the configuration of virtual tasks and solving the technical problem of overly homogeneous configuration of virtual tasks. Attached Figure Description

[0025] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings:

[0026] Figure 1 This is a schematic diagram of an application environment for an optional virtual task configuration method according to an embodiment of this application;

[0027] Figure 2 This is a schematic diagram of the flow of an optional virtual task configuration method according to an embodiment of this application;

[0028] Figure 3 This is a schematic diagram of an optional virtual task configuration method according to an embodiment of this application;

[0029] Figure 4 This is a schematic diagram of another optional virtual task configuration method according to an embodiment of this application;

[0030] Figure 5 This is a schematic diagram of another optional virtual task configuration method according to an embodiment of this application;

[0031] Figure 6 This is a schematic diagram of another optional virtual task configuration method according to an embodiment of this application;

[0032] Figure 7 This is a schematic diagram of another optional virtual task configuration method according to an embodiment of this application;

[0033] Figure 8 This is a schematic diagram of an optional virtual task configuration device according to an embodiment of this application;

[0034] Figure 9 This is a schematic diagram of the structure of an optional electronic device according to an embodiment of this application. Detailed Implementation

[0035] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present application, and not all embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present application.

[0036] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this application described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0037] According to one aspect of the embodiments of this application, a method for configuring virtual tasks is provided. Optionally, as an optional implementation, the above-described method for configuring virtual tasks can be applied to, but is not limited to, [examples of other methods]. Figure 1 The environment shown may include, but is not limited to, user equipment 102 and server 112. User equipment 102 may include, but is not limited to, a display 104, a processor 106 and a memory 108. Server 112 includes a database 114 and a processing engine 116.

[0038] The specific process can be summarized in the following steps:

[0039] Step S102: User equipment 102 obtains a configuration request for a preset virtual task trigger;

[0040] Step S104: Send the configuration request to server 112 via network 110;

[0041] In steps S106-S112, server 112 responds to the configuration request triggered by the preset virtual task, obtains the first task stage and the second task stage, and through processing engine 116 determines the first random pool of the first task stage and the second random pool of the second task stage from at least two event random pools. Further, it randomly selects a first task event from the first random pool and identifies it as the task event corresponding to the first task stage, and randomly selects a second task event from the second random pool and identifies it as the task event corresponding to the second task stage. Based on the first and second task events, it configures the preset virtual task to obtain the configuration result.

[0042] In step S114, the configuration result is sent to the user equipment 102 via the network 110. The user equipment 102 displays the configuration result on the display 104 via the processor 106 and stores the configuration result in the memory 108.

[0043] remove Figure 1 Beyond the examples shown, the user equipment described above can be a terminal device configured with a target client, including but not limited to at least one of the following: mobile phones (such as Android phones, iOS phones, etc.), laptops, tablets, PDAs, MIDs (Mobile Internet Devices), PADs, desktop computers, smart TVs, etc. The target client can be a video client, instant messaging client, browser client, educational client, etc. The network described above can include, but is not limited to, wired networks and wireless networks. The wired network includes local area networks (LANs), metropolitan area networks (MANs), and wide area networks (WANs). The wireless network includes Bluetooth, Wi-Fi, and other networks that enable wireless communication. The server described above can be a single server, a server cluster consisting of multiple servers, or a cloud server. The above is merely an example, and no limitations are imposed in this embodiment.

[0044] As an example, the terminal device may include, but is not limited to, mobile phones, computers, smart voice interaction devices, smart home appliances, vehicle terminals, and aircraft. This embodiment can be applied to various scenarios, including but not limited to digital humans, virtual humans, games, virtual reality, and extended reality (XR).

[0045] For example, a server can also be a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDN, and big data and artificial intelligence platforms.

[0046] Alternatively, as an alternative implementation method, such as Figure 2 As shown, the configuration method for virtual tasks can be executed by an electronic device, such as... Figure 1 The user equipment or server shown includes the following specific steps:

[0047] S202, in response to the configuration request triggered by the preset virtual task, obtain the first task stage and the second task stage, wherein the first task stage and the second task stage are used to form the task flow of the preset virtual task.

[0048] In an optional embodiment, the preset virtual task can be a pre-set virtual task with certain goals and processes, such as a dungeon task in a game, which includes a series of goals and steps that need to be completed.

[0049] In an optional embodiment, the configuration request may be an instruction issued by the user or the system to configure a preset virtual task, such as a request issued by the user when they want to adjust the difficulty and event triggering method of a game instance task.

[0050] In an optional embodiment, the first task stage and the second task stage can be two independent parts of a pre-defined virtual task, which together constitute the task flow of the pre-defined virtual task. For example, in a game instance task, the first task stage can be "entering the instance and defeating the monsters", and the second task stage can be "challenging the final BOSS of the instance".

[0051] In an optional embodiment, the task flow can be an overall flow composed of various task stages in a preset virtual task combined in a certain order, which determines the execution steps and logic of the task.

[0052] Specifically, when this embodiment receives a configuration request for a preset virtual task from a user or itself, it begins to execute subsequent configuration operations, extracts the first task stage and the second task stage that make up the task flow from the preset virtual task, clarifies which task stages the preset virtual task is composed of, and provides a basis for subsequently determining the event random pool corresponding to each stage.

[0053] S204, determine a first random pool for the first task phase and a second random pool for the second task phase from at least two event random pools, wherein the random items in the event random pool are task events, and the task events are events triggered during the task phase.

[0054] In an optional embodiment, a collection of storage task events is provided, which contains multiple random items, each of which is a task event. For example, an event random pool may contain task events such as "user login," "system timeout," and "data anomaly."

[0055] In an optional embodiment, a random item may refer to an element that exists in an event random pool and can be randomly selected. These elements represent various events or behaviors that may be triggered during a task phase.

[0056] In an optional embodiment, a task event can be an event triggered during a task phase that affects the task's execution and outcome. For example, a "user login" event could trigger a series of subsequent operations, such as loading user data or displaying a welcome screen.

[0057] In an optional embodiment, the first random pool and the second random pool may be event random pools corresponding to the first task stage and the second task stage, respectively, for randomly selecting task events from them.

[0058] Specifically, in this embodiment, based on the first task stage and the second task stage, corresponding event random pools are identified from at least two event random pools, establishing a correspondence between task stages and event random pools. This ensures that each task stage has an independent event random pool, providing a basis for the subsequent random selection of task events.

[0059] S206, Randomly select the first task event from the first random pool, and determine the first task event as the task event corresponding to the first task stage;

[0060] S208, randomly select a second task event from the second random pool, and determine the second task event as the task event corresponding to the second task stage;

[0061] In an optional embodiment, the first task event and the second task event may be task events randomly selected from the first random pool and the second random pool, respectively serving as task events corresponding to the first task stage and the second task stage.

[0062] Specifically, in this embodiment, a task event is randomly selected from the first random pool corresponding to the first task stage according to a random algorithm and determined as the task event to be executed in the first task stage. This achieves random determination of task events in the first task stage, increasing the diversity and uncertainty of tasks. Similarly, a task event is randomly selected from the second random pool corresponding to the second task stage according to a random algorithm and determined as the task event to be executed in the second task stage. This achieves random determination of task events in the second task stage, further enriching the task execution process.

[0063] S210, configure the preset virtual task based on the first task event and the second task event.

[0064] Specifically, in this embodiment, based on the task events of the first and second task stages that have been determined, the preset virtual task is configured accordingly, such as setting the task triggering conditions and execution logic. This is the ultimate goal of the entire configuration process. After the task events of each stage are determined through the previous steps, these events are applied to the preset virtual task to complete the configuration operation.

[0065] In optional embodiments, the above-described method for configuring virtual tasks can be applied to, but is not limited to, virtual game scenarios, such as clue-based games, role-playing games, turn-based games, etc.

[0066] To further illustrate, consider a treasure map clue game as an example. The treasure map quest can be broken down into three core stages: clue analysis, path exploration, and treasure acquisition. Each stage corresponds to an independent event random pool, containing various randomly combinable event types, as detailed below:

[0067] Clue Analysis Phase: The random pool includes events such as clue type (text / picture / riddle), hint strength (high / medium / low), and misleading information (whether it contains false clues).

[0068] Path exploration phase: The random pool includes events such as path difficulty (easy / complex / dangerous), environmental interference (weather changes / wildlife attacks), and hidden traps (whether mechanisms are triggered).

[0069] Treasure Acquisition Phase: The random pool includes events such as treasure type (gold / equipment / rare items), guardian mechanism (none / easy puzzle / elite monster), and extra rewards (whether rare materials drop).

[0070] Furthermore, an event is randomly selected from the random pool of each stage according to a preset weight. For example, "clue type: riddle, hint strength: low, contains 1 misleading message" is selected from the clue analysis random pool, and "path difficulty: complex, environmental interference: rainy weather, no hidden traps" is selected from the path exploration random pool.

[0071] The task flow is automatically pieced together based on the extracted events. For example, the treasure map task for players involves finding clues through the riddle "AAAA". Players then need to traverse complex terrain in a rainstorm to reach the location indicated by the clues. Upon arrival, they solve the simple riddle "BBBB" to obtain rare equipment and materials.

[0072] It should be noted that this embodiment aims to configure a preset virtual task through a series of steps to solve the homogenization problem caused by the fixed event triggering and task flow in traditional solutions. First, when a configuration request for a preset virtual task is received, the system obtains the first and second task stages that constitute the task, which together form the task flow of the preset virtual task. Then, from at least two event random pools, corresponding first and second random pools are determined for the first and second task stages, respectively, with each event random pool containing multiple task events. Next, a task event is randomly selected from the first random pool as the task event corresponding to the first task stage, and a task event is randomly selected from the second random pool as the task event corresponding to the second task stage. Finally, based on the determined first and second task events, the preset virtual task is configured to have greater differentiation and personalization.

[0073] To further illustrate, optional examples include... Figure 3 As shown, in response to a configuration request triggered by a preset virtual task 302, a first task stage 304 and a second task stage 306 are obtained, wherein the first task stage 304 and the second task stage 306 are used to form the task flow of the preset virtual task 302; from at least two event random pools, a first random pool 308 for the first task stage 304 and a second random pool 310 for the second task stage 306 are determined, wherein the random items in the event random pools are task events, and the task events are events triggered in the task stages; from the first random pool 308, a first task event 312 (e.g., "5") is randomly selected, and the first task event 312 is determined as the task event corresponding to the first task stage 304; from the second random pool 310, a second task event 314 (e.g., "8") is randomly selected, and the second task event 314 is determined as the task event corresponding to the second task stage 306; based on the first task event 312 and the second task event 314, the preset virtual task 302 is configured.

[0074] Optionally, the content of this embodiment can be applied to other embodiments described above, or combined with other embodiments described above.

[0075] The embodiments provided in this application divide virtual tasks into independent task stages (such as the first and second stages), and allocate an independent event random pool to each stage, making the event triggering mechanisms independent of each stage. Furthermore, task events are randomly selected from the event random pools of each stage. Through the uncertainty of random selection, the same task triggers different events in different configuration instances.

[0076] At the same time, it is worth noting that if all the 'random logic' is opened up, there may be abnormal situations such as conflicts and irrationality.

[0077] Furthermore, in this embodiment, different random pools are used for different stages to address this abnormal situation. The random events in each random pool are independent and do not interfere with each other. In this way, conflicting events will not be assigned to the same random pool, thereby avoiding conflicts and unreasonable situations between random events.

[0078] By introducing an event random pool, a dynamic selection mechanism, and a flexible binding strategy, the fixed pattern of event triggering and task flow is broken, thereby achieving the technical effect of improving the configuration differentiation and personalization of virtual tasks.

[0079] As an optional approach, before randomly selecting the first task event from the first random pool and determining the first task event as the task event corresponding to the first task phase, the method further includes:

[0080] S1-1, Obtain multiple initial event random pools;

[0081] S1-2, perform conflict tests on task events in multiple initial event random pools to obtain test results, wherein the test results are used to represent the conflict situation between at least two task events in multiple initial event random pools;

[0082] S1-3, Based on the test results, conflict coordination is performed on the conflicting task events in multiple initial event random pools to obtain coordinated task events. Among them, at least two event random pools include coordinated task events and task events without conflict.

[0083] In an optional embodiment, the initial event random pool may be a set of multiple pre-prepared events for randomly selecting task events.

[0084] In an optional embodiment, the conflict situation may be a situation of mutual interference or incompatibility between at least two task events in multiple initial event random pools.

[0085] In an optional embodiment, the test results may be information indicating the conflict situation obtained after performing conflict tests on task events in multiple initial event random pools.

[0086] In an optional embodiment, the coordinated task event can be a task event obtained by processing conflicting task events based on test results.

[0087] It should be noted that this embodiment aims to ensure that the final task events (including coordinated task events and task events without conflicts) can be reasonably applied to the subsequent task event random selection and task execution phases by conducting conflict testing and coordination on task events in multiple initial event random pools, thereby avoiding conflicts between task events from affecting the smooth progress of the task.

[0088] Specifically, firstly, multiple initial event random pools are obtained to provide basic data for subsequent processing; then, conflict tests are performed on the task events in these random pools to obtain test results representing the conflict situation; finally, the conflicting task events are coordinated based on the test results to obtain coordinated task events, which, together with the non-conflicting task events, constitute a set of task events that can be used for subsequent stages.

[0089] To further illustrate, options include obtaining a random pool of combat missions (containing various combat missions, such as defeating specific monsters, completing specific combat scenarios, etc.) from the game database, a random pool of gathering missions (containing missions for gathering various resources, such as gathering herbs, ores, etc.), and a random pool of exploration missions (containing missions for exploring specific areas, such as exploring mysterious caves, ancient ruins, etc.).

[0090] Testing revealed a conflict when players simultaneously selected the combat mission "Defeat Specific Monster A" and the exploration mission "Explore Mysterious Cave B." This conflict occurred because Monster A is located in Mysterious Cave B. If a player first selected the exploration mission and entered Cave B, Monster A might have already been defeated by another player, preventing the combat mission from being completed. The test results recorded this conflict.

[0091] Based on the test results, conflicting task events were reconciled. The combat task "Defeat a specific monster A" was adjusted to "Defeat a specific monster A within a specific time period," or the trigger condition for the exploration task "Explore the Mysterious Cave B" was modified so that it would trigger only after the combat task "Defeat a specific monster A" was completed. After reconciliation, the reconciled task events were obtained, which, together with the non-conflicting task events, constituted a new set of task events for use in subsequent game task phases.

[0092] Optionally, the content of this embodiment can be applied to other embodiments described above, or combined with other embodiments described above.

[0093] The embodiments provided in this application involve obtaining multiple initial event random pools; performing conflict tests on task events in the multiple initial event random pools to obtain test results, wherein the test results represent the conflict status between at least two task events in the multiple initial event random pools; and based on the test results, performing conflict coordination on the conflicting task events in the multiple initial event random pools to obtain coordinated task events, wherein at least two event random pools include coordinated task events and task events without conflicts. This effectively avoids conflicts between task events, improves the rationality and feasibility of task event selection and execution, reduces task failures or inefficiencies caused by task event conflicts, and ensures the smooth progress of the entire task process.

[0094] As an optional approach, conflict testing is performed on task events from multiple initial event random pools to obtain test results, including:

[0095] S2-1, perform conflict testing on multiple task events corresponding to the first task stage from multiple initial event random pools to obtain the first result, wherein the test result includes the first result;

[0096] S2-2, perform conflict testing on multiple task events corresponding to the second task stage from multiple initial event random pools to obtain a second result, wherein the test result includes the second result;

[0097] Based on the test results, conflict-prone task events in multiple initial event random pools were reconciled to obtain reconciled task events, including:

[0098] S3-1, Based on the first result, conflict coordination is performed on the multiple task events in the first task stage that have conflicts, to obtain the coordinated task events in the first task stage. The first random pool includes the coordinated task events in the first task stage and the task events that do not have conflicts in the first task stage.

[0099] S3-2, Based on the second result, conflict coordination is performed on the multiple task events in the second task phase that have conflicts, to obtain the coordinated task events of the second task phase. The second random pool includes the coordinated task events of the second task phase and the task events that do not have conflicts with the second task phase.

[0100] In an optional embodiment, the first result may be the conflict test result corresponding to the first task phase. The second result may be the conflict test result corresponding to the second task phase.

[0101] In an optional embodiment, conflict coordination can be an operation that adjusts and processes task events that are in conflict.

[0102] In an optional embodiment, the coordinated task event can be a task event that has undergone conflict coordination processing.

[0103] It should be noted that this embodiment aims to obtain coordinated task events by performing conflict testing and coordination on task events in multiple initial event random pools, and then forming random pools corresponding to different task stages.

[0104] Specifically, a comprehensive conflict test is first conducted on all task events in multiple initial event random pools to obtain the overall test results.

[0105] Then, separate conflict tests were conducted on the task events of the first and second task phases respectively to obtain the first and second results.

[0106] Based on the overall test results and the first and second results, conflict coordination was carried out for the task events with conflicting situations.

[0107] For the first task phase, based on the first result, the task events with conflicting situations are coordinated to obtain the coordinated task events of the first task phase, which together with the task events without conflicting situations in the first task phase form the first random pool.

[0108] For the second task phase, based on the second result, the task events with conflicting situations are coordinated to obtain the coordinated task events of the second task phase, which together with the task events without conflicting situations in the second task phase form the second random pool.

[0109] Optionally, the content of this embodiment can be applied to other embodiments described above, or combined with other embodiments described above.

[0110] The embodiments provided in this application involve performing conflict tests on multiple task events corresponding to a first task stage from multiple initial event random pools to obtain a first result, wherein the test result includes the first result; performing conflict tests on multiple task events corresponding to a second task stage from multiple initial event random pools to obtain a second result, wherein the test result includes the second result; based on the first result, conflict coordination is performed on the conflicting task events among the multiple task events in the first task stage to obtain coordinated task events for the first task stage, wherein the first random pool includes coordinated task events and non-conflicting task events for the first task stage; based on the second result, conflict coordination is performed on the conflicting task events among the multiple task events in the second task stage to obtain coordinated task events for the second task stage, wherein the second random pool includes coordinated task events and non-conflicting task events for the second task stage. This achieves conflict handling and coordination of task events in multiple initial event random pools, providing a more reasonable and orderly set of task events for the execution of subsequent tasks.

[0111] As an optional approach, in the process of resolving conflicts among multiple initial random pools of events based on test results to obtain reconciled task events, the method further includes:

[0112] If the test results indicate that there are mutually exclusive first and second events in multiple initial event random pools, use a mutual exclusion label to mark the first and second events. The task events with mutual exclusion labels are prohibited from being configured in the same virtual task.

[0113] In an optional embodiment, the test result may be the result obtained after performing conflict tests on task events in multiple initial event random pools, which is used to determine whether there are conflicts between task events.

[0114] In an optional embodiment, a mutual exclusion relationship can be a relationship in which two or more task events cannot occur or be executed simultaneously.

[0115] In an optional embodiment, the first event and the second event can be two specific task events that are mutually exclusive in multiple initial event random pools.

[0116] In an optional embodiment, the mutual exclusion label may be a special identifier used to mark task events that have a mutual exclusion relationship.

[0117] It should be noted that this embodiment adds a processing mechanism for task events with mutual exclusion during the conflict coordination process of multiple initial event random pools.

[0118] Specifically, the first step is to coordinate conflicts between task events that conflict in multiple initial event random pools based on the test results. This is the fundamental step of the entire solution, which aims to resolve conflicts between task events and ensure the normal operation of the system.

[0119] During conflict resolution, the test results are further analyzed to determine whether there are mutually exclusive first and second events in the multiple initial event random pools. This step is to identify special conflict situations, i.e., mutually exclusive relationships, in order to take targeted measures.

[0120] Once the first and second events are identified as mutually exclusive, they are marked with mutual exclusion labels. These mutual exclusion labels serve as special identifiers, facilitating subsequent system processing and identification, and providing a basis for setting subsequent constraints.

[0121] Finally, it is stipulated that task events with mutual exclusion labels cannot be configured in the same virtual task. This constraint can effectively prevent mutually exclusive task events from executing simultaneously in the same virtual task, thereby preventing system errors or anomalies caused by mutual exclusion.

[0122] To further illustrate, consider an optional assumption in a game development project: multiple initial event pools containing various game task events, such as "player attacks monster," "monster attacks player," and "player uses item." During conflict testing and reconciliation, it is discovered that the task events "player attacks monster" and "monster attacks player" are mutually exclusive because they cannot occur simultaneously (at any given moment, either the player attacks the monster, or the monster attacks the player).

[0123] According to this embodiment, the two mutually exclusive task events are first marked with a mutual exclusion label. Then, it is stipulated that these two task events with the mutual exclusion label cannot be configured to be executed in the same virtual task. For example, in a game scene, the task events "player attacks monster" and "monster attacks player" cannot be scheduled to be executed simultaneously in the same virtual game round, thereby avoiding game logic errors caused by mutual exclusion.

[0124] Optionally, the content of this embodiment can be applied to other embodiments described above, or combined with other embodiments described above.

[0125] Through the embodiments provided in this application, when test results indicate that there are mutually exclusive first and second events in multiple initial event random pools, mutual exclusion labels are used to mark the first and second events. Task events with mutual exclusion labels are prohibited from being configured in the same virtual task. By identifying and handling mutually exclusive task events and prohibiting their execution in the same virtual task, system conflicts and errors caused by mutual exclusion can be avoided, thereby improving system stability and reliability. After clarifying the mutual exclusion relationships between task events, task scheduling can be performed more rationally, avoiding the allocation of mutually exclusive task events to the same virtual task, thus improving the efficiency and accuracy of task scheduling.

[0126] As an optional approach, in the process of randomly selecting the first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage, the method further includes:

[0127] S4-1, when the task level corresponding to the preset virtual task is obtained, a third random pool that meets the task level is determined from at least two object random pools. The random items in the object random pool are task objects, which are virtual objects that interact during the virtual task.

[0128] S4-2, randomly select a virtual task object from the third random pool, and determine the virtual task object as the task object that triggers the first task event.

[0129] In an optional embodiment, the task level can be an attribute of a preset virtual task, used to measure the difficulty, complexity, etc. of the task.

[0130] In an optional embodiment, the object random pool may be a pool storing a variety of task objects, at least two, which is the source for randomly selecting virtual task objects.

[0131] In an optional embodiment, the third random pool may be an object random pool that conforms to the task level, determined from at least two object random pools.

[0132] In an optional embodiment, the virtual task object may be a task object randomly selected from a third random pool to trigger the first task event.

[0133] It should be noted that in this embodiment, a step is added to determine the task object that triggers the task event based on the task level of the preset virtual task during the process of determining the task event corresponding to the first task stage.

[0134] Specifically, firstly, a task event is randomly selected from the first random pool as the task event corresponding to the first task stage. The task level corresponding to the preset virtual task is obtained, providing a basis for subsequently determining a suitable task object. Based on the task level, a third random pool of objects matching that level is selected from at least two object random pools. Finally, a task object is randomly selected from the third random pool and determined as the task object that triggers the first task event.

[0135] To illustrate further, consider an optional scenario in a role-playing game where there is a pre-set virtual quest "Defeat the Evil Wizard," and the quest level is "Hard."

[0136] The game system has a first random pool containing various task events, such as "finding magic potions," "talking to villagers," and "exploring a mysterious cave." The system randomly selected "exploring a mysterious cave" from the first random pool as the task event corresponding to the first task stage. The preset virtual task "defeat the evil wizard" is assigned a "hard" difficulty level.

[0137] There are three random pools of objects, each storing task objects of different difficulty levels. The first random pool contains task objects suitable for easy tasks, the second for medium-difficulty tasks, and the third for difficult tasks. Based on the task level of "difficult," the system has designated the third random pool as the third random pool.

[0138] Furthermore, a quest object, "The Evil Wizard's Powerful Assistant," was randomly selected from the third random pool and designated as the quest object to trigger the "Explore the Mysterious Cave" event. In the game, players will encounter "The Evil Wizard's Powerful Assistant" while exploring the mysterious cave, leading to interactions such as combat.

[0139] Optionally, the content of this embodiment can be applied to other embodiments described above, or combined with other embodiments described above.

[0140] According to the embodiments provided in this application, when a preset virtual task's corresponding task level is obtained, a third random pool matching the task level is determined from at least two object random pools. The random items in the object random pools are task objects, which are virtual objects that interact during the virtual task. A virtual task object is randomly selected from the third random pool and identified as the task object that triggers the first task event. By determining task objects from different object random pools based on the task level, the diversity and variability of tasks can be increased, allowing players to face different challenges and situations when performing tasks. Determining task objects based on the task level ensures that the difficulty of the task matches the attributes of the task object, making the task more reasonable.

[0141] As an optional approach, a virtual task object is randomly selected from a third random pool and identified as the task object that triggers the first task event, including:

[0142] S5-1, If ​​the third random pool is a random pool that meets the first task level, randomly select the first non-player character from the third random pool and determine the first non-player character as the virtual character that triggers the first task event.

[0143] S5-2, if the third random pool is a random pool that meets the second task level, randomly select a second non-player character from the third random pool and determine the second non-player character as the virtual character that triggers the second task event. The second task level is higher than the first task level, and the interaction difficulty of the second virtual character is higher than the interaction difficulty of the first virtual character.

[0144] In an optional embodiment, the first task level may be one of the preset task difficulty levels, used to distinguish tasks of different difficulties.

[0145] In an optional embodiment, the first non-player character may be a non-player character randomly selected from a third random pool that meets the first task level, serving as the virtual character that triggers the first task event.

[0146] In an optional embodiment, the second task level can be one of the preset task difficulty levels, which is more difficult than the first task level.

[0147] In an optional embodiment, the second non-player character may be a non-player character randomly selected from a third random pool that meets the second task level, serving as the virtual character that triggers the second task event.

[0148] In an optional embodiment, a virtual character can be an entity that plays a certain role in a virtual task and interacts with players or other characters, including non-player characters (NPCs).

[0149] In an optional embodiment, the interaction difficulty can be the complexity and challenge of the virtual character interacting with the player or other characters.

[0150] It should be noted that in this embodiment, different random selection and determination methods are adopted in the process of randomly selecting virtual task objects from the third random pool and determining them as virtual characters that trigger task events, depending on the different task levels that the third random pool meets.

[0151] Specifically, the process first determines whether the third random pool matches the first or second task level. If the third random pool matches the first task level, a non-player character is randomly selected from this pool and designated as the virtual character triggering the first task event. If the third random pool matches the second task level, a non-player character is randomly selected from this pool and designated as the virtual character triggering the second task event. The second task level is higher than the first task level, and the interaction difficulty of the second virtual character is higher than that of the first virtual character.

[0152] To illustrate further, consider an adventure game with two mission levels: the first level is "easy" and the second level is "hard".

[0153] The game system has a third random pool. Based on the relevant settings of the task, it is determined that the third random pool meets the first task level of "easy".

[0154] A non-player character, a "friendly villager," is randomly selected from the third random pool that meets the requirements of the first task level. This character is then designated as the virtual character to trigger the first task event, "Help the villager collect resources." When the player interacts with the "friendly villager," the task is relatively simple; they only need to collect resources according to the prompts.

[0155] In another mission scenario, the game system determines that another third random pool meets the second mission level, "Difficult".

[0156] A non-player character, "The Evil Wizard," is randomly selected from the third random pool that meets the requirements of the second quest level. This character is designated as the virtual character to trigger the second quest event, "Defeat the Evil Wizard and Save the Village." When the player interacts with the "Evil Wizard," the quest is quite challenging, requiring intense combat with the wizard, who possesses powerful magic and skills.

[0157] Optionally, the content of this embodiment can be applied to other embodiments described above, or combined with other embodiments described above.

[0158] According to the embodiments provided in this application, when the third random pool is a random pool that meets the first task level, a first non-player character is randomly selected from the third random pool and determined as the virtual character that triggers the first task event; when the third random pool is a random pool that meets the second task level, a second non-player character is randomly selected from the third random pool and determined as the virtual character that triggers the second task event. The second task level is higher than the first task level, and the interaction difficulty of the second virtual character is higher than that of the first virtual character. By selecting different random pools and non-player characters based on the task level, a tiered approach to task difficulty is achieved, satisfying the needs and ability levels of different players. The different interaction difficulties of the non-player characters corresponding to different task levels increase the challenge and fun of the game, allowing players to have different experiences while completing tasks.

[0159] As an optional approach, when the preset virtual task requires completion in conjunction with virtual clues, and given the task level corresponding to the preset virtual task, a third random pool matching the task level is determined from at least two object random pools, including:

[0160] Given the clue level of the virtual clue, a third random pool is determined from at least two object random pools, wherein the third random pool conforms to the random pool of the clue level, and the task level includes the clue level.

[0161] In an optional embodiment, the virtual clues may be virtual information associated with a preset virtual task, used to assist in completing the task or to provide task guidance.

[0162] In an optional embodiment, the clue level can be a level of importance or complexity of the virtual clue, associated with the task level.

[0163] It should be noted that in this embodiment, when the preset virtual task needs to be completed in conjunction with virtual clues, a third random pool that meets the task level (clue level) corresponding to the preset virtual task is determined from at least two object random pools.

[0164] Specifically, the process first determines whether the preset virtual task requires virtual clues to complete. If it does, the task level corresponding to the preset virtual task and the clue level of the virtual clue are obtained, where the task level includes the clue level. Based on the obtained task level (clue level), a third random pool matching that level is determined from at least two object random pools.

[0165] To illustrate further, consider a hypothetical puzzle game where a pre-set virtual task is to "unravel the mystery of a hidden treasure," which requires the use of virtual clues to complete.

[0166] The game system has determined that the pre-set virtual task of "unraveling the mystery of the hidden treasure" requires the use of virtual clues to complete. The task level corresponding to this pre-set virtual task is "Intermediate." Simultaneously, the level of the virtual clues related to this task is also "Intermediate."

[0167] The game has at least two object random pools, each storing task objects of different difficulty levels. Based on the obtained "Intermediate" task level (clue level), a third random pool matching the "Intermediate" level is determined from the at least two object random pools. This third random pool stores task objects suitable for the intermediate task of "Unraveling the Mystery of the Mysterious Treasure" and matching the "Intermediate" clue level.

[0168] Optionally, the content of this embodiment can be applied to other embodiments described above, or combined with other embodiments described above.

[0169] Through the embodiments provided in this application, given the clue level of the virtual clues, a third random pool is determined from at least two object random pools. This third random pool conforms to the clue level, and the task level includes the clue level. Determining the third random pool based on the task level (clue level) ensures that the task objects selected from the random pool match the difficulty of the task and clues, improving the task's rationality and playability. Different task levels (clue levels) correspond to different random pools, requiring players to choose appropriate strategies based on the requirements of the task and clues to complete the task, increasing the game's strategic depth and challenge.

[0170] As an alternative approach, when the virtual clue is a special clue composed of first clue fragments and second clue fragments, the method further includes the following steps in determining the first random pool for the first task phase and the second random pool for the second task phase from at least two event random pools:

[0171] From at least two event random pools, determine the random pool for the first clue indexing stage and the random pool for the second clue indexing stage, where the first clue indexing stage is the task stage for obtaining the first clue fragment and the second clue indexing stage is the task stage for obtaining the second clue fragment.

[0172] In an optional embodiment, the first clue indexing stage may be a task stage for obtaining first clue fragments.

[0173] In an optional embodiment, the second clue indexing stage may be a task stage for obtaining second clue fragments.

[0174] In an optional embodiment, the random pool for the first clue indexing phase may be a random pool determined from at least two event random pools for obtaining the first clue fragment during the first clue indexing phase.

[0175] In an optional embodiment, the random pool for the second clue indexing phase may be a random pool determined from at least two event random pools for obtaining the second clue fragment during the second clue indexing phase.

[0176] It should be noted that in this embodiment, in the case of a special clue in which the virtual clue is composed of a first clue fragment and a second clue fragment, in the process of determining the first random pool of the first task stage and the second random pool of the second task stage, the random pool of the first clue index stage and the random pool of the second clue index stage are further determined from at least two event random pools.

[0177] Specifically, the first step is to determine whether the virtual clue is a special clue composed of fragments of the first and second clues. The first random pool for the first task phase and the second random pool for the second task phase are determined from at least two event random pools.

[0178] Based on the above, the random pool for the first clue indexing stage and the random pool for the second clue indexing stage are determined from at least two event random pools, wherein the first clue indexing stage is the task stage for obtaining the first clue fragment, and the second clue indexing stage is the task stage for obtaining the second clue fragment.

[0179] To further illustrate, consider an adventure puzzle game where a virtual quest is "finding a mysterious treasure." The virtual clues consist of an "ancient map fragment" (first clue fragment) and a "mysterious key clue" (second clue fragment). The game system determines that this virtual clue is a special clue composed of the "ancient map fragment" and the "mysterious key clue." The game has at least two event random pools, each storing relevant information for different stages of the quest.

[0180] The first task phase is determined to be "Exploring Ancient Ruins". A first random pool that meets the requirements of this phase is selected from at least two event random pools. This random pool contains task events and reward information related to exploring ancient ruins.

[0181] The second task phase is determined to be "finding the location of the mysterious treasure". A second random pool that meets the requirements of this phase is selected from at least two event random pools. This random pool contains task events and hints related to finding the location of the mysterious treasure.

[0182] The first clue indexing phase is determined to be "solving the puzzles in the ancient ruins to obtain ancient map fragments". The random pool for the first clue indexing phase is determined from at least two event random pools. This random pool contains task events related to solving the puzzles in the ancient ruins and ways to obtain ancient map fragments.

[0183] The second clue indexing phase is determined to be "Searching for clues to the mysterious key in a mysterious location". A random pool for the second clue indexing phase is determined from at least two event random pools. This random pool contains task events and hints related to searching for clues to the mysterious key in a mysterious location.

[0184] Optionally, the content of this embodiment can be applied to other embodiments described above, or combined with other embodiments described above.

[0185] The embodiments provided in this application determine a random pool for the first clue indexing stage and a random pool for the second clue indexing stage from at least two event random pools. The first clue indexing stage is the task stage for obtaining the first clue fragment, and the second clue indexing stage is the task stage for obtaining the second clue fragment. By clearly defining the composition of the virtual clues and each clue indexing stage, the logic of the virtual task is made clearer, allowing players to better understand the task's flow and objectives. Different clue indexing stages and corresponding random pools provide players with a diverse gaming experience, increasing the game's fun and challenge.

[0186] As an optional approach, before obtaining the first and second task phases in response to a configuration request triggered by a preset virtual task, the method further includes:

[0187] S6-1, Obtain the task container of the preset virtual task;

[0188] S6-2, in response to the setting request for the task container, obtain multiple data prefabs and place the multiple data prefabs in the task container, wherein the data prefabs are used to provide game data for the preset virtual task, and the game data includes task event data;

[0189] S6-3 binds the task container to the gameplay blueprint of each virtual task. The gameplay blueprint is used to provide execution logic for the preset virtual tasks. The execution logic includes the logic of task events.

[0190] S6-4. Arrange the configured task containers in a virtual scene, where the virtual scene is a preset scene in which virtual tasks are allowed to execute.

[0191] In an optional embodiment, the setup request may be a request to perform setup operations on the task container.

[0192] In an optional embodiment, the data prefab can be a pre-made data unit used to provide game data for a preset virtual task.

[0193] In an optional embodiment, the game data may include data such as task events, which is the data required for the operation of a preset virtual task.

[0194] In an optional embodiment, the gameplay blueprint may be a blueprint used to provide execution logic for a preset virtual task, including logic for task events, etc.

[0195] In an optional embodiment, the execution logic may be the preset running rules and processes of the virtual task, including the logic of task events.

[0196] In an optional embodiment, the virtual scene can be a scene in which a preset virtual task is allowed to be executed, which is the spatial environment in which the task occurs.

[0197] It should be noted that in this embodiment, a series of preliminary preparations are performed on the preset virtual task before obtaining the first task stage and the second task stage in response to the configuration request triggered by the preset virtual task.

[0198] Specifically, the system first obtains a task container for the preset virtual task, providing a foundation for storage and management in subsequent operations. In response to a request to set up the task container, it retrieves multiple data prefabs and places them within the task container. These data prefabs provide game data for the preset virtual task, including task event data.

[0199] The task containers are then further bound to the gameplay blueprints of each virtual task. The gameplay blueprints provide the execution logic for the preset virtual tasks, including the logic for task events. The configured task containers are then deployed in a virtual scene, which is a scene where the preset virtual tasks are allowed to execute.

[0200] Optionally, the content of this embodiment can be applied to other embodiments described above, or combined with other embodiments described above.

[0201] The embodiments provided in this application involve obtaining a task container for a preset virtual task; responding to a setting request for the task container, obtaining multiple data prefabs and placing them within the task container, wherein the data prefabs provide game data for the preset virtual task, including task event data; binding the task container to the gameplay blueprints of each virtual task, wherein the gameplay blueprints provide execution logic for the preset virtual task, including task event logic; and deploying the set task container in a virtual scene, wherein the virtual scene is a scene where the preset virtual task is allowed to execute. Through the separate design of the task container, data prefabs, and gameplay blueprints, developers can independently develop and test different parts of the task, improving the efficiency and quality of task development. The task container allows for easy addition, deletion, or modification of data prefabs and gameplay blueprints, making the preset virtual task highly scalable and allowing for adjustments and updates at any time according to game needs.

[0202] As an optional approach, after arranging the configured task containers in the virtual scene, the method also includes:

[0203] S7-1, in response to the first adjustment request triggered on the configured task container, adjust the data prefab placed in the task container; or...

[0204] S7-2, in response to a second adjustment request triggered on a configured task container, adjusts the gameplay blueprint bound to the task container.

[0205] In an optional embodiment, the configured task container can be a task container that has already completed setup operations such as data prefab placement and gameplay blueprint binding.

[0206] In an optional embodiment, the first adjustment request may be a request to adjust the data prefab in the configured task container.

[0207] In an optional embodiment, the second adjustment request may be a request to adjust the gameplay blueprint bound to the configured task container.

[0208] It should be noted that this embodiment provides a mechanism for further adjusting the task containers after they have been set up and arranged in the virtual scene.

[0209] Specifically, the configured task containers are first deployed in the virtual scene to provide a basic environment for the execution of preset virtual tasks. When the first adjustment request triggered by the configured task containers is received, the data prefabs placed in the task containers are adjusted to meet the changing needs of task data during game development or operation.

[0210] When a second adjustment request is received that triggers the configured task container, the gameplay blueprint bound to the task container is adjusted to change the execution logic of the preset virtual task, thereby increasing the diversity and playability of the game.

[0211] Optionally, the content of this embodiment can be applied to other embodiments described above, or combined with other embodiments described above.

[0212] Through the embodiments provided in this application, in response to a first adjustment request triggered on a set task container, the data prefab placed in the task container is adjusted; or, in response to a second adjustment request triggered on a set task container, the gameplay blueprint bound to the task container is adjusted. By providing adjustment mechanisms for the data prefab and gameplay blueprint of the task container, the game can be flexibly adjusted according to different needs and situations, improving the game's adaptability and playability.

[0213] As an optional approach, before randomly selecting the first task event from the first random pool, the method further includes: assigning a first weight to each task event in the first random pool according to the task characteristics of the preset virtual task, wherein the first weight is used to increase the probability that a task event matching the task characteristics of the preset virtual task is randomly selected from the first random pool.

[0214] The first task event is randomly selected from the first random pool, including: using the first weight, the first task event is randomly selected from the first random pool;

[0215] Before randomly selecting a second task event from the second random pool, the method further includes: assigning a second weight to each task event in the second random pool according to the task characteristics of the preset virtual task, wherein the second weight is used to increase the probability that a task event matching the task characteristics of the preset virtual task is randomly selected from the second random pool;

[0216] The second task event is randomly selected from the second random pool, including: using the second weight to randomly select the second task event from the second random pool.

[0217] In an optional embodiment, the task characteristics can be features of a preset virtual task, such as task type, difficulty level, theme style, etc., which are used to guide the allocation and extraction of task events.

[0218] In an optional embodiment, the first weight may be a value assigned to each task event in the first random pool, used to increase the probability that a task event matching the task characteristics of a preset virtual task is randomly selected.

[0219] In an optional embodiment, the second weight may be a value assigned to each task event in the second random pool, used to increase the probability that a task event matching the task characteristics of a preset virtual task is randomly selected.

[0220] It should be noted that this embodiment aims to assign weights to task events in two random pools (the first random pool and the second random pool) based on the task characteristics of the preset virtual task, so as to increase the probability of task events that match the task characteristics being randomly selected, thereby achieving task event extraction that better meets the needs of the preset virtual task.

[0221] Specifically, based on the task characteristics of the preset virtual task, a first weight and a second weight are assigned to each task event in the first random pool and the second random pool, respectively. When randomly selecting task events from the first random pool and the second random pool, the assigned first weight and second weight are used to increase the probability of selecting task events that match the task characteristics of the preset virtual task.

[0222] Optionally, the content of this embodiment can be applied to other embodiments described above, or combined with other embodiments described above.

[0223] According to the embodiments provided in this application, a first weight is assigned to each task event in a first random pool based on the task characteristics of a preset virtual task. This first weight increases the probability that a task event matching the task characteristics of the preset virtual task will be randomly selected from the first random pool. Using the first weight, a first task event is randomly selected from the first random pool. Similarly, a second weight is assigned to each task event in a second random pool based on the task characteristics of the preset virtual task. This second weight increases the probability that a task event matching the task characteristics of the preset virtual task will be randomly selected from the second random pool. Using the second weight, a second task event is randomly selected from the second random pool. By assigning weights based on the task characteristics of the preset virtual task, the randomly selected task events are more aligned with the task requirements, improving the matching degree between the task and the preset virtual task. Different task characteristics correspond to different weight assignments, thereby generating various combinations of task events, increasing the diversity and playability of the game.

[0224] As an optional approach, for ease of understanding, the above-mentioned virtual task configuration method is applied to a virtual game scene of treasure map gameplay. Specifically, this embodiment proposes a development process for batch production of random treasure map gameplay. By creating treasure map sublayers and process blueprints, and binding them as needed according to the requirements of different gameplay modes, it satisfies the need for batch production while supporting customized or randomized treasure map gameplay processes. The process blueprint is used to edit the specific gameplay flow of the treasure map, dividing the gameplay into stages and allowing for the randomization of different events at different stages. The treasure map sublayer serves as the carrier for storing treasure map gameplay data and associating it with the blueprint process. A sublayer can be understood as a layer or container in game development, used to organize and manage game objects. In the game scene, the sublayer helps developers better organize and manage game objects, making the scene structure clearer.

[0225] The game already has a large world map with a consistent scale to the game's 3D scene. Treasure map locations can be randomly divided within a defined range on the corresponding world map by the game designers, and markers with positional offsets can be added. Later, the treasure map images can be further processed in batches using pre-defined graphical user interface (GUI) stylized textures or filters. This implementation reduces GUI production costs, increases the overall randomness and variety of gameplay, and provides players with more diverse puzzle-solving options. The treasure map is randomly refreshed to a suitable medium (such as NPCs, treasure chests, etc.) based on pre-defined placement conditions.

[0226] In an optional embodiment, treasure maps are first categorized into common treasure maps and seasonal treasure maps. Common treasure maps are further divided into three quality levels: Common, Rare, and Epic, while seasonal treasure maps are of Legendary quality. The distribution of treasure maps will be random or customized based on their quality level, placing them in different gameplay modes or on NPCs. Common treasure maps, being the easiest to obtain in the game, contain location information and gameplay details. They are consumables and disappear after the player obtains the treasure map reward. Seasonal treasure maps require collecting a certain number of treasure map fragments to synthesize, contain location information and gameplay details, and are also consumables that disappear after the player obtains the treasure map reward. They are refreshed in the game upon seasonal reset.

[0227] Seasonal treasure maps are a limited number released each season. A complete treasure map requires collecting N treasure map fragments (where N is an integer greater than 1) to craft. Seasonal treasure map fragments drop randomly and only once per season, ensuring no duplicate fragments are obtained. Once all fragments are acquired, the drop method will be replaced by random regular treasure maps.

[0228] Once you obtain a regular treasure map, you can simply follow the map's clues to the designated location to trigger its random gameplay. The difficulty and complexity of the treasure map gameplay will be randomized based on the treasure map's quality level.

[0229] The treasure map distribution method can also be adapted to various distribution channels (shared distribution limit), such as... Figure 4 As shown, taking the Treasure Map 402 being placed on an NPC as an example, the system will daily select random NPCs that meet certain conditions (such as character A, character B, character C, and character D), and determine the quality level of the Treasure Map 402 placed on that NPC based on the NPC's own attributes (such as level and combat AI difficulty). Players can obtain Treasure Map 402 from NPCs through various in-game actions such as defeating them in combat, requesting them from the AI, or purchasing them with real money. Treasure Map 402 will preferentially appear on NPCs near the player who are not carrying a Treasure Map (such as character D).

[0230] Drag and drop all prefab data that might be randomly or custom-triggered in the treasure map process into the treasure map's sublayer. In subsequent blueprint configuration processes, the created prefabs can be activated and called according to the process requirements to meet the differentiated needs of different processes. A prefab is a type of prefab in game development; it's a collection of pre-made game objects or components that can be reused in the game. A prefab contains the complete configuration of the game object, including properties, components, and sub-objects.

[0231] Optional, for example Figure 5 As shown, the specific location information of the treasure map can be obtained by dragging the container (sublayer) 502 into the large world scene 504 in the game editor according to the required number of treasure maps. The program logic will make the large world GUI map correspond to the scene map proportionally, and after adding the position offset, form the in-game image of the treasure map, thereby realizing the batch creation of treasure map props and treasure map image information.

[0232] Each treasure map, as an independent entity, can be bound to the same or different process blueprints to achieve mass production or special customization of the processes required for certain gameplay / tasks. The blueprint can realize the special event processes of the gameplay, rewards and other differentiated configurations.

[0233] To further illustrate, an example flow for the optional treasure map gameplay is as follows: Figure 6 As shown, the specific steps are as follows:

[0234] S602, Obtain the treasure map.

[0235] Players obtain treasure maps by completing main quests, defeating specific bosses, participating in limited-time events, or triggering random events (such as exploring hidden areas or talking to mysterious NPCs). Treasure maps are divided into three levels based on rarity: common, rare, and epic. Different levels correspond to different difficulties and rewards. Once obtained, the treasure maps are automatically stored in the player's inventory.

[0236] S604, Deciphering the Treasure Map.

[0237] Players double-click the treasure map in their inventory to enter the analysis interface. The interface displays a blurry map of the treasure map and clues. Once the analysis is successful, the exact location of the treasure is marked on the map.

[0238] S606, head to the treasure location.

[0239] Players tap the map marker to activate the navigation system. As they approach the treasure location, a light effect appears at the edge of the screen, accompanied by a special sound effect.

[0240] S608, digging for treasure.

[0241] Upon reaching the treasure location, players must complete one of the following actions: play a mini-game (such as solving a puzzle to unlock a treasure chest, or a rhythm game to trigger a mechanism), solve a puzzle (such as rotating a stone tablet to align symbols, or adjusting the flow of water in a canal), or complete a battle verification (such as defeating a guardian boss; the boss's strength is linked to the treasure map's level). After successfully excavating, the treasure location will emit a golden light effect, displaying the reward information.

[0242] S610, Rewards and Feedback.

[0243] The reward display can include various types of rewards, such as basic rewards (e.g., gold coins, experience points), rare rewards (e.g., equipment, skill books, pet eggs), bonus rewards (e.g., special titles, limited skins), and achievement systems (e.g., unlocking achievements such as "first treasure discovery" and "analyzing 100 treasure maps," which provide additional rewards).

[0244] Players can repeat the above process to obtain other players' treasure maps through the trading system (such as the auction house) or through events to obtain limited treasure maps.

[0245] The treasure map gameplay can be linked to the game's economic system, and rare rewards can enhance player strength, promoting the cycle of PVP / PVE content.

[0246] Depending on the quality level of the treasure map itself, the random events of the treasure map will be randomly combined in the random pool at different stages to form new special events, including but not limited to the type and level of the monster guarding the treasure, whether there are additional enemies who would steal from the treasure, whether additional rewards can be obtained, whether additional mechanisms are triggered, etc.

[0247] During subsequent production, the planners can, as needed, fill or expand the random event library at any stage of the treasure map gameplay blueprint process with various modules such as gameplay, content, mechanics, and combat. They can also add new process stages to meet the needs of more diverse randomness in the treasure map gameplay.

[0248] While it possesses a degree of randomness, each random stage in the treasure map gameplay is independent. Testing only requires extreme case analysis of each random option in the random event pool for each stage. Subsequent random events only need to be tested on a single time period. For random events that may be mutually exclusive across different stages, mutual exclusion configurations can be implemented to prevent such situations from occurring.

[0249] To further illustrate, optional examples include... Figure 7 As shown, the production chain for the treasure map gameplay is as follows:

[0250] S702, based on the requirements of the treasure map gameplay, creates the basic configuration for the treasure map gameplay container (sublayer). This configuration can add all the prefabs required for the treasure map, including the treasure location itself, monsters or other NPCs needed for special events, mechanisms, etc. It also develops or ports the functional logic for the gameplay's random events.

[0251] S704, on the sublayer, executes the gameplay blueprint required for binding the treasure map gameplay, distinguishes the process stages of random events, and places the corresponding events into the corresponding process stages.

[0252] S706, in the editor, select a suitable location in the world as a treasure map embedding point, and drag the sublayer from the above process into the scene for placement.

[0253] S708 configures the offset values ​​of the generated treasure map images for the selected treasure map locations, and uses tools to batch generate treasure map location information and treasure map GUI images.

[0254] S710, export the world configuration data of the treasure map, the treasure map image data, and the blueprint gameplay data.

[0255] S712, complete the creation of the treasure map item and treasure map gameplay process.

[0256] Optionally, the content of this embodiment can be applied to other embodiments described above, or combined with other embodiments described above.

[0257] Through the embodiments provided in this application, for the treasure map gameplay of mass production, the randomness of the general process blueprint can be achieved by designing multiple branches and controlling the weight of each branch to achieve randomness and fun.

[0258] This embodiment can reduce the workload of the GUI for batch production of treasure maps, and also reduce the workload of planning and configuring the batch production of treasure map gameplay, while retaining the ability to customize the process for specific treasure maps, and at the same time taking into account the efficiency and scalability of batch gameplay production.

[0259] It is understood that in the specific embodiments of this application, data such as user information are involved. When the above embodiments of this application are applied to specific products or technologies, user permission or consent is required, and the collection, use and processing of related data must comply with the relevant laws, regulations and standards of the relevant countries and regions.

[0260] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that this application is not limited to the described order of actions, as some steps may be performed in other orders or simultaneously according to this application. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions and modules involved are not necessarily essential to this application.

[0261] According to another aspect of the embodiments of this application, a virtual task configuration apparatus for implementing the above-described virtual task configuration method is also provided. For example... Figure 8 As shown, the device includes:

[0262] The first acquisition unit 802 is used to acquire a first task stage and a second task stage in response to a configuration request triggered by a preset virtual task, wherein the first task stage and the second task stage are used to form the task flow of the preset virtual task.

[0263] The first determining unit 804 is used to determine a first random pool for a first task phase and a second random pool for a second task phase from at least two event random pools, wherein the random items in the event random pool are task events, and the task events are events triggered in the task phase.

[0264] The first random unit 806 is used to randomly select the first task event from the first random pool and determine the first task event as the task event corresponding to the first task stage.

[0265] The second random unit 808 is used to randomly select the second task event from the second random pool and determine the second task event as the task event corresponding to the second task stage.

[0266] Configuration unit 810 is used to configure a preset virtual task based on a first task event and a second task event.

[0267] For specific implementation examples, please refer to the examples shown in the configuration method of the virtual task above, which will not be repeated here.

[0268] As an optional solution, the device also includes:

[0269] The second acquisition unit is used to acquire multiple initial event random pools before randomly selecting the first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage.

[0270] The test unit is used to perform conflict tests on task events in multiple initial event random pools before randomly selecting a first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage, and to obtain test results. The test results are used to represent the conflict situation between at least two task events in multiple initial event random pools.

[0271] The coordination unit is used to coordinate the conflicting task events in multiple initial event random pools based on test results before randomly selecting the first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage, so as to obtain the coordinated task event. At least two event random pools include the coordinated task event and the task event without conflict.

[0272] For specific implementation examples, please refer to the examples shown in the configuration method of the virtual task above, which will not be repeated here.

[0273] As an optional solution, the test unit includes:

[0274] The first testing module is used to perform conflict tests on multiple task events corresponding to the first task stage from multiple initial event random pools to obtain a first result, wherein the test result includes the first result;

[0275] The second testing module is used to perform conflict tests on multiple task events corresponding to the second task stage from multiple initial event random pools to obtain a second result, wherein the test result includes the second result;

[0276] Coordination units, including:

[0277] The first coordination module is used to coordinate the conflicting task events among multiple task events in the first task phase based on the first result, so as to obtain the coordinated task events in the first task phase. The first random pool includes the coordinated task events in the first task phase and the task events that do not conflict in the first task phase.

[0278] The second coordination module is used to coordinate the conflicting task events among multiple task events in the second task phase based on the second result, so as to obtain the coordinated task events in the second task phase. The second random pool includes the coordinated task events in the second task phase and the task events that do not conflict with the second task phase.

[0279] For specific implementation examples, please refer to the examples shown in the configuration method of the virtual task above, which will not be repeated here.

[0280] As an optional solution, the device also includes:

[0281] The tagging unit is used to coordinate conflicting task events in multiple initial event random pools based on test results to obtain coordinated task events. In the case where the test results indicate that there are mutually exclusive first and second events in multiple initial event random pools, the first and second events are tagged with mutual exclusion labels. Task events with mutual exclusion labels are prohibited from being configured in the same virtual task.

[0282] For specific implementation examples, please refer to the examples shown in the configuration method of the virtual task above, which will not be repeated here.

[0283] As an optional solution, the device also includes:

[0284] The second determining unit is used to determine a third random pool that meets the task level from at least two object random pools when, in the process of randomly selecting a first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage, the task level corresponding to the preset virtual task is obtained. The random items in the object random pool are task objects, and the task objects are virtual objects that interact during the virtual task process.

[0285] The third random unit is used to randomly select a virtual task object from the third random pool during the process of randomly selecting a first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage, and to determine the virtual task object as the task object that triggers the first task event.

[0286] For specific implementation examples, please refer to the examples shown in the configuration method of the virtual task above, which will not be repeated here.

[0287] As an alternative, the third random unit includes:

[0288] The first random module is used to randomly select the first non-player character from the third random pool when the third random pool is a random pool that meets the first task level, and to determine the first non-player character as the virtual character that triggers the first task event.

[0289] The second random module is used to randomly select a second non-player character from the third random pool when the third random pool is a random pool that meets the second task level, and to determine the second non-player character as the virtual character that triggers the second task event. The second task level is higher than the first task level, and the interaction difficulty of the second virtual character is higher than the interaction difficulty of the first virtual character.

[0290] For specific implementation examples, please refer to the examples shown in the configuration method of the virtual task above, which will not be repeated here.

[0291] As an optional solution, the second determining unit includes:

[0292] The first determining module is used to determine a third random pool from at least two object random pools when a preset virtual task requires the completion of virtual clues and the clue level of the virtual clues is obtained. The third random pool is a random pool that meets the clue level, and the task level includes the clue level.

[0293] For specific implementation examples, please refer to the examples shown in the configuration method of the virtual task above, which will not be repeated here.

[0294] As an optional solution, the device also includes:

[0295] The second determining module is used to determine, in the case where the virtual clue is a special clue composed of a first clue fragment and a second clue fragment, the random pool for the first clue index stage and the random pool for the second clue index stage from at least two event random pools during the process of determining the first random pool for the first task stage and the second random pool for the second task stage from at least two event random pools, wherein the first clue index stage is the task stage for obtaining the first clue fragment and the second clue index stage is the task stage for obtaining the second clue fragment.

[0296] For specific implementation examples, please refer to the examples shown in the configuration method of the virtual task above, which will not be repeated here.

[0297] As an optional solution, the device also includes:

[0298] The third acquisition unit is used to acquire the task container of the preset virtual task before acquiring the first task stage and the second task stage in response to the configuration request triggered by the preset virtual task.

[0299] The fourth acquisition unit is used to acquire multiple data prefabs in response to a configuration request triggered by a preset virtual task, before acquiring the first task stage and the second task stage, and to place the multiple data prefabs in the task container in response to a setting request for the task container. The data prefabs are used to provide game data for the preset virtual task, and the game data includes data of task events.

[0300] The binding unit is used to bind the task container to the gameplay blueprint of each virtual task before obtaining the first task stage and the second task stage in response to the configuration request triggered by the preset virtual task. The gameplay blueprint is used to provide execution logic for the preset virtual task, and the execution logic includes the logic of task events.

[0301] The deployment unit is used to deploy the configured task container in a virtual scene in response to a configuration request triggered by a preset virtual task and before obtaining the first task stage and the second task stage. The virtual scene is a scene in which the preset virtual task is allowed to execute.

[0302] For specific implementation examples, please refer to the examples shown in the configuration method of the virtual task above, which will not be repeated here.

[0303] As an optional solution, the device also includes:

[0304] The first adjustment unit is configured to adjust the data prefab placed within the task container in response to a first adjustment request triggered by the task container after the configured task container has been deployed in the virtual scene; or...

[0305] The second adjustment unit is used to adjust the gameplay blueprint bound to the task container in response to a second adjustment request triggered by the task container after the task container has been set up in the virtual scene.

[0306] For specific implementation examples, please refer to the examples shown in the configuration method of the virtual task above, which will not be repeated here.

[0307] As an optional solution, the device further includes: a first allocation unit, configured to assign a first weight to each task event in the first random pool according to the task characteristics of a preset virtual task before randomly selecting a first task event from the first random pool, wherein the first weight is used to increase the probability that a task event matching the task characteristics of the preset virtual task is randomly selected from the first random pool;

[0308] The first random unit 806 includes: a third random module, used to randomly select a first task event from the first random pool using a first weight;

[0309] The device further includes: a second allocation unit, configured to assign a second weight to each task event in the second random pool according to the task characteristics of a preset virtual task before randomly selecting a second task event from the second random pool, wherein the second weight is used to increase the probability that a task event matching the task characteristics of the preset virtual task is randomly selected from the second random pool;

[0310] The second random unit 808 includes: a fourth random module, used to randomly select a second task event from the second random pool using a second weight.

[0311] For specific implementation examples, please refer to the examples shown in the configuration method of the virtual task above, which will not be repeated here.

[0312] According to another aspect of the embodiments of this application, an electronic device for implementing the above-described configuration method for virtual tasks is also provided. This electronic device may, but is not limited to, […]. Figure 1 The user equipment 102 or server 112 shown in the figure, in this embodiment, is taken as an example of an electronic device, namely user equipment 102. Further, as shown in the figure... Figure 9 As shown, the electronic device includes a memory 902 and a processor 904. The memory 902 stores a computer program, and the processor 904 is configured to execute the steps of any of the above method embodiments through the computer program.

[0313] In an optional embodiment, the aforementioned electronic device may be located in at least one of a plurality of network devices in a computer network.

[0314] In an optional embodiment, the processor described above may be configured to perform the following steps via a computer program:

[0315] S1, in response to the configuration request triggered by the preset virtual task, obtain the first task stage and the second task stage, wherein the first task stage and the second task stage are used to form the task flow of the preset virtual task.

[0316] S2, determine the first random pool for the first task phase and the second random pool for the second task phase from at least two event random pools, wherein the random items in the event random pool are task events, which are events triggered during the task phase;

[0317] S3, randomly select the first task event from the first random pool, and determine the first task event as the task event corresponding to the first task stage;

[0318] S4. Randomly select the second task event from the second random pool and determine the second task event as the task event corresponding to the second task stage;

[0319] S5 configures preset virtual tasks based on the first task event and the second task event.

[0320] Alternatively, as those skilled in the art will understand, Figure 9 The structure shown is for illustrative purposes only. Figure 9 This does not limit the structure of the aforementioned electronic devices. For example, the electronic device may also include components that are more... Figure 9 The more or fewer components shown (such as network interfaces, etc.), or having the same Figure 9 The different configurations shown.

[0321] The memory 902 can be used to store software programs and modules, such as the program instructions / modules corresponding to the virtual task configuration method and apparatus in this embodiment. The processor 904 executes various functional applications and data processing by running the software programs and modules stored in the memory 902, thereby implementing the aforementioned virtual task configuration method. The memory 902 may include high-speed random access memory and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory 902 may further include memory remotely located relative to the processor 904, and these remote memories can be connected to electronic devices via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof. Specifically, the memory 902 may be used, but is not limited to, to store information such as first task events, second task events, and preset virtual tasks. As an example, such as... Figure 9As shown, the memory 902 may include, but is not limited to, the first acquisition unit 802, the first determination unit 804, the first randomization unit 806, the second randomization unit 808, and the configuration unit 810 of the virtual task configuration device. Furthermore, it may include, but is not limited to, other module units of the virtual task configuration device, which will not be elaborated upon in this example.

[0322] Optionally, the transmission device 906 described above is used to receive or send data via a network. Specific examples of the network described above may include wired networks and wireless networks. In one example, the transmission device 906 includes a Network Interface Controller (NIC), which can be connected to other network devices and routers via a network cable to communicate with the Internet or a local area network. In another example, the transmission device 906 is a Radio Frequency (RF) module, used for wireless communication with the Internet.

[0323] In addition, the aforementioned electronic device also includes: a display 908 for displaying information such as the first task event, the second task event, and preset virtual tasks; and a connection bus 910 for connecting various module components in the aforementioned electronic device.

[0324] In other embodiments, the aforementioned user equipment or server can be a node in a distributed system, wherein the distributed system can be a blockchain system, which is a distributed system formed by connecting multiple nodes through network communication. The nodes can form a peer-to-peer network, and any form of computing device, such as a server, user equipment, or other electronic device, can become a node in the blockchain system by joining this peer-to-peer network.

[0325] According to one aspect of this application, a computer program product is provided, comprising a computer program / instructions containing program code for performing the methods shown in the flowchart. In such embodiments, the computer program can be downloaded and installed from a network via a communication component, and / or installed from a removable medium. When the computer program is executed by a central processing unit, it performs various functions provided in embodiments of this application.

[0326] The sequence numbers of the embodiments in this application are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0327] It should be noted that the computer system of the electronic device is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of this application.

[0328] A computer system includes a Central Processing Unit (CPU), which performs various appropriate actions and processes based on programs stored in Read-Only Memory (ROM) or loaded from RAM. ROM also stores various programs and data required for system operation. The CPU, ROM, and RAM are interconnected via a bus. Input / output interfaces (I / O interfaces) are also connected to the bus.

[0329] The following components are connected to the input / output interface: input sections including keyboards, mice, etc.; output sections including cathode ray tubes (CRTs), liquid crystal displays (LCDs), and speakers; storage sections including hard drives; and communication sections including network interface cards such as LAN cards and modems. The communication section performs communication processing via a network such as the Internet. Drives are also connected to the input / output interface as needed. Removable media, such as disks, optical discs, magneto-optical discs, semiconductor memories, etc., are installed on the drive as needed so that computer programs read from them can be installed into the storage section as required.

[0330] Specifically, according to embodiments of this application, the processes described in the various method flowcharts can be implemented as computer software programs. For example, embodiments of this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication component, and / or installed from a removable medium. When the computer program is executed by a central processing unit, it performs various functions defined in the system of this application.

[0331] According to one aspect of this application, a computer-readable storage medium is provided, wherein a processor of a computer device reads computer instructions from the computer-readable storage medium, and executes the computer instructions, causing the computer device to perform the methods provided in the various alternative implementations described above.

[0332] In an optional embodiment, the computer-readable storage medium described above may be configured to store a computer program for performing the following steps:

[0333] S1, in response to the configuration request triggered by the preset virtual task, obtain the first task stage and the second task stage, wherein the first task stage and the second task stage are used to form the task flow of the preset virtual task.

[0334] S2, determine the first random pool for the first task phase and the second random pool for the second task phase from at least two event random pools, wherein the random items in the event random pool are task events, which are events triggered during the task phase;

[0335] S3, randomly select the first task event from the first random pool, and determine the first task event as the task event corresponding to the first task stage;

[0336] S4. Randomly select the second task event from the second random pool and determine the second task event as the task event corresponding to the second task stage;

[0337] S5 configures preset virtual tasks based on the first task event and the second task event.

[0338] Optionally, in embodiments of this application, the terms "module" or "unit" refer to a computer program or part of a computer program that has a predetermined function and works with other related parts to achieve a predetermined goal, and can be implemented wholly or partially using software, hardware (such as processing circuitry or memory), or a combination thereof. Similarly, a processor (or multiple processors or memory) can be used to implement one or more modules or units. Furthermore, each module or unit can be part of an overall module or unit that includes the functionality of that module or unit.

[0339] In optional embodiments, those skilled in the art will understand that all or part of the steps in the various methods of the above embodiments can be implemented by a program instructing related hardware of an electronic device. The program can be stored in a computer-readable storage medium, which may include: a flash drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk, etc.

[0340] The sequence numbers of the embodiments in this application are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0341] If the integrated units in the above embodiments are implemented as software functional units and sold or used as independent products, they can be stored in the aforementioned computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause one or more computer devices (which may be personal computers, servers, or network devices, etc.) to execute all or part of the steps of the methods of the various embodiments of this application.

[0342] In the above embodiments of this application, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0343] In the several embodiments provided in this application, it should be understood that the disclosed user equipment can be implemented in other ways. The device embodiments described above are merely illustrative; for example, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection of units or modules may be electrical or other forms.

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

[0345] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0346] The above description is only a preferred embodiment of this application. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of this application, and these improvements and modifications should also be considered within the scope of protection of this application.

Claims

1. A method for configuring virtual tasks, characterized in that, include: In response to a configuration request triggered by a preset virtual task, a first task stage and a second task stage are obtained, wherein the first task stage and the second task stage are used to form the task flow of the preset virtual task. From at least two event random pools, a first random pool for the first task phase and a second random pool for the second task phase are determined, wherein the random items in the event random pools are task events, which are events triggered during the task phase; A first task event is randomly selected from the first random pool, and the first task event is determined as the task event corresponding to the first task stage; A second task event is randomly selected from the second random pool, and the second task event is determined as the task event corresponding to the second task stage; The preset virtual task is configured based on the first task event and the second task event.

2. The method according to claim 1, characterized in that, Before randomly selecting a first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage, the method further includes: Obtain multiple initial event random pools; Conflict tests are performed on the task events in the plurality of initial event random pools to obtain test results, wherein the test results are used to indicate the conflict situation between at least two task events in the plurality of initial event random pools; Based on the test results, conflict coordination is performed on the task events with conflicting conditions in the multiple initial event random pools to obtain coordinated task events. The at least two event random pools include the coordinated task events and task events without conflicting conditions.

3. The method according to claim 2, characterized in that, The conflict test is performed on the task events in the multiple initial event random pools to obtain the test results, including: Conflict tests are performed on multiple task events corresponding to the first task stage in the multiple initial event random pools to obtain a first result, wherein the test result includes the first result; Conflict tests are performed on multiple task events corresponding to the second task stage in the multiple initial event random pools to obtain a second result, wherein the test result includes the second result; Based on the test results, conflict coordination is performed on the conflicting task events in the multiple initial event random pools to obtain coordinated task events, including: Based on the first result, conflict coordination is performed on the multiple task events in the first task phase that have the conflict situation to obtain the coordinated task events in the first task phase. The first random pool includes the coordinated task events in the first task phase and the task events that do not have the conflict situation in the first task phase. Based on the second result, conflict coordination is performed on the multiple task events in the second task phase that have the conflict, to obtain the coordinated task events in the second task phase. The second random pool includes the coordinated task events in the second task phase and the task events in the second task phase that do not have the conflict.

4. The method according to claim 2, characterized in that, In the process of resolving conflicts among the multiple initial random pools of events with conflicting conditions based on the test results, and obtaining reconciled task events, the method further includes: If the test results indicate that there is a mutually exclusive first event and a second event in the plurality of initial event random pools, the first event and the second event are marked with a mutual exclusion label, wherein task events with the mutual exclusion label are prohibited from being configured in the same virtual task.

5. The method according to claim 1, characterized in that, In the process of randomly selecting a first task event from the first random pool and determining the first task event as the task event corresponding to the first task stage, the method further includes: Given the task level corresponding to the preset virtual task, a third random pool that meets the task level is determined from at least two object random pools, wherein the random items in the object random pool are task objects, and the task objects are virtual objects that interact during the virtual task. From the third random pool, a virtual task object is randomly selected, and the virtual task object is determined as the task object that triggers the first task event.

6. The method according to claim 5, characterized in that, The step of randomly selecting a virtual task object from the third random pool and determining the virtual task object as the task object that triggers the first task event includes: If the third random pool is a random pool that meets the first task level, a first non-player character is randomly selected from the third random pool, and the first non-player character is determined as the virtual character that triggers the first task event. If the third random pool is a random pool that meets the second task level, a second non-player character is randomly selected from the third random pool and the second non-player character is determined as the virtual character that triggers the second task event. The second task level is greater than the first task level, and the interaction difficulty of the second virtual character is greater than the interaction difficulty of the first virtual character.

7. The method according to claim 5, characterized in that, When the preset virtual task requires virtual clues to complete, the step of determining a third random pool that matches the task level from at least two object random pools, after obtaining the task level corresponding to the preset virtual task, includes: Upon obtaining the clue level of the virtual clue, a third random pool is determined from the at least two object random pools, wherein the third random pool conforms to the random pool of the clue level, and the task level includes the clue level.

8. The method according to claim 7, characterized in that, In the case where the virtual clue is a special clue composed of a first clue fragment and a second clue fragment, the method further includes, in the process of determining the first random pool for the first task phase and the second random pool for the second task phase from at least two event random pools: From the at least two event random pools, determine the random pool for the first clue indexing stage and the random pool for the second clue indexing stage, wherein the first clue indexing stage is the task stage for obtaining the first clue fragment, and the second clue indexing stage is the task stage for obtaining the second clue fragment.

9. The method according to claim 1, characterized in that, Before obtaining the first task stage and the second task stage in response to a configuration request triggered by a preset virtual task, the method further includes: Obtain the task container of the preset virtual task; In response to a setting request for the task container, multiple data prefabs are obtained and placed in the task container, wherein the data prefabs are used to provide game data for the preset virtual task, and the game data includes data of the task events; The task container is bound to the gameplay blueprint of each virtual task, wherein the gameplay blueprint is used to provide execution logic for the preset virtual task, and the execution logic includes the logic of the task event; The configured task containers are then arranged in a virtual scene, where the virtual scene is a scene in which the preset virtual task is allowed to execute.

10. The method according to claim 9, characterized in that, After arranging the configured task containers in the virtual scene, the method further includes: In response to a first adjustment request triggered on the configured task container, adjust the data prefab placed in the task container; or, In response to a second adjustment request triggered on the task container after the settings are applied, the gameplay blueprint bound to the task container is adjusted.

11. The method according to any one of claims 1 to 10, characterized in that, Before randomly selecting a first task event from the first random pool, the method further includes: assigning a first weight to each task event in the first random pool according to the task characteristics of the preset virtual task, wherein the first weight is used to increase the probability that a task event matching the task characteristics of the preset virtual task is randomly selected from the first random pool; The step of randomly selecting the first task event from the first random pool includes: using the first weight to randomly select the first task event from the first random pool; Before randomly selecting a second task event from the second random pool, the method further includes: assigning a second weight to each task event in the second random pool according to the task characteristics of the preset virtual task, wherein the second weight is used to increase the probability that a task event matching the task characteristics of the preset virtual task is randomly selected from the second random pool; The step of randomly selecting a second task event from the second random pool includes: using the second weight to randomly select the second task event from the second random pool.

12. A configuration device for virtual tasks, characterized in that, include: The first acquisition unit is used to acquire a first task stage and a second task stage in response to a configuration request triggered by a preset virtual task, wherein the first task stage and the second task stage are used to form the task flow of the preset virtual task. The first determining unit is configured to determine, from at least two event random pools, a first random pool for the first task phase and a second random pool for the second task phase, wherein the random items in the event random pools are task events, and the task events are events triggered during the task phase. The first random unit is used to randomly select a first task event from the first random pool and determine the first task event as the task event corresponding to the first task stage. The second random unit is used to randomly select a second task event from the second random pool and determine the second task event as the task event corresponding to the second task stage. The configuration unit is used to configure the preset virtual task based on the first task event and the second task event.

13. A computer-readable storage medium, characterized in that, The computer-readable storage medium includes a stored program, wherein the program is executed by an electronic device to perform the method according to any one of claims 1 to 11.

14. A computer program product comprising a computer program / instructions, characterized in that, When the computer program / instructions are executed by the processor, they implement the steps of the method described in any one of claims 1 to 11.

15. An electronic device comprising a memory and a processor, characterized in that, The memory stores a computer program, and the processor is configured to execute the method described in any one of claims 1 to 11 through the computer program.

Images