/// <summary>
        /// Détermine si le joueur a appuyé sur des touches pour lancer des sorts.
        /// </summary>
        void UpdateSpells()
        {
            int spellUsed = -1;

            if (Input.IsTrigger(Microsoft.Xna.Framework.Input.Keys.A))
            {
                spellUsed = 0;
            }
            else if (Input.IsTrigger(Microsoft.Xna.Framework.Input.Keys.Z))
            {
                spellUsed = 1;
            }
            else if (Input.IsTrigger(Microsoft.Xna.Framework.Input.Keys.E))
            {
                spellUsed = 2;
            }
            else if (Input.IsTrigger(Microsoft.Xna.Framework.Input.Keys.R))
            {
                spellUsed = 3;
            }

            var     ms  = Input.GetMouseState();
            Vector2 pos = MapRdr.ToMapSpace(new Vector2(ms.X, ms.Y));

            // Utilise le sort correspondant.
            if (spellUsed != -1 && m_hero.Spells.Count > spellUsed)
            {
                Spell spell = m_hero.Spells[spellUsed];

                if (spell.Description.TargetType.Type == TargettingType.Targetted)
                {
                    if (spell.Description.TargetType.AllowedTargetTypes == EntityTypeRelative.Me)
                    {
                        EntityBase entityDst = m_hero;
                        Vector2    dir       = pos - m_hero.Position; dir.Normalize();
                        spell.Use(new SpellCastTargetInfo()
                        {
                            Type                 = TargettingType.Targetted,
                            TargetId             = m_hero.ID,
                            AlterationParameters = new StateAlterationParameters()
                            {
                                DashTargetDirection = dir,
                            }
                        });
                    }
                    else
                    {
                        EntityBase entityDst = GameServer.GetMap().Entities.GetAliveEntitiesInRange(pos, 1.0f).GetEntitiesInSight(m_hero.Type).NearestFrom(pos);
                        if (entityDst != null)
                        {
                            spell.Use(new SpellCastTargetInfo()
                            {
                                TargetId = entityDst.ID, Type = TargettingType.Targetted
                            });
                        }
                    }
                }
                else if (spell.Description.TargetType.Type == TargettingType.Direction)
                {
                    Vector2 dir = pos - m_hero.Position; dir.Normalize();
                    spell.Use(new SpellCastTargetInfo()
                    {
                        Type = TargettingType.Direction, TargetDirection = dir
                    });
                }
                else if (spell.Description.TargetType.Type == TargettingType.Position)
                {
                    spell.Use(new SpellCastTargetInfo()
                    {
                        Type = TargettingType.Position, TargetPosition = pos
                    });
                }
            }
        }
        /// <summary>
        /// Mets à jour le déplacement du héros en fonction des entrées du joueur humain.
        /// </summary>
        void UpdateHeroMovement()
        {
            // Mouvement du héros.
            var     ms  = Input.GetMouseState();
            Vector2 pos = MapRdr.ToMapSpace(new Vector2(ms.X, ms.Y));

            if (Input.IsRightClickTrigger() && GameServer.GetMap().GetPassabilityAt(pos))
            {
                float dst = Vector2.Distance(pos, Hero.Position);
                // Obtient les entités targettables par le héros à portée.
                var entities = GameServer.GetMap().Entities.GetEntitiesInSight(Hero.Type).
                               GetAliveEntitiesInRange(pos, 1).Where(delegate(KeyValuePair <int, EntityBase> kvp)
                {
                    EntityType ennemyteam = (Hero.Type & EntityType.Teams) ^ EntityType.Teams;
                    return(kvp.Value.Type.HasFlag(ennemyteam) || EntityType.AllTargettableNeutral.HasFlag(kvp.Value.Type));
                }).ToList();

                // Utilise l'arme sur le héros.
                bool hasAttacked = false;
                if (Hero.Weapon != null)
                {
                    if (entities.Count != 0)
                    {
                        float range = Hero.Weapon.GetAttackSpell().TargetType.Range;
                        if (Hero.Weapon.Use(Hero, entities.First().Value) == SpellUseResult.Success ||
                            Vector2.Distance(m_hero.Position, entities.First().Value.Position) <= range)
                        {
                            m_hero.EndMoveTo();
                            m_hero.Path = null;
                            hasAttacked = true;
                        }
                    }
                }
                // Si on effectue pas d'auto attaque => on peut avancer.
                if (entities.Count == 0 || !hasAttacked)
                {
                    // Si on peut bouger en ligne droite, on le fait
                    if (m_client.Controler.GetMap().CanMoveLine(this.Hero.Position, pos))
                    {
                        m_hero.Path = new Trajectory(new List <Vector2>()
                        {
                            pos
                        });
                    }
                    else
                    {
                        // Sinon : on calcule le chemin.
                        m_hero.StartMoveTo(pos);
                    }
                }
            }

            // Vision range
            if (ms.ScrollWheelValue - __oldScroll < 0)
            {
                m_hero.VisionRange--;
            }
            else if (ms.ScrollWheelValue - __oldScroll > 0)
            {
                m_hero.VisionRange++;
            }
        }