private async void ProcessArea(Creature creature, Skill skill, Targeting targeting, TargetingArea area,
Projectile projectile = null)
{
try
{
bool isProjectileSkill = skill.Type == SkillType.Projectile || skill.Type == SkillType.Userslug;
int skillId = creature.Attack.Args.SkillId;
if (isProjectileSkill)
{
skillId += 20;
}
if (targeting.Time > 0)
{
await Task.Delay((int)(targeting.Time / skill.TimeRate));
}
int elapsed = targeting.Time;
Player player = creature as Player;
do
{
try
{
if (creature.LifeStats.IsDead())
{
return;
}
if (area.DropItem != null)
{
creature.Instance.AddDrop(new Item
{
Owner = player,
ItemId = (int)area.DropItem,
Count = 1,
Position = Geom.ForwardPosition(creature.Position, 40),
Instance = player.Instance,
});
}
Point3D center =
projectile != null
? projectile.Position.ToPoint3D()
: Geom.GetNormal(creature.Position.Heading)
.Multiple(area.OffsetDistance)
.Add(creature.Position);
int count = 0;
List <Creature> targets =
creature.Attack.Args.Targets.Count > 0
? creature.Attack.Args.Targets
: VisibleService.FindTargets(creature,
center,
projectile != null
? projectile.AttackDistance
: area.MaxRadius,
area.Type);
foreach (Creature target in targets)
{
if (target != creature && //Ignore checks for self-target
!isProjectileSkill &&
!creature.Attack.Args.IsItemSkill)
{
if (center.DistanceTo(target.Position) < area.MinRadius - 40)
{
continue;
}
if (center.DistanceTo(target.Position) > area.MaxRadius)
{
continue;
}
short diff = Geom.GetAngleDiff(creature.Attack.Args.StartPosition.Heading,
Geom.GetHeading(center, target.Position));
//diff from 0 to 180
//area.RangeAngel from 0 to 360
if (diff * 2 > (creature.Attack.Args.IsTargetAttack ? 90 : Math.Abs(area.RangeAngle) + 10))
{
continue;
}
}
if (skill.TotalAtk > 0)
{
int damage = SeUtils.CalculateDamage(creature, target, skill.TotalAtk * area.Effect.Atk);
AttackResult result
= new AttackResult
{
AttackType = AttackType.Normal,
AttackUid = creature.Attack.UID,
Damage = damage,
Target = target,
};
result.AngleDif = Geom.GetAngleDiff(creature.Attack.Args.StartPosition.Heading, result.Target.Position.Heading);
SeUtils.UpdateAttackResult(creature, result);
if (result.AttackType == AttackType.Block)
{
VisibleService.Send(target, new SpAttackShowBlock(target, skillId));
}
VisibleService.Send(target, new SpAttackResult(creature, skillId, result));
AiLogic.OnAttack(creature, target);
AiLogic.OnAttacked(target, creature, result.Damage);
if (target is Player && ((Player)target).Duel != null && player != null &&
((Player)target).Duel.Equals(player.Duel) &&
target.LifeStats.GetHpDiffResult(damage) < 1)
{
DuelService.FinishDuel(player);
}
else
{
CreatureLogic.HpChanged(target, target.LifeStats.MinusHp(result.Damage));
}
}
if (area.Effect.HpDiff > 0)
{
AttackResult result = new AttackResult {
HpDiff = area.Effect.HpDiff, Target = target
};
PassivityProcessor.OnHeal(player, result);
if (target is Player)
{
PassivityProcessor.OnHealed((Player)target, result);
}
CreatureLogic.HpChanged(target, target.LifeStats.PlusHp(result.HpDiff),
creature);
}
if (area.Effect.MpDiff > 0)
{
CreatureLogic.MpChanged(target, target.LifeStats.PlusMp(area.Effect.MpDiff), creature);
}
if (area.Effect.AbnormalityOnCommon != null)
{
for (int i = 0; i < area.Effect.AbnormalityOnCommon.Count; i++)
{
AbnormalityProcessor.AddAbnormality(target, area.Effect.AbnormalityOnCommon[i],
creature);
}
}
if (player != null)
{
DuelService.ProcessDamage(player);
//MP regen on combo skill
if (skill.Id / 10000 == 1 && player.GameStats.CombatMpRegen > 0)
{
CreatureLogic.MpChanged(player, player.LifeStats.PlusMp(
player.MaxMp * player.GameStats.CombatMpRegen / 200));
}
}
if (++count == area.MaxCount)
{
break;
}
}
}
catch (Exception ex)
{
Logger.WriteLine(LogState.Exception, "SkillEngine: ProcessAreaExc: " + ex);
}
if (targeting.Interval > 0)
{
await Task.Delay((int)(targeting.Interval / skill.TimeRate));
elapsed += targeting.Interval;
}
} while (targeting.Interval > 0 && elapsed < targeting.Until);
}
catch (Exception ex)
{
Logger.WriteLine(LogState.Exception, "SkillEngine: ProcessArea: " + ex);
}
}
private static TargetingArea ParseTargetingArea(Dictionary <string, object> data)
{
TargetingArea area = new TargetingArea();
if (data.ContainsKey("type"))
{
area.Type = (TargetingAreaType)Enum.Parse(
typeof(TargetingAreaType), data["type"].ToString().Replace("_", ""), true);
}
else
{
area.Type = TargetingAreaType.EnemyOrPvP;
}
if (data.ContainsKey("rotateAngle"))
{
area.RotateAngle = float.Parse(data["rotateAngle"].ToString());
}
if (data.ContainsKey("maxHeight"))
{
area.MaxHeight = float.Parse(data["maxHeight"].ToString());
}
if (data.ContainsKey("crosshairRadius"))
{
area.CrosshairRadius = float.Parse(data["crosshairRadius"].ToString());
}
if (data.ContainsKey("maxCount"))
{
area.MaxCount = int.Parse(data["maxCount"].ToString());
}
if (data.ContainsKey("maxRadius"))
{
area.MaxRadius = float.Parse(data["maxRadius"].ToString());
}
if (data.ContainsKey("minHeight"))
{
area.MinHeight = float.Parse(data["minHeight"].ToString());
}
if (data.ContainsKey("minRadius"))
{
area.MinRadius = float.Parse(data["minRadius"].ToString());
}
if (data.ContainsKey("offsetAngle"))
{
area.OffsetAngle = float.Parse(data["offsetAngle"].ToString());
}
if (data.ContainsKey("offsetDistance"))
{
area.OffsetDistance = float.Parse(data["offsetDistance"].ToString());
}
if (data.ContainsKey("pierceDepth"))
{
area.PierceDepth = int.Parse(data["pierceDepth"].ToString());
}
if (data.ContainsKey("rangeAngle"))
{
area.RangeAngle = float.Parse(data["rangeAngle"].ToString());
}
if (data.ContainsKey("crosshairRadius2"))
{
area.CrosshairRadius2 = float.Parse(data["crosshairRadius2"].ToString());
}
area.Effect = ParseAreaEffect(((List <Dictionary <string, object> >)data["Effect"])[0]);
//HitEffect
if (data.ContainsKey("Reaction"))
{
Dictionary <string, object> reactionData = ((List <Dictionary <string, object> >)data["Reaction"])[0];
area.ReactionBasicRate = float.Parse(reactionData["basicRate"].ToString());
area.ReactionMiniRate = float.Parse(reactionData["miniRate"].ToString());
}
return(area);
}