init, thx MrExtremez

2006Redone Server/src/redone/net/ActionSender.java

@@ -0,0 +1,629 @@
+package redone.net;
+
+import java.text.DecimalFormat;
+
+import redone.game.players.Client;
+import redone.game.players.Player;
+import redone.game.players.PlayerHandler;
+import redone.util.Misc;
+import redone.world.clip.Region;
+
+public class ActionSender {
+
+	private final Client player;
+
+	public ActionSender(Client client) {
+		this.player = client;
+	}
+
+
+	public ActionSender sendClan(String name, String message, String clan, int rights) {
+		player.outStream.createFrameVarSizeWord(217);
+		player.outStream.writeString(name);
+		player.outStream.writeString(message);
+		player.outStream.writeString(clan);
+		player.outStream.writeWord(rights);
+		player.outStream.endFrameVarSize();
+		return this;
+	}
+	
+	public ActionSender createPlayersObjectAnim(int X, int Y, int animationID, int tileObjectType, int orientation) {
+		try{
+			player.getOutStream().createFrame(85);
+			player.getOutStream().writeByteC(Y - (player.mapRegionY * 8));
+			player.getOutStream().writeByteC(X - (player.mapRegionX * 8));
+			int x = 0;
+			int y = 0;
+			player.getOutStream().createFrame(160);
+			player.getOutStream().writeByteS(((x&7) << 4) + (y&7));//tiles away - could just send 0       
+			player.getOutStream().writeByteS((tileObjectType<<2) +(orientation&3));
+			player.getOutStream().writeWordA(animationID);// animation id
+		} catch(Exception e){
+			e.printStackTrace();
+		}
+		return this;
+	}
+	
+	
+	public ActionSender setInterfaceOffset(int x, int y, int id) {
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrame(70);
+			player.getOutStream().writeWord(x);
+			player.getOutStream().writeWordBigEndian(y);
+			player.getOutStream().writeWordBigEndian(id);
+			player.flushOutStream();
+		}
+		return this;
+	}
+	
+	public ActionSender shakeScreen(int verticleAmount, int verticleSpeed,
+			int horizontalAmount, int horizontalSpeed) {
+		player.getOutStream().createFrame(35); // Creates frame 35.
+		player.getOutStream().writeByte(verticleAmount);
+		player.getOutStream().writeByte(verticleSpeed);
+		player.getOutStream().writeByte(horizontalAmount);
+		player.getOutStream().writeByte(horizontalSpeed);
+		return this;
+	}
+
+	public ActionSender chatbox(int i1) {
+		if (player.getOutStream() != null && player != null) {
+			player.outStream.createFrame(218);
+			player.outStream.writeWordBigEndianA(i1);
+			player.updateRequired = true;
+			player.appearanceUpdateRequired = true;
+		}
+		return this;
+	}
+
+	public ActionSender sendMessage(String s) {
+		if (player.getOutStream() != null) {
+			player.getOutStream().createFrameVarSize(253);
+			player.getOutStream().writeString(s);
+			player.getOutStream().endFrameVarSize();
+		}
+		return this;
+	}
+
+	public ActionSender setSidebarInterface(int menuId, int form) {
+		if (player.getOutStream() != null) {
+			player.getOutStream().createFrame(71);
+			player.getOutStream().writeWord(form);
+			player.getOutStream().writeByteA(menuId);
+		}
+		return this;
+	}
+
+	/**
+	 * Flashes Sidebar Icon
+	 */
+
+	public ActionSender flashSideBarIcon(int i1) {
+		// Makes the sidebar Icons flash
+		// Usage: i1 = 0 through -12 inorder to work
+		player.outStream.createFrame(24);
+		player.outStream.writeByteA(i1);
+		player.updateRequired = true;
+		player.appearanceUpdateRequired = true;
+		return this;
+	}
+
+	public ActionSender createPlayerHints(int type, int id) {
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrame(254);
+			player.getOutStream().writeByte(type);
+			player.getOutStream().writeWord(id);
+			player.getOutStream().write3Byte(0);
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	public ActionSender createObjectHints(int x, int y, int height, int pos) {
+		// synchronized(c) {
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrame(254);
+			player.getOutStream().writeByte(pos);
+			player.getOutStream().writeWord(x);
+			player.getOutStream().writeWord(y);
+			player.getOutStream().writeByte(height);
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	public ActionSender createProjectile(int x, int y, int offX, int offY,
+			int angle, int speed, int gfxMoving, int startHeight,
+			int endHeight, int lockon, int time) {
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrame(85);
+			player.getOutStream()
+					.writeByteC(y - player.getMapRegionY() * 8 - 2);
+			player.getOutStream()
+					.writeByteC(x - player.getMapRegionX() * 8 - 3);
+			player.getOutStream().createFrame(117);
+			player.getOutStream().writeByte(angle);
+			player.getOutStream().writeByte(offY);
+			player.getOutStream().writeByte(offX);
+			player.getOutStream().writeWord(lockon);
+			player.getOutStream().writeWord(gfxMoving);
+			player.getOutStream().writeByte(startHeight);
+			player.getOutStream().writeByte(endHeight);
+			player.getOutStream().writeWord(time);
+			player.getOutStream().writeWord(speed);
+			player.getOutStream().writeByte(16);
+			player.getOutStream().writeByte(64);
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	public ActionSender createProjectile2(int x, int y, int offX, int offY,
+			int angle, int speed, int gfxMoving, int startHeight,
+			int endHeight, int lockon, int time, int slope) {
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrame(85);
+			player.getOutStream()
+					.writeByteC(y - player.getMapRegionY() * 8 - 2);
+			player.getOutStream()
+					.writeByteC(x - player.getMapRegionX() * 8 - 3);
+			player.getOutStream().createFrame(117);
+			player.getOutStream().writeByte(angle);
+			player.getOutStream().writeByte(offY);
+			player.getOutStream().writeByte(offX);
+			player.getOutStream().writeWord(lockon);
+			player.getOutStream().writeWord(gfxMoving);
+			player.getOutStream().writeByte(startHeight);
+			player.getOutStream().writeByte(endHeight);
+			player.getOutStream().writeWord(time);
+			player.getOutStream().writeWord(speed);
+			player.getOutStream().writeByte(slope);
+			player.getOutStream().writeByte(64);
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	/**
+	 * Objects, add and remove
+	 **/
+	public ActionSender object(int objectId, int objectX, int objectY, int face, int objectType) {
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrame(85);
+			player.getOutStream().writeByteC(
+					objectY - player.getMapRegionY() * 8);
+			player.getOutStream().writeByteC(
+					objectX - player.getMapRegionX() * 8);
+			player.getOutStream().createFrame(101);
+			player.getOutStream().writeByteC((objectType << 2) + (face & 3));
+			player.getOutStream().writeByte(0);
+			if (objectId != -1) { // removing
+				player.getOutStream().createFrame(151);
+				player.getOutStream().writeByteS(0);
+				player.getOutStream().writeWordBigEndian(objectId);
+				player.getOutStream()
+						.writeByteS((objectType << 2) + (face & 3));
+			}
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	public ActionSender object(int objectId, int objectX, int objectY, int objectH, int face, int objectType) {
+		if (player.heightLevel != objectH) {
+			return this;
+		}
+		if (Misc.goodDistance(objectX, objectY, player.absX, player.absY, 60)) {
+			if (player.getOutStream() != null && player != null) {
+				player.getOutStream().createFrame(85);
+				player.getOutStream().writeByteC(objectY - player.getMapRegionY() * 8);
+				player.getOutStream().writeByteC(objectX - player.getMapRegionX() * 8);
+				player.getOutStream().createFrame(101);
+				player.getOutStream().writeByteC((objectType << 2) + (face & 3));
+				player.getOutStream().writeByte(0);
+				if (objectId != -1) { // removing
+					player.getOutStream().createFrame(151);
+					player.getOutStream().writeByteS(0);
+					player.getOutStream().writeWordBigEndian(objectId);
+					player.getOutStream().writeByteS((objectType << 2) + (face & 3));
+				}
+				player.flushOutStream();
+			}
+		}
+		return this;
+	}
+
+	public ActionSender tempSong(int songID, int songID2) {
+		player.outStream.createFrame(121);
+		player.outStream.writeWordBigEndian(songID);
+		player.outStream.writeWordBigEndian(songID2);
+		player.flushOutStream();
+		return this;
+	}
+
+	public ActionSender frame174(int sound, int vol, int delay) {
+		player.outStream.createFrame(174);
+		player.outStream.writeWord(sound);
+		player.outStream.writeByte(vol);
+		player.outStream.writeWord(delay);
+		player.updateRequired = true;
+		player.appearanceUpdateRequired = true;
+		return this;
+	}
+
+	public ActionSender frame174(int id, int type, int delay, int volume) {
+		if (player.outStream != null && player != null && id != -1) {
+			player.outStream.createFrame(174);
+			player.outStream.writeWord(id);
+			player.outStream.writeWord(delay);
+			player.outStream.writeWord(volume);
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	public ActionSender writeWeight(int weight) {
+		player.outStream.createFrame(240);
+		DecimalFormat twoDForm = new DecimalFormat("#.##");
+		player.outStream.writeWord(Integer.valueOf(twoDForm.format(weight)));
+		return this;
+	}
+
+	public ActionSender sendConfig(int id, int state) {
+		if (player.getOutStream() != null && player != null) {
+			if (state < 128) {
+
+			}
+			if (state < Byte.MIN_VALUE || state > Byte.MAX_VALUE) {
+				player.getOutStream().createFrame(87);
+				player.getOutStream().writeWordBigEndian_dup(id);
+				player.getOutStream().writeDWord_v1(state);
+				player.flushOutStream();
+			} else {
+				player.getOutStream().createFrame(36);
+				player.getOutStream().writeWordBigEndian(id);
+				player.getOutStream().writeByte(state);
+				player.flushOutStream();
+			}
+		}
+		return this;
+	}
+
+	public ActionSender multiWay(int i1) {
+		player.outStream.createFrame(61);
+		player.outStream.writeByte(i1);
+		player.updateRequired = true;
+		player.setAppearanceUpdateRequired(true);
+		return this;
+	}
+
+	public ActionSender sendColor(int id, int color) {
+		if (player.getOutStream() != null && player != null) {
+			player.outStream.createFrame(122);
+			player.outStream.writeWordBigEndianA(id);
+			player.outStream.writeWordBigEndianA(color);
+		}
+		return this;
+	}
+
+	public ActionSender sendCrashFrame() { // used for crashing cheat
+												// clients
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrame(123);
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	public ActionSender createStillGfx(int id, int x, int y, int height,
+			int time) {
+		for (Player p : PlayerHandler.players) {
+			if (p != null) {
+				Client person = (Client) p;
+				if (person != null) {
+					if (person.getOutStream() != null) {
+						if (person.distanceToPoint(x, y) <= 25) {
+							person.getPlayerAssistant().stillGfx(id, x, y,
+									height, time);
+						}
+					}
+				}
+			}
+		}
+		return this;
+	}
+
+	public ActionSender object(int objectId, int objectX, int objectY,
+			int objectType) {
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrame(85);
+			player.getOutStream().writeByteC(
+					objectY - player.getMapRegionY() * 8);
+			player.getOutStream().writeByteC(
+					objectX - player.getMapRegionX() * 8);
+			player.getOutStream().createFrame(101);
+			player.getOutStream().writeByteC((objectType << 2) + (0 & 3));
+			player.getOutStream().writeByte(0);
+			if (objectId != -1) { // removing
+				player.getOutStream().createFrame(151);
+				player.getOutStream().writeByteS(0);
+				player.getOutStream().writeWordBigEndian(objectId);
+				player.getOutStream().writeByteS((objectType << 2) + (0 & 3));
+			}
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	public ActionSender itemOnInterface(int interfaceChild, int zoom, int itemId) {
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrame(246);
+			player.getOutStream().writeWordBigEndian(interfaceChild);
+			player.getOutStream().writeWord(zoom);
+			player.getOutStream().writeWord(itemId);
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	public ActionSender setConfig(int id, int state) {
+		player.outStream.createFrame(36);
+		player.outStream.writeWordBigEndian(id);
+		player.outStream.writeByte(state);
+		return this;
+	}
+
+	public ActionSender sendLink(String s) {
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrameVarSizeWord(187);
+			player.getOutStream().writeString(s);
+		}
+		return this;
+	}
+
+	public ActionSender setSkillLevel(int skillNum, int currentLevel, int XP) {
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrame(134);
+			player.getOutStream().writeByte(skillNum);
+			player.getOutStream().writeDWord_v1(XP);
+			player.getOutStream().writeByte(currentLevel);
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	/**
+	 * Show an arrow icon on the selected player.
+	 * 
+	 * @Param i - Either 0 or 1; 1 is arrow, 0 is none.
+	 * @Param j - The player/Npc that the arrow will be displayed above.
+	 * @Param k - Keep this set as 0
+	 * @Param l - Keep this set as 0
+	 */
+	public ActionSender drawHeadicon(int i, int j, int k, int l) {
+		// synchronized(c) {
+		player.outStream.createFrame(254);
+		player.outStream.writeByte(i);
+
+		if (i == 1 || i == 10) {
+			player.outStream.writeWord(j);
+			player.outStream.writeWord(k);
+			player.outStream.writeByte(l);
+		} else {
+			player.outStream.writeWord(k);
+			player.outStream.writeWord(l);
+			player.outStream.writeByte(j);
+		}
+		return this;
+	}
+
+	// object
+
+	public ActionSender createArrow(int x, int y, int height, int pos) {
+		if (player != null) {
+			player.getOutStream().createFrame(254); // The packet ID
+			player.getOutStream().writeByte(pos); // Position on Square(2 =
+													// middle, 3
+													// = west, 4 = east, 5 =
+													// south,
+													// 6 = north)
+			player.getOutStream().writeWord(x); // X-Coord of Object
+			player.getOutStream().writeWord(y); // Y-Coord of Object
+			player.getOutStream().writeByte(height); // Height off Ground
+		}
+		return this;
+	}
+
+	// npc
+
+	public ActionSender createArrow(int type, int id) {
+		if (player != null) {
+			player.getOutStream().createFrame(254); // The packet ID
+			player.getOutStream().writeByte(type); // 1=NPC, 10=Player
+			player.getOutStream().writeWord(id); // NPC/Player ID
+			player.getOutStream().write3Byte(0); // Junk
+		}
+		return this;
+	}	
+
+	public ActionSender checkObjectSpawn(int objectId, int objectX, int objectY, int face, int objectType) {
+		if (player.distanceToPoint(objectX, objectY) < 60) {
+			if (player.getOutStream() != null && player != null) {
+				player.getOutStream().createFrame(85);
+				player.getOutStream().writeByteC(
+						objectY - player.getMapRegionY() * 8);
+				player.getOutStream().writeByteC(
+						objectX - player.getMapRegionX() * 8);
+				player.getOutStream().createFrame(101);
+				player.getOutStream()
+						.writeByteC((objectType << 2) + (face & 3));
+				player.getOutStream().writeByte(0);
+				if (objectId != -1) { // removing
+					player.getOutStream().createFrame(151);
+					player.getOutStream().writeByteS(0);
+					player.getOutStream().writeWordBigEndian(objectId);
+					player.getOutStream().writeByteS(
+							(objectType << 2) + (face & 3));
+				}
+				player.flushOutStream();
+			}
+			if (objectId > 0) {
+				Region.addObject(objectId, objectX, objectX, player.heightLevel, objectType, face, false);
+			}
+		}
+		return this;
+	}
+	
+	public ActionSender createObjectSpawn(int objectId, int objectX, int objectY, int height, int face, int objectType) {
+		if (player.heightLevel != height) {
+			return this;
+		}
+		if (player.distanceToPoint(objectX, objectY) < 60) {
+			if (player.getOutStream() != null && player != null) {
+				player.getOutStream().createFrame(85);
+				player.getOutStream().writeByteC(objectY - player.getMapRegionY() * 8);
+				player.getOutStream().writeByteC(objectX - player.getMapRegionX() * 8);
+				player.getOutStream().createFrame(101);
+				player.getOutStream().writeByteC((objectType << 2) + (face & 3));
+				player.getOutStream().writeByte(0);
+				if (objectId != -1) { // removing
+					player.getOutStream().createFrame(151);
+					player.getOutStream().writeByteS(0);
+					player.getOutStream().writeWordBigEndian(objectId);
+					player.getOutStream().writeByteS((objectType << 2) + (face & 3));
+				}
+				player.flushOutStream();
+			}
+		}
+		return this;
+	}
+
+	/**
+	 * Show option, attack, trade, follow etc
+	 **/
+	public String optionType = "null";
+
+	public ActionSender showOption(int i, int l, String s, int a) {
+		// synchronized(c) {
+		if (player.getOutStream() != null && player != null) {
+			if (!optionType.equalsIgnoreCase(s)) {
+				optionType = s;
+				player.getOutStream().createFrameVarSize(104);
+				player.getOutStream().writeByteC(i);
+				player.getOutStream().writeByteA(l);
+				player.getOutStream().writeString(s);
+				player.getOutStream().endFrameVarSize();
+				player.flushOutStream();
+			}
+		}
+		return this;
+	}
+
+	/**
+	 * sendSong(id);
+	 */
+
+	public ActionSender sendSong(int id) {
+		if (player.getOutStream() != null && player != null && id != -1) {
+			player.getOutStream().createFrame(74);
+			player.getOutStream().writeWordBigEndian(id);
+		}
+		return this;
+	}
+
+	/**
+	 * sendQuickSong(id, delay); - used for things such as level up music
+	 */
+
+	public ActionSender sendQuickSong(int id, int songDelay) {
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrame(121);
+			player.getOutStream().writeWordBigEndian(id);
+			player.getOutStream().writeWordBigEndian(songDelay);
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	/**
+	 * sendSound(id, volume, delay);
+	 */
+
+	public ActionSender sendSound(int id, int type, int delay, int volume) {
+		if (player.getOutStream() != null && player != null && id != -1) {
+			player.getOutStream().createFrame(174);
+			player.getOutStream().writeWord(id);
+			player.getOutStream().writeByte(type);
+			player.getOutStream().writeWord(delay);
+			player.getOutStream().writeWord(volume);
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	/**
+	 * Send Misc Songs
+	 */
+
+	public ActionSender sendSound(int id, int volume, int delay) {
+		frame174(id, volume, delay);
+		player.updateRequired = true;
+		player.appearanceUpdateRequired = true;
+		return this;
+	}
+
+	public ActionSender sendClearScreen() {
+		if (player.getOutStream() != null && player != null) {
+			player.getOutStream().createFrame(219);
+			player.flushOutStream();
+		}
+		return this;
+	}
+
+	public ActionSender createGroundItem(int itemID, int itemX, int itemY, int itemAmount) {
+		player.getOutStream().createFrame(85);
+		player.getOutStream().writeByteC(itemY - 8 * player.mapRegionY);
+		player.getOutStream().writeByteC(itemX - 8 * player.mapRegionX);
+		player.getOutStream().createFrame(44);
+		player.getOutStream().writeWordBigEndianA(itemID);
+		player.getOutStream().writeWord(itemAmount);
+		player.getOutStream().writeByte(0);
+		player.flushOutStream();
+		return this;
+	}
+	
+	public ActionSender createGroundItem(int itemID, int itemX, int itemY, int itemAmount, int height) {
+		if (player.heightLevel != height) {
+			return this;
+		}
+		player.getOutStream().createFrame(85);
+		player.getOutStream().writeByteC(itemY - 8 * player.mapRegionY);
+		player.getOutStream().writeByteC(itemX - 8 * player.mapRegionX);
+		player.getOutStream().createFrame(44);
+		player.getOutStream().writeWordBigEndianA(itemID);
+		player.getOutStream().writeWord(itemAmount);
+		player.getOutStream().writeByte(0);
+		player.flushOutStream();
+		return this;
+	}
+
+
+	/**
+	 * Pickup Item
+	 **/
+
+	public ActionSender removeGroundItem(int itemID, int itemX, int itemY, int Amount) {
+		if (player == null) {
+			return this;
+		}
+		player.getOutStream().createFrame(85);
+		player.getOutStream().writeByteC(itemY - 8 * player.mapRegionY);
+		player.getOutStream().writeByteC(itemX - 8 * player.mapRegionX);
+		player.getOutStream().createFrame(156);
+		player.getOutStream().writeByteS(0);
+		player.getOutStream().writeWord(itemID);
+		player.flushOutStream();
+		return this;
+	}
+
+}

2006Redone Server/src/redone/net/CodecFactory.java

@@ -0,0 +1,40 @@
+package redone.net;
+
+import org.apache.mina.filter.codec.ProtocolCodecFactory;
+import org.apache.mina.filter.codec.ProtocolDecoder;
+import org.apache.mina.filter.codec.ProtocolEncoder;
+
+/**
+ * Provides access to the encoders and decoders for the 508 protocol.
+ * 
+ * @author Graham
+ */
+public class CodecFactory implements ProtocolCodecFactory {
+
+	/**
+	 * The encoder.
+	 */
+	private final ProtocolEncoder encoder = new RS2ProtocolEncoder();
+
+	/**
+	 * The decoder.
+	 */
+	private final ProtocolDecoder decoder = new RS2LoginProtocolDecoder();
+
+	@Override
+	/**
+	 * Get the encoder.
+	 */
+	public ProtocolEncoder getEncoder() throws Exception {
+		return encoder;
+	}
+
+	@Override
+	/**
+	 * Get the decoder.
+	 */
+	public ProtocolDecoder getDecoder() throws Exception {
+		return decoder;
+	}
+
+}

2006Redone Server/src/redone/net/ConnectionHandler.java

@@ -0,0 +1,63 @@
+package redone.net;
+
+import org.apache.mina.common.IdleStatus;
+import org.apache.mina.common.IoHandler;
+import org.apache.mina.common.IoSession;
+import org.apache.mina.filter.codec.ProtocolCodecFilter;
+
+import redone.game.players.Client;
+
+public class ConnectionHandler implements IoHandler {
+
+	@Override
+	public void exceptionCaught(IoSession arg0, Throwable arg1)
+			throws Exception {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void messageReceived(IoSession arg0, Object arg1) throws Exception {
+		if (arg0.getAttachment() != null) {
+			Client plr = (Client) arg0.getAttachment();
+			plr.queueMessage((Packet) arg1);
+		}
+	}
+
+	@Override
+	public void messageSent(IoSession arg0, Object arg1) throws Exception {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void sessionClosed(IoSession arg0) throws Exception {
+		if (arg0.getAttachment() != null) {
+			Client plr = (Client) arg0.getAttachment();
+			plr.disconnected = true;
+		}
+		HostList.getHostList().remove(arg0);
+	}
+
+	@Override
+	public void sessionCreated(IoSession arg0) throws Exception {
+		if (!HostList.getHostList().add(arg0)) {
+			arg0.close();
+		} else {
+			arg0.setAttribute("inList", Boolean.TRUE);
+		}
+	}
+
+	@Override
+	public void sessionIdle(IoSession arg0, IdleStatus arg1) throws Exception {
+		arg0.close();
+	}
+
+	@Override
+	public void sessionOpened(IoSession arg0) throws Exception {
+		arg0.setIdleTime(IdleStatus.BOTH_IDLE, 60);
+		arg0.getFilterChain().addLast("protocolFilter",
+				new ProtocolCodecFilter(new CodecFactory()));
+	}
+
+}

2006Redone Server/src/redone/net/ConnectionThrottleFilter.java

@@ -0,0 +1,132 @@
+package redone.net;
+
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.mina.common.IoFilter;
+import org.apache.mina.common.IoFilterAdapter;
+import org.apache.mina.common.IoSession;
+
+/**
+ * A {@link IoFilter} which blocks connections from connecting at a rate faster
+ * than the specified interval.
+ * 
+ * @author The Apache MINA Project (dev@mina.apache.org)
+ * @version $Rev$, $Date$
+ */
+public class ConnectionThrottleFilter extends IoFilterAdapter {
+
+	private long allowedInterval;
+	private final Map<InetAddress, Long> clients;
+	private final Map<InetAddress, Integer> counts;
+	private final Set<InetAddress> connectedAddresses;
+
+	/**
+	 * Constructor that takes in a specified wait time.
+	 * 
+	 * @param allowedInterval
+	 *            The number of milliseconds a client is allowed to wait before
+	 *            making another successful connection
+	 */
+	public ConnectionThrottleFilter(long allowedInterval) {
+		this.allowedInterval = allowedInterval;
+		clients = Collections.synchronizedMap(new HashMap<InetAddress, Long>());
+		counts = Collections
+				.synchronizedMap(new HashMap<InetAddress, Integer>());
+		connectedAddresses = new HashSet<InetAddress>();
+	}
+
+	/**
+	 * Sets the interval between connections from a client. This value is
+	 * measured in milliseconds.
+	 * 
+	 * @param allowedInterval
+	 *            The number of milliseconds a client is allowed to wait before
+	 *            making another successful connection
+	 */
+	public void setAllowedInterval(long allowedInterval) {
+		this.allowedInterval = allowedInterval;
+	}
+
+	public void delayClient(IoSession session, int delay) {
+		long d = System.currentTimeMillis() - delay;
+		clients.put(getAddress(session), d);
+	}
+
+	private InetAddress getAddress(IoSession io) {
+		return ((InetSocketAddress) io.getRemoteAddress()).getAddress();
+	}
+
+	/**
+	 * Method responsible for deciding if a connection is OK to continue
+	 * 
+	 * @param session
+	 *            The new session that will be verified
+	 * @return True if the session meets the criteria, otherwise false
+	 */
+	public boolean isConnectionOk(IoSession session) {
+		InetAddress addr = getAddress(session);
+		long now = System.currentTimeMillis();
+		if (clients.containsKey(addr)) {
+			long lastConnTime = clients.get(addr);
+
+			if (now - lastConnTime < allowedInterval) {
+				int c = 0;
+				if (!counts.containsKey(addr)) {
+					counts.put(addr, 0);
+				} else {
+					c = counts.get(addr) + 1;
+				}
+				if (c >= 350) {
+
+					c = 0;
+				}
+				counts.put(addr, c);
+				// Logger.err("["+host+"] Session dropped (delay="+(now-lastConnTime)+"ms)");
+				return false;
+			} else {
+				clients.put(addr, now);
+				return true;
+			}
+		} else {
+			clients.put(addr, now);
+			return true;
+		}
+	}
+
+	public void closedSession(IoSession io) {
+		connectedAddresses.remove(getAddress(io));
+	}
+
+	public void acceptedLogin(IoSession io) {
+		connectedAddresses.add(getAddress(io));
+	}
+
+	public boolean isConnected(IoSession io) {
+		return connectedAddresses.contains(getAddress(io));
+	}
+
+	public int[] getSizes() {
+		return new int[] { clients.size(), counts.size(),
+				connectedAddresses.size() };
+	}
+
+	public void connectionOk(IoSession io) {
+		counts.remove(getAddress(io));
+	}
+
+	@Override
+	public void sessionCreated(NextFilter nextFilter, IoSession session)
+			throws Exception {
+		if (!isConnectionOk(session)) {
+			session.close();
+			return;
+		}
+		nextFilter.sessionCreated(session);
+	}
+}

2006Redone Server/src/redone/net/GameCodecFactory.java

@@ -0,0 +1,46 @@
+package redone.net;
+
+import org.apache.mina.filter.codec.ProtocolCodecFactory;
+import org.apache.mina.filter.codec.ProtocolDecoder;
+import org.apache.mina.filter.codec.ProtocolEncoder;
+
+import redone.util.ISAACRandomGen;
+
+/**
+ * Provides access to the encoders and decoders for the 508 protocol.
+ * 
+ * @author Graham
+ */
+public class GameCodecFactory implements ProtocolCodecFactory {
+
+	/**
+	 * The encoder.
+	 */
+	private final ProtocolEncoder encoder = new RS2ProtocolEncoder();
+
+	/**
+	 * The decoder.
+	 */
+	private final ProtocolDecoder decoder;
+
+	public GameCodecFactory(ISAACRandomGen inC) {
+		decoder = new RS2ProtocolDecoder(inC);
+	}
+
+	@Override
+	/**
+	 * Get the encoder.
+	 */
+	public ProtocolEncoder getEncoder() throws Exception {
+		return encoder;
+	}
+
+	@Override
+	/**
+	 * Get the decoder.
+	 */
+	public ProtocolDecoder getDecoder() throws Exception {
+		return decoder;
+	}
+
+}

2006Redone Server/src/redone/net/HostList.java

@@ -0,0 +1,57 @@
+package redone.net;
+
+import java.net.InetSocketAddress;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.mina.common.IoSession;
+
+import redone.Connection;
+import redone.Constants;
+
+public class HostList {
+
+	private static HostList list = new HostList();
+
+	public static HostList getHostList() {
+		return list;
+	}
+
+	private final Map<String, Integer> connections = new HashMap<String, Integer>();
+
+	public synchronized boolean add(IoSession session) {
+		String addr = ((InetSocketAddress) session.getRemoteAddress())
+				.getAddress().getHostAddress();
+		Integer amt = connections.get(addr);
+		if (amt == null) {
+			amt = 1;
+		} else {
+			amt += 1;
+		}
+		if (amt > Constants.IPS_ALLOWED || Connection.isIpBanned(addr)) {
+			return false;
+		} else {
+			connections.put(addr, amt);
+			return true;
+		}
+	}
+
+	public synchronized void remove(IoSession session) {
+		if (session.getAttribute("inList") != Boolean.TRUE) {
+			return;
+		}
+		String addr = ((InetSocketAddress) session.getRemoteAddress())
+				.getAddress().getHostAddress();
+		Integer amt = connections.get(addr);
+		if (amt == null) {
+			return;
+		}
+		amt -= 1;
+		if (amt <= 0) {
+			connections.remove(addr);
+		} else {
+			connections.put(addr, amt);
+		}
+	}
+
+}

2006Redone Server/src/redone/net/Packet.java

@@ -0,0 +1,304 @@
+package redone.net;
+
+import org.apache.mina.common.IoSession;
+
+/**
+ * Immutable packet object.
+ * 
+ * @author Graham
+ */
+public final class Packet {
+
+	public static enum Size {
+		Fixed, VariableByte, VariableShort
+	};
+
+	/**
+	 * The associated IO session
+	 */
+	private final IoSession session;
+	/**
+	 * The ID of the packet
+	 */
+	private final int pID;
+	/**
+	 * The length of the payload
+	 */
+	private final int pLength;
+	/**
+	 * The payload
+	 */
+	private final byte[] pData;
+	/**
+	 * The current index into the payload buffer for reading
+	 */
+	private int caret = 0;
+	/**
+	 * Whether this packet is without the standard packet header
+	 */
+	private final boolean bare;
+	private Size size = Size.Fixed;
+
+	public Packet(IoSession session, int pID, byte[] pData, boolean bare, Size s) {
+		this.session = session;
+		this.pID = pID;
+		this.pData = pData;
+		pLength = pData.length;
+		this.bare = bare;
+		size = s;
+	}
+
+	/**
+	 * Creates a new packet with the specified parameters.
+	 * 
+	 * @param session
+	 *            The session to associate with the packet
+	 * @param pID
+	 *            The ID of the packet
+	 * @param pData
+	 *            The payload of the packet
+	 * @param bare
+	 *            Whether this packet is bare, which means that it does not
+	 *            include the standard packet header
+	 */
+	public Packet(IoSession session, int pID, byte[] pData, boolean bare) {
+		this(session, pID, pData, bare, Size.Fixed);
+	}
+
+	/**
+	 * Creates a new packet with the specified parameters. The packet is
+	 * considered not to be a bare packet.
+	 * 
+	 * @param session
+	 *            The session to associate with the packet
+	 * @param pID
+	 *            The ID of the packet
+	 * @param pData
+	 *            The payload the packet
+	 */
+	public Packet(IoSession session, int pID, byte[] pData) {
+		this(session, pID, pData, false);
+	}
+
+	/**
+	 * Returns the IO session associated with the packet, if any.
+	 * 
+	 * @return The <code>IoSession</code> object, or <code>null</code> if none.
+	 */
+	public IoSession getSession() {
+		return session;
+	}
+
+	/**
+	 * Checks if this packet is considered to be a bare packet, which means that
+	 * it does not include the standard packet header (ID and length values).
+	 * 
+	 * @return Whether this packet is a bare packet
+	 */
+	public boolean isBare() {
+		return bare;
+	}
+
+	public Size getSize() {
+		return size;
+	}
+
+	/**
+	 * Returns the packet ID.
+	 * 
+	 * @return The packet ID
+	 */
+	public int getId() {
+		return pID;
+	}
+
+	/**
+	 * Returns the length of the payload of this packet.
+	 * 
+	 * @return The length of the packet's payload
+	 */
+	public int getLength() {
+		return pLength;
+	}
+
+	/**
+	 * Returns the entire payload data of this packet.
+	 * 
+	 * @return The payload <code>byte</code> array
+	 */
+	public byte[] getData() {
+		return pData;
+	}
+
+	/**
+	 * Returns the remaining payload data of this packet.
+	 * 
+	 * @return The payload <code>byte</code> array
+	 */
+	public byte[] getRemainingData() {
+		byte[] data = new byte[pLength - caret];
+		for (int i = 0; i < data.length; i++) {
+			data[i] = pData[i + caret];
+		}
+		caret += data.length;
+		return data;
+
+	}
+
+	/**
+	 * Reads the next <code>byte</code> from the payload.
+	 * 
+	 * @return A <code>byte</code>
+	 */
+	public byte readByte() {
+		return pData[caret++];
+	}
+
+	/**
+	 * Reads the next <code>short</code> from the payload.
+	 * 
+	 * @return A <code>short</code>
+	 */
+	public short readShort() {
+		return (short) ((short) ((pData[caret++] & 0xff) << 8) | (short) (pData[caret++] & 0xff));
+	}
+
+	public int readLEShortA() {
+		int i = (pData[caret++] - 128 & 0xff) + ((pData[caret++] & 0xff) << 8);
+		if (i > 32767) {
+			i -= 0x10000;
+		}
+		return i;
+	}
+
+	public int readLEShort() {
+		int i = (pData[caret++] & 0xff) + ((pData[caret++] & 0xff) << 8);
+		if (i > 32767) {
+			i -= 0x10000;
+		}
+		return i;
+	}
+
+	/**
+	 * Reads the next <code>int</code> from the payload.
+	 * 
+	 * @return An <code>int</code>
+	 */
+	public int readInt() {
+		return (pData[caret++] & 0xff) << 24 | (pData[caret++] & 0xff) << 16
+				| (pData[caret++] & 0xff) << 8 | pData[caret++] & 0xff;
+	}
+
+	public int readLEInt() {
+		return pData[caret++] & 0xff | (pData[caret++] & 0xff) << 8
+				| (pData[caret++] & 0xff) << 16 | (pData[caret++] & 0xff) << 24;
+	}
+
+	/**
+	 * Reads the next <code>long</code> from the payload.
+	 * 
+	 * @return A <code>long</code>
+	 */
+	public long readLong() {
+		return (long) (pData[caret++] & 0xff) << 56
+				| (long) (pData[caret++] & 0xff) << 48
+				| (long) (pData[caret++] & 0xff) << 40
+				| (long) (pData[caret++] & 0xff) << 32
+				| (long) (pData[caret++] & 0xff) << 24
+				| (long) (pData[caret++] & 0xff) << 16
+				| (long) (pData[caret++] & 0xff) << 8 | pData[caret++] & 0xff;
+	}
+
+	/**
+	 * Reads the string which is formed by the unread portion of the payload.
+	 * 
+	 * @return A <code>String</code>
+	 */
+	public String readString() {
+		return readString(pLength - caret);
+	}
+
+	public String readRS2String() {
+		int start = caret;
+		while (pData[caret++] != 0) {
+			;
+		}
+		return new String(pData, start, caret - start - 1);
+	}
+
+	public void readBytes(byte[] buf, int off, int len) {
+		for (int i = 0; i < len; i++) {
+			buf[off + i] = pData[caret++];
+		}
+	}
+
+	/**
+	 * Reads a string of the specified length from the payload.
+	 * 
+	 * @param length
+	 *            The length of the string to be read
+	 * @return A <code>String</code>
+	 */
+	public String readString(int length) {
+		String rv = new String(pData, caret, length);
+		caret += length;
+		return rv;
+	}
+
+	/**
+	 * Skips the specified number of bytes in the payload.
+	 * 
+	 * @param x
+	 *            The number of bytes to be skipped
+	 */
+	public void skip(int x) {
+		caret += x;
+	}
+
+	public int remaining() {
+		return pData.length - caret;
+	}
+
+	/**
+	 * Returns this packet in string form.
+	 * 
+	 * @return A <code>String</code> representing this packet
+	 */
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		sb.append("[id=" + pID + ",len=" + pLength + ",data=0x");
+		for (int x = 0; x < pLength; x++) {
+			sb.append(byteToHex(pData[x], true));
+		}
+		sb.append("]");
+		return sb.toString();
+	}
+
+	private static String byteToHex(byte b, boolean forceLeadingZero) {
+		StringBuilder out = new StringBuilder();
+		int ub = b & 0xff;
+		if (ub / 16 > 0 || forceLeadingZero) {
+			out.append(hex[ub / 16]);
+		}
+		out.append(hex[ub % 16]);
+		return out.toString();
+	}
+
+	private static final char[] hex = "0123456789ABCDEF".toCharArray();
+
+	public int readShortA() {
+		caret += 2;
+		return ((pData[caret - 2] & 0xFF) << 8)
+				+ (pData[caret - 1] - 128 & 0xFF);
+	}
+
+	public byte readByteC() {
+		return (byte) -readByte();
+	}
+
+	public byte readByteS() {
+		return (byte) (128 - readByte());
+	}
+
+}

2006Redone Server/src/redone/net/PacketBuffer.java

@@ -0,0 +1,104 @@
+package redone.net;
+
+/**
+ * Represents a packet buffer.
+ * 
+ * @author Ultimate1
+ * @author blakeman8192
+ */
+
+public class PacketBuffer {
+
+	private int caret;
+	private byte[] buffer;
+
+	public PacketBuffer(int capcity) {
+		buffer = new byte[capcity];
+		caret = 0;
+	}
+
+	public void setBuffer(byte[] buffer) {
+		this.buffer = buffer;
+		caret = 0;
+	}
+
+	public PacketBuffer setOpcode(int opcode) {
+		return addByte(opcode);
+	}
+
+	public PacketBuffer addByte(int i) {
+		buffer[caret++] = (byte) i;
+		return this;
+	}
+
+	public int getByte() {
+		return buffer[caret++] & 0xff;
+	}
+
+	public PacketBuffer addBoolean(boolean val) {
+		return addByte(val == true ? 1 : 0);
+	}
+
+	public boolean getBoolean() {
+		return getByte() == 1;
+	}
+
+	public PacketBuffer addShort(int i) {
+		return addByte(i >> 8).addByte(i);
+	}
+
+	public int getShort() {
+		return getByte() << 8 | getByte();
+	}
+
+	public PacketBuffer addInt(int i) {
+		return addShort(i >> 16).addShort(i);
+	}
+
+	public int getInt() {
+		return getShort() << 16 | getShort();
+	}
+
+	public PacketBuffer addLong(long i) {
+		return addInt((int) (i >> 32)).addInt((int) i);
+	}
+
+	public long getLong() {
+		return (long) getInt() << 32L | getInt();
+	}
+
+	public PacketBuffer addString(String s) {
+		for (byte b : s.getBytes()) {
+			addByte(b);
+		}
+		return addByte('\n');
+	}
+
+	public String getString() {
+		int c;
+		StringBuilder builder = new StringBuilder();
+		while ((c = getByte()) != '\n') {
+			builder.append((char) c);
+		}
+		return builder.toString();
+	}
+
+	public byte[] getBuffer() {
+		byte[] newBuffer = new byte[caret + 1];
+		newBuffer[0] = (byte) caret;
+		System.arraycopy(buffer, 0, newBuffer, 1, caret);
+		return newBuffer;
+	}
+
+	public int getLength() {
+		return buffer.length;
+	}
+
+	public void reset() {
+		caret = 0;
+		for (int i = 0; i < buffer.length; i++) {
+			buffer[i] = 0;
+		}
+		buffer = null;
+	}
+}

2006Redone Server/src/redone/net/PacketBuilder.java

@@ -0,0 +1,10 @@
+package redone.net;
+
+/**
+ * Packet builder interface
+ * 
+ * @author Graham
+ */
+public interface PacketBuilder {
+
+}

2006Redone Server/src/redone/net/RS2LoginProtocolDecoder.java

@@ -0,0 +1,301 @@
+package redone.net;
+
+import java.math.BigInteger;
+import java.net.InetSocketAddress;
+
+import org.apache.mina.common.ByteBuffer;
+import org.apache.mina.common.IoFuture;
+import org.apache.mina.common.IoFutureListener;
+import org.apache.mina.common.IoSession;
+import org.apache.mina.filter.codec.CumulativeProtocolDecoder;
+import org.apache.mina.filter.codec.ProtocolCodecFilter;
+import org.apache.mina.filter.codec.ProtocolDecoderOutput;
+
+import redone.Connection;
+import redone.Constants;
+import redone.Server;
+import redone.game.players.Client;
+import redone.game.players.PlayerHandler;
+import redone.game.players.PlayerSave;
+import redone.util.HostBlacklist;
+import redone.util.ISAACRandomGen;
+
+/**
+ * Login protocol decoder.
+ * 
+ * @author Graham
+ * @author Ryan / Lmctruck30 <- login Protocol fixes
+ */
+
+public class RS2LoginProtocolDecoder extends CumulativeProtocolDecoder {
+	
+	private static final BigInteger RSA_MODULUS = new BigInteger("91553247461173033466542043374346300088148707506479543786501537350363031301992107112953015516557748875487935404852620239974482067336878286174236183516364787082711186740254168914127361643305190640280157664988536979163450791820893999053469529344247707567448479470137716627440246788713008490213212272520901741443");
+	private static final BigInteger RSA_EXPONENT = new BigInteger("33280025241734061313051117678670856264399753710527826596057587687835856000539511539311834363046145710983857746766009612538140077973762171163294453513440619295457626227183742315140865830778841533445402605660729039310637444146319289077374748018792349647460850308384280105990607337322160553135806205784213241305");
+
+
+	/**
+	 * Parses the data in the provided byte buffer and writes it to
+	 * <code>out</code> as a <code>Packet</code>.
+	 * 
+	 * @param session
+	 *            The IoSession the data was read from
+	 * @param in
+	 *            The buffer
+	 * @param out
+	 *            The decoder output stream to which to write the
+	 *            <code>Packet</code>
+	 * @return Whether enough data was available to create a packet
+	 */
+	@Override
+	public boolean doDecode(IoSession session, ByteBuffer in,
+			ProtocolDecoderOutput out) {
+		synchronized (session) {
+			Object loginStageObj = session.getAttribute("LOGIN_STAGE");
+			int loginStage = 0;
+			if (loginStageObj != null) {
+				loginStage = (Integer) loginStageObj;
+			}
+			// Logger.log("recv login packet, stage: "+loginStage);
+			switch (loginStage) {
+			case 0:
+				if (2 <= in.remaining()) {
+					int protocol = in.get() & 0xff;
+					@SuppressWarnings("unused")
+					int nameHash = in.get() & 0xff;
+					if (protocol == 14) {
+						long serverSessionKey = ((long) (java.lang.Math
+								.random() * 99999999D) << 32)
+								+ (long) (java.lang.Math.random() * 99999999D);
+						StaticPacketBuilder s1Response = new StaticPacketBuilder();
+						s1Response
+								.setBare(true)
+								.addBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 })
+								.addByte((byte) 0).addLong(serverSessionKey);
+						session.setAttribute("SERVER_SESSION_KEY",
+								serverSessionKey);
+						session.write(s1Response.toPacket());
+						session.setAttribute("LOGIN_STAGE", 1);
+					}
+					return true;
+				} else {
+					in.rewind();
+					return false;
+				}
+			case 1:
+				@SuppressWarnings("unused")
+				int loginType = -1,
+				loginPacketSize = -1,
+				loginEncryptPacketSize = -1;
+				if (2 <= in.remaining()) {
+					loginType = in.get() & 0xff; // should be 16 or 18
+					loginPacketSize = in.get() & 0xff;
+					loginEncryptPacketSize = loginPacketSize - (36 + 1 + 1 + 2);
+					if (loginPacketSize <= 0 || loginEncryptPacketSize <= 0) {
+						System.out.println("Zero or negative login size.");
+						session.close();
+						return false;
+					}
+				} else {
+					in.rewind();
+					return false;
+				}
+				if (loginPacketSize <= in.remaining()) {
+					int magic = in.get() & 0xff;
+					int version = in.getUnsignedShort();
+					if (magic != 255) {
+						// System.out.println("Wrong magic id.");
+						session.close();
+						return false;
+					}
+					if (version != 1) {
+						// Dont Add Anything
+					}
+					@SuppressWarnings("unused")
+					int lowMem = in.get() & 0xff;
+					for (int i = 0; i < 9; i++) {
+						in.getInt();
+					}
+					loginEncryptPacketSize--;
+					if(loginEncryptPacketSize != (in.get() & 0xff)) {
+						System.out.println("Encrypted size mismatch.");
+						session.close();
+						return false;
+					}
+                    byte[] encryptionBytes = new byte[loginEncryptPacketSize];
+                    in.get(encryptionBytes);
+                    ByteBuffer rsaBuffer = ByteBuffer.wrap(new BigInteger(encryptionBytes).modPow(RSA_EXPONENT, RSA_MODULUS).toByteArray());
+					if((rsaBuffer.get() & 0xff) != 10) {
+						System.out.println("Encrypted id != 10.");
+						session.close();
+						return false;
+					}
+					long clientSessionKey = rsaBuffer.getLong();
+					long serverSessionKey = rsaBuffer.getLong();
+					int uid = rsaBuffer.getInt();
+					if(uid != 314268572) {
+						session.close();
+						return false;
+					}
+					String name = readRS2String(rsaBuffer);
+					String pass = readRS2String(rsaBuffer);
+					int sessionKey[] = new int[4];
+					sessionKey[0] = (int) (clientSessionKey >> 32);
+					sessionKey[1] = (int) clientSessionKey;
+					sessionKey[2] = (int) (serverSessionKey >> 32);
+					sessionKey[3] = (int) serverSessionKey;
+					ISAACRandomGen inC = new ISAACRandomGen(sessionKey);
+					for (int i = 0; i < 4; i++)
+						sessionKey[i] += 50;
+					ISAACRandomGen outC = new ISAACRandomGen(sessionKey);
+					load(session, uid, name, pass, inC, outC, version);
+					session.getFilterChain().remove("protocolFilter");
+					session.getFilterChain().addLast("protocolFilter", new ProtocolCodecFilter(new GameCodecFactory(inC)));
+					return true;
+				} else {
+					in.rewind();
+					return false;
+				}
+			}
+		}
+		return false;
+	}
+
+
+	private synchronized void load(final IoSession session, final int uid,
+			String name, String pass, final ISAACRandomGen inC,
+			ISAACRandomGen outC, int version) {
+		session.setAttribute("opcode", -1);
+		session.setAttribute("size", -1);
+		int returnCode = 2;
+
+		name = name.trim();
+		name = name.toLowerCase();
+	//	pass = pass.toLowerCase();
+
+		String hostName = ((InetSocketAddress) session.getRemoteAddress())
+				.getAddress().getHostName();
+
+		//if (version != 1) {
+			//returnCode = 31;
+		//d}
+
+		if (HostBlacklist.isBlocked(hostName)) {
+			returnCode = 11;
+		}
+
+		if (!name.matches("[A-Za-z0-9 ]+")) {
+			returnCode = 4;
+		}
+
+		if (name.length() > 12) {
+			returnCode = 8;
+		}
+
+		Client cl = new Client(session, -1);
+		cl.playerName = name;
+		cl.playerName2 = cl.playerName;
+		cl.playerPass = pass;
+
+		cl.setInStreamDecryption(inC);
+		cl.setOutStreamDecryption(outC);
+		cl.outStream.packetEncryption = outC;
+		cl.saveCharacter = false;
+		char first = name.charAt(0);
+		cl.properName = Character.toUpperCase(first)
+				+ name.substring(1, name.length());
+
+		if (Connection.isNamedBanned(cl.playerName)) {
+			returnCode = 4;
+		}
+
+
+		if (PlayerHandler.isPlayerOn(name)) {
+			returnCode = 5;
+		}
+
+		if (PlayerHandler.playerCount >= Constants.MAX_PLAYERS) {
+			returnCode = 7;
+		}
+
+		if (Server.UpdateServer) {
+			returnCode = 14;
+		}
+
+		if (returnCode == 2) {
+			int load = PlayerSave.loadGame(cl, cl.playerName, cl.playerPass);
+			if (load == 0) {
+				cl.addStarter = true;
+			}
+			if (load == 3) {
+				returnCode = 3;
+				cl.saveFile = false;
+			} else {
+				for (int i = 0; i < cl.playerEquipment.length; i++) {
+					if (cl.playerEquipment[i] == 0) {
+						cl.playerEquipment[i] = -1;
+						cl.playerEquipmentN[i] = 0;
+					}
+				}
+				if (!Server.playerHandler.newPlayerClient(cl)) {
+					returnCode = 7;
+					cl.saveFile = false;
+				} else {
+					cl.saveFile = true;
+				}
+			}
+		}
+
+		cl.packetType = -1;
+		cl.packetSize = 0;
+
+		StaticPacketBuilder bldr = new StaticPacketBuilder();
+		bldr.setBare(true);
+		bldr.addByte((byte) returnCode);
+		if (returnCode == 2) {
+			cl.saveCharacter = true;
+			if (cl.playerRights == 3) {
+				bldr.addByte((byte) 2);
+			} else {
+				bldr.addByte((byte) cl.playerRights);
+			}
+		} else {
+			bldr.addByte((byte) 0);
+		}
+		bldr.addByte((byte) 0);
+		cl.isActive = true;
+		Packet pkt = bldr.toPacket();
+		session.setAttachment(cl);
+		session.write(pkt).addListener(new IoFutureListener() {
+
+			@Override
+			public void operationComplete(IoFuture arg0) {
+				session.getFilterChain().remove("protocolFilter");
+				session.getFilterChain().addFirst("protocolFilter",
+						new ProtocolCodecFilter(new GameCodecFactory(inC)));
+			}
+		});
+	}
+
+	private synchronized String readRS2String(ByteBuffer in) {
+		StringBuilder sb = new StringBuilder();
+		byte b;
+		while ((b = in.get()) != 10) {
+			sb.append((char) b);
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * Releases the buffer used by the given session.
+	 * 
+	 * @param session
+	 *            The session for which to release the buffer
+	 * @throws Exception
+	 *             if failed to dispose all resources
+	 */
+	@Override
+	public void dispose(IoSession session) throws Exception {
+		super.dispose(session);
+	}
+
+}

2006Redone Server/src/redone/net/RS2ProtocolDecoder.java

@@ -0,0 +1,145 @@
+package redone.net;
+
+import org.apache.mina.common.ByteBuffer;
+import org.apache.mina.common.IoSession;
+import org.apache.mina.filter.codec.CumulativeProtocolDecoder;
+import org.apache.mina.filter.codec.ProtocolDecoderOutput;
+
+import redone.game.players.Client;
+import redone.util.ISAACRandomGen;
+
+public class RS2ProtocolDecoder extends CumulativeProtocolDecoder {
+
+	private final ISAACRandomGen isaac;
+
+	/**
+	 * To make sure only the CodecFactory can initialise us.
+	 */
+	protected RS2ProtocolDecoder(ISAACRandomGen isaac) {
+		this.isaac = isaac;
+	}
+
+	/**
+	 * Decodes a message.
+	 * 
+	 * @param session
+	 * @param in
+	 * @param out
+	 * @return
+	 */
+	@Override
+	protected boolean doDecode(IoSession session, ByteBuffer in,
+			ProtocolDecoderOutput out) throws Exception {
+		synchronized (session) {
+			/*
+			 * Fetch the ISAAC cipher for this session.
+			 */
+			// ISAACRandomGen inCipher = ((Player)
+			// session.getAttribute("player")).getInStreamDecryption();
+
+			/*
+			 * Fetch any cached opcodes and sizes, reset to -1 if not present.
+			 */
+			int opcode = (Integer) session.getAttribute("opcode");
+			int size = (Integer) session.getAttribute("size");
+
+			/*
+			 * If the opcode is not present.
+			 */
+			if (opcode == -1) {
+				/*
+				 * Check if it can be read.
+				 */
+				if (in.remaining() >= 1) {
+					/*
+					 * Read and decrypt the opcode.
+					 */
+					opcode = in.get() & 0xFF;
+					opcode = opcode - isaac.getNextKey() & 0xFF;
+
+					/*
+					 * Find the packet size.
+					 */
+					size = Client.PACKET_SIZES[opcode];
+
+					/*
+					 * Set the cached opcode and size.
+					 */
+					session.setAttribute("opcode", opcode);
+					session.setAttribute("size", size);
+				} else {
+					/*
+					 * We need to wait for more data.
+					 */
+					return false;
+				}
+			}
+
+			/*
+			 * If the packet is variable-length.
+			 */
+			if (size == -1) {
+				/*
+				 * Check if the size can be read.
+				 */
+				if (in.remaining() >= 1) {
+					/*
+					 * Read the packet size and cache it.
+					 */
+					size = in.get() & 0xFF;
+					session.setAttribute("size", size);
+				} else {
+					/*
+					 * We need to wait for more data.
+					 */
+					return false;
+				}
+			}
+
+			/*
+			 * If the packet payload (data) can be read.
+			 */
+			if (in.remaining() >= size) {
+				/*
+				 * Read it.
+				 */
+				byte[] data = new byte[size];
+				in.get(data);
+				ByteBuffer payload = ByteBuffer.allocate(data.length);
+				payload.put(data);
+				payload.flip();
+
+				/*
+				 * Produce and write the packet object.
+				 */
+				out.write(new Packet(session, opcode, data));
+
+				/*
+				 * Reset the cached opcode and sizes.
+				 */
+				session.setAttribute("opcode", -1);
+				session.setAttribute("size", -1);
+
+				/*
+				 * Indicate we are ready to read another packet.
+				 */
+				return true;
+			}
+
+			/*
+			 * We need to wait for more data.
+			 */
+			return false;
+		}
+	}
+
+	@Override
+	/**
+	 * Releases resources used by this decoder.
+	 * @param session
+	 */
+	public void dispose(IoSession session) throws Exception {
+		super.dispose(session);
+	}
+
+}

2006Redone Server/src/redone/net/RS2ProtocolEncoder.java

@@ -0,0 +1,82 @@
+package redone.net;
+
+import org.apache.mina.common.ByteBuffer;
+import org.apache.mina.common.IoSession;
+import org.apache.mina.filter.codec.ProtocolEncoder;
+import org.apache.mina.filter.codec.ProtocolEncoderOutput;
+
+public class RS2ProtocolEncoder implements ProtocolEncoder {
+
+	/**
+	 * Only CodecFactory can create us.
+	 */
+	protected RS2ProtocolEncoder() {
+	}
+
+	@Override
+	/**
+	 * Encodes a message.
+	 * @param session
+	 * @param message
+	 * @param out
+	 */
+	public void encode(IoSession session, Object message,
+			ProtocolEncoderOutput out) throws Exception {
+		try {
+			synchronized (session) {
+				Packet p = (Packet) message;
+				byte[] data = p.getData();
+				int dataLength = p.getLength();
+				ByteBuffer buffer;
+				if (!p.isBare()) {
+					buffer = ByteBuffer.allocate(dataLength + 3);
+					int id = p.getId();
+					buffer.put((byte) id);
+					if (p.getSize() != Packet.Size.Fixed) { // variable length
+						// Logger.log("variable length: id="+id+",dataLength="+dataLength);
+						if (p.getSize() == Packet.Size.VariableByte) {
+							if (dataLength > 255) {
+								// then we can represent
+								// with 8 bits!
+								throw new IllegalArgumentException(
+										"Tried to send packet length "
+												+ dataLength
+												+ " in 8 bits [pid="
+												+ p.getId() + "]");
+							}
+							buffer.put((byte) dataLength);
+						} else if (p.getSize() == Packet.Size.VariableShort) {
+							if (dataLength > 65535) {
+								// then we can represent
+								// with 16 bits!
+								throw new IllegalArgumentException(
+										"Tried to send packet length "
+												+ dataLength
+												+ " in 16 bits [pid="
+												+ p.getId() + "]");
+							}
+							buffer.put((byte) (dataLength >> 8));
+							buffer.put((byte) dataLength);
+						}
+					}
+				} else {
+					buffer = ByteBuffer.allocate(dataLength);
+				}
+				buffer.put(data, 0, dataLength);
+				buffer.flip();
+				out.write(buffer);
+			}
+		} catch (Exception err) {
+			err.printStackTrace();
+		}
+	}
+
+	@Override
+	/**
+	 * Releases resources used by this encoder.
+	 * @param session
+	 */
+	public void dispose(IoSession session) throws Exception {
+	}
+
+}

2006Redone Server/src/redone/net/StaticPacketBuilder.java

@@ -0,0 +1,385 @@
+package redone.net;
+
+/**
+ * A mutable sequence of bytes used to construct the immutable
+ * <code>Packet</code> objects. By default, methods use big endian byte
+ * ordering.
+ */
+public class StaticPacketBuilder implements PacketBuilder {
+
+	/**
+	 * Default capacity
+	 */
+	private static final int DEFAULT_SIZE = 32;
+	/**
+	 * The payload buffer
+	 */
+	private byte[] payload;
+	/**
+	 * Current number of bytes used in the buffer
+	 */
+	private int curLength;
+	/**
+	 * ID of the packet
+	 */
+	private int id;
+	/**
+	 * Current index into the buffer by bits
+	 */
+	private int bitPosition = 0;
+	private Packet.Size size = Packet.Size.Fixed;
+	/**
+	 * Whether this packet does not use the standard packet header
+	 */
+	private boolean bare = false;
+
+	/**
+	 * Bitmasks for <code>addBits()</code>
+	 */
+	private static int bitmasks[] = { 0, 0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f,
+			0xff, 0x1ff, 0x3ff, 0x7ff, 0xfff, 0x1fff, 0x3fff, 0x7fff, 0xffff,
+			0x1ffff, 0x3ffff, 0x7ffff, 0xfffff, 0x1fffff, 0x3fffff, 0x7fffff,
+			0xffffff, 0x1ffffff, 0x3ffffff, 0x7ffffff, 0xfffffff, 0x1fffffff,
+			0x3fffffff, 0x7fffffff, -1 };
+
+	/**
+	 * Constructs a packet builder with no data and an initial capacity of
+	 * <code>DEFAULT_SIZE</code>.
+	 * 
+	 * @see DEFAULT_SIZE
+	 */
+	public StaticPacketBuilder() {
+		this(DEFAULT_SIZE);
+	}
+
+	public byte[] getPayload() {
+		return payload;
+	}
+
+	/**
+	 * Constructs a packet builder with no data and an initial capacity of
+	 * <code>capacity</code>.
+	 * 
+	 * @param capacity
+	 *            The initial capacity of the buffer
+	 */
+	public StaticPacketBuilder(int capacity) {
+		payload = new byte[capacity];
+	}
+
+	/**
+	 * Ensures that the buffer is at least <code>minimumBytes</code> bytes.
+	 * 
+	 * @param minimumCapacity
+	 *            The size needed
+	 */
+	private void ensureCapacity(int minimumCapacity) {
+		if (minimumCapacity >= payload.length) {
+			expandCapacity(minimumCapacity);
+		}
+	}
+
+	/**
+	 * Expands the buffer to the specified size.
+	 * 
+	 * @param minimumCapacity
+	 *            The minimum capacity to which to expand
+	 * @see java.lang.AbstractStringBuilder#expandCapacity(int)
+	 */
+	private void expandCapacity(int minimumCapacity) {
+		int newCapacity = (payload.length + 1) * 2;
+		if (newCapacity < 0) {
+			newCapacity = Integer.MAX_VALUE;
+		} else if (minimumCapacity > newCapacity) {
+			newCapacity = minimumCapacity;
+		}
+		byte[] newPayload = new byte[newCapacity];
+		try {
+			while (curLength > payload.length) {
+				curLength--;
+			}
+			System.arraycopy(payload, 0, newPayload, 0, curLength);
+		} catch (Exception e) {
+
+		}
+		payload = newPayload;
+	}
+
+	/**
+	 * Sets this packet as bare. A bare packet will contain only the payload
+	 * data, rather than having the standard packet header prepended.
+	 * 
+	 * @param bare
+	 *            Whether this packet is to be sent bare
+	 */
+	public StaticPacketBuilder setBare(boolean bare) {
+		this.bare = bare;
+		return this;
+	}
+
+	/**
+	 * Sets the ID for this packet.
+	 * 
+	 * @param id
+	 *            The ID of the packet
+	 */
+	public StaticPacketBuilder setId(int id) {
+		this.id = id;
+		return this;
+	}
+
+	public StaticPacketBuilder setSize(Packet.Size s) {
+		size = s;
+		return this;
+	}
+
+	public StaticPacketBuilder initBitAccess() {
+		bitPosition = curLength * 8;
+		return this;
+	}
+
+	public StaticPacketBuilder finishBitAccess() {
+		curLength = (bitPosition + 7) / 8;
+		return this;
+	}
+
+	/**
+	 * TODO needs a proper description.
+	 */
+	public StaticPacketBuilder addBits(int numBits, int value) {
+		int bytePos = bitPosition >> 3;
+		int bitOffset = 8 - (bitPosition & 7);
+		bitPosition += numBits;
+		curLength = (bitPosition + 7) / 8;
+		ensureCapacity(curLength);
+		for (; numBits > bitOffset; bitOffset = 8) {
+			payload[bytePos] &= ~bitmasks[bitOffset]; // mask out the desired
+														// area
+			payload[bytePos++] |= value >> numBits - bitOffset
+					& bitmasks[bitOffset];
+
+			numBits -= bitOffset;
+		}
+		if (numBits == bitOffset) {
+			payload[bytePos] &= ~bitmasks[bitOffset];
+			payload[bytePos] |= value & bitmasks[bitOffset];
+		} else {
+			payload[bytePos] &= ~(bitmasks[numBits] << bitOffset - numBits);
+			payload[bytePos] |= (value & bitmasks[numBits]) << bitOffset
+					- numBits;
+		}
+		return this;
+	}
+
+	/**
+	 * Adds the contents of <code>byte</code> array <code>data</code> to the
+	 * packet. The size of this packet will grow by the length of the provided
+	 * array.
+	 * 
+	 * @param data
+	 *            The bytes to add to this packet
+	 * @return A reference to this object
+	 */
+	public StaticPacketBuilder addBytes(byte[] data) {
+		return addBytes(data, 0, data.length);
+	}
+
+	/**
+	 * Adds the contents of <code>byte</code> array <code>data</code>, starting
+	 * at index <code>offset</code>. The size of this packet will grow by
+	 * <code>len</code> bytes.
+	 * 
+	 * @param data
+	 *            The bytes to add to this packet
+	 * @param offset
+	 *            The index of the first byte to append
+	 * @param len
+	 *            The number of bytes to append
+	 * @return A reference to this object
+	 */
+	public StaticPacketBuilder addBytes(byte[] data, int offset, int len) {
+		int newLength = curLength + len;
+		ensureCapacity(newLength);
+		System.arraycopy(data, offset, payload, curLength, len);
+		curLength = newLength;
+		return this;
+	}
+
+	public StaticPacketBuilder addLEShortA(int i) {
+		ensureCapacity(curLength + 2);
+		addByte((byte) (i + 128), false);
+		addByte((byte) (i >> 8), false);
+		return this;
+	}
+
+	public StaticPacketBuilder addShortA(int i) {
+		ensureCapacity(curLength + 2);
+		addByte((byte) (i >> 8), false);
+		addByte((byte) (i + 128), false);
+		return this;
+	}
+
+	/**
+	 * Adds a <code>byte</code> to the data buffer. The size of this packet will
+	 * grow by one byte.
+	 * 
+	 * @param val
+	 *            The <code>byte</code> value to add
+	 * @return A reference to this object
+	 */
+	public StaticPacketBuilder addByte(byte val) {
+		return addByte(val, true);
+	}
+
+	public StaticPacketBuilder addByteA(int i) {
+		return addByte((byte) (i + 128), true);
+	}
+
+	/**
+	 * Adds a <code>byte</code> to the data buffer. The size of this packet will
+	 * grow by one byte.
+	 * 
+	 * @param val
+	 *            The <code>byte</code> value to add
+	 * @param checkCapacity
+	 *            Whether the buffer capacity should be checked
+	 * @return A reference to this object
+	 */
+	private StaticPacketBuilder addByte(byte val, boolean checkCapacity) {
+		if (checkCapacity) {
+			ensureCapacity(curLength + 1);
+		}
+		payload[curLength++] = val;
+		return this;
+	}
+
+	/**
+	 * Adds a <code>short</code> to the data stream. The size of this packet
+	 * will grow by two bytes.
+	 * 
+	 * @param val
+	 *            The <code>short</code> value to add
+	 * @return A reference to this object
+	 */
+	public StaticPacketBuilder addShort(int val) {
+		ensureCapacity(curLength + 2);
+		addByte((byte) (val >> 8), false);
+		addByte((byte) val, false);
+		return this;
+	}
+
+	public StaticPacketBuilder addLEShort(int val) {
+		ensureCapacity(curLength + 2);
+		addByte((byte) val, false);
+		addByte((byte) (val >> 8), false);
+		return this;
+	}
+
+	public StaticPacketBuilder setShort(int val, int offset) {
+		payload[offset++] = (byte) (val >> 8);
+		payload[offset++] = (byte) val;
+		if (curLength < offset + 2) {
+			curLength += 2;
+		}
+		return this;
+	}
+
+	/**
+	 * Adds a <code>int</code> to the data stream. The size of this packet will
+	 * grow by four bytes.
+	 * 
+	 * @param val
+	 *            The <code>int</code> value to add
+	 * @return A reference to this object
+	 */
+	public StaticPacketBuilder addInt(int val) {
+		ensureCapacity(curLength + 4);
+		addByte((byte) (val >> 24), false);
+		addByte((byte) (val >> 16), false);
+		addByte((byte) (val >> 8), false);
+		addByte((byte) val, false);
+		return this;
+	}
+
+	public StaticPacketBuilder addInt1(int val) {
+		ensureCapacity(curLength + 4);
+		addByte((byte) (val >> 8), false);
+		addByte((byte) val, false);
+		addByte((byte) (val >> 24), false);
+		addByte((byte) (val >> 16), false);
+		return this;
+	}
+
+	public StaticPacketBuilder addInt2(int val) {
+		ensureCapacity(curLength + 4);
+		addByte((byte) (val >> 16), false);
+		addByte((byte) (val >> 24), false);
+		addByte((byte) val, false);
+		addByte((byte) (val >> 8), false);
+		return this;
+	}
+
+	public StaticPacketBuilder addLEInt(int val) {
+		ensureCapacity(curLength + 4);
+		addByte((byte) val, false);
+		addByte((byte) (val >> 8), false);
+		addByte((byte) (val >> 16), false);
+		addByte((byte) (val >> 24), false);
+		return this;
+	}
+
+	/**
+	 * Adds a <code>long</code> to the data stream. The size of this packet will
+	 * grow by eight bytes.
+	 * 
+	 * @param val
+	 *            The <code>long</code> value to add
+	 * @return A reference to this object
+	 */
+	public StaticPacketBuilder addLong(long val) {
+		addInt((int) (val >> 32));
+		addInt((int) (val & -1L));
+		return this;
+	}
+
+	public StaticPacketBuilder addLELong(long val) {
+		addLEInt((int) (val & -1L));
+		addLEInt((int) (val >> 32));
+		return this;
+	}
+
+	@SuppressWarnings("deprecation")
+	public StaticPacketBuilder addString(String s) {
+		ensureCapacity(curLength + s.length() + 1);
+		s.getBytes(0, s.length(), payload, curLength);
+		curLength += s.length();
+		payload[curLength++] = 0;
+		return this;
+	}
+
+	public int getLength() {
+		return curLength;
+	}
+
+	/**
+	 * Returns a <code>Packet</code> object for the data contained in this
+	 * builder.
+	 * 
+	 * @return A <code>Packet</code> object
+	 */
+	public Packet toPacket() {
+		byte[] data = new byte[curLength];
+		System.arraycopy(payload, 0, data, 0, curLength);
+		return new Packet(null, id, data, bare, size);
+	}
+
+	public StaticPacketBuilder addByteC(int val) {
+		addByte((byte) -val);
+		return this;
+	}
+
+	public StaticPacketBuilder addByteS(int val) {
+		addByte((byte) (128 - val));
+		return this;
+	}
+}

2006Redone Server/src/redone/net/packets/PacketHandler.java

@@ -0,0 +1,176 @@
+package redone.net.packets;
+
+import redone.Constants;
+import redone.game.dialogues.Dialogue;
+import redone.game.players.Client;
+import redone.net.packets.impl.AttackPlayer;
+import redone.net.packets.impl.Bank10;
+import redone.net.packets.impl.Bank5;
+import redone.net.packets.impl.BankAll;
+import redone.net.packets.impl.BankX1;
+import redone.net.packets.impl.BankX2;
+import redone.net.packets.impl.ChallengePlayer;
+import redone.net.packets.impl.ChangeAppearance;
+import redone.net.packets.impl.ChangeRegions;
+import redone.net.packets.impl.Chat;
+import redone.net.packets.impl.ClanChat;
+import redone.net.packets.impl.ClickItem;
+import redone.net.packets.impl.ClickNPC;
+import redone.net.packets.impl.ClickObject;
+import redone.net.packets.impl.ClickTab;
+import redone.net.packets.impl.ClickingButtons;
+import redone.net.packets.impl.ClickingInGame;
+import redone.net.packets.impl.ClickingStuff;
+import redone.net.packets.impl.Commands;
+import redone.net.packets.impl.DropItem;
+import redone.net.packets.impl.FollowPlayer;
+import redone.net.packets.impl.IdleLogout;
+import redone.net.packets.impl.ItemClick2;
+import redone.net.packets.impl.ItemClick2OnGroundItem;
+import redone.net.packets.impl.ItemClick3;
+import redone.net.packets.impl.ItemOnGroundItem;
+import redone.net.packets.impl.ItemOnItem;
+import redone.net.packets.impl.ItemOnNpc;
+import redone.net.packets.impl.ItemOnObject;
+import redone.net.packets.impl.ItemOnPlayer;
+import redone.net.packets.impl.MagicOnFloorItems;
+import redone.net.packets.impl.MagicOnItems;
+import redone.net.packets.impl.MoveItems;
+import redone.net.packets.impl.PickupItem;
+import redone.net.packets.impl.PrivateMessaging;
+import redone.net.packets.impl.RemoveItem;
+import redone.net.packets.impl.Report;
+import redone.net.packets.impl.SilentPacket;
+import redone.net.packets.impl.Trade;
+import redone.net.packets.impl.Walking;
+import redone.net.packets.impl.WearItem;
+
+public class PacketHandler {
+
+	private static PacketType packetId[] = new PacketType[256];
+
+	static {
+
+		SilentPacket u = new SilentPacket();
+		packetId[3] = u;
+		packetId[202] = u;
+		packetId[77] = u;
+		packetId[86] = u;
+		packetId[78] = u;
+		packetId[36] = u;
+		packetId[226] = u;
+		packetId[246] = u;
+		packetId[148] = u;
+		packetId[183] = u;
+		packetId[230] = u;
+		packetId[136] = u;
+		packetId[189] = u;
+		packetId[152] = u;
+		packetId[200] = u;
+		packetId[85] = u;
+		packetId[165] = u;
+		packetId[238] = u;
+		packetId[150] = u;
+		packetId[60] = new ClanChat();
+		packetId[120] = new ClickTab();
+		packetId[14] = new ItemOnPlayer();
+		packetId[40] = new Dialogue();
+		ClickObject co = new ClickObject();
+		packetId[132] = co;
+		packetId[252] = co;
+		packetId[70] = co;
+		packetId[234] = co;
+		packetId[57] = new ItemOnNpc();
+		ClickNPC cn = new ClickNPC();
+		packetId[72] = cn;
+		packetId[131] = cn;
+		packetId[155] = cn;
+		packetId[17] = cn;
+		packetId[21] = cn;
+		packetId[218] = new Report();
+		packetId[16] = new ItemClick2();
+		packetId[75] = new ItemClick3();
+		packetId[122] = new ClickItem();
+		packetId[241] = new ClickingInGame();
+		packetId[4] = new Chat();
+		packetId[236] = new PickupItem();
+		packetId[87] = new DropItem();
+		packetId[185] = new ClickingButtons();
+		packetId[130] = new ClickingStuff();
+		packetId[103] = new Commands();
+		packetId[214] = new MoveItems();
+		packetId[237] = new MagicOnItems();
+		packetId[181] = new MagicOnFloorItems();
+		packetId[202] = new IdleLogout();
+		AttackPlayer ap = new AttackPlayer();
+		packetId[73] = ap;
+		packetId[249] = ap;
+		packetId[128] = new ChallengePlayer();
+		packetId[139] = new Trade();
+		packetId[39] = new FollowPlayer();
+		packetId[41] = new WearItem();
+		packetId[145] = new RemoveItem();
+		packetId[117] = new Bank5();
+		packetId[43] = new Bank10();
+		packetId[129] = new BankAll();
+		packetId[101] = new ChangeAppearance();
+		PrivateMessaging pm = new PrivateMessaging();
+		packetId[188] = pm;
+		packetId[126] = pm;
+		packetId[215] = pm;
+		packetId[59] = pm;
+		packetId[95] = pm;
+		packetId[133] = pm;
+		packetId[135] = new BankX1();
+		packetId[208] = new BankX2();
+		Walking w = new Walking();
+		packetId[98] = w;
+		packetId[164] = w;
+		packetId[248] = w;
+		packetId[53] = new ItemOnItem();
+		packetId[192] = new ItemOnObject();
+		packetId[25] = new ItemOnGroundItem();
+		ChangeRegions cr = new ChangeRegions();
+		packetId[121] = cr;
+		packetId[210] = cr;
+		packetId[253] = new ItemClick2OnGroundItem();
+		// packetId[ContinueDialoguePacketHandler.CONTINUE] = new
+		// ContinueDialoguePacketHandler();
+	}
+
+	/*public static void processPacket(Client c, int packetType, int packetSize) {
+		if (packetType == -1) {
+			return;
+		}
+		PacketType p = packetId[packetType];
+		if (p != null) {
+			try {
+				// System.out.println("packet: " + packetType);
+				p.processPacket(c, packetType, packetSize);
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		} else {
+			System.out.println("Unhandled packet type: " + packetType
+					+ " - size: " + packetSize);
+		}
+	}*/
+	
+	public static void processPacket(Client c, int packetType, int packetSize) {
+        PacketType p = packetId[packetType];
+        if(p != null && packetType > 0 && packetType < 257 && packetType == c.packetType && packetSize == c.packetSize) {
+            if (Constants.sendServerPackets && c.playerRights == 3) {
+                c.getActionSender().sendMessage("PacketType: " + packetType + ". PacketSize: " + packetSize + ".");
+            }
+            try {
+                p.processPacket(c, packetType, packetSize);
+            } catch(Exception e) {
+                e.printStackTrace();
+            }
+        } else {
+            c.disconnected = true;
+            System.out.println(c.playerName + "is sending invalid PacketType: " + packetType + ". PacketSize: " + packetSize);
+        }
+    }
+
+}

2006Redone Server/src/redone/net/packets/PacketType.java

@@ -0,0 +1,8 @@
+package redone.net.packets;
+
+import redone.game.players.Client;
+
+public interface PacketType {
+
+	public void processPacket(Client c, int packetType, int packetSize);
+}

2006Redone Server/src/redone/net/packets/impl/AttackPlayer.java

@@ -0,0 +1,309 @@
+package redone.net.packets.impl;
+
+import redone.Constants;
+import redone.game.content.combat.magic.CastOnOther;
+import redone.game.content.combat.magic.MagicData;
+import redone.game.content.combat.range.RangeData;
+import redone.game.items.ItemAssistant;
+import redone.game.players.Client;
+import redone.game.players.PlayerHandler;
+import redone.net.packets.PacketType;
+
+/**
+ * Attack Player
+ **/
+public class AttackPlayer implements PacketType {
+
+	public static final int ATTACK_PLAYER = 73, MAGE_PLAYER = 249;
+
+	@Override
+	public void processPacket(Client c, int packetType, int packetSize) {
+		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.isBotting == true) {
+				c.getActionSender().sendMessage("You can't attack players, until you confirm you are not botting.");
+				c.getActionSender().sendMessage("If you need to you can type ::amibotting, to see if your botting.");
+				return;
+			}
+
+			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.getActionSender().sendMessage(
+							"The duel hasn't started yet!");
+					c.playerIndex = 0;
+					return;
+				}
+				if (c.duelRule[9]) {
+					boolean canUseWeapon = false;
+					for (int funWeapon : Constants.FUN_WEAPONS) {
+						if (c.playerEquipment[c.playerWeapon] == funWeapon) {
+							canUseWeapon = true;
+						}
+					}
+					if (!canUseWeapon) {
+						c.getActionSender().sendMessage(
+								"You can only use fun weapons in this duel!");
+						return;
+					}
+				}
+
+				if (c.duelRule[2] && (usingBow || usingOtherRangeWeapons)) {
+					c.getActionSender().sendMessage(
+							"Range has been disabled in this duel!");
+					return;
+				}
+				if (c.duelRule[3] && !usingBow && !usingOtherRangeWeapons) {
+					c.getActionSender().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.getActionSender().sendMessage(
+						"You have run out of arrows!");
+				return;
+			}
+			if (RangeData.correctBowAndArrows(c) < c.playerEquipment[c.playerArrows]
+					&& Constants.CORRECT_ARROWS
+					&& usingBow
+					&& !RangeData.usingCrystalBow(c)
+					&& c.playerEquipment[c.playerWeapon] != 9185) {
+				c.getActionSender().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.getActionSender().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;
+			}
+			if (c.isBotting == true) {
+				c.getActionSender().sendMessage("You can't mage players, until you confirm you are not botting.");
+				c.getActionSender().sendMessage("If you need to you can type ::amibotting, to see if your botting.");
+				return;
+			}
+			// c.usingSpecial = false;
+			// c.getItems().updateSpecialBar();
+
+			c.playerIndex = c.getInStream().readSignedWordA();
+			int castingSpellId = c.getInStream().readSignedWordBigEndian();
+			c.usingMagic = false;
+
+			boolean teleother = CastOnOther.castOnOtherSpells(c);
+
+			if (PlayerHandler.players[c.playerIndex] == null) {
+				break;
+			}
+
+			if (c.respawnTimer > 0) {
+				break;
+			}
+
+			if (c.playerRights == 3) {
+				c.getActionSender().sendMessage(
+						"Casting Spell id: " + c.castingSpellId + ".");
+			}
+			switch (c.castingSpellId) {
+			case 12425:
+				CastOnOther.teleOtherDistance(c, 1, 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();
+				if (c.inTrade) {
+					c.getTrading().declineTrade(true);
+				}
+			}
+
+			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.getActionSender().sendMessage(
+								"The duel hasn't started yet!");
+						c.playerIndex = 0;
+						return;
+					}
+					if (c.duelRule[4]) {
+						c.getActionSender().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.getActionSender()
+									.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.getActionSender().sendMessage(
+							"That player is already affected by this spell.");
+					c.usingMagic = false;
+					c.stopMovement();
+					c.getCombatAssistant().resetPlayerAttack();
+				}
+
+				if (c.usingMagic) {
+					if (c.goodDistance(c.getX(), c.getY(),
+							PlayerHandler.players[c.playerIndex].getX(),
+							PlayerHandler.players[c.playerIndex].getY(), 7)) {
+						c.stopMovement();
+					}
+					if (c.getCombatAssistant().checkReqs()) {
+						c.followId = c.playerIndex;
+						c.mageFollow = true;
+					}
+				}
+			}
+			break;
+
+		}
+
+	}
+
+}

2006Redone Server/src/redone/net/packets/impl/Bank10.java

@@ -0,0 +1,98 @@
+package redone.net.packets.impl;
+
+import redone.game.content.random.PartyRoom;
+import redone.game.content.skills.crafting.JewelryMaking;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+/**
+ * Bank 10 Items
+ **/
+public class Bank10 implements PacketType {
+
+	@Override
+	public void processPacket(Client player, int packetType, int packetSize) {
+		int interfaceId = player.getInStream().readUnsignedWordBigEndian();
+		int removeId = player.getInStream().readUnsignedWordA();
+		int removeSlot = player.getInStream().readUnsignedWordA();
+
+		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, 5);
+			break;
+
+		case 3823:
+			if(!player.getItemAssistant().playerHasItem(removeId)) {
+				return;
+			}
+			player.getShopAssistant().sellItem(removeId, removeSlot, 5);
+			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.getActionSender().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/redone/net/packets/impl/Bank5.java

@@ -0,0 +1,97 @@
+package redone.net.packets.impl;
+
+import redone.game.content.random.PartyRoom;
+import redone.game.content.skills.crafting.JewelryMaking;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+/**
+ * Bank 5 Items
+ **/
+public class Bank5 implements PacketType {
+
+	@Override
+	public void processPacket(Client player, int packetType, int packetSize) {
+		int interfaceId = player.getInStream().readSignedWordBigEndianA();
+		int removeId = player.getInStream().readSignedWordBigEndianA();
+		int removeSlot = player.getInStream().readSignedWordBigEndian();
+
+		switch (interfaceId) {
+
+		case 4233:
+		case 4239:
+		case 4245:
+			JewelryMaking.mouldItem(player, removeId, 5);
+			break;
+		case 3900:
+			player.getShopAssistant().buyItem(removeId, removeSlot, 1);
+			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.getActionSender().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/redone/net/packets/impl/BankAll.java

@@ -0,0 +1,134 @@
+package redone.net.packets.impl;
+
+import redone.game.content.random.PartyRoom;
+import redone.game.items.GameItem;
+import redone.game.items.Item;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+/**
+ * Bank All Items
+ **/
+public class BankAll implements PacketType {
+
+	@Override
+	public void processPacket(Client player, int packetType, int packetSize) {
+		int removeSlot = player.getInStream().readUnsignedWordA();
+		int interfaceId = player.getInStream().readUnsignedWord();
+		int removeId = player.getInStream().readUnsignedWordA();
+		switch (interfaceId) {
+		case 3900:
+			player.getShopAssistant().buyItem(removeId, removeSlot, 10);
+			break;
+
+		case 3823:
+			if(!player.getItemAssistant().playerHasItem(removeId)) {
+				return;
+			}
+			player.getShopAssistant().sellItem(removeId, removeSlot, 10);
+			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.getActionSender().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/redone/net/packets/impl/BankX1.java

@@ -0,0 +1,45 @@
+package redone.net.packets.impl;
+
+import redone.game.players.Client;
+import redone.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(Client c, int packetType, int packetSize) {
+		if (packetType == 135) {
+			c.xRemoveSlot = c.getInStream().readSignedWordBigEndian();
+			c.xInterfaceId = c.getInStream().readUnsignedWordA();
+			c.xRemoveId = c.getInStream().readSignedWordBigEndian();
+		}
+		if (c.xInterfaceId == 3900) {
+			c.getShopAssistant().buyItem(c.xRemoveId, c.xRemoveSlot, 20);// buy
+																			// 20
+			c.xRemoveSlot = 0;
+			c.xInterfaceId = 0;
+			c.xRemoveId = 0;
+			return;
+		} 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/redone/net/packets/impl/BankX2.java

@@ -0,0 +1,70 @@
+package redone.net.packets.impl;
+
+import redone.game.content.random.PartyRoom;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+/**
+ * Bank X Items
+ **/
+public class BankX2 implements PacketType {
+
+	@Override
+	public void processPacket(Client player, int packetType, int packetSize) {
+		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.getItemAssistant().playerHasItem(player.playerItems[player.xRemoveSlot], Xamount))
+                return;
+			if (player.inPartyRoom) {
+				PartyRoom.depositItem(player, player.xRemoveId, player.getItemAssistant().itemAmount(player.playerItems[player.xRemoveSlot]));
+				break;
+			}
+			if (player.inTrade) {
+				player.getActionSender().sendMessage("You can't store items while trading!");
+				return;
+			}
+			player.getItemAssistant().bankItem(player.playerItems[player.xRemoveSlot], player.xRemoveSlot, Xamount);
+			break;
+
+		case 5382:
+			if(!player.getItemAssistant().playerHasItem(player.playerItems[player.xRemoveSlot], Xamount))
+                return;
+			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;
+		}
+	}
+}

2006Redone Server/src/redone/net/packets/impl/ChallengePlayer.java

@@ -0,0 +1,36 @@
+package redone.net.packets.impl;
+
+import redone.game.players.Client;
+import redone.game.players.PlayerHandler;
+import redone.net.packets.PacketType;
+
+/**
+ * Challenge Player
+ **/
+public class ChallengePlayer implements PacketType {
+
+	@Override
+	public void processPacket(Client 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.getActionSender().sendMessage("You can't challenge inside the arena!");
+				return;
+			}
+			
+			if (c.isBotting == true) {
+				c.getActionSender().sendMessage("You can't challenge players, until you confirm you are not botting.");
+				c.getActionSender().sendMessage("If you need to you can type ::amibotting, to see if your botting.");
+				return;
+			}
+			if (c.inDuelArena()) {
+				c.getDueling().requestDuel(answerPlayer);
+			}
+			break;
+		}
+	}
+}

2006Redone Server/src/redone/net/packets/impl/ChangeAppearance.java

@@ -0,0 +1,90 @@
+package redone.net.packets.impl;
+
+import redone.game.players.Client;
+import redone.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 Client 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.getPlayerAssistant().removeAllWindows();
+			client.getPlayerAssistant().requestUpdates();
+			client.canChangeAppearance = false;
+		}
+	}
+
+}

2006Redone Server/src/redone/net/packets/impl/ChangeRegions.java

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

2006Redone Server/src/redone/net/packets/impl/Chat.java

@@ -0,0 +1,32 @@
+package redone.net.packets.impl;
+
+import redone.Connection;
+import redone.game.players.Client;
+import redone.game.players.antimacro.AntiSpam;
+import redone.net.packets.PacketType;
+import redone.util.Misc;
+
+/**
+ * Chat
+ **/
+public class Chat implements PacketType {
+
+	@Override
+	public void processPacket(Client 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);
+		}
+		System.out.println(word);
+		if (Connection.isMuted(player)) {
+			player.getActionSender().sendMessage("You are muted and can't speak.");
+			player.setChatTextUpdateRequired(false);
+			return;
+		}
+	}
+}

2006Redone Server/src/redone/net/packets/impl/ClanChat.java

@@ -0,0 +1,20 @@
+package redone.net.packets.impl;
+
+import redone.Server;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+import redone.util.Misc;
+
+/**
+ * Chat
+ **/
+public class ClanChat implements PacketType {
+
+	@Override
+	public void processPacket(Client c, int packetType, int packetSize) {
+		String textSent = Misc.longToPlayerName2(c.getInStream().readQWord());
+		textSent = textSent.replaceAll("_", " ");
+		// c.sendMessage(textSent);
+		Server.clanChat.handleClanChat(c, textSent);
+	}
+}

2006Redone Server/src/redone/net/packets/impl/ClickItem.java

@@ -0,0 +1,293 @@
+package redone.net.packets.impl;
+
+import redone.Server;
+import redone.game.content.consumables.Beverages;
+import redone.game.content.consumables.Kebabs;
+import redone.game.content.consumables.Beverages.beverageData;
+import redone.game.content.minigames.TreasureTrails;
+import redone.game.content.minigames.castlewars.CastleWars;
+import redone.game.content.skills.core.Prayer;
+import redone.game.content.skills.herblore.Herblore;
+import redone.game.items.ItemAssistant;
+import redone.game.items.impl.ExperienceLamp;
+import redone.game.items.impl.Flowers;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+import redone.util.GameLogger;
+import redone.util.Misc;
+
+/**
+ * Clicking an item, bury bone, eat food etc
+ **/
+public class ClickItem implements PacketType {
+
+	@Override
+	public void processPacket(Client player, int packetType, int packetSize) {
+		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();
+		}
+		if (player.isBotting) {
+			player.getActionSender().sendMessage("You can't click items until you confirm you aren't botting.");
+			player.getActionSender().sendMessage("If you need to you can type ::amibotting, to see if your botting.");
+			return;
+		}
+		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
+			Server.npcHandler.spawnNpc2(1532, player.absX, player.absY, player.heightLevel, 0, 200, 0, 0, 100);
+			player.getActionSender().sendMessage("You setup a barricade.");
+		} else if (!CastleWars.isInCw(player) && itemId == 4053) {
+			player.getActionSender().sendMessage("You need to be in castlewars to drop a barricade.");
+			player.getItemAssistant().deleteItem2(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().deleteItem2(407, 1);
+			} else {
+				if (Misc.random(1) == 0) {
+					player.getItemAssistant().addItem(411, 1);
+					player.getItemAssistant().deleteItem2(409, 1);
+				} else if (Misc.random(1) == 1) {
+					player.getItemAssistant().addItem(413, 1);
+					player.getItemAssistant().deleteItem2(407, 1);
+				}
+			}
+		break;
+		
+		case 2329:
+			player.getItemAssistant().deleteItem2(2329, 1);
+			player.getItemAssistant().addItem(2313, 1);
+		break;
+		
+		case 550:
+			player.getPlayerAssistant().showMap();
+		break;
+		
+		  case 583:
+	            Server.trawler.bail(player);
+	            break;
+	        case 585:
+	            Server.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:
+			player.getItemAssistant().deleteItem(itemId, 1);
+			TreasureTrails.addClueReward(player, 0);
+			break;
+
+		case 2678:
+			player.getItemAssistant().deleteItem(itemId, 1);
+			TreasureTrails.addClueReward(player, 1);
+			break;
+
+		case 2679:
+			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().deleteItem2(3691, 1);
+			player.getItemAssistant().addItem(3690, 1);
+			player.getPlayerAssistant().startTeleport(2661, 3310, 0, "modern");
+			break;
+
+		// case 2528:
+		// ExperienceLamp.showInterface(c);
+		// break;
+
+		case 5070:
+			player.getActionSender().sendMessage("You search the nest.");
+			player.getItemAssistant().addItem(5076, 1);
+			player.getItemAssistant().deleteItem(itemId, 1);
+			player.getItemAssistant().addItem(5075, 1);
+			break;
+
+		case 5071:
+			player.getActionSender().sendMessage("You search the nest.");
+			player.getItemAssistant().addItem(5078, 1);
+			player.getItemAssistant().deleteItem(itemId, 1);
+			player.getItemAssistant().addItem(5075, 1);
+			break;
+
+		case 5072:
+			player.getActionSender().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().deleteItem2(2297, 1);
+			break;
+
+		case 2299:
+			player.getItemAssistant().deleteItem2(2299, 1);
+			break;
+
+		case 2301:
+			player.getItemAssistant().addItem(2303, 1);
+			player.getItemAssistant().deleteItem2(2301, 1);
+			break;
+
+		case 2303:
+			player.getItemAssistant().deleteItem2(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().deleteItem2(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/redone/net/packets/impl/ClickNPC.java

@@ -0,0 +1,363 @@
+package redone.net.packets.impl;
+
+import redone.Constants;
+import redone.event.CycleEvent;
+import redone.event.CycleEventContainer;
+import redone.event.CycleEventHandler;
+import redone.game.content.combat.magic.MagicData;
+import redone.game.content.combat.range.RangeData;
+import redone.game.content.skills.thieving.Pickpocket;
+import redone.game.items.ItemAssistant;
+import redone.game.npcs.NpcHandler;
+import redone.game.players.Client;
+import redone.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 Client 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();
+		switch (packetType) {
+
+		/**
+		 * Attack npc melee or range
+		 **/
+		case ATTACK_NPC:
+			if (client.tutorialProgress == 24) {
+				client.getActionSender().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.getActionSender().chatbox(6179);
+
+			}
+			if (client.tutorialProgress == 33) {
+				client.getActionSender()
+						.sendMessage(
+								"You can't range these chickens you have to mage them!");
+				return;
+			}
+			if (!client.mageAllowed) {
+				client.mageAllowed = true;
+				client.getActionSender().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.getActionSender().sendMessage(
+						"You have run out of arrows!");
+				break;
+			}
+			if (RangeData.correctBowAndArrows(client) < client.playerEquipment[client.playerArrows]
+					&& Constants.CORRECT_ARROWS
+					&& usingBow
+					&& !RangeData.usingCrystalBow(client)
+					&& client.playerEquipment[client.playerWeapon] != 9185) {
+				client.getActionSender().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.getActionSender().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.getActionSender().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.getActionSender().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.getActionSender().createArrow(1, 9);
+			}
+			if (!client.mageAllowed) {
+				client.mageAllowed = true;
+				client.getActionSender().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.getActionSender().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/redone/net/packets/impl/ClickTab.java

@@ -0,0 +1,149 @@
+package redone.net.packets.impl;
+
+import redone.game.items.ItemAssistant;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+public class ClickTab implements PacketType {
+
+	@Override
+	public void processPacket(final Client c, int packetType, int packetSize) {
+		switch (packetSize) {
+		case 1:// first part.
+			if (c.tutorialProgress == 0) { // wrench
+				c.getActionSender().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.getActionSender().chatbox(6179);
+				c.tutorialProgress = 1;
+			} else if (c.tutorialProgress == 3) { // backpack
+				c.getActionSender().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.getActionSender().createArrow(3099, 3095, c.getH(), 2);
+				c.getActionSender().chatbox(6179);
+			} else if (c.tutorialProgress == 4) { // Skills tab
+				c.getActionSender().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.getActionSender().chatbox(6179);
+				c.getActionSender().createArrow(1, 2);
+			} else if (c.tutorialProgress == 9) { // Music tab
+				c.getActionSender().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.getActionSender().createArrow(3073, 3090, c.getH(), 2);
+				c.tutorialProgress = 10;
+				c.getActionSender().chatbox(6179);
+			} else if (c.tutorialProgress == 10) { // Emotes aNd running
+				c.getActionSender().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.getActionSender().chatbox(6179);
+			} else if (c.tutorialProgress == 12) { // Quest Tab
+				c.getActionSender().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.getActionSender().chatbox(6179);
+			} else if (c.tutorialProgress == 21) { // Worn inventory
+				c.getActionSender().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.getActionSender().chatbox(6179);
+				c.tutorialProgress = 22;
+			} else if (c.tutorialProgress == 23) { // Attack syle tabs
+				c.getActionSender().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.getActionSender().chatbox(6179);
+				c.getItemAssistant()
+						.sendWeapon(
+								c.playerEquipment[c.playerWeapon],
+								ItemAssistant
+										.getItemName(c.playerEquipment[c.playerWeapon]));
+				c.getActionSender().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.getActionSender().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.getActionSender().setSidebarInterface(9, 5715);
+				c.getActionSender().flashSideBarIcon(-9);
+				c.tutorialProgress = 31;
+				c.getActionSender().chatbox(6179);
+			} else if (c.tutorialProgress == 31) { // ignores tab
+				c.getActionSender().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.getActionSender().chatbox(6179);
+			} else if (c.tutorialProgress == 32) { // Final magic tab
+				c.tutorialProgress = 33;
+				c.getDialogueHandler().sendDialogues(3108, 946);
+			}
+			break;
+
+		}
+
+	}
+
+}

2006Redone Server/src/redone/net/packets/impl/ClickingInGame.java

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

2006Redone Server/src/redone/net/packets/impl/ClickingStuff.java

@@ -0,0 +1,52 @@
+package redone.net.packets.impl;
+
+import redone.game.players.Client;
+import redone.game.players.PlayerHandler;
+import redone.net.packets.PacketType;
+import redone.util.Misc;
+
+/**
+ * Clicking stuff (interfaces)
+ **/
+public class ClickingStuff implements PacketType {
+
+	@Override
+	public void processPacket(Client 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) {
+			if (!player.acceptedTrade) {
+				Client opponent = (Client) PlayerHandler.players[player.tradeWith];
+				opponent.tradeAccepted = false;
+				player.tradeAccepted = false;
+				opponent.tradeStatus = 0;
+				player.tradeStatus = 0;
+				player.tradeConfirmed = false;
+				player.tradeConfirmed2 = false;
+				player.getActionSender().sendMessage("@red@Trade has been declined.");
+				opponent.getActionSender().sendMessage("@red@Other player has declined the trade.");
+				Misc.println("trade reset");
+				player.getTrading().declineTrade();
+			}
+		}
+
+		if(player.openDuel && player.duelStatus >= 1 && player.duelStatus <= 4) {
+		Client o = (Client) 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/redone/net/packets/impl/Commands.java

@@ -0,0 +1,512 @@
+package redone.net.packets.impl;
+ 
+import redone.Connection;
+import redone.Constants;
+import redone.game.items.ItemAssistant;
+import redone.game.npcs.NpcHandler;
+import redone.game.players.Client;
+import redone.game.players.PlayerHandler;
+import redone.net.packets.PacketType;
+import redone.util.GameLogger;
+import redone.util.Misc;
+import redone.world.clip.Region;
+ 
+public class Commands implements PacketType {
+ 
+        @Override
+        public void processPacket(Client player, int packetType, int packetSize) {
+                String playerCommand = player.getInStream().readString();
+                if ((playerCommand.startsWith("ban") || playerCommand.startsWith("ip") || playerCommand.startsWith("mute") || playerCommand.startsWith("un")) && player.playerRights > 0 && player.playerRights < 4) {
+        			GameLogger.writeLog(player.playerName, "commands", player.playerName + " used command: " + playerCommand + "");
+        		}
+                if (player.playerRights >= 0) {
+                        playerCommands(player, playerCommand);
+                }
+                if (player.membership || player.playerRights > 1) {
+                        donatorCommands(player, playerCommand);
+                }
+                if (player.playerRights >= 1) {
+                        moderatorCommands(player, playerCommand);
+                }
+                if (player.playerRights >= 2 && player.playerRights < 4) {
+                        adminCommands(player, playerCommand);
+                }
+                if (player.playerRights == 3) {
+                        developerCommands(player, playerCommand);
+                }
+        }
+       
+        public static void playerCommands(Client player, String playerCommand) {
+                if (playerCommand.equalsIgnoreCase("players")) {
+                        if (PlayerHandler.getPlayerCount() > 1) {
+                                player.getActionSender().sendMessage("There are currently " + PlayerHandler.getPlayerCount() + " players online.");
+                        } else {
+                                player.getActionSender().sendMessage("There is currently " + PlayerHandler.getPlayerCount() + " player online.");
+                        }
+                }
+               
+                if (playerCommand.contains("clip") && player.playerRights < 2) {
+                        return;
+                }
+ 
+        }
+       
+        public static void donatorCommands(Client player, String playerCommand) {
+               
+        }
+       
+        public static void moderatorCommands(Client player, String playerCommand) {
+        	if (playerCommand.startsWith("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.getActionSender().sendMessage("@blu@[Moderator]@bla@"+ Misc.optimizeText(player.playerName) +": " + Misc.optimizeText(playerCommand.substring(5)) +"");
+						} else if (player.playerRights == 2) {
+							c2.getActionSender().sendMessage("@gre@[Administator]@bla@"+ Misc.optimizeText(player.playerName) +": " + Misc.optimizeText(playerCommand.substring(5)) +"");
+						} else if (player.playerRights == 3) {
+							c2.getActionSender().sendMessage("@red@[Owner]@bla@"+ Misc.optimizeText(player.playerName) +": " + Misc.optimizeText(playerCommand.substring(5)) +"");
+						}
+					}
+				}
+			}
+              
+                if (playerCommand.startsWith("mute")) {
+                        try {  
+                                String playerToBan = playerCommand.substring(5);
+                                Connection.addNameToMuteList(playerToBan);
+                                for(int i = 0; i < Constants.MAX_PLAYERS; i++) {
+                                        if(PlayerHandler.players[i] != null) {
+                                                if(PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                                        Client c2 = (Client)PlayerHandler.players[i];
+                                                        c2.getActionSender().sendMessage("You have been muted by: " + player.playerName);
+                                                        break;
+                                                }
+                                        }
+                                }
+                        } catch(Exception e) {
+                                player.getActionSender().sendMessage("Player Must Be Offline.");
+                        }                      
+                }
+ 
+                if (playerCommand.startsWith("ipmute")) {
+                        try {  
+                                String playerToBan = playerCommand.substring(7);
+                                for(int i = 0; i < Constants.MAX_PLAYERS; i++) {
+                                        if(PlayerHandler.players[i] != null) {
+                                                if(PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                                        Connection.addIpToMuteList(PlayerHandler.players[i].connectedFrom);
+                                                        player.getActionSender().sendMessage("You have IP Muted the user: "+PlayerHandler.players[i].playerName);
+                                                        Client c2 = (Client)PlayerHandler.players[i];
+                                                        c2.getActionSender().sendMessage("You have been muted by: " + player.playerName);
+                                                        break;
+                                                }
+                                        }
+                                }
+                        } catch(Exception e) {
+                                player.getActionSender().sendMessage("Player Must Be Offline.");
+                        }                      
+                }
+ 
+                if (playerCommand.startsWith("unipmute")) {
+                        try {  
+                                String playerToBan = playerCommand.substring(9);
+                                for(int i = 0; i < Constants.MAX_PLAYERS; i++) {
+                                        if(PlayerHandler.players[i] != null) {
+                                                if(PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                                        Connection.unIPMuteUser(PlayerHandler.players[i].connectedFrom);
+                                                        player.getActionSender().sendMessage("You have Un Ip-Muted the user: "+PlayerHandler.players[i].playerName);
+                                                        break;
+                                                }
+                                        }
+                                }
+                        } catch(Exception e) {
+                                player.getActionSender().sendMessage("Player Must Be Offline.");
+                        }                      
+                }
+ 
+                if (playerCommand.startsWith("unmute")) {
+                        try {  
+                                String playerToBan = playerCommand.substring(7);
+                                Connection.unMuteUser(playerToBan);
+                        } catch(Exception e) {
+                                player.getActionSender().sendMessage("Player Must Be Offline.");
+                        }                      
+                }
+        }
+       
+        public static void adminCommands(Client player, String playerCommand) {
+        	
+        		if (playerCommand.equalsIgnoreCase("clearbank")) {
+        			player.getItemAssistant().clearBank();
+        		}
+               
+                if (playerCommand.startsWith("ipban")) { // use as ::ipban name
+                        try {
+                                String playerToBan = playerCommand.substring(6);
+                                for(int i = 0; i < Constants.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.getActionSender().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.getActionSender().sendMessage("Player Must Be Offline.");
+                        }
+                }
+ 
+                if (playerCommand.startsWith("ban") && playerCommand.charAt(3) == ' ') { // use as ::ban name
+                        try {  
+                                String playerToBan = playerCommand.substring(4);
+                                Connection.addNameToBanList(playerToBan);
+                                Connection.addNameToFile(playerToBan);
+                                for(int i = 0; i < Constants.MAX_PLAYERS; i++) {
+                                        if(PlayerHandler.players[i] != null) {
+                                                if(PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                                        PlayerHandler.players[i].disconnected = true;
+                                                }
+                                        }
+                                }
+                        } catch(Exception e) {
+                                player.getActionSender().sendMessage("Player Must Be Offline.");
+                        }
+                }
+ 
+                if (playerCommand.startsWith("unban")) {
+                        try {  
+                                String playerToBan = playerCommand.substring(6);
+                                Connection.removeNameFromBanList(playerToBan);
+                                player.getActionSender().sendMessage(playerToBan + " has been unbanned.");
+                        } catch(Exception e) {
+                                player.getActionSender().sendMessage("Player Must Be Offline.");
+                        }
+                }
+               
+                if (playerCommand.equalsIgnoreCase("empty")) {
+                        player.getPlayerAssistant().handleEmpty();
+                }
+               
+                if (playerCommand.startsWith("dialogue")) {
+                        int npcType = 1552;
+                        int id = Integer.parseInt(playerCommand.split(" ")[1]);
+                        player.getDialogueHandler().sendDialogues(id, npcType);
+                }
+ 
+                if (playerCommand.startsWith("interface")) {
+                        String[] args = playerCommand.split(" ");
+                        player.getPlayerAssistant().showInterface(Integer.parseInt(args[1]));
+                }
+ 
+                if (playerCommand.startsWith("gfx")) {
+                	   String[] args = playerCommand.split(" ");
+                	   player.gfx0(Integer.parseInt(args[1]));
+                	  }
+ 
+                if (playerCommand.startsWith("anim")) {
+                        String[] args = playerCommand.split(" ");
+                        player.startAnimation(Integer.parseInt(args[1]));
+                        player.getPlayerAssistant().requestUpdates();
+                }
+               
+                if (playerCommand.equalsIgnoreCase("mypos")) {
+                        player.getActionSender().sendMessage("X: " + player.absX);
+                        player.getActionSender().sendMessage("Y: " + player.absY);
+                        player.getActionSender().sendMessage("H: " + player.heightLevel);
+                }
+ 
+                if (playerCommand.startsWith("bank")) {
+                        player.getPlayerAssistant().openUpBank();
+                }
+ 
+
+                if (playerCommand.startsWith("xteletome")) {
+                    try {
+                        String teleTo = playerCommand.substring(10);
+                        for (int i = 0; i < PlayerHandler.players.length; i++) {
+                            if (PlayerHandler.players[i] != null) {
+                                if (PlayerHandler.players[i].playerName.equalsIgnoreCase(teleTo)) {
+                                    Client p = (Client) PlayerHandler.players[i];
+                                        player.getActionSender().sendMessage(p.playerName + " has been teleported to you.");
+                                        p.getPlayerAssistant().movePlayer(player.absX, player.absY, player.heightLevel);
+                                	}
+                                }
+                            }
+                    } catch (Exception e) {
+                        player.getActionSender().sendMessage("Player is not online.");
+                    }
+                }
+        
+            if (playerCommand.startsWith("xteleto")) {
+                String name = playerCommand.substring(8);
+                for (int i = 0; i < PlayerHandler.players.length; i++) {
+                    if (PlayerHandler.players[i] != null) {
+                        if (PlayerHandler.players[i].playerName.equalsIgnoreCase(name)) {
+                            player.getPlayerAssistant().movePlayer(PlayerHandler.players[i].getX(), PlayerHandler.players[i].getY(), PlayerHandler.players[i].heightLevel);
+                        }
+                    }
+                }
+            }
+                if (playerCommand.startsWith("tele")) {
+                        String[] arg = playerCommand.split(" ");
+                        if (arg.length > 3) {
+                                player.getPlayerAssistant().movePlayer(Integer.parseInt(arg[1]), Integer.parseInt(arg[2]), Integer.parseInt(arg[3]));
+                        } else if (arg.length == 3) {
+                                player.getPlayerAssistant().movePlayer(Integer.parseInt(arg[1]), Integer.parseInt(arg[2]), player.heightLevel);
+                        }
+                }
+               
+                if (playerCommand.equalsIgnoreCase("up")) {
+                        player.getPlayerAssistant().movePlayer(player.absX, player.absY, player.heightLevel + 1);
+                        player.getActionSender().sendMessage("You are now on height level " + player.heightLevel + ".");
+                }
+ 
+                if (playerCommand.equalsIgnoreCase("down2")) {
+                        player.getPlayerAssistant().movePlayer(player.absX, player.absY + 6400, player.heightLevel);
+                }
+ 
+                if (playerCommand.equalsIgnoreCase("down")) {
+                        player.getPlayerAssistant().movePlayer(player.absX, player.absY, player.heightLevel - 1);
+                        player.getActionSender().sendMessage("You are now on height level " + player.heightLevel + ".");
+                }
+ 
+                if (playerCommand.equalsIgnoreCase("up2")) {
+                        player.getPlayerAssistant().movePlayer(player.absX, player.absY - 6400, player.heightLevel);
+                }
+               
+                if (playerCommand.equals("spec")) {
+                        player.specAmount = 100.0;
+                }
+               
+                if (playerCommand.startsWith("setlevel")) {
+                        try {
+                                String[] args = playerCommand.split(" ");
+                                int skill = Integer.parseInt(args[1]);
+                                int level = Integer.parseInt(args[2]);
+                                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) {
+                               
+                        }
+                }
+               
+                if (playerCommand.equalsIgnoreCase("spellbook")) {
+                        if (player.inWild()) {
+                                return;
+                        }
+                        if (player.playerMagicBook == 0) {
+                                player.playerMagicBook = 1;
+                                player.getActionSender().setSidebarInterface(6, 12855);
+                                player.getActionSender().sendMessage("An ancient wisdomin fills your mind.");
+                                player.getPlayerAssistant().resetAutocast();
+                        } else if (player.playerMagicBook == 1) {
+                                player.getActionSender().setSidebarInterface(6, 1151); // modern
+                                player.playerMagicBook = 0;
+                                player.getActionSender().sendMessage(   "You feel a drain on your memory.");
+                                player.autocastId = -1;
+                                player.getPlayerAssistant().resetAutocast();
+                        }
+                }
+ 
+                if (playerCommand.startsWith("item")) {
+                        try {
+                                String[] args = playerCommand.split(" ");
+                                if (args.length == 3) {
+                                        int newItemID = Integer.parseInt(args[1]);
+                                        int newItemAmount = Integer.parseInt(args[2]);
+                                        if (newItemID <= 10000 && newItemID >= 0) {
+                                                player.getItemAssistant().addItem(newItemID, newItemAmount);
+                                                if (player.isBusy()) {
+                        							player.getPlayerAssistant().closeAllWindows();
+                        						}
+                                                player.getActionSender().sendMessage("You spawn (" + newItemAmount + ") "+ ItemAssistant.getItemName(newItemID) + ".");
+                                        } else {
+                                                player.getActionSender().sendMessage("No such item.");
+                                        }
+                                } else {
+                                        player.getActionSender().sendMessage("Use as ::item 995 200");
+                                }
+                        } catch (Exception e) {
+                        }
+                }
+ 
+                if (playerCommand.equalsIgnoreCase("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();
+                }
+ 
+               
+        }
+ 
+        public static void developerCommands(Client player, String playerCommand) {
+               
+                if (playerCommand.startsWith("giveadmin")) {
+                        try {  
+                                String playerToAdmin = playerCommand.substring(10);
+                                for(int i = 0; i < Constants.MAX_PLAYERS; i++) {
+                                        if(PlayerHandler.players[i] != null) {
+                                                if(PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToAdmin)) {
+                                                        Client c2 = (Client)PlayerHandler.players[i];
+                                                        player.getActionSender().sendMessage("You have given " + playerToAdmin + " admin.");
+                                                        c2.playerRights = 2;
+                                                        c2.logout();
+                                                        break;
+                                                }
+                                        }
+                                }
+                        } catch(Exception e) {
+                                player.getActionSender().sendMessage("Player Must Be Offline.");
+                        }                      
+                }
+               
+                if (playerCommand.startsWith("demote")) {
+                        try {  
+                                String playerToAdmin = playerCommand.substring(7);
+                                for(int i = 0; i < Constants.MAX_PLAYERS; i++) {
+                                        if(PlayerHandler.players[i] != null) {
+                                                if(PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToAdmin)) {
+                                                        Client c2 = (Client)PlayerHandler.players[i];
+                                                        player.getActionSender().sendMessage("You have demoted " + playerToAdmin + ".");
+                                                        c2.playerRights = 0;
+                                                        c2.logout();
+                                                        break;
+                                                }
+                                        }
+                                }
+                        } catch(Exception e) {
+                                player.getActionSender().sendMessage("Player Must Be Offline.");
+                        }                      
+                }
+               
+                if (playerCommand.startsWith("givemod")) {
+                        try {  
+                                String playerToMod = playerCommand.substring(8);
+                                for(int i = 0; i < Constants.MAX_PLAYERS; i++) {
+                                        if(PlayerHandler.players[i] != null) {
+                                                if(PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToMod)) {
+                                                        Client c2 = (Client)PlayerHandler.players[i];
+                                                        player.getActionSender().sendMessage("You have given " + playerToMod + " mod.");
+                                                        c2.playerRights = 1;
+                                                        c2.logout();
+                                                        break;
+                                                }
+                                        }
+                                }
+                        } catch(Exception e) {
+                                player.getActionSender().sendMessage("Player Must Be Offline.");
+                        }                      
+                }
+               
+                if (playerCommand.startsWith("object")) {
+                        String[] args = playerCommand.split(" ");
+                        player.getActionSender().object(Integer.parseInt(args[1]), player.absX, player.absY, player.heightLevel, 0, 10);
+                        Region.addObject(Integer.parseInt(args[1]), player.absX, player.absY, player.heightLevel, 10, 0, false);
+                }
+                
+                if (playerCommand.startsWith("object2")) {
+                    String[] args = playerCommand.split(" ");
+                    player.getActionSender().object(Integer.parseInt(args[1]), player.absX, player.absY, player.heightLevel, 0, 0);
+                    Region.addObject(Integer.parseInt(args[1]), player.absX, player.absY, player.heightLevel, 0, 0, false);
+            }
+ 
+                if (playerCommand.startsWith("npc")) {
+                        try {
+                                int newNPC = Integer.parseInt(playerCommand.substring(4)), 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.getActionSender().sendMessage("You spawn a " + NpcHandler.getNpcListName(newNPC).toLowerCase() + ".");
+                                        //player.npcSpawned = newNPC;
+                                } else {
+                                        player.getActionSender().sendMessage("Npc " + newNPC + " does not exist.");
+                                }
+                        } catch (Exception e) {
+ 
+                        }
+                }
+               
+                if (playerCommand.equalsIgnoreCase("cantAttack")) {
+                        if (player.npcCanAttack == true) {
+                                player.getActionSender().sendMessage("Npcs can no longer attack you.");
+                                player.npcCanAttack = false;
+                        } else if (player.npcCanAttack == false) {
+                                player.getActionSender().sendMessage("Npcs can attack you again.");
+                                player.npcCanAttack = true;
+                        }
+                }
+                
+                if (playerCommand.startsWith("sound")) {
+                	 String[] args = playerCommand.split(" ");
+                	 player.getActionSender().sendSound(Integer.parseInt(args[1]), 100, 0);
+                }
+                
+            	if (playerCommand.startsWith("tutprog")) {
+        			String[] args = playerCommand.split(" ");
+        			int id = Integer.parseInt(args[1]);
+        			player.tutorialProgress = id;
+        		}
+            	
+            	if (playerCommand.startsWith("song")) {
+        			String[] args = playerCommand.split(" ");
+        			int id = Integer.parseInt(args[1]);
+        			player.getActionSender().sendSong(id);
+        		}
+            	
+        		if (playerCommand.equalsIgnoreCase("run")) {
+        			player.getActionSender().sendMessage("You have refilled your run-energy!");
+        			player.playerEnergy = 100;
+        		}
+
+        		if (playerCommand.equalsIgnoreCase("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);
+        			}
+        		}
+
+        		if (playerCommand.startsWith("sidebars")) {
+        			player.getPlayerAssistant().sendSidebars();
+        		}
+ 
+                if (playerCommand.startsWith("update")) {
+                        try {
+                                String[] args = playerCommand.split(" ");
+                                if (args.length == 2) {
+                                        int seconds = Integer.parseInt(args[1]);
+                                        PlayerHandler.updateSeconds = seconds;
+                                        PlayerHandler.updateAnnounced = false;
+                                        PlayerHandler.updateRunning = true;
+                                        PlayerHandler.updateStartTime = System.currentTimeMillis();
+                                } else {
+                                        player.getActionSender().sendMessage("Use as ::update (seconds)");
+                                }
+                        } catch (Exception e) {
+                        }
+                }
+               
+        }
+ 
+               
+}

2006Redone Server/src/redone/net/packets/impl/Countdown.java

@@ -0,0 +1,127 @@
+package redone.net.packets.impl;
+
+/**
+ * @author Jayden
+ */
+
+public class Countdown {
+	private long endMillis;
+	private long countdownMillis;
+	private long setMillis;
+
+	public Countdown() {
+		endMillis = System.currentTimeMillis();
+	}
+
+	public Countdown(long endMillis) {
+		this.endMillis = endMillis;
+	}
+
+	public void setTimeMillis(long millis) {
+		this.setMillis = millis;
+	}
+
+	public void addDays(int days) {
+		endMillis += days * 24 * 60 * 60 * 1000;
+	}
+
+	public void addHours(int hours) {
+		endMillis += hours * 60 * 60 * 1000;
+	}
+
+	public void addMinutes(int minutes) {
+		endMillis += minutes * 60 * 1000;
+	}
+
+	public void addSeconds(int seconds) {
+		endMillis += seconds * 1000;
+	}
+
+	public void removeDays(int days) {
+		endMillis -= days * 24 * 60 * 60 * 1000;
+	}
+
+	public void removeHours(int hours) {
+		endMillis -= hours * 60 * 60 * 1000;
+	}
+
+	public void removeMinutes(int minutes) {
+		endMillis -= minutes * 60 * 1000;
+	}
+
+	public void removeSeconds(int seconds) {
+		endMillis -= seconds * 1000;
+	}
+
+	public int getSeconds() {
+		calculate();
+		int seconds = (int) (countdownMillis / 1000);
+		if (seconds > 60) {
+			seconds = seconds % 60;
+		}
+		return seconds;
+	}
+
+	public int getMinutes() {
+		calculate();
+		int minutes = (int) (countdownMillis / (60 * 1000));
+		if (minutes >= 60) {
+			minutes = minutes % 60;
+		}
+		return minutes;
+	}
+
+	public int getHours() {
+		calculate();
+		int hours = (int) (countdownMillis / (60 * 60 * 1000));
+		if (hours >= 24) {
+			hours = hours % 24;
+		}
+		return hours;
+	}
+
+	public int getDays() {
+		calculate();
+		return (int) (countdownMillis / (24 * 60 * 60 * 1000));
+	}
+
+	public int getTotalSeconds() {
+		calculate();
+		return (int) (countdownMillis / 1000);
+	}
+
+	public int getTotalMinutes() {
+		calculate();
+		return (int) (countdownMillis / (60 * 1000));
+	}
+
+	public String daysToString() {
+		int days = getDays();
+		return (days == 0 ? "a day" : days + (days == 1 ? " day" : " days"));
+	}
+
+	public String minutesToString() {
+		int minutes = getMinutes();
+		return (minutes == 0 ? "a minute" : minutes + (minutes == 1 ? " minute" : " minutes"));
+	}
+
+	public String secondsToString() {
+		int seconds = getSeconds();
+		return (seconds + (seconds == 1 ? " second" : " seconds"));
+	}
+
+	public long getEndMillis() {
+		return endMillis;
+	}
+
+	public boolean finished() {
+		if (getDays() <= 0 && getHours() <= 0 && getMinutes() <= 0 && getSeconds() <= 0) {
+			return true;
+		}
+		return false;
+	}
+
+	private void calculate() {
+		countdownMillis = endMillis - (System.currentTimeMillis() - setMillis);
+	}
+}

2006Redone Server/src/redone/net/packets/impl/DropItem.java

@@ -0,0 +1,366 @@
+package redone.net.packets.impl;
+
+import redone.Constants;
+import redone.Server;
+import redone.game.content.minigames.castlewars.CastleWars;
+import redone.game.content.music.sound.SoundList;
+import redone.game.content.skills.SkillHandler;
+import redone.game.content.skills.firemaking.Firemaking;
+import redone.game.content.skills.firemaking.LogData;
+import redone.game.items.impl.RareProtection;
+import redone.game.npcs.impl.Pets;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+/**
+ * Drop Item
+ **/
+public class DropItem implements PacketType {
+
+	@Override
+	public void processPacket(Client player, int packetType, int packetSize) {
+		int itemId = player.getInStream().readUnsignedWordA();
+		player.getInStream().readUnsignedByte();
+		player.getInStream().readUnsignedByte();
+		int slot = player.getInStream().readUnsignedWordA();
+		if (player.isBotting) {
+			player.getActionSender().sendMessage("You can't drop items, until you confirm you aren't botting.");
+			player.getActionSender().sendMessage("If you need to you can type ::amibotting, to see if your botting.");
+			return;
+		}
+		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 (Server.objectManager.objectExists(player.absX, player.absY)) {
+					player.getActionSender().sendMessage(
+							"You cannot drop a log here.");
+					return;
+				}
+			}
+		}
+		if (player.duelingArena()) {
+			player.getActionSender().sendMessage(
+					"You can't drop items inside the arena!");
+			return;
+		}
+		if (player.inTrade) {
+			player.getActionSender().sendMessage(
+					"You can't drop items while trading!");
+			return;
+		}
+		if (player.hasNpc == true) {
+			player.getActionSender().sendMessage(
+					"You already have a pet dropped.");
+			return;
+		}
+		SkillHandler.resetSkills(player);
+		if (player.tutorialProgress < 36 && Constants.TUTORIAL_ISLAND) {
+			player.getActionSender().sendMessage(
+					"You can't drop items on tutorial island!");
+			return;
+		}
+		switch (itemId) {
+		case 1560:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage("You drop your Kitten.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Kitten.");
+			}
+			break;
+		case 1559:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage("You drop your Kitten.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Kitten.");
+			}
+			break;
+		case 1558:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage("You drop your Kitten.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Kitten.");
+			}
+			break;
+		case 1557:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage("You drop your Kitten.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Kitten.");
+			}
+			break;
+		case 1556:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage("You drop your Kitten.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Kitten.");
+			}
+			break;
+		case 1555:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage("You drop your Kitten.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Kitten.");
+			}
+			break;
+		case 1561:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage("You drop your Cat.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Cat.");
+			}
+			break;
+		case 1562:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage("You drop your Cat.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Cat.");
+			}
+			break;
+		case 1563:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage("You drop your Cat.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Cat.");
+			}
+			break;
+		case 1564:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage("You drop your Cat.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Cat.");
+			}
+			break;
+		case 1565:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage("You drop your Cat.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Cat.");
+			}
+			break;
+		case 7583:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage(
+						"You drop your Hell Kitten.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Hell Kitten.");
+			}
+			break;
+		case 1566:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage("You drop your Cat.");
+			} else {
+				player.getActionSender().sendMessage(
+						"You already dropped your Cat.");
+			}
+			break;
+		case 7585:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage(
+						"You drop your Hell Kitten.");
+			} else {
+				player.getActionSender().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.getActionSender().sendMessage("You can't do that! Your not in castle wars!");
+			}
+			break;
+		case 7584:
+			if (!player.hasNpc) {
+				Server.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.getActionSender().sendMessage(
+						"You drop your Hell Kitten.");
+			} else {
+				player.getActionSender().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 < Constants.DESTROYABLE_ITEMS.length; i++) { 
+					if (itemId == Constants.DESTROYABLE_ITEMS[i]) {
+						player.droppedItem = itemId;
+						player.getItemAssistant().destroyInterface(itemId);
+						return;
+					}
+				}
+				if (player.underAttackBy > 0) {
+					if (player.getShopAssistant().getItemShopValue(itemId) > 1000) {
+						player.getActionSender()
+								.sendMessage(
+										"You may not drop items worth more than 1000 while in combat.");
+						return;
+					}
+				}
+				Server.itemHandler.createGroundItem(player, itemId, player.getX(),
+						player.getY(), player.playerItemsN[slot], player.getId());
+				player.getItemAssistant().deleteItem(itemId, slot,
+						player.playerItemsN[slot]);
+				if (Constants.SOUND) {
+					player.getActionSender().sendSound(SoundList.ITEM_DROP, 100,
+							0);
+				}
+			} else {
+				player.getActionSender().sendMessage(
+						"This items cannot be dropped.");
+			}
+		}
+	}
+}

2006Redone Server/src/redone/net/packets/impl/FollowPlayer.java

@@ -0,0 +1,35 @@
+package redone.net.packets.impl;
+
+import redone.game.players.Client;
+import redone.game.players.PlayerHandler;
+import redone.net.packets.PacketType;
+
+public class FollowPlayer implements PacketType {
+
+	@Override
+	public void processPacket(Client c, int packetType, int packetSize) {
+		int followPlayer = c.getInStream().readUnsignedWordBigEndian();
+		if (PlayerHandler.players[followPlayer] == null) {
+			return;
+		}
+		if (c.isBotting == true) {
+			c.getActionSender().sendMessage("You can't follow players, until you confirm you are not botting.");
+			c.getActionSender().sendMessage("If you need to you can type ::amibotting, to see if your botting.");
+			c.stopMovement();
+			c.getPlayerAssistant().resetFollow();
+			return;
+		}
+		/*if (c.performingAction) {
+			c.stopMovement();
+			c.getPlayerAssistant().resetFollow();
+			return;
+		}*/
+		c.playerIndex = 0;
+		c.npcIndex = 0;
+		c.mageFollow = false;
+		c.usingBow = false;
+		c.usingRangeWeapon = false;
+		c.followDistance = 1;
+		c.followId = followPlayer;
+	}
+}

2006Redone Server/src/redone/net/packets/impl/IdleLogout.java

@@ -0,0 +1,21 @@
+package redone.net.packets.impl;
+
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+/**
+ * @author Andrew
+ */
+
+public class IdleLogout implements PacketType {
+
+	@Override
+	public void processPacket(Client player, int packetType, int packetSize) {
+		if (player.underAttackBy > 0 || player.underAttackBy2 > 0) {
+			return;
+		} else {
+			player.logout();
+			//Misc.println(player.playerName + " is idle, kicked.");
+		}
+	}
+}

2006Redone Server/src/redone/net/packets/impl/ItemClick2.java

@@ -0,0 +1,33 @@
+package redone.net.packets.impl;
+
+import redone.game.items.impl.HandleEmpty;
+import redone.game.players.Client;
+import redone.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(Client c, int packetType, int packetSize) {
+		int itemId = c.getInStream().readSignedWordA();
+
+		if (!c.getItemAssistant().playerHasItem(itemId, 1)) {
+			return;
+		}
+		
+		if (HandleEmpty.canEmpty(c, itemId)) {
+			HandleEmpty.handleEmptyItem(c, itemId, HandleEmpty.filledToEmpty(c, itemId));
+			return;
+		}
+
+		switch (itemId) {
+		}
+
+	}
+
+}

2006Redone Server/src/redone/net/packets/impl/ItemClick2OnGroundItem.java

@@ -0,0 +1,28 @@
+package redone.net.packets.impl;
+
+import redone.game.content.skills.firemaking.Firemaking;
+import redone.game.content.skills.firemaking.LogData;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+public class ItemClick2OnGroundItem implements PacketType {
+
+	@Override
+	public void processPacket(Client 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.getActionSender().sendMessage("You can't do that there!");
+			return;
+		}
+		for (LogData l : LogData.values()) {
+			if (itemId == l.getLogId()) {
+				Firemaking.attemptFire(c, 590, itemId, itemX, itemY, true);
+				return;
+			}
+		}
+	}
+}

2006Redone Server/src/redone/net/packets/impl/ItemClick3.java

@@ -0,0 +1,87 @@
+package redone.net.packets.impl;
+
+import redone.game.items.impl.HandleEmpty;
+import redone.game.items.impl.Teles;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+import redone.util.Misc;
+
+/**
+ * Item Click 3 Or Alternative Item Option 1
+ * 
+ * @author Ryan / Lmctruck30 Proper Streams
+ */
+
+public class ItemClick3 implements PacketType {
+
+	@Override
+	public void processPacket(Client 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;
+		}
+		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().deleteItem2(1933, 1);
+			player.getItemAssistant().addItem(1931, 1);
+		break;
+		
+		case 1921:
+			player.getItemAssistant().deleteItem2(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/redone/net/packets/impl/ItemOnGroundItem.java

@@ -0,0 +1,44 @@
+package redone.net.packets.impl;
+
+import redone.Server;
+import redone.game.content.skills.firemaking.Firemaking;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+import redone.util.Misc;
+
+public class ItemOnGroundItem implements PacketType {
+
+	@Override
+	public void processPacket(Client 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 (!Server.itemHandler.itemExists(groundItem, gItemX, gItemY)) {
+			return;
+		}
+
+		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/redone/net/packets/impl/ItemOnItem.java

@@ -0,0 +1,21 @@
+package redone.net.packets.impl;
+
+import redone.game.items.UseItem;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+public class ItemOnItem implements PacketType {
+
+	@Override
+	public void processPacket(Client 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;
+		}
+		UseItem.ItemonItem(player, itemUsed, useWith);
+	}
+
+}

2006Redone Server/src/redone/net/packets/impl/ItemOnNpc.java

@@ -0,0 +1,53 @@
+package redone.net.packets.impl;
+
+import redone.game.content.skills.SkillHandler;
+import redone.game.items.UseItem;
+import redone.game.npcs.NpcHandler;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+public class ItemOnNpc implements PacketType {
+
+	@Override
+	public void processPacket(final Client 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);
+		if (player.playerRights == 3) {
+			player.getActionSender().sendMessage("Item id: " + itemId + " slot: " + slot + " i: " + i);
+		}
+		if (player.getItemAssistant().freeSlots() < 1) {
+			player.getActionSender().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:
+			NpcHandler.npcs[i].requestTransformTime(player, 1735, 893, 43, 42, 50);
+		break;
+		}
+		if (player.getItemAssistant().playerHasItem(995, 1) && npcId == 736) {
+			player.getItemAssistant().deleteItem2(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().deleteItem2(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().deleteItem2(1552, 1);
+			player.gertCat = 4;
+		} else if (player.getItemAssistant().playerHasItem(1554, 1) && player.gertCat == 5 && npcId == 2997) {
+			player.getItemAssistant().deleteItem2(1554, 1);
+			player.getDialogueHandler().sendDialogues(326, npcId);
+		}
+		UseItem.ItemonNpc(player, itemId, slot, i);
+	}
+}

2006Redone Server/src/redone/net/packets/impl/ItemOnObject.java

@@ -0,0 +1,219 @@
+package redone.net.packets.impl;
+
+import redone.game.content.skills.cooking.Cooking;
+import redone.game.content.skills.cooking.CookingTutorialIsland;
+import redone.game.content.skills.crafting.JewelryMaking;
+import redone.game.content.skills.crafting.Pottery;
+import redone.game.content.skills.crafting.Spinning;
+import redone.game.items.UseItem;
+import redone.game.items.impl.Fillables;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+import redone.world.clip.Region;
+
+public class ItemOnObject implements PacketType {
+
+	@Override
+	public void processPacket(Client 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.cookingCoords[0] = objectX;
+		player.cookingCoords[1] = objectY;
+		player.turnPlayerTo(objectX, objectY);
+		player.objectX = objectX;
+		player.objectY = objectY;
+		if (!player.getItemAssistant().playerHasItem(itemId, 1)) {
+			return;
+		}
+		if (player.playerRights == 3) {
+			player.getActionSender().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.getActionSender().sendSound(352, 100, 1);
+						player.getActionSender().sendMessage("You smelt the copper and tin together in the furnace.");
+						player.getItemAssistant().deleteItem2(438, 1);
+						player.getItemAssistant().deleteItem2(436, 1);
+						player.getActionSender().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.getActionSender().sendSound(352, 100, 1);
+						player.getActionSender().sendMessage("You smelt the copper and tin together in the furnace.");
+						player.getItemAssistant().deleteItem2(438, 1);
+						player.getItemAssistant().deleteItem2(436, 1);
+						player.getActionSender().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.getActionSender().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.getActionSender().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.getActionSender().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.getActionSender().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().deleteItem2(954, 1);
+		} else if (objectId == 2327 && itemId != 954) {
+			player.getActionSender().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.getActionSender().sendMessage(Fillables.fillMessage(itemId, objectId));
+			player.startAnimation(832);
+			return;
+		}
+
+		UseItem.ItemonObject(player, objectId, objectX, objectY, itemId);
+
+	}
+
+}

2006Redone Server/src/redone/net/packets/impl/ItemOnPlayer.java

@@ -0,0 +1,53 @@
+package redone.net.packets.impl;
+
+import redone.game.items.impl.RareProtection;
+import redone.game.players.Client;
+import redone.game.players.PlayerHandler;
+import redone.net.packets.PacketType;
+import redone.util.Misc;
+
+/**
+ * @author JaydenD12/Jaydennn
+ */
+
+public class ItemOnPlayer implements PacketType {
+
+	@Override
+	public void processPacket(Client c, int packetType, int packetSize) {
+		int playerId = c.inStream.readUnsignedWord();
+		int itemId = c.playerItems[c.inStream.readSignedWordBigEndian()] - 1;
+		switch (itemId) {
+
+		case 962:
+			Client o = (Client) PlayerHandler.players[playerId];
+			if (!RareProtection.CRACKERS && c.playerRights < 3) {
+				int delete = c.getItemAssistant().getItemCount(962);
+				c.getItemAssistant().deleteItem2(962, delete);
+				c.getActionSender().sendMessage("You can't do that!");
+				return;
+			}
+			c.gfx0(176);
+			c.startAnimation(451);
+			c.getActionSender().sendMessage(
+					"You pull the Christmas Cracker...");
+			o.getActionSender().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.getActionSender().sendMessage("Nothing interesting happens.");
+			break;
+		}
+
+	}
+}

2006Redone Server/src/redone/net/packets/impl/MagicOnFloorItems.java

@@ -0,0 +1,113 @@
+package redone.net.packets.impl;
+
+import redone.Server;
+import redone.event.CycleEvent;
+import redone.event.CycleEventContainer;
+import redone.event.CycleEventHandler;
+import redone.game.content.combat.magic.MagicData;
+import redone.game.items.Item;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+/**
+ * Magic on floor items
+ **/
+public class MagicOnFloorItems implements PacketType {
+
+	@Override
+	public void processPacket(final Client 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 (!Server.itemHandler.itemExists(itemId, itemX, itemY)) {
+			c.stopMovement();
+			return;
+		}
+		c.usingMagic = true;
+		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 (Server.itemHandler.itemExists(c.teleGrabItem,
+									c.teleGrabX, c.teleGrabY)
+									&& c.goodDistance(c.getX(), c.getY(),
+											itemX, itemY, 12)) {
+								Server.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.getActionSender().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/redone/net/packets/impl/MagicOnItems.java

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

2006Redone Server/src/redone/net/packets/impl/MoveItems.java

@@ -0,0 +1,32 @@
+package redone.net.packets.impl;
+
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+/**
+ * Move Items
+ **/
+public class MoveItems implements PacketType {
+
+	@Override
+	public void processPacket(Client 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);
+	}
+}

2006Redone Server/src/redone/net/packets/impl/PickupItem.java

@@ -0,0 +1,106 @@
+package redone.net.packets.impl;
+
+import redone.Server;
+import redone.event.CycleEvent;
+import redone.event.CycleEventContainer;
+import redone.event.CycleEventHandler;
+import redone.game.content.minigames.castlewars.CastleWars;
+import redone.game.content.music.sound.SoundList;
+import redone.game.content.skills.SkillHandler;
+import redone.game.content.skills.firemaking.Firemaking;
+import redone.game.content.skills.firemaking.LogData;
+import redone.game.items.ItemAssistant;
+import redone.game.items.impl.RareProtection;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+import redone.util.GameLogger;
+import redone.world.GlobalDropsHandler;
+
+/**
+ * Pickup Item
+ **/
+public class PickupItem implements PacketType {
+
+
+	@Override
+	public void processPacket(final Client 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;
+		}
+		if(!Server.itemHandler.itemExists(player.pItemId, player.pItemX, player.pItemY)) {
+			player.stopMovement();
+			return;
+		}
+		player.getCombatAssistant().resetPlayerAttack();
+		if (player.stopPlayerPacket) {
+			return;
+		}
+		if (player.isBotting) {
+			player.getActionSender().sendMessage("You can't pickup items, until you confirm you aren't botting.");
+			player.getActionSender().sendMessage("If you need to you can type ::amibotting, to see if your botting.");
+			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.getActionSender().sendMessage(
+					"You can't pick up these items!");
+			return;
+		}
+		for (LogData logData : LogData.values()) {
+			if (player.isFiremaking == true && player.pItemId == logData.getLogId()) {
+				player.getActionSender().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) {
+			Server.itemHandler.removeGroundItem(player, player.pItemId, player.pItemX,
+					player.pItemY, true);
+			player.getActionSender().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) {
+						Server.itemHandler.removeGroundItem(player, player.pItemId, player.pItemX, player.pItemY, true);
+						container.stop();
+					}
+				}
+
+				@Override
+				public void stop() {
+					player.walkingToItem = false;
+				}
+			}, 1);
+		}
+	}
+}

2006Redone Server/src/redone/net/packets/impl/PrivateMessaging.java

@@ -0,0 +1,159 @@
+package redone.net.packets.impl;
+
+import redone.Connection;
+import redone.game.players.Client;
+import redone.game.players.PlayerHandler;
+import redone.game.players.antimacro.AntiSpam;
+import redone.net.packets.PacketType;
+import redone.util.GameLogger;
+import redone.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(Client 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.getActionSender().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.getPlayerAssistant().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.getPlayerAssistant().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.getActionSender().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:
+			// int tradeAndCompete = c.getInStream().readUnsignedByte();
+			player.privateChat = player.getInStream().readUnsignedByte();
+			// int publicChat = c.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/redone/net/packets/impl/RemoveItem.java

@@ -0,0 +1,97 @@
+package redone.net.packets.impl;
+
+import redone.game.content.random.PartyRoom;
+import redone.game.content.skills.crafting.JewelryMaking;
+import redone.game.items.impl.RareProtection;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+/**
+ * Remove Item
+ **/
+public class RemoveItem implements PacketType {
+
+	@Override
+	public void processPacket(Client 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.getActionSender().writeWeight((int) c.weight);
+		}
+		if (!RareProtection.removeItem(c, removeId)) {
+			return;
+		}
+		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, removeSlot);
+			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/redone/net/packets/impl/Report.java

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

2006Redone Server/src/redone/net/packets/impl/ReportHandler.java

@@ -0,0 +1,192 @@
+package redone.net.packets.impl;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import redone.game.players.Client;
+import redone.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(Client 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.getActionSender().sendMessage("You can only report a player once every 60 seconds.");
+			return;
+		}
+		if (c.playerName.equalsIgnoreCase(player)) {
+			c.getActionSender().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.getActionSender()
+					.sendMessage(
+							"Thank you, your report has been received and will be reviewed.");
+			if (mute == 1 && c.playerRights > 0) {
+				c.getActionSender()
+						.sendMessage(
+								"This user is not muted yet! Go to the MODCP on the forums to mute him!");
+				c.getActionSender()
+						.sendMessage(
+								"After you have muted him there, do ::update (username) to finish the mute!");
+			}
+			c.lastReported = player;
+			c.lastReport = System.currentTimeMillis();
+		} else {
+			c.getActionSender()
+					.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/redone/net/packets/impl/SilentPacket.java

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

2006Redone Server/src/redone/net/packets/impl/Trade.java

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

2006Redone Server/src/redone/net/packets/impl/Walking.java

@@ -0,0 +1,184 @@
+package redone.net.packets.impl;
+
+import redone.game.content.skills.SkillHandler;
+import redone.game.content.skills.cooking.Cooking;
+import redone.game.content.skills.core.Fishing;
+import redone.game.content.skills.smithing.Smelting;
+import redone.game.players.Client;
+import redone.game.players.PlayerHandler;
+import redone.net.packets.PacketType;
+
+/**
+ * Walking packet
+ **/
+public class Walking implements PacketType {
+
+	@Override
+	public void processPacket(Client 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.isBotting == true) {
+			player.getActionSender().sendMessage("Please type ::amibotting if you would like to move again");
+			return;
+		}
+		if (player.isFiremaking == true) {
+			player.isFiremaking = false;
+		}
+		if (player.stopPlayerPacket == true) {
+			return;
+		}
+		if (player.inTrade) {
+			player.inTrade = false;
+		}
+		if (player.tutorialProgress > 35 && !player.isSmithing) {
+			player.getPlayerAssistant().closeAllWindows();
+		} else if (player.tutorialProgress < 36 && player.isSmithing) {
+			player.getPlayerAssistant().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.getActionSender().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.getActionSender().sendMessage(
+						"A magical force stops you from moving.");
+				player.playerIndex = 0;
+			}
+			return;
+		}
+
+		if (System.currentTimeMillis() - player.lastSpear < 4000) {
+			player.getActionSender().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.getPlayerAssistant().sendFrame126("WARNING!", 6940);
+			player.getPlayerAssistant().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;
+		}
+		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 = player.getInStream().readSignedWordBigEndianA()
+				- player.getMapRegionX() * 8;
+		for (int i = 1; i < player.newWalkCmdSteps; i++) {
+			player.getNewWalkCmdX()[i] = player.getInStream().readSignedByte();
+			player.getNewWalkCmdY()[i] = player.getInStream().readSignedByte();
+		}
+
+		int firstStepY = player.getInStream().readSignedWordBigEndian() - player.getMapRegionY() * 8;
+		player.setNewWalkCmdIsRunning(player.getInStream().readSignedByteC() == 1 && player.playerEnergy > 0);
+		for (int i1 = 0; i1 < player.newWalkCmdSteps; i1++) {
+			player.getNewWalkCmdX()[i1] += firstStepX;
+			player.getNewWalkCmdY()[i1] += firstStepY;
+		}
+	}
+
+}

2006Redone Server/src/redone/net/packets/impl/WearItem.java

@@ -0,0 +1,64 @@
+package redone.net.packets.impl;
+
+import redone.game.items.impl.RareProtection;
+import redone.game.players.Client;
+import redone.net.packets.PacketType;
+
+/**
+ * Wear Item
+ **/
+public class WearItem implements PacketType {
+
+	/* (non-Javadoc)
+	 * @see server.net.packets.PacketType#processPacket(server.game.players.Client, int, int)
+	 */
+	@Override
+	public void processPacket(Client 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();
+		}
+		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.getActionSender().writeWeight((int) player.weight);
+		}
+
+		if (player.wearSlot == player.playerHat) {
+			player.getActionSender().setConfig(491, 0);
+		}
+
+		player.getPlayerAssistant().handleTiara();
+		player.getItemAssistant().wearItem(player.wearId, player.wearSlot);
+	}
+
+}

2006Redone Server/src/redone/net/rsa/RSAKeyGen.java

@@ -0,0 +1,57 @@
+package redone.net.rsa;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.math.BigInteger;
+import java.security.KeyFactory;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.spec.RSAPrivateKeySpec;
+import java.security.spec.RSAPublicKeySpec;
+
+/**
+ * A class to generate a simple 1024 bit RSA pair
+ * @author Nikki
+ */
+public class RSAKeyGen {
+
+	public static void main(String[] args) {
+		try {
+			KeyFactory factory = KeyFactory.getInstance("RSA");
+		    KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
+		    keyGen.initialize(1024);
+		    KeyPair keypair = keyGen.genKeyPair();
+		    PrivateKey privateKey = keypair.getPrivate();
+		    PublicKey publicKey = keypair.getPublic();
+		    
+		    RSAPrivateKeySpec privSpec = factory.getKeySpec(privateKey, RSAPrivateKeySpec.class);
+		    
+		    writeKey("rsapriv", privSpec.getModulus(), privSpec.getPrivateExponent());
+		    
+		    
+		    RSAPublicKeySpec pubSpec = factory.getKeySpec(publicKey, RSAPublicKeySpec.class);
+		    
+		    writeKey("rsapub", pubSpec.getModulus(), pubSpec.getPublicExponent());
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public static void writeKey(String file, BigInteger modulus, BigInteger exponent) {
+		try {
+			BufferedWriter writer = new BufferedWriter(new FileWriter(file));
+		    writer.write("private static final BigInteger RSA_MODULUS = new BigInteger(\""+modulus.toString()+"\");");
+		    writer.newLine();
+		    writer.newLine();
+		    writer.write("private static final BigInteger RSA_EXPONENT = new BigInteger(\""+exponent.toString()+"\");");
+		    writer.newLine();
+		    writer.flush();
+		    writer.close();
+		} catch(Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+}

2006Redone Server/src/redone/net/rsa/rsapriv

@@ -0,0 +1,3 @@
+private static final BigInteger RSA_MODULUS = new BigInteger("91553247461173033466542043374346300088148707506479543786501537350363031301992107112953015516557748875487935404852620239974482067336878286174236183516364787082711186740254168914127361643305190640280157664988536979163450791820893999053469529344247707567448479470137716627440246788713008490213212272520901741443");
+
+private static final BigInteger RSA_EXPONENT = new BigInteger("33280025241734061313051117678670856264399753710527826596057587687835856000539511539311834363046145710983857746766009612538140077973762171163294453513440619295457626227183742315140865830778841533445402605660729039310637444146319289077374748018792349647460850308384280105990607337322160553135806205784213241305");

2006Redone Server/src/redone/net/rsa/rsapub

@@ -0,0 +1,3 @@
+private static final BigInteger RSA_MODULUS = new BigInteger("91553247461173033466542043374346300088148707506479543786501537350363031301992107112953015516557748875487935404852620239974482067336878286174236183516364787082711186740254168914127361643305190640280157664988536979163450791820893999053469529344247707567448479470137716627440246788713008490213212272520901741443");
+
+private static final BigInteger RSA_EXPONENT = new BigInteger("65537");