public void should_only_trigger_teardown_system_when_entity_loses_required_component()
{
var dummyGroup = new Group(typeof(TestComponentOne), typeof(TestComponentTwo));
var mockPoolManager = Substitute.For <IPoolManager>();
var pool = mockPoolManager.GetPool();
var mockEventSystem = Substitute.For <IEventSystem>();
var fakeSystem = Substitute.For <ITeardownSystem>();
fakeSystem.TargetGroup.Returns(dummyGroup);
var systemExecutor = new SystemExecutor(mockPoolManager, mockEventSystem,
null, null, null, null, null);
systemExecutor.AddSystem(fakeSystem);
var entity = new Entity(Guid.NewGuid(), pool, mockEventSystem);
entity.AddComponent(new TestComponentOne());
entity.AddComponent(new TestComponentTwo());
// Should not trigger
systemExecutor.OnEntityComponentRemoved(new ComponentRemovedEvent(entity, new TestComponentThree()));
// Should trigger
systemExecutor.OnEntityComponentRemoved(new ComponentRemovedEvent(entity, new TestComponentTwo()));
fakeSystem.Received(1).Teardown(Arg.Is(entity));
}
protected virtual ISystem RegisterBoundSystem <T>() where T : ISystem
{
var system = DependencyContainer.Resolve <T>();
SystemExecutor.AddSystem(system);
return(system);
}
public void should_effect_correct_setup_systems_once()
{
var dummyGroup = new Group(typeof(TestComponentOne), typeof(TestComponentTwo));
var mockPoolManager = Substitute.For <IPoolManager>();
var pool = mockPoolManager.GetPool();
var mockEventSystem = Substitute.For <IEventSystem>();
var mockSetupSystemHandler = Substitute.For <ISetupSystemHandler>();
var fakeSystem = Substitute.For <ISetupSystem>();
fakeSystem.TargetGroup.Returns(dummyGroup);
var systemExecutor = new SystemExecutor(mockPoolManager, mockEventSystem,
null, null, mockSetupSystemHandler, null, null);
systemExecutor.AddSystem(fakeSystem);
var entity = new Entity(Guid.NewGuid(), pool, mockEventSystem);
entity.AddComponent(new TestComponentOne());
systemExecutor.OnEntityComponentAdded(new ComponentAddedEvent(entity, new TestComponentOne()));
entity.AddComponent(new TestComponentTwo());
systemExecutor.OnEntityComponentAdded(new ComponentAddedEvent(entity, new TestComponentTwo()));
entity.AddComponent(new TestComponentThree());
systemExecutor.OnEntityComponentAdded(new ComponentAddedEvent(entity, new TestComponentThree()));
mockSetupSystemHandler.Received(1).ProcessEntity(Arg.Is(fakeSystem), Arg.Is(entity));
}
public void should_destroy_all_systems_and_handlers_when_disposed()
{
var fakeSetupSystemHandler1 = Substitute.For <IConventionalSystemHandler>();
var fakeSetupSystemHandler2 = Substitute.For <IConventionalSystemHandler>();
var fakeSystem1 = Substitute.For <ISetupSystem>();
var fakeSystem2 = Substitute.For <ISetupSystem>();
var fakeSystem3 = Substitute.For <ISetupSystem>();
fakeSetupSystemHandler1.CanHandleSystem(Arg.Any <ISystem>()).Returns(true);
fakeSetupSystemHandler2.CanHandleSystem(Arg.Any <ISystem>()).Returns(true);
var systemExecutor = new SystemExecutor(new[] { fakeSetupSystemHandler1, fakeSetupSystemHandler2 });
systemExecutor._systems.Add(fakeSystem1);
systemExecutor._systems.Add(fakeSystem2);
systemExecutor._systems.Add(fakeSystem3);
systemExecutor.Dispose();
fakeSetupSystemHandler1.Received(3).DestroySystem(Arg.Any <ISystem>());
fakeSetupSystemHandler2.Received(3).DestroySystem(Arg.Any <ISystem>());
fakeSetupSystemHandler1.Received(1).Dispose();
fakeSetupSystemHandler2.Received(1).Dispose();
Assert.Empty(systemExecutor._systems);
}
public void should_remove_setup_system_subscriptions_and_dispose_when_removing_corresponding_entity()
{
var dummyGroup = new Group(typeof(TestComponentOne));
var mockPoolManager = Substitute.For <IPoolManager>();
var mockEventSystem = Substitute.For <IEventSystem>();
var mockSetupSystemHandler = Substitute.For <ISetupSystemHandler>();
var fakeSystem = Substitute.For <ISetupSystem>();
fakeSystem.TargetGroup.Returns(dummyGroup);
var entity = new Entity(Guid.NewGuid(), mockEventSystem);
entity.AddComponent(new TestComponentOne());
var fakeDisposable = Substitute.For <IDisposable>();
mockSetupSystemHandler.ProcessEntity(fakeSystem, entity).Returns(new SubscriptionToken(entity, fakeDisposable));
var systemExecutor = new SystemExecutor(mockPoolManager, mockEventSystem,
null, null, mockSetupSystemHandler, null, null);
systemExecutor.AddSystem(fakeSystem);
systemExecutor.OnEntityAddedToPool(new EntityAddedEvent(entity, null));
Assert.That(systemExecutor.GetSubscriptionCountForSystem(fakeSystem), Is.EqualTo(1));
Assert.That(systemExecutor.GetTotalSubscriptions(), Is.EqualTo(1));
systemExecutor.OnEntityRemovedFromPool(new EntityRemovedEvent(entity, null));
Assert.That(systemExecutor.GetSubscriptionCountForSystem(fakeSystem), Is.EqualTo(0));
Assert.That(systemExecutor.GetTotalSubscriptions(), Is.EqualTo(0));
fakeDisposable.Received().Dispose();
}
public void StartApplication()
{
ApplicationStarting();
SystemExecutor.Start(CoreManager);
ApplicationStarted();
}
public void should_return_false_if_system_doesnt_exist()
{
var fakeSystem = Substitute.For <ISystem>();
var systemExecutor = new SystemExecutor(new IConventionalSystemHandler[0]);
Assert.False(systemExecutor.HasSystem(fakeSystem));
}
public void should_return_true_if_system_already_exists()
{
var fakeSystem = Substitute.For <ISystem>();
var systemExecutor = new SystemExecutor(new IConventionalSystemHandler[0]);
systemExecutor._systems.Add(fakeSystem);
Assert.True(systemExecutor.HasSystem(fakeSystem));
}
protected override void GameStarted()
{
var defaultPool = PoolManager.GetPool();
SystemExecutor.AddSystem(DefaultViewResolver);
SystemExecutor.AddSystem(RandomMovementSystem);
var entity = defaultPool.CreateEntity();
entity.AddComponent(new ViewComponent());
}
protected override void ApplicationStarted()
{
SystemExecutor.AddSystem(CustomViewSetupSystem);
SystemExecutor.AddSystem(PlayerControlSystem);
SystemExecutor.AddSystem(CameraFollowSystem);
var defaultPool = PoolManager.GetPool();
var viewEntity = defaultPool.CreateEntity();
viewEntity.AddComponent(new CustomViewComponent());
viewEntity.AddComponent(new PlayerControlledComponent());
viewEntity.AddComponent(new CameraFollowsComponent());
}
private void backgroundWorkerExecute_DoWork(object sender, DoWorkEventArgs e)
{
var worker = (BackgroundWorker)sender;
var args = (Object[])e.Argument;
_name = (string)args[0];
var executor = new SystemExecutor((string)args[0], (BrandList)args[1], (TimeFrame)args[2]);
executor.Execute(worker, WrapInvoke(textBoxExecute.AppendText));
if (worker.CancellationPending)
{
e.Cancel = true;
}
}
public void should_handle_and_expose_system()
{
var fakeSetupSystemHandler = Substitute.For <IConventionalSystemHandler>();
var fakeSystem = Substitute.For <ISetupSystem>();
fakeSetupSystemHandler.CanHandleSystem(Arg.Is(fakeSystem)).Returns(true);
var systemExecutor = new SystemExecutor(new[] { fakeSetupSystemHandler });
systemExecutor.AddSystem(fakeSystem);
fakeSetupSystemHandler.Received(1).SetupSystem(fakeSystem);
Assert.Contains(fakeSystem, systemExecutor.Systems);
}
public void should_remove_system_from_systems()
{
var mockPoolManager = Substitute.For <IPoolManager>();
var mockEventSystem = Substitute.For <IEventSystem>();
var mockSetupSystemHandler = Substitute.For <ISetupSystemHandler>();
var fakeSystem = Substitute.For <ISetupSystem>();
var systemExecutor = new SystemExecutor(mockPoolManager, mockEventSystem,
null, null, mockSetupSystemHandler, null, null);
systemExecutor.AddSystem(fakeSystem);
systemExecutor.RemoveSystem(fakeSystem);
Assert.That(systemExecutor.Systems, Is.Empty);
}
public void should_identify_as_reactive_entity_system_and_add_to_systems()
{
var mockPoolManager = Substitute.For <IPoolManager>();
var messageBroker = Substitute.For <IMessageBroker>();
var mockReactToEntitySystemHandler = Substitute.For <IReactToEntitySystemHandler>();
var fakeSystem = Substitute.For <IReactToEntitySystem>();
var systemExecutor = new SystemExecutor(mockPoolManager, messageBroker,
mockReactToEntitySystemHandler, null, null, null);
systemExecutor.AddSystem(fakeSystem);
mockReactToEntitySystemHandler.Received().Setup(fakeSystem);
Assert.That(systemExecutor.Systems, Contains.Item(fakeSystem));
}
public void should_identify_as_react_with_data_system_and_add_to_systems()
{
var mockPoolManager = Substitute.For <IPoolManager>();
var mockEventSystem = Substitute.For <IEventSystem>();
var mockReactToDataSystemHandler = Substitute.For <IReactToDataSystemHandler>();
var fakeSystem = Substitute.For <IReactToDataSystem <int> >();
var systemExecutor = new SystemExecutor(mockPoolManager, mockEventSystem,
null, null, null, mockReactToDataSystemHandler, null);
systemExecutor.AddSystem(fakeSystem);
mockReactToDataSystemHandler.Received().SetupWithoutType(fakeSystem);
Assert.That(systemExecutor.Systems, Contains.Item(fakeSystem));
}
public void should_identify_as_reactive_group_system_and_add_to_systems()
{
var mockPoolManager = Substitute.For <IPoolManager>();
var mockEventSystem = Substitute.For <IEventSystem>();
var mockReactToGroupSystemHandler = Substitute.For <IGroupReactionSystemHandler>();
var fakeSystem = Substitute.For <IGroupReactionSystem>();
var systemExecutor = new SystemExecutor(mockPoolManager, mockEventSystem,
null, mockReactToGroupSystemHandler, null, null, null);
systemExecutor.AddSystem(fakeSystem);
mockReactToGroupSystemHandler.Received().Setup(fakeSystem);
Assert.That(systemExecutor.Systems, Contains.Item(fakeSystem));
}
public void should_handle_and_remove_system()
{
var fakeSetupSystemHandler = Substitute.For <IConventionalSystemHandler>();
var fakeSystem = Substitute.For <ISetupSystem>();
fakeSetupSystemHandler.CanHandleSystem(Arg.Is(fakeSystem)).Returns(true);
var systemExecutor = new SystemExecutor(new[] { fakeSetupSystemHandler });
systemExecutor._systems.Add(fakeSystem);
systemExecutor.RemoveSystem(fakeSystem);
fakeSetupSystemHandler.Received(1).DestroySystem(fakeSystem);
Assert.Empty(systemExecutor.Systems);
}
public void should_run_systems_in_correct_priority()
{
var expectedOrder = "1234";
var actualOrder = new StringBuilder();
var conventionalSystems = new IConventionalSystemHandler[]
{
new DefaultPriorityHandler(() => actualOrder.Append(3)),
new HigherPriorityHandler(() => actualOrder.Append(1)),
new HighPriorityHandler(() => actualOrder.Append(2)),
new LowerPriorityHandler(() => actualOrder.Append(4))
};
var systemExecutor = new SystemExecutor(conventionalSystems);
var fakeSystem1 = Substitute.For <ISetupSystem>();
systemExecutor.AddSystem(fakeSystem1);
Assert.Equal(expectedOrder, actualOrder.ToString());
}
protected EcsRxApplication()
{
// For sending events around
EventSystem = new EventSystem(new MessageBroker());
// For mapping component types to underlying indexes
var componentTypeAssigner = new DefaultComponentTypeAssigner();
var allComponents = componentTypeAssigner.GenerateComponentLookups();
var componentLookup = new ComponentTypeLookup(allComponents);
// For interacting with the component databases
var componentDatabase = new ComponentDatabase(componentLookup);
var componentRepository = new ComponentRepository(componentLookup, componentDatabase);
// For creating entities, collections, observable groups and managing Ids
var entityFactory = new DefaultEntityFactory(new IdPool(), componentRepository);
var entityCollectionFactory = new DefaultEntityCollectionFactory(entityFactory);
var observableGroupFactory = new DefaultObservableObservableGroupFactory();
EntityCollectionManager = new EntityCollectionManager(entityCollectionFactory, observableGroupFactory, componentLookup);
// All system handlers for the system types you want to support
var reactsToEntityHandler = new ReactToEntitySystemHandler(EntityCollectionManager);
var reactsToGroupHandler = new ReactToGroupSystemHandler(EntityCollectionManager);
var reactsToDataHandler = new ReactToDataSystemHandler(EntityCollectionManager);
var manualSystemHandler = new ManualSystemHandler(EntityCollectionManager);
var setupHandler = new SetupSystemHandler(EntityCollectionManager);
var teardownHandler = new TeardownSystemHandler(EntityCollectionManager);
var conventionalSystems = new List <IConventionalSystemHandler>
{
setupHandler,
teardownHandler,
reactsToEntityHandler,
reactsToGroupHandler,
reactsToDataHandler,
manualSystemHandler
};
// The main executor which manages how systems are given information
SystemExecutor = new SystemExecutor(conventionalSystems);
}
public void should_throw_exception_if_system_already_exists()
{
var fakeSystem = Substitute.For <ISystem>();
var systemExecutor = new SystemExecutor(new IConventionalSystemHandler[0]);
systemExecutor._systems.Add(fakeSystem);
var exceptionWasRaised = false;
try
{
systemExecutor.AddSystem(fakeSystem);
}
catch (SystemAlreadyRegisteredException e)
{
exceptionWasRaised = true;
}
Assert.Single(systemExecutor.Systems);
Assert.True(exceptionWasRaised);
}
protected override void ApplicationStarted()
{
var namedHealthGroup = EntityCollectionManager.GetObservableGroup(new Group(typeof(HasHealthComponent), typeof(HasNameComponent)));
var computedGroup = new LowestHealthComputedGroup(namedHealthGroup);
var displayHealthSystem = new DisplayLowestHealthSystem(computedGroup);
SystemExecutor.AddSystem(displayHealthSystem);
this.StartAllBoundSystems();
var defaultPool = EntityCollectionManager.GetCollection();
defaultPool.CreateEntity(new CharacterBlueprint("Bob", 200));
defaultPool.CreateEntity(new CharacterBlueprint("Tom", 150));
defaultPool.CreateEntity(new CharacterBlueprint("Rolf", 150));
defaultPool.CreateEntity(new CharacterBlueprint("Mez", 100));
defaultPool.CreateEntity(new CharacterBlueprint("TP", 1000));
defaultPool.CreateEntity(new CharacterBlueprint("MasterChief", 100));
defaultPool.CreateEntity(new CharacterBlueprint("Weakling", 20));
HandleInput();
}
protected ReactorApplication()
{
var messageBroker = new MessageBroker();
EventSystem = new EventSystem(messageBroker);
SystemExecutor = new SystemExecutor(EventSystem);
var entityFactory = new DefaultEntityFactory();
var entityIndexPool = new EntityIndexPool();
var poolFactory = new DefaultPoolFactory(entityFactory, EventSystem, entityIndexPool, SystemExecutor);
var groupAccessorFactory = new DefaultGroupAccessorFactory(EventSystem);
PoolManager = new PoolManager(EventSystem, poolFactory, groupAccessorFactory);
var entitySytemHandler = new EntityReactionSystemHandler(PoolManager);
var groupSystemHandler = new GroupReactionSystemHandler(PoolManager);
var setupSystemHandler = new SetupSystemHandler(PoolManager);
var interactSystemHandler = new InteractReactionSystemHandler(PoolManager);
var manualSystemHandler = new ManualSystemHandler(PoolManager);
var systemHandlerManager = new SystemHandlerManager(entitySytemHandler, groupSystemHandler, setupSystemHandler, interactSystemHandler, manualSystemHandler);
CoreManager = new CoreManager(PoolManager, systemHandlerManager, SystemExecutor);
}
protected override void ApplicationStarting()
{
SystemExecutor.AddSystem(new SomeSystem());
SystemExecutor.AddSystem(new SomeSystem2());
SystemExecutor.AddSystem(new SomeSystem3());
}
protected virtual void SetupAllPluginSystems()
{
Plugins.SelectMany(x => x.GetSystemsForRegistration(DependencyContainer))
.ForEachRun(x => SystemExecutor.AddSystem(x));
}
protected override void SetupSystems()
{
SystemExecutor.AddSystem(ViewSetupSystem);
SystemExecutor.AddSystem(PlayerControlSystem);
SystemExecutor.AddSystem(CameraFollowSystem);
}
protected virtual void StartPluginSystems()
{
_plugins.SelectMany(x => x.GetSystemsForRegistration(Container))
.ForEachRun(x => SystemExecutor.AddSystem(x));
}
protected virtual void RegisterBoundSystem <T>() where T : ISystem
{
var system = Container.Resolve <T>();
SystemExecutor.AddSystem(system);
}
protected override void SetupSystems()
{
SystemExecutor.AddSystem(CubeSetupSystem);
SystemExecutor.AddSystem(ColorChangingSystem);
SystemExecutor.AddSystem(CubeColourChangerSystem);
}
