コード例 #1
0
ファイル: Spell.cs プロジェクト: Scriptopathe/codinsa2015
        /// <summary>
        /// Indique si oui ou non ce sort a un effet sur l'entité donné.
        /// </summary>
        public bool HasEffectOn(EntityBase entity, SpellCastTargetInfo info)
        {
            // Vérifie que le sort peut toucher cette entité.
            EntityTypeRelative flag = EntityTypeConverter.ToRelative(entity.Type, SourceCaster.Type & (EntityType.Team1 | EntityType.Team2));

            if (!(Description.TargetType.AllowedTargetTypes.HasFlag(flag) ||
                  (Description.TargetType.AllowedTargetTypes.HasFlag(EntityTypeRelative.Me) && entity.ID == SourceCaster.ID)))
            {
                return(false);
            }

            // Vérifie que si le sort est targetté, il on est bien sur la bonne cible.
            if (Description.TargetType.Type == Spells.TargettingType.Targetted &&
                entity.ID != info.TargetId)
            {
                return(false);
            }

            // Si le caster et le receveur, on vérifie que le flag "me" est présent.
            if ((!Description.TargetType.AllowedTargetTypes.HasFlag(EntityTypeRelative.Me)) && entity.ID == SourceCaster.ID)
            {
                return(false);
            }

            return(true);
        }
コード例 #2
0
        /// <summary>
        /// Prépare les paramètres du sort à partir des informations de ciblage.
        /// </summary>
        /// <param name="target"></param>
        public override void SetupParameters(SpellCastTargetInfo target)
        {
            base.SetupParameters(target);

            target.AlterationParameters.DashTargetPosition = target.TargetPosition;
            target.AlterationParameters.DashTargetEntity   = GameServer.GetMap().GetEntityById(target.TargetId);
        }
コード例 #3
0
        /// <summary>
        /// Utilise le spell
        /// </summary>
        /// <param name="target"></param>
        protected override void DoUseSpell(SpellCastTargetInfo target)
        {
            base.DoUseSpell(target);

            // TODO ici : vérification de range etc...

            Spellcasts.SpellcastBase fireball = new Spellcasts.SpellcastBase(this, target);
            GameServer.GetMap().AddSpellcast(fireball);
        }
コード例 #4
0
ファイル: Spell.cs プロジェクト: Scriptopathe/codinsa2015
 /// <summary>
 /// Effectue un setup des paramètres du sort à partir des infos de targetting.
 /// </summary>
 /// <param name="cast"></param>
 public virtual void SetupParameters(SpellCastTargetInfo target)
 {
 }
コード例 #5
0
ファイル: Spell.cs プロジェクト: Scriptopathe/codinsa2015
 /// <summary>
 /// Fonction à réécrire pour chaque sous-classe de Spell, qui contient le comportement du sort.
 /// </summary>
 /// <param name="target"></param>
 protected virtual void DoUseSpell(SpellCastTargetInfo target)
 {
 }
コード例 #6
0
ファイル: Spell.cs プロジェクト: Scriptopathe/codinsa2015
        /// <summary>
        /// Utilise ce spell, si il n'est pas en cooldown et que la cible spécifiée est valide.
        /// </summary>
        /// <returns>Retourne une valeur indiquant le résultat du cast du sort. Le sort n'est pas casté si : la
        /// cible subit un silence, tente de cibler une entité invalide, le sort est en cooldown,
        /// le sort est ciblé sur une entité et l'entité n'est pas en range.</returns>
        public SpellUseResult Use(SpellCastTargetInfo target, bool isWeaponAttack = false)
        {
            // Vérifie que le type de ciblage est le bon.
            if (((target.Type & Description.TargetType.Type) != Description.TargetType.Type))
            {
                return(SpellUseResult.InvalidTargettingType);
            }

            // Vérifie que le sort n'est pas en cooldown.
            if (CurrentCooldown > 0)
            {
                return(SpellUseResult.OnCooldown);
            }

            // Vérifie que la cible ne subit pas un silence
            if (!isWeaponAttack && SourceCaster.IsSilenced)
            {
                return(SpellUseResult.Silenced);
            }

            // Vérifie que la cible est dans le bon range.
            if ((target.Type & TargettingType.Targetted) == TargettingType.Targetted)
            {
                EntityBase entity = GameServer.GetMap().GetEntityById(target.TargetId);
                if (entity == null)
                {
                    return(SpellUseResult.InvalidTarget);
                }

                if (!this.HasEffectOn(entity, target))
                {
                    return(SpellUseResult.InvalidTarget);
                }

                Vector2 entityPosition = entity.Position;
                if (Vector2.Distance(entityPosition, SourceCaster.Position) > Description.TargetType.Range)
                {
                    return(SpellUseResult.OutOfRange);
                }
            }
            else if ((target.Type & TargettingType.Position) == TargettingType.Position)
            {
                if (Vector2.Distance(target.TargetPosition, SourceCaster.Position) > Description.TargetType.Range)
                {
                    return(SpellUseResult.OutOfRange);
                }
            }
            // Préparation des paramètres
            SetupParameters(target);

            // Applique les effets du casting time.
            string altId = "spell-casting-time-" + this.Name;

            SourceCaster.StateAlterations.EndAlterations(altId);
            foreach (var alterationModel in Description.CastingTimeAlterations)
            {
                SourceCaster.AddAlteration(new Entities.StateAlteration(altId,
                                                                        SourceCaster,
                                                                        alterationModel,
                                                                        target.AlterationParameters,
                                                                        isWeaponAttack ? Entities.StateAlterationSource.Weapon : Entities.StateAlterationSource.SpellActive));
            }


            // Appelle la fonction qui va lancer le spell avec un délai correspondant au casting time.
            GameServer.GetScene().EventSheduler.Schedule(new Scheduler.ActionDelegate(() => {
                DoUseSpell(target);
            }), Description.CastingTime);


            // Met le spell en cooldown.
            CurrentCooldown = GetUseCooldown() * (1 - Math.Min(0.40f, SourceCaster.GetCooldownReduction()));
            return(SpellUseResult.Success);
        }
コード例 #7
0
 /// <summary>
 /// Utilise le spell.
 /// </summary>
 /// <param name="target"></param>
 protected override void DoUseSpell(SpellCastTargetInfo target)
 {
     base.DoUseSpell(target);
     Spellcasts.SpellcastBase cast = new Spellcasts.SpellcastBase(this, target);
     GameServer.GetMap().AddSpellcast(cast);
 }