public static void generatePet(Player aOwner, Int32 aPetType)
{
MonsterInfo petInfo;
if (!Database.AllMonsters.TryGetValue(aPetType, out petInfo))
{
return;
}
if (aOwner.Pet != null)
{
aOwner.Pet.Brain.Sleep();
aOwner.Pet.Disappear();
aOwner.Pet = null;
}
Pet pet = new Pet(++World.LastMonsterUID, petInfo, aOwner);
pet.Map = aOwner.Map;
pet.StartX = aOwner.X;
pet.StartY = aOwner.Y;
pet.X = aOwner.X;
pet.Y = aOwner.Y;
World.AllMonsters.Add(pet.UniqId, pet);
pet.Map.AddEntity(pet);
aOwner.Pet = pet;
pet.Reborn();
World.BroadcastRoomMsg(pet, new MsgPetInfo(pet));
}
public void AddMember(Player aPlayer)
{
Member member = null;
Database.CreateSynMember(aPlayer, this, (Byte)Rank.Member, 0, out member);
lock (mMembers) { mMembers.Add(member.Id, member); }
aPlayer.Syndicate = this;
aPlayer.Send(new MsgSynAttrInfo(aPlayer.UniqId, this));
aPlayer.Send(new MsgTalk("SYSTEM", "ALLUSERS", Announce, Channel.SynAnnounce, Color.White));
foreach (Int16 enemyId in Enemies)
{
aPlayer.Send(new MsgSyndicate((UInt32)enemyId, MsgSyndicate.Action.SetAntagonize));
}
foreach (Int16 allyId in Allies)
{
aPlayer.Send(new MsgSyndicate((UInt32)allyId, MsgSyndicate.Action.SetAlly));
}
World.BroadcastRoomMsg(aPlayer, new MsgPlayer(aPlayer), true);
World.BroadcastSynMsg(this, new MsgTalk("SYSTEM", "ALLUSERS", String.Format(StrRes.STR_SYN_JOIN, aPlayer.Name), Channel.Syndicate, Color.White));
}
public void DelMember(Member Member, Boolean Kicked)
{
if (Member.Id == Leader.Id)
{
return;
}
Player Player = null;
if (World.AllPlayers.TryGetValue(Member.Id, out Player))
{
lock (Members) { Members.Remove(Member.Id); }
Player.Syndicate = null;
Database.LeaveSyn(Member.Name);
Player.Send(new MsgSynAttrInfo(Player.UniqId, Player.Syndicate));
World.BroadcastRoomMsg(Player, new MsgPlayer(Player), true);
}
else
{
lock (Members) { Members.Remove(Member.Id); }
Database.LeaveSyn(Member.Name);
}
if (Kicked)
{
World.BroadcastSynMsg(this, new MsgTalk("SYSTEM", "ALLUSERS", String.Format(StrRes.STR_KICKOUT, Member.Name), Channel.Syndicate, Color.White));
}
}
public static Int32 GetDamageMonster2Player(Monster Attacker, Player Target)
{
Double Damage = 0;
Double Reborn = 1.00;
if (Target.Metempsychosis == 1)
{
Reborn -= 0.30; //30%
}
else if (Target.Metempsychosis >= 2)
{
Reborn -= 0.50; //50%
}
switch (Attacker.AtkType)
{
case 2:
{
Damage = MyMath.Generate(Attacker.MinAtk, Attacker.MaxAtk);
Damage = AdjustDamageMonster2Player(Damage, Attacker, Target);
Damage -= Target.Defence;
break;
}
case 21:
{
Damage = Attacker.MagicAtk;
Damage = AdjustDamageMonster2Player(Damage, Attacker, Target);
Damage *= ((Double)(100 - Target.MagicDef) / 100);
Damage -= Target.MagicBlock;
Damage *= 0.75;
break;
}
}
Damage *= Reborn;
Damage *= Target.Bless;
Damage *= Target.GemBonus;
if (Damage < 1)
{
Damage = 1;
}
Damage = AdjustMinDamageMonster2Player(Damage, Attacker, Target);
if (Target.LuckyTime > 0 && MyMath.Success(10))
{
Damage = 1;
World.BroadcastRoomMsg(Target, new MsgName(Target.UniqId, "LuckyGuy", Network.MsgName.NameAct.RoleEffect), true);
}
return((Int32)Math.Round(Damage, 0));
}
public static Int32 GetDamagePlayer2Monster(Player Attacker, Monster Target)
{
Double Damage = 0;
switch (Attacker.AtkType)
{
case 2:
{
Damage = MyMath.Generate(Attacker.MinAtk, Attacker.MaxAtk);
Damage = AdjustDamagePlayer2Monster(Damage, Attacker, Target);
Damage -= Target.Defence;
break;
}
case 21:
{
Damage = Attacker.MagicAtk;
Damage = AdjustDamagePlayer2Monster(Damage, Attacker, Target);
Damage *= ((Double)(100 - Target.MagicDef) / 100);
Damage -= Target.MagicBlock;
Damage *= 0.75;
break;
}
case 25:
{
Damage = MyMath.Generate(Attacker.MinAtk, Attacker.MaxAtk);
Damage = AdjustDamagePlayer2Monster(Damage, Attacker, Target);
break;
}
}
if (Damage < 1)
{
Damage = 1;
}
Damage = AdjustMinDamagePlayer2Monster(Damage, Attacker, Target);
if (Attacker.LuckyTime > 0 && MyMath.Success(10))
{
Damage *= 2;
World.BroadcastRoomMsg(Attacker, new MsgName(Attacker.UniqId, "LuckyGuy", Network.MsgName.NameAct.RoleEffect), true);
}
return((Int32)Math.Round(Damage, 0));
}
public static void SynchroInfo(Player aPlayer, bool aAnnounce)
{
Msg msg = null;
msg = new MsgSynAttrInfo(aPlayer.UniqId, aPlayer.Syndicate);
aPlayer.Send(msg);
msg = new MsgPlayer(aPlayer);
World.BroadcastRoomMsg(aPlayer, msg, true);
if (aAnnounce)
{
String words = "";
if (aPlayer.Syndicate != null)
{
var master = aPlayer.Syndicate.GetMasterSyn();
words = master.Announce;
}
msg = new MsgTalk("SYSTEM", "ALLUSERS", words, Channel.SynAnnounce, Color.White);
aPlayer.Send(msg);
}
}
public static Int32 GetDamagePlayer2Environment(Player Attacker, TerrainNPC Target, UInt16 MagicType, Byte MagicLevel)
{
Magic.Info Info = new Magic.Info();
Database.AllMagics.TryGetValue((MagicType * 10) + MagicLevel, out Info);
Double Damage = 0;
if (Info.Type == 1115 || (Info.WeaponSubtype != 0 && Info.WeaponSubtype != 500))
{
Damage = MyMath.Generate(Attacker.MinAtk, Attacker.MaxAtk);
if (Info.Power > 30000)
{
Damage *= (Double)(Info.Power - 30000) / 100;
}
else
{
Damage += Info.Power;
}
Damage -= Target.Defence;
}
else if (Info.WeaponSubtype == 500)
{
Damage = MyMath.Generate(Attacker.MinAtk, Attacker.MaxAtk);
if (Info.Power > 30000)
{
Damage *= (Double)(Info.Power - 30000) / 100;
}
else
{
Damage += Info.Power;
}
}
else
{
Damage = Attacker.MagicAtk;
if (Info.Power > 30000)
{
Damage *= (Double)(Info.Power - 30000) / 100;
}
else
{
Damage += Info.Power;
}
Damage *= ((Double)(100 - Target.MagicDef) / 100);
Damage -= Target.MagicBlock;
}
if (Damage < 1)
{
Damage = 1;
}
if (Attacker.LuckyTime > 0 && MyMath.Success(10))
{
Damage *= 2;
World.BroadcastRoomMsg(Attacker, new MsgName(Attacker.UniqId, "LuckyGuy", Network.MsgName.NameAct.RoleEffect), true);
}
return((Int32)Math.Round(Damage, 0));
}
/// <summary>
/// Try to generate aAmount monsters.
/// </summary>
/// <param name="aAmount">The amount of monsters to generate</param>
/// <returns>The number of generated monsters</returns>
public UInt32 Generate(UInt32 aAmount)
{
const UInt32 RANDOM_GENERATOR_SECS = 600;
if (mGenAmount >= mMaxNPC)
{
return(0);
}
if (mTimerElapsed)
{
if (mRestSecs >= RANDOM_GENERATOR_SECS)
{
mTimer.Interval = (mRestSecs + sRand.Next(mRestSecs)) * 1000;
mTimer.Start();
}
mCurGen = mMaxPerGen;
}
if (mCurGen <= 0)
{
return(0);
}
UInt32 generated = 0;
for (UInt32 i = 0; i < aAmount; ++i)
{
UInt16 posX = 0, posY = 0;
FindGenPos(ref posX, ref posY);
if (!mMap.GetFloorAccess(posX, posY))
{
posX = (UInt16)(mBoundX + sRand.Next(mBoundCX));
posY = (UInt16)(mBoundY + sRand.Next(mBoundCY));
if (!mMap.GetFloorAccess(posX, posY))
{
continue;
}
}
Monster monster = null;
lock (World.AllMonsters)
{
// TODO protection for infinite loop
while (World.AllMonsters.ContainsKey(World.LastMonsterUID))
{
++World.LastMonsterUID;
if (!Entity.IsMonster(World.LastMonsterUID))
{
World.LastMonsterUID = Entity.MONSTERID_FIRST;
}
}
monster = new Monster(World.LastMonsterUID++, mMonsterType, this);
++mAmount;
monster.Map = mMap;
monster.StartX = posX;
monster.StartY = posY;
monster.X = posX;
monster.Y = posY;
World.AllMonsters.Add(monster.UniqId, monster);
mMap.AddEntity(monster);
}
World.BroadcastRoomMsg(monster, new MsgPlayer(monster));
World.BroadcastRoomMsg(monster, new MsgAction(monster, 0, MsgAction.Action.Reborn));
World.BroadcastRoomMsg(monster, new MsgName(monster.UniqId, "MBStandard", MsgName.NameAct.RoleEffect));
--mCurGen;
++mGenAmount;
++generated;
if (mCurGen <= 0)
{
break;
}
}
return(generated);
}
public static Int32 GetDamagePlayer2Player(Player Attacker, Player Target, UInt16 MagicType, Byte MagicLevel)
{
Magic.Info Info = new Magic.Info();
Database.AllMagics.TryGetValue((MagicType * 10) + MagicLevel, out Info);
Double Damage = 0;
Double Reborn = 1.00;
if (Target.Metempsychosis == 1)
{
Reborn -= 0.30; //30%
}
else if (Target.Metempsychosis >= 2)
{
Reborn -= 0.50; //50%
}
Double Dodge = 1.00 - (Math.Min(Target.Dodge, 100.00) / 100.00);
if (Info.Type == 1115 || (Info.WeaponSubtype != 0 && Info.WeaponSubtype != 500))
{
Damage = MyMath.Generate(Attacker.MinAtk, Attacker.MaxAtk);
if (Attacker.HasStatus(Status.SuperAtk))
{
Damage *= 0.2; //PvP Reduction!
}
if (Info.Power > 30000)
{
Damage *= (Double)(Info.Power - 30000) / 100;
}
else
{
Damage += Info.Power;
}
Damage -= Target.Defence;
}
else if (Info.WeaponSubtype == 500)
{
Damage = MyMath.Generate(Attacker.MinAtk, Attacker.MaxAtk);
if (Attacker.HasStatus(Status.SuperAtk))
{
Damage *= 0.2; //PvP Reduction!
}
if (Info.Power > 30000)
{
Damage *= (Double)(Info.Power - 30000) / 100;
}
else
{
Damage += Info.Power;
}
Damage *= Dodge;
Damage *= 0.12;
}
else
{
Damage = Attacker.MagicAtk;
if (Info.Power > 30000)
{
Damage *= (Double)(Info.Power - 30000) / 100;
}
else
{
Damage += Info.Power;
}
Damage *= ((Double)(100 - Target.MagicDef) / 100);
Damage -= Target.MagicBlock;
Damage *= 0.75;
}
Damage *= Reborn;
Damage *= Target.Bless;
Damage *= Target.GemBonus;
if (Damage < 1)
{
Damage = 1;
}
if (Attacker.LuckyTime > 0 && MyMath.Success(10))
{
Damage *= 2;
World.BroadcastRoomMsg(Attacker, new MsgName(Attacker.UniqId, "LuckyGuy", Network.MsgName.NameAct.RoleEffect), true);
}
if (Target.LuckyTime > 0 && MyMath.Success(10))
{
Damage = 1;
World.BroadcastRoomMsg(Target, new MsgName(Target.UniqId, "LuckyGuy", Network.MsgName.NameAct.RoleEffect), true);
}
return((Int32)Math.Round(Damage, 0));
}
public static Int32 GetDamagePlayer2Player(Player Attacker, Player Target)
{
Double Damage = 0;
Double Reborn = 1.00;
if (Target.Metempsychosis == 1)
{
Reborn -= 0.30; //30%
}
else if (Target.Metempsychosis >= 2)
{
Reborn -= 0.50; //50%
}
Double Dodge = 1.00 - (Math.Min(Target.Dodge, 100.00) / 100.00);
switch (Attacker.AtkType)
{
case 2:
{
Damage = MyMath.Generate(Attacker.MinAtk, Attacker.MaxAtk);
if (Attacker.HasStatus(Status.SuperAtk))
{
Damage *= 0.2; //PvP Reduction!
}
Damage -= Target.Defence;
break;
}
case 21:
{
Damage = Attacker.MagicAtk;
Damage *= ((Double)(100 - Target.MagicDef) / 100);
Damage -= Target.MagicBlock;
Damage *= 0.75;
break;
}
case 25:
{
Damage = MyMath.Generate(Attacker.MinAtk, Attacker.MaxAtk);
if (Attacker.HasStatus(Status.SuperAtk))
{
Damage *= 0.2; //PvP Reduction!
}
Damage *= Dodge;
Damage *= 0.12;
break;
}
}
Damage *= Reborn;
Damage *= Target.Bless;
Damage *= Target.GemBonus;
if (Damage < 1)
{
Damage = 1;
}
if (Attacker.LuckyTime > 0 && MyMath.Success(10))
{
Damage *= 2;
World.BroadcastRoomMsg(Attacker, new MsgName(Attacker.UniqId, "LuckyGuy", Network.MsgName.NameAct.RoleEffect), true);
}
if (Target.LuckyTime > 0 && MyMath.Success(10))
{
Damage = 1;
World.BroadcastRoomMsg(Target, new MsgName(Target.UniqId, "LuckyGuy", Network.MsgName.NameAct.RoleEffect), true);
}
return((Int32)Math.Round(Damage, 0));
}
public static void MvP(Monster Attacker, Player Target)
{
try
{
if (!Attacker.IsAlive())
{
Attacker.IsInBattle = false;
return;
}
if (Target == null || !Target.IsAlive())
{
Attacker.IsInBattle = false;
return;
}
if (Attacker.Map != Target.Map)
{
Attacker.IsInBattle = false;
return;
}
if (!MyMath.CanSee(Attacker.X, Attacker.Y, Target.X, Target.Y, (Attacker.AtkRange)))
{
Attacker.IsInBattle = false;
return;
}
if (Target.IsFlying())
{
Attacker.IsInBattle = false;
return;
}
if (!MyMath.Success(Attacker.Dexterity))
{
World.BroadcastMapMsg(Attacker, new MsgInteract(Attacker, Target, 0, (MsgInteract.Action)Attacker.AtkType));
return;
}
Int32 Damage = 0;
Damage = MyMath.GetDamageMonster2Player(Attacker, Target);
Target.RemoveDefDura();
if (!Target.Reflect())
{
World.BroadcastMapMsg(Attacker, new MsgInteract(Attacker, Target, Damage, MsgInteract.Action.Attack));
if (Damage >= Target.CurHP)
{
Target.Die(Attacker);
World.BroadcastMapMsg(Attacker, new MsgInteract(Attacker, Target, 1, MsgInteract.Action.Kill));
}
else
{
Target.CurHP -= Damage;
Target.Send(new MsgUserAttrib(Target, Target.CurHP, MsgUserAttrib.AttributeType.Life));
if (Target.Team != null)
{
Target.Team.BroadcastMsg(new MsgUserAttrib(Target, Target.CurHP, MsgUserAttrib.AttributeType.Life));
}
if (Target.Action == Emotion.SitDown)
{
Target.Energy /= 2;
Target.Send(new MsgUserAttrib(Target, Target.Energy, MsgUserAttrib.AttributeType.Energy));
Target.Action = Emotion.StandBy;
World.BroadcastRoomMsg(Target, new MsgAction(Target, (int)Target.Action, MsgAction.Action.Emotion), true);
}
}
}
else
{
if (Damage > 2000)
{
Damage = 2000;
}
World.BroadcastMapMsg(Attacker, new MsgInteract(Target, Attacker, Damage, MsgInteract.Action.ReflectWeapon));
if (Damage >= Attacker.CurHP)
{
Attacker.Die(0);
World.BroadcastMapMsg(Target, new MsgInteract(Target, Attacker, 1, MsgInteract.Action.Kill), true);
}
else
{
Attacker.CurHP -= Damage;
World.BroadcastMapMsg(Attacker, new MsgUserAttrib(Attacker, Attacker.CurHP, MsgUserAttrib.AttributeType.Life));
}
}
}
catch (Exception exc) { sLogger.Error(exc); }
}
public static void UseMagic(AdvancedEntity aAttacker, AdvancedEntity aTarget, UInt16 aTargetX, UInt16 aTargetY)
{
try
{
// a lot of logic depends on the fact that the attacker is a player...
Player attacker = aAttacker as Player;
if (!aAttacker.IsAlive())
{
return;
}
if (aAttacker.IsPlayer())
{
if (attacker.MagicType == 8000 || attacker.MagicType == 8001)
{
Item arrow = attacker.GetItemByPos(5);
if (arrow.Type / 10000 != 105)
{
return;
}
if (attacker.MagicType == 8000)
{
if (arrow.CurDura < 5)
{
return;
}
}
if (attacker.MagicType == 8001)
{
if (arrow.CurDura < 3)
{
return;
}
}
}
}
Magic.Info Info = new Magic.Info();
if (!Database.AllMagics.TryGetValue((aAttacker.MagicType * 10) + aAttacker.MagicLevel, out Info))
{
return;
}
GameMap Map = aAttacker.Map;
if (aAttacker.IsPlayer() && Program.Debug)
{
attacker.SendSysMsg(String.Format("Using magic skill {0} [sort={1}, power={2}, status={3}]",
Info.Type, Info.Sort, Info.Power, Info.Status));
}
#region Fly | IsWing_Disable
if (Info.Type == 8002 || Info.Type == 8003)
{
if (Map.IsWing_Disable())
{
return;
}
}
#endregion
#region Use Mp/PP/Xp
if (aAttacker.IsPlayer())
{
if (Info.UseMP != 0 && attacker.CurMP < Info.UseMP)
{
return;
}
if (Info.UseEP != 0 && attacker.Energy < Info.UseEP)
{
return;
}
if (Info.UseXP == Magic.TYPE_XPSKILL && attacker.XP < 100)
{
return;
}
if (Info.UseMP != 0 && attacker.Map.Id != 1039)
{
attacker.CurMP -= (UInt16)Info.UseMP;
attacker.Send(new MsgUserAttrib(attacker, attacker.CurMP, MsgUserAttrib.AttributeType.Mana));
}
if (Info.UseEP != 0 && attacker.Map.Id != 1039)
{
attacker.Energy -= (Byte)Info.UseEP;
attacker.Send(new MsgUserAttrib(attacker, attacker.Energy, MsgUserAttrib.AttributeType.Energy));
}
if (Info.UseXP == Magic.TYPE_XPSKILL)
{
attacker.XP = 0;
attacker.Send(new MsgUserAttrib(attacker, attacker.XP, MsgUserAttrib.AttributeType.XP));
attacker.DetachStatus(Status.XpFull);
}
}
#endregion
#region Intone
if (Info.IntoneDuration > 0)
{
aAttacker.MagicIntone = true;
// TODO implement intonation
//Thread.Sleep((Int32)Info.IntoneDuration);
if (!aAttacker.MagicIntone)
{
return;
}
aAttacker.MagicIntone = false;
}
#endregion
#region Potential targets
AdvancedEntity[] potential_targets = new AdvancedEntity[0];
if (aTarget == null || Info.Sort == MagicSort.RecoverSingleHP || Info.Sort == MagicSort.AttackRoundHP || Info.Sort == MagicSort.DispatchXP)
{
switch (Info.Sort)
{
case MagicSort.RecoverSingleHP:
{
// team healing...
if (Info.Type == 1055 || Info.Type == 1170)
{
if ((aTarget.IsPlayer() && (aTarget as Player).Team == null))
{
potential_targets = new AdvancedEntity[] { aTarget };
break;
}
if (aAttacker.IsPlayer()) // only a player can have a team...
{
potential_targets = Battle.GetTargetsForType11(attacker);
}
}
else
{
potential_targets = new AdvancedEntity[] { aTarget }
};
break;
}
case MagicSort.AttackSectorHP:
potential_targets = Battle.GetTargetsForType04(aAttacker, aTargetX, aTargetY, Info.Distance, Info.Range);
break;
case MagicSort.AttackRoundHP:
{
if (aTarget != null)
{
aTargetX = aTarget.X;
aTargetY = aTarget.Y;
aTarget = null;
}
potential_targets = Battle.GetTargetsForType05(aAttacker, aTargetX, aTargetY, Info.Range);
break;
}
case MagicSort.DispatchXP:
{
if (aAttacker.IsPlayer()) // only a player can have a team...
{
potential_targets = Battle.GetTargetsForType11(attacker);
}
break;
}
case MagicSort.Line:
{
potential_targets = Battle.GetTargetsForType14(aAttacker, aTargetX, aTargetY, Info.Range);
break;
}
}
}
else
{
potential_targets = new AdvancedEntity[] { aTarget }
};
#endregion
Dictionary <AdvancedEntity, Int32> targets = new Dictionary <AdvancedEntity, Int32>(potential_targets.Length);
UInt32 Exp = 0;
UInt32 MagicExp = 0;
foreach (AdvancedEntity entity in potential_targets)
{
Boolean Reflected = false;
Player Player = entity as Player;
Monster Monster = entity as Monster;
TerrainNPC Npc = entity as TerrainNPC;
// entity == NULL || entity isn't alive and not using pray
if (entity == null || (!entity.IsAlive() && Info.Sort != MagicSort.RecoverSingleStatus))
{
continue;
}
if (aAttacker.Map != entity.Map)
{
continue;
}
if (!MyMath.CanSee(aAttacker.X, aAttacker.Y, entity.X, entity.Y, (Int32)Info.Distance))
{
continue;
}
if (Info.Target == 0 && aAttacker.UniqId == entity.UniqId)
{
continue;
}
else if (Info.Target == 2 && aAttacker.UniqId != entity.UniqId)
{
continue;
}
else if (Info.Target == 4 && aAttacker.UniqId == entity.UniqId)
{
continue;
}
else if (Info.Target == 8 && aAttacker.UniqId == entity.UniqId &&
!((Info.Type - (Info.Type % 1000)) == 10000))
{
continue;
}
if (Info.Ground && entity.IsPlayer()) // Ground skill
{
if (Player.IsFlying())
{
continue;
}
}
#region Blue name (Crime)
if (aAttacker.IsPlayer() && Info.Crime) // Is a crime to use the skill
{
if (entity.IsPlayer())
{
if (!CanAttack(attacker, Player))
{
continue;
}
if (!Map.IsPkField() && !Map.IsSynMap() && !Map.IsPrisonMap())
{
if (!Player.IsCriminal())
{
attacker.AttachStatus(Status.Crime, 25000);
}
}
}
else if (entity.IsMonster())
{
if (!CanAttack(attacker, Monster))
{
continue;
}
if ((Byte)(Monster.Id / 100) == 9) //Is a guard
{
attacker.AttachStatus(Status.Crime, 25000);
}
}
}
#endregion
#region Get base damage
Int32 damage = 0;
if (Info.Sort == MagicSort.RecoverSingleHP || Info.Sort == MagicSort.AttackSingleStatus || Info.Sort == MagicSort.DispatchXP || Info.Sort == MagicSort.Transform || Info.Sort == MagicSort.AddMana)
{
damage = (Int32)Info.Power;
}
else if (Info.Sort == MagicSort.RecoverSingleStatus)
{
damage = entity.MaxHP;
}
else if (Info.Sort == MagicSort.DecLife)
{
damage = (Int32)(entity.CurHP * ((Double)(Info.Power - 30000) / 100.00));
}
else
{
if (aAttacker.IsPlayer())
{
if (entity.IsPlayer())
{
damage = MyMath.GetDamagePlayer2Player(attacker, Player, attacker.MagicType, attacker.MagicLevel);
}
else if (entity.IsMonster())
{
damage = MyMath.GetDamagePlayer2Monster(attacker, Monster, attacker.MagicType, attacker.MagicLevel);
}
else if (entity.IsTerrainNPC())
{
damage = MyMath.GetDamagePlayer2Environment(attacker, Npc, attacker.MagicType, attacker.MagicLevel);
}
}
else
{
if (entity.IsPlayer())
{
damage = MyMath.GetDamageMonster2Player((Monster)aAttacker, Player, aAttacker.MagicType, aAttacker.MagicLevel);
}
}
}
//TargetType -> 8; Passive skill
if (Info.Target != 8 && Info.Success != 100 && !MyMath.Success(Info.Success))
{
damage = 0;
}
#endregion
#region Process damage / skill
switch (Info.Sort)
{
case MagicSort.RecoverSingleHP:
{
if (entity.CurHP + damage >= entity.MaxHP)
{
MagicExp += (UInt32)(entity.MaxHP - entity.CurHP);
entity.CurHP = entity.MaxHP;
}
else
{
MagicExp += (UInt32)damage;
entity.CurHP += damage;
}
if (entity.IsPlayer())
{
var msg = new MsgUserAttrib(Player, Player.CurHP, MsgUserAttrib.AttributeType.Life);
Player.Send(msg);
if (Player.Team != null)
{
Player.Team.BroadcastMsg(msg);
}
msg = null;
}
break;
}
case MagicSort.AttackSingleStatus:
{
int duration = (int)Info.StepSecs * 1000;
double power = ((double)(damage - 30000) / 100.00);
switch (aAttacker.MagicType)
{
case 1015:
{
entity.AttachStatus(Status.Accuracy, duration, power);
if (entity.IsPlayer())
{
MyMath.GetEquipStats(Player);
}
break;
}
case 1020:
{
entity.AttachStatus(Status.MagicDefense, duration, power);
if (entity.IsPlayer())
{
MyMath.GetEquipStats(Player);
}
break;
}
case 1025:
{
if (entity.HasStatus(Status.SuperSpeed))
{
entity.DetachStatus(Status.SuperSpeed);
}
entity.AttachStatus(Status.SuperAtk, duration, power);
if (entity.IsPlayer())
{
MyMath.GetEquipStats(Player);
}
break;
}
case 1075:
{
++MagicExp;
entity.AttachStatus(Status.Hidden, duration);
break;
}
case 1085:
{
++MagicExp;
entity.AttachStatus(Status.Accuracy, duration, power);
if (entity.IsPlayer())
{
MyMath.GetEquipStats(Player);
}
break;
}
case 1090:
{
++MagicExp;
entity.AttachStatus(Status.MagicDefense, duration, power);
if (entity.IsPlayer())
{
MyMath.GetEquipStats(Player);
}
break;
}
case 1095:
{
++MagicExp;
entity.AttachStatus(Status.MagicAttack, duration, power);
if (entity.IsPlayer())
{
MyMath.GetEquipStats(Player);
}
break;
}
case 1110:
{
if (entity.HasStatus(Status.SuperAtk))
{
entity.DetachStatus(Status.SuperAtk);
}
entity.AttachStatus(Status.SuperSpeed, duration, power);
if (entity.IsPlayer())
{
MyMath.GetEquipStats(Player);
}
break;
}
case 8002:
{
if (entity.HasStatus(Status.MagicDefense))
{
break;
}
entity.AttachStatus(Status.Flying, duration);
break;
}
case 8003:
{
if (entity.HasStatus(Status.MagicDefense))
{
break;
}
entity.AttachStatus(Status.Flying, duration);
break;
}
case 9000:
{
++MagicExp;
entity.AttachStatus((Status)Info.Status, -1, power);
break;
}
case 9876:
{
entity.AttachStatus(Status.CastingPray);
if (entity.IsPlayer())
{
Player.CastingPray = true;
Player.PrayMap = entity.Map.Id;
Player.PrayX = entity.X;
Player.PrayY = entity.Y;
}
break;
}
case 10203:
{
StatusEffect effect;
if (entity.GetStatus(Status.MagicDefense, out effect))
{
effect.Data = power;
effect.ResetTimeout(duration);
break;
}
entity.AttachStatus(Status.MagicDefense, duration, power);
if (entity.IsPlayer())
{
MyMath.GetEquipStats(Player);
}
break;
}
default:
sLogger.Warn("Magic {0} is not implemented !", aAttacker.MagicType);
break;
}
damage = 0;
break;
}
case MagicSort.RecoverSingleStatus:
{
if (entity.IsPlayer() && !entity.IsAlive())
{
Player.Reborn(false);
}
break;
}
case MagicSort.DispatchXP:
{
if (entity.IsPlayer())
{
if (Player.XP + damage >= 100)
{
Player.XP = 100;
}
else
{
Player.XP += (Byte)damage;
}
Player.Send(new MsgUserAttrib(Player, Player.XP, MsgUserAttrib.AttributeType.XP));
}
break;
}
case MagicSort.Transform:
{
if (entity.IsPlayer())
{
MonsterInfo MonsterInfo;
if (Database.AllMonsters.TryGetValue(damage, out MonsterInfo))
{
MagicExp++;
Player.TransformEndTime = Environment.TickCount + ((Int32)Info.StepSecs * 1000);
// TODO re-enable transformation skills
//Player.AddTransform(MonsterInfo.Look);
Player.MinAtk = (Int32)MonsterInfo.MinAtk;
Player.MaxAtk = (Int32)MonsterInfo.MaxAtk;
Player.Defence = (Int32)MonsterInfo.Defense;
Player.MagicAtk = 0;
Player.MagicDef = (Int32)MonsterInfo.MagicDef;
Player.MagicBlock = 0;
Player.Dodge = MonsterInfo.Dodge;
Player.Dexterity = 1000;
Player.AtkRange = MonsterInfo.AtkRange;
Player.AtkSpeed = MonsterInfo.AtkSpeed;
Player.AtkType = 2;
Player.Bless = 1.00;
Player.GemBonus = 1.00;
if (Player.CurHP >= Player.MaxHP)
{
Player.CurHP = Player.MaxHP;
}
Player.CurHP = (Int32)((Double)MonsterInfo.Life * ((Double)Player.CurHP / (Double)Player.MaxHP));
Player.MaxHP = MonsterInfo.Life;
Player.Send(new MsgUserAttrib(Player, Player.CurHP, MsgUserAttrib.AttributeType.Life));
Player.Send(new MsgUserAttrib(Player, Player.MaxHP, (MsgUserAttrib.AttributeType.Life + 1)));
if (Player.Team != null)
{
Player.Team.BroadcastMsg(new MsgUserAttrib(Player, Player.CurHP, MsgUserAttrib.AttributeType.Life));
Player.Team.BroadcastMsg(new MsgUserAttrib(Player, Player.MaxHP, (MsgUserAttrib.AttributeType.Life + 1)));
}
World.BroadcastRoomMsg(Player, new MsgUserAttrib(Player, Player.Look, MsgUserAttrib.AttributeType.Look), true);
}
}
damage = 0;
break;
}
case MagicSort.AddMana:
{
if (entity.IsPlayer())
{
if (Player.CurMP + damage >= Player.MaxMP)
{
MagicExp += (UInt32)(Player.MaxMP - Player.CurMP);
Player.CurMP = Player.MaxMP;
}
else
{
MagicExp += (UInt32)damage;
Player.CurMP += (UInt16)damage;
}
Player.Send(new MsgUserAttrib(Player, Player.CurMP, MsgUserAttrib.AttributeType.Mana));
}
break;
}
case MagicSort.CallPet:
{
if (!aAttacker.IsPlayer())
{
sLogger.Error("MagicSort::CallPet used by a non-player entity.");
return;
}
damage = 0;
MagicExp += 1;
Generator.generatePet((Player)aAttacker, (Int32)Info.Power);
break;
}
default:
{
if (entity.IsPlayer())
{
Player.RemoveDefDura();
}
#region Not a player || Not reflected
if (!entity.IsPlayer() || (entity.IsPlayer() && !Player.Reflect()))
{
if (damage >= entity.CurHP)
{
if (entity.IsPlayer())
{
Player.Die(aAttacker);
}
else if (entity.IsMonster())
{
if (aAttacker.IsPlayer())
{
if (attacker.XP < 99)
{
++attacker.XP;
}
StatusEffect effect;
if (attacker.GetStatus(Status.SuperSpeed, out effect))
{
effect.IncreaseDuration(820);
++attacker.CurKO;
}
if (attacker.GetStatus(Status.SuperAtk, out effect))
{
effect.IncreaseDuration(820);
++attacker.CurKO;
}
Int32 CurHP = entity.CurHP;
Monster.Die(attacker.UniqId);
Exp += AdjustExp(CurHP, attacker, Monster);
MagicExp += AdjustExp(CurHP, attacker, Monster);
Int32 Bonus = (Int32)(Monster.MaxHP * 0.05);
if (attacker.Team != null)
{
attacker.Team.AwardMemberExp(attacker, Monster, Bonus);
}
UInt32 BonusExp = AdjustExp(Bonus, attacker, Monster);
attacker.AddExp(BonusExp, true);
attacker.SendSysMsg(String.Format(StrRes.STR_KILL_EXPERIENCE, BonusExp));
}
}
else if (entity.IsTerrainNPC())
{
if (attacker.IsPlayer())
{
if (attacker.XP < 99)
{
attacker.XP++;
}
Int32 CurHP = entity.CurHP;
if (Npc.Type == 21 || Npc.Type == 22)
{
Exp += AdjustExp(CurHP, attacker, Npc);
MagicExp += AdjustExp(CurHP, attacker, Npc);
Int32 Bonus = (Int32)(entity.MaxHP * 0.05);
UInt32 BonusExp = AdjustExp(Bonus, attacker, Npc);
attacker.AddExp(BonusExp, true);
}
else if (Npc.Type == (Byte)TerrainNPC.NpcType.SynFlag)
{
if (attacker.Syndicate != null)
{
// TODO re-enable donation gain on pole
//if (attacker.Map.InWar)
// if (attacker.Syndicate.Id != attacker.Map.Holder)
// {
// attacker.Money += (UInt32)(CurHP / 10000);
// attacker.Send(new MsgUserAttrib(attacker, attacker.Money, MsgUserAttrib.AttributeType.Money));
// Syndicate.Member Member = attacker.Syndicate.GetMemberInfo(attacker.UniqId);
// if (Member != null)
// {
// Member.Donation += (UInt32)(CurHP / 10000);
// attacker.Syndicate.Money += (UInt32)(CurHP / 10000);
// }
// }
}
}
Npc.GetAttacked(attacker, Npc.CurHP);
World.BroadcastMapMsg(attacker, new MsgInteract(attacker, entity, 1, MsgInteract.Action.Kill), true);
Npc.Die();
}
}
if (!entity.IsTerrainNPC())
{
if (aAttacker.IsPlayer())
{
if (!entity.IsMonster() || (!aAttacker.HasStatus(Status.SuperAtk) && !aAttacker.HasStatus(Status.SuperSpeed)))
{
World.BroadcastMapMsg(attacker, new MsgInteract(aAttacker, entity, 1, MsgInteract.Action.Kill), true);
}
else
{
World.BroadcastMapMsg(attacker, new MsgInteract(aAttacker, entity, 0xFFFF * (attacker.CurKO + 1), MsgInteract.Action.Kill), true);
}
}
else
{
World.BroadcastMapMsg(aAttacker, new MsgInteract(aAttacker, entity, 1, MsgInteract.Action.Kill));
}
}
}
else
{
entity.CurHP -= damage;
if (entity.IsPlayer())
{
Player.Send(new MsgUserAttrib(entity, entity.CurHP, MsgUserAttrib.AttributeType.Life));
if (Player.Team != null)
{
Player.Team.BroadcastMsg(new MsgUserAttrib(entity, entity.CurHP, MsgUserAttrib.AttributeType.Life));
}
if (Player.Action == Emotion.SitDown)
{
Player.Energy /= 2;
Player.Send(new MsgUserAttrib(Player, Player.Energy, MsgUserAttrib.AttributeType.Energy));
Player.Action = Emotion.StandBy;
World.BroadcastRoomMsg(Player, new MsgAction(Player, (int)Player.Action, MsgAction.Action.Emotion), true);
}
}
else if (entity.IsMonster())
{
if (aAttacker.IsPlayer())
{
Exp += AdjustExp(damage, attacker, Monster);
MagicExp += (UInt32)AdjustExp(damage, attacker, Monster);
}
}
else if (entity.IsTerrainNPC())
{
if (aAttacker.IsPlayer())
{
if (Npc.Type == 21 || Npc.Type == 22)
{
Exp += AdjustExp(damage, attacker, Npc);
MagicExp += (UInt32)AdjustExp(damage, attacker, Npc);
}
else if (Npc.Type == (Byte)TerrainNPC.NpcType.SynFlag)
{
if (attacker.Syndicate != null)
{
// TODO re-enable donation gain on pole
//if (attacker.Map.InWar)
// if (attacker.Syndicate.Id != attacker.Map.Holder)
// {
// attacker.Money += (UInt32)(damage / 10000);
// attacker.Send(new MsgUserAttrib(attacker, attacker.Money, MsgUserAttrib.AttributeType.Money));
// Syndicate.Member Member = attacker.Syndicate.GetMemberInfo(attacker.UniqId);
// if (Member != null)
// {
// Member.Donation += (UInt32)(damage / 10000);
// attacker.Syndicate.Money += (UInt32)(damage / 10000);
// attacker.Send(new MsgSynAttrInfo(attacker.UniqId, attacker.Syndicate));
// }
// }
}
}
Npc.GetAttacked(attacker, damage);
}
}
}
}
#endregion
#region Reflected
else
{
if (damage > 2000)
{
damage = 2000;
}
var msg = new MsgInteract(entity, aAttacker, damage, MsgInteract.Action.ReflectMagic);
if (aAttacker.IsPlayer())
{
World.BroadcastMapMsg(attacker, msg, true);
}
else
{
World.BroadcastMapMsg(aAttacker, msg);
}
if (damage >= aAttacker.CurHP)
{
if (aAttacker.IsPlayer())
{
attacker.Die(null);
}
else
{
((Monster)aAttacker).Die(entity.UniqId);
}
World.BroadcastMapMsg(Player, new MsgInteract(entity, aAttacker, 1, MsgInteract.Action.Kill), true);
}
else
{
aAttacker.CurHP -= damage;
var msg2 = new MsgUserAttrib(aAttacker, aAttacker.CurHP, MsgUserAttrib.AttributeType.Life);
if (aAttacker.IsPlayer())
{
attacker.Send(msg2);
if (attacker.Team != null)
{
attacker.Team.BroadcastMsg(msg2);
}
}
else
{
World.BroadcastMapMsg(aAttacker, msg2);
}
}
Reflected = true;
}
#endregion
break;
}
}
#endregion
if (aTarget != null && Info.Sort != MagicSort.DispatchXP && Info.Sort != MagicSort.RecoverSingleHP && !Reflected)
{
var msg = new MsgMagicEffect(aAttacker, aTarget, damage, aTargetX, aTargetY);
if (aAttacker.IsPlayer())
{
World.BroadcastMapMsg(attacker, msg, true);
}
else
{
World.BroadcastMapMsg(aAttacker, msg);
}
}
else if (!Reflected)
{
targets.Add(entity, damage);
}
}
#region Player: Update LastAttackTick
if (aAttacker.IsPlayer())
{
attacker.LastAttackTick = Environment.TickCount;
}
#endregion
#region Player: Remove Dura
if (aAttacker.IsPlayer() && aAttacker.Map.Id != 1039)
{
if (attacker.MagicType == 8000)
{
for (SByte i = 0; i < 5; i++)
{
attacker.RemoveAtkDura();
}
}
else if (attacker.MagicType == 8001)
{
for (SByte i = 0; i < 3; i++)
{
attacker.RemoveAtkDura();
}
}
else
{
attacker.RemoveAtkDura();
}
}
#endregion
#region Player: Add Exp
if (aAttacker.IsPlayer())
{
attacker.AddExp(Exp, true);
if (MagicExp > 0 && Info.Sort != MagicSort.AtkStatus)
{
attacker.AddMagicExp(attacker.MagicType, MagicExp);
}
else if (MagicExp > 0)
{
attacker.AddMagicExp(attacker.MagicType, 1);
}
}
#endregion
if (aTarget == null || Info.Sort == MagicSort.DispatchXP || Info.Sort == MagicSort.RecoverSingleHP)
{
var msg = new MsgMagicEffect(aAttacker, targets, aTargetX, aTargetY);
if (aAttacker.IsPlayer())
{
World.BroadcastMapMsg(attacker, msg, true);
}
else
{
World.BroadcastMapMsg(aAttacker, msg);
}
}
#region Player: Activate the weapon attribute (e.g. Poison Blade)
if (aAttacker.IsPlayer() && aAttacker.Map.Id != 1039)
{
Battle.WeaponAttribute(attacker, null);
}
#endregion
}
catch (Exception exc) { sLogger.Error(exc); }
}
public static void PvP(Player Attacker, Player Target)
{
try
{
if (!Attacker.IsAlive())
{
Attacker.IsInBattle = false;
return;
}
if (Target == null || !Target.IsAlive())
{
Attacker.IsInBattle = false;
return;
}
if (Attacker.Map != Target.Map)
{
Attacker.IsInBattle = false;
return;
}
if (!MyMath.CanSee(Attacker.X, Attacker.Y, Target.X, Target.Y, (Attacker.AtkRange + 1)))
{
Attacker.IsInBattle = false;
return;
}
if (!CanAttack(Attacker, Target))
{
Attacker.IsInBattle = false;
return;
}
if (Battle.WeaponSkill(Attacker, Target))
{
return;
}
if (Attacker.AtkType != 25 && Target.IsFlying())
{
Attacker.IsInBattle = false;
return;
}
if (!Attacker.Map.IsPkField() && !Attacker.Map.IsSynMap() && !Attacker.Map.IsPrisonMap())
{
if (!Target.IsCriminal())
{
Attacker.AttachStatus(Status.Crime, 25000);
}
}
Attacker.LastAttackTick = Environment.TickCount;
if (!MyMath.Success(Attacker.Dexterity))
{
World.BroadcastMapMsg(Attacker, new MsgInteract(Attacker, Target, 0, (MsgInteract.Action)Attacker.AtkType), true);
return;
}
Int32 Damage = 0;
Damage = MyMath.GetDamagePlayer2Player(Attacker, Target);
if (Attacker.Map.Id != 1039)
{
Attacker.RemoveAtkDura();
Target.RemoveDefDura();
}
if (!Target.Reflect())
{
World.BroadcastMapMsg(Attacker, new MsgInteract(Attacker, Target, Damage, MsgInteract.Action.Attack), true);
if (Damage >= Target.CurHP)
{
Target.Die(Attacker);
World.BroadcastMapMsg(Attacker, new MsgInteract(Attacker, Target, 1, MsgInteract.Action.Kill), true);
}
else
{
Target.CurHP -= Damage;
Target.Send(new MsgUserAttrib(Target, Target.CurHP, MsgUserAttrib.AttributeType.Life));
if (Target.Team != null)
{
Target.Team.BroadcastMsg(new MsgUserAttrib(Target, Target.CurHP, MsgUserAttrib.AttributeType.Life));
}
if (Target.Action == Emotion.SitDown)
{
Target.Energy /= 2;
Target.Send(new MsgUserAttrib(Target, Target.Energy, MsgUserAttrib.AttributeType.Energy));
Target.Action = Emotion.StandBy;
World.BroadcastRoomMsg(Target, new MsgAction(Target, (int)Target.Action, MsgAction.Action.Emotion), true);
}
}
}
else
{
if (Damage > 2000)
{
Damage = 2000;
}
World.BroadcastMapMsg(Attacker, new MsgInteract(Target, Attacker, Damage, MsgInteract.Action.ReflectWeapon), true);
if (Damage >= Attacker.CurHP)
{
Attacker.Die(null);
World.BroadcastMapMsg(Target, new MsgInteract(Target, Attacker, 1, MsgInteract.Action.Kill), true);
}
else
{
Attacker.CurHP -= Damage;
Attacker.Send(new MsgUserAttrib(Attacker, Attacker.CurHP, MsgUserAttrib.AttributeType.Life));
if (Attacker.Team != null)
{
Attacker.Team.BroadcastMsg(new MsgUserAttrib(Attacker, Attacker.CurHP, MsgUserAttrib.AttributeType.Life));
}
}
}
if (Attacker.Map.Id != 1039)
{
Battle.WeaponAttribute(Attacker, Target);
}
}
catch (Exception exc) { sLogger.Error(exc); }
}
