### Unity Package Manager Installation

Source: https://github.com/leopotam/ecslite-extendedsystems/blob/master/README.md

Установка LeoECS Lite Extended Systems через Unity Package Manager, с возможностью выбора релизной версии или версии в разработке.

```json
"com.leopotam.ecslite.extendedsystems": "https://github.com/Leopotam/ecslite-extendedsystems.git",
"com.leopotam.ecslite.extendedsystems": "https://github.com/Leopotam/ecslite-extendedsystems.git#develop"
```

--------------------------------

### EcsGroupSystem with Dependency Injection (C#)

Source: https://context7.com/leopotam/ecslite-extendedsystems/llms.txt

Demonstrates how EcsGroupSystem supports dependency injection when using the LeoECS Lite DI package. It automatically injects dependencies into nested systems within a group, simplifying service and configuration access.

```csharp
#if LEOECSLITE_DI
using Leopotam.EcsLite;
using Leopotam.EcsLite.Di;
using Leopotam.EcsLite.ExtendedSystems;

class GameConfig {
    public float PlayerSpeed = 5.0f;
    public int MaxHealth = 100;
}

class AudioService {
    public void PlaySound(string soundName) { }
}

class MovementSystem : IEcsRunSystem {
    [EcsInject] GameConfig _config;

    public void Run (IEcsSystems systems) {
        // Use injected _config.PlayerSpeed
    }
}

class HealthSystem : IEcsRunSystem {
    [EcsInject] GameConfig _config;
    [EcsInject] AudioService _audio;

    public void Run (IEcsSystems systems) {
        // Use injected _config.MaxHealth and _audio
        _audio.PlaySound("damage");
    }
}

// Setup with dependency injection
var world = new EcsWorld();
var config = new GameConfig();
var audio = new AudioService();

var systems = new EcsSystems(world);
systems
    // Inject shared services
    .Inject(config)
    .Inject(audio)

    // Group systems will receive injected dependencies
    .AddGroup("PlayerSystems", true, null,
        new MovementSystem(),
        new HealthSystem())

    .Init();
#endif
```

--------------------------------

### Group Systems with Runtime Toggle using LeoECS Lite Extended

Source: https://context7.com/leopotam/ecslite-extendedsystems/llms.txt

Demonstrates how to group multiple IEcsRunSystem implementations into a named group that can be enabled or disabled at runtime via EcsGroupSystemState events. This allows for dynamic control of system execution based on game state. It requires the Leopotam.EcsLite and Leopotam.EcsLite.ExtendedSystems libraries.

```csharp
using Leopotam.EcsLite;
using Leopotam.EcsLite.ExtendedSystems;

// Define systems that will be grouped
class MeleeAttackSystem : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        // Process melee attack logic
        var world = systems.GetWorld();
        var damagePool = world.GetPool<MeleeDamage>();
        // ... melee combat logic
    }
}

class MeleeComboSystem : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        // Process combo chains for melee attacks
        var world = systems.GetWorld();
        var comboPool = world.GetPool<ComboState>();
        // ... combo detection logic
    }
}

class GameStateController : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        var world = systems.GetWorld();

        // Enable melee combat group when player equips melee weapon
        var entity = world.NewEntity();
        ref var enableEvent = ref world.GetPool<EcsGroupSystemState>().Add(entity);
        enableEvent.Name = "MeleeCombat";
        enableEvent.State = true;

        // Later, disable when switching to ranged weapon
        var disableEntity = world.NewEntity();
        ref var disableEvent = ref world.GetPool<EcsGroupSystemState>().Add(disableEntity);
        disableEvent.Name = "MeleeCombat";
        disableEvent.State = false;
    }
}

// Initialize ECS with grouped systems
var world = new EcsWorld();
var systems = new EcsSystems(world);
systems
    // Add melee combat group (disabled by default, events in default world)
    .AddGroup("MeleeCombat", false, null, 
        new MeleeAttackSystem(), 
        new MeleeComboSystem())
    // Add controller system
    .Add(new GameStateController())
    .Init();

// Run game loop
while (gameRunning) {
    systems.Run();
}
```

--------------------------------

### DelHere for Automatic Event Component Cleanup in C#

Source: https://github.com/leopotam/ecslite-extendedsystems/blob/master/README.md

Использование DelHere для автоматической очистки компонентов-событий после их обработки. Компоненты удаляются из указанного мира, который должен быть предварительно зарегистрирован.

```csharp
var systems = new EcsSystems (new EcsWorld ());
systems
    .Add (new System1 ()) 
    .Add (new System2 ())
    // Все компоненты "C1" будут удалены здесь.
    .DelHere<C1> () 
    .Add (new System3 ())
    // Все компоненты "C2" будут удалены здесь.
    .DelHere<C2> () 
    .Add (new System4 ())
    .Init ();
```

--------------------------------

### Control System Group States with EcsGroupSystemState

Source: https://context7.com/leopotam/ecslite-extendedsystems/llms.txt

Demonstrates how to use the EcsGroupSystemState component to enable or disable entire system groups at runtime. This is useful for managing different game states like combat or dialogue by activating/deactivating relevant systems.

```csharp
using Leopotam.EcsLite;
using Leopotam.EcsLite.ExtendedSystems;

struct PlayerState {
    public bool IsInCombat;
    public bool IsInDialogue;
}

class AIUpdateSystem : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        // AI logic
    }
}

class CombatAISystem : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        // Combat-specific AI
    }
}

class DialogueSystem : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        // Dialogue processing
    }
}

class GameModeController : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        var world = systems.GetWorld();
        var statePool = world.GetPool<PlayerState>();
        var groupStatePool = world.GetPool<EcsGroupSystemState>();

        // Check game state changes
        bool enteringCombat = true; // Game logic determines this
        bool enteringDialogue = false;

        if (enteringCombat) {
            // Enable combat systems
            var entity = world.NewEntity();
            ref var state = ref groupStatePool.Add(entity);
            state.Name = "CombatAI";
            state.State = true;

            // Disable dialogue systems
            var entity2 = world.NewEntity();
            ref var state2 = ref groupStatePool.Add(entity2);
            state2.Name = "DialogueSystems";
            state2.State = false;
        }

        if (enteringDialogue) {
            // Enable dialogue, disable combat
            var entity = world.NewEntity();
            ref var state = ref groupStatePool.Add(entity);
            state.Name = "DialogueSystems";
            state.State = true;

            var entity2 = world.NewEntity();
            ref var state2 = ref groupStatePool.Add(entity2);
            state2.Name = "CombatAI";
            state2.State = false;
        }
    }
}

// Setup multiple toggleable system groups
var world = new EcsWorld();
var systems = new EcsSystems(world);
systems
    .Add(new GameModeController())

    // Always-active base AI
    .Add(new AIUpdateSystem())

    // Combat AI group (disabled by default)
    .AddGroup("CombatAI", false, null,
        new CombatAISystem())

    // Dialogue group (disabled by default)
    .AddGroup("DialogueSystems", false, null,
        new DialogueSystem())

    .Init();
```

--------------------------------

### EcsGroupSystem for Grouping Systems in C#

Source: https://github.com/leopotam/ecslite-extendedsystems/blob/master/README.md

Использование EcsGroupSystem для группировки ECS-систем с возможностью их включения/отключения. Требует наличия LeoECS Lite.

```csharp
// Эти системы будут вложены в группу с именем "Melee".
class MeleeSystem1 : IEcsRunSystem {
    public void Run (IEcsSystems systems) { }
}
class MeleeSystem2 : IEcsRunSystem {
    public void Run (IEcsSystems systems) { }
}

class MeleeGroupEnableSystem : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        // Мы можем включать и выключать группу "Melee" с помощью
        // отправки специального события "EcsGroupSystemState".
        var world = systems.GetWorld ();
        var entity = world.NewEntity ();
        ref var evt = ref world.GetPool<EcsGroupSystemState> ().Add (entity);
        evt.Name = "Melee";
        evt.State = true;
    }
}
// Стартовая инициализация.
var systems = new EcsSystems (new EcsWorld ());
systems
    // Добавляем выключенную на старте группу "Melee" с 2 вложенными
    // системами, события изменения состояния группы будут
    // храниться в мире по умолчанию.
    .AddGroup ("Melee", false, null,
        new MeleeSystem1 (),
        new MeleeSystem2 ())
    // Остальные системы.
    .Add (new MeleeGroupEnableSystem ())
    .Init ();
```

--------------------------------

### Cleanup Components from Named Worlds with DelHere

Source: https://context7.com/leopotam/ecslite-extendedsystems/llms.txt

Illustrates how to use the DelHere extension method to remove components from a specific named ECS world, rather than the default one. This is particularly useful in multi-world architectures where different worlds handle distinct game logic.

```csharp
using Leopotam.EcsLite;
using Leopotam.EcsLite.ExtendedSystems;

struct UIClickEvent {
    public int ButtonId;
}

struct NetworkMessageEvent {
    public byte[] Data;
}

class UISystem : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        var uiWorld = systems.GetWorld("ui");
        var eventPool = uiWorld.GetPool<UIClickEvent>();

        var entity = uiWorld.NewEntity();
        ref var evt = ref eventPool.Add(entity);
        evt.ButtonId = 5;
    }
}

class NetworkSystem : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        var netWorld = systems.GetWorld("network");
        var eventPool = netWorld.GetPool<NetworkMessageEvent>();

        var entity = netWorld.NewEntity();
        ref var evt = ref eventPool.Add(entity);
        evt.Data = new byte[] { 0x01, 0x02, 0x03 };
    }
}

// Multi-world setup with targeted cleanup
var gameWorld = new EcsWorld();
var uiWorld = new EcsWorld();
var networkWorld = new EcsWorld();

var systems = new EcsSystems(gameWorld);
systems
    // Register additional worlds
    .AddWorld(uiWorld, "ui")
    .AddWorld(networkWorld, "network")

    // UI systems
    .Add(new UISystem())
    // Cleanup UI events from "ui" world
    .DelHere<UIClickEvent>("ui")

    // Network systems
    .Add(new NetworkSystem())
    // Cleanup network events from "network" world
    .DelHere<NetworkMessageEvent>("network")

    .Init();
```

--------------------------------

### C# DelHere: Automatic Event Component Cleanup in ECS Lite

Source: https://context7.com/leopotam/ecslite-extendedsystems/llms.txt

Demonstrates how to use the DelHere system to automatically remove 'PlayerDamagedEvent' and 'SpawnEnemyEvent' components after their respective processing stages. This prevents stale event data from persisting and simplifies system management. It requires the Leopotam.EcsLite and Leopotam.EcsLite.ExtendedSystems packages.

```csharp
using Leopotam.EcsLite;
using Leopotam.EcsLite.ExtendedSystems;

// Define event components
struct PlayerDamagedEvent {
    public int Damage;
    public int AttackerId;
}

struct SpawnEnemyEvent {
    public int EnemyType;
    public float X, Y, Z;
}

// Systems that produce events
class DamageCalculationSystem : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        var world = systems.GetWorld();
        var eventPool = world.GetPool<PlayerDamagedEvent>();

        // Create damage event
        var entity = world.NewEntity();
        ref var evt = ref eventPool.Add(entity);
        evt.Damage = 25;
        evt.AttackerId = 42;
    }
}

// Systems that consume events
class HealthUpdateSystem : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        var world = systems.GetWorld();
        var filter = world.Filter<PlayerDamagedEvent>().End();
        var eventPool = world.GetPool<PlayerDamagedEvent>();

        foreach (var entity in filter) {
            ref var evt = ref eventPool.Get(entity);
            // Process damage: evt.Damage, evt.AttackerId
            // Events will be auto-cleaned after this system group
        }
    }
}

class DamageVFXSystem : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        var world = systems.GetWorld();
        var filter = world.Filter<PlayerDamagedEvent>().End();
        var eventPool = world.GetPool<PlayerDamagedEvent>();

        foreach (var entity in filter) {
            // Show damage visual effects
            // Event still available here
        }
    }
}

class EnemySpawnerSystem : IEcsRunSystem {
    public void Run (IEcsSystems systems) {
        var world = systems.GetWorld();
        var eventPool = world.GetPool<SpawnEnemyEvent>();

        var entity = world.NewEntity();
        ref var evt = ref eventPool.Add(entity);
        evt.EnemyType = 3;
        evt.X = 10.5f;
        evt.Y = 0.0f;
        evt.Z = -5.2f;
    }
}

// Setup system pipeline with automatic cleanup
var world = new EcsWorld();
var systems = new EcsSystems(world);
systems
    // Damage processing phase
    .Add(new DamageCalculationSystem())
    .Add(new HealthUpdateSystem())
    .Add(new DamageVFXSystem())
    // Auto-cleanup PlayerDamagedEvent components here
    .DelHere<PlayerDamagedEvent>()

    // Enemy spawning phase
    .Add(new EnemySpawnerSystem())
    // Auto-cleanup SpawnEnemyEvent components here
    .DelHere<SpawnEnemyEvent>()

    .Init();

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.