Пример #1
0
        public void TestAspectAllMultiple()
        {
            Aspect      aspect      = Aspect.All(typeof(TestHealthComponent), typeof(TestPowerComponent));
            EntityWorld entityWorld = new EntityWorld();
            Entity      entity;

            entity = entityWorld.CreateEntity();
            Assert.IsFalse(aspect.Interests(entity), "Entity without components must NOT be subject to \"Healthy Powered\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            Assert.IsFalse(aspect.Interests(entity), "Entity with {TestHealthComponent} must NOT be subject to \"Healthy Powered\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            entity.AddComponent(new TestPowerComponentPoolable());
            Assert.IsFalse(aspect.Interests(entity), "Entity with {TestHealthComponent, TestPowerComponentPoolable} must NOT be subject to \"Healthy Powered\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            entity.AddComponent(new TestPowerComponent());
            Assert.IsTrue(aspect.Interests(entity), "Entity with {TestHealthComponent, TestPowerComponent} must be subject to \"Healthy Powered\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            entity.AddComponent(new TestPowerComponent());
            entity.AddComponent(new TestPowerComponentPoolable());
            Assert.IsTrue(aspect.Interests(entity), "Entity with {TestHealthComponent, TestPowerComponent, TestPowerComponentPoolable} must be subject to \"Healthy Powered\" Aspect");
        }
Пример #2
0
        public void TestAspectEmpty()
        {
            Aspect      aspect      = Aspect.Empty();
            EntityWorld entityWorld = new EntityWorld();
            Entity      entity;

            // Aspect.Empty is a base Aspect for EntitySystem meaning "no entities to process"
            entity = entityWorld.CreateEntity();
            Assert.IsFalse(aspect.Interests(entity), "Entity without components must NOT be subject to empty Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            Assert.IsFalse(aspect.Interests(entity), "Entity with any component must NOT be subject to empty Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestPowerComponent());
            entity.AddComponent(new TestHealthComponent());
            Assert.IsFalse(aspect.Interests(entity), "Entity with any components must NOT be subject to empty Aspect");
        }
Пример #3
0
        public void TestAspectExcludeSingle()
        {
            Aspect      aspect      = Aspect.Exclude(typeof(TestPowerComponent));
            EntityWorld entityWorld = new EntityWorld();
            Entity      entity;

            entity = entityWorld.CreateEntity();
            Assert.IsTrue(aspect.Interests(entity), "Entity without components must be subject to \"Not Powered\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            Assert.IsTrue(aspect.Interests(entity), "Entity with {TestHealthComponent} must be subject to \"Not Powered\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestPowerComponent());
            Assert.IsFalse(aspect.Interests(entity), "Entity with {TestPowerComponent} must NOT be subject to \"Not Powered\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            entity.AddComponent(new TestPowerComponent());
            Assert.IsFalse(aspect.Interests(entity), "Entity with {TestHealthComponent, TestPowerComponent} must NOT be subject to \"Not Powered\" Aspect");
        }
Пример #4
0
        /// <summary>Gets the entities.</summary>
        /// <param name="aspect">The aspect.</param>
        /// <returns>The filled Bag{Entity}.</returns>
        public Bag <Entity> GetEntities(Aspect aspect)
        {
            Bag <Entity> entitiesBag = new Bag <Entity>();

            for (int index = 0; index < this.ActiveEntities.Count; ++index)
            {
                Entity entity = this.ActiveEntities.Get(index);
                if (entity != null && aspect.Interests(entity))
                {
                    entitiesBag.Add(entity);
                }
            }

            return(entitiesBag);
        }
Пример #5
0
        public void TestAspectAllOneExclude()
        {
            Aspect aspect = Aspect.Empty()
                            .GetAll(typeof(TestHealthComponent))
                            .GetOne(typeof(TestBaseComponent), typeof(TestDerivedComponent))
                            .GetExclude(typeof(TestPowerComponent), typeof(TestPowerComponentPoolable));

            EntityWorld entityWorld = new EntityWorld();
            Entity      entity;

            entity = entityWorld.CreateEntity();
            Assert.IsFalse(aspect.Interests(entity), "Entity without components must NOT be subject to \"(Healthy) && (Base || Derived) && !(Power || PowerPoolable)\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            Assert.IsFalse(aspect.Interests(entity), "Entity with {TestHealthComponent} must NOT be subject to \"(Healthy) && (Base || Derived) && !(Power || PowerPoolable)\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            entity.AddComponent(new TestBaseComponent());
            Assert.IsTrue(aspect.Interests(entity), "Entity with {TestHealthComponent, TestBaseComponent} must be subject to \"(Healthy) && (Base || Derived) && !(Power || PowerPoolable)\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            entity.AddComponent(new TestBaseComponent());
            entity.AddComponent(new TestDerivedComponent());
            Assert.IsTrue(aspect.Interests(entity), "Entity with {TestHealthComponent, TestBaseComponent, TestDerivedComponent} must be subject to \"(Healthy) && (Base || Derived) && !(Power || PowerPoolable)\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            entity.AddComponent(new TestBaseComponent());
            entity.AddComponent(new TestDerivedComponent());
            entity.AddComponent(new TestPowerComponent());
            Assert.IsFalse(aspect.Interests(entity), "Entity with {TestHealthComponent, TestBaseComponent, TestDerivedComponent, TestPowerComponent} must NOT be subject to \"(Healthy) && (Base || Derived) && !(Power || PowerPoolable)\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            entity.AddComponent(new TestDerivedComponent());
            entity.AddComponent(new TestPowerComponentPoolable());
            Assert.IsFalse(aspect.Interests(entity), "Entity with {TestHealthComponent, TestDerivedComponent, TestPowerComponentPoolable} must NOT be subject to \"(Healthy) && (Base || Derived) && !(Power || PowerPoolable)\" Aspect");

            entity = entityWorld.CreateEntity();
            entity.AddComponent(new TestHealthComponent());
            entity.AddComponent(new TestBaseComponent());
            entity.AddComponent(new TestDerivedComponent());
            entity.AddComponent(new TestPowerComponent());
            entity.AddComponent(new TestPowerComponentPoolable());
            Assert.IsFalse(aspect.Interests(entity), "Entity with {TestHealthComponent, TestBaseComponent, TestDerivedComponent, TestPowerComponent, TestPowerComponentPoolable} must NOT be subject to \"(Healthy) && (Base || Derived) && !(Power || PowerPoolable)\" Aspect");
        }