public void Run() { for (int i = 0; i < n; i++) { _e.ReplaceComponent(CP.ComponentA, new ComponentA()); } }
public static void DrawAndSetElement(Type type, string fieldName, object value, Entity entity, int index, IComponent component, Action <object> setValue) { var newValue = DrawAndGetNewValue(type, fieldName, value, entity, index, component); if (DidValueChange(value, newValue)) { setValue(newValue); entity.ReplaceComponent(index, component); } }
/// replace Component with a NEW one public static T ReplaceNewComponent <T>(this Entity entity) where T : IComponent, new() { int index = ComponentIndex <T> .FindIn(entity.contextInfo); T component = entity.CreateComponent <T>(index); entity.ReplaceComponent(index, component); return(component); }
public static void DrawAndSetElement(Type type, string fieldName, object value, Entity entity, int index, IComponent component, Action <IComponent, object> setValue) { var newValue = DrawAndGetNewValue(type, fieldName, value, entity, index, component); if (DidValueChange(value, newValue)) { var newComponent = entity.CreateComponent(index, component.GetType()); component.CopyPublicMemberValues(newComponent); setValue(newComponent, newValue); entity.ReplaceComponent(index, newComponent); } }
void when_created() { Entity e = null; before = () => { e = this.CreateEntity(); }; context["initial state"] = () => { it["throws when attempting to get component of type which hasn't been added"] = expect <EntityDoesNotHaveComponentException>(() => { e.GetComponentA(); }); it["gets empty array of components when no components were added"] = () => { e.GetComponents().should_be_empty(); }; it["gets empty array of component indices when no components were added"] = () => { e.GetComponentIndices().should_be_empty(); }; it["doesn't have component of type when no component of that type was added"] = () => { e.HasComponentA().should_be_false(); }; it["doesn't have components of types when no components of these types were added"] = () => { e.HasComponents(_indicesA).should_be_false(); }; it["doesn't have any components of types when no components of these types were added"] = () => { e.HasAnyComponent(_indicesA).should_be_false(); }; it["returns entity when adding a component"] = () => { e.AddComponent(0, null).should_be_same(e); }; it["adds a component"] = () => { e.AddComponentA(); assertHasComponentA(e); }; it["throws when attempting to remove a component of type which hasn't been added"] = expect <EntityDoesNotHaveComponentException>(() => { e.RemoveComponentA(); }); it["replacing a non existing component adds component"] = () => { e.ReplaceComponentA(Component.A); assertHasComponentA(e); }; }; context["when component added"] = () => { before = () => { e.AddComponentA(); }; it["throws when adding a component of the same type twice"] = expect <EntityAlreadyHasComponentException>(() => { e.AddComponentA(); e.AddComponentA(); }); it["returns entity when removing a component"] = () => { e.RemoveComponent(CID.ComponentA).should_be_same(e); }; it["removes a component of type"] = () => { e.RemoveComponentA(); assertHasNotComponentA(e); }; it["returns entity when replacing a component"] = () => { e.ReplaceComponent(CID.ComponentA, null).should_be_same(e); }; it["replaces existing component"] = () => { var newComponentA = new ComponentA(); e.ReplaceComponentA(newComponentA); assertHasComponentA(e, newComponentA); }; it["doesn't have components of types when not all components of these types were added"] = () => { e.HasComponents(_indicesAB).should_be_false(); }; it["has any components of types when any component of these types was added"] = () => { e.HasAnyComponent(_indicesAB).should_be_true(); }; context["when adding another component"] = () => { before = () => { e.AddComponentB(); }; it["gets all components"] = () => { var components = e.GetComponents(); components.Length.should_be(2); components.should_contain(Component.A); components.should_contain(Component.B); }; it["gets all component indices"] = () => { var componentIndices = e.GetComponentIndices(); componentIndices.Length.should_be(2); componentIndices.should_contain(CID.ComponentA); componentIndices.should_contain(CID.ComponentB); }; it["has other component"] = () => { e.HasComponentB().should_be_true(); }; it["has components of types when all components of these types were added"] = () => { e.HasComponents(_indicesAB).should_be_true(); }; it["removes all components"] = () => { e.RemoveAllComponents(); e.HasComponentA().should_be_false(); e.HasComponentB().should_be_false(); e.GetComponents().should_be_empty(); e.GetComponentIndices().should_be_empty(); }; it["can ToString"] = () => { e.AddComponent(0, new SomeComponent()); e.ToString().should_be("Entity_0(Some, ComponentA, ComponentB)"); }; }; }; context["events"] = () => { int didDispatch = 0; before = () => { didDispatch = 0; }; it["dispatches OnComponentAdded when adding a component"] = () => { e.OnComponentAdded += (entity, index, component) => { didDispatch += 1; entity.should_be_same(e); index.should_be(CID.ComponentA); component.should_be_same(Component.A); }; e.OnComponentRemoved += (entity, index, component) => this.Fail(); e.OnComponentReplaced += (entity, index, previousComponent, newComponent) => this.Fail(); e.AddComponentA(); didDispatch.should_be(1); }; it["dispatches OnComponentRemoved when removing a component"] = () => { e.AddComponentA(); e.OnComponentRemoved += (entity, index, component) => { didDispatch += 1; entity.should_be_same(e); index.should_be(CID.ComponentA); component.should_be_same(Component.A); }; e.OnComponentAdded += (entity, index, component) => this.Fail(); e.OnComponentReplaced += (entity, index, previousComponent, newComponent) => this.Fail(); e.RemoveComponentA(); didDispatch.should_be(1); }; it["dispatches OnComponentReplaced when replacing a component"] = () => { e.AddComponentA(); var newComponentA = new ComponentA(); e.OnComponentReplaced += (entity, index, previousComponent, newComponent) => { didDispatch += 1; entity.should_be_same(e); index.should_be(CID.ComponentA); previousComponent.should_be_same(Component.A); newComponent.should_be_same(newComponentA); }; e.OnComponentAdded += (entity, index, component) => this.Fail(); e.OnComponentRemoved += (entity, index, component) => this.Fail(); e.ReplaceComponentA(newComponentA); didDispatch.should_be(1); }; it["provides previous and new component OnComponentReplaced when replacing with different component"] = () => { var prevComp = new ComponentA(); var newComp = new ComponentA(); e.OnComponentReplaced += (entity, index, previousComponent, newComponent) => { didDispatch += 1; entity.should_be_same(e); previousComponent.should_be_same(prevComp); newComponent.should_be_same(newComp); }; e.AddComponent(CID.ComponentA, prevComp); e.ReplaceComponent(CID.ComponentA, newComp); didDispatch.should_be(1); }; it["provides previous and new component OnComponentReplaced when replacing with same component"] = () => { e.OnComponentReplaced += (entity, index, previousComponent, newComponent) => { didDispatch += 1; entity.should_be_same(e); previousComponent.should_be_same(Component.A); newComponent.should_be_same(Component.A); }; e.AddComponentA(); e.ReplaceComponentA(Component.A); didDispatch.should_be(1); }; it["doesn't dispatch anything when replacing a non existing component with null"] = () => { e.OnComponentAdded += (entity, index, component) => this.Fail(); e.OnComponentReplaced += (entity, index, previousComponent, newComponent) => this.Fail(); e.OnComponentRemoved += (entity, index, component) => this.Fail(); e.ReplaceComponentA(null); }; it["dispatches OnComponentAdded when attempting to replace a component which hasn't been added"] = () => { var newComponentA = new ComponentA(); e.OnComponentAdded += (entity, index, component) => { didDispatch += 1; entity.should_be_same(e); index.should_be(CID.ComponentA); component.should_be_same(newComponentA); }; e.OnComponentReplaced += (entity, index, previousComponent, newComponent) => this.Fail(); e.OnComponentRemoved += (entity, index, component) => this.Fail(); e.ReplaceComponentA(newComponentA); didDispatch.should_be(1); }; it["dispatches OnComponentRemoved when replacing a component with null"] = () => { e.AddComponentA(); e.OnComponentRemoved += (entity, index, component) => { didDispatch += 1; }; e.OnComponentAdded += (entity, index, component) => this.Fail(); e.OnComponentReplaced += (entity, index, previousComponent, newComponent) => this.Fail(); e.ReplaceComponentA(null); didDispatch.should_be(1); }; it["dispatches OnComponentRemoved when removing all components"] = () => { e.AddComponentA(); e.AddComponentB(); e.OnComponentRemoved += (entity, index, component) => didDispatch += 1; e.RemoveAllComponents(); didDispatch.should_be(2); }; }; context["reference counting"] = () => { it["retains entity"] = () => { e.RefCount().should_be(0); e.Retain(); e.RefCount().should_be(1); }; it["releases entity"] = () => { e.Retain(); e.Release(); e.RefCount().should_be(0); }; it["throws when releasing more than it has been retained"] = expect <EntityIsAlreadyReleasedException>(() => { e.Retain(); e.Release(); e.Release(); }); context["events"] = () => { it["doesn't dispatch OnEntityReleased when retaining"] = () => { e.OnEntityReleased += entity => this.Fail(); e.Retain(); }; it["dispatches OnEntityReleased when retain and release"] = () => { var didDispatch = 0; e.OnEntityReleased += entity => { didDispatch += 1; entity.should_be_same(e); }; e.Retain(); e.Release(); }; }; }; context["internal caching"] = () => { context["components"] = () => { IComponent[] cache = null; before = () => { e.AddComponentA(); cache = e.GetComponents(); }; it["caches components"] = () => { e.GetComponents().should_be_same(cache); }; it["updates cache when a new component was added"] = () => { e.AddComponentB(); e.GetComponents().should_not_be_same(cache); }; it["updates cache when a component was removed"] = () => { e.RemoveComponentA(); e.GetComponents().should_not_be_same(cache); }; it["updates cache when a component was replaced"] = () => { e.ReplaceComponentA(new ComponentA()); e.GetComponents().should_not_be_same(cache); }; it["doesn't update cache when a component was replaced with same component"] = () => { e.ReplaceComponentA(Component.A); e.GetComponents().should_be_same(cache); }; it["updates cache when all components were removed"] = () => { e.RemoveAllComponents(); e.GetComponents().should_not_be_same(cache); }; }; context["component indices"] = () => { int[] cache = null; before = () => { e.AddComponentA(); cache = e.GetComponentIndices(); }; it["caches component indices"] = () => { e.GetComponentIndices().should_be_same(cache); }; it["updates cache when a new component was added"] = () => { e.AddComponentB(); e.GetComponentIndices().should_not_be_same(cache); }; it["updates cache when a component was removed"] = () => { e.RemoveComponentA(); e.GetComponentIndices().should_not_be_same(cache); }; it["doesn't update cache when a component was replaced"] = () => { e.ReplaceComponentA(new ComponentA()); e.GetComponentIndices().should_be_same(cache); }; it["updates cache when adding a new component with ReplaceComponent"] = () => { e.ReplaceComponentC(Component.C); e.GetComponentIndices().should_not_be_same(cache); }; it["updates cache when all components were removed"] = () => { e.RemoveAllComponents(); e.GetComponentIndices().should_not_be_same(cache); }; }; context["ToString"] = () => { context["when component was added"] = () => { string cache = null; before = () => { e.AddComponentA(); cache = e.ToString(); }; it["caches entity description"] = () => { e.ToString().should_be_same(cache); }; it["updates cache when a new component was added"] = () => { e.AddComponentB(); e.ToString().should_not_be_same(cache); }; it["updates cache when a component was removed"] = () => { e.RemoveComponentA(); e.ToString().should_not_be_same(cache); }; it["doesn't update cache when a component was replaced"] = () => { e.ReplaceComponentA(new ComponentA()); e.ToString().should_be_same(cache); }; it["updates cache when all components were removed"] = () => { e.RemoveAllComponents(); e.ToString().should_not_be_same(cache); }; }; it["updates cache when RemoveAllComponents is called, even if entity has no components"] = () => { var str = e.ToString(); e.RemoveAllComponents(); e.ToString().should_not_be_same(str); }; }; }; }
public static void ReplaceComponentC(this Entity e, ComponentC component) { e.ReplaceComponent(CID.ComponentC, component); }
public static void DrawAndSetElement(Type type, string fieldName, object value, Entity entity, int index, IComponent component, Action<object> setValue) { var newValue = DrawAndGetNewValue(type, fieldName, value, entity, index, component); if (DidValueChange(value, newValue)) { setValue(newValue); entity.ReplaceComponent(index, component); } }
void when_created() { it["increments creationIndex"] = () => { _pool.CreateEntity().creationIndex.should_be(0); _pool.CreateEntity().creationIndex.should_be(1); }; it["starts with given creationIndex"] = () => { new Pool(CID.NumComponents, 42).CreateEntity().creationIndex.should_be(42); }; it["has no entities when no entities were created"] = () => { _pool.GetEntities().should_be_empty(); }; it["creates entity"] = () => { var e = _pool.CreateEntity(); e.should_not_be_null(); e.GetType().should_be(typeof(Entity)); }; it["gets total entity count"] = () => { _pool.CreateEntity(); _pool.Count.should_be(1); }; it["doesn't have entites that were not created with CreateEntity()"] = () => { _pool.HasEntity(this.CreateEntity()).should_be_false(); }; it["has entites that were created with CreateEntity()"] = () => { _pool.HasEntity(_pool.CreateEntity()).should_be_true(); }; it["returns all created entities"] = () => { var e1 = _pool.CreateEntity(); var e2 = _pool.CreateEntity(); var entities = _pool.GetEntities(); entities.should_contain(e1); entities.should_contain(e2); entities.Length.should_be(2); }; it["destroys entity and removes it"] = () => { var e = _pool.CreateEntity(); _pool.DestroyEntity(e); _pool.HasEntity(e).should_be_false(); }; it["destroys an entity and removes all its components"] = () => { var e = _pool.CreateEntity(); e.AddComponentA(); _pool.DestroyEntity(e); e.GetComponents().should_be_empty(); }; it["destroys all entites"] = () => { var e = _pool.CreateEntity(); e.AddComponentA(); _pool.CreateEntity(); _pool.DestroyAllEntities(); _pool.GetEntities().should_be_empty(); e.GetComponents().should_be_empty(); }; it["caches entities"] = () => { _pool.CreateEntity(); var entities1 = _pool.GetEntities(); var entities2 = _pool.GetEntities(); entities1.should_be_same(entities2); _pool.DestroyEntity(_pool.CreateEntity()); _pool.GetEntities().should_not_be_same(entities1); }; context["events"] = () => { it["dispatches OnEntityCreated when creating a new entity"] = () => { Pool eventPool = null; Entity eventEntity = null; _pool.OnEntityCreated += (pool, entity) => { eventPool = pool; eventEntity = entity; }; var e = _pool.CreateEntity(); eventPool.should_be_same(_pool); eventEntity.should_be_same(e); }; it["dispatches OnEntityWillBeDestroyed when destroying a new entity"] = () => { var e = _pool.CreateEntity(); e.AddComponentA(); Pool eventPool = null; Entity eventEntity = null; _pool.OnEntityWillBeDestroyed += (pool, entity) => { eventPool = pool; eventEntity = entity; entity.HasComponentA().should_be_true(); }; _pool.DestroyEntity(e); eventPool.should_be_same(_pool); eventEntity.should_be_same(e); }; it["dispatches OnEntityDestroyed when destroying a new entity"] = () => { var e = _pool.CreateEntity(); Pool eventPool = null; Entity eventEntity = null; _pool.OnEntityDestroyed += (pool, entity) => { eventPool = pool; eventEntity = entity; entity.HasComponentA().should_be_false(); }; _pool.DestroyEntity(e); eventPool.should_be_same(_pool); eventEntity.should_be_same(e); }; it["dispatches OnGroupCreated when creating a new group"] = () => { Pool eventPool = null; Group eventGroup = null; _pool.OnGroupCreated += (pool, g) => { eventPool = pool; eventGroup = g; }; var group = _pool.GetGroup(Matcher.AllOf(0)); eventPool.should_be_same(_pool); eventGroup.should_be_same(group); }; it["doesn't dispatch OnGroupCreeated when group alredy exists"] = () => { _pool.GetGroup(Matcher.AllOf(0)); _pool.OnGroupCreated += (pool, g) => this.Fail(); _pool.GetGroup(Matcher.AllOf(0)); }; }; context["entity pool"] = () => { it["gets entity from object pool"] = () => { var e = _pool.CreateEntity(); e.should_not_be_null(); e.GetType().should_be(typeof(Entity)); }; it["destroys entity when pushing back to object pool"] = () => { var e = _pool.CreateEntity(); e.AddComponentA(); _pool.DestroyEntity(e); e.HasComponent(CID.ComponentA).should_be_false(); }; it["returns pushed entity"] = () => { var e = _pool.CreateEntity(); e.AddComponentA(); _pool.DestroyEntity(e); var entity = _pool.CreateEntity(); entity.HasComponent(CID.ComponentA).should_be_false(); entity.should_be_same(e); }; it["returns new entity"] = () => { var e = _pool.CreateEntity(); e.AddComponentA(); _pool.DestroyEntity(e); _pool.CreateEntity(); var entityFromPool = _pool.CreateEntity(); entityFromPool.HasComponent(CID.ComponentA).should_be_false(); entityFromPool.should_not_be_same(e); }; it["sets up entity from pool"] = () => { _pool.DestroyEntity(_pool.CreateEntity()); var g = _pool.GetGroup(Matcher.AllOf(new [] { CID.ComponentA })); var e = _pool.CreateEntity(); e.AddComponentA(); g.GetEntities().should_contain(e); }; }; context["get entities"] = () => { it["gets empty group for matcher when no entities were created"] = () => { var g = _pool.GetGroup(Matcher.AllOf(new [] { 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 matcher = Matcher.AllOf(new [] { CID.ComponentA, CID.ComponentB }); before = () => { eAB1 = _pool.CreateEntity(); eAB1.AddComponentA(); eAB1.AddComponentB(); eAB2 = _pool.CreateEntity(); eAB2.AddComponentA(); eAB2.AddComponentB(); eA = _pool.CreateEntity(); eA.AddComponentA(); }; it["gets group with matching entities"] = () => { var g = _pool.GetGroup(matcher).GetEntities(); g.Length.should_be(2); g.should_contain(eAB1); g.should_contain(eAB2); }; it["gets cached group"] = () => { _pool.GetGroup(matcher).should_be_same(_pool.GetGroup(matcher)); }; it["cached group contains newly created matching entity"] = () => { var g = _pool.GetGroup(matcher); eA.AddComponentB(); g.GetEntities().should_contain(eA); }; it["cached group doesn't contain entity which are not matching anymore"] = () => { var g = _pool.GetGroup(matcher); eAB1.RemoveComponentA(); g.GetEntities().should_not_contain(eAB1); }; it["removes destroyed entity"] = () => { var g = _pool.GetGroup(matcher); _pool.DestroyEntity(eAB1); g.GetEntities().should_not_contain(eAB1); }; it["ignores adding components to destroyed entity"] = () => { var g = _pool.GetGroup(matcher); _pool.DestroyEntity(eA); eA.AddComponentA(); eA.AddComponentB(); g.GetEntities().should_not_contain(eA); }; it["throws when destroying an entity the pool doesn't contain"] = expect <PoolDoesNotContainEntityException>(() => { var e = _pool.CreateEntity(); _pool.DestroyEntity(e); _pool.DestroyEntity(e); }); it["group dispatches OnEntityRemoved and OnEntityAdded when replacing components"] = () => { var g = _pool.GetGroup(matcher); 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 = _pool.GetGroup(Matcher.AllOf(new [] { 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); }; }; }; context["getGroup"] = () => { context["AnyOfCompoundMatcher"] = () => { AllOfMatcher allOfA = null; AllOfMatcher allOfB = null; AnyOfCompoundMatcher compound = null; Group group = null; Entity e = null; before = () => { allOfA = Matcher.AllOf(CID.ComponentA); allOfB = Matcher.AllOf(CID.ComponentB); compound = Matcher.AnyOf(allOfA, allOfB); group = _pool.GetGroup(compound); e = _pool.CreateEntity(); }; it["adds entity when matching"] = () => { e.AddComponentA(); compound.Matches(e).should_be_true(); group.Count.should_be(1); }; it["doesn't add entity when not matching"] = () => { e.AddComponentC(); compound.Matches(e).should_be_false(); group.Count.should_be(0); }; it["removes entity when not matching anymore"] = () => { e.AddComponentA(); e.RemoveComponentA(); group.Count.should_be(0); }; it["doesn't remove entity when still matching"] = () => { e.AddComponentA(); e.AddComponentB(); e.RemoveComponentB(); group.Count.should_be(1); }; }; context["AllOfOfCompoundMatcher containing a NoneOfMatcher"] = () => { AllOfMatcher allOfAB = null; NoneOfMatcher noneOfC = null; AllOfCompoundMatcher compound = null; Group group = null; Entity e = null; before = () => { allOfAB = Matcher.AllOf(CID.ComponentA, CID.ComponentB); noneOfC = Matcher.NoneOf(CID.ComponentC); compound = Matcher.AllOf(allOfAB, noneOfC); group = _pool.GetGroup(compound); e = _pool.CreateEntity(); }; it["adds entity when matching"] = () => { e.AddComponentA(); e.AddComponentB(); compound.Matches(e).should_be_true(); group.Count.should_be(1); }; it["doesn't add entity when not matching"] = () => { e.AddComponentA(); e.AddComponentB(); e.AddComponentC(); compound.Matches(e).should_be_false(); group.Count.should_be(0); }; it["removes entity when not matching anymore"] = () => { e.AddComponentA(); e.AddComponentB(); e.RemoveComponentB(); group.Count.should_be(0); }; it["doesn't remove entity when still matching"] = () => { e.AddComponentA(); e.AddComponentB(); e.AddComponentC(); e.RemoveComponentC(); group.Count.should_be(1); }; }; }; }
private void ApplyReplace() { entity.ReplaceComponent(componentId, component); }
void when_created() { Entity e = null; before = () => { e = this.CreateEntity(); }; it["has component of type when component of that type was added"] = () => { e.AddComponentA(); e.HasComponentA().should_be_true(); }; it["returns entity when adding a component"] = () => { e.AddComponent(0, null).should_be_same(e); }; it["doesn't have component of type when no component of that type was added"] = () => { e.HasComponentA().should_be_false(); }; it["doesn't have components of types when no components of these types were added"] = () => { e.HasComponents(new [] { CID.ComponentA }).should_be_false(); }; it["doesn't have components of types when not all components of these types were added"] = () => { e.AddComponentA(); e.HasComponents(new [] { CID.ComponentA, CID.ComponentB }).should_be_false(); }; it["has components of types when all components of these types were added"] = () => { e.AddComponentA(); e.AddComponentB(); e.HasComponents(new [] { CID.ComponentA, CID.ComponentB }).should_be_true(); }; it["doesn't have any components of types when no components of these types were added"] = () => { e.HasAnyComponent(new [] { CID.ComponentA }).should_be_false(); }; it["has any components of types when any component of these types was added"] = () => { e.AddComponentA(); e.HasAnyComponent(new [] { CID.ComponentA, CID.ComponentB }).should_be_true(); }; it["removes a component of type"] = () => { e.AddComponentA(); e.RemoveComponentA(); e.HasComponentA().should_be_false(); }; it["returns entity when removing a component"] = () => { e.AddComponentA(); e.RemoveComponent(1).should_be_same(e); }; it["gets a component of type"] = () => { e.AddComponentA(); e.GetComponentA().should_be_same(Component.A); }; it["replaces existing component"] = () => { e.AddComponentA(); var newComponentA = new ComponentA(); e.ReplaceComponentA(newComponentA); e.GetComponentA().should_be_same(newComponentA); }; it["returns entity when replacing a component"] = () => { e.ReplaceComponent(1, null).should_be_same(e); }; it["replacing a non existing component adds component"] = () => { var newComponentA = new ComponentA(); e.ReplaceComponentA(newComponentA); e.GetComponentA().should_be_same(newComponentA); }; it["gets empty array of components when no components were added"] = () => { e.GetComponents().should_be_empty(); }; it["gets empty array of component indices when no components were added"] = () => { e.GetComponentIndices().should_be_empty(); }; it["gets all components"] = () => { e.AddComponentA(); e.AddComponentB(); var allComponents = e.GetComponents(); allComponents.should_contain(Component.A); allComponents.should_contain(Component.B); allComponents.Length.should_be(2); }; it["gets all component indices"] = () => { e.AddComponentA(); e.AddComponentB(); var allComponentIndices = e.GetComponentIndices(); allComponentIndices.should_contain(CID.ComponentA); allComponentIndices.should_contain(CID.ComponentB); allComponentIndices.Length.should_be(2); }; it["removes all components"] = () => { e.AddComponentA(); e.AddComponentB(); e.RemoveAllComponents(); e.HasComponentA().should_be_false(); e.HasComponentB().should_be_false(); e.GetComponents().should_be_empty(); e.GetComponentIndices().should_be_empty(); }; it["can ToString"] = () => { e.AddComponentA(); e.AddComponentB(); e.ToString().should_be("Entity_0(ComponentA, ComponentB)"); }; context["events"] = () => { Entity eventEntity = null; int eventIndex = CID.None; IComponent eventComponent = null; before = () => { eventEntity = null; eventIndex = CID.None; eventComponent = null; }; it["dispatches OnComponentAdded when adding a component"] = () => { e.OnComponentAdded += (entity, index, component) => { eventEntity = entity; eventIndex = index; eventComponent = component; }; e.OnComponentReplaced += (entity, index, component) => this.Fail(); e.OnComponentWillBeRemoved += (entity, index, component) => this.Fail(); e.OnComponentRemoved += (entity, index, component) => this.Fail(); e.AddComponentA(); eventEntity.should_be_same(e); eventIndex.should_be(CID.ComponentA); eventComponent.should_be_same(Component.A); }; it["dispatches OnComponentRemoved when removing a component"] = () => { e.AddComponentA(); e.OnComponentAdded += (entity, index, component) => this.Fail(); e.OnComponentReplaced += (entity, index, component) => this.Fail(); e.OnComponentRemoved += (entity, index, component) => { eventEntity = entity; eventIndex = index; eventComponent = component; }; e.RemoveComponentA(); eventEntity.should_be_same(e); eventIndex.should_be(CID.ComponentA); eventComponent.should_be_same(Component.A); }; it["dispatches OnComponentWillBeRemoved when removing a component"] = () => { e.AddComponentA(); e.OnComponentWillBeRemoved += (entity, index, component) => { eventEntity = entity; eventIndex = index; eventComponent = component; }; e.RemoveComponentA(); eventEntity.should_be_same(e); eventIndex.should_be(CID.ComponentA); eventComponent.should_be_same(Component.A); }; it["dispatches OnComponentReplaced when replacing a component"] = () => { e.AddComponentA(); var newComponentA = new ComponentA(); var didReplace = 0; e.OnComponentAdded += (entity, index, component) => this.Fail(); e.OnComponentReplaced += (entity, index, component) => { entity.should_be_same(entity); index.should_be(CID.ComponentA); component.should_be_same(newComponentA); didReplace++; }; e.OnComponentWillBeRemoved += (entity, index, component) => this.Fail(); e.OnComponentRemoved += (entity, index, component) => this.Fail(); e.ReplaceComponentA(newComponentA); didReplace.should_be(1); }; it["doesn't dispatch anything when replacing a non existing component with null"] = () => { e.OnComponentAdded += (entity, index, component) => this.Fail(); e.OnComponentReplaced += (entity, index, component) => this.Fail(); e.OnComponentWillBeRemoved += (entity, index, component) => this.Fail(); e.OnComponentRemoved += (entity, index, component) => this.Fail(); e.ReplaceComponentA(null); }; it["dispatches OnComponentWillBeRemoved when called manually and component exists"] = () => { e.AddComponentA(); e.OnComponentWillBeRemoved += (entity, index, component) => { eventEntity = entity; eventIndex = index; eventComponent = component; }; e.WillRemoveComponent(CID.ComponentA); eventEntity.should_be_same(e); eventIndex.should_be(CID.ComponentA); eventComponent.should_be_same(Component.A); }; it["doesn't dispatch OnComponentWillBeRemoved when called manually and entity doesn't have"] = () => { e.OnComponentWillBeRemoved += (entity, index, component) => { eventEntity = entity; eventIndex = index; eventComponent = component; }; e.WillRemoveComponent(CID.ComponentA); eventEntity.should_be_null(); eventIndex.should_be(CID.None); eventComponent.should_be_null(); }; it["dispatches OnComponentAdded when attempting to replace a component which hasn't been added"] = () => { e.OnComponentAdded += (entity, index, component) => { eventEntity = entity; eventIndex = index; eventComponent = component; }; e.OnComponentReplaced += (entity, index, component) => this.Fail(); e.OnComponentWillBeRemoved += (entity, index, component) => this.Fail(); e.OnComponentRemoved += (entity, index, component) => this.Fail(); var newComponentA = new ComponentA(); e.ReplaceComponentA(newComponentA); eventEntity.should_be_same(e); eventIndex.should_be(CID.ComponentA); eventComponent.should_be_same(newComponentA); }; it["dispatches OnComponentRemoved when removing all components"] = () => { var removed = 0; e.AddComponentA(); e.AddComponentB(); e.OnComponentRemoved += (entity, index, component) => removed++; e.RemoveAllComponents(); removed.should_be(2); }; }; context["invalid operations"] = () => { it["throws when adding a component of the same type twice"] = expect <EntityAlreadyHasComponentException>(() => { e.AddComponentA(); e.AddComponentA(); }); it["throws when attempting to remove a component of type which hasn't been added"] = expect <EntityDoesNotHaveComponentException>(() => { e.RemoveComponentA(); }); it["throws when attempting to get component of type which hasn't been added"] = expect <EntityDoesNotHaveComponentException>(() => { e.GetComponentA(); }); }; context["internal caching"] = () => { context["components"] = () => { it["caches components"] = () => { e.AddComponentA(); var c = e.GetComponents(); e.GetComponents().should_be_same(c); }; it["updates cache when a new component was added"] = () => { e.AddComponentA(); var c = e.GetComponents(); e.AddComponentB(); e.GetComponents().should_not_be_same(c); }; it["updates cache when a component was removed"] = () => { e.AddComponentA(); e.AddComponentB(); var c = e.GetComponents(); e.RemoveComponentA(); e.GetComponents().should_not_be_same(c); }; it["updates cache when a component was replaced"] = () => { e.AddComponentA(); e.AddComponentB(); var c = e.GetComponents(); e.ReplaceComponentA(new ComponentA()); e.GetComponents().should_not_be_same(c); }; it["doesn't update cache when a component was replaced with same component"] = () => { e.AddComponentA(); e.AddComponentB(); var c = e.GetComponents(); e.ReplaceComponentA(Component.A); e.GetComponents().should_be_same(c); }; it["updates cache when all components were removed"] = () => { e.AddComponentA(); e.AddComponentB(); var c = e.GetComponents(); e.RemoveAllComponents(); e.GetComponents().should_not_be_same(c); }; }; context["component indices"] = () => { it["caches component indices"] = () => { e.AddComponentA(); var c = e.GetComponentIndices(); e.GetComponentIndices().should_be_same(c); }; it["updates cache when a new component was added"] = () => { e.AddComponentA(); var c = e.GetComponentIndices(); e.AddComponentB(); e.GetComponentIndices().should_not_be_same(c); }; it["updates cache when a component was removed"] = () => { e.AddComponentA(); e.AddComponentB(); var c = e.GetComponentIndices(); e.RemoveComponentA(); e.GetComponentIndices().should_not_be_same(c); }; it["doesn't update cache when a component was replaced"] = () => { e.AddComponentA(); e.AddComponentB(); var c = e.GetComponentIndices(); e.ReplaceComponentA(new ComponentA()); e.GetComponentIndices().should_be_same(c); }; it["updates cache when adding a new component with ReplaceComponent"] = () => { e.AddComponentA(); e.AddComponentB(); var c = e.GetComponentIndices(); e.ReplaceComponentC(Component.C); e.GetComponentIndices().should_not_be_same(c); }; it["updates cache when all components were removed"] = () => { e.AddComponentA(); e.AddComponentB(); var c = e.GetComponentIndices(); e.RemoveAllComponents(); e.GetComponentIndices().should_not_be_same(c); }; }; }; }
public static void DrawComponent(bool[] unfoldedComponents, Entity entity, int index, IComponent component) { var componentType = component.GetType(); var componentName = componentType.Name.RemoveComponentSuffix(); if (componentName.ToLower().Contains(_componentNameSearchTerm.ToLower())) { var boxStyle = getColoredBoxStyle(entity.totalComponents, index); EntitasEditorLayout.BeginVerticalBox(boxStyle); { var memberInfos = componentType.GetPublicMemberInfos(); EntitasEditorLayout.BeginHorizontal(); { if (memberInfos.Count == 0) { EditorGUILayout.LabelField(componentName, EditorStyles.boldLabel); } else { unfoldedComponents[index] = EntitasEditorLayout.Foldout(unfoldedComponents[index], componentName, _foldoutStyle); } if (GUILayout.Button("-", GUILayout.Width(19), GUILayout.Height(14))) { entity.RemoveComponent(index); } } EntitasEditorLayout.EndHorizontal(); if (unfoldedComponents[index]) { var componentDrawer = getComponentDrawer(componentType); if (componentDrawer != null) { var newComponent = entity.CreateComponent(index, componentType); component.CopyPublicMemberValues(newComponent); EditorGUI.BeginChangeCheck(); { componentDrawer.DrawComponent(newComponent); } var changed = EditorGUI.EndChangeCheck(); if (changed) { entity.ReplaceComponent(index, newComponent); } else { entity.GetComponentPool(index).Push(newComponent); } } else { foreach (var info in memberInfos) { DrawAndSetElement(info.type, info.name, info.GetValue(component), entity, index, component, info.SetValue); } } } } EntitasEditorLayout.EndVertical(); } }
public static void MarkUpdated(this Entity entity, int index) { entity.ReplaceComponent(index, entity.GetComponent(index)); }
void when_created() { Pool pool = null; before = () => { pool = new Pool(CID.TotalComponents); }; it["increments creationIndex"] = () => { pool.CreateEntity().creationIndex.should_be(0); pool.CreateEntity().creationIndex.should_be(1); }; it["starts with given creationIndex"] = () => { new Pool(CID.TotalComponents, 42, null).CreateEntity().creationIndex.should_be(42); }; it["has no entities when no entities were created"] = () => { pool.GetEntities().should_be_empty(); }; it["gets total entity count"] = () => { pool.count.should_be(0); }; it["creates entity"] = () => { var e = pool.CreateEntity(); e.should_not_be_null(); e.GetType().should_be(typeof(Entity)); }; it["has default PoolMetaData"] = () => { pool.metaData.poolName.should_be("Unnamed Pool"); pool.metaData.componentNames.Length.should_be(CID.TotalComponents); for (int i = 0; i < pool.metaData.componentNames.Length; i++) { pool.metaData.componentNames[i].should_be("Index " + i); } }; it["creates component pools"] = () => { pool.componentPools.should_not_be_null(); pool.componentPools.Length.should_be(CID.TotalComponents); }; it["creates entity with component pools"] = () => { var e = pool.CreateEntity(); e.componentPools.should_be_same(pool.componentPools); }; it["throws when destroying an entity which the pool doesn't contain"] = expect <PoolDoesNotContainEntityException>(() => { var e = pool.CreateEntity(); pool.DestroyEntity(e); pool.DestroyEntity(e); }); it["can ToString"] = () => { pool.ToString().should_be("Unnamed Pool"); }; context["when PoolMetaData set"] = () => { PoolMetaData metaData = null; before = () => { var componentNames = new [] { "Health", "Position", "View" }; var componentTypes = new [] { typeof(ComponentA), typeof(ComponentB), typeof(ComponentC) }; metaData = new PoolMetaData("My Pool", componentNames, componentTypes); pool = new Pool(componentNames.Length, 0, metaData); }; it["has custom PoolMetaData"] = () => { pool.metaData.should_be_same(metaData); }; it["creates entity with same PoolMetaData"] = () => { pool.CreateEntity().poolMetaData.should_be_same(metaData); }; it["throws when componentNames is not same length as totalComponents"] = expect <PoolMetaDataException>(() => { new Pool(metaData.componentNames.Length + 1, 0, metaData); }); }; context["when entity created"] = () => { Entity e = null; before = () => { e = pool.CreateEntity(); e.AddComponentA(); }; it["gets total entity count"] = () => { pool.count.should_be(1); }; it["has entities that were created with CreateEntity()"] = () => { pool.HasEntity(e).should_be_true(); }; it["doesn't have entities that were not created with CreateEntity()"] = () => { pool.HasEntity(this.CreateEntity()).should_be_false(); }; it["returns all created entities"] = () => { var e2 = pool.CreateEntity(); var entities = pool.GetEntities(); entities.Length.should_be(2); entities.should_contain(e); entities.should_contain(e2); }; it["destroys entity and removes it"] = () => { pool.DestroyEntity(e); pool.HasEntity(e).should_be_false(); pool.count.should_be(0); pool.GetEntities().should_be_empty(); }; it["destroys an entity and removes all its components"] = () => { pool.DestroyEntity(e); e.GetComponents().should_be_empty(); }; it["destroys all entities"] = () => { pool.CreateEntity(); pool.DestroyAllEntities(); pool.HasEntity(e).should_be_false(); pool.count.should_be(0); pool.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++) { pool.CreateEntity(); } var order1 = new int[numEntities]; var entities1 = pool.GetEntities(); for (int i = 0; i < numEntities; i++) { order1[i] = entities1[i].creationIndex; } pool.DestroyAllEntities(); pool.ResetCreationIndex(); for (int i = 0; i < numEntities; i++) { pool.CreateEntity(); } var order2 = new int[numEntities]; var entities2 = pool.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 <PoolStillHasRetainedEntitiesException>(() => { pool.CreateEntity().Retain(new object()); pool.DestroyAllEntities(); }); }; context["internal caching"] = () => { it["caches entities"] = () => { var entities = pool.GetEntities(); pool.GetEntities().should_be_same(entities); }; it["updates entities cache when creating an entity"] = () => { var entities = pool.GetEntities(); pool.CreateEntity(); pool.GetEntities().should_not_be_same(entities); }; it["updates entities cache when destroying an entity"] = () => { var e = pool.CreateEntity(); var entities = pool.GetEntities(); pool.DestroyEntity(e); pool.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; pool.OnEntityCreated += (p, entity) => { didDispatch += 1; eventEntity = entity; p.should_be_same(p); }; var e = pool.CreateEntity(); didDispatch.should_be(1); eventEntity.should_be_same(e); }; it["dispatches OnEntityWillBeDestroyed when destroying an entity"] = () => { var e = pool.CreateEntity(); e.AddComponentA(); pool.OnEntityWillBeDestroyed += (p, entity) => { didDispatch += 1; p.should_be_same(pool); entity.should_be_same(e); entity.HasComponentA().should_be_true(); entity.isEnabled.should_be_true(); p.GetEntities().Length.should_be(0); }; pool.GetEntities(); pool.DestroyEntity(e); didDispatch.should_be(1); }; it["dispatches OnEntityDestroyed when destroying an entity"] = () => { var e = pool.CreateEntity(); pool.OnEntityDestroyed += (p, entity) => { didDispatch += 1; p.should_be_same(pool); entity.should_be_same(e); entity.HasComponentA().should_be_false(); entity.isEnabled.should_be_false(); }; pool.DestroyEntity(e); didDispatch.should_be(1); }; it["entity is released after OnEntityDestroyed"] = () => { var e = pool.CreateEntity(); pool.OnEntityDestroyed += (p, entity) => { didDispatch += 1; entity.retainCount.should_be(1); var newEntity = pool.CreateEntity(); newEntity.should_not_be_null(); newEntity.should_not_be_same(entity); }; pool.DestroyEntity(e); var reusedEntity = pool.CreateEntity(); reusedEntity.should_be_same(e); didDispatch.should_be(1); }; it["throws if entity is released before it is destroyed"] = expect <EntityIsNotDestroyedException>(() => { var e = pool.CreateEntity(); e.Release(pool); }); it["dispatches OnGroupCreated when creating a new group"] = () => { Group eventGroup = null; pool.OnGroupCreated += (p, g) => { didDispatch += 1; p.should_be_same(pool); eventGroup = g; }; var group = pool.GetGroup(Matcher.AllOf(0)); didDispatch.should_be(1); eventGroup.should_be_same(group); }; it["doesn't dispatch OnGroupCreated when group alredy exists"] = () => { pool.GetGroup(Matcher.AllOf(0)); pool.OnGroupCreated += delegate { this.Fail(); }; pool.GetGroup(Matcher.AllOf(0)); }; it["dispatches OnGroupCleared when clearing groups"] = () => { Group eventGroup = null; pool.OnGroupCleared += (p, g) => { didDispatch += 1; p.should_be_same(pool); eventGroup = g; }; pool.GetGroup(Matcher.AllOf(0)); var group2 = pool.GetGroup(Matcher.AllOf(1)); pool.ClearGroups(); didDispatch.should_be(2); eventGroup.should_be_same(group2); }; it["removes all external delegates when destroying an entity"] = () => { var e = pool.CreateEntity(); e.OnComponentAdded += delegate { this.Fail(); }; e.OnComponentRemoved += delegate { this.Fail(); }; e.OnComponentReplaced += delegate { this.Fail(); }; pool.DestroyEntity(e); var e2 = pool.CreateEntity(); e2.should_be_same(e); e2.AddComponentA(); e2.ReplaceComponentA(Component.A); e2.RemoveComponentA(); }; it["will not remove external delegates for OnEntityReleased"] = () => { var e = pool.CreateEntity(); var didRelease = 0; e.OnEntityReleased += entity => didRelease += 1; pool.DestroyEntity(e); didRelease.should_be(1); }; it["removes all external delegates from OnEntityReleased when after being dispatched"] = () => { var e = pool.CreateEntity(); var didRelease = 0; e.OnEntityReleased += entity => didRelease += 1; pool.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 = pool.CreateEntity(); var didRelease = 0; e.OnEntityReleased += entity => didRelease += 1; e.Retain(this); pool.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 = pool.CreateEntity(); e.should_not_be_null(); e.GetType().should_be(typeof(Entity)); }; it["destroys entity when pushing back to object pool"] = () => { var e = pool.CreateEntity(); e.AddComponentA(); pool.DestroyEntity(e); e.HasComponent(CID.ComponentA).should_be_false(); }; it["returns pushed entity"] = () => { var e = pool.CreateEntity(); e.AddComponentA(); pool.DestroyEntity(e); var entity = pool.CreateEntity(); entity.HasComponent(CID.ComponentA).should_be_false(); entity.should_be_same(e); }; it["only returns released entities"] = () => { var e1 = pool.CreateEntity(); e1.Retain(this); pool.DestroyEntity(e1); var e2 = pool.CreateEntity(); e2.should_not_be_same(e1); e1.Release(this); var e3 = pool.CreateEntity(); e3.should_be_same(e1); }; it["returns new entity"] = () => { var e1 = pool.CreateEntity(); e1.AddComponentA(); pool.DestroyEntity(e1); pool.CreateEntity(); var e2 = pool.CreateEntity(); e2.HasComponent(CID.ComponentA).should_be_false(); e2.should_not_be_same(e1); }; it["sets up entity from pool"] = () => { pool.DestroyEntity(pool.CreateEntity()); var g = pool.GetGroup(Matcher.AllOf(CID.ComponentA)); var e = pool.CreateEntity(); e.AddComponentA(); g.GetEntities().should_contain(e); }; context["when entity gets destroyed"] = () => { Entity e = null; before = () => { e = pool.CreateEntity(); e.AddComponentA(); pool.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 = pool.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 = pool.CreateEntity(); eAB1.AddComponentA(); eAB1.AddComponentB(); eAB2 = pool.CreateEntity(); eAB2.AddComponentA(); eAB2.AddComponentB(); eA = pool.CreateEntity(); eA.AddComponentA(); }; it["gets group with matching entities"] = () => { var g = pool.GetGroup(matcherAB).GetEntities(); g.Length.should_be(2); g.should_contain(eAB1); g.should_contain(eAB2); }; it["gets cached group"] = () => { pool.GetGroup(matcherAB).should_be_same(pool.GetGroup(matcherAB)); }; it["cached group contains newly created matching entity"] = () => { var g = pool.GetGroup(matcherAB); eA.AddComponentB(); g.GetEntities().should_contain(eA); }; it["cached group doesn't contain entity which are not matching anymore"] = () => { var g = pool.GetGroup(matcherAB); eAB1.RemoveComponentA(); g.GetEntities().should_not_contain(eAB1); }; it["removes destroyed entity"] = () => { var g = pool.GetGroup(matcherAB); pool.DestroyEntity(eAB1); g.GetEntities().should_not_contain(eAB1); }; it["group dispatches OnEntityRemoved and OnEntityAdded when replacing components"] = () => { var g = pool.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 = pool.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); }; context["event timing"] = () => { before = () => { pool = new Pool(CID.TotalComponents); }; it["dispatches group.OnEntityAdded events after all groups are updated"] = () => { var groupA = pool.GetGroup(Matcher.AllOf(CID.ComponentA, CID.ComponentB)); var groupB = pool.GetGroup(Matcher.AllOf(CID.ComponentB)); groupA.OnEntityAdded += delegate { groupB.count.should_be(1); }; var entity = pool.CreateEntity(); entity.AddComponentA(); entity.AddComponentB(); }; it["dispatches group.OnEntityRemoved events after all groups are updated"] = () => { pool = new Pool(CID.TotalComponents); var groupB = pool.GetGroup(Matcher.AllOf(CID.ComponentB)); var groupAB = pool.GetGroup(Matcher.AllOf(CID.ComponentA, CID.ComponentB)); groupB.OnEntityRemoved += delegate { groupAB.count.should_be(0); }; var entity = pool.CreateEntity(); entity.AddComponentA(); entity.AddComponentB(); entity.RemoveComponentB(); }; }; }; }; context["EntityIndex"] = () => { it["throws when EntityIndex for key doesn't exist"] = expect <PoolEntityIndexDoesNotExistException>(() => { pool.GetEntityIndex("unknown"); }); it["adds and EntityIndex"] = () => { const int componentIndex = 1; var entityIndex = new PrimaryEntityIndex <string>(pool.GetGroup(Matcher.AllOf(componentIndex)), null); pool.AddEntityIndex(componentIndex.ToString(), entityIndex); pool.GetEntityIndex(componentIndex.ToString()).should_be_same(entityIndex); }; it["throws when adding an EntityIndex with same name"] = expect <PoolEntityIndexDoesAlreadyExistException>(() => { const int componentIndex = 1; var entityIndex = new PrimaryEntityIndex <string>(pool.GetGroup(Matcher.AllOf(componentIndex)), null); pool.AddEntityIndex(componentIndex.ToString(), entityIndex); pool.AddEntityIndex(componentIndex.ToString(), entityIndex); }); }; context["reset"] = () => { context["groups"] = () => { it["resets and removes groups from pool"] = () => { var m = Matcher.AllOf(CID.ComponentA); var groupsCreated = 0; Group createdGroup = null; pool.OnGroupCreated += (p, g) => { groupsCreated += 1; createdGroup = g; }; var initialGroup = pool.GetGroup(m); pool.ClearGroups(); pool.GetGroup(m); pool.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 = pool.GetGroup(m); group.OnEntityAdded += delegate { this.Fail(); }; pool.ClearGroups(); var e = pool.CreateEntity(); e.AddComponentA(); group.HandleEntity(e, CID.ComponentA, Component.A); }; it["releases entities in groups"] = () => { var m = Matcher.AllOf(CID.ComponentA); pool.GetGroup(m); var entity = pool.CreateEntity(); entity.AddComponentA(); pool.ClearGroups(); entity.retainCount.should_be(1); }; }; context["pool"] = () => { it["resets creation index"] = () => { pool.CreateEntity(); pool.ResetCreationIndex(); pool.CreateEntity().creationIndex.should_be(0); }; context["removes all event handlers"] = () => { it["removes OnEntityCreated"] = () => { pool.OnEntityCreated += delegate { this.Fail(); }; pool.Reset(); pool.CreateEntity(); }; it["removes OnEntityWillBeDestroyed"] = () => { pool.OnEntityWillBeDestroyed += delegate { this.Fail(); }; pool.Reset(); pool.DestroyEntity(pool.CreateEntity()); }; it["removes OnEntityDestroyed"] = () => { pool.OnEntityDestroyed += delegate { this.Fail(); }; pool.Reset(); pool.DestroyEntity(pool.CreateEntity()); }; it["removes OnGroupCreated"] = () => { pool.OnGroupCreated += delegate { this.Fail(); }; pool.Reset(); pool.GetGroup(Matcher.AllOf(0)); }; it["removes OnGroupCleared"] = () => { pool.OnGroupCleared += delegate { this.Fail(); }; pool.Reset(); pool.GetGroup(Matcher.AllOf(0)); pool.ClearGroups(); }; }; }; context["component pools"] = () => { before = () => { var entity = pool.CreateEntity(); entity.AddComponentA(); entity.AddComponentB(); entity.RemoveComponentA(); entity.RemoveComponentB(); }; it["clears all component pools"] = () => { pool.componentPools[CID.ComponentA].Count.should_be(1); pool.componentPools[CID.ComponentB].Count.should_be(1); pool.ClearComponentPools(); pool.componentPools[CID.ComponentA].Count.should_be(0); pool.componentPools[CID.ComponentB].Count.should_be(0); }; it["clears a specific component pool"] = () => { pool.ClearComponentPool(CID.ComponentB); pool.componentPools[CID.ComponentA].Count.should_be(1); pool.componentPools[CID.ComponentB].Count.should_be(0); }; it["only clears existing component pool"] = () => { pool.ClearComponentPool(CID.ComponentC); }; }; context["EntityIndex"] = () => { PrimaryEntityIndex <string> entityIndex = null; before = () => { entityIndex = new PrimaryEntityIndex <string>(pool.GetGroup(Matcher.AllOf(CID.ComponentA)), (e, c) => ((NameAgeComponent)(c)).name); pool.AddEntityIndex(CID.ComponentA.ToString(), entityIndex); }; it["deactivates EntityIndex"] = () => { var nameAgeComponent = new NameAgeComponent(); nameAgeComponent.name = "Max"; pool.CreateEntity().AddComponent(CID.ComponentA, nameAgeComponent); entityIndex.HasEntity("Max").should_be_true(); pool.DeactivateAndRemoveEntityIndices(); entityIndex.HasEntity("Max").should_be_false(); }; it["removes EntityIndex"] = expect <PoolEntityIndexDoesNotExistException>(() => { pool.DeactivateAndRemoveEntityIndices(); pool.GetEntityIndex(CID.ComponentA.ToString()); }); }; }; context["EntitasCache"] = () => { it["pops new list from list pool"] = () => { var groupA = pool.GetGroup(Matcher.AllOf(CID.ComponentA)); var groupAB = pool.GetGroup(Matcher.AnyOf(CID.ComponentA, CID.ComponentB)); var groupABC = pool.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; }; pool.CreateEntity().AddComponentA(); didExecute.should_be(3); }; }; }
public static Entity ReplaceComponentC(this Entity e, ComponentC component) { return(e.ReplaceComponent(CID.ComponentC, component)); }
public static void DrawAndSetElement(Type memberType, string memberName, object value, Entity entity, int index, IComponent component, Action<IComponent, object> setValue) { var newValue = DrawAndGetNewValue(memberType, memberName, value, entity, index, component); if (DidValueChange(value, newValue)) { var newComponent = entity.CreateComponent(index, component.GetType()); component.CopyPublicMemberValues(newComponent); setValue(newComponent, newValue); entity.ReplaceComponent(index, newComponent); } }
void when_created() { Pool pool = null; before = () => { pool = new Pool(CID.NumComponents); }; it["increments creationIndex"] = () => { pool.CreateEntity().creationIndex.should_be(0); pool.CreateEntity().creationIndex.should_be(1); }; it["starts with given creationIndex"] = () => { new Pool(CID.NumComponents, 42).CreateEntity().creationIndex.should_be(42); }; it["has no entities when no entities were created"] = () => { pool.GetEntities().should_be_empty(); }; it["gets total entity count"] = () => { pool.count.should_be(0); }; it["creates entity"] = () => { var e = pool.CreateEntity(); e.should_not_be_null(); e.GetType().should_be(typeof(Entity)); }; context["when entity created"] = () => { Entity e = null; before = () => { e = pool.CreateEntity(); e.AddComponentA(); }; it["gets total entity count"] = () => { pool.count.should_be(1); }; it["has entities that were created with CreateEntity()"] = () => { pool.HasEntity(e).should_be_true(); }; it["doesn't have entities that were not created with CreateEntity()"] = () => { pool.HasEntity(this.CreateEntity()).should_be_false(); }; it["returns all created entities"] = () => { var e2 = pool.CreateEntity(); var entities = pool.GetEntities(); entities.Length.should_be(2); entities.should_contain(e); entities.should_contain(e2); }; it["destroys entity and removes it"] = () => { pool.DestroyEntity(e); pool.HasEntity(e).should_be_false(); pool.count.should_be(0); pool.GetEntities().should_be_empty(); }; it["destroys an entity and removes all its components"] = () => { pool.DestroyEntity(e); e.GetComponents().should_be_empty(); }; it["destroys all entities"] = () => { pool.CreateEntity(); pool.DestroyAllEntities(); pool.HasEntity(e).should_be_false(); pool.count.should_be(0); pool.GetEntities().should_be_empty(); e.GetComponents().should_be_empty(); }; }; context["internal caching"] = () => { it["caches entities"] = () => { var entities = pool.GetEntities(); pool.GetEntities().should_be_same(entities); }; it["updates entities cache when creating an entity"] = () => { var entities = pool.GetEntities(); pool.CreateEntity(); pool.GetEntities().should_not_be_same(entities); }; it["updates entities cache when destroying an entity"] = () => { var e = pool.CreateEntity(); var entities = pool.GetEntities(); pool.DestroyEntity(e); pool.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; pool.OnEntityCreated += (p, entity) => { didDispatch += 1; eventEntity = entity; p.should_be_same(p); }; var e = pool.CreateEntity(); didDispatch.should_be(1); eventEntity.should_be_same(e); }; it["dispatches OnEntityWillBeDestroyed when destroying an entity"] = () => { var e = pool.CreateEntity(); e.AddComponentA(); pool.OnEntityWillBeDestroyed += (p, entity) => { didDispatch += 1; p.should_be_same(pool); entity.should_be_same(e); entity.HasComponentA().should_be_true(); entity.IsEnabled().should_be_true(); }; pool.DestroyEntity(e); didDispatch.should_be(1); }; it["dispatches OnEntityDestroyed when destroying an entity"] = () => { var e = pool.CreateEntity(); pool.OnEntityDestroyed += (p, entity) => { didDispatch += 1; p.should_be_same(pool); entity.should_be_same(e); entity.HasComponentA().should_be_false(); entity.IsEnabled().should_be_false(); }; pool.DestroyEntity(e); didDispatch.should_be(1); }; it["Entity is released after OnEntityDestroyed"] = () => { var e = pool.CreateEntity(); pool.OnEntityDestroyed += (p, entity) => { didDispatch += 1; p.should_be_same(pool); entity.should_be_same(e); entity.RefCount().should_be(1); var newEntity = pool.CreateEntity(); newEntity.should_not_be_null(); newEntity.should_not_be_same(entity); }; pool.DestroyEntity(e); var reusedEntity = pool.CreateEntity(); reusedEntity.should_be_same(e); didDispatch.should_be(1); }; it["throws if entity is released before it is destroyed"] = expect <EntityIsNotDestroyedException>(() => { var e = pool.CreateEntity(); e.Release(); }); it["dispatches OnGroupCreated when creating a new group"] = () => { Group eventGroup = null; pool.OnGroupCreated += (p, g) => { didDispatch += 1; p.should_be_same(pool); eventGroup = g; }; var group = pool.GetGroup(Matcher.AllOf(0)); didDispatch.should_be(1); eventGroup.should_be_same(group); }; it["doesn't dispatch OnGroupCreated when group alredy exists"] = () => { pool.GetGroup(Matcher.AllOf(0)); pool.OnGroupCreated += (p, g) => this.Fail(); pool.GetGroup(Matcher.AllOf(0)); }; it["removes all external delegates when destroying an entity"] = () => { var e = pool.CreateEntity(); e.OnComponentAdded += (entity, index, component) => this.Fail(); e.OnComponentRemoved += (entity, index, component) => this.Fail(); e.OnComponentReplaced += (entity, index, previousComponent, newComponent) => this.Fail(); pool.DestroyEntity(e); var e2 = pool.CreateEntity(); e2.should_be_same(e); e2.AddComponentA(); e2.ReplaceComponentA(Component.A); e2.RemoveComponentA(); }; }; context["entity pool"] = () => { it["gets entity from object pool"] = () => { var e = pool.CreateEntity(); e.should_not_be_null(); e.GetType().should_be(typeof(Entity)); }; it["destroys entity when pushing back to object pool"] = () => { var e = pool.CreateEntity(); e.AddComponentA(); pool.DestroyEntity(e); e.HasComponent(CID.ComponentA).should_be_false(); }; it["returns pushed entity"] = () => { var e = pool.CreateEntity(); e.AddComponentA(); pool.DestroyEntity(e); var entity = pool.CreateEntity(); entity.HasComponent(CID.ComponentA).should_be_false(); entity.should_be_same(e); }; it["only returns released entities"] = () => { var e1 = pool.CreateEntity(); e1.Retain(); pool.DestroyEntity(e1); var e2 = pool.CreateEntity(); e2.should_not_be_same(e1); e1.Release(); var e3 = pool.CreateEntity(); e3.should_be_same(e1); }; it["returns new entity"] = () => { var e1 = pool.CreateEntity(); e1.AddComponentA(); pool.DestroyEntity(e1); pool.CreateEntity(); var e2 = pool.CreateEntity(); e2.HasComponent(CID.ComponentA).should_be_false(); e2.should_not_be_same(e1); }; it["sets up entity from pool"] = () => { pool.DestroyEntity(pool.CreateEntity()); var g = pool.GetGroup(Matcher.AllOf(new [] { CID.ComponentA })); var e = pool.CreateEntity(); e.AddComponentA(); g.GetEntities().should_contain(e); }; context["when entity gets destroyed"] = () => { Entity e = null; before = () => { e = pool.CreateEntity(); e.AddComponentA(); pool.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)); it["sets componentIndexResolver to null"] = () => { e = pool.CreateEntity(); e.componentNames = new string[0]; pool.DestroyEntity(e); e.componentNames.should_be_null(); }; }; }; context["groups"] = () => { it["gets empty group for matcher when no entities were created"] = () => { var g = pool.GetGroup(Matcher.AllOf(new [] { 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 = pool.CreateEntity(); eAB1.AddComponentA(); eAB1.AddComponentB(); eAB2 = pool.CreateEntity(); eAB2.AddComponentA(); eAB2.AddComponentB(); eA = pool.CreateEntity(); eA.AddComponentA(); }; it["gets group with matching entities"] = () => { var g = pool.GetGroup(matcherAB).GetEntities(); g.Length.should_be(2); g.should_contain(eAB1); g.should_contain(eAB2); }; it["gets cached group"] = () => { pool.GetGroup(matcherAB).should_be_same(pool.GetGroup(matcherAB)); }; it["cached group contains newly created matching entity"] = () => { var g = pool.GetGroup(matcherAB); eA.AddComponentB(); g.GetEntities().should_contain(eA); }; it["cached group doesn't contain entity which are not matching anymore"] = () => { var g = pool.GetGroup(matcherAB); eAB1.RemoveComponentA(); g.GetEntities().should_not_contain(eAB1); }; it["removes destroyed entity"] = () => { var g = pool.GetGroup(matcherAB); pool.DestroyEntity(eAB1); g.GetEntities().should_not_contain(eAB1); }; it["throws when destroying an entity the pool doesn't contain"] = expect <PoolDoesNotContainEntityException>(() => { var e = pool.CreateEntity(); pool.DestroyEntity(e); pool.DestroyEntity(e); }); it["group dispatches OnEntityRemoved and OnEntityAdded when replacing components"] = () => { var g = pool.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 = pool.GetGroup(Matcher.AllOf(new [] { 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); }; }; }; }
public static void DrawComponent(bool[] unfoldedComponents, Entity entity, int index, IComponent component) { var componentType = component.GetType(); var componentName = componentType.Name.RemoveComponentSuffix(); if (componentName.ToLower().Contains(_componentNameSearchTerm.ToLower())) { var boxStyle = getColoredBoxStyle(entity.totalComponents, index); EntitasEditorLayout.BeginVerticalBox(boxStyle); { var memberInfos = componentType.GetPublicMemberInfos(); EntitasEditorLayout.BeginHorizontal(); { if (memberInfos.Count == 0) { EditorGUILayout.LabelField(componentName, EditorStyles.boldLabel); } else { unfoldedComponents[index] = EditorGUILayout.Foldout(unfoldedComponents[index], componentName, _foldoutStyle); } if (GUILayout.Button("-", GUILayout.Width(19), GUILayout.Height(14))) { entity.RemoveComponent(index); } } EntitasEditorLayout.EndHorizontal(); if (unfoldedComponents[index]) { var componentDrawer = getComponentDrawer(componentType); if (componentDrawer != null) { var newComponent = entity.CreateComponent(index, componentType); component.CopyPublicMemberValues(newComponent); EditorGUI.BeginChangeCheck(); { componentDrawer.DrawComponent(newComponent); } var changed = EditorGUI.EndChangeCheck(); if (changed) { entity.ReplaceComponent(index, newComponent); } else { entity.GetComponentPool(index).Push(newComponent); } } else { foreach (var info in memberInfos) { DrawAndSetElement(info.type, info.name, info.GetValue(component), entity, index, component, info.SetValue); } } } } EntitasEditorLayout.EndVertical(); } }
void when_created() { Pool pool = null; before = () => { pool = new Pool(CID.NumComponents); }; it["increments creationIndex"] = () => { pool.CreateEntity().creationIndex.should_be(0); pool.CreateEntity().creationIndex.should_be(1); }; it["starts with given creationIndex"] = () => { new Pool(CID.NumComponents, 42).CreateEntity().creationIndex.should_be(42); }; it["has no entities when no entities were created"] = () => { pool.GetEntities().should_be_empty(); }; it["gets total entity count"] = () => { pool.count.should_be(0); }; it["creates entity"] = () => { var e = pool.CreateEntity(); e.should_not_be_null(); e.GetType().should_be(typeof(Entity)); }; context["when entity created"] = () => { Entity e = null; before = () => { e = pool.CreateEntity(); e.AddComponentA(); }; it["gets total entity count"] = () => { pool.count.should_be(1); }; it["has entities that were created with CreateEntity()"] = () => { pool.HasEntity(e).should_be_true(); }; it["doesn't have entities that were not created with CreateEntity()"] = () => { pool.HasEntity(this.CreateEntity()).should_be_false(); }; it["returns all created entities"] = () => { var e2 = pool.CreateEntity(); var entities = pool.GetEntities(); entities.Length.should_be(2); entities.should_contain(e); entities.should_contain(e2); }; it["destroys entity and removes it"] = () => { pool.DestroyEntity(e); pool.HasEntity(e).should_be_false(); pool.count.should_be(0); pool.GetEntities().should_be_empty(); }; it["destroys an entity and removes all its components"] = () => { pool.DestroyEntity(e); e.GetComponents().should_be_empty(); }; it["destroys all entities"] = () => { pool.CreateEntity(); pool.DestroyAllEntities(); pool.HasEntity(e).should_be_false(); pool.count.should_be(0); pool.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++) { pool.CreateEntity(); } var order1 = new int[numEntities]; var entities1 = pool.GetEntities(); for (int i = 0; i < numEntities; i++) { order1[i] = entities1[i].creationIndex; } pool.DestroyAllEntities(); pool.ResetCreationIndex(); for (int i = 0; i < numEntities; i++) { pool.CreateEntity(); } var order2 = new int[numEntities]; var entities2 = pool.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]; System.Console.WriteLine(index1 + " | " + index2); index1.should_be(index2); } }; it["throws when destroying all entities and there are stille entities retained"] = expect <PoolStillHasRetainedEntitiesException>(() => { pool.CreateEntity().Retain(new object()); pool.DestroyAllEntities(); }); }; context["internal caching"] = () => { it["caches entities"] = () => { var entities = pool.GetEntities(); pool.GetEntities().should_be_same(entities); }; it["updates entities cache when creating an entity"] = () => { var entities = pool.GetEntities(); pool.CreateEntity(); pool.GetEntities().should_not_be_same(entities); }; it["updates entities cache when destroying an entity"] = () => { var e = pool.CreateEntity(); var entities = pool.GetEntities(); pool.DestroyEntity(e); pool.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; pool.OnEntityCreated += (p, entity) => { didDispatch += 1; eventEntity = entity; p.should_be_same(p); }; var e = pool.CreateEntity(); didDispatch.should_be(1); eventEntity.should_be_same(e); }; it["dispatches OnEntityWillBeDestroyed when destroying an entity"] = () => { var e = pool.CreateEntity(); e.AddComponentA(); pool.OnEntityWillBeDestroyed += (p, entity) => { didDispatch += 1; p.should_be_same(pool); entity.should_be_same(e); entity.HasComponentA().should_be_true(); entity.IsEnabled().should_be_true(); }; pool.DestroyEntity(e); didDispatch.should_be(1); }; it["dispatches OnEntityDestroyed when destroying an entity"] = () => { var e = pool.CreateEntity(); pool.OnEntityDestroyed += (p, entity) => { didDispatch += 1; p.should_be_same(pool); entity.should_be_same(e); entity.HasComponentA().should_be_false(); entity.IsEnabled().should_be_false(); }; pool.DestroyEntity(e); didDispatch.should_be(1); }; it["Entity is released after OnEntityDestroyed"] = () => { var e = pool.CreateEntity(); pool.OnEntityDestroyed += (p, entity) => { didDispatch += 1; p.should_be_same(pool); entity.should_be_same(e); entity.retainCount.should_be(1); var newEntity = pool.CreateEntity(); newEntity.should_not_be_null(); newEntity.should_not_be_same(entity); }; pool.DestroyEntity(e); var reusedEntity = pool.CreateEntity(); reusedEntity.should_be_same(e); didDispatch.should_be(1); }; it["throws if entity is released before it is destroyed"] = expect <EntityIsNotDestroyedException>(() => { var e = pool.CreateEntity(); e.Release(pool); }); it["dispatches OnGroupCreated when creating a new group"] = () => { Group eventGroup = null; pool.OnGroupCreated += (p, g) => { didDispatch += 1; p.should_be_same(pool); eventGroup = g; }; var group = pool.GetGroup(Matcher.AllOf(0)); didDispatch.should_be(1); eventGroup.should_be_same(group); }; it["doesn't dispatch OnGroupCreated when group alredy exists"] = () => { pool.GetGroup(Matcher.AllOf(0)); pool.OnGroupCreated += (p, g) => this.Fail(); pool.GetGroup(Matcher.AllOf(0)); }; it["dispatches OnGroupCleared when clearing groups"] = () => { Group eventGroup = null; pool.OnGroupCleared += (p, g) => { didDispatch += 1; p.should_be_same(pool); eventGroup = g; }; pool.GetGroup(Matcher.AllOf(0)); var group2 = pool.GetGroup(Matcher.AllOf(1)); pool.ClearGroups(); didDispatch.should_be(2); eventGroup.should_be_same(group2); }; it["removes all external delegates when destroying an entity"] = () => { var e = pool.CreateEntity(); e.OnComponentAdded += (entity, index, component) => this.Fail(); e.OnComponentRemoved += (entity, index, component) => this.Fail(); e.OnComponentReplaced += (entity, index, previousComponent, newComponent) => this.Fail(); pool.DestroyEntity(e); var e2 = pool.CreateEntity(); e2.should_be_same(e); e2.AddComponentA(); e2.ReplaceComponentA(Component.A); e2.RemoveComponentA(); }; }; context["entity pool"] = () => { it["gets entity from object pool"] = () => { var e = pool.CreateEntity(); e.should_not_be_null(); e.GetType().should_be(typeof(Entity)); }; it["destroys entity when pushing back to object pool"] = () => { var e = pool.CreateEntity(); e.AddComponentA(); pool.DestroyEntity(e); e.HasComponent(CID.ComponentA).should_be_false(); }; it["returns pushed entity"] = () => { var e = pool.CreateEntity(); e.AddComponentA(); pool.DestroyEntity(e); var entity = pool.CreateEntity(); entity.HasComponent(CID.ComponentA).should_be_false(); entity.should_be_same(e); }; it["only returns released entities"] = () => { var e1 = pool.CreateEntity(); e1.Retain(this); pool.DestroyEntity(e1); var e2 = pool.CreateEntity(); e2.should_not_be_same(e1); e1.Release(this); var e3 = pool.CreateEntity(); e3.should_be_same(e1); }; it["returns new entity"] = () => { var e1 = pool.CreateEntity(); e1.AddComponentA(); pool.DestroyEntity(e1); pool.CreateEntity(); var e2 = pool.CreateEntity(); e2.HasComponent(CID.ComponentA).should_be_false(); e2.should_not_be_same(e1); }; it["sets up entity from pool"] = () => { pool.DestroyEntity(pool.CreateEntity()); var g = pool.GetGroup(Matcher.AllOf(new [] { CID.ComponentA })); var e = pool.CreateEntity(); e.AddComponentA(); g.GetEntities().should_contain(e); }; context["when entity gets destroyed"] = () => { Entity e = null; before = () => { e = pool.CreateEntity(); e.AddComponentA(); pool.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)); it["sets componentIndexResolver to null"] = () => { e = pool.CreateEntity(); e.componentNames = new string[0]; pool.DestroyEntity(e); e.componentNames.should_be_null(); }; }; }; context["groups"] = () => { it["gets empty group for matcher when no entities were created"] = () => { var g = pool.GetGroup(Matcher.AllOf(new [] { 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 = pool.CreateEntity(); eAB1.AddComponentA(); eAB1.AddComponentB(); eAB2 = pool.CreateEntity(); eAB2.AddComponentA(); eAB2.AddComponentB(); eA = pool.CreateEntity(); eA.AddComponentA(); }; it["gets group with matching entities"] = () => { var g = pool.GetGroup(matcherAB).GetEntities(); g.Length.should_be(2); g.should_contain(eAB1); g.should_contain(eAB2); }; it["gets cached group"] = () => { pool.GetGroup(matcherAB).should_be_same(pool.GetGroup(matcherAB)); }; it["cached group contains newly created matching entity"] = () => { var g = pool.GetGroup(matcherAB); eA.AddComponentB(); g.GetEntities().should_contain(eA); }; it["cached group doesn't contain entity which are not matching anymore"] = () => { var g = pool.GetGroup(matcherAB); eAB1.RemoveComponentA(); g.GetEntities().should_not_contain(eAB1); }; it["removes destroyed entity"] = () => { var g = pool.GetGroup(matcherAB); pool.DestroyEntity(eAB1); g.GetEntities().should_not_contain(eAB1); }; it["throws when destroying an entity the pool doesn't contain"] = expect <PoolDoesNotContainEntityException>(() => { var e = pool.CreateEntity(); pool.DestroyEntity(e); pool.DestroyEntity(e); }); it["group dispatches OnEntityRemoved and OnEntityAdded when replacing components"] = () => { var g = pool.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 = pool.GetGroup(Matcher.AllOf(new [] { 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); }; context["event timing"] = () => { before = () => { pool = new Pool(CID.NumComponents); }; it["dispatches group.OnEntityAdded events after all groups are updated"] = () => { var groupA = pool.GetGroup(Matcher.AllOf(CID.ComponentA, CID.ComponentB)); var groupB = pool.GetGroup(Matcher.AllOf(CID.ComponentB)); groupA.OnEntityAdded += delegate { groupB.count.should_be(1); }; var entity = pool.CreateEntity(); entity.AddComponentA(); entity.AddComponentB(); }; it["dispatches group.OnEntityRemoved events after all groups are updated"] = () => { pool = new Pool(CID.NumComponents); var groupB = pool.GetGroup(Matcher.AllOf(CID.ComponentB)); var groupA = pool.GetGroup(Matcher.AllOf(CID.ComponentA, CID.ComponentB)); groupB.OnEntityRemoved += delegate { groupA.count.should_be(0); }; var entity = pool.CreateEntity(); entity.AddComponentA(); entity.AddComponentB(); entity.RemoveComponentB(); }; }; }; }; context["reset"] = () => { context["groups"] = () => { it["resets and removes groups from pool"] = () => { var m = Matcher.AllOf(CID.ComponentA); var groupsCreated = 0; Group createdGroup = null; pool.OnGroupCreated += (p, g) => { groupsCreated += 1; createdGroup = g; }; var initialGroup = pool.GetGroup(m); pool.ClearGroups(); pool.GetGroup(m); pool.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 = pool.GetGroup(m); group.OnEntityAdded += (g, entity, index, component) => this.Fail(); pool.ClearGroups(); var e = pool.CreateEntity(); e.AddComponentA(); group.HandleEntity(e, CID.ComponentA, Component.A); }; it["releases entities in groups"] = () => { var m = Matcher.AllOf(CID.ComponentA); pool.GetGroup(m); var entity = pool.CreateEntity(); entity.AddComponentA(); pool.ClearGroups(); entity.retainCount.should_be(1); }; }; context["pool"] = () => { it["resets creation index"] = () => { pool.CreateEntity(); pool.ResetCreationIndex(); pool.CreateEntity().creationIndex.should_be(0); }; }; }; }