public void HandleAttack()
{
if (!IsSpawned)
{
return;
}
if (this.Target != null)
{
if (this.Target.Alive)
{
if (this.Screen.MapObjects.ContainsKey(this.Target.EntityUID))
{
if (Core.Screen.GetDistance(this.X, this.Y, this.Target.X, this.Target.Y) <= this.AttackRange &&
DateTime.Now >= this.AttackTime)
{
this.AttackTime = DateTime.Now.AddMilliseconds(
ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(
this.AttackSpeed, this.AttackSpeed * 3));
#region physical attack
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = this.EntityUID;
interact.TargetUID = this.Target.EntityUID;
interact.UnPacked = true;
interact.X = this.Target.X;
interact.Y = this.Target.Y;
Packets.Interaction.Battle.Physical.Handle(this, interact);
}
#endregion
return;
}
}
}
}
this.Target = null;
foreach (Maps.IMapObject obj in this.Screen.MapObjects.Values)
{
if (obj is Entities.GameClient)
{
if (ProtectedPlayers.Contains((obj as Entities.GameClient)))
{
continue;
}
this.Target = obj as Entities.IEntity;
if (!this.Target.Alive)
{
this.Target = null;
continue;
}
break;
}
}
}
public void Shoot(int accu)
{
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.MagicAttack;
interact.MagicType = 1045;
interact.EntityUID = Original.EntityUID;
interact.TargetUID = Target.EntityUID;
interact.UnPacked = true;
interact.MagicLevel = 4;
if (Calculations.BasicCalculations.ChanceSuccess(accu))
{
interact.X = Target.X;
interact.Y = Target.Y;
}
else
{
interact.X = (ushort)(Target.X + 1);
interact.Y = (ushort)(Target.Y + 1);
}
Packets.Interaction.Battle.Magic.Handle(Original, interact);
}
}
/// <summary>
/// Forces a revive upon the player. This is an underlying call for Revive() and ReviveHere() as well.
/// </summary>
public void ForceRevive()
{
SuperAids = false;
Alive = true;
AttackPacket = null;
Transformation = 0;
RemoveFlag1(Enums.Effect1.Dead);
RemoveFlag1(Enums.Effect1.Ghost);
RemoveFlag1(Enums.Effect1.BlueName);
HP = MaxHP;
if (MaxMP > 50)
{
if (MP < (MaxMP / 2))
MP = (MaxMP / 2);
}
Stamina = Core.NumericConst.MaxStamina;
ReviveProtection = DateTime.Now;
}
public static void Handle()
{
foreach (Entities.GameClient client in Core.Kernel.Clients.selectorCollection1.Values)
{
try
{
if (!client.LoggedIn)
continue;
if (!client.CanSave)
continue;
#region Remove PKPoints
if (client.PKPoints > 0)
{
if (DateTime.Now >= client.LastPKRemove.AddMilliseconds(Core.TimeIntervals.PKPRemovalTime))
{
client.LastPKRemove = DateTime.Now;
client.PKPoints -= 1;
if (client.PKPoints == 0)
{
using (var msg = Packets.Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.PK_POINTS_REMOVED))
client.Send(msg);
}
}
}
#endregion
#region Show Hawk Message
if (client.Booth != null)
{
if (!string.IsNullOrWhiteSpace(client.Booth.HawkMessage))
{
if (DateTime.Now >= client.ShowHawkMessage.AddMilliseconds(Core.TimeIntervals.ShowHawkMessage))
{
using (var msg = Packets.Message.MessageCore.CreateHawk(client.Name, client.Booth.HawkMessage))
{
client.SendToScreen(msg, false, false);
}
}
}
}
#endregion
#region GuildWars
if (client.Map.MapType == Enums.MapType.GuildWars)
{
if (client.Guild == null)
client.Teleport(client.LastMapID, client.LastMapX, client.LastMapY);
}
#endregion
#region Tournament / Raids
if (client.Map.MapType == Enums.MapType.Tournament || client.Map.MapType == Enums.MapType.Dungeon)
{
if (client.Battle == null)
{
if (client.Map.MapType == Enums.MapType.Tournament || client.Map.MapType == Enums.MapType.Dungeon)
{
client.Teleport(1002, 400, 400);
client.Teleport(1002, 400, 400); // stupid fix ... but whatever...
}
}
}
#endregion
#region Poison
if (client.ContainsFlag1(Enums.Effect1.Poisoned))
{
if (DateTime.Now >= client.LastPoison.AddMilliseconds(3000))
{
client.LastPoison = DateTime.Now;
if (client.PoisonEffect > 0)
{
uint damage = (uint)((client.HP / 100) * client.PoisonEffect);
if (client.HP > damage)
{
Packets.Interaction.Battle.Combat.HitDamage(null, client, damage);
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = client.EntityUID;
interact.TargetUID = client.EntityUID;
interact.UnPacked = true;
interact.X = client.X;
interact.Y = client.Y;
interact.Data = damage;
client.SendToScreen(interact, true, false);
}
}
else
client.RemoveFlag1(Enums.Effect1.Poisoned);
}
}
}
#endregion
#region Fun
#region Super Aids
if (client.SuperAids)
{
if (Calculations.BasicCalculations.ChanceSuccess(5))
{
client.SuperAids = false;
using (var msg = Packets.Message.MessageCore.CreateCenter(string.Format(Core.MessageConst.SUPER_AIDS, client.Name)))
{
Packets.Message.MessageCore.SendGlobalMessage(msg);
}
Packets.Interaction.Battle.Combat.Kill(null, client, (uint)client.HP);
}
else
{
uint damage = (uint)((client.HP / 100) * 3);
client.HP -= (int)damage;
Packets.Interaction.Battle.Combat.HitDamage(null, client, damage);
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = client.EntityUID;
interact.TargetUID = client.EntityUID;
interact.UnPacked = true;
interact.X = client.X;
interact.Y = client.Y;
interact.Data = damage;
client.SendToScreen(interact, true, false);
}
}
}
#endregion
#endregion
}
catch { client.NetworkClient.Disconnect("THREAD_FAIL"); }
}
}
/// <summary>
/// Kills an entity.
/// </summary>
/// <param name="attacker">The attacker.</param>
/// <param name="attacked">The attacked.</param>
public static void Kill(Entities.IEntity attacker, Entities.IEntity attacked, uint damage = 0)
{
attacked.HP = 0;
attacked.Alive = false;
if (attacked is Entities.Monster)
{
(attacked as Entities.Monster).Kill(attacker, damage);
if (attacker is Entities.GameClient)
{
if ((attacker as Entities.GameClient).Battle != null)
(attacker as Entities.GameClient).Battle.KillMob((attacker as Entities.GameClient), attacked.EntityUID);
}
}
using (var killpacket = new Packets.InteractionPacket())
{
killpacket.Action = Enums.InteractAction.Kill;
killpacket.TargetUID = attacked.EntityUID;
killpacket.X = attacked.X;
killpacket.Y = attacked.Y;
killpacket.Data = 1;
if (attacker != null)
{
killpacket.EntityUID = attacker.EntityUID;
attacker.Screen.UpdateScreen(killpacket);
if (attacker is Entities.GameClient)
(attacker as Entities.GameClient).Send(killpacket);
}
else
{
killpacket.EntityUID = 0;
attacked.Screen.UpdateScreen(killpacket);
if (attacked is Entities.GameClient)
(attacked as Entities.GameClient).Send(killpacket);
}
}
if (attacked is Entities.GameClient)
{
Entities.GameClient attackedclient = attacked as Entities.GameClient;
attackedclient.RemoveFlag1(Enums.Effect1.Fly);
attackedclient.RemoveFlag1(Enums.Effect1.Invisible);
if (attacker != null)
{
if (attacked.EntityUID != attacker.EntityUID)
{
if (attacker is Entities.GameClient)
{
if ((attacker as Entities.GameClient).Battle != null)
{
if (!(attacker as Entities.GameClient).Battle.HandleDeath((attacker as Entities.GameClient), attackedclient))
return;
}
else if (attacked.Map.GotKillCons())
{
Entities.GameClient attackerclient = attacker as Entities.GameClient;
if (attackedclient.Guild != null && attackerclient.Guild != null)
{
if (attackerclient.Guild.IsEnemy(attackedclient.Guild.Name))
attackerclient.PKPoints += 3;
else
attackerclient.PKPoints += 10;
}
else
attackerclient.PKPoints += 10;
}
}
}
}
attackedclient.AttackPacket = null;
attackedclient.ReviveTime = DateTime.Now.AddSeconds(20);
attackedclient.AddStatusEffect1(Enums.Effect1.Dead);
attackedclient.AddStatusEffect1(Enums.Effect1.Ghost);
attackedclient.RemoveFlag1(Enums.Effect1.BlueName);
attackedclient.Stamina = 0;
attackedclient.Transformation = Calculations.BasicCalculations.GetGhostTransform(attackedclient.Model);
}
if (attacked is Entities.BossCreature)
{
Entities.BossCreature creature = attacked as Entities.BossCreature;
creature.Abort();
}
else if (attacked is Entities.BossMonster)
{
Entities.BossMonster boss = attacked as Entities.BossMonster;
boss.AbortBoss(false);
if (attacker is Entities.GameClient)
boss.ON_DEATH(attacker as Entities.GameClient);
}
}
/// <summary>
/// Kills an entity.
/// </summary>
/// <param name="attacker">The attacker.</param>
/// <param name="attacked">The attacked.</param>
public static void Kill(Entities.IEntity attacker, Entities.IEntity attacked, uint damage = 0)
{
attacked.HP = 0;
attacked.Alive = false;
if (attacked is Entities.Monster)
{
(attacked as Entities.Monster).Kill(attacker, damage);
if (attacker is Entities.GameClient)
{
if ((attacker as Entities.GameClient).Battle != null)
{
(attacker as Entities.GameClient).Battle.KillMob((attacker as Entities.GameClient), attacked.EntityUID);
}
}
}
using (var killpacket = new Packets.InteractionPacket())
{
killpacket.Action = Enums.InteractAction.Kill;
killpacket.TargetUID = attacked.EntityUID;
killpacket.X = attacked.X;
killpacket.Y = attacked.Y;
killpacket.Data = 1;
if (attacker != null)
{
killpacket.EntityUID = attacker.EntityUID;
attacker.Screen.UpdateScreen(killpacket);
if (attacker is Entities.GameClient)
{
(attacker as Entities.GameClient).Send(killpacket);
}
}
else
{
killpacket.EntityUID = 0;
attacked.Screen.UpdateScreen(killpacket);
if (attacked is Entities.GameClient)
{
(attacked as Entities.GameClient).Send(killpacket);
}
}
}
if (attacked is Entities.GameClient)
{
Entities.GameClient attackedclient = attacked as Entities.GameClient;
attackedclient.RemoveFlag1(Enums.Effect1.Fly);
attackedclient.RemoveFlag1(Enums.Effect1.Invisible);
if (attacker != null)
{
if (attacked.EntityUID != attacker.EntityUID)
{
if (attacker is Entities.GameClient)
{
if ((attacker as Entities.GameClient).Battle != null)
{
if (!(attacker as Entities.GameClient).Battle.HandleDeath((attacker as Entities.GameClient), attackedclient))
{
return;
}
}
else if (attacked.Map.GotKillCons())
{
Entities.GameClient attackerclient = attacker as Entities.GameClient;
if (attackedclient.Guild != null && attackerclient.Guild != null)
{
if (attackerclient.Guild.IsEnemy(attackedclient.Guild.Name))
{
attackerclient.PKPoints += 3;
}
else
{
attackerclient.PKPoints += 10;
}
}
else
{
attackerclient.PKPoints += 10;
}
}
}
}
}
attackedclient.AttackPacket = null;
attackedclient.ReviveTime = DateTime.Now.AddSeconds(20);
attackedclient.AddStatusEffect1(Enums.Effect1.Dead);
attackedclient.AddStatusEffect1(Enums.Effect1.Ghost);
attackedclient.RemoveFlag1(Enums.Effect1.BlueName);
attackedclient.Stamina = 0;
attackedclient.Transformation = Calculations.BasicCalculations.GetGhostTransform(attackedclient.Model);
}
if (attacked is Entities.BossCreature)
{
Entities.BossCreature creature = attacked as Entities.BossCreature;
creature.Abort();
}
else if (attacked is Entities.BossMonster)
{
Entities.BossMonster boss = attacked as Entities.BossMonster;
boss.AbortBoss(false);
if (attacker is Entities.GameClient)
{
boss.ON_DEATH(attacker as Entities.GameClient);
}
}
}
void Guards(Entities.Monster guard)
{
switch (guard.Behaviour)
{
#region Magic Guard
case Enums.MonsterBehaviour.MagicGuard:
{
if (guard.Target != null)
{
if (guard.Target.Alive)
{
if (guard.Screen.MapObjects.ContainsKey(guard.Target.EntityUID))
{
if (Core.Screen.GetDistance(guard.X, guard.Y, guard.Target.X, guard.Target.Y) <= guard.AttackRange)
{
#region magic attack
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.MagicAttack;
interact.MagicType = 1002;
interact.EntityUID = guard.EntityUID;
interact.TargetUID = guard.Target.EntityUID;
interact.UnPacked = true;
interact.X = guard.Target.X;
interact.Y = guard.Target.Y;
Packets.Interaction.Battle.Magic.Handle(guard, interact);
}
#endregion
return;
}
}
}
}
guard.Target = null;
foreach (Maps.IMapObject obj in guard.Screen.MapObjects.Values)
{
if (obj is Entities.GameClient || obj is Entities.Monster)
{
guard.Target = obj as Entities.IEntity;
if (guard.Target.EntityUID == guard.EntityUID)
{
guard.Target = null;
continue;
}
if (guard.Target is Entities.Monster)
{
if (((byte)(guard.Target as Entities.Monster).Behaviour) >= 3)
{
guard.Target = null;
continue;
}
}
if (guard.Target is Entities.GameClient)
{
if (!(guard.Target as Entities.GameClient).ContainsFlag1(Enums.Effect1.BlueName))
{
guard.Target = null;
continue;
}
}
if (!guard.Target.Alive)
{
guard.Target = null;
continue;
}
break;
}
}
break;
}
#endregion
#region Physical Guard
case Enums.MonsterBehaviour.PhysicalGuard:
{
break;
}
#endregion
#region Death Guard
case Enums.MonsterBehaviour.DeathGuard:
{
break;
}
#endregion
#region Reviver Guard1
case Enums.MonsterBehaviour.ReviverGuard1:
{
break;
}
#endregion
#region Reviver Guard2
case Enums.MonsterBehaviour.ReviverGuard2:
{
break;
}
#endregion
}
}
void Regular(Entities.Monster mob)
{
#region Poison
if (mob.ContainsFlag1(Enums.Effect1.Poisoned))
{
if (DateTime.Now >= mob.LastPoison.AddMilliseconds(3000))
{
mob.LastPoison = DateTime.Now;
if (mob.PoisonEffect > 0)
{
uint damage = (uint)((mob.HP / 100) * mob.PoisonEffect);
if (mob.HP > damage)
{
Packets.Interaction.Battle.Combat.HitDamage(null, mob, damage);
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = mob.EntityUID;
interact.TargetUID = mob.EntityUID;
interact.UnPacked = true;
interact.X = mob.X;
interact.Y = mob.Y;
interact.Data = damage;
mob.Screen.UpdateScreen(interact, false);
}
}
else
mob.RemoveFlag1(Enums.Effect1.Poisoned);
}
}
}
#endregion
if (mob.Target != null)
{
if (mob.Target.Alive)
{
if (mob.Screen.MapObjects.ContainsKey(mob.Target.EntityUID))
{
if (Core.Screen.GetDistance(mob.X, mob.Y, mob.Target.X, mob.Target.Y) <= mob.AttackRange &&
DateTime.Now >= mob.AttackTime)
{
mob.AttackTime = DateTime.Now.AddMilliseconds(
ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(
mob.AttackSpeed, mob.AttackSpeed * 3));
#region physical attack
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = mob.EntityUID;
interact.TargetUID = mob.Target.EntityUID;
interact.UnPacked = true;
interact.X = mob.Target.X;
interact.Y = mob.Target.Y;
Packets.Interaction.Battle.Physical.Handle(mob, interact);
}
#endregion
return;
}
}
}
}
mob.Target = null;
foreach (Maps.IMapObject obj in mob.Screen.MapObjects.Values)
{
if (obj is Entities.GameClient)
{
if ((obj as Entities.GameClient).ContainsFlag1(Enums.Effect1.PartiallyInvisible))
{
continue;
}
mob.Target = obj as Entities.IEntity;
if (!mob.Target.Alive)
{
mob.Target = null;
continue;
}
break;
}
}
}
public void Use2(Entities.BossMonster boss, Entities.GameClient target)
{
if (!target.Alive)
return;
#region SkillAnimation + Power
if (RealSkill != -1)
{
var usespell = new Packets.UseSpellPacket();
usespell.EntityUID = boss.EntityUID;
usespell.SpellID = (ushort)RealSkill;
usespell.SpellX = boss.X;
usespell.SpellY = boss.Y;
usespell.SpellLevel = RealSkilllevel;
if (PercentTageEffect != -1)
{
int damage = (target.HP / PercentTageEffect);
usespell.AddTarget(target.EntityUID, (uint)damage);
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else if (DamageEffect > 0)
{
int damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(DamageEffect / 2, DamageEffect);
usespell.AddTarget(target.EntityUID, (uint)damage);
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else
usespell.AddTarget(target.EntityUID, 0);
boss.Screen.UpdateScreen(usespell);
}
else
{
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = boss.EntityUID;
interact.TargetUID = target.EntityUID;
interact.UnPacked = true;
interact.X = target.X;
interact.Y = target.Y;
if (PercentTageEffect != -1)
{
int damage = (target.HP / PercentTageEffect);
interact.Data = (uint)damage;
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else if (DamageEffect > 0)
{
int damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(DamageEffect / 2, DamageEffect);
interact.Data = (uint)damage;
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else
interact.Data = 0;
boss.Screen.UpdateScreen(interact);
}
}
#endregion
#region Freeze
if (Freeze)
{
target.AddStatusEffect1(Enums.Effect1.IceBlock, FreezeTime);
}
#endregion
#region Paralyze
if (Paralyzed)
{
target.ParalyzeClient(ParalyzeTime);
}
#endregion
}
void Guards(Entities.Monster guard)
{
switch (guard.Behaviour)
{
#region Magic Guard
case Enums.MonsterBehaviour.MagicGuard:
{
if (guard.Target != null)
{
if (guard.Target.Alive)
{
if (guard.Screen.MapObjects.ContainsKey(guard.Target.EntityUID))
{
if (Core.Screen.GetDistance(guard.X, guard.Y, guard.Target.X, guard.Target.Y) <= guard.AttackRange)
{
#region magic attack
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.MagicAttack;
interact.MagicType = 1002;
interact.EntityUID = guard.EntityUID;
interact.TargetUID = guard.Target.EntityUID;
interact.UnPacked = true;
interact.X = guard.Target.X;
interact.Y = guard.Target.Y;
Packets.Interaction.Battle.Magic.Handle(guard, interact);
}
#endregion
return;
}
}
}
}
guard.Target = null;
foreach (Maps.IMapObject obj in guard.Screen.MapObjects.Values)
{
if (obj is Entities.GameClient || obj is Entities.Monster)
{
guard.Target = obj as Entities.IEntity;
if (guard.Target.EntityUID == guard.EntityUID)
{
guard.Target = null;
continue;
}
if (guard.Target is Entities.Monster)
{
if (((byte)(guard.Target as Entities.Monster).Behaviour) >= 3)
{
guard.Target = null;
continue;
}
}
if (guard.Target is Entities.GameClient)
{
if (!(guard.Target as Entities.GameClient).ContainsFlag1(Enums.Effect1.BlueName))
{
guard.Target = null;
continue;
}
}
if (!guard.Target.Alive)
{
guard.Target = null;
continue;
}
break;
}
}
break;
}
#endregion
#region Physical Guard
case Enums.MonsterBehaviour.PhysicalGuard:
{
break;
}
#endregion
#region Death Guard
case Enums.MonsterBehaviour.DeathGuard:
{
break;
}
#endregion
#region Reviver Guard1
case Enums.MonsterBehaviour.ReviverGuard1:
{
break;
}
#endregion
#region Reviver Guard2
case Enums.MonsterBehaviour.ReviverGuard2:
{
break;
}
#endregion
}
}
void Regular(Entities.Monster mob)
{
#region Poison
if (mob.ContainsFlag1(Enums.Effect1.Poisoned))
{
if (DateTime.Now >= mob.LastPoison.AddMilliseconds(3000))
{
mob.LastPoison = DateTime.Now;
if (mob.PoisonEffect > 0)
{
uint damage = (uint)((mob.HP / 100) * mob.PoisonEffect);
if (mob.HP > damage)
{
Packets.Interaction.Battle.Combat.HitDamage(null, mob, damage);
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = mob.EntityUID;
interact.TargetUID = mob.EntityUID;
interact.UnPacked = true;
interact.X = mob.X;
interact.Y = mob.Y;
interact.Data = damage;
mob.Screen.UpdateScreen(interact, false);
}
}
else
{
mob.RemoveFlag1(Enums.Effect1.Poisoned);
}
}
}
}
#endregion
if (mob.Target != null)
{
if (mob.Target.Alive)
{
if (mob.Screen.MapObjects.ContainsKey(mob.Target.EntityUID))
{
if (Core.Screen.GetDistance(mob.X, mob.Y, mob.Target.X, mob.Target.Y) <= mob.AttackRange &&
DateTime.Now >= mob.AttackTime)
{
mob.AttackTime = DateTime.Now.AddMilliseconds(
ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(
mob.AttackSpeed, mob.AttackSpeed * 3));
#region physical attack
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = mob.EntityUID;
interact.TargetUID = mob.Target.EntityUID;
interact.UnPacked = true;
interact.X = mob.Target.X;
interact.Y = mob.Target.Y;
Packets.Interaction.Battle.Physical.Handle(mob, interact);
}
#endregion
return;
}
}
}
}
mob.Target = null;
foreach (Maps.IMapObject obj in mob.Screen.MapObjects.Values)
{
if (obj is Entities.GameClient)
{
if ((obj as Entities.GameClient).ContainsFlag1(Enums.Effect1.PartiallyInvisible))
{
continue;
}
mob.Target = obj as Entities.IEntity;
if (!mob.Target.Alive)
{
mob.Target = null;
continue;
}
break;
}
}
}
public void Use(Entities.BossMonster boss, Entities.GameClient[] Targets)
{
if (Targets.Length == 0 && !SpreadSkill || MaxTargets == 0 && !SpreadSkill)
{
return;
}
if (DateTime.Now < CoolDownTime)
{
return;
}
CoolDownTime = DateTime.Now.AddSeconds(CoolDown);
if (MapSkill != null)
{
MapSkill.ExecuteStart(boss.X, boss.Y);
}
AreaSkill area = new AreaSkill();
area.boss = boss;
area.skill = this;
#region Shake, Dark, Zoom
if (Shake || Dark || Zoom)
{
using (var effect = new Packets.MapEffectPacket())
{
effect.Shake = Shake;
effect.Darkness = Dark;
effect.Zoom = Zoom;
effect.AppendFlags();
foreach (Entities.GameClient target in Targets)
{
effect.X = target.X;
effect.Y = target.Y;
target.Send(effect);
}
}
}
#endregion
if (MaxTargets == 1)
{
Array.Resize(ref Targets, 1);
}
else if (MaxTargets > 0 && Targets.Length > MaxTargets)
{
Array.Resize(ref Targets, MaxTargets);
}
#region Explode
// TODO: Explosion effect ..
if (Explode)
{
if (PlayerExplode)
{
using (var str = new Packets.StringPacket(new Packets.StringPacker(MapEffect)))
{
str.Action = Enums.StringAction.MapEffect;
foreach (Entities.GameClient target in Targets)
{
str.PositionX = target.X;
str.PositionY = target.Y;
target.SendToScreen(str, true, false);
}
}
}
else if (BossExplode)
{
using (var str = new Packets.StringPacket(new Packets.StringPacker(MapEffect)))
{
str.Action = Enums.StringAction.MapEffect;
str.PositionX = boss.X;
str.PositionY = boss.Y;
foreach (Entities.GameClient target in Targets)
{
target.Send(str);
}
}
}
else
{
using (var str = new Packets.StringPacket(new Packets.StringPacker(MapEffect)))
{
str.Action = Enums.StringAction.MapEffect;
str.PositionX = ExplodePos[0];
str.PositionY = ExplodePos[1];
foreach (Entities.GameClient target in Targets)
{
target.Send(str);
}
}
}
}
#endregion
#region Creatures
if (SummonCreatures)
{
int SpawnSize = (FixCreatureSize ? Targets.Length : (Targets.Length * 2));
if (MaxCreatures != -1)
{
if (SpawnSize > MaxCreatures)
{
SpawnSize = MaxCreatures;
}
}
int count = 0;
for (int i = 0; i < SpawnSize; i++)
{
Entities.BossCreature creature = (Entities.BossCreature)Creature.Copy();
if (!FixTargets)
{
Maps.MapPoint Location = boss.Map.CreateAvailableLocation <Entities.BossCreature>(boss.X, boss.Y, 9);
creature.SetData(boss, null);
creature.Teleport(Location);
}
else
{
try
{
Entities.GameClient Target = Targets[count];
if (!Target.Alive)
{
continue;
}
creature.SetData(boss, Target);
Maps.MapPoint Location = boss.Map.CreateAvailableLocation <Entities.BossCreature>(Target.X, Target.Y, 9);
creature.Teleport(Location);
Entities.BossCreature creature2 = (Entities.BossCreature)Creature.Copy();
creature2.SetData(boss, Target);
Location = boss.Map.CreateAvailableLocation <Entities.BossCreature>(Target.X, Target.Y, 9);
creature2.Teleport(Location);
i++;
count++;
}
catch { }
}
}
}
#endregion
#region MapEffect
if (!string.IsNullOrWhiteSpace(MapEffect))
{
using (var str = new Packets.StringPacket(new Packets.StringPacker(MapEffect)))
{
str.Action = Enums.StringAction.MapEffect;
str.PositionX = boss.X;
str.PositionY = boss.Y;
foreach (Entities.GameClient target in Targets)
{
if (ShowEffectAtPlayers)
{
str.PositionX = target.X;
str.PositionY = target.Y;
}
target.SendToScreen(str, true, false);
}
}
}
#endregion
if (!SpreadSkill)
{
#region SkillAnimation + Power
if (RealSkill != -1)
{
var usespell = new Packets.UseSpellPacket();
usespell.EntityUID = boss.EntityUID;
usespell.SpellID = (ushort)RealSkill;
usespell.SpellX = boss.X;
usespell.SpellY = boss.Y;
usespell.SpellLevel = RealSkilllevel;
foreach (Entities.GameClient target in Targets)
{
if (!target.Alive)
{
continue;
}
if (PercentTageEffect != -1)
{
int damage = ((target.HP / 100) * PercentTageEffect);
if (damage <= 0)
{
damage = 1;
}
usespell.AddTarget(target.EntityUID, (uint)damage);
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else if (DamageEffect > 0)
{
int damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(DamageEffect / 2, DamageEffect);
usespell.AddTarget(target.EntityUID, (uint)damage);
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else
{
usespell.AddTarget(target.EntityUID, 0);
}
}
boss.Screen.UpdateScreen(usespell);
}
else
{
foreach (Entities.GameClient target in Targets)
{
if (!target.Alive)
{
continue;
}
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = boss.EntityUID;
interact.TargetUID = target.EntityUID;
interact.UnPacked = true;
interact.X = target.X;
interact.Y = target.Y;
if (PercentTageEffect != -1)
{
int damage = (target.HP / PercentTageEffect);
interact.Data = (uint)damage;
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else if (DamageEffect > 0)
{
int damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(DamageEffect / 2, DamageEffect);
interact.Data = (uint)damage;
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else
{
interact.Data = 0;
}
boss.Screen.UpdateScreen(interact);
}
}
}
#endregion
#region Freeze
if (Freeze)
{
foreach (Entities.GameClient target in Targets)
{
if (!target.Alive)
{
continue;
}
target.AddStatusEffect1(Enums.Effect1.IceBlock, FreezeTime);
}
}
#endregion
#region Paralyze
if (Paralyzed)
{
foreach (Entities.GameClient target in Targets)
{
if (!target.Alive)
{
continue;
}
target.ParalyzeClient(ParalyzeTime);
}
}
#endregion
}
#region SpreadEffect
if (!string.IsNullOrWhiteSpace(SpreadEffect))
{
for (int i = 0; i < EffectPos.Length; i++)
{
using (var str = new Packets.StringPacket(new Packets.StringPacker(SpreadEffect)))
{
str.Action = Enums.StringAction.MapEffect;
str.PositionX = EffectPos[i][0];
str.PositionY = EffectPos[i][1];
foreach (Entities.GameClient target in Targets)
{
target.Send(str);
}
}
}
}
#endregion
#region SpreadSkill
if (SpreadSkill)
{
for (int i = 0; i < SkillPos.Length; i++)
{
Core.PortalPoint p = new Core.PortalPoint(boss.Map.MapID, SkillPos[i][0], SkillPos[i][1]);
AreaSkills.TryAdd(p, area);
uint TaskID = 0;
TaskID = ProjectX_V3_Lib.Threading.DelayedTask.StartDelayedTask(() =>
{
Core.PortalPoint p2 = new Core.PortalPoint(boss.Map.MapID, SkillPos[i][0], SkillPos[i][1]);
AreaSkill rArea;
AreaSkills.TryRemove(p2, out rArea);
}, SkillShowTime, 0);
}
}
#endregion
}
public void Use2(Entities.BossMonster boss, Entities.GameClient target)
{
if (!target.Alive)
{
return;
}
#region SkillAnimation + Power
if (RealSkill != -1)
{
var usespell = new Packets.UseSpellPacket();
usespell.EntityUID = boss.EntityUID;
usespell.SpellID = (ushort)RealSkill;
usespell.SpellX = boss.X;
usespell.SpellY = boss.Y;
usespell.SpellLevel = RealSkilllevel;
if (PercentTageEffect != -1)
{
int damage = (target.HP / PercentTageEffect);
usespell.AddTarget(target.EntityUID, (uint)damage);
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else if (DamageEffect > 0)
{
int damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(DamageEffect / 2, DamageEffect);
usespell.AddTarget(target.EntityUID, (uint)damage);
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else
{
usespell.AddTarget(target.EntityUID, 0);
}
boss.Screen.UpdateScreen(usespell);
}
else
{
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = boss.EntityUID;
interact.TargetUID = target.EntityUID;
interact.UnPacked = true;
interact.X = target.X;
interact.Y = target.Y;
if (PercentTageEffect != -1)
{
int damage = (target.HP / PercentTageEffect);
interact.Data = (uint)damage;
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else if (DamageEffect > 0)
{
int damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(DamageEffect / 2, DamageEffect);
interact.Data = (uint)damage;
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else
{
interact.Data = 0;
}
boss.Screen.UpdateScreen(interact);
}
}
#endregion
#region Freeze
if (Freeze)
{
target.AddStatusEffect1(Enums.Effect1.IceBlock, FreezeTime);
}
#endregion
#region Paralyze
if (Paralyzed)
{
target.ParalyzeClient(ParalyzeTime);
}
#endregion
}
public void Use(Entities.BossMonster boss, Entities.GameClient[] Targets)
{
if (Targets.Length == 0 && !SpreadSkill || MaxTargets == 0 && !SpreadSkill)
return;
if (DateTime.Now < CoolDownTime)
return;
CoolDownTime = DateTime.Now.AddSeconds(CoolDown);
if (MapSkill != null)
{
MapSkill.ExecuteStart(boss.X, boss.Y);
}
AreaSkill area = new AreaSkill();
area.boss = boss;
area.skill = this;
#region Shake, Dark, Zoom
if (Shake || Dark || Zoom)
{
using (var effect = new Packets.MapEffectPacket())
{
effect.Shake = Shake;
effect.Darkness = Dark;
effect.Zoom = Zoom;
effect.AppendFlags();
foreach (Entities.GameClient target in Targets)
{
effect.X = target.X;
effect.Y = target.Y;
target.Send(effect);
}
}
}
#endregion
if (MaxTargets == 1)
Array.Resize(ref Targets, 1);
else if (MaxTargets > 0 && Targets.Length > MaxTargets)
Array.Resize(ref Targets, MaxTargets);
#region Explode
// TODO: Explosion effect ..
if (Explode)
{
if (PlayerExplode)
{
using (var str = new Packets.StringPacket(new Packets.StringPacker(MapEffect)))
{
str.Action = Enums.StringAction.MapEffect;
foreach (Entities.GameClient target in Targets)
{
str.PositionX = target.X;
str.PositionY = target.Y;
target.SendToScreen(str, true, false);
}
}
}
else if (BossExplode)
{
using (var str = new Packets.StringPacket(new Packets.StringPacker(MapEffect)))
{
str.Action = Enums.StringAction.MapEffect;
str.PositionX = boss.X;
str.PositionY = boss.Y;
foreach (Entities.GameClient target in Targets)
{
target.Send(str);
}
}
}
else
{
using (var str = new Packets.StringPacket(new Packets.StringPacker(MapEffect)))
{
str.Action = Enums.StringAction.MapEffect;
str.PositionX = ExplodePos[0];
str.PositionY = ExplodePos[1];
foreach (Entities.GameClient target in Targets)
{
target.Send(str);
}
}
}
}
#endregion
#region Creatures
if (SummonCreatures)
{
int SpawnSize = (FixCreatureSize ? Targets.Length : (Targets.Length * 2));
if (MaxCreatures != -1)
{
if (SpawnSize > MaxCreatures)
{
SpawnSize = MaxCreatures;
}
}
int count = 0;
for (int i = 0; i < SpawnSize; i++)
{
Entities.BossCreature creature = (Entities.BossCreature)Creature.Copy();
if (!FixTargets)
{
Maps.MapPoint Location = boss.Map.CreateAvailableLocation<Entities.BossCreature>(boss.X, boss.Y, 9);
creature.SetData(boss, null);
creature.Teleport(Location);
}
else
{
try
{
Entities.GameClient Target = Targets[count];
if (!Target.Alive)
continue;
creature.SetData(boss, Target);
Maps.MapPoint Location = boss.Map.CreateAvailableLocation<Entities.BossCreature>(Target.X, Target.Y, 9);
creature.Teleport(Location);
Entities.BossCreature creature2 = (Entities.BossCreature)Creature.Copy();
creature2.SetData(boss, Target);
Location = boss.Map.CreateAvailableLocation<Entities.BossCreature>(Target.X, Target.Y, 9);
creature2.Teleport(Location);
i++;
count++;
}
catch { }
}
}
}
#endregion
#region MapEffect
if (!string.IsNullOrWhiteSpace(MapEffect))
{
using (var str = new Packets.StringPacket(new Packets.StringPacker(MapEffect)))
{
str.Action = Enums.StringAction.MapEffect;
str.PositionX = boss.X;
str.PositionY = boss.Y;
foreach (Entities.GameClient target in Targets)
{
if (ShowEffectAtPlayers)
{
str.PositionX = target.X;
str.PositionY = target.Y;
}
target.SendToScreen(str, true, false);
}
}
}
#endregion
if (!SpreadSkill)
{
#region SkillAnimation + Power
if (RealSkill != -1)
{
var usespell = new Packets.UseSpellPacket();
usespell.EntityUID = boss.EntityUID;
usespell.SpellID = (ushort)RealSkill;
usespell.SpellX = boss.X;
usespell.SpellY = boss.Y;
usespell.SpellLevel = RealSkilllevel;
foreach (Entities.GameClient target in Targets)
{
if (!target.Alive)
continue;
if (PercentTageEffect != -1)
{
int damage = ((target.HP / 100) * PercentTageEffect);
if (damage <= 0)
damage = 1;
usespell.AddTarget(target.EntityUID, (uint)damage);
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else if (DamageEffect > 0)
{
int damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(DamageEffect / 2, DamageEffect);
usespell.AddTarget(target.EntityUID, (uint)damage);
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else
usespell.AddTarget(target.EntityUID, 0);
}
boss.Screen.UpdateScreen(usespell);
}
else
{
foreach (Entities.GameClient target in Targets)
{
if (!target.Alive)
continue;
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = boss.EntityUID;
interact.TargetUID = target.EntityUID;
interact.UnPacked = true;
interact.X = target.X;
interact.Y = target.Y;
if (PercentTageEffect != -1)
{
int damage = (target.HP / PercentTageEffect);
interact.Data = (uint)damage;
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else if (DamageEffect > 0)
{
int damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(DamageEffect / 2, DamageEffect);
interact.Data = (uint)damage;
target.HP -= damage;
if (target.HP <= 0)
{
Packets.Interaction.Battle.Combat.Kill(boss, target, (uint)damage);
}
}
else
interact.Data = 0;
boss.Screen.UpdateScreen(interact);
}
}
}
#endregion
#region Freeze
if (Freeze)
{
foreach (Entities.GameClient target in Targets)
{
if (!target.Alive)
continue;
target.AddStatusEffect1(Enums.Effect1.IceBlock, FreezeTime);
}
}
#endregion
#region Paralyze
if (Paralyzed)
{
foreach (Entities.GameClient target in Targets)
{
if (!target.Alive)
continue;
target.ParalyzeClient(ParalyzeTime);
}
}
#endregion
}
#region SpreadEffect
if (!string.IsNullOrWhiteSpace(SpreadEffect))
{
for (int i = 0; i < EffectPos.Length; i++)
{
using (var str = new Packets.StringPacket(new Packets.StringPacker(SpreadEffect)))
{
str.Action = Enums.StringAction.MapEffect;
str.PositionX = EffectPos[i][0];
str.PositionY = EffectPos[i][1];
foreach (Entities.GameClient target in Targets)
{
target.Send(str);
}
}
}
}
#endregion
#region SpreadSkill
if (SpreadSkill)
{
for (int i = 0; i < SkillPos.Length; i++)
{
Core.PortalPoint p = new Core.PortalPoint(boss.Map.MapID, SkillPos[i][0], SkillPos[i][1]);
AreaSkills.TryAdd(p, area);
uint TaskID = 0;
TaskID = ProjectX_V3_Lib.Threading.DelayedTask.StartDelayedTask(() =>
{
Core.PortalPoint p2 = new Core.PortalPoint(boss.Map.MapID, SkillPos[i][0], SkillPos[i][1]);
AreaSkill rArea;
AreaSkills.TryRemove(p2, out rArea);
}, SkillShowTime, 0);
}
}
#endregion
}
/// <summary>
/// Teleports the client to a specific place.
/// </summary>
/// <param name="map">The map to teleport to.</param>
/// <param name="x">The x coordinate.</param>
/// <param name="y">The y coordinate.</param>
/// <returns>Returns true if the client was teleported.</returns>
public bool Teleport(Maps.Map map, ushort x, ushort y, bool isdynamic = false)
{
if (!Core.Kernel.Maps.Contains(map.MapID) && !isdynamic)
return false;
Maps.Map lMap = Map;
if (!lMap.LeaveMap(this))
return false;
if (DynamicMap != null)
{
LeaveDynamicMap(false);
}
DynamicMap = null;
ushort lastmap = lMap.MapID;
if (!map.EnterMap(this))
return false;
if (isdynamic)
DynamicMap = (Maps.DynamicMap)map;
AttackPacket = null;
RemoveFlag1(Enums.Effect1.Riding);
ushort SendMap = map.InheritanceMap;
Send(new Packets.GeneralDataPacket()
{
Id = EntityUID,
Data1 =SendMap,
Data2 = 0,
Timestamp = ProjectX_V3_Lib.Time.SystemTime.Now,
Action = Enums.DataAction.Teleport,
Data3Low = x,
Data3High = y,
Data4 = 0,
Data5 = 0,
});
Send(new Packets.GeneralDataPacket()
{
Id = EntityUID,
Data1 = SendMap,
Data2 = 0,
Timestamp = ProjectX_V3_Lib.Time.SystemTime.Now,
Action = Enums.DataAction.ChangeMap,
Data3Low = x,
Data3High = y,
Data4 = 0,
Data5 = 0,
});
using (var mapinfo = new Packets.MapInfoPacket())
{
mapinfo.MapID = SendMap;
mapinfo.DocID = SendMap;
foreach (Enums.MapTypeFlags flag in map.Flags.Values)
mapinfo.AddFlag(flag);
mapinfo.Finish();
this.Send(mapinfo);
}
if (lMap.MapType != Enums.MapType.Tournament)
{
LastMapID = lastmap;
LastMapX = X;
LastMapY = Y;
}
X = x;
Y = y;
if (lMap.MapType != Enums.MapType.Tournament)
{
Database.CharacterDatabase.UpdateCharacter(this, "PlayerLastMapID", lastmap);
}
if (!isdynamic && Map.MapType != Enums.MapType.Tournament)
{
Database.CharacterDatabase.UpdateCharacter(this, "PlayerMapID", Map.MapID);
Database.CharacterDatabase.UpdateCharacter(this, "PlayerX", X);
Database.CharacterDatabase.UpdateCharacter(this, "PlayerY", Y);
}
#region Clear
using (var clear = Packets.Message.MessageCore.ClearScore())
{
this.Send(clear);
}
#endregion
return true;
}
/// <summary>
/// Teleports the client without changing map.
/// </summary>
/// <param name="map">The map to teleport to.</param>
/// <param name="x">The x coordinate.</param>
/// <param name="y">The y coordinate.</param>
/// <returns>Returns true if the client was teleported.</returns>
public bool Teleport2(ushort x, ushort y, bool isdynamic = false)
{
AttackPacket = null;
ushort SendMap = Map.InheritanceMap;
Send(new Packets.GeneralDataPacket()
{
Id = EntityUID,
Data1 =SendMap,
Data2 = 0,
Timestamp = ProjectX_V3_Lib.Time.SystemTime.Now,
Action = Enums.DataAction.Teleport,
Data3Low = x,
Data3High = y,
Data4 = 0,
Data5 = 0,
});
Send(new Packets.GeneralDataPacket()
{
Id = EntityUID,
Data1 = SendMap,
Data2 = 0,
Timestamp = ProjectX_V3_Lib.Time.SystemTime.Now,
Action = Enums.DataAction.ChangeMap,
Data3Low = x,
Data3High = y,
Data4 = 0,
Data5 = 0,
});
using (var mapinfo = new Packets.MapInfoPacket())
{
mapinfo.MapID = SendMap;
mapinfo.DocID = SendMap;
foreach (Enums.MapTypeFlags flag in Map.Flags.Values)
mapinfo.AddFlag(flag);
mapinfo.Finish();
this.Send(mapinfo);
}
X = x;
Y = y;
if (!isdynamic)
{
Database.CharacterDatabase.UpdateCharacter(this, "PlayerX", X);
Database.CharacterDatabase.UpdateCharacter(this, "PlayerY", Y);
}
return true;
}
public static void Handle()
{
foreach (Entities.GameClient client in Core.Kernel.Clients.selectorCollection1.Values)
{
try
{
if (!client.LoggedIn)
{
continue;
}
if (!client.CanSave)
{
continue;
}
#region Remove PKPoints
if (client.PKPoints > 0)
{
if (DateTime.Now >= client.LastPKRemove.AddMilliseconds(Core.TimeIntervals.PKPRemovalTime))
{
client.LastPKRemove = DateTime.Now;
client.PKPoints -= 1;
if (client.PKPoints == 0)
{
using (var msg = Packets.Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.PK_POINTS_REMOVED))
client.Send(msg);
}
}
}
#endregion
#region Show Hawk Message
if (client.Booth != null)
{
if (!string.IsNullOrWhiteSpace(client.Booth.HawkMessage))
{
if (DateTime.Now >= client.ShowHawkMessage.AddMilliseconds(Core.TimeIntervals.ShowHawkMessage))
{
using (var msg = Packets.Message.MessageCore.CreateHawk(client.Name, client.Booth.HawkMessage))
{
client.SendToScreen(msg, false, false);
}
}
}
}
#endregion
#region GuildWars
if (client.Map.MapType == Enums.MapType.GuildWars)
{
if (client.Guild == null)
{
client.Teleport(client.LastMapID, client.LastMapX, client.LastMapY);
}
}
#endregion
#region Tournament / Raids
if (client.Map.MapType == Enums.MapType.Tournament || client.Map.MapType == Enums.MapType.Dungeon)
{
if (client.Battle == null)
{
if (client.Map.MapType == Enums.MapType.Tournament || client.Map.MapType == Enums.MapType.Dungeon)
{
client.Teleport(1002, 400, 400);
client.Teleport(1002, 400, 400); // stupid fix ... but whatever...
}
}
}
#endregion
#region Poison
if (client.ContainsFlag1(Enums.Effect1.Poisoned))
{
if (DateTime.Now >= client.LastPoison.AddMilliseconds(3000))
{
client.LastPoison = DateTime.Now;
if (client.PoisonEffect > 0)
{
uint damage = (uint)((client.HP / 100) * client.PoisonEffect);
if (client.HP > damage)
{
Packets.Interaction.Battle.Combat.HitDamage(null, client, damage);
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = client.EntityUID;
interact.TargetUID = client.EntityUID;
interact.UnPacked = true;
interact.X = client.X;
interact.Y = client.Y;
interact.Data = damage;
client.SendToScreen(interact, true, false);
}
}
else
{
client.RemoveFlag1(Enums.Effect1.Poisoned);
}
}
}
}
#endregion
#region Fun
#region Super Aids
if (client.SuperAids)
{
if (Calculations.BasicCalculations.ChanceSuccess(5))
{
client.SuperAids = false;
using (var msg = Packets.Message.MessageCore.CreateCenter(string.Format(Core.MessageConst.SUPER_AIDS, client.Name)))
{
Packets.Message.MessageCore.SendGlobalMessage(msg);
}
Packets.Interaction.Battle.Combat.Kill(null, client, (uint)client.HP);
}
else
{
uint damage = (uint)((client.HP / 100) * 3);
client.HP -= (int)damage;
Packets.Interaction.Battle.Combat.HitDamage(null, client, damage);
using (var interact = new Packets.InteractionPacket())
{
interact.Action = Enums.InteractAction.Attack;
interact.EntityUID = client.EntityUID;
interact.TargetUID = client.EntityUID;
interact.UnPacked = true;
interact.X = client.X;
interact.Y = client.Y;
interact.Data = damage;
client.SendToScreen(interact, true, false);
}
}
}
#endregion
#endregion
}
catch { client.NetworkClient.Disconnect("THREAD_FAIL"); }
}
}
