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

2006Redone Server/src/com/rebotted/net/packets/impl/AttackPlayer.java

@@ -0,0 +1,298 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.GameConstants;
+import com.rebotted.game.content.combat.magic.CastOnOther;
+import com.rebotted.game.content.combat.magic.MagicData;
+import com.rebotted.game.content.combat.range.RangeData;
+import com.rebotted.game.items.ItemAssistant;
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Attack Player
+ **/
+public class AttackPlayer implements PacketType {
+
+	public static final int ATTACK_PLAYER = 73, MAGE_PLAYER = 249;
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+		c.endCurrentTask();
+		c.playerIndex = 0;
+		c.npcIndex = 0;
+		switch (packetType) {
+
+		/**
+		 * Attack player
+		 **/
+		case ATTACK_PLAYER:
+			c.playerIndex = c.getInStream().readSignedWordBigEndian();
+			if (PlayerHandler.players[c.playerIndex] == null) {
+				break;
+			}
+			
+			if (c.inDuelArena() && !c.duelingArena()) {
+				c.getChallengePlayer().processPacket(c, packetType, packetSize);
+			}
+
+			if (c.respawnTimer > 0) {
+				break;
+			}
+
+			if (c.autocastId > 0) {
+				c.autocasting = true;
+			}
+
+			if (!c.autocasting && c.spellId > 0) {
+				c.spellId = 0;
+			}
+			c.mageFollow = false;
+			c.spellId = 0;
+			c.usingMagic = false;
+			boolean usingBow = false;
+			boolean usingOtherRangeWeapons = false;
+			boolean usingArrows = false;
+			boolean usingCross = c.playerEquipment[c.playerWeapon] == 9185;
+			for (int bowId : RangeData.BOWS) {
+				if (c.playerEquipment[c.playerWeapon] == bowId) {
+					usingBow = true;
+					for (int arrowId : RangeData.ARROWS) {
+						if (c.playerEquipment[c.playerArrows] == arrowId) {
+							usingArrows = true;
+						}
+					}
+				}
+			}
+			for (int otherRangeId : RangeData.OTHER_RANGE_WEAPONS) {
+				if (c.playerEquipment[c.playerWeapon] == otherRangeId) {
+					usingOtherRangeWeapons = true;
+				}
+			}
+			if (c.duelStatus == 5) {
+				if (c.duelCount > 0) {
+					c.getPacketSender().sendMessage(
+							"The duel hasn't started yet!");
+					c.playerIndex = 0;
+					return;
+				}
+				if (c.duelRule[9]) {
+					boolean canUseWeapon = false;
+					for (int funWeapon : GameConstants.FUN_WEAPONS) {
+						if (c.playerEquipment[c.playerWeapon] == funWeapon) {
+							canUseWeapon = true;
+						}
+					}
+					if (!canUseWeapon) {
+						c.getPacketSender().sendMessage(
+								"You can only use fun weapons in this duel!");
+						return;
+					}
+				}
+
+				if (c.duelRule[2] && (usingBow || usingOtherRangeWeapons)) {
+					c.getPacketSender().sendMessage(
+							"Range has been disabled in this duel!");
+					return;
+				}
+				if (c.duelRule[3] && !usingBow && !usingOtherRangeWeapons) {
+					c.getPacketSender().sendMessage(
+							"Melee has been disabled in this duel!");
+					return;
+				}
+			}
+
+			if ((usingBow || c.autocasting)
+					&& c.goodDistance(c.getX(), c.getY(),
+							PlayerHandler.players[c.playerIndex].getX(),
+							PlayerHandler.players[c.playerIndex].getY(), 6)) {
+				c.usingBow = true;
+				c.stopMovement();
+			}
+
+			if (usingOtherRangeWeapons
+					&& c.goodDistance(c.getX(), c.getY(),
+							PlayerHandler.players[c.playerIndex].getX(),
+							PlayerHandler.players[c.playerIndex].getY(), 3)) {
+				c.usingRangeWeapon = true;
+				c.stopMovement();
+			}
+			if (!usingBow) {
+				c.usingBow = false;
+			}
+			if (!usingOtherRangeWeapons) {
+				c.usingRangeWeapon = false;
+			}
+
+			if (!usingCross && !usingArrows && usingBow
+					&& c.playerEquipment[c.playerWeapon] < 4212
+					&& c.playerEquipment[c.playerWeapon] > 4223) {
+				c.getPacketSender().sendMessage(
+						"You have run out of arrows!");
+				return;
+			}
+			if (RangeData.correctBowAndArrows(c) < c.playerEquipment[c.playerArrows]
+					&& GameConstants.CORRECT_ARROWS
+					&& usingBow
+					&& !RangeData.usingCrystalBow(c)
+					&& c.playerEquipment[c.playerWeapon] != 9185) {
+				c.getPacketSender().sendMessage(
+						"You can't use "
+								+ ItemAssistant.getItemName(
+										c.playerEquipment[c.playerArrows])
+										.toLowerCase()
+								+ "s with a "
+								+ ItemAssistant.getItemName(
+										c.playerEquipment[c.playerWeapon])
+										.toLowerCase() + ".");
+				c.stopMovement();
+				c.getCombatAssistant().resetPlayerAttack();
+				return;
+			}
+			if (c.playerEquipment[c.playerWeapon] == 9185
+					&& !c.getCombatAssistant().properBolts()) {
+				c.getPacketSender().sendMessage(
+						"You must use bolts with a crossbow.");
+				c.stopMovement();
+				c.getCombatAssistant().resetPlayerAttack();
+				return;
+			}
+			if (c.getCombatAssistant().checkReqs()) {
+				c.followId = c.playerIndex;
+				if (!c.usingMagic && !usingBow && !usingOtherRangeWeapons) {
+					c.followDistance = 1;
+					c.getPlayerAssistant().followPlayer();
+				}
+				if (c.attackTimer <= 0) {
+					// c.getPacketDispatcher().sendMessage("Tried to attack...");
+					// c.getCombat().attackPlayer(c.playerIndex);
+					// c.attackTimer++;
+				}
+			}
+			break;
+
+		/**
+		 * Attack player with magic
+		 **/
+		case MAGE_PLAYER:
+			if (!c.mageAllowed) {
+				c.mageAllowed = true;
+				break;
+			}
+
+			c.playerIndex = c.getInStream().readSignedWordA();
+			int castingSpellId = c.getInStream().readSignedWordBigEndian();
+			c.castingSpellId = castingSpellId;
+			c.usingMagic = false;
+
+			boolean teleother = CastOnOther.castOnOtherSpells(castingSpellId);
+
+			if (PlayerHandler.players[c.playerIndex] == null) {
+				break;
+			}
+
+			if (c.respawnTimer > 0) {
+				break;
+			}
+
+			if (c.playerRights == 3) {
+				c.getPacketSender().sendMessage(
+						"Casting Spell id: " + castingSpellId + ".");
+			}
+
+			if (teleother) {
+				if (c.inTrade) {
+					c.getTrading().declineTrade(true);
+				}
+				if (c.inWild()
+						&& c.wildLevel > GameConstants.NO_TELEPORT_WILD_LEVEL) {
+					c.getPacketSender().sendMessage(
+							"You can't teleport above level "
+									+ GameConstants.NO_TELEPORT_WILD_LEVEL
+									+ " in the wilderness.");
+					break;
+				}
+			}
+
+			switch (c.castingSpellId) {
+			case 12425:
+				CastOnOther.teleOtherDistance(c, 0, c.playerIndex);
+				break;
+			case 12435:
+				CastOnOther.teleOtherDistance(c, 1, c.playerIndex);
+				break;
+			case 12455:
+				CastOnOther.teleOtherDistance(c, 2, c.playerIndex);
+				break;
+			}
+
+			if (teleother) {
+				c.stopMovement();
+				c.getCombatAssistant().resetPlayerAttack();
+			}
+
+			for (int i = 0; i < MagicData.MAGIC_SPELLS.length; i++) {
+				if (castingSpellId == MagicData.MAGIC_SPELLS[i][0]) {
+					c.spellId = i;
+					c.usingMagic = true;
+					break;
+				}
+			}
+
+			if (c.autocasting) {
+				c.autocasting = false;
+			}
+
+			if (!teleother) {
+				if (!c.getCombatAssistant().checkReqs()) {
+					break;
+				}
+
+				if (c.duelStatus == 5) {
+					if (c.duelCount > 0) {
+						c.getPacketSender().sendMessage(
+								"The duel hasn't started yet!");
+						c.playerIndex = 0;
+						return;
+					}
+					if (c.duelRule[4]) {
+						c.getPacketSender().sendMessage(
+								"Magic has been disabled in this duel!");
+						return;
+					}
+				}
+
+				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[c.spellId][0]) {
+						if (System.currentTimeMillis()
+								- PlayerHandler.players[c.playerIndex].reduceSpellDelay[r] < PlayerHandler.players[c.playerIndex].REDUCE_SPELL_TIME[r]) {
+							c.getPacketSender()
+									.sendMessage(
+											"That player is currently immune to this spell.");
+							c.usingMagic = false;
+							c.stopMovement();
+							c.getCombatAssistant().resetPlayerAttack();
+						}
+						break;
+					}
+				}
+
+				if (System.currentTimeMillis()
+						- PlayerHandler.players[c.playerIndex].teleBlockDelay < PlayerHandler.players[c.playerIndex].teleBlockLength
+						&& MagicData.MAGIC_SPELLS[c.spellId][0] == 12445) {
+					c.getPacketSender().sendMessage(
+							"That player is already affected by this spell.");
+					c.usingMagic = false;
+					c.stopMovement();
+					c.getCombatAssistant().resetPlayerAttack();
+				}
+			}
+			break;
+		}
+
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/Bank10.java

@@ -0,0 +1,99 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.content.random.PartyRoom;
+import com.rebotted.game.content.skills.crafting.JewelryMaking;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Bank 10 Items
+ **/
+public class Bank10 implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		int interfaceId = player.getInStream().readUnsignedWordBigEndian();
+		int removeId = player.getInStream().readUnsignedWordA();
+		int removeSlot = player.getInStream().readUnsignedWordA();
+		player.endCurrentTask();
+		switch (interfaceId) {
+
+		case 4233:
+		case 4239:
+		case 4245:
+			JewelryMaking.mouldItem(player, removeId, 10);
+			break;
+
+		case 1688:
+			player.getPlayerAssistant().useOperate(removeId);
+			break;
+		case 3900:
+			player.getShopAssistant().buyItem(removeId, removeSlot, 10);
+			break;
+
+		case 3823:
+			if(!player.getItemAssistant().playerHasItem(removeId)) {
+				return;
+			}
+			player.getShopAssistant().sellItem(removeId, removeSlot, 10);
+			player.getItemAssistant().resetItems(3823);
+			break;
+
+		case 7423:
+			if (player.storing) {
+				return;
+			}
+			player.getItemAssistant().bankItem(removeId, removeSlot, 10);
+			player.getItemAssistant().resetItems(7423);
+			break;
+
+		case 5064:
+			if(!player.getItemAssistant().playerHasItem(removeId)) {
+				return;
+			}
+			if (player.inPartyRoom) {
+				PartyRoom.depositItem(player, removeId, 10);
+				break;
+			}
+			if (player.inTrade) {
+				player.getPacketSender().sendMessage("You can't store items while trading!");
+				return;
+			}
+			player.getItemAssistant().bankItem(removeId, removeSlot, 10);
+			break;
+
+		case 5382:
+			player.getItemAssistant().fromBank(removeId, removeSlot, 10);
+			break;
+
+		case 3322:
+			if (player.duelStatus <= 0) {
+				player.getTrading().tradeItem(removeId, removeSlot, 10);
+			} else {
+				player.getDueling().stakeItem(removeId, removeSlot, 10);
+			}
+			break;
+
+		case 3415:
+			if (player.duelStatus <= 0) {
+				player.getTrading().fromTrade(removeId, removeSlot, 10);
+			}
+			break;
+
+		case 6669:
+			player.getDueling().fromDuel(removeId, removeSlot, 10);
+			break;
+
+		case 1119:
+		case 1120:
+		case 1121:
+		case 1122:
+		case 1123:
+			player.getSmithing().readInput(player.playerLevel[player.playerSmithing],
+					Integer.toString(removeId), player, 10);
+			break;
+
+		}
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/Bank5.java

@@ -0,0 +1,97 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.content.random.PartyRoom;
+import com.rebotted.game.content.skills.crafting.JewelryMaking;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Bank 5 Items
+ **/
+public class Bank5 implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		int interfaceId = player.getInStream().readSignedWordBigEndianA();
+		int removeId = player.getInStream().readSignedWordBigEndianA();
+		int removeSlot = player.getInStream().readSignedWordBigEndian();
+		player.endCurrentTask();
+		switch (interfaceId) {
+
+		case 4233:
+		case 4239:
+		case 4245:
+			JewelryMaking.mouldItem(player, removeId, 5);
+			break;
+		case 3900:
+			player.getShopAssistant().buyItem(removeId, removeSlot, 1); //this says 1 in BANKx5 but it's banking 5 for real... strange shit.
+			break;
+
+		case 3823:
+			if(!player.getItemAssistant().playerHasItem(removeId)) {
+				return;
+			}
+			if (player.inTrade) {
+				player.getTrading().declineTrade(true);
+			}
+			player.getShopAssistant().sellItem(removeId, removeSlot, 1);
+			break;
+
+		case 7423:
+			if (player.storing) {
+				return;
+			}
+			player.getItemAssistant().bankItem(removeId, removeSlot, 5);
+			player.getItemAssistant().resetItems(7423);
+			break;
+
+		case 5064:
+			if(!player.getItemAssistant().playerHasItem(removeId)) {
+				return;
+			}
+			if (player.inPartyRoom) {
+				PartyRoom.depositItem(player, removeId, 5);
+				break;
+			}
+			if (player.inTrade) {
+				player.getPacketSender().sendMessage(
+						"You can't store items while trading!");
+				return;
+			}
+			player.getItemAssistant().bankItem(removeId, removeSlot, 5);
+			break;
+
+		case 5382:
+			player.getItemAssistant().fromBank(removeId, removeSlot, 5);
+			break;
+
+		case 3322:
+			if (player.duelStatus <= 0) {
+				player.getTrading().tradeItem(removeId, removeSlot, 5);
+			} else {
+				player.getDueling().stakeItem(removeId, removeSlot, 5);
+			}
+			break;
+
+		case 3415:
+			if (player.duelStatus <= 0) {
+				player.getTrading().fromTrade(removeId, removeSlot, 5);
+			}
+			break;
+
+		case 6669:
+			player.getDueling().fromDuel(removeId, removeSlot, 5);
+			break;
+
+		case 1119:
+		case 1120:
+		case 1121:
+		case 1122:
+		case 1123:
+			player.getSmithing().readInput(player.playerLevel[player.playerSmithing],
+					Integer.toString(removeId), player, 5);
+			break;
+		}
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/BankAll.java

@@ -0,0 +1,143 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.content.random.PartyRoom;
+import com.rebotted.game.items.GameItem;
+import com.rebotted.game.items.Item;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Bank All Items
+ **/
+public class BankAll implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		int removeSlot = player.getInStream().readUnsignedWordA();
+		int interfaceId = player.getInStream().readUnsignedWord();
+		int removeId = player.getInStream().readUnsignedWordA();
+		player.endCurrentTask();
+		switch (interfaceId) {
+		// buy x
+		case 3900:
+			player.outStream.createFrame(27);
+			player.xRemoveSlot = removeSlot;
+			player.xRemoveId = removeId;
+			player.xInterfaceId = interfaceId;
+			break;
+
+		// sell x
+		case 3823:
+			if(!player.getItemAssistant().playerHasItem(removeId)) {
+				return;
+			}
+			player.outStream.createFrame(27);
+			player.xRemoveSlot = removeSlot;
+			player.xRemoveId = removeId;
+			player.xInterfaceId = interfaceId;
+			break;
+
+		case 7423:
+			if (player.storing) {
+
+				return;
+			}
+			player.getItemAssistant().bankItem(player.playerItems[removeSlot],
+					removeSlot, player.playerItemsN[removeSlot]);
+			player.getItemAssistant().resetItems(7423);
+			break;
+
+		case 5064:
+			if(!player.getItemAssistant().playerHasItem(removeId)) {
+				return;
+			}
+			if (player.inPartyRoom) {
+				PartyRoom.depositItem(player, removeId, player.getItemAssistant()
+						.itemAmount(player.playerItems[removeSlot]));
+				break;
+			}
+			if (player.inTrade) {
+				player.getPacketSender().sendMessage(
+						"You can't store items while trading!");
+				return;
+			}
+			if (Item.itemStackable[removeId]) {
+				player.getItemAssistant().bankItem(player.playerItems[removeSlot],
+						removeSlot, player.playerItemsN[removeSlot]);
+			} else {
+				player.getItemAssistant().bankItem(
+						player.playerItems[removeSlot],
+						removeSlot,
+						player.getItemAssistant().itemAmount(
+								player.playerItems[removeSlot]));
+			}
+			break;
+
+		case 5382:
+			player.getItemAssistant().fromBank(player.bankItems[removeSlot], removeSlot,
+					player.bankItemsN[removeSlot]);
+			break;
+
+		case 3322:
+			if (player.duelStatus <= 0) {
+				if (Item.itemStackable[removeId]) {
+					player.getTrading().tradeItem(removeId, removeSlot,
+							player.playerItemsN[removeSlot]);
+				} else {
+					player.getTrading().tradeItem(removeId, removeSlot, 28);
+				}
+			} else {
+				if (Item.itemStackable[removeId] || Item.itemIsNote[removeId]) {
+					player.getDueling().stakeItem(removeId, removeSlot,
+							player.playerItemsN[removeSlot]);
+				} else {
+					player.getDueling().stakeItem(removeId, removeSlot, 28);
+				}
+			}
+			break;
+
+		case 3415:
+			if (player.duelStatus <= 0) {
+				if (Item.itemStackable[removeId]) {
+					for (GameItem item : player.getTrading().offeredItems) {
+						if (item.id == removeId) {
+							player.getTrading()
+									.fromTrade(
+											removeId,
+											removeSlot,
+											player.getTrading().offeredItems
+													.get(removeSlot).amount);
+						}
+					}
+				} else {
+					for (GameItem item : player.getTrading().offeredItems) {
+						if (item.id == removeId) {
+							player.getTrading().fromTrade(removeId, removeSlot, 28);
+						}
+					}
+				}
+			}
+			break;
+
+		case 6669:
+			if (Item.itemStackable[removeId] || Item.itemIsNote[removeId]) {
+				for (GameItem item : player.getDueling().stakedItems) {
+					if (item.id == removeId) {
+						player.getDueling()
+								.fromDuel(
+										removeId,
+										removeSlot,
+										player.getDueling().stakedItems
+												.get(removeSlot).amount);
+					}
+				}
+
+			} else {
+				player.getDueling().fromDuel(removeId, removeSlot, 28);
+			}
+			break;
+
+		}
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/BankX1.java

@@ -0,0 +1,36 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Bank X Items
+ **/
+public class BankX1 implements PacketType {
+
+	public static final int PART1 = 135;
+	public static final int PART2 = 208;
+	public int XremoveSlot, XinterfaceID, XremoveID, Xamount;
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+		c.endCurrentTask();
+		if (packetType == 135) {
+			c.xRemoveSlot = c.getInStream().readSignedWordBigEndian();
+			c.xInterfaceId = c.getInStream().readUnsignedWordA();
+			c.xRemoveId = c.getInStream().readSignedWordBigEndian();
+		}
+		else {
+			if (c.xInterfaceId == 7423) {
+				c.getItemAssistant().bankItem(c.xRemoveId, c.xRemoveSlot, Xamount);// Depo 1
+				c.getItemAssistant().resetItems(7423);
+			}
+		}
+		if (packetType == PART1) {
+			synchronized (c) {
+				c.getOutStream().createFrame(27);
+			}
+		}
+
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/BankX2.java

@@ -0,0 +1,74 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.content.random.PartyRoom;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Bank X Items
+ **/
+public class BankX2 implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		player.endCurrentTask();
+		int Xamount = player.getInStream().readDWord();
+		if (Xamount < 0) {
+            Xamount = player.getItemAssistant().getItemAmount(player.xRemoveId);
+        }
+        if (Xamount == 0) {
+            Xamount = 1;
+        }
+		switch (player.xInterfaceId) {
+			case 5064:
+				if (player.inPartyRoom) {
+					PartyRoom.depositItem(player, player.xRemoveId, player.getItemAssistant().itemAmount(player.playerItems[player.xRemoveSlot]));
+					break;
+				}
+				if (player.inTrade) {
+					player.getPacketSender().sendMessage("You can't store items while trading!");
+					return;
+				}
+				player.getItemAssistant().bankItem(player.playerItems[player.xRemoveSlot], player.xRemoveSlot, Xamount);
+				break;
+
+			case 5382:
+				player.getItemAssistant().fromBank(player.bankItems[player.xRemoveSlot], player.xRemoveSlot, Xamount);
+				break;
+
+			case 7423:
+				if (player.storing) {
+					return;
+				}
+				player.getItemAssistant().bankItem(player.playerItems[player.xRemoveSlot], player.xRemoveSlot, Xamount);
+				player.getItemAssistant().resetItems(7423);
+				break;
+
+			case 3322:
+				if (player.duelStatus <= 0) {
+					player.getTrading().tradeItem(player.xRemoveId, player.xRemoveSlot, Xamount);
+				} else {
+					player.getDueling().stakeItem(player.xRemoveId, player.xRemoveSlot, Xamount);
+				}
+				break;
+
+			case 3415:
+				if (player.duelStatus <= 0) {
+					player.getTrading().fromTrade(player.xRemoveId, player.xRemoveSlot, Xamount);
+				}
+				break;
+
+			case 6669:
+				player.getDueling().fromDuel(player.xRemoveId, player.xRemoveSlot, Xamount);
+				break;
+
+			case 3900:
+				player.getShopAssistant().buyItem(player.xRemoveId, player.xRemoveSlot, Xamount);
+				break;
+
+			case 3823:
+				player.getShopAssistant().sellItem(player.xRemoveId, player.xRemoveSlot, Xamount);
+				break;
+		}
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ChallengePlayer.java

@@ -0,0 +1,30 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Challenge Player
+ **/
+public class ChallengePlayer implements PacketType {
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+		switch (packetType) {
+		case 128:
+			int answerPlayer = c.getInStream().readUnsignedWord();
+		    if(PlayerHandler.players[answerPlayer] == null || answerPlayer == c.playerId)
+                return;
+
+			if (c.duelingArena() || c.duelStatus == 5) {
+				c.getPacketSender().sendMessage("You can't challenge inside the arena!");
+				return;
+			}
+			if (c.inDuelArena()) {
+				c.getDueling().requestDuel(answerPlayer);
+			}
+			break;
+		}
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ChangeAppearance.java

@@ -0,0 +1,90 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Change appearance
+ **/
+
+public class ChangeAppearance implements PacketType {
+
+	private static final int[][] MALE_VALUES = { { 0, 8 }, // head
+			{ 10, 17 }, // jaw
+			{ 18, 25 }, // torso
+			{ 26, 31 }, // arms
+			{ 33, 34 }, // hands
+			{ 36, 40 }, // legs
+			{ 42, 43 }, // feet
+	};
+
+	private static final int[][] FEMALE_VALUES = { { 45, 54 }, // head
+			{ -1, -1 }, // jaw
+			{ 56, 60 }, // torso
+			{ 61, 65 }, // arms
+			{ 67, 68 }, // hands
+			{ 70, 77 }, // legs
+			{ 79, 80 }, // feet
+	};
+
+	private static final int[][] ALLOWED_COLORS = { { 0, 11 }, // hair color
+			{ 0, 15 }, // torso color
+			{ 0, 15 }, // legs color
+			{ 0, 5 }, // feet color
+			{ 0, 7 } // skin color
+	};
+
+	@Override
+	public void processPacket(final Player client, final int packetType, final int packetSize) {
+		final int gender = client.getInStream().readSignedByte();
+
+		if (gender != 0 && gender != 1) {
+			return;
+		}
+
+		final int[] apperances = new int[MALE_VALUES.length]; // apperance's
+																// value
+		// check
+		for (int i = 0; i < apperances.length; i++) {
+			int value = client.getInStream().readSignedByte();
+			if (value < (gender == 0 ? MALE_VALUES[i][0] : FEMALE_VALUES[i][0])
+					|| value > (gender == 0 ? MALE_VALUES[i][1]
+							: FEMALE_VALUES[i][1])) {
+				value = gender == 0 ? MALE_VALUES[i][0] : FEMALE_VALUES[i][0];
+			}
+			apperances[i] = value;
+		}
+
+		final int[] colors = new int[ALLOWED_COLORS.length]; // color value
+																// check
+		for (int i = 0; i < colors.length; i++) {
+			int value = client.getInStream().readSignedByte();
+			if (value < ALLOWED_COLORS[i][0] || value > ALLOWED_COLORS[i][1]) {
+				value = ALLOWED_COLORS[i][0];
+			}
+			colors[i] = value;
+		}
+
+		if (client.canChangeAppearance) {
+			client.playerAppearance[0] = gender; // gender
+			client.playerAppearance[1] = apperances[0]; // head
+			client.playerAppearance[2] = apperances[2]; // torso
+			client.playerAppearance[3] = apperances[3]; // arms
+			client.playerAppearance[4] = apperances[4]; // hands
+			client.playerAppearance[5] = apperances[5]; // legs
+			client.playerAppearance[6] = apperances[6]; // feet
+			client.playerAppearance[7] = apperances[1]; // beard
+			client.playerAppearance[8] = colors[0]; // hair colour
+			client.playerAppearance[9] = colors[1]; // torso colour
+			client.playerAppearance[10] = colors[2]; // legs colour
+			client.playerAppearance[11] = colors[3]; // feet colour
+			client.playerAppearance[12] = colors[4]; // skin colour
+
+			client.endCurrentTask();
+			client.getPacketSender().closeAllWindows();
+			client.getPlayerAssistant().requestUpdates();
+			client.canChangeAppearance = false;
+		}
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ChangeRegions.java

@@ -0,0 +1,35 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.GameConstants;
+import com.rebotted.GameEngine;
+import com.rebotted.game.content.music.Music;
+import com.rebotted.game.globalworldobjects.Doors;
+import com.rebotted.game.players.Client;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+import com.rebotted.world.GlobalDropsHandler;
+
+/**
+ * Change Regions
+ */
+public class ChangeRegions implements PacketType {
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+		if (GameConstants.SOUND && c.musicOn) {
+			Music.playMusic(c);
+		}
+		GameEngine.objectHandler.updateObjects(c);//testing
+		Doors.getSingleton().load();
+		GameEngine.itemHandler.reloadItems(c);
+		GameEngine.objectManager.loadObjects(c);
+		GlobalDropsHandler.reset(c);
+		c.getPlayerAssistant().removeObjects();// testing
+		c.saveFile = true;
+		if (c.skullTimer > 0) {
+			c.isSkulled = true;
+			c.headIconPk = 0;
+			c.getPlayerAssistant().requestUpdates();
+		}
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/Chat.java

@@ -0,0 +1,31 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.Connection;
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.antimacro.AntiSpam;
+import com.rebotted.net.packets.PacketType;
+import com.rebotted.util.Misc;
+
+/**
+ * Chat
+ **/
+public class Chat implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		player.setChatTextEffects(player.getInStream().readUnsignedByteS());
+		player.setChatTextColor(player.getInStream().readUnsignedByteS());
+		player.setChatTextSize((byte) (player.packetSize - 2));
+		player.inStream.readBytes_reverseA(player.getChatText(), player.getChatTextSize(), 0);
+		ReportHandler.addText(player.playerName, player.getChatText(), packetSize - 2);
+		String word = Misc.textUnpack(player.getChatText(), player.packetSize - 2).toLowerCase();
+		if (AntiSpam.blockedWords(player, word, true) && !Connection.isMuted(player)) {
+			player.setChatTextUpdateRequired(true);
+		}
+		if (Connection.isMuted(player)) {
+			player.getPacketSender().sendMessage("You are muted and can't speak.");
+			player.setChatTextUpdateRequired(false);
+			return;
+		}
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ClickItem.java

@@ -0,0 +1,296 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.GameConstants;
+import com.rebotted.GameEngine;
+import com.rebotted.game.content.consumables.Beverages;
+import com.rebotted.game.content.consumables.Kebabs;
+import com.rebotted.game.content.consumables.Beverages.beverageData;
+import com.rebotted.game.content.minigames.TreasureTrails;
+import com.rebotted.game.content.minigames.castlewars.CastleWars;
+import com.rebotted.game.content.skills.core.Prayer;
+import com.rebotted.game.content.skills.herblore.Herblore;
+import com.rebotted.game.items.ItemAssistant;
+import com.rebotted.game.items.impl.ExperienceLamp;
+import com.rebotted.game.items.impl.Flowers;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+import com.rebotted.util.GameLogger;
+import com.rebotted.util.Misc;
+
+/**
+ * Clicking an item, bury bone, eat food etc
+ **/
+public class ClickItem implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		player.endCurrentTask();
+		player.getInStream().readSignedWordBigEndianA();
+		int itemSlot = player.getInStream().readUnsignedWordA();
+		int itemId = player.getInStream().readUnsignedWordBigEndian();
+		if (itemId != player.playerItems[itemSlot] - 1) {
+			return;
+		}
+		if(!player.getItemAssistant().playerHasItem(itemId, 1)) {
+			return;
+		}
+		if (itemId == 6) {
+			player.getCannon().placeCannon();
+		}
+		String itemName = ItemAssistant.getItemName(itemId).toLowerCase();
+		if (player.getPlayerAssistant().isPlayer()) {
+			GameLogger.writeLog(player.playerName, "clickitem", player.playerName + " clicked item " + itemName + "");
+		}
+		if (!CastleWars.deleteCastleWarsItems(player, itemId)) {
+			return;
+		}
+		if(CastleWars.isInCw(player) && itemId == 4053) {
+			player.getItemAssistant().deleteItem(4053, player.getItemAssistant().getItemSlot(4053), 1);
+			//npc id, x, y, height, walk, hp, maxhit, att, def
+			GameEngine.npcHandler.spawnNpc2(1532, player.absX, player.absY, player.heightLevel, 0, 200, 0, 0, 100);
+			player.getPacketSender().sendMessage("You setup a barricade.");
+		} else if (!CastleWars.isInCw(player) && itemId == 4053) {
+			player.getPacketSender().sendMessage("You need to be in castlewars to drop a barricade.");
+			player.getItemAssistant().deleteItem(itemId, player.getItemAssistant().getItemAmount(itemId));
+		}
+		if (itemId >= 5509 && itemId <= 5514) {
+			int pouch = -1;
+			int a = itemId;
+			if (a == 5509) {
+				pouch = 0;
+			}
+			if (a == 5510) {
+				pouch = 1;
+			}
+			if (a == 5512) {
+				pouch = 2;
+			}
+			if (a == 5514) {
+				pouch = 3;
+			}
+			player.getPlayerAssistant().fillPouch(pouch);
+			return;
+		}
+		switch (itemId) {
+		
+		case 407:
+			if (Misc.random(1) == 0) {
+				player.getItemAssistant().addItem(409, 1);
+				player.getItemAssistant().deleteItem(407, 1);
+			} else {
+				if (Misc.random(1) == 0) {
+					player.getItemAssistant().addItem(411, 1);
+					player.getItemAssistant().deleteItem(409, 1);
+				} else if (Misc.random(1) == 1) {
+					player.getItemAssistant().addItem(413, 1);
+					player.getItemAssistant().deleteItem(407, 1);
+				}
+			}
+		break;
+		
+		case 2329:
+			player.getItemAssistant().deleteItem(2329, 1);
+			player.getItemAssistant().addItem(2313, 1);
+		break;
+		
+		case 550:
+			player.getPlayerAssistant().showMap();
+		break;
+		
+		  case 583:
+	            GameEngine.trawler.bail(player);
+	            break;
+	        case 585:
+	            GameEngine.trawler.emptyBucket(player);
+	            break;
+
+		case 33:
+			player.getItemAssistant().deleteItem(itemId, 1);
+			player.getItemAssistant().addItem(36, 1);
+			break;
+
+		case 32:
+			player.getItemAssistant().deleteItem(itemId, 1);
+			player.getItemAssistant().addItem(38, 1);
+			break;
+
+		case 594:
+			player.getItemAssistant().deleteItem(itemId, 1);
+			player.getItemAssistant().addItem(596, 1);
+			break;
+
+		case 4550:
+			player.getItemAssistant().deleteItem(itemId, 1);
+			player.getItemAssistant().addItem(4548, 1);
+			break;
+
+		case 4537:
+			player.getItemAssistant().deleteItem(itemId, 1);
+			player.getItemAssistant().addItem(4539, 1);
+			break;
+
+		case 1971:
+			Kebabs.eat(player, itemSlot);
+			break;
+
+		case 2528:
+		case 4447:
+			ExperienceLamp.rubLamp(player, itemId);
+			break;
+			
+		case 2677:
+			if (GameConstants.CLUES_ENABLED) {
+				player.getItemAssistant().deleteItem(itemId, 1);
+				TreasureTrails.addClueReward(player, 0);
+			}
+			break;
+
+		case 2678:
+			if (GameConstants.CLUES_ENABLED) {
+				player.getItemAssistant().deleteItem(itemId, 1);
+				TreasureTrails.addClueReward(player, 1);
+			}
+			break;
+
+		case 2679:
+			if (GameConstants.CLUES_ENABLED) {
+				player.getItemAssistant().deleteItem(itemId, 1);
+				TreasureTrails.addClueReward(player, 2);
+			}
+			break;
+
+		case 299:
+			new Flowers(player);
+			player.dialogueAction = 21;
+			break;
+
+		case 4155:// enchanted gem
+			player.getDialogueHandler().sendOption4("How many kills do I have left?",
+					"Who are you?", "Where are you located?",
+					"How many slayer points do I have?");
+			player.dialogueAction = 145;
+			break;
+
+		case 3691:
+			player.getItemAssistant().deleteItem(3691, 1);
+			player.getItemAssistant().addItem(3690, 1);
+			player.getPlayerAssistant().startTeleport(2661, 3310, 0, "modern");
+			break;
+
+		// case 2528:
+		// ExperienceLamp.showInterface(c);
+		// break;
+
+		case 5070:
+			player.getPacketSender().sendMessage("You search the nest.");
+			player.getItemAssistant().addItem(5076, 1);
+			player.getItemAssistant().deleteItem(itemId, 1);
+			player.getItemAssistant().addItem(5075, 1);
+			break;
+
+		case 5071:
+			player.getPacketSender().sendMessage("You search the nest.");
+			player.getItemAssistant().addItem(5078, 1);
+			player.getItemAssistant().deleteItem(itemId, 1);
+			player.getItemAssistant().addItem(5075, 1);
+			break;
+
+		case 5072:
+			player.getPacketSender().sendMessage("You search the nest.");
+			player.getItemAssistant().addItem(5077, 1);
+			player.getItemAssistant().deleteItem(itemId, 1);
+			player.getItemAssistant().addItem(5075, 1);
+			break;
+
+		case 5073:
+			player.getItemAssistant().handleTreeSeeds(itemId);
+			break;
+
+		case 5074:
+			player.getItemAssistant().handleRings(itemId);
+			break;
+			
+		case 7413:
+			player.getItemAssistant().handleNonTreeSeeds(itemId);
+		break;
+
+		case 2297:
+			player.getItemAssistant().addItem(2299, 1);
+			player.getItemAssistant().deleteItem(2297, 1);
+			break;
+
+		case 2299:
+			player.getItemAssistant().deleteItem(2299, 1);
+			break;
+
+		case 2301:
+			player.getItemAssistant().addItem(2303, 1);
+			player.getItemAssistant().deleteItem(2301, 1);
+			break;
+
+		case 2303:
+			player.getItemAssistant().deleteItem(2303, 1);
+			break;
+
+		case 2520:
+			player.forcedChat("Come on Dobbin, we can win the race!");
+			player.startAnimation(918);
+			break;
+		case 2522:
+			player.forcedChat("Come on Dobbin, we can win the race!");
+			player.startAnimation(919);
+			break;
+		case 2524:
+			player.forcedChat("Hi-ho Silver, and away!");
+			player.startAnimation(920);
+			break;
+		case 2526:
+			player.forcedChat("Neahhhyyy! Giddy-up horsey!");
+			player.startAnimation(921);
+			break;
+
+		case 405:
+			player.getItemAssistant().addCasketRewards(itemId);
+			break;
+
+		case 433:
+			player.getDialogueHandler().sendStatement("Visit the city of the white knights.");
+			player.nextChat = 0;
+			player.isBanking = false;
+			break;
+
+		case 2714:
+			player.getItemAssistant().deleteItem(itemId, 1);
+			player.getItemAssistant().addItem(995, 450);
+			player.getItemAssistant().addItem(1639, 1);
+			player.getItemAssistant().addItem(1635, 1);
+			player.pirateTreasure = 6;
+			break;
+		}
+		
+		for (final beverageData b : beverageData.values()) {
+			if (itemId == b.getBev()) {
+				Beverages.drinkBeverage(player, itemId, itemSlot);
+			}
+		}
+
+		if (player.getFood().isFood(itemId)) {
+			player.getFood().eat(itemId, itemSlot);
+		}
+		if (Prayer.playerBones(player, itemId)) {
+			Prayer.buryBones(player, itemId, itemSlot);
+		}
+		if (player.getPotions().isPotion(itemId)) {
+			player.getPotions().handlePotion(itemId, itemSlot);
+		}
+		if (Herblore.isHerb(itemId)) {
+			Herblore.handleHerbCleaning(player, itemId, itemSlot);
+			return;
+		}
+		if (itemId == 952) {
+			player.getBarrows().spadeDigging();
+			return;
+		}
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ClickNPC.java

@@ -0,0 +1,364 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.GameConstants;
+import com.rebotted.event.CycleEvent;
+import com.rebotted.event.CycleEventContainer;
+import com.rebotted.event.CycleEventHandler;
+import com.rebotted.game.content.combat.magic.MagicData;
+import com.rebotted.game.content.combat.range.RangeData;
+import com.rebotted.game.content.skills.thieving.Pickpocket;
+import com.rebotted.game.items.ItemAssistant;
+import com.rebotted.game.npcs.NpcHandler;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Click NPC
+ */
+public class ClickNPC implements PacketType {
+
+	public static final int ATTACK_NPC = 72, MAGE_NPC = 131, FIRST_CLICK = 155,
+			SECOND_CLICK = 17, THIRD_CLICK = 21;
+
+	@Override
+	public void processPacket(final Player client, int packetType, int packetSize) {
+		client.npcIndex = 0;
+		client.npcClickIndex = 0;
+		client.playerIndex = 0;
+		client.clickNpcType = 0;
+		client.getPlayerAssistant().resetFollow();
+		client.getCombatAssistant().resetPlayerAttack();
+		client.getPlayerAssistant().requestUpdates();
+		client.endCurrentTask();
+		switch (packetType) {
+
+		/**
+		 * Attack npc melee or range
+		 **/
+		case ATTACK_NPC:
+			if (client.tutorialProgress == 24) {
+				client.getPacketSender().chatbox(6180);
+				client.getDialogueHandler()
+						.chatboxText(
+								client,
+								"While you are fighting you will see a bar over your head. The",
+								"bar shows how much health you have left. Your opponent will",
+								"have one too. You will continue to attack the rat until it's dead",
+								"or you do something else.",
+								"Sit back and watch");
+				client.getPacketSender().chatbox(6179);
+
+			}
+			if (client.tutorialProgress == 33) {
+				client.getPacketSender()
+						.sendMessage(
+								"You can't range these chickens you have to mage them!");
+				return;
+			}
+			if (!client.mageAllowed) {
+				client.mageAllowed = true;
+				client.getPacketSender().sendMessage("I can't reach that.");
+				break;
+			}
+			client.npcIndex = client.getInStream().readUnsignedWordA();
+			if (NpcHandler.npcs[client.npcIndex] == null) {
+				client.npcIndex = 0;
+				break;
+			}
+			if (NpcHandler.npcs[client.npcIndex].MaxHP == 0) {
+				client.npcIndex = 0;
+				break;
+			}
+			if (NpcHandler.npcs[client.npcIndex] == null) {
+				break;
+			}
+			if (client.autocastId > 0) {
+				client.autocasting = true;
+			}
+			if (!client.autocasting && client.spellId > 0) {
+				client.spellId = 0;
+			}
+			client.faceUpdate(client.npcIndex);
+			client.usingMagic = false;
+			boolean usingBow = false;
+			boolean usingOtherRangeWeapons = false;
+			boolean usingArrows = false;
+			boolean usingCross = client.playerEquipment[client.playerWeapon] == 9185;
+			if (client.playerEquipment[client.playerWeapon] >= 4214
+					&& client.playerEquipment[client.playerWeapon] <= 4223) {
+				usingBow = true;
+			}
+			for (int bowId : RangeData.BOWS) {
+				if (client.playerEquipment[client.playerWeapon] == bowId) {
+					usingBow = true;
+					for (int arrowId : RangeData.ARROWS) {
+						if (client.playerEquipment[client.playerArrows] == arrowId) {
+							usingArrows = true;
+						}
+					}
+				}
+			}
+			for (int otherRangeId : RangeData.OTHER_RANGE_WEAPONS) {
+				if (client.playerEquipment[client.playerWeapon] == otherRangeId) {
+					usingOtherRangeWeapons = true;
+				}
+			}
+			if ((usingBow || client.autocasting)
+					&& client.goodDistance(client.getX(), client.getY(),
+							NpcHandler.npcs[client.npcIndex].getX(),
+							NpcHandler.npcs[client.npcIndex].getY(), 7)) {
+				client.stopMovement();
+			}
+
+			if (usingOtherRangeWeapons
+					&& client.goodDistance(client.getX(), client.getY(),
+							NpcHandler.npcs[client.npcIndex].getX(),
+							NpcHandler.npcs[client.npcIndex].getY(), 4)) {
+				client.stopMovement();
+			}
+			if (!usingCross && !usingArrows && usingBow
+					&& client.playerEquipment[client.playerWeapon] < 4212
+					&& client.playerEquipment[client.playerWeapon] > 4223 && !usingCross) {
+				client.getPacketSender().sendMessage(
+						"You have run out of arrows!");
+				break;
+			}
+			if (RangeData.correctBowAndArrows(client) < client.playerEquipment[client.playerArrows]
+					&& GameConstants.CORRECT_ARROWS
+					&& usingBow
+					&& !RangeData.usingCrystalBow(client)
+					&& client.playerEquipment[client.playerWeapon] != 9185) {
+				client.getPacketSender().sendMessage(
+						"You can't use "
+								+ ItemAssistant.getItemName(
+										client.playerEquipment[client.playerArrows])
+										.toLowerCase()
+								+ "s with a "
+								+ ItemAssistant.getItemName(
+										client.playerEquipment[client.playerWeapon])
+										.toLowerCase() + ".");
+				client.stopMovement();
+				client.getCombatAssistant().resetPlayerAttack();
+				return;
+			}
+			if (client.playerEquipment[client.playerWeapon] == 9185
+					&& !client.getCombatAssistant().properBolts()) {
+				client.getPacketSender().sendMessage(
+						"You must use bolts with a crossbow.");
+				client.stopMovement();
+				client.getCombatAssistant().resetPlayerAttack();
+				return;
+			}
+
+			if (client.followId > 0) {
+				client.getPlayerAssistant().resetFollow();
+			}
+			if (client.attackTimer <= 0) {
+				client.getCombatAssistant().attackNpc(client.npcIndex);
+				client.attackTimer++;
+			}
+
+			break;
+
+		/**
+		 * Attack npc with magic
+		 **/
+		case MAGE_NPC:
+			if (client.tutorialProgress == 33) {
+				client.getPacketSender().chatbox(6180);
+				client.getDialogueHandler()
+						.chatboxText(
+								client,
+								"",
+								"All you need to do is move on to the mainland. Just speak",
+								"with Terrova and he'll teleport you to Lumbridge Castle.",
+								"", "You have almost completed the tutorial!");
+				client.getPacketSender().chatbox(6179);
+				// c.getDialogues().sendStatement4("You have almost completed the tutorial!",
+				// "All you need to do is move on to the mainland. Just speak",
+				// "with Terrova and he'll teleport you to Lumbridge.", "");
+				client.tutorialProgress = 34;
+				client.getPacketSender().createArrow(1, 9);
+			}
+			if (!client.mageAllowed) {
+				client.mageAllowed = true;
+				client.getPacketSender().sendMessage("I can't reach that.");
+				break;
+			}
+			// c.usingSpecial = false;
+			// c.getItems().updateSpecialBar();
+
+			client.npcIndex = client.getInStream().readSignedWordBigEndianA();
+			int castingSpellId = client.getInStream().readSignedWordA();
+			client.usingMagic = false;
+
+			if (NpcHandler.npcs[client.npcIndex] == null) {
+				break;
+			}
+
+			if (NpcHandler.npcs[client.npcIndex].MaxHP == 0
+					|| NpcHandler.npcs[client.npcIndex].npcType == 944) {
+				client.getPacketSender().sendMessage(
+						"You can't attack this npc.");
+				break;
+			}
+
+			for (int i = 0; i < MagicData.MAGIC_SPELLS.length; i++) {
+				if (castingSpellId == MagicData.MAGIC_SPELLS[i][0]) {
+					client.spellId = i;
+					client.usingMagic = true;
+					break;
+				}
+			}
+
+			if (client.autocasting) {
+				client.autocasting = false;
+			}
+
+			if (client.usingMagic) {
+				if (client.goodDistance(client.getX(), client.getY(),
+						NpcHandler.npcs[client.npcIndex].getX(),
+						NpcHandler.npcs[client.npcIndex].getY(), 6)) {
+					client.stopMovement();
+				}
+				if (client.attackTimer <= 0) {
+					client.getCombatAssistant().attackNpc(client.npcIndex);
+					client.attackTimer++;
+				}
+			}
+
+			break;
+
+		case FIRST_CLICK:
+			client.npcClickIndex = client.inStream.readSignedWordBigEndian();
+			client.npcType = NpcHandler.npcs[client.npcClickIndex].npcType;
+			if (client.goodDistance(NpcHandler.npcs[client.npcClickIndex].getX(),
+					NpcHandler.npcs[client.npcClickIndex].getY(), client.getX(),
+					client.getY(), 2)) {
+				client.turnPlayerTo(NpcHandler.npcs[client.npcClickIndex].getX(),
+						NpcHandler.npcs[client.npcClickIndex].getY());
+				NpcHandler.npcs[client.npcClickIndex].facePlayer(client.playerId);
+				client.getNpcs().firstClickNpc(client.npcType);
+			} else {
+				client.clickNpcType = 1;
+				   CycleEventHandler.getSingleton().addEvent(client, new CycleEvent() {
+			            @Override
+			            public void execute(CycleEventContainer container) {
+						if (client.clickNpcType == 1
+								&& NpcHandler.npcs[client.npcClickIndex] != null) {
+							if (client.goodDistance(client.getX(), client.getY(),
+									NpcHandler.npcs[client.npcClickIndex].getX(),
+									NpcHandler.npcs[client.npcClickIndex].getY(), 1)) {
+								client.turnPlayerTo(
+										NpcHandler.npcs[client.npcClickIndex].getX(),
+										NpcHandler.npcs[client.npcClickIndex].getY());
+								NpcHandler.npcs[client.npcClickIndex]
+										.facePlayer(client.playerId);
+								client.getNpcs().firstClickNpc(client.npcType);
+								container.stop();
+							}
+						}
+						if (client.clickNpcType == 0 || client.clickNpcType > 1) {
+							container.stop();
+						}
+					}
+
+					@Override
+					public void stop() {
+						client.clickNpcType = 0;
+					}
+				}, 1);
+			}
+			break;
+
+		case SECOND_CLICK:
+			client.npcClickIndex = client.inStream.readUnsignedWordBigEndianA();
+			client.npcType = NpcHandler.npcs[client.npcClickIndex].npcType;
+			if (client.goodDistance(NpcHandler.npcs[client.npcClickIndex].getX(),
+					NpcHandler.npcs[client.npcClickIndex].getY(), client.getX(),
+					client.getY(), 2)) {
+				client.turnPlayerTo(NpcHandler.npcs[client.npcClickIndex].getX(),
+						NpcHandler.npcs[client.npcClickIndex].getY());
+				NpcHandler.npcs[client.npcClickIndex].facePlayer(client.playerId);
+				client.getNpcs().secondClickNpc(client.npcType);
+				if (Pickpocket.isNPC(client, client.npcType)) {
+					Pickpocket.attemptPickpocket(client, client.npcType);
+					return;
+				}
+			} else {
+				client.clickNpcType = 2;
+				   CycleEventHandler.getSingleton().addEvent(client, new CycleEvent() {
+			            @Override
+			            public void execute(CycleEventContainer container) {
+						if (client.clickNpcType == 2
+								&& NpcHandler.npcs[client.npcClickIndex] != null) {
+							if (client.goodDistance(client.getX(), client.getY(),
+									NpcHandler.npcs[client.npcClickIndex].getX(),
+									NpcHandler.npcs[client.npcClickIndex].getY(), 1)) {
+								client.turnPlayerTo(
+										NpcHandler.npcs[client.npcClickIndex].getX(),
+										NpcHandler.npcs[client.npcClickIndex].getY());
+								NpcHandler.npcs[client.npcClickIndex]
+										.facePlayer(client.playerId);
+								client.getNpcs().secondClickNpc(client.npcType);
+								container.stop();
+							}
+						}
+						if (client.clickNpcType < 2 || client.clickNpcType > 2) {
+							container.stop();
+						}
+					}
+
+					@Override
+					public void stop() {
+						client.clickNpcType = 0;
+					}
+				}, 1);
+			}
+			break;
+
+		case THIRD_CLICK:
+			client.npcClickIndex = client.inStream.readSignedWord();
+			client.npcType = NpcHandler.npcs[client.npcClickIndex].npcType;
+			if (client.goodDistance(NpcHandler.npcs[client.npcClickIndex].getX(),
+					NpcHandler.npcs[client.npcClickIndex].getY(), client.getX(),
+					client.getY(), 2)) {
+				client.turnPlayerTo(NpcHandler.npcs[client.npcClickIndex].getX(),
+						NpcHandler.npcs[client.npcClickIndex].getY());
+				NpcHandler.npcs[client.npcClickIndex].facePlayer(client.playerId);
+				client.getNpcs().thirdClickNpc(client.npcType);
+			} else {
+				client.clickNpcType = 3;
+				   CycleEventHandler.getSingleton().addEvent(client, new CycleEvent() {
+			            @Override
+			            public void execute(CycleEventContainer container) {
+						if (client.clickNpcType == 3
+								&& NpcHandler.npcs[client.npcClickIndex] != null) {
+							if (client.goodDistance(client.getX(), client.getY(),
+									NpcHandler.npcs[client.npcClickIndex].getX(),
+									NpcHandler.npcs[client.npcClickIndex].getY(), 1)) {
+								client.turnPlayerTo(
+										NpcHandler.npcs[client.npcClickIndex].getX(),
+										NpcHandler.npcs[client.npcClickIndex].getY());
+								NpcHandler.npcs[client.npcClickIndex]
+										.facePlayer(client.playerId);
+								client.getNpcs().thirdClickNpc(client.npcType);
+								container.stop();
+							}
+						}
+						if (client.clickNpcType < 3) {
+							container.stop();
+						}
+					}
+
+					@Override
+					public void stop() {
+						client.clickNpcType = 0;
+					}
+				}, 1);
+			}
+			break;
+		}
+
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ClickObject.java

@@ -0,0 +1,489 @@
+package com.rebotted.net.packets.impl;
+
+import java.util.function.Consumer;
+import com.rebotted.GameEngine;
+import com.rebotted.event.CycleEvent;
+import com.rebotted.event.CycleEventContainer;
+import com.rebotted.event.CycleEventHandler;
+import com.rebotted.game.content.minigames.castlewars.CastleWarObjects;
+import com.rebotted.game.content.minigames.castlewars.CastleWars;
+import com.rebotted.game.content.skills.core.Woodcutting;
+import com.rebotted.game.content.skills.thieving.Stalls;
+import com.rebotted.game.globalworldobjects.Doors;
+import com.rebotted.game.npcs.NpcHandler;
+import com.rebotted.game.objects.Objects;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+import com.rebotted.world.clip.Region;
+
+public class ClickObject implements PacketType {
+
+	public static final int FIRST_CLICK = 132, SECOND_CLICK = 252,
+			THIRD_CLICK = 70, FOURTH_CLICK = 234;
+
+	public void onObjectReached(Player player, Consumer<Player> consumer) {
+		if (System.currentTimeMillis() - player.clickDelay < 300)
+			return;
+		player.clickDelay = System.currentTimeMillis();
+
+		final int objectX = player.objectX;
+		final int objectY = player.objectY;
+		final int objectId = player.objectId;
+
+		Objects object = Region.getObject(objectId, objectX, objectY, player.heightLevel);
+		if (object == null) {
+			// Since most content is coded poorly we will have to assume the object is valid
+			// but we won't know the face direction, so some objects will behave incorrectly
+			// if the object size is not equal on both axes and the face
+			// is not set to zero. The proper fix would be when an object is removed or added
+			// they are added into the region configuration properly so we can retrieve
+			// the object at runtime. This will suffice for now.
+			object = new Objects(objectId, objectX, objectY, player.heightLevel, 0, 10, 0);
+		}
+
+		int[] size = object.getObjectSize();
+
+		CycleEvent objectWalkToEvent = new CycleEvent() {
+			@Override
+			public void execute(CycleEventContainer container) {
+				if (objectX != player.objectX || objectY != player.objectY || objectId != player.objectId) {
+					container.stop();
+					return;
+				}
+
+				int x = player.absX;
+				int y = player.absY;
+				int xMin = objectX - 1;
+				int xMax = xMin + size[0] + 1;
+				int yMin = objectY - 1;
+				int yMax = yMin + size[1] + 1;
+
+				if (x >= xMin && y >= yMin && x <= xMax && y <= yMax) {
+					consumer.accept(player);
+					container.stop();
+				}
+			}
+
+			@Override
+			public void stop() {}
+		};
+
+		player.startCurrentTask(1, objectWalkToEvent);
+		objectWalkToEvent.execute(player.getCurrentTask()); // cheap hax for instant event execution, since we don't support it
+	}
+
+	@Override
+	public void processPacket(final Player player, int packetType, int packetSize) {
+		player.clickObjectType = player.objectX = player.objectId = player.objectY = 0;
+		player.getPlayerAssistant().resetFollow();
+		player.getCombatAssistant().resetPlayerAttack();
+		player.getPlayerAssistant().requestUpdates();
+		player.endCurrentTask();
+		switch (packetType) {
+
+			case FIRST_CLICK:
+				player.objectX = player.getInStream().readSignedWordBigEndianA();
+				player.objectId = player.getInStream().readUnsignedWord();
+				player.objectY = player.getInStream().readUnsignedWordA();
+				onObjectReached(player, (p) -> completeObjectClick(p, 1));
+				break;
+
+			case SECOND_CLICK:
+				player.objectId = player.getInStream().readUnsignedWordBigEndianA();
+				player.objectY = player.getInStream().readSignedWordBigEndian();
+				player.objectX = player.getInStream().readUnsignedWordA();
+				onObjectReached(player, (p) -> completeObjectClick(p, 2));
+				break;
+
+			case THIRD_CLICK: // 'F'
+				player.objectX = player.getInStream().readSignedWordBigEndian();
+				player.objectY = player.getInStream().readUnsignedWord();
+				player.objectId = player.getInStream().readUnsignedWordBigEndianA();
+				onObjectReached(player, (p) -> completeObjectClick(p, 3));
+				break;
+
+
+			case FOURTH_CLICK:
+				player.objectX = player.getInStream().readSignedWordBigEndianA();
+				player.objectId = player.getInStream().readUnsignedWordA();
+				player.objectY = player.getInStream().readUnsignedWordBigEndianA();
+				onObjectReached(player, (p) -> completeObjectClick(p, 4));
+				break;
+		}
+	}
+
+	public void completeObjectClick(final Player p, int objectOption) {
+		p.turnPlayerTo(p.objectX, p.objectY);
+
+		switch (objectOption) {
+		case 1:
+			if (p.playerRights == 3 || p.debugMode) {
+				p.getPacketSender().sendMessage("ObjectId: " + p.objectId + " ObjectX: " + p.objectX + " ObjectY: " + p.objectY + " Objectclick = 1, Xoff: " + (p.getX() - p.objectX) + " Yoff: " + (p.getY() - p.objectY));
+			}
+
+			//todo: check if it's a door before fire handle
+			Doors.getSingleton().handleDoor(p.objectId, p.objectX, p.objectY, p.heightLevel, p);
+
+			/*if (client.performingAction) {
+				return;
+			}*/
+
+			if (Stalls.isObject(p.objectId)) {
+				Stalls.attemptStall(p, p.objectId, p.objectX, p.objectX);
+				return;
+			}
+
+			if (p.teleTimer > 0) {
+				p.getPacketSender().sendMessage(
+						"You cannot use objects while teleporting.");
+				return;
+			}
+			if (Math.abs(p.getX() - p.objectX) > 25 || Math.abs(p.getY() - p.objectY) > 25) {
+				p.resetWalkingQueue();
+				break;
+			}
+			switch (p.objectId) {
+			case 1276:
+				Woodcutting.startWoodcutting(p, 0, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1278:
+				Woodcutting.startWoodcutting(p, 1, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1286:
+				Woodcutting.startWoodcutting(p, 2, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1281:
+				Woodcutting.startWoodcutting(p, 3, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1308:
+				Woodcutting.startWoodcutting(p, 4, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 5552:
+				Woodcutting.startWoodcutting(p, 5, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1307:
+				Woodcutting.startWoodcutting(p, 6, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1309:
+				Woodcutting.startWoodcutting(p, 7, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1306:
+				Woodcutting.startWoodcutting(p, 8, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 5551:
+				Woodcutting.startWoodcutting(p, 9, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 5553:
+				Woodcutting.startWoodcutting(p, 10, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 3033:
+				Woodcutting.startWoodcutting(p, 11, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 3037:
+				Woodcutting.startWoodcutting(p, 12, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1282:
+				Woodcutting.startWoodcutting(p, 13, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1383:
+				Woodcutting.startWoodcutting(p, 14, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 2023:
+				Woodcutting.startWoodcutting(p, 15, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1319:
+				Woodcutting.startWoodcutting(p, 16, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1318:
+				Woodcutting.startWoodcutting(p, 17, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1315:
+				Woodcutting.startWoodcutting(p, 18, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1316:
+				Woodcutting.startWoodcutting(p, 19, p.objectX, p.objectY, p.clickObjectType);
+				break;
+			case 1332:
+				Woodcutting.startWoodcutting(p, 20, p.objectX, p.objectY, p.clickObjectType);
+				break;
+
+			case 1292:
+				if (p.spiritTree == false && p.clickedTree == true) {
+					p.getPacketSender().sendMessage("You have already spawned a tree spirit.");
+					return;
+				}
+				if (p.spiritTree == false && p.clickedTree == false) {
+					p.getPacketSender().sendMessage("You attempt to chop the tree, and a tree spirit appears.");
+					NpcHandler.spawnNpc(p, 655, p.getX(), p.getY(), 0, 0, 225, 20, 80, 80, true, false);
+					p.clickedTree = true;
+				} else if (p.spiritTree == true) {
+					Woodcutting.startWoodcutting(p, 21, p.objectX, p.objectY, p.clickObjectType);
+				}
+				break;
+
+			case 1294:
+			case 1293:
+			case 1317:
+				p.getPlayerAssistant().spiritTree();
+				break;
+
+		      case 2164:
+              case 2165:
+                  GameEngine.trawler.fixNet(p);
+                  break;
+
+			case 4462:
+			case 4460:
+			case 4461:
+			case 4463:
+			case 4464:
+			case 4459:
+				if (!CastleWars.isInCw(p)) {
+					p.getPacketSender().sendMessage("You have to be in castle wars to use these objects.");
+					CastleWars.resetPlayer(p);
+					return;
+				}
+				CastleWarObjects.handleObject(p, p.objectId, p.objectX, p.objectY);
+			break;
+
+			case 2513:
+				p.getRangersGuild().fireAtTarget();
+			break;
+
+	        case 8930:
+                p.fade(1975, 4409, 3);
+            break;
+            case 8929:
+                p.fade(2442, 10147, 0);
+            break;
+
+			case 1568:
+				if (p.objectX == 2399 && p.objectY == 3099) {
+					p.getPacketSender()
+							.object(9472, 2399, 3099, 0, 10);
+				}
+				if (p.objectX == 2400 && p.objectY == 3108) {
+					p.getPacketSender()
+							.object(9472, 2400, 3108, 2, 10);
+				}
+				break;
+
+			case 4437:
+				if (p.getItemAssistant().playerHasItem(1265, 1)) {
+					p.getPacketSender().sendMessage(
+							"You start to break up the rocks...");
+					p.startAnimation(625);
+					   CycleEventHandler.getSingleton().addEvent(p, new CycleEvent() {
+				            @Override
+				            public void execute(CycleEventContainer container) {
+							container.stop();
+							p.startAnimation(65535);
+						}
+
+						@Override
+						public void stop() {
+							p.getPacketSender().object(-1,
+									p.objectX, p.objectY, 0, 10);
+							p.getPacketSender().object(4438,
+									p.objectX, p.objectY, 0, 10);
+							p.getPacketSender().sendMessage(
+									"You break up the rocks.");
+						}
+					}, 3);
+				}
+				break;
+
+			case 4438:
+				if (p.getItemAssistant().playerHasItem(1265, 1)) {
+					p.getPacketSender().sendMessage(
+							"You start to break up the rocks...");
+					p.startAnimation(625);
+					   CycleEventHandler.getSingleton().addEvent(p, new CycleEvent() {
+				            @Override
+				            public void execute(CycleEventContainer container) {
+							stop();
+							p.startAnimation(65535);
+						}
+
+						@Override
+						public void stop() {
+							p.getPacketSender().object(-1,
+									p.objectX, p.objectY, 0, 10);
+							p.getPacketSender().sendMessage(
+									"You break up the rocks.");
+						}
+					}, 3);
+				}
+				break;
+
+			case 4448:
+				if (p.getItemAssistant().playerHasItem(1265, 1)) {
+					p.getPacketSender().sendMessage(
+							"You start to mine the wall...");
+					p.startAnimation(625);
+					   CycleEventHandler.getSingleton().addEvent(p, new CycleEvent() {
+				            @Override
+				            public void execute(CycleEventContainer container) {
+							stop();
+							p.startAnimation(65535);
+							p.getPacketSender().sendMessage(
+									"You collapse the cave wall.");
+						}
+
+						@Override
+						public void stop() {
+							if ((p.objectX == 2390 || p.objectX == 2393)
+									&& (p.objectY == 9503 || p.objectY == 9500)) { // east
+								// cave
+								// side
+								p.getPacketSender().object(-1, 2391,
+										9501, 0, 10);
+								p.getPacketSender().object(4437, 2391,
+										9501, 0, 10);
+								CastleWars.collapseCave(1);
+							}
+							if ((p.objectX == 2399 || p.objectX == 2402)
+									&& (p.objectY == 9511 || p.objectY == 9514)) { // north
+								// cave
+								// side
+								p.getPacketSender().object(-1, 2400,
+										9512, 1, 10);
+								p.getPacketSender().object(4437, 2400,
+										9512, 1, 10);
+								CastleWars.collapseCave(0);
+							}
+							if ((p.objectX == 2408 || p.objectX == 2411)
+									&& (p.objectY == 9502 || p.objectY == 9505)) { // west
+								// cave
+								// side
+								p.getPacketSender().object(-1, 2409,
+										9503, 0, 10);
+								p.getPacketSender().object(4437, 2409,
+										9503, 0, 10);
+								CastleWars.collapseCave(3);
+							}
+							if ((p.objectX == 2400 || p.objectX == 2403)
+									&& (p.objectY == 9496 || p.objectY == 9493)) { // south
+								// cave
+								// side
+								p.getPacketSender().object(-1, 2401,
+										9494, 1, 10);
+								p.getPacketSender().object(4437, 2401,
+										9494, 1, 10);
+								CastleWars.collapseCave(2);
+							}
+						}
+					}, 3);
+				}
+				break;
+
+			case 1733:
+				if (p.objectX == 3058 && p.objectY == 3376) {
+					p.getPlayerAssistant().movePlayer(3058, 9776, 0);
+				} else if (p.objectX == 2603 && p.objectY == 3078) {
+				}
+				break;
+
+			case 55:
+				if (p.objectX == 3061 && p.objectY == 3374) {
+					p.getPlayerAssistant().movePlayer(3058, 9776, 0);
+				}
+				break;
+
+			case 9472:
+				if (p.objectX == 2399 && p.objectY == 3099) {
+					p.startAnimation(828);
+					p.stopMovement();
+					p.resetWalkingQueue();
+					p.getPlayerAssistant().requestUpdates();
+					p.getPacketSender().closeAllWindows();
+					   CycleEventHandler.getSingleton().addEvent(p, new CycleEvent() {
+				            @Override
+				            public void execute(CycleEventContainer container) {
+							container.stop();
+							p.startAnimation(65535);
+							p.getPlayerAssistant().movePlayer(2400, 9507,
+									0);
+						}
+
+							@Override
+							public void stop() {
+
+							}
+					}, 1);
+				}
+				if (p.objectX == 2400 && p.objectY == 3108) {
+					p.startAnimation(828);
+					p.stopMovement();
+					p.resetWalkingQueue();
+					p.getPlayerAssistant().requestUpdates();
+					p.getPacketSender().closeAllWindows();
+					   CycleEventHandler.getSingleton().addEvent(p, new CycleEvent() {
+				            @Override
+				            public void execute(CycleEventContainer container) {
+							stop();
+							p.startAnimation(65535);
+							p.getPlayerAssistant().movePlayer(2399, 9500, 0);
+						}
+
+						@Override
+							public void stop() {
+
+							}
+					}, 1);
+				}
+				break;
+
+			case 4387:
+				CastleWars.addToWaitRoom(p, 1); // saradomin
+				break;
+
+			case 4388:
+				CastleWars.addToWaitRoom(p, 2); // zamorak
+				break;
+
+			case 4408:
+				CastleWars.addToWaitRoom(p, 3); // guthix
+				break;
+
+			case 4389: // sara
+			case 4390: // zammy waiting room portal
+				CastleWars.leaveWaitingRoom(p);
+				break;
+			}
+			p.getObjects().firstClickObject(p.objectId, p.objectX, p.objectY);
+			break;
+
+		case 2:
+			if (p.playerRights == 3) {
+				p.getPacketSender().sendMessage("ObjectId: " + p.objectId + " ObjectX: " + p.objectX + " ObjectY: " + p.objectY + " Objectclick = 2, Xoff: " + (p.getX() - p.objectX) + " Yoff: " + (p.getY() - p.objectY));
+			}
+			if (Stalls.isObject(p.objectId)) {
+				Stalls.attemptStall(p, p.objectId, p.objectX, p.objectX);
+				return;
+			}
+			p.getObjects().secondClickObject(p.objectId, p.objectX, p.objectY);
+			break;
+
+		case 3: // 'F'
+			if (p.playerRights == 3) {
+				p.getPacketSender().sendMessage("ObjectId: " + p.objectId + " ObjectX: " + p.objectX + " ObjectY: " + p.objectY + " Objectclick = 3, Xoff: " + (p.getX() - p.objectX) + " Yoff: " + (p.getY() - p.objectY));
+			}
+
+			p.getObjects().thirdClickObject(p.objectId, p.objectX, p.objectY);
+			break;
+			
+
+		case 4:
+			if (p.playerRights == 3) {
+				p.getPacketSender().sendMessage("ObjectId: " + p.objectId + " ObjectX: " + p.objectX + " ObjectY: " + p.objectY + " Objectclick = 4, Xoff: " + (p.getX() - p.objectX) + " Yoff: " + (p.getY() - p.objectY));
+			}
+
+			p.getObjects().fourthClickObject(p.objectId, p.objectX, p.objectY);
+			break;
+		}
+	}
+
+
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ClickTab.java

@@ -0,0 +1,149 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.items.ItemAssistant;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+public class ClickTab implements PacketType {
+
+	@Override
+	public void processPacket(final Player c, int packetType, int packetSize) {
+		switch (packetSize) {
+		case 1:// first part.
+			if (c.tutorialProgress == 0) { // wrench
+				c.getPacketSender().chatbox(6180);
+				c.getDialogueHandler()
+						.chatboxText(
+								c,
+								"On the side panel you can now see a variety of options from",
+								"changing your graphic settings and audio and music volume",
+								"to selecting whether your player should accept help from",
+								"other players. Don't worry about these too much for now.",
+								"@blu@Player controls");
+				c.getPacketSender().chatbox(6179);
+				c.tutorialProgress = 1;
+			} else if (c.tutorialProgress == 3) { // backpack
+				c.getPacketSender().chatbox(6180);
+				c.getDialogueHandler()
+						.chatboxText(
+								c,
+								"You can click on the backpack icon at any time to view the",
+								"items that you currently have in your inventory. You will see",
+								"that you now have an axe in your inventory. Use this to get",
+								"some logs by clicking on one of the trees in the area.",
+								"Cut down a tree");
+				c.getPacketSender().createArrow(3099, 3095, c.getH(), 2);
+				c.getPacketSender().chatbox(6179);
+			} else if (c.tutorialProgress == 4) { // Skills tab
+				c.getPacketSender().chatbox(6180);
+				c.getDialogueHandler()
+						.chatboxText(
+								c,
+								"Here you will see how good your skills are. As you move your",
+								"mouse over any of the icons in this panel, the small yellow",
+								"popup box will show you the exact amount of experience you",
+								"have and how much is needed to get to the next level.",
+								"Your skill stats");
+				c.tutorialProgress = 5;
+				c.getPacketSender().chatbox(6179);
+				c.getPacketSender().createArrow(1, 2);
+			} else if (c.tutorialProgress == 9) { // Music tab
+				c.getPacketSender().chatbox(6180);
+				c.getDialogueHandler()
+						.chatboxText(
+								c,
+								"From this interface you can control the music that is played.",
+								"As you explore the world, more of the tunes will become",
+								"unlocked. Once you've examined this menu use the next door",
+								"to continue. If you need a recap, talk to the Master Chef",
+								"The music player");
+				c.getPacketSender().createArrow(3073, 3090, c.getH(), 2);
+				c.tutorialProgress = 10;
+				c.getPacketSender().chatbox(6179);
+			} else if (c.tutorialProgress == 10) { // Emotes aNd running
+				c.getPacketSender().chatbox(6180);
+				c.getDialogueHandler()
+						.chatboxText(
+								c,
+								"For those situations where words don't quite describe how you",
+								"feel, try an emote. Go ahead, try one out! You might notice",
+								"that some of the emotes are grey and cannot be used now.",
+								"As you progress further into the game you'll gain more.",
+								"Emotes");
+				c.getPacketSender().chatbox(6179);
+			} else if (c.tutorialProgress == 12) { // Quest Tab
+				c.getPacketSender().chatbox(6180);
+				c.getDialogueHandler()
+						.chatboxText(
+								c,
+								"",
+								"This is your Quest Journal, a list of all the quests in the game.",
+								"Talk to the Quest Guide again for an explaination.",
+								"", "Your Quest Journal");
+				c.tutorialProgress = 13;
+				c.getPacketSender().chatbox(6179);
+			} else if (c.tutorialProgress == 21) { // Worn inventory
+				c.getPacketSender().chatbox(6180);
+				c.getDialogueHandler()
+						.chatboxText(
+								c,
+								"You can see what items you are wearing in the worn inventory",
+								"to the left of the screen with their combined statistics on the",
+								"right. Let's add something. Left click your dagger to 'wield' it.",
+								"", "Worn interface");
+				c.getPacketSender().chatbox(6179);
+				c.tutorialProgress = 22;
+			} else if (c.tutorialProgress == 23) { // Attack syle tabs
+				c.getPacketSender().chatbox(6180);
+				c.getDialogueHandler()
+						.chatboxText(
+								c,
+								"From this interface you can select the type of attack your",
+								"character will use. Different monsters have different",
+								"weaknesses. If you hover your mouse over the buttons, you",
+								"will see the type of XP you will receive when using each attack.",
+								"This is your combat interface");
+				c.tutorialProgress = 24;
+				c.getPacketSender().chatbox(6179);
+				c.getItemAssistant()
+						.sendWeapon(
+								c.playerEquipment[c.playerWeapon],
+								ItemAssistant
+										.getItemName(c.playerEquipment[c.playerWeapon]));
+				c.getPacketSender().createArrow(3111, 9518, c.getH(), 2);
+			} else if (c.tutorialProgress == 29) { // Prayer
+				c.getDialogueHandler().sendDialogues(3092, 222);
+			} else if (c.tutorialProgress == 30) { // friends tab
+				c.getPacketSender().chatbox(6180);
+				c.getDialogueHandler()
+						.chatboxText(
+								c,
+								"This will be explaing by Brother Brace shortly, but first click",
+								"on the other flashing face to the right of your screen.",
+								"", "", "This is your friends list");
+				c.getPacketSender().setSidebarInterface(9, 5715);
+				c.getPacketSender().flashSideBarIcon(-9);
+				c.tutorialProgress = 31;
+				c.getPacketSender().chatbox(6179);
+			} else if (c.tutorialProgress == 31) { // ignores tab
+				c.getPacketSender().chatbox(6180);
+				c.getDialogueHandler()
+						.chatboxText(
+								c,
+								"The two lists - friends and ignore - can be very helpful for",
+								"keeping track of when your friends are online or for blocking",
+								"messages from people you simply don't like. Speak with",
+								"Brother Brace and he will tell you more.",
+								"This is your ignore list");
+				c.getPacketSender().chatbox(6179);
+			} else if (c.tutorialProgress == 32) { // Final magic tab
+				c.tutorialProgress = 33;
+				c.getDialogueHandler().sendDialogues(3108, 946);
+			}
+			break;
+
+		}
+
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ClickingInGame.java

@@ -0,0 +1,16 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Clicking in game
+ **/
+public class ClickingInGame implements PacketType {
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ClickingStuff.java

@@ -0,0 +1,54 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+import com.rebotted.net.packets.PacketType;
+import com.rebotted.util.Misc;
+
+/**
+ * Clicking stuff (interfaces)
+ **/
+public class ClickingStuff implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		if (player.playerIsBusy()) {
+			player.playerIsBusy = false;
+		}
+		if (player.isBanking)
+	         player.isBanking = false;
+		if(player.isShopping)
+	        player.isShopping = false;
+		if (player.inTrade) {
+			Player opponent = (Player) PlayerHandler.players[player.tradeWith];
+			if (!player.acceptedTrade || !opponent.inTrade || opponent == null) {
+				opponent = (Player) PlayerHandler.players[player.tradeWith];
+				opponent.tradeAccepted = false;
+				player.tradeAccepted = false;
+				opponent.tradeStatus = 0;
+				player.tradeStatus = 0;
+				player.tradeConfirmed = false;
+				player.tradeConfirmed2 = false;
+				player.getPacketSender().sendMessage("@red@Trade has been declined.");
+				opponent.getPacketSender().sendMessage("@red@Other player has declined the trade.");
+				Misc.println("trade reset");
+				player.getTrading().declineTrade();
+				opponent.getTrading().declineTrade();
+				}
+			}
+
+		if(player.openDuel && player.duelStatus >= 1 && player.duelStatus <= 4) {
+		Player o = (Player) PlayerHandler.players[player.duelingWith];
+		if (o != null)
+			if (player.duelStatus >= 1 && player.duelStatus <= 4)
+				player.getDueling().declineDuel();
+				o.getDueling().declineDuel();
+			}
+
+		if (player.duelStatus == 6) {
+			player.getDueling().claimStakedItems();
+		}
+
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/Commands.java

@@ -0,0 +1,740 @@
+package com.rebotted.net.packets.impl;
+
+import static com.rebotted.game.content.combat.magic.MagicTeleports.LUMBRIDGE_X;
+import static com.rebotted.game.content.combat.magic.MagicTeleports.LUMBRIDGE_Y;
+import static com.rebotted.util.GameLogger.writeLog;
+import java.util.Arrays;
+import com.rebotted.Connection;
+import com.rebotted.GameConstants;
+import com.rebotted.GameEngine;
+import com.rebotted.game.bots.BotHandler;
+import com.rebotted.game.items.ItemAssistant;
+import com.rebotted.game.npcs.NpcHandler;
+import com.rebotted.game.players.*;
+import com.rebotted.net.packets.PacketType;
+import com.rebotted.util.Misc;
+import com.rebotted.world.clip.Region;
+
+public class Commands implements PacketType {
+
+        @Override
+        public void processPacket(Player player, int packetType, int packetSize) {
+                String[] messageArr = player.getInStream().readString().split(" ");
+                String playerCommand = messageArr[0];
+                String[] commandArguments = Arrays.copyOfRange(messageArr, 1, messageArr.length);
+                if ((playerCommand.startsWith("ban") || playerCommand.startsWith("ip") || playerCommand.startsWith("mute") || playerCommand.startsWith("un")) && player.playerRights > 0 && player.playerRights < 4) {
+                        writeLog(player.playerName, "commands", player.playerName + " used command: " + playerCommand);
+                }
+                if (player.playerRights >= 0) {
+                        playerCommands(player, playerCommand, commandArguments);
+                }
+                if (player.playerRights >= 1) {
+                        moderatorCommands(player, playerCommand, commandArguments);
+                }
+                if (player.playerRights >= 2 && player.playerRights < 4) {
+                        adminCommands(player, playerCommand, commandArguments);
+                }
+                if (player.playerRights == 3) {
+                        developerCommands(player, playerCommand, commandArguments);
+                }
+        }
+
+        public static void playerCommands(Player player, String playerCommand, String[] arguments) {
+                switch (playerCommand.toLowerCase())
+                {
+                        case "bank":
+                                player.getPacketSender().openUpBank();
+                                break;
+                        case "claimvote":
+                                if(!GameEngine.ersSecret.equals("")) {
+                                        final String playerName = player.playerName;
+
+                                        com.everythingrs.vote.Vote.service.execute(new Runnable() {
+                                                @Override
+                                                public void run() {
+                                                        try {
+                                                                int currentPoints = player.votePoints;
+                                                                com.everythingrs.vote.Vote[] reward = com.everythingrs.vote.Vote.reward(GameEngine.ersSecret, playerName, "1", "all");
+                                                                if (reward[0].message != null) {
+                                                                        player.getPacketSender().sendMessage(reward[0].message);
+                                                                        return;
+                                                                }
+                                                                player.votePoints = (currentPoints + reward[0].give_amount);
+                                                                //player.getActionSender().sendMessage("Thank you for voting! You now have " + reward[0].vote_points + " vote points.");
+                                                                player.getPacketSender().sendMessage(
+                                                                        "Thank you for voting! You now have " + player.votePoints + " vote points.");
+                                                        } catch (Exception e) {
+                                                                player.getPacketSender().sendMessage("Api Services are currently offline. Please check back shortly");
+                                                                e.printStackTrace();
+                                                        }
+                                                }
+
+                                        });
+                                } else {
+                                        player.getPacketSender().sendMessage("Voting Is Not Enabled");
+                                }
+                                break;
+                        case "coords":
+                        case "coord":
+                        case "pos":
+                                player.getPacketSender().sendMessage("Your coords are [" + player.absX + "," + player.absY + "]");
+                                break;
+                        case "null":
+                                break;
+                        case "players":
+                                if (PlayerHandler.getPlayerCount() != 1) {
+                                        player.getPacketSender().sendMessage("There are currently " + PlayerHandler.getPlayerCount() + " players online.");
+                                } else {
+                                        player.getPacketSender().sendMessage("There is currently " + PlayerHandler.getPlayerCount() + " player online.");
+                                }
+                                break;
+                        case "shop":
+                                BotHandler.playerShop(player);
+                                break;
+                        case "withdrawshop":
+                        case "wshop":
+                                BotHandler.takeCoins(player);
+                                break;
+                        case "closeshop":
+                        case "cshop":
+                                BotHandler.closeShop(player);
+                                break;
+                        case "wealth":
+                                int totalWealth = player.getPlayerAssistant().totalGold();
+                                player.getPacketSender().sendMessage("You currently have " + totalWealth + "gp.");
+                                break;
+                        case "gfx100":
+                                if (arguments.length == 0)
+                                        player.getPacketSender().sendMessage("Must have 1 argument: ::gfx100 80");
+                                else
+                                        player.gfx100(Integer.parseInt(arguments[0]));
+                                break;
+                        case "gfx0":
+                                if (arguments.length == 0)
+                                        player.getPacketSender().sendMessage("Must have 1 argument: ::gfx0 80");
+                                else
+                                        player.gfx0(Integer.parseInt(arguments[0]));
+                                break;
+                        case "tele":
+                                if (player.connectedFrom.equals("127.0.0.1")) {
+                                        try {
+                                                if (arguments.length < 2) {
+                                                        player.getPacketSender().sendMessage("Must specify x, y and optionally z coordinates: ::tele 3222 3218 0");
+                                                        return;
+                                                }
+                                                if (arguments.length == 3)
+                                                        player.getPlayerAssistant().movePlayer(Integer.parseInt(arguments[0]), Integer.parseInt(arguments[1]), Integer.parseInt(arguments[2]));
+                                                else
+                                                        player.getPlayerAssistant().movePlayer(Integer.parseInt(arguments[0]), Integer.parseInt(arguments[1]), player.heightLevel);
+                                        } catch (Exception e) {
+                                                player.getPacketSender().sendMessage("Invalid coordinates");
+                                        }
+                                } else {
+                                        player.getPacketSender().sendMessage("Can't tele with ip " + player.connectedFrom);
+                                }
+                                break;
+                        case "close_interface":
+                                player.getPacketSender().closeAllWindows();
+                                break;
+                        case "commands":
+                                player.getPacketSender().sendMessage("::players, ::highscores, ::loc, ::stuck, ::randomtoggle, ::debug, ::togglegfx, ::shop, ::withdrawshop, ::closeshop");
+                                break;
+                        case "loc":
+                                player.getPacketSender().sendMessage(player.absX + "," + player.absY);
+                                break;
+                        case "stuck":
+                                player.getPlayerAssistant().startTeleport(LUMBRIDGE_X, LUMBRIDGE_Y, 0, "modern");
+                                player.getPacketSender().sendMessage("How did you manage that one..");
+                                player.gfx100(80);
+                                player.startAnimation(404);
+                                break;
+                        case "randomtoggle":
+                        case "togglerandom":
+                                player.randomEventsEnabled = !player.randomEventsEnabled;
+                                player.getPacketSender().sendMessage("You will " + (player.randomEventsEnabled ? "now" : "no longer") + " receieve random events.");
+                                break;
+                        case "debug":
+                        case "debugmode":
+                                player.debugMode = !player.debugMode;
+                                player.getPacketSender().sendMessage("You will " + (player.debugMode ? "now" : "no longer") + " receieve additional debug information when doing things.");
+                                break;
+                        case "highscores":
+                                for (Player p : PlayerHandler.players) {
+                                        if (p == null) {
+                                                continue;
+                                        }
+                                        PlayerSave.saveGame((Client) p);
+                                        System.out.println("Saved game for " + p.playerName + ".");
+                                        GameEngine.lastMassSave = System.currentTimeMillis();
+                                }
+                                HighscoresHandler hs = new HighscoresHandler();
+                                String[] highscores = new String[]{
+                                        "Top 5 Total Level:",
+                                        hs.getRank(player, 0, "level"),
+                                        hs.getRank(player, 1, "level"),
+                                        hs.getRank(player, 2, "level"),
+                                        hs.getRank(player, 3, "level"),
+                                        hs.getRank(player, 4, "level"),
+                                        "",
+                                        "Top 5 Wealthiest Players:",
+                                        hs.getRank(player, 0, "gold"),
+                                        hs.getRank(player, 1, "gold"),
+                                        hs.getRank(player, 2, "gold"),
+                                        hs.getRank(player, 3, "gold"),
+                                        hs.getRank(player, 4, "gold"),
+                                        "",
+                                        "Top 5 Highest Total Damage:",
+                                        hs.getRank(player, 0, "damage"),
+                                        hs.getRank(player, 1, "damage"),
+                                        hs.getRank(player, 2, "damage"),
+                                        hs.getRank(player, 3, "damage"),
+                                        hs.getRank(player, 4, "damage"),
+                                };
+
+
+                                // Clear all lines
+                                for (int i = 8144; i < 8195; i++) player.getPacketSender().sendFrame126("", i);
+
+                                player.getPacketSender().sendFrame126("@dre@Highscores", 8144);
+
+                                int lineNumber = 8147;
+                                for (String line : highscores){
+                                        System.out.println(line + " - " + lineNumber);
+                                        player.getPacketSender().sendFrame126(line, lineNumber++);
+                                }
+                                player.getPacketSender().showInterface(8134);
+
+                                break;
+
+                }
+
+        }
+
+        public static void moderatorCommands(Player player, String playerCommand, String[] arguments) {
+                switch (playerCommand.toLowerCase()) {
+                        case "kick":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify a player name: ::kick playername");
+                                                return;
+                                        }
+                                        String playerToKick = String.join(" ", arguments);
+                                        for(Player player2 : PlayerHandler.players) {
+                                                if(player2 != null) {
+                                                        if(player2.playerName.equalsIgnoreCase(playerToKick)) {
+                                                                Client c2 = (Client)player2;
+                                                                player.getPacketSender().sendMessage("You have kicked " + playerToKick + ".");
+                                                                c2.disconnected = true;
+                                                                c2.logout(true);
+                                                                break;
+                                                        }
+                                                }
+                                        }
+                                } catch(Exception e) {
+                                        player.getPacketSender().sendMessage("Player Must Be Online.");
+                                }
+                                break;
+                        case "yell":
+                                for (int j = 0; j < PlayerHandler.players.length; j++) {
+                                        if (PlayerHandler.players[j] != null) {
+                                                Client c2 = (Client) PlayerHandler.players[j];
+                                                if (player.playerRights == 1) {
+                                                        c2.getPacketSender().sendMessage("@blu@[Moderator] @bla@" + Misc.optimizeText(player.playerName) + ": " + Misc.optimizeText(String.join(" ", arguments)) + "");
+                                                } else if (player.playerRights == 2) {
+                                                        c2.getPacketSender().sendMessage("@gre@[Administator] @bla@" + Misc.optimizeText(player.playerName) + ": " + Misc.optimizeText(String.join(" ", arguments)) + "");
+                                                } else if (player.playerRights == 3) {
+                                                        c2.getPacketSender().sendMessage("@red@[Developer] @bla@" + Misc.optimizeText(player.playerName) + ": " + Misc.optimizeText(String.join(" ", arguments)) + "");
+                                                }
+                                        }
+                                }
+                                break;
+
+                        case "mute":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify a player name: ::mute playername");
+                                                return;
+                                        }
+                                        String playerToBan = String.join(" ", arguments);
+                                        Connection.addNameToMuteList(playerToBan);
+                                        for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                                                if (PlayerHandler.players[i] != null) {
+                                                        if (PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                                                Client c2 = (Client) PlayerHandler.players[i];
+                                                                c2.getPacketSender().sendMessage("You have been muted by: " + player.playerName);
+                                                                break;
+                                                        }
+                                                }
+                                        }
+                                } catch (Exception e) {
+                                        player.getPacketSender().sendMessage("Player Must Be Offline.");
+                                }
+                                break;
+
+                        case "ipmute":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify a player name: ::ipmute playername");
+                                                return;
+                                        }
+                                        String playerToBan = String.join(" ", arguments);
+                                        for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                                                if (PlayerHandler.players[i] != null) {
+                                                        if (PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                                                Connection.addIpToMuteList(PlayerHandler.players[i].connectedFrom);
+                                                                player.getPacketSender().sendMessage("You have IP Muted the user: " + PlayerHandler.players[i].playerName);
+                                                                Client c2 = (Client) PlayerHandler.players[i];
+                                                                c2.getPacketSender().sendMessage("You have been muted by: " + player.playerName);
+                                                                break;
+                                                        }
+                                                }
+                                        }
+                                } catch (Exception e) {
+                                        player.getPacketSender().sendMessage("Player Must Be Offline.");
+                                }
+                                break;
+
+                        case "unipmute":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify a player name: ::unipmute playername");
+                                                return;
+                                        }
+                                        String playerToBan = String.join(" ", arguments);
+                                        for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                                                if (PlayerHandler.players[i] != null) {
+                                                        if (PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                                                Connection.unIPMuteUser(PlayerHandler.players[i].connectedFrom);
+                                                                player.getPacketSender().sendMessage("You have Un Ip-Muted the user: " + PlayerHandler.players[i].playerName);
+                                                                break;
+                                                        }
+                                                }
+                                        }
+                                } catch (Exception e) {
+                                        player.getPacketSender().sendMessage("Player Must Be Offline.");
+                                }
+                                break;
+
+                        case "unmute":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify a player name: ::unmute playername");
+                                                return;
+                                        }
+                                        String playerToBan = String.join(" ", arguments);
+                                        Connection.unMuteUser(playerToBan);
+                                } catch (Exception e) {
+                                        player.getPacketSender().sendMessage("Player Must Be Offline.");
+                                }
+                                break;
+                        case "update":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify the amount of time in seconds: ::update 300");
+                                                return;
+                                        }
+                                        int seconds = Integer.parseInt(arguments[0]);
+                                        PlayerHandler.updateSeconds = seconds;
+                                        PlayerHandler.updateAnnounced = false;
+                                        PlayerHandler.updateRunning = true;
+                                        PlayerHandler.updateStartTime = System.currentTimeMillis();
+                                } catch (Exception e) {}
+                                break;
+                }
+        }
+
+        public static void adminCommands(Player player, String playerCommand, String[] arguments) {
+                switch (playerCommand.toLowerCase()) {
+                        case "clearbank":
+                                player.getItemAssistant().clearBank();
+                                break;
+                        case "ipban":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify a player name: ::ipban playername");
+                                                return;
+                                        }
+                                        String playerToBan = String.join(" ", arguments);
+                                        for(int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                                                if(PlayerHandler.players[i] != null) {
+                                                        if(PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                                                Connection.addIpToBanList(PlayerHandler.players[i].connectedFrom);
+                                                                Connection.addIpToFile(PlayerHandler.players[i].connectedFrom);
+                                                                player.getPacketSender().sendMessage("You have IP banned the user: "+PlayerHandler.players[i].playerName+" with the host: "+PlayerHandler.players[i].connectedFrom);
+                                                                PlayerHandler.players[i].disconnected = true;
+                                                        }
+                                                }
+                                        }
+                                } catch(Exception e) {
+                                        player.getPacketSender().sendMessage("Player Must Be Offline.");
+                                }
+                                break;
+                        case "ban":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify a player name: ::ban playername");
+                                                return;
+                                        }
+                                        String playerToBan = String.join(" ", arguments);
+                                        Connection.addNameToBanList(playerToBan);
+                                        Connection.addNameToFile(playerToBan);
+                                        for(int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                                                if(PlayerHandler.players[i] != null) {
+                                                        if(PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                                                PlayerHandler.players[i].disconnected = true;
+                                                        }
+                                                }
+                                        }
+                                } catch(Exception e) {
+                                        player.getPacketSender().sendMessage("Player Must Be Offline.");
+                                }
+                                break;
+                        case "unban":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify a player name: ::unban playername");
+                                                return;
+                                        }
+                                        String playerToBan = String.join(" ", arguments);
+                                        Connection.removeNameFromBanList(playerToBan);
+                                        player.getPacketSender().sendMessage(playerToBan + " has been unbanned.");
+                                } catch(Exception e) {
+                                        player.getPacketSender().sendMessage("Player Must Be Offline.");
+                                }
+                                break;
+                        case "empty":
+                                player.getPlayerAssistant().handleEmpty();
+                                break;
+                        case "dialogue":
+                                if (arguments.length == 0) {
+                                        player.getPacketSender().sendMessage("You must specify an id: ::dialogue id");
+                                        return;
+                                }
+                                int npcType = 1552;
+                                int dialogueID = Integer.parseInt(arguments[0]);
+                                player.getDialogueHandler().sendDialogues(dialogueID, npcType);
+                                break;
+                        case "interface":
+                                if (arguments.length == 0) {
+                                        player.getPacketSender().sendMessage("You must specify an id: ::interface id");
+                                        return;
+                                }
+                                int interfaceID = Integer.parseInt(arguments[0]);
+                                player.getPacketSender().showInterface(interfaceID);
+                                break;
+                        case "gfx":
+                                if (arguments.length == 0) {
+                                        player.getPacketSender().sendMessage("You must specify an id: ::gfx id");
+                                        return;
+                                }
+                                int gfxID = Integer.parseInt(arguments[0]);
+                                player.gfx0(gfxID);
+                                break;
+                        case "anim":
+                                if (arguments.length == 0) {
+                                        player.getPacketSender().sendMessage("You must specify an id: ::anim id");
+                                        return;
+                                }
+                                int animationID = Integer.parseInt(arguments[0]);
+                                player.startAnimation(animationID);
+                                player.getPlayerAssistant().requestUpdates();
+                                break;
+                        case "mypos":
+                                player.getPacketSender().sendMessage("X: " + player.absX);
+                                player.getPacketSender().sendMessage("Y: " + player.absY);
+                                player.getPacketSender().sendMessage("H: " + player.heightLevel);
+                                break;
+                        case "bank":
+                                player.getPacketSender().openUpBank();
+                                break;
+                        case "xteletome":
+                        case "teletome":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify a player name: ::teletome playername");
+                                                return;
+                                        }
+                                        String teleToMe = String.join(" ", arguments);
+                                        for (int i = 0; i < PlayerHandler.players.length; i++) {
+                                                if (PlayerHandler.players[i] != null) {
+                                                        if (PlayerHandler.players[i].playerName.equalsIgnoreCase(teleToMe)) {
+                                                                Client p = (Client) PlayerHandler.players[i];
+                                                                player.getPacketSender().sendMessage(p.playerName + " has been teleported to you.");
+                                                                p.getPlayerAssistant().movePlayer(player.absX, player.absY, player.heightLevel);
+                                                        }
+                                                }
+                                        }
+                                } catch (Exception e) {
+                                        player.getPacketSender().sendMessage("Player is not online.");
+                                }
+                                break;
+                        case "xteleto":
+                        case "teleto":
+                                if (arguments.length == 0) {
+                                        player.getPacketSender().sendMessage("You must specify a player name: ::teleto playername");
+                                        return;
+                                }
+                                String teleTo = String.join(" ", arguments);
+                                for (int i = 0; i < PlayerHandler.players.length; i++) {
+                                        if (PlayerHandler.players[i] != null) {
+                                                if (PlayerHandler.players[i].playerName.equalsIgnoreCase(teleTo)) {
+                                                        player.getPlayerAssistant().movePlayer(PlayerHandler.players[i].getX(), PlayerHandler.players[i].getY(), PlayerHandler.players[i].heightLevel);
+                                                        return;
+                                                }
+                                        }
+                                }
+                                player.getPacketSender().sendMessage("Could not find " + teleTo + " they must be online!");
+                                break;
+                        case "tp":
+                        case "teleport":
+                        case "to":
+                                if (arguments.length <= 2)
+                                        player.getPlayerAssistant().movePlayer(Integer.parseInt(arguments[0]), Integer.parseInt(arguments[1]), 0);
+                                else
+                                        player.getPlayerAssistant().movePlayer(Integer.parseInt(arguments[0]), Integer.parseInt(arguments[1]), Integer.parseInt(arguments[2]));
+                                break;
+                        case "up":
+                                player.getPlayerAssistant().movePlayer(player.absX, player.absY, player.heightLevel + 1);
+                                player.getPacketSender().sendMessage("You are now on height level " + player.heightLevel + ".");
+                                break;
+                        case "up2":
+                                player.getPlayerAssistant().movePlayer(player.absX, player.absY - 6400, player.heightLevel);
+                                player.getPacketSender().sendMessage("You are now on height level " + player.heightLevel + ".");
+                                break;
+                        case "down":
+                                player.getPlayerAssistant().movePlayer(player.absX, player.absY, player.heightLevel - 1);
+                                player.getPacketSender().sendMessage("You are now on height level " + player.heightLevel + ".");
+                                break;
+                        case "down2":
+                                player.getPlayerAssistant().movePlayer(player.absX, player.absY + 6400, player.heightLevel);
+                                player.getPacketSender().sendMessage("You are now on height level " + player.heightLevel + ".");
+                                break;
+                        case "spec":
+                                player.specAmount = 100.0;
+                                break;
+                        case "setlevel":
+                                try {
+                                        if (arguments.length < 2) {
+                                                player.getPacketSender().sendMessage("Must specify a skill and level: ::setlevel 1 99");
+                                                return;
+                                        }
+                                        int skill = Integer.parseInt(arguments[0]);
+                                        int level = Integer.parseInt(arguments[1]);
+                                        if (level > 99) {
+                                                level = 99;
+                                        } else if (level < 0) {
+                                                level = 1;
+                                        }
+                                        player.playerXP[skill] = player.getPlayerAssistant().getXPForLevel(level) + 5;
+                                        player.playerLevel[skill] = player.getPlayerAssistant().getLevelForXP(player.playerXP[skill]);
+                                        player.getPlayerAssistant().refreshSkill(skill);
+                                        player.getPlayerAssistant().levelUp(skill);
+                                } catch (Exception e) {}
+                                break;
+                        case "spellbook":
+                                if (player.inWild()) {
+                                        return;
+                                }
+                                if (player.playerMagicBook == 0) {
+                                        player.playerMagicBook = 1;
+                                        player.getPacketSender().setSidebarInterface(6, 12855);
+                                        player.getPacketSender().sendMessage("An ancient wisdomin fills your mind.");
+                                        player.getPlayerAssistant().resetAutocast();
+                                } else if (player.playerMagicBook == 1) {
+                                        player.getPacketSender().setSidebarInterface(6, 1151); // modern
+                                        player.playerMagicBook = 0;
+                                        player.getPacketSender().sendMessage("You feel a drain on your memory.");
+                                        player.autocastId = -1;
+                                        player.getPlayerAssistant().resetAutocast();
+                                }
+                                break;
+                        case "item":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("Must specify an item id: ::item 995 1000");
+                                                return;
+                                        }
+                                        int newItemID = Integer.parseInt(arguments[0]);
+                                        int newItemAmount = arguments.length >= 2 ? Integer.parseInt(arguments[1]) : 1;
+                                        if (newItemID <= 10000 && newItemID >= 0) {
+                                                player.getItemAssistant().addItem(newItemID, newItemAmount);
+                                                if (player.isBusy()) {
+                                                        player.getPacketSender().closeAllWindows();
+                                                }
+                                                player.getPacketSender().sendMessage("You spawn " + newItemAmount + " × "+ ItemAssistant.getItemName(newItemID) + ".");
+                                        } else {
+                                                player.getPacketSender().sendMessage("No such item.");
+                                        }
+                                } catch (Exception e) {}
+                                break;
+                        case "master":
+                                for (int i = 0; i < 25; i++) {
+                                        player.playerLevel[i] = 99;
+                                        player.playerXP[i] = player.getPlayerAssistant().getXPForLevel(100);
+                                        player.getPlayerAssistant().refreshSkill(i);
+                                }
+                                player.getPlayerAssistant().requestUpdates();
+                                break;
+                }
+        }
+
+        public static void developerCommands(Player player, String playerCommand, String[] arguments) {
+                switch (playerCommand.toLowerCase()) {
+                        case "clicktotele":
+                        case "ctt": // alias
+                                player.clickToTele = !player.clickToTele;
+                                player.getPacketSender().sendMessage("Click to teleport: " + (player.clickToTele ? "Enabled" : "Disabled"));
+                                break;
+                        case "giveadmin":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify a player name: ::giveadmin playername");
+                                                return;
+                                        }
+                                        String playerToAdmin = String.join(" ", arguments);
+                                        for(int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                                                if(PlayerHandler.players[i] != null) {
+                                                        if(PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToAdmin)) {
+                                                                Client c2 = (Client)PlayerHandler.players[i];
+                                                                player.getPacketSender().sendMessage("You have given " + playerToAdmin + " admin.");
+                                                                c2.playerRights = 2;
+                                                                c2.logout(true);
+                                                                break;
+                                                        }
+                                                }
+                                        }
+                                } catch(Exception e) {
+                                        player.getPacketSender().sendMessage("Player Must Be Offline.");
+                                }
+                                break;
+                        case "demote":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify a player name: ::demote playername");
+                                                return;
+                                        }
+                                        String playerToAdmin = String.join(" ", arguments);
+                                        for(int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                                                if(PlayerHandler.players[i] != null) {
+                                                        if(PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToAdmin)) {
+                                                                Client c2 = (Client)PlayerHandler.players[i];
+                                                                player.getPacketSender().sendMessage("You have demoted " + playerToAdmin + ".");
+                                                                c2.playerRights = 0;
+                                                                c2.logout(true);
+                                                                break;
+                                                        }
+                                                }
+                                        }
+                                } catch(Exception e) {
+                                        player.getPacketSender().sendMessage("Player Must Be Offline.");
+                                }
+                                break;
+                        case "givemod":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify a player name: ::givemod playername");
+                                                return;
+                                        }
+                                        String playerToMod = String.join(" ", arguments);
+                                        for(int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                                                if(PlayerHandler.players[i] != null) {
+                                                        if(PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToMod)) {
+                                                                Client c2 = (Client)PlayerHandler.players[i];
+                                                                player.getPacketSender().sendMessage("You have given " + playerToMod + " mod.");
+                                                                c2.playerRights = 1;
+                                                                c2.logout(true);
+                                                                break;
+                                                        }
+                                                }
+                                        }
+                                } catch(Exception e) {
+                                        player.getPacketSender().sendMessage("Player Must Be Offline.");
+                                }
+                                break;
+                        case "object":
+                                if (arguments.length == 0) {
+                                        player.getPacketSender().sendMessage("You must specify an ID: ::object 1000");
+                                        return;
+                                }
+                                player.getPacketSender().object(Integer.parseInt(arguments[0]), player.absX, player.absY, player.heightLevel, 0, 10);
+                                Region.addObject(Integer.parseInt(arguments[0]), player.absX, player.absY, player.heightLevel, 10, 0, false);
+                                break;
+                        case "object2":
+                                if (arguments.length == 0) {
+                                        player.getPacketSender().sendMessage("You must specify an ID: ::object2 1000");
+                                        return;
+                                }
+                                player.getPacketSender().object(Integer.parseInt(arguments[0]), player.absX, player.absY, player.heightLevel, 0, 0);
+                                Region.addObject(Integer.parseInt(arguments[0]), player.absX, player.absY, player.heightLevel, 0, 0, false);
+                                break;
+                        case "npc":
+                                try {
+                                        if (arguments.length == 0) {
+                                                player.getPacketSender().sendMessage("You must specify an ID: ::npc 1000");
+                                                return;
+                                        }
+                                        int newNPC = Integer.parseInt(arguments[0]),
+                                                maxHit = NpcHandler.getNpcListCombat(newNPC) / 10,
+                                                attack = NpcHandler.getNpcListCombat(newNPC),
+                                                defence = NpcHandler.getNpcListCombat(newNPC);
+                                        boolean attackPlayer = NpcHandler.getNpcListCombat(newNPC) > 0;
+                                        if (newNPC > 0) {
+                                                NpcHandler.spawnNpc(player, newNPC, player.absX, player.absY, player.heightLevel, 0, NpcHandler.getNpcListHP(newNPC), maxHit, attack, defence, attackPlayer, false);
+                                                player.getPacketSender().sendMessage("You spawn a " + NpcHandler.getNpcListName(newNPC).toLowerCase() + ".");
+                                                //player.npcSpawned = newNPC;
+                                        } else {
+                                                player.getPacketSender().sendMessage("Npc " + newNPC + " does not exist.");
+                                        }
+                                } catch (Exception e) {}
+                                break;
+                        case "cantattack":
+                                player.npcCanAttack = !player.npcCanAttack;
+                                player.getPacketSender().sendMessage("Npcs " + (player.npcCanAttack ? "can" : "can no longer") + " attack you.");
+                                break;
+                        case "sound":
+                                if (arguments.length == 0) {
+                                        player.getPacketSender().sendMessage("You must specify an ID: ::sound 10");
+                                        return;
+                                }
+                                player.getPacketSender().sendSound(Integer.parseInt(arguments[0]), 100, 0);
+                                break;
+                        case "tutprog":
+                                if (arguments.length == 0) {
+                                        player.getPacketSender().sendMessage("You must specify an ID: ::tutprog 10");
+                                        return;
+                                }
+                                player.tutorialProgress = Integer.parseInt(arguments[0]);;
+                                break;
+                        case "song":
+                                if (arguments.length == 0) {
+                                        player.getPacketSender().sendMessage("You must specify an ID: ::song 10");
+                                        return;
+                                }
+                                int songID = Integer.parseInt(arguments[0]);
+                                player.getPacketSender().sendSong(songID);
+                                break;
+                        case "run":
+                                player.getPacketSender().sendMessage("You have refilled your run-energy!");
+                                player.playerEnergy = 100;
+                                break;
+                        case "runes":
+                                final int amount = 10000;
+                                final int[][] RUNES = { { 554, amount }, { 555, amount },
+                                        { 556, amount }, { 557, amount }, { 558, amount },
+                                        { 559, amount }, { 560, amount }, { 561, amount },
+                                        { 562, amount }, { 563, amount }, { 564, amount },
+                                        { 565, amount }, { 566, amount }, { 1963, 1 }, };
+                                for (int[] element : RUNES) {
+                                        int item = element[0];
+                                        int amountToRecieve = element[1];
+                                        player.getItemAssistant().addItem(item, amountToRecieve);
+                                }
+                                break;
+                        case "sidebars":
+                                player.getPlayerAssistant().sendSidebars();
+                                break;
+                }
+        }
+
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/DropItem.java

@@ -0,0 +1,364 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.GameConstants;
+import com.rebotted.GameEngine;
+import com.rebotted.game.content.minigames.castlewars.CastleWars;
+import com.rebotted.game.content.music.sound.SoundList;
+import com.rebotted.game.content.skills.SkillHandler;
+import com.rebotted.game.content.skills.firemaking.Firemaking;
+import com.rebotted.game.content.skills.firemaking.LogData;
+import com.rebotted.game.items.impl.RareProtection;
+import com.rebotted.game.npcs.impl.Pets;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Drop Item
+ **/
+public class DropItem implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		int itemId = player.getInStream().readUnsignedWordA();
+		player.getInStream().readUnsignedByte();
+		player.getInStream().readUnsignedByte();
+		int slot = player.getInStream().readUnsignedWordA();
+		if (!player.getItemAssistant().playerHasItem(itemId) || !RareProtection.doOtherDupe(player, itemId) || System.currentTimeMillis() - player.alchDelay < 1800 || player.stopPlayerPacket || System.currentTimeMillis() - player.buryDelay < 1800 || !CastleWars.deleteCastleWarsItems(player, itemId)) {
+			return;
+		}
+		for (LogData logData : LogData.values()) {
+			if (itemId == logData.getLogId()) {
+				Firemaking.pickedUpFiremakingLog = false;
+			}
+		}
+		for (LogData logData : LogData.values()) {
+			if (itemId == logData.getLogId()) {
+				if (GameEngine.objectManager.objectExists(player.absX, player.absY)) {
+					player.getPacketSender().sendMessage(
+							"You cannot drop a log here.");
+					return;
+				}
+			}
+		}
+		if (player.duelingArena()) {
+			player.getPacketSender().sendMessage(
+					"You can't drop items inside the arena!");
+			return;
+		}
+		if (player.inTrade) {
+			player.getPacketSender().sendMessage(
+					"You can't drop items while trading!");
+			return;
+		}
+		if (player.hasNpc == true) {
+			player.getPacketSender().sendMessage(
+					"You already have a pet dropped.");
+			return;
+		}
+		SkillHandler.resetSkills(player);
+		if (player.tutorialProgress < 36 && GameConstants.TUTORIAL_ISLAND) {
+			player.getPacketSender().sendMessage(
+					"You can't drop items on tutorial island!");
+			return;
+		}
+
+		player.endCurrentTask();
+
+		switch (itemId) {
+		case 1560:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage("You drop your Kitten.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Kitten.");
+			}
+			break;
+		case 1559:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage("You drop your Kitten.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Kitten.");
+			}
+			break;
+		case 1558:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage("You drop your Kitten.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Kitten.");
+			}
+			break;
+		case 1557:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage("You drop your Kitten.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Kitten.");
+			}
+			break;
+		case 1556:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage("You drop your Kitten.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Kitten.");
+			}
+			break;
+		case 1555:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage("You drop your Kitten.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Kitten.");
+			}
+			break;
+		case 1561:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage("You drop your Cat.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Cat.");
+			}
+			break;
+		case 1562:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage("You drop your Cat.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Cat.");
+			}
+			break;
+		case 1563:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage("You drop your Cat.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Cat.");
+			}
+			break;
+		case 1564:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage("You drop your Cat.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Cat.");
+			}
+			break;
+		case 1565:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage("You drop your Cat.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Cat.");
+			}
+			break;
+		case 7583:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage(
+						"You drop your Hell Kitten.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Hell Kitten.");
+			}
+			break;
+		case 1566:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage("You drop your Cat.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Cat.");
+			}
+			break;
+		case 7585:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage(
+						"You drop your Hell Kitten.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Hell Kitten.");
+			}
+			break;
+		case 4045:
+			if (CastleWars.isInCw(player)) {
+				int explosiveHit = 15;
+				player.startAnimation(827);
+				player.getItemAssistant().deleteItem(itemId, slot, player.playerItemsN[slot]);
+				player.handleHitMask(explosiveHit);
+				player.dealDamage(explosiveHit);
+				player.getPlayerAssistant().refreshSkill(3);
+				player.forcedText = "Ow! That really hurt!";
+				player.forcedChatUpdateRequired = true;
+				player.updateRequired = true;
+			} else {
+				player.getItemAssistant().deleteItem(4045, player.getItemAssistant().getItemAmount(4045));
+				player.getItemAssistant().deleteItem(4046, player.getItemAssistant().getItemAmount(4046));
+				player.getPacketSender().sendMessage("You can't do that! Your not in castle wars!");
+			}
+			break;
+		case 7584:
+			if (!player.hasNpc) {
+				GameEngine.npcHandler.spawnNpc3(player, Pets.summonItemId(itemId),
+						player.absX, player.absY - 1, player.heightLevel, 0, 120, 25, 200,
+						200, false, false, true);
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				player.hasNpc = true;
+				player.getPlayerAssistant().followPlayer();
+				player.getPacketSender().sendMessage(
+						"You drop your Hell Kitten.");
+			} else {
+				player.getPacketSender().sendMessage(
+						"You already dropped your Hell Kitten.");
+			}
+			break;
+		}
+
+		boolean droppable = true;
+		/*for (int i : Constants.UNDROPPABLE_ITEMS) {
+			if (i == itemId) {
+				droppable = false;
+				break;
+			}
+		}*/
+
+		for (int p : Pets.CAT_ITEMS) {
+			if (p == itemId) {
+				if (player.hasNpc == true) {
+					droppable = false;
+					break;
+				}
+			}
+		}
+
+		if (player.playerItemsN[slot] != 0 && itemId != -1
+				&& player.playerItems[slot] == itemId + 1) {
+			if (droppable) {
+				for (int i = 0; i < GameConstants.DESTROYABLE_ITEMS.length; i++) { 
+					if (itemId == GameConstants.DESTROYABLE_ITEMS[i]) {
+						player.droppedItem = itemId;
+						player.getItemAssistant().destroyInterface(itemId);
+						return;
+					}
+				}
+				if (player.underAttackBy > 0) {
+					if (player.getShopAssistant().getItemShopValue(itemId) > 1000) {
+						player.getPacketSender()
+								.sendMessage(
+										"You may not drop items worth more than 1000 while in combat.");
+						return;
+					}
+				}
+				GameEngine.itemHandler.createGroundItem(player, itemId, player.getX(),
+						player.getY(), player.playerItemsN[slot], player.getId());
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				if (GameConstants.SOUND) {
+					player.getPacketSender().sendSound(SoundList.ITEM_DROP, 100,
+							0);
+				}
+			} else {
+				player.getPacketSender().sendMessage(
+						"This items cannot be dropped.");
+			}
+		}
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/FollowPlayer.java

@@ -0,0 +1,24 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+import com.rebotted.net.packets.PacketType;
+
+public class FollowPlayer implements PacketType {
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+		int followPlayer = c.getInStream().readUnsignedWordBigEndian();
+		if (PlayerHandler.players[followPlayer] == null) {
+			return;
+		}
+		c.playerIndex = 0;
+		c.npcIndex = 0;
+		c.mageFollow = false;
+		c.usingBow = false;
+		c.usingRangeWeapon = false;
+		c.followDistance = 1;
+		c.followId = followPlayer;
+		c.endCurrentTask();
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/IdleLogout.java

@@ -0,0 +1,19 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * @author Andrew (Mr Extremez)
+ */
+
+public class IdleLogout implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		if (player.underAttackBy > 0 || player.underAttackBy2 > 0 || player.isBot) {
+			return;
+		}
+		player.logout();
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ItemClick2.java

@@ -0,0 +1,34 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.items.impl.HandleEmpty;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Item Click 2 Or Alternative Item Option 1
+ * @author Ryan / Lmctruck30 Proper Streams
+ */
+
+public class ItemClick2 implements PacketType {
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+		int itemId = c.getInStream().readSignedWordA();
+
+		if (!c.getItemAssistant().playerHasItem(itemId, 1)) {
+			return;
+		}
+
+		c.endCurrentTask();
+
+		if (HandleEmpty.canEmpty(c, itemId)) {
+			HandleEmpty.handleEmptyItem(c, itemId, HandleEmpty.filledToEmpty(c, itemId));
+			return;
+		}
+
+		switch (itemId) {
+		}
+
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ItemClick2OnGroundItem.java

@@ -0,0 +1,28 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.content.skills.firemaking.Firemaking;
+import com.rebotted.game.content.skills.firemaking.LogData;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+public class ItemClick2OnGroundItem implements PacketType {
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+		final int itemX = c.getInStream().readSignedWordBigEndian();
+		final int itemY = c.getInStream().readSignedWordBigEndianA();
+		final int itemId = c.getInStream().readUnsignedWordA();
+		System.out.println("ItemClick2OnGroundItem - " + c.playerName + " - " + itemId + " - " + itemX + " - " + itemY);
+		if (c.absX != itemX || c.absY != itemY) {
+			c.getPacketSender().sendMessage("You can't do that there!");
+			return;
+		}
+		c.endCurrentTask();
+		for (LogData l : LogData.values()) {
+			if (itemId == l.getLogId()) {
+				Firemaking.attemptFire(c, 590, itemId, itemX, itemY, true);
+				return;
+			}
+		}
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ItemClick3.java

@@ -0,0 +1,90 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.items.impl.HandleEmpty;
+import com.rebotted.game.items.impl.Teles;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+import com.rebotted.util.Misc;
+
+/**
+ * Item Click 3 Or Alternative Item Option 1
+ * 
+ * @author Ryan / Lmctruck30 Proper Streams
+ */
+
+public class ItemClick3 implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		int itemId11 = player.getInStream().readSignedWordBigEndianA();
+		int itemId1 = player.getInStream().readSignedWordA();
+		int itemId = player.getInStream().readSignedWordA();
+		if (!player.getItemAssistant().playerHasItem(itemId, 1)) {
+			return;
+		}
+		if (HandleEmpty.canEmpty(player, itemId)) {
+			HandleEmpty.handleEmptyItem(player, itemId, HandleEmpty.filledToEmpty(player, itemId));
+			return;
+		}
+		if (player.duelStatus > 0 && player.duelStatus < 5 || player.tradeStatus == 1) {
+			return;
+		}
+
+		player.endCurrentTask();
+
+		switch (itemId) {
+
+		case 2552:
+		case 2554:
+		case 2556:
+		case 2558:
+		case 2560:
+		case 2562:
+		case 2564:
+		case 2566:
+			player.itemUsing = itemId;
+			Teles.useROD(player);
+			break;
+
+		case 1712:
+		case 1710:
+		case 1708:
+		case 1706:
+			player.itemUsing = itemId;
+			Teles.useAOG(player);
+			break;
+
+		case 3853:
+		case 3855:
+		case 3857:
+		case 3859:
+		case 3861:
+		case 3863:
+		case 3865:
+		case 3867:
+			player.itemUsing = itemId;
+			Teles.useGN(player);
+			break;
+			
+		case 1933:
+			player.getItemAssistant().deleteItem(1933, 1);
+			player.getItemAssistant().addItem(1931, 1);
+		break;
+		
+		case 1921:
+			player.getItemAssistant().deleteItem(1921, 1);
+			player.getItemAssistant().addItem(1923, 1);
+		break;
+
+		default:
+
+			if (player.playerRights == 3) {
+				Misc.println(player.playerName + " - Item3rdOption: " + itemId
+						+ " : " + itemId11 + " : " + itemId1);
+			}
+			break;
+		}
+
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ItemOnGroundItem.java

@@ -0,0 +1,46 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.GameEngine;
+import com.rebotted.game.content.skills.firemaking.Firemaking;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+import com.rebotted.util.Misc;
+
+public class ItemOnGroundItem implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		player.getInStream().readSignedWordBigEndian();
+		int itemUsed = player.getInStream().readSignedWordA();
+		int groundItem = player.getInStream().readUnsignedWord();
+		int gItemY = player.getInStream().readSignedWordA();
+		int itemUsedSlot = player.getInStream().readSignedWordBigEndianA();
+		int gItemX = player.getInStream().readUnsignedWord();
+		if (!player.getItemAssistant().playerHasItem(itemUsed, 1, itemUsedSlot)) {
+			return;
+		}
+		if (!GameEngine.itemHandler.itemExists(groundItem, gItemX, gItemY)) {
+			return;
+		}
+
+		player.endCurrentTask();
+
+		switch (itemUsed) {
+		case 590:
+		case 7331:
+		case 7330:
+		case 7329:
+			Firemaking.attemptFire(player, itemUsed, groundItem, gItemX, gItemY,
+					true);
+			break;
+
+		default:
+			if (player.playerRights == 3) {
+				Misc.println("ItemUsed " + itemUsed + " on Ground Item "
+						+ groundItem);
+			}
+			break;
+		}
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ItemOnItem.java

@@ -0,0 +1,22 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.items.UseItem;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+public class ItemOnItem implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		int usedWithSlot = player.getInStream().readUnsignedWord();
+		int itemUsedSlot = player.getInStream().readUnsignedWordA();
+		int useWith = player.playerItems[usedWithSlot] - 1;
+		int itemUsed = player.playerItems[itemUsedSlot] - 1;
+		if (!player.getItemAssistant().playerHasItem(useWith, 1, usedWithSlot)|| !player.getItemAssistant().playerHasItem(itemUsed, 1, itemUsedSlot)) {
+			return;
+		}
+		player.endCurrentTask();
+		UseItem.ItemonItem(player, itemUsed, useWith);
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ItemOnNpc.java

@@ -0,0 +1,58 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.content.skills.SkillHandler;
+import com.rebotted.game.items.UseItem;
+import com.rebotted.game.npcs.NpcHandler;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+public class ItemOnNpc implements PacketType {
+
+	@Override
+	public void processPacket(final Player player, int packetType, int packetSize) {
+		final int itemId = player.getInStream().readSignedWordA();
+		final int i = player.getInStream().readSignedWordA();
+		final int slot = player.getInStream().readSignedWordBigEndian();
+		final int npcId = NpcHandler.npcs[i].npcType;
+		SkillHandler.resetItemOnNpc(player);
+		player.endCurrentTask();
+		if (player.playerRights == 3) {
+			player.getPacketSender().sendMessage("Item id: " + itemId + " slot: " + slot + " i: " + i);
+		}
+		if (player.getItemAssistant().freeSlots() < 1) {
+			player.getPacketSender().sendMessage("Your inventory is full.");
+			return;
+		}
+		if (player == null || player.disconnected == true || !player.getItemAssistant().playerHasItem(itemId, 1, slot) || NpcHandler.npcs[i] == null || NpcHandler.npcs[i].isDead || player.isDead || player.isTeleporting) {
+			return;
+		}
+		player.faceNpc(i);
+		switch(npcId) {
+			case 43:
+				if (NpcHandler.npcs[i].requestTransformTime(player, 1735, 893, 43, 42, 50, i)) {
+					player.getItemAssistant().addItem(1737, 1);
+				} else {
+					player.getPacketSender().sendMessage("You need to wait for this sheep's wool to regrow!");
+				}
+			break;
+		}
+		if (player.getItemAssistant().playerHasItem(995, 1) && npcId == 736) {
+			player.getItemAssistant().deleteItem(995, 1);
+			player.getDialogueHandler().sendNpcChat1("Thanks!", player.npcType, "Emily");
+		}
+		if (player.getItemAssistant().playerHasItem(1927, 1) && player.gertCat == 2 && npcId == 2997) {
+			player.getDialogueHandler().sendDialogues(319, npcId);
+			player.getItemAssistant().deleteItem(1927, 1);
+			player.getItemAssistant().addItem(1925, 1);
+			player.gertCat = 3;
+		} else if (player.getItemAssistant().playerHasItem(1552, 1) && player.gertCat == 3 && npcId == 2997) {
+			player.getDialogueHandler().sendDialogues(323, npcId);
+			player.getItemAssistant().deleteItem(1552, 1);
+			player.gertCat = 4;
+		} else if (player.getItemAssistant().playerHasItem(1554, 1) && player.gertCat == 5 && npcId == 2997) {
+			player.getItemAssistant().deleteItem(1554, 1);
+			player.getDialogueHandler().sendDialogues(326, npcId);
+		}
+		UseItem.itemOnNpc(player, itemId, slot, i);
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ItemOnObject.java

@@ -0,0 +1,218 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.content.skills.cooking.Cooking;
+import com.rebotted.game.content.skills.cooking.CookingTutorialIsland;
+import com.rebotted.game.content.skills.crafting.JewelryMaking;
+import com.rebotted.game.content.skills.crafting.Pottery;
+import com.rebotted.game.content.skills.crafting.Spinning;
+import com.rebotted.game.items.UseItem;
+import com.rebotted.game.items.impl.Fillables;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+import com.rebotted.world.clip.Region;
+
+public class ItemOnObject implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		player.getInStream().readUnsignedWord();
+		int objectId = player.getInStream().readSignedWordBigEndian();
+		int objectY = player.getInStream().readSignedWordBigEndianA();
+		player.getInStream().readUnsignedWord();
+		int objectX = player.getInStream().readSignedWordBigEndianA();
+		int itemId = player.getInStream().readUnsignedWord();
+		player.turnPlayerTo(objectX, objectY);
+		player.objectX = objectX;
+		player.objectY = objectY;
+		player.endCurrentTask();
+		if (!player.getItemAssistant().playerHasItem(itemId, 1)) {
+			return;
+		}
+		if (player.playerRights == 3) {
+			player.getPacketSender().sendMessage(
+					"Object Id:" + objectId + " ObjectX: " + objectX
+							+ " ObjectY: " + objectY + ".");
+		}
+		switch (objectId) {
+		case 3044:
+			if (itemId == 438 || itemId == 436) {
+				if (player.getItemAssistant().playerHasItem(438) && player.getItemAssistant().playerHasItem(436)) {
+					if (player.tutorialProgress == 19) {
+						player.startAnimation(899);
+						player.getPacketSender().sendSound(352, 100, 1);
+						player.getPacketSender().sendMessage("You smelt the copper and tin together in the furnace.");
+						player.getItemAssistant().deleteItem(438, 1);
+						player.getItemAssistant().deleteItem(436, 1);
+						player.getPacketSender().sendMessage("You retrieve a bar of bronze.");
+						player.getItemAssistant().addItem(2349, 1);
+						player.getDialogueHandler().sendDialogues(3062, -1);
+					} else if (player.tutorialProgress > 19) {
+						player.startAnimation(899);
+						player.getPacketSender().sendSound(352, 100, 1);
+						player.getPacketSender().sendMessage("You smelt the copper and tin together in the furnace.");
+						player.getItemAssistant().deleteItem(438, 1);
+						player.getItemAssistant().deleteItem(436, 1);
+						player.getPacketSender().sendMessage("You retrieve a bar of bronze.");
+						player.getItemAssistant().addItem(2349, 1);
+					}
+				}
+			}
+		break;
+		case 2645:
+			if (itemId == 1925) {
+				player.getItemAssistant().deleteItem(itemId, 1);
+				player.getItemAssistant().addItem(1783, 1);
+			} else {
+				player.getPacketSender().sendMessage("You need a bucket of sand to do that!");
+			}
+		break;
+		case 12269:
+		case 2732:
+		case 114:
+		case 2727:
+		case 385:
+		case 14919:
+		case 2728:
+		case 9682:
+			if (player.absX == 3014 && player.absY > 3235 && player.absY < 3238
+					|| player.absX == 3012 && player.absY == 3239 || player.absX == 3020
+					&& player.absY > 3236 && player.absY < 3239 || player.absX > 2805
+					&& player.absX < 2813 || player.absY > 3437 && player.absY < 3442) {
+				return;
+			}
+			if (player.tutorialProgress < 36 || player.isInTut()) {
+				CookingTutorialIsland.cookThisFood(player, itemId, objectId);
+			} else {
+				Cooking.startCooking(player, itemId, objectId);
+			}
+			break;
+
+		case 14921:
+		case 9390:
+		case 2781:
+		case 2785:
+		case 2966:
+		case 3294:
+		case 3413:
+		case 4304:
+		case 4305:
+		case 6189:
+		case 6190:
+		case 11009:
+		case 11010:
+		case 11666:
+		case 12100:
+		case 12809:
+		if (itemId == 2357) {
+			JewelryMaking.mouldInterface(player);
+		/*} else if (itemId == SilverCrafting.SILVER_BAR) {
+			Menus.sendSkillMenu(c, "silverCrafting");*/
+		}
+		break;
+
+		case 2452:
+		case 2453:
+		case 2454:
+		case 2455:
+		case 2456:
+		case 2457:
+		case 2458:
+		case 2459:
+		case 2460:
+		case 2461:
+		case 2462:
+			player.getRC().enterAltar(objectId, itemId);
+			break;
+
+		case 3039:// tutorial island need to check if it needs break or not
+			if (player.getItemAssistant().playerHasItem(2307)
+					&& player.tutorialProgress == 8) {
+				player.startAnimation(896);
+				player.getPlayerAssistant().requestUpdates();
+				player.getItemAssistant().deleteItem(2307, 1);
+				player.getItemAssistant().addItem(2309, 1);
+				player.getDialogueHandler().sendDialogues(3037, 0);
+			}
+			break;
+
+		case 10093:
+			if (player.getItemAssistant().playerHasItem(1927, 1)) {
+				player.turnPlayerTo(player.objectX, player.objectY);
+				player.startAnimation(883);
+				player.getItemAssistant().addItem(2130, 1);
+				player.getItemAssistant().deleteItem(1927, 1);
+				player.getPlayerAssistant().addSkillXP(18, player.playerCooking);
+			} else {
+				player.getPacketSender().sendMessage("You need a bucket of milk to do this.");
+			}
+			break;
+		}
+
+		if (itemId == 1710 || itemId == 1708 || itemId == 1706
+				|| itemId == 1704 && objectId == 2638) { // glory
+			int amount = player.getItemAssistant().getItemCount(1710)
+					+ player.getItemAssistant().getItemCount(1708)
+					+ player.getItemAssistant().getItemCount(1706)
+					+ player.getItemAssistant().getItemCount(1704);
+			int[] glories = { 1710, 1708, 1706, 1704 };
+			for (int i : glories) {
+				player.getItemAssistant().deleteItem(i,
+						player.getItemAssistant().getItemCount(i));
+			}
+			player.startAnimation(832);
+			player.getItemAssistant().addItem(1712, amount);
+		}
+
+		if (itemId == 954 && objectId == 3827 && player.rope == false) {
+			player.getPacketSender().object(3828, 3227, 3108, 0, 0, 10);
+			Region.addObject(3828, 3227, 3108, 0, 0, 0, false);
+			player.rope = true;
+		}
+
+		if (itemId == 954 && objectId == 3830 && player.rope2 == false) {
+			player.getPacketSender().object(3828, 3509, 9497, 2, 0, 10);
+			Region.addObject(3828, 3509, 9497, 2, 0, 0, false);
+			player.rope2 = true;
+		}
+
+		if (itemId == 1737 || itemId == 1779 && objectId == 2644) {
+			Spinning.showSpinning(player);
+		}
+
+		if (itemId == 1761 && objectId == 2642) {
+			Pottery.showUnfire(player);
+		}
+
+		if (itemId == 954 && objectId == 2327) {
+			player.getPlayerAssistant().movePlayer(2505, 3087, 0);
+			player.getItemAssistant().deleteItem(954, 1);
+		} else if (objectId == 2327 && itemId != 954) {
+			player.getPacketSender().sendMessage("You need a rope to swing across.");
+		}
+
+		if (objectId == 2327 && player.absX == 2511 && player.absY == 3092) {
+			player.getPlayerAssistant().movePlayer(2510, 3096, 0);
+		}
+
+		/*
+		 * if (itemId == 1779 && objectId == 2644) { int amount =
+		 * (c.getItemAssistant().getItemCount(1777)); int[] spin = {1777}; for
+		 * (int i : spin) { c.getItemAssistant().deleteItem(i,
+		 * c.getItemAssistant().getItemCount(i)); } c.startAnimation(883);
+		 * c.getItemAssistant().addItem(1777, amount); }
+		 */
+
+		if (Fillables.canFill(itemId, objectId) && player.getItemAssistant().playerHasItem(itemId)) {
+			int amount = player.getItemAssistant().getItemCount(itemId);
+			player.getItemAssistant().deleteItem(itemId, amount);
+			player.getItemAssistant().addItem(Fillables.counterpart(itemId), amount);
+			player.getPacketSender().sendMessage(Fillables.fillMessage(itemId, objectId));
+			player.startAnimation(832);
+			return;
+		}
+
+		UseItem.itemOnObject(player, objectId, objectX, objectY, itemId);
+
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ItemOnPlayer.java

@@ -0,0 +1,54 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.items.impl.RareProtection;
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+import com.rebotted.net.packets.PacketType;
+import com.rebotted.util.Misc;
+
+/**
+ * @author JaydenD12/Jaydennn
+ */
+
+public class ItemOnPlayer implements PacketType {
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+		int playerId = c.inStream.readUnsignedWord();
+		int itemId = c.playerItems[c.inStream.readSignedWordBigEndian()] - 1;
+		c.endCurrentTask();
+		switch (itemId) {
+
+		case 962:
+			Player o = (Player) PlayerHandler.players[playerId];
+			if (!RareProtection.CRACKERS && c.playerRights < 3) {
+				int delete = c.getItemAssistant().getItemCount(962);
+				c.getItemAssistant().deleteItem(962, delete);
+				c.getPacketSender().sendMessage("You can't do that!");
+				return;
+			}
+			c.gfx0(176);
+			c.startAnimation(451);
+			c.getPacketSender().sendMessage(
+					"You pull the Christmas Cracker...");
+			o.getPacketSender().sendMessage(
+					"You pull the Christmas Cracker...");
+			c.getItemAssistant().deleteItem(962, 1);
+			if (Misc.random(3) == 1) {
+				o.forcedText = "Yay I got the Cracker!";
+				o.forcedChatUpdateRequired = true;
+				o.getItemAssistant().addItem(1038 + Misc.random(5) * 2, 1);
+			} else {
+				c.forcedText = "Yay I got the Cracker!";
+				c.forcedChatUpdateRequired = true;
+				c.getItemAssistant().addItem(1038 + Misc.random(5) * 2, 1);
+			}
+			c.turnPlayerTo(o.absX, o.absY);
+			break;
+		default:
+			c.getPacketSender().sendMessage("Nothing interesting happens.");
+			break;
+		}
+
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/MagicOnFloorItems.java

@@ -0,0 +1,115 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.GameEngine;
+import com.rebotted.event.CycleEvent;
+import com.rebotted.event.CycleEventContainer;
+import com.rebotted.event.CycleEventHandler;
+import com.rebotted.game.content.combat.magic.MagicData;
+import com.rebotted.game.items.Item;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Magic on floor items
+ **/
+
+public class MagicOnFloorItems implements PacketType {
+
+	@Override
+	public void processPacket(final Player c, int packetType, int packetSize) {
+		final int itemY = c.getInStream().readSignedWordBigEndian();
+		int itemId = c.getInStream().readUnsignedWord();
+		final int itemX = c.getInStream().readSignedWordBigEndian();
+		c.getInStream().readUnsignedWordA();
+
+		if (!GameEngine.itemHandler.itemExists(itemId, itemX, itemY)) {
+			c.stopMovement();
+			return;
+		}
+		c.usingMagic = true;
+		c.endCurrentTask();
+		if (!c.getCombatAssistant().checkMagicReqs(51)) {
+			c.stopMovement();
+			return;
+		}
+
+		if ((c.getItemAssistant().freeSlots() >= 1 || c.getItemAssistant()
+				.playerHasItem(itemId, 1))
+				&& Item.itemStackable[itemId]
+				|| c.getItemAssistant().freeSlots() > 0
+				&& !Item.itemStackable[itemId]) {
+			if (c.goodDistance(c.getX(), c.getY(), itemX, itemY, 12)) {
+				c.walkingToItem = true;
+				int offY = (c.getX() - itemX) * -1;
+				int offX = (c.getY() - itemY) * -1;
+				c.teleGrabX = itemX;
+				c.teleGrabY = itemY;
+				c.teleGrabItem = itemId;
+				c.turnPlayerTo(itemX, itemY);
+				c.teleGrabDelay = System.currentTimeMillis();
+				c.startAnimation(MagicData.MAGIC_SPELLS[51][2]);
+				c.gfx100(MagicData.MAGIC_SPELLS[51][3]);
+				c.getPlayerAssistant().createPlayersStillGfx(144, itemX, itemY,
+						0, 72);
+				c.getPlayerAssistant().createPlayersProjectile(c.getX(),
+						c.getY(), offX, offY, 50, 70,
+						MagicData.MAGIC_SPELLS[51][4], 50, 10, 0, 50);
+				c.getPlayerAssistant().addSkillXP(
+						MagicData.MAGIC_SPELLS[51][7], 6);
+				c.getPlayerAssistant().refreshSkill(6);
+				c.stopMovement();
+				   CycleEventHandler.getSingleton().addEvent(c, new CycleEvent() {
+			            @Override
+			            public void execute(CycleEventContainer container) {
+						if (!c.walkingToItem) {
+							stop();
+						}
+						if (System.currentTimeMillis() - c.teleGrabDelay > 1550
+								&& c.usingMagic) {
+							if (GameEngine.itemHandler.itemExists(c.teleGrabItem,
+									c.teleGrabX, c.teleGrabY)
+									&& c.goodDistance(c.getX(), c.getY(),
+											itemX, itemY, 12)) {
+								GameEngine.itemHandler.removeGroundItem(c,
+										c.teleGrabItem, c.teleGrabX,
+										c.teleGrabY, true);
+								c.usingMagic = false;
+								container.stop();
+							}
+						}
+					}
+
+					@Override
+					public void stop() {
+						c.walkingToItem = false;
+					}
+				}, 1);
+			}
+		} else {
+			c.getPacketSender().sendMessage(
+					"You don't have enough space in your inventory.");
+			c.stopMovement();
+		}
+
+		if (c.goodDistance(c.getX(), c.getY(), itemX, itemY, 12)) {
+			int offY = (c.getX() - itemX) * -1;
+			int offX = (c.getY() - itemY) * -1;
+			c.teleGrabX = itemX;
+			c.teleGrabY = itemY;
+			c.teleGrabItem = itemId;
+			c.turnPlayerTo(itemX, itemY);
+			c.teleGrabDelay = System.currentTimeMillis();
+			c.startAnimation(MagicData.MAGIC_SPELLS[51][2]);
+			c.gfx100(MagicData.MAGIC_SPELLS[51][3]);
+			c.getPlayerAssistant().createPlayersStillGfx(144, itemX, itemY, 0,
+					72);
+			c.getPlayerAssistant().createPlayersProjectile(c.getX(), c.getY(),
+					offX, offY, 50, 70, MagicData.MAGIC_SPELLS[51][4], 50, 10,
+					0, 50);
+			c.getPlayerAssistant().addSkillXP(MagicData.MAGIC_SPELLS[51][7], 6);
+			c.getPlayerAssistant().refreshSkill(6);
+			c.stopMovement();
+		}
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/MagicOnItems.java

@@ -0,0 +1,28 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Magic on items
+ **/
+
+public class MagicOnItems implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		int slot = player.getInStream().readSignedWord();
+		int itemId = player.getInStream().readSignedWordA();
+		player.getInStream().readSignedWord();
+		int spellId = player.getInStream().readSignedWordA();
+		player.endCurrentTask();
+		if(!player.getItemAssistant().playerHasItem(itemId, 1, slot)) {
+			return;
+		}
+		player.usingMagic = true;
+		player.getPlayerAssistant().magicOnItems(slot, itemId, spellId);
+		player.usingMagic = false;
+
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/MoveItems.java

@@ -0,0 +1,33 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Move Items
+ **/
+public class MoveItems implements PacketType {
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+		int interfaceId = c.getInStream().readSignedWordBigEndianA();
+		boolean insertMode = c.getInStream().readSignedByteC() == 1;
+		int from = c.getInStream().readSignedWordBigEndianA();
+		int to = c.getInStream().readSignedWordBigEndian();
+		// c.sendMessage("junk: " + somejunk);
+		if (c.inTrade) {
+			c.getTrading().declineTrade();
+			return;
+		}
+		if (c.tradeStatus == 1) {
+			c.getTrading().declineTrade();
+			return;
+		}
+		if (c.duelStatus == 1) {
+			c.getDueling().declineDuel();
+			return;
+		}
+		c.getItemAssistant().moveItems(from, to, interfaceId, insertMode);
+		c.endCurrentTask();
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/PickupItem.java

@@ -0,0 +1,98 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.GameEngine;
+import com.rebotted.event.CycleEvent;
+import com.rebotted.event.CycleEventContainer;
+import com.rebotted.event.CycleEventHandler;
+import com.rebotted.game.content.minigames.castlewars.CastleWars;
+import com.rebotted.game.content.music.sound.SoundList;
+import com.rebotted.game.content.skills.SkillHandler;
+import com.rebotted.game.content.skills.firemaking.Firemaking;
+import com.rebotted.game.content.skills.firemaking.LogData;
+import com.rebotted.game.items.ItemAssistant;
+import com.rebotted.game.items.impl.RareProtection;
+import com.rebotted.game.players.Client;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+import com.rebotted.util.GameLogger;
+import com.rebotted.world.GlobalDropsHandler;
+
+/**
+ * Pickup Item
+ **/
+public class PickupItem implements PacketType {
+
+
+	@Override
+	public void processPacket(final Player player, int packetType, int packetSize) {
+		player.pItemY = player.getInStream().readSignedWordBigEndian();
+		player.pItemId = player.getInStream().readUnsignedWord();
+		player.pItemX = player.getInStream().readSignedWordBigEndian();
+		if (Math.abs(player.getX() - player.pItemX) > 25 || Math.abs(player.getY() - player.pItemY) > 25) {
+			player.resetWalkingQueue();
+			return;
+		}
+		player.getCombatAssistant().resetPlayerAttack();
+		player.endCurrentTask();
+		if (player.stopPlayerPacket) {
+			return;
+		}
+		String itemName = ItemAssistant.getItemName(player.pItemId).toLowerCase();
+		if (player.getPlayerAssistant().isPlayer()) {
+			GameLogger.writeLog(player.playerName, "pickupitem", player.playerName + " picked up " + itemName + " itemX: " + player.pItemX + ", itemY: " + player.pItemY + "");
+		}
+		if (!CastleWars.deleteCastleWarsItems(player, player.pItemId)) {
+			return;
+		}
+		if (!RareProtection.doOtherDupe(player, player.pItemId)) {
+			return;
+		}
+		if (player.pItemY > 9817 && player.pItemY < 9825 && player.pItemX > 3186 && player.pItemX < 3197 || player.pItemX > 3107 && player.pItemX < 3113 && player.pItemY > 3155 && player.pItemY < 3159 && player.heightLevel == 2) {
+			player.getPacketSender().sendMessage("You can't pick up these items!");
+			return;
+		}
+		for (LogData logData : LogData.values()) {
+			if (player.isFiremaking == true && player.pItemId == logData.getLogId()) {
+				player.getPacketSender().sendMessage("You can't do that!");
+				Firemaking.stopFiremaking = true;
+				return;
+			}
+		}
+		for (LogData logData : LogData.values()) {
+			if (player.pItemId == logData.getLogId()) {
+				Firemaking.pickedUpFiremakingLog = true;
+			}
+		}
+		SkillHandler.resetSkills(player);
+		player.getCombatAssistant().resetPlayerAttack();
+		if (player.getX() == player.pItemX && player.getY() == player.pItemY
+				|| player.getX() - 1 == player.pItemX && player.getY() == player.pItemY
+				|| player.getY() - 1 == player.pItemY && player.getX() == player.pItemX
+				|| player.getX() + 1 == player.pItemX && player.getY() == player.pItemY
+				|| player.getY() + 1 == player.pItemY && player.getX() == player.pItemX) {
+			GameEngine.itemHandler.removeGroundItem(player, player.pItemId, player.pItemX,
+					player.pItemY, true);
+			player.getPacketSender().sendSound(SoundList.ITEM_PICKUP, 100, 0);
+			GlobalDropsHandler.pickup(player, player.pItemId, player.pItemX, player.pItemY);
+		} else {
+			player.walkingToItem = true;
+			   CycleEventHandler.getSingleton().addEvent(player, new CycleEvent() {
+		            @Override
+		            public void execute(CycleEventContainer container) {
+					if (!player.walkingToItem) {
+						container.stop();
+					}
+					if (player.getX() == player.pItemX && player.getY() == player.pItemY && player.walkingToItem) {
+						GameEngine.itemHandler.removeGroundItem(player, player.pItemId, player.pItemX, player.pItemY, true);
+						container.stop();
+					}
+				}
+
+				@Override
+				public void stop() {
+					player.walkingToItem = false;
+				}
+			}, 1);
+		}
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/PrivateMessaging.java

@@ -0,0 +1,157 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.Connection;
+import com.rebotted.game.players.Client;
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+import com.rebotted.game.players.antimacro.AntiSpam;
+import com.rebotted.net.packets.PacketType;
+import com.rebotted.util.GameLogger;
+import com.rebotted.util.Misc;
+
+/**
+ * Private messaging, friends etc
+ **/
+public class PrivateMessaging implements PacketType {
+
+	public final int ADD_FRIEND = 188, SEND_PM = 126, REMOVE_FRIEND = 215,
+			CHANGE_PM_STATUS = 95, REMOVE_IGNORE = 59, ADD_IGNORE = 133;
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		switch (packetType) {
+
+		case ADD_FRIEND:
+			player.friendUpdate = true;
+			long friendToAdd = player.getInStream().readQWord();
+			boolean canAdd = true;
+
+			for (long friend : player.friends) {
+				if (friend != 0 && friend == friendToAdd) {
+					canAdd = false;
+					player.getPacketSender().sendMessage(friendToAdd + " is already on your friends list.");
+				}
+			}
+			if (canAdd) {
+				for (int i1 = 0; i1 < player.friends.length; i1++) {
+					if (player.friends[i1] == 0) {
+						player.friends[i1] = friendToAdd;
+						for (int i2 = 1; i2 < PlayerHandler.players.length; i2++) {
+							if (PlayerHandler.players[i2] != null && PlayerHandler.players[i2].isActive && Misc.playerNameToInt64(PlayerHandler.players[i2].playerName) == friendToAdd) {
+								Client o = (Client) PlayerHandler.players[i2];
+								if (o != null) {
+									if (PlayerHandler.players[i2].privateChat == 0 || PlayerHandler.players[i2].privateChat == 1 && o.getPlayerAssistant().isInPM(Misc.playerNameToInt64(player.playerName))) {
+										player.getPacketSender().loadPM(friendToAdd, 1);
+										break;
+									}
+								}
+							}
+						}
+						break;
+					}
+				}
+			}
+			break;
+
+		case SEND_PM:
+			long sendMessageToFriendId = player.getInStream().readQWord();
+			byte pmchatText[] = new byte[100];
+			int pmchatTextSize = (byte) (packetSize - 8);
+			player.getInStream().readBytes(pmchatText, pmchatTextSize, 0);
+			String word = Misc.textUnpack(pmchatText, player.packetSize - 2).toLowerCase();// used
+			if (player.getPlayerAssistant().isPlayer()) {
+				GameLogger.writeLog(player.playerName, "pmsent", player.playerName + " said " + Misc.textUnpack(pmchatText, packetSize - 8) + "");
+			}
+			if (!AntiSpam.blockedWords(player, word, false) || Connection.isMuted(player)) {
+				return;
+			}
+			for (long friend : player.friends) {
+				if (friend == sendMessageToFriendId) {
+					boolean pmSent = false;
+
+					for (int i2 = 1; i2 < PlayerHandler.players.length; i2++) {
+						if (PlayerHandler.players[i2] != null && PlayerHandler.players[i2].isActive && Misc.playerNameToInt64(PlayerHandler.players[i2].playerName) == sendMessageToFriendId) {
+							Client o = (Client) PlayerHandler.players[i2];
+							if (o != null) {
+								if (PlayerHandler.players[i2].privateChat == 0 || PlayerHandler.players[i2].privateChat == 1 && o.getPlayerAssistant().isInPM(Misc.playerNameToInt64(player.playerName))) {
+									if (friend == sendMessageToFriendId) {
+										o.getPacketSender().sendPM(Misc.playerNameToInt64(player.playerName), player.playerRights, pmchatText, pmchatTextSize);
+										if (player.getPlayerAssistant().isPlayer()) {
+											GameLogger.writeLog(o.playerName, "pmrecieved", player.playerName + " said to " + o.playerName + " " + Misc.textUnpack(pmchatText, packetSize - 8) + "");
+										}
+										pmSent = true;
+									}
+								}
+							}
+							break;
+						}
+					}
+					if (!pmSent) {
+						player.getPacketSender().sendMessage("That player is currently offline.");
+						break;
+					}
+				}
+			}
+			break;
+
+		case REMOVE_FRIEND:
+			player.friendUpdate = true;
+			long friendToRemove = player.getInStream().readQWord();
+
+			for (int i1 = 0; i1 < player.friends.length; i1++) {
+				if (player.friends[i1] == friendToRemove) {
+					for (int i2 = 1; i2 < PlayerHandler.players.length; i2++) {
+						Client o = (Client) PlayerHandler.players[i2];
+						if (o != null) {
+							if (player.friends[i1] == Misc.playerNameToInt64(PlayerHandler.players[i2].playerName)) {
+								o.getPlayerAssistant().updatePM(player.playerId, 0);
+								break;
+							}
+						}
+					}
+					player.friends[i1] = 0;
+					break;
+				}
+			}
+			break;
+
+		case REMOVE_IGNORE:
+			player.friendUpdate = true;
+			long ignore = player.getInStream().readQWord();
+
+			for (int i = 0; i < player.ignores.length; i++) {
+				if (player.ignores[i] == ignore) {
+					player.ignores[i] = 0;
+					break;
+				}
+			}
+			break;
+
+		case CHANGE_PM_STATUS:
+			player.privateChat = player.getInStream().readUnsignedByte();
+			for (int i1 = 1; i1 < PlayerHandler.players.length; i1++) {
+				if (PlayerHandler.players[i1] != null
+						&& PlayerHandler.players[i1].isActive) {
+					Client o = (Client) PlayerHandler.players[i1];
+					if (o != null) {
+						o.getPlayerAssistant().updatePM(player.playerId, 1);
+					}
+				}
+			}
+			break;
+
+		case ADD_IGNORE:
+			player.friendUpdate = true;
+			long ignoreAdd = player.getInStream().readQWord();
+			for (int i = 0; i < player.ignores.length; i++) {
+				if (player.ignores[i] == 0) {
+					player.ignores[i] = ignoreAdd;
+					break;
+				}
+			}
+			break;
+
+		}
+
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/RemoveItem.java

@@ -0,0 +1,100 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.content.random.PartyRoom;
+import com.rebotted.game.content.skills.crafting.JewelryMaking;
+import com.rebotted.game.items.impl.RareProtection;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Remove Item
+ **/
+public class RemoveItem implements PacketType {
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+		int interfaceId = c.getInStream().readUnsignedWordA();
+		int removeSlot = c.getInStream().readUnsignedWordA();
+		int removeId = c.getInStream().readUnsignedWordA();
+		if (removeId == 88) {
+			c.weight += 4.5;
+			c.getPacketSender().writeWeight((int) c.weight);
+		}
+		if (!RareProtection.removeItem(c, removeId)) {
+			return;
+		}
+
+		c.endCurrentTask();
+
+		switch (interfaceId) {
+
+		case 4233:
+		case 4239:
+		case 4245:
+			JewelryMaking.mouldItem(c, removeId, 1);
+			break;
+
+		case 7423:
+			if (c.inTrade) {
+				c.getTrading().declineTrade(true);
+				return;
+			}
+			c.getItemAssistant().bankItem(removeId, removeSlot, 1);
+			c.getItemAssistant().resetItems(7423);
+			break;
+
+		case 1688:
+			c.getItemAssistant().removeItem(removeId, removeSlot);
+			break;
+
+		case 5064:
+			if (c.inPartyRoom) {
+				PartyRoom.depositItem(c, removeId, 1);
+			} else {
+				c.getItemAssistant().bankItem(removeId, removeSlot, 1);
+			}
+			break;
+
+		case 5382:
+			c.getItemAssistant().fromBank(removeId, removeSlot, 1);
+			break;
+
+		case 3900:
+			c.getShopAssistant().buyFromShopPrice(removeId);
+			break;
+
+		case 3823:
+			c.getShopAssistant().sellToShopPrice(removeId, removeSlot);
+			break;
+
+		case 3322:
+			if (c.duelStatus <= 0) {
+				c.getTrading().tradeItem(removeId, removeSlot, 1);
+			} else {
+				c.getDueling().stakeItem(removeId, removeSlot, 1);
+			}
+			break;
+
+		case 3415:
+			if (c.duelStatus <= 0) {
+				c.getTrading().fromTrade(removeId, removeSlot, 1);
+			}
+			break;
+
+		case 6669:
+			c.getDueling().fromDuel(removeId, removeSlot, 1);
+			break;
+
+		case 1119:
+		case 1120:
+		case 1121:
+		case 1122:
+		case 1123:
+			c.getSmithing().readInput(c.playerLevel[c.playerSmithing],
+					Integer.toString(removeId), c, 1);
+			break;
+
+		}
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/Report.java

@@ -0,0 +1,17 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+public class Report implements PacketType {
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+		try {
+			ReportHandler.handleReport(c);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/ReportHandler.java

@@ -0,0 +1,191 @@
+package com.rebotted.net.packets.impl;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import com.rebotted.game.players.Player;
+import com.rebotted.util.Misc;
+
+public class ReportHandler {
+
+	public static String[] savedNames = new String[500];
+	public static String[] savedSpeach = new String[500];
+	public static String[] savedTimes = new String[500];
+
+	/**
+	 * Reports
+	 */
+
+	public static final String[] reportNames = { "Offensive language",
+			"Item scamming", "Password scamming", "Bug abuse",
+			"Staff impersonation", "Account Sharing/Trading", "Macroing",
+			"Multiple Logging in", "Encouragig others to break the rules",
+			"Misuse of Customer Support", "Advertising", "Real World Trading",
+			"Asking for personal detail" };
+
+	/**
+	 * Adding texts
+	 * 
+	 * @param name
+	 *            The player's name.
+	 * @param data
+	 *            The data.
+	 * @param dataLength
+	 *            The data's length.
+	 */
+
+	public static void addText(String name, byte[] data, int dataLength) {
+		for (int i = 499; i > 0; i--) {
+			savedNames[i] = savedNames[i - 1];
+			savedSpeach[i] = savedSpeach[i - 1];
+			savedTimes[i] = savedTimes[i - 1];
+		}
+		savedNames[0] = name;
+		savedSpeach[0] = Misc.textUnpack(data, dataLength);
+		String minute = new SimpleDateFormat("mm").format(new Date());
+		String second = new SimpleDateFormat("ss").format(new Date());
+		String hour = new SimpleDateFormat("hh").format(new Date());
+		savedTimes[0] = hour + ":" + minute + ":" + second;
+	}
+
+	/**
+	 * Report Handler
+	 * 
+	 * @param c
+	 *            Client x
+	 * @throws Exception
+	 *             ex
+	 */
+
+	public static void handleReport(Player c) throws Exception {
+		String player = Misc.longToReportPlayerName(c.inStream.readQWord2());
+		player = player.replaceAll("_", " ");
+		byte rule = (byte) c.inStream.readUnsignedByte();
+		int mute = c.getInStream().readUnsignedByte();
+
+		if (c.lastReported.equalsIgnoreCase(player) && System.currentTimeMillis() - c.lastReport < 60000) {
+			c.getPacketSender().sendMessage("You can only report a player once every 60 seconds.");
+			return;
+		}
+		if (c.playerName.equalsIgnoreCase(player)) {
+			c.getPacketSender().sendMessage("You cannot report yourself!");
+			return;
+		}
+		if (hasSpoke(player)) {
+			String sendText = "";
+
+			for (int i = 20; i > 0; i--) {
+				if (savedNames[i] != null) {
+					if (savedNames[i].equalsIgnoreCase(c.playerName)
+							|| savedNames[i].equalsIgnoreCase(player)) {
+						sendText += " -[" + savedTimes[i] + ": "
+								+ savedNames[i] + "]: " + savedSpeach[i]
+								+ "\r\n";
+					}
+				}
+			}
+
+			sendText = sendText.replaceAll("'", " ");
+			String month = getMonth(new SimpleDateFormat("MM")
+					.format(new Date()));
+			String day = new SimpleDateFormat("dd").format(new Date());
+			writeReport("" + player + " was reported by " + c.playerName + ", "
+					+ reportNames[rule] + ", " + month + ", " + day + "",
+					sendText + ".", reportNames[rule]);
+			c.getPacketSender()
+					.sendMessage(
+							"Thank you, your report has been received and will be reviewed.");
+			if (mute == 1 && c.playerRights > 0) {
+				c.getPacketSender()
+						.sendMessage(
+								"This user is not muted yet! Go to the MODCP on the forums to mute him!");
+				c.getPacketSender()
+						.sendMessage(
+								"After you have muted him there, do ::update (username) to finish the mute!");
+			}
+			c.lastReported = player;
+			c.lastReport = System.currentTimeMillis();
+		} else {
+			c.getPacketSender()
+					.sendMessage(
+							"You can only report someone who has spoken in the last 60 seconds.");
+		}
+	}
+
+	/**
+	 * Saves Reports to System
+	 * 
+	 * @param data
+	 *            The data.
+	 * @param text
+	 *            The text.
+	 * @param file
+	 *            The file.
+	 */
+
+	public static void writeReport(String data, String text, String file) {
+		BufferedWriter bw = null;
+		try {
+			int time = (int) System.currentTimeMillis();
+			String month = getMonth(new SimpleDateFormat("MM")
+					.format(new Date()));
+			String day = new SimpleDateFormat("dd").format(new Date());
+			bw = new BufferedWriter(new FileWriter(
+					"C:/Users/Administrator/Dropbox/2006Redone - Reportabuses/"
+							+ file + " month;" + month + " day;" + day
+							+ " ms-id;" + time + ".txt", true));
+			bw.write(data);
+			bw.newLine();
+			bw.write(text);
+			bw.newLine();
+			bw.newLine();
+			bw.flush();
+		} catch (IOException ioe) {
+			ioe.printStackTrace();
+		} finally {
+			if (bw != null) {
+				try {
+					bw.close();
+				} catch (IOException ioe2) {
+					System.out.println("Error writing system log.");
+					ioe2.printStackTrace();
+				}
+			}
+		}
+
+	}
+
+	public static boolean hasSpoke(String s) {
+		for (int i = 0; i < 500; i++) {
+			if (savedNames[i] != null) {
+				if (savedNames[i].equalsIgnoreCase(s)) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Gets the Month
+	 * 
+	 * @param s
+	 *            The s.
+	 * @return return
+	 */
+
+	public static String getMonth(String s) {
+		try {
+			int i = Integer.parseInt(s);
+			String[] months = { "", "January", "February", "March", "April",
+					"May", "June", "July", "August", "September", "October",
+					"November", "December" };
+			return months[i];
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return "Unknown";
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/SilentPacket.java

@@ -0,0 +1,15 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Slient Packet
+ **/
+public class SilentPacket implements PacketType {
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+
+	}
+}

2006Redone Server/src/com/rebotted/net/packets/impl/Trade.java

@@ -0,0 +1,39 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.GameConstants;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Trading
+ */
+
+public class Trade implements PacketType {
+
+	@Override
+	public void processPacket(Player c, int packetType, int packetSize) {
+		int tradeId = c.getInStream().readSignedWordBigEndian();
+		c.getPlayerAssistant().resetFollow();
+		c.endCurrentTask();
+		if (c.disconnected) {
+			c.tradeStatus = 0;
+		}
+		if (c.duelingArena()) {
+			c.getPacketSender().sendMessage("You can't trade inside the arena!");
+			return;
+		}
+	
+		if (c.playerRights == 2 && !GameConstants.ADMIN_CAN_TRADE) {
+			c.getPacketSender().sendMessage("Trading as an admin has been disabled.");
+			return;
+		}
+
+	    if(tradeId < 1) {
+            return;
+	    }
+	    if (tradeId != c.playerId) {
+            c.getTrading().requestTrade(tradeId);
+		}
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/Walking.java

@@ -0,0 +1,208 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.content.skills.SkillHandler;
+import com.rebotted.game.content.skills.cooking.Cooking;
+import com.rebotted.game.content.skills.core.Fishing;
+import com.rebotted.game.content.skills.smithing.Smelting;
+import com.rebotted.game.players.Client;
+import com.rebotted.game.players.Player;
+import com.rebotted.game.players.PlayerHandler;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Walking packet
+ **/
+public class Walking implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		player.getDueling().checkDuelWalk();
+
+		if (player.canChangeAppearance) { //|| c.performingAction) {
+			return;
+		}
+		if (player.getCannon().settingUp) {
+			return;
+		}
+		if (player.isTeleporting == true) {
+			player.isTeleporting = false;
+		}
+		if (player.playerSkilling[10]) {// fishing
+			Fishing.resetFishing(player);
+		}
+		if (player.playerIsCooking) {// cooking
+			Cooking.resetCooking(player);
+		}
+		if (player.playerSkilling[13]) {// smelting
+			Smelting.resetSmelting(player);
+		}
+		if (player.playerStun) {
+			return;
+		}
+		if (player.stopPlayer == true) {
+			return;
+		}
+		if (player.isFiremaking == true) {
+			player.isFiremaking = false;
+		}
+		if (player.stopPlayerPacket == true) {
+			return;
+		}
+		if (player.inTrade) {
+			player.inTrade = false;
+			player.getTrading().declineTrade(true);
+		}
+		if (player.tutorialProgress > 35 && !player.isSmithing) {
+			player.getPacketSender().closeAllWindows();
+		} else if (player.tutorialProgress < 36 && player.isSmithing) {
+			player.getPacketSender().closeAllWindows();
+			player.isSmithing = false;
+		}
+		SkillHandler.resetSkills(player);
+		if (player.closeTutorialInterface == false && player.tutorialProgress == 36) {
+			player.getDialogueHandler().sendDialogues(3116, player.npcType);
+		}
+		if (player.gliderOpen == true) {
+			player.gliderOpen = false;
+		}
+		if (player.isBanking == true) {
+			player.isBanking = false;
+		}
+		if (player.canWalkTutorial == false && player.tutorialProgress < 36) {
+			return;
+		}
+		if (player.followId > 0 || player.followId2 > 0) {
+			player.getPlayerAssistant().resetFollow();
+		}
+		if (player.getPlayerAction().checkWalking() == false) {
+			return;
+		}
+		if (packetType == 248 || packetType == 164) {
+			player.faceUpdate(0);
+			player.npcIndex = 0;
+			player.playerIndex = 0;
+			if (player.clickObjectType > 0) {
+				player.clickObjectType = 0;
+			} else if (player.clickNpcType > 0) {
+				player.clickNpcType = 0;
+			}
+		}
+
+		if (player.duelRule[1] && player.duelStatus == 5) {
+			if (PlayerHandler.players[player.duelingWith] != null) {
+				if (!player.goodDistance(player.getX(), player.getY(),
+						PlayerHandler.players[player.duelingWith].getX(),
+						PlayerHandler.players[player.duelingWith].getY(), 1)
+						|| player.attackTimer == 0) {
+					player.getPacketSender().sendMessage(
+							"Walking has been disabled in this duel!");
+				}
+			}
+			player.playerIndex = 0;
+			return;
+		}
+
+
+		if (player.freezeTimer > 0) {
+			if (PlayerHandler.players[player.playerIndex] != null) {
+				if (player.goodDistance(player.getX(), player.getY(),
+						PlayerHandler.players[player.playerIndex].getX(),
+						PlayerHandler.players[player.playerIndex].getY(), 1)
+						&& packetType != 98) {
+					player.playerIndex = 0;
+					return;
+				}
+			}
+			if (packetType != 98) {
+				player.getPacketSender().sendMessage("A magical force stops you from moving.");
+				player.playerIndex = 0;
+			}
+			return;
+		}
+
+		if (System.currentTimeMillis() - player.lastSpear < 4000) {
+			player.getPacketSender().sendMessage("You have been stunned.");
+			player.playerIndex = 0;
+			return;
+		}
+
+		if (packetType == 98) {
+			player.mageAllowed = true;
+		}
+
+		if (player.WildernessWarning == false && player.wildLevel > 0) {
+			player.resetWalkingQueue();
+			player.WildernessWarning = true;
+			player.getPacketSender().sendFrame126("WARNING!", 6940);
+			player.getPacketSender().showInterface(1908);
+		}
+
+		  if(player.openDuel) {
+	            Client o = (Client) PlayerHandler.players[player.duelingWith];
+	            if(o != null) {
+	                o.getDueling().declineDuel();
+	            }
+	            player.getDueling().declineDuel();
+	        }
+	        if((player.duelStatus >= 1 && player.duelStatus <= 4) || player.duelStatus == 6) {
+	            if(player.duelStatus == 6) {
+	                player.getDueling().claimStakedItems();
+	            }
+	            return;
+	        }
+
+		if (player.respawnTimer > 3) {
+			return;
+		}
+
+		player.endCurrentTask();
+
+		if (packetType == 248) {
+			packetSize -= 14;
+		}
+		player.newWalkCmdSteps = (packetSize - 5) / 2;
+		if (++player.newWalkCmdSteps > player.walkingQueueSize) {
+			player.newWalkCmdSteps = 0;
+			return;
+		}
+
+		player.getNewWalkCmdX()[0] = player.getNewWalkCmdY()[0] = 0;
+
+		int firstStepX, firstStepY;
+		int realX = 0;
+		int realY = 0;
+
+		if (player.clickToTele) {
+			firstStepX = player.getInStream().readSignedWordBigEndianA();
+		} else {
+			realX = player.getInStream().readSignedWordBigEndianA();
+			firstStepX = realX - player.getMapRegionX() * 8;
+		}
+		for (int i = 1; i < player.newWalkCmdSteps; i++) {
+			player.getNewWalkCmdX()[i] = player.getInStream().readSignedByte();
+			player.getNewWalkCmdY()[i] = player.getInStream().readSignedByte();
+		}
+
+		if (player.clickToTele) {
+			firstStepY = player.getInStream().readSignedWordBigEndian();
+		} else {
+			realY = player.getInStream().readSignedWordBigEndian();
+			firstStepY = realY - player.getMapRegionY() * 8;
+		}
+
+		if (!player.clickToTele) {
+			if (player.distanceToPoint(realX, realY) > 30) {
+				return;
+			}
+		}
+
+		player.setNewWalkCmdIsRunning(player.getInStream().readSignedByteC() == 1 && player.playerEnergy > 0);
+		for (int i1 = 0; i1 < player.newWalkCmdSteps; i1++) {
+			if (player.clickToTele)
+				player.getPlayerAssistant().movePlayer(player.getNewWalkCmdX()[i1] + firstStepX, player.getNewWalkCmdY()[i1] + firstStepY, player.heightLevel);
+			player.getNewWalkCmdX()[i1] += firstStepX;
+			player.getNewWalkCmdY()[i1] += firstStepY;
+		}
+	}
+
+}

2006Redone Server/src/com/rebotted/net/packets/impl/WearItem.java

@@ -0,0 +1,64 @@
+package com.rebotted.net.packets.impl;
+
+import com.rebotted.game.items.impl.RareProtection;
+import com.rebotted.game.players.Player;
+import com.rebotted.net.packets.PacketType;
+
+/**
+ * Wear Item
+ **/
+public class WearItem implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		player.wearId = player.getInStream().readUnsignedWord();
+		player.wearSlot = player.getInStream().readUnsignedWordA();
+		player.interfaceId = player.getInStream().readUnsignedWordA();
+		if (!RareProtection.equipItem(player)) {
+			return;
+		}
+		if (player.duelStatus > 0 && player.duelStatus < 5) {
+			return;
+		}
+		if (!player.getItemAssistant().playerHasItem(player.wearId, 1, player.wearSlot)) {
+			return;
+		}
+		if (player.playerIndex > 0 || player.npcIndex > 0) {
+			player.getCombatAssistant().resetPlayerAttack();
+		}
+
+		player.endCurrentTask();
+
+		if (player.wearId >= 5509 && player.wearId <= 5515) {
+			int pouch = -1;
+			int a = player.wearId;
+			if (a == 5509) {
+				pouch = 0;
+			}
+			if (a == 5510) {
+				pouch = 1;
+			}
+			if (a == 5512) {
+				pouch = 2;
+			}
+			if (a == 5514) {
+				pouch = 3;
+			}
+			player.getPlayerAssistant().emptyPouch(pouch);
+			return;
+		}
+
+		if (player.wearId == 88) {
+			player.weight -= 4.5;
+			player.getPacketSender().writeWeight((int) player.weight);
+		}
+
+		if (player.wearSlot == player.playerHat) {
+			player.getPacketSender().setConfig(491, 0);
+		}
+
+		player.getPlayerAssistant().handleTiara();
+		player.getItemAssistant().wearItem(player.wearId, player.wearSlot);
+	}
+
+}