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); }