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 AddSystem(ISystem system)
{
_systems.Add(system);
if (system is ISetupSystem)
{
SetupSystemHandler.Setup(system as ISetupSystem);
}
if (system is IReactToGroupSystem)
{
var subscription = ReactToGroupSystemHandler.Setup(system as IReactToGroupSystem);
_systemSubscriptions.Add(system, new List <SubscriptionToken> {
subscription
});
}
if (system is IReactToEntitySystem)
{
var subscriptions = ReactToEntitySystemHandler.Setup(system as IReactToEntitySystem);
_systemSubscriptions.Add(system, new List <SubscriptionToken>(subscriptions));
}
if (system.IsReactiveDataSystem())
{
var subscriptions = ReactToDataSystemHandler.SetupWithoutType(system);
_systemSubscriptions.Add(system, new List <SubscriptionToken>(subscriptions));
}
}
public void AddSystemsToEntity(IEntity entity, ISystemContainer container)
{
for (int i = 0; i < container.SetupSystems.Length; i++)
{
var system = container.SetupSystems[i];
var subscription = SetupSystemHandler.ProcessEntity(system, entity);
if (subscription != null)
{
_entitySubscribtionsOnSystems[system].Add(entity, subscription);
}
}
for (int i = 0; i < container.EntityReactionSystems.Length; i++)
{
var system = container.EntityReactionSystems[i];
var subscription = EntityReactionSystemHandler.ProcessEntity(system, entity);
if (subscription != null)
{
_entitySubscribtionsOnSystems[system].Add(entity, subscription);
}
}
for (int i = 0; i < container.InteractReactionSystems.Length; i++)
{
var system = container.InteractReactionSystems[i];
var subscription = InteractReactionSystemHandler.ProcessEntity(system, entity);
if (subscription != null)
{
_entitySubscribtionsOnSystems[system].Add(entity, subscription);
}
}
}
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 is IManualSystem)
{
ManualSystemHandler.Start(system as IManualSystem);
}
_systemSubscriptions.Add(system, subscriptionList);
}
public void AddSystem(ISystem system)
{
_systems.Add(system);
if (system is ISetupSystem)
{
_entitySubscribtionsOnSystems.Add(system, SetupSystemHandler.Setup((ISetupSystem)system)
.ToDictionary(x => x.AssociatedObject as IEntity));
}
else if (system is IGroupReactionSystem)
{
_nonEntitySubscriptions.Add(system, GroupReactionSystemHandler.Setup((IGroupReactionSystem)system));
}
else if (system is IEntityReactionSystem)
{
_entitySubscribtionsOnSystems.Add(system, EntityReactionSystemHandler.Setup((IEntityReactionSystem)system)
.ToDictionary(x => x.AssociatedObject as IEntity));
}
else if (system is IInteractReactionSystem)
{
_entitySubscribtionsOnSystems.Add(system, InteractReactionSystemHandler.Setup((IInteractReactionSystem)system)
.ToDictionary(x => x.AssociatedObject as IEntity));
}
else if (system is IManualSystem)
{
ManualSystemHandler.Start((IManualSystem)system);
}
}
public void should_treat_view_handler_as_setup_system_and_teardown_system()
{
var observableGroupManager = Substitute.For <IObservableGroupManager>();
var setupSystemHandler = new SetupSystemHandler(observableGroupManager);
var teardownSystemHandler = new TeardownSystemHandler(observableGroupManager);
var viewSystem = Substitute.For <IViewResolverSystem>();
Assert.True(setupSystemHandler.CanHandleSystem(viewSystem));
Assert.True(teardownSystemHandler.CanHandleSystem(viewSystem));
}
public void should_treat_view_handler_as_setup_system_and_teardown_system()
{
var mockEntityCollectionManager = Substitute.For <IEntityCollectionManager>();
var setupSystemHandler = new SetupSystemHandler(mockEntityCollectionManager);
var teardownSystemHandler = new TeardownSystemHandler(mockEntityCollectionManager);
var viewSystem = Substitute.For <IViewResolverSystem>();
Assert.True(setupSystemHandler.CanHandleSystem(viewSystem));
Assert.True(teardownSystemHandler.CanHandleSystem(viewSystem));
}
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_systems_when_predicate_met_after_period()
{
var id1 = 1;
var id2 = 2;
var expectedDate = DateTime.Now + TimeSpan.FromMilliseconds(500);
var fakeEntity1 = Substitute.For <IEntity>();
var fakeEntity2 = Substitute.For <IEntity>();
var fakeEntities = new List <IEntity> {
fakeEntity1, fakeEntity2
};
fakeEntity1.Id.Returns(id1);
fakeEntity2.Id.Returns(id2);
var mockObservableGroup = Substitute.For <IObservableGroup>();
mockObservableGroup.OnEntityAdded.Returns(new Subject <IEntity>());
mockObservableGroup.OnEntityRemoved.Returns(new Subject <IEntity>());
mockObservableGroup.GetEnumerator().Returns(fakeEntities.GetEnumerator());
var observableGroupManager = Substitute.For <IObservableGroupManager>();
var fakeGroup = new GroupWithPredicate(x => x.Id == fakeEntity1.Id && DateTime.Now >= expectedDate);
observableGroupManager.GetObservableGroup(Arg.Is(fakeGroup), Arg.Any <int[]>()).Returns(mockObservableGroup);
var mockSystem = Substitute.For <ISetupSystem>();
mockSystem.Group.Returns(fakeGroup);
var systemHandler = new SetupSystemHandler(observableGroupManager);
systemHandler.SetupSystem(mockSystem);
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].ContainsKey(fakeEntity1.Id));
Assert.True(systemHandler._entitySubscriptions[mockSystem].ContainsKey(fakeEntity2.Id));
Thread.Sleep(2000);
mockSystem.Received(1).Setup(Arg.Is(fakeEntity1));
mockSystem.Received(0).Setup(Arg.Is(fakeEntity2));
Assert.Equal(1, systemHandler._systemSubscriptions.Count);
Assert.NotNull(systemHandler._systemSubscriptions[mockSystem]);
Assert.Equal(1, systemHandler._entitySubscriptions.Count);
Assert.Equal(1, systemHandler._entitySubscriptions[mockSystem].Count);
Assert.True(systemHandler._entitySubscriptions[mockSystem].ContainsKey(fakeEntity2.Id));
}
public void should_correctly_handle_systems()
{
var mockCollectionManager = Substitute.For <IEntityCollectionManager>();
var reactToEntitySystemHandler = new SetupSystemHandler(mockCollectionManager);
var fakeMatchingSystem = Substitute.For <ISetupSystem>();
var fakeNonMatchingSystem1 = Substitute.For <IReactToEntitySystem>();
var fakeNonMatchingSystem2 = Substitute.For <ISystem>();
Assert.True(reactToEntitySystemHandler.CanHandleSystem(fakeMatchingSystem));
Assert.False(reactToEntitySystemHandler.CanHandleSystem(fakeNonMatchingSystem1));
Assert.False(reactToEntitySystemHandler.CanHandleSystem(fakeNonMatchingSystem2));
}
public void should_return_valid_subscription_token_when_processing()
{
var mockEnity = Substitute.For <IEntity>();
var mockPoolManager = Substitute.For <IPoolManager>();
mockPoolManager.GetEntitiesFor(Arg.Any <IGroup>()).Returns(new[] { mockEnity });
var mockSystem = Substitute.For <ISetupSystem>();
var handler = new SetupSystemHandler(mockPoolManager);
handler.Setup(mockSystem);
mockSystem.Received().Setup(mockEnity);
}
public void should_execute_systems_when_predicate_met_after_period()
{
var guid1 = Guid.NewGuid();
var guid2 = Guid.NewGuid();
var expectedDate = DateTime.Now + TimeSpan.FromSeconds(1);
var fakeEntity1 = Substitute.For <IEntity>();
var fakeEntity2 = Substitute.For <IEntity>();
var fakeEntities = new[] { fakeEntity1, fakeEntity2 };
fakeEntity1.Id.Returns(guid1);
fakeEntity2.Id.Returns(guid2);
var mockObservableGroup = Substitute.For <IObservableGroup>();
mockObservableGroup.OnEntityAdded.Returns(new Subject <IEntity>());
mockObservableGroup.OnEntityRemoved.Returns(new Subject <IEntity>());
mockObservableGroup.Entities.Returns(fakeEntities);
var mockCollectionManager = Substitute.For <IEntityCollectionManager>();
var fakeGroup = new Group(x => x.Id == fakeEntity1.Id && DateTime.Now >= expectedDate);
mockCollectionManager.CreateObservableGroup(Arg.Is(fakeGroup)).Returns(mockObservableGroup);
var mockSystem = Substitute.For <ISetupSystem>();
mockSystem.TargetGroup.Returns(fakeGroup);
var systemHandler = new SetupSystemHandler(mockCollectionManager);
systemHandler.SetupSystem(mockSystem);
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].ContainsKey(fakeEntity1.Id));
Assert.True(systemHandler._entitySubscriptions[mockSystem].ContainsKey(fakeEntity2.Id));
Thread.Sleep(1100);
mockSystem.Received(1).Setup(Arg.Is(fakeEntity1));
mockSystem.Received(0).Setup(Arg.Is(fakeEntity2));
Assert.Equal(1, systemHandler._systemSubscriptions.Count);
Assert.NotNull(systemHandler._systemSubscriptions[mockSystem]);
Assert.Equal(1, systemHandler._entitySubscriptions.Count);
Assert.Equal(1, systemHandler._entitySubscriptions[mockSystem].Count);
Assert.True(systemHandler._entitySubscriptions[mockSystem].ContainsKey(fakeEntity2.Id));
}
public void should_execute_system_when_entity_added_without_predicate()
{
var fakeEntity1 = Substitute.For <IEntity>();
var fakeEntity2 = Substitute.For <IEntity>();
fakeEntity1.Id.Returns(Guid.NewGuid());
fakeEntity2.Id.Returns(Guid.NewGuid());
var fakeEntities = new IEntity[] { };
var mockObservableGroup = Substitute.For <IObservableGroup>();
var addingSubject = new Subject <IEntity>();
mockObservableGroup.OnEntityAdded.Returns(addingSubject);
mockObservableGroup.OnEntityRemoved.Returns(new Subject <IEntity>());
mockObservableGroup.Entities.Returns(fakeEntities);
var mockCollectionManager = Substitute.For <IEntityCollectionManager>();
var fakeGroup = Substitute.For <IGroup>();
fakeGroup.MatchesComponents.Returns(new Type[0]);
mockCollectionManager.CreateObservableGroup(Arg.Is(fakeGroup)).Returns(mockObservableGroup);
var mockSystem = Substitute.For <ISetupSystem>();
mockSystem.TargetGroup.Returns(fakeGroup);
var systemHandler = new SetupSystemHandler(mockCollectionManager);
systemHandler.SetupSystem(mockSystem);
mockSystem.Received(0).Setup(Arg.Is(fakeEntity1));
mockSystem.Received(0).Setup(Arg.Is(fakeEntity2));
Assert.Equal(1, systemHandler._systemSubscriptions.Count);
Assert.NotNull(systemHandler._systemSubscriptions[mockSystem]);
Assert.Equal(1, systemHandler._entitySubscriptions.Count);
Assert.Equal(0, systemHandler._entitySubscriptions[mockSystem].Count);
addingSubject.OnNext(fakeEntity1);
addingSubject.OnNext(fakeEntity2);
mockSystem.Received(1).Setup(Arg.Is(fakeEntity1));
mockSystem.Received(1).Setup(Arg.Is(fakeEntity2));
Assert.Equal(1, systemHandler._systemSubscriptions.Count);
Assert.NotNull(systemHandler._systemSubscriptions[mockSystem]);
Assert.Equal(1, systemHandler._entitySubscriptions.Count);
Assert.Equal(0, systemHandler._entitySubscriptions[mockSystem].Count);
}
public void should_execute_system_when_entity_added_without_predicate()
{
var fakeEntity1 = Substitute.For <IEntity>();
var fakeEntity2 = Substitute.For <IEntity>();
fakeEntity1.Id.Returns(1);
fakeEntity2.Id.Returns(2);
var fakeEntities = new List <IEntity>();
var mockObservableGroup = Substitute.For <IObservableGroup>();
var addingSubject = new Subject <IEntity>();
mockObservableGroup.OnEntityAdded.Returns(addingSubject);
mockObservableGroup.OnEntityRemoved.Returns(new Subject <IEntity>());
mockObservableGroup.GetEnumerator().Returns(fakeEntities.GetEnumerator());
var observableGroupManager = Substitute.For <IObservableGroupManager>();
var fakeGroup = Substitute.For <IGroup>();
fakeGroup.RequiredComponents.Returns(new Type[0]);
observableGroupManager.GetObservableGroup(Arg.Is(fakeGroup), Arg.Any <int[]>()).Returns(mockObservableGroup);
var mockSystem = Substitute.For <ISetupSystem>();
mockSystem.Group.Returns(fakeGroup);
var systemHandler = new SetupSystemHandler(observableGroupManager);
systemHandler.SetupSystem(mockSystem);
mockSystem.Received(0).Setup(Arg.Is(fakeEntity1));
mockSystem.Received(0).Setup(Arg.Is(fakeEntity2));
Assert.Equal(1, systemHandler._systemSubscriptions.Count);
Assert.NotNull(systemHandler._systemSubscriptions[mockSystem]);
Assert.Equal(1, systemHandler._entitySubscriptions.Count);
Assert.Equal(0, systemHandler._entitySubscriptions[mockSystem].Count);
addingSubject.OnNext(fakeEntity1);
addingSubject.OnNext(fakeEntity2);
mockSystem.Received(1).Setup(Arg.Is(fakeEntity1));
mockSystem.Received(1).Setup(Arg.Is(fakeEntity2));
Assert.Equal(1, systemHandler._systemSubscriptions.Count);
Assert.NotNull(systemHandler._systemSubscriptions[mockSystem]);
Assert.Equal(1, systemHandler._entitySubscriptions.Count);
Assert.Equal(0, systemHandler._entitySubscriptions[mockSystem].Count);
}
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));
}
public void should_return_valid_subscription_token_when_processing()
{
var mockEnity = Substitute.For <IEntity>();
var mockPoolManager = Substitute.For <IPoolManager>();
var fakeGroupAccessor = new GroupAccessor(null, new [] { mockEnity });
mockPoolManager.CreateGroupAccessor(Arg.Any <IGroup>()).Returns(fakeGroupAccessor);
var mockSystem = Substitute.For <ISetupSystem>();
mockSystem.TargetGroup.TargettedEntities.Returns(x => null);
var handler = new SetupSystemHandler(mockPoolManager);
handler.Setup(mockSystem);
mockSystem.Received().Setup(mockEnity);
}
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));
}
public void should_execute_systems_when_predicate_met()
{
var id1 = 1;
var id2 = 2;
var fakeEntity1 = Substitute.For <IEntity>();
var fakeEntity2 = Substitute.For <IEntity>();
var fakeEntities = new List <IEntity> {
fakeEntity1, fakeEntity2
};
fakeEntity1.Id.Returns(id1);
fakeEntity2.Id.Returns(id2);
var mockObservableGroup = Substitute.For <IObservableGroup>();
mockObservableGroup.OnEntityAdded.Returns(new Subject <IEntity>());
mockObservableGroup.OnEntityRemoved.Returns(new Subject <IEntity>());
mockObservableGroup.GetEnumerator().Returns(fakeEntities.GetEnumerator());
var mockCollectionManager = Substitute.For <IEntityCollectionManager>();
var fakeGroup = new Group(x => x.Id == fakeEntity1.Id);
mockCollectionManager.GetObservableGroup(Arg.Is(fakeGroup)).Returns(mockObservableGroup);
var mockSystem = Substitute.For <ISetupSystem>();
mockSystem.Group.Returns(fakeGroup);
var systemHandler = new SetupSystemHandler(mockCollectionManager);
systemHandler.SetupSystem(mockSystem);
mockSystem.Received(1).Setup(Arg.Is(fakeEntity1));
mockSystem.Received(0).Setup(Arg.Is(fakeEntity2));
Assert.Equal(1, systemHandler._systemSubscriptions.Count);
Assert.NotNull(systemHandler._systemSubscriptions[mockSystem]);
Assert.Equal(1, systemHandler._entitySubscriptions.Count);
Assert.Equal(1, systemHandler._entitySubscriptions[mockSystem].Count);
Assert.True(systemHandler._entitySubscriptions[mockSystem].ContainsKey(fakeEntity2.Id));
}
public void should_dispose_observables_when_entity_removed()
{
var fakeEntity1 = Substitute.For <IEntity>();
fakeEntity1.Id.Returns(Guid.NewGuid());
var fakeEntities = new IEntity[] { };
var mockObservableGroup = Substitute.For <IObservableGroup>();
var removingSubject = new Subject <IEntity>();
mockObservableGroup.OnEntityAdded.Returns(new Subject <IEntity>());
mockObservableGroup.OnEntityRemoved.Returns(removingSubject);
mockObservableGroup.Entities.Returns(fakeEntities);
var mockCollectionManager = Substitute.For <IEntityCollectionManager>();
var fakeGroup = Substitute.For <IGroup>();
fakeGroup.MatchesComponents.Returns(new Type[0]);
mockCollectionManager.CreateObservableGroup(Arg.Is(fakeGroup)).Returns(mockObservableGroup);
var mockSystem = Substitute.For <ISetupSystem>();
mockSystem.TargetGroup.Returns(fakeGroup);
var systemHandler = new SetupSystemHandler(mockCollectionManager);
systemHandler.SetupSystem(mockSystem);
var mockDisposable = Substitute.For <IDisposable>();
systemHandler._entitySubscriptions[mockSystem].Add(fakeEntity1.Id, mockDisposable);
removingSubject.OnNext(fakeEntity1);
mockDisposable.Received(1).Dispose();
Assert.Equal(1, systemHandler._systemSubscriptions.Count);
Assert.NotNull(systemHandler._systemSubscriptions[mockSystem]);
Assert.Equal(1, systemHandler._entitySubscriptions.Count);
Assert.Equal(0, systemHandler._entitySubscriptions[mockSystem].Count);
}
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_dispose_observables_when_entity_removed()
{
var fakeEntity1 = Substitute.For <IEntity>();
fakeEntity1.Id.Returns(1);
var fakeEntities = new List <IEntity>();
var mockObservableGroup = Substitute.For <IObservableGroup>();
var removingSubject = new Subject <IEntity>();
mockObservableGroup.OnEntityAdded.Returns(new Subject <IEntity>());
mockObservableGroup.OnEntityRemoved.Returns(removingSubject);
mockObservableGroup.GetEnumerator().Returns(fakeEntities.GetEnumerator());
var observableGroupManager = Substitute.For <IObservableGroupManager>();
var fakeGroup = Substitute.For <IGroup>();
fakeGroup.RequiredComponents.Returns(new Type[0]);
observableGroupManager.GetObservableGroup(Arg.Is(fakeGroup), Arg.Any <int[]>()).Returns(mockObservableGroup);
var mockSystem = Substitute.For <ISetupSystem>();
mockSystem.Group.Returns(fakeGroup);
var systemHandler = new SetupSystemHandler(observableGroupManager);
systemHandler.SetupSystem(mockSystem);
var mockDisposable = Substitute.For <IDisposable>();
systemHandler._entitySubscriptions[mockSystem].Add(fakeEntity1.Id, mockDisposable);
removingSubject.OnNext(fakeEntity1);
mockDisposable.Received(1).Dispose();
Assert.Equal(1, systemHandler._systemSubscriptions.Count);
Assert.NotNull(systemHandler._systemSubscriptions[mockSystem]);
Assert.Equal(1, systemHandler._entitySubscriptions.Count);
Assert.Equal(0, systemHandler._entitySubscriptions[mockSystem].Count);
}
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));
}
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);
}
