A simple asynchronous task manager for Unity3D

Introduction

Welcome, dear readers. This article will discuss the implementation of a simple manager of asynchronously executed tasks for the development of Unity3d . This manager basically uses the so-called Coroutine , which is present in the engine.

As usual, before describing the implementation and going into details, you need to understand what we are doing and why we need it.

Consider a simple example that I think many have encountered when developing games. We have a certain character who must perform a series of actions: go to point A, take an object, move to point B, put an object. As you can see, this is the usual sequence. It can be implemented in the code in different ways, as the most primitive version in one Update with condition checking. However, everything becomes more complicated if we have a lot of such characters and actions, they also have quite a lot. I would like our code to be able to say such a character, perform a series of actions consistently and let you know when you’re done, but for the time being I’ll do other things. In this case, just asynchronous approach will be useful. At the moment there are many different systems (including for Unity ) that allow you to do this, for example, UniRx (reactive asynchronous programming). But all such things for beginner developers are quite complicated in understanding and mastering, so let's try to take advantage of what the engine itself gives us, namely Coroutine .

Note : the example described above is just one of many, besides it there are many areas where you can describe a similar situation: sequential (or parallel) loading of resources over the network, initialization of interdependent subsystems, animation in the UI, etc.
')

Implementation

Before you write code and go into the depths of C #, we’ll dwell on architecture and terminology.

So, above, I wrote as an example, the actions of the character that he should perform. As part of the system that will be described in this article, this action is a kind of task that the character must perform. If we generalize this concept, then a task is any action that any essence of the game logic can perform. The task should obey the following rules:

• You can run it
• You can subscribe to the completion event
• It can be forced to stop

Why does Subscribe return ITask? It just increases the convenience due to the possibility of creating a structure of the form:

 ITask myTask; myTask.Subscribe(() => Debug.Log(“Task Complete”)).Start(); 

The interface for the task is created, but it lacks one important thing - this is the priority of execution. What is it for? Imagine a situation where we set tasks for a character and, logically, a situation arises that he must stop all his tasks and perform another - important for the game process. In this case, we need to completely stop the current chain and perform a new task. The described example is only one of several behaviors, besides this the priorities may be as follows:

• Normal priority, each new task is placed at the end of the queue.
• Top priority, new task placed at the top of the queue
• Priority with the forced stop of current tasks

So, we have decided on a common understanding of what a task is, now we need a concrete implementation. As described above, Coroutine will be used in this system. Coroutine , in the simplest sense, is a coroutine (if translated literally), which runs mostly on the thread, but without blocking it. Due to the use of iterators (IEnumerator), a return to this coroutine occurs on each frame if a yield return call has occurred within it.


A bit of explanation on the code:

• The static Create method is necessary for the convenience of writing the form:
  

   Task.Create(..).Subscribe(..).Start() 

• _coroutineHost is a link to an instance of any MonoBehaviour object on behalf of which the task will be launched (or Coroutine ). You can send a link, for example, through a static variable.
• In the Subscribe method, subscribers are added via + =, since there may be several of them (and we will need this later)

In the rest, it is quite simple and clear code without any frills.

So, we described the task interface and made an implementation of the class that implements it, but for a full-fledged system, this is not enough, we need a manager who will monitor the execution of tasks along the chain in compliance with priorities. Since in any game there can be a multitude of subsystems that may need their own task manager, we will implement it in the form of a regular class, instances of which will be created and stored by everyone it needs.


Let's sort the given code:

• CurrentTask property - it is necessary to monitor the activity of the task chain and it is possible to subscribe to the current task end event for anyone who has access to the manager
• AddTask is the main class method that creates and adds to the queue a new task according to the specified priority. After adding, if the task list is empty, it automatically starts
• At the time of launching the task (in the ProcessingAddedTask method), an additional subscription occurs by the task manager itself to the event of its completion (this is why + was used in the Task class). When the task is completed, the manager takes the next one from the queue and so on until all the tasks in the list are completed.

Otherwise, as in the case of the Task class, the code is very primitive, but this was the goal of this article.

Using

So what does this code do? Clicking the StartTaskQueue button launches a chain of tasks for operating an Image ( TargetImage ) object:

• moves an object from the From position to the To position
• hides an object through alpha
• waiting one second
• shows the object through alpha
• moves an object from the To position to the From position

When you click the StopTaskQueue button, the current task chain is stopped, if there is an active task in the manager, and if it is not there, then the task chain is restored (if possible).

Conclusion

Despite the relative simplicity of the code, this subsystem allows you to solve many problems in the development, which, when solved in the forehead, can cause certain difficulties. When using such managers and other similar (more complex) ones, you get flexibility and a guarantee that the applied actions to the object will be completed in the necessary sequence and if this process is to be interrupted, it will not cause “dances with a tambourine”. In my projects, I use a more complex version of the described system, which allows working with both Action and YieldInstruction and CustomYieldInstruction . Among other things, I use more priority options for performing tasks, as well as the mode for starting a task outside the manager and out of queues using Func (allows you to return the result of the task). Implementing these things is not difficult, and you yourself can easily figure out how to do this using the code above.