public void should_correctly_add_component()
{
var expectedSize = 10;
var fakeEntityId = 1;
var fakeComponent = new TestComponentOne();
var fakeComponentTypes = new Dictionary <Type, int>
{
{ typeof(TestComponentOne), 0 },
{ typeof(TestComponentTwo), 1 },
{ typeof(TestComponentThree), 2 }
};
var mockComponentLookup = Substitute.For <IComponentTypeLookup>();
mockComponentLookup.GetAllComponentTypes().Returns(fakeComponentTypes);
var database = new ComponentDatabase(mockComponentLookup, expectedSize);
database.Add(0, fakeEntityId, fakeComponent);
Assert.Equal(database.EntityComponents[0][1], fakeComponent);
var nullCount = database.EntityComponents.Sum(x => x.Count(y => y == null));
Assert.Equal(29, nullCount);
}
public void should_only_add_entity_when_components_match_group()
{
var mockEventSystem = Substitute.For <IEventSystem>();
var accessorToken = new GroupAccessorToken(new[] { typeof(TestComponentOne), typeof(TestComponentTwo) }, "default");
var existingEntityOne = new Entity(Guid.NewGuid(), mockEventSystem);
var componentToAdd = new TestComponentOne();
existingEntityOne.AddComponent <TestComponentTwo>();
var existingEntityTwo = new Entity(Guid.NewGuid(), mockEventSystem);
var unapplicableComponent = new TestComponentThree();
existingEntityTwo.AddComponent <TestComponentOne>();
var dummyEventToSeedMock = new ComponentAddedEvent(new Entity(Guid.NewGuid(), mockEventSystem), new TestComponentOne());
var underlyingEvent = new ReactiveProperty <ComponentAddedEvent>(dummyEventToSeedMock);
mockEventSystem.Receive <ComponentAddedEvent>().Returns(underlyingEvent);
var cacheableGroupAccessor = new CacheableGroupAccessor(accessorToken, new IEntity[] {}, mockEventSystem);
cacheableGroupAccessor.MonitorEntityChanges();
existingEntityOne.AddComponent(componentToAdd);
underlyingEvent.SetValueAndForceNotify(new ComponentAddedEvent(existingEntityOne, componentToAdd));
existingEntityTwo.AddComponent(unapplicableComponent);
underlyingEvent.SetValueAndForceNotify(new ComponentAddedEvent(existingEntityTwo, unapplicableComponent));
Assert.That(cacheableGroupAccessor.CachedEntities, Has.Count.EqualTo(1));
Assert.That(cacheableGroupAccessor.CachedEntities[existingEntityOne.Id], Is.EqualTo(existingEntityOne));
}
public void should_get_all_components_for_entity()
{
var expectedSize = 10;
var fakeEntityId = 1;
var otherEntityId = 2;
var fakeComponent1 = new TestComponentOne();
var fakeComponent2 = new TestComponentThree();
var fakeComponentTypes = new Dictionary <Type, int>
{
{ typeof(TestComponentOne), 0 },
{ typeof(TestComponentTwo), 1 },
{ typeof(TestComponentThree), 2 }
};
var mockComponentLookup = Substitute.For <IComponentTypeLookup>();
mockComponentLookup.GetAllComponentTypes().Returns(fakeComponentTypes);
var database = new ComponentDatabase(mockComponentLookup, expectedSize);
database.Add(0, fakeEntityId, fakeComponent1);
database.Add(2, fakeEntityId, fakeComponent2);
database.Add(0, otherEntityId, new TestComponentOne());
database.Add(1, otherEntityId, new TestComponentTwo());
database.Add(2, otherEntityId, new TestComponentThree());
var allComponents = database.GetAll(fakeEntityId).ToArray();
Assert.True(allComponents.Contains(fakeComponent1));
Assert.True(allComponents.Contains(fakeComponent2));
Assert.Equal(allComponents.Length, 2);
}
public void should_correctly_remove_component_for_entity()
{
var expectedSize = 10;
var fakeEntityId = 1;
var otherEntityId = 2;
var fakeComponent1 = new TestComponentOne();
var fakeComponentTypes = new Dictionary <Type, int>
{
{ typeof(TestComponentOne), 0 },
{ typeof(TestComponentTwo), 1 },
{ typeof(TestComponentThree), 2 }
};
var mockComponentLookup = Substitute.For <IComponentTypeLookup>();
mockComponentLookup.GetAllComponentTypes().Returns(fakeComponentTypes);
var database = new ComponentDatabase(mockComponentLookup, expectedSize);
database.Add(0, fakeEntityId, fakeComponent1);
database.Add(0, otherEntityId, new TestComponentOne());
database.Add(1, otherEntityId, new TestComponentOne());
database.Remove(0, fakeEntityId);
Assert.False(database.Has(0, fakeEntityId));
}
public void should_get_specific_components_for_entity()
{
var expectedSize = 10;
var fakeEntityId = 1;
var otherEntityId = 2;
var fakeComponent1 = new TestComponentOne();
var fakeComponentTypes = new Dictionary <Type, int>
{
{ typeof(TestComponentOne), 0 },
{ typeof(TestComponentTwo), 1 },
{ typeof(TestComponentThree), 2 }
};
var mockComponentLookup = Substitute.For <IComponentTypeLookup>();
mockComponentLookup.GetAllComponentTypes().Returns(fakeComponentTypes);
var database = new ComponentDatabase(mockComponentLookup, expectedSize);
database.Add(0, fakeEntityId, fakeComponent1);
database.Add(0, otherEntityId, new TestComponentOne());
var component = database.Get(0, fakeEntityId);
Assert.Equal(fakeComponent1, component);
}
public void should_only_add_entity_when_components_match_group()
{
var mockEventSystem = Substitute.For <IEventSystem>();
var accessorToken = new ObservableGroupToken(new[] { typeof(TestComponentOne), typeof(TestComponentTwo) }, "default");
var existingEntityOne = new Entity(Guid.NewGuid(), mockEventSystem);
var componentToAdd = new TestComponentOne();
existingEntityOne.AddComponent <TestComponentTwo>();
var existingEntityTwo = new Entity(Guid.NewGuid(), mockEventSystem);
var unapplicableComponent = new TestComponentThree();
existingEntityTwo.AddComponent <TestComponentOne>();
var dummyEventToSeedMock = new ComponentsAddedEvent(new Entity(Guid.NewGuid(), mockEventSystem), new[] { new TestComponentOne() });
var underlyingEvent = new ReactiveProperty <ComponentsAddedEvent>(dummyEventToSeedMock);
mockEventSystem.Receive <ComponentsAddedEvent>().Returns(underlyingEvent);
mockEventSystem.Receive <ComponentsRemovedEvent>().Returns(Observable.Empty <ComponentsRemovedEvent>());
mockEventSystem.Receive <EntityAddedEvent>().Returns(Observable.Empty <EntityAddedEvent>());
mockEventSystem.Receive <EntityRemovedEvent>().Returns(Observable.Empty <EntityRemovedEvent>());
var cacheableGroupAccessor = new ObservableGroup(mockEventSystem, accessorToken, new IEntity[] {});
existingEntityOne.AddComponent(componentToAdd);
underlyingEvent.SetValueAndForceNotify(new ComponentsAddedEvent(existingEntityOne, new[] { componentToAdd }));
existingEntityTwo.AddComponent(unapplicableComponent);
underlyingEvent.SetValueAndForceNotify(new ComponentsAddedEvent(existingEntityTwo, new[] { unapplicableComponent }));
Assert.Equal(1, cacheableGroupAccessor.CachedEntities.Count);
Assert.Equal <IEntity>(existingEntityOne, cacheableGroupAccessor.CachedEntities[existingEntityOne.Id]);
}
public void should_not_throw_error_when_removing_non_existent_component_with_instance()
{
var mockMessageBroker = Substitute.For <IMessageBroker>();
var entity = new Entity(1, mockMessageBroker);
var dummyComponent = new TestComponentOne();
entity.RemoveComponent(dummyComponent);
}
public void should_not_throw_error_when_removing_non_existent_component_with_instance()
{
var mockEventSystem = Substitute.For <IEventSystem>();
var entity = new Entity(Guid.NewGuid(), mockEventSystem);
var dummyComponent = new TestComponentOne();
entity.RemoveComponent(dummyComponent);
}
public void should_return_true_when_entity_has_component()
{
var mockMessageBroker = Substitute.For <IMessageBroker>();
var entity = new Entity(1, mockMessageBroker);
var dummyComponent = new TestComponentOne();
entity.AddComponent(dummyComponent);
Assert.That(entity.HasComponent <TestComponentOne>());
}
public void should_return_true_when_entity_has_component()
{
var mockEventSystem = Substitute.For <IEventSystem>();
var entity = new Entity(1, mockEventSystem);
var dummyComponent = new TestComponentOne();
entity.AddComponent(dummyComponent);
Assert.That(entity.HasComponent <TestComponentOne>());
}
public void should_create_batch_with_correct_values()
{
var fakeOne1 = new TestComponentOne {
Data = "hello"
};
var fakeOne2 = new TestComponentOne {
Data = "hi"
};
var fakeOnes = new[] { fakeOne1, fakeOne2 };
var fakeTwo1 = new TestComponentTwo {
Data = "goodbye"
};
var fakeTwo2 = new TestComponentTwo {
Data = "bye"
};
var fakeTwos = new[] { fakeTwo1, fakeTwo2 };
var mockComponentDatabase = Substitute.For <IComponentDatabase>();
mockComponentDatabase.GetComponents <TestComponentOne>(Arg.Any <int>()).Returns(fakeOnes);
mockComponentDatabase.GetComponents <TestComponentTwo>(Arg.Any <int>()).Returns(fakeTwos);
var mockTypeLookup = Substitute.For <IComponentTypeLookup>();
mockTypeLookup.GetComponentType(typeof(TestComponentOne)).Returns(0);
mockTypeLookup.GetComponentType(typeof(TestComponentTwo)).Returns(1);
var fakeEntity1 = Substitute.For <IEntity>();
fakeEntity1.Id.Returns(1);
fakeEntity1.ComponentAllocations.Returns(new[] { 0, 0 });
var fakeEntity2 = Substitute.For <IEntity>();
fakeEntity2.Id.Returns(2);
fakeEntity2.ComponentAllocations.Returns(new[] { 1, 1 });
var fakeEntities = new [] { fakeEntity1, fakeEntity2 };
var batchBuilder = new ReferenceBatchBuilder <TestComponentOne, TestComponentTwo>(mockComponentDatabase, mockTypeLookup);
var batches = batchBuilder.Build(fakeEntities);
Assert.Equal(fakeEntities.Length, batches.Length);
Assert.Equal(fakeEntities[0].Id, batches[0].EntityId);
Assert.Equal(fakeOne1.Data, batches[0].Component1.Data);
Assert.Equal(fakeTwo1.Data, batches[0].Component2.Data);
Assert.Equal(fakeEntities[1].Id, batches[1].EntityId);
Assert.Equal(fakeOne2.Data, batches[1].Component1.Data);
Assert.Equal(fakeTwo2.Data, batches[1].Component2.Data);
}
public void should_only_remove_entity_when_components_no_longer_match_group()
{
var mockEventSystem = Substitute.For <IEventSystem>();
var mockEntityIndexPool = Substitute.For <IEntityIndexPool>();
var mockReactor = Substitute.For <ISystemReactor>();
var accessorToken = new GroupAccessorToken(new[] { typeof(TestComponentOne), typeof(TestComponentTwo) }, "default");
var mockPool = Substitute.For <IPool>();
var componentToRemove = new TestComponentOne();
var existingEntityOne = new Entity(mockEntityIndexPool.GetId(), new List <IComponent>
{
componentToRemove,
new TestComponentTwo()
}, mockPool, mockReactor);
var unapplicableComponent = new TestComponentThree();
var existingEntityTwo = new Entity(mockEntityIndexPool.GetId(), new List <IComponent>
{
new TestComponentOne(),
new TestComponentTwo(),
unapplicableComponent
}, mockPool, mockReactor);
/*
* var dummyEventToSeedMock = new ComponentRemovedEvent(new Entity(mockEntityIndexPool.GetId(), mockPool, mockEventSystem), new TestComponentOne());
* var underlyingEvent = new ReactiveProperty<ComponentRemovedEvent>(dummyEventToSeedMock);
* mockEventSystem.Receive<ComponentRemovedEvent>().Returns(underlyingEvent);
*
* var cacheableGroupAccessor = new CacheableGroupAccessor(accessorToken, new IEntity[] { existingEntityOne, existingEntityTwo }, mockEventSystem);
* cacheableGroupAccessor.MonitorEntityChanges();
*
* existingEntityOne.RemoveComponent(componentToRemove);
* underlyingEvent.SetValueAndForceNotify(new ComponentRemovedEvent(existingEntityOne, componentToRemove));
*
* existingEntityTwo.RemoveComponent(unapplicableComponent);
* underlyingEvent.SetValueAndForceNotify(new ComponentRemovedEvent(existingEntityTwo, unapplicableComponent));
*
* Assert.That(cacheableGroupAccessor.CachedEntities, Has.Count.EqualTo(1));
* Assert.That(cacheableGroupAccessor.CachedEntities, Contains.Item(existingEntityTwo));*/
}
