// Create new entity in world.
int entity = _world.NewEntity ();

// Any entity can be destroyed, all components will be automatically removed first and only after that entity will be considered as destroyed.
world.DelEntity (entity); 

// Components from any entity can be copied to another one. If source or destination entities do not exist - exception will be thrown in DEBUG mode.  
world.CopyEntity (srcEntity, dstEntity);

struct Component1 {
    public int Id;
    public string Name;
}

class UserSystem : IEcsPreInitSystem, IEcsInitSystem, IEcsRunSystem, IEcsPostRunSystem, IEcsDestroySystem, IEcsPostDestroySystem {
    public void PreInit (IEcsSystems systems) {
        // Will be called once on IEcsSystems.Init() before IEcsInitSystem.Init() triggered on any system.
    }
    
    public void Init (IEcsSystems systems) {
        // Will be called once on IEcsSystems.Init() after IEcsPreInitSystem.PreInit() triggered on all systems.
    }
    
    public void Run (IEcsSystems systems) {
        // Will be called once on IEcsSystems.Run().
    }
    
    public void PostRun (IEcsSystems systems) {
        // Will be called once on IEcsSystems.Run() after IEcsRunSystem.Run() triggered on all systems.
    }

    public void Destroy (IEcsSystems systems) {
        // Will be called once on IEcsSystems.Destroy() before IEcsPostDestroySystem.PostDestroy() triggered on any system.
    }
    
    public void PostDestroy (IEcsSystems systems) {
        // Will be called once on IEcsSystems.Destroy() after IEcsDestroySystem.Destroy() triggered on all systems.
    }
}

class SharedData {
    public string PrefabsPath;
}
...
SharedData sharedData = new SharedData { PrefabsPath = "Items/{0}" };
IEcsSystems systems = new EcsSystems (world, sharedData);
systems
    .Add (new TestSystem1 ())
    .Init ();
...
class TestSystem1 : IEcsInitSystem {
    public void Init(IEcsSystems systems) {
        SharedData shared = systems.GetShared<SharedData> ();
        string prefabPath = string.Format (shared.PrefabsPath, 123);
        // prefabPath = "Items/123" at this point. 
    }
}

int entity = world.NewEntity ();
EcsPool<Component1> pool = world.GetPool<Component1> ();

// Add() adds component to entity. If component already exists - exception will be thrown in DEBUG mode. 
ref Component1 c1 = ref pool.Add (entity);

// Has() checks if entity has component.
bool c1Exists = pool.Has (entity);

// Get() returns existing component on entity. If component does not exist - exception will be thrown in DEBUG mode.
ref Component1 c1 = ref pool.Get (entity); 

// Del() removes component from entity. No errors if component did not exist. If it was last component - entity will be removed automatically.
pool.Del (entity);

// Copy() copies all components from one entity to another. If source or destination entities do not exist - exception will be thrown in DEBUG mode.
pool.Copy (srcEntity, dstEntity);

class WeaponSystem : IEcsInitSystem, IEcsRunSystem {
    EcsFilter _filter;
    EcsPool<Weapon> _weapons;
    
    public void Init (IEcsSystems systems) {
        // Get default world instance.
        EcsWorld world = systems.GetWorld ();
        
        // We want all entities with "Weapon" component and without "Health" component.
        // Filter stores only entities, data itself resides in "Weapon" component pool.
        // Filter can be rebuilt dynamically each time, but caching is recommended. 
        _filter = world.Filter<Weapon> ().Exc<Health> ().End ();
        
        // Request and cache weapons pool.
        _weapons = world.GetPool<Weapon> ();
        
        // Create new entity for test.
        int entity = world.NewEntity ();
        
        // And add "Weapon" component to it - this entity should appear in filter.
        _weapons.Add (entity);
    }

    public void Run (IEcsSystems systems) {
        foreach (int entity in filter) {
            ref Weapon weapon = ref _weapons.Get (entity);
            weapon.Ammo = System.Math.Max (0, weapon.Ammo - 1); 
        }
    }
}

class Startup : MonoBehaviour {
    EcsWorld _world;
    IEcsSystems _systems;

    void Start () {
        // Create environment, connect systems.
        _world = new EcsWorld ();
        _systems = new EcsSystems (_world);
        _systems
            .Add (new WeaponSystem ())
            .Init ();
    }
    
    void Update () {
        // Run all connected systems.
        _systems?.Run (); 
    }

    void OnDestroy () {
        // Destroy connected systems.
        if (_systems != null) {
            _systems.Destroy ();
            _systems = null;
        }
        // Cleanup environment.
        if (_world != null) {
            _world.Destroy ();
            _world = null;
        }
    }
}

using Leopotam.EcsLite;

class EcsStartup {
    EcsWorld _world;
    IEcsSystems _systems;

    // Environment initialization.
    void Init () {        
        _world = new EcsWorld ();
        _systems = new EcsSystems (_world);
        _systems
            // Additional world instances 
            // should be registered here.
            // .AddWorld (customWorldInstance, "events")
            
            // Systems with core logic should
            // be registered here.
            // .Add (new TestSystem1 ()) 
            // .Add (new TestSystem2 ())
            
            .Init ();
    }

    // Method should be called from
    // main update loop of engine. 
    void UpdateLoop () {
        _systems?.Run ();
    }

    // Environment cleanup.
    void Destroy () {
        if (_systems != null) {
            _systems.Destroy ();
            _systems = null;
        }
        if (_world != null) {
            _world.Destroy ();
            _world = null;
        }
    }
}