Rename & Repackage

2006Scape Server/src/main/java/com/rs2/net/CodecFactory.java

@@ -0,0 +1,40 @@
+package com.rs2.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;
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/net/ConnectionHandler.java

@@ -0,0 +1,63 @@
+package com.rs2.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 com.rs2.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()));
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/net/ConnectionThrottleFilter.java

@@ -0,0 +1,132 @@
+package com.rs2.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);
+	}
+}

2006Scape Server/src/main/java/com/rs2/net/GameCodecFactory.java

@@ -0,0 +1,46 @@
+package com.rs2.net;
+
+import org.apache.mina.filter.codec.ProtocolCodecFactory;
+import org.apache.mina.filter.codec.ProtocolDecoder;
+import org.apache.mina.filter.codec.ProtocolEncoder;
+
+import com.rs2.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;
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/net/HostList.java

@@ -0,0 +1,57 @@
+package com.rs2.net;
+
+import java.net.InetSocketAddress;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.mina.common.IoSession;
+
+import com.rs2.Connection;
+import com.rs2.GameConstants;
+
+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 > GameConstants.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);
+		}
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/net/Packet.java

@@ -0,0 +1,304 @@
+package com.rs2.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());
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/net/PacketBuffer.java

@@ -0,0 +1,104 @@
+package com.rs2.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 ? 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;
+	}
+}

2006Scape Server/src/main/java/com/rs2/net/PacketBuilder.java

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

2006Scape Server/src/main/java/com/rs2/net/RS2LoginProtocolDecoder.java

@@ -0,0 +1,305 @@
+package com.rs2.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 com.rs2.Connection;
+import com.rs2.GameConstants;
+import com.rs2.GameEngine;
+import com.rs2.game.players.Client;
+import com.rs2.game.players.PlayerHandler;
+import com.rs2.game.players.PlayerSave;
+import com.rs2.util.HostBlacklist;
+import com.rs2.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;
+		}
+                
+                if (pass.length() == 0) {
+                        returnCode = 4;
+                }
+
+		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 >= GameConstants.MAX_PLAYERS) {
+			returnCode = 7;
+		}
+
+		if (GameEngine.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 (!GameEngine.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);
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/net/RS2ProtocolDecoder.java

@@ -0,0 +1,145 @@
+package com.rs2.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 com.rs2.game.players.Client;
+import com.rs2.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);
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/net/RS2ProtocolEncoder.java

@@ -0,0 +1,82 @@
+package com.rs2.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 {
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/net/StaticPacketBuilder.java

@@ -0,0 +1,385 @@
+package com.rs2.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;
+	}
+}

2006Scape Server/src/main/java/com/rs2/net/packets/PacketHandler.java

@@ -0,0 +1,176 @@
+package com.rs2.net.packets;
+
+import com.rs2.GameConstants;
+import com.rs2.game.dialogues.Dialogue;
+import com.rs2.game.players.Player;
+import com.rs2.net.packets.impl.AttackPlayer;
+import com.rs2.net.packets.impl.Bank10;
+import com.rs2.net.packets.impl.Bank5;
+import com.rs2.net.packets.impl.BankAll;
+import com.rs2.net.packets.impl.BankX1;
+import com.rs2.net.packets.impl.InterfaceX;
+import com.rs2.net.packets.impl.ChallengePlayer;
+import com.rs2.net.packets.impl.ChangeAppearance;
+import com.rs2.net.packets.impl.ChangeRegions;
+import com.rs2.net.packets.impl.Chat;
+import com.rs2.net.packets.impl.ClickItem;
+import com.rs2.net.packets.impl.ClickNPC;
+import com.rs2.net.packets.impl.ClickObject;
+import com.rs2.net.packets.impl.ClickTab;
+import com.rs2.net.packets.impl.ClickingButtons;
+import com.rs2.net.packets.impl.ClickingInGame;
+import com.rs2.net.packets.impl.ClickingStuff;
+import com.rs2.net.packets.impl.Commands;
+import com.rs2.net.packets.impl.DropItem;
+import com.rs2.net.packets.impl.FollowPlayer;
+import com.rs2.net.packets.impl.IdleLogout;
+import com.rs2.net.packets.impl.ItemClick2;
+import com.rs2.net.packets.impl.ItemClick2OnGroundItem;
+import com.rs2.net.packets.impl.ItemClick3;
+import com.rs2.net.packets.impl.ItemOnGroundItem;
+import com.rs2.net.packets.impl.ItemOnItem;
+import com.rs2.net.packets.impl.ItemOnNpc;
+import com.rs2.net.packets.impl.ItemOnObject;
+import com.rs2.net.packets.impl.ItemOnPlayer;
+import com.rs2.net.packets.impl.MagicOnFloorItems;
+import com.rs2.net.packets.impl.MagicOnItems;
+import com.rs2.net.packets.impl.MagicOnObject;
+import com.rs2.net.packets.impl.MoveItems;
+import com.rs2.net.packets.impl.PickupItem;
+import com.rs2.net.packets.impl.PrivateMessaging;
+import com.rs2.net.packets.impl.RemoveItem;
+import com.rs2.net.packets.impl.Report;
+import com.rs2.net.packets.impl.SilentPacket;
+import com.rs2.net.packets.impl.Trade;
+import com.rs2.net.packets.impl.Walking;
+import com.rs2.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[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();
+		packetId[35] = new MagicOnObject();
+		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 InterfaceX();
+		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(Player player, int packetType, int packetSize) {
+        PacketType p = packetId[packetType];
+        if(p != null && packetType > 0 && packetType < 257 && packetType == player.packetType && packetSize == player.packetSize) {
+            if (GameConstants.sendServerPackets && player.playerRights == 3) {
+                player.getPacketSender().sendMessage("PacketType: " + packetType + ". PacketSize: " + packetSize + ".");
+            }
+            try {
+                p.processPacket(player, packetType, packetSize);
+            } catch(Exception e) {
+                e.printStackTrace();
+            }
+        } else {
+            player.disconnected = true;
+            System.out.println(player.playerName + "is sending invalid PacketType: " + packetType + ". PacketSize: " + packetSize);
+        }
+    }
+
+}

2006Scape Server/src/main/java/com/rs2/net/packets/PacketType.java

@@ -0,0 +1,8 @@
+package com.rs2.net.packets;
+
+import com.rs2.game.players.Player;
+
+public interface PacketType {
+
+	public void processPacket(Player player, int packetType, int packetSize);
+}

2006Scape Server/src/main/java/com/rs2/net/packets/impl/AttackPlayer.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/Bank10.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/Bank5.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/BankAll.java

@@ -0,0 +1,153 @@
+package com.rs2.net.packets.impl;
+
+import com.rs2.game.content.random.PartyRoom;
+import com.rs2.game.items.GameItem;
+import com.rs2.game.items.ItemData;
+import com.rs2.game.players.Player;
+import com.rs2.net.packets.PacketType;
+
+/**
+ * Bank All Items
+ **/
+public class BankAll implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		int removeSlot = player.getInStream().readUnsignedWordA();
+		int interfaceId = player.getInStream().readUnsignedWord();
+		int removeId = player.getInStream().readUnsignedWordA();
+		player.endCurrentTask();
+		switch (interfaceId) {
+		// buy x
+		case 3900:
+			player.outStream.createFrame(27);
+			player.xRemoveSlot = removeSlot;
+			player.xRemoveId = removeId;
+			player.xInterfaceId = interfaceId;
+			break;
+
+		// sell x
+		case 3823:
+			if(!player.getItemAssistant().playerHasItem(removeId)) {
+				return;
+			}
+			player.outStream.createFrame(27);
+			player.xRemoveSlot = removeSlot;
+			player.xRemoveId = removeId;
+			player.xInterfaceId = interfaceId;
+			break;
+
+		case 7423:
+			if (player.storing) {
+
+				return;
+			}
+			player.getItemAssistant().bankItem(player.playerItems[removeSlot],
+					removeSlot, player.playerItemsN[removeSlot]);
+			player.getItemAssistant().resetItems(7423);
+			break;
+
+		case 5064:
+			if(!player.getItemAssistant().playerHasItem(removeId)) {
+				return;
+			}
+			if (player.inPartyRoom) {
+				PartyRoom.depositItem(player, removeId, player.getItemAssistant().itemAmount(player.playerItems[removeSlot]));
+				break;
+			}
+			if (player.inTrade) {
+				player.getPacketSender().sendMessage("You can't store items while trading!");
+				return;
+			}
+			if (ItemData.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:
+			if (player.getItemAssistant().playerHasItem(removeId)) {
+				for (int i = 0; i <= 27; i++) {
+					if (removeId == player.playerItems[i] - 1)
+					{
+						if ((player.playerItemsN[i] + player.bankItemsN[removeSlot] + 1) < -1) {
+							player.getPacketSender().sendMessage("Can't withdraw more of that item!");
+							break;
+						} else {
+							player.getItemAssistant().fromBank(player.bankItems[removeSlot], removeSlot,
+									player.bankItemsN[removeSlot]);
+						}
+					}
+				}
+			}
+			else
+			{
+				player.getItemAssistant().fromBank(player.bankItems[removeSlot], removeSlot,
+						player.bankItemsN[removeSlot]);
+			}
+			break;
+
+		case 3322:
+			if (player.duelStatus <= 0) {
+				if (ItemData.itemStackable[removeId]) {
+					player.getTrading().tradeItem(removeId, removeSlot,
+							player.playerItemsN[removeSlot]);
+				} else {
+					player.getTrading().tradeItem(removeId, removeSlot, 28);
+				}
+			} else {
+				if (ItemData.itemStackable[removeId] || ItemData.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 (ItemData.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 (ItemData.itemStackable[removeId] || ItemData.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;
+
+		}
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/net/packets/impl/BankX1.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ChallengePlayer.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ChangeAppearance.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ChangeRegions.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/Chat.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ClickItem.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ClickNPC.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ClickObject.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ClickTab.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ClickingInGame.java

@@ -0,0 +1,13 @@
+package com.rs2.net.packets.impl;
+
+import com.rs2.game.players.Player;
+import com.rs2.net.packets.PacketType;
+
+public class ClickingInGame implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ClickingStuff.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/Commands.java

@@ -0,0 +1,942 @@
+package com.rs2.net.packets.impl;
+
+import static com.rs2.util.GameLogger.writeLog;
+
+import java.util.Arrays;
+
+import com.rs2.Connection;
+import com.rs2.GameConstants;
+import com.rs2.GameEngine;
+import com.rs2.game.bots.BotHandler;
+import com.rs2.game.content.combat.magic.SpellTeleport;
+import com.rs2.game.npcs.NpcHandler;
+import com.rs2.game.players.*;
+import com.rs2.game.players.antimacro.AntiSpam;
+import com.rs2.net.packets.PacketType;
+import com.rs2.util.Misc;
+import com.rs2.world.clip.Region;
+
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+
+public class Commands implements PacketType {
+
+    @Override
+    public void processPacket(Player player, int packetType, int packetSize) {
+        String[] messageArr = player.getInStream().readString().split(" ");
+        String playerCommand = messageArr[0];
+        String[] commandArguments = Arrays.copyOfRange(messageArr, 1, messageArr.length);
+        if ((playerCommand.startsWith("ban") || playerCommand.startsWith("ip") || playerCommand.startsWith("mute") || playerCommand.startsWith("un")) && player.playerRights > 0 && player.playerRights < 4) {
+            writeLog(player.playerName, "commands", player.playerName + " used command: " + playerCommand);
+        }
+        if (player.playerRights >= 0) {
+            playerCommands(player, playerCommand, commandArguments);
+        }
+        if (player.playerRights >= 1) {
+            moderatorCommands(player, playerCommand, commandArguments);
+        }
+        if (player.playerRights >= 2 && player.playerRights < 4) {
+            adminCommands(player, playerCommand, commandArguments);
+        }
+        if (player.playerRights == 3) {
+            developerCommands(player, playerCommand, commandArguments);
+        }
+    }
+
+    public static void playerCommands(Player player, String playerCommand, String[] arguments) {
+        switch (playerCommand.toLowerCase()) {
+            case "hideYell":
+                player.hideYell = !player.hideYell;
+                player.getPacketSender().sendMessage("Your yell visibility preferences have been updated.");
+                break;
+            case "yell":
+                int delay = 0;
+                if (player.playerRights <= 1) {
+                    delay = 30000;
+                }
+                if (!AntiSpam.blockedWords(player, arguments[0].substring(5), true)) {
+                    return;
+                }
+                if (Connection.isMuted(player)) {
+                    player.getPacketSender().sendMessage("You are muted and can't speak.");
+                    return;
+                }
+                if (System.currentTimeMillis() - player.lastYell < delay) {
+                    player.getPacketSender().sendMessage("You must wait " + delay / 1000 + " seconds before yelling again.");
+                    return;
+                }
+                for (int j = 0; j < PlayerHandler.players.length; j++) {
+                    if (PlayerHandler.players[j] != null) {
+                        Client c2 = (Client) PlayerHandler.players[j];
+                        if (c2.hideYell) {
+                            return;
+                        }
+                        if (player.playerRights == 0) {
+                            c2.getPacketSender().sendMessage("[Player]" + Misc.optimizeText(player.playerName) + ": " + Misc.optimizeText(String.join(" ", arguments)) + "");
+                        } else if (player.playerRights == 1) {
+                            c2.getPacketSender().sendMessage("@blu@[Moderator] @bla@" + Misc.optimizeText(player.playerName) + ": " + Misc.optimizeText(String.join(" ", arguments)) + "");
+                        } else if (player.playerRights == 2) {
+                            c2.getPacketSender().sendMessage("@gre@[Administator] @bla@" + Misc.optimizeText(player.playerName) + ": " + Misc.optimizeText(String.join(" ", arguments)) + "");
+                        } else if (player.playerRights == 3) {
+                            c2.getPacketSender().sendMessage("@red@[Developer] @bla@" + Misc.optimizeText(player.playerName) + ": " + Misc.optimizeText(String.join(" ", arguments)) + "");
+                        }
+                        player.lastYell = System.currentTimeMillis();
+                    }
+                }
+                break;
+            case "claimvote":
+                if (!GameEngine.ersSecret.equals("")) {
+                    final String playerName = player.playerName;
+
+                    com.everythingrs.vote.Vote.service.execute(new Runnable() {
+                        @Override
+                        public void run() {
+                            try {
+                                int currentPoints = player.votePoints;
+                                com.everythingrs.vote.Vote[] reward = com.everythingrs.vote.Vote.reward(GameEngine.ersSecret, playerName, "1", "all");
+                                if (reward[0].message != null) {
+                                    player.getPacketSender().sendMessage(reward[0].message);
+                                    return;
+                                }
+                                player.votePoints = (currentPoints + reward[0].give_amount);
+                                //player.getActionSender().sendMessage("Thank you for voting! You now have " + reward[0].vote_points + " vote points.");
+                                player.getPacketSender().sendMessage(
+                                        "Thank you for voting! You now have " + player.votePoints + " vote points.");
+                            } catch (Exception e) {
+                                player.getPacketSender().sendMessage("Api Services are currently offline. Please check back shortly");
+                                e.printStackTrace();
+                            }
+                        }
+
+                    });
+                } else {
+                    player.getPacketSender().sendMessage("Voting Is Not Enabled");
+                }
+                break;
+            case "coords":
+            case "coord":
+            case "pos":
+            case "loc":
+                player.getPacketSender().sendMessage("Your coords are [" + player.absX + ", " + player.absY + ", " + player.heightLevel + "]");
+                break;
+            case "energy":
+                player.getPacketSender().sendMessage(String.format("Run energy: %d", (int) player.playerEnergy));
+                break;
+            case "password":
+            case "changepassword":
+            case "pwd":
+                if (arguments.length < 2) {
+                    player.getPacketSender().sendMessage("Must have 2 arguments: ::password oldpassword newpassword");
+                    return;
+                } else if (!PlayerSave.passwordHash(arguments[0]).equalsIgnoreCase(player.playerPass) || arguments[0].equalsIgnoreCase(player.playerPass)) {
+                    player.getPacketSender().sendMessage("Your old password is incorrect");
+                    return;
+                } else {
+                    player.getPacketSender().sendMessage("Password updated!");
+                    player.playerPass = arguments[1];
+                    player.disconnected = true;
+                    player.logout(true);
+                }
+                break;
+            case "players":
+            case "playershops":
+                int count = playerCommand.equalsIgnoreCase("players") ? PlayerHandler.getPlayerCount() : PlayerHandler.getPlayerShopCount();
+                if (count != 1) {
+                    player.getPacketSender().sendMessage("There are currently " + count + " " + (playerCommand.equalsIgnoreCase("players") ? "players" : "player shops") + " online (" + PlayerHandler.getNonPlayerCount() + " staff member online).");
+                } else {
+                    player.getPacketSender().sendMessage("There is currently " + count + " " + (playerCommand.equalsIgnoreCase("players") ? "player" : "player shop") + " online.");
+                }
+                String[] players = new String[count];
+
+                int playerIndex = 0;
+                for (Player _player : PlayerHandler.players) {
+                    if (_player != null) {
+                        if (playerCommand.equalsIgnoreCase("players") != _player.isBot) {
+                            players[playerIndex++] = _player.properName;
+                        }
+                    }
+                }
+
+
+                // Clear all lines
+                for (int i = 8144; i < 8195; i++) player.getPacketSender().sendString("", i);
+
+                player.getPacketSender().sendString("@dre@" + (playerCommand.equalsIgnoreCase("players") ? "Players" : "Player Shops"), 8144);
+
+                int playersLineNumber = 8147;
+                for (String line : players) {
+                    player.getPacketSender().sendString(line, playersLineNumber++);
+                }
+                player.getPacketSender().showInterface(8134);
+
+                break;
+            case "prayer":
+                player.getPacketSender().sendMessage(String.format("Prayer points: %d", player.playerLevel[5]));
+                break;
+            case "shop":
+                BotHandler.playerShop(player);
+                break;
+            case "snow":
+                Calendar date = new GregorianCalendar();
+                if ((date.get(Calendar.MONTH) + 1) == 12 && !player.inWild()) {
+                    if (player.isSnowy) {
+                        player.isSnowy = false;
+                        player.getPacketSender().walkableInterface(-1);
+                    } else {
+                        player.isSnowy = true;
+                        player.getPacketSender().walkableInterface(11877);
+                        player.getPacketSender().sendMessage("Happy Holidays! Type ::snow to disable/enable! (Auto-disabling in certain area)");
+                    }
+                }
+                break;
+            case "withdrawshop":
+                player.getPacketSender().sendMessage("Shorter version: ::wshop");
+            case "wshop":
+                BotHandler.takeCoins(player);
+                break;
+            case "closeshop":
+                player.getPacketSender().sendMessage("Shorter version: ::cshop");
+            case "cshop":
+                BotHandler.closeShop(player);
+                break;
+            case "wealth":
+                int totalWealth = player.getPlayerAssistant().totalGold();
+                player.getPacketSender().sendMessage("You currently have " + totalWealth + "gp.");
+                break;
+            case "gfx100":
+                if (arguments.length == 0)
+                    player.getPacketSender().sendMessage("Must have 1 argument: ::gfx100 80");
+                else
+                    player.gfx100(Integer.parseInt(arguments[0]));
+                break;
+            case "gfx0":
+                if (arguments.length == 0)
+                    player.getPacketSender().sendMessage("Must have 1 argument: ::gfx0 80");
+                else
+                    player.gfx0(Integer.parseInt(arguments[0]));
+                break;
+            case "tele":
+                if (player.connectedFrom.equals("127.0.0.1")) {
+                    try {
+                        if (arguments.length < 2) {
+                            player.getPacketSender().sendMessage("Must specify x, y and optionally z coordinates: ::tele 3222 3218 0");
+                            return;
+                        }
+                        if (arguments.length == 3)
+                            player.getPlayerAssistant().movePlayer(Integer.parseInt(arguments[0]), Integer.parseInt(arguments[1]), Integer.parseInt(arguments[2]));
+                        else
+                            player.getPlayerAssistant().movePlayer(Integer.parseInt(arguments[0]), Integer.parseInt(arguments[1]), player.heightLevel);
+                    } catch (Exception e) {
+                        player.getPacketSender().sendMessage("Invalid coordinates");
+                    }
+                } else {
+                    player.getPacketSender().sendMessage("Can't tele with ip " + player.connectedFrom);
+                }
+                break;
+            case "close_interface":
+                player.getPacketSender().closeAllWindows();
+                break;
+            case "commands":
+            case "cmd":
+                String[] commands = new String[]{
+                        "::players",
+                        "Show a list of active players",
+                        "",
+                        "::changepassword",
+                        "Change your password",
+                        "",
+                        "::highscores",
+                        "Get a list of current highscores",
+                        "",
+                        "::loc, ::pos, ::coord",
+                        "Get your current world position",
+                        "",
+                        "::stuck",
+                        "Return to Lumbridge when stuck",
+                        "",
+                        "::randomtoggle",
+                        "Enable/Disable random events",
+                        "",
+                        "::debug",
+                        "Enable/Disable debug information",
+                        "",
+                        "::togglegfx",
+                        "Enable/Disable graphics rendering",
+                        "",
+                        "::shop",
+                        "Open/Move player owned shop to your location",
+                        "",
+                        "::closeshop(::cshop)",
+                        "Close your player owned shop",
+                        "",
+                        "::withdrawshop(::wshop)",
+                        "Withdraw profits from player owned shop",
+                        "",
+                        "::snow",
+                        "Add some snow in your mainscreen(works only in december)",
+                };
+
+                // Clear all lines
+                for (int i = 8144; i < 8195; i++)
+                    player.getPacketSender().sendString("", i);
+
+                player.getPacketSender().sendString("@dre@Commands", 8144);
+
+                int commandsLineNumber = 8147;
+                for (String line : commands) {
+                    player.getPacketSender().sendString(line, commandsLineNumber++);
+                }
+                player.getPacketSender().showInterface(8134);
+                break;
+            case "stuck":
+                if (player.getCombatAssistant().inCombat()) {
+                    player.getPacketSender().sendMessage("You cannot do that while in combat.");
+                    return;
+                }
+                player.getPlayerAssistant().movePlayer(SpellTeleport.LUMBRIDGE.getDestX(), SpellTeleport.LUMBRIDGE.getDestY(), 0);
+                player.getPacketSender().sendMessage("How did you manage that one...");
+                player.getPacketSender().sendMessage("If it's bug related, please report on Github/Discord!");
+                player.gfx100(80);
+                player.startAnimation(404);
+                break;
+            case "randomtoggle":
+            case "togglerandom":
+            case "random":
+                player.randomEventsEnabled = !player.randomEventsEnabled;
+                player.getPacketSender().sendMessage("You will " + (player.randomEventsEnabled ? "now" : "no longer") + " receieve random events.");
+                break;
+            case "debug":
+            case "debugmode":
+                player.debugMode = !player.debugMode;
+                player.getPacketSender().sendMessage("You will " + (player.debugMode ? "now" : "no longer") + " receieve additional debug information when doing things.");
+                break;
+            case "highscores":
+            case "highscore":
+            case "hiscores":
+            case "hiscore":
+                for (Player p : PlayerHandler.players) {
+                    if (p == null) {
+                        continue;
+                    }
+                    PlayerSave.saveGame(p);
+                    System.out.println("Saved game for " + p.playerName + ".");
+                    GameEngine.lastMassSave = System.currentTimeMillis();
+                }
+                HighscoresHandler hs = new HighscoresHandler();
+                String[] highscores = new String[]{
+                        "Top 10 Total Level:",
+                        hs.getRank(player, 0, "level"),
+                        hs.getRank(player, 1, "level"),
+                        hs.getRank(player, 2, "level"),
+                        hs.getRank(player, 3, "level"),
+                        hs.getRank(player, 4, "level"),
+                        hs.getRank(player, 5, "level"),
+                        hs.getRank(player, 6, "level"),
+                        hs.getRank(player, 7, "level"),
+                        hs.getRank(player, 8, "level"),
+                        hs.getRank(player, 9, "level"),
+                        "",
+                        "Top 10 Wealthiest Players:",
+                        hs.getRank(player, 0, "gold"),
+                        hs.getRank(player, 1, "gold"),
+                        hs.getRank(player, 2, "gold"),
+                        hs.getRank(player, 3, "gold"),
+                        hs.getRank(player, 4, "gold"),
+                        hs.getRank(player, 5, "gold"),
+                        hs.getRank(player, 6, "gold"),
+                        hs.getRank(player, 7, "gold"),
+                        hs.getRank(player, 8, "gold"),
+                        hs.getRank(player, 9, "gold"),
+                        "",
+                        "Top 10 Highest Total Damage:",
+                        hs.getRank(player, 0, "damage"),
+                        hs.getRank(player, 1, "damage"),
+                        hs.getRank(player, 2, "damage"),
+                        hs.getRank(player, 3, "damage"),
+                        hs.getRank(player, 4, "damage"),
+                        hs.getRank(player, 5, "damage"),
+                        hs.getRank(player, 6, "damage"),
+                        hs.getRank(player, 7, "damage"),
+                        hs.getRank(player, 8, "damage"),
+                        hs.getRank(player, 9, "damage"),
+                };
+
+                // Clear all lines
+                for (int i = 8144; i < 8195; i++) player.getPacketSender().sendString("", i);
+
+                player.getPacketSender().sendString("@dre@Highscores", 8144);
+
+                int highscoresLineNumber = 8147;
+                for (String line : highscores) {
+                    player.getPacketSender().sendString(line, highscoresLineNumber++);
+                }
+                player.getPacketSender().showInterface(8134);
+
+                break;
+
+        }
+
+    }
+
+    public static void moderatorCommands(Player player, String playerCommand, String[] arguments) {
+        switch (playerCommand.toLowerCase()) {
+            case "kick":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a player name: ::kick playername");
+                        return;
+                    }
+                    String playerToKick = String.join(" ", arguments);
+                    for (Player player2 : PlayerHandler.players) {
+                        if (player2 != null) {
+                            if (player2.playerName.equalsIgnoreCase(playerToKick)) {
+                                Client c2 = (Client) player2;
+                                player.getPacketSender().sendMessage("You have kicked " + playerToKick + ".");
+                                c2.disconnected = true;
+                                c2.logout(true);
+                                break;
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Player Must Be Online.");
+                }
+                break;
+
+            case "mute":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a player name: ::mute playername");
+                        return;
+                    }
+                    String playerToBan = String.join(" ", arguments);
+                    Connection.addNameToMuteList(playerToBan);
+                    for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                        if (PlayerHandler.players[i] != null) {
+                            if (PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                Client c2 = (Client) PlayerHandler.players[i];
+                                c2.getPacketSender().sendMessage("You have been muted by: " + player.playerName);
+                                break;
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Player Must Be Offline.");
+                }
+                break;
+
+            case "ipmute":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a player name: ::ipmute playername");
+                        return;
+                    }
+                    String playerToBan = String.join(" ", arguments);
+                    for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                        if (PlayerHandler.players[i] != null) {
+                            if (PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                Connection.addIpToMuteList(PlayerHandler.players[i].connectedFrom);
+                                player.getPacketSender().sendMessage("You have IP Muted the user: " + PlayerHandler.players[i].playerName);
+                                Client c2 = (Client) PlayerHandler.players[i];
+                                c2.getPacketSender().sendMessage("You have been muted by: " + player.playerName);
+                                break;
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Player Must Be Offline.");
+                }
+                break;
+
+            case "unipmute":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a player name: ::unipmute playername");
+                        return;
+                    }
+                    String playerToBan = String.join(" ", arguments);
+                    for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                        if (PlayerHandler.players[i] != null) {
+                            if (PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                Connection.unIPMuteUser(PlayerHandler.players[i].connectedFrom);
+                                player.getPacketSender().sendMessage("You have Un Ip-Muted the user: " + PlayerHandler.players[i].playerName);
+                                break;
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Player Must Be Offline.");
+                }
+                break;
+
+            case "unmute":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a player name: ::unmute playername");
+                        return;
+                    }
+                    String playerToBan = String.join(" ", arguments);
+                    Connection.unMuteUser(playerToBan);
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Player Must Be Offline.");
+                }
+                break;
+            case "update":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify the amount of time in seconds: ::update 300");
+                        return;
+                    }
+                    PlayerHandler.updateSeconds = Integer.parseInt(arguments[0]);
+                    PlayerHandler.updateAnnounced = false;
+                    PlayerHandler.updateRunning = true;
+                    PlayerHandler.updateStartTime = System.currentTimeMillis();
+                } catch (Exception e) {
+                    System.out.println("Update exception: " + e);
+                }
+                break;
+        }
+    }
+
+    public static void adminCommands(Player player, String playerCommand, String[] arguments) {
+        switch (playerCommand.toLowerCase()) {
+            case "clearbank":
+                player.getItemAssistant().clearBank();
+                break;
+            case "ipban":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a player name: ::ipban playername");
+                        return;
+                    }
+                    String playerToBan = String.join(" ", arguments);
+                    for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                        if (PlayerHandler.players[i] != null) {
+                            if (PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                Connection.addIpToBanList(PlayerHandler.players[i].connectedFrom);
+                                Connection.addIpToFile(PlayerHandler.players[i].connectedFrom);
+                                player.getPacketSender().sendMessage("You have IP banned the user: " + PlayerHandler.players[i].playerName + " with the host: " + PlayerHandler.players[i].connectedFrom);
+                                PlayerHandler.players[i].disconnected = true;
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Player Must Be Offline.");
+                }
+                break;
+            case "ban":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a player name: ::ban playername");
+                        return;
+                    }
+                    String playerToBan = String.join(" ", arguments);
+                    Connection.addNameToBanList(playerToBan);
+                    Connection.addNameToFile(playerToBan);
+                    for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                        if (PlayerHandler.players[i] != null) {
+                            if (PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToBan)) {
+                                PlayerHandler.players[i].disconnected = true;
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Player Must Be Offline.");
+                }
+                break;
+            case "unban":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a player name: ::unban playername");
+                        return;
+                    }
+                    String playerToBan = String.join(" ", arguments);
+                    Connection.removeNameFromBanList(playerToBan);
+                    player.getPacketSender().sendMessage(playerToBan + " has been unbanned.");
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Player Must Be Offline.");
+                }
+                break;
+            case "empty":
+                player.getPlayerAssistant().handleEmpty();
+                break;
+            case "dialogue":
+                if (arguments.length == 0) {
+                    player.getPacketSender().sendMessage("You must specify an id: ::dialogue id");
+                    return;
+                }
+                int npcType = 1552;
+                int dialogueID = Integer.parseInt(arguments[0]);
+                player.getDialogueHandler().sendDialogues(dialogueID, npcType);
+                break;
+            case "interface":
+            case "int":
+                if (arguments.length == 0) {
+                    player.getPacketSender().sendMessage("You must specify an id: ::interface id");
+                    return;
+                }
+                int interfaceID = Integer.parseInt(arguments[0]);
+                player.getPacketSender().showInterface(interfaceID);
+                break;
+            case "gfx":
+                if (arguments.length == 0) {
+                    player.getPacketSender().sendMessage("You must specify an id: ::gfx id");
+                    return;
+                }
+                int gfxID = Integer.parseInt(arguments[0]);
+                player.gfx0(gfxID);
+                break;
+            case "anim":
+                if (arguments.length == 0) {
+                    player.getPacketSender().sendMessage("You must specify an id: ::anim id");
+                    return;
+                }
+                int animationID = Integer.parseInt(arguments[0]);
+                player.startAnimation(animationID);
+                player.getPlayerAssistant().requestUpdates();
+                break;
+            case "playnpc":    
+            case "pnpc":
+                int newNPC = Integer.parseInt(arguments[0]);
+                if (newNPC <= 10000 && newNPC >= 0) {
+                    player.npcId2 = newNPC;
+                    player.getPacketSender().sendMessage("Playing NPC#" + player.npcId2);
+                    player.isNpc = true;
+                    player.updateRequired = true;
+                    player.appearanceUpdateRequired = true;
+                } else {
+                    player.getPacketSender().sendMessage("You must specify an id: ::pnpc id");
+                }
+                break;    
+            case "mypos":
+                player.getPacketSender().sendMessage("X: " + player.absX);
+                player.getPacketSender().sendMessage("Y: " + player.absY);
+                player.getPacketSender().sendMessage("H: " + player.heightLevel);
+                break;
+            case "bank":
+                player.getPacketSender().openUpBank();
+                break;
+            case "xteletome":
+            case "teletome":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a player name: ::teletome playername");
+                        return;
+                    }
+                    String teleToMe = String.join(" ", arguments);
+                    for (int i = 0; i < PlayerHandler.players.length; i++) {
+                        if (PlayerHandler.players[i] != null) {
+                            if (PlayerHandler.players[i].playerName.equalsIgnoreCase(teleToMe)) {
+                                Client p = (Client) PlayerHandler.players[i];
+                                player.getPacketSender().sendMessage(p.playerName + " has been teleported to you.");
+                                p.getPlayerAssistant().movePlayer(player.absX, player.absY, player.heightLevel);
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Player is not online.");
+                }
+                break;
+            case "xteleto":
+            case "teleto":
+                if (arguments.length == 0) {
+                    player.getPacketSender().sendMessage("You must specify a player name: ::teleto playername");
+                    return;
+                }
+                String teleTo = String.join(" ", arguments);
+                for (int i = 0; i < PlayerHandler.players.length; i++) {
+                    if (PlayerHandler.players[i] != null) {
+                        if (PlayerHandler.players[i].playerName.equalsIgnoreCase(teleTo)) {
+                            player.getPlayerAssistant().movePlayer(PlayerHandler.players[i].getX(), PlayerHandler.players[i].getY(), PlayerHandler.players[i].heightLevel);
+                            return;
+                        }
+                    }
+                }
+                player.getPacketSender().sendMessage("Could not find " + teleTo + " they must be online!");
+                break;
+            case "tp":
+            case "teleport":
+            case "to":
+                if (arguments.length <= 2)
+                    player.getPlayerAssistant().movePlayer(Integer.parseInt(arguments[0]), Integer.parseInt(arguments[1]), 0);
+                else
+                    player.getPlayerAssistant().movePlayer(Integer.parseInt(arguments[0]), Integer.parseInt(arguments[1]), Integer.parseInt(arguments[2]));
+                break;
+            case "up":
+                player.getPlayerAssistant().movePlayer(player.absX, player.absY, player.heightLevel + 1);
+                player.getPacketSender().sendMessage("You are now on height level " + player.heightLevel + ".");
+                break;
+            case "up2":
+                player.getPlayerAssistant().movePlayer(player.absX, player.absY - 6400, player.heightLevel);
+                player.getPacketSender().sendMessage("You are now on height level " + player.heightLevel + ".");
+                break;
+            case "down":
+                player.getPlayerAssistant().movePlayer(player.absX, player.absY, player.heightLevel - 1);
+                player.getPacketSender().sendMessage("You are now on height level " + player.heightLevel + ".");
+                break;
+            case "down2":
+                player.getPlayerAssistant().movePlayer(player.absX, player.absY + 6400, player.heightLevel);
+                player.getPacketSender().sendMessage("You are now on height level " + player.heightLevel + ".");
+                break;
+            case "spec":
+                player.specAmount = 100.0;
+                break;
+            case "hp":
+                player.getPacketSender().sendMessage("You attributed yourself 999,999 hitpoints.");
+                player.playerLevel[3] = 999999;
+                break;
+            case "pray":
+                player.getPacketSender().sendMessage("You attributed yourself 999,999 prayer points.");
+                player.playerLevel[5] = 999999;
+                break;
+            case "setlevel":
+            case "level":
+            case "skill":
+                try {
+                    if (arguments.length < 2) {
+                        player.getPacketSender().sendMessage("Must specify a skill and level - ::setlevel 1 99");
+                        return;
+                    }
+                    int skill = Integer.parseInt(arguments[0]);
+                    int level = Integer.parseInt(arguments[1]);
+                    if (level > 99) {
+                        level = 99;
+                    } else if (level < 0) {
+                        level = 1;
+                    }
+                    player.playerXP[skill] = player.getPlayerAssistant().getXPForLevel(level) + 5;
+                    player.playerLevel[skill] = player.getPlayerAssistant().getLevelForXP(player.playerXP[skill]);
+                    player.getPlayerAssistant().refreshSkill(skill);
+                    player.getPlayerAssistant().levelUp(skill);
+                } catch (Exception e) {
+                }
+                break;
+            case "spellbook":
+                if (player.inWild()) {
+                    return;
+                }
+                if (player.playerMagicBook == 0) {
+                    player.playerMagicBook = 1;
+                    player.getPacketSender().setSidebarInterface(6, 12855);
+                    player.getPacketSender().sendMessage("An ancient wisdomin fills your mind.");
+                    player.getPlayerAssistant().resetAutocast();
+                } else if (player.playerMagicBook == 1) {
+                    player.getPacketSender().setSidebarInterface(6, 1151); // modern
+                    player.playerMagicBook = 0;
+                    player.getPacketSender().sendMessage("You feel a drain on your memory.");
+                    player.autocastId = -1;
+                    player.getPlayerAssistant().resetAutocast();
+                }
+                break;
+            case "item":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("Must specify an item id: ::item 995 1000");
+                        return;
+                    }
+                    int newItemID = Integer.parseInt(arguments[0]);
+                    int newItemAmount = arguments.length >= 2 ? Integer.parseInt(arguments[1]) : 1;
+                    if (newItemID <= 10000 && newItemID >= 0) {
+                        player.getItemAssistant().addItem(newItemID, newItemAmount);
+                        if (player.isBusy()) {
+                            player.getPacketSender().closeAllWindows();
+                        }
+                        // player.getPacketSender().sendMessage("You spawn " + newItemAmount + " × "+ ItemAssistant.getItemName(newItemID) + ".");
+                    } else {
+                        player.getPacketSender().sendMessage("No such item.");
+                    }
+                } catch (Exception e) {
+                }
+                break;
+            case "master":
+                for (int i = 0; i < 25; i++) {
+                    player.playerLevel[i] = 99;
+                    player.playerXP[i] = player.getPlayerAssistant().getXPForLevel(100);
+                    player.getPlayerAssistant().refreshSkill(i);
+                }
+                player.getPlayerAssistant().requestUpdates();
+                break;
+        }
+    }
+
+    public static void developerCommands(Player player, String playerCommand, String[] arguments) {
+        switch (playerCommand.toLowerCase()) {
+            case "quicksong":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a quick song id: ::quicksong id");
+                        return;
+                    }
+                    int song = Integer.parseInt(arguments[0]);
+                    player.getPacketSender().sendQuickSong(song, 2); //delay of 2 to repeat at least once before returning to regular music
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Sound could not be sent.");
+                }
+                break;
+            case "cameracutscene":
+                player.getPlayerAssistant().sendCameraCutscene(player.getX(), player.getY(), 10, 10, 10); //Test numbers
+                break;
+            case "camerashake":
+                player.getPlayerAssistant().sendCameraShake(1, 9, 1, 9); //these are just test numbers
+                break;
+            case "camerareset":
+                player.getPlayerAssistant().sendCameraReset(); //Resets the camera to the normal player view
+                break;
+            case "clicktotele":
+            case "ctt": // alias
+                player.clickToTele = !player.clickToTele;
+                player.getPacketSender().sendMessage("Click to teleport: " + (player.clickToTele ? "Enabled" : "Disabled"));
+                break;
+            case "giveadmin":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a player name: ::giveadmin playername");
+                        return;
+                    }
+                    String playerToAdmin = String.join(" ", arguments);
+                    for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                        if (PlayerHandler.players[i] != null) {
+                            if (PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToAdmin)) {
+                                Client c2 = (Client) PlayerHandler.players[i];
+                                player.getPacketSender().sendMessage("You have given " + playerToAdmin + " admin.");
+                                c2.playerRights = 2;
+                                c2.logout(true);
+                                break;
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Player Must Be Offline.");
+                }
+                break;
+            case "demote":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a player name: ::demote playername");
+                        return;
+                    }
+                    String playerToAdmin = String.join(" ", arguments);
+                    for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                        if (PlayerHandler.players[i] != null) {
+                            if (PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToAdmin)) {
+                                Client c2 = (Client) PlayerHandler.players[i];
+                                player.getPacketSender().sendMessage("You have demoted " + playerToAdmin + ".");
+                                c2.playerRights = 0;
+                                c2.logout(true);
+                                break;
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Player Must Be Offline.");
+                }
+                break;
+            case "givemod":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify a player name: ::givemod playername");
+                        return;
+                    }
+                    String playerToMod = String.join(" ", arguments);
+                    for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+                        if (PlayerHandler.players[i] != null) {
+                            if (PlayerHandler.players[i].playerName.equalsIgnoreCase(playerToMod)) {
+                                Client c2 = (Client) PlayerHandler.players[i];
+                                player.getPacketSender().sendMessage("You have given " + playerToMod + " mod.");
+                                c2.playerRights = 1;
+                                c2.logout(true);
+                                break;
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    player.getPacketSender().sendMessage("Player Must Be Offline.");
+                }
+                break;
+            case "object":
+                if (arguments.length == 0) {
+                    player.getPacketSender().sendMessage("You must specify an ID: ::object 1000");
+                    return;
+                }
+                player.getPacketSender().object(Integer.parseInt(arguments[0]), player.absX, player.absY, player.heightLevel, 0, 10);
+                Region.addObject(Integer.parseInt(arguments[0]), player.absX, player.absY, player.heightLevel, 10, 0, false);
+                break;
+            case "object2":
+                if (arguments.length == 0) {
+                    player.getPacketSender().sendMessage("You must specify an ID: ::object2 1000");
+                    return;
+                }
+                player.getPacketSender().object(Integer.parseInt(arguments[0]), player.absX, player.absY, player.heightLevel, 0, 0);
+                Region.addObject(Integer.parseInt(arguments[0]), player.absX, player.absY, player.heightLevel, 0, 0, false);
+                break;
+            case "npc":
+                try {
+                    if (arguments.length == 0) {
+                        player.getPacketSender().sendMessage("You must specify an ID: ::npc 1000");
+                        return;
+                    }
+                    int newNPC = Integer.parseInt(arguments[0]),
+                            maxHit = NpcHandler.getNpcListCombat(newNPC) / 10,
+                            attack = NpcHandler.getNpcListCombat(newNPC),
+                            defence = NpcHandler.getNpcListCombat(newNPC);
+                    boolean attackPlayer = NpcHandler.getNpcListCombat(newNPC) > 0;
+                    if (newNPC > 0) {
+                        NpcHandler.spawnNpc(player, newNPC, player.absX, player.absY, player.heightLevel, 0, NpcHandler.getNpcListHP(newNPC), maxHit, attack, defence, attackPlayer, false);
+                        player.getPacketSender().sendMessage("You spawn a " + NpcHandler.getNpcListName(newNPC) + ".");
+                        //player.npcSpawned = newNPC;
+                    } else {
+                        player.getPacketSender().sendMessage("Npc " + newNPC + " does not exist.");
+                    }
+                } catch (Exception e) {
+                }
+                break;
+            case "cantattack":
+                player.npcCanAttack = !player.npcCanAttack;
+                player.getPacketSender().sendMessage("Npcs " + (player.npcCanAttack ? "can" : "can no longer") + " attack you.");
+                break;
+            case "sound":
+                if (arguments.length == 0) {
+                    player.getPacketSender().sendMessage("You must specify an ID: ::sound 10");
+                    return;
+                }
+                player.getPacketSender().sendSound(Integer.parseInt(arguments[0]), 100, 0);
+                break;
+            case "tutprog":
+                if (arguments.length == 0) {
+                    player.getPacketSender().sendMessage("You must specify an ID: ::tutprog 10");
+                    return;
+                }
+                player.tutorialProgress = Integer.parseInt(arguments[0]);
+                ;
+                break;
+            case "song":
+                if (arguments.length == 0) {
+                    player.getPacketSender().sendMessage("You must specify an ID: ::song 10");
+                    return;
+                }
+                int songID = Integer.parseInt(arguments[0]);
+                player.getPacketSender().sendSong(songID);
+                break;
+            case "run":
+                player.getPacketSender().sendMessage("You have refilled your run-energy!");
+                player.playerEnergy = 100;
+                break;
+            case "runes":
+                final int amount = 10000;
+                final int[][] RUNES = {{554, amount}, {555, amount},
+                        {556, amount}, {557, amount}, {558, amount},
+                        {559, amount}, {560, amount}, {561, amount},
+                        {562, amount}, {563, amount}, {564, amount},
+                        {565, amount}, {566, amount}, {1963, 1},};
+                for (int[] element : RUNES) {
+                    int item = element[0];
+                    int amountToRecieve = element[1];
+                    player.getItemAssistant().addItem(item, amountToRecieve);
+                }
+                break;
+            case "sidebars":
+                player.getPlayerAssistant().sendSidebars();
+                break;
+        }
+    }
+}

2006Scape Server/src/main/java/com/rs2/net/packets/impl/DropItem.java

@@ -0,0 +1,123 @@
+package com.rs2.net.packets.impl;
+
+import com.rs2.GameConstants;
+import com.rs2.GameEngine;
+import com.rs2.game.content.minigames.castlewars.CastleWars;
+import com.rs2.game.content.music.sound.SoundList;
+import com.rs2.game.content.skills.SkillHandler;
+import com.rs2.game.content.skills.firemaking.LogData;
+import com.rs2.game.items.ItemConstants;
+import com.rs2.game.items.impl.RareProtection;
+import com.rs2.game.npcs.impl.Pets;
+import com.rs2.game.players.Player;
+import com.rs2.net.packets.PacketType;
+
+/**
+ * Drop Item
+ **/
+public class DropItem implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		int itemId = player.getInStream().readUnsignedWordA();
+		player.getInStream().readUnsignedByte();
+		player.getInStream().readUnsignedByte();
+		int slot = player.getInStream().readUnsignedWordA();
+		if (!player.getItemAssistant().playerHasItem(itemId) || !RareProtection.removeItemOtherActions(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()) {
+				player.pickedUpFiremakingLog = false;
+			}
+		}
+		for (LogData logData : LogData.values()) {
+			if (itemId == logData.getLogId()) {
+				if (GameEngine.objectManager.objectExists(player.absX, player.absY)) {
+					player.getPacketSender().sendMessage("You cannot drop a log here.");
+					return;
+				}
+			}
+		}
+		if (player.duelingArena()) {
+			player.getPacketSender().sendMessage(
+					"You can't drop items inside the arena!");
+			return;
+		}
+		if (player.inTrade) {
+			player.getPacketSender().sendMessage(
+					"You can't drop items while trading!");
+			return;
+		}
+		if (player.hasNpc) {
+			player.getPacketSender().sendMessage(
+					"You already have a pet dropped.");
+			return;
+		}
+		SkillHandler.resetSkills(player);
+		if (player.tutorialProgress < 36 && GameConstants.TUTORIAL_ISLAND) {
+			player.getPacketSender().sendMessage(
+					"You can't drop items on tutorial island!");
+			return;
+		}
+		if (Pets.isCatItem(itemId)) {
+			Pets.dropPet(player, itemId, slot);
+		}
+
+		player.endCurrentTask();
+		switch (itemId) {
+		case 4045:
+			if (CastleWars.isInCw(player)) {
+				int explosiveHit = 15;
+				player.startAnimation(827);
+				player.getItemAssistant().deleteItem(itemId, slot, player.playerItemsN[slot]);
+				player.handleHitMask(explosiveHit);
+				player.dealDamage(explosiveHit);
+				player.getPlayerAssistant().refreshSkill(3);
+				player.forcedText = "Ow! That really hurt!";
+				player.forcedChatUpdateRequired = true;
+				player.updateRequired = true;
+			} else {
+				player.getItemAssistant().deleteItem(4045, player.getItemAssistant().getItemAmount(4045));
+				player.getItemAssistant().deleteItem(4046, player.getItemAssistant().getItemAmount(4046));
+				player.getPacketSender().sendMessage("You can't do that! Your not in castle wars!");
+			}
+			break;
+		}
+
+		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) {
+					droppable = false;
+					break;
+				}
+			}
+		}
+		if (player.playerItemsN[slot] != 0 && itemId != -1 && player.playerItems[slot] == itemId + 1) {
+			if (droppable) {
+				for (int i = 0; i < ItemConstants.DESTROYABLE_ITEMS.length; i++) { 
+					if (itemId == ItemConstants.DESTROYABLE_ITEMS[i]) {
+						player.droppedItem = itemId;
+						player.getItemAssistant().destroyInterface(itemId);
+						return;
+					}
+				}
+				GameEngine.itemHandler.createGroundItem(player, itemId, player.getX(), player.getY(), player.playerItemsN[slot], player.getId());
+				player.getItemAssistant().deleteItem(itemId, slot, player.playerItemsN[slot]);
+				if (GameConstants.SOUND) {
+					player.getPacketSender().sendSound(SoundList.ITEM_DROP, 100, 0);
+				}
+			} else {
+				player.getPacketSender().sendMessage("This item cannot be dropped.");
+			}
+		}
+	}
+}

2006Scape Server/src/main/java/com/rs2/net/packets/impl/FollowPlayer.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/IdleLogout.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/InterfaceX.java

@@ -0,0 +1,81 @@
+package com.rs2.net.packets.impl;
+
+import com.rs2.game.content.random.PartyRoom;
+import com.rs2.game.content.skills.cooking.Cooking;
+import com.rs2.game.content.skills.smithing.Smelting;
+import com.rs2.game.players.Player;
+import com.rs2.net.packets.PacketType;
+
+public class InterfaceX implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		player.endCurrentTask();
+		int Xamount = player.getInStream().readDWord();
+		if (Xamount < 0) {
+            Xamount = player.getItemAssistant().getItemAmount(player.xRemoveId);
+        }
+        if (Xamount == 0) {
+            Xamount = 1;
+        }
+        if (!player.isBanking) {
+	        if (player.playerIsCooking && player.doAmount > 0) {
+				Cooking.cookItem(player, player.cookingItem, Xamount, player.cookingObject);
+			}
+	        if (player.isSmelting && player.doAmount > 0) {
+	        	Smelting.smeltBar(player, player.smeltingItem);
+	        }
+        }
+		switch (player.xInterfaceId) {
+			case 5064:
+				if (player.inPartyRoom) {
+					PartyRoom.depositItem(player, player.xRemoveId, player.getItemAssistant().itemAmount(player.playerItems[player.xRemoveSlot]));
+					break;
+				}
+				if (player.inTrade) {
+					player.getPacketSender().sendMessage("You can't store items while trading!");
+					return;
+				}
+				player.getItemAssistant().bankItem(player.playerItems[player.xRemoveSlot], player.xRemoveSlot, Xamount);
+				break;
+
+			case 5382:
+					player.getItemAssistant().fromBank(player.bankItems[player.xRemoveSlot], player.xRemoveSlot, Xamount);
+				break;
+
+			case 7423:
+				if (player.storing) {
+					return;
+				}
+				player.getItemAssistant().bankItem(player.playerItems[player.xRemoveSlot], player.xRemoveSlot, Xamount);
+				player.getItemAssistant().resetItems(7423);
+				break;
+
+			case 3322:
+				if (player.duelStatus <= 0) {
+					player.getTrading().tradeItem(player.xRemoveId, player.xRemoveSlot, Xamount);
+				} else {
+					player.getDueling().stakeItem(player.xRemoveId, player.xRemoveSlot, Xamount);
+				}
+				break;
+
+			case 3415:
+				if (player.duelStatus <= 0) {
+					player.getTrading().fromTrade(player.xRemoveId, player.xRemoveSlot, Xamount);
+				}
+				break;
+
+			case 6669:
+				player.getDueling().fromDuel(player.xRemoveId, player.xRemoveSlot, Xamount);
+				break;
+
+			case 3900:
+				player.getShopAssistant().buyItem(player.xRemoveId, player.xRemoveSlot, Xamount);
+				break;
+
+			case 3823:
+				player.getShopAssistant().sellItem(player.xRemoveId, player.xRemoveSlot, Xamount);
+				break;
+		}
+	}
+}

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ItemClick2.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ItemClick2OnGroundItem.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ItemClick3.java

@@ -0,0 +1,112 @@
+package com.rs2.net.packets.impl;
+
+import com.rs2.game.content.skills.runecrafting.Runecrafting;
+import com.rs2.game.items.impl.HandleEmpty;
+import com.rs2.game.items.impl.Teles;
+import com.rs2.game.players.Player;
+import com.rs2.net.packets.PacketType;
+import com.rs2.util.Misc;
+
+/**
+ * Item Click 3 Or Alternative Item Option 1
+ * 
+ * @author Ryan / Lmctruck30 Proper Streams
+ */
+
+public class ItemClick3 implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		int itemId11 = player.getInStream().readSignedWordBigEndianA();
+		int itemId1 = player.getInStream().readSignedWordA();
+		int itemId = player.getInStream().readSignedWordA();
+		if (!player.getItemAssistant().playerHasItem(itemId, 1)) {
+			return;
+		}
+		if (HandleEmpty.canEmpty(player, itemId)) {
+			HandleEmpty.handleEmptyItem(player, itemId, HandleEmpty.filledToEmpty(player, itemId));
+			return;
+		}
+		if (player.duelStatus > 0 && player.duelStatus < 5 || player.tradeStatus == 1) {
+			return;
+		}
+
+		player.endCurrentTask();
+
+		switch (itemId) {
+		case 1438:// Air Talisman
+			Runecrafting.locate(player, 2985, 3292);
+			break;
+		case 1440:// Earth Talisman
+			Runecrafting.locate(player, 3306, 3474);
+			break;
+		case 1442:// Fire Talisman
+			Runecrafting.locate(player, 3313, 3255);
+			break;
+		case 1444:// Water Talisman
+			Runecrafting.locate(player, 3185, 3165);
+			break;
+		case 1446:// Body Talisman
+			Runecrafting.locate(player, 3053, 3445);
+			break;
+		case 1448:// Mind Talisman
+			Runecrafting.locate(player, 2982, 3514);
+			break;
+		case 4079:
+			player.startAnimation(1460);
+			break;
+			
+		case 2552:
+		case 2554:
+		case 2556:
+		case 2558:
+		case 2560:
+		case 2562:
+		case 2564:
+		case 2566:
+			player.itemUsing = itemId;
+			Teles.useROD(player);
+			break;
+
+		case 1712:
+		case 1710:
+		case 1708:
+		case 1706:
+			player.itemUsing = itemId;
+			Teles.useAOG(player);
+			break;
+
+		case 3853:
+		case 3855:
+		case 3857:
+		case 3859:
+		case 3861:
+		case 3863:
+		case 3865:
+		case 3867:
+			player.itemUsing = itemId;
+			Teles.useGN(player);
+			break;
+			
+		case 1933:
+			player.getItemAssistant().deleteItem(1933, 1);
+			player.getItemAssistant().addItem(1931, 1);
+		break;
+		
+		case 1921:
+			player.getItemAssistant().deleteItem(1921, 1);
+			player.getItemAssistant().addItem(1923, 1);
+		break;
+
+		default:
+
+			if (player.playerRights == 3) {
+				Misc.println(player.playerName + " - Item3rdOption: " + itemId
+						+ " : " + itemId11 + " : " + itemId1);
+			}
+			break;
+		}
+
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ItemOnGroundItem.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ItemOnItem.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ItemOnNpc.java

@@ -0,0 +1,59 @@
+package com.rs2.net.packets.impl;
+
+import com.rs2.game.content.skills.SkillHandler;
+import com.rs2.game.items.UseItem;
+import com.rs2.game.npcs.NpcHandler;
+import com.rs2.game.players.Player;
+import com.rs2.net.packets.PacketType;
+
+public class ItemOnNpc implements PacketType {
+
+	@Override
+	public void processPacket(final Player player, int packetType, int packetSize) {
+		final int itemId = player.getInStream().readSignedWordA();
+		final int i = player.getInStream().readSignedWordA();
+		final int slot = player.getInStream().readSignedWordBigEndian();
+		final int npcId = NpcHandler.npcs[i].npcType;
+		SkillHandler.resetItemOnNpc(player);
+		player.endCurrentTask();
+		if (player.playerRights == 3) {
+			player.getPacketSender().sendMessage("Item id: " + itemId + " slot: " + slot + " i: " + i);
+		}
+		if (player.getItemAssistant().freeSlots() < 1) {
+			player.getPacketSender().sendMessage("Your inventory is full.");
+			return;
+		}
+		if (player == null || player.disconnected || !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 3021:
+			if (player.getFarmingTools().noteItem(itemId)) {
+				return;
+			}
+			break;
+			case 43:
+				NpcHandler.npcs[i].shearSheep(player, 1735, 1737, 893, 43, 42, 50);
+				break;
+		}
+		if (player.getItemAssistant().playerHasItem(995, 1) && npcId == 736) {
+			player.getItemAssistant().deleteItem(995, 1);
+			player.getDialogueHandler().sendNpcChat1("Thanks!", player.npcType, "Emily");
+		}
+		if (player.getItemAssistant().playerHasItem(1927, 1) && player.gertCat == 2 && npcId == 2997) {
+			player.getDialogueHandler().sendDialogues(319, npcId);
+			player.getItemAssistant().deleteItem(1927, 1);
+			player.getItemAssistant().addItem(1925, 1);
+			player.gertCat = 3;
+		} else if (player.getItemAssistant().playerHasItem(1552, 1) && player.gertCat == 3 && npcId == 2997) {
+			player.getDialogueHandler().sendDialogues(323, npcId);
+			player.getItemAssistant().deleteItem(1552, 1);
+			player.gertCat = 4;
+		} else if (player.getItemAssistant().playerHasItem(1554, 1) && player.gertCat == 5 && npcId == 2997) {
+			player.getItemAssistant().deleteItem(1554, 1);
+			player.getDialogueHandler().sendDialogues(326, npcId);
+		}
+		UseItem.itemOnNpc(player, itemId, slot, i);
+	}
+}

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ItemOnObject.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ItemOnPlayer.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/MagicOnFloorItems.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/MagicOnItems.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/MagicOnObject.java

@@ -0,0 +1,27 @@
+package com.rs2.net.packets.impl;
+
+import com.rs2.game.content.skills.crafting.OrbCharging;
+import com.rs2.game.players.Player;
+import com.rs2.net.packets.PacketType;
+
+public class MagicOnObject implements PacketType {
+
+	@Override
+	public void processPacket(Player player, int packetType, int packetSize) {
+		int x = player.getInStream().readSignedWordBigEndian();
+		int magicId = player.getInStream().readUnsignedWord();
+		int y = player.getInStream().readUnsignedWordA();
+		int objectId = player.getInStream().readSignedWordBigEndian();
+		
+		player.turnPlayerTo(x, y);
+		switch (objectId) {
+		case 2153:
+		case 2152:
+		case 2151:
+		case 2150:
+			OrbCharging.chargeOrbs(player, magicId, objectId);
+			break;
+		}
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/net/packets/impl/MoveItems.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/PickupItem.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/PrivateMessaging.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/RemoveItem.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/Report.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/ReportHandler.java

@@ -0,0 +1,191 @@
+package com.rs2.net.packets.impl;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import com.rs2.game.players.Player;
+import com.rs2.util.Misc;
+
+public class ReportHandler {
+
+	public static String[] savedNames = new String[500];
+	public static String[] savedSpeach = new String[500];
+	public static String[] savedTimes = new String[500];
+
+	/**
+	 * Reports
+	 */
+
+	public static final String[] reportNames = { "Offensive language",
+			"Item scamming", "Password scamming", "Bug abuse",
+			"Staff impersonation", "Account Sharing/Trading", "Macroing",
+			"Multiple Logging in", "Encouragig others to break the rules",
+			"Misuse of Customer Support", "Advertising", "Real World Trading",
+			"Asking for personal detail" };
+
+	/**
+	 * Adding texts
+	 * 
+	 * @param name
+	 *            The player's name.
+	 * @param data
+	 *            The data.
+	 * @param dataLength
+	 *            The data's length.
+	 */
+
+	public static void addText(String name, byte[] data, int dataLength) {
+		for (int i = 499; i > 0; i--) {
+			savedNames[i] = savedNames[i - 1];
+			savedSpeach[i] = savedSpeach[i - 1];
+			savedTimes[i] = savedTimes[i - 1];
+		}
+		savedNames[0] = name;
+		savedSpeach[0] = Misc.textUnpack(data, dataLength);
+		String minute = new SimpleDateFormat("mm").format(new Date());
+		String second = new SimpleDateFormat("ss").format(new Date());
+		String hour = new SimpleDateFormat("hh").format(new Date());
+		savedTimes[0] = hour + ":" + minute + ":" + second;
+	}
+
+	/**
+	 * Report Handler
+	 * 
+	 * @param c
+	 *            Client x
+	 * @throws Exception
+	 *             ex
+	 */
+
+	public static void handleReport(Player c) throws Exception {
+		String player = Misc.longToReportPlayerName(c.inStream.readQWord2());
+		player = player.replaceAll("_", " ");
+		byte rule = (byte) c.inStream.readUnsignedByte();
+		int mute = c.getInStream().readUnsignedByte();
+
+		if (c.lastReported.equalsIgnoreCase(player) && System.currentTimeMillis() - c.lastReport < 60000) {
+			c.getPacketSender().sendMessage("You can only report a player once every 60 seconds.");
+			return;
+		}
+		if (c.playerName.equalsIgnoreCase(player)) {
+			c.getPacketSender().sendMessage("You cannot report yourself!");
+			return;
+		}
+		if (hasSpoke(player)) {
+			String sendText = "";
+
+			for (int i = 20; i > 0; i--) {
+				if (savedNames[i] != null) {
+					if (savedNames[i].equalsIgnoreCase(c.playerName)
+							|| savedNames[i].equalsIgnoreCase(player)) {
+						sendText += " -[" + savedTimes[i] + ": "
+								+ savedNames[i] + "]: " + savedSpeach[i]
+								+ "\r\n";
+					}
+				}
+			}
+
+			sendText = sendText.replaceAll("'", " ");
+			String month = getMonth(new SimpleDateFormat("MM")
+					.format(new Date()));
+			String day = new SimpleDateFormat("dd").format(new Date());
+			writeReport("" + player + " was reported by " + c.playerName + ", "
+					+ reportNames[rule] + ", " + month + ", " + day + "",
+					sendText + ".", reportNames[rule]);
+			c.getPacketSender()
+					.sendMessage(
+							"Thank you, your report has been received and will be reviewed.");
+			if (mute == 1 && c.playerRights > 0) {
+				c.getPacketSender()
+						.sendMessage(
+								"This user is not muted yet! Go to the MODCP on the forums to mute him!");
+				c.getPacketSender()
+						.sendMessage(
+								"After you have muted him there, do ::update (username) to finish the mute!");
+			}
+			c.lastReported = player;
+			c.lastReport = System.currentTimeMillis();
+		} else {
+			c.getPacketSender()
+					.sendMessage(
+							"You can only report someone who has spoken in the last 60 seconds.");
+		}
+	}
+
+	/**
+	 * Saves Reports to System
+	 * 
+	 * @param data
+	 *            The data.
+	 * @param text
+	 *            The text.
+	 * @param file
+	 *            The file.
+	 */
+
+	public static void writeReport(String data, String text, String file) {
+		BufferedWriter bw = null;
+		try {
+			int time = (int) System.currentTimeMillis();
+			String month = getMonth(new SimpleDateFormat("MM")
+					.format(new Date()));
+			String day = new SimpleDateFormat("dd").format(new Date());
+			bw = new BufferedWriter(new FileWriter(
+					"data/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";
+	}
+}

2006Scape Server/src/main/java/com/rs2/net/packets/impl/SilentPacket.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/Trade.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/Walking.java

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

2006Scape Server/src/main/java/com/rs2/net/packets/impl/WearItem.java

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

2006Scape Server/src/main/java/com/rs2/net/rsa/RSAKeyGen.java

@@ -0,0 +1,57 @@
+package com.rs2.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();
+		}
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/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");

2006Scape Server/src/main/java/com/rs2/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");