C# Entity.Has方法代码示例

 public void Add(Entity e)
 {
     if (e.Has<ImageComponent>())
     {
         var i = e.Get<ImageComponent>();
         this.images.Add(i);
     }
     else if (e.Has<SpriteSheetComponent>())
     {
         var i = e.Get<SpriteSheetComponent>();
         this.images.Add(i);
     }
 }

        internal void OnInteract(Entity entity, MessageSession session, InteractMsg msg)
        {
            if (entity.Has<Fightable>())
            {
                var template = DataCenter.Instance.GetDatum<InteractTemplate>(msg.InteractId);
                if (template == null)
                {
                    Logger.Write("Request a invalid interact[{0}]", msg.InteractId);
                    return;
                }

                EffectSystem.Affect(entity, template);
            }
            else
            {
                PositionSystem.Global.Interact(entity, targets =>
                    {
                        // default interaction - remove removables
                        foreach (var target in targets.Where(target => target.Has<Removable>() && target.Get<Removable>().Action))
                        {
                            // despawn target
                            PositionSystem.Global.Disappear(target);
                            EntityBinder.Instance.Remove(target);
                            EntityManager.Instance.Remove(target.Id);
                        }
                    });
            }
        }

 public void TryPoison(Entity attacker, Entity defender)
 {
     if (attacker.Has<Poison> ()) {
         if (defender.Has<Health> ()) {
             float poisonChanceMult = defender.Has<PoisonChanceMultiplier> () ? defender.Get<PoisonChanceMultiplier> ().Multiplier : 1;
             if (Utils.DropChance ((int)(attacker.Get<Poison> ().Chance * poisonChanceMult))) {
                 if (defender.Has<Execute> ()) {
                     var poisonLoop = new Loop (new DoPoisonEntity (defender, attacker.Get<Poison> ().Damage, m_onPoisoned),
                                             attacker.Get<Poison> ().Speed);
                     defender.Get<Execute> ().AddNew (poisonLoop, "poison_effect");
                     IsPoisoned = true;
                 }
             }
         }
     }
 }

 public bool IsFoe(Entity target)
 {
     if (target.Has<IFFSystem> ()) {
         return ID != target.Get<IFFSystem> ().ID;
     }
     return false;
 }

 public void testEntityHas()
 {
     Entity entity = new Entity();
     Id id = new Id();
     id.Value = 1;
     entity.Add(id);
     Assert.AreEqual(entity.Has<Id>(), true);
 }

        internal bool ChangeMe(Entity admin,
                               [CommandArgument("새로운 Resource Id")] int newResourceId)
        {
            if (!admin.Has<Displayable>())
                return false;

            ChangeResourceAndBroadcast(admin, newResourceId);
            return true;
        }

        internal bool SetPos(Entity admin,
                             [CommandArgument("새로운 X 위치", 0)] double newX,
                             [CommandArgument("새로운 Y 위치", 0)] double newY)
        {
            if (!admin.Has<Pos>())
                return false;

            var msg = new UpdatePositionMsg {X = newX, Y = newY, InstanceMove = true};
            admin.Assign(msg);

            PositionSystem.Global.Move(admin);
            return true;
        }

        public void Attack(Entity attacker, Entity defender)
        {
            if (attacker.Has<Attack> ()) {
                if (defender.Has<Health> ()) {
                    int basedmg = attacker.Get<Attack> ().Damage;
                    int criticaldmg = 0;
                    if (attacker.Has<CriticalHit> ()) {
                        if (Utils.DropChance (attacker.Get<CriticalHit> ().HitChance)) {
                            criticaldmg = attacker.Get<CriticalHit> ().CriticalDamage;
                        }
                    }
                    float attackMult = attacker.Has<AttackMultiplier> () ? attacker.Get<AttackMultiplier> ().Multiplier : 1;
                    int defence = defender.Has<Armor> () ? defender.Get<Armor> ().Defence : 0;
                    basedmg = (int)(basedmg * attackMult);
                    criticaldmg = (int)(criticaldmg * attackMult);
                    int damage = Math.Max(0, basedmg + criticaldmg - defence);

                    if (m_onAttack != null)
                        m_onAttack (attacker, damage, criticaldmg);

                    defender.Get<Health> ().HP = Math.Max (0, defender.Get<Health> ().HP - damage);
                }
            }
        }

        internal bool SpawnNpc(Entity admin,
                               [CommandArgument("Npc의 이름")] string npcName,
                               [CommandArgument("Npc의 X 위치", 0)] double newX,
                               [CommandArgument("Npc의 Y 위치", 0)] double newY)
        {
            if (!admin.Has<Pos>())
                return false;

            var npc = EntityManager.Instance.Create(EntityTemplate.Ids.Npc);
            npc.Get<Motion>().Dir = admin.Get<Motion>().Dir;
            npc.Get<Nameplate>().Name = npcName;
            npc.Get<Pos>().Assign(new Pos {X = newX, Y = newY});

            PositionSystem.Global.Appear(npc);
            EntityBinder.Instance.Add(npc);
            return true;
        }

        internal bool SpawnEntity(Entity admin,
                                  [CommandArgument("생성할 Entity의 TemplateId")] int templateId)
        {
            var entityTemplate = DataCenter.Instance.GetEntityTemplate(templateId);
            if (entityTemplate == null)
                return false;

            var entity = EntityManager.Instance.Create(DataCenter.Instance.GetCreateInfo(entityTemplate));
            if (entity.Has<Pos>() && admin.Has<Pos>())
            {
                entity.Get<Pos>().Assign(admin.Get<Pos>());
                PositionSystem.Global.Appear(entity);
            }

            EntityBinder.Instance.Add(entity);
            return true;
        }

        internal void OnResetPeer(Entity entity, MessageSession session, ResetPeerMessage msg)
        {
            PositionSystem.Global.Disappear(entity);

            if (entity.Has<Player>())
                entity.Get<Player>().Logged = false;

            if (entity.Has<Tickable>())
                entity.Detach<Tickable>();

            EntityBinder.Instance.Update(entity);

            if (entity.Has<Nameplate>())
                Logger.Write("{0} is logout.", entity.Get<Nameplate>().Name);
        }

        void OnArmorTriggered(Entity item, Entity attacker)
        {
            var gameState = (IGameState)Game.Services.GetService (typeof(IGameState));
            var hud = (HUDLayer)Scene.GetLayer ("hud");

            if (attacker.Has<Consumable<ConsumableTypes>> ()) {
                int cost = item.Get<Price> ().Cost;
                int armorId = item.Get<Loot> ().Drop;

                if (attacker.Has<Armor> () && attacker.Get<Armor> ().ArchetypeID >= armorId) {
                    hud.FeedbackMessage ("Already weared", Color.Red);
                } else {
                    if (attacker.Get<Consumable<ConsumableTypes>> ().TryConsume (ConsumableTypes.Money, cost)) {
                        if (!attacker.Has<Armor> ()) {
                            attacker.Register (new Armor (Archetypes.Armors [armorId] ["defence"], armorId));
                        } else {
                            attacker.Get<Armor> ().ArchetypeID = armorId;
                            attacker.Get<Armor> ().Defence = Archetypes.Armors [armorId] ["defence"];
                        }
                        gameState.PlayerArmorID = armorId;
                        RemoveEntityByTag (item.Tag);
                        hud.FeedbackMessage ("Picked up new armor", Color.Yellow);
                    } else {
                        string feedbackMsg = string.Format ("Need {0} money", cost);
                        hud.FeedbackMessage (feedbackMsg, Color.Red);
                    }
                }
            }
        }

        void OnHealthTriggered(Entity item, Entity from)
        {
            var hud = (HUDLayer)Scene.GetLayer ("hud");

            if (from.Has<Health> ()) {
                if (from.Get<Health> ().HP < from.Get<Health> ().MaxHP) {
                    from.Get<Health> ().HP = from.Get<Health> ().HP + item.Get<Loot>().Drop;
                    RemoveEntityByTag (item.Tag);
                    hud.FeedbackMessage ("Picked up health potion", Color.Yellow);
                }
            }
        }

        void OnMoneyTriggered(Entity item, Entity attacker)
        {
            var hud = (HUDLayer)Scene.GetLayer ("hud");

            if (attacker.Has<Consumable<ConsumableTypes>> ()) {
                int droppedMoney = item.Get<Loot>().Drop;
                float moneyMult = attacker.Get<MoneyMultiplier> ().Multiplier;
                droppedMoney = (int)(droppedMoney * moneyMult);
                attacker.Get<Consumable<ConsumableTypes>> ().Refill (ConsumableTypes.Money, droppedMoney);
                RemoveEntityByTag (item.Tag);

                string feedbackMsg = string.Format ("Picked {0} money", droppedMoney);
                hud.FeedbackMessage (feedbackMsg, Color.Yellow);
            }
        }

        void TryFindEnemyOnRoute(Entity monster, IEnumerable<Entity> targets)
        {
            if (!monster.Has<IFFSystem> ())
                return;

            foreach (var enemy in monster.Get<IFFSystem> ().GetFoes (targets)) {
                var enemyPos = enemy.Get<Position> ().MapPos;
                var monsterPos = monster.Get<Position> ().MapPos;

                var distToEnemy = Utils.DirectionDist (monsterPos, enemyPos, monster.Get<LookDirection> ().Direction);
                if (distToEnemy < monster.Get<Perception> ().AlertDistance) {
                    monster.Get<Patrol> ().Steps += monster.Get<Perception> ().AlertDistance - distToEnemy + 1;
                    if (monster.Has<DirectLight> ()) {
                        monster.Get<DirectLight> ().LightColor = Color.Red;
                    }
                    break;
                } else {
                    if (monster.Has<DirectLight> ()) {
                        monster.Get<DirectLight> ().LightColor = Color.White;
                    }
                }
            }
        }