public void should_teardown_entity_when_removed()
{
var fakeEntity1 = Substitute.For <IEntity>();
fakeEntity1.Id.Returns(Guid.NewGuid());
var fakeEntities = new IEntity[] {};
var removeSubject = new Subject <IEntity>();
var mockObservableGroup = Substitute.For <IObservableGroup>();
mockObservableGroup.OnEntityAdded.Returns(new Subject <IEntity>());
mockObservableGroup.OnEntityRemoved.Returns(removeSubject);
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 <ITeardownSystem>();
mockSystem.TargetGroup.Returns(fakeGroup);
var systemHandler = new TeardownSystemHandler(mockCollectionManager);
systemHandler.SetupSystem(mockSystem);
removeSubject.OnNext(fakeEntity1);
mockSystem.Received(1).Teardown(Arg.Is(fakeEntity1));
Assert.Equal(1, systemHandler._systemSubscriptions.Count);
Assert.NotNull(systemHandler._systemSubscriptions[mockSystem]);
}
public void should_teardown_entity_when_removed()
{
var fakeEntity1 = Substitute.For <IEntity>();
fakeEntity1.Id.Returns(1);
var fakeEntities = new List <IEntity>();
var removeSubject = new Subject <IEntity>();
var mockObservableGroup = Substitute.For <IObservableGroup>();
mockObservableGroup.OnEntityAdded.Returns(new Subject <IEntity>());
mockObservableGroup.OnEntityRemoving.Returns(removeSubject);
mockObservableGroup.GetEnumerator().Returns(fakeEntities.GetEnumerator());
var mockCollectionManager = Substitute.For <IEntityCollectionManager>();
var fakeGroup = Substitute.For <IGroup>();
fakeGroup.RequiredComponents.Returns(new Type[0]);
mockCollectionManager.GetObservableGroup(Arg.Is(fakeGroup)).Returns(mockObservableGroup);
var mockSystem = Substitute.For <ITeardownSystem>();
mockSystem.Group.Returns(fakeGroup);
var systemHandler = new TeardownSystemHandler(mockCollectionManager);
systemHandler.SetupSystem(mockSystem);
removeSubject.OnNext(fakeEntity1);
mockSystem.Received(1).Teardown(Arg.Is(fakeEntity1));
Assert.Equal(1, systemHandler.SystemSubscriptions.Count);
Assert.NotNull(systemHandler.SystemSubscriptions[mockSystem]);
}
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));
}
public void should_correctly_handle_systems()
{
var mockCollectionManager = Substitute.For <IEntityCollectionManager>();
var teardownSystemHandler = new TeardownSystemHandler(mockCollectionManager);
var fakeMatchingSystem = Substitute.For <ITeardownSystem>();
var fakeNonMatchingSystem1 = Substitute.For <IReactToEntitySystem>();
var fakeNonMatchingSystem2 = Substitute.For <ISystem>();
Assert.True(teardownSystemHandler.CanHandleSystem(fakeMatchingSystem));
Assert.False(teardownSystemHandler.CanHandleSystem(fakeNonMatchingSystem1));
Assert.False(teardownSystemHandler.CanHandleSystem(fakeNonMatchingSystem2));
}
public void should_correctly_handle_systems()
{
var observableGroupManager = Substitute.For <IObservableGroupManager>();
var teardownSystemHandler = new TeardownSystemHandler(observableGroupManager);
var fakeMatchingSystem = Substitute.For <ITeardownSystem>();
var fakeNonMatchingSystem1 = Substitute.For <IReactToEntitySystem>();
var fakeNonMatchingSystem2 = Substitute.For <IGroupSystem>();
Assert.True(teardownSystemHandler.CanHandleSystem(fakeMatchingSystem));
Assert.False(teardownSystemHandler.CanHandleSystem(fakeNonMatchingSystem1));
Assert.False(teardownSystemHandler.CanHandleSystem(fakeNonMatchingSystem2));
}
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(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 teardownHandler = new TeardownSystemHandler(entityCollectionManager);
var conventionalSystems = new List <IConventionalSystemHandler>
{
setupHandler,
reactsToEntityHandler,
reactsToGroupHandler,
reactsToDataHandler,
manualSystemHandler,
teardownHandler
};
return(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));
}
