void OnBuffTriggered(TriggerBuff buff, FightActor triggerrer, BuffTriggerType trigger, object token)
{
var damages = new Fights.Damage(Dice)
{
Source = buff.Caster,
Buff = buff,
IgnoreDamageReduction = true,
IgnoreDamageBoost = true,
School = GetEffectSchool(buff.Dice.EffectId),
MarkTrigger = MarkTrigger,
IsCritical = Critical,
Amount = (int)Math.Floor((buff.Target.Stats.Health.PermanentDamages * Dice.DiceNum) / 100d)
};
if (Effect.EffectId == EffectsEnum.Effect_DamageNeutralPerCasterHPEroded ||
Effect.EffectId == EffectsEnum.Effect_DamageEarthPerCasterHPEroded ||
Effect.EffectId == EffectsEnum.Effect_DamageFirePerCasterHPEroded ||
Effect.EffectId == EffectsEnum.Effect_DamageWaterPerCasterHPEroded ||
Effect.EffectId == EffectsEnum.Effect_DamageAirPerCasterHPEroded)
{
damages.Amount = (int)Math.Floor((buff.Caster.Stats.Health.PermanentDamages * Dice.DiceNum) / 100d);
}
buff.Target.InflictDamage(damages);
}
void StealHp(FightActor target)
{
var damage = new Fights.Damage(Dice, GetEffectSchool(Effect.EffectId), Caster, Spell, TargetedCell, EffectZone)
{
IsCritical = Critical
};
// spell reflected
var buff = target.GetBestReflectionBuff();
if (buff != null && buff.ReflectedLevel >= Spell.CurrentLevel && Spell.Template.Id != 0)
{
NotifySpellReflected(target);
damage.Source = Caster;
damage.ReflectedDamages = true;
Caster.InflictDamage(damage);
if (buff.Duration <= 0)
{
target.RemoveBuff(buff);
}
}
else
{
target.InflictDamage(damage);
var amount = (short)Math.Floor(damage.Amount / 2.0);
if (amount > 0)
{
Caster.Heal(amount, target, true);
}
}
}
private void OnActorAttacked(TriggerBuff buff, BuffTriggerType trigger, object token)
{
System.Collections.Generic.IEnumerable <StatBuff> source = buff.Target.GetBuffs((Buff entry) => entry.Spell == base.Spell).OfType <StatBuff>();
int num = (
from entry in source
where (int)entry.Duration == this.Effect.Duration
select entry).Sum((StatBuff entry) => (int)entry.Value);
short diceFace = base.Dice.DiceFace;
if (num < (int)diceFace)
{
Fights.Damage damage = (Fights.Damage)token;
int num2 = damage.Amount;
if (num2 + num > (int)diceFace)
{
num2 = (int)((short)((int)diceFace - num));
}
PlayerFields punishmentBoostType = Punishment.GetPunishmentBoostType(base.Dice.DiceNum);
StatBuff buff2 = new StatBuff(buff.Target.PopNextBuffId(), buff.Target, base.Caster, base.Dice, base.Spell, (short)num2, punishmentBoostType, false, true, (short)Punishment.GetBuffEffectId(punishmentBoostType))
{
Duration = base.Dice.Value
};
buff.Target.AddAndApplyBuff(buff2, true);
}
}
protected override bool InternalApply()
{
foreach (var actor in GetAffectedActors())
{
var integerEffect = GenerateEffect();
if (integerEffect == null)
{
return(false);
}
if (Effect.Duration != 0 || Effect.Delay != 0)
{
AddTriggerBuff(actor, BuffTriggerType.OnTurnBegin, OnBuffTriggered);
}
else
{
var damages = new Fights.Damage(Dice, EffectSchoolEnum.Neutral, Caster, Spell, TargetedCell, EffectZone)
{
IsCritical = Critical,
IgnoreDamageBoost = true,
IgnoreDamageReduction = false
};
damages.GenerateDamages();
var inflictedDamages = actor.InflictDamage(damages);
var heal = (int)Math.Floor(inflictedDamages / 2d);
Caster.Heal(heal, actor, true);
}
}
return(true);
}
void DamageBuffTrigger(TriggerBuff buff, FightActor triggerrer, BuffTriggerType trigger, object token)
{
var triggerDmg = token as Fights.Damage;
if (triggerDmg == null)
{
return;
}
if (triggerDmg.ReflectedDamages)
{
return;
}
var damage = new Fights.Damage(buff.Dice, GetEffectSchool(buff.Dice.EffectId), buff.Target, buff.Spell, buff.Target.Cell)
{
Buff = buff,
ReflectedDamages = true,
IsCritical = Critical,
MarkTrigger = MarkTrigger,
IgnoreDamageBoost = true
};
damage.GenerateDamages();
damage.Amount = (int)((buff.Target.LifePoints * (buff.Dice.DiceNum / 100.0)));
buff.Target.InflictDamage(damage);
}
public override bool Apply()
{
foreach (FightActor current in base.GetAffectedActors())
{
if (this.Effect.Duration > 0)
{
base.AddTriggerBuff(current, true, BuffTriggerType.TURN_BEGIN, new TriggerBuffApplyHandler(DamagePercent.DamageBuffTrigger));
}
else
{
Fights.Damage damage = new Fights.Damage(base.Dice, DamagePercent.GetEffectSchool(base.Dice.EffectId), base.Caster, base.Spell);
damage.GenerateDamages();
damage.Amount = (int)((double)current.MaxLifePoints * ((double)damage.Amount / 100.0));
damage.IgnoreDamageBoost = true;
damage.MarkTrigger = base.MarkTrigger;
SpellReflectionBuff bestReflectionBuff = current.GetBestReflectionBuff();
if (bestReflectionBuff != null && bestReflectionBuff.ReflectedLevel >= (int)base.Spell.CurrentLevel && base.Spell.Template.Id != 0)
{
this.NotifySpellReflected(current);
damage.Source = current;
damage.ReflectedDamages = true;
base.Caster.InflictDamage(damage);
current.RemoveAndDispellBuff(bestReflectionBuff);
}
else
{
current.InflictDamage(damage);
}
}
}
return(true);
}
private static void DamageBuffTrigger(TriggerBuff buff, BuffTriggerType trigger, object token)
{
Fights.Damage damage = new Fights.Damage(buff.Dice, DirectDamage.GetEffectSchool(buff.Dice.EffectId), buff.Caster, buff.Spell)
{
Buff = buff
};
buff.Target.InflictDamage(damage);
}
protected override bool InternalApply()
{
foreach (var actor in GetAffectedActors())
{
if (Effect.Duration != 0 || Effect.Delay != 0)
{
if (BuffTriggerType == BuffTriggerType.Unknown)
{
AddTriggerBuff(actor, DamageBuffTrigger);
}
else
{
AddTriggerBuff(actor, BuffTriggerType, DamageBuffTrigger);
}
}
else
{
// spell reflected
var buff = actor.GetBestReflectionBuff();
if (buff != null && buff.ReflectedLevel >= Spell.CurrentLevel &&
Spell.Template.Id != 0 && !Caster.IsIndirectSpellCast(Spell) && !Caster.IsPoisonSpellCast(Spell))
{
NotifySpellReflected(actor);
var damage = new Fights.Damage(Dice, GetEffectSchool(Dice.EffectId), Caster, Spell, Caster.Cell)
{
ReflectedDamages = true,
MarkTrigger = MarkTrigger,
IsCritical = Critical
};
damage.GenerateDamages();
damage.Amount = (short)(damage.Amount * Efficiency);
Caster.InflictDamage(damage);
if (buff.Duration <= 0)
{
actor.RemoveBuff(buff);
}
}
else
{
var damage = new Fights.Damage(Dice, GetEffectSchool(Dice.EffectId), Caster, Spell, TargetedCell, EffectZone)
{
MarkTrigger = MarkTrigger,
IsCritical = Critical
};
damage.GenerateDamages();
damage.Amount = (short)(damage.Amount * Efficiency);
actor.InflictDamage(damage);
}
}
}
return(true);
}
private void OnBuffTriggered(TriggerBuff buff, BuffTriggerType trigger, object token)
{
Fights.Damage damage = new Fights.Damage(base.Dice)
{
Source = buff.Caster,
Buff = buff,
IgnoreDamageReduction = true,
School = DamagePerAPUsed.GetEffectSchool(buff.Dice.EffectId),
MarkTrigger = base.MarkTrigger
};
damage.BaseMaxDamages = (int)buff.Target.UsedAP * damage.BaseMaxDamages;
damage.BaseMinDamages = (int)buff.Target.UsedAP * damage.BaseMinDamages;
buff.Target.InflictDamage(damage);
}
static void OnBuffTriggered(TriggerBuff buff, FightActor triggerrer, BuffTriggerType trigger, object token)
{
var damages = new Fights.Damage(buff.Dice, EffectSchoolEnum.Unknown, buff.Caster, buff.Spell, buff.Target.Cell)
{
Buff = buff,
IsCritical = buff.Critical,
};
damages.GenerateDamages();
buff.Target.InflictDirectDamage(damages.Amount);
var heal = (int)Math.Floor(damages.Amount / 2d);
buff.Caster.Heal(heal, buff.Target, true);
}
private static void DamageBuffTrigger(TriggerBuff buff, BuffTriggerType trigger, object token)
{
EffectInteger left = buff.GenerateEffect();
if (!(left == null))
{
Fights.Damage damage = new Fights.Damage(buff.Dice, DamagePercent.GetEffectSchool(buff.Dice.EffectId), buff.Caster, buff.Spell)
{
Buff = buff
};
damage.GenerateDamages();
damage.Amount = (int)((double)buff.Target.MaxLifePoints * ((double)damage.Amount / 100.0));
damage.IgnoreDamageBoost = true;
buff.Target.InflictDamage(damage);
}
}
void BuffTrigger(TriggerBuff buff, FightActor triggerrer, BuffTriggerType trigger, object token)
{
var damage = token as Fights.Damage;
if (damage == null)
{
return;
}
if (damage.ReflectedDamages)
{
return;
}
if (damage.IsWeaponAttack)
{
return;
}
if (damage.Source == null)
{
return;
}
var damages = (int)Math.Floor((damage.Amount * Dice.DiceNum) / 100.0);
foreach (var actor in GetAffectedActors())
{
var reflectDamage = new Fights.Damage(damages)
{
Source = buff.Target,
School = damage.School,
IsCritical = damage.IsCritical,
IgnoreDamageBoost = true,
IgnoreDamageReduction = false,
Spell = null,
ReflectedDamages = true,
};
actor.InflictDamage(reflectDamage);
}
buff.Target.RemoveBuff(buff);
}
protected override bool InternalApply()
{
foreach (var actor in GetAffectedActors())
{
var integerEffect = GenerateEffect();
if (integerEffect == null)
{
return(false);
}
if (Effect.Duration != 0 || Effect.Delay != 0)
{
var triggerType = BuffTriggerType.Instant;
switch (Spell.Id)
{
case (int)SpellIdEnum.SPORE_TEILLE:
triggerType = BuffTriggerType.OnTackle;
break;
}
AddTriggerBuff(actor, triggerType, HealBuffTrigger);
}
else
{
if (actor.IsAlive())
{
var damage = new Fights.Damage(Dice, EffectSchoolEnum.Healing, Caster, Spell, TargetedCell, EffectZone)
{
MarkTrigger = MarkTrigger,
IsCritical = Critical
};
damage.GenerateDamages();
damage.Amount = (short)(damage.Amount * Efficiency);
actor.Heal(damage);
}
}
}
return(true);
}
static void DamageBuffTrigger(TriggerBuff buff, FightActor triggerrer, BuffTriggerType trigger, object token)
{
var damages = token as Fights.Damage;
if (damages != null && (damages.Spell == null || damages.ReflectedDamages))
{
return;
}
var damage = new Fights.Damage(buff.Dice, GetEffectSchool(buff.Dice.EffectId), buff.Caster, null, buff.Target.Cell)
{
IsCritical = buff.Critical,
ReflectedDamages = true
};
damage.GenerateDamages();
damage.Amount = (short)(damage.Amount * buff.Efficiency);
buff.Target.InflictDamage(damage);
}
protected override bool InternalApply()
{
foreach (var actor in GetAffectedActors())
{
var damages = new Fights.Damage(Dice)
{
Source = Caster,
School = GetEffectSchool(Dice.EffectId),
MarkTrigger = MarkTrigger,
IsCritical = Critical
};
var percent = ((double)Caster.Stats.MP.Total / Caster.Stats.MP.TotalMax) * 100.0;
damages.BaseMaxDamages = (int)Math.Floor(damages.BaseMaxDamages * (percent / 100.0));
damages.BaseMinDamages = (int)Math.Floor(damages.BaseMinDamages * (percent / 100.0));
actor.InflictDamage(damages);
}
return(true);
}
protected override bool InternalApply()
{
foreach (var actor in GetAffectedActors().ToArray())
{
var damages = new Fights.Damage(Dice)
{
MarkTrigger = MarkTrigger
};
damages.GenerateDamages();
damages.Amount = (int)(Dice.DiceNum * Caster.Stats.Health.TotalMaxWithoutPermanentDamages * (Math.Pow(Math.Cos(2 * Math.PI * ((100 * Caster.LifePoints / Caster.MaxLifePoints) * 0.01 - 0.5)) + 1, 2) / 4) / 100);
// spell reflected
var buff = actor.GetBestReflectionBuff();
if (buff != null && buff.ReflectedLevel >= Spell.CurrentLevel && Spell.Template.Id != 0)
{
NotifySpellReflected(actor);
damages.Source = Caster;
damages.ReflectedDamages = true;
damages.IgnoreDamageBoost = true;
damages.IsCritical = Critical;
Caster.InflictDamage(damages);
if (buff.Duration <= 0)
{
actor.RemoveBuff(buff);
}
}
else
{
damages.Source = Caster;
damages.IgnoreDamageBoost = true;
actor.InflictDamage(damages);
}
}
return(true);
}
public override bool Apply()
{
foreach (FightActor current in base.GetAffectedActors())
{
Fights.Damage damage = new Fights.Damage(base.Dice);
damage.MarkTrigger = base.MarkTrigger;
damage.GenerateDamages();
double num = 0.0;
double num2 = (double)base.Caster.LifePoints / (double)base.Caster.MaxLifePoints;
if (num2 <= 0.5)
{
num = 2.0 * num2;
}
else
{
if (num2 > 0.5)
{
num = 1.0 + (num2 - 0.5) * -2.0;
}
}
damage.Amount = (int)((double)base.Caster.LifePoints * num * (double)damage.Amount / 100.0);
SpellReflectionBuff bestReflectionBuff = current.GetBestReflectionBuff();
if (bestReflectionBuff != null && bestReflectionBuff.ReflectedLevel >= (int)base.Spell.CurrentLevel && base.Spell.Template.Id != 0)
{
this.NotifySpellReflected(current);
damage.Source = current;
damage.ReflectedDamages = true;
damage.IgnoreDamageBoost = true;
base.Caster.InflictDamage(damage);
current.RemoveAndDispellBuff(bestReflectionBuff);
}
else
{
current.InflictDamage(damage);
}
}
return(true);
}
protected override bool InternalApply()
{
foreach (var actor in GetAffectedActors())
{
var damages = new Fights.Damage(Dice)
{
Source = Caster,
IgnoreDamageReduction = true,
IgnoreDamageBoost = true,
School = GetEffectSchool(Dice.EffectId),
MarkTrigger = MarkTrigger,
IsCritical = Critical
};
var damagesAmount = Math.Round(((Caster.Stats.Health.DamageTaken * Dice.DiceNum) / 100d));
damages.Amount = (int)damagesAmount;
actor.InflictDamage(damages);
}
return(true);
}
protected override bool InternalApply()
{
foreach (var actor in GetAffectedActors().ToArray())
{
if (Effect.Duration != 0 || Effect.Delay != 0)
{
AddTriggerBuff(actor, DamageBuffTrigger);
}
else
{
var damage = new Fights.Damage(Dice, GetEffectSchool(Dice.EffectId), Caster, Spell, TargetedCell, EffectZone);
damage.GenerateDamages();
damage.Amount = (int)Math.Floor((Caster.LifePoints * Dice.DiceNum) / 100d);
damage.IgnoreDamageBoost = true;
damage.MarkTrigger = MarkTrigger;
damage.IsCritical = Critical;
// spell reflected
var buff = actor.GetBestReflectionBuff();
if (buff != null && buff.ReflectedLevel >= Spell.CurrentLevel && Spell.Template.Id != 0)
{
NotifySpellReflected(actor);
damage.Source = Caster;
damage.ReflectedDamages = true;
Caster.InflictDamage(damage);
actor.RemoveBuff(buff);
}
else
{
actor.InflictDamage(damage);
}
}
}
return(true);
}
protected override bool InternalApply()
{
foreach (var actor in GetAffectedActors())
{
if (Effect.Duration != 0 || Effect.Delay != 0)
{
AddTriggerBuff(actor, BuffTriggerType.Instant, OnBuffTriggered);
}
else
{
var damages = new Fights.Damage(Dice)
{
Source = Caster,
IgnoreDamageReduction = true,
IgnoreDamageBoost = true,
School = GetEffectSchool(Dice.EffectId),
MarkTrigger = MarkTrigger,
IsCritical = Critical,
Amount = (int)Math.Floor((actor.Stats.Health.PermanentDamages * Dice.DiceNum) / 100d)
};
if (Effect.EffectId == EffectsEnum.Effect_DamageNeutralPerCasterHPEroded ||
Effect.EffectId == EffectsEnum.Effect_DamageEarthPerCasterHPEroded ||
Effect.EffectId == EffectsEnum.Effect_DamageFirePerCasterHPEroded ||
Effect.EffectId == EffectsEnum.Effect_DamageWaterPerCasterHPEroded ||
Effect.EffectId == EffectsEnum.Effect_DamageAirPerCasterHPEroded)
{
damages.Amount = (int)Math.Floor((Caster.Stats.Health.PermanentDamages * Dice.DiceNum) / 100d);
}
actor.InflictDamage(damages);
}
}
return(true);
}
void OnBuffTriggered(TriggerBuff buff, FightActor triggerrer, BuffTriggerType trigger, object token)
{
var usedAP = buff.Target.UsedAP;
if (usedAP <= 0)
{
return;
}
var damages = new Fights.Damage(Dice)
{
Source = buff.Caster,
Buff = buff,
School = GetEffectSchool(buff.Dice.EffectId),
MarkTrigger = MarkTrigger,
IsCritical = Critical,
Spell = buff.Spell
};
damages.GenerateDamages();
damages.Amount = usedAP * damages.BaseMaxDamages;
buff.Target.InflictDamage(damages);
}
protected override bool InternalApply()
{
var integerEffect = GenerateEffect();
if (integerEffect == null)
{
return(false);
}
var actors = new List <FightActor>();
if (Pull)
{
actors = GetAffectedActors().OrderBy(entry => entry.Position.Point.ManhattanDistanceTo(TargetedPoint)).ToList();
}
else
{
actors = GetAffectedActors().OrderByDescending(entry => entry.Position.Point.ManhattanDistanceTo(TargetedPoint)).ToList();
}
foreach (var actor in actors)
{
if (!actor.CanBePushed())
{
continue;
}
var referenceCell = TargetedCell.Id == actor.Cell.Id ? CastPoint : TargetedPoint;
if (referenceCell.CellId == actor.Position.Cell.Id)
{
continue;
}
var pushDirection = Pull ? actor.Position.Point.OrientationTo(referenceCell) : referenceCell.OrientationTo(actor.Position.Point);
if (PushDirection != null)
{
pushDirection = PushDirection.Value;
}
var startCell = actor.Position.Point;
var lastCell = startCell;
if (Distance == 0)
{
Distance = (short)(pushDirection.IsDiagonal() ? Math.Ceiling(integerEffect.Value / 2.0) : integerEffect.Value);
}
var stopCell = startCell.GetCellInDirection(pushDirection, Distance);
for (var i = 0; i < Distance; i++)
{
var nextCell = lastCell.GetNearestCellInDirection(pushDirection);
// the next cell is blocking, or an adjacent cell is blocking if it's in diagonal
if (IsBlockingCell(nextCell, actor) ||
(pushDirection.IsDiagonal() && pushDirection.GetDiagonalDecomposition().Any(x => IsBlockingCell(lastCell.GetNearestCellInDirection(x), actor))))
{
if (nextCell == null)
{
stopCell = lastCell;
nextCell = stopCell;
}
if (Fight.ShouldTriggerOnMove(Fight.Map.Cells[nextCell.CellId], actor))
{
DamagesDisabled = true;
stopCell = nextCell;
}
else
{
stopCell = lastCell;
}
break;
}
if (nextCell != null)
{
lastCell = nextCell;
}
}
if (actor.IsAlive())
{
foreach (var character in Fight.GetCharactersAndSpectators().Where(actor.IsVisibleFor))
{
ActionsHandler.SendGameActionFightSlideMessage(character.Client, Caster, actor, startCell.CellId, stopCell.CellId);
}
}
if (!DamagesDisabled)
{
var fightersInline = Fight.GetAllFightersInLine(startCell, Distance, pushDirection);
fightersInline.Insert(0, actor);
var distance = integerEffect.Value - startCell.ManhattanDistanceTo(stopCell);
var targets = 0;
foreach (var fighter in fightersInline)
{
var pushDamages = Formulas.FightFormulas.CalculatePushBackDamages(Caster, fighter, (int)distance, targets);
if (pushDamages > 0)
{
var pushDamage = new Fights.Damage(pushDamages)
{
Source = actor,
School = EffectSchoolEnum.Pushback,
IgnoreDamageBoost = true,
IgnoreDamageReduction = false
};
fighter.InflictDamage(pushDamage);
}
targets++;
}
}
if (actor.IsCarrying() && stopCell != startCell)
{
actor.ThrowActor(Map.Cells[startCell.CellId], true);
}
actor.Position.Cell = Map.Cells[stopCell.CellId];
if (Effect.EffectId != EffectsEnum.Effect_PullForward)
{
actor.TriggerBuffs(Caster, BuffTriggerType.OnPushed);
}
actor.TriggerBuffs(Caster, BuffTriggerType.OnMoved);
}
return(true);
}
