# Morpeh [![License](https://camo.githubusercontent.com/988edd71131a4785209032a657ab8677d41e7480bad6505827b93c570dd3da15/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f6c6963656e73652f7363656c6c6563732f6d6f727065683f636f6c6f723d333735306331267374796c653d666c61742d737175617265)](https://github.com/scellecs/morpeh/blob/main/LICENSE.md) [![Version](https://camo.githubusercontent.com/7438a431caf34b71b3ae12cb26c591e87bf2282966fc3a2dd27ade41ab0ca08f/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f7061636b6167652d6a736f6e2f762f7363656c6c6563732f6d6f727065683f636f6c6f723d333735306331267374796c653d666c61742d737175617265)](https://github.com/scellecs/morpeh/raw/main/package.json) 🎲 **ECS Framework for Unity Game Engine and .Net Platform** * Simple Syntax. * Plug & Play Installation. * No code generation. * Structure-Based and Cache-Friendly. ## 📖 Table of Contents * [Migration](https://github.com/scellecs/morpeh/raw/main/#-migration-to-new-version) * [How To Install](https://github.com/scellecs/morpeh/raw/main/#-how-to-install) * [Unity Engine](https://github.com/scellecs/morpeh/raw/main/#unity-engine) * [.Net Platform](https://github.com/scellecs/morpeh/raw/main/#net-platform) * [Introduction](https://github.com/scellecs/morpeh/raw/main/#-introduction) * [Base concept of ECS pattern](https://github.com/scellecs/morpeh/raw/main/#-base-concept-of-ecs-pattern) * [Getting Started](https://github.com/scellecs/morpeh/raw/main/#-getting-started) * [Advanced](https://github.com/scellecs/morpeh/raw/main/#-advanced) * [Filter Extensions](https://github.com/scellecs/morpeh/raw/main/#-filter-extensions) * [Aspects](https://github.com/scellecs/morpeh/raw/main/#-aspects) * [Component Disposing](https://github.com/scellecs/morpeh/raw/main/#-component-disposing) * [Unity Jobs And Burst](https://github.com/scellecs/morpeh/raw/main/#-unity-jobs-and-burst) * [Defines](https://github.com/scellecs/morpeh/raw/main/#%EF%B8%8F-defines) * [World Plugins](https://github.com/scellecs/morpeh/raw/main/#%EF%B8%8F-world-plugins) * [Metrics](https://github.com/scellecs/morpeh/raw/main/#-metrics) * [Plugins](https://github.com/scellecs/morpeh/raw/main/#-plugins) * [Examples](https://github.com/scellecs/morpeh/raw/main/#-examples) * [Games](https://github.com/scellecs/morpeh/raw/main/#-games) * [License](https://github.com/scellecs/morpeh/raw/main/#-license) * [Contacts](https://github.com/scellecs/morpeh/raw/main/#-contacts) ## 🛸 Migration To New Version English version: [Migration Guide](https://github.com/scellecs/morpeh/blob/main/MIGRATION.md) Russian version: [Гайд по миграции](https://github.com/scellecs/morpeh/blob/main/MIGRATION_RU.md) ## 📖 How To Install ### Unity Engine Minimal Unity Version is 2020.3.* Require [Git](https://git-scm.com/) for installing package. Require [Tri Inspector](https://github.com/codewriter-packages/Tri-Inspector) for drawing in inspector.

Open Unity Package Manager and add Morpeh URL.

![installation_step1.png](https://github.com/scellecs/morpeh/raw/main/Gifs~/installation_step1.png) ![installation_step2.png](https://github.com/scellecs/morpeh/raw/main/Gifs~/installation_step2.png)

⭐ Master: https://github.com/scellecs/morpeh.git 🚧 Stage: https://github.com/scellecs/morpeh.git#stage-2023.1 🏷️ Tag: https://github.com/scellecs/morpeh.git#2023.1.0 ### .Net Platform NuGet package URL: https://www.nuget.org/packages/Scellecs.Morpeh ## 📖 Introduction ### 📘 Base concept of ECS pattern #### 🔖 Entity Container of components. Has a set of methods for add, get, set, remove components. It is reference type. Each entity is unique and not pooled. Only entity IDs are reused. ```c# var entity = this.World.CreateEntity(); ref var addedHealthComponent = ref entity.AddComponent(); ref var gottenHealthComponent = ref entity.GetComponent(); //if you remove last component on entity it will be destroyd on next world.Commit() bool removed = entity.RemoveComponent(); entity.SetComponent(new HealthComponent {healthPoints = 100}); bool hasHealthComponent = entity.Has(); var newEntity = this.World.CreateEntity(); //after migration entity has no components, so it will be destroyd on next world.Commit() entity.MigrateTo(newEntity); //get string with entity ID var debugString = entity.ToString(); ``` #### 🔖 Component Components are types which include only data. In Morpeh components are value types for performance purposes. ```c# public struct HealthComponent : IComponent { public int healthPoints; } ``` #### 🔖 System Types that process entities with a specific set of components. Entities are selected using a filter. All systems are represented by interfaces, but for convenience, there are ScriptableObject classes that make it easier to work with the inspector and `Installer`. Such classes are the default tool, but you can write pure classes that implement the interface, but then you need to use the `SystemsGroup` API instead of the `Installer`. ```c# public class HealthSystem : ISystem { public World World { get; set; } private Filter filter; public void OnAwake() { this.filter = this.World.Filter.With().Build(); } public void OnUpdate(float deltaTime) { foreach (var entity in this.filter) { ref var healthComponent = ref entity.GetComponent(); healthComponent.healthPoints += 1; } } public void Dispose() { } } ``` All systems types: * `IInitializer` & `Initializer` - have only OnAwake and Dispose methods, convenient for executing startup logic * `ISystem` & `UpdateSystem` * `IFixedSystem` & `FixedUpdateSystem` * `ILateSystem` & `LateUpdateSystem` * `ICleanupSystem` & `CleanupSystem` #### 🔖 SystemsGroup The type that contains the systems. There is an `Installer` wrapper to work in the inspector, but if you want to control everything from code, you can use the systems group directly. ```c# var newWorld = World.Create(); var newSystem = new HealthSystem(); var newInitializer = new HealthInitializer(); var systemsGroup = newWorld.CreateSystemsGroup(); systemsGroup.AddSystem(newSystem); systemsGroup.AddInitializer(newInitializer); //it is bad practice to turn systems off and on, but sometimes it is very necessary for debugging systemsGroup.DisableSystem(newSystem); systemsGroup.EnableSystem(newSystem); systemsGroup.RemoveSystem(newSystem); systemsGroup.RemoveInitializer(newInitializer); newWorld.AddSystemsGroup(order: 0, systemsGroup); newWorld.RemoveSystemsGroup(systemsGroup); ``` #### 🔖 World A type that contains entities, components stashes, systems and root filter. ```c# var newWorld = World.Create(); //a variable that specifies whether the world should be updated automatically by the game engine. //if set to false, then you can update the world manually. //and can also be used for game pauses by changing the value of this variable. newWorld.UpdateByUnity = true; var newEntity = newWorld.CreateEntity(); newWorld.RemoveEntity(newEntity); var systemsGroup = newWorld.CreateSystemsGroup(); systemsGroup.AddSystem(new HealthSystem()); newWorld.AddSystemsGroup(order: 0, systemsGroup); newWorld.RemoveSystemsGroup(systemsGroup); var filter = newWorld.Filter.With(); var healthCache = newWorld.GetStash(); var reflectionHealthCache = newWorld.GetReflectionStash(typeof(HealthComponent)); //manually world updates newWorld.Update(Time.deltaTime); newWorld.FixedUpdate(Time.fixedDeltaTime); newWorld.LateUpdate(Time.deltaTime); newWorld.CleanupUpdate(Time.deltaTime); //apply all entity changes, filters will be updated. //automatically invoked between systems newWorld.Commit(); ``` #### 🔖 Filter A type that contains entities constrained by conditions With and/or Without. You can chain them in any order and quantity. After compose all constrains you should call Build() method. ```c# var filter = this.World.Filter.With() .With() .Without() .Build(); var firstEntityOrException = filter.First(); var firstEntityOrNull = filter.FirstOrDefault(); bool filterIsEmpty = filter.IsEmpty(); int filterLengthCalculatedOnCall = filter.GetLengthSlow(); ``` #### 🔖 Stash A type that contains components. You can get components and do other operations directly from the stash, because entity methods look up the stash each time on call. However, such code is harder to read. ```c# var healthStash = this.World.GetStash(); var entity = this.World.CreateEntity(); ref var addedHealthComponent = ref healthStash.Add(entity); ref var gottenHealthComponent = ref healthStash.Get(entity); bool removed = healthStash.Remove(entity); healthStash.Set(entity, new HealthComponent {healthPoints = 100}); bool hasHealthComponent = healthStash.Has(entity); //delete all components that type from the world healthStash.RemoveAll(); var newEntity = this.World.CreateEntity(); //transfers a component from one entity to another healthStash.Migrate(from: entity, to: newEntity); //not a generic variation of stash, so we can only do a limited set of operations var reflectionHealthCache = newWorld.GetReflectionStash(typeof(HealthComponent)); //set default(HealthComponent) to entity reflectionHealthCache.Set(entity); bool removed = reflectionHealthCache.Remove(entity); bool hasHealthComponent = reflectionHealthCache.Has(entity); ``` #### 🅿️ Providers Morpeh has providers for integration with the game engine. This is a `MonoBehaviour` that allows you to create associations between GameObject and Entity. For each ECS component, you can create a provider; it will allow you to change the component values directly through the inspector, use prefabs and use the workflow as close as possible to classic Unity development. There are two main types of providers. * **EntityProvider**. It automatically creates an associated entity and allows you to access it. * **MonoProvider**. It is an inheritor of EntityProvider, and adds a component to the entity. Allows you to view and change component values directly in the playmode. > [!NOTE] > Precisely because providers allow you to work with component values directly from the kernel, because components are not stored in the provider, it only renders them; > We use third-party solutions for rendering inspectors like Tri Inspector or Odin Inspector. > It's a difficult task to render the completely different data that you can put into a component. All providers do their work in the `OnEnable()` and `OnDisable()` methods. This allows you to emulate turning components on and off, although the kernel does not have such a feature. All providers are synchronized with each other, so if you attach several providers to one GameObject, they will be associated with one entity, and will not create several different ones. Providers can be inherited and logic can be overridden in the `Initialize()` and `Deinitialize()` methods. We do not use methods like `Awake()`, `Start()` and others, because the provider needs to control the creation of the entity and synchronize with other providers. At the time of calling `Initialize()`, the entity is definitely created. API: ```c# var entityProvider = someGameObject.GetComponent(); var entity = entityProvider.Entity; ``` ```c# var monoProvider = someGameObject.GetComponent(); var entity = monoProvider.Entity; //returns serialized data or direct value of component ref var data = ref monoProvider.GetData(); ref var data = ref monoProvider.GetData(out bool existOnEntity); ref var serializedData = ref monoProvider.GetSerializedData(); var stash = monoProvider.Stash; ``` We also have one additional provider that allows you to destroy an entity when a GameObject is removed from the scene. You can simply hang it on a GameObject and no matter how many components are left on the entity, it will be deleted. The provider is called `RemoveEntityOnDestroy`. --- ### 📘 Getting Started > [!IMPORTANT] > All GIFs are hidden under spoilers. Press ➤ to open it. First step: install [Tri Inspector](https://github.com/codewriter-packages/Tri-Inspector). Second step: install Morpeh.

After installation import ScriptTemplates and Restart Unity.

![import_script_templates.gif](https://github.com/scellecs/morpeh/raw/main/Gifs~/import_script_templates.gif)

Let's create our first component and open it.

Right click in project window and select Create/ECS/Component.

![create_component.gif](https://github.com/scellecs/morpeh/raw/main/Gifs~/create_component.gif)

After it, you will see something like this. ```c# using Scellecs.Morpeh; using UnityEngine; using Unity.IL2CPP.CompilerServices; [Il2CppSetOption(Option.NullChecks, false)] [Il2CppSetOption(Option.ArrayBoundsChecks, false)] [Il2CppSetOption(Option.DivideByZeroChecks, false)] [System.Serializable] public struct HealthComponent : IComponent { } ``` > [!NOTE] > Don't care about attributes. > Il2CppSetOption attribute can give you better performance. > It is important to understand that this disables any checks for null, so in the release build any calls to a null object will lead to a hard crash. > We recommend that in places where you are in doubt about using this attribute, you check everything for null yourself. Add health points field to the component. ```c# public struct HealthComponent : IComponent { public int healthPoints; } ``` It is okay. Now let's create first system.

Right click in project window and select Create/ECS/System.

![create_system.gif](https://github.com/scellecs/morpeh/raw/main/Gifs~/create_system.gif)

> [!NOTE] > Icon U means UpdateSystem. Also you can create FixedUpdateSystem and LateUpdateSystem, CleanupSystem. > They are similar as MonoBehaviour's Update, FixedUpdate, LateUpdate. CleanupSystem called the most recent in LateUpdate. System looks like this. ```c# using Scellecs.Morpeh.Systems; using UnityEngine; using Unity.IL2CPP.CompilerServices; [Il2CppSetOption(Option.NullChecks, false)] [Il2CppSetOption(Option.ArrayBoundsChecks, false)] [Il2CppSetOption(Option.DivideByZeroChecks, false)] [CreateAssetMenu(menuName = "ECS/Systems/" + nameof(HealthSystem))] public sealed class HealthSystem : UpdateSystem { public override void OnAwake() { } public override void OnUpdate(float deltaTime) { } } ``` We have to add a filter to find all the entities with `HealthComponent`. ```c# public sealed class HealthSystem : UpdateSystem { private Filter filter; public override void OnAwake() { this.filter = this.World.Filter.With().Build(); } public override void OnUpdate(float deltaTime) { } } ``` > [!NOTE] > You can chain filters by two operators `With<>` and `Without<>`. > For example `this.World.Filter.With().With().Without().Build();` The filters themselves are very lightweight and are free to create. They do not store entities directly, so if you like, you can declare them directly in hot methods like `OnUpdate()`. For example: ```c# public sealed class HealthSystem : UpdateSystem { public override void OnAwake() { } public override void OnUpdate(float deltaTime) { var filter = this.World.Filter.With().Build(); //Or just iterate without variable foreach (var entity in this.World.Filter.With().Build()) { } } } ``` But we will focus on the option with caching to a variable, because we believe that the filters declared in the header of system increase the readability of the code. Now we can iterate all needed entities. ```c# public sealed class HealthSystem : UpdateSystem { private Filter filter; public override void OnAwake() { this.filter = this.World.Filter.With().Build(); } public override void OnUpdate(float deltaTime) { foreach (var entity in this.filter) { ref var healthComponent = ref entity.GetComponent(); Debug.Log(healthComponent.healthPoints); } } } ``` > [!IMPORTANT] > Don't forget about `ref` operator. > Components are struct and if you want to change them directly, then you must use reference operator. For high performance, you can use stash directly. No need to do GetComponent from entity every time, which trying to find suitable stash. However, we use such code only in very hot areas, because it is quite difficult to read it. ```c# public sealed class HealthSystem : UpdateSystem { private Filter filter; private Stash healthStash; public override void OnAwake() { this.filter = this.World.Filter.With().Build(); this.healthStash = this.World.GetStash(); } public override void OnUpdate(float deltaTime) { foreach (var entity in this.filter) { ref var healthComponent = ref healthStash.Get(entity); Debug.Log(healthComponent.healthPoints); } } } ``` We will focus on a simplified version, because even in this version entity.GetComponent is very fast. Let's create ScriptableObject for HealthSystem. This will allow the system to have its inspector and we can refer to it in the scene.

Right click in project window and select Create/ECS/Systems/HealthSystem.

![create_system_scriptableobject.gif](https://github.com/scellecs/morpeh/raw/main/Gifs~/create_system_scriptableobject.gif)

Next step: create `Installer` on the scene. This will help us choose which systems should work and in which order.

Right click in hierarchy window and select ECS/Installer.

![create_installer.gif](https://github.com/scellecs/morpeh/raw/main/Gifs~/create_installer.gif)

Add system to the installer and run project.

![add_system_to_installer.gif](https://github.com/scellecs/morpeh/raw/main/Gifs~/add_system_to_installer.gif)

Nothing happened because we did not create our entities. I will show the creation of entities directly related to GameObject, because to create them from the code it is enough to write `world.CreateEntity()`. To do this, we need a provider that associates GameObject with an entity. Create a new provider.

Right click in project window and select Create/ECS/Provider.

![create_provider.gif](https://github.com/scellecs/morpeh/raw/main/Gifs~/create_provider.gif)

```c# using Scellecs.Morpeh.Providers; using Unity.IL2CPP.CompilerServices; [Il2CppSetOption(Option.NullChecks, false)] [Il2CppSetOption(Option.ArrayBoundsChecks, false)] [Il2CppSetOption(Option.DivideByZeroChecks, false)] public sealed class HealthProvider : MonoProvider<{YOUR_COMPONENT}> { } ``` We need to specify a component for the provider. ```c# public sealed class HealthProvider : MonoProvider { } ```

Create new GameObject and add HealthProvider.

![add_provider.gif](https://github.com/scellecs/morpeh/raw/main/Gifs~/add_provider.gif)

Now press the play button, and you will see Debug.Log with healthPoints. Nice! --- ### 📖 Advanced #### 🧩 Filter Extensions Filter extensions required for easy reuse of filter queries. Let's look at an example: We need to implement the IFilterExtension interface and the type must be a struct. ```c# public struct SomeExtension : IFilterExtension { public FilterBuilder Extend(FilterBuilder rootFilter) => rootFilter.With().With(); } ``` The next step is to call the Extend method in any order when requesting a filter. The Extend method continues query. ```c# private Filter filter; public void OnAwake() { this.filter = this.World.Filter.With() .Extend() .With() .Build(); } ``` #### 🔍 Aspects An aspect is an object-like wrapper that you can use to group together a subset of an entity's components into a single C# struct. Aspects are useful for organizing component code and simplifying queries in your systems. For example, the Transform groups together the individual position, rotation, and scale of components and enables you to access these components from a query that includes the Transform. You can also define your own aspects with the IAspect interface. Our components: ```c# public struct Translation : IComponent { public float x; public float y; public float z; } public struct Rotation : IComponent { public float x; public float y; public float z; public float w; } public struct Scale : IComponent { public float x; public float y; public float z; } ``` Let's group them in aspect. Simple entity version: ```c# public struct Transform : IAspect { //Set on each call of AspectFactory.Get(Entity entity) public Entity Entity { get; set;} public ref Translation Translation => ref this.Entity.GetComponent(); public ref Rotation Rotation => ref this.Entity.GetComponent(); public ref Scale Scale => ref this.Entity.GetComponent(); //Called once on world.GetAspectFactory public void OnGetAspectFactory(World world) { } } ``` In an aspect, you can write any combination of properties and methods to work with components on an entity. Let's write a variation with stashes to make it work faster. ```c# public struct Transform : IAspect { public Entity Entity { get; set;} public ref Translation Translation => ref this.translation.Get(this.Entity); public ref Rotation Rotation => ref this.rotation.Get(this.Entity); public ref Scale Scale => ref this.scale.Get(this.Entity); private Stash translation; private Stash rotation; private Stash scale; public void OnGetAspectFactory(World world) { this.translation = world.GetStash(); this.rotation = world.GetStash(); this.scale = world.GetStash(); } } ``` Let's add an IFilterExtension implementation to always have a query. ```c# public struct Transform : IAspect, IFilterExtension { public Entity Entity { get; set;} public ref Translation Translation => ref this.translation.Get(this.Entity); public ref Rotation Rotation => ref this.rotation.Get(this.Entity); public ref Scale Scale => ref this.scale.Get(this.Entity); private Stash translation; private Stash rotation; private Stash scale; public void OnGetAspectFactory(World world) { this.translation = world.GetStash(); this.rotation = world.GetStash(); this.scale = world.GetStash(); } public FilterBuilder Extend(FilterBuilder rootFilter) => rootFilter.With().With().With(); } ``` Now we write a system that uses our aspect. ```c# public class TransformAspectSystem : ISystem { public World World { get; set; } private Filter filter; private AspectFactory transform; public void OnAwake() { //Extend filter with ready query from Transform this.filter = this.World.Filter.Extend().Build(); //Getting aspect factory AspectFactory this.transform = this.World.GetAspectFactory(); for (int i = 0, length = 100; i < length; i++) { var entity = this.World.CreateEntity(); entity.AddComponent(); entity.AddComponent(); entity.AddComponent(); } } public void OnUpdate(float deltaTime) { foreach (var entity in this.filter) { //Getting aspect copy for current entity var trs = this.transform.Get(entity); ref var trans = ref trs.Translation; trans.x += 1; ref var rot = ref trs.Rotation; rot.x += 1; ref var scale = ref trs.Scale; scale.x += 1; } } public void Dispose() { } } ``` #### 🧹 Component Disposing Sometimes it becomes necessary to clear component values. For this, it is enough that the component implements `IDisposable`. For example: ```c# public struct PlayerView : IComponent, IDisposable { public GameObject value; public void Dispose() { Object.Destroy(value); } } ``` The initializer or system needs to mark the stash as disposable. For example: ```c# public class PlayerViewDisposeInitializer : Initializer { public override void OnAwake() { this.World.GetStash().AsDisposable(); } } ``` or ```c# public class PlayerViewSystem : UpdateSystem { public override void OnAwake() { this.World.GetStash().AsDisposable(); } public override void OnUpdate(float deltaTime) { ... } } ``` Now, when the component is removed from the entity, the `Dispose()` method will be called on the `PlayerView` component. #### 🧨 Unity Jobs And Burst > [!IMPORTANT] > Supported only in Unity. Subjected to further improvements and modifications. You can convert `Filter` to `NativeFilter` which allows you to do component-based manipulations inside a Job. Conversion of `Stash` to `NativeStash` allows you to operate on components based on entity ids. Current limitations: * `NativeFilter` and `NativeStash` and their contents should never be re-used outside of single system tick. * `NativeFilter` and `NativeStash` cannot be used in-between `World.Commit()` calls inside Morpeh. Example job scheduling: ```c# public sealed class SomeSystem : UpdateSystem { private Filter filter; private Stash stash; ... public override void OnUpdate(float deltaTime) { var nativeFilter = this.filter.AsNative(); var parallelJob = new ExampleParallelJob { entities = nativeFilter, healthComponents = stash.AsNative(), // Add more native stashes if needed }; var parallelJobHandle = parallelJob.Schedule(nativeFilter.length, 64); parallelJobHandle.Complete(); } } ``` Example job: ```c# [BurstCompile] public struct TestParallelJobReference : IJobParallelFor { [ReadOnly] public NativeFilter entities; public NativeStash healthComponents; public void Execute(int index) { var entityId = this.entities[index]; ref var component = ref this.healthComponents.Get(entityId, out var exists); if (exists) { component.Value += 1; } // Alternatively, you can avoid checking existance of the component // if the filter includes said component anyway ref var component = ref this.healthComponents.Get(entityId); component.Value += 1; } } ``` For flexible Job scheduling, you can use `World.JobHandle`. It allows you to schedule Jobs within one SystemsGroup, rather than calling `.Complete()` directly on the system. Planning between SystemsGroup is impossible because in Morpeh, unlike Entities or other frameworks, there is no dependency graph that would allow Jobs to be planned among all systems, taking into account dependencies. Example scheduling: ```c# public sealed class SomeSystem : UpdateSystem { private Filter filter; private Stash stash; ... public override void OnUpdate(float deltaTime) { var nativeFilter = this.filter.AsNative(); var parallelJob = new ExampleParallelJob { entities = nativeFilter, healthComponents = stash.AsNative() }; World.JobHandle = parallelJob.Schedule(nativeFilter.length, 64, World.JobHandle); } } ``` `World.JobHandle.Complete()` is called automatically after each Update type. For example: * Call OnUpdate() on all systems within the SystemsGroup. * Call World.JobHandle.Complete(). * Call OnFixedUpdate() on all systems within the SystemsGroup. * Call World.JobHandle.Complete(). > [!WARNING] > You cannot change the set of components on any entities if you have scheduled Jobs. > Any addition or deletion of components is considered a change. > The kernel will warn you at World.Commit() that you cannot do this. You can manually control `World.JobHandle`, assign it, and call `.Complete()` on systems if you need to. Currently Morpeh uses some additional temporary collections for the native part, so instead of just calling `World.JobHandle.Complete()` we recommend using `World.JobsComplete()`. This method is optional; the kernel will clear these collections one way or another, it will simply do it later. #### 🗒️ Defines Can be set by user: * `MORPEH_DEBUG` Define if you need debug in application build. In editor it works automatically. * `MORPEH_EXTERNAL_IL2CPP_ATTRS` If you have conflicts with attributes, you can set this define and Morpeh core will be use internal version of attributes. * `MORPEH_PROFILING` Define for systems profiling in Unity Profiling Window. * `MORPEH_METRICS` Define for additional Morpeh Metrics in Unity Profiling Window. * `MORPEH_NON_SERIALIZED` Define to avoid serialization of Morpeh core parts. * `MORPEH_THREAD_SAFETY` Define that forces the kernel to validate that all calls come from the same thread the world was created on. The binding to a thread can be changed using the `World.GetThreadId()`, `World.SetThreadId()` methods. * `MORPEH_DISABLE_SET_ICONS` Define for disabling set icons in Project Window. * `MORPEH_DISABLE_AUTOINITIALIZATION` Define for disable default world creation and creating Morpeh Runner GameObject. Will be set by framework: * `MORPEH_BURST` Determine if Burst is enabled, and framework has enabled Native API. #### 🌍️ World Plugins Sometimes you need to make an automatic plugin for the world. Add some systems, make a custom game loop, or automatic serialization. World plugins are great for this. To do this, you need to declare a class that implements the IWorldPlugin interface. After that, create a static method with an attribute and register the plugin in the kernel. For example: ```c# class GlobalsWorldPlugin : IWorldPlugin { [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)] public static void RuntimeInitialize() { WorldExtensions.AddWorldPlugin(new GlobalsWorldPlugin()); } public void Initialize(World world) { var sg = world.CreateSystemsGroup(); sg.AddSystem(new ECS.ProcessEventsSystem()); world.AddPluginSystemsGroup(sg); } public void Deinitialize(World world) { } } ``` #### 📊 Metrics To debug the game, you may need statistics on basic data in the ECS framework, such as: 1. Number of entities 2. Number of archetypes 3. Number of filters 4. Number of systems 5. Number of commits in the world 6. Number of entity migrations You can find all this in the profiler window. To do this, you need to add the official **Unity Profiling Core API** package to your project. Its quick name to search is: `com.unity.profiling.core` After this, specify the `MORPEH_METRICS` definition in the project. Now you can observe all the statistics for the kernel. Open the profiler window. On the top left, click the Profiler Modules button and find Morpeh there. We turn it on with a checkmark and can move it higher or lower. Metrics work the same way in debug builds, so you can see the whole picture directly from the device.

It will be look like this in playmode.

![metrics.png](https://github.com/scellecs/morpeh/raw/main/Gifs~/metrics.png)

--- ## 🔌 Plugins * [**Morpeh Helpers**](https://github.com/SH42913/morpeh.helpers) * [**Morpeh.Events**](https://github.com/codewriter-packages/Morpeh.Events) * [**Morpeh.SystemStateProcessor**](https://github.com/codewriter-packages/Morpeh.SystemStateProcessor) * [**Morpeh.Queries**](https://github.com/actionk/Morpeh.Queries) * [**Morpeh.SourceGenerator**](https://github.com/kandreyc/Scellecs.Morpeh.SourceGenerator) * [**Morpeh.Addons**](https://github.com/MexicanMan/morpeh.addons) * [**PlayerLoopAPI Runner Morpeh plugin**](https://github.com/skelitheprogrammer/PlayerLoopCustomizationAPI.Runner.Morpeh-Plugin) --- ## 📚 Examples * [**Tanks**](https://github.com/scellecs/morpeh.examples.tanks) by *SH42913* * [**Ping Pong**](https://github.com/scellecs/morpeh.examples.pong) by *SH42913* * [**Flappy Bird**](https://github.com/R1nge/MorpehECS_FlappyBird) by *R1nge* * [**Mobile Runner Hypercasual**](https://github.com/StinkySteak/unity-morpeh-hypercasual) by *StinkySteak* --- ## 🔥 Games * **One State RP - Life Simulator** by *Chillbase* [Android](https://play.google.com/store/apps/details?id=com.Chillgaming.oneState) [iOS](https://apps.apple.com/us/app/one-state-rp-online/id1597760047) * **Zombie City** by *GreenButtonGames* [Android](https://play.google.com/store/apps/details?id=com.greenbuttongames.zombiecity) [iOS](https://apps.apple.com/us/app/zombie-city-master/id1543420906) * **Fish Idle** by *GreenButtonGames* [Android](https://play.google.com/store/apps/details?id=com.greenbuttongames.FishIdle) [iOS](https://apps.apple.com/us/app/fish-idle-hooked-tycoon/id1534396279) * **Stickman of Wars: RPG Shooters** by *Multicast Games* [Android](https://play.google.com/store/apps/details?id=com.multicastgames.sow3) [iOS](https://apps.apple.com/us/app/stickman-of-wars-rpg-shooters/id1620422798) * **Cowravaneer** by *FESUNENKO GAMES* [Android](https://play.google.com/store/apps/details?id=com.FesunenkoGames.Cowravaneer) --- ## 📘 License 📄 [MIT License](https://github.com/scellecs/morpeh/blob/main/LICENSE.md) --- ## 💬 Contacts ✉️ Telegram: [olegmrzv](https://t.me/olegmrzv) 📧 E-Mail: [benjminmoore@gmail.com](https://github.com/scellecs/morpeh/raw/main/mailto:benjminmoore@gmail.com) 👥 Telegram Community RU: [Morpeh ECS Development](https://t.me/morpeh_development_chat)