public void Queues_messages_for_registered_events()
        {
            var manager = TestHelper.CreateGameManager();

            Assert.Equal(nameof(manager.RacesToBeingRelationship), manager.RacesToBeingRelationship.Name);

            RelationshipTestSystem testSystem;

            using (var beingEntityReference = ((IEntityManager)manager).CreateEntity())
            {
                var beingEntity = (GameEntity)beingEntityReference.Referenced;
                beingEntity.AddComponent <BeingComponent>((int)EntityComponent.Being);
                beingEntity.AddComponent <PhysicalComponent>((int)EntityComponent.Physical);
                beingEntity.AddComponent <SensorComponent>((int)EntityComponent.Sensor);

                using (var raceEntityReference = manager.CreateEntity())
                {
                    var raceEntity = raceEntityReference.Referenced;
                    var effect     = raceEntity.AddComponent <EffectComponent>((int)EntityComponent.Effect);
                    effect.EffectType       = EffectType.Move;
                    effect.Duration         = EffectDuration.Infinite;
                    effect.AffectedEntityId = beingEntity.Id;
                    var race = manager.CreateComponent <RaceComponent>((int)EntityComponent.Race);

                    manager.Queue.ProcessQueue(manager);

                    testSystem = new RelationshipTestSystem(raceEntity, race, manager.RacesToBeingRelationship);

                    manager.Queue.Add <EntityAddedMessage <GameEntity> >(
                        testSystem, manager.RacesToBeingRelationship.GetEntityAddedMessageName(), 10);
                    manager.Queue.Add <EntityRemovedMessage <GameEntity> >(
                        testSystem, manager.RacesToBeingRelationship.GetEntityRemovedMessageName(), 10);
                    manager.Queue.Add <PropertyValueChangedMessage <GameEntity, Species> >(
                        testSystem, manager.RacesToBeingRelationship.GetPropertyValueChangedMessageName(
                            nameof(RaceComponent.Species)), 10);
                    manager.RacesToBeingRelationship.AddListener(testSystem);

                    raceEntity.Race = race;

                    Assert.Equal(2, manager.Queue.QueuedCount);

                    race.Species = Species.Dragon;

                    Assert.Equal(3, manager.Queue.QueuedCount);
                }
            }

            Assert.Equal(1, manager.Beings.Count);
            Assert.Equal(0, manager.EntityItems.Count);

            manager.Queue.ProcessQueue(manager);

            Assert.Equal(0, manager.Queue.QueuedCount);
            Assert.Equal(0, manager.Beings.Count);
            Assert.Equal(3, testSystem.MessagesProcessed);
            Assert.Equal(3, testSystem.GroupChangesDetected);
        }
Exemplo n.º 2
0
        public void Queues_messages_for_registered_events()
        {
            var manager = TestHelper.CreateGameManager();

            Assert.Equal(nameof(manager.BeingToPrimaryNaturalWeaponRelationship), manager.BeingToPrimaryNaturalWeaponRelationship.Name);

            RelationshipTestSystem testSystem;

            using (var weaponEntityReference = manager.CreateEntity())
            {
                var weaponEntity = weaponEntityReference.Referenced;
                weaponEntity.AddComponent <ItemComponent>((int)EntityComponent.Item);
                weaponEntity.AddComponent <PhysicalComponent>((int)EntityComponent.Physical);

                using (var beingEntityReference = ((IEntityManager)manager).CreateEntity())
                {
                    var beingEntity = (GameEntity)beingEntityReference.Referenced;
                    var being       = beingEntity.AddComponent <BeingComponent>((int)EntityComponent.Being);
                    beingEntity.AddComponent <PhysicalComponent>((int)EntityComponent.Physical);
                    beingEntity.AddComponent <SensorComponent>((int)EntityComponent.Sensor);

                    manager.Queue.ProcessQueue(manager);

                    testSystem = new RelationshipTestSystem(beingEntity, being, manager.BeingToPrimaryNaturalWeaponRelationship);

                    manager.Queue.Add <EntityAddedMessage <GameEntity> >(
                        testSystem, manager.BeingToPrimaryNaturalWeaponRelationship.GetEntityAddedMessageName(), 10);
                    manager.Queue.Add <EntityRemovedMessage <GameEntity> >(
                        testSystem, manager.BeingToPrimaryNaturalWeaponRelationship.GetEntityRemovedMessageName(), 10);
                    manager.Queue.Add <PropertyValueChangedMessage <GameEntity, int> >(
                        testSystem, manager.BeingToPrimaryNaturalWeaponRelationship.GetPropertyValueChangedMessageName(
                            nameof(BeingComponent.ColdResistance)), 10);
                    manager.BeingToPrimaryNaturalWeaponRelationship.AddListener(testSystem);

                    being.PrimaryNaturalWeaponId = weaponEntity.Id;

                    Assert.Equal(1, manager.Queue.QueuedCount);

                    being.ColdResistance = 10;

                    Assert.Equal(2, manager.Queue.QueuedCount);
                }
            }

            Assert.Equal(1, manager.Beings.Count);
            Assert.Equal(1, manager.EntityItems.Count);

            manager.Queue.ProcessQueue(manager);

            Assert.Equal(0, manager.Beings.Count);
            Assert.Equal(0, manager.EntityItems.Count);
            Assert.Equal(0, manager.Queue.QueuedCount);
            Assert.Equal(3, testSystem.MessagesProcessed);
            Assert.Equal(3, testSystem.GroupChangesDetected);
        }
        public void Queues_messages_for_registered_events()
        {
            var manager = TestHelper.CreateGameManager();

            Assert.Equal(nameof(manager.EffectsToContainingAbilityRelationship), manager.EffectsToContainingAbilityRelationship.Name);

            RelationshipTestSystem testSystem;

            using (var abilityEntityReference = manager.CreateEntity())
            {
                var abilityEntity = abilityEntityReference.Referenced;
                abilityEntity.AddComponent <AbilityComponent>((int)EntityComponent.Ability);

                using (var effectEntityReference = ((IEntityManager)manager).CreateEntity())
                {
                    var effectEntity = (GameEntity)effectEntityReference.Referenced;
                    var effect       = effectEntity.AddComponent <EffectComponent>((int)EntityComponent.Effect);

                    manager.Queue.ProcessQueue(manager);

                    testSystem = new RelationshipTestSystem(effectEntity, effect, manager.EffectsToContainingAbilityRelationship);

                    manager.Queue.Add <EntityAddedMessage <GameEntity> >(
                        testSystem, manager.EffectsToContainingAbilityRelationship.GetEntityAddedMessageName(), 10);
                    manager.Queue.Add <EntityRemovedMessage <GameEntity> >(
                        testSystem, manager.EffectsToContainingAbilityRelationship.GetEntityRemovedMessageName(), 10);
                    manager.Queue.Add <PropertyValueChangedMessage <GameEntity, string> >(
                        testSystem, manager.EffectsToContainingAbilityRelationship.GetPropertyValueChangedMessageName(
                            nameof(EffectComponent.DurationAmount)), 10);
                    manager.EffectsToContainingAbilityRelationship.AddListener(testSystem);

                    effect.ContainingAbilityId = abilityEntity.Id;

                    Assert.Equal(1, manager.Queue.QueuedCount);

                    effect.DurationAmount = "10";

                    Assert.Equal(2, manager.Queue.QueuedCount);
                }
            }

            Assert.Equal(2, manager.Queue.QueuedCount);

            manager.Queue.ProcessQueue(manager);

            Assert.Equal(3, testSystem.MessagesProcessed);
            Assert.Equal(3, testSystem.GroupChangesDetected);
        }