Register for your free account! | Forgot your password?

You last visited: Today at 03:56

  • Please register to post and access all features, it's quick, easy and FREE!

Advertisement



[Release]GuildWars - ProjectX

Discussion on [Release]GuildWars - ProjectX within the CO2 PServer Guides & Releases forum part of the CO2 Private Server category.

Reply
 
Old   #1
 
elite*gold: 0
Join Date: Dec 2012
Posts: 1,719
Received Thanks: 911
[Release]GuildWars - ProjectX

This is for the ProjectX V3.2 source.
Which can be found .

Database

Source: (The files that does not exist, create them!)

ProjectX_V3_Game\SobDatabase.cs
Code:
//Project by BaussHacker aka. L33TS

using System;
using ProjectX_V3_Lib.Sql;

namespace ProjectX_V3_Game.Database
{
	/// <summary>
	/// Description of SobDatabase.
	/// </summary>
	public class SobDatabase
	{
		public static bool LoadSobs(bool display = true)
		{
			Console.ForegroundColor = ConsoleColor.Yellow;
			if (display)
				Console.WriteLine("\tLoading Sobs...");
			using (var sql = new SqlHandler(Program.Config.ReadString("GameConnectionString")))
			{
				using (var cmd = new SqlCommandBuilder(sql, SqlCommandType.SELECT, false))
				{
					cmd.Finish("DB_Sobs");
				}
				while (sql.Read())
				{
					uint ID = sql.ReadUInt32("SobID");
					Entities.NPC associatedNPC = null;
					if (Core.Kernel.NPCs.ContainsKey(ID))
						associatedNPC = Core.Kernel.NPCs[ID];
					
					Entities.Sob sob = new ProjectX_V3_Game.Entities.Sob(associatedNPC);
					sob.EntityUID = ID;
					sob.Name = sql.ReadString("SobName");
					sob.MaxHP = sql.ReadInt32("SobHP");
					sob.HP = sob.MaxHP;
					
					sob.OriginalName = sql.ReadString("SobOriginalName");
					sob.Mesh = sql.ReadUInt16("SobMesh");
					sob.SecondaryMesh = sql.ReadUInt16("SobSecondaryMesh");
					sob.ShowMesh = sob.Mesh;
					
					sob.Flag = sql.ReadUInt16("SobFlag");
					sob.SobType = sql.ReadUInt32("SobType");
					
					ushort mapid = sql.ReadUInt16("SobMap");
					sob.X = sql.ReadUInt16("SobX");
					sob.Y = sql.ReadUInt16("SobY");
					if (mapid == 0)
					{
						Console.ForegroundColor = ConsoleColor.Red;
						Console.WriteLine("Failed to load sobs. [MAPID]");
						Console.ResetColor();
						return false;
					}
					
					Maps.Map map;
					Core.Kernel.Maps.TrySelect(mapid, out map);
					sob.Map = map;
					if (!sob.Map.EnterMap(sob))
					{
						Console.ForegroundColor = ConsoleColor.Red;
						Console.WriteLine("Failed to load sobs. [MAP]");
						Console.ResetColor();
						return false;
					}
					
					if (!Core.Kernel.Sobs.TryAdd(sob.EntityUID, sob))
					{
						Console.ForegroundColor = ConsoleColor.Red;
						Console.WriteLine("Failed to load npcs. [ADD]");
						Console.ResetColor();
						return false;
					}
				}
			}
			
			Console.ForegroundColor = ConsoleColor.Green;
			Console.WriteLine("\tLoaded {0} Sobs...", Core.Kernel.Sobs.Count);
			return true;
		}
	}
}
ProjectX_V3_Game\Tournaments\GuildWars.cs
Code:
//Project by BaussHacker aka. L33TS

using System;
using System.Linq;
using ProjectX_V3_Lib.Sql;

namespace ProjectX_V3_Game.Tournaments
{
	/// <summary>
	/// The handler for guild wars.
	/// </summary>
	public class GuildWars : Data.BattleClass
	{
		private Maps.Map Map;
		private Entities.Sob GuildPole;
		private Entities.Sob LeftGate;
		private Entities.Sob RightGate;
		private byte Round = 0;
		public Data.Guild WinnerGuild;
		public DateTime LastGuildWars;
		
		public bool LeftGateOpen
		{
			get { return LeftGate.ShowMesh == LeftGate.SecondaryMesh; }
			set { LeftGate.ShowMesh = (value) ? LeftGate.SecondaryMesh : LeftGate.Mesh; }
		}
		public bool RightGateOpen
		{
			get { return RightGate.ShowMesh == RightGate.SecondaryMesh; }
			set { RightGate.ShowMesh = (value) ? RightGate.SecondaryMesh : RightGate.Mesh; }
		}
		
		private static GuildWars _gw;
		public static GuildWars GW
		{
			get { return _gw; }
		}
		static GuildWars()
		{
			_gw = new GuildWars();
		}
		public GuildWars()
			: base()
		{
			Map = Core.Kernel.Maps[1038];
			GuildPole = Core.Kernel.Sobs[6700];
			LeftGate = Core.Kernel.Sobs[6701];
			RightGate = Core.Kernel.Sobs[6702];
			
			string winner = Core.SystemVariables.Variables["GuildWarsWinner"];
			string last = Core.SystemVariables.Variables["LastGuildWars"];
			if (!string.IsNullOrWhiteSpace(winner))
			{
				Core.Kernel.Guilds.TrySelect(winner, out WinnerGuild);
			}
			if (!string.IsNullOrWhiteSpace(last))
			{
				DateTime gwTime;
				if (!DateTime.TryParse(last, out gwTime))
					gwTime = DateTime.Now;
				
				LastGuildWars = gwTime;
			}
		}
		
		public static void Handle()
		{
			if (DateTime.Now.Hour == 03)
			{
				if (GW.Start())
					System.Threading.Thread.Sleep((60000) * 60);
			}
		}
		
		public bool Start()
		{
			if (!GW.IsOn)
			{
				if (DateTime.Now >= LastGuildWars.AddHours(1) || WinnerGuild == null)
				{
					GW.Round = 0;
					GW.IsOn = true;
					
					using (var msg = Packets.Message.MessageCore.CreateCenter(Core.MessageConst.GW_START))
					{
						Packets.Message.MessageCore.SendGlobalMessage(msg);
					}
					return true;
				}
			}
			return false;
		}
		public bool IsOn = false;
		
		public Data.Guild[] GetTop5()
		{
			if (Core.Kernel.Guilds.Count == 0)
				return new Data.Guild[0];
			
			System.Collections.Generic.KeyValuePair<uint, Data.Guild>[]
				OrderGuilds = Core.Kernel.Guilds.selectorCollection1.OrderBy(guild => guild.Value.GWDamage).ToArray();
			
			Array.Reverse(OrderGuilds);
			int len = Math.Min(5, OrderGuilds.Length);
			
			Data.Guild[] guilds = new ProjectX_V3_Game.Data.Guild[len];
			for (int i = 0; i < len; i++)
			{
				guilds[i] = OrderGuilds[i].Value;
			}
			
			return guilds;
		}
		
		public Data.Guild GetWinner()
		{
			Data.Guild[] TopGuilds = GetTop5();
			if (TopGuilds.Length == 0)
				return null;
			return TopGuilds[0];
		}
		
		public void UpdateBroadcast()
		{
			Data.Guild[] TopGuilds = GetTop5();
			if (TopGuilds.Length == 0)
				return;
			string[] Messages = new string[TopGuilds.Length];
			int scorecount = 1;
			for (int i = 0; i< TopGuilds.Length; i++)
			{
				if (TopGuilds[i].GWDamage > 0)
				{
					Messages[i] = string.Format(Core.MessageConst.GW_SCORE, scorecount, TopGuilds[i].Name, TopGuilds[i].GWDamage);
					scorecount++;
				}
				else
					Messages[i] = "";
			}
			//string GuildPoleHP = string.Format("Pole: {0}/{1}",
			
			foreach (Maps.IMapObject mapObject in Map.MapObjects.Values)
			{
				if (mapObject is Entities.GameClient)
				{
					Entities.GameClient client = mapObject as Entities.GameClient;
					
					#region Clear
					using (var msg = Packets.Message.MessageCore.ClearScore())
					{
						client.Send(msg);
					}
					#endregion
					
					#region Score
					for (int i = 0; i< Messages.Length; i++)
					{
						if (string.IsNullOrWhiteSpace(Messages[i]))
							break;
						
						using (var msg = Packets.Message.MessageCore.CreateScore(Messages[i]))
						{
							client.Send(msg);
						}
					}
					#endregion
				}
			}
		}
		
		public override bool HandleAttack(ProjectX_V3_Game.Entities.GameClient Attacker, ProjectX_V3_Game.Entities.GameClient Attacked, ref uint damage)
		{
			return true;
		}
		
		public override bool HandleBeginAttack(ProjectX_V3_Game.Entities.GameClient Attacker)
		{
			return true;
		}
		
		public override bool HandleBeginHit_Magic(ProjectX_V3_Game.Entities.GameClient Attacker, ProjectX_V3_Game.Packets.UseSpellPacket usespell)
		{
			return true;
		}
		
		public override bool HandleBeginHit_Physical(ProjectX_V3_Game.Entities.GameClient Attacker)
		{
			return true;
		}
		
		public override bool HandleBeginHit_Ranged(ProjectX_V3_Game.Entities.GameClient Attacker)
		{
			return true;
		}
		
		public override bool HandleDeath(ProjectX_V3_Game.Entities.GameClient Attacker, ProjectX_V3_Game.Entities.GameClient Attacked)
		{
			return true;
		}
		
		public override bool HandleRevive(ProjectX_V3_Game.Entities.GameClient Killed)
		{
			if (Killed.LastMapID == Map.MapID)
				Killed.Teleport(1002, 400, 400);
			else
				Killed.Teleport(Killed.LastMapID, Killed.LastMapX, Killed.LastMapY);
			return false;
		}
		
		public override void KillMob(ProjectX_V3_Game.Entities.GameClient Attacker, uint MobUID)
		{
			
		}
		
		public override bool LeaveArea(ProjectX_V3_Game.Entities.GameClient client)
		{
			return true;
		}
		
		public override bool EnterArea(ProjectX_V3_Game.Entities.GameClient client)
		{
			if (LeftGateOpen || RightGateOpen)
				return true;
			if (client.Guild != null)
			{
				if (client.Guild.Name == GuildPole.Name)
					return true;
			}
			
			if (client.X <= LeftGate.X && client.Y <= LeftGate.Y)
			{
				client.Teleport(client.Map.MapID, (ushort)(LeftGate.X + 1), (ushort)(LeftGate.Y + 1));
				client.LastX = (ushort)(LeftGate.X + 1);
				client.LastY = (ushort)(LeftGate.Y + 1);
				return false;
			}
			else if (client.X <= RightGate.X && client.Y <= RightGate.Y)
			{
				client.Teleport(client.Map.MapID, (ushort)(RightGate.X + 1), (ushort)(RightGate.Y + 1));
				client.LastX = (ushort)(RightGate.X + 1);
				client.LastY = (ushort)(RightGate.Y + 1);
				return false;
			}
			return true;
		}
		
		public override void ChangeMap(ProjectX_V3_Game.Entities.GameClient client)
		{
			if (client.Map.MapID == Map.MapID)
			{
				client.Battle = this;
				UpdateBroadcast();
			}
			else if (client.LastMapID == Map.MapID)
			{
				if (client.Battle is GuildWars)
					client.Battle = null;
				
				#region Clear
				using (var msg = Packets.Message.MessageCore.ClearScore())
				{
					client.Send(msg);
				}
				#endregion
			}
		}
		
		public void Handle_GuildPole(Entities.Sob sob, Entities.IEntity attacker, int damage)
		{
			if (!IsOn)
				return;
			if (!(attacker is Entities.GameClient))
				return;
			Entities.GameClient attackerClient = (attacker as Entities.GameClient);
			if (attackerClient.Guild == null)
				return;
			if (attackerClient.Guild.Name == GuildPole.Name)
				return;
			
			attackerClient.Guild.GWDamage += damage;
			sob.HP -= damage;
			
			UpdateBroadcast();
			
			if (sob.HP < 0)
			{
				Data.Guild Winner = GetWinner();
				if (Winner != null)
				{
					#region clear score
					foreach (Maps.IMapObject mapObject in Map.MapObjects.Values)
					{
						if (mapObject is Entities.GameClient)
						{
							Entities.GameClient client = mapObject as Entities.GameClient;
							
							#region Clear
							using (var msg = Packets.Message.MessageCore.ClearScore())
							{
								client.Send(msg);
							}
							#endregion
						}
					}
					#endregion

					Round++;
					
					if (Round >= 3)
					{
						GuildPole.HP = GuildPole.MaxHP;
						GuildPole.Name = Winner.Name;
						GuildPole.Screen.FullUpdate();
						SaveWinner(Winner.Name);
						WinnerGuild = Winner;
						
						LeftGateOpen = false;
						LeftGate.HP = GuildPole.MaxHP;
						LeftGate.Screen.FullUpdate();
						RightGateOpen = false;
						RightGate.HP = GuildPole.MaxHP;
						RightGate.Screen.FullUpdate();
						
						foreach (Data.Guild guild in Core.Kernel.Guilds.selectorCollection1.Values)
							guild.GWDamage = 0;
						
						IsOn = false;
						
						foreach (Maps.IMapObject mapObject in Map.MapObjects.Values)
						{
							if (mapObject is Entities.GameClient)
							{
								Entities.GameClient client = mapObject as Entities.GameClient;
								if (client.Guild.Name == GuildPole.Name)
									continue;
								
								if (client.LastMapID == Map.MapID)
									client.Teleport(1002, 400, 400);
								else
									client.Teleport(client.LastMapID, client.LastMapX, client.LastMapY);
							}
						}
						
						using (var msg = Packets.Message.MessageCore.CreateCenter(
							string.Format(Core.MessageConst.GW_WIN_FINAL, Winner.Name)))
						{
							Packets.Message.MessageCore.SendGlobalMessage(msg);
						}
					}
					else
					{
						GuildPole.HP = GuildPole.MaxHP;
						GuildPole.Name = Winner.Name;
						GuildPole.Screen.FullUpdate();
						
						LeftGateOpen = false;
						LeftGate.HP = GuildPole.MaxHP;
						LeftGate.Screen.FullUpdate();
						RightGateOpen = false;
						RightGate.HP = GuildPole.MaxHP;
						RightGate.Screen.FullUpdate();
						
						foreach (Data.Guild guild in Core.Kernel.Guilds.selectorCollection1.Values)
							guild.GWDamage = 0;
						
						foreach (Maps.IMapObject mapObject in Map.MapObjects.Values)
						{
							if (mapObject is Entities.GameClient)
							{
								Entities.GameClient client = mapObject as Entities.GameClient;
								if (client.Guild.Name == GuildPole.Name)
									continue;
								
								if (client.LastMapID == Map.MapID)
									client.Teleport(1002, 400, 400);
								else
									client.Teleport(client.LastMapID, client.LastMapX, client.LastMapY);
							}
						}
						
						using (var msg = Packets.Message.MessageCore.CreateCenter(
							string.Format(Core.MessageConst.GW_WIN, Winner.Name)))
						{
							Packets.Message.MessageCore.SendGlobalMessage(msg);
						}
					}
				}
			}
		}
		public void Handle_LeftGate(Entities.Sob sob, Entities.IEntity attacker, int damage)
		{
			if (!IsOn)
				return;
			if (!(attacker is Entities.GameClient))
				return;
			if (LeftGateOpen)
				return;
			
			Entities.GameClient attackerClient = (attacker as Entities.GameClient);
			
			sob.HP -= damage;
			
			if (sob.HP < 0)
			{
				LeftGateOpen = true;
				sob.Screen.FullUpdate();
			}
		}
		public void Handle_RightGate(Entities.Sob sob, Entities.IEntity attacker, int damage)
		{
			if (!IsOn)
				return;
			if (!(attacker is Entities.GameClient))
				return;
			if (RightGateOpen)
				return;
			
			Entities.GameClient attackerClient = (attacker as Entities.GameClient);
			
			sob.HP -= damage;
			
			if (sob.HP < 0)
			{
				RightGateOpen = true;
				sob.Screen.FullUpdate();
			}
		}
		
		private void SaveWinner(string Name = "")
		{
			LastGuildWars = DateTime.Now;
			using (var sql = new SqlHandler(Program.Config.ReadString("GameConnectionString")))
			{
				using (var cmd = new SqlCommandBuilder(sql, SqlCommandType.UPDATE, true))
				{
					cmd.AddWhereValue("SystemVariableName", "GuildWarsWinner");
					cmd.AddUpdateValue("SystemVariableValue", Name);
					cmd.Finish("DB_SystemVariables");
				}
				sql.Execute();
			}
			using (var sql = new SqlHandler(Program.Config.ReadString("GameConnectionString")))
			{
				using (var cmd = new SqlCommandBuilder(sql, SqlCommandType.UPDATE, true))
				{
					cmd.AddWhereValue("SystemVariableName", "LastGuildWars");
					cmd.AddUpdateValue("SystemVariableValue", LastGuildWars.ToString());
					cmd.Finish("DB_SystemVariables");
				}
				sql.Execute();
			}
		}
	}
}
ProjectX_V3_Game\Core\MessageConst.cs [Add to it.]
Code:
#region GuildWars
		public const string GW_SCORE = "[{0}] {1}: {2}";
		public const string GW_WIN = "The winner of this round of GuildWars is {0}!";
		public const string GW_WIN_FINAL = "The final winner of GuildWars is {0}!";
		public const string GW_START = "GuildWars has started!";
		#endregion
ProjectX_V3_Game\Packets\Interaction\Battle\SobCom bat.cs
Code:
//Project by BaussHacker aka. L33TS

using System;

namespace ProjectX_V3_Game.Packets.Interaction.Battle
{
	/// <summary>
	/// Description of SobCombat.
	/// </summary>
	public class SobCombat
	{
		const uint GuildPole = 6700;
		const uint LeftGate = 6701;
		const uint RightGate = 6702;
		
		public static void Handle(Entities.Sob sob, Entities.IEntity attacker, int damage)
		{
			switch (sob.EntityUID)
			{
					#region GuildPole
				case GuildPole:
					Tournaments.GuildWars.GW.Handle_GuildPole(sob, attacker, damage);
					break;
					#endregion
					#region LeftGate
				case LeftGate:
					Tournaments.GuildWars.GW.Handle_LeftGate(sob, attacker, damage);
					break;
					#endregion
					#region RightGate
				case RightGate:
					Tournaments.GuildWars.GW.Handle_RightGate(sob, attacker, damage);
					break;
					#endregion				
			}
		}
	}
}
ProjectX_V3_Game\Packets\Interaction\Battle\Combat .cs
Code:
//Project by BaussHacker aka. L33TS

using System;

namespace ProjectX_V3_Game.Packets.Interaction.Battle
{
	/// <summary>
	/// Subtypes: ?
	/// </summary>
	public class Combat
	{
		/// <summary>
		/// Handling the combat of the interact packet.
		/// </summary>
		/// <param name="client">The client.</param>
		/// <param name="interact">The interact packet.</param>
		public static void Handle(Entities.GameClient client, InteractionPacket interact)
		{
			if (interact == null)
				return;
			
			if (!client.Alive)
				return;
			
			if (client.Paralyzed)
				return;
			
			if (!client.CanAttack)
				return;
			
			if (!(DateTime.Now >= client.LoginProtection.AddSeconds(10)))
			{
				using (var fmsg = Packets.Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.REST))
					client.Send(fmsg);
				return;
			}
			if (!(DateTime.Now >= client.ReviveProtection.AddSeconds(5)))
			{
				using (var fmsg = Packets.Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.REST))
					client.Send(fmsg);
				return;
			}
			
			if (!(DateTime.Now >= client.LastAttack.AddMilliseconds(Core.TimeIntervals.AttackInterval)) && client.AttackPacket == null)
			{
				using (var fmsg = Packets.Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.REST))
					client.Send(fmsg);
				return;
			}
			
			if (client.Battle != null)
			{
				if (!client.Battle.HandleBeginAttack(client))
				{
					using (var fmsg = Packets.Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.REST))
						client.Send(fmsg);
					return;
				}
			}
			client.LastAttack = DateTime.Now;
			//client.AutoAttacking = false;
			switch (interact.Action)
			{
				case Enums.InteractAction.MagicAttack:
					{
						#region TemporaryDecryption
						if (!interact.UnPacked)
						{
							interact.UnPacked = true;
							
							byte[] packet = interact.Copy();
							ushort SkillId = Convert.ToUInt16(((long)packet[24] & 0xFF) | (((long)packet[25] & 0xFF) << 8));
							SkillId ^= (ushort)0x915d;
							SkillId ^= (ushort)client.EntityUID;
							SkillId = (ushort)(SkillId << 0x3 | SkillId >> 0xd);
							SkillId -= 0xeb42;

							uint Target = ((uint)packet[12] & 0xFF) | (((uint)packet[13] & 0xFF) << 8) | (((uint)packet[14] & 0xFF) << 16) | (((uint)packet[15] & 0xFF) << 24);
							Target = ((((Target & 0xffffe000) >> 13) | ((Target & 0x1fff) << 19)) ^ 0x5F2D2463 ^ client.EntityUID) - 0x746F4AE6;

							ushort TargetX = 0;
							ushort TargetY = 0;
							long xx = (packet[16] & 0xFF) | ((packet[17] & 0xFF) << 8);
							long yy = (packet[18] & 0xFF) | ((packet[19] & 0xFF) << 8);
							xx = xx ^ (client.EntityUID & 0xffff) ^ 0x2ed6;
							xx = ((xx << 1) | ((xx & 0x8000) >> 15)) & 0xffff;
							xx |= 0xffff0000;
							xx -= 0xffff22ee;
							yy = yy ^ (client.EntityUID & 0xffff) ^ 0xb99b;
							yy = ((yy << 5) | ((yy & 0xF800) >> 11)) & 0xffff;
							yy |= 0xffff0000;
							yy -= 0xffff8922;
							TargetX = Convert.ToUInt16(xx);
							TargetY = Convert.ToUInt16(yy);
							
							interact.TargetUID = Target;
							interact.MagicType = SkillId;
							interact.X = TargetX;
							interact.Y = TargetY;
						}
						#endregion
						
						if (client.ContainsFlag1(Enums.Effect1.Riding) && interact.MagicType != 7001)
						{
							if (client.Stamina >= 100)
							{
								client.Stamina = 0;
								client.RemoveFlag1(Enums.Effect1.Riding);
							}
							return;
						}
						
						Magic.Handle(client, interact);
						break;
					}
				case Enums.InteractAction.Attack:
					if (client.ContainsFlag1(Enums.Effect1.Riding))
					{
						if (client.Stamina >= 100)
						{
							client.Stamina = 0;
							client.RemoveFlag1(Enums.Effect1.Riding);
						}
						return;
					}
					Physical.Handle(client, interact);
					break;
				case Enums.InteractAction.Shoot:
					if (client.ContainsFlag1(Enums.Effect1.Riding))
					{
						if (client.Stamina >= 100)
						{
							client.Stamina = 0;
							client.RemoveFlag1(Enums.Effect1.Riding);
						}
						return;
					}
					Ranged.Handle(client, interact);
					break;
			}
		}
		
		/// <summary>
		/// Processing damage.
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="damage">The damage.</param>
		public static void ProcessDamage(Entities.IEntity attacker, Entities.IEntity attacked, ref uint damage, bool kill_damage = true)
		{
			// Removed dura, bugged atm. the dura works, although client doesn't update proper etc. CBA to fix it as I never intended to use it
			// Although you can go ahead and fix it yourself if you want, I may do it if I ever feel like it
			// The dura lose is commented out below.
			#region ATTACKER : GAMECLIENT
			if (attacker is Entities.GameClient)
			{
				Entities.GameClient attackerclient = attacker as Entities.GameClient;
				attackerclient.LoseAttackDura(damage);
				
				#region ATTACKED : GAMECLIENT
				if (attacked is Entities.GameClient)
				{
					Entities.GameClient attackedclient = attacked as Entities.GameClient;
					// tournament check, damage = 1 + return
					if (attackerclient.Battle != null)
					{
						if (!attackerclient.Battle.HandleAttack(attackerclient, attackedclient, ref damage))
						{
							damage = 0;
							return;
						}
					}
					else
					{
						if (attacked.Map.GotKillCons() && !attackedclient.ContainsFlag1(Enums.Effect1.BlueName) && !attackedclient.ContainsFlag1(Enums.Effect1.RedName) && !attackedclient.ContainsFlag1(Enums.Effect1.BlackName))
						{
							attackerclient.AddStatusEffect1(Enums.Effect1.BlueName, 20000);
						}
						
						attackedclient.LoseDefenseDura(damage);
					}
				}
				#endregion
				#region ATTACKED : MONSTER
				else if (attacked is Entities.Monster)
				{
					Entities.Monster attackedmob = attacked as Entities.Monster;
					
					if (((byte)attackedmob.Behaviour) >= 3)
					{
						attackerclient.AddStatusEffect1(Enums.Effect1.BlueName, 20000);
					}
					if (damage > 0)
					{
						ulong exp = (ulong)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)(damage / 2), (int)damage);
						if (attacked.Level > (attacker.Level + 10))
							exp *= 2;
						else if (attacker.Level > (attacked.Level + 10))
							exp = (ulong)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(1, (int)attackedmob.Level);
						attackerclient.AddExp(exp);
					}
				}
				#endregion
				#region ATTACKED : SOB
				/*else if (attacked is Entities.Sob)
				{
					Entities.Sob attackedsob = attacked as Entities.Sob;
					
					if (damage > 0)
					{
						// Do stuff ...
					}
				}*/
				#endregion
				//if (Calculations.Battle.LoseDuraAttak())
				//attackerclient.LoseAttackDura(damage);
			}
			#endregion
			#region ATTACKER : MONSTER
			
			#region ATTACKED : GAMECLIENT
			if (attacked is Entities.GameClient)
			{
				Entities.GameClient attackedclient = attacked as Entities.GameClient;

				attackedclient.LoseDefenseDura(damage);
			}
			#endregion
			
			#endregion
			
			if (kill_damage)
			{
				HitDamage(attacker, attacked, damage);
			}
		}
		
		public static void HitDamage(Entities.IEntity attacker, Entities.IEntity attacked, uint damage)
		{
			if (attacked is Entities.Sob)
			{
				SobCombat.Handle(attacked as Entities.Sob, attacker, (int)damage);
			}
			else
			{
				attacked.HP -= (int)damage;
				if (attacked.HP <= 0)
				{
					Kill(attacker, attacked, damage);
				}
			}
		}
		
		/// <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);
			}
		}
		
		public static bool FixTarget(Entities.IEntity attacker, Entities.IEntity target)
		{
			if (attacker is Entities.GameClient && target is Entities.GameClient)
			{
				if ((attacker as Entities.GameClient).PKMode == Enums.PKMode.Team)
				{
					if ((attacker as Entities.GameClient).Team != null)
					{
						if ((attacker as Entities.GameClient).Team.Members.ContainsKey(target.EntityUID))
							return false;
					}
					else if ((attacker as Entities.GameClient).Guild != null)
					{
						if ((attacker as Entities.GameClient).Guild.Members.Contains((target as Entities.GameClient).DatabaseUID))
							return false;
						else if ((attacker as Entities.GameClient).Guild != null)
						{
							if ((attacker as Entities.GameClient).Guild.IsAllie((target as Entities.GameClient).Guild.Name))
								return false;
						}
					}
				}
			}
			return true;
		}
	}
}
ProjectX_V3_Game\Calculations\Battle.cs
Code:
//Project by BaussHacker aka. L33TS

using System;

namespace ProjectX_V3_Game.Calculations
{
	/// <summary>
	/// Calculations used for battle / combat.
	/// </summary>
	public class Battle
	{
		/// <summary>
		/// Returns a boolean defining whether the attack is a success. [Unused atm.]
		/// </summary>
		/// <param name="Percentage">The percentage.</param>
		/// <returns>Returns true if the attack is a success.</returns>
		public static bool AttackSuccess(double Percentage)
		{
			return false;
		}
		
		/// <summary>
		/// Getting a boolean defining whether or not defense dura can be lost.
		/// </summary>
		/// <returns>Returns true if the chance is success.</returns>
		public static bool LoseDuraDefense()
		{
			return false;
			//return BasicCalculations.ChanceSuccess(2); // 10 % chance
		}
		
		/// <summary>
		/// Getting a boolean defining whether or not attack dura can be lost.
		/// </summary>
		/// <returns>Returns true if the chance is success.</returns>
		public static bool LoseDuraAttack()
		{
			return false;
			//return BasicCalculations.ChanceSuccess(1); // 3 % chance
		}
		
		#region Physical
		/// <summary>
		/// Gets the physical damage.
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <returns>Returns the damage.</returns>
		public static uint GetPhysicalDamage(Entities.IEntity attacker, Entities.IEntity attacked)
		{
			double damage = 0;
			if (attacker is Entities.GameClient)
			{
				if (attacked is Entities.GameClient)
					damage = GetPhysicalDamage_PVP((attacker as Entities.GameClient), (attacked as Entities.GameClient));
				else if (attacked is Entities.Monster)
					damage = GetPhysicalDamage_PVM((attacker as Entities.GameClient), (attacked as Entities.Monster));
				else if (attacked is Entities.Sob)
					damage = GetPhysicalDamage_PVS((attacker as Entities.GameClient));
			}
			if (attacker is Entities.Monster)
			{
				if (attacked is Entities.GameClient)
					damage = GetPhysicalDamage_MVP((attacker as Entities.Monster), (attacked as Entities.GameClient));
				else if (attacked is Entities.Monster)
					damage = GetPhysicalDamage_MVM((attacker as Entities.Monster), (attacked as Entities.Monster));
			}
			if (damage > 1)
			{
				if (attacker.Level > (attacked.Level + 10))
					damage *= 1.25;
				else if ((attacker.Level + 10) < attacked.Level)
					damage = (damage * 0.75);
			}
			damage = (damage >= 1 ? damage : 1);
			if (damage > 1)
			{
				damage += ((damage / 2) * attacker.Reborns);
			}
			return (uint)damage;
		}
		
		/// <summary>
		/// Gets the physical damage (PVP).
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetPhysicalDamage_PVP(Entities.GameClient attacker, Entities.GameClient attacked)
		{
			double damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(attacker.MinAttack, attacker.MaxAttack);
			damage *= 1 + attacker.DragonGemPercentage;
			damage -= attacked.Defense;
			
			if (attacked.ContainsFlag1(Enums.Effect1.Shield))
				damage *= 0.5;
			if (attacker.ContainsFlag1(Enums.Effect1.Stig))
				damage *= 1.75;
			
			double damage_perc = damage;
			damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			damage -= damage_perc;
			damage_perc = (damage / 100) * attacked.Bless;
			damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the physical damage (PVM).
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetPhysicalDamage_PVM(Entities.GameClient attacker, Entities.Monster attacked)
		{
			double damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(attacker.MinAttack, attacker.MaxAttack);
			damage *= 1 + attacker.DragonGemPercentage;
			damage -= attacked.Defense;
			
			if (attacker.ContainsFlag1(Enums.Effect1.Stig))
				damage *= 1.75;
			//double damage_perc = damage;
			//damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//damage -= damage_perc;
			//damage_perc = (damage / 100) * attacked.Bless;
			//damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the physical damage (PVS).
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetPhysicalDamage_PVS(Entities.GameClient attacker)
		{
			double damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(attacker.MinAttack, attacker.MaxAttack);
			damage *= 1 + attacker.DragonGemPercentage;
			
			if (attacker.ContainsFlag1(Enums.Effect1.Stig))
				damage *= 1.75;
			//double damage_perc = damage;
			//damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//damage -= damage_perc;
			//damage_perc = (damage / 100) * attacked.Bless;
			//damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the physical damage (MVP).
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetPhysicalDamage_MVP(Entities.Monster attacker, Entities.GameClient attacked)
		{
			double damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)attacker.MinAttack, (int)attacker.MaxAttack);
			//damage *= 1 + attacker.DragonGemPercentage;
			damage -= attacked.Defense;
			
			if (attacked.ContainsFlag1(Enums.Effect1.Shield))
				damage *= 0.5;
			
			double damage_perc = damage;
			damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			damage -= damage_perc;
			damage_perc = (damage / 100) * attacked.Bless;
			damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the physical damage (MVM).
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetPhysicalDamage_MVM(Entities.Monster attacker, Entities.Monster attacked)
		{
			double damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)attacker.MinAttack, (int)attacker.MaxAttack);
			//damage *= 1 + attacker.DragonGemPercentage;
			damage -= attacked.Defense;
			//double damage_perc = damage;
			//damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//damage -= damage_perc;
			//damage_perc = (damage / 100) * attacked.Bless;
			//damage -= damage_perc;
			
			return damage;
		}
		#endregion
		#region Ranged
		/// <summary>
		/// Gets the ranged damage.
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <returns>Returns the damage.</returns>
		public static uint GetRangedDamage(Entities.IEntity attacker, Entities.IEntity attacked)
		{
			double damage = 0;
			if (attacker is Entities.GameClient)
			{
				if (attacked is Entities.GameClient)
					damage = GetRangedDamage_PVP((attacker as Entities.GameClient), (attacked as Entities.GameClient));
				if (attacked is Entities.Monster)
					damage = GetRangedDamage_PVM((attacker as Entities.GameClient), (attacked as Entities.Monster));
				if (attacked is Entities.Sob)
					damage = GetRangedDamage_PVS((attacker as Entities.GameClient));
			}
			if (damage > 1)
			{
				if (attacker.Level > (attacked.Level + 10))
					damage *= 1.25;
				else if ((attacker.Level + 10) < attacked.Level)
					damage = (damage * 0.75);
			}
			damage = (damage >= 1 ? damage : 1);
			if (damage > 1)
			{
				damage += ((damage / 2) * attacker.Reborns);
			}
			return (uint)damage;
		}
		
		/// <summary>
		/// Gets the ranged damage. (PVP)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetRangedDamage_PVP(Entities.GameClient attacker, Entities.GameClient attacked)
		{
			double damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(attacker.MinAttack, attacker.MaxAttack);
			damage *= 1 - (attacked.Dodge * 0.01);
			damage *= 0.45;
			
			if (attacker.ContainsFlag1(Enums.Effect1.Stig))
				damage *= 1.75;
			
			damage *= 1 + attacker.DragonGemPercentage;
			
			double damage_perc = damage;
			damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			damage -= damage_perc;
			damage_perc = (damage / 100) * attacked.Bless;
			damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the ranged damage. (PVM)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetRangedDamage_PVM(Entities.GameClient attacker, Entities.Monster attacked)
		{
			double damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(attacker.MinAttack, attacker.MaxAttack);
			damage *= 1 - (attacked.Dodge * 0.01);
			damage *= 0.45;
			
			if (attacker.ContainsFlag1(Enums.Effect1.Stig))
				damage *= 1.75;
			
			damage *= 1 + attacker.DragonGemPercentage;
			//double damage_perc = damage;
			//damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//damage -= damage_perc;
			//damage_perc = (damage / 100) * attacked.Bless;
			//damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the ranged damage. (PVS)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetRangedDamage_PVS(Entities.GameClient attacker)
		{
			double damage = ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(attacker.MinAttack, attacker.MaxAttack);
			damage *= 0.45;
			
			if (attacker.ContainsFlag1(Enums.Effect1.Stig))
				damage *= 1.75;
			
			damage *= 1 + attacker.DragonGemPercentage;
			//double damage_perc = damage;
			//damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//damage -= damage_perc;
			//damage_perc = (damage / 100) * attacked.Bless;
			//damage -= damage_perc;
			
			return damage;
		}
		#endregion
		#region Magic
		/// <summary>
		/// Gets the magic damage.
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="spell">The spell.</param>
		/// <returns>Returns the damage.</returns>
		public static uint GetMagicDamage(Entities.IEntity attacker, Entities.IEntity attacked, Data.Spell spell)
		{
			double damage = 0;
			if (attacker is Entities.GameClient)
			{
				if (attacked is Entities.GameClient)
					damage = GetMagicDamage_PVP((attacker as Entities.GameClient), (attacked as Entities.GameClient), spell);
				else if (attacked is Entities.Monster)
					damage = GetMagicDamage_PVM((attacker as Entities.GameClient), (attacked as Entities.Monster), spell);
				else if (attacked is Entities.Sob)
					damage = GetMagicDamage_PVS((attacker as Entities.GameClient), spell);
			}
			if (attacker is Entities.Monster)
			{
				if (attacked is Entities.GameClient)
					damage = GetMagicDamage_MVP((attacker as Entities.Monster), (attacked as Entities.GameClient), spell);
				else if (attacked is Entities.Monster)
					damage = GetMagicDamage_MVM((attacker as Entities.Monster), (attacked as Entities.Monster), spell);
			}
			if (damage > 1)
			{
				if (attacker.Level > (attacked.Level + 10))
					damage *= 1.25;
				else if ((attacker.Level + 10) < attacked.Level)
					damage = (damage * 0.75);
			}
			damage = (damage >= 1 ? damage : 1);
			if (damage > 1)
			{
				damage += ((damage / 2) * attacker.Reborns);
			}
			return (uint)damage;
		}
		
		/// <summary>
		/// Gets the magic damage. (PVP)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="spell">The spell.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetMagicDamage_PVP(Entities.GameClient attacker, Entities.GameClient attacked, Data.Spell spell)
		{
			double damage = (double)attacker.MagicAttack;
			damage -= attacked.MagicDefense;
			damage *= 0.65;
			damage += spell.Power;
			damage *= 1 + attacker.PhoenixGemPercentage;
			//	damage -= attacked.Defense;
			double damage_perc = damage;
			damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			damage -= damage_perc;
			damage_perc = (damage / 100) * attacked.Bless;
			damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the magic damage. (PVM)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="spell">The spell.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetMagicDamage_PVM(Entities.GameClient attacker, Entities.Monster attacked, Data.Spell spell)
		{
			double damage = (double)attacker.MagicAttack;
			damage -= attacked.MagicDefense;
			damage *= 0.65;
			damage += spell.Power;
			damage *= 1 + attacker.PhoenixGemPercentage;
			//	damage -= attacked.Defense;
			//	double damage_perc = damage;
			//	damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//	damage -= damage_perc;
			//	damage_perc = (damage / 100) * attacked.Bless;
			//	damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the magic damage. (PVS)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="spell">The spell.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetMagicDamage_PVS(Entities.GameClient attacker, Data.Spell spell)
		{
			double damage = (double)attacker.MagicAttack;
			
			damage *= 0.65;
			damage += spell.Power;
			damage *= 1 + attacker.PhoenixGemPercentage;
			//	damage -= attacked.Defense;
			//	double damage_perc = damage;
			//	damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//	damage -= damage_perc;
			//	damage_perc = (damage / 100) * attacked.Bless;
			//	damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the magic damage. (MVP)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="spell">The spell.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetMagicDamage_MVP(Entities.Monster attacker, Entities.GameClient attacked, Data.Spell spell)
		{
			double damage = (double)attacker.MaxAttack;
			damage -= attacked.MagicDefense;
			damage *= 0.65;
			damage += spell.Power;
			//damage *= 1 + attacker.PhoenixGemPercentage;
			//	damage -= attacked.Defense;
			//	double damage_perc = damage;
			//	damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//	damage -= damage_perc;
			//	damage_perc = (damage / 100) * attacked.Bless;
			//	damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the magic damage. (MVM)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="spell">The spell.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetMagicDamage_MVM(Entities.Monster attacker, Entities.Monster attacked, Data.Spell spell)
		{
			double damage = attacker.MaxAttack;
			damage -= attacked.MagicDefense;
			damage *= 0.65;
			damage += spell.Power;
			//	damage *= 1 + attacker.PhoenixGemPercentage;
			//	damage -= attacked.Defense;
			//	double damage_perc = damage;
			//	damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//	damage -= damage_perc;
			//	damage_perc = (damage / 100) * attacked.Bless;
			//	damage -= damage_perc;
			
			return damage;
		}
		#endregion
		#region PhysicalMagic
		/// <summary>
		/// Gets the physical magic damage.
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="spell">The spell.</param>
		/// <returns>Returns the damage.</returns>
		public static uint GetPhysicalMagicDamage(Entities.IEntity attacker, Entities.IEntity attacked, Data.Spell spell)
		{
			double damage = 0;
			if (attacker is Entities.GameClient)
			{
				if (attacked is Entities.GameClient)
					damage = GetPhysicalMagicDamage_PVP((attacker as Entities.GameClient), (attacked as Entities.GameClient), spell);
				else if (attacked is Entities.Monster)
					damage = GetPhysicalMagicDamage_PVM((attacker as Entities.GameClient), (attacked as Entities.Monster), spell);
				else if (attacked is Entities.Sob)
					damage = GetPhysicalMagicDamage_PVS((attacker as Entities.GameClient), spell);
			}
			if (attacker is Entities.Monster)
			{
				if (attacked is Entities.GameClient)
					damage = GetPhysicalMagicDamage_MVP((attacker as Entities.Monster), (attacked as Entities.GameClient), spell);
				else if (attacked is Entities.Monster)
					damage = GetPhysicalMagicDamage_MVM((attacker as Entities.Monster), (attacked as Entities.Monster), spell);
			}
			if (damage > 1)
			{
				if (attacker.Level > (attacked.Level + 10))
					damage *= 1.25;
				else if ((attacker.Level + 10) < attacked.Level)
					damage = (damage * 0.75);
			}
			damage = (damage >= 1 ? damage : 1);
			if (damage > 1)
			{
				damage += ((damage / 2) * attacker.Reborns);
			}
			return (uint)damage;
		}
		
		/// <summary>
		/// Gets the magic damage. (PVP)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="spell">The spell.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetPhysicalMagicDamage_PVP(Entities.GameClient attacker, Entities.GameClient attacked, Data.Spell spell)
		{
			double damage = (double) ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(attacker.MinAttack, attacker.MaxAttack * 2);
			
			damage -= attacked.Defense;
			damage *= 0.65;
			// penetration extra damage
			if (spell.SpellID == 1290 && damage > 0)
			{
				double hunperc = (double)((damage / 100) * 26.6);
				damage += (hunperc * spell.Level);
			}
			//	damage += spell.Power;
			damage *= 1 + attacker.DragonGemPercentage;
			
			if (attacked.ContainsFlag1(Enums.Effect1.Shield))
				damage *= 0.5;
			
			//	damage -= attacked.Defense;
			double damage_perc = damage;
			damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			damage -= damage_perc;
			damage_perc = (damage / 100) * attacked.Bless;
			damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the physical magic damage. (PVM)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="spell">The spell.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetPhysicalMagicDamage_PVM(Entities.GameClient attacker, Entities.Monster attacked, Data.Spell spell)
		{
			double damage = (double) ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(attacker.MinAttack, attacker.MaxAttack * 2);
			
			damage -= attacked.Defense;
			damage *= 0.65;
			// penetration extra damage
			if (spell.SpellID == 1290 && damage > 0)
			{
				double hunperc = (double)((damage / 100) * 26.6);
				damage += (hunperc * spell.Level);
			}
			//damage += spell.Power;
			damage *= 1 + attacker.DragonGemPercentage;
			//	damage -= attacked.Defense;
			//	double damage_perc = damage;
			//	damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//	damage -= damage_perc;
			//	damage_perc = (damage / 100) * attacked.Bless;
			//	damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the physical magic damage. (PVS)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="spell">The spell.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetPhysicalMagicDamage_PVS(Entities.GameClient attacker, Data.Spell spell)
		{
			double damage = (double) ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(attacker.MinAttack, attacker.MaxAttack * 2);
			
			damage *= 0.65;
			// penetration extra damage
			if (spell.SpellID == 1290 && damage > 0)
			{
				double hunperc = (double)((damage / 100) * 26.6);
				damage += (hunperc * spell.Level);
			}
			//damage += spell.Power;
			damage *= 1 + attacker.DragonGemPercentage;
			//	damage -= attacked.Defense;
			//	double damage_perc = damage;
			//	damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//	damage -= damage_perc;
			//	damage_perc = (damage / 100) * attacked.Bless;
			//	damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the physical magic damage. (MVP)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="spell">The spell.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetPhysicalMagicDamage_MVP(Entities.Monster attacker, Entities.GameClient attacked, Data.Spell spell)
		{
			double damage = (double) ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)attacker.MaxAttack, (int)attacker.MaxAttack * 2);
			
			damage -= attacked.Defense;
			damage *= 0.65;
			// penetration extra damage
			if (spell.SpellID == 1290 && damage > 0)
			{
				double hunperc = (double)((damage / 100) * 26.6);
				damage += (hunperc * spell.Level);
			}
			
			if (attacked.ContainsFlag1(Enums.Effect1.Shield))
				damage *= 0.5;
			//	damage += spell.Power;
			//damage *= 1 + attacker.PhoenixGemPercentage;
			//	damage -= attacked.Defense;
			//	double damage_perc = damage;
			//	damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//	damage -= damage_perc;
			//	damage_perc = (damage / 100) * attacked.Bless;
			//	damage -= damage_perc;
			
			return damage;
		}
		
		/// <summary>
		/// Gets the physical magic damage. (MVM)
		/// </summary>
		/// <param name="attacker">The attacker.</param>
		/// <param name="attacked">The attacked.</param>
		/// <param name="spell">The spell.</param>
		/// <returns>Returns the damage.</returns>
		private static double GetPhysicalMagicDamage_MVM(Entities.Monster attacker, Entities.Monster attacked, Data.Spell spell)
		{
			double damage = (double) ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)attacker.MaxAttack, (int)attacker.MaxAttack * 2);
			
			damage -= attacked.Defense;
			damage *= 0.65;
			// penetration extra damage
			if (spell.SpellID == 1290 && damage > 0)
			{
				double hunperc = (double)((damage / 100) * 26.6);
				damage += (hunperc * spell.Level);
			}
			//damage += spell.Power;
			//	damage *= 1 + attacker.PhoenixGemPercentage;
			//	damage -= attacked.Defense;
			//	double damage_perc = damage;
			//	damage_perc = (damage / 100) * attacked.TortoiseGemPercentage;
			//	damage -= damage_perc;
			//	damage_perc = (damage / 100) * attacked.Bless;
			//	damage -= damage_perc;
			
			return damage;
		}
		#endregion
	}
}
ProjectX_V3_Game\Entities\GameClient.cs [Replace Teleport()]
Code:
/// <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;
			
			#region Clear
			using (var clear = Packets.Message.MessageCore.ClearScore())
			{
				this.Send(clear);
			}
			#endregion
			
			if (Battle != null)
			{
				Battle.ChangeMap(this);
			}
			else
			{
				Tournaments.GuildWars.GW.ChangeMap(this);
			}
			
			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);
			}
			return true;
		}
ProjectX_V3_Game\Threads\GlobalThreads.cs [Add this entry.]
Code:
new BaseThread(Tournaments.GuildWars.Handle, 30000, "GuildWarsThread").Start();
ProjectX_V3_Game\Entities\Sob.cs
Code:
//Project by BaussHacker aka. L33TS
using System;

namespace ProjectX_V3_Game.Entities
{
	/// <summary>
	/// Description of Sob.
	/// </summary>
	public class Sob : IEntity, Maps.IMapObject
	{
		private NPC associatedNPC;
		
		public Sob(NPC associatedNPC)
		{
			this.associatedNPC = associatedNPC;
			_baseentity = new BaseEntity(this);
			_screen = new ProjectX_V3_Game.Core.Screen(this);
		}
		
		#region Global Variables
		/// <summary>
		/// The mesh of the sob.
		/// </summary>
		public ushort Mesh;
		
		/// <summary>
		/// The secondary mesh of the sob.
		/// </summary>
		public ushort SecondaryMesh;
		
		/// <summary>
		/// The mesh to show.
		/// </summary>
		public ushort ShowMesh;
		
		/// <summary>
		/// The flag of the sob.
		/// </summary>
		public ushort Flag;
		
		/// <summary>
		/// The sob type.
		/// </summary>
		public uint SobType;

		/// <summary>
		/// The original sob name.
		/// </summary>
		public string OriginalName;
		#endregion
		
		#region Properties
		/// <summary>
		/// The first status flag holder.
		/// </summary>
		private ulong _statusflag1;
		
		/// <summary>
		/// Gets or sets the first status flag.
		/// </summary>
		public ulong StatusFlag1
		{
			get { return _statusflag1; }
			set
			{
				_statusflag1 = value;
			}
		}
		
		/// <summary>
		/// The alive holder.
		/// </summary>
		private bool _alive = true;
		
		/// <summary>
		/// Gets or sets whether the npc is alive. (Although it's always alive ^~^)
		/// </summary>
		public bool Alive
		{
			get { return _alive; }
			set { _alive = value; }
		}
		
		/// <summary>
		/// The base entity holder.
		/// </summary>
		private BaseEntity _baseentity;
		
		/// <summary>
		/// Gets the base entity holder.
		/// </summary>
		public BaseEntity BaseEntity
		{
			get { return _baseentity; }
		}
		
		/// <summary>
		/// The reborn holder.
		/// </summary>
		private byte _reborns;
		
		/// <summary>
		/// Gets or sets the reborns of the character.
		/// </summary>
		public byte Reborns
		{
			get { return _reborns; }
			set
			{
				_reborns = value;
				this.BaseEntity.CalculateBaseStats();
			}
		}
		
		/// <summary>
		/// The class holder.
		/// </summary>
		private Enums.Class _class = Enums.Class.Other;
		
		/// <summary>
		/// Gets or sets the class.
		/// </summary>
		public Enums.Class Class
		{
			get { return _class; }
			set
			{
				_class = value;
				this.BaseEntity.CalculateBaseStats();
			}
		}
		
		/// <summary>
		/// Gets a boolean defining whether the client can update its own spawn and/or spawn to others.
		/// </summary>
		public bool CanUpdateSpawn
		{
			get { return true; }
		}
		
		/// <summary>
		/// The name holder.
		/// </summary>
		private string _name;
		
		/// <summary>
		/// Gets or sets the name of the npc.
		/// </summary>
		public string Name
		{
			get { return _name; }
			set { _name = value; }
		}
		
		/// <summary>
		/// The entity uid holder.
		/// </summary>
		private uint _entityuid;
		
		/// <summary>
		/// Gets or sets the entity UID of the npc.
		/// </summary>
		public uint EntityUID
		{
			get { return _entityuid; }
			set { _entityuid = value; }
		}
		
		/// <summary>
		/// The screen holder.
		/// </summary>
		private Core.Screen _screen;
		
		/// <summary>
		/// Gets the screen.
		/// </summary>
		public Core.Screen Screen
		{
			get { return _screen; }
		}
		
		/// <summary>
		/// The hp holder.
		/// </summary>
		private int _hp;
		
		/// <summary>
		/// Gets or sets the hp.
		/// </summary>
		public int HP
		{
			get { return _hp; }
			set
			{
				_hp = value;
			}
		}
		
		/// <summary>
		/// The mp holder.
		/// </summary>
		private int _mp;
		
		/// <summary>
		/// Gets or sets the mp.
		/// </summary>
		public int MP
		{
			get { return _mp; }
			set
			{
				_mp = value;
			}
		}
		
		/// <summary>
		/// The max hp holder.
		/// </summary>
		private int _maxhp;
		
		/// <summary>
		/// Gets or sets the max hp.
		/// </summary>
		public int MaxHP
		{
			get { return _maxhp; }
			set
			{
				_maxhp = value;
			}
		}
		
		/// <summary>
		/// The max mp holder.
		/// </summary>
		private int _maxmp;
		
		/// <summary>
		/// Gets or sets the maxmp.
		/// </summary>
		public int MaxMP
		{
			get { return _maxmp; }
			set
			{
				_maxmp = value;
			}
		}
		
		/// <summary>
		/// The level holder.
		/// </summary>
		private byte _level;
		
		/// <summary>
		/// Gets or sets the level.
		/// </summary>
		public byte Level
		{
			get { return _level; }
			set
			{
				_level = value;
			}
		}
		
		/// <summary>
		/// The lastmapid holder.
		/// </summary>
		private ushort _lastmapid;
		
		/// <summary>
		/// Gets or sets the last map.
		/// </summary>
		public ushort LastMapID
		{
			get { return _lastmapid; }
			set { _lastmapid = value; }
		}
		
		/// <summary>
		/// The x coordinate holder.
		/// </summary>
		private ushort _x;
		
		/// <summary>
		/// Gets or sets the x coordinate.
		/// </summary>
		public ushort X
		{
			get { return _x; }
			set
			{
				_x = value;
			}
		}
		
		/// <summary>
		/// The y coordinate holder.
		/// </summary>
		private ushort _y;
		
		/// <summary>
		/// Gets or sets the y coordinate.
		/// </summary>
		public ushort Y
		{
			get { return _y; }
			set
			{
				_y = value;
			}
		}
		
		/// <summary>
		/// The dynamic map holder.
		/// </summary>
		private Maps.DynamicMap _dynamicMap;
		
		/// <summary>
		/// Gets or sets the dynamic map for the npc.
		/// </summary>
		public Maps.DynamicMap DynamicMap
		{
			get { return _dynamicMap; }
			set { _dynamicMap = value; }
		}
		
		/// <summary>
		/// The map holder.
		/// </summary>
		private Maps.Map _map;
		
		/// <summary>
		/// Gets or sets the map.
		/// </summary>
		public Maps.Map Map
		{
			get { return _map; }
			set { _map = value; }
		}
		
		/// <summary>
		/// The direction holder.
		/// </summary>
		private byte _direction;
		
		/// <summary>
		/// Gets or sets the direction.
		/// </summary>
		public byte Direction
		{
			get { return _direction; }
			set { _direction = value; }
		}
		
		/// <summary>
		/// The strength holder.
		/// </summary>
		private ushort _strength;
		
		/// <summary>
		/// Gets or sets the strength.
		/// </summary>
		public ushort Strength
		{
			get { return _strength; }
			set
			{
				_strength = value;
				this.BaseEntity.CalculateBaseStats();
			}
		}
		
		/// <summary>
		/// The agility holder.
		/// </summary>
		private ushort _agility;
		
		/// <summary>
		/// Gets or sets the agility.
		/// </summary>
		public ushort Agility
		{
			get { return _agility; }
			set
			{
				_agility = value;
				this.BaseEntity.CalculateBaseStats();
			}
		}

		/// <summary>
		/// The vitality holder.
		/// </summary>
		private ushort _vitality;
		
		/// <summary>
		/// Gets or sets the vitality.
		/// </summary>
		public ushort Vitality
		{
			get { return _vitality; }
			set
			{
				_vitality = value;
				this.BaseEntity.CalculateBaseStats();
			}
		}
		
		/// <summary>
		/// The spirit holder.
		/// </summary>
		private ushort _spirit;
		
		/// <summary>
		/// Gets or sets the spirit.
		/// </summary>
		public ushort Spirit
		{
			get { return _spirit; }
			set
			{
				_spirit = value;
				this.BaseEntity.CalculateBaseStats();
			}
		}
		#endregion
		
		#region Core Methods
		public bool IsInMap(Maps.IMapObject MapObject)
		{
			if (DynamicMap != null)
			{
				if (MapObject.DynamicMap == null)
					return false;
				
				if (DynamicMap.DynamicID != MapObject.DynamicMap.DynamicID)
					return false;
			}
			return Map.MapID == MapObject.Map.MapID;
		}
		
		public Packets.SobSpawnPacket CreateSobSpawnPacket()
		{
			Packets.SobSpawnPacket spawn = new ProjectX_V3_Game.Packets.SobSpawnPacket(new Packets.StringPacker(Name));
			
			spawn.EntityUID = EntityUID;
			spawn.MaxHealth = (uint)MaxHP;
			spawn.Health = (uint)HP;
			spawn.X = X;
			spawn.Y = Y;
			spawn.Mesh = ShowMesh;
			spawn.Flag = Flag;
			
			return spawn;
		}
		
		public void Revive()
		{
			HP = MaxHP;
			Screen.FullUpdate();
		}
		
		[Obsolete("This method should never be called.")]
		public Packets.SpawnPacket CreateSpawnPacket()
		{
			throw new Exception("DO NOT CALL THIS!");
		}
		
		/// <summary>
		/// Calls the npc dialog associated with the npc.
		/// </summary>
		/// <param name="client">The client.</param>
		/// <param name="option">The dialog option.</param>
		public void CallDialog(GameClient client, byte option)
		{
			if (associatedNPC != null)
				associatedNPC.CallDialog(client, option);
		}
		#endregion
		
		#region Methods
		/*private int MoveCount = 0;
		private bool LastLeft = false;
		public void Move()
		{		
			new ProjectX_V3_Lib.Threading.BaseThread(MoveT, 500, "").Start();
		}
		private void MoveT()
		{
			if (LastLeft)
			{
				// move right
				using (var movepacket = new Packets.MovementPacket())
				{
					movepacket.EntityUID = mob.EntityUID;
					movepacket.TimeStamp = ProjectX_V3_Lib.Native.Winmm.timeGetTime();
					movepacket.Direction = (uint)Enums.ConquerAngle.East;
					movepacket.WalkMode = Enums.WalkMode.Run;
					mob.Screen.UpdateScreen(movepacket);
				}
			}
			else
			{
				// move left
				using (var movepacket = new Packets.MovementPacket())
				{
					movepacket.EntityUID = mob.EntityUID;
					movepacket.TimeStamp = ProjectX_V3_Lib.Native.Winmm.timeGetTime();
					movepacket.Direction = (uint)Enums.ConquerAngle.West;
					movepacket.WalkMode = Enums.WalkMode.Run;
					mob.Screen.UpdateScreen(movepacket);
				}
			}
			if (MoveCount >= 5)
			{
				LastLeft = !LastLeft;
				MoveCount = 0;
			}
		}
		*/
		#endregion
		
		#region Misc
		#endregion
	}
}
ProjectX_V3_Game\Core\Screen.cs
Code:
//Project by BaussHacker aka. L33TS

using System;
using System.Collections.Concurrent;
using ProjectX_V3_Lib.Network;
using System.Diagnostics;

namespace ProjectX_V3_Game.Core
{
	/// <summary>
	/// A screen class. TODO: Rewrite this to make it even faster and with better readability ;)
	/// </summary>
	[Serializable()]
	public class Screen
	{
		/// <summary>
		/// The collection of screen objects.
		/// </summary>
		public ConcurrentDictionary<uint, Maps.IMapObject> MapObjects;
		
		/// <summary>
		/// The collection of screen objects.
		/// </summary>
		public ConcurrentDictionary<uint, Maps.IMapObject> Items;
		
		/// <summary>
		/// The screen owner.
		/// </summary>
		private Maps.IMapObject Owner;
		
		/// <summary>
		/// Creates a new screen.
		/// </summary>
		/// <param name="owner">The owner of the screen.</param>
		public Screen(Maps.IMapObject owner)
		{
			Owner = owner;
			MapObjects = new ConcurrentDictionary<uint, ProjectX_V3_Game.Maps.IMapObject>();
			Items = new ConcurrentDictionary<uint, ProjectX_V3_Game.Maps.IMapObject>();
		}
		
		public void FullUpdate()
		{
			ClearScreen();
			UpdateScreen(null);
			foreach (Maps.IMapObject MapObject in MapObjects.Values)
			{
				if (MapObject is Entities.GameClient)
				{
					MapObject.Screen.UpdateScreen(null);
				}
			}
		}
		/// <summary>
		/// Clears the screen.
		/// </summary>
		public void ClearScreen()
		{
			foreach (Maps.IMapObject MapObject in MapObjects.Values)
			{
				try
				{
					MapObject.Screen.UpdateScreen(null);
					if (Owner is Data.GroundItem && MapObject is Entities.GameClient)
					{
						using (var itemspawn = (Owner as Data.GroundItem).CreateItemSpawnPacket(2))
						{
							itemspawn.X = 0;
							itemspawn.Y = 0;
							(MapObject as Entities.GameClient).Send(itemspawn);
						}
					}
					else
					{
						if (Owner is Entities.GameClient)
						{
							(Owner as Entities.GameClient).Send(Packets.GeneralDataPacket.Create(MapObject.EntityUID, Enums.DataAction.RemoveEntity, 0, 0, 0, 0, 0, 0));
						}
						if (MapObject is Entities.GameClient)
						{
							(MapObject as Entities.GameClient).Send(Packets.GeneralDataPacket.Create(Owner.EntityUID, Enums.DataAction.RemoveEntity, 0, 0, 0, 0, 0, 0));
						}
					}
					Remove(MapObject);
				}
				catch { }
			}
			foreach (Maps.IMapObject MapObject in Items.Values)
			{
				try
				{
					MapObject.Screen.UpdateScreen(null);
					if (Owner is Entities.GameClient)
					{
						using (var itemspawn = (MapObject as Data.GroundItem).CreateItemSpawnPacket(2))
						{
							itemspawn.X = 0;
							itemspawn.Y = 0;
							(Owner as Entities.GameClient).Send(itemspawn);
						}
					}
					Remove(MapObject);
				}
				catch { }
			}
			MapObjects.Clear();
			Items.Clear();
		}
		
		#region New
		/*
 * 		/// <summary>
		/// Adds a map object to the screen.
		/// </summary>
		/// <param name="MapObject">The map object to add.</param>
		public void AddToScreen(Maps.IMapObject MapObject)
		{
			if (MapObject is Data.GroundItem)
			{
				if (Items.ContainsKey(MapObject.EntityUID))
					return;
				Items.TryAdd(MapObject.EntityUID, MapObject);
			}
			else
			{
				if (MapObjects.ContainsKey(MapObject.EntityUID))
					return;
				MapObjects.TryAdd(MapObject.EntityUID, MapObject);
				
				if (MapObject is Entities.GameClient)
				{
					ProjectX_V3_Lib.Network.DataPacket spawn;
					if (Owner is Data.GroundItem)
						spawn = (Owner as Data.GroundItem).CreateItemSpawnPacket(1);
					else if (Owner is Entities.NPC)
						spawn = (Owner as Entities.NPC).CreateNPCSpawnPacket();
					else
						spawn = Owner.CreateSpawnPacket(); // Player + Monster + AI
					(MapObject as Entities.GameClient).Send(spawn);
				}
			}
		}
		
		public void UpdateScreen(DataPacket Packet, bool deadonly = false)
		{
			if (!Owner.CanUpdateSpawn)
				return;
			
			foreach (Maps.IMapObject MapObject in Owner.Map.MapObjects.Values)
			{
				if (MapObject == Owner)
					continue;
				
				if (ValidDistance(MapObject.X, MapObject.Y, Owner.X, Owner.Y))
				{
					bool CanSpawnTo = true;
					bool CanSpawnFrom = true;
					#region Owner is GameClient
					if (Owner is Entities.GameClient)
					{
						Entities.GameClient OwnerClient = Owner as Entities.GameClient;
						#region Arena Watch
						if (!OwnerClient.IsAIBot)
						{
							if (MapObject is Entities.GameClient)
							{
								Entities.GameClient ObjectClient = MapObject as Entities.GameClient;
								if (!ObjectClient.IsAIBot)
								{
									if (OwnerClient.ArenaMatch != null)
									{
										if (!OwnerClient.ArenaMatch.SpawnInArena(ObjectClient))
											CanSpawnTo = false;
									}
									else if (ObjectClient.ArenaMatch != null)
									{
										if (!ObjectClient.ArenaMatch.SpawnInArena(OwnerClient))
											CanSpawnFrom = false;
									}
								}
							}
						}
						#endregion
					}
					#endregion
					#region Owner is Monster
					if (Owner is Entities.Monster)
					{
						Entities.Monster OwnerMonster = Owner as Entities.Monster;
					}
					#endregion
					#region Owner is NPC
					if (Owner is Entities.NPC)
					{
						Entities.NPC OwnerNPC = Owner as Entities.NPC;
					}
					#endregion
					
					if (CanSpawnFrom)
					{
						AddToScreen(MapObject);
						MapObject.Screen.AddToScreen(Owner);
					}
					else
					{
						Remove(MapObject);
						MapObject.Screen.Remove(Owner);
					}
				}
				else
				{
					Remove(MapObject);
					MapObject.Screen.Remove(Owner);
				}
			}
			
			UpdateScreenItems();
		}
		
				/// <summary>
		/// Removes a mapobject from the screen.
		/// </summary>
		/// <param name="MapObject">The mapobject to remove.</param>
		public void Remove(Maps.IMapObject MapObject)
		{
			Maps.IMapObject rObject;
			if (MapObject is Data.GroundItem)
				Items.TryRemove(MapObject.EntityUID, out rObject);
			else if (MapObjects.TryRemove(MapObject.EntityUID, out rObject))
			{
				if (Owner is Entities.GameClient)
				{
					(Owner as Entities.GameClient).Send(Packets.GeneralDataPacket.Create(MapObject.EntityUID, Enums.DataAction.RemoveEntity, 0, 0, 0, 0, 0, 0));
				}
			}
			
			if (Owner is Data.GroundItem)
				MapObject.Screen.Items.TryRemove(Owner.EntityUID, out rObject);
		} */
		#endregion
		
		#region old
		public void AddToScreen(Maps.IMapObject MapObject)
		{
			if (MapObject is Data.GroundItem)
			{
				if (Items.ContainsKey(MapObject.EntityUID))
					return;
				Items.TryAdd(MapObject.EntityUID, MapObject);
			}
			else
			{
				if (MapObjects.ContainsKey(MapObject.EntityUID))
					return;
				MapObjects.TryAdd(MapObject.EntityUID, MapObject);
			}
		}
		
		/// <summary>
		/// Removes a mapobject from the screen.
		/// </summary>
		/// <param name="MapObject">The mapobject to remove.</param>
		public void Remove(Maps.IMapObject MapObject)
		{
			Maps.IMapObject rObject;
			if (MapObject is Data.GroundItem)
				Items.TryRemove(MapObject.EntityUID, out rObject);
			else
				MapObjects.TryRemove(MapObject.EntityUID, out rObject);
			
			if (Owner is Data.GroundItem)
				MapObject.Screen.Items.TryRemove(Owner.EntityUID, out rObject);
			else
				MapObject.Screen.MapObjects.TryRemove(Owner.EntityUID, out rObject);
		}
		
		/// <summary>
		/// Updates the screen.
		/// </summary>
		/// <param name="Packet">Set to null if sending no packets to the screen.</param>
		public void UpdateScreen(DataPacket Packet, bool deadonly = false)
		{
			if (!Owner.CanUpdateSpawn)
				return;

			foreach (Maps.IMapObject MapObject in MapObjects.Values)
			{
				try
				{
					if (MapObject == Owner)
						continue;
					if (!MapObject.IsInMap(Owner))
					{
						Remove(MapObject);
						continue;
					}
					if (ValidDistance(Owner.X, Owner.Y, MapObject.X, MapObject.Y) && MapObject.CanUpdateSpawn)
					{
						if (MapObject is Entities.Monster)
						{
							if (!(MapObject as Entities.Monster).Alive && (DateTime.Now >= (MapObject as Entities.Monster).DieTime.AddMilliseconds(5000)))
							{
								if (Owner is Entities.GameClient)
								{
									(Owner as Entities.GameClient).Send(Packets.GeneralDataPacket.Create(MapObject.EntityUID, Enums.DataAction.RemoveEntity, 0, 0, 0, 0, 0, 0));
								}
								
								Remove(MapObject);
								
								continue;
							}
						}
						
						if (Packet != null)
						{
							if (MapObject is Entities.GameClient)
							{
								Entities.GameClient client = MapObject as Entities.GameClient;
								if (client != null)
								{
									if (!client.IsAIBot) // if the person in screen is not a bot
									{
										if (client.ArenaMatch != null) // if the person in screen has an arena match
										{
											if ((Owner as Entities.GameClient).ArenaMatch == null) // the the owner does not have an arena match
											{
												if (!client.ArenaMatch.SpawnInArena((Owner as Entities.GameClient))) // if the owner is a watcher
													continue; // do not send any packets ...
											}
										}
									}
									
									if (!deadonly || deadonly && !client.Alive)
										client.Send(Packet);
								}
							}
						}
						MapObject.Screen.AddToScreen(MapObject);
					}
					else
					{
						if (Owner is Entities.GameClient)
						{
							(Owner as Entities.GameClient).Send(Packets.GeneralDataPacket.Create(MapObject.EntityUID, Enums.DataAction.RemoveEntity, 0, 0, 0, 0, 0, 0));
						}
						if (MapObject is Entities.GameClient)
						{
							(MapObject as Entities.GameClient).Send(Packets.GeneralDataPacket.Create(Owner.EntityUID, Enums.DataAction.RemoveEntity, 0, 0, 0, 0, 0, 0));
						}

						Remove(MapObject);
					}
				}
				catch { }
			}
			
			ProjectX_V3_Lib.Network.DataPacket spawn;
			if (Owner is Data.GroundItem)
				spawn = (Owner as Data.GroundItem).CreateItemSpawnPacket(1);
			else if (Owner is Entities.NPC)
				spawn = (Owner as Entities.NPC).CreateNPCSpawnPacket();
			else if (Owner is Entities.Sob)
				spawn = (Owner as Entities.Sob).CreateSobSpawnPacket();
			else
				spawn = Owner.CreateSpawnPacket(); // Player + Monster + AI
			
			foreach (Maps.IMapObject MapObject in Owner.Map.MapObjects.Values)
			{
				try
				{
					if (MapObject == Owner)
						continue;
					
					if (!MapObject.IsInMap(Owner))
					{
						Remove(MapObject);
						continue;
					}
					
					if (MapObjects.ContainsKey(MapObject.EntityUID))
						continue;
					
					if (ValidDistance(Owner.X, Owner.Y, MapObject.X, MapObject.Y) && MapObject.CanUpdateSpawn)
					{
						if (MapObject is Entities.Monster)
						{
							if (!(MapObject as Entities.Monster).Alive && (DateTime.Now >= (MapObject as Entities.Monster).DieTime.AddMilliseconds(5000)))
							{
								if (Owner is Entities.GameClient)
								{
									(Owner as Entities.GameClient).Send(Packets.GeneralDataPacket.Create(MapObject.EntityUID, Enums.DataAction.RemoveEntity, 0, 0, 0, 0, 0, 0));
								}
								
								Remove(MapObject);
								
								continue; // we don't want to add it, because it died before getting in screen
							}
						}
						if (MapObject is Entities.GameClient)
						{
							Entities.GameClient client = MapObject as Entities.GameClient;

							if (client != null) // if the person in screen is not null
							{
								if (Packet != null)
								{
									if (!deadonly || deadonly && !client.Alive)
										client.Send(Packet);
								}
								
								client.Send(spawn);
							}
						}
						if (Owner is Entities.GameClient)
						{
							if (MapObject is Entities.NPC)
							{
								using (var objspawn = (MapObject as Entities.NPC).CreateNPCSpawnPacket())
									(Owner as Entities.GameClient).Send(objspawn);
							}
							else if (MapObject is Entities.Sob)
							{
								using (var objspawn = (MapObject as Entities.Sob).CreateSobSpawnPacket())
									(Owner as Entities.GameClient).Send(objspawn);
							}
							else
							{
								bool send_spawn = true;
								
								if (send_spawn)
								{
									using (var objspawn = MapObject.CreateSpawnPacket())
										(Owner as Entities.GameClient).Send(objspawn);
								}
							}
						}
						MapObject.Screen.AddToScreen(Owner);
						AddToScreen(MapObject);
					}
					else
					{
						if (Owner is Entities.GameClient)
						{
							(Owner as Entities.GameClient).Send(Packets.GeneralDataPacket.Create(MapObject.EntityUID, Enums.DataAction.RemoveEntity, 0, 0, 0, 0, 0, 0));
						}
						
						Remove(MapObject);
					}
				}
				catch { }
			}
			spawn.Dispose();
			
			if (!(Owner is Entities.NPC))
				UpdateScreenItems();
			
//			if (Owner is Entities.Monster)
//			{
//				if (MapObjects.Count == 0)
//				{
//					Entities.Monster mob;
//					Core.Kernel.SpawnedMonsters.TryRemove(Owner.EntityUID, out mob);
//				}
//				else if (!Core.Kernel.SpawnedMonsters.ContainsKey(Owner.EntityUID))
//					Core.Kernel.SpawnedMonsters.TryAdd(Owner.EntityUID, Owner);
//			}
		}
		 
		#endregion
		
		/// <summary>
		/// Updates the screen with items.
		/// </summary>
		public void UpdateScreenItems()
		{
			if (!Owner.CanUpdateSpawn)
				return;

			foreach (Maps.IMapObject MapObject in Items.Values)
			{
				try
				{
					if (MapObject == Owner)
						continue;
					if (!MapObject.IsInMap(Owner))
					{
						Remove(MapObject);
						continue;
					}
					
					if (ValidDistance(Owner.X, Owner.Y, MapObject.X, MapObject.Y) && MapObject.CanUpdateSpawn)
					{
						MapObject.Screen.AddToScreen(Owner);
					}
					else
					{
						if (Owner is Entities.GameClient)
						{
							using (var itemspawn = (MapObject as Data.GroundItem).CreateItemSpawnPacket(2))
							{
								itemspawn.X = 0;
								itemspawn.Y = 0;
								(Owner as Entities.GameClient).Send(itemspawn);
							}
						}
						
						Remove(MapObject);
					}
				}
				catch { }
			}
			foreach (Maps.IMapObject MapObject in Owner.Map.Items.Values)
			{
				try
				{
					if (MapObject == Owner)
						continue;
					
					if (!MapObject.IsInMap(Owner))
					{
						Remove(MapObject);
						continue;
					}
					
					if (Items.ContainsKey(MapObject.EntityUID))
						continue;
					
					if (ValidDistance(Owner.X, Owner.Y, MapObject.X, MapObject.Y) && MapObject.CanUpdateSpawn)
					{
						if (Owner is Entities.GameClient)
						{
							using (var itemspawn = (MapObject as Data.GroundItem).CreateItemSpawnPacket(1))
							{
								(Owner as Entities.GameClient).Send(itemspawn);
							}
						}
						
						MapObject.Screen.AddToScreen(Owner);
						AddToScreen(MapObject);
					}
					else
					{
						if (Owner is Entities.GameClient)
						{
							using (var itemspawn = (MapObject as Data.GroundItem).CreateItemSpawnPacket(2))
							{
								itemspawn.X = 0;
								itemspawn.Y = 0;
								(Owner as Entities.GameClient).Send(itemspawn);
							}
						}
						
						Remove(MapObject);
					}
				}
				catch { }
			}
		}
		
		public bool ContainsEntity(uint UID)
		{
			return MapObjects.ContainsKey(UID);
		}
		
		public bool GetEntity(uint UID, out Maps.IMapObject map)
		{
			return MapObjects.TryGetValue(UID, out map);
		}
		/// <summary>
		/// Checks if there is a valid distance.
		/// </summary>
		/// <param name="x1">The first x coordinate.</param>
		/// <param name="y1">The first y coordinate.</param>
		/// <param name="x2">The second x coordinate.</param>
		/// <param name="y2">The second y coordinate.</param>
		/// <returns>Returns true if the distance is valid.</returns>
		public static bool ValidDistance(ushort x1, ushort y1, ushort x2, ushort y2)
		{
			return (GetDistance(x1, y1, x2, y2) <= 18);
		}
		
		/// <summary>
		/// Checks if there is a valid distance.
		/// </summary>
		/// <param name="x1">The first x coordinate.</param>
		/// <param name="y1">The first y coordinate.</param>
		/// <param name="x2">The second x coordinate.</param>
		/// <param name="y2">The second y coordinate.</param>
		/// <returns>Returns true if the distance is valid.</returns>
		public static bool ValidDistance(int x1, int y1, int x2, int y2)
		{
			return (GetDistance(x1, y1, x2, y2) <= 18);
		}
		
		/// <summary>
		/// Checks if there is a valid distance.
		/// </summary>
		/// <param name="x1">The first x coordinate.</param>
		/// <param name="y1">The first y coordinate.</param>
		/// <param name="x2">The second x coordinate.</param>
		/// <param name="y2">The second y coordinate.</param>
		/// <returns>Returns true if the distance is valid.</returns>
		public static bool ValidDistance(double x1, double y1, double x2, double y2)
		{
			return (GetDistance(x1, y1, x2, y2) <= 18);
		}
		
		/// <summary>
		/// Gets the distance between coordinates.
		/// </summary>
		/// <param name="x1">The first x coordinate.</param>
		/// <param name="y1">The first y coordinate.</param>
		/// <param name="x2">The second x coordinate.</param>
		/// <param name="y2">The second y coordinate.</param>
		/// <returns>Returns the distance.</returns>
		public static int GetDistance(ushort x1, ushort y1, ushort x2, ushort y2)
		{
			return GetDistance((double)x1, (double)y1, (double)x2, (double)y2);
		}
		
		/// <summary>
		/// Gets the distance between coordinates.
		/// </summary>
		/// <param name="x1">The first x coordinate.</param>
		/// <param name="y1">The first y coordinate.</param>
		/// <param name="x2">The second x coordinate.</param>
		/// <param name="y2">The second y coordinate.</param>
		/// <returns>Returns the distance.</returns>
		public static int GetDistance(int x1, int y1, int x2, int y2)
		{
			return GetDistance((double)x1, (double)y1, (double)x2, (double)y2);
		}
		
		/// <summary>
		/// Gets the distance between coordinates.
		/// </summary>
		/// <param name="x1">The first x coordinate.</param>
		/// <param name="y1">The first y coordinate.</param>
		/// <param name="x2">The second x coordinate.</param>
		/// <param name="y2">The second y coordinate.</param>
		/// <returns>Returns the distance.</returns>
		public static int GetDistance(double x1, double y1, double x2, double y2)
		{
			return (int)System.Math.Sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2)));;
		}
		
		public static int GetDegree(int X, int X2, int Y, int Y2)
		{
			int direction = 0;

			double AddX = X2 - X;
			double AddY = Y2 - Y;
			double r = (double)Math.Atan2(AddY, AddX);
			if (r < 0) r += (double)Math.PI * 2;

			direction = (int)(360 - (r * 180 / Math.PI));

			return direction;
		}
		
		public static short GetAngle(ushort X, ushort Y, ushort x2, ushort y2)
		{
			double r = Math.Atan2(y2 - Y, x2 - X);
			if (r < 0)
				r += Math.PI * 2;
			return (short)Math.Round(r * 180 / Math.PI);
		}
		
		public static Enums.ConquerAngle GetFacing(short angle)
		{
			sbyte c_angle = (sbyte)((angle / 46) - 1);
			return (c_angle == -1) ? Enums.ConquerAngle.South : (Enums.ConquerAngle)c_angle;
		}
	}
}
Please check the fix / organization in the original thread, because there is one bug about attacks which you have to fix for this work.

I think this is it, now GuildWars should work.

If you're not using the ProjectX source you could use this as a reference.



Super Aids is offline  
Thanks
2 Users
Old 11/25/2013, 19:47   #2
 
elite*gold: 0
Join Date: Oct 2013
Posts: 8
Received Thanks: 0
It's not full ...


Lyon1 is offline  
Old 11/25/2013, 19:51   #3
 
elite*gold: 0
Join Date: Dec 2012
Posts: 1,719
Received Thanks: 911
Quote:
Originally Posted by Lyon1 View Post
It's not full ...
Please press the sign out button. This is no place for you.
Super Aids is offline  
Thanks
6 Users
Old 11/26/2013, 00:55   #4
 
elite*gold: 0
Join Date: May 2012
Posts: 87
Received Thanks: 4
lol, I see why barely anyone uses this source.


CriticallyDev is offline  
Old 11/26/2013, 01:15   #5
 
elite*gold: 0
Join Date: Dec 2012
Posts: 1,719
Received Thanks: 911
Quote:
Originally Posted by CriticallyDev View Post
lol, I see why barely anyone uses this source.
Remember this is not GuildWars only. It's a full implementation of Sobs which is why there is so much code. The actual GuildWars is only GuildWars.cs
Super Aids is offline  
Thanks
1 User
Old 11/26/2013, 07:17   #6
 
elite*gold: 0
Join Date: Oct 2013
Posts: 8
Received Thanks: 0
Quote:
Originally Posted by Super Aids View Post
Please press the sign out button. This is no place for you.
Stupid
Lyon1 is offline  
Old 11/26/2013, 07:30   #7
 
elite*gold: 12
Join Date: Jul 2011
Posts: 7,445
Received Thanks: 3,639
Quote:
Originally Posted by Lyon1 View Post
Stupid
He's requesting that you sign off because your demands are obscene. It takes years to develop a fully functional source and you're complaining that the free source (which took months of his time and effort) isn't complete. Think about it, it takes a company like NetDragon websoft a few months to develop a source based off a public base called soul. We're doing it from scratch, alone or in a small group. We're students, mostly - not a company of trained software engineers. If you'd like to contribute in some way, great. If you'd like to give suggestions on how we can better our work or ask questions on how you can better your work, fantastic, but don't complain that our months of hard work isn't to your satisfaction. He is absolutely right, this section is no place for consumers.
Spirited is offline  
Thanks
9 Users
Old 12/04/2013, 20:51   #8
 
elite*gold: 0
Join Date: Jun 2013
Posts: 7
Received Thanks: 0
Thanks, I will try it ASAP.
Rooocky is offline  
Old 12/04/2013, 22:04   #9
 
elite*gold: 0
Join Date: Dec 2012
Posts: 1,719
Received Thanks: 911
Quote:
Originally Posted by Rooocky View Post
Thanks, I will try it ASAP.
Let me know if you run into issues and thanks for using the source for so long
Super Aids is offline  
Old 02/20/2015, 15:25   #10
 
elite*gold: 21
Join Date: Jul 2005
Posts: 9,193
Received Thanks: 5,347
#reported

Why are you bumping a 2 year old thread?.... This has no relevance to any newer sources
pro4never is offline  
Old 02/20/2015, 22:08   #11
 
elite*gold: 0
Join Date: Apr 2007
Posts: 137
Received Thanks: 51
I have no idea what are you reporting!
I'm just learning how everyone manage the logic of coding, nothing related with any source "maybe" but it's related with C#, and I want to know how to read methods, codes.. etc to understand everything that comes into my screen.. I'm sure I gonna reach up somewhere by messing around every source to find something to learn.

I assure you again that I'm totally amazed with your Redux source!
and I'm trying to make it full source on my own, by full I meant totally FULL Playable source even the single ****** item piece I will make it work.

Until that I have to learn from every source my eyes see. :3
And actually I'm downloading new sources everyday just to learn something even if it wasn't that useful at the time I will manage to make it useful later.
Well, if you didn't like what I've just said, please show me your point of view, I would even learn something from it.
if you didn't like the way I write English that's 'cuz I used to teach myself your language, well that's totally another story! xD
Regards! Bahhaha

#EDIT: I was just reading the Board rules to see why I was reported, and now I do know why.
Reporting accepted and also the infraction/warning, Regrets.
m e n a is offline  
Old 02/28/2015, 23:38   #12
 
elite*gold: 0
Join Date: Dec 2012
Posts: 1,719
Received Thanks: 911
Quote:
Originally Posted by pro4never View Post
#reported

Why are you bumping a 2 year old thread?.... This has no relevance to any newer sources
The source is still used by people though.
The thread of the source is only one page back. I don't know what the bumping post was, but honestly if it's related to this then I don't see a problem.
Super Aids is offline  
Thanks
1 User
Old 03/01/2015, 03:07   #13
 
elite*gold: 21
Join Date: Jul 2005
Posts: 9,193
Received Thanks: 5,347
Quote:
Originally Posted by Super Aids View Post
The source is still used by people though.
The thread of the source is only one page back. I don't know what the bumping post was, but honestly if it's related to this then I don't see a problem.
I was mistaken. A different project X was bumped a day before this one was. I assumed this thread was targeting the OLD project X release, not the new one which yes, is very commonly used.
pro4never is offline  
Old 03/01/2015, 04:10   #14
 
elite*gold: 0
Join Date: Apr 2007
Posts: 137
Received Thanks: 51
Quote:
Originally Posted by Super Aids View Post
The source is still used by people though.
The thread of the source is only one page back. I don't know what the bumping post was, but honestly if it's related to this then I don't see a problem.
The dude saved my ***.


m e n a is offline  
Reply



« [Release] - Binary Servers Unprotected Exes [7th August 2014] | Emoneyshopv2 Editor. »

Similar Threads
[Biete] 1x Guildwars Prophecies 1x Guildwars Nightfall (Key)[Suche] Psc/Egold
12/08/2011 - Guild Wars Trading - 5 Replies
Hallo verkaufe hier mein spielpacket mit 2 spielen Guildwars Prophecies und Guildwars Nightfall. ich habe die spiele nie ausgepackt aus der follie,heisst sind noch komplett eingepackt--> ungeöffnet ,keys noch nicht freigerubbelt. Hinweis: Verkaufe sie entweder als key oder verschicke sie per post.Lieber wäre mir sie als key zu verkaufen spare ich mir den versand. Bezhalmöglichkeiten: Psc/Egold
[Mini-Release]CPs/PVPpoints Exchanger for ProjectX source!
02/28/2011 - CO2 PServer Guides & Releases - 4 Replies
Hei guys, i was bored and wanted to improve some ... anyway heres the exchanger for CPs/PVPpoints for ProjectX source Every 1000PVPpoints =1KK CPs you can change the value as much as you want i dun care -.-" #region Exchanger case 983: { if (Control == 0) { GC.AddSend(Packets.NPCSay("Hello, Im the great exchanger who...
ProjectX
07/14/2008 - Conquer Online 2 - 10 Replies
yesterday i logged in to my other email and Project just comes up and say this ZoMg Its..Project Aka Andrew Owner Of YourFunWorld.comBored...! says: Lol ZoMg Its..Project Aka Andrew Owner Of YourFunWorld.comBored...! says: ur server is prob gunna fail again ZoMg Its..Project Aka Andrew Owner Of YourFunWorld.comBored...! says: zZz ZoMg Its..Project Aka Andrew Owner Of YourFunWorld.comBored...! says: whats the site now?
how to use UCE projectx 3.0
04/30/2008 - Dekaron - 1 Replies
Hi, I'm a new cheater and i want to create a bot, but i want to be sure my acount wasn't ban. So i have install projectX 3.0 but i dont say how to use it? Anyone can say me plz.



All times are GMT +1. The time now is 03:56.


Powered by vBulletin®
Copyright ©2000 - 2019, Jelsoft Enterprises Ltd.
SEO by vBSEO ©2011, Crawlability, Inc.

BTC: 33E6kMtxYa7dApCFzrS3Jb7U3NrVvo8nsK
ETH: 0xc6ec801B7563A4376751F33b0573308aDa611E05

Support | Contact Us | FAQ | Advertising | Privacy Policy | Terms of Service | Abuse
Copyright ©2019 elitepvpers All Rights Reserved.