Create componentized development based on ILRuntime hot update

Build component development based on ILRuntime

In the previous section, we explained in detail the startup process of the ILRuntime game project framework, as well as the entry into the hot update project, which laid a solid foundation for us to build the framework. The logical hot update project is completed with C#.Therefore, in the logic hot update project, we ensure that the development is not much different from the ordinary Unity C#, so today we will design a componentized development mechanism based on the logic hot update project, we call it ILRBehaviour, similar to MonoBehaviour, try our best toEnsure that all development habits are very similar to MonoBehaviour. Since MonoBehaviour is a data object type in the Unity C# domain, we cannot use it directly in the logic hotfix project, so we have to design a set of class-based mechanisms by ourselves, mainly to accomplish 3 things:

There is a Game Development Communication Team

a> Everyone can go to get the source material to learn and communicate together

Design ILRBehaviour interface

The design of the ILRBehaviour interface is mainly consistent with MonoBehaviour. The common development habits of MonoBehaviour are mainly interface + gameObject + transform object. Later, we will do a good job in the collision detection interface of the physics engine.Regarding the timer of MonoBehaviour, we will design a timer module separately to do the timer, instead of simulating the timer mechanism of MonoBehaviour.With this consideration, the data members and interfaces of our ILRBehaviour can be designed,

As follows:

class ILRBehaviour {public GameObject gameObject; // Simulation component instance.gameObject;public Transform transform; // Simulate component instance.transform;virtual public void Awake() {}virtual public void Start() {}virtual public void Update() {}virtual public void LateUpdate() {}virtual public void FixedUpdate() {}virtual public void onDestroy() {}}

What's different from MonoBehaviour here is that the interface of the base class is made a virtual function directly, instead of looking up through reflection to see if the subclass has this method like MonoBehaviour.Therefore, when the subclass overloads the interface function, the override keyword is added.

Add, find, delete ILRBehaviour component instance mechanism

In Unity's development habits, the GameObject class is used to add components. Here GameObject is a natvie c# object, so other methods must be found. Here I added a global singleton of ILRBeahviourMgr to add an instance of the ILRehaviour component.Find, delete.

ILRBehaviour AddILRComponent(GameObject gameObject, Type classType)

public T AddILRComponent(GameObject gameObject) where T : new()

How does this principle work?All MonoBehaviour components in Unity C# GameObject are "hanging" on the GameObject node instance, but for the logic hot change project, GameObject is a nativie C# object, which cannot be directly recorded on it. Our design here is to build here ILRBehaviourMgrA dictionary Dictionary>behaviourMap, each GameObject has an interface GetInstanceID, you can get its unique ID number, according to this ID number, you can get the List of all ILRBehaviours on the GameObject, when we add to a gameObjectAn instance of an ILRBehaviour component is to first create a new instance of an ILRBehaviour object, and then go to the behaviorMap to obtain the List object according to the ID of the GameObject, and then put the new ILRBehaviour instance into the List.This completes adding an ILRBehaviour component object instance to the GameObject object, then initializes the gameObject and transform data members of ILRBehaviour for easy access by developers, and finally calls the Awake and Start functions of the component instance.The detailed process is shown in Figure 1.4-1,

Figure 1.4-1: AddILRComponent Process Details

Other search and delete interfaces are similar. I won't analyze them one by one here. You can check the source code.

Let the specific interface of ILRBehaviour be called at a specific time

After designing the interface of adding, searching, and deleting the ILRBehaviour component, the next step is to make the specific interface in the ILRBehaviour component mechanism be called at a specific period.The specific period of the current hot update comes from Unity C#, and the entry is in main.cs, so if we want to make the specific interface in the ILRBehaviour component callable, we can start from the specific interface in main.cs, letThey call the specific interface in ILRBehaviourMgr, and then in IlRBehaviourMgr, we traverse each gameObject in the behaviorMap, find the List array list of ILRBehaviour that belongs to it, traverse each ILRBehaviour component instance in it, and call the specific interface.Let's take update as an example to analyze:

The whole process is shown in Figure 1.4-2.

Figure 1.4-2: The whole process of triggering ILRBehaviour.Update call

After implementing these mechanisms, we have designed a complete set of componentized development mechanism based on ILRBehaviour, which combines the previous Mono development habits of Unity c# as much as possible, so that other small partners can seamlesslyDo development in the hot update project.Finally, the last architecture diagram, deepen the impression.

Figure 1.4-3: ILRBehaviour. Mechanism Design Architecture

That's it for today's sharing, you can go to the study group announcement, you can get the source code of our ILRuntime hot update tutorial, and it's more sour to look at the source code.