Cleanup part 1 (#213)

* Clean up part 1 - Removed lots of dead code - Removed unncessary files not in use - Cleaned up small bits of code - Removed a few warnings - Server.java ---> GameEngine.java - Constants.java ---> GameConstants.java * Cape Dye Rewrote cape dying * Packaging - redone ----> com.rebotted * PacketSender/clean up - ActionSender ---> PacketSender - Moved many more packets to packetsender - Cleaned up more dead code * Merge Client/Player - Merged Client.java with Player.java (both were doing same thing so redundant to have both) - Removed some more dead code - Tidy a few small things up * Quests/more clean up - Removed more dead code - Made quests static in order to clean them up a bit * More cleanup - Removed some more of the dead quest code - Correcting naming of some of the shop variables
2026-07-07 08:39:07 +00:00 · 2019-11-25 11:08:56 -06:00
parent 3d1ae1b288
commit d876a923b9
379 changed files with 80684 additions and 83170 deletions
@@ -0,0 +1,401 @@
+package com.rebotted.game.content.combat;
+
+import java.util.HashMap;
+
+import com.rebotted.GameConstants;
+import com.rebotted.game.content.combat.range.RangeData;
+import com.rebotted.game.content.music.sound.CombatSounds;
+import com.rebotted.game.npcs.NpcHandler;
+import com.rebotted.game.players.Client;
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+import com.rebotted.util.Misc;
+
+public class Specials {
+
+	private final Player player;
+
+	public Specials(Player player2) {
+		this.player = player2;
+	}
+
+	private enum specialAttack {
+
+		// ItemName(ItemId, SpecDamage, SpecAccuracy, SpecAmount, Anim, GFX0,
+		// GFX100, DoubleHit, SsSpec, SpecEffect)
+
+		ABYSSAL_WHIP(4151, 1, 1.25, 5, 1658, 341, -1, false, false, 0),
+		DRAGON_DAGGER(1215, 1.15, 1.25, 2.5, 1062, -1, 252, true, false, 0),
+		DRAGON_DAGGER_P(1231, 1.15, 1.25, 2.5, 1062, -1, 252, true, false, 0),
+		DRAGON_DAGGER_PP(5698, 1.15, 1.25, 2.5, 1062, -1, 252, true, false, 0),
+		DRAGON_DAGGER_PPP(5680, 1.15, 1.25, 2.5, 1062, -1, 252, true, false, 0),
+		DRAGON_LONG(1305, 1.20, 1.10, 2.5, 1058, -1, 248, false, false, 0),
+		DRAGON_MACE(1434, 1.55, 1.25, 2.5, 1060, -1, 251, false, false, 0),
+		DRAGON_SCIMITAR(4587, 1, 1.25, 5.5, 1872, -1, 347, false, false, 1),
+		DRAGON_HALBERD(3204, 1.25, .85, 3, 1203, -1, 282, true, false, 0),
+		GRANITE_MAUL(4153, 1.10, .85, 5, 1667, -1, 337, false, false, 0),
+		MAGIC_SHORTBOW(861, 1.05, .95, 5.5, 1074, -1, -1, true, false, 0), 
+		MAGIC_LONGBOW(859, 1.20, 1.05, 5.5, 426, -1, -1, false, false, 0);
+		
+		private int weapon, anim, gfx1, gfx2, specEffect;
+		private double specDamage, specAccuracy, specAmount;
+		private boolean doubleHit, ssSpec;
+
+		private specialAttack(int weapon, double specDamage,
+				double specAccuracy, double specAmount, int anim, int gfx1,
+				int gfx2, boolean doubleHit, boolean ssSpec, int specEffect) {
+			this.weapon = weapon;
+			this.specDamage = specDamage;
+			this.specAccuracy = specAccuracy;
+			this.specAmount = specAmount;
+			this.anim = anim;
+			this.gfx1 = gfx1;
+			this.gfx2 = gfx2;
+			this.doubleHit = doubleHit;
+			this.ssSpec = ssSpec;
+			this.specEffect = specEffect;
+		}
+
+		private int getWeapon() {
+			return weapon;
+		}
+
+		private double getSpecDamage() {
+			return specDamage;
+		}
+
+		private double getSpecAccuracy() {
+			return specAccuracy;
+		}
+
+		private double getSpecAmount() {
+			return specAmount;
+		}
+
+		private int getAnim() {
+			return anim;
+		}
+
+		private int getGfx1() {
+			return gfx1;
+		}
+
+		private int getGfx2() {
+			return gfx2;
+		}
+
+		private boolean getDoubleHit() {
+			return doubleHit;
+		}
+
+		private boolean getSsSpec() {
+			return ssSpec;
+		}
+
+		@SuppressWarnings("unused")
+		private int getSpecEffect() {
+			return specEffect;
+		}
+
+		public static HashMap<Integer, specialAttack> specialAttack = new HashMap<Integer, specialAttack>();
+
+		@SuppressWarnings("unused")
+		public static specialAttack getWeapon(int weapon) {
+			return specialAttack.get(weapon);
+		}
+
+		static {
+			for (specialAttack SA : specialAttack.values()) {
+				specialAttack.put(SA.getWeapon(), SA);
+			}
+		}
+	}
+
+	public void activateSpecial(int weapon, int i) {
+		int equippedWeapon = player.playerEquipment[player.playerWeapon];
+		if (NpcHandler.npcs[i] == null && player.npcIndex > 0
+				|| PlayerHandler.players[player.playerIndex] == null
+				&& player.playerIndex > 0) {
+			return;
+		}
+		player.doubleHit = false;
+		player.specEffect = 0;
+		player.projectileStage = 0;
+		player.specMaxHitIncrease = 2;
+		if (player.npcIndex > 0) {
+			player.oldNpcIndex = i;
+		} else if (player.playerIndex > 0) {
+			player.oldPlayerIndex = i;
+			PlayerHandler.players[i].underAttackBy = player.playerId;
+			PlayerHandler.players[i].logoutDelay = System.currentTimeMillis();
+			PlayerHandler.players[i].singleCombatDelay = System
+					.currentTimeMillis();
+			PlayerHandler.players[i].killerId = player.playerId;
+		}
+		player.specEffect = 0;
+		player.projectileStage = 0;
+		for (specialAttack SA : specialAttack.values()) {
+			if (NpcHandler.npcs[player.npcIndex] == null && player.npcIndex > 0) {
+				return;
+			}
+			if (PlayerHandler.players[player.playerIndex] == null
+					&& player.playerIndex > 0) {
+				return;
+			}
+			if (equippedWeapon == SA.getWeapon()) {
+				if (SA.getWeapon() == 11235) {
+					player.usingBow = true;
+					player.dbowSpec = true;
+					player.rangeItemUsed = player.playerEquipment[player.playerArrows];
+					player.getItemAssistant().deleteArrow();
+					player.getItemAssistant().deleteArrow();
+					player.lastWeaponUsed = weapon;
+					player.hitDelay = 3;
+					player.startAnimation(426);
+					player.projectileStage = 1;
+					player.gfx100(RangeData.getRangeStartGFX(player));
+					player.hitDelay = player.getCombatAssistant().getHitDelay();
+					if (player.fightMode == 2) {
+						player.attackTimer--;
+					}
+					if (player.playerIndex > 0) {
+						player.getCombatAssistant().fireProjectilePlayer();
+					} else if (player.npcIndex > 0) {
+						player.getCombatAssistant().fireProjectileNpc();
+					}
+					player.specAccuracy = SA.getSpecAccuracy();
+					player.specDamage = SA.getSpecDamage();
+				} else if (SA.getWeapon() == 15241) {
+					player.usingBow = true;
+					player.rangeItemUsed = player.playerEquipment[player.playerArrows];
+					player.getItemAssistant().deleteArrow();
+					player.lastWeaponUsed = weapon;
+					player.startAnimation(12175);
+					player.specAccuracy = SA.getSpecAccuracy();
+					player.specDamage = SA.getSpecDamage();
+					player.hitDelay = 5;
+					player.attackTimer -= 7;
+					player.hitDelay = player.getCombatAssistant().getHitDelay();
+					if (player.fightMode == 2) {
+						if (player.playerIndex > 0) {
+							player.getCombatAssistant().fireProjectilePlayer();
+						} else if (player.npcIndex > 0) {
+							player.getCombatAssistant().fireProjectileNpc();
+						}
+					}
+				} else if (SA.getWeapon() == 13879 || SA.getWeapon() == 13883) {
+					player.usingRangeWeapon = true;
+					player.rangeItemUsed = player.playerEquipment[player.playerWeapon];
+					player.getItemAssistant().deleteArrow();
+					player.lastWeaponUsed = weapon;
+					player.startAnimation(SA.getAnim());
+					player.gfx0(SA.getGfx1());
+					player.specAccuracy = SA.getSpecAccuracy();
+					player.specDamage = SA.getSpecDamage();
+					player.projectileStage = 1;
+					player.hitDelay = player.getCombatAssistant().getHitDelay();
+					if (player.fightMode == 2) {
+						player.attackTimer--;
+					}
+					if (player.playerIndex > 0) {
+						player.getCombatAssistant().fireProjectilePlayer();
+					} else if (player.npcIndex > 0) {
+						player.getCombatAssistant().fireProjectileNpc();
+					}
+				} else if (SA.getWeapon() == 859 || SA.getWeapon() == 861) {
+					player.usingBow = true;
+					player.bowSpecShot = 1;
+					player.rangeItemUsed = player.playerEquipment[player.playerArrows];
+					player.getItemAssistant().deleteArrow();
+					player.lastWeaponUsed = weapon;
+					player.startAnimation(SA.getAnim());
+					player.projectileStage = 1;
+					player.hitDelay = player.getCombatAssistant().getHitDelay();
+					if (player.fightMode == 2) {
+						player.attackTimer--;
+					}
+					if (player.playerIndex > 0) {
+						player.getCombatAssistant().fireProjectilePlayer();
+					} else if (player.npcIndex > 0) {
+						player.getCombatAssistant().fireProjectileNpc();
+					}
+				} else if (SA.getGfx1() == -1) {
+					player.gfx100(SA.getGfx2());
+					player.startAnimation(SA.getAnim());
+					player.specDamage = SA.getSpecDamage();
+					player.specAccuracy = SA.getSpecAccuracy();
+					player.hitDelay = player.getCombatAssistant().getHitDelay();
+					player.doubleHit = SA.getDoubleHit();
+					player.ssSpec = SA.getSsSpec();
+				} else {
+					player.gfx0(SA.getGfx1());
+					player.startAnimation(SA.getAnim());
+					player.specDamage = SA.getSpecDamage();
+					player.specAccuracy = SA.getSpecAccuracy();
+					player.hitDelay = player.getCombatAssistant().getHitDelay();
+					player.doubleHit = SA.getDoubleHit();
+					player.ssSpec = SA.getSsSpec();
+				}
+			}
+			player.delayedDamage = Misc.random(player.getCombatAssistant().meleeMaxHit());
+			player.delayedDamage2 = Misc
+					.random(player.getCombatAssistant().meleeMaxHit());
+			player.usingSpecial = false;
+			player.getItemAssistant().updateSpecialBar();
+			if (GameConstants.COMBAT_SOUNDS) {
+				player.getPacketSender()
+						.sendSound(
+								CombatSounds
+										.specialSounds(player.playerEquipment[player.playerWeapon]),
+								100, 0);
+			}
+		}
+	}
+
+	public void handleGmaul() {
+		if (player.npcIndex > 0 && NpcHandler.npcs[player.npcIndex] != null) {
+			if (player.goodDistance(player.getX(), player.getY(), NpcHandler.npcs[player.npcIndex]
+					.getX(), NpcHandler.npcs[player.npcIndex].getY(), player
+					.getCombatAssistant().getRequiredDistance())) {
+				if (player.getCombatAssistant().checkSpecAmount(4153)) {
+					boolean hit = Misc.random(player.getCombatAssistant().calcAtt()) > Misc
+							.random(NpcHandler.npcs[player.npcIndex].defence);
+					int damage = 0;
+					if (hit) {
+						damage = Misc.random(player.getCombatAssistant()
+								.meleeMaxHit());
+						NpcHandler.npcs[player.npcIndex].HP -= damage;
+						NpcHandler.npcs[player.npcIndex].hitDiff2 = damage;
+						NpcHandler.npcs[player.npcIndex].hitUpdateRequired2 = true;
+						NpcHandler.npcs[player.npcIndex].updateRequired = true;
+						player.startAnimation(1667);
+						player.gfx100(340);
+					}
+				}
+			}
+		} else if (player.playerIndex > 0) {
+			final Client o = (Client) PlayerHandler.players[player.playerIndex];
+			if (player.goodDistance(player.getX(), player.getY(), o.getX(), o.getY(), player
+					.getCombatAssistant().getRequiredDistance())) {
+				if (player.getCombatAssistant().checkReqs()) {
+					if (player.getCombatAssistant().checkSpecAmount(4153)) {
+						boolean hit = Misc.random(player.getCombatAssistant()
+								.calcAtt()) > Misc.random(o
+								.getCombatAssistant().calcDef());
+						int damage = 0;
+						if (hit) {
+							damage = Misc.random(player.getCombatAssistant()
+									.meleeMaxHit());
+						}
+						if (o.getPrayer().prayerActive[18]
+								&& System.currentTimeMillis()
+										- o.protMeleeDelay > 1500) {
+							damage *= .6;
+						}
+						if (o.playerLevel[3] - damage <= 0) {
+							damage = o.playerLevel[3];
+						}
+						if (o.playerLevel[3] > 0) {
+							o.handleHitMask(damage);
+							player.startAnimation(1667);
+							o.gfx100(337);
+							o.dealDamage(damage);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	public double specAmount() {
+		for (specialAttack SA : specialAttack.values()) {
+			if (player.playerEquipment[player.playerWeapon] == SA.getWeapon()) {
+				return SA.getSpecAmount();
+			}
+		}
+		return 0;
+	}
+	
+   public static void specialClicking(Player player2, int actionButtonId) {
+	   switch (actionButtonId) {
+		case 29188:
+			if (player2.playerEquipment[player2.playerWeapon] == 1434) {
+				player2.specBarId = 7636;
+				player2.usingSpecial = !player2.usingSpecial;
+				player2.getItemAssistant().updateSpecialBar();
+			}
+			break;
+
+		case 29163:
+			if (player2.playerEquipment[player2.playerWeapon] == 4587) {
+				player2.specBarId = 7611;
+				player2.usingSpecial = !player2.usingSpecial;
+				player2.getItemAssistant().updateSpecialBar();
+			}
+			break;
+
+		case 33033:
+			if (player2.playerEquipment[player2.playerWeapon] == 4153) {
+				player2.specBarId = 8505;
+				player2.usingSpecial = !player2.usingSpecial;
+				player2.getItemAssistant().updateSpecialBar();
+			}
+			break;
+
+		case 29038:
+			if (player2.playerEquipment[player2.playerWeapon] == 4153) {
+				player2.specBarId = 7486;
+				player2.getSpecials().handleGmaul();
+				player2.usingSpecial = !player2.usingSpecial;
+				player2.getItemAssistant().updateSpecialBar();
+			}
+			break;
+
+		case 29063:
+		if (player2.playerEquipment[player2.playerWeapon] == 1377) {
+			if (player2.getCombatAssistant().checkSpecAmount(1377)) {
+				player2.gfx0(246);
+				player2.forcedChat("Raarrrrrgggggghhhhhhh!");
+				player2.startAnimation(1056);
+				player2.playerLevel[2] = player2.getLevelForXP(player2.playerXP[2]) + player2.getLevelForXP(player2.playerXP[2]) * 15 / 100;
+				player2.getPlayerAssistant().refreshSkill(2);
+				player2.getItemAssistant().updateSpecialBar();
+			} else {
+				player2.getPacketSender().sendMessage("You don't have the required special energy to use this attack.");
+			}
+		}
+		break;
+
+		case 48023:
+			if (player2.playerEquipment[player2.playerWeapon] == 4151) {
+				player2.specBarId = 12335;
+				player2.usingSpecial = !player2.usingSpecial;
+				player2.getItemAssistant().updateSpecialBar();
+			}
+			break;
+
+		case 29138:
+			if (player2.playerEquipment[player2.playerWeapon] == 1215 || player2.playerEquipment[player2.playerWeapon] == 1231 || player2.playerEquipment[player2.playerWeapon] == 5680 || player2.playerEquipment[player2.playerWeapon] == 5698) {
+				player2.specBarId = 7586;
+				player2.usingSpecial = !player2.usingSpecial;
+				player2.getItemAssistant().updateSpecialBar();
+			}
+			break;
+
+		case 29113:
+			if (player2.playerEquipment[player2.playerWeapon] == 861 || player2.playerEquipment[player2.playerWeapon] == 859) {
+				player2.specBarId = 7561;
+				player2.usingSpecial = !player2.usingSpecial;
+				player2.getItemAssistant().updateSpecialBar();
+			}
+			break;
+
+		case 29238:
+			player2.specBarId = 7686;
+			player2.usingSpecial = !player2.usingSpecial;
+			player2.getItemAssistant().updateSpecialBar();
+			break;
+	   }
+   }
+
+}
@@ -0,0 +1,84 @@
+package com.rebotted.game.content.combat.magic;
+
+import com.rebotted.event.CycleEvent;
+import com.rebotted.event.CycleEventContainer;
+import com.rebotted.event.CycleEventHandler;
+import com.rebotted.game.players.Client;
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+
+public class CastOnOther extends CastRequirements {
+
+	public static boolean castOnOtherSpells(int castingSpellId) {
+		int[] spells = { 12435, 12455, 12425, 30298, 30290, 30282, };
+		for (int spell : spells) {
+			if (castingSpellId == spell) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public static void teleOtherDistance(Player c, int type, int i) {
+		Player castOn = (Client) PlayerHandler.players[i];
+		int[][] data = { { 74, SOUL, LAW, EARTH, 1, 1, 1 },
+				{ 82, SOUL, LAW, WATER, 1, 1, 1 },
+				{ 90, SOUL, LAW, -1, 2, 1, -1 }, };
+		if (!hasRequiredLevel(c, data[type][0])) {
+			c.getPacketSender().sendMessage(
+					"You need to have a magic level of " + data[type][0]
+							+ " to cast this spell.");
+			return;
+		}
+		if (!hasRunes(c, new int[] { data[type][1], data[type][2],
+				data[type][3] }, new int[] { data[type][4], data[type][5],
+				data[type][6] })) {
+			return;
+		}
+		deleteRunes(c,
+				new int[] { data[type][1], data[type][2], data[type][3] },
+				new int[] { data[type][4], data[type][5], data[type][6] });
+		String[] location = { "Lumbridge", "Falador", "Camelot", };
+		c.faceUpdate(i + 32768);
+		c.startAnimation(1818);
+		c.gfx0(343);
+		if (castOn != null) {
+			if (castOn.distanceToPoint(c.absX, c.absY) <= 15) {
+				if (c.heightLevel == castOn.heightLevel) {
+					castOn.getPacketSender().sendFrame126(location[type], 12560);
+					castOn.getPacketSender().sendFrame126(c.playerName, 12558);
+					castOn.getPacketSender().showInterface(12468);
+					castOn.teleotherType = type;
+				}
+			}
+		}
+	}
+
+	public static void teleOtherLocation(final Player player, final int i,
+			boolean decline) {
+		player.getPacketSender().closeAllWindows();
+		final int[][] coords = { { 3222, 3218 }, // LUMBRIDGE
+				{ 2967, 3378 }, // FALADOR
+				{ 2757, 3477 }, // CAMELOT
+		};
+		if (!decline) {
+			   CycleEventHandler.getSingleton().addEvent(player, new CycleEvent() {
+		            @Override
+		            public void execute(CycleEventContainer container) {
+					player.startAnimation(715);
+					player.teleportToX = coords[player.teleotherType][0];
+					player.teleportToY = coords[player.teleotherType][1];
+					player.teleotherType = -1;
+					container.stop();
+				}
+				@Override
+					public void stop() {
+						// TODO Auto-generated method stub
+						
+					}
+			}, 3);
+			player.startAnimation(1816);
+			player.gfx100(342);
+		}
+	}
+}
@@ -0,0 +1,61 @@
+package com.rebotted.game.content.combat.magic;
+
+import com.rebotted.game.players.Player;
+
+public class CastRequirements {
+
+	public static boolean hasRunes(Player c, int[] runes, int[] amount) {
+		for (int i = 0; i < runes.length; i++) {
+			if (c.getItemAssistant().playerHasItem(runes[i], amount[i]) || MagicRequirements.wearingStaff(c, runes[i])) {
+				return true;
+			}
+		}
+		c.getPacketSender().sendMessage(
+				"You don't have enough required runes to cast this spell!");
+		return false;
+	}
+
+	public static boolean hasRunes(Player player, int[][] runes) {
+		for (int[] rune : runes) {
+			// if player doesn't have the required amount of runes or a staff for that rune
+			if (!player.getItemAssistant().playerHasItem(rune[0], rune[1]) && !MagicRequirements.wearingStaff(player, rune[0])) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public static void deleteRunes(Player player, int[][] runes) {
+		for (int[] rune : runes) {
+			if (!MagicRequirements.wearingStaff(player, rune[0])) {
+				player.getItemAssistant().deleteItem(rune[0], rune[1]);
+			}
+		}
+	}
+
+	public static void deleteRunes(Player c, int[] runes, int[] amount) {
+		for (int i = 0; i < runes.length; i++) {
+			c.getItemAssistant().deleteItem(runes[i],
+					c.getItemAssistant().getItemSlot(runes[i]), amount[i]);
+		}
+	}
+
+	public static boolean hasRequiredLevel(Player c, int i) {
+		return c.playerLevel[6] >= i;
+	}
+
+	public static final int FIRE = 554,
+							WATER = 555,
+							AIR = 556,
+							EARTH = 557,
+							MIND = 558,
+							BODY = 559,
+							DEATH = 560,
+							NATURE = 561,
+							CHAOS = 562,
+							LAW = 563,
+							COSMIC = 564,
+							BLOOD = 565,
+							SOUL = 566,
+							ASTRAL = 9075;
+}
@@ -0,0 +1,248 @@
+package com.rebotted.game.content.combat.magic;
+
+import java.util.HashMap;
+import java.util.Map;
+import com.rebotted.game.players.Player;
+
+public class Enchanting {
+
+	private final Player c;
+
+	public Enchanting(Player player) {
+		this.c = player;
+	}
+
+	public enum Enchant {
+
+		SAPPHIRERING(1637, 2550, 7, 18, 719, 114, 1), SAPPHIREAMULET(1694,
+				1727, 7, 18, 719, 114, 1), SAPPHIRENECKLACE(1656, 3853, 7, 18,
+				719, 114, 1),
+
+		EMERALDRING(1639, 2552, 27, 37, 719, 114, 2), EMERALDAMULET(1696, 1729,
+				27, 37, 719, 114, 2), EMERALDNECKLACE(1658, 5521, 27, 37, 719,
+				114, 2),
+
+		RUBYRING(1641, 2568, 47, 59, 720, 115, 3), RUBYAMULET(1698, 1725, 47,
+				59, 720, 115, 3),
+		// RUBYNECKLACE(1660, 11194, 47, 59, 720, 115, 3),
+
+		DIAMONDRING(1643, 2570, 57, 67, 720, 115, 4), DIAMONDAMULET(1700, 1731,
+				57, 67, 720, 115, 4),
+		// DIAMONDNECKLACE(1662, 11090, 57, 67, 720, 115, 4),
+
+		DRAGONSTONERING(1645, 2572, 68, 78, 721, 116, 5), 
+		DRAGONSTONEAMULET(1702, 1704, 68, 78, 721, 116, 5),
+		// DRAGONSTONENECKLACE(1664, 11105, 68, 78, 721, 116, 5),
+
+		ONYXRING(6575, 6583, 87, 97, 721, 452, 6), ONYXAMULET(6581, 6585, 87,
+				97, 721, 452, 6);
+
+		// ONYXNECKLACE(6577, 11128, 87, 97, 721, 452, 6)
+
+		int unenchanted, enchanted, levelReq, xpGiven, anim, gfx,
+				reqEnchantmentLevel;
+
+		private Enchant(int unenchanted, int enchanted, int levelReq,
+				int xpGiven, int anim, int gfx, int reqEnchantmentLevel) {
+			this.unenchanted = unenchanted;
+			this.enchanted = enchanted;
+			this.levelReq = levelReq;
+			this.xpGiven = xpGiven;
+			this.anim = anim;
+			this.gfx = gfx;
+			this.reqEnchantmentLevel = reqEnchantmentLevel;
+		}
+
+		public int getUnenchanted() {
+			return unenchanted;
+		}
+
+		public int getEnchanted() {
+			return enchanted;
+		}
+
+		public int getLevelReq() {
+			return levelReq;
+		}
+
+		public int getXp() {
+			return xpGiven;
+		}
+
+		public int getAnim() {
+			return anim;
+		}
+
+		public int getGFX() {
+			return gfx;
+		}
+
+		public int getELevel() {
+			return reqEnchantmentLevel;
+		}
+
+		private static final Map<Integer, Enchant> enc = new HashMap<Integer, Enchant>();
+
+		public static Enchant forId(int itemID) {
+			return enc.get(itemID);
+		}
+
+		static {
+			for (Enchant en : Enchant.values()) {
+				enc.put(en.getUnenchanted(), en);
+			}
+		}
+	}
+
+	private enum EnchantSpell {
+
+		SAPPHIRE(1155, 555, 1, 564, 1, -1, 0), EMERALD(1165, 556, 3, 564, 1,
+				-1, 0), RUBY(1176, 554, 5, 564, 1, -1, 0), DIAMOND(1180, 557,
+				10, 564, 1, -1, 0), DRAGONSTONE(1187, 555, 15, 557, 15, 564, 1), ONYX(
+				6003, 557, 20, 554, 20, 564, 1);
+
+		int spell, reqRune1, reqAmtRune1, reqRune2, reqAmtRune2, reqRune3,
+				reqAmtRune3;
+
+		private EnchantSpell(int spell, int reqRune1, int reqAmtRune1,
+				int reqRune2, int reqAmtRune2, int reqRune3, int reqAmtRune3) {
+			this.spell = spell;
+			this.reqRune1 = reqRune1;
+			this.reqAmtRune1 = reqAmtRune1;
+			this.reqRune2 = reqRune2;
+			this.reqAmtRune2 = reqAmtRune2;
+			this.reqRune3 = reqRune3;
+			this.reqAmtRune3 = reqAmtRune3;
+		}
+
+		public int getSpell() {
+			return spell;
+		}
+
+		public int getReq1() {
+			return reqRune1;
+		}
+
+		public int getReqAmt1() {
+			return reqAmtRune1;
+		}
+
+		public int getReq2() {
+			return reqRune2;
+		}
+
+		public int getReqAmt2() {
+			return reqAmtRune2;
+		}
+
+		public int getReq3() {
+			return reqRune3;
+		}
+
+		public int getReqAmt3() {
+			return reqAmtRune3;
+		}
+
+		public static final Map<Integer, EnchantSpell> ens = new HashMap<Integer, EnchantSpell>();
+
+		public static EnchantSpell forId(int id) {
+			return ens.get(id);
+		}
+
+		static {
+			for (EnchantSpell en : EnchantSpell.values()) {
+				ens.put(en.getSpell(), en);
+			}
+		}
+
+	}
+
+	private boolean hasRunes(int spellID) {
+		EnchantSpell ens = EnchantSpell.forId(spellID);
+		if (ens.getReq3() == 0) {
+			return c.getItemAssistant().playerHasItem(ens.getReq1(),
+					ens.getReqAmt1())
+					&& c.getItemAssistant().playerHasItem(ens.getReq2(),
+							ens.getReqAmt2())
+					&& c.getItemAssistant().playerHasItem(ens.getReq3(),
+							ens.getReqAmt3());
+		} else {
+			return c.getItemAssistant().playerHasItem(ens.getReq1(),
+					ens.getReqAmt1())
+					&& c.getItemAssistant().playerHasItem(ens.getReq2(),
+							ens.getReqAmt2());
+		}
+	}
+
+	private int getEnchantmentLevel(int spellID) {
+		switch (spellID) {
+		case 1155: // Lvl-1 enchant sapphire
+			return 1;
+		case 1165: // Lvl-2 enchant emerald
+			return 2;
+		case 1176: // Lvl-3 enchant ruby
+			return 3;
+		case 1180: // Lvl-4 enchant diamond
+			return 4;
+		case 1187: // Lvl-5 enchant dragonstone
+			return 5;
+		case 6003: // Lvl-6 enchant onyx
+			return 6;
+		}
+		return 0;
+	}
+
+	public void enchantItem(int itemID, int spellID) {
+		Enchant enc = Enchant.forId(itemID);
+		EnchantSpell ens = EnchantSpell.forId(spellID);
+		if (enc == null || ens == null) {
+
+			return;
+		}
+		if (c.playerLevel[c.playerMagic] >= enc.getLevelReq()) {
+			if (c.getItemAssistant().playerHasItem(enc.getUnenchanted(), 1)) {
+				if (hasRunes(spellID)) {
+					if (getEnchantmentLevel(spellID) == enc.getELevel()) {
+						c.getItemAssistant().deleteItem(enc.getUnenchanted(), 1);
+						c.getItemAssistant().addItem(enc.getEnchanted(), 1);
+						c.getPlayerAssistant().addSkillXP(enc.getXp(),
+								c.playerMagic);
+						c.getItemAssistant()
+								.deleteItem(
+										ens.getReq1(),
+										c.getItemAssistant().getItemSlot(
+												ens.getReq1()),
+										ens.getReqAmt1());
+						c.getItemAssistant()
+								.deleteItem(
+										ens.getReq2(),
+										c.getItemAssistant().getItemSlot(
+												ens.getReq2()),
+										ens.getReqAmt2());
+						c.startAnimation(enc.getAnim());
+						c.gfx100(enc.getGFX());
+						if (ens.getReq3() != -1) {
+							c.getItemAssistant().deleteItem(
+									ens.getReq3(),
+									c.getItemAssistant().getItemSlot(
+											ens.getReq3()), ens.getReqAmt3());
+						}
+						c.getPacketSender().sendFrame106(6);
+					} else {
+						c.getPacketSender().sendMessage(
+								"You can only enchant this jewelry using a level-"
+										+ enc.getELevel()
+										+ " enchantment spell!");
+					}
+				} else {
+					c.getPacketSender().sendMessage(
+							"You do not have enough runes to cast this spell.");
+				}
+			}
+		} else {
+			c.getPacketSender().sendMessage(
+					"You need a magic level of at least " + enc.getLevelReq()
+							+ " to cast this spell.");
+		}
+	}
+}
@@ -0,0 +1,388 @@
+package com.rebotted.game.content.combat.magic;
+
+import com.rebotted.game.players.Player;
+public class MagicData {
+
+	public static final int[][] MAGIC_SPELLS = {
+			// example {magicId, level req, animation, startGFX, projectile Id,
+			// endGFX, maxhit, exp gained, rune 1, rune 1 amount, rune 2, rune 2
+			// amount, rune 3, rune 3 amount, rune 4, rune 4 amount}
+
+			// Modern Spells
+			{ 1152, 1, 711, 90, 91, 92, 2, 5, 556, 1, 558, 1, 0, 0, 0, 0, 993 }, // wind
+																					// strike
+			{ 1154, 5, 711, 93, 94, 95, 4, 7, 555, 1, 556, 1, 558, 1, 0, 0, 211 }, // water
+																					// strike
+			{ 1156, 9, 711, 96, 97, 98, 6, 9, 557, 2, 556, 1, 558, 1, 0, 0, 0 },// earth
+																				// strike
+			{ 1158, 13, 711, 99, 100, 101, 8, 11, 554, 3, 556, 2, 558, 1, 0, 0,
+					0 }, // fire
+							// strike
+			{ 1160, 17, 711, 117, 118, 119, 9, 13, 556, 2, 562, 1, 0, 0, 0, 0,
+					0 }, // wind
+							// bolt
+			{ 1163, 23, 711, 120, 121, 122, 10, 16, 556, 2, 555, 2, 562, 1, 0,
+					0, 0 }, // water
+							// bolt
+			{ 1166, 29, 711, 123, 124, 125, 11, 20, 556, 2, 557, 3, 562, 1, 0,
+					0, 0 }, // earth
+							// bolt
+			{ 1169, 35, 711, 126, 127, 128, 12, 22, 556, 3, 554, 4, 562, 1, 0,
+					0, 0 }, // fire
+							// bolt
+			{ 1172, 41, 711, 132, 133, 134, 13, 25, 556, 3, 560, 1, 0, 0, 0, 0,
+					0 }, // wind
+							// blast
+			{ 1175, 47, 711, 135, 136, 137, 14, 28, 556, 3, 555, 3, 560, 1, 0,
+					0, 0 }, // water
+							// blast
+			{ 1177, 53, 711, 138, 139, 140, 15, 31, 556, 3, 557, 4, 560, 1, 0,
+					0, 0 }, // earth
+							// blast
+			{ 1181, 59, 711, 129, 130, 131, 16, 35, 556, 4, 554, 5, 560, 1, 0,
+					0, 0 }, // fire
+							// blast
+			{ 1183, 62, 727, 158, 159, 160, 17, 36, 556, 5, 565, 1, 0, 0, 0, 0,
+					0 }, // wind
+							// wave
+			{ 1185, 65, 727, 161, 162, 163, 18, 37, 556, 5, 555, 7, 565, 1, 0,
+					0, 0 }, // water
+							// wave
+			{ 1188, 70, 727, 164, 165, 166, 19, 40, 556, 5, 557, 7, 565, 1, 0,
+					0, 0 }, // earth
+							// wave
+			{ 1189, 75, 727, 155, 156, 157, 20, 42, 556, 5, 554, 7, 565, 1, 0,
+					0, 0 }, // fire
+							// wave
+
+			{ 1153, 3, 716, 102, 103, 104, 0, 13, 555, 3, 557, 2, 559, 1, 0, 0,
+					0 }, // confuse
+			{ 1157, 11, 716, 105, 106, 107, 0, 20, 555, 3, 557, 2, 559, 1, 0,
+					0, 0 }, // weaken
+			{ 1161, 19, 716, 108, 109, 110, 0, 29, 555, 2, 557, 3, 559, 1, 0,
+					0, 0 }, // curse
+			{ 1542, 66, 729, 167, 168, 169, 0, 76, 557, 5, 555, 5, 566, 1, 0,
+					0, 0 }, // vulnerability
+			{ 1543, 73, 729, 170, 171, 172, 0, 83, 557, 8, 555, 8, 566, 1, 0,
+					0, 0 }, // enfeeble
+			{ 1562, 80, 729, 173, 174, 107, 0, 90, 557, 12, 555, 12, 556, 1, 0,
+					0, 0 }, // stun
+
+			{ 1572, 20, 710, 177, 178, 181, 0, 30, 557, 3, 555, 3, 561, 2, 0,
+					0, 0 }, // bind
+			{ 1582, 50, 710, 177, 178, 180, 2, 60, 557, 4, 555, 4, 561, 3, 0,
+					0, 0 }, // snare
+			{ 1592, 79, 710, 177, 178, 179, 4, 90, 557, 5, 555, 5, 561, 4, 0,
+					0, 0 }, // entangle
+
+			{ 1171, 39, 724, 145, 146, 147, 15, 25, 556, 2, 557, 2, 562, 1, 0, 0, 0 }, // crumble
+			{ 1539, 50, 708, 87, 88, 89, 25, 42, 554, 5, 560, 1, 0, 0, 0, 0, 0 }, // iban
+																					// blast
+			{ 12037, 50, 1576, 327, 328, 329, 19, 30, 560, 1, 558, 4, 0, 0, 0,
+					0, 0 }, // magic
+							// dart
+
+			{ 1190, 60, 811, 0, 0, 76, 20, 60, 554, 2, 565, 2, 556, 4, 0, 0, 0 }, // sara
+																					// strike
+			{ 1191, 60, 811, 0, 0, 77, 20, 60, 554, 1, 565, 2, 556, 4, 0, 0, 0 }, // cause
+																					// of
+																					// guthix
+			{ 1192, 60, 811, 0, 0, 78, 20, 60, 554, 4, 565, 2, 556, 1, 0, 0, 0 }, // flames
+																					// of
+																					// zammy
+
+			{ 12445, 85, 1819, 0, 344, 345, 0, 65, 563, 1, 562, 1, 560, 1, 0,
+					0, 0 }, // teleblock
+
+			// Ancient Spells
+			{ 12939, 50, 1978, 0, 384, 385, 13, 30, 560, 2, 562, 2, 554, 1,
+					556, 1, 0 }, // smoke
+									// rush
+			{ 12987, 52, 1978, 0, 378, 379, 14, 31, 560, 2, 562, 2, 566, 1,
+					556, 1, 0 }, // shadow
+									// rush
+			{ 12901, 56, 1978, 0, 0, 373, 15, 33, 560, 2, 562, 2, 565, 1, 0, 0,
+					0 }, // blood
+							// rush
+			{ 12861, 58, 1978, 0, 360, 361, 16, 34, 560, 2, 562, 2, 555, 2, 0,
+					0, 0 }, // ice
+							// rush
+			{ 12963, 62, 1979, 0, 0, 389, 19, 36, 560, 2, 562, 4, 556, 2, 554,
+					2, 0 }, // smoke
+							// burst
+			{ 13011, 64, 1979, 0, 0, 382, 20, 37, 560, 2, 562, 4, 556, 2, 566,
+					2, 0 }, // shadow
+							// burst
+			{ 12919, 68, 1979, 0, 0, 376, 21, 39, 560, 2, 562, 4, 565, 2, 0, 0,
+					0 }, // blood
+							// burst
+			{ 12881, 70, 1979, 0, 0, 363, 22, 40, 560, 2, 562, 4, 555, 4, 0, 0,
+					0 }, // ice
+							// burst
+			{ 12951, 74, 1978, 0, 386, 387, 23, 42, 560, 2, 554, 2, 565, 2,
+					556, 2, 0 }, // smoke
+									// blitz
+			{ 12999, 76, 1978, 0, 380, 381, 24, 43, 560, 2, 565, 2, 556, 2,
+					566, 2, 0 }, // shadow
+									// blitz
+			{ 12911, 80, 1978, 0, 374, 375, 25, 45, 560, 2, 565, 4, 0, 0, 0, 0,
+					0 }, // blood
+							// blitz
+			{ 12871, 82, 1978, 366, 0, 367, 26, 46, 560, 2, 565, 2, 555, 3, 0,
+					0, 0 }, // ice
+							// blitz
+			{ 12975, 86, 1979, 0, 0, 391, 27, 48, 560, 4, 565, 2, 556, 4, 554,
+					4, 0 }, // smoke
+							// barrage
+			{ 13023, 88, 1979, 0, 0, 383, 28, 49, 560, 4, 565, 2, 556, 4, 566,
+					3, 0 }, // shadow
+							// barrage
+			{ 12929, 92, 1979, 0, 0, 377, 29, 51, 560, 4, 565, 4, 566, 1, 0, 0,
+					0 }, // blood
+							// barrage
+			{ 12891, 94, 1979, 0, 0, 369, 30, 52, 560, 4, 565, 2, 555, 6, 0, 0,
+					0 }, // ice
+							// barrage
+
+			{ -1, 80, 811, 301, 0, 0, 0, 0, 554, 3, 565, 3, 556, 3, 0, 0, 0 }, // charge
+			{ -1, 21, 712, 112, 0, 0, 0, 10, 554, 3, 561, 1, 0, 0, 0, 0, 0 }, // low
+																				// alch
+			{ -1, 55, 713, 113, 0, 0, 0, 20, 554, 5, 561, 1, 0, 0, 0, 0, 0 }, // high
+																				// alch
+			{ -1, 33, 728, 142, 143, 144, 0, 35, 556, 1, 563, 1, 0, 0, 0, 0, 0 } // telegrab
+
+	};
+
+	public static String getSpellName(int id) {
+		switch (id) {
+		case 0:
+			return "Air Strike";
+		case 1:
+			return "Water Strike";
+		case 2:
+			return "Earth Strike";
+		case 3:
+			return "Fire Strike";
+		case 4:
+			return "Air Bolt";
+		case 5:
+			return "Water Bolt";
+		case 6:
+			return "Earth Bolt";
+		case 7:
+			return "Fire Bolt";
+		case 8:
+			return "Air Blast";
+		case 9:
+			return "Water Blast";
+		case 10:
+			return "Earth Blast";
+		case 11:
+			return "Fire Blast";
+		case 12:
+			return "Air Wave";
+		case 13:
+			return "Water Wave";
+		case 14:
+			return "Earth Wave";
+		case 15:
+			return "Fire Wave";
+		case 32:
+			return "Shadow Rush";
+		case 33:
+			return "Smoke Rush";
+		case 34:
+			return "Blood Rush";
+		case 35:
+			return "Ice Rush";
+		case 36:
+			return "Shadow Burst";
+		case 37:
+			return "Smoke Burst";
+		case 38:
+			return "Blood Burst";
+		case 39:
+			return "Ice Burst";
+		case 40:
+			return "Shadow Blitz";
+		case 41:
+			return "Smoke Blitz";
+		case 42:
+			return "Blood Blitz";
+		case 43:
+			return "Ice Blitz";
+		case 44:
+			return "Shadow Barrage";
+		case 45:
+			return "Smoke Barrage";
+		case 46:
+			return "Blood Barrage";
+		case 47:
+			return "Ice Barrage";
+		default:
+			return "Select Spell";
+		}
+	}
+	
+	public static boolean multis(Player c) {
+		switch (MAGIC_SPELLS[c.oldSpellId][0]) {
+		case 12891:
+		case 12881:
+		case 13011:
+		case 13023:
+		case 12919: // blood spells
+		case 12929:
+		case 12963:
+		case 12975:
+			return true;
+		}
+		return false;
+
+	}
+	
+	public static int getFreezeTime(Player c) {
+		switch (MAGIC_SPELLS[c.oldSpellId][0]) {
+		case 1572:
+		case 12861: // ice rush
+			return 10;
+
+		case 1582:
+		case 12881: // ice burst
+			return 17;
+
+		case 1592:
+		case 12871: // ice blitz
+			return 25;
+
+		case 12891: // ice barrage
+			return 33;
+
+		default:
+			return 0;
+		}
+	}
+
+	public static int getStartHeight(Player c) {
+		switch (MAGIC_SPELLS[c.spellId][0]) {
+		case 1562: // stun
+			return 25;
+
+		case 12939:// smoke rush
+			return 35;
+
+		case 12987: // shadow rush
+			return 38;
+
+		case 12861: // ice rush
+			return 15;
+
+		case 12951: // smoke blitz
+			return 38;
+
+		case 12999: // shadow blitz
+			return 25;
+
+		case 12911: // blood blitz
+			return 25;
+
+		default:
+			return 43;
+		}
+	}
+
+	public static int getEndHeight(Player c) {
+		switch (MAGIC_SPELLS[c.spellId][0]) {
+		case 1562: // stun
+			return 10;
+
+		case 12939: // smoke rush
+			return 20;
+
+		case 12987: // shadow rush
+			return 28;
+
+		case 12861: // ice rush
+			return 10;
+
+		case 12951: // smoke blitz
+			return 28;
+
+		case 12999: // shadow blitz
+			return 15;
+
+		case 12911: // blood blitz
+			return 10;
+
+		default:
+			return 31;
+		}
+	}
+
+	public static int getStartDelay(Player c) {
+		switch (MAGIC_SPELLS[c.spellId][0]) {
+		case 1539:
+			return 60;
+
+		default:
+			return 53;
+		}
+	}
+
+	public static boolean godSpells(Player c) {
+		switch (MAGIC_SPELLS[c.spellId][0]) {
+		case 1190:
+			return true;
+
+		case 1191:
+			return true;
+
+		case 1192:
+			return true;
+
+		default:
+			return false;
+		}
+	}
+
+	public static int getEndGfxHeight(Player c) {
+		switch (MAGIC_SPELLS[c.oldSpellId][0]) {
+		case 12987:
+		case 12901:
+		case 12861:
+		case 12445:
+		case 1192:
+		case 13011:
+		case 12919:
+		case 12881:
+		case 12999:
+		case 12911:
+		case 12871:
+		case 13023:
+		case 12929:
+		case 12891:
+			return 0;
+
+		default:
+			return 100;
+		}
+	}
+
+	public static int getStartGfxHeight(Player c) {
+		switch (MAGIC_SPELLS[c.spellId][0]) {
+		case 12871:
+		case 12891:
+			return 0;
+
+		default:
+			return 100;
+		}
+	}
+	
+	public static boolean fullVoidMage(Player c) {
+		return c.playerEquipment[c.playerHat] == 11663
+				&& c.playerEquipment[c.playerLegs] == 8840
+				&& c.playerEquipment[c.playerChest] == 8839
+				&& c.playerEquipment[c.playerHands] == 8842;
+	}
+
+}
@@ -0,0 +1,38 @@
+package com.rebotted.game.content.combat.magic;
+
+import com.rebotted.game.players.Player;
+
+public class MagicMaxHit {
+
+	public static int mageAttackBonus(Player c) {
+		int magicBonus = c.playerLevel[6];
+		if (MagicData.fullVoidMage(c)) {
+			magicBonus += c.getLevelForXP(c.playerXP[6]) * 0.2;
+		}
+		if (c.getPrayer().prayerActive[4]) {
+			magicBonus *= 1.05;
+		} else if (c.getPrayer().prayerActive[12]) {
+			magicBonus *= 1.10;
+		} else if (c.getPrayer().prayerActive[20]) {
+			magicBonus *= 1.15;
+		}
+		return magicBonus + c.playerBonus[3] * 2;
+	}
+
+	public static int mageDefenceBonus(Player c) {
+		int defenceBonus = c.playerLevel[1] / 2 + c.playerLevel[6] / 2;
+		if (c.getPrayer().prayerActive[0]) {
+			defenceBonus += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.05;
+		} else if (c.getPrayer().prayerActive[3]) {
+			defenceBonus += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.1;
+		} else if (c.getPrayer().prayerActive[9]) {
+			defenceBonus += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.15;
+		} else if (c.getPrayer().prayerActive[18]) {
+			defenceBonus += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.2;
+		} else if (c.getPrayer().prayerActive[19]) {
+			defenceBonus += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.25;
+		}
+		return defenceBonus + c.playerBonus[8] + c.playerBonus[8] / 3;
+	}
+
+}
@@ -0,0 +1,175 @@
+package com.rebotted.game.content.combat.magic;
+
+import com.rebotted.game.items.ItemAssistant;
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+
+public class MagicRequirements {
+
+	public static boolean wearingStaff(Player player, int runeId) {
+		int wep = player.playerEquipment[player.playerWeapon];
+		switch (runeId) {
+		case 554:
+			if (wep == 1387 || wep == 1393 || wep == 3053) {
+				return true;
+			}
+			break;
+		case 555:
+			if (wep == 1383 || wep == 1395) {
+				return true;
+			}
+			break;
+		case 556:
+			if (wep == 1381 || wep == 1397) {
+				return true;
+			}
+			break;
+		case 557:
+			if (wep == 1385 || wep == 1399 || wep == 3053) {
+				return true;
+			}
+			break;
+		}
+		return false;
+	}
+
+	public static boolean checkMagicReqs(Player c, int spell) {
+		if (c.usingMagic && MagicTeleports.RUNES_REQUIRED) { // check for runes
+			if (!c.getItemAssistant().playerHasItem(
+					MagicData.MAGIC_SPELLS[spell][8],
+					MagicData.MAGIC_SPELLS[spell][9])
+					&& !wearingStaff(c, MagicData.MAGIC_SPELLS[spell][8])
+					|| !c.getItemAssistant().playerHasItem(
+							MagicData.MAGIC_SPELLS[spell][10],
+							MagicData.MAGIC_SPELLS[spell][11])
+					&& !wearingStaff(c, MagicData.MAGIC_SPELLS[spell][10])
+					|| !c.getItemAssistant().playerHasItem(
+							MagicData.MAGIC_SPELLS[spell][12],
+							MagicData.MAGIC_SPELLS[spell][13])
+					&& !wearingStaff(c, MagicData.MAGIC_SPELLS[spell][12])
+					|| !c.getItemAssistant().playerHasItem(
+							MagicData.MAGIC_SPELLS[spell][14],
+							MagicData.MAGIC_SPELLS[spell][15])
+					&& !wearingStaff(c, MagicData.MAGIC_SPELLS[spell][14])) {
+				c.getPacketSender()
+						.sendMessage(
+								"You don't have the required runes to cast this spell.");
+				return false;
+			}
+		}
+
+		if (c.usingMagic && c.playerIndex > 0) {
+			if (PlayerHandler.players[c.playerIndex] != null) {
+				for (int r = 0; r < c.REDUCE_SPELLS.length; r++) { // reducing
+																	// spells,
+																	// confuse
+																	// etc
+					if (PlayerHandler.players[c.playerIndex].REDUCE_SPELLS[r] == MagicData.MAGIC_SPELLS[spell][0]) {
+						c.reduceSpellId = r;
+						if (System.currentTimeMillis()
+								- PlayerHandler.players[c.playerIndex].reduceSpellDelay[c.reduceSpellId] > PlayerHandler.players[c.playerIndex].REDUCE_SPELL_TIME[c.reduceSpellId]) {
+							PlayerHandler.players[c.playerIndex].canUseReducingSpell[c.reduceSpellId] = true;
+						} else {
+							PlayerHandler.players[c.playerIndex].canUseReducingSpell[c.reduceSpellId] = false;
+						}
+						break;
+					}
+				}
+				if (!PlayerHandler.players[c.playerIndex].canUseReducingSpell[c.reduceSpellId]) {
+					c.getPacketSender().sendMessage(
+							"That player is currently immune to this spell.");
+					c.usingMagic = false;
+					c.stopMovement();
+					c.getCombatAssistant().resetPlayerAttack();
+					return false;
+				}
+			}
+		}
+
+		int staffRequired = getStaffNeeded(c);
+		if (c.usingMagic && staffRequired > 0 && MagicTeleports.RUNES_REQUIRED) { // staff
+																			// required
+			if (c.playerEquipment[c.playerWeapon] != staffRequired) {
+				c.getPacketSender()
+						.sendMessage(
+								"You need a "
+										+ ItemAssistant.getItemName(
+												staffRequired).toLowerCase()
+										+ " to cast this spell.");
+				return false;
+			}
+		}
+
+		if (c.usingMagic && MagicTeleports.MAGIC_LEVEL_REQUIRED) { // check magic level
+			if (c.playerLevel[6] < MagicData.MAGIC_SPELLS[spell][1]) {
+				c.getPacketSender().sendMessage(
+						"You need to have a magic level of "
+								+ MagicData.MAGIC_SPELLS[spell][1]
+								+ " to cast this spell.");
+				return false;
+			}
+		}
+		if (c.usingMagic && MagicTeleports.RUNES_REQUIRED) {
+			if (MagicData.MAGIC_SPELLS[spell][8] > 0) { // deleting runes
+				if (!wearingStaff(c, MagicData.MAGIC_SPELLS[spell][8])) {
+					c.getItemAssistant().deleteItem(
+							MagicData.MAGIC_SPELLS[spell][8],
+							c.getItemAssistant().getItemSlot(
+									MagicData.MAGIC_SPELLS[spell][8]),
+							MagicData.MAGIC_SPELLS[spell][9]);
+				}
+			}
+			if (MagicData.MAGIC_SPELLS[spell][10] > 0) {
+				if (!wearingStaff(c, MagicData.MAGIC_SPELLS[spell][10])) {
+					c.getItemAssistant().deleteItem(
+							MagicData.MAGIC_SPELLS[spell][10],
+							c.getItemAssistant().getItemSlot(
+									MagicData.MAGIC_SPELLS[spell][10]),
+							MagicData.MAGIC_SPELLS[spell][11]);
+				}
+			}
+			if (MagicData.MAGIC_SPELLS[spell][12] > 0) {
+				if (!wearingStaff(c, MagicData.MAGIC_SPELLS[spell][12])) {
+					c.getItemAssistant().deleteItem(
+							MagicData.MAGIC_SPELLS[spell][12],
+							c.getItemAssistant().getItemSlot(
+									MagicData.MAGIC_SPELLS[spell][12]),
+							MagicData.MAGIC_SPELLS[spell][13]);
+				}
+			}
+			if (MagicData.MAGIC_SPELLS[spell][14] > 0) {
+				if (!wearingStaff(c, MagicData.MAGIC_SPELLS[spell][14])) {
+					c.getItemAssistant().deleteItem(
+							MagicData.MAGIC_SPELLS[spell][14],
+							c.getItemAssistant().getItemSlot(
+									MagicData.MAGIC_SPELLS[spell][14]),
+							MagicData.MAGIC_SPELLS[spell][15]);
+				}
+			}
+		}
+		return true;
+	}
+
+	public static int getStaffNeeded(Player c) {
+		switch (MagicData.MAGIC_SPELLS[c.spellId][0]) {
+		case 1539:
+			return 1409;
+
+		case 12037:
+			return 4170;
+
+		case 1190:
+			return 2415;
+
+		case 1191:
+			return 2416;
+
+		case 1192:
+			return 2417;
+
+		default:
+			return 0;
+		}
+	}
+
+}
@@ -0,0 +1,140 @@
+package com.rebotted.game.content.combat.magic;
+
+import com.rebotted.GameConstants;
+import com.rebotted.game.content.music.sound.SoundList;
+import com.rebotted.game.players.Client;
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+import com.rebotted.util.Misc;
+
+public class MagicSpells extends MagicData {
+	
+	public static void appendMultiBarrage(Player c, int playerId, boolean splashed) {
+		if (PlayerHandler.players[playerId] != null) {
+			Player c2 = (Client) PlayerHandler.players[playerId];
+			if (c2.isDead || c2.respawnTimer > 0) {
+				return;
+			}
+			if (checkMultiBarrageReqs(c, playerId)) {
+				c.barrageCount++;
+				if (Misc.random(mageAtk(c)) > Misc.random(mageDef(c))
+						&& !c.magicFailed) {
+					if (getEndGfxHeight(c) == 100) { // end GFX
+						c2.gfx100(MagicData.MAGIC_SPELLS[c.oldSpellId][5]);
+					} else {
+						c2.gfx0(MagicData.MAGIC_SPELLS[c.oldSpellId][5]);
+					}
+					int damage = Misc
+							.random(MagicData.MAGIC_SPELLS[c.oldSpellId][6]);
+					if (c2.getPrayer().prayerActive[12]) {
+						damage *= (int) .60;
+					}
+					if (c2.playerLevel[3] - damage < 0) {
+						damage = c2.playerLevel[3];
+					}
+					c.getPlayerAssistant().addSkillXP(MagicData.MAGIC_SPELLS[c.oldSpellId][7] + damage * GameConstants.MAGIC_EXP_RATE, 6);
+					c.getPlayerAssistant().addSkillXP(MagicData.MAGIC_SPELLS[c.oldSpellId][7] + damage / 3, 3);
+					// Server.playerHandler.players[playerId].setHitDiff(damage);
+					// Server.playerHandler.players[playerId].setHitUpdateRequired(true);
+					PlayerHandler.players[playerId].handleHitMask(damage);
+					// Server.playerHandler.players[playerId].playerLevel[3] -=
+					// damage;
+					PlayerHandler.players[playerId].dealDamage(damage);
+					PlayerHandler.players[playerId].damageTaken[c.playerId] += damage;
+					c2.getPlayerAssistant().refreshSkill(3);
+					c.totalPlayerDamageDealt += damage;
+					multiSpellEffect(c, playerId, damage);
+				} else {
+					c2.gfx100(85);
+					c.getPacketSender().sendSound(SoundList.MAGE_FAIL, 100,
+							0);
+				}
+			}
+		}
+	}
+
+	public static void multiSpellEffect(Player c, int playerId, int damage) {
+		switch (MagicData.MAGIC_SPELLS[c.oldSpellId][0]) {
+		case 13011:
+		case 13023:
+			if (System.currentTimeMillis()
+					- PlayerHandler.players[playerId].reduceStat > 35000) {
+				PlayerHandler.players[playerId].reduceStat = System
+						.currentTimeMillis();
+				PlayerHandler.players[playerId].playerLevel[0] -= PlayerHandler.players[playerId]
+						.getLevelForXP(PlayerHandler.players[playerId].playerXP[0]) * 10 / 100;
+			}
+			break;
+		case 12919: // blood spells
+		case 12929:
+			int heal = damage / 4;
+			if (c.playerLevel[3] + heal >= c.getPlayerAssistant()
+					.getLevelForXP(c.playerXP[3])) {
+				c.playerLevel[3] = c.getPlayerAssistant().getLevelForXP(
+						c.playerXP[3]);
+			} else {
+				c.playerLevel[3] += heal;
+			}
+			c.getPlayerAssistant().refreshSkill(3);
+			break;
+		case 12891:
+		case 12881:
+			if (PlayerHandler.players[playerId].freezeTimer < -4) {
+				PlayerHandler.players[playerId].freezeTimer = getFreezeTime(c);
+				PlayerHandler.players[playerId].stopMovement();
+			}
+			break;
+		}
+	}
+	
+	public static boolean checkMultiBarrageReqs(Player c, int i) {
+		if (PlayerHandler.players[i] == null) {
+			return false;
+		}
+		if (i == c.playerId) {
+			return false;
+		}
+		if (c.inPits && PlayerHandler.players[i].inPits) {
+			return true;
+		}
+		if (!PlayerHandler.players[i].inWild()) {
+			return false;
+		}
+		if (GameConstants.COMBAT_LEVEL_DIFFERENCE) {
+			int combatDif1 = c.getCombatAssistant().getCombatDifference(c.combatLevel,
+					PlayerHandler.players[i].combatLevel);
+			if (combatDif1 > c.wildLevel
+					|| combatDif1 > PlayerHandler.players[i].wildLevel) {
+				c.getPacketSender()
+						.sendMessage(
+								"Your combat level difference is too great to attack that player here.");
+				return false;
+			}
+		}
+
+		if (GameConstants.SINGLE_AND_MULTI_ZONES) {
+			if (!PlayerHandler.players[i].inMulti()) { // single combat
+														// zones
+				if (PlayerHandler.players[i].underAttackBy != c.playerId
+						&& PlayerHandler.players[i].underAttackBy != 0) {
+					return false;
+				}
+				if (PlayerHandler.players[i].playerId != c.underAttackBy
+						&& c.underAttackBy != 0) {
+					c.getPacketSender().sendMessage(
+							"You are already in combat.");
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+	
+	public static int mageAtk(Player c) {
+		return MagicMaxHit.mageAttackBonus(c);
+	}
+	
+	public static int mageDef(Player c) {
+		return MagicMaxHit.mageDefenceBonus(c);
+	}
+}
@@ -0,0 +1,425 @@
+package com.rebotted.game.content.combat.magic;
+
+import com.rebotted.game.content.randomevents.RandomEventHandler;
+import com.rebotted.game.players.Player;
+import com.rebotted.util.Misc;
+
+public class MagicTeleports {
+
+	public static final int AIR_RUNE = 556, FIRE_RUNE = 554,
+			WATER_RUNE = 555, EARTH_RUNE = 557,
+			LAW_RUNE = 563, BLOOD_RUNE = 565,
+			SOUL_RUNE = 566, BANANA = 1963;
+
+	public static void handleLoginText(Player player) {
+		player.getPacketSender().sendFrame126("Level 25: Varrock Teleport", 1300);
+		player.getPacketSender().sendFrame126("Level 31: Lumbridge Teleport", 1325);
+		player.getPacketSender().sendFrame126("Level 37: Falador Teleport", 1350);
+		player.getPacketSender().sendFrame126("Level 45: Camelot Teleport", 1382);
+		player.getPacketSender().sendFrame126("Level 51: Ardougne Teleport", 1415);
+		player.getPacketSender().sendFrame126("Level 54: Paddewwa Teleport", 13037);
+		player.getPacketSender().sendFrame126("Level 60: Senntisten Teleport", 13047);
+		player.getPacketSender().sendFrame126("Level 66: Kharyrll Teleport", 13055);
+		player.getPacketSender().sendFrame126("Level 72: Lassar Teleport", 13063);
+		player.getPacketSender().sendFrame126("Level 78: Dareeyak Teleport", 13071);
+	}
+
+	/**
+	 * Modern Teleports
+	 */
+	public static final int VARROCK_X = 3213, VARROCK_Y = 3423;
+	public static final int LUMBRIDGE_X = 3222, LUMBRIDGE_Y = 3218;
+	public static final int FALADOR_X = 2964, FALADOR_Y = 3378;
+	public static final int CAMELOT_X = 2757, CAMELOT_Y = 3479;
+	public static final int ARDOUGNE_X = 2662, ARDOUGNE_Y = 3305;
+	public static final int WATCHTOWER_X = 2547, WATCHTOWER_Y = 3112;
+	public static final int TROLLHEIM_X = 2910, TROLLHEIM_Y = 3612;
+	public static final int APE_ATOLL_X = 2754, APE_ATOLL_Y = 2784;
+
+	/**
+	 * Ancient Teleports
+	 */
+	public static final int PADDEWWA_X = 3098, PADDEWWA_Y = 9884;
+	public static final int SENNTISTEN_X = 3321, SENNTISTEN_Y = 3335;
+	public static final int KHARYRLL_X = 3493, KHARYRLL_Y = 3472;
+	public static final int LASSAR_X = 3006, LASSAR_Y = 3471;
+	public static final int DAREEYAK_X = 3161, DAREEYAK_Y = 3671;
+	public static final int CARRALLANGAR_X = 3157, CARRALLANGAR_Y = 3669;
+	public static final int ANNAKARL_X = 3286, ANNAKARL_Y = 3884;
+	public static final int GHORROCK_X = 2977, GHORROCK_Y = 3873;
+
+	public static final boolean MAGIC_LEVEL_REQUIRED = true, RUNES_REQUIRED = true;
+
+	public static boolean teleportCheck(Player player) {
+		if (player.teleTimer > 0) {
+			return false;
+		}
+		return true;
+	}
+
+	public static void paddewwaTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 2}, {FIRE_RUNE, 1}, {AIR_RUNE, 1}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 54) {
+				player.getPacketSender().sendMessage("You need a magic level of 54 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 2}, {FIRE_RUNE, 1}, {AIR_RUNE, 1}});
+		player.getPlayerAssistant().startTeleport(PADDEWWA_X + Misc.random(2), PADDEWWA_Y - Misc.random(2), 0, "ancient");
+		player.getPlayerAssistant().addSkillXP(64, player.playerMagic);
+	}
+
+	public static void senntisenTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 2}, {SOUL_RUNE, 1}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 60) {
+				player.getPacketSender().sendMessage("You need a magic level of 60 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 2}, {SOUL_RUNE, 1}});
+		player.getPlayerAssistant().startTeleport(SENNTISTEN_X + Misc.random(1), SENNTISTEN_Y - Misc.random(1), 0, "ancient");
+		player.getPlayerAssistant().addSkillXP(70, player.playerMagic);
+	}
+
+	public static void kharyllTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 2}, {BLOOD_RUNE, 1}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 66) {
+				player.getPacketSender().sendMessage("You need a magic level of 66 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 2}, {BLOOD_RUNE, 1}});
+		player.getPlayerAssistant().startTeleport(KHARYRLL_X, KHARYRLL_Y, 0, "ancient");
+		player.getPlayerAssistant().addSkillXP(76, player.playerMagic);
+	}
+
+	public static void lassarTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 2}, {WATER_RUNE, 4}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 72) {
+				player.getPacketSender().sendMessage("You need a magic level of 72 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 2}, {WATER_RUNE, 4}});
+		player.getPlayerAssistant().startTeleport(LASSAR_X + Misc.random(2), LASSAR_Y - Misc.random(2), 0, "ancient");
+		player.getPlayerAssistant().addSkillXP(82, player.playerMagic);
+	}
+
+	public static void dareeyakTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 2}, {FIRE_RUNE, 3}, {AIR_RUNE, 2}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 78) {
+				player.getPacketSender().sendMessage("You need a magic level of 78 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 2}, {FIRE_RUNE, 3}, {AIR_RUNE, 2}});
+		player.getPlayerAssistant().startTeleport(
+				DAREEYAK_X + Misc.random(1),
+				DAREEYAK_Y - Misc.random(1), 0, "ancient");
+		player.getPlayerAssistant().addSkillXP(88, player.playerMagic);
+	}
+
+	public static void carrallangarTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 2}, {SOUL_RUNE, 2}})) {
+				player.getPacketSender()
+						.sendMessage(
+								"You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 84) {
+				player.getPacketSender().sendMessage("You need a magic level of 84 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 2}, {SOUL_RUNE, 2}});
+		player.getPlayerAssistant().startTeleport(CARRALLANGAR_X + Misc.random(2), CARRALLANGAR_Y - Misc.random(2), 0, "ancient");
+		player.getPlayerAssistant().addSkillXP(94, player.playerMagic);
+	}
+
+	public static void annakarlTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 2}, {BLOOD_RUNE, 2}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 90) {
+				player.getPacketSender().sendMessage("You need a magic level of 90 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 2}, {BLOOD_RUNE, 2}});
+		player.getPlayerAssistant().startTeleport(ANNAKARL_X + Misc.random(1), ANNAKARL_Y - Misc.random(1), 0, "ancient");
+		player.getPlayerAssistant().addSkillXP(100, player.playerMagic);
+	}
+
+	public static void ghorrockTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 2}, {WATER_RUNE, 8}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 96) {
+				player.getPacketSender().sendMessage("You need a magic level of 96 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 2}, {WATER_RUNE, 8}});
+		player.getPlayerAssistant().startTeleport(GHORROCK_X + Misc.random(3),
+				GHORROCK_Y - Misc.random(3), 0, "ancient");
+		player.getPlayerAssistant().addSkillXP(106, player.playerMagic);
+	}
+
+	public static void varrockTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 1}, {FIRE_RUNE, 1}, {AIR_RUNE, 3}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 25) {
+				player.getPacketSender().sendMessage("You need a magic level of 25 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 1}, {FIRE_RUNE, 1}, {AIR_RUNE, 3}});
+		player.getPlayerAssistant().startTeleport(VARROCK_X + Misc.random(2), VARROCK_Y - Misc.random(2), 0, "modern");
+		player.getPlayerAssistant().addSkillXP(35, player.playerMagic);
+	}
+
+	public static void lumbridgeTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 1}, {EARTH_RUNE, 1}, {AIR_RUNE, 3}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 32) {
+				player.getPacketSender().sendMessage("You need a magic level of 32 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 1}, {EARTH_RUNE, 1}, {AIR_RUNE, 3}});
+		player.getPlayerAssistant().startTeleport(LUMBRIDGE_X, LUMBRIDGE_Y, 0, "modern");
+		player.getPlayerAssistant().addSkillXP(35, player.playerMagic);
+	}
+
+	public static void faladorTeleport(Player player) {
+		/*if (!teleportCheck(player)) {
+			return;
+		}*/
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 1}, {WATER_RUNE, 1}, {AIR_RUNE, 3}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 37) {
+				player.getPacketSender().sendMessage("You need a magic level of 37 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 1}, {WATER_RUNE, 1}, {AIR_RUNE, 3}});
+		player.getPlayerAssistant().startTeleport(FALADOR_X + Misc.random(4), FALADOR_Y - Misc.random(4), 0, "modern");
+		player.getPlayerAssistant().addSkillXP(48, player.playerMagic);
+	}
+
+	public static void camelotTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 1}, {AIR_RUNE, 5}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 45) {
+				player.getPacketSender().sendMessage("You need a magic level of 45 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 1}, {AIR_RUNE, 5}});
+		// 2757, 3479
+		player.getPlayerAssistant().startTeleport(CAMELOT_X + Misc.random(1), CAMELOT_Y - Misc.random(1), 0, "modern");
+		player.getPlayerAssistant().addSkillXP(55.5, player.playerMagic);
+	}
+
+	public static void ardougneTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 2}, {WATER_RUNE, 2}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 51) {
+				player.getPacketSender().sendMessage("You need a magic level of 51 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 2}, {WATER_RUNE, 2}});
+		player.getPlayerAssistant().startTeleport(ARDOUGNE_X + Misc.random(4),
+				ARDOUGNE_Y - Misc.random(4), 0, "modern");
+		player.getPlayerAssistant().addSkillXP(61, player.playerMagic);
+	}
+
+	public static void watchTowerTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 2}, {EARTH_RUNE, 2}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 58) {
+				player.getPacketSender().sendMessage(
+						"You need a magic level of 58 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 2}, {EARTH_RUNE, 2}});
+		player.getPlayerAssistant().startTeleport(WATCHTOWER_X, WATCHTOWER_Y, 1, "modern");
+		player.getPlayerAssistant().addSkillXP(68, player.playerMagic);
+	}
+
+	public static void trollhiemTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 2}, {FIRE_RUNE, 2}})) {
+				player.getPacketSender().sendMessage("You don't have the required runes to cast this spell.");
+				return;
+			}
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 61) {
+				player.getPacketSender().sendMessage("You need a magic level of 61 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 2}, {FIRE_RUNE, 2}});
+		player.getPlayerAssistant().startTeleport(2892 + Misc.random(2),
+				3679 - Misc.random(2), 0, "modern");
+		player.getPlayerAssistant().addSkillXP(68, player.playerMagic);
+	}
+
+	public static void apeAtollTeleport(Player player) {
+		if (!teleportCheck(player)) {
+			return;
+		}
+		RandomEventHandler.addRandom(player);
+		if (RUNES_REQUIRED) {
+			if (!CastRequirements.hasRunes(player, new int[][]{{LAW_RUNE, 2}, {FIRE_RUNE, 2}, {WATER_RUNE, 2}}) || !player.getItemAssistant().playerHasItem(BANANA, 1)) {
+				player.getPacketSender().sendMessage("You don't have the required items to cast this spell.");
+				return;
+			}
+		}
+		if (player.questPoints < 19) {
+			player.getPacketSender().sendMessage("You need " + 19 + " quest points to teleport here.");
+			return;
+		}
+		if (MAGIC_LEVEL_REQUIRED) {
+			if (player.playerLevel[player.playerMagic] < 64) {
+				player.getPacketSender().sendMessage("You need a magic level of 64 to cast this spell.");
+				return;
+			}
+		}
+		CastRequirements.deleteRunes(player, new int[][]{{LAW_RUNE, 2}, {FIRE_RUNE, 2}, {WATER_RUNE, 2}});
+		player.getItemAssistant().deleteItem(BANANA, 1);
+		player.getPlayerAssistant().startTeleport(2798 + Misc.random(1), 2798 - Misc.random(1), 1, "modern");
+		player.getPlayerAssistant().addSkillXP(76, player.playerMagic);
+	}
+}
@@ -0,0 +1,23 @@
+package com.rebotted.game.content.combat.magic;
+
+import com.rebotted.game.players.Client;
+
+public class NonCombatSpells {
+
+	public static void teleportObelisk(Client c, int x, int y, int height) {
+		if (System.currentTimeMillis() - c.teleBlockDelay < c.teleBlockLength) {
+			c.getPacketSender().sendMessage(
+					"You are teleblocked and can't teleport.");
+			return;
+		}
+		if (!c.isDead && !c.isTeleporting) {
+			c.stopMovement();
+			c.getPacketSender().closeAllWindows();
+			c.npcIndex = 0;
+			c.playerIndex = 0;
+			c.faceNpc(0);
+			c.getPlayerAssistant().spellTeleport(x, y, height);
+		}
+	}
+
+}
@@ -0,0 +1,463 @@
+package com.rebotted.game.content.combat.melee;
+
+import com.rebotted.GameConstants;
+import com.rebotted.game.content.combat.magic.MagicData;
+import com.rebotted.game.items.ItemAssistant;
+import com.rebotted.game.players.Player;
+
+public class MeleeData {
+
+	public static boolean fullVoidMelee(Player c) {
+		return c.playerEquipment[c.playerHat] == 11665
+				&& c.playerEquipment[c.playerLegs] == 8840
+				&& c.playerEquipment[c.playerChest] == 8839
+				&& c.playerEquipment[c.playerHands] == 8842;
+	}
+
+	public static int calculateMeleeAttack(Player c) {
+		int attackLevel = c.playerLevel[0];
+		// 2, 5, 11, 18, 19
+		if (c.getPrayer().prayerActive[2]) {
+			attackLevel += c.getLevelForXP(c.playerXP[c.playerAttack]) * 0.05;
+		} else if (c.getPrayer().prayerActive[7]) {
+			attackLevel += c.getLevelForXP(c.playerXP[c.playerAttack]) * 0.1;
+		} else if (c.getPrayer().prayerActive[15]) {
+			attackLevel += c.getLevelForXP(c.playerXP[c.playerAttack]) * 0.15;
+		} else if (c.getPrayer().prayerActive[24]) {
+			attackLevel += c.getLevelForXP(c.playerXP[c.playerAttack]) * 0.15;
+		} else if (c.getPrayer().prayerActive[25]) {
+			attackLevel += c.getLevelForXP(c.playerXP[c.playerAttack]) * 0.2;
+		}
+		if (fullVoidMelee(c)) {
+			attackLevel += c.getLevelForXP(c.playerXP[c.playerAttack]) * 0.1;
+		}
+		attackLevel *= c.specAccuracy;
+		// c.sendMessage("Attack: " + (attackLevel +
+		// (c.playerBonus[bestMeleeAtk()] * 2)));
+		int i = c.playerBonus[bestMeleeAtk(c)];
+		i += c.bonusAttack;
+		if (c.playerEquipment[c.playerAmulet] == 11128
+				&& c.playerEquipment[c.playerWeapon] == 6528) {
+			i *= 1.30;
+		}
+		return (int) (attackLevel + attackLevel * 0.15 + (i + i * 0.05));
+	}
+
+	public static int bestMeleeAtk(Player c) {
+		if (c.playerBonus[0] > c.playerBonus[1]
+				&& c.playerBonus[0] > c.playerBonus[2]) {
+			return 0;
+		}
+		if (c.playerBonus[1] > c.playerBonus[0]
+				&& c.playerBonus[1] > c.playerBonus[2]) {
+			return 1;
+		}
+		return c.playerBonus[2] <= c.playerBonus[1]
+				|| c.playerBonus[2] <= c.playerBonus[0] ? 0 : 2;
+	}
+
+	public static int calculateMeleeDefence(Player c) {
+		int defenceLevel = c.playerLevel[1];
+		int i = c.playerBonus[bestMeleeDef(c)];
+		if (c.getPrayer().prayerActive[0]) {
+			defenceLevel += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.05;
+		} else if (c.getPrayer().prayerActive[5]) {
+			defenceLevel += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.1;
+		} else if (c.getPrayer().prayerActive[13]) {
+			defenceLevel += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.15;
+		} else if (c.getPrayer().prayerActive[24]) {
+			defenceLevel += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.2;
+		} else if (c.getPrayer().prayerActive[25]) {
+			defenceLevel += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.25;
+		}
+		return (int) (defenceLevel + defenceLevel * 0.15 + (i + i * 0.05));
+	}
+
+	public static int bestMeleeDef(Player c) {
+		if (c.playerBonus[5] > c.playerBonus[6]
+				&& c.playerBonus[5] > c.playerBonus[7]) {
+			return 5;
+		}
+		if (c.playerBonus[6] > c.playerBonus[5]
+				&& c.playerBonus[6] > c.playerBonus[7]) {
+			return 6;
+		}
+		return c.playerBonus[7] <= c.playerBonus[5]
+				|| c.playerBonus[7] <= c.playerBonus[6] ? 5 : 7;
+	}
+
+	/**
+	 * Weapon and magic attack speed!
+	 **/
+
+	public static int getAttackDelay(Player c) {
+		String s = ItemAssistant.getItemName(c.playerEquipment[GameConstants.WEAPON]).toLowerCase();
+		if (c.usingMagic) {
+			switch (MagicData.MAGIC_SPELLS[c.spellId][0]) {
+			case 12871: // ice blitz
+			case 13023: // shadow barrage
+			case 12891: // ice barrage
+				return 5;
+
+			default:
+				return 5;
+			}
+		}
+		if (c.playerEquipment[c.playerWeapon] == -1) {
+			return 4;// unarmed
+		}
+
+		switch (c.playerEquipment[c.playerWeapon]) {
+		case 11235:
+			return 9;
+		case 11730:
+			return 4;
+		case 6528:
+			return 7;
+		}
+
+		if (s.endsWith("greataxe")) {
+			return 7;
+		} else if (s.equals("torags hammers")) {
+			return 5;
+		} else if (s.equals("guthans warspear")) {
+			return 5;
+		} else if (s.equals("veracs flail")) {
+			return 5;
+		} else if (s.equals("ahrims staff")) {
+			return 6;
+		} else if (s.contains("staff")) {
+			if (s.contains("zamarok") || s.contains("guthix")
+					|| s.contains("saradomian") || s.contains("slayer")
+					|| s.contains("ancient")) {
+				return 4;
+			} else {
+				return 5;
+			}
+		} else if (s.contains("bow")) {
+			if (s.contains("composite") || s.equals("seercull")) {
+				return 5;
+			} else if (s.contains("aril")) {
+				return 4;
+			} else if (s.contains("Ogre")) {
+				return 8;
+			} else if (s.contains("short") || s.contains("hunt")
+					|| s.contains("sword")) {
+				return 4;
+			} else if (s.contains("long") || s.contains("crystal")) {
+				return 6;
+			} else if (s.contains("'bow")) {
+				return 7;
+			}
+
+			return 5;
+		} else if (s.contains("dagger")) {
+			return 4;
+		} else if (s.contains("godsword") || s.contains("2h")) {
+			return 6;
+		} else if (s.contains("longsword")) {
+			return 5;
+		} else if (s.contains("sword")) {
+			return 4;
+		} else if (s.contains("scimitar")) {
+			return 4;
+		} else if (s.contains("mace")) {
+			return 5;
+		} else if (s.contains("battleaxe")) {
+			return 6;
+		} else if (s.contains("pickaxe")) {
+			return 5;
+		} else if (s.contains("thrownaxe")) {
+			return 5;
+		} else if (s.contains("axe")) {
+			return 5;
+		} else if (s.contains("warhammer")) {
+			return 6;
+		} else if (s.contains("2h")) {
+			return 7;
+		} else if (s.contains("spear")) {
+			return 5;
+		} else if (s.contains("claw")) {
+			return 4;
+		} else if (s.contains("halberd")) {
+			return 7;
+		} else if (s.equals("granite maul")) {
+			return 7;
+		} else if (s.equals("toktz-xil-ak")) {
+			return 4;
+		} else if (s.equals("tzhaar-ket-em")) {
+			return 5;
+		} else if (s.equals("tzhaar-ket-om")) {
+			return 7;
+		} else if (s.equals("toktz-xil-ek")) {
+			return 4;
+		} else if (s.equals("toktz-xil-ul")) {
+			return 4;
+		} else if (s.equals("toktz-mej-tal")) {
+			return 6;
+		} else if (s.contains("whip")) {
+			return 4;
+		} else if (s.contains("dart")) {
+			return 3;
+		} else if (s.contains("knife")) {
+			return 3;
+		} else if (s.contains("javelin")) {
+			return 6;
+		}
+		return 5;
+	}
+
+	/**
+	 * Weapon stand, walk, run, etc emotes
+	 **/
+
+	public static void getPlayerAnimIndex(Player c) {
+		String weaponName = ItemAssistant.getItemName(
+				c.playerEquipment[GameConstants.WEAPON]).toLowerCase();
+		c.playerStandIndex = 0x328;
+		c.playerTurnIndex = 0x337;
+		c.playerWalkIndex = 0x333;
+		c.playerTurn180Index = 0x334;
+		c.playerTurn90CWIndex = 0x335;
+		c.playerTurn90CCWIndex = 0x336;
+		c.playerRunIndex = 0x338;
+
+		if (weaponName.contains("halberd") || weaponName.contains("guthan")) {
+			c.playerStandIndex = 809;
+			c.playerWalkIndex = 1146;
+			c.playerRunIndex = 1210;
+			return;
+		}
+		if (weaponName.contains("dharok")) {
+			c.playerStandIndex = 0x811;
+			c.playerWalkIndex = 0x67F;
+			c.playerRunIndex = 0x680;
+			return;
+		}
+		if (weaponName.contains("ahrim")) {
+			c.playerStandIndex = 809;
+			c.playerWalkIndex = 1146;
+			c.playerRunIndex = 1210;
+			return;
+		}
+		if (weaponName.contains("verac")) {
+			c.playerStandIndex = 1832;
+			c.playerWalkIndex = 1830;
+			c.playerRunIndex = 1831;
+			return;
+		}
+		if (weaponName.contains("wand") || weaponName.contains("staff")) {
+			c.playerStandIndex = 809;
+			c.playerRunIndex = 1210;
+			c.playerWalkIndex = 1146;
+			return;
+		}
+		if (weaponName.contains("karil")) {
+			c.playerStandIndex = 2074;
+			c.playerWalkIndex = 2076;
+			c.playerRunIndex = 2077;
+			return;
+		}
+		if (weaponName.contains("2h sword")) {
+			c.playerStandIndex = 2561;
+			c.playerWalkIndex = 2562;
+			c.playerRunIndex = 2563;
+			return;
+		}
+		if (weaponName.contains("bow")) {
+			c.playerStandIndex = 808;
+			c.playerWalkIndex = 819;
+			c.playerRunIndex = 824;
+			return;
+		}
+
+		switch (c.playerEquipment[c.playerWeapon]) {
+		case 4151:
+			c.playerStandIndex = 1832;
+			c.playerWalkIndex = 1660;
+			c.playerRunIndex = 1661;
+			break;
+		case 6528:
+			c.playerStandIndex = 0x811;
+			c.playerWalkIndex = 2064;
+			c.playerRunIndex = 1664;
+			break;
+		case 4153:
+			c.playerStandIndex = 1662;
+			c.playerWalkIndex = 1663;
+			c.playerRunIndex = 1664;
+			break;
+		case 11694:
+		case 11696:
+		case 11730:
+		case 11698:
+		case 11700:
+			c.playerStandIndex = 4300;
+			c.playerWalkIndex = 4306;
+			c.playerRunIndex = 4305;
+			break;
+		case 1305:
+			c.playerStandIndex = 809;
+			break;
+		}
+	}
+
+	/**
+	 * Weapon emotes
+	 **/
+
+	public static int getWeaponAnimation(Player c) {
+		String weaponName = ItemAssistant.getItemName(
+				c.playerEquipment[GameConstants.WEAPON]).toLowerCase();
+		if (c.playerEquipment[c.playerWeapon] <= 0) {
+			switch (c.fightMode) {
+			case 0:
+				return 422;
+			case 2:
+				return 423;
+			case 1:
+				return 451;
+			}
+		}
+		if (weaponName.contains("knife") || weaponName.contains("dart")
+				|| weaponName.contains("javelin")
+				|| weaponName.contains("thrownaxe")) {
+			return 806;
+		}
+		if (weaponName.contains("halberd")) {
+			return 440;
+		}
+		if (weaponName.contains("dragon dagger")) {
+			return 402;
+		}
+		if (weaponName.endsWith("dagger")) {
+			return 412;
+		}
+		if (weaponName.contains("2h sword") || weaponName.contains("godsword")
+				|| weaponName.contains("aradomin sword")) {
+			switch (c.fightMode) {
+			case 4:
+				return 406;
+			case 0:
+			case 2:
+			case 1:
+				return 407;
+			}
+		}
+		if (weaponName.contains("sword")) {
+			switch (c.fightMode) {
+			case 0:
+			case 1:
+				return 412;
+			case 2:
+				return 451;
+			}
+		}
+		if (weaponName.contains("karil")) {
+			return 2075;
+		}
+		if (weaponName.contains("bow") && !weaponName.contains("'bow")) {
+			return 426;
+		}
+		if (weaponName.contains("'bow")) {
+			return 4230;
+		}
+
+		switch (c.playerEquipment[c.playerWeapon]) { // if you don't want to
+														// use
+														// strings
+		case 6522:
+			return 2614;
+		case 4153: // granite maul
+			return 1665;
+		case 4726: // guthan
+			return 2080;
+		case 4747: // torag
+			return 0x814;
+		case 4718: // dharok
+			return 2067;
+		case 4710: // ahrim
+			return 406;
+		case 4755: // verac
+			return 2062;
+		case 4734: // karil
+			return 2075;
+		case 4151:
+			return 1658;
+		case 6528:
+			return 2661;
+		default:
+			return 451;
+		}
+	}
+
+	/**
+	 * Block emotes
+	 */
+	public static int getBlockEmote(Player c) {
+		if (c.playerEquipment[c.playerShield] >= 8844
+				&& c.playerEquipment[c.playerShield] <= 8850) {
+			return 4177;
+		}
+		switch (c.playerEquipment[c.playerWeapon]) {
+		case 4755:
+			return 2063;
+
+		case 4153:
+			return 1666;
+
+		case 4151:
+			return 1659;
+
+		case 11694:
+		case 11698:
+		case 11700:
+		case 11696:
+		case 11730:
+			return -1;
+		default:
+			return 404;
+		}
+	}
+
+	/**
+	 * How long it takes to hit your enemy
+	 **/
+	public static int getHitDelay(Player c) {
+		String weaponName = ItemAssistant.getItemName(
+				c.playerEquipment[GameConstants.WEAPON]).toLowerCase();
+		if (c.usingMagic) {
+			switch (MagicData.MAGIC_SPELLS[c.spellId][0]) {
+			case 12891:
+				return 4;
+			case 12871:
+				return 6;
+			default:
+				return 4;
+			}
+		} else {
+
+			if (weaponName.contains("knife") || weaponName.contains("dart")
+					|| weaponName.contains("javelin")
+					|| weaponName.contains("thrownaxe")) {
+				return 3;
+			}
+			if (weaponName.contains("cross") || weaponName.contains("c'bow")) {
+				return 4;
+			}
+			if (weaponName.contains("bow") && !c.dbowSpec) {
+				return 4;
+			} else if (c.dbowSpec) {
+				return 4;
+			}
+
+			switch (c.playerEquipment[c.playerWeapon]) {
+			case 6522: // Toktz-xil-ul
+				return 3;
+
+			default:
+				return 2;
+			}
+		}
+	}
+}
@@ -0,0 +1,52 @@
+package com.rebotted.game.content.combat.melee;
+
+import com.rebotted.game.players.Player;
+
+public class MeleeMaxHit {
+
+	public static int calculateMeleeMaxHit(Player c) {
+		double maxHit = 0;
+		int strBonus = c.playerBonus[10];
+		int strength = c.playerLevel[2];
+		int lvlForXP = c.getLevelForXP(c.playerXP[2]);
+		if (c.getPrayer().prayerActive[1]) {
+			strength += (int) (lvlForXP * .05);
+		} else if (c.getPrayer().prayerActive[6]) {
+			strength += (int) (lvlForXP * .10);
+		} else if (c.getPrayer().prayerActive[14]) {
+			strength += (int) (lvlForXP * .15);
+		} else if (c.getPrayer().prayerActive[24]) {
+			strength += (int) (lvlForXP * .18);
+		} else if (c.getPrayer().prayerActive[25]) {
+			strength += (int) (lvlForXP * .23);
+		}
+		if (c.playerEquipment[c.playerHat] == 2526
+				&& c.playerEquipment[c.playerChest] == 2520
+				&& c.playerEquipment[c.playerLegs] == 2522) {
+			maxHit += maxHit * 10 / 100;
+		}
+		maxHit += 1.05D + strBonus * strength * 0.00175D;
+		maxHit += strength * 0.11D;
+		if (c.playerEquipment[c.playerWeapon] == 4718
+				&& c.playerEquipment[c.playerHat] == 4716
+				&& c.playerEquipment[c.playerChest] == 4720
+				&& c.playerEquipment[c.playerLegs] == 4722) {
+			maxHit += (c.getPlayerAssistant().getLevelForXP(c.playerXP[3]) - c.playerLevel[3]) / 2;
+		}
+		if (c.specDamage > 1) {
+			maxHit = (int) (maxHit * c.specDamage);
+		}
+		if (maxHit < 0) {
+			maxHit = 1;
+		}
+		if (MeleeData.fullVoidMelee(c)) {
+			maxHit = (int) (maxHit * 1.10);
+		}
+		if (c.playerEquipment[c.playerAmulet] == 11128
+				&& c.playerEquipment[c.playerWeapon] == 6528) {
+			maxHit *= 1.20;
+		}
+		return (int) Math.floor(maxHit);
+	}
+
+}
@@ -0,0 +1,71 @@
+package com.rebotted.game.content.combat.melee;
+
+import com.rebotted.game.players.Client;
+
+/**
+ * Handles adding and removing hosts to the players array list.
+ */
+public class PlayerKilling {
+
+	/**
+	 * Adds the host of the killed player.
+	 * 
+	 * @param client
+	 *            Player that saves the host.
+	 * @param host
+	 *            Host address of the killed player.
+	 * @return True if the host is added to the players array.
+	 */
+
+	public static boolean addHostToList(Client client, String host) {
+		if (client != null) {
+			return client.lastKilledPlayers.add(host);
+		}
+		return false;
+	}
+
+	/**
+	 * Checks if the host is already on the players array.
+	 * 
+	 * @param client
+	 *            Player that is adding the killed players host.
+	 * @param host
+	 *            Host address of the killed player.
+	 * @return True if the host is on the players array.
+	 */
+
+	public static boolean hostOnList(Client client, String host) {
+		if (client != null) {
+			if (client.lastKilledPlayers.lastIndexOf(host) >= KILL_WAIT_MAX) {
+				removeHostFromList(client, host);
+				return false;
+			}
+			return client.lastKilledPlayers.contains(host);
+		}
+		return false;
+	}
+
+	/**
+	 * Removes the host from the players array.
+	 * 
+	 * @param client
+	 *            Player that is removing the host.
+	 * @param host
+	 *            Host that is being removed.
+	 * @return True if host is successfully removed.
+	 */
+
+	public static boolean removeHostFromList(Client client, String host) {
+		if (client != null) {
+			return client.lastKilledPlayers.remove(host);
+		}
+		return false;
+	}
+
+	/*
+	 * Amount of kills you have to wait before the host is deleted.
+	 */
+
+	public static final int KILL_WAIT_MAX = 3;
+
+}
@@ -0,0 +1,31 @@
+package com.rebotted.game.content.combat.npcs;
+
+import com.rebotted.game.content.minigames.FightCaves;
+import com.rebotted.game.content.minigames.PestControl;
+import com.rebotted.game.npcs.NpcHandler;
+
+public class NpcAggressive {
+
+	/**
+	 * Aggressive monsters
+	 */
+	private static final int[] AGGRESSIVE_MONSTERS = { 
+			1155, 374, 1157, 1158, 1159, 1160, 141, 1459, 1456, 96, 97, 142,
+			2550, 2551, 2552, 2553, 2558, 2559, 2560, 2561, 2562, 2563,
+			2564, 2565, 2892, 2894, 2881, 2882, 2883, 1593, 144, 112, 84, 3068,
+			50, 1590, 1591, 1592, 53, 54, 55, 178, 49, 2455, 2456, 2454,
+			82, 752, 1608, 1609, 1610, 1827, 2783, 1926, 1931, 2457, 412, 1604, 1612,
+			110, 1611, 83, 941, 49, 117, 111, 125, 1154, 107, 1342, 1338, 447, 448, 449, 917,
+			1265, 1267
+	};
+
+	public static boolean isAggressive(int i) {
+		boolean aggressive = NpcHandler.npcs[i].inWild() || PestControl.npcIsPCMonster(NpcHandler.npcs[i].npcType) || FightCaves.isFightCaveNpc(i);
+		for (int element : AGGRESSIVE_MONSTERS) {
+			if (NpcHandler.npcs[i].npcType == element || aggressive) {
+				return true;
+			}
+		}
+		return false;
+	}
+}
@@ -0,0 +1,678 @@
+package com.rebotted.game.content.combat.npcs;
+
+import com.rebotted.GameConstants;
+import com.rebotted.game.content.combat.CombatAssistant;
+import com.rebotted.game.content.combat.melee.MeleeData;
+import com.rebotted.game.content.minigames.FightCaves;
+import com.rebotted.game.content.music.sound.CombatSounds;
+import com.rebotted.game.content.music.sound.SoundList;
+import com.rebotted.game.npcs.NpcData;
+import com.rebotted.game.npcs.NpcHandler;
+import com.rebotted.game.players.Client;
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+import com.rebotted.util.Misc;
+
+public class NpcCombat {
+
+	public static void multiAttackDamage(int i) {
+		int max = NpcHandler.getMaxHit(i);
+		for (Player player : PlayerHandler.players) {
+			if (player != null) {
+				Client c = (Client) player;
+				if (c.isDead || c.heightLevel != NpcHandler.npcs[i].heightLevel) {
+					continue;
+				}
+				if (player.goodDistance(c.absX, c.absY,
+						NpcHandler.npcs[i].absX, NpcHandler.npcs[i].absY, 15)) {
+					if (NpcHandler.npcs[i].attackType == 2) {
+						if (!c.getPrayer().prayerActive[16]) {
+							if (Misc.random(500) + 200 > Misc.random(c
+									.getCombatAssistant().mageDef())) {
+								int dam = Misc.random(max);
+								c.dealDamage(dam);
+								c.handleHitMask(dam);
+							} else {
+								c.dealDamage(0);
+								c.handleHitMask(0);
+							}
+						} else {
+							c.dealDamage(0);
+							c.handleHitMask(0);
+						}
+					} else if (NpcHandler.npcs[i].attackType == 1) {
+						if (!c.getPrayer().prayerActive[17]) {
+							int dam = Misc.random(max);
+							if (Misc.random(500) + 200 > Misc.random(c
+									.getCombatAssistant()
+									.calculateRangeDefence())) {
+								c.dealDamage(dam);
+								c.handleHitMask(dam);
+							} else {
+								c.dealDamage(0);
+								c.handleHitMask(0);
+							}
+						} else {
+							c.dealDamage(0);
+							c.handleHitMask(0);
+						}
+					}
+					if (NpcHandler.npcs[i].endGfx > 0) {
+						c.gfx0(NpcHandler.npcs[i].endGfx);
+					}
+				}
+				c.getPlayerAssistant().refreshSkill(3);
+			}
+		}
+	}
+
+	public static void multiAttackGfx(int i, int gfx) {
+		if (NpcHandler.npcs[i].projectileId < 0) {
+			return;
+		}
+		for (Player player : PlayerHandler.players) {
+			if (player != null) {
+				Client c = (Client) player;
+				if (c.heightLevel != NpcHandler.npcs[i].heightLevel) {
+					continue;
+				}
+				if (player.goodDistance(c.absX, c.absY,
+						NpcHandler.npcs[i].absX, NpcHandler.npcs[i].absY, 15)) {
+					int nX = NpcHandler.npcs[i].getX() + NpcHandler.offset(i);
+					int nY = NpcHandler.npcs[i].getY() + NpcHandler.offset(i);
+					int pX = c.getX();
+					int pY = c.getY();
+					int offX = (nY - pY) * -1;
+					int offY = (nX - pX) * -1;
+					c.getPlayerAssistant().createPlayersProjectile(nX, nY,
+							offX, offY, 50, NpcHandler.getProjectileSpeed(i),
+							NpcHandler.npcs[i].projectileId, 43, 31,
+							-c.getId() - 1, 65);
+				}
+			}
+		}
+	}
+
+	public static void attackPlayer(Player c, int i) {
+		if (NpcHandler.npcs[i] != null) {
+			if (NpcHandler.npcs[i].isDead) {
+				return;
+			}
+			if (c.npcCanAttack == false) {
+				return;
+			}
+			if (NpcHandler.npcs[i].inLesserNpc()) {
+				return;
+			}
+			if (c.inDraynorBuilding()) {
+				if (NpcHandler.npcs[i].npcType == 172 || NpcHandler.npcs[i].npcType == 174) {
+					return;
+				}
+			}
+			if (NpcHandler.npcs[i].absY == 3228 && c.absY == 3227) {
+				return;
+			}
+			if (NpcHandler.npcs[i].absY == 3224 && c.absY == 3225) {
+				return;
+			}
+			if (NpcHandler.npcs[i].absY == 3226 && c.absY == 3227) {
+				return;
+			}
+			if (NpcHandler.npcs[i].absY == 3228 && c.absY == 3227) {
+				return;
+			}
+			if (NpcHandler.npcs[i].npcType > 2462 && NpcHandler.npcs[i].npcType < 2468) {
+				if (Misc.random(5) == 0) {
+					NpcHandler.npcs[i].forceChat("Flee from me, " + c.playerName + "!");
+				} else if (Misc.random(5) == 1) {
+					NpcHandler.npcs[i].forceChat("Begone, " + c.playerName + "!");
+				} else if (Misc.random(5) == 2) {
+					NpcHandler.npcs[i].forceChat("Bwuk");
+				} else if (Misc.random(5) == 3) {
+					NpcHandler.npcs[i].forceChat("Bwuk bwuk bwuk");
+				} else if (Misc.random(5) == 4) {
+					NpcHandler.npcs[i].forceChat("MUAHAHAHAHAAA!");
+				} else if (Misc.random(5) == 5) {
+					NpcHandler.npcs[i].forceChat("Bwaaaaaaauk bwuk bwuk");
+				}
+			}
+			if (NpcHandler.npcs[i].npcType == 1532
+					|| NpcHandler.npcs[i].npcType == 1534
+					|| NpcHandler.npcs[i].npcType == 6145
+					|| NpcHandler.npcs[i].npcType == 6144
+					|| NpcHandler.npcs[i].npcType == 6143
+					|| NpcHandler.npcs[i].npcType == 6142
+					|| NpcHandler.npcs[i].npcType == 752) {
+				return;
+			}
+			if (NpcHandler.npcs[i].npcType == 1401 && c.isInTut()
+					|| c.tutorialProgress < 36) {
+				return;
+			}
+			if (NpcHandler.npcs[i].npcType == 9 && c.absX == 3180
+					&& c.absY > 3433 && c.absY < 3447) {
+				return;
+			}
+			if (NpcHandler.npcs[i].npcType == 374 && c.absY == 3372 && c.absX > 2522 && c.absX < 2532) {
+				return;
+			}
+			if (!NpcHandler.npcs[i].inMulti() && NpcHandler.npcs[i].underAttackBy > 0 && NpcHandler.npcs[i].underAttackBy != c.playerId) {
+				NpcHandler.npcs[i].killerId = 0;
+				return;
+			}
+			if (!NpcHandler.npcs[i].inMulti()
+					&& (c.underAttackBy > 0 || c.underAttackBy2 > 0
+							&& c.underAttackBy2 != i)) {
+				NpcHandler.npcs[i].killerId = 0;
+				return;
+			}
+			if (NpcHandler.npcs[i].heightLevel != c.heightLevel) {
+				NpcHandler.npcs[i].killerId = 0;
+				return;
+			}
+			if (!NpcData.goodDistanceNpc(NpcHandler.npcs[i].npcId, c.getX(), c.getY(), NpcData.distanceRequired(NpcHandler.npcs[i].npcId)) || NpcData.inNpc(NpcHandler.npcs[i].npcId, c.getX(), c.getY())) {
+				return;
+			}
+			NpcHandler.npcs[i].facePlayer(c.playerId);
+			boolean special = false;//specialCase(c,i);
+			if (NpcData.checkClip(NpcHandler.npcs[i]) || special) {
+				if (c.respawnTimer <= 0) {
+					NpcHandler.npcs[i].facePlayer(c.playerId);
+					NpcHandler.npcs[i].attackTimer = NpcData.getNpcDelay(i);
+					NpcHandler.npcs[i].hitDelayTimer = NpcData.getHitDelay(i);
+					NpcHandler.npcs[i].attackType = 0;
+					if (GameConstants.COMBAT_SOUNDS
+							&& NpcHandler.npcs[i].npcType < 3177
+							&& NpcHandler.npcs[i].npcType > 3180) {
+						c.getPacketSender()
+								.sendSound(
+										CombatSounds
+												.getNpcAttackSounds(NpcHandler.npcs[i].npcType),
+										100, 0);
+					}
+					if (special) {
+						loadSpell2(i);
+					} else {
+						loadSpell(c, i);
+					}
+					if (NpcHandler.npcs[i].attackType == 3) {
+						NpcHandler.npcs[i].hitDelayTimer += 2;
+					}
+					if (NpcHandler.multiAttacks(i)) {
+						multiAttackGfx(i, NpcHandler.npcs[i].projectileId);
+						NpcData.startAnimation(NpcEmotes.getAttackEmote(i), i);
+						if (GameConstants.COMBAT_SOUNDS
+								&& NpcHandler.npcs[i].npcType < 3177
+								&& NpcHandler.npcs[i].npcType > 3180) {
+							c.getPacketSender()
+									.sendSound(
+											CombatSounds
+													.getNpcAttackSounds(NpcHandler.npcs[i].npcType),
+											100, 0);
+						}
+						NpcHandler.npcs[i].oldIndex = c.playerId;
+						return;
+					}
+					if (NpcHandler.npcs[i].projectileId > 0) {
+						int nX = NpcHandler.npcs[i].getX()
+								+ NpcHandler.offset(i);
+						int nY = NpcHandler.npcs[i].getY()
+								+ NpcHandler.offset(i);
+						int pX = c.getX();
+						int pY = c.getY();
+						int offX = (nY - pY) * -1;
+						int offY = (nX - pX) * -1;
+						c.getPlayerAssistant().createPlayersProjectile(nX, nY,
+								offX, offY, 50,
+								NpcHandler.getProjectileSpeed(i),
+								NpcHandler.npcs[i].projectileId, 43, 31,
+								-c.getId() - 1, 65);
+					}
+					int random = Misc.random(10);
+					if (NpcHandler.npcs[i].npcType == 222 && (NpcHandler.npcs[i].killerId > 0 && NpcHandler.npcs[i].underAttack) && !NpcHandler.npcs[i].isDead && (NpcHandler.npcs[i].HP < NpcHandler.npcs[i].MaxHP + 1)) {
+						if (random < 3) {
+							NpcHandler.npcs[i].HP += 2;
+							//NpcHandler.npcs[i].startAnimation(84); 
+							NpcHandler.npcs[i].updateRequired = true;
+						}
+					}
+					c.underAttackBy2 = i;
+					c.singleCombatDelay2 = System.currentTimeMillis();
+					NpcHandler.npcs[i].oldIndex = c.playerId;
+					NpcData.startAnimation(NpcEmotes.getAttackEmote(i), i);
+					if (GameConstants.COMBAT_SOUNDS
+							&& NpcHandler.npcs[i].npcType < 3177
+							&& NpcHandler.npcs[i].npcType > 3180) {
+						c.getPacketSender()
+								.sendSound(
+										CombatSounds
+												.getNpcAttackSounds(NpcHandler.npcs[i].npcType),
+										100, 0);
+					}
+					c.getPacketSender().closeAllWindows();
+				}
+			}
+		}
+	}
+
+	public static void loadSpell2(int i) {
+		NpcHandler.npcs[i].attackType = 3;
+		int random = Misc.random(3);
+		if (random == 0) {
+			NpcHandler.npcs[i].projectileId = 393; // red
+			NpcHandler.npcs[i].endGfx = 430;
+		} else if (random == 1) {
+			NpcHandler.npcs[i].projectileId = 394; // green
+			NpcHandler.npcs[i].endGfx = 429;
+		} else if (random == 2) {
+			NpcHandler.npcs[i].projectileId = 395; // white
+			NpcHandler.npcs[i].endGfx = 431;
+		} else if (random == 3) {
+			NpcHandler.npcs[i].projectileId = 396; // blue
+			NpcHandler.npcs[i].endGfx = 428;
+		}
+	}
+
+	public static void loadSpell(Player c, int i) {
+		if (NpcHandler.npcs[i].npcType > 2462 && NpcHandler.npcs[i].npcType < 2469 || NpcHandler.npcs[i].npcType > 3751 && NpcHandler.npcs[i].npcType < 3762) {
+			NpcHandler.npcs[i].attackType = 2;
+		}
+		if (NpcHandler.npcs[i].npcType > 3761 && NpcHandler.npcs[i].npcType < 3772) {
+			NpcHandler.npcs[i].attackType = 1;
+		}
+		switch (NpcHandler.npcs[i].npcType) {
+		case 2607:
+			NpcHandler.npcs[i].attackType = 1;
+		case 2591:
+		case 172:
+		case 174:
+			NpcHandler.npcs[i].attackType = 2;
+		break;
+		case 3068:
+		if(Misc.random(10) > 7) {
+			NpcHandler.npcs[i].projectileId = 393; //red
+			NpcHandler.npcs[i].endGfx = 430;
+			NpcHandler.npcs[i].attackType = 3;
+			NpcData.startAnimation(2989, i);
+		} else {
+			NpcData.startAnimation(2980, i);
+			NpcHandler.npcs[i].attackType = 0;
+		}
+		break;
+		case 2892:
+			NpcHandler.npcs[i].projectileId = 94;
+			NpcHandler.npcs[i].attackType = 2;
+			NpcHandler.npcs[i].endGfx = 95;
+			break;
+		case 2894:
+			NpcHandler.npcs[i].projectileId = 298;
+			NpcHandler.npcs[i].attackType = 1;
+			break;
+		/*
+		 * Better Dragons
+		 */
+		case 5363: // Mithril-Dragon
+		case 53: // Red Dragon
+		case 54: // Black-Dragon
+		case 55: // Blue-Dragon
+		case 941: // Green-Dragon
+		case 4682:
+		case 5362:
+		case 1590:
+		case 1591:
+		case 1592:
+			int random1 = Misc.random(3);
+			switch (random1) {
+			case 1:
+				NpcHandler.npcs[i].projectileId = 393; // red
+				NpcHandler.npcs[i].endGfx = 430;
+				NpcHandler.npcs[i].attackType = 3;
+				break;
+			default:
+				NpcHandler.npcs[i].projectileId = -1; // melee
+				NpcHandler.npcs[i].endGfx = -1;
+				NpcHandler.npcs[i].attackType = 0;
+				break;
+			}
+			break;
+		case 134:
+			if (c.playerLevel[5] > 0) {
+				c.playerLevel[5]--;
+				c.getPlayerAssistant().refreshSkill(5);
+				c.getPlayerAssistant().appendPoison(5);
+				c.getCombatAssistant().resetPlayerAttack();
+			}
+			break;
+
+		case 3590:
+		case 50:
+		case 742:
+			int random = Misc.random(4);
+			switch (random) {
+			case 0:
+				NpcHandler.npcs[i].projectileId = 393; // red
+				NpcHandler.npcs[i].endGfx = 430;
+				NpcHandler.npcs[i].attackType = 3;
+				break;
+			case 1:
+				NpcHandler.npcs[i].projectileId = 394; // green
+				NpcHandler.npcs[i].endGfx = 429;
+				NpcHandler.npcs[i].attackType = 3;
+				break;
+			case 2:
+				NpcHandler.npcs[i].projectileId = 395; // white
+				NpcHandler.npcs[i].endGfx = 431;
+				NpcHandler.npcs[i].attackType = 3;
+				break;
+			case 3:
+				NpcHandler.npcs[i].projectileId = 396; // blue
+				NpcHandler.npcs[i].endGfx = 428;
+				NpcHandler.npcs[i].attackType = 3;
+				break;
+			case 4:
+				NpcHandler.npcs[i].projectileId = -1; // melee
+				NpcHandler.npcs[i].endGfx = -1;
+				NpcHandler.npcs[i].attackType = 0;
+				break;
+			}
+			break;
+		// arma npcs
+		case 2561:
+			NpcHandler.npcs[i].attackType = 0;
+			break;
+		case 2560:
+			NpcHandler.npcs[i].attackType = 1;
+			NpcHandler.npcs[i].projectileId = 1190;
+			break;
+		case 2559:
+			NpcHandler.npcs[i].attackType = 2;
+			NpcHandler.npcs[i].projectileId = 1203;
+			break;
+		case 2558:
+			random = Misc.random(1);
+			NpcHandler.npcs[i].attackType = 1 + random;
+			if (NpcHandler.npcs[i].attackType == 1) {
+				NpcHandler.npcs[i].projectileId = 1197;
+			} else {
+				NpcHandler.npcs[i].attackType = 2;
+				NpcHandler.npcs[i].projectileId = 1198;
+			}
+			break;
+		// sara npcs
+		case 2562: // sara
+			random = Misc.random(1);
+			if (random == 0) {
+				NpcHandler.npcs[i].attackType = 2;
+				NpcHandler.npcs[i].endGfx = 1224;
+				NpcHandler.npcs[i].projectileId = -1;
+			} else if (random == 1) {
+				NpcHandler.npcs[i].attackType = 0;
+			}
+			break;
+		case 2563: // star
+			NpcHandler.npcs[i].attackType = 0;
+			break;
+		case 2564: // growler
+			NpcHandler.npcs[i].attackType = 2;
+			NpcHandler.npcs[i].projectileId = 1203;
+			break;
+		case 2565: // bree
+			NpcHandler.npcs[i].attackType = 1;
+			NpcHandler.npcs[i].projectileId = 9;
+			break;
+		// bandos npcs
+		case 2550:
+			random = Misc.random(2);
+			if (random == 0 || random == 1) {
+				NpcHandler.npcs[i].attackType = 0;
+			} else {
+				NpcHandler.npcs[i].attackType = 1;
+				NpcHandler.npcs[i].endGfx = 1211;
+				NpcHandler.npcs[i].projectileId = 288;
+			}
+			break;
+		case 2551:
+			NpcHandler.npcs[i].attackType = 0;
+			break;
+		case 2552:
+			NpcHandler.npcs[i].attackType = 2;
+			NpcHandler.npcs[i].projectileId = 1203;
+			break;
+		case 2553:
+			NpcHandler.npcs[i].attackType = 1;
+			NpcHandler.npcs[i].projectileId = 1206;
+			break;
+		case 2025:
+			NpcHandler.npcs[i].attackType = 2;
+			int r = Misc.random(3);
+			if (r == 0) {
+				NpcHandler.npcs[i].gfx100(158);
+				NpcHandler.npcs[i].projectileId = 159;
+				NpcHandler.npcs[i].endGfx = 160;
+			}
+			if (r == 1) {
+				NpcHandler.npcs[i].gfx100(161);
+				NpcHandler.npcs[i].projectileId = 162;
+				NpcHandler.npcs[i].endGfx = 163;
+			}
+			if (r == 2) {
+				NpcHandler.npcs[i].gfx100(164);
+				NpcHandler.npcs[i].projectileId = 165;
+				NpcHandler.npcs[i].endGfx = 166;
+			}
+			if (r == 3) {
+				NpcHandler.npcs[i].gfx100(155);
+				NpcHandler.npcs[i].projectileId = 156;
+			}
+			break;
+		case 2881:// supreme
+			NpcHandler.npcs[i].attackType = 1;
+			NpcHandler.npcs[i].projectileId = 298;
+			break;
+
+		case 2882:// prime
+			NpcHandler.npcs[i].attackType = 2;
+			NpcHandler.npcs[i].projectileId = 162;
+			NpcHandler.npcs[i].endGfx = 477;
+			break;
+
+		case 2028:
+			NpcHandler.npcs[i].attackType = 1;
+			NpcHandler.npcs[i].projectileId = 27;
+			break;
+
+		case 3200:
+			int r2 = Misc.random(1);
+			if (r2 == 0) {
+				NpcHandler.npcs[i].attackType = 1;
+				NpcHandler.npcs[i].gfx100(550);
+				NpcHandler.npcs[i].projectileId = 551;
+				NpcHandler.npcs[i].endGfx = 552;
+			} else {
+				NpcHandler.npcs[i].attackType = 2;
+				NpcHandler.npcs[i].gfx100(553);
+				NpcHandler.npcs[i].projectileId = 554;
+				NpcHandler.npcs[i].endGfx = 555;
+			}
+			break;
+		case 2745:
+			int r3 = 0;
+			if (NpcHandler
+					.goodDistance(
+							NpcHandler.npcs[i].absX,
+							NpcHandler.npcs[i].absY,
+							PlayerHandler.players[NpcHandler.npcs[i].spawnedBy].absX,
+							PlayerHandler.players[NpcHandler.npcs[i].spawnedBy].absY,
+							1)) {
+				r3 = Misc.random(2);
+			} else {
+				r3 = Misc.random(1);
+			}
+			if (r3 == 0) {
+				NpcHandler.npcs[i].attackType = 2;
+				NpcHandler.npcs[i].endGfx = 157;
+				NpcHandler.npcs[i].projectileId = 448;
+			} else if (r3 == 1) {
+				NpcHandler.npcs[i].attackType = 1;
+				NpcHandler.npcs[i].endGfx = 451;
+				NpcHandler.npcs[i].projectileId = -1;
+			} else if (r3 == 2) {
+				NpcHandler.npcs[i].attackType = 0;
+				NpcHandler.npcs[i].projectileId = -1;
+			}
+			break;
+		case 2743:
+			NpcHandler.npcs[i].attackType = 2;
+			NpcHandler.npcs[i].projectileId = 445;
+			NpcHandler.npcs[i].endGfx = 446;
+			break;
+
+		case 2631:
+			NpcHandler.npcs[i].attackType = 1;
+			NpcHandler.npcs[i].projectileId = 443;
+			break;
+		}
+	}
+
+	public static void registerNpcHit(int i) {
+		if (NpcHandler.npcs[i] != null) {
+			if (PlayerHandler.players[NpcHandler.npcs[i].oldIndex] == null) {
+				return;
+			}
+			if (NpcHandler.npcs[i].isDead) {
+				return;
+			}
+			Client c = (Client) PlayerHandler.players[NpcHandler.npcs[i].oldIndex];
+			if (NpcHandler.multiAttacks(i)) {
+				NpcCombat.multiAttackDamage(i);
+				return;
+			}
+			if (c.playerIndex <= 0 && c.npcIndex <= 0) {
+				if (c.autoRet == 1 && NpcHandler.npcs[i].npcType != 411) {
+					c.npcIndex = i;
+				}
+			}
+			if (c.attackTimer <= 3 || c.attackTimer == 0 && c.npcIndex == 0 && c.oldNpcIndex == 0) {
+				c.startAnimation(c.getCombatAssistant().getBlockEmote());
+			}
+			if (c.respawnTimer <= 0) {
+				int damage = 0;
+				if (NpcHandler.npcs[i].attackType == 0) {
+					damage = Misc.random(NpcHandler.npcs[i].maxHit);
+					if (10 + Misc.random(c.getCombatAssistant().calcDef()) > Misc
+							.random(NpcHandler.npcs[i].attack)) {
+						damage = 0;
+					}
+					if (NpcData.cantKillYou(NpcHandler.npcs[i].npcType)) {
+						if (damage >= c.playerLevel[GameConstants.HITPOINTS]) {
+							damage = c.playerLevel[GameConstants.HITPOINTS] - 1;
+						}
+					}
+					if (c.getPrayer().prayerActive[18]
+							&& !(NpcHandler.npcs[i].npcType == 2030)) { // protect
+																		// from
+																		// melee)
+																		// {
+																		// //
+																		// protect
+																		// from
+																		// melee
+						damage = 0;
+					} else if (c.getPrayer().prayerActive[18]
+							&& NpcHandler.npcs[i].npcType == 2030) {
+						if (NpcHandler.npcs[i].attackType == 0) {
+							damage = Misc.random(NpcHandler.npcs[i].maxHit);
+						}
+						if (10 + Misc
+								.random(MeleeData.calculateMeleeDefence(c)) > Misc
+								.random(NpcHandler.npcs[i].attack)) {
+							damage = 0;
+						}
+					}
+					if (c.playerLevel[3] - damage < 0) {
+						damage = c.playerLevel[3];
+					}
+				}
+
+				if (NpcHandler.npcs[i].attackType == 1) { // range
+					damage = Misc.random(NpcHandler.npcs[i].maxHit);
+					if (10 + Misc.random(c.getCombatAssistant()
+							.calculateRangeDefence()) > Misc
+							.random(NpcHandler.npcs[i].attack)) {
+						damage = 0;
+					}
+					if (NpcData.cantKillYou(NpcHandler.npcs[i].npcType)) {
+						if (damage >= c.playerLevel[GameConstants.HITPOINTS]) {
+							damage = c.playerLevel[GameConstants.HITPOINTS] - 1;
+						}
+					}
+					if (c.getPrayer().prayerActive[17]) { // protect from range
+						damage = 0;
+					}
+					if (c.playerLevel[3] - damage < 0) {
+						damage = c.playerLevel[3];
+					}
+				}
+
+				if (NpcHandler.npcs[i].attackType == 2) { // magic
+					damage = Misc.random(NpcHandler.npcs[i].maxHit);
+					boolean magicFailed = false;
+					if (10 + Misc.random(c.getCombatAssistant().mageDef()) > Misc
+							.random(NpcHandler.npcs[i].attack)) {
+						damage = 0;
+						magicFailed = true;
+					}
+					if (NpcData.cantKillYou(NpcHandler.npcs[i].npcType)) {
+						if (damage >= c.playerLevel[GameConstants.HITPOINTS]) {
+							damage = c.playerLevel[GameConstants.HITPOINTS] - 1;
+						}
+					}
+					if (c.getPrayer().prayerActive[16]) { // protect from magic
+						damage = 0;
+						magicFailed = true;
+					}
+					if (c.playerLevel[3] - damage < 0) {
+						damage = c.playerLevel[3];
+					}
+					if (NpcHandler.npcs[i].endGfx > 0 && (!magicFailed || FightCaves.isFightCaveNpc(i))) {
+						c.gfx100(NpcHandler.npcs[i].endGfx);
+					} else {
+						c.gfx100(85);
+						c.getPacketSender().sendSound(SoundList.MAGE_FAIL,
+								100, 0);
+					}
+				}
+
+				if (NpcHandler.npcs[i].attackType == 3) { // fire breath
+					int anti = c.getPlayerAssistant().antiFire();
+					switch (anti) {
+					case 0:// has no shield
+						damage = Misc.random(45) + 10;
+						c.getPacketSender().sendMessage("You are badly burnt by the dragon fire!");
+						break;
+					case 1:// has a shield
+						if (c.getItemAssistant().playerHasEquipped(5, 1540)) {
+							damage = Misc.random(4) + 1;
+							c.getPacketSender().sendMessage("Your shield protects you from the fire.");
+						}
+						break;
+					case 2:// melee
+						damage = Misc.random(5);
+						break;
+					}
+				}
+				if (damage > 0) {
+					CombatAssistant.applyRecoilNPC(c, damage, i);
+				}
+				NpcHandler.handleSpecialEffects(c, i, damage);
+				c.logoutDelay = System.currentTimeMillis(); // logout delay
+				c.handleHitMask(damage);
+				c.playerLevel[3] -= damage;
+				c.getPlayerAssistant().refreshSkill(3);
+				FightCaves.tzKihEffect(c, i, damage);
+				c.updateRequired = true;
+			}
+		}
+	}
+
+}
@@ -0,0 +1,182 @@
+package com.rebotted.game.content.combat.npcs;
+
+import com.rebotted.game.npcs.NpcHandler;
+
+/**
+ * Npc Emotes
+ * @author Andrew (Mr Extremez)
+ */
+
+public enum NpcEmotes {
+		MAN(new int[] {1, 2, 3, 4, 5, 6}, 422, 1834, 836),
+		GARGOYLE(new int[] {1610, 1611}, 1517, 1519, 1518),
+		SKELETAL_WYVERN(new int[] {3068}, 2989, 2988, 2987),
+		BAT(new int[] {412, 78}, 30, 31, 36),
+		BEAR(new int[] {105, 106}, 41, 42, 44),
+		HOB_GOBLIN(new int[] {122, 123}, 164, 165, 167),
+		AHRIM(new int[] {2025}, 729, 404, 2304),
+		DHAROK(new int[] {2026}, 2067, 404, 2304),
+		GUTHAN(new int[] {2027}, 422, 404, 2304),
+		KARIL(new int[] {2028}, 2075, 404, 2304),
+		TORAG(new int[] {2029}, 0x814, 404, 2304),
+		VERAC(new int[] {2030}, 2062, 404, 2304),
+		BABY_DRAGON(new int[] {51, 52, 1589, 3376}, 25, 26, 28),
+		CHICKEN(new int[] {41}, 55, 56, 57),
+		KBD_METAL_DRAGON(new int [] {50, 1590, 1591, 1592}, 80, 89, 92),
+		DRAGON(new int[] {53, 54, 55, 941}, 91, 89, 92),
+		BASILISK(new int[] {1616, 1617, 4228}, 1546, 1547, 1548),
+		BLOOD_WORM(new int[] {2031}, 2070, 2072, 2073),
+		TREE_SPIRIT(new int[] {438, 439, 440, 441, 442, 443}, 94, 95, 97),
+		ZOMBIE(new int[] {73, 74, 75, 76, 751}, 299, 300, 302),
+		ROCK_GOLEM(new int[] {413, 414, 415, 416, 417, 418}, 153, 154, 156),
+		RIVER_TROLL(new int[] {391, 392, 393, 394, 395, 396}, 284, 285, 287),
+		GOBLIN(new int[] {100, 101, 102, 1769, 1770, 1771, 1772, 1773, 1774, 1775, 1776}, 309, 312, 313),
+		COW(new int[] {81, 397, 1766, 1767, 1768}, 59, 60, 62),
+		BLOODVELD(new int[] {1618, 1619}, 1552, 1550, 1553),
+		IMP(new int[] {708}, 169, 170, 172),
+		DARK_WIZARD(new int[] {172, 13}, 711, 1834, 836),
+		DUCK(new int[] {44, 45}, 7, 8, 9),
+		SPINOLYP(new int[] {2892, 2894}, 2868, 2864, 2865),
+		DWARF(new int[] {118, 119}, 99, 100, 102),
+		DEFILER(new int[] {3762, 3763, 3764, 3765, 3766, 3767, 3768, 3769, 3770, 3771}, 3920, 3921, 3922),
+		SPINNER(new int[] {3747, 3748, 3749, 3750, 3751}, 3908, 3909, 3910),
+		SHIFTER(new int[] {3732, 3733, 3734, 3735, 3736, 3737, 3738, 3739, 3740, 3741}, 3901, 3902, 3903),
+		RAVAGER(new int[] {3742, 3743, 3744, 3745, 3746}, 3915, 3916, 3917),
+		BRAWLER(new int[] {3772, 3773, 3774, 3775, 3776}, 3897, 3895, 3894),
+		SPLATTER(new int[] {3727, 3728, 3729, 3730, 3731}, 3891, 3890, 3888),
+		TORCHER(new int[] {3752, 3753, 3754, 3755, 3756, 3757, 3758, 3759, 3760, 3761}, 3882, 3880, 3881),
+		KALPHITE_WORKER(new int[] {1153, 1154, 1155, 1156, 1157, 1158, 1161}, 1184, 1186, 1187),
+		KALPHITE_QUEEN(new int[] {1159}, 1185, 1186, 1187),
+		KALPHITE_QUEEN_2(new int[] {1160}, 1177, 1179, 1182),
+		DEMON(new int[] {82, 83, 84, 1472}, 64, 65, 67),
+		DUST_DEVIL(new int[] {1624}, 1557, 1555, 1558),
+		CHAOS_ELEMENTAL(new int[] {3200}, 3146, 3148, 3147),
+		GIANT(new int[] {110, 111, 112, 113, 116, 117}, 128, 129, 131),
+		DAGGANOTH_PRIME(new int[] {2881}, 2855, 2852, 2856),
+		DAGGANOTH_SUPREME(new int[] {2882}, 2854, 2852, 2856),
+		DAGGANOTH_REX(new int[] {2883}, 2851, 2852, 2856),
+		WHITE_KNIGHT(new int[] {1092, 19}, 406, -1, 843),
+		KNIGHT_WARRIOR(new int[] {125, 178, 179}, 451, -1, 843),
+		PORTAL(new int[] {3777, 3778, 3779, 3780}, -1, -1, -1),
+		DARK_BEAST(new int[] {2783}, 2731, 2732, 2733),
+		TZHAAR_NPCS(new int[] {2604, 2598, 2591}, 2609, 2606, 2607),
+		TZHAAR_MEJ(new int[] {2591}, 2612, 2606, 2607),
+		TZHAAR_KET(new int[] {2610, 2615}, 2612, 2606, 2608),
+		TZHAAR_XIL(new int[] {2607}, 2611, 2610, 2607),
+		TZ_KIH(new int[] {2627}, 2621, 2622, 2620),
+		TZ_KEK(new int[] {2629, 2630, 2736, 2738}, 2625, 2626, 2627),
+		TOK_XIL(new int[] {2631, 2632}, 2628, 2629, 2630),
+		TZHAAR_YT(new int[] {2741, 2742, 2746}, 2637, 2635, 2638),
+		KET_ZEK(new int[] {2743, 2744}, 2644, 2645, 2646),
+		COCKATRICE(new int[] {1620, 1621}, 1562, 1560, 1563),
+		GNOME_CHILD(new int[] {160, 161}, 191, 194, 196),
+		GNOME_GUARD(new int[] {163, 164}, 192, 193, 196),
+		GNOME_WOMAN(new int[] {168, 169}, 190, 193, 196),
+		TUROTH(new int[] {1626, 1627, 1628, 1629, 1630, 1631, 1632}, 1595, 1596, 1597),
+		GHOST(new int[] {103, 104, 491}, 123, 124, 126),
+		ROCK_CRAB(new int[] {1265, 1267}, 1312, 1313, 1314),
+		DOG_WOLF(new int[] {96, 97, 99, 1593, 1594, 141, 142, 143}, 75, 76, 78),
+		SPIDER(new int[] {58, 59, 60, 62, 63, 64, 134, 1009, 2035}, 143, 144, 146),
+		UNICORN(new int[] {89, 133, 987}, 289, 290, 292),
+		OGRE(new int[] {114, 115, 374}, 359, 360, 361),
+		FIEND(new int[] {1633, 1634, 1635, 1636, 3406}, 1582, 1581, 1580),
+		BANSHEE(new int[] {1612}, 1523, 1525, 1524),
+		EXPERIMENT_25(new int[] {1677}, 1616, 1617, 1618),
+		EXPERIMENT_25_2(new int[] {1678}, 1612, 1613, 1614),
+		EXPERIMENT_51(new int[] {1676}, 1626, 1627, 1628),
+		ABYSSAL_DEMON(new int[] {1615}, 1537, 1539, 1538),
+		NECHRYAEL(new int[] {1613}, 1528, 1529, 1530),
+		SCORPION(new int[] {144, 107, 108}, 246, 247, 248),
+		SMALL_SPIDER(new int[] {61}, 280, 279, 273),
+		PIT_SCORPION(new int[] {109}, 270, 271, 273),
+		CRAWLING_HAND(new int[] {1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657}, 1592, 1591, 1590),
+		ABBERANT_SPECTRE(new int[] {1604, 1605, 1606, 1607}, 1507, 1509, 1508),
+		INFERNAL_MAGE(new int[] {1643, 1644, 1645, 1646, 1647}, 429, 430, 2304),
+		MONKEY_GUARD(new int[] {1455, 1459, 1460}, 1402, 1403, 1404),
+		RAT(new int[] {86, 87, 88, 224, 446, 748, 950, 978, 2033}, 138, 139, 141),
+		SMALL_RAT(new int[] {47, 2032}, 2705, 2706, 2707),
+		DAGGANOTH(new int[] {1338, 1340, 1341, 1342, 2455, 2456}, 1341, 1340, 1342),
+		SKELETON(new int[] {90, 91, 92, 93}, 260, 261, 263);
+		
+		int[] npcId;
+		int attackAnim, blockAnim, deadAnim;
+	
+		private NpcEmotes(int[] npcId, int attackAnim, int blockAnim, int deadAnim) {
+			this.npcId = npcId;
+			this.attackAnim = attackAnim;
+			this.blockAnim = blockAnim;
+			this.deadAnim = deadAnim;
+		}
+		
+		private int[] getNpcId() {
+			return npcId;
+		}
+		
+		private int getAttack() {
+			return attackAnim;
+		}
+		
+		private int getBlock() {
+			return blockAnim;	
+		}
+		
+		private int getDead() {
+			return deadAnim;
+		}
+
+	public static int getAttackEmote(int i) {
+		for (NpcEmotes e : NpcEmotes.values()) {
+			for (int f = 0; f < e.getNpcId().length; f++) {
+				if (NpcHandler.npcs[i].npcType == e.getNpcId()[f]) {
+					return e.getAttack();
+				} else {
+					switch (NpcHandler.npcs[i].npcType) {
+					case 2745:
+						if (NpcHandler.npcs[i].attackType == 2) {
+							return 2656;
+						} else if (NpcHandler.npcs[i].attackType == 1) {
+							return 2652;
+						} else if (NpcHandler.npcs[i].attackType == 0) {
+							return 2655;
+						}
+						
+					}
+				}
+			}
+		}
+		return 0x326;
+	}
+
+	public static int getBlockEmote(int i) {
+		for (NpcEmotes e : NpcEmotes.values()) {
+			for (int f = 0; f < e.getNpcId().length; f++) {
+				if (NpcHandler.npcs[i].npcType == e.getNpcId()[f]) {
+					return e.getBlock();
+				} else {
+					switch (NpcHandler.npcs[i].npcType) {
+					case 2745:
+						return 2653;
+					}
+				}
+			}
+		}
+		return -1;
+	}
+
+	public static int getDeadEmote(int i) {
+		for (NpcEmotes e : NpcEmotes.values()) {
+			for (int f = 0; f < e.getNpcId().length; f++) {
+				if (NpcHandler.npcs[i].npcType == e.getNpcId()[f]) {
+					return e.getDead();
+				} else {
+					switch (NpcHandler.npcs[i].npcType) {
+					case 2745:
+						return 2654;
+					}
+				}
+			}
+		}
+		return 2304;
+	}
+
+}
@@ -0,0 +1,287 @@
+package com.rebotted.game.content.combat.prayer;
+
+import com.rebotted.game.content.music.sound.SoundList;
+import com.rebotted.game.players.Player;
+
+public class ActivatePrayers {
+
+	public static void activatePrayer(Player player, int i) {
+		if (player.duelRule[7]) {
+			for (int p = 0; p < player.getPrayer().PRAYER.length; p++) { // reset
+																	// prayer
+																	// glows
+				player.getPrayer().prayerActive[p] = false;
+				player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[p],
+						0);
+			}
+			player.getPacketSender().sendMessage(
+					"Prayer has been disabled in this duel!");
+			return;
+		}
+		if (i == 24 && player.playerLevel[1] < 65) {
+			player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[i], 0);
+			player.getPacketSender().sendMessage(
+					"You may not use this prayer yet.");
+			return;
+		}
+		if (i == 25 && player.playerLevel[1] < 70) {
+			player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[i], 0);
+			player.getPacketSender().sendMessage(
+					"You may not use this prayer yet.");
+			return;
+		}
+		int[] defencePrayer = { 0, 5, 13, 24, 25 };
+		int[] strengthPrayer = { 1, 6, 14, 24, 25 };
+		int[] attackPrayer = { 2, 7, 15, 24, 25 };
+		int[] rangePrayer = { 3, 11, 19 };
+		int[] magePrayer = { 4, 12, 20 };
+
+		if (player.playerLevel[5] > 0) {
+			if (player.getPlayerAssistant().getLevelForXP(player.playerXP[5]) >= player
+					.getPrayer().PRAYER_LEVEL_REQUIRED[i]) {
+				boolean headIcon = false;
+				switch (i) {
+				case 0:
+				case 5:
+				case 13:
+					if (player.getPrayer().prayerActive[i] == false) {
+						for (int j = 0; j < defencePrayer.length; j++) {
+							if (defencePrayer[j] != i) {
+								player.getPrayer().prayerActive[defencePrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[defencePrayer[j]], 0);
+							}
+						}
+					}
+					break;
+
+				case 1:
+				case 6:
+				case 14:
+					if (player.getPrayer().prayerActive[i] == false) {
+						for (int j = 0; j < strengthPrayer.length; j++) {
+							if (strengthPrayer[j] != i) {
+								player.getPrayer().prayerActive[strengthPrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[strengthPrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < rangePrayer.length; j++) {
+							if (rangePrayer[j] != i) {
+								player.getPrayer().prayerActive[rangePrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[rangePrayer[j]],0);
+							}
+						}
+						for (int j = 0; j < magePrayer.length; j++) {
+							if (magePrayer[j] != i) {
+								player.getPrayer().prayerActive[magePrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[magePrayer[j]], 0);
+							}
+						}
+					}
+					break;
+
+				case 2:
+				case 7:
+				case 15:
+					if (player.getPrayer().prayerActive[i] == false) {
+						for (int j = 0; j < attackPrayer.length; j++) {
+							if (attackPrayer[j] != i) {
+								player.getPrayer().prayerActive[attackPrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[attackPrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < rangePrayer.length; j++) {
+							if (rangePrayer[j] != i) {
+								player.getPrayer().prayerActive[rangePrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[rangePrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < magePrayer.length; j++) {
+							if (magePrayer[j] != i) {
+								player.getPrayer().prayerActive[magePrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[magePrayer[j]], 0);
+							}
+						}
+					}
+					break;
+
+				case 3:// range prays
+				case 11:
+				case 19:
+					if (player.getPrayer().prayerActive[i] == false) {
+						for (int j = 0; j < attackPrayer.length; j++) {
+							if (attackPrayer[j] != i) {
+								player.getPrayer().prayerActive[attackPrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[attackPrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < strengthPrayer.length; j++) {
+							if (strengthPrayer[j] != i) {
+								player.getPrayer().prayerActive[strengthPrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[strengthPrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < rangePrayer.length; j++) {
+							if (rangePrayer[j] != i) {
+								player.getPrayer().prayerActive[rangePrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[rangePrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < magePrayer.length; j++) {
+							if (magePrayer[j] != i) {
+								player.getPrayer().prayerActive[magePrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[magePrayer[j]], 0);
+							}
+						}
+					}
+					break;
+				case 4:
+				case 12:
+				case 20:
+					if (player.getPrayer().prayerActive[i] == false) {
+						for (int j = 0; j < attackPrayer.length; j++) {
+							if (attackPrayer[j] != i) {
+								player.getPrayer().prayerActive[attackPrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[attackPrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < strengthPrayer.length; j++) {
+							if (strengthPrayer[j] != i) {
+								player.getPrayer().prayerActive[strengthPrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[strengthPrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < rangePrayer.length; j++) {
+							if (rangePrayer[j] != i) {
+								player.getPrayer().prayerActive[rangePrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[rangePrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < magePrayer.length; j++) {
+							if (magePrayer[j] != i) {
+								player.getPrayer().prayerActive[magePrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[magePrayer[j]], 0);
+							}
+						}
+					}
+					break;
+				case 10:
+					player.lastProtItem = System.currentTimeMillis();
+					break;
+
+				case 16:
+				case 17:
+				case 18:
+					if (System.currentTimeMillis()
+							- player.getPrayer().stopPrayerDelay < 5000) {
+						player.getPacketSender()
+								.sendMessage(
+										"You have been injured and can't use this prayer!");
+						player.getPacketSender().sendConfig(
+								player.getPrayer().PRAYER_GLOW[16], 0);
+						player.getPacketSender().sendConfig(
+								player.getPrayer().PRAYER_GLOW[17], 0);
+						player.getPacketSender().sendConfig(
+								player.getPrayer().PRAYER_GLOW[18], 0);
+						return;
+					}
+					if (i == 16) {
+						player.protMageDelay = System.currentTimeMillis();
+					} else if (i == 17) {
+						player.protRangeDelay = System.currentTimeMillis();
+					} else if (i == 18) {
+						player.protMeleeDelay = System.currentTimeMillis();
+					}
+				case 21:
+				case 22:
+				case 23:
+					headIcon = true;
+					for (int p = 16; p < 24; p++) {
+						if (i != p && p != 19 && p != 20) {
+							player.getPrayer().prayerActive[p] = false;
+							player.getPacketSender().sendConfig(
+									player.getPrayer().PRAYER_GLOW[p], 0);
+						}
+					}
+					break;
+				case 24:
+				case 25:
+					if (player.getPrayer().prayerActive[i] == false) {
+						for (int j = 0; j < attackPrayer.length; j++) {
+							if (attackPrayer[j] != i) {
+								player.getPrayer().prayerActive[attackPrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[attackPrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < strengthPrayer.length; j++) {
+							if (strengthPrayer[j] != i) {
+								player.getPrayer().prayerActive[strengthPrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[strengthPrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < rangePrayer.length; j++) {
+							if (rangePrayer[j] != i) {
+								player.getPrayer().prayerActive[rangePrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[rangePrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < magePrayer.length; j++) {
+							if (magePrayer[j] != i) {
+								player.getPrayer().prayerActive[magePrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[magePrayer[j]], 0);
+							}
+						}
+						for (int j = 0; j < defencePrayer.length; j++) {
+							if (defencePrayer[j] != i) {
+								player.getPrayer().prayerActive[defencePrayer[j]] = false;
+								player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[defencePrayer[j]], 0);
+							}
+						}
+					}
+					break;
+				}
+
+				if (!headIcon) {
+					if (player.getPrayer().prayerActive[i] == false) {
+						player.getPrayer().prayerActive[i] = true;
+						player.getPacketSender().sendConfig(
+								player.getPrayer().PRAYER_GLOW[i], 1);
+					} else {
+						player.getPrayer().prayerActive[i] = false;
+						player.getPacketSender().sendConfig(
+								player.getPrayer().PRAYER_GLOW[i], 0);
+					}
+				} else {
+					if (player.getPrayer().prayerActive[i] == false) {
+						player.getPrayer().prayerActive[i] = true;
+						player.getPacketSender().sendConfig(
+								player.getPrayer().PRAYER_GLOW[i], 1);
+						player.headIcon = player.getPrayer().PRAYER_HEAD_ICONS[i];
+						player.getPlayerAssistant().requestUpdates();
+					} else {
+						player.getPrayer().prayerActive[i] = false;
+						player.getPacketSender().sendConfig(
+								player.getPrayer().PRAYER_GLOW[i], 0);
+						player.headIcon = -1;
+						player.getPlayerAssistant().requestUpdates();
+					}
+				}
+			} else {
+				player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[i],
+						0);
+				player.getPacketSender().sendFrame126(
+						"You need a @blu@Prayer level of "
+								+ player.getPrayer().PRAYER_LEVEL_REQUIRED[i]
+								+ " to use " + player.getPrayer().PRAYER_NAME[i]
+								+ ".", 357);
+				player.getPacketSender().sendFrame126("Click here to continue", 358);
+				player.getPacketSender().sendChatInterface(356);
+			}
+		} else {
+			player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[i], 0);
+			player.getPacketSender().sendMessage("You have run out of prayer points!");
+			player.getPacketSender().sendSound(SoundList.NO_PRAY, 100, 0);
+		}
+
+	}
+
+}
@@ -0,0 +1,72 @@
+package com.rebotted.game.content.combat.prayer;
+
+public class PrayerData {
+
+	public int prayerId = -1;
+	public static double prayerPoint = 1.0;
+	public long stopPrayerDelay, prayerDelay;
+	public boolean usingPrayer;
+
+	public final int[] PRAYER_DRAIN_RATE = { 500, 500, 500, 500, 500, 500, 500,
+			500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500,
+			500, 500, 500, 500, 500, 500 };
+
+	public final int[] PRAYER_LEVEL_REQUIRED = { 1, 4, 7, 8, 9, 10, 13, 16, 19,
+			22, 25, 26, 27, 28, 31, 34, 37, 40, 43, 44, 45, 46, 49, 52, 60, 70 };
+
+	public final int[] PRAYER = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+			14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 };
+
+	public final String[] PRAYER_NAME = { "Thick Skin", "Burst of Strength",
+			"Clarity of Thought", "Sharp Eye", "Mystic Will", "Rock Skin",
+			"Superhuman Strength", "Improved Reflexes", "Rapid Restore",
+			"Rapid Heal", "Protect Item", "Hawk Eye", "Mystic Lore",
+			"Steel Skin", "Ultimate Strength", "Incredible Reflexes",
+			"Protect from Magic", "Protect from Missiles",
+			"Protect from Melee", "Eagle Eye", "Mystic Might", "Retribution",
+			"Redemption", "Smite", "Chivalry", "Piety" };
+
+	public final int[] PRAYER_GLOW = { 83, 84, 85, 601, 602, 86, 87, 88, 89,
+			90, 91, 603, 604, 92, 93, 94, 95, 96, 97, 605, 606, 98, 99, 100,
+			607, 608 };
+
+	public final int[] PRAYER_HEAD_ICONS = { -1, -1, -1, -1, -1, -1, -1, -1,
+			-1, -1, -1, -1, -1, -1, -1, -1, 2, 1, 0, -1, -1, 3, 5, 4, -1, -1 };
+
+	public boolean[] prayerActive = { false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false, false, false, false, false, false, false, false,
+			false, false };
+
+	/**
+	 * How fast the prayer is drained
+	 */
+
+	public static final double[] prayerData = { 1, // Thick Skin.
+			1, // Burst of Strength.
+			1, // Clarity of Thought.
+			1, // Sharp Eye.
+			1, // Mystic Will.
+			2, // Rock Skin.
+			2, // SuperHuman Strength.
+			2, // Improved Reflexes.
+			0.4, // Rapid restore.
+			0.6, // Rapid Heal.
+			0.6, // Protect Items.
+			1.5, // Hawk eye.
+			2, // Mystic Lore.
+			4, // Steel Skin.
+			4, // Ultimate Strength.
+			4, // Incredible Reflexes.
+			4, // Protect from Magic.
+			4, // Protect from Missiles.
+			4, // Protect from Melee.
+			4, // Eagle Eye.
+			4, // Mystic Might.
+			1, // Retribution.
+			2, // Redemption.
+			6, // Smite.
+			8, // Chivalry.
+			8, // Piety.
+	};
+}
@@ -0,0 +1,49 @@
+package com.rebotted.game.content.combat.prayer;
+
+import com.rebotted.game.players.Player;
+
+public class PrayerDrain {
+
+	public static void handlePrayerDrain(Player player) {
+		player.getPrayer().usingPrayer = false;
+		double toRemove = 0.0;
+		for (int j = 0; j < PrayerData.prayerData.length; j++) {
+			if (player.getPrayer().prayerActive[j]) {
+				toRemove += PrayerData.prayerData[j] / 20;
+				player.getPrayer().usingPrayer = true;
+			}
+		}
+		if (toRemove > 0) {
+			toRemove /= 1 + 0.035 * player.playerBonus[11];
+		}
+		PrayerData.prayerPoint -= toRemove;
+		if (PrayerData.prayerPoint <= 0) {
+			PrayerData.prayerPoint = 1.0 + PrayerData.prayerPoint;
+			reducePrayerLevel(player);
+		}
+
+	}
+
+	public static void reducePrayerLevel(Player c) {
+		if (c.playerLevel[5] - 1 > 0) {
+			c.playerLevel[5] -= 1;
+		} else {
+			c.getPacketSender().sendMessage(
+					"You have run out of prayer points!");
+			c.playerLevel[5] = 0;
+			resetPrayers(c);
+			c.getPrayer().prayerId = -1;
+		}
+		c.getPlayerAssistant().refreshSkill(5);
+	}
+
+	public static void resetPrayers(Player player) {
+		for (int i = 0; i < player.getPrayer().prayerActive.length; i++) {
+			player.getPrayer().prayerActive[i] = false;
+			player.getPacketSender().sendConfig(player.getPrayer().PRAYER_GLOW[i], 0);
+		}
+		player.headIcon = -1;
+		player.getPlayerAssistant().requestUpdates();
+	}
+
+}
@@ -0,0 +1,518 @@
+package com.rebotted.game.content.combat.range;
+
+import com.rebotted.GameConstants;
+import com.rebotted.GameEngine;
+import com.rebotted.event.CycleEvent;
+import com.rebotted.event.CycleEventContainer;
+import com.rebotted.event.CycleEventHandler;
+import com.rebotted.game.npcs.Npc;
+import com.rebotted.game.npcs.NpcHandler;
+import com.rebotted.game.players.Client;
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+import com.rebotted.util.Misc;
+
+/**
+ * Cannon
+ * @author Andrew (Mr Extremez)
+ */
+
+public class DwarfCannon {
+
+	public DwarfCannon(Player player2) {
+		this.player = player2;
+	}
+
+	private Player player;
+
+	public final int[] ITEM_PARTS = {6, 8, 10, 12};
+	
+	private final int[] OBJECT_PARTS = {7, 8, 9, 6};
+	
+	private final int ballsID = 2;
+
+	public boolean settingUp = false;
+	
+	private int setUpStage = 0;
+	
+	private int maxBalls = 30;
+	
+	public int myBalls = 0;
+	
+	private boolean rotating = false;
+	
+	private int rotation = 0;
+	
+	private int maxHit = 30;
+	
+	private final int maxDistance = 20;
+	
+	private int totalRotations = 0;
+	
+	private boolean justClicked = false;
+
+	public void placeCannon() {
+		if (settingUp == true) {
+			return;
+		}
+		if (noSetUpArea()) {
+			player.getPacketSender().sendMessage("You are not allowed to set up a cannon here!");
+			return;
+		}
+		if (hasCannon()) {
+			player.getPacketSender().sendMessage("You already have a cannon placed!");
+			return;
+		}
+		if (nearCannon()) {
+			player.getPacketSender().sendMessage("You must be farther away from an existing cannon to set a new one up!");
+			return;
+		}
+		if (!canSetUp()) {
+			player.getPacketSender().sendMessage("You need all the parts of the cannon to set a cannon up.");
+			return;
+		}
+		for (int i = 0; i < 50; i++) {
+			if (GameEngine.cannonsX[i] == 0 && GameEngine.cannonsY[i] == 0) {
+				GameEngine.cannonsX[i] = player.absX;
+				GameEngine.cannonsY[i] = player.absY;
+				break;
+			}
+		}
+		CycleEventHandler.getSingleton().addEvent(player, new CycleEvent() {
+		@Override
+    		public void execute(CycleEventContainer container) {
+				if (setUpStage >= 4) {
+					container.stop();
+					setUpStage = 0;
+					settingUp = false;
+					return;
+				}
+				if (!canSetUp()) {
+					player.getPacketSender().sendMessage("You need all the parts of the cannon to set a cannon up.");
+					container.stop();
+					return;
+				}
+				settingUp = true;
+				player.startAnimation(827);
+				player.turnPlayerTo(player.absX, player.absY);
+				player.cannonX = player.absX;
+				player.cannonY = player.absY;
+				placeObject(OBJECT_PARTS[setUpStage], player.absX, player.absY);
+				player.getItemAssistant().deleteItem(ITEM_PARTS[setUpStage], 1);
+				setUpStage ++;
+			}
+			@Override
+			public void stop() {
+				/**
+				 * Balls
+				 */
+				int cballs = getBalls();
+				int amount = cballs - myBalls;
+				player.getItemAssistant().deleteItem(ballsID, player.getItemAssistant().getItemSlot(ballsID), amount);
+				myBalls = cballs;
+			}
+		}, 2);
+	}
+	
+		public boolean needsCannon() {
+			return (player.lostCannon == true);
+		}
+		
+		public void loginCheck() {
+			if (needsCannon()) {
+				player.getPacketSender().sendMessage("@red@You can collect your cannon at home from Nulodion.");
+			}
+		}
+		
+		private boolean canSetUp() {
+			if (setUpStage == 0) {
+				if (player.getItemAssistant().playerHasItem(ITEM_PARTS[0])  && player.getItemAssistant().playerHasItem(ITEM_PARTS[1]) && player.getItemAssistant().playerHasItem(ITEM_PARTS[2]) && player.getItemAssistant().playerHasItem(ITEM_PARTS[3])) {
+					return true;
+				}
+			} else if (setUpStage == 1) {
+				if (player.getItemAssistant().playerHasItem(ITEM_PARTS[1]) && player.getItemAssistant().playerHasItem(ITEM_PARTS[2]) && player.getItemAssistant().playerHasItem(ITEM_PARTS[3])) {
+					return true;
+				}
+			} else if (setUpStage == 2) {
+				if (player.getItemAssistant().playerHasItem(ITEM_PARTS[2]) && player.getItemAssistant().playerHasItem(ITEM_PARTS[3])) {
+					return true;
+				}
+			} else if (setUpStage == 3) {
+				if (player.getItemAssistant().playerHasItem(ITEM_PARTS[3])) {
+					return true;
+				}
+			}
+			return false;
+		}
+		
+		public boolean hasCannon() {
+			return (player.cannonX > 0) && (player.cannonY > 0) || (player.cannonX > 0 && player.cannonY > 0);
+		}
+		
+		private boolean myCannon(int x, int y) {
+			return (player.cannonX == x) && (player.cannonY == y);
+		}
+		
+		public int getBalls() {
+			int cannonBalls = player.getItemAssistant().getItemAmount(ballsID);
+			if (cannonBalls >= maxBalls) {
+				return maxBalls;
+			}
+			return cannonBalls;
+		}
+		
+		public boolean nearCannon() {
+			for(int i = 0; i < GameEngine.cannonsX.length; i++) {
+				if ((player.absX >= GameEngine.cannonsX[i] - 1) && (player.absX <= GameEngine.cannonsX[i] + 1) && (player.absY >= GameEngine.cannonsY[i] - 2) && (player.absY <= GameEngine.cannonsY[i] + 1)) {
+						return true;
+					}
+				}
+			return false;
+		}
+		
+		public void loadCannons() {
+			for(int i = 0; i < GameEngine.cannonsX.length; i++) {
+				if (GameEngine.cannonsX[i] != 0) {
+					player.getPacketSender().checkObjectSpawn(6, GameEngine.cannonsX[i], GameEngine.cannonsY[i], 0, 10);
+				}
+			}
+		}
+		
+		public void loadCannon(int x, int y) {
+			int cballs = getBalls();
+			if (!myCannon(x, y)) {
+				player.getPacketSender().sendMessage("You can't load somebody else's cannon!");
+				return;
+			}
+			if (myBalls <= 29) {
+				int amount = cballs - myBalls;
+				player.getItemAssistant().deleteItem(ballsID, player.getItemAssistant().getItemSlot(ballsID), amount);
+				myBalls = cballs;
+				if (player.getItemAssistant().playerHasItem(ballsID)) {
+					player.getPacketSender().sendMessage(amount > 1 ? "You load the cannon with " + amount + " cannonballs." : "You load the cannon with 1 cannonball.");
+				} else {
+					player.getPacketSender().sendMessage("You have no cannonballs to load into the cannon.");
+				}
+			}
+		}
+		
+		public void clickCannon(int x, int y) {
+			if (!myCannon(x, y)) {
+				player.getPacketSender().sendMessage("You can't fire somebody else's cannon!");
+				return;
+			}
+			if (myBalls == 0) {
+				player.getPacketSender().sendMessage("Your cannon has run out of cannonballs.");
+				return;
+			}
+			if (myBalls >= 1 && rotating == false) {
+				shoot();
+			} else if (myBalls >= 1 && rotating == true) {
+				player.getPacketSender().sendMessage("Your cannon is already shooting.");
+			}
+		}
+			
+		public void handleDisconnect() {
+			removeObject(player.cannonX, player.cannonY);
+			for(int i = 0; i < GameEngine.cannonsX.length; i++) {
+				if (GameEngine.cannonsX[i] == player.cannonX && GameEngine.cannonsY[i] == player.cannonY) {
+					GameEngine.cannonsX[i] = 0;
+					GameEngine.cannonsY[i] = 0;
+					GameEngine.cannonsO[i] = null;
+				}
+			}
+		}
+		
+		public void handleDeath() {
+			if (hasCannon()) {
+				player.lostCannon = true;
+				removeObject(player.cannonX, player.cannonY);
+				for(int i = 0; i < GameEngine.cannonsX.length; i++) {
+					if (GameEngine.cannonsX[i] == player.cannonX && GameEngine.cannonsY[i] == player.cannonY) {
+						GameEngine.cannonsX[i] = 0;
+						GameEngine.cannonsY[i] = 0;
+						GameEngine.cannonsO[i] = null;
+					}
+				}
+				player.cannonX = 0;
+				player.cannonY = 0;
+			}
+		}
+		
+		public void shoot() {
+			if (justClicked == true) {
+				return;
+			}
+			rotating = true;
+			justClicked = true;
+			CycleEventHandler.getSingleton().addEvent(player, new CycleEvent() {
+				@Override
+				public void execute(CycleEventContainer e) {
+					totalRotations += 1;
+					if (totalRotations >= 2) {
+						justClicked = false;
+					}
+					if(rotating == false) {
+						e.stop();
+					}
+					if (myBalls < 1) {
+						rotating = false;
+						e.stop();
+					}
+					if (rotating == true) {
+						rotation += 1;
+						rotateCannon();
+						shootNpcs();
+					}
+				}
+				@Override
+				public void stop() {
+					
+				}
+			}, 2);
+		}
+		
+		private void rotateCannon() {
+		switch (rotation) {
+			case 1: //north
+				player.getPlayerAssistant().objectAnim(player.cannonX, player.cannonY, 516, 10, -1);
+			break;
+			case 2: //north-east
+				player.getPlayerAssistant().objectAnim(player.cannonX, player.cannonY, 517, 10, -1);
+			break;
+			case 3: //east
+				player.getPlayerAssistant().objectAnim(player.cannonX, player.cannonY, 518, 10, -1);
+			break;
+			case 4: //south-east
+				player.getPlayerAssistant().objectAnim(player.cannonX, player.cannonY, 519, 10, -1);
+			break;
+			case 5: //south
+				player.getPlayerAssistant().objectAnim(player.cannonX, player.cannonY, 520, 10, -1);
+			break;
+			case 6: //south-west
+				player.getPlayerAssistant().objectAnim(player.cannonX, player.cannonY, 521, 10, -1);
+			break;
+			case 7: //west
+				player.getPlayerAssistant().objectAnim(player.cannonX, player.cannonY, 514, 10, -1);
+			break;
+			case 8: //north-west
+				player.getPlayerAssistant().objectAnim(player.cannonX, player.cannonY, 515, 10, -1);
+				rotation = 0;
+			break;
+			}
+		}
+		
+		public void removeCannon(int x, int y) {
+			for (int i = 0; i < GameEngine.cannonsX.length; i++) {
+				if (GameEngine.cannonsX[i] == x && GameEngine.cannonsY[i] == y) {
+					GameEngine.cannonsX[i] = 0;
+					GameEngine.cannonsY[i] = 0;
+					break;
+				}
+			}
+		}
+		
+		public void pickup(int x, int y) {
+			if (!myCannon(x, y)) {
+				player.getPacketSender().sendMessage("You can't pick up somebody else's cannon!");
+				return;
+			}
+			if (rotating == true) {
+				rotating = false;
+			}
+			if (player.getItemAssistant().freeSlots() > 3) {
+				player.startAnimation(827);
+				player.getPacketSender().sendMessage("You pick up the cannon. It's really heavy.");
+				removeCannon(player.cannonX, player.cannonY);
+				player.getItemAssistant().addItem(ITEM_PARTS[0], 1);
+				player.getItemAssistant().addItem(ITEM_PARTS[1], 1);
+				player.getItemAssistant().addItem(ITEM_PARTS[2], 1);
+				player.getItemAssistant().addItem(ITEM_PARTS[3], 1);
+			} else {
+				player.getPacketSender().sendMessage("You don't have enough free inventory slots to do that.");
+			}
+			if (myBalls > 0) {
+				player.getItemAssistant().addItem(ballsID, myBalls);
+				myBalls = 0;
+			}
+			removeObject(player.cannonX, player.cannonY);
+			player.cannonX = 0;
+			player.cannonY = 0;
+			player.cannonX = 0;
+			player.cannonY = 0;
+		}
+		
+		public void placeObject(int id, int x, int y) {
+			for (int j = 0; j < PlayerHandler.players.length; j++) {
+				if (PlayerHandler.players[j] != null) {
+					Client a = (Client)PlayerHandler.players[j];
+					 a.getPacketSender().object(id, x, y, 516, 10);
+				}
+			}
+		}
+		
+		public void removeObject(int x, int y) {
+			placeObject(-1, x, y);
+		}
+		
+		public boolean noSetUpArea() {
+			return player.inBank() || player.inFightCaves();
+		}
+		
+		private int getHit() {
+			int hits = Misc.random(2);
+			switch (hits) {
+			case 0:
+				return Misc.random(maxHit);
+			case 1:
+				return 15+Misc.random(maxHit-15);
+			case 2:
+				return 10+Misc.random(maxHit-10);
+			}
+			return 0;
+		}
+		
+		public void shootNpcs() {
+			int damage = getHit();
+			Npc target = targetNpc();
+			if (target != null) {
+				if (damage > target.HP) {
+					damage = target.HP;
+				}
+				if (!player.inMulti()) {
+					if (target.underAttackBy > 0 && target.underAttackBy != player.playerId) {
+						return;
+					}
+					if (player.underAttackBy2 > 0 && player.underAttackBy2 != target.npcId) {
+						return;
+					}
+				}
+				cannonProjectile(target);
+				target.hitDiff2 = damage;
+				target.HP -= damage;
+				player.globalDamageDealt += damage;
+				target.killerId = player.playerId;
+				target.killedBy = player.playerId;
+				target.facePlayer(player.playerId);
+				target.hitUpdateRequired2 = true;
+				target.updateRequired = true;
+				myBalls -= 1;
+				player.getPlayerAssistant().addSkillXP(damage * GameConstants.RANGE_EXP_RATE, player.playerRanged);
+			}
+		}
+		
+		
+		private Npc targetNpc() {
+			for (int i = 0; i < NpcHandler.MAX_NPCS; i++) {
+            if (NpcHandler.npcs[i] == null) {
+                continue;
+            }
+            Npc npc = NpcHandler.npcs[i];
+            int myX = player.cannonX;
+            int myY = player.cannonY;
+            int theirX = npc.absX;
+            int theirY = npc.absY;
+            if (!npc.isDead && !npc.isDead && npc.HP != 0 && npc.npcType != 1266 && npc.npcType != 1268 && inDistance(theirX, theirY)) {
+                switch (rotation) {
+                    case 1:
+                        if (theirY > myY && theirX >= myX - 1 && theirX <= myX + 1) {
+                            return npc;
+                        }
+                        break;
+                    case 2:
+                        if (theirX >= myX + 1 && theirY >= myY + 1) {
+                            return npc;
+                        }
+                        break;
+                    case 3:
+                        if (theirX > myX && theirY >= myY - 1 && theirY <= myY + 1) {
+                            return npc;
+                        }
+                        break;
+                    case 4:
+                        if (theirY <= myY - 1 && theirX >= myX + 1) {
+                            return npc;
+                        }
+                        break;
+                    case 5:
+                        if (theirY < myY && theirX >= myX - 1 && theirX <= myX + 1) {
+                            return npc;
+                        }
+                        break;
+                    case 6:
+                        if (theirX <= myX - 1 && theirY <= myY - 1) {
+                            return npc;
+                        }
+                        break;
+                    case 7:
+                        if (theirX < myX && theirY >= myY - 1 && theirY <= myY + 1) {
+                            return npc;
+                        }
+                        break;
+                    case 8:
+                        if (theirX <= myX - 1 && theirY >= myY + 1) {
+                            return npc;
+                        }
+                        break;
+                	}
+            	}
+			}
+			return null;
+		}
+		
+		public boolean inDistance(int npcX, int npcY) {
+			return (npcX >= player.cannonX - maxDistance && npcX <= player.cannonX + maxDistance && npcY >= player.cannonY - maxDistance && npcY <= player.cannonY + maxDistance);
+		}
+		
+		private void cannonProjectile(Npc n) {
+			int oX = player.cannonX+getShootXPos();
+			int oY = player.cannonY+getShootYPos();
+			int offX = ((oX - n.absX) * -1);
+			int offY = ((oY - n.absY) * -1);
+        	player.getPlayerAssistant().createPlayersProjectile(oX, oY, offY, offX, 50, 60, 53, 20, 20, -player.oldNpcIndex + 1, 30);
+		}
+	
+		public int getShootXPos() {
+			switch(rotation) {
+				case 1:
+					return 1;
+				case 2:
+					return 2;
+				case 3:
+					return 2;
+				case 4:
+					return 2;
+				case 5:
+					return 1;
+				case 6:
+					return 0;
+				case 7:
+					return 0;
+				case 8:
+					return 0;
+			}
+			return 0;
+		}
+		
+		public int getShootYPos() {
+			switch(rotation) {
+				case 1:
+					return 2;
+				case 2:
+					return 2;
+				case 3:
+					return 1;
+				case 4:
+					return 0;
+				case 5:
+					return 0;
+				case 6:
+					return 0;
+				case 7:
+					return 1;
+				case 8:
+					return 2;
+			}
+			return 0;
+		}
+}
@@ -0,0 +1,370 @@
+package com.rebotted.game.content.combat.range;
+
+import com.rebotted.game.players.Player;
+
+public class RangeData {
+
+	public final static int[] BOWS = { 9185, 839, 845, 847, 851, 855, 859, 841,
+			843, 849, 853, 857, 861, 4212, 4214, 4215, 11235, 4216, 4217, 4218,
+			4219, 4220, 4221, 4222, 4223, 6724, 4734, 4934, 4935, 4936, 4937 };
+	public final static int[] ARROWS = { 882, 884, 886, 888, 890, 892, 4740,
+			11212, 9140, 9141, 4142, 9143, 9144, 9240, 9241, 9242, 9243, 9244,
+			9245, 4150, 4160, 4172 };
+	public final static int[] NO_ARROW_DROP = { 4212, 4214, 4215, 4216, 4217,
+			4218, 4219, 4220, 4221, 4222, 4223, 4734, 4934, 4935, 4936, 4937 };
+	public final static int[] OTHER_RANGE_WEAPONS = { 863, 864, 865, 866, 867,
+			868, 869, 806, 807, 808, 809, 810, 811, 825, 826, 827, 828, 829,
+			830, 800, 801, 802, 803, 804, 805, 6522 };
+	
+	public static boolean usingDbow(Player c) {
+		return c.playerEquipment[c.playerWeapon] == 11235;
+	}
+	
+	public static boolean usingCrystalBow(Player c) {
+		return c.playerEquipment[c.playerWeapon] >= 4212
+				&& c.playerEquipment[c.playerWeapon] <= 4223;
+	}
+
+	public static boolean usingBolts(Player c) {
+		return c.playerEquipment[c.playerArrows] >= 9130
+				&& c.playerEquipment[c.playerArrows] <= 9145
+				|| c.playerEquipment[c.playerArrows] >= 9230
+				&& c.playerEquipment[c.playerArrows] <= 9245;
+	}
+
+	public static boolean properBolts(Player c) {
+		return c.playerEquipment[c.playerArrows] >= 9140
+				&& c.playerEquipment[c.playerArrows] <= 9144
+				|| c.playerEquipment[c.playerArrows] >= 9240
+				&& c.playerEquipment[c.playerArrows] <= 9244;
+	}
+	
+	public static boolean usingHally(Player c) {
+		switch (c.playerEquipment[c.playerWeapon]) {
+		case 3190:
+		case 3192:
+		case 3194:
+		case 3196:
+		case 3198:
+		case 3200:
+		case 3202:
+		case 3204:
+			return true;
+
+		default:
+			return false;
+		}
+	}
+
+	public static int correctBowAndArrows(Player c) {
+		if (usingBolts(c)) {
+			return -1;
+		}
+		switch (c.playerEquipment[c.playerWeapon]) {
+
+		case 839:
+		case 841:
+			return 882;
+
+		case 843:
+		case 845:
+			return 884;
+
+		case 847:
+		case 849:
+			return 886;
+
+		case 851:
+		case 853:
+			return 888;
+
+		case 855:
+		case 857:
+			return 890;
+
+		case 859:
+		case 861:
+			if (c.playerEquipment[c.playerArrows] == 892) {
+				return 892;
+			} else if (c.playerEquipment[c.playerArrows] == 4172) {
+				return 4172;
+			}
+
+		case 4734:
+		case 4935:
+		case 4936:
+		case 4937:
+			return 4740;
+
+		case 11235:
+			return 11212;
+		}
+		return -1;
+	}
+
+	public static int getRangeStartGFX(Player c) {
+		switch (c.rangeItemUsed) {
+
+		case 863:
+			return 220;
+		case 864:
+			return 219;
+		case 865:
+			return 221;
+		case 866: // knives
+			return 223;
+		case 867:
+			return 224;
+		case 868:
+			return 225;
+		case 869:
+			return 222;
+
+		case 806:
+			return 232;
+		case 807:
+			return 233;
+		case 808:
+			return 234;
+		case 809: // darts
+			return 235;
+		case 810:
+			return 236;
+		case 811:
+			return 237;
+
+		case 825:
+			return 206;
+		case 826:
+			return 207;
+		case 827: // javelin
+			return 208;
+		case 828:
+			return 209;
+		case 829:
+			return 210;
+		case 830:
+			return 211;
+
+		case 800:
+			return 42;
+		case 801:
+			return 43;
+		case 802:
+			return 44; // axes
+		case 803:
+			return 45;
+		case 804:
+			return 46;
+		case 805:
+			return 48;
+
+		case 882:
+			return 19;
+
+		case 884:
+			return 18;
+
+		case 886:
+			return 20;
+
+		case 888:
+			return 21;
+
+		case 890:
+			return 22;
+
+		case 892:
+			return 24;
+
+		case 11212:
+			return 26;
+
+		case 4212:
+		case 4214:
+		case 4215:
+		case 4216:
+		case 4217:
+		case 4218:
+		case 4219:
+		case 4220:
+		case 4221:
+		case 4222:
+		case 4223:
+			return 250;
+
+		}
+		return -1;
+	}
+
+	public static int getRangeProjectileGFX(Player c) {
+		if (c.dbowSpec) {
+			return 672;
+		}
+		if (c.bowSpecShot > 0) {
+			switch (c.rangeItemUsed) {
+			default:
+				return 249;
+			}
+		}
+		if (c.playerEquipment[c.playerWeapon] == 9185) {
+			return 27;
+		}
+		switch (c.rangeItemUsed) {
+
+		case 863:
+			return 213;
+		case 864:
+			return 212;
+		case 865:
+			return 214;
+		case 866: // knives
+			return 216;
+		case 867:
+			return 217;
+		case 868:
+			return 218;
+		case 869:
+			return 215;
+
+		case 806:
+			return 226;
+		case 807:
+			return 227;
+		case 808:
+			return 228;
+		case 809: // darts
+			return 229;
+		case 810:
+			return 230;
+		case 811:
+			return 231;
+
+		case 825:
+			return 200;
+		case 826:
+			return 201;
+		case 827: // javelin
+			return 202;
+		case 828:
+			return 203;
+		case 829:
+			return 204;
+		case 830:
+			return 205;
+
+		case 6522: // Toktz-xil-ul
+			return 442;
+
+		case 800:
+			return 36;
+		case 801:
+			return 35;
+		case 802:
+			return 37; // axes
+		case 803:
+			return 38;
+		case 804:
+			return 39;
+		case 805:
+			return 40;
+
+		case 882:
+			return 10;
+
+		case 884:
+			return 9;
+
+		case 886:
+			return 11;
+
+		case 888:
+			return 12;
+
+		case 890:
+			return 13;
+
+		case 892:
+			return 15;
+
+		case 11212:
+			return 17;
+
+		case 4740: // bolt rack
+			return 27;
+
+		case 4212:
+		case 4214:
+		case 4215:
+		case 4216:
+		case 4217:
+		case 4218:
+		case 4219:
+		case 4220:
+		case 4221:
+		case 4222:
+		case 4223:
+			return 249;
+
+		}
+		return -1;
+	}
+
+	public static int getProjectileSpeed(Player c) {
+		if (c.dbowSpec) {
+			return 100;
+		}
+		return 70;
+	}
+
+	public static int getProjectileShowDelay(Player c) {
+		switch (c.playerEquipment[c.playerWeapon]) {
+		case 863:
+		case 864:
+		case 865:
+		case 866: // knives
+		case 867:
+		case 868:
+		case 869:
+
+		case 806:
+		case 807:
+		case 808:
+		case 809: // darts
+		case 810:
+		case 811:
+
+		case 825:
+		case 826:
+		case 827: // javelin
+		case 828:
+		case 829:
+		case 830:
+
+		case 800:
+		case 801:
+		case 802:
+		case 803: // axes
+		case 804:
+		case 805:
+
+		case 4734:
+		case 9185:
+		case 4935:
+		case 4936:
+		case 4937:
+			return 15;
+
+		default:
+			return 5;
+		}
+	}
+	
+	public static boolean fullVoidRange(Player c) {
+		return c.playerEquipment[c.playerHat] == 11664
+				&& c.playerEquipment[c.playerLegs] == 8840
+				&& c.playerEquipment[c.playerChest] == 8839
+				&& c.playerEquipment[c.playerHands] == 8842;
+	}
+
+}
@@ -0,0 +1,101 @@
+package com.rebotted.game.content.combat.range;
+
+import com.rebotted.game.players.Player;
+
+public class RangeMaxHit {
+	
+	public static int calculateRangeDefence(Player c) {
+		int defenceLevel = c.playerLevel[1];
+		if (c.getPrayer().prayerActive[0]) {
+			defenceLevel += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.05;
+		} else if (c.getPrayer().prayerActive[5]) {
+			defenceLevel += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.1;
+		} else if (c.getPrayer().prayerActive[13]) {
+			defenceLevel += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.15;
+		} else if (c.getPrayer().prayerActive[24]) {
+			defenceLevel += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.2;
+		} else if (c.getPrayer().prayerActive[25]) {
+			defenceLevel += c.getLevelForXP(c.playerXP[c.playerDefence]) * 0.25;
+		}
+		return defenceLevel + c.playerBonus[9] + c.playerBonus[9] / 2;
+	}
+
+	public static int calculateRangeAttack(Player c) {
+		int rangeLevel = c.playerLevel[4];
+		rangeLevel *= c.specAccuracy;
+		if (RangeData.fullVoidRange(c)) {
+			rangeLevel += c.getLevelForXP(c.playerXP[c.playerRanged]) * 0.1;
+		}
+		if (c.getPrayer().prayerActive[3]) {
+			rangeLevel *= 1.05;
+		} else if (c.getPrayer().prayerActive[11]) {
+			rangeLevel *= 1.10;
+		} else if (c.getPrayer().prayerActive[19]) {
+			rangeLevel *= 1.15;
+		}
+		// dbow spec
+		if (RangeData.fullVoidRange(c) && c.specAccuracy > 1.15) {
+			rangeLevel *= 1.75;
+		}
+		return (int) (rangeLevel + c.playerBonus[4] * 1.95);
+	}
+
+	public static int rangeMaxHit(Player c) {
+		int rangeLevel = c.playerLevel[4];
+		int itemUsed = getRangeStr(c.usingBow ? c.lastArrowUsed : c.lastWeaponUsed);
+		double modifier = 1.00;
+		if (c.getPrayer().prayerActive[3]) {
+			modifier *= 1.05;
+		} else if (c.getPrayer().prayerActive[11]) {
+			modifier *= 1.10;
+		} else if (c.getPrayer().prayerActive[19]) {
+			modifier *= 1.15;
+		}
+		if (RangeData.fullVoidRange(c)) {
+			modifier *= 1.20;
+		}
+		double e = Math.floor(rangeLevel * modifier);
+		if (c.fightMode == 0) {
+			e = (e + 3.0);
+		}
+		double darkbow = 1.0;
+		if (c.usingSpecial) {
+			if (c.playerEquipment[3] == 11235) {
+				if (c.lastArrowUsed == 11212) {
+					darkbow = 1.5;
+				} else {
+					darkbow = 1.3;
+				}
+			}
+		}
+		double max = (1.3 + e / 10 + itemUsed / 80 + e * itemUsed / 640) * darkbow;
+		return (int) max;
+	}
+
+	public static int getRangeStr(int i) {
+		int str = 0;
+		int[][] data = { { 877, 10 }, { 9140, 46 }, { 9145, 36 }, { 9141, 64 },
+				{ 9142, 82 }, { 9143, 100 }, { 9144, 115 }, { 9236, 14 },
+				{ 9237, 30 }, { 9238, 48 }, { 9239, 66 }, { 9240, 83 },
+				{ 9241, 85 }, { 9242, 103 }, { 9243, 105 }, { 9244, 117 },
+				{ 9245, 120 }, { 882, 7 }, { 884, 10 }, { 886, 16 },
+				{ 888, 22 }, { 890, 31 }, { 892, 49 }, { 4740, 55 },
+				{ 11212, 60 }, { 806, 1 }, { 807, 3 }, { 808, 4 }, { 809, 7 },
+				{ 810, 10 }, { 811, 14 }, { 11230, 20 }, { 864, 3 },
+				{ 863, 4 }, { 865, 7 }, { 866, 10 }, { 867, 14 }, { 868, 24 },
+				{ 825, 6 }, { 826, 10 }, { 827, 12 }, { 828, 18 }, { 829, 28 },
+				{ 830, 42 }, { 800, 5 }, { 801, 7 }, { 802, 11 }, { 803, 16 },
+				{ 804, 23 }, { 805, 36 }, { 9976, 0 }, { 9977, 15 },
+				{ 4212, 70 }, { 4214, 70 }, { 4215, 70 }, { 4216, 70 },
+				{ 4217, 70 }, { 4218, 70 }, { 4219, 70 }, { 4220, 70 },
+				{ 4221, 70 }, { 4222, 70 }, { 4223, 70 }, { 6522, 49 },
+				{ 10034, 15 }, };
+		for (int[] element : data) {
+			if (i == element[0]) {
+				str = element[1];
+			}
+		}
+		return str;
+	}
+
+}