/// <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);
}
/// <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);
}
/// <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);
}
/// <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)
{
}
/// <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)
{
}
/// <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);
}
/// <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);
}