Merge branch 'systems-rx-split'

Author: grofit

README.md

@@ -1,6 +1,6 @@
-# EcsRx
+# EcsRx / SystemsRx
 
-EcsRx is a reactive take on the common ECS pattern with a well separated design using rx and adhering to IoC and other sensible design patterns.
+EcsRx is a reactive take on the common ECS pattern with a well separated design using rx and adhering to IoC and other sensible design patterns, with a more cut down systems only version called SystemsRx if you dont need Entities and Components.
 
 [![Build Status][build-status-image]][build-status-url]
 [![Code Quality Status][codacy-image]][codacy-url]
@@ -91,15 +91,30 @@ If you want to run the examples then just clone it and open examples project in
 
 There are also a suite of tests which are being expanded as the project grows, it was written with testability in mind.
 
-## Note on infrastructure/view namespaces and going forward
+## Architecture / Infrastructure
 
-This library started out as a unity specific project but has moved to a generic .net library, due to this the movement of functionality from the unity layer down into the core has been incremental. 
+### MicroRx
 
-We are now at a point where the underlying infrastructure module (mainly for `EcsRxApplication` and dependency injection notions) has been added, and the generic view module has been moved here. While both of these libraries offer a stepping stone to get up and running quicker they unfortunately are not as easy as just including and off you go.
+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
+
+SystemsRx is a really just the Systems aspect of the ECS paradigm without any dependencies on Entites or Components. It allows you create your own conventions for systems as well as 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**
+
+### EcsRx
+
+This is layered on top of **SystemsRx** and adds the ECS paradigm to the framework as well as adding a couple of systems specifically for entity handling. This also contains an **EcsRx.Infrastructure** layer which builds off the **SystemsRx.Infrastructure** layer to provide additional ECS related infrastructure.
+
+### EcsRx.Plugins.*
+
+These are plugins that can be used with **EcsRx** to add new functionality to the library, from entity persistance/rehydration to schedulable systems, these can optionally be added to your projects.
+
+### History
+The library was originally deveoped for unity (way before they had their own ECS framework) and since then has moved to be a regular .net library that can run anywhere (Even in Blazor WASM).
 
-The examples folder shows examples on how to create your own application implementations, but hopefully once things have been ironed out in the whole Rx world this area will improve more as we start to add another layer which will let you just drop in and go (like the unity version).
 
-If you want to know more about this drop into the discord chat and we can discuss more.
 
 ## Docs
 

appveyor.yml

@@ -1,4 +1,4 @@
-version: 3.12.{build}
+version: 4.0.{build}
 branches:
   only:
   - master

build/pack.bat

@@ -1,5 +1,7 @@
 set version=3.0.0
 dotnet pack ../src/EcsRx.MicroRx -c Release -o ../../_dist /p:version=%version%
+dotnet pack ../src/SystemsRx -c Release -o ../../_dist /p:version=%version%
+dotnet pack ../src/SystemsRx.Infrastructure -c Release -o ../../_dist /p:version=%version%
 dotnet pack ../src/EcsRx -c Release -o ../../_dist /p:version=%version%
 dotnet pack ../src/EcsRx.Plugins.ReactiveSystems -c Release -o ../../_dist /p:version=%version%
 dotnet pack ../src/EcsRx.Plugins.Views -c Release -o ../../_dist /p:version=%version%

docs/breaking-changes.md

@@ -1,12 +1,21 @@
 # Breaking Changes
 
+## 3.12.0 -> 4.0.0
+
+- `IEcsRxPlugin` has been renamed to `ISystemsRxPlugin` and lives in `SystemsRx.Infrastructure`
+- `EventReactionSystem<T>` no longer exists, the same convention can be mapped to `IReactToEventSystem` from `SystemsRx`
+- `IBasicSystem` has changed and has no `IEntity` dependencies and lives in `SystemsRx`, the same convention can be mapped to `IBasicEntitySystem` in `EcsRx`
+- `IManualSystem` no longer has a group or gets passed `IObservableGroupManager`, you can inject it yourself if you need it
+- `EcsRx` now depends upon `SystemsRx`, all the classes in `SystemsRx` were originally in `EcsRx` but now can be used without the `ECS` related paradigm dependencies
+- `ISystem` no longer contains an `IGroup` and now lives in `SystemsRx` there is now an `IGroupSystem` which represents a system with a `IGroup`
+
 ## 3.10.0 -> 3.11.0
 
-- IEntityCollectionManager no longer exists, it is now just `IObservableGroupManager`
+- `IEntityCollectionManager` no longer exists, it is now just `IObservableGroupManager`
 
 ## 3.9.0 -> 3.10.0
 
-- IEntityCollectionManager no longer contains EntityCollections its now within `IEntityDatabase`, which is within there
+- `IEntityCollectionManager` no longer contains EntityCollections its now within `IEntityDatabase`, which is within there
 
 ## 3.8.0 -> 3.9.0
 

docs/framework/systems.md

@@ -4,30 +4,47 @@ Systems are where all the logic lives, it takes entities from the collection and
 
 This means your systems don't need to worry about the logistics of getting entities and dealing with them, you just express how you want to interact with entities and let the `SystemExecutor` handle the heavy lifting and pass you the entities for processing. This can easily be seen when you look at all the available system interfaces which all process individual entities not groups of them.
 
+> Since version 4.0.0 of EcsRx some systems can be used without the Ecs paradigm and live within the `SystemsRx` library, which can be included without the need for `EcsRx`. 
+
 ## System Types
 
 This is where it gets interesting, so we have multiple flavours of systems depending on how you want to consume the entities, by default there is `IManualSystem` but there is a project containing all most common systems (`EcsRx.Systems`). You can also mix them up so you could have a single system implement `ISetupSystem`, `ITeardown` and `IReactToEntitySystem` which would run a setup method for each entity when it joins the group then react to the entity changes and process them on changes, then finally run some logic when the entity is being removed from the group.
 
-All systems have the notion of a `Group` which describes what entities to target out of the pool, so you don't need to do much other than setup the right groupings and implement the methods for the interfaces.
+All **ECS** *(Not SystemsRx)* systems have the notion of a `Group` which describes what entities to target out of the pool, so you don't need to do much other than setup the right groupings and implement the methods for the interfaces.
 
-### IManualSystem
+### `IManualSystem` *(SystemsRx)*
 
 This is a niche system for when you want to carry out some logic outside the scope of entities, or want to have 
 more fine grained control over how you deal with the entities matched.
 
-Rather than the `SystemExecutor` doing most of the work for you and managing the subscriptions and entity interactions 
-this just provides you the `GroupAccessor` for the entities targeted and its up to you to control how they are 
-dealt with.
+Rather than the `SystemExecutor` doing most of the work for you and managing the subscriptions it leaves it up to you
+to manage everything how you want once the system has been started.
 
 The `StartSystem` method will be triggered when the system has been added to the executor, and the `StopSystem` 
 will be triggered when the system is removed.
 
+### `IBasicSystem` *(SystemsRx)*
+
+This is a basic system that is triggered every update (based on scheduler update frequency) and lets you do anything you want per update.
+
+### `IReactToEventSystem` *(SystemsRx)*
+
+This allows you to react to any event of that type which is published over the `IEventSystem`.
+
+### `IBasicEntitySystem` *(EcsRx)*
+
+This system allows you to process each entity within the group on every update cycle (much like `IBasicSystem` but with entities).
+
+### `ReactiveSystems`
+
+There is a few plugins that contain more contextual systems that can be read about more in the docs.
+
 ## System Loading Order
 
 So by default (with the default implementation of `ISystemExecutor`) systems will load in the order of:
 
 1. Implementations of `ISetupSystem`
 2. Implementations of `IReactToEntitySystem`
-3. Other Systems
+3. Other Systems 
 
 However within those groupings it will load the systems in whatever order Zenject/Extenject (assuming you are using it) provides them, however there is a way to enforce some level of priority by applying the `[Priority(1)]` attribute, this allows you to specify the priority of how systems should be loaded. The ordering will be from lowest to highest so if you have a priority of 1 it will load before a system with a priority of 10.

src/EcsRx.Examples/Application/EcsRxConsoleApplication.cs

@@ -1,5 +1,5 @@
-using EcsRx.Infrastructure;
-using EcsRx.Infrastructure.Dependencies;
+using SystemsRx.Infrastructure.Dependencies;
+using EcsRx.Infrastructure;
 using EcsRx.Infrastructure.Ninject;
 using EcsRx.Plugins.Batching;
 using EcsRx.Plugins.Computeds;

src/EcsRx.Examples/Custom/Systems/FirstSystem.cs

@@ -1,5 +1,5 @@
 using System;
-using EcsRx.Attributes;
+using SystemsRx.Attributes;
 using EcsRx.Entities;
 using EcsRx.Examples.Custom.Groups;
 using EcsRx.Groups;

src/EcsRx.Examples/Custom/Systems/SecondSystem.cs

@@ -1,5 +1,5 @@
 using System;
-using EcsRx.Attributes;
+using SystemsRx.Attributes;
 using EcsRx.Entities;
 using EcsRx.Examples.Custom.Groups;
 using EcsRx.Groups;

src/EcsRx.Examples/ExampleApps/BatchedGroupExample/BatchedGroupExampleApplication.cs

@@ -1,8 +1,8 @@
 using System;
+using SystemsRx.Infrastructure.Extensions;
 using EcsRx.Examples.Application;
 using EcsRx.Examples.ExampleApps.BatchedGroupExample.Blueprints;
 using EcsRx.Examples.ExampleApps.BatchedGroupExample.Modules;
-using EcsRx.Infrastructure.Extensions;
 
 namespace EcsRx.Examples.ExampleApps.BatchedGroupExample
 {

src/EcsRx.Examples/ExampleApps/BatchedGroupExample/Modules/CustomComponentLookupsModule.cs

@@ -1,10 +1,10 @@
 using System;
 using System.Collections.Generic;
+using SystemsRx.Infrastructure.Dependencies;
+using SystemsRx.Infrastructure.Extensions;
 using EcsRx.Components.Lookups;
 using EcsRx.Examples.ExampleApps.BatchedGroupExample.Components;
 using EcsRx.Examples.ExampleApps.BatchedGroupExample.Lookups;
-using EcsRx.Infrastructure.Dependencies;
-using EcsRx.Infrastructure.Extensions;
 
 namespace EcsRx.Examples.ExampleApps.BatchedGroupExample.Modules
 {

src/EcsRx.Examples/ExampleApps/BatchedGroupExample/Systems/BatchedMovementSystem.cs

@@ -1,18 +1,20 @@
 using System;
 using System.Numerics;
 using System.Reactive.Linq;
+using SystemsRx.Threading;
+using EcsRx.Collections;
 using EcsRx.Components.Database;
 using EcsRx.Components.Lookups;
 using EcsRx.Examples.ExampleApps.BatchedGroupExample.Components;
 using EcsRx.Plugins.Batching.Factories;
 using EcsRx.Plugins.Batching.Systems;
-using EcsRx.Threading;
 
 namespace EcsRx.Examples.ExampleApps.BatchedGroupExample.Systems
 {
     public class BatchedMovementSystem : BatchedSystem<PositionComponent, MovementSpeedComponent>
     {
-        public BatchedMovementSystem(IComponentDatabase componentDatabase, IComponentTypeLookup componentTypeLookup, IBatchBuilderFactory batchBuilderFactory, IThreadHandler threadHandler) : base(componentDatabase, componentTypeLookup, batchBuilderFactory, threadHandler)
+        public BatchedMovementSystem(IComponentDatabase componentDatabase, IComponentTypeLookup componentTypeLookup, IBatchBuilderFactory batchBuilderFactory, IThreadHandler threadHandler, IObservableGroupManager observableGroupManager) 
+            : base(componentDatabase, componentTypeLookup, batchBuilderFactory, threadHandler, observableGroupManager)
         {}
 
         protected override IObservable<bool> ReactWhen()

src/EcsRx.Examples/ExampleApps/BatchedGroupExample/Systems/LifetimeSystem.cs renamed to src/EcsRx.Examples/ExampleApps/BatchedGroupExample/Systems/SpawnerSystem.cs

@@ -1,34 +1,30 @@
 using System;
 using System.Reactive.Linq;
+using SystemsRx.Systems.Conventional;
 using EcsRx.Blueprints;
-using EcsRx.Collections;
 using EcsRx.Collections.Database;
 using EcsRx.Collections.Entity;
 using EcsRx.Examples.ExampleApps.BatchedGroupExample.Blueprints;
-using EcsRx.Groups;
-using EcsRx.Groups.Observable;
-using EcsRx.Systems;
 
 namespace EcsRx.Examples.ExampleApps.BatchedGroupExample.Systems
 {
     public class SpawnerSystem : IManualSystem
     {
         private IDisposable _sub;
         private IBlueprint _blueprint = new MoveableBlueprint();
-        
-        public IGroup Group { get; } = new EmptyGroup();       
+            
         public IEntityCollection DefaultCollection { get; }
 
         public SpawnerSystem(IEntityDatabase entityDatabase)
         { DefaultCollection = entityDatabase.GetCollection(); }
 
-        public void StartSystem(IObservableGroup observableGroup)
+        public void StartSystem()
         { _sub = Observable.Interval(TimeSpan.FromSeconds(2)).Subscribe(x => Spawn()); }
 
         public void Spawn()
         { DefaultCollection.CreateEntity(_blueprint); }
 
-        public void StopSystem(IObservableGroup observableGroup)
+        public void StopSystem()
         { _sub.Dispose(); }
     }
 }

src/EcsRx.Examples/ExampleApps/ComputedGroupExample/ComputedGroupExampleApplication.cs

@@ -1,8 +1,8 @@
 using System;
+using SystemsRx.Infrastructure.Extensions;
 using EcsRx.Examples.Application;
 using EcsRx.Examples.ExampleApps.ComputedGroupExample.Blueprints;
 using EcsRx.Examples.ExampleApps.ComputedGroupExample.Modules;
-using EcsRx.Infrastructure.Extensions;
 
 namespace EcsRx.Examples.ExampleApps.ComputedGroupExample
 {

src/EcsRx.Examples/ExampleApps/ComputedGroupExample/Modules/ComputedModule.cs

@@ -1,7 +1,8 @@
+using SystemsRx.Infrastructure.Dependencies;
+using SystemsRx.Infrastructure.Extensions;
 using EcsRx.Examples.ExampleApps.ComputedGroupExample.Components;
 using EcsRx.Examples.ExampleApps.ComputedGroupExample.ComputedGroups;
 using EcsRx.Groups;
-using EcsRx.Infrastructure.Dependencies;
 using EcsRx.Infrastructure.Extensions;
 
 namespace EcsRx.Examples.ExampleApps.ComputedGroupExample.Modules

src/EcsRx.Examples/ExampleApps/ComputedGroupExample/Systems/DisplayLowestHealthSystem.cs

@@ -1,6 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Reactive.Linq;
+using SystemsRx.Extensions;
+using SystemsRx.Systems;
+using SystemsRx.Systems.Conventional;
 using EcsRx.Examples.ExampleApps.ComputedGroupExample.ComputedGroups;
 using EcsRx.Examples.ExampleApps.ComputedGroupExample.Extensions;
 using EcsRx.Extensions;
@@ -13,8 +16,6 @@ namespace EcsRx.Examples.ExampleApps.ComputedGroupExample.Systems
 {
     public class DisplayLowestHealthSystem : IManualSystem
     {
-        public IGroup Group { get; } = new EmptyGroup();
-        
         private readonly IList<IDisposable> _subscriptions = new List<IDisposable>();
 
         private readonly ILowestHealthComputedGroup _lowestHealthGroup;
@@ -24,10 +25,10 @@ public DisplayLowestHealthSystem(ILowestHealthComputedGroup lowestHealthGroup)
             _lowestHealthGroup = lowestHealthGroup;
         }
 
-        public void StartSystem(IObservableGroup observableGroup)
+        public void StartSystem()
         { Observable.Interval(TimeSpan.FromSeconds(1)).Subscribe(UpdateListings).AddTo(_subscriptions); }
 
-        public void StopSystem(IObservableGroup observableGroup)
+        public void StopSystem()
         { _subscriptions.DisposeAll(); }
 
         public void UpdateListings(long _)

src/EcsRx.Examples/ExampleApps/ComputedGroupExample/Systems/RandomlyChangeHp.cs

@@ -9,7 +9,7 @@
 
 namespace EcsRx.Examples.ExampleApps.ComputedGroupExample.Systems
 {
-    public class RandomlyChangeHpSystem : IReactToGroupSystem
+    public class RandomlyChangeHpGroupSystem : IReactToGroupSystem
     {
         private const int HealthChange = 20;
 

src/EcsRx.Examples/ExampleApps/DataPipelinesExample/Modules/PipelineModule.cs

@@ -1,6 +1,6 @@
+using SystemsRx.Infrastructure.Dependencies;
+using SystemsRx.Infrastructure.Extensions;
 using EcsRx.Examples.ExampleApps.DataPipelinesExample.Pipelines;
-using EcsRx.Infrastructure.Dependencies;
-using EcsRx.Infrastructure.Extensions;
 using LazyData.Json;
 using LazyData.Json.Handlers;
 

src/EcsRx.Examples/ExampleApps/DataPipelinesExample/PersistDataApplication.cs

@@ -1,15 +1,10 @@
 using System;
-using EcsRx.Entities;
+using SystemsRx.Infrastructure.Extensions;
 using EcsRx.Examples.Application;
 using EcsRx.Examples.ExampleApps.DataPipelinesExample.Components;
 using EcsRx.Examples.ExampleApps.DataPipelinesExample.Events;
 using EcsRx.Examples.ExampleApps.DataPipelinesExample.Modules;
-using EcsRx.Examples.ExampleApps.HealthExample.Blueprints;
-using EcsRx.Examples.ExampleApps.HealthExample.Components;
-using EcsRx.Examples.ExampleApps.HealthExample.Events;
 using EcsRx.Extensions;
-using EcsRx.Infrastructure.Extensions;
-using Persistity.Pipelines;
 
 namespace EcsRx.Examples.ExampleApps.DataPipelinesExample
 {

src/EcsRx.Examples/ExampleApps/DataPipelinesExample/Systems/PlayerStateUpdaterSystem.cs renamed to src/EcsRx.Examples/ExampleApps/DataPipelinesExample/Systems/PlayerStateUpdaterGroupSystem.cs

@@ -1,19 +1,19 @@
+using SystemsRx.Scheduling;
 using EcsRx.Entities;
 using EcsRx.Examples.ExampleApps.DataPipelinesExample.Components;
 using EcsRx.Extensions;
 using EcsRx.Groups;
-using EcsRx.Scheduling;
 using EcsRx.Systems;
 
 namespace EcsRx.Examples.ExampleApps.DataPipelinesExample.Systems
 {
-    public class PlayerStateUpdaterSystem : IBasicSystem
+    public class PlayerStateUpdaterEntitySystem : IBasicEntitySystem
     {
         public IGroup Group { get; } = new Group(typeof(PlayerStateComponent));
 
         public ITimeTracker TimeTracker { get; }
 
-        public PlayerStateUpdaterSystem(ITimeTracker timeTracker)
+        public PlayerStateUpdaterEntitySystem(ITimeTracker timeTracker)
         {
             TimeTracker = timeTracker;
         }