private void ApplyEntityToSystems(IEnumerable <ISystem> systems, IEntity entity) { systems.OfType <ISetupSystem>() .OrderByPriority() .ForEachRun(x => { var possibleSubscription = SetupSystemHandler.ProcessEntity(x, entity); if (possibleSubscription != null) { _systemSubscriptions[x].Add(possibleSubscription); } }); systems.OfType <IReactToEntitySystem>() .OrderByPriority() .ForEachRun(x => { var subscription = ReactToEntitySystemHandler.ProcessEntity(x, entity); _systemSubscriptions[x].Add(subscription); }); systems.Where(x => x.IsReactiveDataSystem()) .OrderByPriority() .ForEachRun(x => { var subscription = ReactToDataSystemHandler.ProcessEntityWithoutType(x, entity); _systemSubscriptions[x].Add(subscription); }); }
public void should_destroy_and_dispose_system() { var id1 = 1; var id2 = 2; var mockCollectionManager = Substitute.For <IEntityCollectionManager>(); var mockSystem = Substitute.For <IReactToDataSystem <int> >(); var mockSystemDisposable = Substitute.For <IDisposable>(); var systemHandler = new ReactToDataSystemHandler(mockCollectionManager); systemHandler._systemSubscriptions.Add(mockSystem, mockSystemDisposable); var entitySubscriptions = new Dictionary <int, IDisposable>(); var mockEntityDisposable1 = Substitute.For <IDisposable>(); entitySubscriptions.Add(id1, mockEntityDisposable1); var mockEntityDisposable2 = Substitute.For <IDisposable>(); entitySubscriptions.Add(id2, mockEntityDisposable2); systemHandler._entitySubscriptions.Add(mockSystem, entitySubscriptions); systemHandler.DestroySystem(mockSystem); mockSystemDisposable.Received(1).Dispose(); Assert.Equal(0, systemHandler._systemSubscriptions.Count); mockEntityDisposable1.Received(1).Dispose(); mockEntityDisposable2.Received(1).Dispose(); Assert.Equal(0, systemHandler._entitySubscriptions.Count); }
public void should_dispose_entity_subscriptions_when_removed_from_group() { var fakeEntity1 = Substitute.For <IEntity>(); var fakeEntity2 = Substitute.For <IEntity>(); var fakeEntities = new List <IEntity> { fakeEntity1, fakeEntity2 }; var id1 = 1; var id2 = 2; fakeEntity1.Id.Returns(id1); fakeEntity2.Id.Returns(id2); var mockObservableGroup = Substitute.For <IObservableGroup>(); mockObservableGroup.GetEnumerator() .Returns(fakeEntities.GetEnumerator()); mockObservableGroup.OnEntityAdded.Returns(new Subject <IEntity>()); var removedSubject = new Subject <IEntity>(); mockObservableGroup.OnEntityRemoved.Returns(removedSubject); var mockCollectionManager = Substitute.For <IEntityCollectionManager>(); var fakeGroup = new Group(); mockCollectionManager.GetObservableGroup(Arg.Is(fakeGroup)).Returns(mockObservableGroup); var firstEntitySubject = new Subject <int>(); var secondEntitySubject = new Subject <int>(); var mockSystem = Substitute.For <IReactToDataSystem <int> >(); mockSystem.Group.Returns(fakeGroup); mockSystem.ReactToData(Arg.Is(fakeEntity1)).Returns(firstEntitySubject); mockSystem.ReactToData(Arg.Is(fakeEntity2)).Returns(secondEntitySubject); var systemHandler = new ReactToDataSystemHandler(mockCollectionManager); systemHandler.SetupSystem(mockSystem); Assert.Equal(1, systemHandler._entitySubscriptions.Count); Assert.Equal(2, systemHandler._entitySubscriptions[mockSystem].Count); Assert.True(systemHandler._entitySubscriptions[mockSystem].Keys.Contains(id1)); Assert.True(systemHandler._entitySubscriptions[mockSystem].Keys.Contains(id2)); Assert.All(systemHandler._entitySubscriptions[mockSystem].Values, Assert.NotNull); removedSubject.OnNext(fakeEntity1); Assert.Equal(1, systemHandler._entitySubscriptions.Count); Assert.Equal(1, systemHandler._entitySubscriptions[mockSystem].Count); Assert.True(systemHandler._entitySubscriptions[mockSystem].Keys.Contains(id2)); Assert.All(systemHandler._entitySubscriptions[mockSystem].Values, Assert.NotNull); }
public void should_only_execute_system_when_predicate_met() { var fakeEntity1 = Substitute.For <IEntity>(); var fakeEntity2 = Substitute.For <IEntity>(); var fakeEntities = new List <IEntity> { fakeEntity1, fakeEntity2 }; var id1 = 1; var id2 = 2; fakeEntity1.Id.Returns(id1); fakeEntity2.Id.Returns(id2); var mockObservableGroup = Substitute.For <IObservableGroup>(); mockObservableGroup.GetEnumerator().Returns(fakeEntities.GetEnumerator()); mockObservableGroup.OnEntityAdded.Returns(new Subject <IEntity>()); mockObservableGroup.OnEntityRemoved.Returns(new Subject <IEntity>()); var mockCollectionManager = Substitute.For <IEntityCollectionManager>(); var fakeGroup = new Group(x => x.Id == id1); mockCollectionManager.GetObservableGroup(Arg.Is(fakeGroup)).Returns(mockObservableGroup); var firstEntitySubject = new Subject <int>(); var secondEntitySubject = new Subject <int>(); var mockSystem = Substitute.For <IReactToDataSystem <int> >(); mockSystem.Group.Returns(fakeGroup); mockSystem.ReactToData(Arg.Is(fakeEntity1)).Returns(firstEntitySubject); mockSystem.ReactToData(Arg.Is(fakeEntity2)).Returns(secondEntitySubject); var systemHandler = new ReactToDataSystemHandler(mockCollectionManager); systemHandler.SetupSystem(mockSystem); firstEntitySubject.OnNext(1); secondEntitySubject.OnNext(2); mockSystem.Received(1).Process(Arg.Is(fakeEntity1), Arg.Is(1)); mockSystem.Received(0).Process(Arg.Is(fakeEntity2), Arg.Is(2)); Assert.Equal(1, systemHandler._systemSubscriptions.Count); Assert.NotNull(systemHandler._systemSubscriptions[mockSystem]); Assert.Equal(1, systemHandler._entitySubscriptions.Count); Assert.Equal(2, systemHandler._entitySubscriptions[mockSystem].Count); Assert.True(systemHandler._entitySubscriptions[mockSystem].Keys.Contains(id1)); Assert.True(systemHandler._entitySubscriptions[mockSystem].Keys.Contains(id2)); Assert.All(systemHandler._entitySubscriptions[mockSystem].Values, Assert.NotNull); }
private SystemExecutor CreateExecutor() { var messageBroker = new MessageBroker(); var identityGenerator = new SequentialIdentityGenerator(); var poolManager = new PoolManager(identityGenerator, messageBroker); var reactsToEntityHandler = new ReactToEntitySystemHandler(poolManager); var reactsToGroupHandler = new ReactToGroupSystemHandler(poolManager); var reactsToDataHandler = new ReactToDataSystemHandler(poolManager); var setupHandler = new SetupSystemHandler(poolManager); return(new SystemExecutor(poolManager, messageBroker, reactsToEntityHandler, reactsToGroupHandler, setupHandler, reactsToDataHandler)); }
public void should_execute_system_without_predicate() { var fakeEntity1 = Substitute.For <IEntity>(); var fakeEntity2 = Substitute.For <IEntity>(); var fakeEntities = new[] { fakeEntity1, fakeEntity2 }; var guid1 = Guid.NewGuid(); var guid2 = Guid.NewGuid(); fakeEntity1.Id.Returns(guid1); fakeEntity2.Id.Returns(guid2); var mockObservableGroup = Substitute.For <IObservableGroup>(); mockObservableGroup.Entities.Returns(fakeEntities); mockObservableGroup.OnEntityAdded.Returns(new Subject <IEntity>()); mockObservableGroup.OnEntityRemoved.Returns(new Subject <IEntity>()); var mockCollectionManager = Substitute.For <IEntityCollectionManager>(); var fakeGroup = new Group(); mockCollectionManager.CreateObservableGroup(Arg.Is(fakeGroup)).Returns(mockObservableGroup); var firstEntitySubject = new Subject <int>(); var secondEntitySubject = new Subject <int>(); var mockSystem = Substitute.For <IReactToDataSystem <int> >(); mockSystem.TargetGroup.Returns(fakeGroup); mockSystem.ReactToData(Arg.Is(fakeEntity1)).Returns(firstEntitySubject); mockSystem.ReactToData(Arg.Is(fakeEntity2)).Returns(secondEntitySubject); var systemHandler = new ReactToDataSystemHandler(mockCollectionManager); systemHandler.SetupSystem(mockSystem); firstEntitySubject.OnNext(1); secondEntitySubject.OnNext(2); mockSystem.Received(1).Execute(Arg.Is(fakeEntity1), Arg.Is(1)); mockSystem.Received(1).Execute(Arg.Is(fakeEntity2), Arg.Is(2)); Assert.Equal(1, systemHandler._systemSubscriptions.Count); Assert.NotNull(systemHandler._systemSubscriptions[mockSystem]); Assert.Equal(1, systemHandler._entitySubscriptions.Count); Assert.Equal(2, systemHandler._entitySubscriptions[mockSystem].Count); Assert.True(systemHandler._entitySubscriptions[mockSystem].Keys.Contains(guid1)); Assert.True(systemHandler._entitySubscriptions[mockSystem].Keys.Contains(guid2)); Assert.All(systemHandler._entitySubscriptions[mockSystem].Values, Assert.NotNull); }
public void should_correctly_handle_systems() { var mockCollectionManager = Substitute.For <IEntityCollectionManager>(); var reactToEntitySystemHandler = new ReactToDataSystemHandler(mockCollectionManager); var fakeMatchingSystem1 = Substitute.For <IReactToDataSystem <int> >(); var fakeMatchingSystem2 = Substitute.For <IReactToDataSystem <DateTime> >(); var fakeNonMatchingSystem1 = Substitute.For <IReactToEntitySystem>(); var fakeNonMatchingSystem2 = Substitute.For <ISystem>(); Assert.True(reactToEntitySystemHandler.CanHandleSystem(fakeMatchingSystem1)); Assert.True(reactToEntitySystemHandler.CanHandleSystem(fakeMatchingSystem2)); Assert.False(reactToEntitySystemHandler.CanHandleSystem(fakeNonMatchingSystem1)); Assert.False(reactToEntitySystemHandler.CanHandleSystem(fakeNonMatchingSystem2)); }
private SystemExecutor CreateExecutor() { var messageBroker = new EventSystem(new MessageBroker()); var entityFactory = new DefaultEntityFactory(messageBroker); var poolFactory = new DefaultPoolFactory(entityFactory, messageBroker); var groupAccessorFactory = new DefaultGroupAccessorFactory(messageBroker); var poolManager = new PoolManager(messageBroker, poolFactory, groupAccessorFactory); var reactsToEntityHandler = new ReactToEntitySystemHandler(poolManager); var reactsToGroupHandler = new ReactToGroupSystemHandler(poolManager); var reactsToDataHandler = new ReactToDataSystemHandler(poolManager); var manualSystemHandler = new ManualSystemHandler(poolManager); var setupHandler = new SetupSystemHandler(poolManager); return(new SystemExecutor(poolManager, messageBroker, reactsToEntityHandler, reactsToGroupHandler, setupHandler, reactsToDataHandler, manualSystemHandler)); }
private SystemExecutor CreateExecutor(IEntityCollectionManager entityCollectionManager) { 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 conventionalSystems = new List <IConventionalSystemHandler> { setupHandler, reactsToEntityHandler, reactsToGroupHandler, reactsToDataHandler, manualSystemHandler }; return(new SystemExecutor(conventionalSystems)); }
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); }
private SystemExecutor CreateExecutor(IObservableGroupManager observableGroupManager) { var threadHandler = new DefaultThreadHandler(); var reactsToEntityHandler = new ReactToEntitySystemHandler(observableGroupManager); var reactsToGroupHandler = new ReactToGroupSystemHandler(observableGroupManager, threadHandler); var reactsToDataHandler = new ReactToDataSystemHandler(observableGroupManager); var manualSystemHandler = new ManualSystemHandler(observableGroupManager); var setupHandler = new SetupSystemHandler(observableGroupManager); var teardownHandler = new TeardownSystemHandler(observableGroupManager); var conventionalSystems = new List <IConventionalSystemHandler> { setupHandler, reactsToEntityHandler, reactsToGroupHandler, reactsToDataHandler, manualSystemHandler, teardownHandler }; return(new SystemExecutor(conventionalSystems)); }
public void AddSystem(ISystem system) { _systems.Add(system); var subscriptionList = new List <SubscriptionToken>(); if (system is ISetupSystem) { var subscriptions = SetupSystemHandler.Setup(system as ISetupSystem); subscriptionList.AddRange(subscriptions); } if (system is IReactToGroupSystem) { var subscription = ReactToGroupSystemHandler.Setup(system as IReactToGroupSystem); subscriptionList.Add(subscription); } if (system is IReactToEntitySystem) { var subscriptions = ReactToEntitySystemHandler.Setup(system as IReactToEntitySystem); subscriptionList.AddRange(subscriptions); } if (system.IsReactiveDataSystem()) { var subscriptions = ReactToDataSystemHandler.SetupWithoutType(system); subscriptionList.AddRange(subscriptions); } if (system is IManualSystem) { ManualSystemHandler.Start(system as IManualSystem); } _systemSubscriptions.Add(system, subscriptionList); }
public void should_execute_system_when_entity_added_to_group() { var fakeEntity1 = Substitute.For <IEntity>(); var fakeEntity2 = Substitute.For <IEntity>(); var id1 = 1; var id2 = 2; fakeEntity1.Id.Returns(id1); fakeEntity2.Id.Returns(id2); var mockObservableGroup = Substitute.For <IObservableGroup>(); mockObservableGroup.GetEnumerator().Returns(new List <IEntity>().GetEnumerator()); mockObservableGroup.OnEntityRemoved.Returns(new Subject <IEntity>()); var addedSubject = new Subject <IEntity>(); mockObservableGroup.OnEntityAdded.Returns(addedSubject); var observableGroupManager = Substitute.For <IObservableGroupManager>(); var fakeGroup = new Group(); observableGroupManager.GetObservableGroup(Arg.Is(fakeGroup), Arg.Any <int[]>()).Returns(mockObservableGroup); var firstEntitySubject = new Subject <int>(); var secondEntitySubject = new Subject <int>(); var mockSystem = Substitute.For <IReactToDataSystem <int> >(); mockSystem.Group.Returns(fakeGroup); mockSystem.ReactToData(Arg.Is(fakeEntity1)).Returns(firstEntitySubject); mockSystem.ReactToData(Arg.Is(fakeEntity2)).Returns(secondEntitySubject); var systemHandler = new ReactToDataSystemHandler(observableGroupManager); systemHandler.SetupSystem(mockSystem); Assert.Equal(1, systemHandler.EntitySubscriptions.Count); Assert.Equal(0, systemHandler.EntitySubscriptions[mockSystem].Count); mockSystem.Received(0).ReactToData(Arg.Any <IEntity>()); addedSubject.OnNext(fakeEntity1); addedSubject.OnNext(fakeEntity2); mockSystem.Received(1).ReactToData(Arg.Is(fakeEntity1)); mockSystem.Received(1).ReactToData(Arg.Is(fakeEntity2)); firstEntitySubject.OnNext(1); secondEntitySubject.OnNext(2); mockSystem.Received(1).Process(Arg.Is(fakeEntity1), Arg.Is(1)); mockSystem.Received(1).Process(Arg.Is(fakeEntity2), Arg.Is(2)); Assert.Equal(1, systemHandler.SystemSubscriptions.Count); Assert.NotNull(systemHandler.SystemSubscriptions[mockSystem]); Assert.Equal(1, systemHandler.EntitySubscriptions.Count); Assert.Equal(2, systemHandler.EntitySubscriptions[mockSystem].Count); Assert.True(systemHandler.EntitySubscriptions[mockSystem].Keys.Contains(id1)); Assert.True(systemHandler.EntitySubscriptions[mockSystem].Keys.Contains(id2)); Assert.All(systemHandler.EntitySubscriptions[mockSystem].Values, Assert.NotNull); }