580 lines
19 KiB
C#
580 lines
19 KiB
C#
using NUnit.Framework;
|
|
using FluentAssertions;
|
|
|
|
using Encompass;
|
|
using System.Collections.Generic;
|
|
using System;
|
|
using System.Linq;
|
|
|
|
namespace Tests
|
|
{
|
|
public class ComponentTests
|
|
{
|
|
struct MockComponent : IComponent
|
|
{
|
|
public string myString;
|
|
public int myInt;
|
|
}
|
|
|
|
struct EntityMessage : IMessage
|
|
{
|
|
public Entity entity;
|
|
}
|
|
|
|
static IEnumerable<(Guid, MockComponent)> gottenMockComponentIDPairs = Enumerable.Empty<(Guid, MockComponent)>();
|
|
static (Guid, MockComponent) gottenMockComponentIDPair;
|
|
|
|
[Reads(typeof(EntityMessage), typeof(MockComponent))]
|
|
class GetMockComponentEngine : Engine
|
|
{
|
|
public override void Update(double dt)
|
|
{
|
|
foreach (var entityMessage in ReadMessages<EntityMessage>())
|
|
{
|
|
gottenMockComponentIDPair = GetComponent<MockComponent>(entityMessage.entity);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct AddComponentTestMessage : IMessage
|
|
{
|
|
public Entity entity;
|
|
public MockComponent mockComponent;
|
|
}
|
|
|
|
[Reads(typeof(AddComponentTestMessage), typeof(MockComponent))]
|
|
class AddComponentTestEngine : Engine
|
|
{
|
|
public override void Update(double dt)
|
|
{
|
|
foreach (var addComponentTestMessage in ReadMessages<AddComponentTestMessage>())
|
|
{
|
|
Assert.IsTrue(HasComponent<MockComponent>(addComponentTestMessage.entity));
|
|
Assert.That(GetComponent<MockComponent>(addComponentTestMessage.entity).Item2, Is.EqualTo(addComponentTestMessage.mockComponent));
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void AddComponent()
|
|
{
|
|
var worldBuilder = new WorldBuilder();
|
|
worldBuilder.AddEngine(new AddComponentTestEngine());
|
|
|
|
var entity = worldBuilder.CreateEntity();
|
|
|
|
MockComponent mockComponent;
|
|
mockComponent.myInt = 3;
|
|
mockComponent.myString = "hello";
|
|
|
|
worldBuilder.AddComponent(entity, mockComponent);
|
|
|
|
AddComponentTestMessage addComponentTestMessage;
|
|
addComponentTestMessage.entity = entity;
|
|
addComponentTestMessage.mockComponent = mockComponent;
|
|
worldBuilder.SendMessage(addComponentTestMessage);
|
|
|
|
var world = worldBuilder.Build();
|
|
|
|
world.Update(0.01);
|
|
}
|
|
|
|
struct AddMockComponentMessage : IMessage
|
|
{
|
|
public Entity entity;
|
|
public MockComponent mockComponent;
|
|
}
|
|
|
|
[Sends(typeof(AddMockComponentMessage))]
|
|
class EmitMockComponentMessageEngine : Engine
|
|
{
|
|
private Entity entity;
|
|
|
|
public EmitMockComponentMessageEngine(Entity entity)
|
|
{
|
|
this.entity = entity;
|
|
}
|
|
|
|
public override void Update(double dt)
|
|
{
|
|
MockComponent mockComponent;
|
|
mockComponent.myInt = 10;
|
|
mockComponent.myString = "four";
|
|
|
|
AddMockComponentMessage addMockComponentMessage;
|
|
addMockComponentMessage.entity = entity;
|
|
addMockComponentMessage.mockComponent = mockComponent;
|
|
SendMessage(addMockComponentMessage);
|
|
}
|
|
}
|
|
|
|
[Activates(typeof(MockComponent))]
|
|
[Reads(typeof(AddMockComponentMessage))]
|
|
class AddMockComponentEngine : Engine
|
|
{
|
|
public override void Update(double dt)
|
|
{
|
|
foreach (var message in ReadMessages<AddMockComponentMessage>())
|
|
{
|
|
AddComponent(message.entity, message.mockComponent);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Reads(typeof(MockComponent))]
|
|
class HasMockComponentEngine : Engine
|
|
{
|
|
private Entity entity;
|
|
|
|
public HasMockComponentEngine(Entity entity)
|
|
{
|
|
this.entity = entity;
|
|
}
|
|
|
|
public override void Update(double dt)
|
|
{
|
|
Assert.IsTrue(HasComponent<MockComponent>(entity));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void AddComponentAndReadSameFrame()
|
|
{
|
|
var worldBuilder = new WorldBuilder();
|
|
var entity = worldBuilder.CreateEntity();
|
|
|
|
worldBuilder.AddEngine(new EmitMockComponentMessageEngine(entity));
|
|
worldBuilder.AddEngine(new AddMockComponentEngine());
|
|
worldBuilder.AddEngine(new HasMockComponentEngine(entity));
|
|
|
|
var world = worldBuilder.Build();
|
|
|
|
world.Update(0.01);
|
|
}
|
|
|
|
[Reads(typeof(EntityMessage), typeof(MockComponent))]
|
|
class GetMockComponentsEngine : Engine
|
|
{
|
|
private Entity entity;
|
|
private Guid componentAID;
|
|
private Guid componentBID;
|
|
private Guid componentCID;
|
|
private MockComponent componentA;
|
|
private MockComponent componentB;
|
|
private MockComponent componentC;
|
|
|
|
public GetMockComponentsEngine(
|
|
Entity entity,
|
|
Guid componentAID,
|
|
MockComponent componentA,
|
|
Guid componentBID,
|
|
MockComponent componentB,
|
|
Guid componentCID,
|
|
MockComponent componentC
|
|
) {
|
|
this.entity = entity;
|
|
this.componentAID = componentAID;
|
|
this.componentA = componentA;
|
|
this.componentBID = componentBID;
|
|
this.componentB = componentB;
|
|
this.componentCID = componentCID;
|
|
this.componentC = componentC;
|
|
}
|
|
|
|
public override void Update(double dt)
|
|
{
|
|
foreach (var entityMessage in ReadMessages<EntityMessage>())
|
|
{
|
|
var results = GetComponents<MockComponent>(entityMessage.entity);
|
|
results.Should().Contain((componentAID, componentA));
|
|
results.Should().Contain((componentBID, componentB));
|
|
results.Should().Contain((componentCID, componentC));
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void GetComponents()
|
|
{
|
|
var worldBuilder = new WorldBuilder();
|
|
var entity = worldBuilder.CreateEntity();
|
|
|
|
MockComponent mockComponentA;
|
|
mockComponentA.myInt = 3;
|
|
mockComponentA.myString = "hello";
|
|
|
|
MockComponent mockComponentB;
|
|
mockComponentB.myInt = 5;
|
|
mockComponentB.myString = "wassup";
|
|
|
|
MockComponent mockComponentC;
|
|
mockComponentC.myInt = 1;
|
|
mockComponentC.myString = "howdy";
|
|
|
|
var componentAID = worldBuilder.AddComponent(entity, mockComponentA);
|
|
var componentBID = worldBuilder.AddComponent(entity, mockComponentB);
|
|
var componentCID = worldBuilder.AddComponent(entity, mockComponentC);
|
|
|
|
worldBuilder.AddEngine(new GetMockComponentsEngine(
|
|
entity,
|
|
componentAID,
|
|
mockComponentA,
|
|
componentBID,
|
|
mockComponentB,
|
|
componentCID,
|
|
mockComponentC
|
|
));
|
|
|
|
EntityMessage entityMessage;
|
|
entityMessage.entity = entity;
|
|
worldBuilder.SendMessage(entityMessage);
|
|
|
|
var world = worldBuilder.Build();
|
|
|
|
world.Update(0.01);
|
|
}
|
|
|
|
[Test]
|
|
public void GetComponent()
|
|
{
|
|
var worldBuilder = new WorldBuilder();
|
|
worldBuilder.AddEngine(new GetMockComponentEngine());
|
|
|
|
var entity = worldBuilder.CreateEntity();
|
|
|
|
MockComponent mockComponent;
|
|
mockComponent.myInt = 3;
|
|
mockComponent.myString = "hello";
|
|
|
|
var componentID = worldBuilder.AddComponent<MockComponent>(entity, mockComponent);
|
|
|
|
EntityMessage entityMessage;
|
|
entityMessage.entity = entity;
|
|
worldBuilder.SendMessage(entityMessage);
|
|
|
|
var world = worldBuilder.Build();
|
|
|
|
world.Update(0.01);
|
|
|
|
Assert.AreEqual((componentID, mockComponent), gottenMockComponentIDPair);
|
|
}
|
|
|
|
struct HasComponentTestMessage : IMessage
|
|
{
|
|
public Entity entity;
|
|
}
|
|
|
|
[Reads(typeof(HasComponentTestMessage), typeof(MockComponent))]
|
|
class HasComponentTestEngine : Engine
|
|
{
|
|
public override void Update(double dt)
|
|
{
|
|
foreach (var hasComponentTestEngine in ReadMessages<HasComponentTestMessage>())
|
|
{
|
|
Assert.IsTrue(HasComponent<MockComponent>(hasComponentTestEngine.entity));
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void HasComponent()
|
|
{
|
|
var worldBuilder = new WorldBuilder();
|
|
worldBuilder.AddEngine(new HasComponentTestEngine());
|
|
|
|
var entity = worldBuilder.CreateEntity();
|
|
|
|
MockComponent mockComponent;
|
|
mockComponent.myInt = 3;
|
|
mockComponent.myString = "hello";
|
|
|
|
worldBuilder.AddComponent(entity, mockComponent);
|
|
|
|
HasComponentTestMessage hasComponentTestMessage;
|
|
hasComponentTestMessage.entity = entity;
|
|
worldBuilder.SendMessage(hasComponentTestMessage);
|
|
|
|
var world = worldBuilder.Build();
|
|
|
|
world.Update(0.01);
|
|
}
|
|
|
|
struct HasComponentWhenInactiveTestMessage : IMessage
|
|
{
|
|
public Entity entity;
|
|
}
|
|
|
|
[Reads(typeof(HasComponentWhenInactiveTestMessage), typeof(MockComponent))]
|
|
class HasComponentWhenInactiveTestEngine : Engine
|
|
{
|
|
public override void Update(double dt)
|
|
{
|
|
foreach (var hasComponentTestEngine in ReadMessages<HasComponentWhenInactiveTestMessage>())
|
|
{
|
|
Assert.IsFalse(HasComponent<MockComponent>(hasComponentTestEngine.entity));
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void HasComponentWhenInactive()
|
|
{
|
|
var worldBuilder = new WorldBuilder();
|
|
worldBuilder.AddEngine(new HasComponentWhenInactiveTestEngine());
|
|
var entity = worldBuilder.CreateEntity();
|
|
|
|
MockComponent mockComponent;
|
|
mockComponent.myInt = 3;
|
|
mockComponent.myString = "hello";
|
|
|
|
var componentID = worldBuilder.AddComponent(entity, mockComponent);
|
|
|
|
HasComponentWhenInactiveTestMessage testMessage;
|
|
testMessage.entity = entity;
|
|
worldBuilder.SendMessage(testMessage);
|
|
|
|
worldBuilder.DeactivateComponent(componentID);
|
|
|
|
var world = worldBuilder.Build();
|
|
|
|
world.Update(0.01f);
|
|
}
|
|
|
|
struct RemoveComponentTestMessage : IMessage
|
|
{
|
|
public Entity entity;
|
|
public Guid componentID;
|
|
}
|
|
|
|
[Reads(typeof(RemoveComponentTestMessage))]
|
|
class RemoveComponentTestEngine : Engine
|
|
{
|
|
public override void Update(double dt)
|
|
{
|
|
foreach (var removeComponentMessage in ReadMessages<RemoveComponentTestMessage>())
|
|
{
|
|
RemoveComponent(removeComponentMessage.componentID);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Reads(typeof(RemoveComponentTestMessage))]
|
|
[Sends(typeof(CheckHasMockComponentMessage))]
|
|
class DoRemoveCheckEngine : Engine
|
|
{
|
|
private Entity entity;
|
|
|
|
public DoRemoveCheckEngine(Entity entity)
|
|
{
|
|
this.entity = entity;
|
|
}
|
|
|
|
public override void Update(double dt)
|
|
{
|
|
if (SomeMessage<RemoveComponentTestMessage>())
|
|
{
|
|
CheckHasMockComponentMessage checkHasMockComponentMessage;
|
|
checkHasMockComponentMessage.entity = entity;
|
|
checkHasMockComponentMessage.shouldHaveComponent = true;
|
|
SendMessage(checkHasMockComponentMessage);
|
|
}
|
|
else
|
|
{
|
|
CheckHasMockComponentMessage checkHasMockComponentMessage;
|
|
checkHasMockComponentMessage.entity = entity;
|
|
checkHasMockComponentMessage.shouldHaveComponent = false;
|
|
SendMessage(checkHasMockComponentMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void RemoveComponent()
|
|
{
|
|
var worldBuilder = new WorldBuilder();
|
|
var entity = worldBuilder.CreateEntity();
|
|
|
|
worldBuilder.AddEngine(new RemoveComponentTestEngine());
|
|
worldBuilder.AddEngine(new CheckHasMockComponentEngine());
|
|
worldBuilder.AddEngine(new DoRemoveCheckEngine(entity));
|
|
|
|
MockComponent mockComponent;
|
|
mockComponent.myInt = 3;
|
|
mockComponent.myString = "hello";
|
|
|
|
var componentID = worldBuilder.AddComponent(entity, mockComponent);
|
|
|
|
RemoveComponentTestMessage removeComponentMessage;
|
|
removeComponentMessage.entity = entity;
|
|
removeComponentMessage.componentID = componentID;
|
|
worldBuilder.SendMessage(removeComponentMessage);
|
|
|
|
var world = worldBuilder.Build();
|
|
|
|
world.Update(0.01f);
|
|
}
|
|
|
|
struct ActivateComponentMessage : IMessage
|
|
{
|
|
public Entity entity;
|
|
public Guid componentID;
|
|
}
|
|
|
|
[Activates(typeof(MockComponent))]
|
|
[Reads(typeof(ActivateComponentMessage))]
|
|
class ActivateComponentEngine : Engine
|
|
{
|
|
public override void Update(double dt)
|
|
{
|
|
foreach (var activateComponentMessage in ReadMessages<ActivateComponentMessage>())
|
|
{
|
|
ActivateComponent<MockComponent>(activateComponentMessage.componentID);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct CheckHasMockComponentMessage : IMessage
|
|
{
|
|
public Entity entity;
|
|
public bool shouldHaveComponent;
|
|
}
|
|
|
|
[Reads(typeof(ActivateComponentMessage))]
|
|
[Sends(typeof(CheckHasMockComponentMessage))]
|
|
class DoActivateCheckEngine : Engine
|
|
{
|
|
private Entity entity;
|
|
|
|
public DoActivateCheckEngine(Entity entity)
|
|
{
|
|
this.entity = entity;
|
|
}
|
|
|
|
public override void Update(double dt)
|
|
{
|
|
if (SomeMessage<ActivateComponentMessage>())
|
|
{
|
|
CheckHasMockComponentMessage checkHasMockComponentMessage;
|
|
checkHasMockComponentMessage.entity = entity;
|
|
checkHasMockComponentMessage.shouldHaveComponent = true;
|
|
SendMessage(checkHasMockComponentMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Reads(typeof(CheckHasMockComponentMessage), typeof(MockComponent))]
|
|
class CheckHasMockComponentEngine : Engine
|
|
{
|
|
public override void Update(double dt)
|
|
{
|
|
foreach (var checkHasMockComponentMessage in ReadMessages<CheckHasMockComponentMessage>())
|
|
{
|
|
Assert.IsTrue(HasComponent<MockComponent>(checkHasMockComponentMessage.entity));
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ActivateComponent()
|
|
{
|
|
var worldBuilder = new WorldBuilder();
|
|
var entity = worldBuilder.CreateEntity();
|
|
|
|
worldBuilder.AddEngine(new ActivateComponentEngine());
|
|
worldBuilder.AddEngine(new CheckHasMockComponentEngine());
|
|
worldBuilder.AddEngine(new DoActivateCheckEngine(entity));
|
|
|
|
MockComponent mockComponent;
|
|
mockComponent.myInt = 3;
|
|
mockComponent.myString = "hello";
|
|
|
|
var componentID = worldBuilder.AddComponent(entity, mockComponent);
|
|
|
|
worldBuilder.DeactivateComponent(componentID);
|
|
|
|
ActivateComponentMessage activateMessage;
|
|
activateMessage.entity = entity;
|
|
activateMessage.componentID = componentID;
|
|
worldBuilder.SendMessage(activateMessage);
|
|
|
|
var world = worldBuilder.Build();
|
|
|
|
world.Update(0.01);
|
|
}
|
|
|
|
struct DeactivateComponentMessage : IMessage
|
|
{
|
|
public Entity entity;
|
|
public Guid componentID;
|
|
}
|
|
|
|
[Reads(typeof(DeactivateComponentMessage))]
|
|
class DeactivateComponentEngine : Engine
|
|
{
|
|
public override void Update(double dt)
|
|
{
|
|
foreach (var deactivateComponentMessage in ReadMessages<DeactivateComponentMessage>())
|
|
{
|
|
DeactivateComponent(deactivateComponentMessage.componentID);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Reads(typeof(DeactivateComponentMessage))]
|
|
[Sends(typeof(CheckHasMockComponentMessage))]
|
|
class DoDeactivateCheckEngine : Engine
|
|
{
|
|
private Entity entity;
|
|
|
|
public DoDeactivateCheckEngine(Entity entity)
|
|
{
|
|
this.entity = entity;
|
|
}
|
|
|
|
public override void Update(double dt)
|
|
{
|
|
if (SomeMessage<DeactivateComponentMessage>())
|
|
{
|
|
CheckHasMockComponentMessage checkHasMockComponentMessage;
|
|
checkHasMockComponentMessage.entity = entity;
|
|
checkHasMockComponentMessage.shouldHaveComponent = true;
|
|
SendMessage(checkHasMockComponentMessage);
|
|
}
|
|
else
|
|
{
|
|
CheckHasMockComponentMessage checkHasMockComponentMessage;
|
|
checkHasMockComponentMessage.entity = entity;
|
|
checkHasMockComponentMessage.shouldHaveComponent = false;
|
|
SendMessage(checkHasMockComponentMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void DeactivateComponent()
|
|
{
|
|
var worldBuilder = new WorldBuilder();
|
|
var entity = worldBuilder.CreateEntity();
|
|
|
|
worldBuilder.AddEngine(new DeactivateComponentEngine());
|
|
worldBuilder.AddEngine(new CheckHasMockComponentEngine());
|
|
worldBuilder.AddEngine(new DoDeactivateCheckEngine(entity));
|
|
|
|
MockComponent mockComponent;
|
|
mockComponent.myInt = 3;
|
|
mockComponent.myString = "hello";
|
|
|
|
var componentID = worldBuilder.AddComponent(entity, mockComponent);
|
|
|
|
DeactivateComponentMessage deactivateComponentMessage;
|
|
deactivateComponentMessage.entity = entity;
|
|
deactivateComponentMessage.componentID = componentID;
|
|
worldBuilder.SendMessage(deactivateComponentMessage);
|
|
|
|
var world = worldBuilder.Build();
|
|
|
|
world.Update(0.01);
|
|
}
|
|
}
|
|
}
|