public void ensures_same_deterministic_order_when_getting_entities_after_DestroyAllEntities()
{
var context = new Context(1);
const int numEntities = 10;
for (int i = 0; i < numEntities; i++) {
context.CreateEntity();
}
var order1 = new int[numEntities];
var entities1 = context.GetEntities();
for (int i = 0; i < numEntities; i++) {
order1[i] = entities1[i].creationIndex;
}
context.DestroyAllEntities();
context.ResetCreationIndex();
for (int i = 0; i < numEntities; i++) {
context.CreateEntity();
}
var order2 = new int[numEntities];
var entities2 = context.GetEntities();
for (int i = 0; i < numEntities; i++) {
order2[i] = entities2[i].creationIndex;
}
for (int i = 0; i < numEntities; i++) {
var index1 = order1[i];
var index2 = order2[i];
Assert.AreEqual(index1, index2);
}
}
public void Before()
{
_context = Helper.CreateContext();
for (int i = 0; i < n; i++) {
_context.CreateEntity();
}
_e = _context.CreateEntity();
}
public void Before()
{
_context = Helper.CreateContext();
_context.GetGroup(Matcher.AllOf(new [] { CP.ComponentA }));
_e = _context.CreateEntity();
_e.AddComponent(CP.ComponentA, new ComponentA());
}
public void Before()
{
_context = Helper.CreateContext();
_index = new PrimaryEntityIndex<string>(_context.GetGroup(Matcher.AllOf(CP.ComponentA)), (e, c) => ((NameComponent)c).name);
for (int i = 0; i < 10; i++) {
var nameComponent = new NameComponent();
nameComponent.name = i.ToString();
_context.CreateEntity().AddComponent(CP.ComponentA, nameComponent);
}
}
/// <summary>
/// Create a Scene Entity (drawn on top of game scene e.g. UI entity)
/// </summary>
/// <returns></returns>
public Entity CreateSceneEntity(string name = "", float initScale = 1.0f)
{
//
// Create the entity at Vector2(0,0), Scale 1.0f
//
Entity ent = SceneContext.CreateEntity();
ent.EntityType = 1; //scene entity type
ent.Name = name;
//
// fix the Transform
//
Transform trm = new Transform();
trm.Scale = new Vector2(initScale, initScale);
trm.Rotation = 0;
ent.Add(trm);
return(ent);
}
public void Before()
{
_context = Helper.CreateContext();
var e = _context.CreateEntity();
var component = new NameAgeComponent();
component.name = "Max";
component.age = 42;
e.AddComponent(CP.ComponentA, component);
_blueprint = new Blueprint(string.Empty, string.Empty, e);
}
void when_entity()
{
context["when adding ComponentSuffix"] = () => {
it["doesn't add component suffix to string ending with ComponentSuffix"] = () => {
const string str = "Position" + EntityExtension.COMPONENT_SUFFIX;
str.AddComponentSuffix().should_be_same(str);
};
it["add ComponentSuffix to string not ending with ComponentSuffix"] = () => {
const string str = "Position";
str.AddComponentSuffix().should_be("Position" + EntityExtension.COMPONENT_SUFFIX);
};
};
context["when removeing ComponentSuffix"] = () => {
it["doesn't change string when not ending with ComponentSuffix"] = () => {
const string str = "Position";
str.RemoveComponentSuffix().should_be_same(str);
};
it["removes ComponentSuffix when ending with ComponentSuffix"] = () => {
const string str = "Position" + EntityExtension.COMPONENT_SUFFIX;
str.RemoveComponentSuffix().should_be("Position");
};
};
context["when copying components"] = () => {
Context ctx = null;
Entity entity = null;
Entity target = null;
NameAgeComponent nameAge = null;
before = () => {
ctx = new Context(CID.TotalComponents);
entity = ctx.CreateEntity();
target = ctx.CreateEntity();
nameAge = new NameAgeComponent { name = "Max", age = 42 };
};
it["doesn't change entity if original doesn't have any components"] = () => {
entity.CopyTo(target);
entity.creationIndex.should_be(0);
target.creationIndex.should_be(1);
target.GetComponents().Length.should_be(0);
};
it["adds copies of all components to target entity"] = () => {
entity.AddComponentA();
entity.AddComponent(CID.ComponentB, nameAge);
entity.CopyTo(target);
target.GetComponents().Length.should_be(2);
target.HasComponentA().should_be_true();
target.HasComponentB().should_be_true();
target.GetComponentA().should_not_be_same(Component.A);
target.GetComponent(CID.ComponentB).should_not_be_same(nameAge);
var clonedComponent = (NameAgeComponent)target.GetComponent(CID.ComponentB);
clonedComponent.name.should_be(nameAge.name);
clonedComponent.age.should_be(nameAge.age);
};
it["throws when target already has a component at index"] = base.expect<EntityAlreadyHasComponentException>(() => {
entity.AddComponentA();
entity.AddComponent(CID.ComponentB, nameAge);
var component = new NameAgeComponent();
target.AddComponent(CID.ComponentB, component);
entity.CopyTo(target);
});
it["replaces existing components when overwrite is set"] = () => {
entity.AddComponentA();
entity.AddComponent(CID.ComponentB, nameAge);
var component = new NameAgeComponent();
target.AddComponent(CID.ComponentB, component);
entity.CopyTo(target, true);
var copy = target.GetComponent(CID.ComponentB);
copy.should_not_be_same(nameAge);
copy.should_not_be_same(component);
((NameAgeComponent)copy).name.should_be(nameAge.name);
((NameAgeComponent)copy).age.should_be(nameAge.age);
};
it["only adds copies of specified components to target entity"] = () => {
entity.AddComponentA();
entity.AddComponentB();
entity.AddComponentC();
entity.CopyTo(target, false, CID.ComponentB, CID.ComponentC);
target.GetComponents().Length.should_be(2);
target.HasComponentB().should_be_true();
target.HasComponentC().should_be_true();
};
it["uses component pool"] = () => {
entity.AddComponentA();
var component = new ComponentA();
target.GetComponentPool(CID.ComponentA).Push(component);
entity.CopyTo(target);
target.GetComponentA().should_be_same(component);
};
};
}
void when_creating()
{
Context ctx = null;
Entity entity = null;
before = () => {
ctx = new Context(CID.TotalComponents);
entity = ctx.CreateEntity();
};
context["ComponentBlueprint"] = () => {
it["creates a component blueprint from a component without members"] = () => {
var component = new ComponentA();
const int index = 42;
var componentBlueprint = new ComponentBlueprint(index, component);
componentBlueprint.index.should_be(index);
componentBlueprint.fullTypeName.should_be(component.GetType().FullName);
componentBlueprint.members.Length.should_be(0);
};
it["throws when unknown type"] = expect<ComponentBlueprintException>(() => {
var componentBlueprint = new ComponentBlueprint();
componentBlueprint.fullTypeName = "UnknownType";
componentBlueprint.CreateComponent(null);
});
it["throws when type doesn't implement IComponent"] = expect<ComponentBlueprintException>(() => {
var componentBlueprint = new ComponentBlueprint();
componentBlueprint.fullTypeName = "string";
componentBlueprint.CreateComponent(null);
});
it["creates a component blueprint from a component with members"] = () => {
var component = new NameAgeComponent();
component.name = "Max";
component.age = 42;
const int index = 24;
var componentBlueprint = new ComponentBlueprint(index, component);
componentBlueprint.index.should_be(index);
componentBlueprint.fullTypeName.should_be(component.GetType().FullName);
componentBlueprint.members.Length.should_be(2);
componentBlueprint.members[0].name.should_be("name");
componentBlueprint.members[0].value.should_be(component.name);
componentBlueprint.members[1].name.should_be("age");
componentBlueprint.members[1].value.should_be(component.age);
};
it["creates a component and sets members values"] = () => {
var componentBlueprint = new ComponentBlueprint();
componentBlueprint.fullTypeName = typeof(ComponentWithFieldsAndProperties).FullName;
componentBlueprint.index = CID.ComponentB;
componentBlueprint.members = new [] {
new SerializableMember("publicField", "publicFieldValue"),
new SerializableMember("publicProperty", "publicPropertyValue")
};
var component = (ComponentWithFieldsAndProperties)componentBlueprint.CreateComponent(entity);
component.publicField.should_be("publicFieldValue");
component.publicProperty.should_be("publicPropertyValue");
};
it["throws when invalid member name"] = expect<ComponentBlueprintException>(() => {
var componentBlueprint = new ComponentBlueprint();
componentBlueprint.index = 0;
componentBlueprint.fullTypeName = typeof(NameAgeComponent).FullName;
componentBlueprint.members = new [] {
new SerializableMember("xxx", "publicFieldValue"),
new SerializableMember("publicProperty", "publicPropertyValue")
};
componentBlueprint.CreateComponent(entity);
});
};
context["Blueprint"] = () => {
it["creates a blueprint from an entity"] = () => {
entity.AddComponentA();
var component = new NameAgeComponent();
component.name = "Max";
component.age = 42;
entity.AddComponent(CID.ComponentB, component);
var blueprint = new Blueprint("My Context", "Hero", entity);
blueprint.contextIdentifier.should_be("My Context");
blueprint.name.should_be("Hero");
blueprint.components.Length.should_be(2);
blueprint.components[0].index.should_be(CID.ComponentA);
blueprint.components[0].fullTypeName.should_be(Component.A.GetType().FullName);
blueprint.components[1].index.should_be(CID.ComponentB);
blueprint.components[1].fullTypeName.should_be(component.GetType().FullName);
};
context["when applying blueprint"] = () => {
Blueprint blueprint = null;
before = () => {
var component1 = new ComponentBlueprint();
component1.index = CID.ComponentA;
component1.fullTypeName = typeof(ComponentA).FullName;
component1.members = new SerializableMember[0];
var component2 = new ComponentBlueprint();
component2.index = CID.ComponentB;
component2.fullTypeName = typeof(NameAgeComponent).FullName;
component2.members = new [] {
new SerializableMember("name", "Max"),
new SerializableMember("age", 42)
};
blueprint = new Blueprint();
blueprint.name = "Hero";
blueprint.components = new [] { component1, component2 };
};
it["applies blueprint to entity"] = () => {
entity.ApplyBlueprint(blueprint).should_be(entity);
entity.GetComponents().Length.should_be(2);
entity.GetComponent(CID.ComponentA).GetType().should_be(typeof(ComponentA));
var nameAgeComponent = (NameAgeComponent)entity.GetComponent(CID.ComponentB);
nameAgeComponent.GetType().should_be(typeof(NameAgeComponent));
nameAgeComponent.name.should_be("Max");
nameAgeComponent.age.should_be(42);
};
it["throws when entity already has a component which should be added from blueprint"] = expect<EntityAlreadyHasComponentException>(() => {
entity.AddComponentA();
entity.ApplyBlueprint(blueprint);
});
it["can overwrite existing components"] = () => {
var nameAgeComponent = new NameAgeComponent();
nameAgeComponent.name = "Jack";
nameAgeComponent.age = 24;
entity.AddComponent(CID.ComponentB, nameAgeComponent);
entity.ApplyBlueprint(blueprint, true);
};
it["uses component from componentPool"] = () => {
var component = new ComponentBlueprint();
component.index = CID.ComponentA;
component.fullTypeName = typeof(ComponentA).FullName;
component.members = new SerializableMember[0];
blueprint = new Blueprint();
blueprint.name = "Hero";
blueprint.components = new [] { component };
var componentA = entity.CreateComponent<ComponentA>(CID.ComponentA);
entity.AddComponent(CID.ComponentA, componentA);
entity.RemoveComponentA();
entity.ApplyBlueprint(blueprint);
entity.GetComponentA().should_be_same(componentA);
};
};
};
}
void createTestEntityWithNullValues(Context context)
{
var e = context.CreateEntity();
// Unity's builtIn
AnimationCurve animationCurve = null;
e.AddAnimationCurve(animationCurve);
string myString = null;
e.AddMyString(myString);
UnityEngine.Object unityObject = null;
e.AddUnityObject(unityObject);
GameObject go = null;
e.AddGameObject(go);
Texture texture = null;
e.AddTexture(texture);
Texture2D texture2D = null;
e.AddTexture2D(texture2D);
// Custom
MonoBehaviourSubClass monoBehaviourSubClass = null;
e.AddMonoBehaviourSubClass(monoBehaviourSubClass);
CustomObject customObject = null;
e.AddCustomObject(customObject);
object systemObject = null;
e.AddSystemObject(systemObject);
string[] array = null;
e.AddAnArray(array);
string[,] array2d = null;
e.AddArray2D(array2d);
string[,,] array3d = null;
e.AddArray3D(array3d);
string[][] jaggedArray = null;
e.AddJaggedArray(jaggedArray);
List<string>[] listArray = null;
e.AddListArray(listArray);
List<string> list = null;
e.AddList(list);
Dictionary<string, string> dict = null;
e.AddDictionary(dict);
Dictionary<int, string[]> dict2 = null;
Dictionary<int, string[]>[] dictArray = null;
e.AddDictArray(dict2, dictArray);
HashSet<string> hashset = null;
e.AddHashSet(hashset);
char c = default(char);
e.AddMyChar(c);
UnsupportedObject unsupportedObject = null;
e.AddUnsupportedObject(unsupportedObject);
e.AddProperty(myString);
string personName = null;
string personGender = null;
e.AddPerson(personName, personGender);
}
void createTestEntityError(Context context)
{
context.DestroyEntity(context.CreateEntity().Retain(this));
}
void createTestEntities(Context context)
{
for (int i = 0; i < 2; i++) {
var e = context.CreateEntity();
// Unity's builtIn
e.AddBounds(new Bounds());
e.AddColor(Color.red);
e.AddAnimationCurve(AnimationCurve.EaseInOut(0f, 0f, 1f, 1f));
e.AddMyEnum(MyEnumComponent.MyEnum.Item2);
e.AddMyFlags(MyFlagsComponent.MyFlags.Item2);
e.AddMyDouble(4.2f);
e.AddMyFloat(4.2f);
e.AddMyInt(42);
e.AddRect(new Rect(1f, 2f, 3f, 4f));
e.AddMyString("Hello, world!");
e.AddVector2(new Vector2(1f, 2f));
e.AddVector3(new Vector3(1f, 2f, 3f));
e.AddVector4(new Vector4(1f, 2f, 3f, 4f));
e.AddMyBool(true);
e.AddUnityObject(new UnityEngine.Object());
e.AddGameObject(new GameObject("Player"));
e.AddTexture(new Texture());
e.AddTexture2D(new Texture2D(2, 2));
// Custom
e.AddMonoBehaviourSubClass(new GameObject().AddComponent<MonoBehaviourSubClass>());
e.AddCustomObject(new CustomObject("Custom Object"));
e.AddSystemObject(new object());
e.AddDateTime(DateTime.Now);
e.AddAnArray(new [] { "Hello", ", ", "world", "!" });
e.AddArray2D(new string[2, 3]);
e.AddArray3D(new string[2, 3, 4]);
string[][] jaggedArray = new string[2][];
jaggedArray[0] = new [] { "Entity", "Component", "System" };
jaggedArray[1] = new [] { "For", "C#" };
e.AddJaggedArray(jaggedArray);
var listArray = new List<string>[] {
new List<string> { "1", "2", "3" },
new List<string> { "One", "Two", "Three" }
};
e.AddListArray(listArray);
e.AddList(new List<string>{ "Apple", "Banana", "Peach" });
var dict = new Dictionary<string, string> {
{ "1", "One" },
{ "2", "Two" },
{ "3", "Three" },
};
e.AddDictionary(dict);
var dict2 = new Dictionary<int, string[]> {
{ 1, new [] { "One", "Two", "Three" } },
{ 2, new [] { "Four", "Five", "Six" } }
};
var dictArray = new Dictionary<int, string[]>[] {
new Dictionary<int, string[]> {
{ 1, new [] { "One", "Two", "Three" } },
{ 2, new [] { "Four", "Five", "Six" } }
}, new Dictionary<int, string[]> {
{ 3, new [] { "One", "Two", "Three" } },
{ 4, new [] { "Four", "Five", "Six" } }
}
};
e.AddDictArray(dict2, dictArray);
e.AddHashSet(new HashSet<string> { "One", "Two", "Three" });
e.AddMyChar('c');
e.AddUnsupportedObject(new UnsupportedObject("Unsupported Object"));
e.AddProperty("My Property");
e.AddPerson("Max", "Male");
}
}
void when_created()
{
Context ctx = null;
before = () => {
ctx = new Context(CID.TotalComponents);
};
it["increments creationIndex"] = () => {
ctx.CreateEntity().creationIndex.should_be(0);
ctx.CreateEntity().creationIndex.should_be(1);
};
it["starts with given creationIndex"] = () => {
new Context(CID.TotalComponents, 42, null).CreateEntity().creationIndex.should_be(42);
};
it["has no entities when no entities were created"] = () => {
ctx.GetEntities().should_be_empty();
};
it["gets total entity count"] = () => {
ctx.count.should_be(0);
};
it["creates entity"] = () => {
var e = ctx.CreateEntity();
e.should_not_be_null();
e.GetType().should_be(typeof(Entity));
};
it["has default ContextInfo"] = () => {
ctx.contextInfo.name.should_be("Unnamed Context");
ctx.contextInfo.componentNames.Length.should_be(CID.TotalComponents);
for (int i = 0; i < ctx.contextInfo.componentNames.Length; i++) {
ctx.contextInfo.componentNames[i].should_be("Index " + i);
}
};
it["creates component pools"] = () => {
ctx.componentPools.should_not_be_null();
ctx.componentPools.Length.should_be(CID.TotalComponents);
};
it["creates entity with component pools"] = () => {
var e = ctx.CreateEntity();
e.componentPools.should_be_same(ctx.componentPools);
};
it["throws when destroying an entity which the context doesn't contain"] = expect<ContextDoesNotContainEntityException>(() => {
var e = ctx.CreateEntity();
ctx.DestroyEntity(e);
ctx.DestroyEntity(e);
});
it["can ToString"] = () => {
ctx.ToString().should_be("Unnamed Context");
};
context["when ContextInfo set"] = () => {
ContextInfo contextInfo = null;
before = () => {
var componentNames = new [] { "Health", "Position", "View" };
var componentTypes = new [] { typeof(ComponentA), typeof(ComponentB), typeof(ComponentC) };
contextInfo = new ContextInfo("My Context", componentNames, componentTypes);
ctx = new Context(componentNames.Length, 0, contextInfo);
};
it["has custom ContextInfo"] = () => {
ctx.contextInfo.should_be_same(contextInfo);
};
it["creates entity with same ContextInfo"] = () => {
ctx.CreateEntity().contextInfo.should_be_same(contextInfo);
};
it["throws when componentNames is not same length as totalComponents"] = expect<ContextInfoException>(() => {
new Context(contextInfo.componentNames.Length + 1, 0, contextInfo);
});
};
context["when entity created"] = () => {
Entity e = null;
before = () => {
e = ctx.CreateEntity();
e.AddComponentA();
};
it["gets total entity count"] = () => {
ctx.count.should_be(1);
};
it["has entities that were created with CreateEntity()"] = () => {
ctx.HasEntity(e).should_be_true();
};
it["doesn't have entities that were not created with CreateEntity()"] = () => {
ctx.HasEntity(this.CreateEntity()).should_be_false();
};
it["returns all created entities"] = () => {
var e2 = ctx.CreateEntity();
var entities = ctx.GetEntities();
entities.Length.should_be(2);
entities.should_contain(e);
entities.should_contain(e2);
};
it["destroys entity and removes it"] = () => {
ctx.DestroyEntity(e);
ctx.HasEntity(e).should_be_false();
ctx.count.should_be(0);
ctx.GetEntities().should_be_empty();
};
it["destroys an entity and removes all its components"] = () => {
ctx.DestroyEntity(e);
e.GetComponents().should_be_empty();
};
it["destroys all entities"] = () => {
ctx.CreateEntity();
ctx.DestroyAllEntities();
ctx.HasEntity(e).should_be_false();
ctx.count.should_be(0);
ctx.GetEntities().should_be_empty();
e.GetComponents().should_be_empty();
};
it["ensures same deterministic order when getting entities after destroying all entities"] = () => {
// This is a Unity specific problem. Run Unity Test Tools with in the Entitas.Unity project
const int numEntities = 10;
for (int i = 0; i < numEntities; i++) {
ctx.CreateEntity();
}
var order1 = new int[numEntities];
var entities1 = ctx.GetEntities();
for (int i = 0; i < numEntities; i++) {
order1[i] = entities1[i].creationIndex;
}
ctx.DestroyAllEntities();
ctx.ResetCreationIndex();
for (int i = 0; i < numEntities; i++) {
ctx.CreateEntity();
}
var order2 = new int[numEntities];
var entities2 = ctx.GetEntities();
for (int i = 0; i < numEntities; i++) {
order2[i] = entities2[i].creationIndex;
}
for (int i = 0; i < numEntities; i++) {
var index1 = order1[i];
var index2 = order2[i];
index1.should_be(index2);
}
};
it["throws when destroying all entities and there are still entities retained"] = expect<ContextStillHasRetainedEntitiesException>(() => {
ctx.CreateEntity().Retain(new object());
ctx.DestroyAllEntities();
});
};
context["internal caching"] = () => {
it["caches entities"] = () => {
var entities = ctx.GetEntities();
ctx.GetEntities().should_be_same(entities);
};
it["updates entities cache when creating an entity"] = () => {
var entities = ctx.GetEntities();
ctx.CreateEntity();
ctx.GetEntities().should_not_be_same(entities);
};
it["updates entities cache when destroying an entity"] = () => {
var e = ctx.CreateEntity();
var entities = ctx.GetEntities();
ctx.DestroyEntity(e);
ctx.GetEntities().should_not_be_same(entities);
};
};
context["events"] = () => {
var didDispatch = 0;
before = () => {
didDispatch = 0;
};
it["dispatches OnEntityCreated when creating a new entity"] = () => {
Entity eventEntity = null;
ctx.OnEntityCreated += (p, entity) => {
didDispatch += 1;
eventEntity = entity;
p.should_be_same(p);
};
var e = ctx.CreateEntity();
didDispatch.should_be(1);
eventEntity.should_be_same(e);
};
it["dispatches OnEntityWillBeDestroyed when destroying an entity"] = () => {
var e = ctx.CreateEntity();
e.AddComponentA();
ctx.OnEntityWillBeDestroyed += (p, entity) => {
didDispatch += 1;
p.should_be_same(ctx);
entity.should_be_same(e);
entity.HasComponentA().should_be_true();
entity.isEnabled.should_be_true();
p.GetEntities().Length.should_be(0);
};
ctx.GetEntities();
ctx.DestroyEntity(e);
didDispatch.should_be(1);
};
it["dispatches OnEntityDestroyed when destroying an entity"] = () => {
var e = ctx.CreateEntity();
ctx.OnEntityDestroyed += (p, entity) => {
didDispatch += 1;
p.should_be_same(ctx);
entity.should_be_same(e);
entity.HasComponentA().should_be_false();
entity.isEnabled.should_be_false();
};
ctx.DestroyEntity(e);
didDispatch.should_be(1);
};
it["entity is released after OnEntityDestroyed"] = () => {
var e = ctx.CreateEntity();
ctx.OnEntityDestroyed += (p, entity) => {
didDispatch += 1;
entity.retainCount.should_be(1);
var newEntity = ctx.CreateEntity();
newEntity.should_not_be_null();
newEntity.should_not_be_same(entity);
};
ctx.DestroyEntity(e);
var reusedEntity = ctx.CreateEntity();
reusedEntity.should_be_same(e);
didDispatch.should_be(1);
};
it["throws if entity is released before it is destroyed"] = expect<EntityIsNotDestroyedException>(() => {
var e = ctx.CreateEntity();
e.Release(ctx);
});
it["dispatches OnGroupCreated when creating a new group"] = () => {
Group eventGroup = null;
ctx.OnGroupCreated += (p, g) => {
didDispatch += 1;
p.should_be_same(ctx);
eventGroup = g;
};
var group = ctx.GetGroup(Matcher.AllOf(0));
didDispatch.should_be(1);
eventGroup.should_be_same(group);
};
it["doesn't dispatch OnGroupCreated when group alredy exists"] = () => {
ctx.GetGroup(Matcher.AllOf(0));
ctx.OnGroupCreated += delegate { this.Fail(); };
ctx.GetGroup(Matcher.AllOf(0));
};
it["dispatches OnGroupCleared when clearing groups"] = () => {
Group eventGroup = null;
ctx.OnGroupCleared += (p, g) => {
didDispatch += 1;
p.should_be_same(ctx);
eventGroup = g;
};
ctx.GetGroup(Matcher.AllOf(0));
var group2 = ctx.GetGroup(Matcher.AllOf(1));
ctx.ClearGroups();
didDispatch.should_be(2);
eventGroup.should_be_same(group2);
};
it["removes all external delegates when destroying an entity"] = () => {
var e = ctx.CreateEntity();
e.OnComponentAdded += delegate { this.Fail(); };
e.OnComponentRemoved += delegate { this.Fail(); };
e.OnComponentReplaced += delegate { this.Fail(); };
ctx.DestroyEntity(e);
var e2 = ctx.CreateEntity();
e2.should_be_same(e);
e2.AddComponentA();
e2.ReplaceComponentA(Component.A);
e2.RemoveComponentA();
};
it["will not remove external delegates for OnEntityReleased"] = () => {
var e = ctx.CreateEntity();
var didRelease = 0;
e.OnEntityReleased += entity => didRelease += 1;
ctx.DestroyEntity(e);
didRelease.should_be(1);
};
it["removes all external delegates from OnEntityReleased when after being dispatched"] = () => {
var e = ctx.CreateEntity();
var didRelease = 0;
e.OnEntityReleased += entity => didRelease += 1;
ctx.DestroyEntity(e);
e.Retain(this);
e.Release(this);
didRelease.should_be(1);
};
it["removes all external delegates from OnEntityReleased after being dispatched (when delayed release)"] = () => {
var e = ctx.CreateEntity();
var didRelease = 0;
e.OnEntityReleased += entity => didRelease += 1;
e.Retain(this);
ctx.DestroyEntity(e);
didRelease.should_be(0);
e.Release(this);
didRelease.should_be(1);
e.Retain(this);
e.Release(this);
didRelease.should_be(1);
};
};
context["entity pool"] = () => {
it["gets entity from object pool"] = () => {
var e = ctx.CreateEntity();
e.should_not_be_null();
e.GetType().should_be(typeof(Entity));
};
it["destroys entity when pushing back to object pool"] = () => {
var e = ctx.CreateEntity();
e.AddComponentA();
ctx.DestroyEntity(e);
e.HasComponent(CID.ComponentA).should_be_false();
};
it["returns pushed entity"] = () => {
var e = ctx.CreateEntity();
e.AddComponentA();
ctx.DestroyEntity(e);
var entity = ctx.CreateEntity();
entity.HasComponent(CID.ComponentA).should_be_false();
entity.should_be_same(e);
};
it["only returns released entities"] = () => {
var e1 = ctx.CreateEntity();
e1.Retain(this);
ctx.DestroyEntity(e1);
var e2 = ctx.CreateEntity();
e2.should_not_be_same(e1);
e1.Release(this);
var e3 = ctx.CreateEntity();
e3.should_be_same(e1);
};
it["returns new entity"] = () => {
var e1 = ctx.CreateEntity();
e1.AddComponentA();
ctx.DestroyEntity(e1);
ctx.CreateEntity();
var e2 = ctx.CreateEntity();
e2.HasComponent(CID.ComponentA).should_be_false();
e2.should_not_be_same(e1);
};
it["sets up entity from pool"] = () => {
ctx.DestroyEntity(ctx.CreateEntity());
var g = ctx.GetGroup(Matcher.AllOf(CID.ComponentA));
var e = ctx.CreateEntity();
e.AddComponentA();
g.GetEntities().should_contain(e);
};
context["when entity gets destroyed"] = () => {
Entity e = null;
before = () => {
e = ctx.CreateEntity();
e.AddComponentA();
ctx.DestroyEntity(e);
};
it["throws when adding component"] = expect<EntityIsNotEnabledException>(() => e.AddComponentA());
it["throws when removing component"] = expect<EntityIsNotEnabledException>(() => e.RemoveComponentA());
it["throws when replacing component"] = expect<EntityIsNotEnabledException>(() => e.ReplaceComponentA(new ComponentA()));
it["throws when replacing component with null"] = expect<EntityIsNotEnabledException>(() => e.ReplaceComponentA(null));
};
};
context["groups"] = () => {
it["gets empty group for matcher when no entities were created"] = () => {
var g = ctx.GetGroup(Matcher.AllOf(CID.ComponentA));
g.should_not_be_null();
g.GetEntities().should_be_empty();
};
context["when entities created"] = () => {
Entity eAB1 = null;
Entity eAB2 = null;
Entity eA = null;
IMatcher matcherAB = Matcher.AllOf(new [] {
CID.ComponentA,
CID.ComponentB
});
before = () => {
eAB1 = ctx.CreateEntity();
eAB1.AddComponentA();
eAB1.AddComponentB();
eAB2 = ctx.CreateEntity();
eAB2.AddComponentA();
eAB2.AddComponentB();
eA = ctx.CreateEntity();
eA.AddComponentA();
};
it["gets group with matching entities"] = () => {
var g = ctx.GetGroup(matcherAB).GetEntities();
g.Length.should_be(2);
g.should_contain(eAB1);
g.should_contain(eAB2);
};
it["gets cached group"] = () => {
ctx.GetGroup(matcherAB).should_be_same(ctx.GetGroup(matcherAB));
};
it["cached group contains newly created matching entity"] = () => {
var g = ctx.GetGroup(matcherAB);
eA.AddComponentB();
g.GetEntities().should_contain(eA);
};
it["cached group doesn't contain entity which are not matching anymore"] = () => {
var g = ctx.GetGroup(matcherAB);
eAB1.RemoveComponentA();
g.GetEntities().should_not_contain(eAB1);
};
it["removes destroyed entity"] = () => {
var g = ctx.GetGroup(matcherAB);
ctx.DestroyEntity(eAB1);
g.GetEntities().should_not_contain(eAB1);
};
it["group dispatches OnEntityRemoved and OnEntityAdded when replacing components"] = () => {
var g = ctx.GetGroup(matcherAB);
var didDispatchRemoved = 0;
var didDispatchAdded = 0;
var componentA = new ComponentA();
g.OnEntityRemoved += (group, entity, index, component) => {
group.should_be_same(g);
entity.should_be_same(eAB1);
index.should_be(CID.ComponentA);
component.should_be_same(Component.A);
didDispatchRemoved++;
};
g.OnEntityAdded += (group, entity, index, component) => {
group.should_be_same(g);
entity.should_be_same(eAB1);
index.should_be(CID.ComponentA);
component.should_be_same(componentA);
didDispatchAdded++;
};
eAB1.ReplaceComponentA(componentA);
didDispatchRemoved.should_be(1);
didDispatchAdded.should_be(1);
};
it["group dispatches OnEntityUpdated with previous and current component when replacing a component"] = () => {
var updated = 0;
var prevComp = eA.GetComponent(CID.ComponentA);
var newComp = new ComponentA();
var g = ctx.GetGroup(Matcher.AllOf(CID.ComponentA));
g.OnEntityUpdated += (group, entity, index, previousComponent, newComponent) => {
updated += 1;
group.should_be_same(g);
entity.should_be_same(eA);
index.should_be(CID.ComponentA);
previousComponent.should_be_same(prevComp);
newComponent.should_be_same(newComp);
};
eA.ReplaceComponent(CID.ComponentA, newComp);
updated.should_be(1);
};
it["group with matcher NoneOf doesn't dispatch OnEntityAdded when destroying entity"] = () => {
var e = ctx.CreateEntity()
.AddComponentA()
.AddComponentB();
var matcher = Matcher.AllOf(CID.ComponentB).NoneOf(CID.ComponentA);
var g = ctx.GetGroup(matcher);
g.OnEntityAdded += delegate { this.Fail(); };
ctx.DestroyEntity(e);
};
context["event timing"] = () => {
before = () => {
ctx = new Context(CID.TotalComponents);
};
it["dispatches group.OnEntityAdded events after all groups are updated"] = () => {
var groupA = ctx.GetGroup(Matcher.AllOf(CID.ComponentA, CID.ComponentB));
var groupB = ctx.GetGroup(Matcher.AllOf(CID.ComponentB));
groupA.OnEntityAdded += delegate {
groupB.count.should_be(1);
};
var entity = ctx.CreateEntity();
entity.AddComponentA();
entity.AddComponentB();
};
it["dispatches group.OnEntityRemoved events after all groups are updated"] = () => {
ctx = new Context(CID.TotalComponents);
var groupB = ctx.GetGroup(Matcher.AllOf(CID.ComponentB));
var groupAB = ctx.GetGroup(Matcher.AllOf(CID.ComponentA, CID.ComponentB));
groupB.OnEntityRemoved += delegate {
groupAB.count.should_be(0);
};
var entity = ctx.CreateEntity();
entity.AddComponentA();
entity.AddComponentB();
entity.RemoveComponentB();
};
};
};
};
context["EntityIndex"] = () => {
it["throws when EntityIndex for key doesn't exist"] = expect<ContextEntityIndexDoesNotExistException>(() => {
ctx.GetEntityIndex("unknown");
});
it["adds and EntityIndex"] = () => {
const int componentIndex = 1;
var entityIndex = new PrimaryEntityIndex<string>(ctx.GetGroup(Matcher.AllOf(componentIndex)), null);
ctx.AddEntityIndex(componentIndex.ToString(), entityIndex);
ctx.GetEntityIndex(componentIndex.ToString()).should_be_same(entityIndex);
};
it["throws when adding an EntityIndex with same name"] = expect<ContextEntityIndexDoesAlreadyExistException>(() => {
const int componentIndex = 1;
var entityIndex = new PrimaryEntityIndex<string>(ctx.GetGroup(Matcher.AllOf(componentIndex)), null);
ctx.AddEntityIndex(componentIndex.ToString(), entityIndex);
ctx.AddEntityIndex(componentIndex.ToString(), entityIndex);
});
};
context["reset"] = () => {
context["groups"] = () => {
it["resets and removes groups from context"] = () => {
var m = Matcher.AllOf(CID.ComponentA);
var groupsCreated = 0;
Group createdGroup = null;
ctx.OnGroupCreated += (p, g) => {
groupsCreated += 1;
createdGroup = g;
};
var initialGroup = ctx.GetGroup(m);
ctx.ClearGroups();
ctx.GetGroup(m);
ctx.CreateEntity().AddComponentA();
groupsCreated.should_be(2);
createdGroup.should_not_be_same(initialGroup);
initialGroup.count.should_be(0);
createdGroup.count.should_be(1);
};
it["removes all event handlers from groups"] = () => {
var m = Matcher.AllOf(CID.ComponentA);
var group = ctx.GetGroup(m);
group.OnEntityAdded += delegate { this.Fail(); };
ctx.ClearGroups();
var e = ctx.CreateEntity();
e.AddComponentA();
group.HandleEntity(e, CID.ComponentA, Component.A);
};
it["releases entities in groups"] = () => {
var m = Matcher.AllOf(CID.ComponentA);
ctx.GetGroup(m);
var entity = ctx.CreateEntity();
entity.AddComponentA();
ctx.ClearGroups();
entity.retainCount.should_be(1);
};
};
context["context"] = () => {
it["resets creation index"] = () => {
ctx.CreateEntity();
ctx.ResetCreationIndex();
ctx.CreateEntity().creationIndex.should_be(0);
};
context["removes all event handlers"] = () => {
it["removes OnEntityCreated"] = () => {
ctx.OnEntityCreated += delegate { this.Fail(); };
ctx.Reset();
ctx.CreateEntity();
};
it["removes OnEntityWillBeDestroyed"] = () => {
ctx.OnEntityWillBeDestroyed += delegate { this.Fail(); };
ctx.Reset();
ctx.DestroyEntity(ctx.CreateEntity());
};
it["removes OnEntityDestroyed"] = () => {
ctx.OnEntityDestroyed += delegate { this.Fail(); };
ctx.Reset();
ctx.DestroyEntity(ctx.CreateEntity());
};
it["removes OnGroupCreated"] = () => {
ctx.OnGroupCreated += delegate { this.Fail(); };
ctx.Reset();
ctx.GetGroup(Matcher.AllOf(0));
};
it["removes OnGroupCleared"] = () => {
ctx.OnGroupCleared += delegate { this.Fail(); };
ctx.Reset();
ctx.GetGroup(Matcher.AllOf(0));
ctx.ClearGroups();
};
};
};
context["component pools"] = () => {
before = () => {
var entity = ctx.CreateEntity();
entity.AddComponentA();
entity.AddComponentB();
entity.RemoveComponentA();
entity.RemoveComponentB();
};
it["clears all component pools"] = () => {
ctx.componentPools[CID.ComponentA].Count.should_be(1);
ctx.componentPools[CID.ComponentB].Count.should_be(1);
ctx.ClearComponentPools();
ctx.componentPools[CID.ComponentA].Count.should_be(0);
ctx.componentPools[CID.ComponentB].Count.should_be(0);
};
it["clears a specific component pool"] = () => {
ctx.ClearComponentPool(CID.ComponentB);
ctx.componentPools[CID.ComponentA].Count.should_be(1);
ctx.componentPools[CID.ComponentB].Count.should_be(0);
};
it["only clears existing component pool"] = () => {
ctx.ClearComponentPool(CID.ComponentC);
};
};
context["EntityIndex"] = () => {
PrimaryEntityIndex<string> entityIndex = null;
before = () => {
entityIndex = new PrimaryEntityIndex<string>(ctx.GetGroup(Matcher.AllOf(CID.ComponentA)),
(e, c) => ((NameAgeComponent)(c)).name);
ctx.AddEntityIndex(CID.ComponentA.ToString(), entityIndex);
};
it["deactivates EntityIndex"] = () => {
var nameAgeComponent = new NameAgeComponent();
nameAgeComponent.name = "Max";
ctx.CreateEntity().AddComponent(CID.ComponentA, nameAgeComponent);
entityIndex.HasEntity("Max").should_be_true();
ctx.DeactivateAndRemoveEntityIndices();
entityIndex.HasEntity("Max").should_be_false();
};
it["removes EntityIndex"] = expect<ContextEntityIndexDoesNotExistException>(() => {
ctx.DeactivateAndRemoveEntityIndices();
ctx.GetEntityIndex(CID.ComponentA.ToString());
});
};
};
context["EntitasCache"] = () => {
it["pops new list from list pool"] = () => {
var groupA = ctx.GetGroup(Matcher.AllOf(CID.ComponentA));
var groupAB = ctx.GetGroup(Matcher.AnyOf(CID.ComponentA, CID.ComponentB));
var groupABC = ctx.GetGroup(Matcher.AnyOf(CID.ComponentA, CID.ComponentB, CID.ComponentC));
var didExecute = 0;
groupA.OnEntityAdded += (g, entity, index, component) => {
didExecute += 1;
entity.RemoveComponentA();
};
groupAB.OnEntityAdded += (g, entity, index, component) => {
didExecute += 1;
};
groupABC.OnEntityAdded += (g, entity, index, component) => {
didExecute += 1;
};
ctx.CreateEntity().AddComponentA();
didExecute.should_be(3);
};
};
}
