SystemsRx

A general system execution framework with additional layers for Application scenarios with DI abstraction and plugin support.

This originally was a core part of EcsRx however now lives as it's own repo, but EcsRx is built on top of this.

Features

• Simple system interfaces and implementations to use/extend
• Fully reactive architecture
• Favours composition over inheritance
• Adheres to inversion of control
• Lightweight codebase
• Built in support for events (raise your own and react to them)
• Built in Dependency Injection abstraction layer
• Built in support for plugins (wrap up your own components/systems/events and share them with others)

Quick Start

You have 3 system conventions out of the box, IBasicSystem, IManualSystem and IReactToEventSystem. They can be mixed and matched and when added to the ISystemExecutor they will be triggered as expected.

It is advised to look at the setup docs, this covers the 2 avenues to setup the application using it without the helper libraries, or with the helper libraries which offer you dependency injection and other benefits.

IBasicSystem

public class SayHelloSystem : IBasicSystem
{
    // Triggered every time the IUpdateScheduler ticks (default 60 fps)
    public void Execute(ElapsedTime elapsedTime)
    {
        Console.WriteLine($"System says hello @ {elapsedTime.TotalTime.ToString()}");
    }
}

IReactToEventSystem

public class ReactToPlayerDeadEventSystem : IReactToEventSystem<PlayerDeadEvent>
{
    // Triggered when the IEventSystem gets a PlayerDeadEvent
    public void Process(PlayerDeadEvent eventData)
    {
        Console.WriteLine("Oh no the player has died");
    }
}

IManualSystem

public class StartGameManualSystem : IManualSystem
{
    // Triggered when the system is first registered
    public void StartSystem()
    {
        Console.WriteLine("Game Has Started");
    }
        
    // Triggered when the system is removed/stopped
    public void StopSystem()
    {
        Console.WriteLine("Game Has Ended");
    }
}

Architecture

The architecture is layered so you can use the core parts without needing the additional layers if you want to keep things bare bones.

MicroRx

This is a bare bones rx implementation, it literally just contains some basic Subject and other related rx classes, this is so that we do not have a dependencies on rx.net or unirx in the core.

SystemsRx

This takes the barebones rx implementation and creates a basic ISystem convention with an ISystemExecutor and IConventionalSystemHandler implementations to provide basic systems interfaces (As shown in quick start above).

While this can be used alone for basic systems you can build your own conventions on top of here, such as EcsRx which adds an ECS paradigm on top of SystemsRx.

Infrastructure

This allows you to make use of the infrastructure layer which provides a DI abstraction layer, Plugin support and some best practice classes.

The 2 main libraries here are SystemsRx and SystemsRx.Infrastructure, these only have a dependency on MicroRx

Docs

There is a book available which covers the main parts which can be found here:

This is basically just the docs folder in a fancy viewer

Community Plugins/Extensions

This can all be found within the docs here