Rename & Repackage

2006Scape Server/src/main/java/com/rs2/game/players/Client.java

@@ -0,0 +1,30 @@
+package com.rs2.game.players;
+
+import org.apache.mina.common.IoSession;
+
+import com.rs2.GameConstants;
+import com.rs2.util.Stream;
+
+public class Client extends Player {
+	
+	public Client(IoSession s, int _playerId) {
+		super(_playerId);
+		session = s;
+		outStream = new Stream(new byte[GameConstants.BUFFER_SIZE]);
+		outStream.currentOffset = 0;
+		inStream = new Stream(new byte[GameConstants.BUFFER_SIZE]);
+		inStream.currentOffset = 0;
+		buffer = new byte[GameConstants.BUFFER_SIZE];
+	}
+	
+	//bots
+	public Client(IoSession s) {
+		super(-1);
+		isBot = true;
+		session = null;
+		inStream = new Stream(new byte[GameConstants.BUFFER_SIZE]);
+		inStream.currentOffset = 0;
+		buffer = new byte[GameConstants.BUFFER_SIZE];
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/game/players/HighscoresHandler.java

@@ -0,0 +1,67 @@
+package com.rs2.game.players;
+
+import static com.rs2.game.players.PlayerSave.loadPlayerInfo;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Comparator;
+
+public class HighscoresHandler {
+    public ArrayList<Client> players = new ArrayList<>();
+
+    public HighscoresHandler() {
+        File dir = new File("./data/characters");
+        File[] directoryListing = dir.listFiles();
+        for (File child : directoryListing) {
+            Client player = new Client(null, -1);
+            player.playerName = child.getName().split("\\.")[0];
+            loadPlayerInfo(player, child.getName().split("\\.")[0], "", false);
+            if (player.playerRights >= 2 || // admin or dev
+                player.isBot || player.playerName.startsWith("♥")) { // ignore bots
+                continue;
+            }
+            players.add(player);
+        }
+    }
+
+    public String getRank(Player player, int i, String sortBy) {
+        if (players.size() <= i) {
+            return "-----";
+    	}
+
+        switch (sortBy) {
+            case "level":
+                players.sort(new totalLevelComparator());
+                return players.get(i).playerName + ": " + players.get(i).getPlayerAssistant().getTotalLevel();
+            case "gold":
+                players.sort(new totalGoldComparator());
+                return players.get(i).playerName + ": " + players.get(i).getPlayerAssistant().totalGold() + "gp";
+            case "damage":
+            default:
+                players.sort(new globalDmgComparator());
+                return players.get(i).playerName + ": " + players.get(i).globalDamageDealt;
+        }
+    }
+
+    private class totalLevelComparator implements Comparator<Client> {
+        @Override
+        public int compare(Client client, Client t1) {
+            return - client.getPlayerAssistant().getTotalLevel() + t1.getPlayerAssistant().getTotalLevel();
+        }
+    }
+
+    private class totalGoldComparator implements Comparator<Client> {
+        @Override
+        public int compare(Client client, Client t1) {
+            return - client.getPlayerAssistant().totalGold() + t1.getPlayerAssistant().totalGold();
+        }
+    }
+
+    private class globalDmgComparator implements Comparator<Client> {
+        @Override
+        public int compare(Client client, Client t1) {
+            return - client.globalDamageDealt + t1.globalDamageDealt;
+        }
+    }
+
+}

2006Scape Server/src/main/java/com/rs2/game/players/MainFrameIDs.java

@@ -0,0 +1,11 @@
+package com.rs2.game.players;
+
+/**
+ * Easy access to common interface IDs
+ */
+public class MainFrameIDs {
+	
+    public static final int DEPOSIT_BOX = 4465;
+    public static final int BANK = 5292; //Might be incorrect!!
+    
+}

2006Scape Server/src/main/java/com/rs2/game/players/PlayerAction.java

@@ -0,0 +1,40 @@
+package com.rs2.game.players;
+
+public class PlayerAction {
+
+	Player c;
+
+	public PlayerAction(Player player) {
+		this.c = player;
+	}
+
+	public boolean inAction = false;
+	
+	public boolean canWalk = true;
+	
+	public boolean canEat = true;
+
+	public boolean setAction(boolean action) {
+		return inAction = action;
+	}
+
+	public boolean checkAction() {
+		return inAction;
+	}
+
+	public boolean canWalk(boolean walk) {
+		return canWalk = walk;
+	}
+
+	public boolean checkWalking() {
+		return canWalk;
+	}
+
+	public boolean canEat(boolean eat) {
+		return canEat = eat;
+	}
+
+	public boolean checkEating() {
+		return canEat;
+	}
+}

2006Scape Server/src/main/java/com/rs2/game/players/PlayerHandler.java

@@ -0,0 +1,421 @@
+package com.rs2.game.players;
+
+import java.net.InetSocketAddress;
+import com.rs2.GameConstants;
+import com.rs2.GameEngine;
+import com.rs2.game.content.minigames.castlewars.CastleWars;
+import com.rs2.game.npcs.Npc;
+import com.rs2.game.npcs.NpcHandler;
+import com.rs2.util.Misc;
+import com.rs2.util.Stream;
+import com.rs2.world.GlobalDropsHandler;
+
+public class PlayerHandler {
+
+	public static Player players[] = new Player[GameConstants.MAX_PLAYERS];
+	public static int playerCount = 0, playerShopCount = 0;
+	public static String playersCurrentlyOn[] = new String[GameConstants.MAX_PLAYERS];
+	public static boolean updateAnnounced;
+	public static boolean updateRunning;
+	public static int updateSeconds;
+	public static long updateStartTime;
+	private boolean kickAllPlayers = false;
+
+	static {
+		for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+			players[i] = null;
+		}
+	}
+
+	public boolean newPlayerClient(Client client1) {
+		int slot = -1;
+		for (int i = 1; i < GameConstants.MAX_PLAYERS; i++) {
+			if (players[i] == null || players[i].disconnected) {
+				slot = i;
+				break;
+			}
+		}
+		if (slot == -1) {
+			return false;
+		}
+		client1.handler = this;
+		client1.playerId = slot;
+		players[slot] = client1;
+		players[slot].isActive = true;
+		players[slot].connectedFrom = client1.isBot ? "127.0.0.1" : ((InetSocketAddress) client1.getSession().getRemoteAddress()).getAddress().getHostAddress();
+		if (GameConstants.SERVER_DEBUG) {
+			Misc.println("Player Slot " + slot + " slot 0 " + players[0]
+					+ " Player Hit " + players[slot]);
+		}
+		return true;
+	}
+
+	public static int getPlayerCount() {
+		return playerCount;
+	}
+	
+	public static int getNonPlayerCount() {
+		int count = 0;
+		for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+			if (players[i] != null) {
+				if (players[i].playerRights >= 1) {
+					count++;
+				}
+			}
+		}
+		return count;
+	}
+
+	public static int getPlayerShopCount() {
+		return playerShopCount;
+	}
+
+	public void updatePlayerNames() {
+		playerShopCount = 0;
+		playerCount = 0;
+		for (int i = 0; i < GameConstants.MAX_PLAYERS; i++) {
+			if (players[i] != null) {
+				playersCurrentlyOn[i] = players[i].playerName;
+				if (players[i].isBot)
+					playerShopCount++;
+				else
+					playerCount++;
+			} else {
+				playersCurrentlyOn[i] = "";
+			}
+		}
+	}
+
+	public static int getPlayerID(String playerName) {
+		for (int i = 0; i < PlayerHandler.players.length; i++) {
+			if (playersCurrentlyOn[i] != null) {
+				if (playersCurrentlyOn[i].equalsIgnoreCase(playerName)) {
+					return i;
+				}
+			}
+		}
+		return -1;
+	}
+
+	public static boolean isPlayerOn(String playerName) {
+		// synchronized (PlayerHandler.players) {
+		for (int i = 0; i < PlayerHandler.players.length; i++) {
+			if (playersCurrentlyOn[i] != null) {
+				if (playersCurrentlyOn[i].equalsIgnoreCase(playerName)) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	public void process() {
+		// synchronized (PlayerHandler.players) {
+		updatePlayerNames();
+		if (kickAllPlayers) {
+			for (int i = 0; i < PlayerHandler.players.length; i++) {
+				if (players[i] != null) {
+					players[i].disconnected = true;
+				}
+			}
+			if (updateRunning) //If there's an update intended, and that's why we kicked everyone:
+			{
+				GameEngine.shutdownServer = true;
+			}
+		}
+		for (int i = 0; i < PlayerHandler.players.length; i++) {
+			if (players[i] == null || !players[i].isActive) {
+				continue;
+			}
+			try {
+
+				Client t = (Client) PlayerHandler.players[i];
+				if (players[i].disconnected) {
+					if (players[i].playerEquipment[t.playerCape] == 4042
+							|| players[i].playerEquipment[t.playerCape] == 4041) {
+						CastleWars.deleteGameItems(t);
+					}
+					PlayerSave.saveGame(t);
+				}
+
+				if (players[i].disconnected
+						&& (System.currentTimeMillis() - players[i].logoutDelay > 10000
+								|| players[i].properLogout || kickAllPlayers)) {
+					if (players[i].inTrade) {
+						Client o = (Client) PlayerHandler.players[players[i].tradeWith];
+						if (o != null) {
+							o.getTrading().declineTrade();
+						}
+					}
+					if(GameEngine.trawler.players.contains(players[i])) {
+						GameEngine.trawler.players.remove(players[i]);
+				    }
+					players[i].lastX = players[i].absX;
+					players[i].lastY = players[i].absY;
+					players[i].lastH = players[i].heightLevel;
+					if (players[i].hasNpc) {
+						t.getSummon().quickPickup(t, players[i].summonId);
+					}
+					if (players[i].duelStatus == 5) {
+						Client o = (Client) PlayerHandler.players[players[i].duelingWith];
+						if (o != null) {
+							o.getDueling().duelVictory();
+						}
+					} else if (players[i].duelStatus <= 4
+							&& players[i].duelStatus >= 1) {
+						Client o = (Client) PlayerHandler.players[players[i].duelingWith];
+						if (o != null) {
+							o.getDueling().declineDuel();
+						}
+					}
+					Client o = (Client) PlayerHandler.players[i];
+					if (PlayerSave.saveGame(o)) {
+						System.out.println("Game saved for player "
+								+ players[i].playerName);
+					} else {
+						System.out.println("Could not save for "
+								+ players[i].playerName);
+					}
+					removePlayer(players[i]);
+					players[i] = null;
+					continue;
+				}
+
+
+				while (players[i].processQueuedPackets()) {
+					;
+				}
+
+				players[i].process();
+				players[i].postProcessing();
+				players[i].getNextPlayerMovement();
+				players[i].preProcessing();
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+
+
+		for (int i = 0; i < PlayerHandler.players.length; i++) {
+			if (players[i] == null || !players[i].isActive) {
+				continue;
+			}
+			try {
+				Client t = (Client) PlayerHandler.players[i];
+				if (players[i].disconnected) {
+					if (players[i].playerEquipment[t.playerCape] == 4042
+							|| players[i].playerEquipment[t.playerCape] == 4041) {
+						CastleWars.deleteGameItems(t);
+					}
+					PlayerSave.saveGame(t);
+				}
+				if (players[i].disconnected
+						&& (System.currentTimeMillis() - players[i].logoutDelay > 10000
+								|| players[i].properLogout || kickAllPlayers)) {
+					if (players[i].inTrade) {
+						Client o = (Client) PlayerHandler.players[players[i].tradeWith];
+						if (o != null) {
+							o.getTrading().declineTrade();
+						}
+					}
+					if(GameEngine.trawler.players.contains(players[i])) {
+						GameEngine.trawler.players.remove(players[i]);
+				    }
+					players[i].lastX = players[i].absX;
+					players[i].lastY = players[i].absY;
+					players[i].lastH = players[i].heightLevel;
+					if (players[i].hasNpc) {
+						t.getSummon().quickPickup(t, players[i].summonId);
+					}
+					if (players[i].duelStatus == 5) {
+						Client o1 = (Client) PlayerHandler.players[players[i].duelingWith];
+						if (o1 != null) {
+							o1.getDueling().duelVictory();
+						}
+					} else if (players[i].duelStatus <= 4
+							&& players[i].duelStatus >= 1) {
+						Client o1 = (Client) PlayerHandler.players[players[i].duelingWith];
+						if (o1 != null) {
+							o1.getDueling().declineDuel();
+						}
+					}
+
+					Client o1 = (Client) PlayerHandler.players[i];
+					if (PlayerSave.saveGame(o1)) {
+						System.out.println("Game saved for player " + players[i].playerName);
+					} else {
+						System.out.println("Could not save for " + players[i].playerName);
+					}
+					removePlayer(players[i]);
+					players[i] = null;
+				} else {
+					if (!players[i].initialized) {
+						players[i].getPacketSender().loginPlayer();
+						players[i].initialized = true;
+					} else {
+						players[i].update();
+					}
+				}
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+
+		if (updateRunning && !updateAnnounced) {
+			updateAnnounced = true;
+			GameEngine.updateServer = true;
+		}
+		if (updateRunning
+				&& System.currentTimeMillis() - updateStartTime > updateSeconds * 1000) {
+			kickAllPlayers = true;
+		}
+
+		for (int i = 0; i < PlayerHandler.players.length; i++) {
+			if (players[i] == null || !players[i].isActive) {
+				continue;
+			}
+			try {
+				players[i].clearUpdateFlags();
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+	}
+
+	public void updateNPC(Player plr, Stream str) {
+		// synchronized(plr) {
+		updateBlock.currentOffset = 0;
+		if (str != null) {
+			str.createFrameVarSizeWord(65);
+			str.initBitAccess();
+
+			str.writeBits(8, plr.npcListSize);
+		}
+		int size = plr.npcListSize;
+		plr.npcListSize = 0;
+		for (int i = 0; i < size; i++) {
+			if (plr.rebuildNPCList == false && plr.withinDistance(plr.npcList[i])) {
+				plr.npcList[i].updateNPCMovement(str);
+				plr.npcList[i].appendNPCUpdateBlock(updateBlock);
+				plr.npcList[plr.npcListSize++] = plr.npcList[i];
+			} else {
+				int id = plr.npcList[i].npcId;
+				plr.npcInListBitmap[id >> 3] &= ~(1 << (id & 7));
+				if (str != null) {
+					str.writeBits(1, 1);
+					str.writeBits(2, 3);
+				}
+			}
+		}
+		for (Npc i : NpcHandler.npcs) {
+			if (i != null) {
+				int id = i.npcId;
+				if (plr.rebuildNPCList == false
+						&& (plr.npcInListBitmap[id >> 3] & 1 << (id & 7)) != 0) {
+				} else if (plr.withinDistance(i) == false) {
+				} else {
+					plr.addNewNPC(i, str, updateBlock);
+				}
+			}
+		}
+
+		plr.rebuildNPCList = false;
+
+		if (str != null) {
+			if (updateBlock.currentOffset > 0) {
+				str.writeBits(14, 16383);
+				str.finishBitAccess();
+				str.writeBytes(updateBlock.buffer, updateBlock.currentOffset, 0);
+			} else {
+				str.finishBitAccess();
+			}
+			str.endFrameVarSizeWord();
+		}
+	}
+
+	private final Stream updateBlock = new Stream(
+			new byte[GameConstants.BUFFER_SIZE]);
+
+	public void updatePlayer(Player plr, Stream outStr) {
+		// synchronized(plr) {
+		updateBlock.currentOffset = 0;
+		if (updateRunning && !updateAnnounced && outStr != null) {
+			outStr.createFrame(114);
+			outStr.writeWordBigEndian(updateSeconds * 50 / 30);
+		}
+		plr.updateThisPlayerMovement(outStr);
+		boolean saveChatTextUpdate = plr.isChatTextUpdateRequired();
+		plr.setChatTextUpdateRequired(false);
+		plr.appendPlayerUpdateBlock(updateBlock);
+		plr.setChatTextUpdateRequired(saveChatTextUpdate);
+		if (outStr != null) {
+			outStr.writeBits(8, plr.playerListSize);
+		}
+		int size = plr.playerListSize;
+		if (size > 255) {
+			size = 255;
+		}
+		plr.playerListSize = 0;
+		for (int i = 0; i < size; i++) {
+			if (!plr.didTeleport && !plr.playerList[i].didTeleport
+					&& plr.withinDistance(plr.playerList[i])) {
+				plr.playerList[i].updatePlayerMovement(outStr);
+				plr.playerList[i].appendPlayerUpdateBlock(updateBlock);
+				plr.playerList[plr.playerListSize++] = plr.playerList[i];
+			} else {
+				int id = plr.playerList[i].playerId;
+				plr.playerInListBitmap[id >> 3] &= ~(1 << (id & 7));
+
+				if (outStr != null) {
+					outStr.writeBits(1, 1);
+					outStr.writeBits(2, 3);
+				}
+			}
+		}
+		for (int i = 0; i < PlayerHandler.players.length; i++) {
+			if (players[i] == null || !players[i].isActive || players[i] == plr) {
+				continue;
+			}
+			int id = players[i].playerId;
+			if ((plr.playerInListBitmap[id >> 3] & 1 << (id & 7)) != 0) {
+				continue;
+			}
+			if (!plr.withinDistance(players[i])) {
+				continue;
+			}
+			plr.addNewPlayer(players[i], outStr, updateBlock);
+		}
+		if (outStr != null) {
+			if (updateBlock.currentOffset > 0) {
+				outStr.writeBits(11, 2047);
+				outStr.finishBitAccess();
+				outStr.writeBytes(updateBlock.buffer, updateBlock.currentOffset, 0);
+			} else {
+				outStr.finishBitAccess();
+			}
+
+			outStr.endFrameVarSizeWord();
+		}
+		
+		if (plr.refresh) {
+			GlobalDropsHandler.reset((Client)plr);
+			plr.refresh = false;
+		}
+	}
+
+	private void removePlayer(Player plr) {
+		if (plr.privateChat != 2) {
+			for (int i = 1; i < PlayerHandler.players.length; i++) {
+				if (players[i] == null || players[i].isActive == false) {
+					continue;
+				}
+				Client o = (Client) PlayerHandler.players[i];
+				if (o != null) {
+					o.getPlayerAssistant().updatePM(plr.playerId, 0);
+				}
+			}
+		}
+		plr.destruct();
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/game/players/PlayerSave.java

@@ -0,0 +1,859 @@
+package com.rs2.game.players;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Base64;
+
+import com.rs2.util.Misc;
+
+public class PlayerSave {
+
+	/**
+	 * Loading
+	 **/
+	public static int loadGame(Client player, String playerName, String playerPass) {
+		return loadPlayerInfo(player, playerName, playerPass, true);
+	}
+
+	public static int loadPlayerInfo(Client player, String playerName, String playerPass, boolean doRealLogin)	{
+		String line = "";
+		String token = "";
+		String token2 = "";
+		String[] token3 = new String[3];
+		boolean EndOfFile = false;
+		int ReadMode = 0;
+		BufferedReader characterfile = null;
+		boolean File1 = false;
+
+		if (player.playerName == null) {
+			System.out.println("WARNING: called loadPlayerInfo with a Client who does not have a .playerName");
+		}
+		try {
+			characterfile = new BufferedReader(new FileReader(System.getProperty("user.dir") + "/data/characters/" + player.playerName + ".txt"));
+			File1 = true;
+		} catch (FileNotFoundException fileex1) {
+		}
+
+		if (File1) {
+			// new File ("./characters/"+playerName+".txt");
+		} else {
+			if (playerName.equals(""))
+			{
+				//it's the .gitignore :P
+				return 0;
+			}
+			Misc.println(playerName + ": character file not found.");
+			player.newPlayer = false;
+			return 0;
+		}
+		try {
+			line = characterfile.readLine();
+		} catch (IOException ioexception) {
+			Misc.println(playerName + ": error loading file.");
+			return 3;
+		}
+		while (EndOfFile == false && line != null) {
+			line = line.trim();
+			int spot = line.indexOf("=");
+			if (spot > -1) {
+				token = line.substring(0, spot);
+				token = token.trim();
+				token2 = line.substring(spot + 1);
+				token2 = token2.trim();
+				token3 = token2.split("\t+");
+				switch (ReadMode) {
+					case 1:
+					    if (!doRealLogin)
+							break;
+						if (token.equals("character-password")) {
+							if (playerPass.equalsIgnoreCase(token2) || passwordHash(playerPass).equalsIgnoreCase(token2)) {
+								player.playerPass = token2; //Valid password
+							} else {
+							    System.out.println("hash doesn't match: " + passwordHash(playerPass).toLowerCase());
+							    System.out.println("currently is: " + passwordHash(token2).toLowerCase());
+	 							return 3; //Invalid password
+							}
+						}
+						break;
+					case 2:
+						switch (token) {
+							case "character-height":
+								player.heightLevel = Integer.parseInt(token2);
+								break;
+							case "character-posx":
+								player.teleportToX = Integer.parseInt(token2) <= 0 ? player.lastX : Integer.parseInt(token2);
+								break;
+							case "character-posy":
+								player.teleportToY = Integer.parseInt(token2) <= 0 ? player.lastY : Integer.parseInt(token2);
+								break;
+							case "character-rights":
+								player.playerRights = Integer.parseInt(token2);
+								break;
+							case "last-ip":
+								player.lastConnectedFrom = token2;
+								break;
+							case "isBot":
+								player.isBot = Boolean.parseBoolean(token2);
+								break;
+							case "hideYell":
+								player.hideYell = Boolean.parseBoolean(token2);
+								break;
+							case "blackMarks":
+								player.blackMarks = Integer.parseInt(token2);
+								break;
+							case "lostCannon":
+								player.lostCannon = Boolean.parseBoolean(token2);
+								break;
+							case "myBalls":
+								player.getCannon().myBalls = Integer.parseInt(token2);
+								break;
+							case "ratsCaught":
+								player.ratsCaught = Integer.parseInt(token2);
+								break;
+							case "cannonX":
+								player.cannonX = Integer.parseInt(token2);
+								break;
+							case "cannonY":
+								player.cannonY = Integer.parseInt(token2);
+								break;
+							case "removedTask0":
+								player.removedTasks[0] = Integer.parseInt(token2);
+								break;
+							case "removedTask1":
+								player.removedTasks[1] = Integer.parseInt(token2);
+								break;
+							case "removedTask2":
+								player.removedTasks[2] = Integer.parseInt(token2);
+								break;
+							case "removedTask3":
+								player.removedTasks[3] = Integer.parseInt(token2);
+								break;
+							case "SlayerMaster":
+								player.SlayerMaster = Integer.parseInt(token2);
+								break;
+							case "slayerTask":
+								player.slayerTask = Integer.parseInt(token2);
+								break;
+							case "slayerPoints":
+								player.slayerPoints = Integer.parseInt(token2);
+								break;
+							case "taskAmount":
+								player.taskAmount = Integer.parseInt(token2);
+								break;
+							case "cw-games":
+								player.cwGames = Integer.parseInt(token2);
+								break;
+							case "crystal-bow-shots":
+								player.crystalBowArrowCount = Integer.parseInt(token2);
+								break;
+							case "randomActions":
+								player.randomActions = Integer.parseInt(token2);
+								break;
+							case "debugMode":
+								player.debugMode = Boolean.parseBoolean(token2);
+								break;
+							case "global-damage":
+								player.globalDamageDealt = Integer.parseInt(token2);
+								break;
+							case "skull-timer":
+								player.skullTimer = Integer.parseInt(token2);
+								break;
+							case "recoilHits":
+								player.recoilHits = Integer.parseInt(token2);
+								break;
+							case "brightness":
+								player.brightness = Integer.parseInt(token2);
+								break;
+							case "spiritTree":
+								player.spiritTree = Boolean.parseBoolean(token2);
+								break;
+							case "npcCanAttack":
+								player.npcCanAttack = Boolean.parseBoolean(token2);
+								break;
+							case "rope":
+								player.rope = Boolean.parseBoolean(token2);
+								break;
+							case "rope2":
+								player.rope2 = Boolean.parseBoolean(token2);
+								break;
+							case "recievedMask":
+								player.recievedMask = Boolean.parseBoolean(token2);
+								break;
+							case "recievedReward":
+								player.recievedReward = Boolean.parseBoolean(token2);
+								break;
+							case "splitChat":
+								player.splitChat = Boolean.parseBoolean(token2);
+								break;
+							case "hasPaid":
+								player.hasPaid = Boolean.parseBoolean(token2);
+								break;
+							case "poison":
+								player.poison = Boolean.parseBoolean(token2);
+								break;
+							case "closeTutorialInterface":
+								player.closeTutorialInterface = Boolean
+										.parseBoolean(token2);
+								break;
+							case "canWalkTutorial":
+								player.canWalkTutorial = Boolean.parseBoolean(token2);
+								break;
+							case "needsNewTask":
+								player.needsNewTask = Boolean.parseBoolean(token2);
+								break;
+							case "musicOn":
+								player.musicOn = Boolean.parseBoolean(token2);
+								break;
+							case "barrowsNpcs":
+								player.barrowsNpcs[Integer.parseInt(token3[0])][1] = Integer.parseInt(token3[1]);
+								break;
+							case "summonId":
+								player.summonId = Integer.parseInt(token2);
+								break;
+							case "has-npc":
+								player.hasNpc = Boolean.parseBoolean(token2);
+								break;
+							case "barrowsKillCount":
+								player.barrowsKillCount = Integer.parseInt(token2);
+								break;
+							case "luthas":
+								player.luthas = Boolean.parseBoolean(token2);
+								break;
+							case "village":
+								player.village = Boolean.parseBoolean(token2);
+								break;
+							case "lastThieve":
+								player.lastThieve = Long.parseLong(token2);
+								break;
+							case "homeTele":
+								player.homeTele = Long.parseLong(token2);
+								break;
+							case "tutorial-progress":
+								player.tutorialProgress = Integer.parseInt(token2);
+								break;
+							case "strongHold":
+								player.strongHold = Boolean.parseBoolean(token2);
+								break;
+							case "filter":
+								player.filter = Boolean.parseBoolean(token2);
+								break;
+							case "ratdied2":
+								player.ratdied2 = Boolean.parseBoolean(token2);
+								break;
+							case "randomToggle":
+								player.randomEventsEnabled = Boolean.parseBoolean(token2);
+								break;
+							case "questStages":
+								player.questStages = Integer.parseInt(token2);
+								break;
+							case "cookAss":
+								player.cookAss = Integer.parseInt(token2);
+								break;
+							case "bananas":
+								player.bananas = Integer.parseInt(token2);
+								break;
+							case "sheepShear":
+								player.sheepShear = Integer.parseInt(token2);
+								break;
+							case "runeMist":
+								player.runeMist = Integer.parseInt(token2);
+								break;
+							case "doricQuest":
+								player.doricQuest = Integer.parseInt(token2);
+								break;
+							case "blackKnight":
+								player.blackKnight = Integer.parseInt(token2);
+								break;
+							case "shieldArrav":
+								player.shieldArrav = Integer.parseInt(token2);
+								break;
+							case "pirateTreasure":
+								player.pirateTreasure = Integer.parseInt(token2);
+								break;
+							case "romeo-juliet":
+								player.romeojuliet = Integer.parseInt(token2);
+								break;
+							case "vampSlayer":
+								player.vampSlayer = Integer.parseInt(token2);
+								break;
+							case "gertCat":
+								player.gertCat = Integer.parseInt(token2);
+								break;
+							case "witchspot":
+								player.witchspot = Integer.parseInt(token2);
+								break;
+							case "lostCity":
+								player.lostCity = Integer.parseInt(token2);
+								break;
+							case "restGhost":
+								player.restGhost = Integer.parseInt(token2);
+								break;
+							case "impsC":
+								player.impsC = Integer.parseInt(token2);
+								break;
+							case "knightS":
+								player.knightS = Integer.parseInt(token2);
+								break;
+							case "lastX":
+								player.lastX = Integer.parseInt(token2);
+								break;
+							case "lastY":
+								player.lastY = Integer.parseInt(token2);
+								break;
+							case "lastH":
+								player.lastH = Integer.parseInt(token2);
+								break;
+							case "hasStarter":
+								player.hasStarter = Boolean.parseBoolean(token2);
+								break;
+							case "canSpeak":
+								player.canSpeak = Boolean.parseBoolean(token2);
+								break;
+							case "questPoints":
+								player.questPoints = Integer.parseInt(token2);
+								break;
+							case "votePoints":
+								player.votePoints = Integer.parseInt(token2);
+								break;
+							case "magic-book":
+								player.playerMagicBook = Integer.parseInt(token2);
+								break;
+							case "special-amount":
+								player.specAmount = Double.parseDouble(token2);
+								break;
+							case "selected-coffin":
+								player.randomCoffin = Integer.parseInt(token2);
+								break;
+							case "isRunning":
+								player.isRunning2 = Boolean.parseBoolean(token2);
+								break;
+							case "character-energy":
+								player.playerEnergy = Integer.parseInt(token2);
+								break;
+							case "teleblock-length":
+								player.teleBlockDelay = System.currentTimeMillis();
+								player.teleBlockLength = Integer.parseInt(token2);
+								break;
+							case "lastYell":
+								player.lastYell = Long.parseLong(token2);
+								break;
+							case "pc-points":
+								player.pcPoints = Integer.parseInt(token2);
+								break;
+							case "magePoints":
+								player.magePoints = Integer.parseInt(token2);
+								break;
+							case "autoRet":
+								player.autoRet = Integer.parseInt(token2);
+								break;
+							case "flagged":
+								player.accountFlagged = Boolean.parseBoolean(token2);
+								break;
+							case "lastLoginDate":
+								player.lastLoginDate = Integer.parseInt(token2);
+								break;
+							case "hasBankpin":
+								player.hasBankpin = Boolean.parseBoolean(token2);
+								break;
+							case "setPin":
+								player.setPin = Boolean.parseBoolean(token2);
+								break;
+							case "pinRegisteredDeleteDay":
+								player.pinDeleteDateRequested = Integer.parseInt(token2);
+								break;
+							case "requestPinDelete":
+								player.requestPinDelete = Boolean.parseBoolean(token2);
+								break;
+							case "bankPin1":
+								player.bankPin1 = Integer.parseInt(token2);
+								break;
+							case "bankPin2":
+								player.bankPin2 = Integer.parseInt(token2);
+								break;
+							case "bankPin3":
+								player.bankPin3 = Integer.parseInt(token2);
+								break;
+							case "bankPin4":
+								player.bankPin4 = Integer.parseInt(token2);
+								break;
+							case "wave":
+								player.waveId = Integer.parseInt(token2);
+								break;
+							case "ptjob":
+								player.ptjob = Integer.parseInt(token2);
+								break;
+							case "creationAddress":
+								player.creationAddress = token2;
+								break;
+							case "music":
+								for (int j = 0; j < token3.length; j++) {
+									player.getPlayList().unlocked[j] = Boolean.parseBoolean(token3[j]);
+								}
+								break;
+							case "void":
+								for (int j = 0; j < token3.length; j++) {
+									player.voidStatus[j] = Integer.parseInt(token3[j]);
+								}
+								break;
+							case "gwkc":
+								player.killCount = Integer.parseInt(token2);
+								break;
+							case "fightMode":
+								player.fightMode = Integer.parseInt(token2);
+								break;
+						}
+						break;
+					case 3:
+						if (token.equals("character-equip")) {
+							player.playerEquipment[Integer.parseInt(token3[0])] = Integer.parseInt(token3[1]);
+							player.playerEquipmentN[Integer.parseInt(token3[0])] = Integer.parseInt(token3[2]);
+						}
+						break;
+					case 4:
+						if (token.equals("character-look")) {
+							player.playerAppearance[Integer.parseInt(token3[0])] = Integer	.parseInt(token3[1]);
+						}
+						break;
+					case 5:
+						if (token.equals("character-skill")) {
+							player.playerLevel[Integer.parseInt(token3[0])] = Integer.parseInt(token3[1]);
+							player.playerXP[Integer.parseInt(token3[0])] = Integer.parseInt(token3[2]);
+						}
+						break;
+					case 6:
+						if (token.equals("character-item")) {
+							player.playerItems[Integer.parseInt(token3[0])] = Integer.parseInt(token3[1]);
+							player.playerItemsN[Integer.parseInt(token3[0])] = Integer.parseInt(token3[2]);
+						}
+						break;
+					case 7:
+						if (token.equals("character-bank")) {
+							player.bankItems[Integer.parseInt(token3[0])] = Integer.parseInt(token3[1]);
+							player.bankItemsN[Integer.parseInt(token3[0])] = Integer.parseInt(token3[2]);
+							player.bankItemsV[Integer.parseInt(token3[0])] = token3.length > 3 ? Integer.parseInt(token3[3]) : 1;
+						}
+						break;
+					case 8:
+						if (token.equals("character-friend")) {
+							player.friends[Integer.parseInt(token3[0])] = Long.parseLong(token3[1]);
+						}
+						break;
+					case 9:
+						if (token.equals("character-ignore")) {
+							player.ignores[Integer.parseInt(token3[0])] = Long.parseLong(token3[1]);
+						}
+						break;
+				}
+			} else {
+				switch (line) {
+					case "[ACCOUNT]":
+						ReadMode = 1;
+						break;
+					case "[CHARACTER]":
+						ReadMode = 2;
+						break;
+					case "[EQUIPMENT]":
+						ReadMode = 3;
+						break;
+					case "[LOOK]":
+						ReadMode = 4;
+						break;
+					case "[SKILLS]":
+						ReadMode = 5;
+						break;
+					case "[ITEMS]":
+						ReadMode = 6;
+						break;
+					case "[BANK]":
+						ReadMode = 7;
+						break;
+					case "[FRIENDS]":
+						ReadMode = 8;
+						break;
+					case "[IGNORES]":
+						ReadMode = 9;
+						break;
+					case "[EOF]":
+						try {
+							characterfile.close();
+						} catch (IOException ignored) {
+						}
+						return 1;
+				}
+			}
+			try {
+				line = characterfile.readLine();
+			} catch (IOException ioexception1) {
+				EndOfFile = true;
+			}
+		}
+		try {
+			characterfile.close();
+		} catch (IOException ignored) {
+		}
+		if (doRealLogin)
+			return 13;
+		else
+			return 14;
+	}
+
+	public static String passwordHash(String token2) {
+	    String hashed = "HAS HAS FAILED!";
+		try {
+			MessageDigest digest = MessageDigest.getInstance("MD5");
+			byte[] hash = digest.digest(token2.getBytes(StandardCharsets.UTF_8));
+
+			hashed = Base64.getEncoder().encodeToString(hash);
+
+			digest = MessageDigest.getInstance("SHA-256");
+			hash = digest.digest(hashed.getBytes(StandardCharsets.UTF_8));
+
+			hashed = Base64.getEncoder().encodeToString(hash);
+		} catch (NoSuchAlgorithmException e) {
+			e.printStackTrace();
+		}
+		return hashed;
+	}
+
+	/**
+	 * Saving
+	 **/
+	public static boolean saveGame(Player player) {
+		if (!player.saveFile || player.newPlayer || !player.saveCharacter) {
+			// System.out.println("first");
+			return false;
+		}
+		if (player.playerName == null
+				|| PlayerHandler.players[player.playerId] == null) {
+			// System.out.println("second");
+			return false;
+		}
+		player.playerName = player.playerName2;
+		int tbTime = (int) (player.teleBlockDelay - System.currentTimeMillis() + player.teleBlockLength);
+		if (tbTime > 300000 || tbTime < 0) {
+			tbTime = 0;
+		}
+
+		BufferedWriter characterfile = null;
+		try {
+			String filePath = System.getProperty("user.dir") + "/data/characters/" + player.playerName + ".txt";
+			new File(filePath).getParentFile().mkdir();
+			characterfile = new BufferedWriter(new FileWriter(filePath));
+
+			/* ACCOUNT */
+			characterfile.write("[ACCOUNT]");
+			characterfile.newLine();
+			characterfile.write("character-username = " + player.playerName);
+			characterfile.newLine();
+			if (player.playerPass.length() < 40) {
+				player.playerPass = passwordHash(player.playerPass);
+			}
+			characterfile.write("character-password = " + player.playerPass);
+			characterfile.newLine();
+			characterfile.newLine();
+
+			/* CHARACTER */
+			characterfile.write("[CHARACTER]");
+			characterfile.newLine();
+			characterfile.write("character-height = " + player.heightLevel);
+			characterfile.newLine();
+			characterfile.write("character-posx = " + player.absX);
+			characterfile.newLine();
+			characterfile.write("character-posy = " + player.absY);
+			characterfile.newLine();
+			characterfile.write("character-rights = " + player.playerRights);
+			characterfile.newLine();
+			characterfile.write("last-ip = " + player.connectedFrom);
+			characterfile.newLine();
+			characterfile.write("isBot = " + player.isBot);
+			characterfile.newLine();
+			characterfile.write("hideYell = " + player.hideYell);
+			characterfile.newLine();
+			characterfile.write("hasStarter = " + player.hasStarter);
+			characterfile.newLine();
+			characterfile.write("bankPin1 = " + player.bankPin1);
+			characterfile.newLine();
+			characterfile.write("bankPin2 = " + player.bankPin2);
+			characterfile.newLine();
+			characterfile.write("bankPin3 = " + player.bankPin3);
+			characterfile.newLine();
+			characterfile.write("bankPin4 = " + player.bankPin4);
+			characterfile.newLine();
+			characterfile.write("hasBankpin = " + player.hasBankpin);
+			characterfile.newLine();
+			characterfile.write("pinRegisteredDeleteDay = " + player.pinDeleteDateRequested);
+			characterfile.newLine();
+			characterfile.write("requestPinDelete = " + player.requestPinDelete);
+			characterfile.newLine();
+			characterfile.write("lastLoginDate = " + player.lastLoginDate);
+			characterfile.newLine();
+			characterfile.write("setPin = " + player.setPin);
+			characterfile.newLine();
+			characterfile.write("hasPaid = " + player.hasPaid);
+			characterfile.newLine();
+			characterfile.write("lostCannon = " + player.lostCannon);
+			characterfile.newLine();
+			characterfile.write("ratsCaught = " + player.ratsCaught);
+			characterfile.newLine();
+			characterfile.write("cannonX = " + player.cannonX);
+			characterfile.newLine();
+			characterfile.write("cannonY = " + player.cannonY);
+			characterfile.newLine();
+			characterfile.write("myBalls = " + player.getCannon().myBalls);
+			characterfile.newLine();
+			characterfile.write("poison = " + player.poison);
+			characterfile.newLine();
+			characterfile.write("spiritTree = " + player.spiritTree);
+			characterfile.newLine();
+			characterfile.write("npcCanAttack = " + player.npcCanAttack);
+			characterfile.newLine();
+			characterfile.write("rope = " + player.rope);
+			characterfile.newLine();
+			characterfile.write("rope2 = " + player.rope2);
+			characterfile.newLine();
+			characterfile.write("recievedMask = " + player.recievedMask);
+			characterfile.newLine();
+			characterfile.write("recievedReward = " + player.recievedReward);
+			characterfile.newLine();
+			characterfile.write("global-damage = " + player.globalDamageDealt);
+			characterfile.newLine();
+			characterfile.write("brightness = " + player.brightness);
+			characterfile.newLine();
+			characterfile.write("closeTutorialInterface = " + player.closeTutorialInterface);
+			characterfile.newLine();
+			characterfile.write("canWalkTutorial = " + player.canWalkTutorial);
+			characterfile.newLine();
+			characterfile.write("village = " + player.village);
+			characterfile.newLine();
+			characterfile.write("lastThieve = " + player.lastThieve);
+			characterfile.newLine();
+			characterfile.write("homeTele = " + player.homeTele);
+			characterfile.newLine();
+			characterfile.write("strongHold = " + player.strongHold);
+			characterfile.newLine();
+			characterfile.write("character-energy = " + (int) Math.ceil(player.playerEnergy));
+			characterfile.newLine();
+			characterfile.write("crystal-bow-shots = " + player.crystalBowArrowCount);
+			characterfile.newLine();
+			characterfile.write("splitChat = " + player.splitChat);
+			characterfile.newLine();
+			characterfile.write("canSpeak = " + player.canSpeak);
+			characterfile.newLine();
+			for (int b = 0; b < player.barrowsNpcs.length; b++) {
+				characterfile.write("barrowsNpcs = " + b + "\t" + Math.max(0, player.barrowsNpcs[b][1]));
+				characterfile.newLine();
+			}
+			characterfile.write("questStages = " + player.questStages);
+			characterfile.newLine();
+			characterfile.write("SlayerMaster = " + player.SlayerMaster);
+			characterfile.newLine();
+			String music = "";
+			for (boolean element : player.getPlayList().unlocked) {
+				music += element + "\t";
+			}
+			characterfile.write("music = " + music.trim());
+			characterfile.newLine();
+			characterfile.write("randomActions = " + player.randomActions);
+			characterfile.newLine();
+			characterfile.write("blackMarks = " + player.blackMarks);
+			characterfile.newLine();
+			characterfile.write("tutorial-progress = " + player.tutorialProgress);
+			characterfile.newLine();
+			characterfile.write("skull-timer = " + player.skullTimer);
+			characterfile.newLine();
+			characterfile.write("recoilHits = " + player.recoilHits);
+			characterfile.newLine();
+			characterfile.write("lastX = " + player.lastX);
+			characterfile.newLine();
+			characterfile.write("lastY = " + player.lastY);
+			characterfile.newLine();
+			characterfile.write("lastH = " + player.lastH);
+			characterfile.newLine();
+			for (int i = 0; i < player.removedTasks.length; i++) {
+				characterfile.write("removedTask" + i + " = " + player.removedTasks[i]);
+				characterfile.newLine();
+			}
+			characterfile.write("creationAddress = " + player.creationAddress);
+			characterfile.newLine();
+			characterfile.write("has-npc = " + player.hasNpc);
+			characterfile.newLine();
+			characterfile.write("summonId = " + player.summonId);
+			characterfile.newLine();
+			characterfile.write("questPoints = " + player.questPoints);
+			characterfile.newLine();
+			characterfile.write("votePoints = " + player.votePoints);
+			characterfile.newLine();
+			characterfile.write("bananas = " + player.bananas);
+			characterfile.newLine();
+			characterfile.write("magic-book = " + player.playerMagicBook);
+			characterfile.newLine();
+			characterfile.write("special-amount = " + player.specAmount);
+			characterfile.newLine();
+			characterfile.write("musicOn = " + player.musicOn);
+			characterfile.newLine();
+			characterfile.write("needsNewTask = " + player.needsNewTask);
+			characterfile.newLine();
+			characterfile.write("luthas = " + player.luthas);
+			characterfile.newLine();
+			characterfile.write("selected-coffin = " + player.randomCoffin);
+			characterfile.newLine();
+			characterfile.write("runeMist = " + player.runeMist);
+			characterfile.newLine();
+			characterfile.write("blackKnight = " + player.blackKnight);
+			characterfile.newLine();
+			characterfile.write("shieldArrav = " + player.shieldArrav);
+			characterfile.newLine();
+			characterfile.write("cookAss = " + player.cookAss);
+			characterfile.newLine();
+			characterfile.write("pirateTreasure = " + player.pirateTreasure);
+			characterfile.newLine();
+			characterfile.write("ptjob = " + player.ptjob);
+			characterfile.newLine();
+			characterfile.write("doricQuest = " + player.doricQuest);
+			characterfile.newLine();
+			characterfile.write("impsC = " + player.impsC);
+			characterfile.newLine();
+			characterfile.write("knightS = " + player.knightS);
+			characterfile.newLine();
+			characterfile.write("sheepShear = " + player.sheepShear);
+			characterfile.newLine();
+			characterfile.write("romeo-juliet = " + player.romeojuliet);
+			characterfile.newLine();
+			characterfile.write("gertCat = " + player.gertCat);
+			characterfile.newLine();
+			characterfile.write("lostCity = " + player.lostCity);
+			characterfile.newLine();
+			characterfile.write("cw-games = " + player.cwGames);
+			characterfile.newLine();
+			characterfile.write("witchspot = " + player.witchspot);
+			characterfile.newLine();
+			characterfile.write("restGhost = " + player.restGhost);
+			characterfile.newLine();
+			characterfile.write("vampSlayer = " + player.vampSlayer);
+			characterfile.newLine();
+			characterfile.write("RatDied2 = " + player.ratdied2);
+			characterfile.newLine();
+			characterfile.write("debugMode = " + player.debugMode);
+			characterfile.newLine();
+			characterfile.write("randomToggle = " + player.randomEventsEnabled);
+			characterfile.newLine();
+			characterfile.write("teleblock-length = " + tbTime);
+			characterfile.newLine();
+			characterfile.write("pc-points = " + player.pcPoints);
+			characterfile.newLine();
+			characterfile.write("lastYell = " + player.lastYell);
+			characterfile.newLine();
+			characterfile.write("slayerTask = " + player.slayerTask);
+			characterfile.newLine();
+			characterfile.write("taskAmount = " + player.taskAmount);
+			characterfile.newLine();
+			characterfile.write("magePoints = " + player.magePoints);
+			characterfile.newLine();
+			characterfile.write("autoRet = " + player.autoRet);
+			characterfile.newLine();
+			characterfile.write("barrowsKillCount = " + player.barrowsKillCount);
+			characterfile.newLine();
+			characterfile.write("slayerPoints = " + player.slayerPoints);
+			characterfile.newLine();
+			characterfile.write("flagged = " + player.accountFlagged);
+			characterfile.newLine();
+			characterfile.write("wave = " + player.waveId);
+			characterfile.newLine();
+			characterfile.write("gwkc = " + player.killCount);
+			characterfile.newLine();
+			characterfile.write("isRunning = " + player.isRunning2);
+			characterfile.newLine();
+			characterfile.write("fightMode = " + player.fightMode);
+			characterfile.newLine();
+			String voidStatus = "";
+			for (int voidS : player.voidStatus){
+				voidStatus += voidS + "\t";
+			}
+			characterfile.write("void = " + voidStatus.trim());
+			characterfile.newLine();
+			characterfile.newLine();
+
+			/* EQUIPMENT */
+			characterfile.write("[EQUIPMENT]");
+			characterfile.newLine();
+			for (int i = 0; i < player.playerEquipment.length; i++) {
+				characterfile.write("character-equip = " + i + "\t" + player.playerEquipment[i] + "\t" + player.playerEquipmentN[i]);
+				characterfile.newLine();
+			}
+			characterfile.newLine();
+
+			/* LOOK */
+			characterfile.write("[LOOK]");
+			characterfile.newLine();
+			for (int i = 0; i < player.playerAppearance.length; i++) {
+				characterfile.write("character-look = " + i + "\t" + player.playerAppearance[i]);
+				characterfile.newLine();
+			}
+			characterfile.newLine();
+
+			/* SKILLS */
+			characterfile.write("[SKILLS]");
+			characterfile.newLine();
+			for (int i = 0; i < player.playerLevel.length; i++) {
+				characterfile.write("character-skill = " + i + "\t" + player.playerLevel[i] + "\t" + player.playerXP[i]);
+				characterfile.newLine();
+			}
+			characterfile.newLine();
+
+			/* ITEMS */
+			characterfile.write("[ITEMS]");
+			characterfile.newLine();
+			for (int i = 0; i < player.playerItems.length; i++) {
+				if (player.playerItems[i] > 0) {
+					characterfile.write("character-item = " + i + "\t" + player.playerItems[i] + "\t" + player.playerItemsN[i]);
+					characterfile.newLine();
+				}
+			}
+			characterfile.newLine();
+
+			/* BANK */
+			characterfile.write("[BANK]");
+			characterfile.newLine();
+			for (int i = 0; i < player.bankItems.length; i++) {
+				if (player.bankItems[i] > 0) {
+					characterfile.write("character-bank = " + i + "\t" + player.bankItems[i] + "\t" + player.bankItemsN[i] + (player.isBot ? "\t" + player.bankItemsV[i] : ""));
+					characterfile.newLine();
+				}
+			}
+			characterfile.newLine();
+
+			/* FRIENDS */
+			characterfile.write("[FRIENDS]");
+			characterfile.newLine();
+			for (int i = 0; i < player.friends.length; i++) {
+				if (player.friends[i] > 0) {
+					characterfile.write("character-friend = " + i + "\t" + player.friends[i]);
+					characterfile.newLine();
+				}
+			}
+			characterfile.newLine();
+
+			characterfile.write("[IGNORES]");
+			characterfile.newLine();
+			for (int i = 0; i < player.ignores.length; i++) {
+				if (player.ignores[i] > 0) {
+					characterfile.write("character-ignore = " + i + "\t" + player.ignores[i]);
+					characterfile.newLine();
+				}
+			}
+			characterfile.newLine();
+			
+			/* EOF */
+			characterfile.write("[EOF]");
+			characterfile.newLine();
+			characterfile.close();
+		} catch (IOException ioexception) {
+			Misc.println(player.playerName + ": error writing file.");
+			return false;
+		}
+		return true;
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/game/players/Position.java

@@ -0,0 +1,37 @@
+package com.rs2.game.players;
+
+/**
+ * Position
+ * @author Andrew (I'm A Boss on Rune-Server, Mr Extremez on Moparscape & Runelocus)
+ */
+
+public class Position {
+	
+	public static boolean checkPosition(Player player, int x, int y, int h) {
+		return player.absX == x && player.absY == y && player.heightLevel == h;
+	}
+	
+	public static boolean checkPlayerX(Player client, int x, int h) {
+		return client.absX == x && client.heightLevel == h;
+	}
+	
+	public static boolean checkPlayerY(Player player, int y, int h) {
+		return player.absY == y && player.heightLevel == h;
+	}
+	
+	public static boolean checkPlayerH(Player client, int h) {
+		return client.heightLevel == h;
+	}
+	
+	public static boolean checkObject(Player client, int x, int y, int h) {
+		return client.objectX == x && client.objectY == y && client.heightLevel == h;
+	}
+	
+	public static boolean checkObjectX(Player client, int x, int h) {
+		return client.objectX == x && client.heightLevel == h;
+	}
+	
+	public static boolean checkObjectY(Player client, int y, int h) {
+		return client.objectY == y && client.heightLevel == h;
+	}
+}

2006Scape Server/src/main/java/com/rs2/game/players/Trading.java

@@ -0,0 +1,549 @@
+package com.rs2.game.players;
+
+import java.time.temporal.ValueRange;
+import java.util.concurrent.CopyOnWriteArrayList;
+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.items.GameItem;
+import com.rs2.game.items.ItemData;
+import com.rs2.game.items.ItemAssistant;
+import com.rs2.game.items.ItemConstants;
+import com.rs2.util.GameLogger;
+import com.rs2.util.Misc;
+
+public class Trading {
+
+	private final Player player;
+
+	public Trading(Player player2) {
+		player = player2;
+	}
+
+	/**
+	 * Trading
+	 **/
+
+	public CopyOnWriteArrayList<GameItem> offeredItems = new CopyOnWriteArrayList<GameItem>();
+
+	public void requestTrade(int id) {
+		try {
+			Client o = (Client) PlayerHandler.players[id];
+			if (id == player.playerId) {
+				return;
+			}
+
+			// player owned shop
+			if (o.isBot && o.shopId >= 0){
+				if (isCloseTo(o)) {
+					player.getShopAssistant().openShop(o.shopId);
+				} else {
+					player.getPacketSender().sendMessage("Player is not close enough. Retry when you are closer...");
+				}
+				return;
+			}
+
+			player.tradeWith = id;
+
+			if (!CastleWars.deleteCastleWarsItems(player, id)) {
+				return;
+			}
+
+			if (!player.inTrade && o.tradeRequested && o.tradeWith == player.playerId && !player.playerIsBusy() && !o.playerIsBusy() ) { //start trading process
+				if (!isCloseTo(o)) {
+					player.getPacketSender().sendMessage("Player is not close enough. Retry when you are closer...");
+				} else {
+					player.getTrading().openTrade();
+					o.getTrading().openTrade();
+				}
+			} else if (!player.inTrade && !player.playerIsBusy() && !o.playerIsBusy()) { //send trade request
+				//Problem = sends the request then walk to player. Solution= change processing order. Fix= Send message when trying to open the trade interface if the other player isn't closer than 3 tiles.
+				player.tradeRequested = true;
+				player.getPacketSender().sendMessage("Sending trade request...");
+				o.getPacketSender()
+						.sendMessage(player.playerName + ":tradereq:");
+			} else if (player.playerIsBusy()|| o.playerIsBusy()) {
+				player.getPacketSender().sendMessage("Other player is busy at the moment.");
+			}
+		} catch (Exception e) {
+			Misc.println("Error requesting trade.");
+		}
+	}
+	public boolean isCloseTo(Client tradedPlayer) {
+		ValueRange PlayerCoordRangeX = ValueRange.of(tradedPlayer.absX - 3, tradedPlayer.absX + 3);
+		ValueRange PlayerCoordRangeY = ValueRange.of(tradedPlayer.absY - 3, tradedPlayer.absY + 3);
+		if (PlayerCoordRangeX.isValidIntValue(player.absX) && PlayerCoordRangeY.isValidIntValue(player.absY)) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	public void openTrade() {
+		Client o = (Client) PlayerHandler.players[player.tradeWith];
+
+		if (o == null) {
+			return;
+		}
+		player.inTrade = true;
+		player.tradeStatus = 1;
+		player.tradeRequested = false;
+		player.getItemAssistant().resetItems(3322);
+		resetTItems(3415);
+		resetOTItems(3416);
+		String out = o.playerName;
+
+		if (o.playerRights == 1) {
+			out = "@cr1@" + out;
+		} else if (o.playerRights == 2) {
+			out = "@cr2@" + out;
+		}
+		player.getPacketSender().sendString(
+				"Trading with: " + o.playerName + " who has @gre@"
+						+ o.getItemAssistant().freeSlots() + " free slots",
+				3417);
+		player.getPacketSender().sendString("", 3431);
+		player.getPacketSender().sendString(
+				"Are you sure you want to make this trade?", 3535);
+		player.getPacketSender().sendFrame248(3323, 3321);
+	}
+
+	public void resetTItems(int WriteFrame) {
+		synchronized (player) {
+			player.getOutStream().createFrameVarSizeWord(53);
+			player.getOutStream().writeWord(WriteFrame);
+			int len = offeredItems.toArray().length;
+			int current = 0;
+			player.getOutStream().writeWord(len);
+			for (GameItem item : offeredItems) {
+				if (item.amount > 254) {
+					player.getOutStream().writeByte(255);
+					player.getOutStream().writeDWord_v2(item.amount);
+				} else {
+					player.getOutStream().writeByte(item.amount);
+				}
+				player.getOutStream().writeWordBigEndianA(item.id + 1);
+				current++;
+			}
+			if (current < 27) {
+				for (int i = current; i < 28; i++) {
+					player.getOutStream().writeByte(1);
+					player.getOutStream().writeWordBigEndianA(-1);
+				}
+			}
+			player.getOutStream().endFrameVarSizeWord();
+			player.flushOutStream();
+		}
+	}
+
+	public boolean fromTrade(int itemID, int fromSlot, int amount) {
+		Client o = (Client) PlayerHandler.players[player.tradeWith];
+		if (o == null) {
+			return false;
+		}
+		try {
+			if (!player.inTrade) {
+				declineTrade();
+				return false;
+			}
+			player.tradeConfirmed = false;
+			o.tradeConfirmed = false;
+			if (!ItemData.itemStackable[itemID]) {
+				for (int a = 0; a < amount; a++) {
+					for (GameItem item : offeredItems) {
+						if (item.id == itemID) {
+							if (!item.stackable) {
+								offeredItems.remove(item);
+								player.getItemAssistant().addItem(itemID, 1);
+								o.getPacketSender().sendString(
+										"Trading with: "
+												+ player.playerName
+												+ " who has @gre@"
+												+ player.getItemAssistant()
+														.freeSlots()
+												+ " free slots", 3417);
+							} else {
+								if (item.amount > amount) {
+									item.amount -= amount;
+									player.getItemAssistant()
+											.addItem(itemID, amount);
+									o.getPacketSender().sendString(
+											"Trading with: "
+													+ player.playerName
+													+ " who has @gre@"
+													+ player.getItemAssistant()
+															.freeSlots()
+													+ " free slots", 3417);
+								} else {
+									amount = item.amount;
+									offeredItems.remove(item);
+									player.getItemAssistant()
+											.addItem(itemID, amount);
+									o.getPacketSender().sendString(
+											"Trading with: "
+													+ player.playerName
+													+ " who has @gre@"
+													+ player.getItemAssistant()
+															.freeSlots()
+													+ " free slots", 3417);
+								}
+							}
+							break;
+						}
+						o.getPacketSender().sendString(
+								"Trading with: " + player.playerName
+										+ " who has @gre@"
+										+ player.getItemAssistant().freeSlots()
+										+ " free slots", 3417);
+						player.tradeConfirmed = false;
+						o.tradeConfirmed = false;
+						player.getItemAssistant().resetItems(3322);
+						resetTItems(3415);
+						o.getTrading().resetOTItems(3416);
+						player.getPacketSender().sendString("", 3431);
+						o.getPacketSender().sendString("", 3431);
+					}
+				}
+			}
+			for (GameItem item : offeredItems) {
+				if (item.id == itemID) {
+					if (!item.stackable) {
+					} else {
+						if (item.amount > amount) {
+							item.amount -= amount;
+							player.getItemAssistant().addItem(itemID, amount);
+							o.getPacketSender().sendString(
+									"Trading with: " + player.playerName
+											+ " who has @gre@"
+											+ player.getItemAssistant().freeSlots()
+											+ " free slots", 3417);
+						} else {
+							amount = item.amount;
+							offeredItems.remove(item);
+							player.getItemAssistant().addItem(itemID, amount);
+							o.getPacketSender().sendString(
+									"Trading with: " + player.playerName
+											+ " who has @gre@"
+											+ player.getItemAssistant().freeSlots()
+											+ " free slots", 3417);
+						}
+					}
+					break;
+				}
+			}
+
+			o.getPacketSender().sendString(
+					"Trading with: " + player.playerName + " who has @gre@"
+							+ player.getItemAssistant().freeSlots() + " free slots",
+					3417);
+			player.tradeConfirmed = false;
+			o.tradeConfirmed = false;
+			player.getItemAssistant().resetItems(3322);
+			resetTItems(3415);
+			o.getTrading().resetOTItems(3416);
+			player.getPacketSender().sendString("", 3431);
+			o.getPacketSender().sendString("", 3431);
+		} catch (Exception e) {
+		}
+		return true;
+	}
+
+	public boolean tradeItem(int itemID, int fromSlot, int amount) {
+		Client o = (Client) PlayerHandler.players[player.tradeWith];
+		if (o == null) {
+			return false;
+		}
+		if (!(player.playerItems[fromSlot] == itemID + 1 )){//&& player.playerItemsN[fromSlot] >= amount)) { I removed this check to permit trading max amount of item in inventory even when amount is higher than quantity in inventory.
+			player.getPacketSender().sendMessage("You don't have that amount!");
+			return false;
+		}
+		
+		if (amount >= Integer.MAX_VALUE) {
+			player.getPacketSender().sendMessage("You can't possibly have that much of that item!");
+			player.getItemAssistant().deleteItem(itemID, fromSlot, amount);
+			return false;
+		}
+
+		for (int i : ItemConstants.ITEM_TRADEABLE) {
+			if (i == itemID && player.playerRights < 3) {
+				player.getPacketSender().sendMessage("You can't trade this item.");
+				return false;
+			}
+		}
+		player.tradeConfirmed = false;
+		o.tradeConfirmed = false;
+		if (!ItemData.itemStackable[itemID] && !ItemData.itemIsNote[itemID]) {
+			for (int a = 0; a < amount && a < 28; a++) {
+				if (player.getItemAssistant().playerHasItem(itemID, 1)) {
+					offeredItems.add(new GameItem(itemID, 1));
+					player.getItemAssistant().deleteItem(itemID,
+							player.getItemAssistant().getItemSlot(itemID), 1);
+					o.getPacketSender().sendString(
+							"Trading with: " + player.playerName + " who has @gre@"
+									+ player.getItemAssistant().freeSlots()
+									+ " free slots", 3417);
+				}
+			}
+			o.getPacketSender().sendString(
+					"Trading with: " + player.playerName + " who has @gre@"
+							+ player.getItemAssistant().freeSlots() + " free slots",
+					3417);
+			player.getItemAssistant().resetItems(3322);
+			resetTItems(3415);
+			o.getTrading().resetOTItems(3416);
+			player.getPacketSender().sendString("", 3431);
+			o.getPacketSender().sendString("", 3431);
+		}
+		if (player.getItemAssistant().getItemAmount(itemID) < amount) {
+			amount = player.getItemAssistant().getItemAmount(itemID);
+			if (amount == 0) {
+				return false;
+			}
+		}
+		if (!player.inTrade || !o.inTrade) {
+			declineTrade();
+			return false;
+		}
+		if (ItemData.itemStackable[itemID] || ItemData.itemIsNote[itemID]) {
+			boolean inTrade = false;
+			for (GameItem item : offeredItems) {
+				if (item.id == itemID) {
+					inTrade = true;
+					item.amount += amount;
+					player.getItemAssistant().deleteItem(itemID, amount);
+					o.getPacketSender().sendString(
+							"Trading with: " + player.playerName + " who has @gre@"
+									+ player.getItemAssistant().freeSlots()
+									+ " free slots", 3417);
+					break;
+				}
+			}
+
+			if (!inTrade) {
+				offeredItems.add(new GameItem(itemID, amount));
+				player.getItemAssistant().deleteItem(itemID, amount);
+				o.getPacketSender().sendString(
+						"Trading with: " + player.playerName + " who has @gre@"
+								+ player.getItemAssistant().freeSlots()
+								+ " free slots", 3417);
+			}
+		}
+		o.getPacketSender().sendString(
+				"Trading with: " + player.playerName + " who has @gre@"
+						+ player.getItemAssistant().freeSlots() + " free slots",
+				3417);
+		player.getItemAssistant().resetItems(3322);
+		resetTItems(3415);
+		o.getTrading().resetOTItems(3416);
+		player.getPacketSender().sendString("", 3431);
+		o.getPacketSender().sendString("", 3431);
+		return true;
+	}
+
+	public void resetTrade() {
+		offeredItems.clear();
+		player.inTrade = false;
+		player.tradeWith = 0;
+		player.tradeConfirmed = false;
+		player.tradeConfirmed2 = false;
+		player.acceptedTrade = false;
+		player.getPacketSender().closeAllWindows();
+		player.tradeResetNeeded = false;
+		player.getPacketSender().sendString("Are you sure you want to make this trade?", 3535);
+	}
+
+	public void declineTrade() {
+		player.tradeStatus = 0;
+		declineTrade(true);
+	}
+
+	public void declineTrade(boolean tellOther) {
+		player.getPacketSender().closeAllWindows();
+		Client o = (Client) PlayerHandler.players[player.tradeWith];
+		if (o == null) {
+			return;
+		}
+
+		if (tellOther) {
+			o.getTrading().declineTrade(false);
+			o.getTrading().player.getPacketSender().closeAllWindows();
+		}
+
+		for (GameItem item : offeredItems) {
+			if (item.amount < 1) {
+				continue;
+			}
+			if (item.stackable) {
+				player.getItemAssistant().addItem(item.id, item.amount);
+			} else {
+				for (int i = 0; i < item.amount; i++) {
+					player.getItemAssistant().addItem(item.id, 1);
+				}
+			}
+		}
+		player.tradeConfirmed = false;
+		player.tradeConfirmed2 = false;
+		offeredItems.clear();
+		player.inTrade = false;
+		player.tradeWith = 0;
+	}
+
+	public void resetOTItems(int WriteFrame) {
+		synchronized (player) {
+			Client o = (Client) PlayerHandler.players[player.tradeWith];
+			if (o == null) {
+				return;
+			}
+			player.getOutStream().createFrameVarSizeWord(53);
+			player.getOutStream().writeWord(WriteFrame);
+			int len = o.getTrading().offeredItems.toArray().length;
+			int current = 0;
+			player.getOutStream().writeWord(len);
+			for (GameItem item : o.getTrading().offeredItems) {
+				if (item.amount > 254) {
+					player.getOutStream().writeByte(255); // item's stack count. if over 254, write byte 255
+					player.getOutStream().writeDWord_v2(item.amount);
+				} else {
+					player.getOutStream().writeByte(item.amount);
+				}
+				player.getOutStream().writeWordBigEndianA(item.id + 1); // item id
+				current++;
+			}
+			if (current < 27) {
+				for (int i = current; i < 28; i++) {
+					player.getOutStream().writeByte(1);
+					player.getOutStream().writeWordBigEndianA(-1);
+				}
+			}
+			player.getOutStream().endFrameVarSizeWord();
+			player.flushOutStream();
+		}
+	}
+
+	public void confirmScreen() {
+		Client o = (Client) PlayerHandler.players[player.tradeWith];
+		if (o == null) {
+			return;
+		}
+		if(!player.inTrade) {
+            declineTrade();
+            return;
+        }
+		player.getItemAssistant().resetItems(3214);
+		String SendTrade = "Absolutely nothing!";
+		String SendAmount = "";
+		int Count = 0;
+		for (GameItem item : offeredItems) {
+			if (item.id > 0) {
+				if (item.amount >= 1000 && item.amount < 1000000) {
+					SendAmount = "@cya@" + item.amount / 1000 + "K @whi@("
+							+ Misc.format(item.amount) + ")";
+				} else if (item.amount >= 1000000) {
+					SendAmount = "@gre@" + item.amount / 1000000
+							+ " million @whi@(" + Misc.format(item.amount)
+							+ ")";
+				} else {
+					SendAmount = "" + Misc.format(item.amount);
+				}
+
+				if (Count == 0) {
+					SendTrade = ItemAssistant.getItemName(item.id);
+				} else {
+					SendTrade = SendTrade + "\\n"
+							+ ItemAssistant.getItemName(item.id);
+				}
+
+				if (item.stackable) {
+					SendTrade = SendTrade + " x " + SendAmount;
+				}
+				Count++;
+			}
+		}
+
+		player.getPacketSender().sendString(SendTrade, 3557);
+		SendTrade = "Absolutely nothing!";
+		SendAmount = "";
+		Count = 0;
+
+		for (GameItem item : o.getTrading().offeredItems) {
+			if (item.id > 0) {
+				if (item.amount >= 1000 && item.amount < 1000000) {
+					SendAmount = "@cya@" + item.amount / 1000 + "K @whi@("
+							+ Misc.format(item.amount) + ")";
+				} else if (item.amount >= 1000000) {
+					SendAmount = "@gre@" + item.amount / 1000000
+							+ " million @whi@(" + Misc.format(item.amount)
+							+ ")";
+				} else {
+					SendAmount = "" + Misc.format(item.amount);
+				}
+
+				if (Count == 0) {
+					SendTrade = ItemAssistant.getItemName(item.id);
+				} else {
+					SendTrade = SendTrade + "\\n"
+							+ ItemAssistant.getItemName(item.id);
+				}
+				if (item.stackable) {
+					SendTrade = SendTrade + " x " + SendAmount;
+				}
+				Count++;
+			}
+		}
+		player.getPacketSender().sendString(SendTrade, 3558);
+		// TODO: find out what 197 does eee 3213
+		player.getPacketSender().sendFrame248(3443, 197);
+	}
+
+	public void giveItems() {
+		Client o = (Client) PlayerHandler.players[player.tradeWith];
+		if (o == null) {
+			return;
+		}
+		try {
+			for (GameItem item : o.getTrading().offeredItems) {
+				String itemName = ItemAssistant.getItemName(item.id);
+				if (item.id > 0) {
+					player.getItemAssistant().addItem(item.id, item.amount);
+					if (player.getPlayerAssistant().isPlayer()) {
+						GameLogger.writeLog(o.playerName, "tradesgave", o.playerName + " traded " + player.playerName + " and gave " + item.amount + " " + itemName + "");
+					}
+				}
+				if (player.getPlayerAssistant().isPlayer()) {
+					GameLogger.writeLog(player.playerName, "tradesrecieved", player.playerName + " was traded by " + o.playerName + " and recieved " + item.amount + " " + itemName + "");
+				}
+			}
+			player.getPacketSender().closeAllWindows();
+			player.tradeResetNeeded = true;
+			   CycleEventHandler.getSingleton().addEvent(player, new CycleEvent() {
+		            @Override
+		            public void execute(CycleEventContainer container) {
+					if (player.inTrade && player.tradeResetNeeded) {
+						Client o = (Client) PlayerHandler.players[player.tradeWith];
+						if (o != null) {
+							if (o.tradeResetNeeded) {
+								player.getTrading().resetTrade();
+								o.getTrading().resetTrade();
+								container.stop();
+							} else {
+								container.stop();
+							}
+						} else {
+							container.stop();
+						}
+					} else {
+						container.stop();
+					}
+				}
+
+				@Override
+				public void stop() {
+					player.tradeResetNeeded = false;
+				}
+			}, 1);
+		} catch (Exception e) {
+			
+		}
+	}
+
+}

2006Scape Server/src/main/java/com/rs2/game/players/antimacro/AntiSpam.java

@@ -0,0 +1,35 @@
+package com.rs2.game.players.antimacro;
+
+import com.rs2.game.players.Player;
+
+/**
+ * AntiSpam
+ * @author Andrew (I'm A Boss on Rune-Server and Mr Extremez on Mopar & Runelocus)
+ */
+
+public class AntiSpam {
+	
+	private final static String[] BLOCKED_WORDS = {
+		"(dot)", ".com", "tk", ".org", ".net", ".info", ".cam", ".c0m", ". net", "(,)com", ".inf0", ".0rg", "(.)",
+		".biz", ".co.uk", ". com", ". info", ". c0m", ",com", ". biz", ". tk", ". 0rg", ". cam", ". inf0", "c'om",
+		"c'0m", ". org", "http", "no-ip", "tradereq", "duelreq", "www", "vww", "c' om", "c' 0m", "w-w-w", "w'ww",
+		"w'w'w", "w 'ww", "w' w' w", "ww' w", "wvv", "wwv", "vvv", "vwv", "w)w)w", "?com", "/com", "'com",  "(com)",
+		"(w)(w)(w)", "sythe", "abusewith.us", "runerebels", "06prime", "2006prime", "arios498", "ariosrsps", "coom"
+	};
+	
+	public static boolean blockedWords(Player player, String word, boolean chat) {
+		for (int i = 0; i < BLOCKED_WORDS.length; i++) {
+			if (player.getPlayerAssistant().isPlayer()) {
+				if (word.contains(BLOCKED_WORDS[i]) || word.equalsIgnoreCase(player.playerPass)) {
+					player.getPacketSender().sendMessage("You can't say that word!");
+					if (chat) {
+						player.setChatTextUpdateRequired(false);
+					}
+					return false;
+				}	
+			}
+		}
+		return true;
+	}
+
+}