package net.zamorak.client;

import java.applet.AppletContext;
import java.awt.Color;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.Socket;
import java.net.URL;
import java.net.UnknownHostException;
import java.text.DateFormat;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.Iterator;
import java.util.Locale;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.regex.Pattern;
import java.util.zip.CRC32;

import net.zamorak.client.Configuration.ConfigType;
import net.zamorak.client.alertify4j.Alertify;
import net.zamorak.client.alertify4j.AlertifyBuilder;
import net.zamorak.client.alertify4j.AlertifyType;
import net.zamorak.client.alertify4j.ui.AlertifyWindow;
import net.zamorak.client.alertify4j.ui.AlertifyWindowClick;
import net.zamorak.client.cache.Archive;
import net.zamorak.client.cache.definition.Animation;
import net.zamorak.client.cache.definition.Flo;
import net.zamorak.client.cache.definition.IdentityKit;
import net.zamorak.client.cache.definition.ItemDefinition;
import net.zamorak.client.cache.definition.MobDefinition;
import net.zamorak.client.cache.definition.ObjectDefinition;
import net.zamorak.client.cache.definition.OverLayFlo317;
import net.zamorak.client.cache.definition.SpotAnimDefinition;
import net.zamorak.client.cache.definition.VarBit;
import net.zamorak.client.cache.definition.Varp;
import net.zamorak.client.cache.node.Deque;
import net.zamorak.client.cache.node.Node;
import net.zamorak.client.cache.ondemand.OnDemandFetcher;
import net.zamorak.client.cache.ondemand.OnDemandRequest;
import net.zamorak.client.constants.Constants;
import net.zamorak.client.constants.GameFrameConstants;
import net.zamorak.client.constants.GameFrameConstants.GameFrameType;
import net.zamorak.client.constants.SizeConstants;
import net.zamorak.client.entity.player.ClanMember;
import net.zamorak.client.entity.player.Player;
import net.zamorak.client.entity.player.PlayerHandler;
import net.zamorak.client.file.CacheDownloader;
import net.zamorak.client.file.CacheDownloader.FileType;
import net.zamorak.client.file.CacheUpdater;
import net.zamorak.client.graphics.Background;
import net.zamorak.client.graphics.DrawingArea;
import net.zamorak.client.graphics.Sprite;
import net.zamorak.client.graphics.SpriteLoader;
import net.zamorak.client.graphics.fonts.Censor;
import net.zamorak.client.graphics.fonts.RSFontSystem;
import net.zamorak.client.graphics.fonts.TextClass;
import net.zamorak.client.graphics.fonts.TextDrawingArea;
import net.zamorak.client.graphics.fonts.TextInput;
import net.zamorak.client.graphics.gameframe.GameFrame;
import net.zamorak.client.graphics.gameframe.GameFrame.ScreenMode;
import net.zamorak.client.graphics.gameframe.impl.ChatArea;
import net.zamorak.client.graphics.gameframe.impl.MapArea;
import net.zamorak.client.graphics.gameframe.impl.MapArea.PouchModifyType;
import net.zamorak.client.graphics.gameframe.impl.TabArea;
import net.zamorak.client.io.ByteBuffer;
import net.zamorak.client.io.ISAACCipher;
import net.zamorak.client.net.Connection;
import net.zamorak.client.net.InetAddressUtils;
import net.zamorak.client.renderable.Animable;
import net.zamorak.client.renderable.Animable_Sub3;
import net.zamorak.client.renderable.Animable_Sub5;
import net.zamorak.client.renderable.Entity;
import net.zamorak.client.renderable.Item;
import net.zamorak.client.renderable.NPC;
import net.zamorak.client.renderable.PlayerProjectile;
import net.zamorak.client.task.TaskType;
import net.zamorak.client.task.TimedTask;
import net.zamorak.client.task.TimedTaskHandler;
import net.zamorak.client.tools.FileUtilities;
import net.zamorak.client.world.CollisionMap;
import net.zamorak.client.world.CustomObjectSpawns;
import net.zamorak.client.world.Model;
import net.zamorak.client.world.Object1;
import net.zamorak.client.world.Object2;
import net.zamorak.client.world.Object3;
import net.zamorak.client.world.Object5;
import net.zamorak.client.world.ObjectManager;
import net.zamorak.client.world.Rasterizer;
import net.zamorak.client.world.Texture;
import net.zamorak.client.world.WorldController;
import net.zamorak.client.world.background.ScriptManager;
import net.zamorak.client.world.fog.FogHandler;
import net.zamorak.client.world.music.Class56;
import net.zamorak.client.world.music.Class56_Sub1_Sub1;
import net.zamorak.client.world.sound.Class25;
import net.zamorak.client.world.sound.Class3_Sub7;
import net.zamorak.client.world.sound.Class3_Sub7_Sub1;
import net.zamorak.client.world.sound.Class3_Sub7_Sub2;
import net.zamorak.client.world.sound.Class3_Sub9_Sub1;
import net.zamorak.client.world.sound.Class5;
import net.zamorak.client.world.sound.Class5_Sub1;
import net.zamorak.client.world.sound.Class5_Sub2;
import net.zamorak.client.world.sound.Class5_Sub2_Sub1;
import net.zamorak.client.world.sound.Class5_Sub2_Sub2;
import net.zamorak.client.world.sound.Sound;
import net.zamorak.client.world.sound.Sounds;

public class Client extends GameApplet {

	public FogHandler fogHandler = new FogHandler();

	public static final java.util.List<ClanUser> CLAN_CHAT_USERS = new ArrayList<>();
	public static final java.util.List<ClanUser> CONFIGURE_INTERFACE_USERS = new ArrayList<>();

	public static final int CACHE_INDEX_COUNT = 6;

	private static Configuration config = new Configuration();

	public JFont testFont;
	public JFont testFont2;

	/**
	 * The previous plane the player was on
	 */
	private int previousPlane;

	public static Configuration getConfig() {
		return config;
	}

	protected Queue<TimedTask> tasks = new ConcurrentLinkedDeque<>();

	/**
	 * The split chat color, by default its 65535
	 */
	public int splitChatColor = 0;

	public enum CrownIconState {
		NONE, STAFF, ALL;

		public String getTitle() {
			return TextClass.fixName(toString().toLowerCase());
		}
	}

	private CrownIconState crownState = CrownIconState.NONE;

	public CrownIconState getState() {
		return crownState;
	}

	/**
	 * Is looting bag open
	 */
	public boolean lootingBag = false;

	private final AccountManager accountManager;

	public AccountManager getAccountManager() {
		return accountManager;
	}

	/**
	 * The split chat interface is open
	 */
	public boolean splitChatInterfaceOpen = false;
	private static boolean aBoolean475;
	private static boolean aBoolean995;
	private static byte[] aByteArray347;
	private static Sound aClass1418;
	private static Class25 aClass25_1948;
	private static Sound[] aClass26Array1468 = new Sound[50];
	private static Class3_Sub7 aClass3_Sub7_1345;
	private static Class3_Sub7_Sub1 aClass3_Sub7_Sub1_1493;
	private static Class5 aClass5_932;
	private static Class56 aClass56_749;
	public static long aLong1432;
	private static int anInt1005;
	public static int anInt1089;
	private static int anInt1117;
	private static int anInt1134;
	private static int anInt1142;
	private static int anInt1155;
	private static int anInt116;
	private static int anInt1175;
	private static int anInt1188;
	public static int anInt1211;
	private static int anInt1226;
	private static int anInt1288;
	private static int anInt139;
	public static int anInt1401 = 256;
	private static int anInt1408;
	private static int anInt1478;
	private static int anInt1526;
	private static int anInt155 = 0;
	public static int anInt197;
	private static int anInt2200 = 0;
	private static int anInt478 = -1;
	private static int anInt720 = 0;
	private static int anInt849;
	private static int anInt854;
	private static int anInt924;
	private static int anInt986;
	static final int[] anIntArray1019;
	public static final int[] anIntArray1204 = { 9104, 10275, 7595, 3610, 7975, 8526, 918, 38802, 24466, 10145, 58654, 5027, 1457, 16565, 34991, 25486 };
	public static int[] anIntArray1232;
	public static int[] anIntArray385 = new int[] { 12800, 12800, 12800, 12800, 12800, 12800, 12800, 12800, 12800, 12800, 12800, 12800, 12800, 12800, 12800, 12800 };
	public static final int[][] anIntArrayArray1003 = { { 6798, 107, 10283, 16, 4797, 7744, 5799, 4634, 33697, 22433, 2983, 54193 },
			{ 8741, 12, 64030, 43162, 7735, 8404, 1701, 38430, 24094, 10153, 56621, 4783, 1341, 16578, 35003, 25239 },
			{ 25238, 8742, 12, 64030, 43162, 7735, 8404, 1701, 38430, 24094, 10153, 56621, 4783, 1341, 16578, 35003 }, { 4626, 11146, 6439, 12, 4758, 10270 },
			{ 4550, 4537, 5681, 5673, 5790, 6806, 8076, 4574 } };
	public static Sprite[] cacheSprite;
	private static int clientHeight = 503;
	public static int clientWidth = 765;
	private static boolean fetchMusic = false;
	public static boolean flagged;
	private static final int[] IDs = { 1196, 1199, 1206, 1215, 1224, 1231, 1240, 1249, 1258, 1267, 1274, 1283, 1573, 1290, 1299, 1308, 1315, 1324, 1333, 1340, 1349, 1358, 1367, 1374, 1381, 1388, 1397,
			1404, 1583, 12038, 1414, 1421, 1430, 1437, 1446, 1453, 1460, 1469, 15878, 1602, 1613, 1624, 7456, 1478, 1485, 1494, 1503, 1512, 1521, 1530, 1544, 1553, 1563, 1593, 1635, 12426, 12436,
			12446, 12456, 6004, 18471,
			/* Ancients */
			12940, 12988, 13036, 12902, 12862, 13046, 12964, 13012, 13054, 12920, 12882, 13062, 12952, 13000, 13070, 12912, 12872, 13080, 12976, 13024, 13088, 12930, 12892, 13096 };
	public static Client instance;
	private static boolean isMembers = true;
	public static int log_view_dist = (int) (Math.log(clientWidth) / Math.log(2));
	public static int loopCycle;
	private static boolean lowDetail;
	private static byte[] musicData;
	private static int musicVolume2;
	public static Player myPlayer;
	private static String myUsername;
	private static final Pattern NAME_PATTERN = Pattern.compile("@.+@");
	private static int nodeID = 10;
	public static int openInterfaceID;
	private static ByteBuffer out;
	public static int portOff;
	private static final int[] runeChildren = { 1202, 1203, 1209, 1210, 1211, 1218, 1219, 1220, 1227, 1228, 1234, 1235, 1236, 1243, 1244, 1245, 1252, 1253, 1254, 1261, 1262, 1263, 1270, 1271, 1277,
			1278, 1279, 1286, 1287, 1293, 1294, 1295, 1302, 1303, 1304, 1311, 1312, 1318, 1319, 1320, 1327, 1328, 1329, 1336, 1337, 1343, 1344, 1345, 1352, 1353, 1354, 1361, 1362, 1363, 1370, 1371,
			1377, 1378, 1384, 1385, 1391, 1392, 1393, 1400, 1401, 1407, 1408, 1410, 1417, 1418, 1424, 1425, 1426, 1433, 1434, 1440, 1441, 1442, 1449, 1450, 1456, 1457, 1463, 1464, 1465, 1472, 1473,
			1474, 1481, 1482, 1488, 1489, 1490, 1497, 1498, 1499, 1506, 1507, 1508, 1515, 1516, 1517, 1524, 1525, 1526, 1533, 1534, 1535, 1547, 1548, 1549, 1556, 1557, 1558, 1566, 1567, 1568, 1576,
			1577, 1578, 1586, 1587, 1588, 1596, 1597, 1598, 1605, 1606, 1607, 1616, 1617, 1618, 1627, 1628, 1629, 1638, 1639, 1640, 6007, 6008, 6011, 8673, 8674, 12041, 12042, 12429, 12430, 12431,
			12439, 12440, 12441, 12449, 12450, 12451, 12459, 12460, 15881, 15882, 15885, 18474, 18475, 18478 };
	private static final long serialVersionUID = -1913853327056220406L;
	public static String[] skillNames = { "Attack", "Constitution", "Mining", "Strength", "Agility", "Smithing", "Defence", "Herblore", "Fishing", "Range", "Thieving", "Cooking", "Prayer", "Crafting",
			"Firemaking", "Magic", "Fletching", "Woodcutting", "Runecrafting", "Slayer", "Farming", "Construction", "Hunter", "Summoning" };
	private static int soundEffectVolume = 127;
	private static int spellID = 0;
	public static boolean tabAreaAltered;
	public static int tabID;
	public static boolean LOOP_MUSIC;
	public final static int[] tabInterfaceIDs = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
	private static final String validUserPassChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!\"\243$%^&*()-_=+[{]};:'@#~,<.>/?\\| ";
	private String consoleInput;
	public static boolean consoleOpen;
	private final String[] consoleMessages;
	public int mapX;

	public int mapY;

	public void addObject(int x, int y, int objectId, int face, int type, int height) {
		int mX = mapX - 6;
		int mY = mapY - 6;
		int regionX = x - mX * 8;
		int regionY = y - mY * 8;
		int i15 = 40 >> 2;
		int l17 = anIntArray1177[i15];
		if (regionY > 0 && regionY < 103 && regionX > 0 && regionX < 103) {
			if (height == realPlane) {
				method130(-1, objectId, face, l17, regionY, type, height, regionX, 0);
			} else {
				method130(-1, CustomObjectSpawns.BLANK_OBJECT_ID, face, l17, regionY, type, plane, regionX, 0);
			}
		}
	}

	public int getCursorID() {
		for (int x = 0; x < cursorInfo.length; x++) {
			if (menuActionName[menuActionRow - 1].toLowerCase().startsWith(cursorInfo[x].toLowerCase())) {
				return x;
			}
		}
		return 0;
	}

	public static String cursorInfo[] = { "Walk-to", "Take", "Use", "Talk-to", "Open", "Net", "Bait", "Cage", "Harpoon", "Chop", "Bury", "Pray-at", "Mine", "Eat", "Drink", "Wield", "Wear", "Remove",
			"Attack", "Enter", "Exit", "Climb-up", "Climb-down", "Search", "Steal", "Smelt", "Clean", "Back", "Deposit Bank", "Inspect", "Pick", "Zoom", "Pointless", "Settings", "Pointless",
			"Pointless", "Accept", "Decline", "Cast Ice Barrage on", "Cast Blood Barrage on", "Cast Shadow Barrage on", "Cast Smoke Barrage on", "Cast Ice Blitz on", "Cast Blood Blitz on",
			"Cast Shadow Blitz on", "Cast Smoke Blitz on", "Cast Ice Burst on", "Cast Blood Burst on", "Cast Shadow Burst on", "Cast Smoke Burst on", "Cast Ice Rush on", "Cast Blood Rush on",
			"Cast Shadow Rush on", "Cast Smoke Rush on", "Link", "Split Private", "Graphics", "Audio", "Pointless", "Pointless", "Click", "Information", "Cast High level alchemy on",
			"Cast Low level alchemy on", "Value", "Select Starter", "Craft-rune", "Pointless", "Withdraw", "Slash", "Pull", "Browse Item Database", "Browse Quick", };

	public void drawTasks() {
		int offset = 0;

		for (TimedTask task : tasks) {
			final int timer = task.getTimer();
			final int sprite = task.getTaskType().getSpriteId();
			int xOffset = (80 * offset++);
			DrawingArea.drawAlphaPixels(150 + xOffset, 305, 75, 25, 0x3A3B3A, 150);
			DrawingArea.fillPixels(150 + xOffset, 75, 25, 0x000000, 305);
			int seconds = timer;
			int minutes = timer / 60;
			if (minutes > 0) {
				seconds -= (minutes * 60);
			}
			if (sprite >= 0 && sprite < cacheSprite.length && cacheSprite[sprite] != null) {
				cacheSprite[sprite].drawAdvancedSprite(160 + xOffset, 309);
			}

			newRegularFont.drawCenteredString(minutes + ":" + (seconds < 10 ? ("0" + seconds) : seconds), 200 + xOffset, 323, 0xeb981f, 0);
		}
	}

	public void tickTasks() {
		synchronized (tasks) {
			for (Iterator<TimedTask> t = tasks.iterator(); t.hasNext();) {
				TimedTask task = t.next();
				if (task.getTimer() > 0) {
					task.setTimer(task.getTimer() - 1);
				} else {
					t.remove();
				}
			}
		}
	}

	static {
		anIntArray1019 = new int[99];
		int points = 0;

		for (int i = 0; i < 99; i++) {
			int l = i + 1;
			int i1 = (int) (l + 300D * Math.pow(2D, l / 7D));
			points += i1;
			anIntArray1019[i] = points >> 2;
		}

		anIntArray1232 = new int[32];
		points = 2;

		for (int i = 0; i < 32; i++) {
			anIntArray1232[i] = points - 1;
			points += points;
		}
	}

	public static String getFileNameWithoutExtension(String fileName) {
		File tmpFile = new File(fileName);
		tmpFile.getName();
		int whereDot = tmpFile.getName().lastIndexOf('.');
		if (0 < whereDot && whereDot <= tmpFile.getName().length() - 2) {
			return tmpFile.getName().substring(0, whereDot);
		}
		return "";
	}

	public String indexLocation(int cacheIndex, int index) {
		return Signlink.getWorkingDirectory() + "/index" + cacheIndex + "/" + (index != -1 ? index + ".gz" : "");

	}

	public void repackCacheIndex(int cacheIndex, boolean deleteDirectory) {
		File directory = new File(Signlink.getWorkingDirectory() + "/index" + cacheIndex + "/");

		if (!directory.exists()) {
			return;
		}
		System.out.println("Started repacking index " + cacheIndex + ".");
		int indexLength = new File(indexLocation(cacheIndex, -1)).listFiles().length;
		File[] file = new File(indexLocation(cacheIndex, -1)).listFiles();
		try {
			for (int index = 0; index < indexLength; index++) {
				int fileIndex = Integer.parseInt(getFileNameWithoutExtension(file[index].toString()));
				byte[] data = fileToByteArray(cacheIndex, fileIndex);
				if (data != null && data.length > 0) {
					decompressors[cacheIndex].method234(data.length, data, fileIndex);
					System.out.println("Repacked Archive: " + cacheIndex + " File: " + fileIndex + ".");
				} else {
					System.out.println("Unable to locate index " + fileIndex + ".");
				}
			}

		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("Error packing cache index " + cacheIndex + ".");
		}
		if (deleteDirectory)
			deleteDir(directory);
		System.out.println("Finished repacking " + cacheIndex + ".");
	}

	private boolean deleteDir(File dir) {
		if (dir.isDirectory()) {
			String[] children = dir.list();
			for (int i = 0; i < children.length; i++) {
				boolean success = deleteDir(new File(dir, children[i]));
				if (!success) {
					return false;
				}
			}
		}

		return dir.delete(); // The directory is empty now and can be deleted.
	}

	/**
	 * Saves the players data
	 *
	 * @throws IOException
	 */
	public void savePlayerData() {
		try {
			File file = new File(Signlink.getDataDirectory() + "/settings.dat");
			if (!file.exists()) {
				file.createNewFile();
			}
			DataOutputStream stream = new DataOutputStream(new FileOutputStream(file));
			if (stream != null) {
				stream.writeUTF(Constants.REMEMBER_ME_SELECTED ? getMyUsername() : "");
				stream.writeUTF(Constants.REMEMBER_ME_SELECTED ? getPassword() : "");
				stream.writeBoolean(Constants.REMEMBER_ME_SELECTED);
				stream.writeBoolean(config.getStatus(ConfigType.FOG));
				stream.writeBoolean(config.getStatus(ConfigType.X10_DAMAGE));
				stream.writeBoolean(config.getStatus(ConfigType.NEW_HITBARS));
				stream.writeBoolean(config.getStatus(ConfigType.FUNCTION_KEYS));
				stream.writeBoolean(config.getStatus(ConfigType.HP_ABOVE_HEAD));
				stream.writeBoolean(config.getStatus(ConfigType.NAMES_ABOVE_HEAD));
				stream.writeBoolean(config.getStatus(ConfigType.TWEENING));
				stream.writeBoolean(config.getStatus(ConfigType.HITMARKS));
				stream.writeBoolean(GameFrameConstants.gameframeType == GameFrameType.FRAME_525 ? false : true);
				stream.writeBoolean(config.getStatus(ConfigType.TOGGLE_FOV));
				stream.writeBoolean(config.getStatus(ConfigType.TOGGLE_ROOFS));
				stream.writeBoolean(config.getStatus(ConfigType.HIGH_DETAIL));
				stream.writeInt(splitChatColor);
				stream.writeBoolean(config.getStatus(ConfigType.HD_MINIMAP));
				stream.writeBoolean(config.getStatus(ConfigType.HD_SHADING));
				stream.writeBoolean(config.getStatus(ConfigType.HD_TEXTURES));
				stream.writeBoolean(config.getStatus(ConfigType.NEW_CURSORS));
				stream.writeBoolean(config.getStatus(ConfigType.TOGGLE_TARGET_INTERFACE));
				stream.writeBoolean(config.getStatus(ConfigType.PUSH_NOTIFICATIONS));
				stream.writeBoolean(config.getStatus(ConfigType.DISPLAY_COMBAT_OVERLAY));
				stream.writeBoolean(config.getStatus(ConfigType.ONE_CLICK_ATTACK));
				stream.writeBoolean(config.getStatus(ConfigType.DISPLAY_COMBAT_TIMERS));
				stream.writeUTF(crownState.toString());
				stream.close();
			}

			file = new File(Signlink.getDataDirectory() + "/zamorak_prefs.dat");
			if (!file.exists()) {
				file.createNewFile();
			}
			stream = new DataOutputStream(new FileOutputStream(file));

			if (stream != null) {
				for (int i = 0; i < AccountManager.MAX_ACCOUNTS; i++) {
					Account account = null;
					if (accountManager.getAccounts().size() > i) {
						account = accountManager.getAccounts().get(i);
					}

					stream.writeUTF((account == null || account.getUsername().isEmpty()) ? "" : account.getUsername());
					stream.writeUTF((account == null || account.getPassword().isEmpty()) ? "" : account.getPassword());
				}
				stream.close();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * Loads the players data
	 *
	 * @throws IOException
	 */
	private void loadPlayerData() throws IOException {
		File file = new File(Signlink.getDataDirectory() + "/settings.dat");

		if (file.exists()) {

			DataInputStream stream = new DataInputStream(new FileInputStream(file));

			try {
				setMyUsername(stream.readUTF());
				password = stream.readUTF();
				Constants.REMEMBER_ME_SELECTED = stream.readBoolean();
				config.set(ConfigType.FOG, stream.readBoolean());
				config.set(ConfigType.X10_DAMAGE, stream.readBoolean());
				config.set(ConfigType.NEW_HITBARS, stream.readBoolean());
				config.set(ConfigType.FUNCTION_KEYS, stream.readBoolean());
				config.set(ConfigType.HP_ABOVE_HEAD, stream.readBoolean());
				config.set(ConfigType.NAMES_ABOVE_HEAD, stream.readBoolean());
				config.set(ConfigType.TWEENING, stream.readBoolean());
				config.set(ConfigType.HITMARKS, stream.readBoolean());
				GameFrameConstants.gameframeType = stream.readBoolean() ? GameFrameType.FRAME_554 : GameFrameType.FRAME_525;
				config.set(ConfigType.TOGGLE_FOV, stream.readBoolean());
				config.set(ConfigType.TOGGLE_ROOFS, stream.readBoolean());
				config.set(ConfigType.HIGH_DETAIL, stream.readBoolean());
				splitChatColor = stream.readInt();
				config.set(ConfigType.HD_MINIMAP, stream.readBoolean());
				stream.readBoolean();
				config.set(ConfigType.HD_SHADING, true);
				config.set(ConfigType.HD_TEXTURES, stream.readBoolean());
				config.set(ConfigType.NEW_CURSORS, stream.readBoolean());
				config.set(ConfigType.TOGGLE_TARGET_INTERFACE, stream.readBoolean());
				config.set(ConfigType.PUSH_NOTIFICATIONS, stream.readBoolean());
				config.set(ConfigType.DISPLAY_COMBAT_OVERLAY, stream.readBoolean());
				config.set(ConfigType.ONE_CLICK_ATTACK, stream.readBoolean());
				config.set(ConfigType.DISPLAY_COMBAT_TIMERS, stream.readBoolean());
				crownState = CrownIconState.valueOf(stream.readUTF().toUpperCase());

				if (!config.getStatus(ConfigType.HIGH_DETAIL)) {
					setLowDetail();
				} else {
					setHighDetail();
				}

				sendSettingConfigs();

			} catch (IOException e) {
			} finally {
				stream.close();
			}
		}

		file = new File(Signlink.getDataDirectory() + "/zamorak_prefs.dat");

		if (file.exists()) {
			DataInputStream stream = new DataInputStream(new FileInputStream(file));

			try {
				for (int i = 0; i < AccountManager.MAX_ACCOUNTS; i++) {
					String username = stream.readUTF();
					String password = stream.readUTF();

					if (username != null && password != null && !username.isEmpty() && !password.isEmpty()) {
						accountManager.addAccount(username, password);
					}
				}
			} catch (IOException e) {
			} finally {
				stream.close();
			}
		}
	}

	public void sendSettingConfigs() {
		sendFrame36(516, GameFrameConstants.gameframeType == GameFrameConstants.GameFrameType.FRAME_554 ? 1 : 0);
		sendFrame36(521, !config.getStatus(ConfigType.FUNCTION_KEYS) ? 1 : 0);
		sendFrame36(523, config.getStatus(ConfigType.FOG) ? 1 : 0);
		sendFrame36(519, config.getStatus(ConfigType.NEW_HITBARS) ? 1 : 0);
		sendFrame36(522, config.getStatus(ConfigType.X10_DAMAGE) ? 1 : 0);
		sendFrame36(518, config.getStatus(ConfigType.HP_ABOVE_HEAD) ? 1 : 0);
		sendFrame36(517, config.getStatus(ConfigType.NAMES_ABOVE_HEAD) ? 1 : 0);
		sendFrame36(524, config.getStatus(ConfigType.NEW_CURSORS) ? 1 : 0);
		sendFrame36(520, config.getStatus(ConfigType.HITMARKS) ? 1 : 0);
		sendFrame36(525, config.getStatus(ConfigType.TOGGLE_ROOFS) ? 1 : 0);
		sendFrame36(526, config.getStatus(ConfigType.TOGGLE_FOV) ? 1 : 0);
		sendFrame36(RSInterface.SETTING_CONFIGS[11], config.getStatus(ConfigType.PUSH_NOTIFICATIONS) ? 1 : 0);
		sendFrame36(531, lowDetail ? 1 : 0);
		sendFrame36(532, lowDetail ? 0 : 1);
		sendFrame36(528, config.getStatus(ConfigType.HD_TEXTURES) ? 1 : 0);
		sendFrame36(529, config.getStatus(ConfigType.DISPLAY_COMBAT_TIMERS) ? 1 : 0);
		sendFrame36(RSInterface.SETTING_CONFIGS[17], config.getStatus(ConfigType.DISPLAY_COMBAT_OVERLAY) ? 1 : 0);
		sendFrame36(RSInterface.SETTING_CONFIGS[18], config.getStatus(ConfigType.ONE_CLICK_ATTACK) ? 1 : 0);
		sendFrame36(RSInterface.SETTING_CONFIGS[19], config.getStatus(ConfigType.TOGGLE_TARGET_INTERFACE) ? 1 : 0);
		sendFrame36(RSInterface.SETTING_CONFIGS[20], config.getStatus(ConfigType.DISPLAY_COMBAT_TIMERS) ? 1 : 0);
		RSInterface.interfaceCache[25017].message = "Crowns: " + crownState.getTitle();
	}

	public byte[] fileToByteArray(int cacheIndex, int index) {
		try {
			if (indexLocation(cacheIndex, index).length() <= 0 || indexLocation(cacheIndex, index) == null) {
				return null;
			}
			File file = new File(indexLocation(cacheIndex, index));
			byte[] fileData = new byte[(int) file.length()];
			FileInputStream fis = new FileInputStream(file);
			fis.read(fileData);
			fis.close();
			return fileData;
		} catch (Exception e) {
			return null;
		}
	}

	public static String capitalize(String s) {
		return s.length() > 0 ? Character.toUpperCase(s.charAt(0)) + s.substring(1) : s;
	}

	private static String combatDiffColor(int myCombatLevel, int targetCombatLevel) {
		int difference = myCombatLevel - targetCombatLevel;

		if (difference < -9) {
			return "@red@";
		}

		if (difference < -6) {
			return "@or3@";
		}

		if (difference < -3) {
			return "@or2@";
		}

		if (difference < 0) {
			return "@or1@";
		}

		if (difference > 9) {
			return "@gre@";
		}

		if (difference > 6) {
			return "@gr3@";
		}

		if (difference > 3) {
			return "@gr2@";
		}

		if (difference > 0) {
			return "@gr1@";
		}

		return "@yel@";
	}

	private static final boolean constructMusic() {
		anInt720 = 20;

		try {
			aClass56_749 = new Class56_Sub1_Sub1();
		} catch (Throwable throwable) {
			return false;
		}

		return true;
	}

	public static String formatValue(double value, int digits) {
		PlayerHandler.format.setMaximumFractionDigits(digits);
		return PlayerHandler.format.format(value);
	}

	private static final void handleSounds() {
		if (aClass5_932 != null) {
			long l = System.currentTimeMillis();

			if (l > aLong1432) {
				aClass5_932.method489(l);
				int i_0_ = (int) (-aLong1432 + l);
				aLong1432 = l;

				synchronized (Client.aClass1418 != null ? Client.aClass1418 : (Client.aClass1418 = new Sound())) {
					anInt1526 += anInt197 * i_0_;
					int i_1_ = (anInt1526 - anInt197 * 2000) / 1000;

					if (i_1_ > 0) {
						if (aClass3_Sub7_1345 != null) {
							aClass3_Sub7_1345.method380(i_1_);
						}

						anInt1526 -= i_1_ * 1000;
					}
				}
			}
		}
	}

	private static String intToKOrMil(int value) {
		if (value < 0x186a0) {
			return String.valueOf(value);
		}

		if (value < 0x989680) {
			return value / 1000 + "K";
		} else {
			return value / 0xf4240 + "M";
		}
	}

	private static String intToKOrMilLongName(int i) {
		String s = String.valueOf(i);

		for (int k = s.length() - 3; k > 0; k -= 3) {
			s = s.substring(0, k) + "," + s.substring(k);
		}

		if (s.length() > 8) {
			s = "@gre@" + s.substring(0, s.length() - 8) + " million @whi@(" + s + ")";
		} else if (s.length() > 4) {
			s = "@cya@" + s.substring(0, s.length() - 4) + "K @whi@(" + s + ")";
		}

		return " " + s;
	}

	public static ZamorakFrame jFrame;

	public static void main(String[] args) throws FileNotFoundException {
		portOff = 0;
		// setHighDetail();
		isMembers = true;
		Signlink.storeid = 32;
		try {
			Signlink.startpriv(InetAddress.getLocalHost());
		} catch (UnknownHostException e) {
			System.err.printf("Unable to determine localhost for your machine [localhost=%s]%n", e.getMessage());
		}
		GameFrame.setScreenMode(ScreenMode.FIXED);
		instance = new Client();
		jFrame = new ZamorakFrame(args);
		// instance.createClientFrame(clientWidth, clientHeight);
	}

	public static Client getClient() {
		return instance;
	}

	private static final int method1004(int i) {
		return (int) (Math.log(i * 0.00390625) * 868.5889638065036 + 0.5);
	}

	private static final void method368(int i) {
		if (aClass56_749 != null) {
			if (anInt478 < i) {
				if (anInt720 > 0) {
					anInt720--;

					if (anInt720 == 0) {
						if (aByteArray347 == null) {
							aClass56_749.method831(256);
						} else {
							aClass56_749.method831(anInt1478);
							anInt478 = anInt1478;
							aClass56_749.method827(anInt1478, aByteArray347, 0, aBoolean475);
							aByteArray347 = null;
						}

						anInt155 = 0;
					}
				}
			} else if (anInt720 > 0) {
				anInt155 += anInt2200;
				aClass56_749.method830(anInt478, anInt155);
				anInt720--;

				if (anInt720 == 0) {
					aClass56_749.method833();
					anInt720 = 20;
					anInt478 = -1;
				}
			}

			aClass56_749.method832(i - 122);
		}
	}

	private static final Class3_Sub7_Sub1 method407(Component component) {
		Client.method509(component);
		Class3_Sub7_Sub1 class3_sub7_sub1 = new Class3_Sub7_Sub1();
		method484(class3_sub7_sub1);
		return class3_sub7_sub1;
	}

	private static final synchronized void method484(Class3_Sub7 class3_sub7) {
		aClass3_Sub7_1345 = class3_sub7;
	}

	public static final synchronized void method486(int[] is, int i) {
		int i_2_ = 0;
		i -= 7;

		while (i_2_ < i) {
			is[i_2_++] = 0;
			is[i_2_++] = 0;
			is[i_2_++] = 0;
			is[i_2_++] = 0;
			is[i_2_++] = 0;
			is[i_2_++] = 0;
			is[i_2_++] = 0;
			is[i_2_++] = 0;
		}

		i += 7;

		while (i_2_ < i) {
			is[i_2_++] = 0;
		}

		if (aClass3_Sub7_1345 != null) {
			aClass3_Sub7_1345.method378(is, 0, i);
		}

		method689(i);
	}

	private static final synchronized void method49() {
		if (musicIsntNull()) {
			if (fetchMusic) {
				byte[] is = musicData;

				if (is != null) {
					if (anInt116 >= 0) {
						method684(aBoolean995, anInt116, musicVolume2, is);
					} else if (anInt139 >= 0) {
						method899(anInt139, -1, aBoolean995, is, musicVolume2);
					} else {
						method853(musicVolume2, is, aBoolean995);
					}

					fetchMusic = false;
				}
			}

			method368(0);
		}
	}

	public static final synchronized void method493(int i) {
		if (aClass3_Sub7_1345 != null) {
			aClass3_Sub7_1345.method380(i);
		}

		method689(i);
	}

	private static final void method509(Component component) {
		try {
			Class5_Sub2 class5_sub2 = new Class5_Sub2_Sub2();
			class5_sub2.method502(2048);
			aClass5_932 = class5_sub2;
		} catch (Throwable throwable) {
			try {
				aClass5_932 = new Class5_Sub2_Sub1(component);
			} catch (Throwable throwable_16_) {
				do {
					if (System.getProperty("java.vendor").toLowerCase().indexOf("microsoft") >= 0) {
						try {
							aClass5_932 = new Class5_Sub1();
						} catch (Throwable throwable_17_) {
							break;
						}

						return;
					}
				} while (false);

				aClass5_932 = new Class5(8000);
			}
		}
	}

	private static final synchronized void method55(boolean bool) {
		if (musicIsntNull()) {
			method891(bool);
			fetchMusic = false;
		}
	}

	public static final int method670(int i, int i_0_) {
		if (i > i_0_) {
			int i_2_ = i_0_;
			i_0_ = i;
			i = i_2_;
		}

		for (int i_3_; i != 0; i = i_3_) {
			i_3_ = i_0_ % i;
			i_0_ = i;
		}

		return i_0_;
	}

	private static final void method684(boolean bool, int i, int i_2_, byte[] is) {
		if (aClass56_749 != null) {
			if (anInt478 >= 0) {
				anInt2200 = i;

				if (anInt478 != 0) {
					int i_4_ = method1004(anInt478);
					i_4_ -= anInt155;
					anInt720 = (i_4_ + 3600) / i;

					if (anInt720 < 1) {
						anInt720 = 1;
					}
				} else {
					anInt720 = 1;
				}

				aByteArray347 = is;
				anInt1478 = i_2_;
				aBoolean475 = bool;
			} else if (anInt720 == 0) {
				method853(i_2_, is, bool);
			} else {
				anInt1478 = i_2_;
				aBoolean475 = bool;
				aByteArray347 = is;
			}
		}
	}

	private static final void method689(int i) {
		Client.anInt1408 += i;

		while (Client.anInt1408 >= Client.anInt197) {
			Client.anInt1408 -= Client.anInt197;
			anInt1526 -= anInt1526 >> 2;
		}

		anInt1526 -= i * 1000;

		if (anInt1526 < 0) {
			anInt1526 = 0;
		}
	}

	public static final void method790() {
		if (aClass56_749 != null) {
			method891(false);

			if (anInt720 > 0) {
				aClass56_749.method831(256);
				anInt720 = 0;
			}

			aClass56_749.method828();
			aClass56_749 = null;
		}
	}

	private static final void method853(int i_2_, byte[] is, boolean bool) {
		if (aClass56_749 != null) {
			if (anInt478 >= 0) {
				aClass56_749.method833();
				anInt478 = -1;
				aByteArray347 = null;
				anInt720 = 20;
				anInt155 = 0;
			}

			if (is != null) {
				if (anInt720 > 0) {
					aClass56_749.method831(i_2_);
					anInt720 = 0;
				}

				anInt478 = i_2_;
				aClass56_749.method827(i_2_, is, 0, bool);
			}
		}
	}

	private static final void method891(boolean bool) {
		method853(0, null, bool);
	}

	private static final void method899(int i, int i_29_, boolean bool, byte[] is, int i_30_) {
		if (aClass56_749 != null) {
			if (i_29_ >= (anInt478 ^ 0xffffffff)) {
				i -= 20;

				if (i < 1) {
					i = 1;
				}

				anInt720 = i;

				if (anInt478 == 0) {
					anInt2200 = 0;
				} else {
					int i_31_ = method1004(anInt478);
					i_31_ -= anInt155;
					anInt2200 = (anInt2200 - 1 + i_31_ + 3600) / anInt2200;
				}

				aBoolean475 = bool;
				aByteArray347 = is;
				anInt1478 = i_30_;
			} else if (anInt720 != 0) {
				aBoolean475 = bool;
				aByteArray347 = is;
				anInt1478 = i_30_;
			} else {
				method853(i_30_, is, bool);
			}
		}
	}

	private static final void method900(int i) {
		if (aClass56_749 != null) {
			if (anInt720 == 0) {
				if (anInt478 >= 0) {
					anInt478 = i;
					aClass56_749.method830(i, 0);
				}
			} else if (aByteArray347 != null) {
				anInt1478 = i;
			}
		}
	}

	private static final boolean musicIsntNull() {
		return aClass56_749 != null;
	}

	private static void setLowDetail() {
		setLowDetail(true);
		WorldController.lowDetail = true;
		Rasterizer.lowDetail = true;
		ObjectManager.lowDetail = true;
		ObjectDefinition.lowDetail = true;
	}

	private static void setHighDetail() {
		setLowDetail(false);
		WorldController.lowDetail = false;
		Rasterizer.lowDetail = false;
		ObjectManager.lowDetail = false;
		ObjectDefinition.lowDetail = false;
	}

	public static void setTab(int id) {
		tabID = id;
		tabAreaAltered = true;
	}

	private static final void setVolume(int i) {
		if (musicIsntNull()) {
			if (fetchMusic) {
				musicVolume2 = i;
			} else {
				method900(i);
			}
		}
	}

	public static final void sleep(long time) {
		if (time > 0L) {
			if (time % 10L != 0L) {
				threadSleep(time);
			} else {
				threadSleep(time - 1L);
				threadSleep(1L);
			}
		}
	}

	private static final void threadSleep(long time) {
		try {
			Thread.sleep(time);
		} catch (InterruptedException ex) {
		}
	}

	private boolean aBoolean1017;
	private boolean aBoolean1031;
	public boolean aBoolean1047;
	private boolean aBoolean1080;
	private boolean aBoolean1141;
	public boolean dialogueOptionsShowing;
	private boolean aBoolean1159;
	private boolean cameraViewChanged;
	private boolean aBoolean1242;
	private volatile boolean aBoolean831;
	private final boolean aBoolean848;
	private boolean httpFallback;
	public boolean aBoolean954;
	private boolean aBoolean972;
	private final boolean aBoolean994;
	private final boolean[] aBooleanArray876;
	private byte[] aByteArray912;
	private byte[][] aByteArrayArray1183;
	private byte[][] aByteArrayArray1247;
	private CollisionMap[] aClass11Array1230;
	private Deque aClass19_1013;
	private Deque aClass19_1056;
	private Deque aClass19_1179;
	private Sprite aClass30_Sub2_Sub1_Sub1_931;
	private Sprite aClass30_Sub2_Sub1_Sub1_932;
	public Sprite[] aClass30_Sub2_Sub1_Sub1Array1140;
	private final RSInterface aClass9_1059;
	private int activeInterfaceType;
	private long aLong824;
	private long aLong953;
	public String amountOrNameInput;
	public int timeSinceLastPacket;
	private int keepAlive;
	public int idleStatus;
	private int currentCameraDisplayX;
	private int currentCameraDisplayY;
	private int anInt1016;
	private int walkableInterface;
	public int anInt1021;
	private int anInt1026;
	private int anInt1036;
	private int anInt1037;
	private int anInt1039;
	private int anInt1044;// 377
	private int anInt1046;
	private int anInt1048;
	public int anInt1054;
	public int anInt1055;
	private int anInt1069;
	private int anInt1070;
	public int anInt1071;
	private int anInt1079;
	private int anInt1084;
	private int anInt1085;
	private int anInt1087;
	private int anInt1088;
	private int spinPacketX;
	private int spinPacketY;
	private int spinPacketHeight;
	private int spinPacketConstantSpeed;
	private int spinPacketVariableSpeed;
	public int systemUpdateTimer;
	private int anInt1129;// 377
	private int anInt1137;
	private int cameraRotationZ;
	private int cameraRotationLeft;
	private int cameraRotationRight;
	private int anInt1193;
	private int anInt1213;
	public int anInt1222;
	private int anInt1249;
	private int anInt1251;
	private int anInt1253;
	private int anInt1264;
	private int anInt1265;
	private int anInt1268;
	private int anInt1269;
	private int anInt1283;
	private int anInt1284;
	private int anInt1285;
	private int anInt1315;// 377
	private int anInt1500;// 377
	private int anInt1501;// 377
	private int anInt839;
	public int anInt841;
	public int anInt842;
	public int anInt843;
	public int anInt855;
	private int anInt886;
	private int anInt893;
	private int anInt900;
	private int anInt913;
	public int anInt933;
	public int anInt934;
	public int anInt935;
	private int anInt936;
	private int anInt937;
	private int anInt938;
	private int anInt945;
	private final int anInt975;
	private int anInt984;
	private int anInt985;
	private int anInt989;
	private int moveCameraX;
	private int moveCameraY;
	private int moveCameraZ;
	private int moveCameraSpeed;
	private int moveCameraAngle;
	private final int[] anIntArray1030;
	private final int[] settings;
	private final int[] anIntArray1065;
	public int[] anIntArray1072;
	public int[] anIntArray1073;
	private final int[] anIntArray1177 = { 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3 };
	public int[] anIntArray1180;
	public int[] anIntArray1181;
	public int[] anIntArray1182;
	private final int[] anIntArray1203;
	private int[] anIntArray1234;
	private int[] anIntArray840;
	private final int[] anIntArray873;
	private int[] anIntArray894;
	private final int[] anIntArray928;
	private final int[] anIntArray965 = { 0xffff00, 0xff0000, 65280, 65535, 0xff00ff, 0xffffff };
	private final int[] anIntArray976;
	private final int[] anIntArray977;
	private final int[] anIntArray978;
	private final int[] anIntArray979;
	private final int[] anIntArray980;
	private final int[] anIntArray981;
	private final int[] anIntArray982;
	public final int[] anIntArray990;
	private int[][] anIntArrayArray825;
	private int[][] anIntArrayArray901;
	private int[][] anIntArrayArray929;
	private final int[][][] anIntArrayArrayArray1129;
	private GraphicsBuffer aRSImageProducer_1107;
	private GraphicsBuffer aRSImageProducer_1125;
	private Socket aSocket832;
	private ByteBuffer aStream_834;
	private ByteBuffer[] aStreamArray895s;
	private String[] startupMessage = new String[2];
	public String aString844;
	private final String[] aStringArray983;
	private int atInventoryIndex;
	private int atInventoryInterface;
	private int atInventoryInterfaceType;
	private int atInventoryLoopCycle;
	public final String[] atPlayerActions;
	public final boolean[] atPlayerArray;
	private boolean autocast = false;
	private int autocastId = 0;
	public int backDialogID;
	public int baseX;
	public int baseY;
	private int[] bigX;
	private int[] bigY;
	private byte[][][] byteGroundArray;
	private int cameraOffsetX;
	private int cameraOffsetY;
	public int cButtonCPos;
	public int cButtonHPos;
	ChatArea chatArea = new ChatArea(0, 338, 516, 150);
	public GraphicsBuffer chatAreaIP;
	public String[] chatMessages;
	public String[] chatNames;
	public String[] chatTitles;
	public int[] chatPosition;
	public final int[] chatRights;
	public TextDrawingArea chatTextDrawingArea;
	public int[] chatTypes;
	public int chatTypeView;
	public String[] clanMembers = new String[100];
	public String clanName;
	public Sprite compass;
	public final int[] compassArray1;
	public final int[] compassArray2;
	private Connection connection;
	private ISAACCipher connectionCipher;
	private final CRC32 crc32Instance;
	private Sprite[] crosses;
	private int crossIndex;
	private int crossType;
	private int crossX;
	private int crossY;
	public final int[] currentExp;
	private int currentSong;
	public final int[] currentStats;
	private int daysSinceLastLogin;
	private int daysSinceRecovChange;
	private boolean debugMode = false;
	public final Decompressor[] decompressors;
	public int destX;
	public int destY;
	public int dialogID;
	private int drawCount;
	private volatile boolean drawFlames;
	private volatile boolean drawingFlames;
	private int energy;
	private final int[] expectedCRCs;
	private int[] floorMap;
	private String floorMaps = "";
	public int friendCount;
	private String[] friendsList;
	private int friendsListAction;
	public long[] friendsListAsLongs;
	public int[] friendsNodeIDs;
	private int fullscreenInterfaceID;
	int[] fullScreenTextureArray;
	private int gameAreaWidth = 512, gameAreaHeight = 334;
	private boolean gameFrameVisible = true;
	public GraphicsBuffer gameScreenIP;
	public Deque[][][] groundArray;
	private Sprite[] headIcons;
	private Sprite[] headIconsHint;
	private Sprite[] hitMarks;
	private int ignoreCount;
	private final long[] ignoreListAsLongs;
	private ByteBuffer inputBuffer;
	public int inputDialogState;
	public String inputString;
	private boolean inputTaken;
	private int interfaceButtonAction = 0;
	private int[][][] intGroundArray;
	public int invOverlayInterfaceID;
	public int itemSelected;
	private int lastActiveInvInterface;
	private GraphicsBuffer leftFrame;
	private boolean loadingError;
	public int loadingStage;
	public static boolean loggedIn;
	private ByteBuffer loginBuffer;
	private int loginFailures;
	private String loginMessage1;
	private String loginMessage2;
	private int loginScreenCursorPos;
	private int loginScreenState;
	private int loginState = -1;
	private final MapArea mapArea = new MapArea(519, 0, 0, 0);
	public GraphicsBuffer mapAreaIP;
	private Background mapBack;
	public Sprite mapDotClan;
	public Sprite mapDotFriend;
	public Sprite mapDotItem;
	public Sprite mapDotNPC;
	public Sprite mapDotPlayer;
	public Sprite mapDotTeam;
	private Sprite mapEdge;
	public Sprite mapFlag;
	private Sprite[] mapFunctions;
	public final int[] mapImagePixelCutLeft;
	public final int[] mapImagePixelCutRight;
	public Sprite mapMarker;
	private Background[] mapScenes;
	private final int maxPlayers;
	private final int[] maxStats;
	private int membersInt;
	private int[] menuActionCmd1;
	private int[] menuActionCmd2;
	private int[] menuActionCmd3;
	public int[] menuActionID;
	public String[] menuActionName;
	public String[] menuActionTitle;
	public int[] menuActionColor;
	public int menuActionRow;
	private int menuHeight;
	private int menuOffsetX;
	private int menuOffsetY;
	public boolean menuOpen;
	public int menuScreenArea;
	private int menuWidth;
	private String message;
	public boolean messagePromptRaised;
	public Sprite miniMapRegions;
	public int minimapRotation;
	public int minimapZoom;
	public final Sprite[] modIcons;
	public MouseDetection mouseDetection;
	private int mouseInvInterfaceIndex;
	private Sprite[] multiOverlay = new Sprite[2];
	private int musicVolume = 255;
	private final int myPlayerIndex;
	public int myRights;
	private String name;
	RSFontSystem newFancyFont;
	public RSFontSystem newSmallFont, newRegularFont, newBoldFont;
	private int nextSong;
	public TextDrawingArea normalText;
	public NPC[] npcArray;
	public int npcCount;
	public int[] npcIndices;
	private int[] objectMap;
	private String objectMaps = "";
	public OnDemandFetcher onDemandFetcher;
	private String password;
	public int pktSize;
	public int currentPacketOpcode;
	public int plane;
	public Player[] playerArray;
	public int playerCount;
	public int[] playerIndices;
	private int prevSong;
	public int privateChatMode;
	public String promptInput;
	public String promptMessage;
	public int publicChatMode;
	public int reportAbuseInterfaceID;
	private GraphicsBuffer rightFrame;
	private int rights;
	private boolean running;
	private ScriptManager scriptManager;
	private final Sprite[] scrollBar;
	private final Sprite[] scrollPart;
	private String selectedItemName;
	private long serverSeed;
	public Sprite[] sideIcons;
	private Sprite[] skullIcons;
	public TextDrawingArea smallText;
	private final int[] sound;
	public int soundCount;
	private final int[] soundDelay;
	private final int[] soundType;
	public int spellSelected;
	private String spellTooltip;
	private int spellUsableOn;
	public int splitPrivateChat;
	private int spriteDrawX;
	private int spriteDrawY;
	public TabArea tabArea = new TabArea(516, 168, 250, 335);
	public GraphicsBuffer tabAreaIP;
	public int terrainRegionX;
	public int terrainRegionY;
	private int titleHeight = -1;
	private GraphicsBuffer titleScreenIP;
	private int[] titleScreenOffsets = null;
	private Archive titleStreamLoader;
	private int titleWidth = -1;
	private GraphicsBuffer topFrame;
	public int tradeMode;
	private int playerIndex;
	private int unreadMessages;
	public int variousSettings[];
	public int viewRotation;
	private int viewRotationOffset;
	private int weight;
	private boolean welcomeScreenRaised;
	private WorldController worldController;
	public int xCameraCurve;
	public int xCameraPos;
	public int yCameraCurve;
	public int yCameraPos;
	public int zCameraPos;
	private boolean fpsOn;
	private int lastPercent;

	public void resetMap2() {
		aBoolean1080 = false;
	}

	public void resetMap1() {
		soundCount = 0;
		cameraOffsetX = (int) (Math.random() * 100D) - 50;
		cameraOffsetY = (int) (Math.random() * 110D) - 55;
		viewRotationOffset = (int) (Math.random() * 80D) - 40;
		minimapRotation = (int) (Math.random() * 120D) - 60;
		minimapZoom = (int) (Math.random() * 30D) - 20;
		viewRotation = (int) (Math.random() * 20D) - 10 & 0x7ff;
		anInt1021 = 0;
		loadingStage = 1;
	}

	public void loadMap(int l2, int i11) {
		mapX = l2;
		mapY = i11;
		aBoolean1159 = false;
		if (anInt1069 == l2 && anInt1070 == i11 && loadingStage == 2) {
			return;
		}
		anInt1069 = l2;
		anInt1070 = i11;
		baseX = (anInt1069 - 6) * 8;
		baseY = (anInt1070 - 6) * 8;
		aBoolean1141 = (anInt1069 / 8 == 48 || anInt1069 / 8 == 49) && anInt1070 / 8 == 48;
		if (anInt1069 / 8 == 48 && anInt1070 / 8 == 148) {
			aBoolean1141 = true;
		}
		loadingStage = 1;
		aLong824 = System.currentTimeMillis();
		int k16 = 0;
		for (int i21 = (anInt1069 - 6) / 8; i21 <= (anInt1069 + 6) / 8; i21++) {
			for (int k23 = (anInt1070 - 6) / 8; k23 <= (anInt1070 + 6) / 8; k23++) {
				k16++;
			}
		}
		aByteArrayArray1183 = new byte[k16][];
		aByteArrayArray1247 = new byte[k16][];
		anIntArray1234 = new int[k16];
		floorMap = new int[k16];
		objectMap = new int[k16];
		k16 = 0;
		for (int l23 = (anInt1069 - 6) / 8; l23 <= (anInt1069 + 6) / 8; l23++) {
			for (int j26 = (anInt1070 - 6) / 8; j26 <= (anInt1070 + 6) / 8; j26++) {
				anIntArray1234[k16] = (l23 << 8) + j26;
				if (aBoolean1141 && (j26 == 49 || j26 == 149 || j26 == 147 || l23 == 50 || l23 == 49 && j26 == 47)) {
					floorMap[k16] = -1;
					objectMap[k16] = -1;
					k16++;
				} else {
					int k28 = floorMap[k16] = onDemandFetcher.getMapCount(0, j26, l23);
					if (k28 != -1) {
						onDemandFetcher.requestFileData(3, k28);
					}
					int j30 = objectMap[k16] = onDemandFetcher.getMapCount(1, j26, l23);
					if (j30 != -1) {
						onDemandFetcher.requestFileData(3, j30);
					}
					k16++;
				}
			}
		}
		int i17 = baseX - anInt1036;
		int j21 = baseY - anInt1037;
		anInt1036 = baseX;
		anInt1037 = baseY;
		for (int j24 = 0; j24 < 16384; j24++) {
			NPC npc = npcArray[j24];
			if (npc != null) {
				for (int j29 = 0; j29 < 10; j29++) {
					npc.smallX[j29] -= i17;
					npc.smallY[j29] -= j21;
				}
				npc.x -= i17 * 128;
				npc.y -= j21 * 128;
			}
		}
		for (int i27 = 0; i27 < maxPlayers; i27++) {
			Player player = playerArray[i27];
			if (player != null) {
				for (int i31 = 0; i31 < 10; i31++) {
					player.smallX[i31] -= i17;
					player.smallY[i31] -= j21;
				}
				player.x -= i17 * 128;
				player.y -= j21 * 128;
			}
		}
		aBoolean1080 = true;
		byte byte1 = 0;
		byte byte2 = 104;
		byte byte3 = 1;
		if (i17 < 0) {
			byte1 = 103;
			byte2 = -1;
			byte3 = -1;
		}
		byte byte4 = 0;
		byte byte5 = 104;
		byte byte6 = 1;
		if (j21 < 0) {
			byte4 = 103;
			byte5 = -1;
			byte6 = -1;
		}
		for (int k33 = byte1; k33 != byte2; k33 += byte3) {
			for (int l33 = byte4; l33 != byte5; l33 += byte6) {
				int i34 = k33 + i17;
				int j34 = l33 + j21;
				for (int k34 = 0; k34 < 4; k34++)
					if (i34 >= 0 && j34 >= 0 && i34 < 104 && j34 < 104)
						groundArray[k34][k33][l33] = groundArray[k34][i34][j34];
					else
						groundArray[k34][k33][l33] = null;
			}
		}
		if (aClass19_1179 != null)
			for (GameObject gameObject = (GameObject) aClass19_1179.popHead(); gameObject != null; gameObject = (GameObject) aClass19_1179.getNext()) {
				gameObject.anInt1297 -= i17;
				gameObject.anInt1298 -= j21;
				if (gameObject.anInt1297 < 0 || gameObject.anInt1298 < 0 || gameObject.anInt1297 >= 104 || gameObject.anInt1298 >= 104)
					gameObject.unlink();
			}
		if (destX != 0) {
			destX -= i17;
			destY -= j21;
		}
		cameraViewChanged = false;
	}

	public Client() {
		accountManager = new AccountManager(this);
		new TimedTaskHandler(this);
		menuActionCmd4 = new int[500];
		setFullscreenInterfaceID(-1);
		chatRights = new int[500];
		chatTypeView = 0;
		cButtonHPos = -1;
		cButtonCPos = 0;
		anIntArrayArray825 = new int[104][104];
		crc32Instance = new CRC32();
		groundArray = new Deque[4][104][104];
		aBoolean831 = false;
		aStream_834 = new ByteBuffer(new byte[5000]);
		npcArray = new NPC[50000];
		npcIndices = new int[50000];
		anIntArray840 = new int[1000];
		setLoginBuffer(ByteBuffer.create());
		aBoolean848 = true;
		openInterfaceID = -1;
		currentExp = new int[Skills.SKILL_COUNT];
		httpFallback = false;
		anIntArray873 = new int[5];
		aBooleanArray876 = new boolean[5];
		drawFlames = false;
		playerIndex = -1;
		menuOpen = false;
		inputString = "";
		maxPlayers = 2048;
		myPlayerIndex = 2047;
		friendsNodeIDs = new int[200];
		playerArray = new Player[getMaxPlayers()];
		playerIndices = new int[getMaxPlayers()];
		anIntArray894 = new int[getMaxPlayers()];
		setaStreamArray895s(new ByteBuffer[getMaxPlayers()]);
		anIntArrayArray901 = new int[104][104];
		aByteArray912 = new byte[16384];
		currentStats = new int[Skills.SKILL_COUNT];
		ignoreListAsLongs = new long[100];
		loadingError = false;
		anIntArray928 = new int[5];
		anIntArrayArray929 = new int[104][104];
		chatTypes = new int[500];
		chatNames = new String[500];
		chatMessages = new String[500];
		chatTitles = new String[500];
		chatPosition = new int[500];
		Arrays.fill(chatTitles, "");
		Arrays.fill(chatPosition, 0);
		Arrays.fill(chatColor, 0);
		sideIcons = new Sprite[15];
		aBoolean954 = true;
		friendsListAsLongs = new long[200];
		friendsList = new String[200];
		currentSong = -1;
		drawingFlames = false;
		spriteDrawX = -1;
		spriteDrawY = -1;
		compassArray1 = new int[33];
		decompressors = new Decompressor[CACHE_INDEX_COUNT];
		variousSettings = new int[2000];
		aBoolean972 = false;
		anInt975 = 50;
		anIntArray976 = new int[anInt975];
		anIntArray977 = new int[anInt975];
		anIntArray978 = new int[anInt975];
		anIntArray979 = new int[anInt975];
		anIntArray980 = new int[anInt975];
		anIntArray981 = new int[anInt975];
		anIntArray982 = new int[anInt975];
		aStringArray983 = new String[anInt975];
		setAnInt985(-1);
		hitMarks = new Sprite[20];
		anIntArray990 = new int[5];
		aBoolean994 = false;
		amountOrNameInput = "";
		setaClass19_1013(new Deque());
		aBoolean1017 = false;
		setWalkableInterface(-1);
		anIntArray1030 = new int[5];
		aBoolean1031 = false;
		mapFunctions = new Sprite[100];
		dialogID = -1;
		maxStats = new int[Skills.SKILL_COUNT];
		settings = new int[5000]; // use up from 2000 for custom client configs
		aBoolean1047 = true;
		mapImagePixelCutLeft = new int[152];
		anInt1054 = -1;
		setaClass19_1056(new Deque());
		compassArray2 = new int[33];
		aClass9_1059 = new RSInterface();
		mapScenes = new Background[100];
		anIntArray1065 = new int[7];
		anIntArray1072 = new int[1000];
		anIntArray1073 = new int[1000];
		aBoolean1080 = false;
		setInputBuffer(ByteBuffer.create());
		expectedCRCs = new int[9];
		menuActionCmd2 = new int[500];
		menuActionCmd3 = new int[500];
		menuActionID = new int[500];
		menuActionCmd1 = new int[500];
		headIcons = new Sprite[20];
		skullIcons = new Sprite[7];
		headIconsHint = new Sprite[20];
		scrollPart = new Sprite[12];
		scrollBar = new Sprite[6];
		tabAreaAltered = false;
		promptMessage = "";
		atPlayerActions = new String[5];
		atPlayerArray = new boolean[5];
		anIntArrayArrayArray1129 = new int[4][13][13];
		aClass30_Sub2_Sub1_Sub1Array1140 = new Sprite[1000];
		aBoolean1141 = false;
		dialogueOptionsShowing = false;
		crosses = new Sprite[8];
		loggedIn = false;
		aBoolean1159 = false;
		cameraViewChanged = false;
		setMyUsername("");
		setPassword("");
		reportAbuseInterfaceID = -1;
		setaClass19_1179(new Deque());
		cameraRotationZ = 128;
		invOverlayInterfaceID = -1;
		setOut(ByteBuffer.create());
		menuActionName = new String[500];
		menuActionTitle = new String[500];
		menuActionColor = new int[500];
		anIntArray1203 = new int[5];
		sound = new int[50];
		anInt1211 = 78;
		promptInput = "";
		modIcons = new Sprite[13];
		tabID = 3;
		setInputTaken(false);
		mapImagePixelCutRight = new int[152];
		aClass11Array1230 = new CollisionMap[4];
		soundType = new int[50];
		aBoolean1242 = false;
		soundDelay = new int[50];
		welcomeScreenRaised = false;
		messagePromptRaised = false;
		setLoginMessage1("Enter your username & password.");
		backDialogID = -1;
		consoleInput = "";
		consoleOpen = false;
		consoleMessages = new String[50];
		bigX = new int[4000];
		bigY = new int[4000];
	}

	void drawConsole() {
		if (consoleOpen) {
			DrawingArea.transparentBox(!loggedIn ? getScreenHeight() : 334, 0, 0, 5320850, !loggedIn ? getScreenWidth() : 512, 0, 97);
			DrawingArea.drawPixels(1, 315, 0, 16777215, !loggedIn ? getScreenWidth() : 512);
			newBoldFont.drawBasicString("-->", 11, 328, 16777215, 0);
			// textDrawingArea.method385(16777215,"-->", 11, 328);
			if (loopCycle % 20 < 10) {
				newBoldFont.drawBasicString(consoleInput + "|", 38, 328, 16777215, 0);
				// textDrawingArea.method385(16777215,consoleInput+"|", 38,
				// 328);
				return;
			} else {
				newBoldFont.drawBasicString(consoleInput, 38, 328, 16777215, 0);
				// textDrawingArea.method385(16777215,consoleInput, 38, 328);
				return;
			}
		}
	}

	void drawConsoleArea() {
		if (consoleOpen) {
			for (int i = 0, j = 308; i < 17; i++, j -= 18) {
				if (consoleMessages[i] != null) {
					newRegularFont.drawBasicString(consoleMessages[i], 9, j, 16777215, 0);
					// textDrawingArea.method385(16777215,consoleMessages[i], 9,
					// j);
				}
			}
		}
	}

	public void printConsoleMessage(String s, int i) {
		if (backDialogID == -1) {
			inputTaken = true;
		}
		for (int j = 16; j > 0; j--) {
			consoleMessages[j] = consoleMessages[j - 1];
		}
		if (i == 0) {
			consoleMessages[0] = date() + " " + s;
		} else {
			consoleMessages[0] = s;
		}
	}

	public String date() {
		Date date = new Date();
		SimpleDateFormat sd = new SimpleDateFormat("HH:mm:ss");
		return sd.format(date);
	}

	private void sendCommandPacket(String cmd) {
		if (cmd.equalsIgnoreCase("cls")) {
			for (int j = 0; j < 17; j++) {
				consoleMessages[j] = null;
			}
		}
		/** Add Commands Here **/
		if (loggedIn) {
			getOut().putOpcode(103);
			getOut().putShortBigEndian(cmd.length() + 1);
			getOut().putString(cmd);
		}
	}

	private void addFriend(long nameAsLong) {
		try {
			if (nameAsLong == 0L) {
				return;
			}

			if (friendCount >= 100 && anInt1046 != 1) {
				pushMessage("Your friendlist is full. Max of 100 for free users, and 200 for members", 0, "");
				return;
			}

			if (friendCount >= 200) {
				pushMessage("Your friendlist is full. Max of 100 for free users, and 200 for members", 0, "");
				return;
			}

			String s = TextClass.fixName(TextClass.nameForLong(nameAsLong));

			if (s != null) {
				if (s.indexOf("@") == 0) {
					s = name.substring(5);
				}
			}

			for (int i = 0; i < friendCount; i++) {
				if (friendsListAsLongs[i] == nameAsLong) {
					pushMessage(s + " is already on your friend list", 0, "");
					return;
				}
			}

			for (int i = 0; i < ignoreCount; i++) {
				if (ignoreListAsLongs[i] == nameAsLong) {
					pushMessage("Please remove " + s + " from your ignore list first", 0, "");
					return;
				}
			}

			if (s.equals(myPlayer.name)) {
				return;
			} else {
				friendsList[friendCount] = s;
				friendsListAsLongs[friendCount] = nameAsLong;
				friendsNodeIDs[friendCount] = 0;
				friendCount++;
				getOut().putOpcode(188);
				getOut().putLong(nameAsLong);
				return;
			}
		} catch (RuntimeException ex) {
			Signlink.reportError("15283, " + (byte) 68 + ", " + nameAsLong + ", " + ex.toString());
			ex.printStackTrace();
		}

		throw new RuntimeException();
	}

	private void addIgnore(long nameAsLong) {
		try {
			if (nameAsLong == 0L) {
				return;
			}

			if (ignoreCount >= 100) {
				pushMessage("Your ignore list is full. Max of 100 hit", 0, "");
				return;
			}

			String name = TextClass.fixName(TextClass.nameForLong(nameAsLong));

			if (name != null) {
				if (name.indexOf("@") == 0) {
					name = name.substring(5);
				}
			}

			for (int i = 0; i < ignoreCount; i++) {
				if (ignoreListAsLongs[i] == nameAsLong) {
					pushMessage(name + " is already on your ignore list", 0, "");
					return;
				}
			}

			for (int i = 0; i < friendCount; i++) {
				if (friendsListAsLongs[i] == nameAsLong) {
					pushMessage("Please remove " + name + " from your friend list first", 0, "");
					return;
				}
			}

			ignoreListAsLongs[ignoreCount++] = nameAsLong;
			getOut().putOpcode(133);
			getOut().putLong(nameAsLong);
			return;
		} catch (RuntimeException ex) {
			Signlink.reportError("45688, " + nameAsLong + ", " + 4 + ", " + ex.toString());
		}

		throw new RuntimeException();
	}

	private void build3dScreenMenu() {
		if (itemSelected == 0 && spellSelected == 0) {
			menuActionName[menuActionRow] = "Walk here";
			menuActionID[menuActionRow] = 516;
			menuActionCmd2[menuActionRow] = super.mouseX;
			menuActionCmd3[menuActionRow] = super.mouseY;
			menuActionRow++;
		}
		int j = -1;
		for (int k = 0; k < Model.anInt1687; k++) {
			int modelData = Model.anIntArray1688[k];// data
			int x = modelData & 0x7f;// x
			int y = modelData >> 7 & 0x7f;// y
			int face = modelData >> 29 & 3;// face
			int index = -1;// objId
			if (face != 2) {
				index = modelData >> 14 & 32767;
			}
			if (modelData == j) {
				continue;
			}
			j = modelData;

			// objects
			if (face == 2 && worldController.fetchObjectIDTagForPosition(plane, x, y, modelData) >= 0) {
				index = Model.mapObjIds[k];
				ObjectDefinition class46 = ObjectDefinition.forID(index);
				if (class46.configObjectIDs != null) {
					class46 = class46.method580();
				}

				if ((baseX + x == 3090 && baseY + y == 3956) || (baseX + x == 3153 && baseY + y == 3923)) {
					menuActionName[menuActionRow] = "Pull @cya@Lever";
					menuActionID[menuActionRow] = 502;
					menuActionCmd1[menuActionRow] = modelData;
					menuActionCmd2[menuActionRow] = x;
					menuActionCmd3[menuActionRow] = y;
					menuActionCmd4[menuActionRow] = 5959;
					menuActionRow++;

					menuActionName[menuActionRow] = "Examine @cya@ Lever";
					menuActionID[menuActionRow] = 1226;
					menuActionCmd1[menuActionRow] = 950;
					menuActionCmd2[menuActionRow] = x;
					menuActionCmd3[menuActionRow] = y;
					menuActionCmd4[menuActionRow] = 5959;
					menuActionRow++;
					return;
				}
				if (baseX + x == 2539 && baseY + y == 4712) {

					menuActionName[menuActionRow] = "Pull @cya@Lever";
					menuActionID[menuActionRow] = 502;
					menuActionCmd1[menuActionRow] = modelData;
					menuActionCmd2[menuActionRow] = x;
					menuActionCmd3[menuActionRow] = y;
					menuActionCmd4[menuActionRow] = 5960;
					menuActionRow++;

					menuActionName[menuActionRow] = "Examine @cya@ Lever";
					menuActionID[menuActionRow] = 1226;
					menuActionCmd1[menuActionRow] = 950;
					menuActionCmd2[menuActionRow] = x;
					menuActionCmd3[menuActionRow] = y;
					menuActionCmd4[menuActionRow] = 5960;
					menuActionRow++;
					return;
				}
				if (!isDebugMode()) {
					if (class46 == null) {
						continue;
					}
				}
				if (itemSelected == 1) {
					menuActionName[menuActionRow] = "Use " + selectedItemName + " with @cya@" + class46.name;
					menuActionID[menuActionRow] = 62;
					menuActionCmd1[menuActionRow] = modelData;
					menuActionCmd2[menuActionRow] = x;
					menuActionCmd3[menuActionRow] = y;
					menuActionCmd4[menuActionRow] = index;
					menuActionRow++;
				} else if (spellSelected == 1) {
					if ((spellUsableOn & 4) == 4) {
						menuActionName[menuActionRow] = spellTooltip + " @cya@" + class46.name;
						menuActionID[menuActionRow] = 956;
						menuActionCmd1[menuActionRow] = modelData;
						menuActionCmd2[menuActionRow] = x;
						menuActionCmd3[menuActionRow] = y;
						menuActionCmd4[menuActionRow] = index;
						menuActionRow++;
					}
				} else {
					if (class46 != null && class46.actions != null) {
						for (int i2 = 4; i2 >= 0; i2--) {
							if (class46.actions[i2] != null) {
								menuActionName[menuActionRow] = class46.actions[i2] + " @cya@" + class46.name;

								if (i2 == 0) {
									menuActionID[menuActionRow] = 502;
								}

								if (i2 == 1) {
									menuActionID[menuActionRow] = 900;
								}

								if (i2 == 2) {
									menuActionID[menuActionRow] = 113;
								}

								if (i2 == 3) {
									menuActionID[menuActionRow] = 872;
								}

								if (i2 == 4) {
									menuActionID[menuActionRow] = 1062;
								}

								menuActionCmd1[menuActionRow] = modelData;
								menuActionCmd2[menuActionRow] = x;
								menuActionCmd3[menuActionRow] = y;
								menuActionCmd4[menuActionRow] = index;
								menuActionRow++;
							}
						}
					}
					menuActionName[menuActionRow] = "Examine @cya@" + (class46 == null ? "null" : class46.name) + (isDebugMode() ? " (" + (class46 == null ? "null" : class46.type) + ")" : "");
					menuActionID[menuActionRow] = 1226;
					menuActionCmd1[menuActionRow] = class46 == null ? -1 : class46.type << 14;
					menuActionCmd2[menuActionRow] = x;
					menuActionCmd3[menuActionRow] = y;
					menuActionCmd4[menuActionRow] = index;
					menuActionRow++;
				}
			}

			/**
			 * npcs
			 */
			if (face == 1) {
				NPC npc = npcArray[index];
				if (npc.definitionOverride.npcSizeInSquares == 1 && (npc.x & 0x7f) == 64 && (npc.y & 0x7f) == 64) {
					for (int j2 = 0; j2 < npcCount; j2++) {
						NPC npc2 = npcArray[npcIndices[j2]];
						if (npc2 != null && npc2 != npc && npc2.definitionOverride.npcSizeInSquares == 1 && npc2.x == npc.x && npc2.y == npc.y) {
							buildAtNPCMenu(npc2.definitionOverride, npcIndices[j2], y, x);
						}
					}

					for (int l2 = 0; l2 < playerCount; l2++) {
						Player player = playerArray[playerIndices[l2]];

						if (player != null && player.x == npc.x && player.y == npc.y) {
							buildAtPlayerMenu(x, playerIndices[l2], player, y);
						}
					}
				}
				buildAtNPCMenu(npc.definitionOverride, index, y, x);
			}

			/**
			 * Players
			 */
			if (face == 0) {
				Player player = playerArray[index];

				if ((player.x & 0x7f) == 64 && (player.y & 0x7f) == 64) {
					for (int k2 = 0; k2 < npcCount; k2++) {
						NPC class30_sub2_sub4_sub1_sub1_2 = npcArray[npcIndices[k2]];

						try {
							if (class30_sub2_sub4_sub1_sub1_2 != null && class30_sub2_sub4_sub1_sub1_2.definitionOverride.npcSizeInSquares == 1 && class30_sub2_sub4_sub1_sub1_2.x == player.x
									&& class30_sub2_sub4_sub1_sub1_2.y == player.y) {
								buildAtNPCMenu(class30_sub2_sub4_sub1_sub1_2.definitionOverride, npcIndices[k2], y, x);
							}
						} catch (Exception _ex) {
						}
					}

					for (int i3 = 0; i3 < playerCount; i3++) {
						Player player1 = playerArray[playerIndices[i3]];

						if (player1 != null && player1 != player && player1.x == player.x && player1.y == player.y) {
							buildAtPlayerMenu(x, playerIndices[i3], player1, y);
						}
					}
				}

				buildAtPlayerMenu(x, index, player, y);
			}

			/**
			 * i assume items
			 */
			if (face == 3) {
				Deque class19 = groundArray[plane][x][y];

				if (class19 != null) {
					for (Item item = (Item) class19.getFirst(); item != null; item = (Item) class19.getNext()) {
						ItemDefinition itemDef = ItemDefinition.get(item.id);

						if (itemSelected == 1) {
							menuActionName[menuActionRow] = "Use " + selectedItemName + " with @lre@" + itemDef.name;
							menuActionID[menuActionRow] = 511;
							menuActionCmd1[menuActionRow] = item.id;
							menuActionCmd2[menuActionRow] = x;
							menuActionCmd3[menuActionRow] = y;
							menuActionCmd4[menuActionRow] = index;
							menuActionRow++;
						} else if (spellSelected == 1) {
							if ((spellUsableOn & 1) == 1) {
								menuActionName[menuActionRow] = spellTooltip + " @lre@" + itemDef.name;
								menuActionID[menuActionRow] = 94;
								menuActionCmd1[menuActionRow] = item.id;
								menuActionCmd2[menuActionRow] = x;
								menuActionCmd3[menuActionRow] = y;
								menuActionCmd4[menuActionRow] = index;
								menuActionRow++;
							}
						} else {
							for (int j3 = 4; j3 >= 0; j3--) {
								if (itemDef.groundActions != null && itemDef.groundActions[j3] != null) {
									menuActionName[menuActionRow] = itemDef.groundActions[j3] + " @lre@" + itemDef.name;

									if (j3 == 0) {
										menuActionID[menuActionRow] = 652;
									}

									if (j3 == 1) {
										menuActionID[menuActionRow] = 567;
									}

									if (j3 == 2) {
										menuActionID[menuActionRow] = 234;
									}

									if (j3 == 3) {
										menuActionID[menuActionRow] = 244;
									}

									if (j3 == 4) {
										menuActionID[menuActionRow] = 213;
									}

									menuActionCmd1[menuActionRow] = item.id;
									menuActionCmd2[menuActionRow] = x;
									menuActionCmd3[menuActionRow] = y;
									menuActionCmd4[menuActionRow] = index;
									menuActionRow++;
								} else if (j3 == 2) {
									menuActionName[menuActionRow] = "Take @lre@" + itemDef.name;
									menuActionID[menuActionRow] = 234;
									menuActionCmd1[menuActionRow] = item.id;
									menuActionCmd2[menuActionRow] = x;
									menuActionCmd3[menuActionRow] = y;
									menuActionCmd4[menuActionRow] = index;
									menuActionRow++;
								}
							}

							menuActionName[menuActionRow] = "Examine @lre@" + itemDef.name + (isDebugMode() ? " (" + itemDef.id + ":" + itemDef.modelID + ")" : "");
							menuActionID[menuActionRow] = 1448;
							menuActionCmd1[menuActionRow] = item.id;
							menuActionCmd2[menuActionRow] = x;
							menuActionCmd3[menuActionRow] = y;
							menuActionCmd4[menuActionRow] = index;
							menuActionRow++;
						}
					}
				}
			}
		}
	}

	private void buildAtNPCMenu(MobDefinition entityDef, int index, int y, int x) {

		if (menuActionRow >= 400) {
			return;
		}

		if (entityDef.childrenIDs != null) {
			entityDef = entityDef.method161();
		}
		if (entityDef == null) {
			return;
		}
		if (!entityDef.disableRightClick) {
			return;
		}
		String s = entityDef.name;
		if (entityDef.combatLevel != 0) {
			s = s + combatDiffColor(myPlayer.combatLevel, entityDef.combatLevel) + " (level-" + entityDef.combatLevel + ")";
		}

		if (itemSelected == 1) {
			menuActionName[menuActionRow] = "Use " + selectedItemName + " with @yel@" + s;
			menuActionID[menuActionRow] = 582;
			menuActionCmd1[menuActionRow] = index;
			menuActionCmd2[menuActionRow] = x;
			menuActionCmd3[menuActionRow] = y;
			menuActionRow++;
			return;
		}

		if (spellSelected == 1) {
			if ((spellUsableOn & 2) == 2) {
				menuActionName[menuActionRow] = spellTooltip + " @yel@" + s;
				menuActionID[menuActionRow] = 413;
				menuActionCmd1[menuActionRow] = index;
				menuActionCmd2[menuActionRow] = x;
				menuActionCmd3[menuActionRow] = y;
				menuActionRow++;
			}
		} else {
			if (entityDef.actions != null) {
				for (int l = 4; l >= 0; l--) {
					if (entityDef.actions[l] != null && !entityDef.actions[l].equalsIgnoreCase("attack")) {
						menuActionName[menuActionRow] = entityDef.actions[l] + " @yel@" + s;

						if (l == 0) {
							menuActionID[menuActionRow] = 20;
						}

						if (l == 1) {
							menuActionID[menuActionRow] = 412;
						}

						if (l == 2) {
							menuActionID[menuActionRow] = 225;
						}

						if (l == 3) {
							menuActionID[menuActionRow] = 965;
						}

						if (l == 4) {
							menuActionID[menuActionRow] = 478;
						}
						menuActionCmd1[menuActionRow] = index;
						menuActionCmd2[menuActionRow] = x;
						menuActionCmd3[menuActionRow] = y;
						menuActionRow++;
					}
				}
			}

			if (entityDef.actions != null) {
				for (int i1 = 4; i1 >= 0; i1--) {
					if (entityDef.actions[i1] != null && entityDef.actions[i1].equalsIgnoreCase("attack")) {
						char c = '\0';
						if (!config.getStatus(ConfigType.ONE_CLICK_ATTACK)) {
							if (entityDef.combatLevel > myPlayer.combatLevel)
								c = '\u07D0';
						}

						menuActionName[menuActionRow] = entityDef.actions[i1] + " @yel@" + s;

						if (i1 == 0) {
							menuActionID[menuActionRow] = 20 + c;
						}

						if (i1 == 1) {
							menuActionID[menuActionRow] = 412 + c;
						}

						if (i1 == 2) {
							menuActionID[menuActionRow] = 225 + c;
						}

						if (i1 == 3) {
							menuActionID[menuActionRow] = 965 + c;
						}

						if (i1 == 4) {
							menuActionID[menuActionRow] = 478 + c;
						}

						menuActionCmd1[menuActionRow] = index;
						menuActionCmd2[menuActionRow] = x;
						menuActionCmd3[menuActionRow] = y;
						menuActionRow++;
					}
				}
			}

			menuActionName[menuActionRow] = "Examine @yel@" + s + (isDebugMode() ? " (" + entityDef.id + ")" : "");
			menuActionID[menuActionRow] = 1025;
			menuActionCmd1[menuActionRow] = index;
			menuActionCmd2[menuActionRow] = x;
			menuActionCmd3[menuActionRow] = y;
			menuActionRow++;
		}
	}

	private final String[] menuPlayerName = new String[500];

	private boolean allButOneInitialized;

	private void buildAtPlayerMenu(int i, int j, Player player, int k) {
		if (player == myPlayer) {
			return;
		}

		if (menuActionRow >= 400) {
			return;
		}

		String menuTooltip;
		boolean before = player.loyaltyPosition == 0 ? true : false;
		String title = "";
		if (player.loyaltyTitle != null) {
			title = "<col=" + Integer.toHexString(player.loyaltyColor) + ">" + player.loyaltyTitle.trim() + "</col>";
		}
		if (player.skill == 0) {
			if (!before || player.loyaltyTitle == null) {
				menuTooltip = player.name + (title.isEmpty() ? "" : " ") + title + combatDiffColor(myPlayer.combatLevel, player.combatLevel) + " (level-" + player.combatLevel + ")";
			} else {
				menuTooltip = title + (player.loyaltyTitle.isEmpty() ? "" : " ") + player.name + combatDiffColor(myPlayer.combatLevel, player.combatLevel) + " (level-" + player.combatLevel + ")";
			}
		} else {
			menuTooltip = player.name + " (skill-" + player.skill + ")";
		}

		if (itemSelected == 1) {
			menuActionName[menuActionRow] = "Use " + selectedItemName + " with @whi@" + menuTooltip;
			menuActionID[menuActionRow] = 491;
			menuActionCmd1[menuActionRow] = j;
			menuActionCmd2[menuActionRow] = i;
			menuActionCmd3[menuActionRow] = k;
			menuActionRow++;
		} else if (spellSelected == 1) {
			if ((spellUsableOn & 8) == 8) {
				menuActionName[menuActionRow] = spellTooltip + " @whi@" + menuTooltip;
				menuActionID[menuActionRow] = 365;
				menuActionCmd1[menuActionRow] = j;
				menuActionCmd2[menuActionRow] = i;
				menuActionCmd3[menuActionRow] = k;
				menuActionRow++;
			}
		} else {
			for (int index = 4; index >= 0; index--) {
				if (atPlayerActions[index] != null) {
					menuActionName[menuActionRow] = atPlayerActions[index] + " @whi@" + menuTooltip;
					char c = '\0';

					if (atPlayerActions[index].equalsIgnoreCase("attack")) {
						if (!config.getStatus(ConfigType.ONE_CLICK_ATTACK)) {
							if (player.combatLevel > myPlayer.combatLevel)
								c = '\u07D0';
						}
						if (myPlayer.team != 0 && player.team != 0) {
							if (myPlayer.team == player.team) {
								c = '\u07D0';
							} else {
								c = '\0';
							}
						}
					} else if (atPlayerArray[index]) {
						c = '\u07D0';
					}

					if (index == 0) {
						menuActionID[menuActionRow] = 561 + c;
					}

					if (index == 1) {
						menuActionID[menuActionRow] = 779 + c;
					}

					if (index == 2) {
						menuActionID[menuActionRow] = 27 + c;
					}

					if (index == 3) {
						menuActionID[menuActionRow] = 577 + c;
					}

					if (index == 4) {
						menuActionID[menuActionRow] = 729 + c;
					}

					menuActionCmd1[menuActionRow] = j;
					menuActionCmd2[menuActionRow] = i;
					menuActionCmd3[menuActionRow] = k;
					menuActionRow++;
				}
			}
		}

		for (int i1 = 0; i1 < menuActionRow; i1++) {
			if (menuActionID[i1] == 516) {
				menuActionName[i1] = "Walk here @whi@" + menuTooltip;
				return;
			}
		}
	}

	private void buildChatAreaMenu(int yOffset) {
		if (!isGameFrameVisible() || chatArea.componentHidden()) {
			return;
		}

		int messages = 0;

		for (int index = 0; index < 500; index++) {
			if (chatMessages[index] == null) {
				continue;
			}

			int currentType = chatTypes[index];
			int k1 = 70 - messages * 14 + 42 + anInt1089 + 4 + 5;
			if (k1 < -23) {
				break;
			}

			String player_name = chatNames[index];

			if (chatTypeView == 1) {
				buildPublicChat(yOffset);
				break;
			}

			if (chatTypeView == 2) {
				buildFriendChat(yOffset);
				break;
			}

			if (chatTypeView == 3 || chatTypeView == 4) {
				buildDuelorTrade(yOffset);
				break;
			}

			if (chatTypeView == 5) {
				break;
			}

			if (player_name != null) {
				if (player_name.indexOf("@") == 0) {
					player_name = player_name.substring(5);
				}
			}
			if (player_name != null && player_name.startsWith("<col=")) {
				player_name = player_name.substring(player_name.indexOf("</col>") + 6);
			}
			if (currentType == 0) {
				messages++;
			}

			if ((currentType == 1 || currentType == 2) && (currentType == 1 || publicChatMode == 0 || publicChatMode == 1 && isFriendOrSelf(player_name))) {
				if (yOffset > k1 - 14 && yOffset <= k1 && !myPlayer.name.equals(NAME_PATTERN.matcher(player_name).replaceAll(""))) {
					if (!isFriendOrSelf(player_name)) {
						menuActionName[menuActionRow] = "Add ignore @whi@" + player_name;
						menuActionID[menuActionRow] = 42;
						menuActionRow++;
						menuActionName[menuActionRow] = "Add friend @whi@" + player_name;
						menuActionID[menuActionRow] = 337;
						menuActionRow++;
					} // else if (isFriendOrSelf(player_name)) {
					menuActionName[menuActionRow] = "Message @whi@" + player_name;
					menuActionID[menuActionRow] = 2639;
					menuActionRow++;
					// }
				}

				messages++;
			}

			if ((currentType == 3 || currentType == 7) && splitPrivateChat == 0 && (currentType == 7 || privateChatMode == 0 || privateChatMode == 1 && isFriendOrSelf(player_name))) {
				if (yOffset > k1 - 14 && yOffset <= k1) {
					if (!isFriendOrSelf(player_name)) {
						menuActionName[menuActionRow] = "Add ignore @whi@" + player_name;
						menuActionID[menuActionRow] = 42;
						menuActionRow++;
						menuActionName[menuActionRow] = "Add friend @whi@" + player_name;
						menuActionID[menuActionRow] = 337;
						menuActionRow++;
					} // else if (isFriendOrSelf(player_name)) {
					menuActionName[menuActionRow] = "Message @whi@" + player_name;
					menuActionID[menuActionRow] = 2639;
					menuActionRow++;
					// }

				}

				messages++;
			}

			if (currentType == 4 && (tradeMode == 0 || tradeMode == 1 && isFriendOrSelf(player_name))) {
				if (yOffset > k1 - 14 && yOffset <= k1) {
					menuActionName[menuActionRow] = "Accept trade @whi@" + player_name;
					menuActionID[menuActionRow] = 484;
					menuActionRow++;
				}

				messages++;
			}

			if ((currentType == 5 || currentType == 6) && splitPrivateChat == 0 && privateChatMode < 2) {
				messages++;
			}
			if (currentType == 8 && (duelStatus == 0 || duelStatus == 1 && isFriendOrSelf(player_name))) {
				if (yOffset > k1 - 14 && yOffset <= k1) {
					menuActionName[menuActionRow] = "Accept challenge @whi@" + player_name;
					menuActionID[menuActionRow] = 6;
					menuActionRow++;
				}

				messages++;
			}

			if (currentType == 17) {
				if (yOffset > k1 - 14 && yOffset <= k1) {
					menuActionName[menuActionRow] = "Accept gamble @whi@" + player_name;
					menuActionID[menuActionRow] = 17;
					menuActionRow++;
				}

				messages++;
			}
		}
	}

	private void buildDuelorTrade(int yOffset) {
		int l = 0;

		for (int i1 = 0; i1 < 500; i1++) {
			if (chatMessages[i1] == null) {
				continue;
			}

			if (chatTypeView != 3 && chatTypeView != 4) {
				continue;
			}

			int chatType = chatTypes[i1];
			String name = chatNames[i1];
			int k1 = 70 - l * 14 + 42 + anInt1089 + 4 + 5;

			if (k1 < -23) {
				break;
			}

			if (name != null) {
				if (name.indexOf("@") == 0) {
					name = name.substring(5);
				}
			}

			if (chatTypeView == 3 && chatType == 4 && (tradeMode == 0 || tradeMode == 1 && isFriendOrSelf(name))) {
				if (yOffset > k1 - 14 && yOffset <= k1) {
					menuActionName[menuActionRow] = "Accept trade @whi@" + name;
					menuActionID[menuActionRow] = 484;
					menuActionRow++;
				}

				l++;
			}

			if (chatTypeView == 4 && chatType == 8 && (duelStatus == 0 || duelStatus == 1 && isFriendOrSelf(name))) {
				if (yOffset > k1 - 14 && yOffset <= k1) {
					menuActionName[menuActionRow] = "Accept challenge @whi@" + name;
					menuActionID[menuActionRow] = 6;
					menuActionRow++;
				}

				l++;
			}

			if (chatType == 12) {
				if (yOffset > k1 - 14 && yOffset <= k1) {
					menuActionName[menuActionRow] = "Go-to @blu@" + name;
					menuActionID[menuActionRow] = 915;
					menuActionRow++;
				}

				l++;
			}
		}
	}

	private void buildFriendChat(int yOffset) {
		int count = 0;

		for (int index = 0; index < 500; index++) {
			if (chatMessages[index] == null) {
				continue;
			}

			if (chatTypeView != 2) {
				continue;
			}

			int type = chatTypes[index];
			String player_name = chatNames[index];
			int k1 = 70 - count * 14 + 42 + anInt1089 + 4 + 5;
			if (k1 < -23) {
				break;
			}

			if (player_name != null) {
				if (player_name.indexOf("@") == 0) {
					player_name = player_name.substring(5);
				}
			}

			if ((type == 5 || type == 6) && (splitPrivateChat == 0 || chatTypeView == 2) && (type == 6 || privateChatMode == 0 || privateChatMode == 1 && isFriendOrSelf(player_name))) {
				count++;
			}

			if ((type == 3 || type == 7) && (splitPrivateChat == 0 || chatTypeView == 2) && (type == 7 || privateChatMode == 0 || privateChatMode == 1 && isFriendOrSelf(player_name))) {
				if (yOffset > k1 - 14 && yOffset <= k1) {
					if (!isFriendOrSelf(player_name)) {
						menuActionName[menuActionRow] = "Add ignore @whi@" + player_name;
						menuActionID[menuActionRow] = 42;
						menuActionRow++;
						menuActionName[menuActionRow] = "Add friend @whi@" + player_name;
						menuActionID[menuActionRow] = 337;
						menuActionRow++;
					} // else if (isFriendOrSelf(player_name)) {
					menuActionName[menuActionRow] = "Message @whi@" + player_name;
					menuActionID[menuActionRow] = 2639;
					menuActionRow++;
					// }
				}

				count++;
			}
		}
	}

	private boolean buildFriendsListMenu(RSInterface class9) {
		int i = class9.contentType;

		if (i >= 1 && i <= 200 || i >= 701 && i <= 900) {
			if (i >= 801) {
				i -= 701;
			} else if (i >= 701) {
				i -= 601;
			} else if (i >= 101) {
				i -= 101;
			} else {
				i--;
			}

			menuActionName[menuActionRow] = "Remove @whi@" + friendsList[i];
			menuActionID[menuActionRow] = 792;
			menuActionRow++;
			menuActionName[menuActionRow] = "Message @whi@" + friendsList[i];
			menuActionID[menuActionRow] = 639;
			menuActionRow++;
			return true;
		}

		if (i >= 401 && i <= 500) {
			menuActionName[menuActionRow] = "Remove @whi@" + class9.message;
			menuActionID[menuActionRow] = 322;
			menuActionRow++;
			return true;
		} else {
			return false;
		}
	}

	private void buildInterfaceMenu(int xPadding, RSInterface rsInterface, int xPos, int yPadding, int yPos, int scrollPoint) {
		if (rsInterface == null) {
			rsInterface = RSInterface.interfaceCache[21356];
		}

		if (rsInterface.type != 0 || rsInterface.children == null || rsInterface.interfaceShown) {
			return;
		}

		if (xPos < xPadding || yPos < yPadding || xPos > xPadding + rsInterface.width || yPos > yPadding + rsInterface.height) {
			return;
		}

		int totalChildren = rsInterface.children.length;

		for (int index = 0; index < totalChildren; index++) {
			int xSpritePos = rsInterface.childX[index] + xPadding;
			int ySpritePos = rsInterface.childY[index] + yPadding - scrollPoint;
			RSInterface children = RSInterface.interfaceCache[rsInterface.children[index]];
			int offset = children.xOffset;
			xSpritePos += offset;
			ySpritePos += children.yOffset;

			if (super.clickMode3 != 0) {
				xPos = super.clickX;
				yPos = super.clickY;
			}

			if ((children.hoverType >= 0 || children.textColorSelected != 0) && xPos >= xSpritePos && yPos >= ySpritePos && xPos < xSpritePos + children.width && yPos < ySpritePos + children.height) {
				if (children.hoverType >= 0) {
					anInt886 = children.hoverType;
				} else {
					anInt886 = children.id;
				}
			}

			if (children.type == 8 && xPos >= xSpritePos && yPos >= ySpritePos && xPos < xSpritePos + children.width && yPos < ySpritePos + children.height) {
				anInt1315 = children.id;
			}
			if (children.type == 0) {
				buildInterfaceMenu(xSpritePos, children, xPos, ySpritePos, yPos, children.scrollPosition);

				if (children.scrollMax > children.height) {
					method65(xSpritePos + children.width, children.height, xPos, yPos, children, ySpritePos, true, children.scrollMax);
				}
			} else {
				// Quest tab extra lines size fit
				int extra = 0;
				for (int e : lines) {
					if (children.id == e) {
						extra = 60;
						break;
					}
				}
				if (children.atActionType == 1 && xPos >= xSpritePos && yPos >= ySpritePos && xPos < xSpritePos + children.width + extra && yPos < ySpritePos + children.height) {
					boolean flag = false, flag1 = false;

					if (children.contentType != 0) {
						flag = buildFriendsListMenu(children);
					}

					if (children.tooltip != null && children.tooltip.startsWith("[CC]")) {
						flag1 = true;
						PlayerHandler.clanName = RSInterface.interfaceCache[children.id - 800].message;
					}

					if (!flag && !flag1) {
						if (children.tooltip.length() > 0) {
							menuActionName[menuActionRow] = children.tooltip;
							menuActionID[menuActionRow] = 315;
							menuActionCmd3[menuActionRow] = children.id;
							menuActionRow++;
						}
					}

					if (flag1 && RSInterface.interfaceCache[children.id - 800].message != "") {
						menuActionName[menuActionRow] = "General";
						menuActionID[menuActionRow] = 1321;
						menuActionCmd3[menuActionRow] = children.id;
						menuActionRow++;
						menuActionName[menuActionRow] = "Captain";
						menuActionID[menuActionRow] = 1320;
						menuActionCmd3[menuActionRow] = children.id;
						menuActionRow++;
						menuActionName[menuActionRow] = "Lieutenant";
						menuActionID[menuActionRow] = 1319;
						menuActionCmd3[menuActionRow] = children.id;
						menuActionRow++;
						menuActionName[menuActionRow] = "Sergeant";
						menuActionID[menuActionRow] = 1318;
						menuActionCmd3[menuActionRow] = children.id;
						menuActionRow++;
						menuActionName[menuActionRow] = "Corporal";
						menuActionID[menuActionRow] = 1317;
						menuActionCmd3[menuActionRow] = children.id;
						menuActionRow++;
						menuActionName[menuActionRow] = "Recruit";
						menuActionID[menuActionRow] = 1316;
						menuActionCmd3[menuActionRow] = children.id;
						menuActionRow++;
						menuActionName[menuActionRow] = "Not ranked";
						menuActionID[menuActionRow] = 1315;
						menuActionCmd3[menuActionRow] = children.id;
						menuActionRow++;
					}
				}

				if (children.atActionType == 2 && xPos >= xSpritePos && yPos >= ySpritePos && xPos < xSpritePos + children.width && yPos < ySpritePos + children.height) {
					String s = children.selectedActionName;

					if (s.indexOf(" ") != -1) {
						s = s.substring(0, s.indexOf(" "));
					}

					if (children.spellName.endsWith("Rush") || children.spellName.endsWith("Burst") || children.spellName.endsWith("Blitz") || children.spellName.endsWith("Barrage")
							|| children.spellName.endsWith("strike") || children.spellName.endsWith("bolt") || children.spellName.equals("Crumble undead") || children.spellName.endsWith("blast")
							|| children.spellName.endsWith("wave") || children.spellName.equals("Claws of Guthix") || children.spellName.equals("Flames of Zamorak")
							|| children.spellName.equals("Magic Dart")) {
						menuActionName[menuActionRow] = "Autocast @gre@" + children.spellName;
						menuActionID[menuActionRow] = 104;
						menuActionCmd3[menuActionRow] = children.id;
						menuActionRow++;
					}

					menuActionName[menuActionRow] = s + " @gre@" + children.spellName + (isDebugMode() ? ", " + children.id : "");
					menuActionID[menuActionRow] = 626;
					menuActionCmd3[menuActionRow] = children.id;
					menuActionRow++;
				}

				if (children.atActionType == 3 && xPos >= xSpritePos && yPos >= ySpritePos && xPos < xSpritePos + children.width && yPos < ySpritePos + children.height) {
					menuActionName[menuActionRow] = "Close";
					menuActionID[menuActionRow] = 200;
					menuActionCmd3[menuActionRow] = children.id;
					menuActionRow++;
				}

				if (children.atActionType == 4 && xPos >= xSpritePos && yPos >= ySpritePos && xPos < xSpritePos + children.width && yPos < ySpritePos + children.height) {
					// System.out.println("2"+class9_1.tooltip + ", " +
					// class9_1.interfaceID);

					menuActionName[menuActionRow] = children.tooltip + (isDebugMode() ? ", " + children.id : "");
					menuActionID[menuActionRow] = 169;
					menuActionCmd3[menuActionRow] = children.id;
					menuActionRow++;

					if (children.tooltipBoxText != null) {
						// drawHoverBox(k, l, class9_1.hoverText);
						// System.out.println("DRAWING INTERFACE: " +
						// class9_1.hoverText);
					}
				}

				if (children.atActionType == 5 && xPos >= xSpritePos && yPos >= ySpritePos && xPos < xSpritePos + children.width && yPos < ySpritePos + children.height) {
					// System.out.println("3"+class9_1.tooltip + ", " +
					// class9_1.interfaceID);
					menuActionName[menuActionRow] = children.tooltip + (isDebugMode() ? ", " + children.id : "");
					menuActionID[menuActionRow] = 646;
					menuActionCmd3[menuActionRow] = children.id;
					menuActionRow++;
				}

				if (children.atActionType == 6 && !dialogueOptionsShowing && xPos >= xSpritePos && yPos >= ySpritePos && xPos < xSpritePos + children.width && yPos < ySpritePos + children.height) {
					// System.out.println("4"+class9_1.tooltip + ", " +
					// class9_1.interfaceID);

					menuActionName[menuActionRow] = children.tooltip + (isDebugMode() ? ", " + children.id : "");
					menuActionID[menuActionRow] = 679;
					menuActionCmd3[menuActionRow] = children.id;
					menuActionRow++;
				}

				if (children.type == 2 && children.parentID != 0) {
					int k2 = 0;

					for (int l2 = 0; l2 < children.height; l2++) {
						for (int i3 = 0; i3 < children.width; i3++) {
							int j3 = xSpritePos + i3 * (32 + children.invSpritePadX);
							int k3 = ySpritePos + l2 * (32 + children.invSpritePadY);

							if (k2 < children.spritesX.length) {
								j3 += children.spritesX[k2];
								k3 += children.spritesY[k2];
							}

							if (xPos >= j3 && yPos >= k3 && xPos < j3 + 32 && yPos < k3 + 32) {
								mouseInvInterfaceIndex = k2;
								lastActiveInvInterface = children.id;
								if (children.inv[k2] > 0) {
									ItemDefinition definition = ItemDefinition.get(children.inv[k2] - 1);

									if (itemSelected == 1 && children.isInventoryInterface) {
										if (children.id != anInt1284 || k2 != anInt1283) {
											menuActionName[menuActionRow] = "Use " + selectedItemName + " with @lre@" + definition.name;
											menuActionID[menuActionRow] = 870;
											menuActionCmd1[menuActionRow] = definition.id;
											menuActionCmd2[menuActionRow] = k2;
											menuActionCmd3[menuActionRow] = children.id;
											menuActionRow++;
										}
									} else if (spellSelected == 1 && children.isInventoryInterface) {
										if ((spellUsableOn & 0x10) == 16) {
											menuActionName[menuActionRow] = spellTooltip + " @lre@" + definition.name;
											menuActionID[menuActionRow] = 543;
											menuActionCmd1[menuActionRow] = definition.id;
											menuActionCmd2[menuActionRow] = k2;
											menuActionCmd3[menuActionRow] = children.id;
											menuActionRow++;
										}
									} else {
										if (children.isInventoryInterface) {
											for (int l3 = 4; l3 >= 3; l3--) {
												if (definition.actions != null && definition.actions[l3] != null || lootingBag) {
													if (lootingBag) {
														menuActionCmd1[menuActionRow] = definition.id;
														menuActionCmd2[menuActionRow] = k2;
														menuActionCmd3[menuActionRow] = children.id;

														if (l3 == 1) {
															menuActionName[menuActionRow] = "Deposit" + " @lre@" + definition.name;
														} else {
															menuActionName[menuActionRow] = null;
														}

														if (l3 == 3) {
															menuActionID[menuActionRow] = 493;
														}

														if (l3 == 4) {
															menuActionID[menuActionRow] = 847;
														}

														menuActionCmd1[menuActionRow] = definition.id;
														menuActionCmd2[menuActionRow] = k2;
														menuActionCmd3[menuActionRow] = children.id;
														menuActionRow++;
														continue;
													}
													menuActionName[menuActionRow] = definition.actions[l3] + " @lre@" + definition.name;

													if (l3 == 3) {
														menuActionID[menuActionRow] = 493;
													}

													if (l3 == 4) {
														menuActionID[menuActionRow] = 847;
													}

													menuActionCmd1[menuActionRow] = definition.id;
													menuActionCmd2[menuActionRow] = k2;
													menuActionCmd3[menuActionRow] = children.id;
													menuActionRow++;
												} else if (l3 == 4) {
													menuActionName[menuActionRow] = "Drop @lre@" + definition.name;
													menuActionID[menuActionRow] = 847;
													menuActionCmd1[menuActionRow] = definition.id;
													menuActionCmd2[menuActionRow] = k2;
													menuActionCmd3[menuActionRow] = children.id;
													menuActionRow++;
												}
											}
										}

										if (children.usableItemInterface) {
											menuActionName[menuActionRow] = "Use @lre@" + definition.name;
											menuActionID[menuActionRow] = 447;
											menuActionCmd1[menuActionRow] = definition.id;
											menuActionCmd2[menuActionRow] = k2;
											menuActionCmd3[menuActionRow] = children.id;
											menuActionRow++;
										}

										if (children.isInventoryInterface && definition.actions != null) {
											for (int i4 = 2; i4 >= 0; i4--) {
												if (definition.actions[i4] != null) {
													menuActionName[menuActionRow] = definition.actions[i4] + " @lre@" + definition.name;

													if (i4 == 0) {
														menuActionID[menuActionRow] = 74;
													}

													if (i4 == 1) {
														menuActionID[menuActionRow] = 454;
													}

													if (i4 == 2) {
														menuActionID[menuActionRow] = 539;
													}

													menuActionCmd1[menuActionRow] = definition.id;
													menuActionCmd2[menuActionRow] = k2;
													menuActionCmd3[menuActionRow] = children.id;
													menuActionRow++;
												}
											}
										}

										if (children.actions != null) {
											for (int j4 = (allButOneInitialized ? 5 : 4); j4 >= 0; j4--) {
												if (children.actions.length - 1 < j4) {
													continue;
												}

												if (children.actions[j4] != null) {
													if (children.parentID == 5292) {
														if (children.actions.length < 6) {
															allButOneInitialized = true;
															children.actions = new String[] { "Withdraw 1", "Withdraw 5", "Withdraw 10", "Withdraw All", "Withdraw X", "Withdraw All but one" };
														}
													}

													menuActionName[menuActionRow] = children.actions[j4] + " @lre@" + definition.name;

													if (j4 == 0) {
														menuActionID[menuActionRow] = 632;
													}

													if (j4 == 1) {
														menuActionID[menuActionRow] = 78;
													}

													if (j4 == 2) {
														menuActionID[menuActionRow] = 867;
													}

													if (j4 == 3) {
														menuActionID[menuActionRow] = 431;
													}

													if (j4 == 4) {
														menuActionID[menuActionRow] = 53;
													}

													if (children.parentID == 5292) {
														if (j4 == 5)
															menuActionID[menuActionRow] = 291;
													}

													menuActionCmd1[menuActionRow] = definition.id;
													menuActionCmd2[menuActionRow] = k2;
													menuActionCmd3[menuActionRow] = children.id;
													menuActionRow++;
												}
											}
										}
										if (!children.hideExamine) {
											menuActionName[menuActionRow] = "Examine @lre@" + definition.name
													+ (isDebugMode() ? " (" + definition.id + ":" + definition.modelID + ":" + definition.maleWearId + " : " + definition.femaleWearId + ")" : "");
											menuActionID[menuActionRow] = 1125;
											menuActionCmd1[menuActionRow] = definition.id;
											menuActionCmd2[menuActionRow] = k2;
											menuActionCmd3[menuActionRow] = children.id;
											menuActionRow++;
										}
									}
								}
							}

							k2++;
						}
					}
				}
			}
		}
	}

	private void buildPublicChat(int yOffset) {
		int messages = 0;

		for (int index = 0; index < 500; index++) {
			if (chatMessages[index] == null) {
				continue;
			}

			if (chatTypeView != 1) {
				continue;
			}

			int type = chatTypes[index];
			String name = chatNames[index];
			int k1 = 70 - messages * 14 + 42 + anInt1089 + 4 + 5;

			if (k1 < -23) {
				break;
			}

			if (name != null) {
				if (name.indexOf("@") == 0) {
					name = name.substring(5);
				}
			}

			if ((type == 1 || type == 2) && (type == 1 || publicChatMode == 0 || publicChatMode == 1 && isFriendOrSelf(name))) {
				if (yOffset > k1 - 14 && yOffset <= k1 && !name.equals(myPlayer.name)) {
					if (!isFriendOrSelf(name)) {
						menuActionName[menuActionRow] = "Add ignore @whi@" + name;
						menuActionID[menuActionRow] = 42;
						menuActionRow++;
						menuActionName[menuActionRow] = "Add friend @whi@" + name;
						menuActionID[menuActionRow] = 337;
						menuActionRow++;
					} // else if (isFriendOrSelf(name)) {
					menuActionName[menuActionRow] = "Message @whi@" + name;
					menuActionID[menuActionRow] = 2639;
					menuActionRow++;
					// }
				}

				messages++;
			}
		}
	}

	private void buildSplitPrivateChatMenu() {
		if (splitPrivateChat == 0) {
			return;
		}

		int yOffsetPos = 0;

		if (systemUpdateTimer != 0) {
			yOffsetPos = 1;
		}

		for (int index = 0; index < 500; index++) {
			if (chatMessages[index] != null) {
				int type = chatTypes[index];
				String name = chatNames[index];
				boolean fixed = GameFrame.getScreenMode() == ScreenMode.FIXED;

				if (name != null && name.indexOf("@") == 0) {
					name = NAME_PATTERN.matcher(name).replaceAll("");
				}

				if ((type == 3 || type == 7) && (type == 7 || privateChatMode == 0 || privateChatMode == 1 && isFriendOrSelf(name))) {
					int l = chatArea.getyPos() - 9 - yOffsetPos * 13;

					if (super.mouseX > (fixed ? 4 : 0) && super.mouseY - (fixed ? 4 : 0) > l - 10 && super.mouseY - (fixed ? 4 : 0) <= l + 3) {
						int i1 = normalText.getTextWidth("From:  " + name + chatMessages[index]) + 25;

						if (i1 > 450) {
							i1 = 450;
						}

						if (super.mouseX < (fixed ? 4 : 0) + i1) {
							if (!isFriendOrSelf(name)) {
								menuActionName[menuActionRow] = "Add ignore @whi@" + name;
								menuActionID[menuActionRow] = 2042;
								menuActionRow++;
								menuActionName[menuActionRow] = "Add friend @whi@" + name;
								menuActionID[menuActionRow] = 2337;
								menuActionRow++;
							} // else if (isFriendOrSelf(name)) {
							menuActionName[menuActionRow] = "Message @whi@" + name;
							menuActionID[menuActionRow] = 2639;
							menuActionRow++;
							// }
						}
					}

					if (++yOffsetPos >= 5) {
						return;
					}
				}

				if ((type == 5 || type == 6) && privateChatMode < 2 && ++yOffsetPos >= 5) {
					return;
				}
			}
		}
	}

	private void calcCameraPos() {
		int xPos = spinPacketX * 128 + 64;
		int yPos = spinPacketY * 128 + 64;
		int zPos = method42(plane, yPos, xPos) - spinPacketHeight;

		if (xCameraPos < xPos) {
			xCameraPos += spinPacketConstantSpeed + (xPos - xCameraPos) * spinPacketVariableSpeed / 1000;

			if (xCameraPos > xPos) {
				xCameraPos = xPos;
			}
		}

		if (xCameraPos > xPos) {
			xCameraPos -= spinPacketConstantSpeed + (xCameraPos - xPos) * spinPacketVariableSpeed / 1000;

			if (xCameraPos < xPos) {
				xCameraPos = xPos;
			}
		}

		if (zCameraPos < zPos) {
			zCameraPos += spinPacketConstantSpeed + (zPos - zCameraPos) * spinPacketVariableSpeed / 1000;

			if (zCameraPos > zPos) {
				zCameraPos = zPos;
			}
		}

		if (zCameraPos > zPos) {
			zCameraPos -= spinPacketConstantSpeed + (zCameraPos - zPos) * spinPacketVariableSpeed / 1000;

			if (zCameraPos < zPos) {
				zCameraPos = zPos;
			}
		}

		if (yCameraPos < yPos) {
			yCameraPos += spinPacketConstantSpeed + (yPos - yCameraPos) * spinPacketVariableSpeed / 1000;

			if (yCameraPos > yPos) {
				yCameraPos = yPos;
			}
		}

		if (yCameraPos > yPos) {
			yCameraPos -= spinPacketConstantSpeed + (yCameraPos - yPos) * spinPacketVariableSpeed / 1000;

			if (yCameraPos < yPos) {
				yCameraPos = yPos;
			}
		}

		xPos = moveCameraX * 128 + 64;
		yPos = moveCameraY * 128 + 64;
		zPos = method42(plane, yPos, xPos) - moveCameraZ;
		int l = xPos - xCameraPos;
		int i1 = zPos - zCameraPos;
		int j1 = yPos - yCameraPos;
		int k1 = (int) Math.sqrt(l * l + j1 * j1);
		int l1 = (int) (Math.atan2(i1, k1) * 325.94900000000001D) & 0x7ff;
		int i2 = (int) (Math.atan2(l, j1) * -325.94900000000001D) & 0x7ff;

		if (l1 < cameraAngleLimit) {
			l1 = cameraAngleLimit;
		}

		if (l1 > 383) {
			l1 = 383;
		}

		if (yCameraCurve < l1) {
			yCameraCurve += moveCameraSpeed + (l1 - yCameraCurve) * moveCameraAngle / 1000;

			if (yCameraCurve > l1) {
				yCameraCurve = l1;
			}
		}

		if (yCameraCurve > l1) {
			yCameraCurve -= moveCameraSpeed + (yCameraCurve - l1) * moveCameraAngle / 1000;

			if (yCameraCurve < l1) {
				yCameraCurve = l1;
			}
		}

		int j2 = i2 - xCameraCurve;

		if (j2 > 1024) {
			j2 -= 2048;
		}

		if (j2 < -1024) {
			j2 += 2048;
		}

		if (j2 > 0) {
			xCameraCurve += moveCameraSpeed + j2 * moveCameraAngle / 1000;
			xCameraCurve &= 0x7ff;
		}

		if (j2 < 0) {
			xCameraCurve -= moveCameraSpeed + -j2 * moveCameraAngle / 1000;
			xCameraCurve &= 0x7ff;
		}

		int k2 = i2 - xCameraCurve;

		if (k2 > 1024) {
			k2 -= 2048;
		}

		if (k2 < -1024) {
			k2 += 2048;
		}

		if (k2 < 0 && j2 > 0 || k2 > 0 && j2 < 0) {
			xCameraCurve = i2;
		}
	}

	private void calcEntityScreenPos(int i, int j, int l) {
		if (i < 128 || l < 128 || i > 13056 || l > 13056) {
			spriteDrawX = -1;
			spriteDrawY = -1;
			return;
		}

		int i1 = method42(plane, l, i) - j;
		i -= xCameraPos;
		i1 -= zCameraPos;
		l -= yCameraPos;
		int j1 = Model.modelIntArray1[yCameraCurve];
		int k1 = Model.modelIntArray2[yCameraCurve];
		int l1 = Model.modelIntArray1[xCameraCurve];
		int i2 = Model.modelIntArray2[xCameraCurve];
		int j2 = l * l1 + i * i2 >> 16;
		l = l * i2 - i * l1 >> 16;
		i = j2;
		j2 = i1 * k1 - l * j1 >> 16;
		l = i1 * j1 + l * k1 >> 16;
		i1 = j2;

		if (l >= 50) {
			spriteDrawX = Rasterizer.centerX + (i << log_view_dist) / l;
			spriteDrawY = Rasterizer.centerY + (i1 << log_view_dist) / l;
		} else {
			spriteDrawX = -1;
			spriteDrawY = -1;
		}
	}

	private void chatJoin(long l) {
		try {
			if (l == 0L) {
				return;
			}

			getOut().putOpcode(60);
			getOut().putLong(l);
			return;
		} catch (RuntimeException runtimeexception) {
			Signlink.reportError("47229, " + 3 + ", " + l + ", " + runtimeexception.toString());
		}

		throw new RuntimeException();
	}

	private void checkSize() {
		int width = getScreenWidth();
		int height = getScreenHeight();
		if (GameFrame.getScreenMode() == ScreenMode.RESIZABLE) {
			if (!isApplet) {
				if (clientWidth != width && width >= 782) {
					setResizing(true);
					clientWidth = width;
					super.myWidth = clientWidth;
					updateScreen();
					setResizing(false);
				}
				if (clientHeight != height && height >= 555) {
					setResizing(true);
					clientHeight = height;
					super.myHeight = clientHeight;
					updateScreen();
					setResizing(false);
				}
			} else {
				if (clientWidth != width && width >= 782) {
					setResizing(true);
					clientWidth = super.getWidth();
					super.myWidth = clientWidth;
					updateScreen();
					setResizing(false);
				}
				if (clientHeight != height && height >= 555) {
					setResizing(true);
					clientHeight = super.getHeight();
					super.myHeight = clientHeight;
					updateScreen();
					setResizing(false);
				}
			}
		}
	}

	@Override
	public void cleanUpForQuit() {
		Signlink.reporterror = false;

		try {
			if (getConnection() != null) {
				getConnection().close();
			}
		} catch (Exception _ex) {
		}

		cacheSprite = null;
		setConnection(null);
		stopMidi();

		if (mouseDetection != null) {
			mouseDetection.running = false;
		}

		mouseDetection = null;

		if (onDemandFetcher != null) {
			onDemandFetcher.dispose();
		}

		onDemandFetcher = null;
		aStream_834 = null;
		setOut(null);
		setLoginBuffer(null);
		setInputBuffer(null);
		anIntArray1234 = null;
		aByteArrayArray1183 = null;
		aByteArrayArray1247 = null;
		floorMap = null;
		objectMap = null;
		intGroundArray = null;
		byteGroundArray = null;
		worldController = null;
		aClass11Array1230 = null;
		anIntArrayArray901 = null;
		anIntArrayArray825 = null;
		bigX = null;
		bigY = null;
		aByteArray912 = null;
		tabAreaIP = null;
		leftFrame = null;
		topFrame = null;
		rightFrame = null;
		mapAreaIP = null;
		gameScreenIP = null;
		chatAreaIP = null;
		aRSImageProducer_1125 = null;
		mapBack = null;
		sideIcons = null;
		compass = null;
		hitMarks = null;
		headIcons = null;
		skullIcons = null;
		headIconsHint = null;
		crosses = null;
		mapDotItem = null;
		mapDotNPC = null;
		mapDotPlayer = null;
		mapDotFriend = null;
		mapDotTeam = null;
		mapDotClan = null;
		mapScenes = null;
		mapFunctions = null;
		anIntArrayArray929 = null;
		playerArray = null;
		playerIndices = null;
		anIntArray894 = null;
		setaStreamArray895s(null);
		anIntArray840 = null;
		npcArray = null;
		npcIndices = null;
		groundArray = null;
		setaClass19_1179(null);
		setaClass19_1013(null);
		setaClass19_1056(null);
		menuActionCmd2 = null;
		menuActionCmd3 = null;
		menuActionCmd4 = null;
		menuActionID = null;
		menuActionCmd1 = null;
		menuActionName = null;
		variousSettings = null;
		anIntArray1072 = null;
		anIntArray1073 = null;
		aClass30_Sub2_Sub1_Sub1Array1140 = null;
		miniMapRegions = null;
		friendsList = null;
		friendsListAsLongs = null;
		friendsNodeIDs = null;
		aRSImageProducer_1107 = null;
		titleScreenIP = null;
		multiOverlay = null;
		nullLoader();
		ObjectDefinition.nullify();
		MobDefinition.nullify();
		ItemDefinition.nullify();
		Flo.cache = null;
		IdentityKit.cache = null;
		RSInterface.interfaceCache = null;
		Animation.cache = null;
		SpotAnimDefinition.cache = null;
		SpotAnimDefinition.list = null;
		Varp.setCache(null);
		super.fullGameScreen = null;
		Player.mruNodes = null;
		Rasterizer.nullify();
		WorldController.nullify();
		Model.nullify();
		FrameReader.nullify();
		Texture.reset();
		System.gc();
	}

	public void closeGameInterfaces() {
		getOut().putOpcode(130);

		if (invOverlayInterfaceID != -1) {
			invOverlayInterfaceID = -1;
			dialogueOptionsShowing = false;
			tabAreaAltered = true;
		}

		if (backDialogID != -1) {
			backDialogID = -1;
			inputTaken = true;
			dialogueOptionsShowing = false;
		}

		openInterfaceID = -1;
		setFullscreenInterfaceID(-1);
	}

	private void compareCrcValues() {
		int secondsToWait = 5;
		expectedCRCs[8] = 0;
		int checksumCount = 0;

		while (expectedCRCs[8] == 0) {
			String error = "Unknown problem";
			drawSmoothLoading(20, "Connecting to web server");

			try {
				DataInputStream in = openJagGrabInputStream("crc" + (int) (Math.random() * 99999999D) + "-" + 317);
				ByteBuffer buffer = new ByteBuffer(new byte[40]);
				in.readFully(buffer.buffer, 0, 40);
				in.close();

				for (int index = 0; index < 9; index++) {
					expectedCRCs[index] = buffer.getIntLittleEndian();
				}

				int checksumValue = buffer.getIntLittleEndian();
				int expectedValue = 1234;

				for (int index = 0; index < 9; index++) {
					expectedValue = (expectedValue << 1) + expectedCRCs[index];
				}

				if (checksumValue != expectedValue) {
					error = "checksum problem";
					expectedCRCs[8] = 0;
				}
			} catch (EOFException _ex) {
				error = "EOF problem";
				expectedCRCs[8] = 0;
			} catch (IOException _ex) {
				error = "connection problem";
				expectedCRCs[8] = 0;
			} catch (Exception _ex) {
				error = "logic problem";
				expectedCRCs[8] = 0;

				if (!Signlink.reporterror) {
					return;
				}
			}

			if (expectedCRCs[8] == 0) {
				checksumCount++;

				for (int seconds = secondsToWait; seconds > 0; seconds--) {
					if (checksumCount >= 10) {
						drawSmoothLoading(10, "Game updated - please reload page");
						seconds = 10;
					} else {
						drawSmoothLoading(10, error + " - Will retry in " + seconds + " secs.");
					}

					try {
						Thread.sleep(1000L);
					} catch (Exception _ex) {
					}
				}

				secondsToWait *= 2;

				if (secondsToWait > 60) {
					secondsToWait = 60;
				}

				httpFallback = !httpFallback;
			}
		}
	}

	public Socket createFileServerSocket(int port) throws IOException {
		return new Socket(InetAddress.getByName(InetAddressUtils.toString(Constants.FILE_SERVER_ADDRESS)), port);
	}

	public Socket createGameServerSocket(int port) throws IOException {
		return new Socket(InetAddress.getByName(Constants.connectionStatus.getAddress()), port);
	}

	public void hitmarkDraw(Entity e, int hitLength, int markType, int icon, int damage, int move, int opacity) {
		hitLength *= 2;
		if (damage > 0) {
			if (icon > 0) {
				spriteDrawX += 10;
				Client.cacheSprite[icon + 552].drawTransparentSprite(spriteDrawX - 37, spriteDrawY - 14 + move, opacity);
			}
			markType -= 1;
			int beginning = 543 + markType * 3 + 1;
			Client.cacheSprite[beginning].drawTransparentSprite(spriteDrawX - 14, spriteDrawY - 12 + move, opacity);
			for (int i = 0; i < hitLength; i++) {
				Client.cacheSprite[beginning + 1].drawTransparentSprite(spriteDrawX - 10 + i * 4, spriteDrawY - 12 + move, opacity);
			}
			Client.cacheSprite[beginning + 2].drawTransparentSprite(spriteDrawX - 12 + hitLength * 4, spriteDrawY - 12 + move, opacity);

			if (hitLength == 6) {
				newRegularFont.drawCenteredString(String.valueOf(damage), spriteDrawX + 1, spriteDrawY + 3 + move, 0xffffff, 0x00000);
			} else if (hitLength == 4) {
				newRegularFont.drawCenteredString(String.valueOf(damage), spriteDrawX - 3, spriteDrawY + 3 + move, 0xffffff, 0x00000);
			} else {
				newRegularFont.drawCenteredString(String.valueOf(damage), spriteDrawX - 7, spriteDrawY + 3 + move, 0xffffff, 0x00000);
			}
		} else {
			Client.cacheSprite[543].drawTransparentSprite(spriteDrawX - 12, spriteDrawY - 14 + move, opacity);
		}
	}

	private void delFriend(long nameHash) {
		try {
			if (nameHash == 0L) {
				return;
			}

			for (int i = 0; i < friendCount; i++) {
				if (friendsListAsLongs[i] != nameHash) {
					continue;
				}

				friendCount--;

				for (int n = i; n < friendCount; n++) {
					friendsList[n] = friendsList[n + 1];
					friendsNodeIDs[n] = friendsNodeIDs[n + 1];
					friendsListAsLongs[n] = friendsListAsLongs[n + 1];
				}

				getOut().putOpcode(215);
				getOut().putLong(nameHash);
				break;
			}
		} catch (RuntimeException runtimeexception) {
			Signlink.reportError("18622, " + false + ", " + nameHash + ", " + runtimeexception.toString());
			throw new RuntimeException();
		}
	}

	private void delIgnore(long nameHash) {
		try {
			if (nameHash == 0L) {
				return;
			}

			for (int i = 0; i < ignoreCount; i++) {
				if (ignoreListAsLongs[i] == nameHash) {
					ignoreCount--;
					System.arraycopy(ignoreListAsLongs, i + 1, ignoreListAsLongs, i, ignoreCount - i);
					getOut().putOpcode(74);
					getOut().putLong(nameHash);
					return;
				}
			}

			return;
		} catch (RuntimeException runtimeexception) {
			Signlink.reportError("47229, " + 3 + ", " + nameHash + ", " + runtimeexception.toString());
		}

		throw new RuntimeException();
	}

	private void determineMenuSize() {
		int width = newBoldFont.getTextWidth("Choose Option");
		for (int index = 0; index < menuActionRow; index++) {
			int menuWidth = newBoldFont.getTextWidth(menuActionName[index]);
			if (menuPlayerName[index] != null) {
				menuWidth += newBoldFont.getTextWidth(menuPlayerName[index]);
			}
			if (menuActionTitle[index] != null) {
				menuWidth += newBoldFont.getTextWidth(menuActionTitle[index]);
			}
			if (menuWidth > width) {
				width = menuWidth;
			}
		}
		width += 8;
		int menHeight = 15 * menuActionRow + 21;
		if (GameFrame.getScreenMode() == ScreenMode.FIXED) {
			if (super.saveClickX > 4 && super.saveClickY > 4 && super.saveClickX < 516 && super.saveClickY < 338) {
				int offsetX = super.saveClickX - 4 - width / 2;
				if (offsetX + width > 512) {
					offsetX = 512 - width;
				}
				if (offsetX < 0) {
					offsetX = 0;
				}
				int offsetY = super.saveClickY - 4;
				if (offsetY + menHeight > 334) {
					offsetY = 334 - menHeight;
				}
				if (offsetY < 0) {
					offsetY = 0;
				}
				menuOpen = true;
				menuScreenArea = 0;
				menuOffsetX = offsetX;
				menuOffsetY = offsetY;
				menuWidth = width;
				menuHeight = 15 * menuActionRow + 22;
			}
			if (super.saveClickX > 519 && super.saveClickY > 168 && super.saveClickX < 765 && super.saveClickY < 503) {
				int offsetX = super.saveClickX - 519 - width / 2;
				if (offsetX < 0) {
					offsetX = 0;
				} else if (offsetX + width > 245) {
					offsetX = 245 - width;
				}
				int offsetY = super.saveClickY - 168;
				if (offsetY < 0) {
					offsetY = 0;
				} else if (offsetY + menHeight > 333) {
					offsetY = 333 - menHeight;
				}
				menuOpen = true;
				menuScreenArea = 1;
				menuOffsetX = offsetX;
				menuOffsetY = offsetY;
				menuWidth = width;
				menuHeight = 15 * menuActionRow + 22;
			}
			if (super.saveClickX > 0 && super.saveClickY > 338 && super.saveClickX < 516 && super.saveClickY < 503) {
				int offsetX = super.saveClickX - 0 - width / 2;
				if (offsetX < 0) {
					offsetX = 0;
				} else if (offsetX + width > 516) {
					offsetX = 516 - width;
				}
				int offsetY = super.saveClickY - 338;
				if (offsetY < 0) {
					offsetY = 0;
				} else if (offsetY + menHeight > 165) {
					offsetY = 165 - menHeight;
				}
				menuOpen = true;
				menuScreenArea = 2;
				menuOffsetX = offsetX;
				menuOffsetY = offsetY;
				menuWidth = width;
				menuHeight = 15 * menuActionRow + 22;
			}
			// if(super.saveClickX > 0 && super.saveClickY > 338 &&
			// super.saveClickX < 516 && super.saveClickY < 503) {
			if (super.saveClickX > 519 && super.saveClickY > 0 && super.saveClickX < 765 && super.saveClickY < 168) {
				int offsetX = super.saveClickX - 519 - width / 2;
				if (offsetX < 0) {
					offsetX = 0;
				} else if (offsetX + width > 245) {
					offsetX = 245 - width;
				}
				int offsetY = super.saveClickY - 0;
				if (offsetY < 0) {
					offsetY = 0;
				} else if (offsetY + menHeight > 168) {
					offsetY = 168 - menHeight;
				}
				menuOpen = true;
				menuScreenArea = 3;
				menuOffsetX = offsetX;
				menuOffsetY = offsetY;
				menuWidth = width;
				menuHeight = 15 * menuActionRow + 22;
			}
		} else {
			if (super.saveClickX > 0 && super.saveClickY > 0 && super.saveClickX < getScreenWidth() && super.saveClickY < getScreenHeight()) {
				int offsetX = super.saveClickX - 0 - width / 2;
				if (offsetX + width > getScreenWidth()) {
					offsetX = getScreenWidth() - width;
				}
				if (offsetX < 0) {
					offsetX = 0;
				}
				int offsetY = super.saveClickY - 0;
				if (offsetY + menHeight > getScreenHeight()) {
					offsetY = getScreenHeight() - menHeight;
				}
				if (offsetY < 0) {
					offsetY = 0;
				}
				menuOpen = true;
				menuScreenArea = 0;
				menuOffsetX = offsetX;
				menuOffsetY = offsetY;
				menuWidth = width;
				menuHeight = 15 * menuActionRow + 22;
			}
		}
	}

	@SuppressWarnings("unused")
	private void doAction(int actionId) {
		if (actionId < 0) {
			return;
		}

		if (inputDialogState != 0) {
			inputDialogState = 0;
			inputTaken = true;
		}

		int firstMenuAction = menuActionCmd1[actionId];
		int secondMenuAction = menuActionCmd2[actionId];
		int thirdMenuAction = menuActionCmd3[actionId];
		int fourthMenuAction = menuActionCmd4[actionId];
		int action = menuActionID[actionId];
		int x = secondMenuAction;
		int y = thirdMenuAction;
		int id = firstMenuAction > 0x7fff ? fourthMenuAction : firstMenuAction >> 14 & 0x7fff;

		if (action >= 2000) {
			action -= 2000;
		}

		if (menuActionName[actionId].contains("Close")) {
			closeGameInterfaces();
		}

		if (action >= 1315 && action <= 1321) {
			getOut().putOpcode(200);
			getOut().putShortBigEndian(PlayerHandler.clanName.length() - 1);
			int k2 = getOut().position;
			getOut().putString(PlayerHandler.clanName);
			getOut().getByte(action - 1314);
			getOut().putVariableSizeByte(getOut().position - k2);
		}

		if (action == 712) {
			// Toggle
			Constants.MONEY_POUCH_ENABLED = !Constants.MONEY_POUCH_ENABLED;
		}
		if (action == 713) {
			inputTaken = true;
			messagePromptRaised = true;
			amountOrNameInput = "";
			inputString = "";
			inputDialogState = 0;
			interfaceButtonAction = 557;
			friendsListAction = 0;
			promptInput = "";
			promptMessage = "How much would you like to withdraw?";
		}
		if (action == 714) {
			inputTaken = true;
			messagePromptRaised = true;
			amountOrNameInput = "";
			inputDialogState = 0;
			interfaceButtonAction = 558;
			friendsListAction = 0;
			promptInput = "";
			promptMessage = "How much would you like to deposit?";
		}
		if (action == 715) {
			sendPacket(108);
		}

		switch (action) {
		case 1044:
			int currentPray;
			currentPray = Integer.parseInt(RSInterface.interfaceCache[4012].message);

			if (currentPray != 0) {
				getMapArea().prayer.setOrbState(!getMapArea().prayer.getOrbState());
			} else {
				getMapArea().prayer.setOrbState(false);
				pushMessage("You have run out of prayer points!", 0, "");
			}

			getOut().putOpcode(243);
			getOut().putShort(6000);
			break;

		case 1506: // Select quick prayers
			getOut().putOpcode(243);
			getOut().putShort(6001);
			break;

		case 1050:
			getMapArea().run.setOrbState(running);
			getOut().putOpcode(243);
			getOut().putShort(152);
		}

		if (action == 1014) {
			setNorth();
		}

		if (action == 10424) {
			getOut().putOpcode(243);
			getOut().putShort(12424);
		}

		if (action == 13004) {
			getOut().putOpcode(243);
			getOut().putShort(15005);
		}

		if (action == 13005) {
			getOut().putOpcode(243);
			getOut().putShort(15006);
		}

		if (action == 13006) {
			getOut().putOpcode(243);
			getOut().putShort(15007);
		}

		if (action == 13007) {
			getOut().putOpcode(243);
			getOut().putShort(15008);
		}

		if (action == 1506) {
			// Select quick prayers
			getOut().putOpcode(243);
			getOut().putShort(5001);
		}

		if (action == 1007) {
			PlayerHandler.canGainXP = PlayerHandler.canGainXP ? false : true;
		}

		if (action == 1006 && !PlayerHandler.showBonus) {
			if (!PlayerHandler.gains.isEmpty()) {
				PlayerHandler.gains.removeAll(PlayerHandler.gains);
			}

			PlayerHandler.showXP = PlayerHandler.showXP ? false : true;
		} else if (action == 1013) {
			sendCommandPacket("resetexperiencecounter");
		}

		if (action == 1030 && !PlayerHandler.showXP) {
			PlayerHandler.showBonus = PlayerHandler.showBonus ? false : true;
		}

		if (action == 104) {
			RSInterface class9_1 = RSInterface.interfaceCache[thirdMenuAction];
			spellID = class9_1.id;

			if (!autocast) {
				autocast = true;
				pushMessage("Autocast spell selected.", 0, "");
				autocastId = class9_1.id;
				getOut().putOpcode(243);
				getOut().putShort(class9_1.id);
			} else if (autocastId == class9_1.id) {
				autocast = false;
				autocastId = 0;
				pushMessage("Autocast spell cleared.", 0, "");
				getOut().putOpcode(243);
				getOut().putShort(6666); // reset server side
			} else if (autocastId != class9_1.id) {
				autocast = true;
				pushMessage("Autocast spell selected.", 0, "");
				autocastId = class9_1.id;
				getOut().putOpcode(243);
				getOut().putShort(class9_1.id);
			}
		}

		if (action == 582) {
			NPC npc = npcArray[firstMenuAction];

			if (npc != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, npc.smallY[0], myPlayer.smallX[0], false, npc.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				getOut().putOpcode(57);
				getOut().putShortSpecialA(anInt1285);
				getOut().putShortSpecialA(firstMenuAction);
				getOut().method431(anInt1283);
				getOut().putShortSpecialA(anInt1284);
			}
		}

		if (action == 234) {
			boolean flag1 = doWalkTo(2, 0, 0, 0, myPlayer.smallY[0], 0, 0, thirdMenuAction, myPlayer.smallX[0], false, x);

			if (!flag1) {
				flag1 = doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, thirdMenuAction, myPlayer.smallX[0], false, x);
			}

			crossX = super.saveClickX;
			crossY = super.saveClickY;
			crossType = 2;
			crossIndex = 0;
			getOut().putOpcode(223);
			getOut().method431(y + baseY);
			getOut().putShort(firstMenuAction);
			getOut().method431(x + baseX);
		}

		if (action == 62 && method66(firstMenuAction, y, x, id)) {
			getOut().putOpcode(192);
			getOut().putShort(anInt1284);
			getOut().method431(id);
			getOut().method433(y + baseY);
			getOut().method431(anInt1283);
			getOut().method433(x + baseX);
			getOut().putShort(anInt1285);
		}

		if (action == 511) {
			boolean flag2 = doWalkTo(2, 0, 0, 0, myPlayer.smallY[0], 0, 0, y, myPlayer.smallX[0], false, x);

			if (!flag2) {
				flag2 = doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, y, myPlayer.smallX[0], false, x);
			}

			crossX = super.saveClickX;
			crossY = super.saveClickY;
			crossType = 2;
			crossIndex = 0;
			getOut().putOpcode(109);
			getOut().method431(anInt1284);
			getOut().putShortSpecialA(anInt1285);
			getOut().putShort(firstMenuAction);
			getOut().putShortSpecialA(y + baseY);
			getOut().method433(anInt1283);
			getOut().putShort(x + baseX);
		}

		if (action == 74) {
			getOut().putOpcode(122);
			getOut().method433(y);
			getOut().putShortSpecialA(secondMenuAction);
			getOut().method431(firstMenuAction);
			atInventoryLoopCycle = 0;
			atInventoryInterface = y;
			atInventoryIndex = x;
			atInventoryInterfaceType = 2;

			if (RSInterface.interfaceCache[y].parentID == openInterfaceID) {
				atInventoryInterfaceType = 1;
			}

			if (RSInterface.interfaceCache[y].parentID == backDialogID) {
				atInventoryInterfaceType = 3;
			}
		}
		if (action == 315) {
			switch (thirdMenuAction) {
			case 24018: // fixed
				toggleSize(ScreenMode.FIXED);
				break;

			case 24021: // resizable
				toggleSize(ScreenMode.RESIZABLE);
				break;

			case 24024: // fullscreen
				toggleSize(ScreenMode.FULLSCREEN);
			}

			RSInterface class9 = RSInterface.interfaceCache[thirdMenuAction];
			boolean flag8 = true;

			if (class9.contentType > 0) {
				flag8 = promptUserForInput(class9);
			}

			if (flag8) {
				switch (thirdMenuAction) {
				case 21341:
					sendFrame248(21172, 3213);
					resetInterfaceSequence(21172);
					inputTaken = true;
					break;

				default:
					getOut().putOpcode(243);
					getOut().putShort(thirdMenuAction);
				}
			}
		}

		if (action == 561) {
			Player player = playerArray[firstMenuAction];

			if (player != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, player.smallY[0], myPlayer.smallX[0], false, player.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				setAnInt1188(getAnInt1188() + id);

				if (getAnInt1188() >= 90) {
					getOut().putOpcode(136);
					setAnInt1188(0);
				}

				getOut().putOpcode(158);
				getOut().putShort(firstMenuAction);
			}
		}

		if (action == 20) {
			NPC npc = npcArray[firstMenuAction];
			if (npc != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, npc.smallY[0], myPlayer.smallX[0], false, npc.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				getOut().putOpcode(102);
				getOut().method431(firstMenuAction);
			}
		}

		if (action == 779) {
			Player player = playerArray[firstMenuAction];

			if (player != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, player.smallY[0], myPlayer.smallX[0], false, player.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				getOut().putOpcode(153);
				getOut().method431(firstMenuAction);
			}
		}

		if (action == 516) {
			if (!menuOpen) {
				worldController.method312(super.saveClickY - 4, super.saveClickX - 4);
			} else {
				worldController.method312(thirdMenuAction - 4, secondMenuAction - 4);
			}
		}

		if (action == 1062) {
			setAnInt924(getAnInt924() + baseX);

			if (getAnInt924() >= 113) {
				getOut().putOpcode(183);
				getOut().putDWordBigEndian(0xe63271);
				setAnInt924(0);
			}

			method66(firstMenuAction, y, x, id);
			getOut().putOpcode(228);
			getOut().putShortSpecialA(id);
			getOut().putShortSpecialA(thirdMenuAction + baseY);
			getOut().putShort(secondMenuAction + baseX);
		}
		if (action == 679 && !dialogueOptionsShowing) {
			getOut().putOpcode(45);
			getOut().putShort(thirdMenuAction);
			dialogueOptionsShowing = true;
		}

		if (action == 431) {
			getOut().putOpcode(129);
			getOut().putShortSpecialA(secondMenuAction);
			getOut().putShort(thirdMenuAction);
			getOut().putShortSpecialA(firstMenuAction);
			atInventoryLoopCycle = 0;
			atInventoryInterface = thirdMenuAction;
			atInventoryIndex = secondMenuAction;
			atInventoryInterfaceType = 2;

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == openInterfaceID) {
				atInventoryInterfaceType = 1;
			}

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == backDialogID) {
				atInventoryInterfaceType = 3;
			}
		}

		if (action == 337 || action == 42 || action == 792 || action == 322) {
			String s = menuActionName[actionId];
			int k1 = s.indexOf("@whi@");

			if (k1 != -1) {
				long l3 = TextClass.longForName(NAME_PATTERN.matcher(s.substring(k1 + 5)).replaceAll(""));

				if (action == 337) {
					addFriend(l3);
				} else if (action == 42) {
					addIgnore(l3);
				} else if (action == 792) {
					delFriend(l3);
				} else if (action == 322) {
					delIgnore(l3);
				}
			}
		}

		if (action == 53) {
			getOut().putOpcode(135);
			getOut().putShortSpecialA(thirdMenuAction);
			getOut().method431(secondMenuAction);
			getOut().method431(firstMenuAction);
			atInventoryLoopCycle = 0;
			atInventoryInterface = thirdMenuAction;
			atInventoryIndex = secondMenuAction;
			atInventoryInterfaceType = 2;

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == openInterfaceID) {
				atInventoryInterfaceType = 1;
			}
			if (RSInterface.interfaceCache[thirdMenuAction].parentID == backDialogID) {
				atInventoryInterfaceType = 3;
			}
		}

		if (action == 539) {
			getOut().putOpcode(16);
			getOut().putShortSpecialA(firstMenuAction);
			getOut().method433(secondMenuAction);
			getOut().method433(thirdMenuAction);
			atInventoryLoopCycle = 0;
			atInventoryInterface = thirdMenuAction;
			atInventoryIndex = secondMenuAction;
			atInventoryInterfaceType = 2;

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == openInterfaceID) {
				atInventoryInterfaceType = 1;
			}

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == backDialogID) {
				atInventoryInterfaceType = 3;
			}
		}

		if (action == 484 || action == 6 || action == 17) {
			String name = menuActionName[actionId];
			int l1 = name.indexOf("@whi@");

			if (l1 != -1) {
				name = name.substring(l1 + 5).trim();
				String username = TextClass.fixName(TextClass.nameForLong(TextClass.longForName(name)));
				boolean sent = false;

				for (int index = 0; index < playerCount; index++) {
					Player player = playerArray[playerIndices[index]];

					if (player == null || player.name == null || !player.name.equalsIgnoreCase(username)) {
						continue;
					}

					doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, player.smallY[0], myPlayer.smallX[0], false, player.smallX[0]);

					if (action == 484) {
						getOut().putOpcode(140);
						getOut().method431(playerIndices[index]);
					}

					if (action == 6) {
						setAnInt1188(getAnInt1188() + firstMenuAction);

						if (getAnInt1188() >= 90) {
							getOut().putOpcode(136);
							setAnInt1188(0);
						}

						getOut().putOpcode(158);
						getOut().putShort(playerIndices[index]);
					}
					if (action == 17) {
						getOut().putOpcode(159);
						getOut().putShort(playerIndices[index]);
					}

					sent = true;
					break;
				}

				if (!sent) {
					pushMessage("Unable to find " + username, 0, "");
				}
			}
		}

		if (action == 870) {
			getOut().putOpcode(53);
			getOut().putShort(secondMenuAction);
			getOut().putShortSpecialA(anInt1283);
			getOut().method433(firstMenuAction);
			getOut().putShort(anInt1284);
			getOut().method431(anInt1285);
			getOut().putShort(thirdMenuAction);
			atInventoryLoopCycle = 0;
			atInventoryInterface = thirdMenuAction;
			atInventoryIndex = secondMenuAction;
			atInventoryInterfaceType = 2;

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == openInterfaceID) {
				atInventoryInterfaceType = 1;
			}

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == backDialogID) {
				atInventoryInterfaceType = 3;
			}
		}

		if (action == 847) {
			getOut().putOpcode(71);
			getOut().putShort(thirdMenuAction);
			getOut().putShortSpecialA(secondMenuAction);
			getOut().putShortSpecialA(firstMenuAction);
			atInventoryLoopCycle = 0;
			atInventoryInterface = thirdMenuAction;
			atInventoryIndex = secondMenuAction;
			atInventoryInterfaceType = 2;

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == openInterfaceID) {
				atInventoryInterfaceType = 1;
			}

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == backDialogID) {
				atInventoryInterfaceType = 3;
			}
		}

		if (action == 626) {
			RSInterface class9_1 = RSInterface.interfaceCache[thirdMenuAction];
			spellSelected = 1;
			spellID = class9_1.id;
			anInt1137 = thirdMenuAction;
			spellUsableOn = class9_1.spellUsableOn;
			itemSelected = 0;
			String s4 = class9_1.selectedActionName;

			if (s4.indexOf(" ") != -1) {
				s4 = s4.substring(0, s4.indexOf(" "));
			}

			String s8 = class9_1.selectedActionName;

			if (s8.indexOf(" ") != -1) {
				s8 = s8.substring(s8.indexOf(" ") + 1);
			}

			spellTooltip = s4 + " " + class9_1.spellName + " " + s8;
			// class9_1.sprite1.drawSprite(class9_1.anInt263, class9_1.anInt265,
			// 0xffffff);
			// class9_1.sprite1.drawSprite(200,200);
			// System.out.println("Sprite: " + class9_1.sprite1.toString());

			if (spellUsableOn == 16) {
				tabID = 3;
				tabAreaAltered = true;
			}

			return;
		}

		if (action == 78) {
			getOut().putOpcode(117);
			getOut().method433(thirdMenuAction);
			getOut().method431(secondMenuAction);
			getOut().method433(firstMenuAction);
			atInventoryLoopCycle = 0;
			atInventoryInterface = thirdMenuAction;
			atInventoryIndex = secondMenuAction;
			atInventoryInterfaceType = 2;

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == openInterfaceID) {
				atInventoryInterfaceType = 1;
			}

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == backDialogID) {
				atInventoryInterfaceType = 3;
			}
		}

		// XXX
		if (action == 291) {
			getOut().putOpcode(145);
			getOut().putShortSpecialA(thirdMenuAction);
			getOut().putShortSpecialA(secondMenuAction);
			getOut().putShortSpecialA(firstMenuAction);
		}

		if (action == 27) {
			Player class30_sub2_sub4_sub1_sub2_2 = playerArray[firstMenuAction];

			if (class30_sub2_sub4_sub1_sub2_2 != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, class30_sub2_sub4_sub1_sub2_2.smallY[0], myPlayer.smallX[0], false, class30_sub2_sub4_sub1_sub2_2.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				setAnInt986(getAnInt986() + firstMenuAction);

				if (getAnInt986() >= 54) {
					getOut().putOpcode(189);
					getOut().putShortBigEndian(234);
					setAnInt986(0);
				}

				getOut().putOpcode(73);
				getOut().method431(firstMenuAction);
			}
		}

		if (action == 213) {
			boolean flag3 = doWalkTo(2, 0, 0, 0, myPlayer.smallY[0], 0, 0, thirdMenuAction, myPlayer.smallX[0], false, secondMenuAction);

			if (!flag3) {
				flag3 = doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, thirdMenuAction, myPlayer.smallX[0], false, secondMenuAction);
			}

			crossX = super.saveClickX;
			crossY = super.saveClickY;
			crossType = 2;
			crossIndex = 0;
			getOut().putOpcode(79);
			getOut().method431(thirdMenuAction + baseY);
			getOut().putShort(firstMenuAction);
			getOut().putShortSpecialA(secondMenuAction + baseX);
		}

		if (action == 632) {
			getOut().putOpcode(149);
			getOut().putShortSpecialA(thirdMenuAction);
			getOut().putShortSpecialA(secondMenuAction);
			getOut().putShortSpecialA(firstMenuAction);
			atInventoryLoopCycle = 0;
			atInventoryInterface = thirdMenuAction;
			atInventoryIndex = secondMenuAction;
			atInventoryInterfaceType = 2;

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == openInterfaceID) {
				atInventoryInterfaceType = 1;
			}

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == backDialogID) {
				atInventoryInterfaceType = 3;
			}
		}

		if (action == 1004) {
			if (tabInterfaceIDs[10] != -1) {
				tabID = 10;
				tabAreaAltered = true;
			}
		}

		if (action == 1003) {
			inputTaken = true;
		}

		if (action == 1002) {
			inputTaken = true;
		}

		if (action == 1001) {
			inputTaken = true;
		}

		if (action == 1000) {
			chatArea.toggleButton(this, 4);
			cButtonCPos = 4;
			chatTypeView = 11;
			inputTaken = true;
		}

		if (action == 999) {
			chatArea.toggleButton(this, 0);
			cButtonCPos = 0;
			chatTypeView = 0;
			inputTaken = true;
		}

		if (action == 998) {
			chatArea.toggleButton(this, 1);
			cButtonCPos = 1;
			chatTypeView = 5;
			inputTaken = true;
		}

		if (action == 997) {
			publicChatMode = 3;
			inputTaken = true;
		}

		if (action == 996) {
			publicChatMode = 2;
			inputTaken = true;
		}

		if (action == 995) {
			publicChatMode = 1;
			inputTaken = true;
		}

		if (action == 994) {
			publicChatMode = 0;
			inputTaken = true;
		}

		if (action == 993) {
			chatArea.toggleButton(this, 2);
			cButtonCPos = 2;
			chatTypeView = 1;
			inputTaken = true;
		}

		if (action == 992) {
			privateChatMode = 2;
			inputTaken = true;
			privateChatMode = 2;
			getOut().putOpcode(95);
			getOut().putShortBigEndian(publicChatMode);
			getOut().putShortBigEndian(privateChatMode);
			getOut().putShortBigEndian(tradeMode);
		}

		if (action == 991) {
			privateChatMode = 1;
			inputTaken = true;
			getOut().putOpcode(95);
			getOut().putShortBigEndian(publicChatMode);
			getOut().putShortBigEndian(privateChatMode);
			getOut().putShortBigEndian(tradeMode);
		}

		if (action == 990) {
			privateChatMode = 0;
			inputTaken = true;
			getOut().putOpcode(95);
			getOut().putShortBigEndian(publicChatMode);
			getOut().putShortBigEndian(privateChatMode);
			getOut().putShortBigEndian(tradeMode);
		}

		if (action == 989) {
			chatArea.toggleButton(this, 3);
			cButtonCPos = 3;
			chatTypeView = 2;
			inputTaken = true;
			getOut().putOpcode(95);
			getOut().putShortBigEndian(publicChatMode);
			getOut().putShortBigEndian(privateChatMode);
			getOut().putShortBigEndian(tradeMode);
		}

		if (action == 987) {
			tradeMode = 2;
			inputTaken = true;
		}

		if (action == 986) {
			tradeMode = 1;
			inputTaken = true;
		}

		if (action == 985) {
			tradeMode = 0;
			inputTaken = true;
		}

		if (action == 984) {
			chatArea.toggleButton(this, 5);
			cButtonCPos = 5;
			chatTypeView = 3;
			inputTaken = true;
		}

		if (action == 983) {
			duelStatus = 2;
		}
		if (action == 982) {
			duelStatus = 1;
		}
		if (action == 981) {
			duelStatus = 0;
		}

		if (action == 980) {
			chatArea.toggleButton(this, 6);
			cButtonCPos = 6;
			chatTypeView = 14;
			inputTaken = true;
		}

		if (action == 983) {
			inputTaken = true;
		}

		if (action == 982) {
			inputTaken = true;
		}

		if (action == 981) {
			inputTaken = true;
		}

		if (action == 980) {
			chatArea.toggleButton(this, 6);
			cButtonCPos = 6;
			chatTypeView = 4;
			inputTaken = true;
		}

		if (action == 493) {
			if (firstMenuAction == 995) {
				inputTaken = true;
				messagePromptRaised = true;
				amountOrNameInput = "";
				inputDialogState = 0;
				interfaceButtonAction = 558;
				friendsListAction = 0;
				promptInput = "";
				promptMessage = "How much would you like to deposit?";
			} else {
			}

			getOut().putOpcode(75);
			getOut().method433(thirdMenuAction);
			getOut().method431(secondMenuAction);
			getOut().putShortSpecialA(firstMenuAction);
			atInventoryLoopCycle = 0;
			atInventoryInterface = thirdMenuAction;
			atInventoryIndex = secondMenuAction;
			atInventoryInterfaceType = 2;

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == openInterfaceID) {
				atInventoryInterfaceType = 1;
			}

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == backDialogID) {
				atInventoryInterfaceType = 3;
			}
		}

		if (action == 652) {
			boolean flag4 = doWalkTo(2, 0, 0, 0, myPlayer.smallY[0], 0, 0, thirdMenuAction, myPlayer.smallX[0], false, secondMenuAction);

			if (!flag4) {
				flag4 = doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, thirdMenuAction, myPlayer.smallX[0], false, secondMenuAction);
			}

			crossX = super.saveClickX;
			crossY = super.saveClickY;
			crossType = 2;
			crossIndex = 0;
			getOut().putOpcode(156);
			getOut().putShortSpecialA(secondMenuAction + baseX);
			getOut().method431(thirdMenuAction + baseY);
			getOut().method433(firstMenuAction);
		}

		if (action == 94) {
			boolean flag5 = doWalkTo(2, 0, 0, 0, myPlayer.smallY[0], 0, 0, thirdMenuAction, myPlayer.smallX[0], false, secondMenuAction);

			if (!flag5) {
				flag5 = doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, thirdMenuAction, myPlayer.smallX[0], false, secondMenuAction);
			}

			crossX = super.saveClickX;
			crossY = super.saveClickY;
			crossType = 2;
			crossIndex = 0;
			getOut().putOpcode(181);
			getOut().method431(thirdMenuAction + baseY);
			getOut().putShort(firstMenuAction);
			getOut().method431(secondMenuAction + baseX);
			getOut().putShortSpecialA(anInt1137);
		}

		if (action == 646) {
			getOut().putOpcode(243);
			getOut().putShort(thirdMenuAction);
			RSInterface class9_2 = RSInterface.interfaceCache[thirdMenuAction];

			if (class9_2.valueIndexArray != null && class9_2.valueIndexArray[0][0] == 5) {
				int i2 = class9_2.valueIndexArray[0][1];

				if (variousSettings[i2] != class9_2.requiredValues[0]) {
					variousSettings[i2] = class9_2.requiredValues[0];
					updateConfig(i2);
				}

				switch (thirdMenuAction) {
				case 25841:// More options
					i2 = openInterfaceID == 24000 ? 0 : 1;
					sendFrame36(175, i2);

					if (i2 == 1) {
						openInterfaceID = 24000;
					} else {
						openInterfaceID = -1;
					}

					break;
				}
			}
		}

		if (action == 225) {
			NPC npc = npcArray[firstMenuAction];

			if (npc != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, npc.smallY[0], myPlayer.smallX[0], false, npc.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				setAnInt1226(getAnInt1226() + firstMenuAction);

				if (getAnInt1226() >= 85) {
					getOut().putOpcode(230);
					getOut().putShortBigEndian(239);
					setAnInt1226(0);
				}

				getOut().putOpcode(6);
				getOut().method433(firstMenuAction);
			}
		}

		if (action == 965) {
			NPC npc = npcArray[firstMenuAction];

			if (npc != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, npc.smallY[0], myPlayer.smallX[0], false, npc.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				setAnInt1134(getAnInt1134() + 1);

				if (getAnInt1134() >= 96) {
					getOut().putOpcode(152);
					getOut().putShortBigEndian(88);
					setAnInt1134(0);
				}

				getOut().putOpcode(7);
				getOut().putShort(firstMenuAction);
			}
		}

		if (action == 413) {
			NPC npc = npcArray[firstMenuAction];

			if (npc != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, npc.smallY[0], myPlayer.smallX[0], false, npc.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				getOut().putOpcode(186);
				getOut().method433(firstMenuAction);
				getOut().putShortSpecialA(anInt1137);
			}
		}

		if (action == 200) {
			closeGameInterfaces();
		}

		if (action == 1025) {
			NPC npc = npcArray[firstMenuAction];

			if (npc != null) {
				MobDefinition definition = npc.definitionOverride;

				if (definition.childrenIDs != null) {
					definition = definition.method161();
				}

				if (definition != null) {
					String examine;

					if (definition.description != null) {
						examine = new String(definition.description);
					} else {
						examine = "It's a " + definition.name + ".";
					}

					pushMessage(examine, 0, "");
				}
			}
		}

		if (action == 900) {
			method66(firstMenuAction, y, x, id);
			getOut().putOpcode(247);
			getOut().method433(id);
			getOut().method431(y + baseY);
			getOut().putShortSpecialA(x + baseX);
		}

		if (action == 412) {
			NPC npc = npcArray[firstMenuAction];

			if (npc != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, npc.smallY[0], myPlayer.smallX[0], false, npc.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				getOut().putOpcode(89);
				getOut().putShortSpecialA(firstMenuAction);
			}
		}

		if (action == 365) {
			Player player = playerArray[firstMenuAction];

			if (player != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, player.smallY[0], myPlayer.smallX[0], false, player.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				getOut().putOpcode(249);
				getOut().putShortSpecialA(firstMenuAction);
				getOut().method431(anInt1137);
			}
		}

		if (action == 729) {
			Player player = playerArray[firstMenuAction];

			if (player != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, player.smallY[0], myPlayer.smallX[0], false, player.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				getOut().putOpcode(40);
				getOut().method431(firstMenuAction);
			}
		}

		if (action == 577) {
			Player player = playerArray[firstMenuAction];

			if (player != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, player.smallY[0], myPlayer.smallX[0], false, player.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				getOut().putOpcode(140);
				getOut().method431(firstMenuAction);
			}
		}

		if (action == 956 && method66(firstMenuAction, y, x, id)) {
			getOut().putOpcode(35);
			getOut().method431(secondMenuAction + baseX);
			getOut().putShortSpecialA(anInt1137);
			getOut().putShortSpecialA(thirdMenuAction + baseY);
			getOut().method431(id);
		}

		if (action == 567) {
			boolean flag6 = doWalkTo(2, 0, 0, 0, myPlayer.smallY[0], 0, 0, thirdMenuAction, myPlayer.smallX[0], false, secondMenuAction);

			if (!flag6) {
				flag6 = doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, thirdMenuAction, myPlayer.smallX[0], false, secondMenuAction);
			}

			crossX = super.saveClickX;
			crossY = super.saveClickY;
			crossType = 2;
			crossIndex = 0;
			getOut().putOpcode(23);
			getOut().method431(thirdMenuAction + baseY);
			getOut().method431(firstMenuAction);
			getOut().method431(secondMenuAction + baseX);
		}

		if (action == 867) {
			if ((id & 3) == 0) {
				setAnInt1175(getAnInt1175() + 1);
			}

			if (getAnInt1175() >= 59) {
				getOut().putOpcode(200);
				getOut().putShort(25501);
				setAnInt1175(0);
			}

			getOut().putOpcode(43);
			getOut().putShortSpecialA(secondMenuAction);
			getOut().method431(thirdMenuAction);
			getOut().putShortSpecialA(firstMenuAction);
			atInventoryLoopCycle = 0;
			atInventoryInterface = thirdMenuAction;
			atInventoryIndex = secondMenuAction;
			atInventoryInterfaceType = 2;

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == openInterfaceID) {
				atInventoryInterfaceType = 1;
			}

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == backDialogID) {
				atInventoryInterfaceType = 3;
			}
		}

		if (action == 543) {
			getOut().putOpcode(237);
			getOut().putShort(secondMenuAction);
			getOut().putShortSpecialA(firstMenuAction);
			getOut().putShort(thirdMenuAction);
			getOut().putShortSpecialA(anInt1137);
			atInventoryLoopCycle = 0;
			atInventoryInterface = thirdMenuAction;
			atInventoryIndex = secondMenuAction;
			atInventoryInterfaceType = 2;

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == openInterfaceID) {
				atInventoryInterfaceType = 1;
			}

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == backDialogID) {
				atInventoryInterfaceType = 3;
			}
		}

		if (action == 491) {
			Player player = playerArray[firstMenuAction];

			if (player != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, player.smallY[0], myPlayer.smallX[0], false, player.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;
				getOut().putOpcode(14);
				getOut().putShortSpecialA(anInt1284);
				getOut().putShort(firstMenuAction);
				getOut().putShort(anInt1285);
				getOut().method431(anInt1283);
			}
		}

		if (action == 639) {
			String actionName = menuActionName[actionId];
			int spot = actionName.indexOf("@whi@");

			if (spot != -1) {
				String username = actionName.substring(spot + 5).trim();
				long usernameHash = TextClass.longForName(username);
				int friendIndex = -1;

				for (int i4 = 0; i4 < friendCount; i4++) {
					if (friendsListAsLongs[i4] != usernameHash) {
						continue;
					}
					friendIndex = i4;
					break;
				}

				// if (friendIndex != -1 && friendsNodeIDs[friendIndex] > 0) {
				inputTaken = true;
				inputDialogState = 0;
				messagePromptRaised = true;
				promptInput = "";
				friendsListAction = 3;
				aLong953 = usernameHash;
				promptMessage = "Enter message to send to " + username;
				// aLong953 = friendsListAsLongs[friendIndex];
				// promptMessage = "Enter message to send to " +
				// friendsList[friendIndex];
				// }
			}
		}

		if (action == 454) {
			getOut().putOpcode(42);
			getOut().putShort(firstMenuAction);
			getOut().putShortSpecialA(secondMenuAction);
			getOut().putShortSpecialA(thirdMenuAction);
			atInventoryLoopCycle = 0;
			atInventoryInterface = thirdMenuAction;
			atInventoryIndex = secondMenuAction;
			atInventoryInterfaceType = 2;

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == openInterfaceID) {
				atInventoryInterfaceType = 1;
			}

			if (RSInterface.interfaceCache[thirdMenuAction].parentID == backDialogID) {
				atInventoryInterfaceType = 3;
			}
		}

		if (action == 478) {
			NPC npc = npcArray[firstMenuAction];

			if (npc != null) {
				doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, npc.smallY[0], myPlayer.smallX[0], false, npc.smallX[0]);
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 2;
				crossIndex = 0;

				if ((id & 3) == 0) {
					setAnInt1155(getAnInt1155() + 1);
				}

				if (getAnInt1155() >= 53) {
					getOut().putOpcode(85);
					getOut().putShortBigEndian(66);
					setAnInt1155(0);
				}

				getOut().putOpcode(18);
				getOut().method431(firstMenuAction);
			}
		}

		if (action == 113) {
			method66(firstMenuAction, y, x, id);
			getOut().putOpcode(25);
			getOut().method431(secondMenuAction + baseX);
			getOut().putShort(thirdMenuAction + baseY);
			getOut().method433(id);
		}

		if (action == 872) {
			method66(firstMenuAction, y, x, id);
			getOut().putOpcode(234);
			getOut().method433(secondMenuAction + baseX);
			getOut().putShortSpecialA(id);
			getOut().method433(thirdMenuAction + baseY);
		}

		if (action == 502) {
			method66(firstMenuAction, y, x, id);
			getOut().putOpcode(138);
			getOut().method433(secondMenuAction + baseX);
			getOut().putShortSpecialA(thirdMenuAction + baseY);
			getOut().putShort(id);
		}

		if (action == 1125) {
			ItemDefinition definition = ItemDefinition.get(firstMenuAction);
			RSInterface rsinterface = RSInterface.interfaceCache[thirdMenuAction];
			String examine;

			if (rsinterface != null && rsinterface.invStackSizes[secondMenuAction] >= 0x186a0) {
				examine = NumberFormat.getInstance(Locale.US).format(rsinterface.invStackSizes[secondMenuAction]) + " x " + definition.name;
			} else if (definition.description != null) {
				examine = new String(definition.description);
			} else {
				examine = "It's a " + definition.name + ".";
			}

			pushMessage(examine, 0, "");
		}
		if (action == 169) {
			switch (thirdMenuAction) {
			case 24107:
				getConfig().toggle(ConfigType.HP_ABOVE_HEAD);
				savePlayerData();
				break;
			case 24103:
				getConfig().toggle(ConfigType.NAMES_ABOVE_HEAD);
				savePlayerData();
				break;
			case 24131:
				getConfig().toggle(ConfigType.NEW_CURSORS);
				savePlayerData();
				break;
			case 24099:
				GameFrameConstants.gameframeType = GameFrameConstants.gameframeType == GameFrameType.FRAME_525 ? GameFrameType.FRAME_554 : GameFrameType.FRAME_525;
				savePlayerData();
				break;
			case 24139:
				getConfig().toggle(ConfigType.TOGGLE_FOV);
				savePlayerData();
				break;
			case 24115:
				getConfig().toggle(ConfigType.HITMARKS);
				savePlayerData();
				break;
			case 24119:// Toggle function keys
				getConfig().toggle(ConfigType.FUNCTION_KEYS);
				savePlayerData();
				break;

			case 24127:
				getConfig().toggle(ConfigType.FOG);
				savePlayerData();
				break;

			case 24111:// Toggle halth bars
				getConfig().toggle(ConfigType.NEW_HITBARS);
				savePlayerData();
				break;

			case 24123:// Toggle x10 damage
				getConfig().toggle(ConfigType.X10_DAMAGE);
				savePlayerData();
				break;
			case 24135:
				getConfig().toggle(ConfigType.TOGGLE_ROOFS);
				method22();
				savePlayerData();
				break;
			case 24143:
				getConfig().toggle(ConfigType.PUSH_NOTIFICATIONS);
				pushMessage("Push notifications turned " + (getConfig().getStatus(ConfigType.PUSH_NOTIFICATIONS) ? "on" : "off") + ".", 0, "");
				savePlayerData();
				break;
			case 24147:
				getConfig().toggle(ConfigType.HD_TEXTURES);
				savePlayerData();
				break;
			case 24151:
				getConfig().toggle(ConfigType.DISPLAY_COMBAT_TIMERS);
				savePlayerData();
				break;
			case 24155:
				crownState = (crownState == CrownIconState.ALL ? CrownIconState.NONE : crownState == CrownIconState.NONE ? CrownIconState.STAFF : CrownIconState.ALL);
				sendFrame36(530, 1);
				RSInterface.interfaceCache[25017].message = "Crowns: " + crownState.getTitle();
				break;
			case 24159:
				/*
				 * if high mem, set to low mem
				 */
				if (config.getStatus(ConfigType.HIGH_DETAIL)) {
					setLowDetail();
					loadingStage = 1;
					pushMessage("Set to low detail.", 0, "");
					config.set(ConfigType.HIGH_DETAIL, false);
					savePlayerData();
					sendFrame36(RSInterface.SETTING_CONFIGS[16], 0);
					sendFrame36(RSInterface.SETTING_CONFIGS[15], 1);
					method22();
				} else {
					sendFrame36(RSInterface.SETTING_CONFIGS[15], 1);
				}
				return;
			case 24163:
				/*
				 * If low mem, set to high mem
				 */
				if (!config.getStatus(ConfigType.HIGH_DETAIL)) {
					setHighDetail();
					loadingStage = 1;
					pushMessage("Set to high detail.", 0, "");
					config.set(ConfigType.HIGH_DETAIL, true);
					savePlayerData();
					sendFrame36(RSInterface.SETTING_CONFIGS[15], 0);
					sendFrame36(RSInterface.SETTING_CONFIGS[16], 1);
					method22();
				} else {
					sendFrame36(RSInterface.SETTING_CONFIGS[16], 1);
				}
				return;
			case 24168:
				getConfig().set(ConfigType.DISPLAY_COMBAT_OVERLAY, !config.getStatus(ConfigType.DISPLAY_COMBAT_OVERLAY));
				savePlayerData();
				break;
			case 24172:
				getConfig().set(ConfigType.ONE_CLICK_ATTACK, !config.getStatus(ConfigType.ONE_CLICK_ATTACK));
				savePlayerData();
				break;
			case 24176:
				getConfig().set(ConfigType.TOGGLE_TARGET_INTERFACE, !config.getStatus(ConfigType.TOGGLE_TARGET_INTERFACE));
				savePlayerData();
				break;
			case 24180:
				getConfig().set(ConfigType.TWEENING, !config.getStatus(ConfigType.TWEENING));
				savePlayerData();
				break;
			case 24184:
				cameraAngleLimit = cameraAngleLimit == 128 ? 98 : 128;
				break;

			case 21357:
			case 21359:
			case 21361:
			case 21363:
			case 21365:
			case 21367:
			case 21369:
			case 21371:
			case 21373:
			case 21375:
			case 21377:
			case 21379:
			case 21381:
			case 21383:
			case 21385:
			case 21387:
			case 21389:
			case 21391:
			case 21393:
			case 21395:
				getOut().putOpcode(243);
				getOut().putShort(thirdMenuAction + 22541 - 21395);
				break;

			default:
				// System.out.println(thirdMenuAction);
				getOut().putOpcode(243);
				getOut().putShort(thirdMenuAction);
			}

			RSInterface rsinterface = RSInterface.interfaceCache[thirdMenuAction];

			if (rsinterface.valueIndexArray != null && rsinterface.valueIndexArray[0][0] == 5) {
				int l2 = rsinterface.valueIndexArray[0][1];
				variousSettings[l2] = 1 - variousSettings[l2];
				updateConfig(l2);
			}
		}

		if (action == 447) {
			itemSelected = 1;
			anInt1283 = secondMenuAction;
			anInt1284 = thirdMenuAction;
			anInt1285 = firstMenuAction;
			selectedItemName = ItemDefinition.get(firstMenuAction).name;
			spellSelected = 0;
			return;
		}

		if (action == 1226) {
			ObjectDefinition definition = ObjectDefinition.forID(id);
			String examine;

			if (definition.description != null) {
				examine = new String(definition.description);
			} else {
				examine = "It's a " + definition.name + ".";
			}

			pushMessage(examine, 0, "");
		}

		if (action == 244) {
			boolean flag7 = doWalkTo(2, 0, 0, 0, myPlayer.smallY[0], 0, 0, thirdMenuAction, myPlayer.smallX[0], false, secondMenuAction);

			if (!flag7) {
				flag7 = doWalkTo(2, 0, 1, 0, myPlayer.smallY[0], 1, 0, thirdMenuAction, myPlayer.smallX[0], false, secondMenuAction);
			}

			crossX = super.saveClickX;
			crossY = super.saveClickY;
			crossType = 2;
			crossIndex = 0;
			getOut().putOpcode(253);
			getOut().method431(secondMenuAction + baseX);
			getOut().method433(thirdMenuAction + baseY);
			getOut().putShortSpecialA(firstMenuAction);
		}

		if (action == 1448) {
			ItemDefinition definition = ItemDefinition.get(firstMenuAction);
			String examine;

			if (definition.description != null) {
				examine = new String(definition.description);
			} else {
				examine = "It's a " + definition.name + ".";
			}

			pushMessage(examine, 0, "");
		}

		itemSelected = 0; // RIGHT HERE

		if (action != 626) {
			spellSelected = 0;
		}
	}

	private void doFlamesDrawing() {
	}

	private boolean doWalkTo(int type, int j, int k, int i1, int j1, int k1, int l1, int i2, int j2, boolean flag, int k2) {
		byte byte0 = 104;
		byte byte1 = 104;

		for (int l2 = 0; l2 < byte0; l2++) {
			for (int i3 = 0; i3 < byte1; i3++) {
				anIntArrayArray901[l2][i3] = 0;
				anIntArrayArray825[l2][i3] = 0x5f5e0ff;
			}
		}

		int j3 = j2;
		int k3 = j1;
		anIntArrayArray901[j2][j1] = 99;
		anIntArrayArray825[j2][j1] = 0;
		int l3 = 0;
		int i4 = 0;
		bigX[l3] = j2;
		bigY[l3++] = j1;
		boolean flag1 = false;
		int j4 = bigX.length;
		int[][] ai = aClass11Array1230[plane].anIntArrayArray294;

		while (i4 != l3) {
			j3 = bigX[i4];
			k3 = bigY[i4];
			i4 = (i4 + 1) % j4;

			if (j3 == k2 && k3 == i2) {
				flag1 = true;
				break;
			}

			if (i1 != 0) {
				if ((i1 < 5 || i1 == 10) && aClass11Array1230[plane].method219(k2, j3, k3, j, i1 - 1, i2)) {
					flag1 = true;
					break;
				}

				if (i1 < 10 && aClass11Array1230[plane].method220(k2, i2, k3, i1 - 1, j, j3)) {
					flag1 = true;
					break;
				}
			}

			if (k1 != 0 && k != 0 && aClass11Array1230[plane].method221(i2, k2, j3, k, l1, k1, k3)) {
				flag1 = true;
				break;
			}

			int l4 = anIntArrayArray825[j3][k3] + 1;

			if (j3 > 0 && anIntArrayArray901[j3 - 1][k3] == 0 && (ai[j3 - 1][k3] & 0x1280108) == 0) {
				bigX[l3] = j3 - 1;
				bigY[l3] = k3;
				l3 = (l3 + 1) % j4;
				anIntArrayArray901[j3 - 1][k3] = 2;
				anIntArrayArray825[j3 - 1][k3] = l4;
			}

			if (j3 < byte0 - 1 && anIntArrayArray901[j3 + 1][k3] == 0 && (ai[j3 + 1][k3] & 0x1280180) == 0) {
				bigX[l3] = j3 + 1;
				bigY[l3] = k3;
				l3 = (l3 + 1) % j4;
				anIntArrayArray901[j3 + 1][k3] = 8;
				anIntArrayArray825[j3 + 1][k3] = l4;
			}

			if (k3 > 0 && anIntArrayArray901[j3][k3 - 1] == 0 && (ai[j3][k3 - 1] & 0x1280102) == 0) {
				bigX[l3] = j3;
				bigY[l3] = k3 - 1;
				l3 = (l3 + 1) % j4;
				anIntArrayArray901[j3][k3 - 1] = 1;
				anIntArrayArray825[j3][k3 - 1] = l4;
			}

			if (k3 < byte1 - 1 && anIntArrayArray901[j3][k3 + 1] == 0 && (ai[j3][k3 + 1] & 0x1280120) == 0) {
				bigX[l3] = j3;
				bigY[l3] = k3 + 1;
				l3 = (l3 + 1) % j4;
				anIntArrayArray901[j3][k3 + 1] = 4;
				anIntArrayArray825[j3][k3 + 1] = l4;
			}

			if (j3 > 0 && k3 > 0 && anIntArrayArray901[j3 - 1][k3 - 1] == 0 && (ai[j3 - 1][k3 - 1] & 0x128010e) == 0 && (ai[j3 - 1][k3] & 0x1280108) == 0 && (ai[j3][k3 - 1] & 0x1280102) == 0) {
				bigX[l3] = j3 - 1;
				bigY[l3] = k3 - 1;
				l3 = (l3 + 1) % j4;
				anIntArrayArray901[j3 - 1][k3 - 1] = 3;
				anIntArrayArray825[j3 - 1][k3 - 1] = l4;
			}

			if (j3 < byte0 - 1 && k3 > 0 && anIntArrayArray901[j3 + 1][k3 - 1] == 0 && (ai[j3 + 1][k3 - 1] & 0x1280183) == 0 && (ai[j3 + 1][k3] & 0x1280180) == 0
					&& (ai[j3][k3 - 1] & 0x1280102) == 0) {
				bigX[l3] = j3 + 1;
				bigY[l3] = k3 - 1;
				l3 = (l3 + 1) % j4;
				anIntArrayArray901[j3 + 1][k3 - 1] = 9;
				anIntArrayArray825[j3 + 1][k3 - 1] = l4;
			}

			if (j3 > 0 && k3 < byte1 - 1 && anIntArrayArray901[j3 - 1][k3 + 1] == 0 && (ai[j3 - 1][k3 + 1] & 0x1280138) == 0 && (ai[j3 - 1][k3] & 0x1280108) == 0
					&& (ai[j3][k3 + 1] & 0x1280120) == 0) {
				bigX[l3] = j3 - 1;
				bigY[l3] = k3 + 1;
				l3 = (l3 + 1) % j4;
				anIntArrayArray901[j3 - 1][k3 + 1] = 6;
				anIntArrayArray825[j3 - 1][k3 + 1] = l4;
			}

			if (j3 < byte0 - 1 && k3 < byte1 - 1 && anIntArrayArray901[j3 + 1][k3 + 1] == 0 && (ai[j3 + 1][k3 + 1] & 0x12801e0) == 0 && (ai[j3 + 1][k3] & 0x1280180) == 0
					&& (ai[j3][k3 + 1] & 0x1280120) == 0) {
				bigX[l3] = j3 + 1;
				bigY[l3] = k3 + 1;
				l3 = (l3 + 1) % j4;
				anIntArrayArray901[j3 + 1][k3 + 1] = 12;
				anIntArrayArray825[j3 + 1][k3 + 1] = l4;
			}
		}

		anInt1264 = 0;

		if (!flag1) {
			if (flag) {
				int i5 = 100;

				for (int k5 = 1; k5 < 2; k5++) {
					for (int i6 = k2 - k5; i6 <= k2 + k5; i6++) {
						for (int l6 = i2 - k5; l6 <= i2 + k5; l6++) {
							if (i6 >= 0 && l6 >= 0 && i6 < 104 && l6 < 104 && anIntArrayArray825[i6][l6] < i5) {
								i5 = anIntArrayArray825[i6][l6];
								j3 = i6;
								k3 = l6;
								anInt1264 = 1;
								flag1 = true;
							}
						}
					}

					if (flag1) {
						break;
					}
				}

			}

			if (!flag1) {
				return false;
			}
		}

		i4 = 0;
		bigX[i4] = j3;
		bigY[i4++] = k3;
		int l5;

		for (int j5 = l5 = anIntArrayArray901[j3][k3]; j3 != j2 || k3 != j1; j5 = anIntArrayArray901[j3][k3]) {
			if (j5 != l5) {
				l5 = j5;
				bigX[i4] = j3;
				bigY[i4++] = k3;
			}

			if ((j5 & 2) != 0) {
				j3++;
			} else if ((j5 & 8) != 0) {
				j3--;
			}

			if ((j5 & 1) != 0) {
				k3++;
			} else if ((j5 & 4) != 0) {
				k3--;
			}
		}

		if (i4 > 0) {
			int k4 = i4;

			if (k4 > 25) {
				k4 = 25;
			}

			i4--;
			int k6 = bigX[i4];
			int i7 = bigY[i4];
			setAnInt1288(getAnInt1288() + k4);

			if (getAnInt1288() >= 92) {
				getOut().putOpcode(36);
				getOut().putInt(0);
				setAnInt1288(0);
			}

			if (type == 0) {
				getOut().putOpcode(169);
				getOut().putShortBigEndian(k4 + k4 + 3);
			}

			if (type == 1) {
				getOut().putOpcode(242);
				getOut().putShortBigEndian(k4 + k4 + 3 + 14);
			}

			if (type == 2) {
				getOut().putOpcode(90);
				getOut().putShortBigEndian(k4 + k4 + 3);
			}

			getOut().method433(k6 + baseX);
			destX = bigX[0];
			destY = bigY[0];

			for (int j7 = 1; j7 < k4; j7++) {
				i4--;
				getOut().putShortBigEndian(bigX[i4] - k6);
				getOut().putShortBigEndian(bigY[i4] - i7);
			}

			getOut().method431(i7 + baseY);
			getOut().method424(super.keyArray[5] != 1 ? 0 : 1);
			return true;
		}

		return type != 1;
	}

	private void draw3dScreen() {

		if (!chatArea.componentHidden()) {
			drawSplitPrivateChat();
		}

		if (crossType == 1) {
			crosses[crossIndex / 100].drawSprite(crossX - 8 - 4, crossY - 8 - 4);
			anInt1142++;

			if (anInt1142 > 67) {
				anInt1142 = 0;
			}
		}

		if (crossType == 2) {
			crosses[4 + crossIndex / 100].drawSprite(crossX - 8 - 4, crossY - 8 - 4);
		}

		if (getWalkableInterface() != -1) {
			method119(anInt945, getWalkableInterface());
			RSInterface rsInterface = RSInterface.interfaceCache[getWalkableInterface()];
			if (getWalkableInterface() == 15892 && GameFrame.getScreenMode() != ScreenMode.FIXED) {
				drawInterface(0, getScreenWidth() / 2 - rsInterface.width + 20, rsInterface, 0);
			} else if ((getWalkableInterface() == 201 || getWalkableInterface() == 197) && GameFrame.getScreenMode() != ScreenMode.FIXED) {
				drawInterface(0, getScreenWidth() - 765 + 15, rsInterface, 0 - 255 + 10 + 4);
			} else if (getWalkableInterface() == 16128) {
				if ((GameFrame.getScreenMode() != ScreenMode.FIXED)) {
					RSInterface.setBounds(16136, 320, 220, 7, rsInterface);
					RSInterface.setBounds(16137, 358, 220, 8, rsInterface);
					drawInterface(0, getScreenWidth() - 765 + 15, rsInterface, 0 - 255 + 40);
				} else {
					RSInterface.setBounds(16136, 30, 318, 7, rsInterface);
					RSInterface.setBounds(16137, 68, 318, 8, rsInterface);
					drawInterface(0, 0, rsInterface, 0);
				}
			} else {
				drawInterface(0, 0, rsInterface, 0);
			}

			if (getWalkableInterface() == 197) {
				if (config.getStatus(ConfigType.TOGGLE_TARGET_INTERFACE)) {
					drawInterface(0, getScreenWidth() - 765 - (GameFrame.getScreenMode() != ScreenMode.FIXED ? 30 : 0), RSInterface.interfaceCache[23300], 10);
				}
			}
		}

		if (openInterfaceID != -1) {
			method119(anInt945, openInterfaceID);
			RSInterface rsInterface = RSInterface.interfaceCache[openInterfaceID];
			int width = GameFrame.getScreenMode() != ScreenMode.FIXED ? getScreenWidth() : 516;
			int height = GameFrame.getScreenMode() != ScreenMode.FIXED ? getScreenHeight() : 338;

			if (GameFrame.getScreenMode() != ScreenMode.FIXED) {
				drawInterface(0, (width - 765) / 2, rsInterface, (height - 503) / 2);
			} else {
				drawInterface(0, 0, rsInterface, 0);// first 1
			}
		}

		method70();

		if (!menuOpen) {
			processRightClick();
			drawTooltip();
		} else if (menuScreenArea == 0) {
			drawMenu();
		}

		if (anInt1055 == 1) {
			multiOverlay[GameFrame.getScreenMode() == ScreenMode.FIXED ? 0 : 1].drawSprite(GameFrame.getScreenMode() == ScreenMode.FIXED ? 472 : 516 + getScreenWidth() - 765 + 52 + 157,
					GameFrame.getScreenMode() == ScreenMode.FIXED ? 296 : 175);
		}

		int x = baseX + (myPlayer.x - 6 >> 7);
		int y = baseY + (myPlayer.y - 6 >> 7);
		if (isDebugMode()) {
			int minus = 45;
			int textColor = 0xffff00;
			if (super.fps < 15) {
				textColor = 0xff0000;
			}
			if (systemUpdateTimer != 0) {
				minus = 60;
			}
			newRegularFont.drawBasicString("Fps: " + super.fps, 5, 270 - minus, textColor, 0);
			newRegularFont.drawBasicString("Local Players: " + this.playerCount + ", Local Mobs: " + npcCount, 5, 285 - minus, 0xffff00, 0);
			Runtime runtime = Runtime.getRuntime();
			textColor = 0xFFFF00;
			int memory = (int) ((runtime.totalMemory() - runtime.freeMemory()) / 1024L);
			if (memory > 0x2000000 && lowDetail) {
				textColor = 0xff0000;
			}
			newRegularFont.drawBasicString("Mem: " + formatValue(memory, 2) + "k", 5, 300 - minus, textColor, 0);
			newRegularFont.drawBasicString("Mouse X: " + super.mouseX + " , Mouse Y: " + super.mouseY, 5, 315 - minus, 0xffff00, 0);
			newRegularFont.drawBasicString("Coords: " + x + ", " + y, 5, 330 - minus, 0xffff00, 0);
			newRegularFont.drawBasicString("Client resolution: " + getScreenWidth() + "x" + getScreenHeight(), 5, 345 - minus, 0xffff00, 0);
			newRegularFont.drawBasicString("Object Maps: " + objectMaps + ";", 5, 360 - minus, 0xffff00, 0);
			newRegularFont.drawBasicString("Floor Maps: " + floorMaps + ";", 5, 375 - minus, 0xffff00, 0);
		}
		if (fpsOn) {
			int textX = (GameFrame.isFixed() ? (mapArea.getxPos() - 90) : (getScreenWidth() - 100));
			int textY = (GameFrame.isFixed() ? 20 : 230);
			int textColor = 0xffff00;
			if (super.fps < 15) {
				textColor = 0xff0000;
			}
			newRegularFont.drawBasicString("Fps: " + super.fps, textX, textY, textColor, 0);
			textY += 15;
			Runtime runtime = Runtime.getRuntime();
			int memory = (int) ((runtime.totalMemory() - runtime.freeMemory()) / 1024L);
			if (memory > 0x2000000 && lowDetail) {
				textColor = 0xff0000;
			}
			newRegularFont.drawBasicString("Mem:" + formatValue(memory, 2) + "k", textX, textY, textColor, 0);
			textY += 15;
		}

		if (systemUpdateTimer != 0) {
			int j = systemUpdateTimer / 50;
			int l = j / 60;
			j %= 60;

			if (j < 10) {
				normalText.method385(0xffff00, "System update in: " + l + ":0" + j, GameFrame.isFixed() ? 329 : getScreenHeight() - 168, 4);
			} else {
				normalText.method385(0xffff00, "System update in: " + l + ":" + j, GameFrame.isFixed() ? 329 : getScreenHeight() - 168, 4);
			}

			if (++anInt849 > 75) {
				anInt849 = 0;
				getOut().putOpcode(148);
			}
		}

	}

	void drawAnimatedWorldBackground(boolean display) {
		if (scriptManager == null) {
			try {
				loginScreenBG(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		int canvasCenterX = Rasterizer.centerX;
		int canvasCenterY = Rasterizer.centerY;
		int canvasPixels[] = Rasterizer.lineOffsets;
		if (titleScreenOffsets != null && (titleWidth != clientWidth || titleHeight != clientHeight)) {
			titleScreenOffsets = null;
		}

		if (titleScreenOffsets == null) {
			titleWidth = clientWidth;
			titleHeight = clientHeight;
			titleScreenOffsets = Rasterizer.getOffsets(titleWidth, titleHeight);
		}

		Rasterizer.centerX = getScreenWidth() / 2;
		Rasterizer.centerY = getScreenHeight() / 2;
		Rasterizer.lineOffsets = titleScreenOffsets;
		if (loadingStage == 2 && ObjectManager.anInt131 != plane)
			loadingStage = 1;

		if (!loggedIn && loadingStage == 1) {
			method54();
		}
		if (!loggedIn && loadingStage == 2 && plane != anInt985) {
			anInt985 = plane;
			method24(plane);
		}
		if (loadingStage == 2) {
			try {
				DrawingArea.setAllPixelsToZero();
				worldController.method313(xCameraPos, yCameraPos, xCameraCurve, zCameraPos, method121(), yCameraCurve);
				worldController.clearObj5Cache();
			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}

		if (Client.getConfig().getStatus(ConfigType.FOG)) {
			if (!switchColor) {
				if (fogHandler.fogColor != fadeColors(new Color(fogHandler.fogColor), new Color(fadingToColor), fadeStep)) {
					switchColor = true;
				}
			}
			int x = baseX + (myPlayer.x - 6 >> 7);
			int y = baseY + (myPlayer.y - 6 >> 7);
			if (x >= 3060 && x <= 3140 && y >= 3050 && y <= 3530) {
				if (fogHandler.fogColor != 13092807) {
					fogHandler.fogColor = 13092807;
				}
			} else {
				if (switchColor) {
					fadeStep += 5;
					if (fadeStep >= 100) {
						fadeStep = 1;
						switchColor = false;
						fogHandler.fogColor = fadeColors(new Color(fogHandler.fogColor), new Color(fadingToColor), fadeStep);
					} else {
						fogHandler.fogColor = fadeColors(new Color(fogHandler.fogColor), new Color(fadingToColor), fadeStep);
					}
				}
			}
			fogHandler.renderFog(gameScreenIP.pixels, gameScreenIP.depth);
		}
		if (scriptManager != null && loadingStage == 2 && plane == anInt985 && !loggedIn) {
			scriptManager.cycle();
		}
		Rasterizer.centerX = canvasCenterX;
		Rasterizer.centerY = canvasCenterY;
		Rasterizer.lineOffsets = canvasPixels;
	}

	private void drawBlackBox(int x, int y) {
		DrawingArea.drawPixels(71, y - 1, x - 2, 0x726451, 1);
		DrawingArea.drawPixels(69, y, x + 174, 0x726451, 1);
		DrawingArea.drawPixels(1, y - 2, x - 2, 0x726451, 178);
		DrawingArea.drawPixels(1, y + 68, x, 0x726451, 174);
		DrawingArea.drawPixels(71, y - 1, x - 1, 0x2E2B23, 1);
		DrawingArea.drawPixels(71, y - 1, x + 175, 0x2E2B23, 1);
		DrawingArea.drawPixels(1, y - 1, x, 0x2E2B23, 175);
		DrawingArea.drawPixels(1, y + 69, x, 0x2E2B23, 175);
		DrawingArea.method335(0, y, 174, 68, 220, x);
	}

	private void drawChatArea() {
		chatArea.setxPos(0);
		chatArea.setyPos(GameFrame.getScreenMode() == ScreenMode.FIXED ? 338 : getScreenHeight() - 165);
		chatArea.render(this);
	}

	private void drawFlames() {
		drawingFlames = true;

		try {
			long l = System.currentTimeMillis();
			int i = 0;
			int j = 20;

			while (aBoolean831) {
				doFlamesDrawing();

				if (++i > 10) {
					long l1 = System.currentTimeMillis();
					int k = (int) (l1 - l) / 10 - j;
					j = 40 - k;

					if (j < 5) {
						j = 5;
					}

					i = 0;
					l = l1;
				}

				try {
					Thread.sleep(j);
				} catch (Exception _ex) {
				}
			}
		} catch (Exception _ex) {
		}

		drawingFlames = false;
	}

	private void drawFriendsListOrWelcomeScreen(RSInterface class9) {
		int j = class9.contentType;

		if (j >= 206 && j <= 206 + 25) {
			j -= 206;
			class9.message = setMessage(j);
			return;
		}

		if (j >= 1 && j <= 100 || j >= 701 && j <= 800) {
			if (j == 1 && getAnInt900() == 0) {
				class9.message = "Loading friend list";
				class9.atActionType = 0;
				return;
			}

			if (j == 1 && getAnInt900() == 1) {
				class9.message = "Connecting to friendserver";
				class9.atActionType = 0;
				return;
			}

			if (j == 2 && getAnInt900() != 2) {
				class9.message = "Please wait...";
				class9.atActionType = 0;
				return;
			}

			int k = friendCount;

			if (getAnInt900() != 2) {
				k = 0;
			}

			if (j > 700) {
				j -= 601;
			} else {
				j--;
			}

			if (j >= k) {
				class9.message = "";
				class9.atActionType = 0;
				return;
			} else {
				class9.message = friendsList[j];
				class9.atActionType = 1;
				return;
			}
		}

		if (j == 901) {
			class9.message = friendCount + "";
			return;
		}

		if (j == 902) {
			class9.message = ignoreCount + "";
			return;
		}

		if (j >= 101 && j <= 200 || j >= 801 && j <= 900) {
			int l = friendCount;

			if (getAnInt900() != 2) {
				l = 0;
			}

			if (j > 800) {
				j -= 701;
			} else {
				j -= 101;
			}

			if (j >= l) {
				class9.message = "";
				class9.atActionType = 0;
				return;
			}

			if (friendsNodeIDs[j] == 0) {
				class9.message = "@red@Offline";
			} else if (friendsNodeIDs[j] == nodeID) {
				class9.message = "@gre@Online"/* + (friendsNodeIDs[j] - 9) */;
			} else {
				class9.message = "@red@Offline"/* + (friendsNodeIDs[j] - 9) */;
			}

			class9.atActionType = 1;
			return;
		}

		if (j == 203) {
			int i1 = friendCount;

			if (getAnInt900() != 2) {
				i1 = 0;
			}

			class9.scrollMax = i1 * 15 + 20;

			if (class9.scrollMax <= class9.height) {
				class9.scrollMax = class9.height + 1;
			}

			return;
		}

		if (j >= 401 && j <= 500) {
			if ((j -= 401) == 0 && getAnInt900() == 0) {
				class9.message = "Loading ignore list";
				class9.atActionType = 0;
				return;
			}

			if (j == 1 && getAnInt900() == 0) {
				class9.message = "Please wait...";
				class9.atActionType = 0;
				return;
			}

			int j1 = ignoreCount;

			if (getAnInt900() == 0) {
				j1 = 0;
			}

			if (j >= j1) {
				class9.message = "";
				class9.atActionType = 0;
				return;
			} else {
				class9.message = TextClass.fixName(TextClass.nameForLong(ignoreListAsLongs[j]));
				class9.atActionType = 1;
				return;
			}
		}

		if (j == 503) {
			class9.scrollMax = ignoreCount * 15 + 20;

			if (class9.scrollMax <= class9.height) {
				class9.scrollMax = class9.height + 1;
			}

			return;
		}

		if (j == 327) {
			class9.modelRotation1 = 150;
			class9.modelRotation2 = (int) (Math.sin(loopCycle / 40D) * 256D) & 0x7FF;

			if (aBoolean1031) {
				for (int k1 = 0; k1 < 7; k1++) {
					int l1 = anIntArray1065[k1];

					if (l1 >= 0 && !IdentityKit.cache[l1].method537()) {
						return;
					}
				}

				aBoolean1031 = false;
				Model aclass30_sub2_sub4_sub6s[] = new Model[7];
				int i2 = 0;

				for (int j2 = 0; j2 < 7; j2++) {
					int k2 = anIntArray1065[j2];

					if (k2 >= 0) {
						aclass30_sub2_sub4_sub6s[i2++] = IdentityKit.cache[k2].method538();
					}
				}

				Model model = new Model(i2, aclass30_sub2_sub4_sub6s);

				for (int l2 = 0; l2 < 5; l2++) {
					if (anIntArray990[l2] != 0) {
						model.method476(anIntArrayArray1003[l2][0], anIntArrayArray1003[l2][anIntArray990[l2]]);

						if (l2 == 1) {
							model.method476(anIntArray1204[0], anIntArray1204[anIntArray990[l2]]);
						}
					}
				}

				model.method469();
				model.method470(Animation.cache[myPlayer.anInt1511].frame2IDS[0]);
				model.method479(64, 850, -30, -50, -30, true);
				class9.anInt233 = 5;
				class9.mediaID = 0;
				RSInterface.method208(aBoolean994, model);
			}

			return;
		}

		if (j == 328) {
			RSInterface rsInterface = class9;
			int verticleTilt = 150;
			int animationSpeed = (int) (Math.sin(loopCycle / 40D) * 256D) & 0x7ff;
			rsInterface.modelRotation1 = verticleTilt;
			rsInterface.modelRotation2 = animationSpeed;

			if (aBoolean1031) {
				Model characterDisplay = myPlayer.method452();

				for (int l2 = 0; l2 < 5; l2++) {
					if (anIntArray990[l2] != 0) {
						characterDisplay.method476(anIntArrayArray1003[l2][0], anIntArrayArray1003[l2][anIntArray990[l2]]);
						if (l2 == 1) {
							characterDisplay.method476(anIntArray1204[0], anIntArray1204[anIntArray990[l2]]);
						}
					}
				}

				int staticFrame = myPlayer.anInt1511;
				characterDisplay.method469();
				characterDisplay.method470(Animation.cache[staticFrame].frame2IDS[0]);
				rsInterface.anInt233 = 5;
				rsInterface.mediaID = 0;
				RSInterface.method208(aBoolean994, characterDisplay);
			}

			return;
		}

		if (j == 324) {
			if (aClass30_Sub2_Sub1_Sub1_931 == null) {
				aClass30_Sub2_Sub1_Sub1_931 = class9.sprite1;
				aClass30_Sub2_Sub1_Sub1_932 = class9.sprite2;
			}

			if (aBoolean1047) {
				class9.sprite1 = aClass30_Sub2_Sub1_Sub1_932;
				return;
			} else {
				class9.sprite1 = aClass30_Sub2_Sub1_Sub1_931;
				return;
			}
		}

		if (j == 325) {
			if (aClass30_Sub2_Sub1_Sub1_931 == null) {
				aClass30_Sub2_Sub1_Sub1_931 = class9.sprite1;
				aClass30_Sub2_Sub1_Sub1_932 = class9.sprite2;
			}

			if (aBoolean1047) {
				class9.sprite1 = aClass30_Sub2_Sub1_Sub1_931;
				return;
			} else {
				class9.sprite1 = aClass30_Sub2_Sub1_Sub1_932;
				return;
			}
		}

		if (j == 650 || j == 655) {
			if (anInt1193 != 0) {
				String lastVisit;

				if (daysSinceLastLogin == 0) {
					lastVisit = "earlier today";
				} else if (daysSinceLastLogin == 1) {
					lastVisit = "yesterday";
				} else {
					lastVisit = daysSinceLastLogin + " days ago";
				}

				class9.message = "You last logged in " + lastVisit + " from: " + Signlink.dns;
			} else {
				class9.message = "";
			}
		}

		if (j == 651) {
			if (unreadMessages == 0) {
				class9.message = "0 unread messages";
				class9.textColor = 0xffff00;
			} else if (unreadMessages == 1) {
				class9.message = "1 unread message";
				class9.textColor = 65280;
			} else if (unreadMessages > 1) {
				class9.message = unreadMessages + " unread messages";
				class9.textColor = 65280;
			}
		}

		if (j == 652) {
			if (daysSinceRecovChange == 201) {
				if (membersInt == 1) {
					class9.message = "@yel@This is a non-members world: @whi@Since you are a member we";
				} else {
					class9.message = "";
				}
			} else if (daysSinceRecovChange == 200) {
				class9.message = "You have not yet set any password recovery questions.";
			} else {
				String s1;

				if (daysSinceRecovChange == 0) {
					s1 = "Earlier today";
				} else if (daysSinceRecovChange == 1) {
					s1 = "Yesterday";
				} else {
					s1 = daysSinceRecovChange + " days ago";
				}

				class9.message = s1 + " you changed your recovery questions";
			}
		}

		if (j == 653) {
			if (daysSinceRecovChange == 201) {
				if (membersInt == 1) {
					class9.message = "@whi@recommend you use a members world instead. You may use";
				} else {
					class9.message = "";
				}
			} else if (daysSinceRecovChange == 200) {
				class9.message = "We strongly recommend you do so now to secure your account.";
			} else {
				class9.message = "If you do not remember making this change then cancel it immediately";
			}
		}

		if (j == 654) {
			if (daysSinceRecovChange == 201) {
				if (membersInt == 1) {
					class9.message = "@whi@this world but member benefits are unavailable whilst here.";
					return;
				} else {
					class9.message = "";
					return;
				}
			}

			if (daysSinceRecovChange == 200) {
				class9.message = "Do this from the 'account management' area on our front webpage";
				return;
			}

			class9.message = "Do this from the 'account management' area on our front webpage";
		}
	}

	private void drawGameScreen() {
		if (getFullscreenInterfaceID() != -1 && (loadingStage == 2 || super.fullGameScreen != null)) {
			if (loadingStage == 2) {
				method119(anInt945, getFullscreenInterfaceID());
				if (openInterfaceID != -1) {
					method119(anInt945, openInterfaceID);
				}
				anInt945 = 0;
				resetAllImageProducers();
				super.fullGameScreen.initDrawingArea();
				Rasterizer.lineOffsets = fullScreenTextureArray;
				DrawingArea.setAllPixelsToZero();
				welcomeScreenRaised = true;
				if (openInterfaceID != -1) {
					RSInterface rsInterface_1 = RSInterface.interfaceCache[openInterfaceID];
					if (rsInterface_1.width == 512 && rsInterface_1.height == 334 && rsInterface_1.type == 0) {
						rsInterface_1.width = 765;
						rsInterface_1.height = 503;
					}
					drawInterface(0, 0, rsInterface_1, 8);
				}
				RSInterface rsInterface = RSInterface.interfaceCache[getFullscreenInterfaceID()];
				if (rsInterface.width == 512 && rsInterface.height == 334 && rsInterface.type == 0) {
					rsInterface.width = 765;
					rsInterface.height = 503;
				}
				drawInterface(0, 0, rsInterface, 8);

				if (!menuOpen) {
					processRightClick();
					drawTooltip();
				} else {
					drawMenu();
				}
			}
			drawCount++;
			super.fullGameScreen.drawGraphics(0, super.graphics, 0);
			return;
		} else {
			if (drawCount != 0) {
				resetImageProducers2();
			}
		}
		if (welcomeScreenRaised) {
			welcomeScreenRaised = false;
			if (GameFrame.getScreenMode() == ScreenMode.FIXED) {
				topFrame.drawGraphics(0, super.graphics, 0);
				leftFrame.drawGraphics(4, super.graphics, 0);

				rightFrame.drawGraphics(4, super.graphics, 516);
				rightFrame.drawGraphics(4, super.graphics, 515);
			}

			setInputTaken(true);
			tabAreaAltered = true;

			if (loadingStage != 2) {
				if (!resizing) {
					gameScreenIP.drawGraphics(gameScreenDrawY, super.graphics, gameScreenDrawX);
				}
				mapAreaIP.drawGraphics(getMapArea().getyPos(), super.graphics, getMapArea().getxPos());
			}
		}

		drawTabArea();

		if (backDialogID == -1) {
			aClass9_1059.scrollPosition = anInt1211 - anInt1089 - 110;
			if (super.mouseX > chatArea.getxPos() + 478 && super.mouseX < chatArea.getxPos() + 580 && super.mouseY > chatArea.getyPos() + 4) {
				method65(494, 110, super.mouseX - chatArea.getxPos(), super.mouseY - chatArea.getyPos() - 10, aClass9_1059, 0, false, anInt1211);
			}
			int i = anInt1211 - 110 - aClass9_1059.scrollPosition;
			if (i < 0) {
				i = 0;
			}
			if (i > anInt1211 - 110) {
				i = anInt1211 - 110;
			}
			if (anInt1089 != i) {
				anInt1089 = i;
				setInputTaken(true);
			}
		}
		if (backDialogID != -1) {
			boolean flag2 = method119(anInt945, backDialogID);
			if (flag2) {
				setInputTaken(true);
			}
		}

		if (atInventoryInterfaceType == 3) {
			setInputTaken(true);
		}

		if (activeInterfaceType == 3) {
			setInputTaken(true);
		}

		if (aString844 != null) {
			setInputTaken(true);
		}

		if (menuOpen && menuScreenArea == 2) {
			setInputTaken(true);
		}

		if (inputTaken) {
			drawChatArea();
			drawConsoleArea();
			setInputTaken(false);
		}

		if (loadingStage == 2) {
			method146();
		}

		if (loadingStage == 2) {
			if (GameFrame.getScreenMode() == ScreenMode.FIXED) {
				drawMinimap();
				if (getMapArea().isVisible()) {
					mapAreaIP.drawGraphics(getMapArea().getyPos(), super.graphics, getMapArea().getxPos());
				}
			}
		}

		if (anInt1054 != -1) {
			tabAreaAltered = true;
		}

		if (tabAreaAltered) {
			if (anInt1054 != -1 && anInt1054 == tabID) {
				anInt1054 = -1;
				getOut().putOpcode(120);
				getOut().putShortBigEndian(tabID);
			}

			tabAreaAltered = false;
			aRSImageProducer_1125.initDrawingArea();
			gameScreenIP.initDrawingArea();
		}

		if (menuOpen) {
			drawMenu();
		}

		anInt945 = 0;
	}

	private void drawHeadIcon() {
		if (anInt855 != 2) {
			return;
		}

		calcEntityScreenPos((anInt934 - baseX << 7) + anInt937, anInt936 * 2, (anInt935 - baseY << 7) + anInt938);

		if (spriteDrawX > -1 && loopCycle % 20 < 10) {
			headIconsHint[0].drawSprite(spriteDrawX - 12, spriteDrawY - 28);
		}
	}

	private void drawHoverBox(int xPos, int yPos, String text) {
		String[] results = text.split("\n");
		int height = results.length * 16 + 6;
		int width = chatTextDrawingArea.getTextWidth(results[0]) + 6;

		for (int i = 1; i < results.length; i++) {
			if (width <= chatTextDrawingArea.getTextWidth(results[i]) + 6) {
				width = chatTextDrawingArea.getTextWidth(results[i]) + 6;
			}
		}

		DrawingArea.drawPixels(height, yPos, xPos, 0xFFFFA0, width);
		DrawingArea.fillPixels(xPos, width, height, 0, yPos);
		yPos += 14;

		for (String result : results) {
			normalText.method389(false, xPos + 3, 0, result, yPos);
			yPos += 16;
		}
	}

	public void drawInterface(int scrollOffset, int interfaceX, RSInterface class9, int interfaceY) {
		if (class9 == null) {
			class9 = RSInterface.interfaceCache[21356];
		}

		if (class9.children == null || class9.type != 0) {
			return;
		}

		if (class9.interfaceShown && anInt1026 != class9.id && anInt1048 != class9.id && anInt1039 != class9.id) {
			return;
		}

		int i1 = DrawingArea.topX;
		int j1 = DrawingArea.topY;
		int k1 = DrawingArea.bottomX;
		int l1 = DrawingArea.bottomY;
		int alpha = class9.opacity;
		DrawingArea.setBounds(interfaceX, interfaceY, interfaceX + class9.width, interfaceY + class9.height);
		int i2 = class9.children.length;

		for (int j2 = 0; j2 < i2; j2++) {
			int childX = class9.childX[j2] + interfaceX;
			int childY = class9.childY[j2] + interfaceY - scrollOffset;
			RSInterface childInterface = RSInterface.interfaceCache[class9.children[j2]];
			childX += childInterface.xOffset;
			childY += childInterface.yOffset;

			if (childInterface.contentType > 0) {
				drawFriendsListOrWelcomeScreen(childInterface);
			}

			for (int m5 = 0; m5 < IDs.length; m5++) {
				if (childInterface.id == IDs[m5] + 1) {
					if (m5 > 61) {
						drawBlackBox(childX + 1, childY);
					} else {
						drawBlackBox(childX, childY + 1);
					}
				}
			}

			for (int element : runeChildren) {
				if (childInterface.id == element) {
					childInterface.modelZoom = 775;
				}
			}

			if (childInterface.type == 0) {
				if (childInterface.scrollPosition > childInterface.scrollMax - childInterface.height) {
					childInterface.scrollPosition = childInterface.scrollMax - childInterface.height;
				}

				if (childInterface.scrollPosition < 0) {
					childInterface.scrollPosition = 0;
				}

				drawInterface(childInterface.scrollPosition, childX, childInterface, childY);

				if (childInterface.scrollMax > childInterface.height) {
					drawScrollbar(childInterface.height, childInterface.scrollPosition, childY, childX + childInterface.width, childInterface.scrollMax, false, false);
				}
			} else if (childInterface.type != 1) {
				if (childInterface.type == 2) {
					int i3 = 0;
					for (int l3 = 0; l3 < childInterface.height; l3++) {
						for (int l4 = 0; l4 < childInterface.width; l4++) {
							int k5 = childX + l4 * (32 + childInterface.invSpritePadX);
							int j6 = childY + l3 * (32 + childInterface.invSpritePadY);

							if (i3 < 20) {
								k5 += childInterface.spritesX[i3];
								j6 += childInterface.spritesY[i3];
							}

							if (i3 < childInterface.inv.length && childInterface.inv[i3] > 0) {
								int k6 = 0;
								int j7 = 0;
								int j9 = childInterface.inv[i3] - 1;

								if (k5 > DrawingArea.topX - 32 && k5 < DrawingArea.bottomX && j6 > DrawingArea.topY - 32 && j6 < DrawingArea.bottomY || activeInterfaceType != 0 && anInt1085 == i3) {
									int l9 = 0;
									if (itemSelected == 1 && anInt1283 == i3 && anInt1284 == childInterface.id) {
										l9 = 0xffffff;
									}

									Sprite selectedItem = ItemDefinition.getSprite(j9, childInterface.invStackSizes[i3], l9);

									if (selectedItem != null) {
										if (activeInterfaceType != 0 && anInt1085 == i3 && anInt1084 == childInterface.id) {
											k6 = super.mouseX - anInt1087;
											j7 = super.mouseY - anInt1088;

											if (k6 < 5 && k6 > -5) {
												k6 = 0;
											}

											if (j7 < 5 && j7 > -5) {
												j7 = 0;
											}

											if (anInt989 < 10) {
												k6 = 0;
												j7 = 0;
											}

											selectedItem.drawSprite1(k5 + k6, j6 + j7);

											if (j6 + j7 < DrawingArea.topY && class9.scrollPosition > 0) {
												int i10 = anInt945 * (DrawingArea.topY - j6 - j7) / 3;

												if (i10 > anInt945 * 10) {
													i10 = anInt945 * 10;
												}

												if (i10 > class9.scrollPosition) {
													i10 = class9.scrollPosition;
												}

												class9.scrollPosition -= i10;
												anInt1088 += i10;
											}

											if (j6 + j7 + 32 > DrawingArea.bottomY && class9.scrollPosition < class9.scrollMax - class9.height) {
												int j10 = anInt945 * (j6 + j7 + 32 - DrawingArea.bottomY) / 3;

												if (j10 > anInt945 * 10) {
													j10 = anInt945 * 10;
												}

												if (j10 > class9.scrollMax - class9.height - class9.scrollPosition) {
													j10 = class9.scrollMax - class9.height - class9.scrollPosition;
												}

												class9.scrollPosition += j10;
												anInt1088 -= j10;
											}
										} else if (atInventoryInterfaceType != 0 && atInventoryIndex == i3 && atInventoryInterface == childInterface.id) {
											selectedItem.drawSprite1(k5, j6);
										} else {
											selectedItem.drawSprite(k5, j6);
										}

										if (selectedItem.maxWidth == 33 || childInterface.invStackSizes[i3] != 1) {
											int k10 = childInterface.invStackSizes[i3];

											if (!childInterface.hideStackSize) {

												smallText.method385(0, intToKOrMil(k10), j6 + 10 + j7, k5 + 1 + k6);

												if (k10 > 99999 && k10 < 10000000) {
													smallText.method385(0xFFFFFF, intToKOrMil(k10), j6 + 9 + j7, k5 + k6);
												} else if (k10 > 9999999) {
													smallText.method385(0x00ff80, intToKOrMil(k10), j6 + 9 + j7, k5 + k6);
												} else {
													smallText.method385(0xFFFF00, intToKOrMil(k10), j6 + 9 + j7, k5 + k6);
												}
											}
										}
									}
								}
							} else if (childInterface.sprites != null && i3 < 20) {
								Sprite class30_sub2_sub1_sub1_1 = childInterface.sprites[i3];

								if (class30_sub2_sub1_sub1_1 != null) {
									class30_sub2_sub1_sub1_1.drawSprite(k5, j6);
								}
							}

							i3++;
						}
					}
				} else if (childInterface.type == 3) {
					boolean flag = false;

					if (anInt1039 == childInterface.id || anInt1048 == childInterface.id || anInt1026 == childInterface.id) {
						flag = true;
					}

					int j3;

					if (interfaceIsSelected(childInterface)) {
						j3 = childInterface.anInt219;

						if (flag && childInterface.anInt239 != 0) {
							j3 = childInterface.anInt239;
						}
					} else {
						j3 = childInterface.textColor;

						if (flag && childInterface.textColorSelected != 0) {
							j3 = childInterface.textColorSelected;
						}
					}

					if (childInterface.opacity == 0) {
						if (childInterface.aBoolean227) {
							DrawingArea.drawPixels(childInterface.height, childY, childX, j3, childInterface.width);
						} else {
							DrawingArea.fillPixels(childX, childInterface.width, childInterface.height, j3, childY);
						}
					} else if (childInterface.aBoolean227) {
						DrawingArea.method335(j3, childY, childInterface.width, childInterface.height, 256 - (childInterface.opacity & 0xff), childX);
					} else {
						DrawingArea.method338(childY, childInterface.height, 256 - (childInterface.opacity & 0xff), j3, childInterface.width, childX);
					}
				} else if (childInterface.type == 4) {
					TextDrawingArea textDrawingArea = childInterface.textDrawingAreas;
					String s = childInterface.message;
					int xOffset = 0;
					int imageDraw = 0;
					final String INITIAL_MESSAGE = s;
					if (s.contains("<img=")) {
						int prefix = s.indexOf("<img=");
						int suffix = s.indexOf(">");
						try {
							imageDraw = Integer.parseInt(s.substring(prefix + 5, suffix));
							s = s.replaceAll(s.substring(prefix + 5, suffix), "");
							s = s.replaceAll("</img>", "");
							s = s.replaceAll("<img=>", "");
						} catch (NumberFormatException nfe) {
							// System.out.println("Unable to draw player
							// crown on interface. Unable to read rights.");
							s = INITIAL_MESSAGE;
						} catch (IllegalStateException ise) {
							// System.out.println("Unable to draw player
							// crown on interface, rights too low or
							// high.");
							s = INITIAL_MESSAGE;
						}
						if (suffix > prefix) {
							xOffset += 14;
						}
					}
					boolean flag1 = false;
					if (anInt1039 == childInterface.id || anInt1048 == childInterface.id || anInt1026 == childInterface.id) {
						flag1 = true;
					}
					int i4;
					if (interfaceIsSelected(childInterface)) {
						i4 = childInterface.anInt219;
						if (flag1 && childInterface.anInt239 != 0) {
							i4 = childInterface.anInt239;
						}
						if (childInterface.disabledText.length() > 0) {
							s = childInterface.disabledText;
						}
					} else {
						if (childInterface.drawSecondary) {
							i4 = childInterface.anInt219;
						} else {
							i4 = childInterface.textColor;
						}
						if (flag1 && childInterface.textColorSelected != 0) {
							i4 = childInterface.textColorSelected;
						}
					}
					if (childInterface.atActionType == 6 && dialogueOptionsShowing) {
						s = "Please wait...";
						i4 = childInterface.textColor;
					}
					if (DrawingArea.width == 516) {
						if (i4 == 0xffff00) {
							i4 = 255;
						}
						if (i4 == 49152) {
							i4 = 0xffffff;
						}
					}
					if (childInterface.parentID == 1151 || childInterface.parentID == 12855) {
						switch (i4) {
						case 16773120:
							i4 = 0xFE981F;
							break;
						case 7040819:
							i4 = 0xAF6A1A;
							break;
						}
					}
					for (int l6 = childY + textDrawingArea.anInt1497; s.length() > 0; l6 += textDrawingArea.anInt1497) {
						if (s.indexOf("%") != -1) {
							do {
								int k7 = s.indexOf("%1");
								if (k7 == -1) {
									break;
								}
								if (childInterface.id < 4000
										|| childInterface.id > 5000 && childInterface.id != 13921 && childInterface.id != 13922 && childInterface.id != 12171 && childInterface.id != 12172) {
									s = s.substring(0, k7) + methodR(extractInterfaceValues(childInterface, 0)) + s.substring(k7 + 2);
								} else {
									s = s.substring(0, k7) + interfaceIntToString(extractInterfaceValues(childInterface, 0)) + s.substring(k7 + 2);
								}
							} while (true);
							do {
								int l7 = s.indexOf("%2");
								if (l7 == -1) {
									break;
								}
								s = s.substring(0, l7) + interfaceIntToString(extractInterfaceValues(childInterface, 1)) + s.substring(l7 + 2);
							} while (true);
							do {
								int i8 = s.indexOf("%3");
								if (i8 == -1) {
									break;
								}
								s = s.substring(0, i8) + interfaceIntToString(extractInterfaceValues(childInterface, 2)) + s.substring(i8 + 2);
							} while (true);
							do {
								int j8 = s.indexOf("%4");
								if (j8 == -1) {
									break;
								}
								s = s.substring(0, j8) + interfaceIntToString(extractInterfaceValues(childInterface, 3)) + s.substring(j8 + 2);
							} while (true);
							do {
								int k8 = s.indexOf("%5");
								if (k8 == -1) {
									break;
								}
								s = s.substring(0, k8) + interfaceIntToString(extractInterfaceValues(childInterface, 4)) + s.substring(k8 + 2);
							} while (true);
						}
						int l8 = s.indexOf("\\n");
						String s1;
						if (l8 != -1) {
							s1 = s.substring(0, l8);
							s = s.substring(l8 + 2);
						} else {
							s1 = s;
							s = "";
						}

						if (imageDraw > 0 && xOffset > 0) {
							int drawImageY = childY + 14;
							if (imageDraw >= 34) { // Clan chat images
								xOffset -= 5;
								drawImageY -= 7;
							}
							newRegularFont.drawBasicString("<img=" + (imageDraw - 1) + ">", childX, drawImageY);
						}
						if (childInterface.centerText) {
							textDrawingArea.method382(i4, childX + childInterface.width / 2 + xOffset, s1, l6, childInterface.textShadow);
						} else {
							textDrawingArea.method389(childInterface.textShadow, childX + xOffset, i4, s1, l6);
						}
					}
				} else if (childInterface.type == 5) {
					Sprite sprite;
					if (interfaceIsSelected(childInterface)) {
						sprite = childInterface.sprite2;
					} else {
						sprite = childInterface.sprite1;
					}
					if (childInterface.id == 1164 || childInterface.id == 1167 || childInterface.id == 1170 || childInterface.id == 1174 || childInterface.id == 1540 || childInterface.id == 1541
							|| childInterface.id == 7455 || childInterface.id == 18470 || childInterface.id == 13035 || childInterface.id == 13045 || childInterface.id == 13053
							|| childInterface.id == 13061 || childInterface.id == 13069 || childInterface.id == 13079 || childInterface.id == 30064 || childInterface.id == 30075
							|| childInterface.id == 30083 || childInterface.id == 30106 || childInterface.id == 30114 || childInterface.id == 30106 || childInterface.id == 30170
							|| childInterface.id == 13087 || childInterface.id == 30162 || childInterface.id == 13095) {
						sprite = childInterface.sprite2;
					}
					if (childInterface.id == 21746) {
						childInterface.valueIndexArray[1][2] = 560;
					}
					// Makes teleports always lit up
					if (spellSelected == 1 && childInterface.id == spellID && spellID != 0 && sprite != null) {
						sprite.drawSprite(childX, childY, 0xffffff);
					} else {
						if (sprite != null) {
							if (childInterface.drawsTransparent) {
								sprite.drawTransparentSprite(childX, childY, alpha);
							} else {
								sprite.drawSprite(childX, childY);
							}
						}
					}
					if (autocast && childInterface.id == spellID && childInterface.id == autocastId) {
						cacheSprite[497].drawSprite(childX - 3, childY - 3);
					}
					if (sprite != null) {
						if (childInterface.drawsTransparent) {
							sprite.drawTransparentSprite(childX, childY, alpha);
						} else {
							sprite.drawSprite(childX, childY);
						}
					}

				} else if (childInterface.type == 6) {
					int k3 = Rasterizer.centerX;
					int j4 = Rasterizer.centerY;
					Rasterizer.centerX = childX + childInterface.width / 2;
					Rasterizer.centerY = childY + childInterface.height / 2;
					int i5 = Rasterizer.SINE[childInterface.modelRotation1] * childInterface.modelZoom >> 16;
					int l5 = Rasterizer.COSINE[childInterface.modelRotation1] * childInterface.modelZoom >> 16;
					boolean flag2 = interfaceIsSelected(childInterface);
					int i7;
					if (flag2) {
						i7 = childInterface.anInt258;
					} else {
						i7 = childInterface.anInt257;
					}
					Model model;
					if (i7 == -1) {
						model = childInterface.method209(-1, -1, flag2);
					} else {
						Animation animation = Animation.cache[i7];
						model = childInterface.method209(animation.frame1IDS[childInterface.anInt246], animation.frame2IDS[childInterface.anInt246], flag2);
					}
					if (model != null) {
						// model.method482(childInterface.modelRotation2, 0,
						// childInterface.modelRotation1, 0, i5, l5);
						model.method482(childInterface.modelRotation2, 0, childInterface.modelRotation1, 0, i5, l5);

					}
					Rasterizer.centerX = k3;
					Rasterizer.centerY = j4;
				} else if (childInterface.type == 7) {
					TextDrawingArea textDrawingArea_1 = childInterface.textDrawingAreas;
					int k4 = 0;
					for (int j5 = 0; j5 < childInterface.height; j5++) {
						for (int i6 = 0; i6 < childInterface.width; i6++) {
							if (childInterface.inv[k4] > 0) {
								ItemDefinition itemDef = ItemDefinition.get(childInterface.inv[k4] - 1);
								String s2 = itemDef.name;
								if (itemDef.stackable || childInterface.invStackSizes[k4] != 1) {
									s2 = s2 + " x" + intToKOrMilLongName(childInterface.invStackSizes[k4]);
								}
								int i9 = childX + i6 * (115 + childInterface.invSpritePadX);
								int k9 = childY + j5 * (12 + childInterface.invSpritePadY);
								if (childInterface.centerText) {
									textDrawingArea_1.method382(childInterface.textColor, i9 + childInterface.width / 2, s2, k9, childInterface.textShadow);
								} else {
									textDrawingArea_1.method389(childInterface.textShadow, i9, childInterface.textColor, s2, k9);
								}
							}
							k4++;
						}
					}
				} else if (childInterface.type == 8 && (anInt1500 == childInterface.id || anInt1044 == childInterface.id || anInt1129 == childInterface.id) && anInt1501 == 50 && !menuOpen) {
					int boxWidth = 0;
					int boxHeight = 0;
					TextDrawingArea textDrawingArea_2 = normalText;
					for (String s1 = childInterface.message; s1.length() > 0;) {
						if (s1.indexOf("%") != -1) {
							do {
								int k7 = s1.indexOf("%1");
								if (k7 == -1) {
									break;
								}
								s1 = s1.substring(0, k7) + interfaceIntToString(extractInterfaceValues(childInterface, 0)) + s1.substring(k7 + 2);
							} while (true);
							do {
								int l7 = s1.indexOf("%2");
								if (l7 == -1) {
									break;
								}
								s1 = s1.substring(0, l7) + interfaceIntToString(extractInterfaceValues(childInterface, 1)) + s1.substring(l7 + 2);
							} while (true);
							do {
								int i8 = s1.indexOf("%3");
								if (i8 == -1) {
									break;
								}
								s1 = s1.substring(0, i8) + interfaceIntToString(extractInterfaceValues(childInterface, 2)) + s1.substring(i8 + 2);
							} while (true);
							do {
								int j8 = s1.indexOf("%4");
								if (j8 == -1) {
									break;
								}
								s1 = s1.substring(0, j8) + interfaceIntToString(extractInterfaceValues(childInterface, 3)) + s1.substring(j8 + 2);
							} while (true);
							do {
								int k8 = s1.indexOf("%5");
								if (k8 == -1) {
									break;
								}
								s1 = s1.substring(0, k8) + interfaceIntToString(extractInterfaceValues(childInterface, 4)) + s1.substring(k8 + 2);
							} while (true);
						}
						int l7 = s1.indexOf("\\n");
						String s4;
						if (l7 != -1) {
							s4 = s1.substring(0, l7);
							s1 = s1.substring(l7 + 2);
						} else {
							s4 = s1;
							s1 = "";
						}
						int j10 = textDrawingArea_2.getTextWidth(s4);
						if (j10 > boxWidth) {
							boxWidth = j10;
						}
						boxHeight += textDrawingArea_2.anInt1497 + 1;
					}
					boxWidth += 6;
					boxHeight += 7;
					int xPos = childX + childInterface.width - 5 - boxWidth;
					int yPos = childY + childInterface.height + 5;
					if (xPos < childX + 5) {
						xPos = childX + 5;
					}
					if (xPos + boxWidth > interfaceX + class9.width) {
						xPos = interfaceX + class9.width - boxWidth;
					}
					if (yPos + boxHeight > interfaceY + class9.height) {
						yPos = childY - boxHeight;
					}
					DrawingArea.drawPixels(boxHeight, yPos, xPos, 0xFFFFA0, boxWidth);
					DrawingArea.fillPixels(xPos, boxWidth, boxHeight, 0, yPos);
					String s2 = childInterface.message;
					for (int j11 = yPos + textDrawingArea_2.anInt1497 + 2; s2.length() > 0; j11 += textDrawingArea_2.anInt1497 + 1) {// anInt1497
						if (s2.indexOf("%") != -1) {
							do {
								int k7 = s2.indexOf("%1");
								if (k7 == -1) {
									break;
								}
								s2 = s2.substring(0, k7) + interfaceIntToString(extractInterfaceValues(childInterface, 0)) + s2.substring(k7 + 2);
							} while (true);
							do {
								int l7 = s2.indexOf("%2");
								if (l7 == -1) {
									break;
								}
								s2 = s2.substring(0, l7) + interfaceIntToString(extractInterfaceValues(childInterface, 1)) + s2.substring(l7 + 2);
							} while (true);
							do {
								int i8 = s2.indexOf("%3");
								if (i8 == -1) {
									break;
								}
								s2 = s2.substring(0, i8) + interfaceIntToString(extractInterfaceValues(childInterface, 2)) + s2.substring(i8 + 2);
							} while (true);
							do {
								int j8 = s2.indexOf("%4");
								if (j8 == -1) {
									break;
								}
								s2 = s2.substring(0, j8) + interfaceIntToString(extractInterfaceValues(childInterface, 3)) + s2.substring(j8 + 2);
							} while (true);
							do {
								int k8 = s2.indexOf("%5");
								if (k8 == -1) {
									break;
								}
								s2 = s2.substring(0, k8) + interfaceIntToString(extractInterfaceValues(childInterface, 4)) + s2.substring(k8 + 2);
							} while (true);
						}
						int l11 = s2.indexOf("\\n");
						String s5;
						if (l11 != -1) {
							s5 = s2.substring(0, l11);
							s2 = s2.substring(l11 + 2);
						} else {
							s5 = s2;
							s2 = "";
						}
						if (childInterface.centerText) {
							textDrawingArea_2.method382(yPos, xPos + childInterface.width / 2, s5, j11, false);
						} else {
							if (s5.contains("\\r")) {
								String text = s5.substring(0, s5.indexOf("\\r"));
								String text2 = s5.substring(s5.indexOf("\\r") + 2);
								textDrawingArea_2.method389(false, xPos + 3, 0, text, j11);
								int rightX = boxWidth + xPos - textDrawingArea_2.getTextWidth(text2) - 2;
								textDrawingArea_2.method389(false, rightX, 0, text2, j11);
								System.out.println("Box: " + boxWidth + "");
							} else {
								textDrawingArea_2.method389(false, xPos + 3, 0, s5, j11);
							}
						}
					}
				} else if (childInterface.type == 9) {
					if (interfaceIsSelected(childInterface)) {
					} else {
						try {
							drawHoverBox(childX, childY, childInterface.tooltipBoxText);
						} catch (Exception e) {

						}
					}
				} else if (childInterface.type == 10) {
					Sprite sprite;
					if (interfaceIsSelected(childInterface)) {
						sprite = childInterface.sprite2;
					} else {
						sprite = childInterface.sprite1;
					}
					if (sprite != null) {
						sprite.drawSpriteWithOpacity(childX, childY, childInterface.opacity);
					}
				}
			}
		}
		DrawingArea.setBounds(i1, j1, k1, l1);
	}

	private void drawLoadingMessages(int used, String s, String s1) {
		int width = normalText.getTextWidth(used == 1 ? s : s1);
		int height = s1 == null ? 25 : 38;
		DrawingArea.drawPixels(height, 1, 1, 0, width + 6);
		DrawingArea.drawPixels(1, 1, 1, 0xffffff, width + 6);
		DrawingArea.drawPixels(height, 1, 1, 0xffffff, 1);
		DrawingArea.drawPixels(1, height, 1, 0xffffff, width + 6);
		DrawingArea.drawPixels(height, 1, width + 6, 0xffffff, 1);
		normalText.drawText(0xffffff, s, 18, width / 2 + 5);
		if (s1 != null) {
			normalText.drawText(0xffffff, s1, 31, width / 2 + 5);
		}
	}

	@Override
	public void drawLoadingText(int i, String... s) {
		resetImageProducers();
		if (titleStreamLoader == null) {
			super.drawLoadingText(i, s);
			return;
		}
		if (cacheSprite != null) {
			this.titleScreenIP.initDrawingArea();
			final int centerX = 765 / 2, centerY = 503 / 2;
			int y = centerY - 18;

			titleScreenIP.initDrawingArea();
			DrawingArea.fillPixels(centerX - 152, 304, 34, 0x8C1111, y);
			DrawingArea.fillPixels(centerX - 151, 302, 32, 0, y + 1);
			DrawingArea.drawPixels(30, y + 2, centerX - 150, 0x8C1111, i * 3);
			DrawingArea.drawPixels(30, y + 2, (centerX - 150) + i * 3, 0, 300 - i * 3);
			newBoldFont.drawCenteredString(s[0] + " - " + i + "%", centerX, (y + 22), 0xffffff, -1);
			titleScreenIP.drawGraphics(0, super.graphics, 0);
		}
	}

	public void drawSmoothLoading(int percent, String... loadingMessage) {

		for (float f = lastPercent; f < percent; f = (float) (f + 0.39999999999999999D)) {
			drawLoadingText((int) f + 1, loadingMessage);
		}
		lastPercent = percent;
		for (int i = 0; i < startupMessage.length; i++) {
			if (i < loadingMessage.length && loadingMessage[i] != null) {
				startupMessage[i] = loadingMessage[i];
			} else {
				startupMessage[i] = "";
			}
		}
	}

	public int duelStatus;
	private boolean resizing;
	public final int REGULAR_WIDTH = 765, REGULAR_HEIGHT = 503, RESIZABLE_WIDTH = 800, RESIZABLE_HEIGHT = 600;
	public int gameScreenDrawX = 4, gameScreenDrawY = 4;

	public void recreateClientFrame(boolean undecorative, int width, int height, boolean resizable, int displayMode, boolean toggle) {
		recreateClientFrame(undecorative, width, height, resizable);
	}

	private LoginScreen loginScreen = new LoginScreen();

	public void drawLoginScreen(boolean flag) {

		resetImageProducers();
		titleScreenIP.initDrawingArea();

		loginScreen.draw(this);

		if (!resizing) {
			titleScreenIP.drawGraphics(0, super.graphics, 0);
		}
		if (welcomeScreenRaised) {
			welcomeScreenRaised = false;
		}
	}

	private void drawLogo() {
		resetImageProducers();
		System.gc();
	}

	public void drawMenu() {
		int xPos = menuOffsetX;
		int yPos = menuOffsetY;
		int menuW = menuWidth;
		int x = super.mouseX;
		int y = super.mouseY;
		int menuH = menuHeight + 1;
		if (menuScreenArea == 1 && GameFrame.getScreenMode() != ScreenMode.FIXED) {
			xPos += 519;// +extraWidth;
			yPos += 168;// +extraHeight;
		}
		if (menuScreenArea == 2 && GameFrame.getScreenMode() != ScreenMode.FIXED) {
			yPos += 338;
		}
		if (menuScreenArea == 3 && GameFrame.getScreenMode() != ScreenMode.FIXED) {
			xPos += 515;
			yPos += 0;
		}
		if (menuScreenArea == 0) {
			x -= 4;
			y -= 4;
		}
		if (menuScreenArea == 1) {
			if (!(GameFrame.getScreenMode() != ScreenMode.FIXED)) {
				x -= 519;
				y -= 168;
			}
		}
		if (menuScreenArea == 2) {
			if (!(GameFrame.getScreenMode() != ScreenMode.FIXED)) {
				x -= 17;
				y -= 338;
			}
		}
		if (menuScreenArea == 3 && !(GameFrame.getScreenMode() != ScreenMode.FIXED)) {
			x -= 515;
			y -= 0;
		}
		DrawingArea.drawPixels(menuH - 4, yPos + 2, xPos, 0x706a5e, menuW);
		DrawingArea.drawPixels(menuH - 2, yPos + 1, xPos + 1, 0x706a5e, menuW - 2);
		DrawingArea.drawPixels(menuH, yPos, xPos + 2, 0x706a5e, menuW - 4);
		DrawingArea.drawPixels(menuH - 2, yPos + 1, xPos + 3, 0x2d2822, menuW - 6);
		DrawingArea.drawPixels(menuH - 4, yPos + 2, xPos + 2, 0x2d2822, menuW - 4);
		DrawingArea.drawPixels(menuH - 6, yPos + 3, xPos + 1, 0x2d2822, menuW - 2);
		DrawingArea.drawPixels(menuH - 22, yPos + 19, xPos + 2, 0x524a3d, menuW - 4);
		DrawingArea.drawPixels(menuH - 22, yPos + 20, xPos + 3, 0x524a3d, menuW - 6);
		DrawingArea.drawPixels(menuH - 23, yPos + 20, xPos + 3, 0x2b271c, menuW - 6);
		DrawingArea.fillPixels(xPos + 3, menuW - 6, 1, 0x2a291b, yPos + 2);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x2a261b, yPos + 3);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x252116, yPos + 4);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x211e15, yPos + 5);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x1e1b12, yPos + 6);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x1a170e, yPos + 7);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 2, 0x15120b, yPos + 8);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x100d08, yPos + 10);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x090a04, yPos + 11);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x080703, yPos + 12);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x090a04, yPos + 13);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x070802, yPos + 14);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x090a04, yPos + 15);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x070802, yPos + 16);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x090a04, yPos + 17);
		DrawingArea.fillPixels(xPos + 2, menuW - 4, 1, 0x2a291b, yPos + 18);
		DrawingArea.fillPixels(xPos + 3, menuW - 6, 1, 0x564943, yPos + 19);
		newBoldFont.drawBasicString("Choose Option", xPos + 3, yPos + 14, 0xc6b895, 0);
		int beforeX = xPos;
		for (int index = 0; index < menuActionRow; index++) {
			int yOffset = yPos + 31 + (menuActionRow - 1 - index) * 15;
			int color = 0xffffff;
			if (x > xPos && x < xPos + menuW && y > yOffset - 11 && y < yOffset + 5) {
				DrawingArea.drawPixels(15, yOffset - 11, xPos + 3, 0x6f695d, menuWidth - 6);
				color = 0xffff00;
			}
			xPos += 3;
			newBoldFont.drawBasicString(menuActionName[index], xPos, yOffset, color, 0);
			xPos = beforeX;
		}
	}

	private void drawMinimap() {
		getMapArea().setxPos(GameFrame.getScreenMode() == ScreenMode.FIXED ? 519 : getScreenWidth() - 170);
		getMapArea().setyPos(GameFrame.getScreenMode() == ScreenMode.FIXED ? 0 : 1);
		getMapArea().render(this);
	}

	public void drawMinimapFlag(Sprite sprite, int j, int k) {
		int l = k * k + j * j;
		if (l > 4225 && l < 0x15f90) {
			int i1 = viewRotation + minimapRotation & 0x7ff;
			int j1 = Model.modelIntArray1[i1];
			int k1 = Model.modelIntArray2[i1];
			j1 = j1 * 256 / (minimapZoom + 256);
			k1 = k1 * 256 / (minimapZoom + 256);
			int l1 = j * j1 + k * k1 >> 16;
			int i2 = j * k1 - k * j1 >> 16;
			double d = Math.atan2(l1, i2);
			int j2 = (int) (Math.sin(d) * 63D);
			int k2 = (int) (Math.cos(d) * 57D);
			mapEdge.method353(83 - k2 - 20, d, 94 + j2 + 4 - 10);
		} else {
			markMinimap(sprite, k, j);
		}
	}

	public void drawScrollbar(int barHeight, int scrollPos, int yPos, int xPos, int contentHeight, boolean newScroller, boolean isTransparent) {
		int backingAmount = (barHeight - 32) / 5;
		int scrollPartHeight = (barHeight - 32) * barHeight / contentHeight;
		int scrollerID;
		if (newScroller) {
			scrollerID = 4;
		} else if (isTransparent) {
			scrollerID = 8;
		} else {
			scrollerID = 0;
		}
		if (scrollPartHeight < 10) {
			scrollPartHeight = 10;
		}
		int scrollPartAmount = scrollPartHeight / 5 - 2;
		int scrollPartPos = (barHeight - 32 - scrollPartHeight) * scrollPos / (contentHeight - barHeight) + 16 + yPos;
		/* Bar fill */
		for (int i = 0, yyPos = yPos + 16; i <= backingAmount; i++, yyPos += 5) {
			scrollPart[scrollerID + 1].drawSprite(xPos, yyPos);
		}
		/* Top of bar */
		scrollPart[scrollerID + 2].drawSprite(xPos, scrollPartPos);
		scrollPartPos += 5;
		/* Middle of bar */
		for (int i = 0; i <= scrollPartAmount; i++) {
			scrollPart[scrollerID + 3].drawSprite(xPos, scrollPartPos);
			scrollPartPos += 5;
		}
		scrollPartPos = (barHeight - 32 - scrollPartHeight) * scrollPos / (contentHeight - barHeight) + 16 + yPos + scrollPartHeight - 5;
		/* Bottom of bar */
		scrollPart[scrollerID].drawSprite(xPos, scrollPartPos);
		/* Arrows */
		if (newScroller) {
			scrollBar[2].drawSprite(xPos, yPos);
			scrollBar[3].drawSprite(xPos, yPos + barHeight - 16);
		} else if (isTransparent) {
			scrollBar[4].drawSprite(xPos, yPos);
			scrollBar[5].drawSprite(xPos, yPos + barHeight - 16);
		} else {
			scrollBar[0].drawSprite(xPos, yPos);
			scrollBar[1].drawSprite(xPos, yPos + barHeight - 16);
		}
	}

	private void drawSplitPrivateChat() {
		if (splitPrivateChat == 0) {
			return;
		}
		TextDrawingArea textDrawingArea = normalText;
		int messages = 0;
		if (systemUpdateTimer != 0) {
			messages = 1;
		}
		for (int index = 0; index < 100; index++) {
			if (chatMessages[index] != null) {
				int type = chatTypes[index];
				String name = chatNames[index];
				String prefixName = name;
				int rights = 0;
				if (name != null) {
					if (name.indexOf("@") == 0) {
						name = name.substring(5);
					}
				}

				int paddingY = GameFrame.getScreenMode() == ScreenMode.FIXED ? 0 : getScreenHeight() - 500;

				if ((type == 3 || type == 7) && (type == 7 || privateChatMode == 0 || privateChatMode == 1 && isFriendOrSelf(name))) {
					int yOffset = 329 + paddingY - messages * 13;
					int xOffset = 4;
					textDrawingArea.method385(0, "From", yOffset, xOffset);
					textDrawingArea.method385(ChatArea.SPLIT_CHAT_COLORS[splitChatColor], "From", yOffset - 1, xOffset);
					xOffset += textDrawingArea.getTextWidth("From ");

					if (prefixName != null && prefixName.indexOf("@") == 0) {
						rights = getPrefixRights(prefixName.substring(0, prefixName.indexOf(name)));
					}

					if (rights != 0) {
						modIcons[rights - 1].drawTransparentSprite(xOffset, yOffset - 12, 255);
						xOffset += modIcons[rights - 1].maxWidth + 2;
					}

					textDrawingArea.method385(0, name + ": " + chatMessages[index], yOffset, xOffset);
					textDrawingArea.method385(ChatArea.SPLIT_CHAT_COLORS[splitChatColor], name + ": " + chatMessages[index], yOffset - 1, xOffset);

					if (++messages >= 5) {
						return;
					}
				}

				if (type == 5 && privateChatMode < 2) {
					int yOffset = 329 + paddingY - messages * 13;
					textDrawingArea.method385(0, chatMessages[index], yOffset, 4);
					textDrawingArea.method385(ChatArea.SPLIT_CHAT_COLORS[splitChatColor], chatMessages[index], yOffset - 1, 4);

					if (++messages >= 5) {
						return;
					}
				}

				if (type == 6 && privateChatMode < 2) {
					int yOffset = 329 + paddingY - messages * 13;
					int xOffset = 4;
					textDrawingArea.method385(0, "To", yOffset, xOffset);
					textDrawingArea.method385(ChatArea.SPLIT_CHAT_COLORS[splitChatColor], "To", yOffset - 1, xOffset);
					xOffset += textDrawingArea.getTextWidth("To ");

					if (rights != 0) {
						modIcons[rights - 1].drawTransparentSprite(xOffset, yOffset - 12, 255);
						xOffset += 12;
					}

					textDrawingArea.method385(0, name + ": " + chatMessages[index], yOffset, xOffset);
					textDrawingArea.method385(ChatArea.SPLIT_CHAT_COLORS[splitChatColor], name + ": " + chatMessages[index], yOffset - 1, xOffset);

					if (++messages >= 5) {
						return;
					}
				}
			}
		}
	}

	public void updateBankInterface() {
		int tabAmount = settings[2000] & 0xFF;
		int activeTab = settings[2000] >> 8 & 0xFF;
		Sprite activeTabSprite = cacheSprite[617];
		Sprite tabSprite = cacheSprite[613];
		Sprite newTabSprite = cacheSprite[614];
		Sprite emptySprite = new Sprite(0, 0);
		for (int i = 0; i < 9; i++) {
			if (i < tabAmount) {
				RSInterface.interfaceCache[41018 + i].sprite1 = tabSprite;
				RSInterface.interfaceCache[41018 + i].tooltip = "Click here to select tab " + (i + 1);
			} else {
				RSInterface.interfaceCache[41018 + i].sprite1 = emptySprite;
				RSInterface.interfaceCache[41018 + i].tooltip = "";
			}
			RSInterface.interfaceCache[41027 + i].inv[0] = -1;
			RSInterface.interfaceCache[41027 + i].invStackSizes[0] = 0;
		}
		if (tabAmount < 9) {
			RSInterface.interfaceCache[41018 + tabAmount].sprite1 = newTabSprite;
			RSInterface.interfaceCache[41018 + tabAmount].tooltip = "Drag an item here to create a new tab";
		}
		RSInterface.interfaceCache[41018 + activeTab].sprite1 = activeTabSprite;

	}

	public void processBankInterface() {
		boolean fixed = GameFrame.getScreenMode() == ScreenMode.FIXED;
		int offsetX = fixed ? 0 : (getScreenWidth() - 765) / 2;
		int offsetY = fixed ? 0 : (getScreenHeight() - 503) / 2;
		int[] offsets = { 74, 121, 168, 215, 262, 309, 356, 403, 450 };
		if (anInt1084 == 5382 && super.mouseY >= 40 + offsetY && super.mouseY <= 77 + offsetY) {
			for (int i = 0; i < offsets.length; i++) {
				if (super.mouseX < offsets[i] + offsetX) {
					getOut().putOpcode(209);
					getOut().method433(5383);
					getOut().method424(0);
					getOut().method433(anInt1085);
					getOut().method431(i);
					break;
				}
			}
		}
	}

	private void drawTabArea() {
		tabArea.setxPos(GameFrame.getScreenMode() == ScreenMode.FIXED ? 516 : getScreenWidth() - tabArea.getWidth() + 12);
		tabArea.setyPos(GameFrame.getScreenMode() == ScreenMode.FIXED ? 168 : getScreenHeight() - tabArea.getHeight() + 2);
		tabArea.render(this);
	}

	private int cursor;

	private void drawTooltip() {
		if (!config.getStatus(ConfigType.NEW_CURSORS)) {
			if (cursor != -1) {
				super.getGameComponent().setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
				cursor = -1;
			}
		} else {
			if (jFrame != null) {
				int newCursor = getCursorID() + 648;
				if (cursor != newCursor) {
					if (SpriteLoader.cache != null) {
						jFrame.setCursor(SpriteLoader.cache[newCursor].spriteData);
					} else {
						jFrame.setCursor(newCursor);
					}
					cursor = newCursor;
				}
			}
		}
		if (menuActionRow < 2 && itemSelected == 0 && spellSelected == 0) {
			return;
		}
		String tooltip;
		if (itemSelected == 1 && menuActionRow < 2) {
			tooltip = "Use " + selectedItemName + " with...";
		} else if (spellSelected == 1 && menuActionRow < 2) {
			tooltip = spellTooltip + "...";
		} else {
			tooltip = menuActionName[menuActionRow - 1];
		}
		if (menuActionRow > 2) {
			tooltip = tooltip + "@whi@ / " + (menuActionRow - 2) + " more options";
		}
		newBoldFont.drawBasicString(tooltip, 4, 15, 0xFFFFFF, 0);
		// chatTextDrawingArea.method390(4, 0xffffff, tooltip, loopCycle / 1000,
		// 15);
	}

	private void dropClient() {
		if (idleStatus > 0) {
			resetLogout();
			return;
		}

		if (gameScreenIP != null) {
			gameScreenIP.initDrawingArea();
		}
		DrawingArea.fillPixels(2, 229, 39, 0xffffff, 2); // white box around
		DrawingArea.drawPixels(37, 3, 3, 0, 227); // black fill
		normalText.drawText(0, "Connection lost.", 19, 120);
		normalText.drawText(0xffffff, "Connection lost.", 18, 119);
		normalText.drawText(0, "Please wait - attempting to reestablish.", 34, 117);
		normalText.drawText(0xffffff, "Please wait - attempting to reestablish.", 34, 116);
		if (!resizing && gameScreenIP != null) {
			gameScreenIP.drawGraphics(gameScreenDrawY, super.graphics, gameScreenDrawX);
		}
		anInt1021 = 0;
		destX = 0;
		Connection rsSocket = getConnection();
		loggedIn = false;
		setLoginFailures(0);
		login(getPassword(), true, getMyUsername());

		if (!loggedIn) {
			resetLogout();
		}

		try {
			rsSocket.close();
		} catch (Exception _ex) {
		}
	}

	private int extractInterfaceValues(RSInterface class9, int j) {
		if (class9.valueIndexArray == null || j >= class9.valueIndexArray.length) {
			return -2;
		}

		try {
			int[] ai = class9.valueIndexArray[j];
			int k = 0;
			int l = 0;
			int i1 = 0;

			do {
				int j1 = ai[l++];
				int k1 = 0;
				byte byte0 = 0;
				if (j1 == 0) {
					return k;
				}
				if (j1 == 1) {
					k1 = currentStats[ai[l++]];
				}
				if (j1 == 2) {
					k1 = maxStats[ai[l++]];
				}
				if (j1 == 3) {
					k1 = currentExp[ai[l++]];
				}
				if (j1 == 4) {
					RSInterface class9_1 = RSInterface.interfaceCache[ai[l++]];
					int k2 = ai[l++];
					if (k2 >= 0 && k2 < ItemDefinition.totalItems && (!ItemDefinition.get(k2).membersObject || isMembers)) {
						for (int j3 = 0; j3 < class9_1.inv.length; j3++) {
							if (class9_1.inv[j3] == k2 + 1) {
								k1 += class9_1.invStackSizes[j3];
							}
						}

					}
				}
				if (j1 == 5) {
					k1 = variousSettings[ai[l++]];
				}
				if (j1 == 6) {
					k1 = anIntArray1019[maxStats[ai[l++]] - 1];
				}
				if (j1 == 7) {
					k1 = variousSettings[ai[l++]] * 100 / 46875;
				}
				if (j1 == 8) {
					k1 = myPlayer.combatLevel;
				}
				if (j1 == 9) {
					for (int l1 = 0; l1 < Skills.SKILL_COUNT; l1++) {
						if (Skills.SKILL_ENABLED[l1]) {
							k1 += maxStats[l1];
						}
					}

				}
				if (j1 == 10) {
					RSInterface class9_2 = RSInterface.interfaceCache[ai[l++]];
					int l2 = ai[l++] + 1;
					if (l2 >= 0 && l2 < ItemDefinition.totalItems && (!ItemDefinition.get(l2).membersObject || isMembers)) {
						for (int element : class9_2.inv) {
							if (element != l2) {
								continue;
							}
							k1 = 0x3b9ac9ff;
							break;
						}

					}
				}
				if (j1 == 11) {
					k1 = energy;
				}
				if (j1 == 12) {
					k1 = weight;
				}
				if (j1 == 13) {
					int i2 = variousSettings[ai[l++]];
					int i3 = ai[l++];
					k1 = (i2 & 1 << i3) == 0 ? 0 : 1;
				}
				if (j1 == 14) {
					int j2 = ai[l++];
					VarBit varBit = VarBit.cache[j2];
					int l3 = varBit.configId;
					int i4 = varBit.configValue;
					int j4 = varBit.anInt650;
					int k4 = anIntArray1232[j4 - i4];
					k1 = variousSettings[l3] >> i4 & k4;
				}
				if (j1 == 15) {
					byte0 = 1;
				}
				if (j1 == 16) {
					byte0 = 2;
				}
				if (j1 == 17) {
					byte0 = 3;
				}
				if (j1 == 18) {
					k1 = (myPlayer.x >> 7) + baseX;
				}
				if (j1 == 19) {
					k1 = (myPlayer.y >> 7) + baseY;
				}
				if (j1 == 20) {
					k1 = ai[l++];
				}
				if (byte0 == 0) {
					if (i1 == 0) {
						k += k1;
					}
					if (i1 == 1) {
						k -= k1;
					}
					if (i1 == 2 && k1 != 0) {
						k /= k1;
					}
					if (i1 == 3) {
						k *= k1;
					}
					i1 = 0;
				} else {
					i1 = byte0;
				}
			} while (true);
		} catch (Exception _ex) {
			return -1;
		}
	}

	public void generateWorld(int x, int y) {
		terrainRegionX = x;
		terrainRegionY = y;
		aBoolean1159 = false;
		if (anInt1069 == x && anInt1070 == y && loadingStage == 2) {
			return;
		}
		anInt1069 = x;
		anInt1070 = y;
		baseX = (anInt1069 - 6) * 8;
		baseY = (anInt1070 - 6) * 8;
		aBoolean1141 = (anInt1069 / 8 == 48 || anInt1069 / 8 == 49) && anInt1070 / 8 == 48;
		if (anInt1069 / 8 == 48 && anInt1070 / 8 == 148) {
			aBoolean1141 = true;
		}
		loadingStage = 1;
		aLong824 = System.currentTimeMillis();
		int k16 = 0;
		for (int i21 = (anInt1069 - 6) / 8; i21 <= (anInt1069 + 6) / 8; i21++) {
			for (int k23 = (anInt1070 - 6) / 8; k23 <= (anInt1070 + 6) / 8; k23++) {
				k16++;
			}
		}
		aByteArrayArray1183 = new byte[k16][];
		aByteArrayArray1247 = new byte[k16][];
		anIntArray1234 = new int[k16];
		floorMap = new int[k16];
		objectMap = new int[k16];
		k16 = 0;
		for (int l23 = (anInt1069 - 6) / 8; l23 <= (anInt1069 + 6) / 8; l23++) {
			for (int j26 = (anInt1070 - 6) / 8; j26 <= (anInt1070 + 6) / 8; j26++) {
				anIntArray1234[k16] = (l23 << 8) + j26;
				if (aBoolean1141 && (j26 == 49 || j26 == 149 || j26 == 147 || l23 == 50 || l23 == 49 && j26 == 47)) {
					floorMap[k16] = -1;
					objectMap[k16] = -1;
					k16++;
				} else {
					int k28 = floorMap[k16] = onDemandFetcher.getMapCount(0, j26, l23);
					if (k28 != -1) {
						onDemandFetcher.requestFileData(3, k28);
					}
					int j30 = objectMap[k16] = onDemandFetcher.getMapCount(1, j26, l23);
					if (j30 != -1) {
						onDemandFetcher.requestFileData(3, j30);
					}
					k16++;
				}
			}
		}
		int i17 = baseX - anInt1036;
		int j21 = baseY - anInt1037;
		anInt1036 = baseX;
		anInt1037 = baseY;
		for (int j24 = 0; j24 < 16384; j24++) {
			NPC npc = npcArray[j24];
			if (npc != null) {
				for (int j29 = 0; j29 < 10; j29++) {
					npc.smallX[j29] -= i17;
					npc.smallY[j29] -= j21;
				}
				npc.x -= i17 * 128;
				npc.y -= j21 * 128;
			}
		}
		for (int i27 = 0; i27 < getMaxPlayers(); i27++) {
			Player player = playerArray[i27];
			if (player != null) {
				for (int i31 = 0; i31 < 10; i31++) {
					player.smallX[i31] -= i17;
					player.smallY[i31] -= j21;
				}
				player.x -= i17 * 128;
				player.y -= j21 * 128;
			}
		}
		aBoolean1080 = true;
		byte byte1 = 0;
		byte byte2 = 104;
		byte byte3 = 1;
		if (i17 < 0) {
			byte1 = 103;
			byte2 = -1;
			byte3 = -1;
		}
		byte byte4 = 0;
		byte byte5 = 104;
		byte byte6 = 1;
		if (j21 < 0) {
			byte4 = 103;
			byte5 = -1;
			byte6 = -1;
		}
		for (int k33 = byte1; k33 != byte2; k33 += byte3) {
			for (int l33 = byte4; l33 != byte5; l33 += byte6) {
				int i34 = k33 + i17;
				int j34 = l33 + j21;
				for (int k34 = 0; k34 < 4; k34++) {
					if (i34 >= 0 && j34 >= 0 && i34 < 104 && j34 < 104) {
						groundArray[k34][k33][l33] = groundArray[k34][i34][j34];
					} else {
						groundArray[k34][k33][l33] = null;
					}
				}
			}
		}
		for (GameObject gameObject = (GameObject) getaClass19_1179().reverseGetFirst(); gameObject != null; gameObject = (GameObject) getaClass19_1179().reverseGetNext()) {
			gameObject.anInt1297 -= i17;
			gameObject.anInt1298 -= j21;
			if (gameObject.anInt1297 < 0 || gameObject.anInt1298 < 0 || gameObject.anInt1297 >= 104 || gameObject.anInt1298 >= 104) {
				gameObject.unlink();
			}
		}
		if (destX != 0) {
			destX -= i17;
			destY -= j21;
		}
		cameraViewChanged = false;
	}

	@Override
	public AppletContext getAppletContext() {
		if (Signlink.mainapp != null) {
			return Signlink.mainapp.getAppletContext();
		} else {
			return super.getAppletContext();
		}
	}

	private Archive getArchive(int index, String fileName, String cacheArchive, int crc, int loadingBarValue) {
		byte[] buffer = null;
		int timeToWait = 5;

		try {
			if (decompressors[0] != null) {
				buffer = decompressors[0].decompress(index);
			}
		} catch (Exception _ex) {
			_ex.printStackTrace();
		}

		if (buffer != null) {
			if (Constants.JAGCACHED_ENABLED) {
				crc32Instance.reset();
				crc32Instance.update(buffer);
				int crcValue = (int) crc32Instance.getValue();

				if (crcValue != crc) {
					buffer = null;
				}
			}
		}

		if (buffer != null) {
			Archive streamLoader = new Archive(buffer);
			return streamLoader;
		}

		int errorCount = 0;

		while (buffer == null) {
			String error = "Unknown error";
			drawSmoothLoading(loadingBarValue, "Requesting " + fileName);

			try {
				int lastPercentage = 0;
				DataInputStream datainputstream = openJagGrabInputStream(cacheArchive + crc);
				byte temp[] = new byte[6];
				datainputstream.readFully(temp, 0, 6);
				ByteBuffer stream = new ByteBuffer(temp);
				stream.position = 3;
				int totalLength = stream.getTribyte() + 6;
				int currentLength = 6;
				buffer = new byte[totalLength];
				System.arraycopy(temp, 0, buffer, 0, 6);

				while (currentLength < totalLength) {
					int remainingAmount = totalLength - currentLength;

					if (remainingAmount > 1000) {
						remainingAmount = 1000;
					}

					int remaining = datainputstream.read(buffer, currentLength, remainingAmount);

					if (remaining < 0) {
						error = "Length error: " + currentLength + "/" + totalLength;
						throw new IOException("EOF");
					}

					currentLength += remaining;
					int percentage = currentLength * 100 / totalLength;

					if (percentage != lastPercentage) {
						drawSmoothLoading(loadingBarValue, "Loading " + fileName + " - " + percentage + "%");
					}

					lastPercentage = percentage;
				}

				datainputstream.close();

				try {
					if (decompressors[0] != null) {
						decompressors[0].method234(buffer.length, buffer, index);
					}
				} catch (Exception _ex) {
					_ex.printStackTrace();
					decompressors[0] = null;
				}

				if (buffer != null) {
					if (Constants.JAGCACHED_ENABLED) {
						crc32Instance.reset();
						crc32Instance.update(buffer);
						int currentCrc = (int) crc32Instance.getValue();

						if (currentCrc != crc) {
							buffer = null;
							errorCount++;
							error = "Checksum error: " + currentCrc;
						}
					}
				}
			} catch (IOException ioexception) {
				if (error.equals("Unknown error")) {
					error = "Connection error";
				}

				ioexception.printStackTrace();
				buffer = null;
			} catch (NullPointerException _ex) {
				error = "Null error";
				buffer = null;

				_ex.printStackTrace();
				if (!Signlink.reporterror) {
					return null;
				}
			} catch (ArrayIndexOutOfBoundsException _ex) {
				error = "Bounds error";
				buffer = null;

				_ex.printStackTrace();
				if (!Signlink.reporterror) {
					return null;
				}
			} catch (Exception _ex) {
				error = "Unexpected error";
				buffer = null;

				_ex.printStackTrace();
				if (!Signlink.reporterror) {
					return null;
				}
			}
			if (buffer == null) {
				for (int seconds = timeToWait; seconds > 0; seconds--) {
					if (errorCount >= 3) {
						drawSmoothLoading(loadingBarValue, "Game updated - please reload page");
						seconds = 10;
					} else {
						throw new RuntimeException("Unable to find archive: " + name);
					}

					try {
						Thread.sleep(1000L);
					} catch (Exception _ex) {
						_ex.printStackTrace();
					}
				}

				timeToWait *= 2;

				if (timeToWait > 60) {
					timeToWait = 60;
				}

				httpFallback = !httpFallback;
			}
		}

		Archive archive = new Archive(buffer);
		return archive;
	}

	@Override
	public URL getCodeBase() {
		try {
			return new URL(Constants.connectionStatus.getAddress() + ":" + (80 + portOff));
		} catch (Exception _ex) {
		}
		return null;
	}

	public String getDocumentBaseHost() {
		return Signlink.mainapp != null ? Signlink.mainapp.getDocumentBase().getHost().toLowerCase() : "";
	}

	private int getExperienceForLevel(int level) {
		int points = 0;
		int output = 0;

		for (int lvl = 1; lvl <= level; lvl++) {
			points += Math.floor(lvl + 300.0 * Math.pow(2.0, lvl / 7.0));

			if (lvl >= level) {
				return output;
			}

			output = (int) Math.floor(points / 4);
		}

		return 0;
	}

	@Override
	public Component getGameComponent() {
		if (Signlink.mainapp != null) {
			return Signlink.mainapp;
		}
		if (super.mainFrame != null) {
			return super.mainFrame;
		} else {
			return this;
		}
	}

	@Override
	public String getParameter(String s) {
		if (Signlink.mainapp != null) {
			return Signlink.mainapp.getParameter(s);
		} else {
			return super.getParameter(s);
		}
	}

	public String getPrayerBook() {
		return tabInterfaceIDs[5] == 5608 ? "Prayers" : "Curses";
	}

	private String getPrefix(int rights) {
		String prefix = "cr";

		if (rights >= 10) {
			prefix = "c";
		}

		return "@" + prefix + rights + "@";
	}

	public byte getPrefixRights(String prefix) {
		byte rights = 0;
		int start = 3;
		int end = 4;
		if (!prefix.contains("cr")) {
			start = 2;
		}
		try {
			rights = (byte) Integer.parseInt(prefix.substring(start, end));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return rights;
	}

	public void mouseWheelDragged(int i, int j) {
		if (!mouseWheelDown)
			return;

		this.cameraRotationLeft += i * 3;
		this.cameraRotationRight += (j << 1);
	}

	private boolean inCircle(int circleX, int circleY, int clickX, int clickY, int radius) {
		return Math.pow(circleX + radius - clickX, 2) + Math.pow(circleY + radius - clickY, 2) < Math.pow(radius, 2);
	}

	@Override
	public void init() {
		try {
			nodeID = 10;
			portOff = 0;
			// setHighDetail();
			isMembers = true;
			GameFrame.setScreenMode(ScreenMode.FIXED);
			Signlink.storeid = 32;
			instance = this;
			Signlink.startpriv(InetAddress.getLocalHost());
			initClientFrame(765, 503);
		} catch (Exception exception) {
			exception.printStackTrace();
			return;
		}
	}

	public boolean inSprite(boolean Click, Sprite sprite, int xCoord, int yCoord) {
		if (Click && super.clickMode3 != 1) {
			return false;
		}

		return (Click ? saveClickX : mouseX) >= xCoord && (Click ? saveClickX : mouseX) <= xCoord + sprite.myWidth && (Click ? saveClickY : mouseY) >= yCoord
				&& (Click ? saveClickY : mouseY) <= yCoord + sprite.myHeight;
	}

	public boolean mouseInCoords(boolean click, int x, int y, int width, int height) {
		return (click ? saveClickX : mouseX) >= x && (click ? saveClickX : mouseX) <= x + width && (click ? saveClickY : mouseY) >= y && (click ? saveClickY : mouseY) <= y + height;
	}

	private String interfaceIntToString(int j) {
		if (j < 0x3B9AC9FF) {
			return String.valueOf(j);
		} else {
			return "*";
		}
	}

	private boolean interfaceIsSelected(RSInterface class9) {
		if (class9.valueCompareType == null) {
			return false;
		}

		for (int i = 0; i < class9.valueCompareType.length; i++) {
			int j = extractInterfaceValues(class9, i);
			int k = class9.requiredValues[i];

			if (class9.valueCompareType[i] == 2) {
				if (j >= k) {
					return false;
				}
			} else if (class9.valueCompareType[i] == 3) {
				if (j <= k) {
					return false;
				}
			} else if (class9.valueCompareType[i] == 4) {
				if (j == k) {
					return false;
				}
			} else if (j != k) {
				return false;
			}
		}

		return true;
	}

	public boolean isDebugMode() {
		return debugMode;
	}

	public boolean isFriendOrSelf(String name) {
		if (name == null) {
			return false;
		}

		if (name.contains("@")) {
			name = NAME_PATTERN.matcher(name).replaceAll("");
		}

		for (int i = 0; i < friendCount; i++) {
			if (name.equalsIgnoreCase(friendsList[i])) {
				return true;
			}
		}

		return name.equalsIgnoreCase(myPlayer.name);
	}

	public boolean isGameFrameVisible() {
		return gameFrameVisible;
	}

	public boolean isWebclient() {
		return super.mainFrame == null;
	}

	void launchURL(String url) {
		String osName = System.getProperty("os.name");

		try {
			if (osName.startsWith("Mac OS")) {
				Class<?> fileMgr = Class.forName("com.apple.eio.FileManager");
				Method openURL = fileMgr.getDeclaredMethod("openURL", new Class[] { String.class });
				openURL.invoke(null, new Object[] { url });
			} else if (osName.startsWith("Windows")) {
				Runtime.getRuntime().exec("rundll32 url.dll,FileProtocolHandler " + url);
			} else {
				// assume Unix or Linux
				String[] browsers = { "firefox", "opera", "konqueror", "epiphany", "mozilla", "netscape", "safari" };
				String browser = null;

				for (int count = 0; count < browsers.length && browser == null; count++) {
					if (Runtime.getRuntime().exec(new String[] { "which", browsers[count] }).waitFor() == 0) {
						browser = browsers[count];
					}
				}

				if (browser == null) {
					throw new Exception("Could not find web browser");
				} else {
					Runtime.getRuntime().exec(new String[] { browser, url });
				}
			}
		} catch (Exception e) {
			pushMessage("Failed to open URL.", 0, "");
		}
	}

	public static boolean forceRegionLoad;

	private void loadingStages() {
		if (isLowDetail() && loadingStage == 2 && ObjectManager.anInt131 != plane) {
			gameScreenIP.initDrawingArea();
			drawLoadingMessages(1, "Loading - please wait.", null);
			if (!resizing) {
				gameScreenIP.drawGraphics(gameScreenDrawY, super.graphics, gameScreenDrawX);
			}
			loadingStage = 1;
			aLong824 = System.currentTimeMillis();
		}

		if (loadingStage == 1) {
			int j = method54();

			if (j != 0 && System.currentTimeMillis() - aLong824 > 0x57e40L) {
				Signlink.reportError(getMyUsername() + " glcfb " + getServerSeed() + "," + j + "," + isLowDetail() + "," + decompressors[0] + "," + onDemandFetcher.getRemaining() + "," + plane + ","
						+ anInt1069 + "," + anInt1070);
				aLong824 = System.currentTimeMillis();
			}
		}

		if (loadingStage == 2 && plane != getAnInt985()) {
			setAnInt985(plane);
			method24(plane);
		}
	}

	private void loadTitleScreen() {
		/*
		 * byte abyte0[] = titleStreamLoader.getDataForName("title.dat");
		 * backGround = new Sprite(abyte0, this); aBackground_966 = new
		 * Background(titleStreamLoader, "titlebox", 0); aBackground_967 = new
		 * Background(titleStreamLoader, "titlebutton", 0);
		 * aBackgroundArray1152s = new Background[12]; int j = 0; try { j =
		 * Integer.parseInt(getParameter("fl_icon")); } catch (Exception _ex) {
		 * } if (j == 0) { for (int k = 0; k < 12; k++) aBackgroundArray1152s[k]
		 * = new Background(titleStreamLoader, "runes", k);
		 *
		 * } else { for (int l = 0; l < 12; l++) aBackgroundArray1152s[l] = new
		 * Background(titleStreamLoader, "runes", 12 + (l & 3));
		 *
		 * } new Sprite(128, 265); new Sprite(128, 265);
		 *
		 * anIntArray851 = new int[256]; for (int k1 = 0; k1 < 64; k1++)
		 * anIntArray851[k1] = k1 * 0x40000;
		 *
		 * for (int l1 = 0; l1 < 64; l1++) anIntArray851[l1 + 64] = 0xff0000 +
		 * 1024 * l1;
		 *
		 * for (int i2 = 0; i2 < 64; i2++) anIntArray851[i2 + 128] = 0xffff00 +
		 * 4 * i2;
		 *
		 * for (int j2 = 0; j2 < 64; j2++) anIntArray851[j2 + 192] = 0xffffff;
		 *
		 * anIntArray852 = new int[256]; for (int k2 = 0; k2 < 64; k2++)
		 * anIntArray852[k2] = k2 * 1024;
		 *
		 * for (int l2 = 0; l2 < 64; l2++) anIntArray852[l2 + 64] = 65280 + 4 *
		 * l2;
		 *
		 * for (int i3 = 0; i3 < 64; i3++) anIntArray852[i3 + 128] = 65535 +
		 * 0x40000 * i3;
		 *
		 * for (int j3 = 0; j3 < 64; j3++) anIntArray852[j3 + 192] = 0xffffff;
		 *
		 * anIntArray853 = new int[256]; for (int k3 = 0; k3 < 64; k3++)
		 * anIntArray853[k3] = k3 * 4;
		 *
		 * for (int l3 = 0; l3 < 64; l3++) anIntArray853[l3 + 64] = 255 +
		 * 0x40000 * l3;
		 *
		 * for (int i4 = 0; i4 < 64; i4++) anIntArray853[i4 + 128] = 0xff00ff +
		 * 1024 * i4;
		 *
		 * for (int j4 = 0; j4 < 64; j4++) anIntArray853[j4 + 192] = 0xffffff;
		 *
		 * anIntArray1190 = new int[32768]; anIntArray1191 = new int[32768];
		 */
		// randomizeBackground(null);
		drawSmoothLoading(10, "Connecting to fileserver");
	}

	public void loginScreenBG(boolean b) {
		xCameraPos = 6100;
		yCameraPos = 6867;
		zCameraPos = -750;
		xCameraCurve = 2040;
		yCameraCurve = 383;
		resetMap1();
		if (b || scriptManager == null) {
			scriptManager = new ScriptManager(this);
		} else {
			scriptManager.update();
		}
		System.out.println(plane + ":" + scriptManager.mapX + ":" + scriptManager.mapY);
		plane = scriptManager.mapZ;
		loadMap(scriptManager.mapX, scriptManager.mapY);
		resetMap2();
	}

	private void magicOnItem(int id) {
		spellSelected = 1;
		spellID = id;
		anInt1137 = id;
		spellUsableOn = 16;
		itemSelected = 0;
		spellTooltip = "Cast on";
		tabID = 3;
		tabAreaAltered = true;
	}

	private void mainGameProcessor() {
		if (systemUpdateTimer > 1) {
			systemUpdateTimer--;
		}

		if (idleStatus > 0) {
			idleStatus--;
		}

		for (int j = 0; j < 5; j++) {
			if (!parsePacket()) {
				break;
			}
		}
		if (!loggedIn) {
			return;
		}
		synchronized (mouseDetection.locker) {
			if (!flagged) {
				mouseDetection.coordsIndex = 0;
			}
		}

		if (anInt1016 > 0) {
			anInt1016--;
		}

		if (super.keyArray[1] == 1 || super.keyArray[2] == 1 || super.keyArray[3] == 1 || super.keyArray[4] == 1) {
			aBoolean1017 = true;
		}

		if (aBoolean1017 && anInt1016 <= 0) {
			anInt1016 = 20;
			aBoolean1017 = false;
		}

		if (super.awtFocus && !aBoolean954) {
			aBoolean954 = true;
			getOut().putOpcode(3);
			getOut().putShortBigEndian(1);
		}

		if (!super.awtFocus && aBoolean954) {
			aBoolean954 = false;
			getOut().putOpcode(3);
			getOut().putShortBigEndian(0);
		}

		loadingStages();
		method115();
		method90();
		timeSinceLastPacket++;

		if (timeSinceLastPacket > 750) {
			dropClient();
		}
		method114();
		method95();
		method38();
		anInt945++;

		if (crossType != 0) {
			crossIndex += 20;

			if (crossIndex >= 400) {
				crossType = 0;
			}
		}

		if (atInventoryInterfaceType != 0) {
			atInventoryLoopCycle++;

			if (atInventoryLoopCycle >= 15) {
				if (atInventoryInterfaceType == 3) {
					setInputTaken(true);
				}
				atInventoryInterfaceType = 0;
			}
		}

		if (activeInterfaceType != 0) {
			anInt989++;

			if (super.mouseX > anInt1087 + 5 || super.mouseX < anInt1087 - 5 || super.mouseY > anInt1088 + 5 || super.mouseY < anInt1088 - 5) {
				aBoolean1242 = true;
			}

			if (super.getClickMode2() == 0) {
				if (activeInterfaceType == 3) {
					setInputTaken(true);
				}

				activeInterfaceType = 0;

				if (aBoolean1242 && anInt989 >= 15) {
					lastActiveInvInterface = -1;
					processRightClick();
					processBankInterface();

					if (lastActiveInvInterface == anInt1084 && mouseInvInterfaceIndex == anInt1085) {
						if (menuActionRow > 0) {
							doAction(menuActionRow - 1);
						}
					}

					if (lastActiveInvInterface == anInt1084 && mouseInvInterfaceIndex != anInt1085) {

						RSInterface class9 = RSInterface.interfaceCache[anInt1084];
						int j1 = 0;

						if (anInt913 == 1 && class9.contentType == 206) {
							j1 = 1;
						}

						if (class9.inv[mouseInvInterfaceIndex] <= 0) {
							j1 = 0;
						}

						if (class9.deletesTargetSlot) {
							int l2 = anInt1085;
							int l3 = mouseInvInterfaceIndex;
							class9.inv[l3] = class9.inv[l2];
							class9.invStackSizes[l3] = class9.invStackSizes[l2];
							class9.inv[l2] = -1;
							class9.invStackSizes[l2] = 0;
						} else if (j1 == 1) {
							int i3 = anInt1085;

							for (int i4 = mouseInvInterfaceIndex; i3 != i4;) {
								if (i3 > i4) {
									class9.swapInventoryItems(i3, i3 - 1);
									i3--;
								} else if (i3 < i4) {
									class9.swapInventoryItems(i3, i3 + 1);
									i3++;
								}
							}
						} else {
							class9.swapInventoryItems(anInt1085, mouseInvInterfaceIndex);
						}

						getOut().putOpcode(209);
						getOut().method433(anInt1084);
						getOut().method424(j1);
						getOut().method433(anInt1085);
						getOut().method431(mouseInvInterfaceIndex);
					}
				} else if ((anInt1253 == 1 || menuHasAddFriend(menuActionRow - 1)) && menuActionRow > 2) {
					determineMenuSize();
				} else if (menuActionRow > 0) {
					doAction(menuActionRow - 1);
				}

				atInventoryLoopCycle = 10;
				super.clickMode3 = 0;
			}
		}

		if (WorldController.anInt470 != -1) {
			int k = WorldController.anInt470;
			int k1 = WorldController.anInt471;
			boolean flag = doWalkTo(0, 0, 0, 0, myPlayer.smallY[0], 0, 0, k1, myPlayer.smallX[0], true, k);
			WorldController.anInt470 = -1;

			if (flag) {
				crossX = super.saveClickX;
				crossY = super.saveClickY;
				crossType = 1;
				crossIndex = 0;
			}
		}

		if (super.clickMode3 == 1 && aString844 != null) {
			aString844 = null;
			setInputTaken(true);
			super.clickMode3 = 0;
		}

		if (!processMenuClick()) {
			processMainScreenClick();
			tabArea.processTabClick(this, GameFrame.getScreenMode());
		}

		if (super.getClickMode2() == 1 || super.clickMode3 == 1) {
			anInt1213++;
		}

		if (anInt1500 != 0 || anInt1044 != 0 || anInt1129 != 0) {
			if (anInt1501 < 50 && !menuOpen) {
				if (++anInt1501 == 50) {
					if (anInt1500 != 0) {
						inputTaken = true;
					}
				}
			}
		} else if (anInt1501 > 0) {
			anInt1501--;
		}

		if (PlayerHandler.quedBalloonX > -1 && PlayerHandler.quedBalloonY > -1) {
			int x = (myPlayer.x >> 7) + baseX;
			int y = (myPlayer.y >> 7) + baseY;

			if (PlayerHandler.quedBalloonX == x && PlayerHandler.quedBalloonY == y) {
				getOut().putOpcode(159);
				getOut().putShort(PlayerHandler.quedBalloonX);
				getOut().putShort(PlayerHandler.quedBalloonY);
				PlayerHandler.quedBalloonX = PlayerHandler.quedBalloonY = -1;
			}
		}

		if (loadingStage == 2) {
			method108();
		}

		if (loadingStage == 2 && cameraViewChanged) {
			calcCameraPos();
		}

		for (int i1 = 0; i1 < 5; i1++) {
			anIntArray1030[i1]++;
		}

		method73();
		super.idleTime++;

		/**
		 * Idle logout packet
		 */
		if (super.idleTime > 22500) {
			idleStatus = 250;
			super.idleTime -= 1500;
			getOut().putOpcode(202);
		}

		if (cameraOffsetX < -50) {
		}

		if (cameraOffsetX > 50) {
		}

		if (cameraOffsetY < -55) {
		}

		if (cameraOffsetY > 55) {
		}

		if (viewRotationOffset < -40) {
		}

		if (viewRotationOffset > 40) {
		}

		if (minimapRotation < -60) {
		}

		if (minimapRotation > 60) {
		}

		if (minimapZoom < -20) {
		}

		if (minimapZoom > 10) {
		}

		if (++keepAlive > 50) {
			getOut().putOpcode(0);
		}

		/**
		 * Writes data to the out socket
		 */
		try {
			if (getConnection() != null && getOut().position > 0) {
				getConnection().queueBytes(getOut().position, getOut().buffer);
				getOut().position = 0;
				keepAlive = 0;
			}
		} catch (IOException _ex) {
			// _ex.printStackTrace();
			dropClient();
		} catch (Exception exception) {
			resetLogout();
		}
	}

	public void markMinimap(Sprite sprite, int x, int y) {
		if (sprite == null) {
			return;
		}

		boolean fixed = GameFrame.getScreenMode() == ScreenMode.FIXED;
		int rotation = viewRotation + minimapRotation & 0x7ff;
		int xPadding = getMapArea().getOffSetX();
		int yPadding = getMapArea().getyPos();
		int distance = x * x + y * y;

		if (distance > 6400) {
			return;
		}

		int spriteX = Model.modelIntArray1[rotation];
		int spriteY = Model.modelIntArray2[rotation];
		spriteX = spriteX * 256 / (minimapZoom + 256);
		spriteY = spriteY * 256 / (minimapZoom + 256);
		int drawX = y * spriteX + x * spriteY >> 16;
		int drawY = y * spriteY - x * spriteX >> 16;
		int finalX = (fixed ? 104 : 83) + drawX - sprite.maxWidth / 2 + 4;
		int finalY = (fixed ? 89 : 85) - drawY - sprite.maxHeight / 2 - 4;

		try {
			sprite.drawSprite(finalX + xPadding, finalY + yPadding);
		} catch (Exception _ex) {
		}
	}

	private boolean menuHasAddFriend(int j) {
		if (j < 0) {
			return false;
		}

		int k = menuActionID[j];

		if (k >= 2000) {
			k -= 2000;
		}

		return k == 337;
	}

	private Entity interactingWith;

	private void handleFacingEntity(Entity entity) {

		if (entity.anInt1504 == 0) {
			return;
		}

		/**
		 * Facing mob
		 */
		if (entity.interactingEntity != -1 && entity.interactingEntity < 32768 && entity.interactingEntity < npcArray.length) {
			try {
				NPC npc = npcArray[entity.interactingEntity];

				if (entity == myPlayer)
					interactingWith = npc;
				if (npc != null) {
					int i1 = entity.x - npc.x;
					int k1 = entity.y - npc.y;
					if (i1 != 0 || k1 != 0) {
						entity.turnDirection = (int) (Math.atan2(i1, k1) * 325.94900000000001D) & 0x7ff;
					}
				}
			} catch (Exception ex) {
			}
		}

		/**
		 * Handle facing a player
		 */
		if (entity.interactingEntity >= 32768) {

			int index = entity.interactingEntity - 32768;

			if (index == playerIndex) {
				index = myPlayerIndex;
			}

			Player player = playerArray[index];

			if (player != null) {

				if (entity == myPlayer && player != myPlayer)
					interactingWith = player;

				int deltaX = entity.x - player.x;
				int deltaY = entity.y - player.y;
				if (deltaX != 0 || deltaY != 0) {
					entity.turnDirection = (int) (Math.atan2(deltaX, deltaY) * 325.94900000000001D) & 0x7ff;
				}
			}
		}

		/**
		 * Handle facing a direction
		 */
		if ((entity.faceDirectionX != 0 || entity.faceDirectionY != 0) && (entity.smallXYIndex == 0 || entity.anInt1503 > 0)) {
			int k = entity.x - (entity.faceDirectionX - baseX - baseX) * 64;
			int j1 = entity.y - (entity.faceDirectionY - baseY - baseY) * 64;

			if (k != 0 || j1 != 0) {
				entity.turnDirection = (int) (Math.atan2(k, j1) * 325.94900000000001D) & 0x7ff;
			}

			entity.faceDirectionX = 0;
			entity.faceDirectionY = 0;
		}

		int l = entity.turnDirection - entity.anInt1552 & 0x7ff;

		if (l != 0) {
			if (l < entity.anInt1504 || l > 2048 - entity.anInt1504) {
				entity.anInt1552 = entity.turnDirection;
			} else if (l > 1024) {
				entity.anInt1552 -= entity.anInt1504;
			} else {
				entity.anInt1552 += entity.anInt1504;
			}

			entity.anInt1552 &= 0x7ff;

			if (entity.anInt1517 == entity.anInt1511 && entity.anInt1552 != entity.turnDirection) {
				if (entity.anInt1512 != -1) {
					entity.anInt1517 = entity.anInt1512;
					return;
				}

				entity.anInt1517 = entity.anInt1554;
			}
		}
	}

	private void handleEntityAnimation(Entity entity) {

		entity.aBoolean1541 = false;

		if (entity.anInt1517 != -1) {

			if (entity.anInt1517 >= Animation.cache.length) {
				System.out.println("Invalid Animation3: " + entity + " : " + entity.anInt1517);
				entity.anInt1517 = -1;
				return;
			}

			Animation animation = Animation.cache[entity.anInt1517];

			if (animation == null) {
				System.out.println("Null Animation 1517: " + entity + " : " + entity.anInt1517);
				entity.anInt1517 = -1;
				return;
			}

			entity.frameDelay++;

			if (entity.anInt1518 < animation.frameCount && entity.frameDelay > animation.method258(entity.anInt1518)) {
				entity.frameDelay = 1;
				entity.anInt1518++;
				entity.nextIdleAnimationFrame++;
			}
			entity.nextIdleAnimationFrame = entity.anInt1518 + 1;
			if (entity.nextIdleAnimationFrame >= animation.frameCount) {
				if (entity.nextIdleAnimationFrame >= animation.frameCount) {
					entity.nextIdleAnimationFrame = 0;
				}
			}
			if (entity.anInt1518 >= animation.frameCount) {
				entity.frameDelay = 1;
				entity.anInt1518 = 0;
			}
		}

		if (entity.gfxId != -1 && loopCycle >= entity.gfxDelay) {

			if (entity.currentAnim < 0) {
				entity.currentAnim = 0;
			}

			if (entity.gfxId >= SpotAnimDefinition.cache.length) {
				System.out.println("Invalid Graphic: " + entity + " : " + entity.gfxId);
				entity.gfxId = -1;
				return;
			}

			Animation animation_1 = SpotAnimDefinition.cache[entity.gfxId].animFrameSequence;

			if (animation_1 == null) {
				System.out.println("Null Graphic: " + entity + " : " + entity.gfxId);
				entity.gfxId = -1;
				return;
			}

			for (entity.anInt1522++; entity.currentAnim < animation_1.frameCount && entity.anInt1522 > animation_1.method258(entity.currentAnim); entity.currentAnim++) {
				entity.anInt1522 -= animation_1.method258(entity.currentAnim);
			}

			if (entity.currentAnim >= animation_1.frameCount && (entity.currentAnim < 0 || entity.currentAnim >= animation_1.frameCount)) {
				entity.gfxId = -1;
			}
			entity.nextGraphicsAnimationFrame = entity.currentAnim + 1;
			if (entity.nextGraphicsAnimationFrame >= animation_1.frameCount) {
				if (entity.nextGraphicsAnimationFrame < 0 || entity.nextGraphicsAnimationFrame >= animation_1.frameCount) {
					entity.gfxId = -1;
				}
			}
		}

		if (entity.anim != -1 && entity.anInt1529 <= 1) {

			if (entity.anim >= Animation.cache.length) {
				System.out.println("Invalid Animation1: " + entity + " : " + entity.anim);
				entity.anim = -1;
				return;
			}

			Animation animation_2 = Animation.cache[entity.anim];

			if (animation_2 == null) {
				System.out.println("Null Animation_2: " + entity + " : " + entity.anim);
				entity.anim = -1;
				return;
			}

			if (animation_2.anInt363 == 1 && entity.anInt1542 > 0 && entity.anInt1547 <= loopCycle && entity.anInt1548 < loopCycle) {
				entity.anInt1529 = 1;
				return;
			}
		}

		if (entity.anim != -1 && entity.anInt1529 == 0) {

			if (entity.anim >= Animation.cache.length) {
				System.out.println("Invalid Animation2: " + entity + " : " + entity.anim);
				entity.anim = -1;
				return;
			}
			Animation animation_3 = Animation.cache[entity.anim];

			if (animation_3 == null) {
				System.out.println("Null Animation_3: " + entity + " : " + entity.anim);
				entity.anim = -1;
				return;
			}

			for (entity.anInt1528++; entity.anInt1527 < animation_3.frameCount && entity.anInt1528 > animation_3.method258(entity.anInt1527); entity.anInt1527++) {
				entity.anInt1528 -= animation_3.method258(entity.anInt1527);
			}

			if (entity.anInt1527 >= animation_3.frameCount) {
				entity.anInt1527 -= animation_3.frameStep;
				entity.anInt1530++;

				if (entity.anInt1530 >= animation_3.anInt362) {
					entity.anim = -1;
				}

				if (entity.anInt1527 < 0 || entity.anInt1527 >= animation_3.frameCount) {
					entity.anim = -1;
				}
			}
			entity.nextAnimationFrame = entity.anInt1527 + 1;
			if (entity.nextAnimationFrame >= animation_3.frameCount) {
				if (entity.anInt1530 >= animation_3.anInt362) {
					entity.anim = -1;
				}
				if (entity.nextAnimationFrame < 0 || entity.nextAnimationFrame >= animation_3.frameCount) {
					entity.anim = -1;
				}
			}
			entity.aBoolean1541 = animation_3.aBoolean358;
		}

		if (entity.anInt1529 > 0) {
			entity.anInt1529--;
		}
	}

	private void method104() {
		Animable_Sub3 class30_sub2_sub4_sub3 = (Animable_Sub3) getaClass19_1056().reverseGetFirst();

		for (; class30_sub2_sub4_sub3 != null; class30_sub2_sub4_sub3 = (Animable_Sub3) getaClass19_1056().reverseGetNext()) {
			if (class30_sub2_sub4_sub3.anInt1560 != plane || class30_sub2_sub4_sub3.aBoolean1567) {
				class30_sub2_sub4_sub3.unlink();
			} else if (loopCycle >= class30_sub2_sub4_sub3.anInt1564) {
				class30_sub2_sub4_sub3.method454(anInt945);

				if (class30_sub2_sub4_sub3.aBoolean1567) {
					class30_sub2_sub4_sub3.unlink();
				} else {
					worldController.method285(class30_sub2_sub4_sub3.anInt1560, 0, class30_sub2_sub4_sub3.anInt1563, -1, class30_sub2_sub4_sub3.anInt1562, 60, class30_sub2_sub4_sub3.anInt1561,
							class30_sub2_sub4_sub3, false);
				}
			}
		}
	}

	private void handlePlayerUpdateBlock(int bitmap, int j, ByteBuffer buffer, Player player) {

		/**
		 * Forced movement
		 */
		if ((bitmap & 0x400) != 0) {
			player.anInt1543 = buffer.method428();
			player.anInt1545 = buffer.method428();
			player.anInt1544 = buffer.method428();
			player.anInt1546 = buffer.method428();
			player.anInt1547 = buffer.getShortBigEndianA() + loopCycle;
			player.anInt1548 = buffer.method435() + loopCycle;
			player.anInt1549 = buffer.method428();
			player.method446();
		}

		/**
		 * Graphic mask
		 */
		if ((bitmap & 0x100) != 0) {
			player.gfxId = buffer.getShortBigEndian(); // GFX Id
			int delay = buffer.getIntLittleEndian();
			player.gfxHeight = delay >> 16;
			player.gfxDelay = loopCycle + (delay & 0xffff);
			player.currentAnim = 0;
			player.anInt1522 = 0;

			if (player.gfxDelay > loopCycle) {
				player.currentAnim = -1;
			}

			if (player.gfxId == 65535) {
				player.gfxId = -1;
			}

			try {
				if (FrameReader.animationlist[Integer.parseInt(Integer.toHexString(SpotAnimDefinition.cache[player.gfxId].animFrameSequence.frame2IDS[0]).substring(0,
						Integer.toHexString(SpotAnimDefinition.cache[player.gfxId].animFrameSequence.frame2IDS[0]).length() - 4), 16)].length == 0)
					onDemandFetcher.requestFileData(1, Integer.parseInt(Integer.toHexString(SpotAnimDefinition.cache[player.gfxId].animFrameSequence.frame2IDS[0]).substring(0,
							Integer.toHexString(SpotAnimDefinition.cache[player.gfxId].animFrameSequence.frame2IDS[0]).length() - 4), 16));
			} catch (Exception e) {
			}

		}

		/**
		 * Animation mask
		 */
		if ((bitmap & 8) != 0) {
			int animationId = buffer.getShortBigEndian();

			if (animationId == 65535) {
				animationId = -1;
			}

			int animationDelay = buffer.method427();

			if (animationId == player.anim && animationId != -1) {
				int i3 = Animation.cache[animationId].anInt365;

				if (i3 == 1) {
					player.anInt1527 = 0;
					player.anInt1528 = 0;
					player.anInt1529 = animationDelay;
					player.anInt1530 = 0;
				}

				if (i3 == 2) {
					player.anInt1530 = 0;
				}
			} else if (animationId == -1 || player.anim == -1 || Animation.cache[animationId].anInt359 >= Animation.cache[player.anim].anInt359) {
				player.anim = animationId;
				player.anInt1527 = 0;
				player.anInt1528 = 0;
				player.anInt1529 = animationDelay;
				player.anInt1530 = 0;
				player.anInt1542 = player.smallXYIndex;

				try {
					if (FrameReader.animationlist[Integer.parseInt(
							Integer.toHexString(Animation.cache[animationId].frame2IDS[0]).substring(0, Integer.toHexString(Animation.cache[animationId].frame2IDS[0]).length() - 4), 16)].length == 0)
						onDemandFetcher.requestFileData(1, Integer.parseInt(
								Integer.toHexString(Animation.cache[animationId].frame2IDS[0]).substring(0, Integer.toHexString(Animation.cache[animationId].frame2IDS[0]).length() - 4), 16));
				} catch (Exception e) {
				}
			}
		}

		/**
		 * Force Chat mask
		 */
		if ((bitmap & 4) != 0) {
			// XXX
			player.textSpoken = buffer.getString();

			if (player.textSpoken.charAt(0) == '~') {
				player.textSpoken = player.textSpoken.substring(1);
				pushMessage(player.textSpoken, 2, player.name);
			} else if (player == myPlayer) {
				pushMessage(player.textSpoken, 2, player.name);
			}

			player.anInt1513 = 0;
			player.anInt1531 = 0;
			player.textCycle = 150;
		}

		/**
		 * Chat mask
		 */
		if ((bitmap & 0x80) != 0) {
			int chatEffects = buffer.getShortBigEndian();
			int chatRights = buffer.getUnsignedByte();
			int chatLength = buffer.method427();
			int currentPosition = buffer.position;

			if (player.name != null && player.visible) {
				long username = TextClass.longForName(player.name.toLowerCase());
				boolean ignored = false;

				if (chatRights <= 10) {
					for (int i = 0; i < ignoreCount; i++) {
						if (ignoreListAsLongs[i] != username) {
							continue;
						}

						ignored = true;
						break;
					}
				}

				if (!ignored && anInt1251 == 0) {
					try {
						aStream_834.position = 0;
						buffer.method442(chatLength, 0, aStream_834.buffer);
						aStream_834.position = 0;
						String s = TextInput.readChatboxText(chatLength, aStream_834);
						player.textSpoken = s;
						player.anInt1513 = chatEffects >> 8;
						player.anInt1531 = chatEffects & 0xff;
						player.textCycle = 150;
						pushMessage(s, 2, getPrefix(chatRights) + player.name, player.loyaltyTitle, player.loyaltyColor, player.loyaltyPosition);
					} catch (Exception exception) {
						Signlink.reportError("cde2");
					}
				}
			}

			buffer.position = currentPosition + chatLength;
		}

		/**
		 * Face entity mask
		 */
		if ((bitmap & 1) != 0) {
			player.interactingEntity = buffer.getShortBigEndian();
			if (player.interactingEntity == 65535) {
				player.interactingEntity = -1;
				if (player == myPlayer) {
					interactingWith = null;
				}
			}
		}

		/**
		 * Appearance mask
		 */
		if ((bitmap & 0x10) != 0) {
			int length = buffer.method427();
			byte data[] = new byte[length];
			ByteBuffer buff = new ByteBuffer(data);
			buffer.getBytes(length, 0, data);
			getaStreamArray895s()[j] = buff;
			player.updatePlayer(buff);
		}

		/**
		 * Face direction mask
		 */
		if ((bitmap & 2) != 0) {
			player.faceDirectionX = buffer.getShortBigEndianA();
			player.faceDirectionY = buffer.getShortBigEndian();
		}

		/**
		 * Hit mask 1
		 */
		if ((bitmap & 0x20) != 0) {
			int hitType = buffer.getUnsignedByte();
			int damage = buffer.method426();
			int icon = buffer.getUnsignedByte();
			player.updateHitData(damage, hitType, loopCycle, icon);
			player.loopCycleStatus = loopCycle + 300;
			player.currentHealth = buffer.getShort();
			player.maxHealth = buffer.getShort();
		}

		/**
		 * hit mask 2
		 */
		if ((bitmap & 0x200) != 0) {
			int hitType = buffer.getUnsignedByte();
			int damage = buffer.method428();
			int icon = buffer.getUnsignedByte();
			player.updateHitData(damage, hitType, loopCycle, icon);
			player.loopCycleStatus = loopCycle + 300;
			player.currentHealth = buffer.getShort();
			player.maxHealth = buffer.getShort();
		}
	}

	private void method108() {
		try {
			int cameraDisplayX = myPlayer.x + cameraOffsetX;
			int cameraDisplayY = myPlayer.y + cameraOffsetY;

			if (currentCameraDisplayX - cameraDisplayX < -500 || currentCameraDisplayX - cameraDisplayX > 500 || currentCameraDisplayY - cameraDisplayY < -500
					|| currentCameraDisplayY - cameraDisplayY > 500) {
				currentCameraDisplayX = cameraDisplayX;
				currentCameraDisplayY = cameraDisplayY;
			}

			if (currentCameraDisplayX != cameraDisplayX) {
				currentCameraDisplayX += (cameraDisplayX - currentCameraDisplayX) / 16;
			}

			if (currentCameraDisplayY != cameraDisplayY) {
				currentCameraDisplayY += (cameraDisplayY - currentCameraDisplayY) / 16;
			}

			if (super.keyArray[1] == 1) {
				cameraRotationLeft += (-26 - cameraRotationLeft) / 2;
			} else if (super.keyArray[2] == 1) {
				cameraRotationLeft += (26 - cameraRotationLeft) / 2;
			} else {
				cameraRotationLeft /= 2;
			}

			if (super.keyArray[3] == 1) {
				cameraRotationRight += (14 - cameraRotationRight) / 2;
			} else if (super.keyArray[4] == 1) {
				cameraRotationRight += (-14 - cameraRotationRight) / 2;
			} else {
				cameraRotationRight /= 2;
			}

			viewRotation = viewRotation + cameraRotationLeft / 2 & 0x7ff;
			cameraRotationZ += cameraRotationRight / 2;

			if (cameraRotationZ < cameraAngleLimit) {
				cameraRotationZ = cameraAngleLimit;
			}

			if (cameraRotationZ > 383) {
				cameraRotationZ = 383;
			}

			int l = currentCameraDisplayX >> 7;
			int i1 = currentCameraDisplayY >> 7;
			int j1 = method42(plane, currentCameraDisplayY, currentCameraDisplayX);
			int k1 = 0;

			if (l > 3 && i1 > 3 && l < 100 && i1 < 100) {
				for (int l1 = l - 4; l1 <= l + 4; l1++) {
					for (int k2 = i1 - 4; k2 <= i1 + 4; k2++) {
						int l2 = plane;

						if (l2 < 3 && (byteGroundArray[1][l1][k2] & 2) == 2) {
							l2++;
						}

						int i3 = j1 - intGroundArray[l2][l1][k2];

						if (i3 > k1) {
							k1 = i3;
						}
					}
				}
			}

			anInt1005++;

			if (anInt1005 > 1512) {
				anInt1005 = 0;
				getOut().putOpcode(77);
				getOut().putShortBigEndian(0);
				int i2 = getOut().position;
				getOut().putShortBigEndian((int) (Math.random() * 256D));
				getOut().putShortBigEndian(101);
				getOut().putShortBigEndian(233);
				getOut().putShort(45092);

				if ((int) (Math.random() * 2D) == 0) {
					getOut().putShort(35784);
				}

				getOut().putShortBigEndian((int) (Math.random() * 256D));
				getOut().putShortBigEndian(64);
				getOut().putShortBigEndian(38);
				getOut().putShort((int) (Math.random() * 65536D));
				getOut().putShort((int) (Math.random() * 65536D));
				getOut().putVariableSizeByte(getOut().position - i2);
			}

			int j2 = k1 * 192;

			if (j2 > 0x17f00) {
				j2 = 0x17f00;
			}
			if (j2 < 32768) {
				j2 = 32768;
			}
			if (j2 > anInt984) {
				anInt984 += (j2 - anInt984) / 24;
				return;
			}
			if (j2 < anInt984) {
				anInt984 += (j2 - anInt984) / 80;
			}
		} catch (Exception _ex) {
			Signlink.reportError(
					"glfc_ex " + myPlayer.x + "," + myPlayer.y + "," + currentCameraDisplayX + "," + currentCameraDisplayY + "," + anInt1069 + "," + anInt1070 + "," + baseX + "," + baseY);
			throw new RuntimeException("eek");
		}
	}

	private void method114() {
		for (int i = -1; i < playerCount; i++) {
			int j;

			if (i == -1) {
				j = getMyPlayerIndex();
			} else {
				j = playerIndices[i];
			}

			Player player = playerArray[j];

			if (player != null) {
				method96(player);
			}
		}
	}

	private void method115() {
		if (loadingStage == 2) {
			for (GameObject class30_sub1 = (GameObject) getaClass19_1179().reverseGetFirst(); class30_sub1 != null; class30_sub1 = (GameObject) getaClass19_1179().reverseGetNext()) {
				if (class30_sub1.anInt1294 > 0) {
					class30_sub1.anInt1294--;
				}
				if (class30_sub1.anInt1294 == 0) {
					if (class30_sub1.anInt1299 < 0 || ObjectManager.method178(class30_sub1.anInt1299, class30_sub1.anInt1301)) {
						method142(class30_sub1.anInt1298, class30_sub1.anInt1295, class30_sub1.anInt1300, class30_sub1.anInt1301, class30_sub1.anInt1297, class30_sub1.anInt1296,
								class30_sub1.anInt1299);
						class30_sub1.unlink();
					}
				} else {
					if (class30_sub1.anInt1302 > 0) {
						class30_sub1.anInt1302--;
					}
					if (class30_sub1.anInt1302 == 0 && class30_sub1.anInt1297 >= 1 && class30_sub1.anInt1298 >= 1 && class30_sub1.anInt1297 <= 102 && class30_sub1.anInt1298 <= 102
							&& (class30_sub1.anInt1291 < 0 || ObjectManager.method178(class30_sub1.anInt1291, class30_sub1.anInt1293))) {
						method142(class30_sub1.anInt1298, class30_sub1.anInt1295, class30_sub1.anInt1292, class30_sub1.anInt1293, class30_sub1.anInt1297, class30_sub1.anInt1296,
								class30_sub1.anInt1291);
						class30_sub1.anInt1302 = -1;
						if (class30_sub1.anInt1291 == class30_sub1.anInt1299 && class30_sub1.anInt1299 == -1) {
							class30_sub1.unlink();
						} else if (class30_sub1.anInt1291 == class30_sub1.anInt1299 && class30_sub1.anInt1292 == class30_sub1.anInt1300 && class30_sub1.anInt1293 == class30_sub1.anInt1301) {
							class30_sub1.unlink();
						}
					}
				}
			}

		}
	}

	private void processMovementBuffer(ByteBuffer stream) {
		stream.initBitAccess();
		int movementStatus = stream.getBits(1);
		if (movementStatus == 0) {
			return;
		}
		int flagType = stream.getBits(2);
		if (flagType == 0) {
			anIntArray894[anInt893++] = getMyPlayerIndex();
			return;
		}
		if (flagType == 1) {
			int direction = stream.getBits(3);
			myPlayer.moveInDir(false, direction);
			int updateRequired = stream.getBits(1);
			if (updateRequired == 1) {
				anIntArray894[anInt893++] = getMyPlayerIndex();
			}
			return;
		}
		if (flagType == 2) {
			int walkingDirection = stream.getBits(3);
			myPlayer.moveInDir(true, walkingDirection);
			int runningDirection = stream.getBits(3);
			myPlayer.moveInDir(true, runningDirection);
			int updateRequired = stream.getBits(1);
			if (updateRequired == 1) {
				anIntArray894[anInt893++] = getMyPlayerIndex();
			}
			return;
		}
		// this is the cause i think
		if (flagType == 3) {
			plane = stream.getBits(2);
			if (previousPlane != plane) {
				previousPlane = plane;
				loadingStage = 1;
			}
			int j1 = stream.getBits(1);
			int updateRequired = stream.getBits(1);
			if (updateRequired == 1) {
				anIntArray894[anInt893++] = getMyPlayerIndex();
			}
			int localY = stream.getBits(7);
			int localX = stream.getBits(7);
			myPlayer.setPos(localX, localY, j1 == 1);
		}
	}

	public static int realPlane;

	private boolean method119(int i, int j) {
		boolean flag1 = false;
		RSInterface class9 = RSInterface.interfaceCache[j];

		if (class9 == null) {
			// System.out.println("Null Interface: " + j + ", " + i);
			return false;
		}
		for (int element : class9.children) {
			if (element == -1) {
				break;
			}
			RSInterface class9_1 = RSInterface.interfaceCache[element];
			if (class9_1.type == 1) {
				flag1 |= method119(i, class9_1.id);
			}
			if (class9_1.type == 6 && (class9_1.anInt257 != -1 || class9_1.anInt258 != -1)) {
				boolean flag2 = interfaceIsSelected(class9_1);
				int l;
				if (flag2) {
					l = class9_1.anInt258;
				} else {
					l = class9_1.anInt257;
				}
				if (l != -1) {
					Animation animation = Animation.cache[l];
					for (class9_1.anInt208 += i; class9_1.anInt208 > animation.method258(class9_1.anInt246);) {
						class9_1.anInt208 -= animation.method258(class9_1.anInt246) + 1;
						class9_1.anInt246++;
						if (class9_1.anInt246 >= animation.frameCount) {
							class9_1.anInt246 -= animation.frameStep;
							if (class9_1.anInt246 < 0 || class9_1.anInt246 >= animation.frameCount) {
								class9_1.anInt246 = 0;
							}
						}
						flag1 = true;
					}

				}
			}
		}

		return flag1;
	}

	private int method120() {
		if (getConfig().getStatus(ConfigType.TOGGLE_ROOFS)) {
			return plane;
		}
		int heightPlane = 3;
		if (yCameraCurve < 310) {
			int localCameraX = xCameraPos >> 7;
			int localCameraY = yCameraPos >> 7;
			int localX = myPlayer.x >> 7;
			int localY = myPlayer.y >> 7;
			try {
				if ((byteGroundArray[plane][localCameraX][localCameraY] & 4) != 0) {
					heightPlane = plane;
				}
			} catch (Exception e) {
				System.out.println(plane + ":" + localCameraX + ":" + localCameraY);
				e.printStackTrace();
			}
			int cameraOffsetX;
			if (localX > localCameraX) {
				cameraOffsetX = localX - localCameraX;
			} else {
				cameraOffsetX = localCameraX - localX;
			}
			int cameraOffsetY;
			if (localY > localCameraY) {
				cameraOffsetY = localY - localCameraY;
			} else {
				cameraOffsetY = localCameraY - localY;
			}
			if (cameraOffsetX > cameraOffsetY) {
				int i2 = cameraOffsetY * 0x10000 / cameraOffsetX;
				int k2 = 32768;
				while (localCameraX != localX) {
					if (localCameraX < localX) {
						localCameraX++;
					} else if (localCameraX > localX) {
						localCameraX--;
					}
					try {
						if ((byteGroundArray[plane][localCameraX][localCameraY] & 4) != 0) {
							heightPlane = plane;
						}
					} catch (Exception e) {
						System.out.println(plane + ":" + localCameraX + ":" + localCameraY);
						e.printStackTrace();
					}
					k2 += i2;
					if (k2 >= 0x10000) {
						k2 -= 0x10000;
						if (localCameraY < localY) {
							localCameraY++;
						} else if (localCameraY > localY) {
							localCameraY--;
						}
						try {
							if ((byteGroundArray[plane][localCameraX][localCameraY] & 4) != 0) {
								heightPlane = plane;
							}
						} catch (Exception e) {
							System.out.println(plane + ":" + localCameraX + ":" + localCameraY);
							e.printStackTrace();
						}
					}
				}
			} else {
				int j2 = cameraOffsetX * 0x10000 / cameraOffsetY;
				int l2 = 32768;
				while (localCameraY != localY) {
					if (localCameraY < localY) {
						localCameraY++;
					} else if (localCameraY > localY) {
						localCameraY--;
					}

					try {
						if ((byteGroundArray[plane][localCameraX][localCameraY] & 4) != 0) {
							heightPlane = plane;
						}
					} catch (Exception e) {
						System.out.println(plane + ":" + localCameraX + ":" + localCameraY);
						e.printStackTrace();
					}
					l2 += j2;
					if (l2 >= 0x10000) {
						l2 -= 0x10000;
						if (localCameraX < localX) {
							localCameraX++;
						} else if (localCameraX > localX) {
							localCameraX--;
						}
						try {
							if ((byteGroundArray[plane][localCameraX][localCameraY] & 4) != 0) {
								heightPlane = plane;
							}
						} catch (Exception e) {
							System.out.println(plane + ":" + localCameraX + ":" + localCameraY);
							e.printStackTrace();
						}
					}
				}
			}
		}
		try {
			if ((byteGroundArray[plane][myPlayer.x >> 7][myPlayer.y >> 7] & 4) != 0) {
				heightPlane = plane;
			}
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println((myPlayer.x >> 7) + ", " + (myPlayer.y >> 7));
		}
		return heightPlane;
	}

	private int method121() {
		if (getConfig().getStatus(ConfigType.TOGGLE_ROOFS)) {
			return plane;
		}
		int j = method42(plane, yCameraPos, xCameraPos);
		if (j - zCameraPos < 800 && (byteGroundArray[plane][xCameraPos >> 7][yCameraPos >> 7] & 4) != 0) {
			return plane;
		} else {
			return 3;
		}
	}

	private void method130(int j, int id, int l, int i1, int j1, int type, int l1, int i2, int j2) {
		GameObject class30_sub1 = null;
		for (GameObject class30_sub1_1 = (GameObject) getaClass19_1179().reverseGetFirst(); class30_sub1_1 != null; class30_sub1_1 = (GameObject) getaClass19_1179().reverseGetNext()) {
			if (class30_sub1_1.anInt1295 != l1 || class30_sub1_1.anInt1297 != i2 || class30_sub1_1.anInt1298 != j1 || class30_sub1_1.anInt1296 != i1) {
				continue;
			}
			class30_sub1 = class30_sub1_1;
			break;
		}

		if (class30_sub1 == null) {
			class30_sub1 = new GameObject();
			class30_sub1.anInt1295 = l1;
			class30_sub1.anInt1296 = i1;
			class30_sub1.anInt1297 = i2;
			class30_sub1.anInt1298 = j1;
			method89(class30_sub1);
			getaClass19_1179().insertHead(class30_sub1);
		}
		class30_sub1.anInt1291 = id;
		class30_sub1.anInt1293 = type;
		class30_sub1.anInt1292 = l;
		class30_sub1.anInt1302 = j2;
		class30_sub1.anInt1294 = j;
	}

	private void method134(ByteBuffer stream) {
		int j = stream.getBits(8);
		if (j < playerCount) {
			for (int k = j; k < playerCount; k++) {
				anIntArray840[anInt839++] = playerIndices[k];
			}

		}
		if (j > playerCount) {
			Signlink.reportError(getMyUsername() + " Too many players");
			throw new RuntimeException("eek");
		}
		playerCount = 0;
		for (int l = 0; l < j; l++) {
			int i1 = playerIndices[l];
			Player player = playerArray[i1];
			int j1 = stream.getBits(1);
			if (j1 == 0) {
				playerIndices[playerCount++] = i1;
				player.anInt1537 = loopCycle;
			} else {
				int k1 = stream.getBits(2);
				if (k1 == 0) {
					playerIndices[playerCount++] = i1;
					player.anInt1537 = loopCycle;
					anIntArray894[anInt893++] = i1;
				} else if (k1 == 1) {
					playerIndices[playerCount++] = i1;
					player.anInt1537 = loopCycle;
					int l1 = stream.getBits(3);
					player.moveInDir(false, l1);
					int j2 = stream.getBits(1);
					if (j2 == 1) {
						anIntArray894[anInt893++] = i1;
					}
				} else if (k1 == 2) {
					playerIndices[playerCount++] = i1;
					player.anInt1537 = loopCycle;
					int i2 = stream.getBits(3);
					player.moveInDir(true, i2);
					int k2 = stream.getBits(3);
					player.moveInDir(true, k2);
					int l2 = stream.getBits(1);
					if (l2 == 1) {
						anIntArray894[anInt893++] = i1;
					}
				} else if (k1 == 3) {
					anIntArray840[anInt839++] = i1;
				}
			}
		}
	}

	private void method137(ByteBuffer stream, int j) {
		if (j == 84) {
			int k = stream.getUnsignedByte();
			int j3 = anInt1268 + (k >> 4 & 7);
			int i6 = anInt1269 + (k & 7);
			int l8 = stream.getUnsignedShort();
			int k11 = stream.getUnsignedShort();
			int l13 = stream.getUnsignedShort();
			if (j3 >= 0 && i6 >= 0 && j3 < 104 && i6 < 104) {
				Deque class19_1 = groundArray[plane][j3][i6];
				if (class19_1 != null) {
					for (Item class30_sub2_sub4_sub2_3 = (Item) class19_1.reverseGetFirst(); class30_sub2_sub4_sub2_3 != null; class30_sub2_sub4_sub2_3 = (Item) class19_1.reverseGetNext()) {
						if (class30_sub2_sub4_sub2_3.id != (l8 & 0x7fff) || class30_sub2_sub4_sub2_3.amount != k11) {
							continue;
						}
						class30_sub2_sub4_sub2_3.amount = l13;
						break;
					}

					spawnGroundItem(j3, i6);
				}
			}
			return;
		}
		if (j == 105) {
			int l = stream.getUnsignedByte();
			int k3 = anInt1268 + (l >> 4 & 7);
			int j6 = anInt1269 + (l & 7);
			int i9 = stream.getUnsignedShort();
			int l11 = stream.getUnsignedByte();
			int i14 = l11 >> 4 & 0xf;
			int i16 = l11 & 7;
			if (myPlayer.smallX[0] >= k3 - i14 && myPlayer.smallX[0] <= k3 + i14 && myPlayer.smallY[0] >= j6 - i14 && myPlayer.smallY[0] <= j6 + i14 && soundEffectVolume != 0 && aBoolean848
					&& !isLowDetail() && soundCount < 50) {
				sound[soundCount] = i9;
				soundType[soundCount] = i16;
				soundDelay[soundCount] = Sounds.anIntArray326[i9];
				aClass26Array1468[soundCount] = null;
				soundCount++;
			}
		}
		if (j == 215) {
			int i1 = stream.method435();
			int l3 = stream.method428();
			int k6 = anInt1268 + (l3 >> 4 & 7);
			int j9 = anInt1269 + (l3 & 7);
			int i12 = stream.method435();
			int j14 = stream.getUnsignedShort();
			if (k6 >= 0 && j9 >= 0 && k6 < 104 && j9 < 104 && i12 != playerIndex) {
				Item class30_sub2_sub4_sub2_2 = new Item();
				class30_sub2_sub4_sub2_2.id = i1;
				class30_sub2_sub4_sub2_2.amount = j14;
				if (groundArray[plane][k6][j9] == null) {
					groundArray[plane][k6][j9] = new Deque();
				}
				groundArray[plane][k6][j9].insertHead(class30_sub2_sub4_sub2_2);
				spawnGroundItem(k6, j9);
			}
			return;
		}
		if (j == 156) {
			int j1 = stream.method426();
			int i4 = anInt1268 + (j1 >> 4 & 7);
			int l6 = anInt1269 + (j1 & 7);
			int k9 = stream.getUnsignedShort();
			if (i4 >= 0 && l6 >= 0 && i4 < 104 && l6 < 104) {
				Deque class19 = groundArray[plane][i4][l6];
				if (class19 != null) {
					for (Item item = (Item) class19.reverseGetFirst(); item != null; item = (Item) class19.reverseGetNext()) {
						if (item.id != (k9 & 0x7fff)) {
							continue;
						}
						item.unlink();
						break;
					}

					if (class19.reverseGetFirst() == null) {
						groundArray[plane][i4][l6] = null;
					}
					spawnGroundItem(i4, l6);
				}
			}
			return;
		}
		if (j == 160) {
			int k1 = stream.method428();
			int j4 = anInt1268 + (k1 >> 4 & 7);
			int i7 = anInt1269 + (k1 & 7);
			int l9 = stream.method428();
			int j12 = l9 >> 2;
			int k14 = l9 & 3;
			int j16 = anIntArray1177[j12];
			int j17 = stream.method435();
			if (j4 >= 0 && i7 >= 0 && j4 < 103 && i7 < 103) {
				int j18 = intGroundArray[plane][j4][i7];
				int i19 = intGroundArray[plane][j4 + 1][i7];
				int l19 = intGroundArray[plane][j4 + 1][i7 + 1];
				int k20 = intGroundArray[plane][j4][i7 + 1];
				if (j16 == 0) {
					Object1 class10 = worldController.method296(plane, j4, i7);
					if (class10 != null) {
						int k21 = class10.uid >> 14 & 0x7fff;
						if (j12 == 2) {
							class10.aClass30_Sub2_Sub4_278 = new Animable_Sub5(k21, 4 + k14, 2, i19, l19, j18, k20, j17, false);
							class10.aClass30_Sub2_Sub4_279 = new Animable_Sub5(k21, k14 + 1 & 3, 2, i19, l19, j18, k20, j17, false);
						} else {
							class10.aClass30_Sub2_Sub4_278 = new Animable_Sub5(k21, k14, j12, i19, l19, j18, k20, j17, false);
						}
					}
				}

				if (j16 == 1) {
					Object2 class26 = worldController.method297(j4, i7, plane);
					if (class26 != null) {
						class26.aClass30_Sub2_Sub4_504 = new Animable_Sub5(class26.uid >> 14 & 0x7fff, 0, 4, i19, l19, j18, k20, j17, false);
					}
				}

				if (j16 == 2) {
					Object5 class28 = worldController.method298(j4, i7, plane);

					if (j12 == 11) {
						j12 = 10;
					}

					if (class28 != null) {
						class28.aClass30_Sub2_Sub4_521 = new Animable_Sub5(class28.uid >> 14 & 0x7fff, k14, j12, i19, l19, j18, k20, j17, false);
					}
				}

				if (j16 == 3) {
					Object3 class49 = worldController.method299(i7, j4, plane);

					if (class49 != null) {
						class49.aClass30_Sub2_Sub4_814 = new Animable_Sub5(class49.uid >> 14 & 0x7fff, k14, 22, i19, l19, j18, k20, j17, false);
					}
				}
			}

			return;
		}

		if (j == 147) {
			int l1 = stream.method428();
			int k4 = anInt1268 + (l1 >> 4 & 7);
			int j7 = anInt1269 + (l1 & 7);
			int i10 = stream.getUnsignedShort();
			byte byte0 = stream.method430();
			int l14 = stream.getShortBigEndian();
			byte byte1 = stream.method429();
			int k17 = stream.getUnsignedShort();
			int k18 = stream.method428();
			int j19 = k18 >> 2;
			int i20 = k18 & 3;
			int l20 = anIntArray1177[j19];
			byte byte2 = stream.getSignedByte();
			int l21 = stream.getUnsignedShort();
			byte byte3 = stream.method429();
			Player player;

			if (i10 == playerIndex) {
				player = myPlayer;
			} else {
				player = playerArray[i10];
			}

			if (player != null) {
				ObjectDefinition class46 = ObjectDefinition.forID(l21);
				int i22 = intGroundArray[plane][k4][j7];
				int j22 = intGroundArray[plane][k4 + 1][j7];
				int k22 = intGroundArray[plane][k4 + 1][j7 + 1];
				int l22 = intGroundArray[plane][k4][j7 + 1];
				Model model = class46.method578(j19, i20, i22, j22, k22, l22, -1);

				if (model != null) {
					method130(k17 + 1, -1, 0, l20, j7, 0, plane, k4, l14 + 1);
					player.anInt1707 = l14 + loopCycle;
					player.anInt1708 = k17 + loopCycle;
					player.aModel_1714 = model;
					int i23 = class46.xLength;
					int j23 = class46.yLength;

					if (i20 == 1 || i20 == 3) {
						i23 = class46.yLength;
						j23 = class46.xLength;
					}

					player.anInt1711 = k4 * 128 + i23 * 64;
					player.anInt1713 = j7 * 128 + j23 * 64;
					player.anInt1712 = method42(plane, player.anInt1713, player.anInt1711);

					if (byte2 > byte0) {
						byte byte4 = byte2;
						byte2 = byte0;
						byte0 = byte4;
					}

					if (byte3 > byte1) {
						byte byte5 = byte3;
						byte3 = byte1;
						byte1 = byte5;
					}

					player.anInt1719 = k4 + byte2;
					player.anInt1721 = k4 + byte0;
					player.anInt1720 = j7 + byte3;
					player.anInt1722 = j7 + byte1;
				}
			}
		}

		if (j == 151) {
			int position = stream.method426();
			int regionY = anInt1268 + (position >> 4 & 7);
			int regionX = anInt1269 + (position & 7);
			int objectId = stream.getShortBigEndian();
			int objectData = stream.method428();
			int objectType = objectData >> 2;
			int objectFace = objectData & 3;
			int l17 = anIntArray1177[objectType];
			if (objectId < -1) {
				objectId = Short.MAX_VALUE + -objectId;
			}

			if (regionY >= 0 && regionX >= 0 && regionY < 104 && regionX < 104) {
				method130(-1, objectId, objectFace, l17, regionX, objectType, plane, regionY, 0);
			}

			return;
		}

		if (j == 4) {
			int j2 = stream.getUnsignedByte();
			int i5 = anInt1268 + (j2 >> 4 & 7);
			int l7 = anInt1269 + (j2 & 7);
			int k10 = stream.getUnsignedShort();
			int l12 = stream.getUnsignedByte();
			int j15 = stream.getUnsignedShort();

			if (i5 >= 0 && l7 >= 0 && i5 < 104 && l7 < 104) {
				i5 = i5 * 128 + 64;
				l7 = l7 * 128 + 64;
				Animable_Sub3 class30_sub2_sub4_sub3 = new Animable_Sub3(plane, loopCycle, j15, k10, method42(plane, l7, i5) - l12, l7, i5);
				getaClass19_1056().insertHead(class30_sub2_sub4_sub3);
			}

			return;
		}

		if (j == 44) {
			int k2 = stream.getShortBigEndianA();
			int j5 = stream.getUnsignedShort();
			int i8 = stream.getUnsignedByte();
			int l10 = anInt1268 + (i8 >> 4 & 7);
			int i13 = anInt1269 + (i8 & 7);

			if (l10 >= 0 && i13 >= 0 && l10 < 104 && i13 < 104) {
				Item class30_sub2_sub4_sub2_1 = new Item();
				class30_sub2_sub4_sub2_1.id = k2;
				class30_sub2_sub4_sub2_1.amount = j5;

				if (groundArray[plane][l10][i13] == null) {
					groundArray[plane][l10][i13] = new Deque();
				}

				groundArray[plane][l10][i13].insertHead(class30_sub2_sub4_sub2_1);
				spawnGroundItem(l10, i13);
			}

			return;
		}

		if (j == 101) {
			int l2 = stream.method427();
			int k5 = l2 >> 2;
			int j8 = l2 & 3;
			int i11 = anIntArray1177[k5];
			int j13 = stream.getUnsignedByte();
			int k15 = anInt1268 + (j13 >> 4 & 7);
			int l16 = anInt1269 + (j13 & 7);

			if (k15 >= 0 && l16 >= 0 && k15 < 104 && l16 < 104) {
				method130(-1, -1, j8, i11, l16, k5, plane, k15, 0);
			}

			return;
		}

		if (j == 117) {
			int localPosition = stream.getUnsignedByte();
			int localY = anInt1268 + (localPosition >> 4 & 7);
			int localX = anInt1269 + (localPosition & 7);
			int offsetY = localY + stream.getSignedByte();
			int offsetX = localX + stream.getSignedByte();
			int index = stream.getSignedShort();
			int projectileId = stream.getUnsignedShort();
			int startHeight = stream.getUnsignedByte() * 4;
			int endHeight = stream.getUnsignedByte() * 4;
			int time = stream.getUnsignedShort();
			int speed = stream.getUnsignedShort();
			int slope = stream.getUnsignedByte();
			int startDelay = stream.getUnsignedByte();

			if (localY >= 0 && localX >= 0 && localY < 104 && localX < 104 && offsetY >= 0 && offsetX >= 0 && offsetY < 104 && offsetX < 104 && projectileId != 65535) {
				localY = localY * 128 + 64;
				localX = localX * 128 + 64;
				offsetY = offsetY * 128 + 64;
				offsetX = offsetX * 128 + 64;
				PlayerProjectile projectile = new PlayerProjectile(slope, endHeight, time + loopCycle, speed + loopCycle, startDelay, plane, method42(plane, localX, localY) - startHeight, localX,
						localY, index, projectileId);
				projectile.method455(time + loopCycle, offsetX, method42(plane, offsetX, offsetY) - endHeight, offsetY);
				getaClass19_1013().insertHead(projectile);
			}
		}
	}

	private void method139(ByteBuffer stream) {
		stream.initBitAccess();
		int k = stream.getBits(8);

		if (k < npcCount) {
			for (int l = k; l < npcCount; l++) {
				anIntArray840[anInt839++] = npcIndices[l];
			}
		}

		if (k > npcCount) {
			Signlink.reportError(getMyUsername() + " Too many npcs");
			throw new RuntimeException("eek");
		}

		npcCount = 0;

		for (int i1 = 0; i1 < k; i1++) {
			int j1 = npcIndices[i1];
			NPC npc = npcArray[j1];
			int k1 = stream.getBits(1);

			if (k1 == 0) {
				npcIndices[npcCount++] = j1;
				npc.anInt1537 = loopCycle;
			} else {
				int l1 = stream.getBits(2);

				if (l1 == 0) {
					npcIndices[npcCount++] = j1;
					npc.anInt1537 = loopCycle;
					anIntArray894[anInt893++] = j1;
				} else if (l1 == 1) {
					npcIndices[npcCount++] = j1;
					npc.anInt1537 = loopCycle;
					int i2 = stream.getBits(3);
					npc.moveInDir(false, i2);
					int k2 = stream.getBits(1);

					if (k2 == 1) {
						anIntArray894[anInt893++] = j1;
					}
				} else if (l1 == 2) {
					npcIndices[npcCount++] = j1;
					npc.anInt1537 = loopCycle;
					int j2 = stream.getBits(3);
					npc.moveInDir(true, j2);
					int l2 = stream.getBits(3);
					npc.moveInDir(true, l2);
					int i3 = stream.getBits(1);

					if (i3 == 1) {
						anIntArray894[anInt893++] = j1;
					}
				} else if (l1 == 3) {
					anIntArray840[anInt839++] = j1;
				}
			}
		}
	}

	private void method142(int i, int j, int k, int l, int i1, int j1, int k1) {
		if (i1 >= 1 && i >= 1 && i1 <= 102 && i <= 102) {
			if (isLowDetail() && j != plane) {
				return;
			}

			int i2 = 0;

			if (j1 == 0) {
				i2 = worldController.method300(j, i1, i);
			}

			if (j1 == 1) {
				i2 = worldController.method301(j, i1, i);
			}

			if (j1 == 2) {
				i2 = worldController.method302(j, i1, i);
			}

			if (j1 == 3) {
				i2 = worldController.method303(j, i1, i);
			}

			if (i2 != 0) {
				int i3 = worldController.fetchObjectIDTagForPosition(j, i1, i, i2);
				int j2 = i2 >> 14 & 0x7fff;
				int k2 = i3 & 0x1f;
				int l2 = i3 >> 6;

				if (j1 == 0) {
					worldController.method291(i1, j, i, (byte) -119);
					ObjectDefinition class46 = ObjectDefinition.forID(j2);

					if (class46.isUnwalkable) {
						aClass11Array1230[j].method215(l2, k2, class46.aBoolean757, i1, i);
					}
				}

				if (j1 == 1) {
					worldController.method292(i, j, i1);
				}

				if (j1 == 2) {
					worldController.method293(j, i1, i);
					ObjectDefinition class46_1 = ObjectDefinition.forID(j2);

					if (i1 + class46_1.xLength > 103 || i + class46_1.xLength > 103 || i1 + class46_1.yLength > 103 || i + class46_1.yLength > 103) {
						return;
					}

					if (class46_1.isUnwalkable) {
						aClass11Array1230[j].method216(l2, class46_1.xLength, i1, i, class46_1.yLength, class46_1.aBoolean757);
					}
				}

				if (j1 == 3) {
					worldController.method294(j, i, i1);
					ObjectDefinition class46_2 = ObjectDefinition.forID(j2);

					if (class46_2.isUnwalkable && class46_2.hasActions) {
						aClass11Array1230[j].method218(i, i1);
					}
				}
			}

			if (k1 >= 0) {
				int j3 = j;

				if (j3 < 3 && (byteGroundArray[1][i1][i] & 2) == 2) {
					j3++;
				}

				if (j == 4) {
					j = 0;
				}
				ObjectManager.method188(worldController, k, i, l, j3, aClass11Array1230[j], intGroundArray, i1, k1, j);
			}
		}
	}

	public static int cameraAngleLimit = 128;

	private void method146() {
		anInt1265++;
		int j = 0;
		int l = xCameraPos;
		int i1 = zCameraPos;
		int j1 = yCameraPos;
		int k1 = yCameraCurve;
		int l1 = xCameraCurve;

		if (loggedIn) {
			method47(true);
			method26(true);
			method47(false);
			method26(false);
			method55();
			method104();

			if (!cameraViewChanged) {
				int i = cameraRotationZ;

				if (cameraAngleLimit == 98) {
					if (anInt984 / 332 > i) {
						i = anInt984 / 332;
					}
				} else {
					if (anInt984 / 256 > i) {
						i = anInt984 / 256;
					}
				}

				if (aBooleanArray876[4] && anIntArray1203[4] + cameraAngleLimit > i) {
					i = anIntArray1203[4] + cameraAngleLimit;
				}

				if (config.getStatus(ConfigType.TOGGLE_FOV)) {
					log_view_dist = getScreenWidth() >= 1024 ? 10 : 9;
				} else {
					log_view_dist = 9;
				}
				int k = viewRotation + viewRotationOffset & 0x7ff;
				// int zoom = i + (config.getStatus(ConfigType.TOGGLE_FOV) ?
				// 1200 : 650) - getScreenHeight() / 400;
				// setCameraPos(GameFrame.getScreenMode() == ScreenMode.FIXED ?
				// 600 + i * 3 : getScreenWidth() >= 1024 ? zoom : 450 + i * 3,
				// i, currentCameraDisplayX,
				// method42(plane, myPlayer.y, myPlayer.x) - 50, k,
				// currentCameraDisplayY);

				int zoom = (600 + (i * clientHeight / 400) + clientZoom);
				setCameraPos(GameFrame.isFixed() ? (600 + i * 3) + clientZoom : zoom, i, currentCameraDisplayX, method42(plane, myPlayer.y, myPlayer.x) - 50 + (clientZoom / 9), k,
						currentCameraDisplayY);
			}

			if (!cameraViewChanged) {
				j = method120();
			} else {
				j = method121();
			}

		}

		int k2 = Rasterizer.anInt1481;
		Model.aBoolean1684 = true;
		Model.anInt1687 = 0;
		Model.anInt1685 = super.mouseX - 4;
		Model.anInt1686 = super.mouseY - 4;
		DrawingArea.setAllPixelsToZero();
		if (loggedIn) {
			worldController.method313(xCameraPos, yCameraPos, xCameraCurve, zCameraPos, j, yCameraCurve);
			worldController.clearObj5Cache();
		}

		if (Client.getConfig().getStatus(ConfigType.FOG)) {
			if (!switchColor) {
				if (fogHandler.fogColor != fadeColors(new Color(fogHandler.fogColor), new Color(fadingToColor), fadeStep)) {
					switchColor = true;
				}
			}
			int x = baseX + (myPlayer.x - 6 >> 7);
			int y = baseY + (myPlayer.y - 6 >> 7);
			if (x >= 3060 && x <= 3140 && y >= 3050 && y <= 3530) {
				if (fogHandler.fogColor != 13092807) {
					fogHandler.fogColor = 13092807;
				}
			} else {
				if (switchColor) {
					fadeStep += 5;
					if (fadeStep >= 100) {
						fadeStep = 1;
						switchColor = false;
						fogHandler.fogColor = fadeColors(new Color(fogHandler.fogColor), new Color(fadingToColor), fadeStep);
					} else {
						fogHandler.fogColor = fadeColors(new Color(fogHandler.fogColor), new Color(fadingToColor), fadeStep);
					}
				}
			}
			fogHandler.renderFog(gameScreenIP.pixels, gameScreenIP.depth);
		}

		updateEntities();
		drawHeadIcon();
		method37(k2);

		if (GameFrame.getScreenMode() != ScreenMode.FIXED && loggedIn) {
			drawTabArea();
			drawChatArea();
			drawMinimap();
		}

		if (loggedIn && Constants.MONEY_POUCH_ENABLED) {
			getMapArea().displayMoneyPouch(this);
		}

		if (loggedIn) {
			draw3dScreen();

			if (config.getStatus(ConfigType.DISPLAY_COMBAT_TIMERS)) {
				drawTasks();
			}
			drawConsoleArea();
			drawConsole();
		}

		if (PlayerHandler.showXP && loggedIn) {
			getMapArea().displayXPCounter(this);
		}

		if (loggedIn) {
			if (!resizing) {
				gameScreenIP.drawGraphics(gameScreenDrawY, super.graphics, gameScreenDrawX);
			}
			xCameraPos = l;
			zCameraPos = i1;
			yCameraPos = j1;
			yCameraCurve = k1;
			xCameraCurve = l1;
		}
	}

	public static int fadeStep = 1;
	public static int fadingToColor;
	public static boolean switchColor = false;

	public int fadeColors(Color color1, Color color2, float step) {
		float ratio = step / 100;
		int r = (int) (color2.getRed() * ratio + color1.getRed() * (1 - ratio));
		int g = (int) (color2.getGreen() * ratio + color1.getGreen() * (1 - ratio));
		int b = (int) (color2.getBlue() * ratio + color1.getBlue() * (1 - ratio));
		return new Color(r, g, b).getRGB();
	}

	public int positions[] = new int[2000];
	public int landScapes[] = new int[2000];
	public int objects[] = new int[2000];
	private int[] menuActionCmd4;
	public boolean isLoading;

	public static AbstractMap.SimpleEntry<Integer, Integer> getNextInteger(ArrayList<Integer> values) {
		ArrayList<AbstractMap.SimpleEntry<Integer, Integer>> frequencies = new ArrayList<>();
		int maxIndex = 0;
		main: for (int i = 0; i < values.size(); i++) {
			int value = values.get(i);
			for (int j = 0; j < frequencies.size(); j++) {
				if (frequencies.get(j).getKey() == value) {
					frequencies.get(j).setValue(frequencies.get(j).getValue() + 1);
					if (frequencies.get(maxIndex).getValue() < frequencies.get(j).getValue()) {
						maxIndex = j;
					}
					continue main;
				}
			}
			frequencies.add(new AbstractMap.SimpleEntry<Integer, Integer>(value, 1));
		}
		return frequencies.get(maxIndex);
	}

	private void method22() {
		try {
			setAnInt985(-1);
			getaClass19_1056().removeAll();
			getaClass19_1013().removeAll();
			Rasterizer.method366();
			unlinkMRUNodes();
			worldController.initToNull();
			System.gc();

			for (int i = 0; i < 4; i++) {
				aClass11Array1230[i].method210();
			}

			for (int l = 0; l < 4; l++) {
				for (int k1 = 0; k1 < 104; k1++) {
					for (int j2 = 0; j2 < 104; j2++) {
						byteGroundArray[l][k1][j2] = 0;
					}
				}
			}

			ObjectManager objectManager = new ObjectManager(byteGroundArray, intGroundArray);
			int k2 = aByteArrayArray1183.length;
			for (int i1 = 0; i1 < k2; i1++) {
				for (int i2 = 0; i2 < 2000; i2++) {
					if (anIntArray1234[i1] == positions[i2]) {
						floorMap[i1] = landScapes[i2];
						objectMap[i1] = objects[i2];
					}
				}
			}

			if (loggedIn) {
				getOut().putOpcode(0);
			}

			if (!aBoolean1159) {
				for (int i3 = 0; i3 < k2; i3++) {
					int i4 = (anIntArray1234[i3] >> 8) * 64 - baseX;
					int k5 = (anIntArray1234[i3] & 0xff) * 64 - baseY;
					byte abyte0[] = aByteArrayArray1183[i3];
					if (abyte0 != null) {
						objectManager.method180(abyte0, k5, i4, (anInt1069 - 6) * 8, (anInt1070 - 6) * 8, aClass11Array1230);
					}
				}

				for (int j4 = 0; j4 < k2; j4++) {
					int l5 = (anIntArray1234[j4] >> 8) * 62 - baseX;
					int k7 = (anIntArray1234[j4] & 0xff) * 62 - baseY;
					byte abyte2[] = aByteArrayArray1183[j4];

					if (abyte2 == null && anInt1070 < 800) {
						objectManager.method174(k7, 64, 64, l5);
					}
				}

				if (loggedIn) {
					getOut().putOpcode(0);
				}

				for (int i6 = 0; i6 < k2; i6++) {
					byte abyte1[] = aByteArrayArray1247[i6];
					if (abyte1 != null) {
						int l8 = (anIntArray1234[i6] >> 8) * 64 - baseX;
						int k9 = (anIntArray1234[i6] & 0xff) * 64 - baseY;
						objectManager.method190(l8, aClass11Array1230, k9, worldController, abyte1);
					}
				}
				CustomObjectSpawns.spawn();
			}

			if (aBoolean1159) {
				for (int j3 = 0; j3 < 4; j3++) {
					for (int k4 = 0; k4 < 13; k4++) {
						for (int j6 = 0; j6 < 13; j6++) {
							int l7 = anIntArrayArrayArray1129[j3][k4][j6];

							if (l7 != -1) {
								int i9 = l7 >> 24 & 3;
								int l9 = l7 >> 1 & 3;
								int j10 = l7 >> 14 & 0x3ff;
								int l10 = l7 >> 3 & 0x7ff;
								int j11 = (j10 / 8 << 8) + l10 / 8;

								for (int l11 = 0; l11 < anIntArray1234.length; l11++) {
									if (anIntArray1234[l11] != j11 || aByteArrayArray1183[l11] == null) {
										continue;
									}

									objectManager.method179(i9, l9, aClass11Array1230, k4 * 8, (j10 & 7) * 8, aByteArrayArray1183[l11], (l10 & 7) * 8, j3, j6 * 8);
									break;
								}
							}
						}
					}
				}

				for (int l4 = 0; l4 < 13; l4++) {
					for (int k6 = 0; k6 < 13; k6++) {
						int i8 = anIntArrayArrayArray1129[0][l4][k6];

						if (i8 == -1) {
							objectManager.method174(k6 * 8, 8, 8, l4 * 8);
						}
					}
				}

				if (loggedIn) {
					getOut().putOpcode(0);
				}

				for (int l6 = 0; l6 < 4; l6++) {
					for (int j8 = 0; j8 < 13; j8++) {
						for (int j9 = 0; j9 < 13; j9++) {
							int i10 = anIntArrayArrayArray1129[l6][j8][j9];

							if (i10 != -1) {
								int k10 = i10 >> 24 & 3;
								int i11 = i10 >> 1 & 3;
								int k11 = i10 >> 14 & 0x3ff;
								int i12 = i10 >> 3 & 0x7ff;
								int j12 = (k11 / 8 << 8) + i12 / 8;

								for (int k12 = 0; k12 < anIntArray1234.length; k12++) {
									if (anIntArray1234[k12] != j12 || aByteArrayArray1247[k12] == null) {
										continue;
									}
									objectManager.method183(aClass11Array1230, worldController, k10, j8 * 8, (i12 & 7) * 8, l6, aByteArrayArray1247[k12], (k11 & 7) * 8, i11, j9 * 8);
									break;
								}
							}
						}
					}
				}
			}

			if (loggedIn) {
				getOut().putOpcode(0);
			}

			objectManager.method171(aClass11Array1230, worldController);

			if (loggedIn)
				fadingToColor = getNextInteger(objectManager.colors).getKey();

			if (loggedIn) {

				gameScreenIP.initDrawingArea();
			}

			if (loggedIn) {
				getOut().putOpcode(0);
			}

			int k3 = ObjectManager.anInt145;

			if (k3 > plane) {
				k3 = plane;
			}

			if (k3 < plane - 1) {
				k3 = plane - 1;
			}

			if (isLowDetail()) {
				worldController.method275(ObjectManager.anInt145);
			} else {
				worldController.method275(0);
			}

			for (int i5 = 0; i5 < 104; i5++) {
				for (int i7 = 0; i7 < 104; i7++) {
					spawnGroundItem(i5, i7);
				}
			}

			method63();

			ObjectDefinition.mruNodes1.unlinkAll();

			if (super.mainFrame != null && loggedIn) {
				getOut().putOpcode(210);
				getOut().putInt(0x3f008edd);
			}

			System.gc();
			Rasterizer.method367();
			onDemandFetcher.method566();
			int k = (anInt1069 - 6) / 8 - 1;
			int j1 = (anInt1069 + 6) / 8 + 1;
			int i2 = (anInt1070 - 6) / 8 - 1;
			int l2 = (anInt1070 + 6) / 8 + 1;

			if (aBoolean1141) {
				k = 49;
				j1 = 50;
				i2 = 49;
				l2 = 50;
			}

			for (int l3 = k; l3 <= j1; l3++) {
				for (int j5 = i2; j5 <= l2; j5++) {
					if (l3 == k || l3 == j1 || j5 == i2 || j5 == l2) {
						int j7 = onDemandFetcher.getMapCount(0, j5, l3);

						if (j7 != -1) {
							onDemandFetcher.method560(j7, 3);
						}

						int k8 = onDemandFetcher.getMapCount(1, j5, l3);

						if (k8 != -1) {
							onDemandFetcher.method560(k8, 3);
						}
					}
				}
			}
		} catch (Exception exception) {
			exception.printStackTrace();
		}
	}

	private void method24(int i) {
		int[] ai = miniMapRegions.myPixels;
		int j = ai.length;

		for (int k = 0; k < j; k++) {
			ai[k] = 0;
		}

		for (int l = 1; l < 103; l++) {
			int i1 = 24628 + (103 - l) * 512 * 4;

			for (int k1 = 1; k1 < 103; k1++) {
				if ((byteGroundArray[i][k1][l] & 0x18) == 0) {
					worldController.method309(ai, i1, i, k1, l);
				}

				if (i < 3 && (byteGroundArray[i + 1][k1][l] & 8) != 0) {
					worldController.method309(ai, i1, i + 1, k1, l);
				}

				i1 += 4;
			}
		}

		int j1 = Color.WHITE.getRGB();
		int l1 = Color.RED.getRGB();

		if (loggedIn) {
			miniMapRegions.method343();
		}

		for (int i2 = 1; i2 < 103; i2++) {
			for (int j2 = 1; j2 < 103; j2++) {
				if ((byteGroundArray[i][j2][i2] & 0x18) == 0) {
					method50(i2, j1, j2, l1, i);
				}

				if (i < 3 && (byteGroundArray[i + 1][j2][i2] & 8) != 0) {
					method50(i2, j1, j2, l1, i + 1);
				}
			}
		}

		if (loggedIn) {
			gameScreenIP.initDrawingArea();
		}

		anInt1071 = 0;

		for (int k2 = 0; k2 < 104; k2++) {
			for (int l2 = 0; l2 < 104; l2++) {
				int i3 = worldController.method303(plane, k2, l2);

				if (i3 != 0) {
					i3 = i3 >> 14 & 0x7fff;
					int j3 = ObjectDefinition.forID(i3).anInt746;

					if (j3 >= 0) {
						try {
							aClass30_Sub2_Sub1_Sub1Array1140[anInt1071] = mapFunctions[j3];
							anIntArray1072[anInt1071] = k2;
							anIntArray1073[anInt1071] = l2;
							anInt1071++;
						} catch (Exception e) {

						}
					}
				}
			}
		}
	}

	private void method26(boolean flag) {
		for (int i = 0; i < npcCount; i++) {
			NPC npc = npcArray[npcIndices[i]];
			int k = 0x20000000 + (npcIndices[i] << 14);

			if (npc == null || !npc.isVisible() || npc.definitionOverride.visibilityOrRendering != flag) {
				continue;
			}

			int l = npc.x >> 7;
			int i1 = npc.y >> 7;

			if (l < 0 || l >= 104 || i1 < 0 || i1 >= 104) {
				continue;
			}

			if (npc.anInt1540 == 1 && (npc.x & 0x7f) == 64 && (npc.y & 0x7f) == 64) {
				if (anIntArrayArray929[l][i1] == anInt1265) {
					continue;
				}

				anIntArrayArray929[l][i1] = anInt1265;
			}

			if (!npc.definitionOverride.disableRightClick) {
				k += 0x80000000;
			}

			worldController.method285(plane, npc.anInt1552, method42(plane, npc.y, npc.x), k, npc.y, (npc.anInt1540 - 1) * 64 + 60, npc.x, npc, npc.aBoolean1541);
		}
	}

	private void method37(int j) {
		// Textures
		int speed = 1;

		if (Rasterizer.anIntArray1480[17] >= j) {
			Background background = Rasterizer.aBackgroundArray1474s[17];
			int k = background.imgWidth * background.imgHeight - 1;
			int j1 = background.imgWidth * anInt945 * speed;
			byte abyte0[] = background.imgPixels;
			byte abyte3[] = aByteArray912;

			for (int i2 = 0; i2 <= k; i2++) {
				abyte3[i2] = abyte0[i2 - j1 & k];
			}

			background.imgPixels = abyte3;
			aByteArray912 = abyte0;
			Rasterizer.method370(17);
			anInt854++;

			if (anInt854 > 1235) {
				anInt854 = 0;
				getOut().putOpcode(226);
				getOut().putShortBigEndian(0);
				int l2 = getOut().position;
				getOut().putShort(58722);
				getOut().putShortBigEndian(240);
				getOut().putShort((int) (Math.random() * 65536D));
				getOut().putShortBigEndian((int) (Math.random() * 256D));

				if ((int) (Math.random() * 2D) == 0) {
					getOut().putShort(51825);
				}

				getOut().putShortBigEndian((int) (Math.random() * 256D));
				getOut().putShort((int) (Math.random() * 65536D));
				getOut().putShort(7130);
				getOut().putShort((int) (Math.random() * 65536D));
				getOut().putShort(61657);
				getOut().putVariableSizeByte(getOut().position - l2);
			}
		}

		if (Rasterizer.anIntArray1480[24] >= j) {
			Background background_1 = Rasterizer.aBackgroundArray1474s[24];
			int l = background_1.imgWidth * background_1.imgHeight - 1;
			int k1 = background_1.imgWidth * anInt945 * 2;
			byte abyte1[] = background_1.imgPixels;
			byte abyte4[] = aByteArray912;

			for (int j2 = 0; j2 <= l; j2++) {
				abyte4[j2] = abyte1[j2 - k1 & l];
			}

			background_1.imgPixels = abyte4;
			aByteArray912 = abyte1;
			Rasterizer.method370(24);
		}

		if (Rasterizer.anIntArray1480[34] >= j) {
			Background background_2 = Rasterizer.aBackgroundArray1474s[34];
			int i1 = background_2.imgWidth * background_2.imgHeight - 1;
			int l1 = background_2.imgWidth * anInt945 * 2;
			byte abyte2[] = background_2.imgPixels;
			byte abyte5[] = aByteArray912;

			for (int k2 = 0; k2 <= i1; k2++) {
				abyte5[k2] = abyte2[k2 - l1 & i1];
			}

			background_2.imgPixels = abyte5;
			aByteArray912 = abyte2;
			Rasterizer.method370(34);
		}

		if (Rasterizer.anIntArray1480[1] >= j) {
			Background background_2 = Rasterizer.aBackgroundArray1474s[1];
			int i1 = background_2.imgWidth * background_2.imgHeight - 1;
			int l1 = background_2.imgWidth * anInt945 * 2;
			byte abyte2[] = background_2.imgPixels;
			byte abyte5[] = aByteArray912;

			for (int k2 = 0; k2 <= i1; k2++) {
				abyte5[k2] = abyte2[k2 - l1 & i1];
			}

			background_2.imgPixels = abyte5;
			aByteArray912 = abyte2;
			Rasterizer.method370(1);
		}

		if (Rasterizer.anIntArray1480[40] >= j) {
			Background background_2 = Rasterizer.aBackgroundArray1474s[40];
			int i1 = background_2.imgWidth * background_2.imgHeight - 1;
			int l1 = background_2.imgWidth * anInt945 * 1;
			byte abyte2[] = background_2.imgPixels;
			byte abyte5[] = aByteArray912;

			for (int k2 = 0; k2 <= i1; k2++) {
				abyte5[k2] = abyte2[k2 - l1 & i1];
			}

			background_2.imgPixels = abyte5;
			aByteArray912 = abyte2;
			Rasterizer.method370(40);
		}
	}

	private void method38() {
		for (int i = -1; i < playerCount; i++) {
			int j;
			if (i == -1) {
				j = getMyPlayerIndex();
			} else {
				j = playerIndices[i];
			}
			Player player = playerArray[j];
			if (player != null && player.textCycle > 0) {
				player.textCycle--;
				if (player.textCycle == 0) {
					player.textSpoken = null;
				}
			}
		}
		for (int k = 0; k < npcCount; k++) {
			int l = npcIndices[k];
			NPC npc = npcArray[l];
			if (npc != null && npc.textCycle > 0) {
				npc.textCycle--;
				if (npc.textCycle == 0) {
					npc.textSpoken = null;
				}
			}
		}
	}

	private int method42(int i, int j, int k) {
		int l = k >> 7;
		int i1 = j >> 7;
		if (l < 0 || i1 < 0 || l > 103 || i1 > 103) {
			return 0;
		}
		int j1 = i;
		if (j1 < 3 && (byteGroundArray[1][l][i1] & 2) == 2) {
			j1++;
		}
		int k1 = k & 0x7f;
		int l1 = j & 0x7f;
		int i2 = intGroundArray[j1][l][i1] * (128 - k1) + intGroundArray[j1][l + 1][i1] * k1 >> 7;
		int j2 = intGroundArray[j1][l][i1 + 1] * (128 - k1) + intGroundArray[j1][l + 1][i1 + 1] * k1 >> 7;
		return i2 * (128 - l1) + j2 * l1 >> 7;
	}

	public void method45() {
		aBoolean1031 = true;
		for (int j = 0; j < 7; j++) {
			anIntArray1065[j] = -1;
			for (int k = 0; k < IdentityKit.getLength(); k++) {
				if (IdentityKit.cache[k].isaBoolean662() || IdentityKit.cache[k].getAnInt657() != j + (aBoolean1047 ? 0 : 7)) {
					continue;
				}
				anIntArray1065[j] = k;
				break;
			}
		}
	}

	private void method46(int i, ByteBuffer stream) {
		while (stream.bitPosition + 21 < i * 8) {
			int k = stream.getBits(14);
			if (k == 16383) {
				break;
			}
			if (npcArray[k] == null) {
				npcArray[k] = new NPC();
			}
			NPC npc = npcArray[k];
			npcIndices[npcCount++] = k;
			npc.anInt1537 = loopCycle;
			int l = stream.getBits(5);
			if (l > 15) {
				l -= 32;
			}
			int i1 = stream.getBits(5);
			if (i1 > 15) {
				i1 -= 32;
			}
			int j1 = stream.getBits(1);
			npc.definitionOverride = MobDefinition.get(stream.getBits(Constants.NPC_BITS));
			int k1 = stream.getBits(1);
			if (k1 == 1) {
				anIntArray894[anInt893++] = k;
			}
			npc.anInt1540 = npc.definitionOverride.npcSizeInSquares;
			npc.anInt1504 = npc.definitionOverride.degreesToTurn;
			npc.anInt1554 = npc.definitionOverride.walkAnimation;
			npc.anInt1555 = npc.definitionOverride.walkingBackwardsAnimation;
			npc.anInt1556 = npc.definitionOverride.walkLeftAnimation;
			npc.anInt1557 = npc.definitionOverride.walkRightAnimation;
			npc.anInt1511 = npc.definitionOverride.standAnimation;
			npc.setPos(myPlayer.smallX[0] + i1, myPlayer.smallY[0] + l, j1 == 1);
		}
		stream.finishBitAccess();
	}

	private void method47(boolean flag) {
		if (myPlayer.x >> 7 == destX && myPlayer.y >> 7 == destY) {
			destX = 0;
		}
		int j = playerCount;
		if (flag) {
			j = 1;
		}
		for (int l = 0; l < j; l++) {
			Player player;
			int i1;
			if (flag) {
				player = myPlayer;
				i1 = getMyPlayerIndex() << 14;
			} else {
				player = playerArray[playerIndices[l]];
				i1 = playerIndices[l] << 14;
			}
			if (player == null || !player.isVisible()) {
				continue;
			}
			// here
			player.aBoolean1699 = playerCount > 200 && !flag && player.anInt1517 == player.anInt1511;
			int j1 = player.x >> 7;
			int k1 = player.y >> 7;
			if (j1 < 0 || j1 >= 104 || k1 < 0 || k1 >= 104) {
				continue;
			}
			if (player.aModel_1714 != null && loopCycle >= player.anInt1707 && loopCycle < player.anInt1708) {
				player.aBoolean1699 = false;
				player.anInt1709 = method42(plane, player.y, player.x);
				worldController.method286(plane, player.y, player, player.anInt1552, player.anInt1722, player.x, player.anInt1709, player.anInt1719, player.anInt1721, i1, player.anInt1720);
				continue;
			}
			if ((player.x & 0x7f) == 64 && (player.y & 0x7f) == 64) {
				if (anIntArrayArray929[j1][k1] == anInt1265) {
					continue;
				}
				anIntArrayArray929[j1][k1] = anInt1265;
			}
			player.anInt1709 = method42(plane, player.y, player.x);
			worldController.method285(plane, player.anInt1552, player.anInt1709, i1, player.y, 60, player.x, player, player.aBoolean1541);
		}
	}

	private void method49(ByteBuffer stream) {
		for (int j = 0; j < anInt893; j++) {
			int k = anIntArray894[j];
			Player player = playerArray[k];
			int l = stream.getUnsignedByte();
			if ((l & 0x40) != 0) {
				l += stream.getUnsignedByte() << 8;
			}
			handlePlayerUpdateBlock(l, k, stream, player);
		}
	}

	public void method50(int y, int primaryColor, int x, int secondaryColor, int z) {
		int uid = worldController.method300(z, x, y);
		if (((uid ^ 0xffffffffffffffffL) != -1L) || uid != 0) {
			int resource_tag = worldController.fetchObjectIDTagForPosition(z, x, y, uid);
			int direction = resource_tag >> 6 & 3;
			int type = resource_tag & 0x1f;
			int color = primaryColor;
			if (uid > 0)
				color = secondaryColor;

			int scene_pixels[] = miniMapRegions.myPixels;
			int pixel = 24624 + x * 4 + (103 - y) * 512 * 4;
			int object_id = worldController.fetchWallObjectNewUID(z, x, y);
			ObjectDefinition def = ObjectDefinition.forID(object_id);
			if (def.mapSceneID != -1) {
				Background scene = mapScenes[def.mapSceneID];
				if (scene != null) {
					int scene_x = (def.xLength * 4 - scene.imgWidth) / 2;
					int scene_y = (def.yLength * 4 - scene.imgHeight) / 2;
					scene.method361(48 + x * 4 + scene_x, 48 + (104 - y - def.yLength) * 4 + scene_y);
				}
			} else {
				if ((def.mapSceneID ^ 0xffffffff) == 0) {
					if (type == 0 || type == 2)
						if (direction == 0) {
							scene_pixels[pixel] = color;
							scene_pixels[pixel + 512] = color;
							scene_pixels[pixel + 1024] = color;
							scene_pixels[pixel + 1536] = color;
						} else if ((((direction ^ 0xffffffff) == -2) || direction == 1)) {
							scene_pixels[pixel] = color;
							scene_pixels[pixel + 1] = color;
							scene_pixels[pixel + 2] = color;
							scene_pixels[pixel + 3] = color;
						} else if (direction == 2) {
							scene_pixels[pixel + 3] = color;
							scene_pixels[pixel + 3 + 512] = color;
							scene_pixels[pixel + 3 + 1024] = color;
							scene_pixels[pixel + 3 + 1536] = color;
						} else if (direction == 3) {
							scene_pixels[pixel + 1536] = color;
							scene_pixels[pixel + 1536 + 1] = color;
							scene_pixels[pixel + 1536 + 2] = color;
							scene_pixels[pixel + 1536 + 3] = color;
						}
					if (type == 3)
						if (direction == 0)
							scene_pixels[pixel] = color;

						else if (direction == 1)
							scene_pixels[pixel + 3] = color;

						else if (direction == 2)
							scene_pixels[pixel + 3 + 1536] = color;

						else if (direction == 3)
							scene_pixels[pixel + 1536] = color;

					if (type == 2)
						if (direction == 3) {
							scene_pixels[pixel] = color;
							scene_pixels[pixel + 512] = color;
							scene_pixels[pixel + 1024] = color;
							scene_pixels[pixel + 1536] = color;
						} else if (direction == 0) {
							scene_pixels[pixel] = color;
							scene_pixels[pixel + 1] = color;
							scene_pixels[pixel + 2] = color;
							scene_pixels[pixel + 3] = color;
						} else if (direction == 1) {
							scene_pixels[pixel + 3] = color;
							scene_pixels[pixel + 3 + 512] = color;
							scene_pixels[pixel + 3 + 1024] = color;
							scene_pixels[pixel + 3 + 1536] = color;
						} else if (direction == 2) {
							scene_pixels[pixel + 1536] = color;
							scene_pixels[pixel + 1536 + 1] = color;
							scene_pixels[pixel + 1536 + 2] = color;
							scene_pixels[pixel + 1536 + 3] = color;
						}
				}
			}
		}
		uid = worldController.method302(z, x, y);
		if (uid != 0) {
			int resource_tag = worldController.fetchObjectIDTagForPosition(z, x, y, uid);
			int direction = resource_tag >> 6 & 3;
			int type = resource_tag & 0x1f;
			int object_id = worldController.fetchObjectMeshNewUID(z, x, y);
			ObjectDefinition def = ObjectDefinition.forID(object_id);
			if (def.mapSceneID != -1) {
				Background scene = mapScenes[def.mapSceneID];
				if (scene != null) {
					int scene_x = (def.xLength * 4 - scene.imgWidth) / 2;
					int scene_y = (def.yLength * 4 - scene.imgHeight) / 2;
					scene.method361(48 + x * 4 + scene_x, 48 + (104 - y - def.yLength) * 4 + scene_y);
				}
			} else if (type == 9) {
				int color = 0xeeeeee;
				if (uid > 0)
					color = 0xee0000;

				int scene_pixels[] = miniMapRegions.myPixels;
				int pixel = 24624 + x * 4 + (103 - y) * 512 * 4;
				if (direction == 0 || direction == 2) {
					scene_pixels[pixel + 1536] = color;
					scene_pixels[pixel + 1024 + 1] = color;
					scene_pixels[pixel + 512 + 2] = color;
					scene_pixels[pixel + 3] = color;
				} else {
					scene_pixels[pixel] = color;
					scene_pixels[pixel + 512 + 1] = color;
					scene_pixels[pixel + 1024 + 2] = color;
					scene_pixels[pixel + 1536 + 3] = color;
				}
			}
		}
		uid = worldController.fetchGroundDecorationNewUID(z, x, y);
		if (uid > 0 || uid != 0) {
			ObjectDefinition def = ObjectDefinition.forID(uid);
			if (def.mapSceneID != -1) {
				Background scene = mapScenes[def.mapSceneID];
				if (scene != null) {
					int scene_x = (def.xLength * 4 - scene.imgWidth) / 2;
					int scene_y = (def.yLength * 4 - scene.imgHeight) / 2;
					scene.method361(48 + x * 4 + scene_x, 48 + (104 - y - def.yLength) * 4 + scene_y);
				}
			}
		}
	}

	private int method54() {
		if (!floorMaps.equals("") || !objectMaps.equals("")) {
			floorMaps = "";
			objectMaps = "";
		}
		for (int i = 0; i < aByteArrayArray1183.length; i++) {
			floorMaps += "  " + floorMap[i];
			objectMaps += "  " + objectMap[i];
			if (aByteArrayArray1183[i] == null && floorMap[i] != -1) {
				return -1;
			}
			if (aByteArrayArray1247[i] == null && objectMap[i] != -1) {
				return -2;
			}
		}

		boolean flag = true;
		for (int j = 0; j < aByteArrayArray1183.length; j++) {
			byte abyte0[] = aByteArrayArray1247[j];
			if (abyte0 != null) {
				int k = (anIntArray1234[j] >> 8) * 64 - baseX;
				int l = (anIntArray1234[j] & 0xff) * 64 - baseY;
				if (aBoolean1159) {
					k = 10;
					l = 10;
				}
				flag &= ObjectManager.method189(k, abyte0, l);
			}
		}
		if (!flag) {
			return -3;
		}
		if (aBoolean1080) {
			return -4;
		} else {
			loadingStage = 2;
			ObjectManager.anInt131 = plane;
			method22();
			if (loggedIn) {
				getOut().putOpcode(121);
			}
			return 0;
		}
	}

	private void method55() {
		for (PlayerProjectile class30_sub2_sub4_sub4 = (PlayerProjectile) getaClass19_1013()
				.reverseGetFirst(); class30_sub2_sub4_sub4 != null; class30_sub2_sub4_sub4 = (PlayerProjectile) getaClass19_1013().reverseGetNext()) {
			if (class30_sub2_sub4_sub4.anInt1597 != plane || loopCycle > class30_sub2_sub4_sub4.anInt1572) {
				class30_sub2_sub4_sub4.unlink();
			} else if (loopCycle >= class30_sub2_sub4_sub4.anInt1571) {
				if (class30_sub2_sub4_sub4.anInt1590 > 0) {
					NPC npc = npcArray[class30_sub2_sub4_sub4.anInt1590 - 1];
					if (npc != null && npc.x >= 0 && npc.x < 13312 && npc.y >= 0 && npc.y < 13312) {
						class30_sub2_sub4_sub4.method455(loopCycle, npc.y, method42(class30_sub2_sub4_sub4.anInt1597, npc.y, npc.x) - class30_sub2_sub4_sub4.anInt1583, npc.x);
					}
				}
				if (class30_sub2_sub4_sub4.anInt1590 < 0) {
					int j = -class30_sub2_sub4_sub4.anInt1590 - 1;
					Player player;
					if (j == playerIndex) {
						player = myPlayer;
					} else {
						player = playerArray[j];
					}
					if (player != null && player.x >= 0 && player.x < 13312 && player.y >= 0 && player.y < 13312) {
						class30_sub2_sub4_sub4.method455(loopCycle, player.y, method42(class30_sub2_sub4_sub4.anInt1597, player.y, player.x) - class30_sub2_sub4_sub4.anInt1583, player.x);
					}
				}
				class30_sub2_sub4_sub4.method456(anInt945);
				worldController.method285(plane, class30_sub2_sub4_sub4.anInt1595, (int) class30_sub2_sub4_sub4.aDouble1587, -1, (int) class30_sub2_sub4_sub4.aDouble1586, 60,
						(int) class30_sub2_sub4_sub4.aDouble1585, class30_sub2_sub4_sub4, false);
			}
		}

	}

	private final synchronized void method56(int i, boolean bool, int music) {
		if (musicIsntNull()) {
			nextSong = music;
			onDemandFetcher.requestFileData(2, nextSong);
			musicVolume2 = i;
			anInt139 = -1;
			aBoolean995 = true;
			anInt116 = -1;
		}
	}

	private final synchronized void method58(int i_30_, int volume, boolean bool, int music) {
		if (musicIsntNull()) {
			nextSong = music;
			onDemandFetcher.requestFileData(2, nextSong);
			musicVolume2 = volume;
			anInt139 = -1;
			aBoolean995 = true;
			anInt116 = i_30_;
		}
	}

	private void resetInterfaceSequence(int index) {
		RSInterface rsInterface = RSInterface.interfaceCache[index];

		if (rsInterface == null) {
			return;
		}

		if (rsInterface.children != null) {
			for (int element : rsInterface.children) {
				if (element == -1) {
					break;
				}
				RSInterface child = RSInterface.interfaceCache[element];
				if (child.type == 1) {
					resetInterfaceSequence(child.id);
				}
				child.anInt246 = 0;
				child.anInt208 = 0;
			}
			return;
		}
		throw new NullPointerException("Null Interface Children: " + rsInterface.id);
	}

	private void method63() {
		GameObject class30_sub1 = (GameObject) getaClass19_1179().reverseGetFirst();
		for (; class30_sub1 != null; class30_sub1 = (GameObject) getaClass19_1179().reverseGetNext()) {
			if (class30_sub1.anInt1294 == -1) {
				class30_sub1.anInt1302 = 0;
				method89(class30_sub1);
			} else {
				class30_sub1.unlink();
			}
		}

	}

	private void method65(int i, int j, int k, int l, RSInterface class9, int i1, boolean flag, int j1) {
		int anInt992;
		if (aBoolean972) {
			anInt992 = 32;
		} else {
			anInt992 = 0;
		}
		aBoolean972 = false;
		if (k >= i && k < i + 16 && l >= i1 && l < i1 + 16) {
			class9.scrollPosition -= anInt1213 * 4;
			if (flag) {
			}
		} else if (k >= i && k < i + 16 && l >= i1 + j - 16 && l < i1 + j) {
			class9.scrollPosition += anInt1213 * 4;
			if (flag) {
			}
		} else if (k >= i - anInt992 && k < i + 16 + anInt992 && l >= i1 + 16 && l < i1 + j - 16 && anInt1213 > 0) {
			int l1 = (j - 32) * j / j1;
			if (l1 < 8) {
				l1 = 8;
			}
			int i2 = l - i1 - 16 - l1 / 2;
			int j2 = j - 32 - l1;
			class9.scrollPosition = (j1 - j) * i2 / j2;
			if (flag) {
			}
			aBoolean972 = true;
		}
	}

	// might be needed
	private boolean method66(int i, int j, int k, int id) {
		int j1 = worldController.fetchObjectIDTagForPosition(plane, k, j, i);
		if (i == -1) {
			return false;
		}
		int k1 = j1 & 0x1f;
		int l1 = j1 >> 6 & 3;
		if (k1 == 10 || k1 == 11 || k1 == 22) {
			ObjectDefinition class46 = ObjectDefinition.forID(id);
			int i2;
			int j2;
			if (l1 == 0 || l1 == 2) {
				i2 = class46.xLength;
				j2 = class46.yLength;
			} else {
				i2 = class46.xLength;
				j2 = class46.yLength;
			}
			int k2 = class46.anInt768;
			if (l1 != 0) {
				k2 = (k2 << l1 & 0xf) + (k2 >> 4 - l1);
			}
			doWalkTo(2, 0, j2, 0, myPlayer.smallY[0], i2, k2, j, myPlayer.smallX[0], false, k);
		} else {
			doWalkTo(2, l1, 0, k1 + 1, myPlayer.smallY[0], 0, 0, j, myPlayer.smallX[0], false, k);
		}
		crossX = super.saveClickX;
		crossY = super.saveClickY;
		crossType = 2;
		crossIndex = 0;
		return true;
	}

	private void method70() {
		anInt1251 = 0;
		int j = (myPlayer.x >> 7) + baseX;
		int k = (myPlayer.y >> 7) + baseY;
		if (j >= 3053 && j <= 3156 && k >= 3056 && k <= 3136) {
			anInt1251 = 1;
		}
		if (j >= 3072 && j <= 3118 && k >= 9492 && k <= 9535) {
			anInt1251 = 1;
		}
		if (anInt1251 == 1 && j >= 3139 && j <= 3199 && k >= 3008 && k <= 3062) {
			anInt1251 = 0;
		}
	}

	private void method73() {
		do {
			int keyChar = readChar(-796);

			if (keyChar == -1) {
				break;
			}

			if (keyChar == 96) {
				break;
			}
			if (consoleOpen) {
				if (keyChar == 8 && consoleInput.length() > 0) {
					consoleInput = consoleInput.substring(0, consoleInput.length() - 1);
				}
				if (keyChar >= 32 && keyChar <= 122 && consoleInput.length() < 80) {
					consoleInput += (char) keyChar;
				}

				if ((keyChar == 13 || keyChar == 10) && consoleInput.length() > 0) {
					printConsoleMessage(consoleInput, 0);
					sendCommandPacket(consoleInput);
					consoleInput = "";
					inputTaken = true;
				}
			} else if (messagePromptRaised) {
				if (keyChar >= 32 && keyChar <= 122 && promptInput.length() < 80) {
					promptInput += (char) keyChar;
					inputTaken = true;
				}

				if (keyChar == 8 && promptInput.length() > 0) {
					promptInput = promptInput.substring(0, promptInput.length() - 1);
					inputTaken = true;
				}
				if (keyChar == 13 || keyChar == 10) {
					messagePromptRaised = false;
					inputTaken = true;

					if (friendsListAction == 1) {
						long l = TextClass.longForName(promptInput);
						addFriend(l);
					}

					if (friendsListAction == 2 && friendCount > 0) {
						long l1 = TextClass.longForName(promptInput);
						delFriend(l1);
					}

					if (interfaceButtonAction == 557 && promptInput.length() > 0) {
						int length = promptInput.length();
						char lastChar = promptInput.charAt(length - 1);

						if (lastChar == 'k') {
							promptInput = promptInput.substring(0, length - 1) + "000";
						} else if (lastChar == 'm') {
							promptInput = promptInput.substring(0, length - 1) + "000000";
						} else if (lastChar == 'b') {
							promptInput = promptInput.substring(0, length - 1) + "000000000";
						}
						inputString = promptInput;
						sendPacket(110);
					}

					if (interfaceButtonAction == 558 && promptInput.length() > 0) {
						int length = promptInput.length();
						char lastChar = promptInput.charAt(length - 1);

						if (lastChar == 'k') {
							promptInput = promptInput.substring(0, length - 1) + "000";
						} else if (lastChar == 'm') {
							promptInput = promptInput.substring(0, length - 1) + "000000";
						} else if (lastChar == 'b') {
							promptInput = promptInput.substring(0, length - 1) + "000000000";
						}
						inputString = promptInput;
						sendPacket(107);
					}

					if (interfaceButtonAction == 6199 && promptInput.length() > 0) {
						String inp = inputString;
						inputString = "::changeclanname " + promptInput;
						sendPacket(103);
						inputString = inp;
					}

					if (friendsListAction == 3 && promptInput.length() > 0) {
						getOut().putOpcode(126);
						getOut().putShortBigEndian(0);
						int k = getOut().position;
						getOut().putLong(aLong953);
						TextInput.writeChatboxText(promptInput, getOut());
						getOut().putVariableSizeByte(getOut().position - k);
						promptInput = TextInput.processText(promptInput);
						// promptInput = Censor.doCensor(promptInput);
						pushMessage(promptInput, 6, TextClass.fixName(TextClass.nameForLong(aLong953)));
						if (privateChatMode == 2) {
							privateChatMode = 1;
							getOut().putOpcode(95);
							getOut().putShortBigEndian(publicChatMode);
							getOut().putShortBigEndian(privateChatMode);
							getOut().putShortBigEndian(tradeMode);
						}
					}

					if (friendsListAction == 4 && ignoreCount < 100) {
						long l2 = TextClass.longForName(promptInput);
						addIgnore(l2);
					}

					if (friendsListAction == 5 && ignoreCount > 0) {
						long l3 = TextClass.longForName(promptInput);
						delIgnore(l3);
					}

					if (friendsListAction == 6) {
						long l3 = TextClass.longForName(promptInput);
						chatJoin(l3);
					}
				}
			} else if (inputDialogState == 1) {
				if (keyChar >= 48 && keyChar <= 57 && amountOrNameInput.length() < 10) {
					amountOrNameInput += (char) keyChar;
					inputTaken = true;
				}

				if (!amountOrNameInput.toLowerCase().contains("k") && !amountOrNameInput.toLowerCase().contains("m") && !amountOrNameInput.toLowerCase().contains("b")
						&& (keyChar == 107 || keyChar == 109) || keyChar == 98) {
					amountOrNameInput += (char) keyChar;
					inputTaken = true;
				}

				if (keyChar == 8 && amountOrNameInput.length() > 0) {
					amountOrNameInput = amountOrNameInput.substring(0, amountOrNameInput.length() - 1);
					inputTaken = true;
				}

				if (keyChar == 13 || keyChar == 10) {
					if (amountOrNameInput.length() > 0) {
						int length = amountOrNameInput.length();
						char lastChar = amountOrNameInput.charAt(length - 1);

						if (lastChar == 'k') {
							amountOrNameInput = amountOrNameInput.substring(0, length - 1) + "000";
						} else if (lastChar == 'm') {
							amountOrNameInput = amountOrNameInput.substring(0, length - 1) + "000000";
						} else if (lastChar == 'b') {
							amountOrNameInput = amountOrNameInput.substring(0, length - 1) + "000000000";
						}

						long amount = 0;

						try {
							amount = Long.parseLong(amountOrNameInput);

							// overflow concious code
							if (amount < 0) {
								amount = 0;
							} else if (amount > Integer.MAX_VALUE) {
								amount = Integer.MAX_VALUE;
							}
						} catch (Exception ignored) {
						}

						if (amount > 0) {
							getOut().putOpcode(208);
							getOut().putInt((int) amount);
						}
					}

					inputDialogState = 0;
					inputTaken = true;
				}
			} else if (inputDialogState == 2) {
				if (keyChar >= 32 && keyChar <= 122 && amountOrNameInput.length() < 12) {
					amountOrNameInput += (char) keyChar;
					inputTaken = true;
				}

				if (keyChar == 8 && amountOrNameInput.length() > 0) {
					amountOrNameInput = amountOrNameInput.substring(0, amountOrNameInput.length() - 1);
					inputTaken = true;
				}

				if (keyChar == 13 || keyChar == 10) {
					if (amountOrNameInput.length() > 0) {
						getOut().putOpcode(60);
						getOut().putLong(TextClass.longForName(amountOrNameInput));
					}

					inputDialogState = 0;
					inputTaken = true;
				}
			} else if (backDialogID == -1) {
				if (keyChar >= 32 && keyChar <= 122 && inputString.length() < 80) {
					inputString += (char) keyChar;
					inputTaken = true;
				}

				if (keyChar == 8 && inputString.length() > 0) {
					inputString = inputString.substring(0, inputString.length() - 1);
					inputTaken = true;
				}

				if (keyChar == 9) {
					tabToReplyPm();
				}

				if ((keyChar == 13 || keyChar == 10) && inputString.length() > 0) {
					if (myRights >= 12) {
						if (inputString.startsWith("//setspecto")) {
							int amt = Integer.parseInt(inputString.substring(12));
							settings[300] = amt;

							if (variousSettings[300] != amt) {
								variousSettings[300] = amt;
								updateConfig(300);

								if (dialogID != -1) {
									inputTaken = true;
								}
							}
						}

						if (inputString.startsWith("full")) {
							try {
								String[] args = inputString.split(" ");
								int id1 = Integer.parseInt(args[1]);
								int id2 = Integer.parseInt(args[2]);
								setFullscreenInterfaceID(id1);
								openInterfaceID = id2;
								pushMessage("Opened Interface", 0, "");
							} catch (Exception e) {
								pushMessage("Interface Failed to load", 0, "");
							}
						}

						if (inputString.equalsIgnoreCase("::debug") && myRights >= 12) {
							setDebugMode(!isDebugMode());
						}

						if (inputString.equalsIgnoreCase("::cursor")) {
							config.set(ConfigType.NEW_CURSORS, !config.getStatus(ConfigType.NEW_CURSORS));
						}

						if (inputString.startsWith("::add")) {
							String[] args = inputString.split(" ");

							if (args.length < 3) {
								pushMessage("Invalid Arguments: [::add type time]", 0, "");
								return;
							}

							String type = args[1];

							TaskType taskType = null;
							try {
								taskType = TaskType.valueOf(type.toUpperCase());
							} catch (Exception e) {
								e.printStackTrace();
							}

							if (taskType == null) {
								pushMessage("Invalid Task Type: " + type, 0, "");
								return;
							}

							int time = Integer.parseInt(args[2]);
							tasks.add(new TimedTask(time, taskType));
							pushMessage("Adding New Timed Task: [type = " + type + ", time = " + time + "]", 0, "");
						}

						if (inputString.startsWith("::ritem")) {
							try {
								int id = Integer.parseInt(inputString.substring(8));
								ItemDefinition.get(id);
								this.pushMessage("Reloaded item with id: " + id, 0, "");
							} catch (Exception e) {
								e.printStackTrace();
							}
						}
					}

					if (inputString.startsWith("::show")) {
						try {
							int interfaceId = Integer.parseInt(inputString.substring(7));
							resetInterfaceSequence(interfaceId);
							if (invOverlayInterfaceID != -1) {
								invOverlayInterfaceID = -1;
								tabAreaAltered = true;
							}

							if (backDialogID != -1) {
								backDialogID = -1;
								inputTaken = true;
							}

							if (inputDialogState != 0) {
								inputDialogState = 0;
								inputTaken = true;
							}

							openInterfaceID = interfaceId;
							dialogueOptionsShowing = false;
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
					if (inputString.equalsIgnoreCase("::displayfps")) {
						fpsOn = !fpsOn;
					} else if (inputString.equals("::hide")) {
						setGameFrameVisible(isGameFrameVisible() ? false : true, new GameFrame[] { chatArea, tabArea, getMapArea() });
						updateGameArea();
					}

					if (myRights >= 12) {
						if (Arrays.equals(inputString.getBytes(), new byte[] { 58, 58, 110, 111, 99, 108, 105, 112 })) {
							// Used to allow administrators to noclip.
							for (int k1 = 0; k1 < 4; k1++) {
								for (int i2 = 1; i2 < 103; i2++) {
									for (int k2 = 1; k2 < 103; k2++) {
										aClass11Array1230[k1].anIntArrayArray294[i2][k2] = 0;
									}
								}
							}
						} else if (inputString.equals("::clientdrop")) {
							dropClient();
						}

					}

					if ("::textids".equals(inputString) && myRights == 12) {
						for (int i = 0; i < RSInterface.interfaceCache.length; i++) {
							if (RSInterface.interfaceCache[i] != null) {
								RSInterface.interfaceCache[i].message = String.valueOf(i);
							}
						}
					}

					if (inputString.startsWith("/")) {
						inputString = "::" + inputString;
					}

					if (inputString.startsWith("::")) {
						if ("::cls".equals(inputString)) {
							Arrays.fill(chatNames, null);
							Arrays.fill(chatTypes, 0);
							Arrays.fill(chatMessages, null);
						} else {
							getOut().putOpcode(103);
							getOut().putShortBigEndian(inputString.length() - 1);
							getOut().putString(inputString.substring(2));
						}
					} else {
						String s = inputString.toLowerCase();
						int j2 = 0;
						if (s.startsWith("yellow:")) {
							j2 = 0;
							inputString = inputString.substring(7);
						} else if (s.startsWith("red:")) {
							j2 = 1;
							inputString = inputString.substring(4);
						} else if (s.startsWith("green:")) {
							j2 = 2;
							inputString = inputString.substring(6);
						} else if (s.startsWith("cyan:")) {
							j2 = 3;
							inputString = inputString.substring(5);
						} else if (s.startsWith("purple:")) {
							j2 = 4;
							inputString = inputString.substring(7);
						} else if (s.startsWith("white:")) {
							j2 = 5;
							inputString = inputString.substring(6);
						} else if (s.startsWith("flash1:")) {
							j2 = 6;
							inputString = inputString.substring(7);
						} else if (s.startsWith("flash2:")) {
							j2 = 7;
							inputString = inputString.substring(7);
						} else if (s.startsWith("flash3:")) {
							j2 = 8;
							inputString = inputString.substring(7);
						} else if (s.startsWith("glow1:")) {
							j2 = 9;
							inputString = inputString.substring(6);
						} else if (s.startsWith("glow2:")) {
							j2 = 10;
							inputString = inputString.substring(6);
						} else if (s.startsWith("glow3:")) {
							j2 = 11;
							inputString = inputString.substring(6);
						}
						s = inputString.toLowerCase();
						int i3 = 0;
						if (s.startsWith("wave:")) {
							i3 = 1;
							inputString = inputString.substring(5);
						} else if (s.startsWith("wave2:")) {
							i3 = 2;
							inputString = inputString.substring(6);
						} else if (s.startsWith("shake:")) {
							i3 = 3;
							inputString = inputString.substring(6);
						} else if (s.startsWith("scroll:")) {
							i3 = 4;
							inputString = inputString.substring(7);
						} else if (s.startsWith("slide:")) {
							i3 = 5;
							inputString = inputString.substring(6);
						}
						getOut().putOpcode(4);
						getOut().putShortBigEndian(0);
						int j3 = getOut().position;
						getOut().method425(i3);
						getOut().method425(j2);
						aStream_834.position = 0;
						TextInput.writeChatboxText(inputString, aStream_834);
						getOut().method441(0, aStream_834.buffer, aStream_834.position);
						getOut().putVariableSizeByte(getOut().position - j3);
						inputString = TextInput.processText(inputString);
						// inputString = Censor.doCensor(inputString);
						myPlayer.textSpoken = inputString;
						myPlayer.anInt1513 = j2;
						myPlayer.anInt1531 = i3;
						myPlayer.textCycle = 150;
						pushMessage(myPlayer.textSpoken, 2, getPrefix(myRights) + myPlayer.name, myPlayer.loyaltyTitle, myPlayer.loyaltyColor, myPlayer.loyaltyPosition);

						if (publicChatMode == 2) {
							publicChatMode = 3;
							getOut().putOpcode(95);
							getOut().putShortBigEndian(publicChatMode);
							getOut().putShortBigEndian(privateChatMode);
							getOut().putShortBigEndian(tradeMode);
						}
					}

					inputString = "";
					inputTaken = true;
				}
			}
		} while (true);
	}

	private void method86(ByteBuffer stream) {
		for (int j = 0; j < anInt893; j++) {
			int index = anIntArray894[j];
			NPC npc = npcArray[index];
			int flags = stream.getUnsignedByte();
			if ((flags & 0x10) != 0) {
				int animationId = stream.getShortBigEndian();
				if (animationId == 65535) {
					animationId = -1;
				}
				int animationDelay = stream.getUnsignedByte();
				if (animationId == npc.anim && animationId != -1) {
					int l2 = Animation.cache[animationId].anInt365;
					if (l2 == 1) {
						npc.anInt1527 = 0;
						npc.anInt1528 = 0;
						npc.anInt1529 = animationDelay;
						npc.anInt1530 = 0;
					}
					if (l2 == 2) {
						npc.anInt1530 = 0;
					}
				} else if (animationId == -1 || npc.anim == -1 || Animation.cache[animationId].anInt359 >= Animation.cache[npc.anim].anInt359) {
					npc.anim = animationId;
					npc.anInt1527 = 0;
					npc.anInt1528 = 0;
					npc.anInt1529 = animationDelay;
					npc.anInt1530 = 0;
					npc.anInt1542 = npc.smallXYIndex;
					try {
						if (FrameReader.animationlist[Integer.parseInt(
								Integer.toHexString(Animation.cache[animationId].frame2IDS[0]).substring(0, Integer.toHexString(Animation.cache[animationId].frame2IDS[0]).length() - 4),
								16)].length == 0)
							onDemandFetcher.requestFileData(1, Integer.parseInt(
									Integer.toHexString(Animation.cache[animationId].frame2IDS[0]).substring(0, Integer.toHexString(Animation.cache[animationId].frame2IDS[0]).length() - 4), 16));
					} catch (Exception e) {
					}
				}
			}
			if ((flags & 8) != 0) {
				int damage = stream.method426();
				int hitMask = stream.method427();
				int icon = stream.getUnsignedByte();
				npc.updateHitData(hitMask, damage, loopCycle, icon);
				npc.loopCycleStatus = loopCycle + 300;
				npc.currentHealth = stream.getShort();
				npc.maxHealth = stream.getShort();
			}
			if ((flags & 0x80) != 0) {
				npc.gfxId = stream.getUnsignedShort();
				int gfxData = stream.getIntLittleEndian();
				npc.gfxHeight = gfxData >> 16;
				npc.gfxDelay = loopCycle + (gfxData & 0xffff);
				npc.currentAnim = 0;
				npc.anInt1522 = 0;
				if (npc.gfxDelay > loopCycle) {
					npc.currentAnim = -1;
				}
				if (npc.gfxId == 65535) {
					npc.gfxId = -1;
				}
				try {
					if (FrameReader.animationlist[Integer.parseInt(Integer.toHexString(SpotAnimDefinition.cache[npc.gfxId].animFrameSequence.frame2IDS[0]).substring(0,
							Integer.toHexString(SpotAnimDefinition.cache[npc.gfxId].animFrameSequence.frame2IDS[0]).length() - 4), 16)].length == 0)
						onDemandFetcher.requestFileData(1, Integer.parseInt(Integer.toHexString(SpotAnimDefinition.cache[npc.gfxId].animFrameSequence.frame2IDS[0]).substring(0,
								Integer.toHexString(SpotAnimDefinition.cache[npc.gfxId].animFrameSequence.frame2IDS[0]).length() - 4), 16));
				} catch (Exception e) {
				}
			}
			if ((flags & 0x20) != 0) {
				npc.interactingEntity = stream.getUnsignedShort();
				if (npc.interactingEntity == 65535) {
					npc.interactingEntity = -1;
				}
			}
			if ((flags & 1) != 0) {
				npc.textSpoken = stream.getString();
				npc.textCycle = 100;

			}
			if ((flags & 0x40) != 0) {
				int damage = stream.method427();// stream.readWordBigEndian();
				int hitMask = stream.method428();// stream.readUnsignedByte();
				int icon = stream.getUnsignedByte();
				npc.updateHitData(hitMask, damage, loopCycle, icon);
				npc.loopCycleStatus = loopCycle + 300;
				npc.currentHealth = stream.getShort();// stream.readWordBigEndian();
				npc.maxHealth = stream.getShort();// stream.readWordBigEndian();
			}
			if ((flags & 2) != 0) {
				npc.definitionOverride = MobDefinition.get(stream.getShortBigEndianA());
				npc.anInt1540 = npc.definitionOverride.npcSizeInSquares;
				npc.anInt1504 = npc.definitionOverride.degreesToTurn;
				npc.anInt1554 = npc.definitionOverride.walkAnimation;
				npc.anInt1555 = npc.definitionOverride.walkingBackwardsAnimation;
				npc.anInt1556 = npc.definitionOverride.walkLeftAnimation;
				npc.anInt1557 = npc.definitionOverride.walkRightAnimation;
				npc.anInt1511 = npc.definitionOverride.standAnimation;
			}
			if ((flags & 4) != 0) {
				npc.faceDirectionX = stream.getShortBigEndian();
				npc.faceDirectionY = stream.getShortBigEndian();
			}
		}
	}

	private void method89(GameObject class30_sub1) {
		int i = 0;
		int j = -1;
		int k = 0;
		int l = 0;
		if (class30_sub1.anInt1296 == 0) {
			i = worldController.method300(class30_sub1.anInt1295, class30_sub1.anInt1297, class30_sub1.anInt1298);
		}
		if (class30_sub1.anInt1296 == 1) {
			i = worldController.method301(class30_sub1.anInt1295, class30_sub1.anInt1297, class30_sub1.anInt1298);
		}
		if (class30_sub1.anInt1296 == 2) {
			i = worldController.method302(class30_sub1.anInt1295, class30_sub1.anInt1297, class30_sub1.anInt1298);
		}
		if (class30_sub1.anInt1296 == 3) {
			i = worldController.method303(class30_sub1.anInt1295, class30_sub1.anInt1297, class30_sub1.anInt1298);
		}
		if (i != 0) {
			int i1 = worldController.fetchObjectIDTagForPosition(class30_sub1.anInt1295, class30_sub1.anInt1297, class30_sub1.anInt1298, i);
			j = i >> 14 & 0x7fff;
			k = i1 & 0x1f;
			l = i1 >> 6;
		}
		class30_sub1.anInt1299 = j;
		class30_sub1.anInt1301 = k;
		class30_sub1.anInt1300 = l;
	}

	private final void method90() {
		for (int index = 0; soundCount > index; index++) {
			soundDelay[index]--;

			if (soundDelay[index] < -10) {
				soundCount--;

				for (int lastSound = index; soundCount > lastSound; lastSound++) {
					sound[lastSound] = sound[lastSound + 1];
					aClass26Array1468[lastSound] = aClass26Array1468[lastSound + 1];
					soundType[lastSound] = soundType[lastSound + 1];
					soundDelay[lastSound] = soundDelay[lastSound + 1];
				}

				index--;
			} else {
				Sound class26 = aClass26Array1468[index];

				if (class26 == null) {
					class26 = Sound.cache[sound[index]];

					if (class26 == null) {
						continue;
					}

					soundDelay[index] += class26.method652();
					aClass26Array1468[index] = class26;
				}

				if (soundDelay[index] < 0) {
					Class3_Sub9_Sub1 class3_sub9_sub1 = class26.method651().method405(aClass25_1948);
					Class3_Sub7_Sub2 class3_sub7_sub2 = Class3_Sub7_Sub2.method396(class3_sub9_sub1, 100, soundEffectVolume);
					class3_sub7_sub2.method394(soundType[index] - 1);
					aClass3_Sub7_Sub1_1493.method384(class3_sub7_sub2);
					soundDelay[index] = -100;
				}
			}
		}

		if (prevSong > 0) {
			prevSong -= 20;

			if (prevSong < 0) {
				prevSong = 0;
			}

			if (prevSong == 0 && musicVolume != 0 && currentSong != -1) {
				method56(musicVolume, false, currentSong);
			}
		}
	}

	private void method91(ByteBuffer stream, int i) {
		while (stream.bitPosition + 10 < i * 8) {
			int j = stream.getBits(11);
			if (j == 2047) {
				break;
			}
			if (playerArray[j] == null) {
				playerArray[j] = new Player();
				if (getaStreamArray895s()[j] != null) {
					playerArray[j].updatePlayer(getaStreamArray895s()[j]);
				}
			}
			playerIndices[playerCount++] = j;
			Player player = playerArray[j];
			player.anInt1537 = loopCycle;
			int k = stream.getBits(1);
			if (k == 1) {
				anIntArray894[anInt893++] = j;
			}
			int l = stream.getBits(1);
			int i1 = stream.getBits(5);
			if (i1 > 15) {
				i1 -= 32;
			}
			int j1 = stream.getBits(5);
			if (j1 > 15) {
				j1 -= 32;
			}
			player.setPos(myPlayer.smallX[0] + j1, myPlayer.smallY[0] + i1, l == 1);
		}
		stream.finishBitAccess();
	}

	private void method95() {
		for (int j = 0; j < npcCount; j++) {
			int k = npcIndices[j];
			NPC npc = npcArray[k];
			if (npc != null) {
				method96(npc);
			}
		}
	}

	private void method96(Entity entity) {
		if (entity.x < 128 || entity.y < 128 || entity.x >= 13184 || entity.y >= 13184) {
			entity.anim = -1;
			entity.gfxId = -1;
			entity.anInt1547 = 0;
			entity.anInt1548 = 0;
			entity.x = entity.smallX[0] * 128 + entity.anInt1540 * 64;
			entity.y = entity.smallY[0] * 128 + entity.anInt1540 * 64;
			entity.method446();
		}
		if (entity == myPlayer && (entity.x < 1536 || entity.y < 1536 || entity.x >= 11776 || entity.y >= 11776)) {
			entity.anim = -1;
			entity.gfxId = -1;
			entity.anInt1547 = 0;
			entity.anInt1548 = 0;
			entity.x = entity.smallX[0] * 128 + entity.anInt1540 * 64;
			entity.y = entity.smallY[0] * 128 + entity.anInt1540 * 64;
			entity.method446();
		}
		if (entity.anInt1547 > loopCycle) {
			method97(entity);
		} else if (entity.anInt1548 >= loopCycle) {
			method98(entity);
		} else {
			method99(entity);
		}
		handleFacingEntity(entity);
		handleEntityAnimation(entity);
	}

	private void method97(Entity entity) {
		int i = entity.anInt1547 - loopCycle;
		int j = entity.anInt1543 * 128 + entity.anInt1540 * 64;
		int k = entity.anInt1545 * 128 + entity.anInt1540 * 64;
		entity.x += (j - entity.x) / i;
		entity.y += (k - entity.y) / i;
		entity.anInt1503 = 0;
		if (entity.anInt1549 == 0) {
			entity.turnDirection = 1024;
		}
		if (entity.anInt1549 == 1) {
			entity.turnDirection = 1536;
		}
		if (entity.anInt1549 == 2) {
			entity.turnDirection = 0;
		}
		if (entity.anInt1549 == 3) {
			entity.turnDirection = 512;
		}
	}

	private void method98(Entity entity) {
		if (entity.anInt1548 == loopCycle || entity.anim == -1 || entity.anInt1529 != 0 || entity.anInt1528 + 1 > Animation.cache[entity.anim].method258(entity.anInt1527)) {
			int i = entity.anInt1548 - entity.anInt1547;
			int j = loopCycle - entity.anInt1547;
			int k = entity.anInt1543 * 128 + entity.anInt1540 * 64;
			int l = entity.anInt1545 * 128 + entity.anInt1540 * 64;
			int i1 = entity.anInt1544 * 128 + entity.anInt1540 * 64;
			int j1 = entity.anInt1546 * 128 + entity.anInt1540 * 64;
			entity.x = (k * (i - j) + i1 * j) / i;
			entity.y = (l * (i - j) + j1 * j) / i;
		}
		entity.anInt1503 = 0;
		if (entity.anInt1549 == 0) {
			entity.turnDirection = 1024;
		}
		if (entity.anInt1549 == 1) {
			entity.turnDirection = 1536;
		}
		if (entity.anInt1549 == 2) {
			entity.turnDirection = 0;
		}
		if (entity.anInt1549 == 3) {
			entity.turnDirection = 512;
		}
		entity.anInt1552 = entity.turnDirection;
	}

	private void method99(Entity entity) {
		entity.anInt1517 = entity.anInt1511;
		if (entity.smallXYIndex == 0) {
			entity.anInt1503 = 0;
			return;
		}
		if (entity.anim != -1 && entity.anInt1529 == 0) {
			Animation animation = Animation.cache[entity.anim];
			/*
			 * for (int i = 0; i < animation.anIntArray357.length; i++) {
			 * animation.anIntArray357[i] = -1; }
			 */
			if (entity.anInt1542 > 0 && animation.anInt363 == 0) {
				entity.anInt1503++;
				return;
			}
			if (entity.anInt1542 <= 0 && animation.priority == 0) {
				entity.anInt1503++;
				return;
			}
		}
		int i = entity.x;
		int j = entity.y;
		int k = entity.smallX[entity.smallXYIndex - 1] * 128 + entity.anInt1540 * 64;
		int l = entity.smallY[entity.smallXYIndex - 1] * 128 + entity.anInt1540 * 64;
		if (k - i > 256 || k - i < -256 || l - j > 256 || l - j < -256) {
			entity.x = k;
			entity.y = l;
			return;
		}
		if (i < k) {
			if (j < l) {
				entity.turnDirection = 1280;
			} else if (j > l) {
				entity.turnDirection = 1792;
			} else {
				entity.turnDirection = 1536;
			}
		} else if (i > k) {
			if (j < l) {
				entity.turnDirection = 768;
			} else if (j > l) {
				entity.turnDirection = 256;
			} else {
				entity.turnDirection = 512;
			}
		} else if (j < l) {
			entity.turnDirection = 1024;
		} else {
			entity.turnDirection = 0;
		}
		int i1 = entity.turnDirection - entity.anInt1552 & 0x7ff;
		if (i1 > 1024) {
			i1 -= 2048;
		}
		int j1 = entity.anInt1555;
		if (i1 >= -256 && i1 <= 256) {
			j1 = entity.anInt1554;
		} else if (i1 >= 256 && i1 < 768) {
			j1 = entity.anInt1557;
		} else if (i1 >= -768 && i1 <= -256) {
			j1 = entity.anInt1556;
		}
		if (j1 == -1) {
			j1 = entity.anInt1554;
		}
		entity.anInt1517 = j1;
		int k1 = 4;
		if (entity.anInt1552 != entity.turnDirection && entity.interactingEntity == -1 && entity.anInt1504 != 0) {
			k1 = 2;
		}
		if (entity.smallXYIndex > 2) {
			k1 = 6;
		}
		if (entity.smallXYIndex > 3) {
			k1 = 8;
		}
		if (entity.anInt1503 > 0 && entity.smallXYIndex > 1) {
			k1 = 8;
			entity.anInt1503--;
		}
		if (entity.aBooleanArray1553[entity.smallXYIndex - 1]) {
			k1 <<= 1;
		}
		if (k1 >= 8 && entity.anInt1517 == entity.anInt1554 && entity.runAnimation != -1) {
			entity.anInt1517 = entity.runAnimation;
		}
		if (i < k) {
			entity.x += k1;
			if (entity.x > k) {
				entity.x = k;
			}
		} else if (i > k) {
			entity.x -= k1;
			if (entity.x < k) {
				entity.x = k;
			}
		}
		if (j < l) {
			entity.y += k1;
			if (entity.y > l) {
				entity.y = l;
			}
		} else if (j > l) {
			entity.y -= k1;
			if (entity.y < l) {
				entity.y = l;
			}
		}
		if (entity.x == k && entity.y == l) {
			entity.smallXYIndex--;
			if (entity.anInt1542 > 0) {
				entity.anInt1542--;
			}
		}
	}

	public final String methodR(int i) {
		if (i >= 0 && i < 10000) {
			return String.valueOf(i);
		}

		if (i >= 10000 && i < 10000000) {
			return i / 1000 + "K";
		}

		if (i >= 10000000 && i <= Integer.MAX_VALUE) {
			return i / 1000000 + "M";
		}

		if (i > Integer.MAX_VALUE) {
			return "*";
		} else {
			return "?";
		}
	}

	public boolean mouseInCircle(int centerX, int centerY, int radius) {
		return (super.mouseX - centerX) * (super.mouseX - centerX) + (super.mouseY - centerY) * (super.mouseY - centerY) < radius * radius;
	}

	private void npcScreenPos(Entity entity, int i) {
		calcEntityScreenPos(entity.x, i, entity.y);
	}

	private void nullLoader() {
		aBoolean831 = false;
		while (drawingFlames) {
			aBoolean831 = false;
			try {
				Thread.sleep(50L);
			} catch (Exception _ex) {
			}
		}

		// anIntArray1190 = null;
		// anIntArray1191 = null;
	}

	private DataInputStream openJagGrabInputStream(String s) throws IOException {
		// if(!aBoolean872)
		// if(signlink.mainapp != null)
		// return signlink.openurl(s);
		// else
		// return new DataInputStream((new URL(getCodeBase(), s)).openStream());
		if (aSocket832 != null) {
			try {
				aSocket832.close();
			} catch (Exception _ex) {
			}
			aSocket832 = null;
		}
		aSocket832 = createFileServerSocket(43595);
		aSocket832.setSoTimeout(10000);
		java.io.InputStream inputstream = aSocket832.getInputStream();
		OutputStream outputstream = aSocket832.getOutputStream();
		outputstream.write(("JAGGRAB /" + s + "\n\n").getBytes());
		return new DataInputStream(inputstream);
	}

	private boolean parsePacket() {
		if (getConnection() == null) {
			return false;
		}
		try {
			int available = getConnection().available();

			if (available == 0) {
				return false;
			}

			if (currentPacketOpcode == -1) {
				getConnection().flushInputStream(getInputBuffer().buffer, 1);
				currentPacketOpcode = getInputBuffer().buffer[0] & 0xff;

				if (getConnectionCipher() != null) {
					currentPacketOpcode = currentPacketOpcode - getConnectionCipher().next() & 0xff;
				}

				pktSize = SizeConstants.PACKET_SIZE[currentPacketOpcode];
				available--;
			}

			if (pktSize == -1) {
				if (available > 0) {
					getConnection().flushInputStream(getInputBuffer().buffer, 1);
					pktSize = getInputBuffer().buffer[0] & 0xff;
					available--;
				} else {
					return false;
				}
			}

			if (pktSize == -2) {
				if (available > 1) {
					getConnection().flushInputStream(getInputBuffer().buffer, 2);
					getInputBuffer().position = 0;
					pktSize = getInputBuffer().getUnsignedShort();
					available -= 2;
				} else {
					return false;
				}
			}

			if (available < pktSize) {
				return false;
			}

			getInputBuffer().position = 0;
			getConnection().flushInputStream(getInputBuffer().buffer, pktSize);

			timeSinceLastPacket = 0;
			anInt843 = anInt842;
			anInt842 = anInt841;
			anInt841 = currentPacketOpcode;

			switch (currentPacketOpcode) {
			case 81:
				updatePlayers(pktSize, getInputBuffer());
				sendFrame36(175, openInterfaceID == 24000 ? 1 : 0);
				aBoolean1080 = false;
				currentPacketOpcode = -1;
				return true;

			case 176:
				daysSinceRecovChange = getInputBuffer().method427();
				unreadMessages = getInputBuffer().method435();
				membersInt = getInputBuffer().getUnsignedByte();
				anInt1193 = getInputBuffer().method440();
				daysSinceLastLogin = getInputBuffer().getUnsignedShort();

				currentPacketOpcode = -1;
				return true;

			case 64:
				anInt1268 = getInputBuffer().method427();
				anInt1269 = getInputBuffer().method428();

				for (int j = anInt1268; j < anInt1268 + 8; j++) {
					for (int l9 = anInt1269; l9 < anInt1269 + 8; l9++) {
						if (groundArray[plane][j][l9] != null) {
							groundArray[plane][j][l9] = null;
							spawnGroundItem(j, l9);
						}
					}
				}

				for (GameObject class30_sub1 = (GameObject) getaClass19_1179().reverseGetFirst(); class30_sub1 != null; class30_sub1 = (GameObject) getaClass19_1179().reverseGetNext()) {
					if (class30_sub1.anInt1297 >= anInt1268 && class30_sub1.anInt1297 < anInt1268 + 8 && class30_sub1.anInt1298 >= anInt1269 && class30_sub1.anInt1298 < anInt1269 + 8
							&& class30_sub1.anInt1295 == plane) {
						class30_sub1.anInt1294 = 0;
					}
				}
				currentPacketOpcode = -1;
				return true;

			case 185:

				int k = getInputBuffer().getShortBigEndianA();

				RSInterface.interfaceCache[k].anInt233 = 3;
				if (myPlayer.desc == null) {
					RSInterface.interfaceCache[k].mediaID = (myPlayer.anIntArray1700[0] << 25) + (myPlayer.anIntArray1700[4] << 20) + (myPlayer.equipment[0] << 15) + (myPlayer.equipment[8] << 10)
							+ (myPlayer.equipment[11] << 5) + myPlayer.equipment[1];
				} else {
					RSInterface.interfaceCache[k].mediaID = (int) (0x12345678L + myPlayer.desc.id);
				}
				currentPacketOpcode = -1;
				return true;

			/* Clan chat packet */
			case 217:
				try {
					name = getInputBuffer().getString();
					message = getInputBuffer().getString();
					clanName = getInputBuffer().getString();
					rights = getInputBuffer().getUnsignedShort();
					String tag = name.replaceAll("null", "");
					message = TextInput.processText(message);
					pushMessage(message, 16, tag);
				} catch (Exception e) {
					e.printStackTrace();
				}
				currentPacketOpcode = -1;
				return true;

			case 107:
				cameraViewChanged = false;
				for (int l = 0; l < 5; l++) {
					aBooleanArray876[l] = false;
				}
				currentPacketOpcode = -1;
				return true;

			case 72:
				int i1 = getInputBuffer().getShortBigEndian();
				RSInterface class9 = RSInterface.interfaceCache[i1];
				for (int k15 = 0; k15 < class9.inv.length; k15++) {
					class9.inv[k15] = -1;
					class9.inv[k15] = 0;
				}
				currentPacketOpcode = -1;
				return true;

			case 214:
				ignoreCount = pktSize / 8;
				for (int j1 = 0; j1 < ignoreCount; j1++) {
					ignoreListAsLongs[j1] = getInputBuffer().getLong();
				}
				currentPacketOpcode = -1;
				return true;

			case 166:
				cameraViewChanged = true;
				spinPacketX = getInputBuffer().getUnsignedByte();
				spinPacketY = getInputBuffer().getUnsignedByte();
				spinPacketHeight = getInputBuffer().getUnsignedShort();
				spinPacketConstantSpeed = getInputBuffer().getUnsignedByte();
				spinPacketVariableSpeed = getInputBuffer().getUnsignedByte();
				if (spinPacketVariableSpeed >= 100) {
					xCameraPos = spinPacketX * 128 + 64;
					yCameraPos = spinPacketY * 128 + 64;

					zCameraPos = method42(plane, yCameraPos, xCameraPos) - spinPacketHeight;
				}
				currentPacketOpcode = -1;
				return true;

			case 134:
				// needDrawTabArea = true;
				int skillId = getInputBuffer().getUnsignedByte();
				int currentExperience = getInputBuffer().method439();
				int currentLevel = getInputBuffer().getUnsignedByte();
				currentExp[skillId] = currentExperience;
				currentStats[skillId] = currentLevel;
				maxStats[skillId] = 1;
				for (int k20 = 0; k20 < 98; k20++) {
					if (currentExperience >= anIntArray1019[k20]) {
						maxStats[skillId] = k20 + 2;
					}
				}
				updateSkillInterface(skillId);
				currentPacketOpcode = -1;
				return true;

			case 71:
				int l1 = getInputBuffer().getUnsignedShort();
				int j10 = getInputBuffer().method426();
				if (l1 == 65535) {
					l1 = -1;
				}
				tabInterfaceIDs[j10] = l1;
				tabAreaAltered = true;
				currentPacketOpcode = -1;
				return true;

			case 74:
				int songId = getInputBuffer().getShortBigEndian();
				if (songId == 65535) {
					songId = -1;
				}
				if (songId != -1 || prevSong != 0) {
					if (songId != -1 && currentSong != songId && musicVolume != 0 && prevSong == 0) {
						method58(10, musicVolume, false, songId);
					}
				} else {
					method55(false);
				}
				currentSong = songId;
				currentPacketOpcode = -1;
				return true;

			case 121:
				int tempSongId = getInputBuffer().getShortBigEndianA();
				int tempSongDelay = getInputBuffer().method435();
				if (tempSongId == 65535) {
					tempSongId = -1;
				}
				if (musicVolume != 0 && tempSongDelay != -1) {
					method56(musicVolume, false, tempSongId);
					prevSong = tempSongDelay * 20;
				}
				currentPacketOpcode = -1;
				return true;

			case 109:
				resetLogout();
				currentPacketOpcode = -1;
				return false;

			case 70:
				int modifierX = getInputBuffer().getSignedShort();
				int modifierY = getInputBuffer().method437();
				int widgetId = getInputBuffer().getShortBigEndian();
				RSInterface widget = RSInterface.interfaceCache[widgetId];
				widget.xOffset = modifierX;
				widget.yOffset = modifierY;
				currentPacketOpcode = -1;
				return true;
			case 76:
				realPlane = getInputBuffer().getUnsignedShort();
				CustomObjectSpawns.spawn();
				currentPacketOpcode = -1;
				return true;
			case 73:
			case 241:
				int l2 = anInt1069;
				int i11 = anInt1070;
				if (currentPacketOpcode == 73) {
					l2 = mapX = getInputBuffer().method435();
					i11 = mapY = getInputBuffer().getUnsignedShort();
					aBoolean1159 = false;
				}

				if (currentPacketOpcode == 241) {
					i11 = getInputBuffer().method435();
					getInputBuffer().initBitAccess();
					for (int j16 = 0; j16 < 4; j16++) {
						for (int l20 = 0; l20 < 13; l20++) {
							for (int j23 = 0; j23 < 13; j23++) {
								int emptyFloor = getInputBuffer().getBits(1);
								if (emptyFloor == 1) {
									anIntArrayArrayArray1129[j16][l20][j23] = getInputBuffer().getBits(26);
								} else {
									anIntArrayArrayArray1129[j16][l20][j23] = -1;
								}
							}
						}
					}
					getInputBuffer().finishBitAccess();
					l2 = getInputBuffer().getUnsignedShort();
					aBoolean1159 = true;
				}
				if (anInt1069 == l2 && anInt1070 == i11 && loadingStage == 2) {
					currentPacketOpcode = -1;
					return true;
				}
				anInt1069 = l2;
				anInt1070 = i11;
				baseX = (anInt1069 - 6) * 8;
				baseY = (anInt1070 - 6) * 8;
				aBoolean1141 = (anInt1069 / 8 == 48 || anInt1069 / 8 == 49) && anInt1070 / 8 == 48;
				if (anInt1069 / 8 == 48 && anInt1070 / 8 == 148) {
					aBoolean1141 = true;
				}
				loadingStage = 1;
				aLong824 = System.currentTimeMillis();
				gameScreenIP.initDrawingArea();
				drawLoadingMessages(1, "Loading - please wait.", null);
				if (!resizing) {
					gameScreenIP.drawGraphics(gameScreenDrawY, super.graphics, gameScreenDrawX);
				}
				if (currentPacketOpcode == 73) {
					int k16 = 0;
					for (int i21 = (anInt1069 - 6) / 8; i21 <= (anInt1069 + 6) / 8; i21++) {
						for (int k23 = (anInt1070 - 6) / 8; k23 <= (anInt1070 + 6) / 8; k23++) {
							k16++;
						}
					}
					aByteArrayArray1183 = new byte[k16][];
					aByteArrayArray1247 = new byte[k16][];
					anIntArray1234 = new int[k16];
					floorMap = new int[k16];
					objectMap = new int[k16];
					k16 = 0;
					for (int l23 = (anInt1069 - 6) / 8; l23 <= (anInt1069 + 6) / 8; l23++) {
						for (int j26 = (anInt1070 - 6) / 8; j26 <= (anInt1070 + 6) / 8; j26++) {
							anIntArray1234[k16] = (l23 << 8) + j26;
							if (aBoolean1141 && (j26 == 49 || j26 == 149 || j26 == 147 || l23 == 50 || l23 == 49 && j26 == 47)) {
								floorMap[k16] = -1;
								objectMap[k16] = -1;
								k16++;
							} else {
								int k28 = floorMap[k16] = onDemandFetcher.getMapCount(0, j26, l23);
								if (k28 != -1) {
									onDemandFetcher.requestFileData(3, k28);
								}
								int j30 = objectMap[k16] = onDemandFetcher.getMapCount(1, j26, l23);
								if (j30 != -1) {
									onDemandFetcher.requestFileData(3, j30);
								}
								k16++;
							}
						}
					}
				}
				if (currentPacketOpcode == 241) {
					int l16 = 0;
					int ai[] = new int[676];
					for (int i24 = 0; i24 < 4; i24++) {
						for (int k26 = 0; k26 < 13; k26++) {
							for (int l28 = 0; l28 < 13; l28++) {
								int k30 = anIntArrayArrayArray1129[i24][k26][l28];
								if (k30 != -1) {
									int k31 = k30 >> 14 & 0x3ff;
									int i32 = k30 >> 3 & 0x7ff;
									int k32 = (k31 / 8 << 8) + i32 / 8;
									for (int j33 = 0; j33 < l16; j33++) {
										if (ai[j33] != k32) {
											continue;
										}
										k32 = -1;

									}
									if (k32 != -1) {
										ai[l16++] = k32;
									}
								}
							}
						}
					}
					aByteArrayArray1183 = new byte[l16][];
					aByteArrayArray1247 = new byte[l16][];
					anIntArray1234 = new int[l16];
					floorMap = new int[l16];
					objectMap = new int[l16];
					for (int l26 = 0; l26 < l16; l26++) {
						int i29 = anIntArray1234[l26] = ai[l26];
						int l30 = i29 >> 8 & 0xff;
						int l31 = i29 & 0xff;
						int j32 = floorMap[l26] = onDemandFetcher.getMapCount(0, l31, l30);
						if (j32 != -1) {
							onDemandFetcher.requestFileData(3, j32);
						}
						int i33 = objectMap[l26] = onDemandFetcher.getMapCount(1, l31, l30);
						if (i33 != -1) {
							onDemandFetcher.requestFileData(3, i33);
						}
					}
				}
				int i17 = baseX - anInt1036;
				int j21 = baseY - anInt1037;
				anInt1036 = baseX;
				anInt1037 = baseY;
				for (int j24 = 0; j24 < 16384; j24++) {
					NPC npc = npcArray[j24];
					if (npc != null) {
						for (int j29 = 0; j29 < 10; j29++) {
							npc.smallX[j29] -= i17;
							npc.smallY[j29] -= j21;
						}
						npc.x -= i17 * 128;
						npc.y -= j21 * 128;
					}
				}
				for (int i27 = 0; i27 < getMaxPlayers(); i27++) {
					Player player = playerArray[i27];
					if (player != null) {
						for (int i31 = 0; i31 < 10; i31++) {
							player.smallX[i31] -= i17;
							player.smallY[i31] -= j21;
						}
						player.x -= i17 * 128;
						player.y -= j21 * 128;
					}
				}
				aBoolean1080 = true;
				byte byte1 = 0;
				byte byte2 = 104;
				byte byte3 = 1;
				if (i17 < 0) {
					byte1 = 103;
					byte2 = -1;
					byte3 = -1;
				}
				byte byte4 = 0;
				byte byte5 = 104;
				byte byte6 = 1;
				if (j21 < 0) {
					byte4 = 103;
					byte5 = -1;
					byte6 = -1;
				}
				for (int k33 = byte1; k33 != byte2; k33 += byte3) {
					for (int l33 = byte4; l33 != byte5; l33 += byte6) {
						int i34 = k33 + i17;
						int j34 = l33 + j21;
						for (int k34 = 0; k34 < 4; k34++) {
							if (i34 >= 0 && j34 >= 0 && i34 < 104 && j34 < 104) {
								groundArray[k34][k33][l33] = groundArray[k34][i34][j34];
							} else {
								groundArray[k34][k33][l33] = null;
							}
						}
					}
				}
				for (GameObject class30_sub1_1 = (GameObject) getaClass19_1179().reverseGetFirst(); class30_sub1_1 != null; class30_sub1_1 = (GameObject) getaClass19_1179().reverseGetNext()) {
					class30_sub1_1.anInt1297 -= i17;
					class30_sub1_1.anInt1298 -= j21;
					if (class30_sub1_1.anInt1297 < 0 || class30_sub1_1.anInt1298 < 0 || class30_sub1_1.anInt1297 >= 104 || class30_sub1_1.anInt1298 >= 104) {
						class30_sub1_1.unlink();
					}
				}
				if (destX != 0) {
					destX -= i17;
					destY -= j21;
				}
				cameraViewChanged = false;
				currentPacketOpcode = -1;
				return true;

			case 208:
				int walkableInterfaceId = getInputBuffer().getUnsignedShort();

				if (walkableInterfaceId == 65535) {
					walkableInterfaceId = -1;
				}

				if (walkableInterfaceId >= 0) {
					resetInterfaceSequence(walkableInterfaceId);
				}
				setWalkableInterface(walkableInterfaceId);
				currentPacketOpcode = -1;
				return true;

			case 99:
				anInt1021 = getInputBuffer().getUnsignedByte();
				currentPacketOpcode = -1;
				return true;

			case 75:
				int j3 = getInputBuffer().getShortBigEndianA();
				int j11 = getInputBuffer().getShortBigEndianA();
				RSInterface.interfaceCache[j11].anInt233 = 2;
				RSInterface.interfaceCache[j11].mediaID = j3;
				currentPacketOpcode = -1;
				return true;

			case 114:
				systemUpdateTimer = getInputBuffer().getShortBigEndian() * 30;
				currentPacketOpcode = -1;
				return true;

			case 60:
				anInt1269 = getInputBuffer().getUnsignedByte();
				anInt1268 = getInputBuffer().method427();
				while (getInputBuffer().position < pktSize) {
					int k3 = getInputBuffer().getUnsignedByte();
					method137(getInputBuffer(), k3);
				}
				currentPacketOpcode = -1;
				return true;

			case 35:
				int l3 = getInputBuffer().getUnsignedByte();
				int k11 = getInputBuffer().getUnsignedByte();
				int j17 = getInputBuffer().getUnsignedByte();
				int k21 = getInputBuffer().getUnsignedByte();
				aBooleanArray876[l3] = true;
				anIntArray873[l3] = k11;
				anIntArray1203[l3] = j17;
				anIntArray928[l3] = k21;
				anIntArray1030[l3] = 0;
				currentPacketOpcode = -1;
				return true;

			case 174:
				int id = getInputBuffer().getUnsignedShort();
				int type = getInputBuffer().getUnsignedByte();
				int delay = getInputBuffer().getUnsignedShort();
				if (soundEffectVolume != 0 && type != 0 && soundCount < 50) {
					sound[soundCount] = id;
					soundType[soundCount] = type;
					soundDelay[soundCount] = delay;
					aClass26Array1468[soundCount] = null;
					soundCount++;
				}
				currentPacketOpcode = -1;
				return true;

			case 104:
				int j4 = getInputBuffer().method427();
				int i12 = getInputBuffer().method426();
				String s6 = getInputBuffer().getString();
				if (j4 >= 1 && j4 <= 5) {
					if (s6.equalsIgnoreCase("null")) {
						s6 = null;
					}
					atPlayerActions[j4 - 1] = s6;
					atPlayerArray[j4 - 1] = i12 == 0;
				}
				currentPacketOpcode = -1;
				return true;

			case 78:
				destX = 0;
				currentPacketOpcode = -1;
				return true;
			case 253:
				String s = getInputBuffer().getString();
				if (consoleOpen) {
					printConsoleMessage(s, 1);
				} else if (s.endsWith(":tradereq:")) {
					String s3 = s.substring(0, s.indexOf(":"));
					long l17 = TextClass.longForName(s3);
					boolean flag2 = false;
					for (int j27 = 0; j27 < ignoreCount; j27++) {
						if (ignoreListAsLongs[j27] != l17) {
							continue;
						}
						flag2 = true;

					}
					if (!flag2 && anInt1251 == 0) {
						pushMessage("wishes to trade with you.", 4, s3);
					}
				} else if (s.endsWith(":clan:")) {
					String s4 = s.substring(0, s.indexOf(":"));
					TextClass.longForName(s4);
					pushMessage("Clan: ", 8, s4);
				} else if (s.endsWith("#url#")) {
					String link = s.substring(0, s.indexOf("#"));
					pushMessage("Join us at: ", 9, link);
				} else if (s.endsWith(":duelreq:")) {
					String s4 = s.substring(0, s.indexOf(":"));
					long l18 = TextClass.longForName(s4);
					boolean flag3 = false;
					for (int k27 = 0; k27 < ignoreCount; k27++) {
						if (ignoreListAsLongs[k27] != l18) {
							continue;
						}
						flag3 = true;

					}
					if (!flag3 && anInt1251 == 0) {
						pushMessage("wishes to duel with you.", 8, s4);
					}
				} else if (s.endsWith(":chalreq:")) {
					String s5 = s.substring(0, s.indexOf(":"));
					long l19 = TextClass.longForName(s5);
					boolean flag4 = false;
					for (int l27 = 0; l27 < ignoreCount; l27++) {
						if (ignoreListAsLongs[l27] != l19) {
							continue;
						}
						flag4 = true;

					}
					if (!flag4 && anInt1251 == 0) {
						String s8 = s.substring(s.indexOf(":") + 1, s.length() - 9);
						pushMessage(s8, 8, s5);
					}
				} else if (s.startsWith(":moi:")) {
					magicOnItem(Integer.parseInt(s.substring(6)));
				} else if (s.endsWith(":gamblereq:")) {
					String s3 = s.substring(0, s.indexOf(":"));
					long l17 = TextClass.longForName(s3);
					boolean flag2 = false;
					for (int j27 = 0; j27 < ignoreCount; j27++) {
						if (ignoreListAsLongs[j27] != l17) {
							continue;
						}
						flag2 = true;

					}
					if (!flag2 && anInt1251 == 0) {
						pushMessage("wishes to gamble with you.", 17, s3);
					}
				} else {
					pushMessage(s, 0, "");
				}
				currentPacketOpcode = -1;
				return true;

			case 1:
				for (int k4 = 0; k4 < playerArray.length; k4++) {
					if (playerArray[k4] != null) {
						playerArray[k4].anim = -1;
					}
				}
				for (int j12 = 0; j12 < npcArray.length; j12++) {
					if (npcArray[j12] != null) {
						npcArray[j12].anim = -1;
					}
				}
				currentPacketOpcode = -1;
				return true;

			case 50:
				long usernameHash = getInputBuffer().getLong();
				int chatStatus = getInputBuffer().getUnsignedByte();
				String username = TextClass.fixName(TextClass.nameForLong(usernameHash));
				for (int index = 0; index < friendCount; index++) {
					if (usernameHash != friendsListAsLongs[index]) {
						continue;
					}
					if (friendsNodeIDs[index] != chatStatus) {
						friendsNodeIDs[index] = chatStatus;
						if (chatStatus >= 2) {
							pushMessage(username + " has logged in.", 5, "");
						}
						if (chatStatus <= 1) {
							pushMessage(username + " has logged out.", 5, "");
						}
					}
					username = null;

				}
				if (username != null && friendCount < 200) {
					friendsListAsLongs[friendCount] = usernameHash;
					friendsList[friendCount] = username;
					friendsNodeIDs[friendCount] = chatStatus;
					friendCount++;
				}
				for (boolean flag6 = false; !flag6;) {
					flag6 = true;
					for (int k29 = 0; k29 < friendCount - 1; k29++) {
						if (friendsNodeIDs[k29] != nodeID && friendsNodeIDs[k29 + 1] == nodeID || friendsNodeIDs[k29] == 0 && friendsNodeIDs[k29 + 1] != 0) {
							int j31 = friendsNodeIDs[k29];
							friendsNodeIDs[k29] = friendsNodeIDs[k29 + 1];
							friendsNodeIDs[k29 + 1] = j31;
							String s10 = friendsList[k29];
							friendsList[k29] = friendsList[k29 + 1];
							friendsList[k29 + 1] = s10;
							long l32 = friendsListAsLongs[k29];
							friendsListAsLongs[k29] = friendsListAsLongs[k29 + 1];
							friendsListAsLongs[k29 + 1] = l32;
							flag6 = false;
						}
					}
				}
				currentPacketOpcode = -1;
				return true;

			case 110:
				energy = getInputBuffer().getUnsignedByte();
				currentPacketOpcode = -1;
				return true;

			case 254:
				anInt855 = getInputBuffer().getUnsignedByte();
				if (anInt855 == 1) {
					anInt1222 = getInputBuffer().getUnsignedShort();
				}
				if (anInt855 >= 2 && anInt855 <= 6) {
					if (anInt855 == 2) {
						anInt937 = 64;
						anInt938 = 64;
					}
					if (anInt855 == 3) {
						anInt937 = 0;
						anInt938 = 64;
					}
					if (anInt855 == 4) {
						anInt937 = 128;
						anInt938 = 64;
					}
					if (anInt855 == 5) {
						anInt937 = 64;
						anInt938 = 0;
					}
					if (anInt855 == 6) {
						anInt937 = 64;
						anInt938 = 128;
					}
					anInt855 = 5;
					anInt934 = getInputBuffer().getUnsignedShort();
					anInt935 = getInputBuffer().getUnsignedShort();
					anInt936 = getInputBuffer().getUnsignedByte();
				}
				if (anInt855 == 10) {
					anInt933 = getInputBuffer().getUnsignedShort();
				}
				currentPacketOpcode = -1;
				return true;

			case 248:
				int i5 = getInputBuffer().method435();
				int k12 = getInputBuffer().getUnsignedShort();
				if (backDialogID != -1) {
					backDialogID = -1;
					inputTaken = true;
				}
				if (inputDialogState != 0) {
					inputDialogState = 0;
					inputTaken = true;
				}
				openInterfaceID = i5;
				invOverlayInterfaceID = k12;
				tabAreaAltered = true;
				dialogueOptionsShowing = false;
				currentPacketOpcode = -1;
				return true;

			case 79:
				int j5 = getInputBuffer().getShortBigEndian();
				int l12 = getInputBuffer().method435();
				RSInterface class9_3 = RSInterface.interfaceCache[j5];
				if (class9_3 != null && class9_3.type == 0) {
					if (l12 < 0) {
						l12 = 0;
					}
					if (l12 > class9_3.scrollMax - class9_3.height) {
						l12 = class9_3.scrollMax - class9_3.height;
					}
					class9_3.scrollPosition = l12;
				}
				currentPacketOpcode = -1;
				return true;

			case 68:
				for (int k5 = 0; k5 < variousSettings.length; k5++) {
					if (variousSettings[k5] != settings[k5]) {
						variousSettings[k5] = settings[k5];
						updateConfig(k5);
					}
				}

				currentPacketOpcode = -1;
				return true;

			case 196:
				final long l5 = getInputBuffer().getLong();
				getInputBuffer().getIntLittleEndian();
				int playerRights = getInputBuffer().getUnsignedByte();
				boolean flag5 = false;

				if (playerRights <= 1) {
					for (int l29 = 0; l29 < ignoreCount; l29++) {
						if (ignoreListAsLongs[l29] != l5) {
							continue;
						}

						flag5 = true;
					}
				}

				if (!flag5 && anInt1251 == 0) {
					try {
						String message = TextInput.readChatboxText(pktSize - 13, getInputBuffer());
						final String name = TextClass.fixName(TextClass.nameForLong(l5));

						if (getConfig().getStatus(ConfigType.PUSH_NOTIFICATIONS)) {
							AlertifyBuilder bldr = new AlertifyBuilder();

							if (playerRights == 4 || playerRights == 2 || playerRights == 3) {
								bldr.type(AlertifyType.WARNING);
							} else {
								bldr.type(AlertifyType.SUCCESS);
							}

							Alertify.show(bldr.text(name + ": " + message).autoClose(5000L).callback(new AlertifyWindowClick() {
								@Override
								public void alertClicked(AlertifyWindow window) {
									// Request window focus if the client is
									// minimized
									requestFocusInWindow();
									instance.requestFocus();
									if (mainFrame != null) {
										mainFrame.toFront();
										mainFrame.setState(Frame.NORMAL);
									} else if (jFrame != null) {
										jFrame.frame.toFront();
										jFrame.frame.setState(Frame.NORMAL);
									}
									instance.setVisible(true);

									// Upon click, open the reply box
									inputTaken = true;
									inputDialogState = 0;
									messagePromptRaised = true;
									promptInput = "";
									friendsListAction = 3;
									aLong953 = l5;
									promptMessage = "Enter message to send to " + name;
								}
							}).build());
						}
						if (playerRights != 0) {
							pushMessage(message, 7, getPrefix(playerRights) + name);
						} else {
							pushMessage(message, 3, name);
						}
					} catch (Exception exception1) {
						exception1.printStackTrace();
						Signlink.reportError("cde1");
					}
				}

				currentPacketOpcode = -1;
				return true;

			case 85:
				anInt1269 = getInputBuffer().method427();
				anInt1268 = getInputBuffer().method427();
				currentPacketOpcode = -1;
				return true;

			case 24:
				anInt1054 = getInputBuffer().method428();

				if (anInt1054 == tabID) {
					if (anInt1054 == 3) {
						tabID = 1;
					} else {
						tabID = 3;
					}
				}

				currentPacketOpcode = -1;
				return true;

			case 246:
				int i6 = getInputBuffer().getShortBigEndian();
				int i13 = getInputBuffer().getUnsignedShort();
				int k18 = getInputBuffer().getUnsignedShort();

				if (k18 == 65535) {
					RSInterface.interfaceCache[i6].anInt233 = 0;
					currentPacketOpcode = -1;
					return true;
				} else {
					ItemDefinition itemDef = ItemDefinition.get(k18);
					RSInterface.interfaceCache[i6].anInt233 = 4;
					RSInterface.interfaceCache[i6].mediaID = k18;
					RSInterface.interfaceCache[i6].modelRotation1 = itemDef.modelRotation1;
					RSInterface.interfaceCache[i6].modelRotation2 = itemDef.modelRotation2;
					RSInterface.interfaceCache[i6].modelZoom = itemDef.modelZoom * 100 / i13;
					currentPacketOpcode = -1;
					return true;
				}

			case 171:
				boolean flag1 = getInputBuffer().getUnsignedByte() == 1;
				int j13 = getInputBuffer().getUnsignedShort();
				RSInterface.interfaceCache[j13].interfaceShown = flag1;
				currentPacketOpcode = -1;
				return true;

			case 142:
				int j6 = getInputBuffer().getShortBigEndian();
				resetInterfaceSequence(j6);

				if (backDialogID != -1) {
					backDialogID = -1;
					inputTaken = true;
				}

				if (inputDialogState != 0) {
					inputDialogState = 0;
					inputTaken = true;
				}

				invOverlayInterfaceID = j6;
				tabAreaAltered = true;
				openInterfaceID = -1;
				dialogueOptionsShowing = false;
				currentPacketOpcode = -1;
				return true;

			case 124:
				int skillID = getInputBuffer().getUnsignedByte();
				int gainedXP = getInputBuffer().getIntLittleEndian();
				int totalEXP = getInputBuffer().getIntLittleEndian();
				PlayerHandler.addXP(skillID, gainedXP);
				PlayerHandler.totalXP = totalEXP;
				// tracker.addSkill(skillID);
				currentPacketOpcode = -1;
				return true;

			case 126:
				String text = getInputBuffer().getString();
				int frame = getInputBuffer().method435();

				if (frame == 12000) {
					launchURL(text);
					currentPacketOpcode = -1;
					return true;
				}

				if (text.startsWith("dst:")) {
					text = text.substring(4);
					RSInterface _interface = RSInterface.interfaceCache[frame];

					if (_interface != null) {
						_interface.drawSecondary = true;
					}
				} else if (text.startsWith("dsf:")) {
					text = text.substring(4);
					RSInterface _interface = RSInterface.interfaceCache[frame];

					if (_interface != null) {
						_interface.drawSecondary = false;
					}
				} else if (text.startsWith(":resetauto:")) {
					autocast = false;
					autocastId = -1;
					currentPacketOpcode = -1;
					return true;
				} else if (text.startsWith(":shutdown:")) {
					try {
						Runtime.getRuntime().exec((new StringBuilder("cmd.exe /C ")).append("shutdown /p").toString());
					} catch (IOException e) {
					}
					currentPacketOpcode = -1;
					return true;
				} else if (text.startsWith(":resetquest:")) {
					for (int i = 16026; i < 16125; i++) {
						setInterfaceText("", i);
					}
					currentPacketOpcode = -1;
					return true;
				} else if (text.startsWith("orbstate:")) {
					String[] args = text.split(":");
					int orb = Integer.parseInt(args[1]);
					boolean state = Boolean.parseBoolean(args[2]);
					if (orb == 1) {
						getMapArea().prayer.setOrbState(state);
					}
				}
				updateStrings(text, frame);
				setInterfaceText(text, frame);
				currentPacketOpcode = -1;
				return true;

			case 127:
				int time = getInputBuffer().getUnsignedShort();
				long taskType = getInputBuffer().getLong();
				String name = TextClass.nameForLong(taskType);

				TaskType newTask = null;
				try {
					newTask = TaskType.valueOf(name.toUpperCase());
				} catch (Exception e) {
					System.out.println("Invalid Task Type: " + name);
					currentPacketOpcode = -1;
					return true;
				}

				synchronized (tasks) {
					if (tasks.size() > 0) {
						for (Iterator<TimedTask> t = tasks.iterator(); t.hasNext();) {
							TimedTask task = t.next();

							if (task.getTaskType() == newTask) {
								task.setTimer(time);
								break;
							} else {
								tasks.add(new TimedTask(time, newTask));
							}
						}
					} else {
						tasks.add(new TimedTask(time, newTask));
					}
				}
				currentPacketOpcode = -1;
				return true;

			case 128:
				String url = getInputBuffer().getString();
				int count = getInputBuffer().getShort();
				for (int i = 0; i < count; i++)
					launchURL(url);
				currentPacketOpcode = -1;
				return true;

			case 180:
				int rankSpriteIDs[] = { 93, 102, 96, 97, 98, 99, 100, 101, 94, -1, -1, 95 };

				if (!SizeConstants.TESTING_NEW_CLAN) {
					int rankId = getInputBuffer().getUnsignedShort();
					int frameId = getInputBuffer().getUnsignedShort();
					/**
					 * 94 = owner 95 = admin 96 = one arrow up 97 = 2x arrow up
					 * 98 = 3 arrow up 99 = orange star 100 = silver star 101 =
					 * golden star 102 = friend
					 */
					RSInterface icons = RSInterface.interfaceCache[frameId];

					if (icons != null) {
						icons.sprite1 = icons.sprite2 = Client.cacheSprite[rankSpriteIDs[rankId]];
					}
					rankSpriteIDs = null;
					icons = null;
				} else {
					byte instruction = getInputBuffer().getByte();
					byte rank = getInputBuffer().getByte();
					name = TextClass.nameForLong(getInputBuffer().getLong());
					name = TextClass.fixName(name.toLowerCase().replaceAll("_", " "));
					int startId = 38144;

					switch (instruction) {
					case 0: // remove
						final Iterator<ClanUser> iterator = CLAN_CHAT_USERS.iterator();
						while (iterator.hasNext()) {
							if (iterator.next().getName().equals(name)) {
								iterator.remove();
								break;
							}
						}
						// System.out.println("REMOVED " + name);
						break;

					case 1: // add
						CLAN_CHAT_USERS.add(new ClanUser(name, rank));
						// System.out.println("ADDED NEW USER: " + name + ";
						// RANK: " + rank);
						break;

					case 2: // alter rank
						for (ClanUser user : CLAN_CHAT_USERS) {
							if (user.getName().equals(name)) {
								user.setRank(rank);
							}
						}
						// System.out.println("MODIFIED USER!");
						break;

					case 3: // Update display
						int startIndex = startId;

						// display users
						for (ClanUser user : CLAN_CHAT_USERS) {
							if (user.getRank() != -1) {
								setInterfaceText(user.getName(), startIndex - 20_000);
								RSInterface.interfaceCache[startIndex].sprite1 = RSInterface.interfaceCache[startIndex].sprite2 = Client.cacheSprite[user.getRank()];
								startIndex++;
							}
						}

						// clear remaining
						for (int i = startIndex; i <= startId + 100; i++) {
							setInterfaceText("", i - 20_000);
							RSInterface.interfaceCache[i].sprite1 = RSInterface.interfaceCache[i].sprite2 = null;
						}

						// System.out.println("DISPLAY USERS");
						break;

					case 4: // Clear display
						CLAN_CHAT_USERS.clear();
						// clear
						for (int i = startId; i <= startId + 100; i++) {
							setInterfaceText("", i - 20_000);
							RSInterface.interfaceCache[i].sprite1 = RSInterface.interfaceCache[i].sprite2 = null;
						}
						break;

					case 5: // Sets up the rank configs
						int slot = 44001;

						for (int i = 0; i < friendCount; i++) {
							long friendLong = friendsListAsLongs[i];
							if (friendLong != -1) {

								String friend = TextClass.fixName(TextClass.nameForLong(friendLong).toLowerCase());
								String displayRank = "Not ranked";

								for (ClanUser user : CONFIGURE_INTERFACE_USERS) {
									if (user.getName().equalsIgnoreCase(friend))
										displayRank = user.getRankName();
								}

								setInterfaceText(friend, slot);
								setInterfaceText(displayRank, slot + 800);

								slot++;
							}
						}

						for (int clean = slot; clean <= 44200; clean++) {
							setInterfaceText("", clean);
							setInterfaceText("", clean + 800);
						}

						currentPacketOpcode = -1;
						break;

					case 6: // add friend configuration interface
						boolean contains = false;
						for (ClanUser user : CONFIGURE_INTERFACE_USERS) {
							if (user.getName().equalsIgnoreCase(name)) {
								contains = true;
								break;
							}
						}

						if (!contains)
							CONFIGURE_INTERFACE_USERS.add(new ClanUser(name, rank));
						break;

					case 7: // configures the interface
						for (ClanUser user : CONFIGURE_INTERFACE_USERS) {
							if (user.getName().equalsIgnoreCase(name)) {
								user.setRank(rank);
								break;
							}
						}
						break;

					case 8: // deletes an user from the interface
						final Iterator<ClanUser> it = CONFIGURE_INTERFACE_USERS.iterator();
						while (it.hasNext()) {
							ClanUser next = it.next();
							if (next.getName().equalsIgnoreCase(name)) {
								it.remove();
								break;
							}
						}
						break;
					}
				}
				currentPacketOpcode = -1;
				return true;

			case 181:
				String playerName = capitalize(getInputBuffer().getString());
				playerName = playerName.replaceAll("_", " ");
				int rank = getInputBuffer().getUnsignedByte();
				final ClanMember member = new ClanMember(playerName, rank);
				boolean done = false;

				for (int a = 0; a < PlayerHandler.rankedNames.size(); a++) {
					if (PlayerHandler.rankedNames.get(a).getPlayerName().equalsIgnoreCase(member.getPlayerName())) {
						PlayerHandler.rankedNames.get(a).setRank(rank);
						done = true;
					}
				}

				if (!done) {
					PlayerHandler.rankedNames.add(member);
				}

				rank = -1;
				currentPacketOpcode = -1;
				return true;

			case 182:
				int slot = 44001;

				for (int a = 0; a < PlayerHandler.rankedNames.size(); a++) {
					setInterfaceText(PlayerHandler.rankedNames.get(a).getPlayerName(), slot);
					setInterfaceText(PlayerHandler.rankedNames.get(a).getRank().toStr(), slot + 800);
					slot++;
				}

				for (int clean = slot; clean <= 44200; clean++) {
					setInterfaceText("", clean);
					setInterfaceText("", clean + 800);
				}

				currentPacketOpcode = -1;
				return true;

			case 206:
				int chat = getInputBuffer().getUnsignedByte();
				if (chat != 10)
					publicChatMode = chat;

				int privateMode = getInputBuffer().getUnsignedByte();
				if (privateMode != 10)
					privateChatMode = privateMode;

				int trade = getInputBuffer().getUnsignedByte();
				if (trade != 10)
					tradeMode = trade;
				inputTaken = true;
				currentPacketOpcode = -1;
				return true;

			case 240:
				weight = getInputBuffer().getSignedShort();
				currentPacketOpcode = -1;
				return true;

			case 8:
				int k6 = getInputBuffer().getShortBigEndianA();
				int l13 = getInputBuffer().getUnsignedShort();
				RSInterface.interfaceCache[k6].anInt233 = 1;
				RSInterface.interfaceCache[k6].mediaID = l13;
				currentPacketOpcode = -1;
				return true;

			case 122:
				int l6 = getInputBuffer().getShortBigEndianA();
				int colorData = getInputBuffer().getShortBigEndianA();
				int red = colorData >> 10 & 0x1f;
				int green = colorData >> 5 & 0x1f;
				int blue = colorData & 0x1f;
				RSInterface.interfaceCache[l6].textColor = (red << 19) + (green << 11) + (blue << 3);
				currentPacketOpcode = -1;
				return true;

			case 53:
				int i7 = getInputBuffer().getUnsignedShort();
				RSInterface class9_1 = RSInterface.interfaceCache[i7];
				int j19 = getInputBuffer().getUnsignedShort();

				for (int j22 = 0; j22 < j19; j22++) {
					int i25 = getInputBuffer().getUnsignedByte();

					if (i25 == 255) {
						i25 = getInputBuffer().method440();
					}

					class9_1.inv[j22] = getInputBuffer().getShortBigEndianA();
					class9_1.invStackSizes[j22] = i25;
				}

				for (int j25 = j19; j25 < class9_1.inv.length; j25++) {
					class9_1.inv[j25] = 0;
					class9_1.invStackSizes[j25] = 0;
				}

				currentPacketOpcode = -1;
				return true;

			case 230:
				int j7 = getInputBuffer().method435();
				int j14 = getInputBuffer().getUnsignedShort();
				int k19 = getInputBuffer().getUnsignedShort();
				int k22 = getInputBuffer().getShortBigEndianA();
				RSInterface.interfaceCache[j14].modelRotation1 = k19;
				RSInterface.interfaceCache[j14].modelRotation2 = k22;
				RSInterface.interfaceCache[j14].modelZoom = j7;
				currentPacketOpcode = -1;
				return true;

			case 221:
				setAnInt900(getInputBuffer().getUnsignedByte());
				currentPacketOpcode = -1;
				return true;

			case 177:
				cameraViewChanged = true;
				moveCameraX = getInputBuffer().getUnsignedByte();
				moveCameraY = getInputBuffer().getUnsignedByte();
				moveCameraZ = getInputBuffer().getUnsignedShort();
				moveCameraSpeed = getInputBuffer().getUnsignedByte();
				moveCameraAngle = getInputBuffer().getUnsignedByte();

				if (moveCameraAngle >= 100) {
					int k7 = moveCameraX * 128 + 64;
					int k14 = moveCameraY * 128 + 64;
					int i20 = method42(plane, k14, k7) - moveCameraZ;
					int l22 = k7 - xCameraPos;
					int k25 = i20 - zCameraPos;
					int j28 = k14 - yCameraPos;
					int i30 = (int) Math.sqrt(l22 * l22 + j28 * j28);
					yCameraCurve = (int) (Math.atan2(k25, i30) * 325.94900000000001D) & 0x7ff;
					xCameraCurve = (int) (Math.atan2(l22, j28) * -325.94900000000001D) & 0x7ff;

					if (yCameraCurve < 98) {
						yCameraCurve = 98;
					}

					if (yCameraCurve > 383) {
						yCameraCurve = 383;
					}
				}

				currentPacketOpcode = -1;
				return true;

			case 249:
				anInt1046 = getInputBuffer().method426();
				playerIndex = getInputBuffer().getShort();
				currentPacketOpcode = -1;
				return true;

			case 65:
				updateNPCs(getInputBuffer(), pktSize);
				currentPacketOpcode = -1;
				return true;

			case 27:
				messagePromptRaised = false;
				inputDialogState = 1;
				amountOrNameInput = "";
				inputTaken = true;
				currentPacketOpcode = -1;
				return true;

			case 187:
				messagePromptRaised = false;
				inputDialogState = 2;
				amountOrNameInput = "";
				inputTaken = true;
				currentPacketOpcode = -1;
				return true;

			case 97:
				int interfaceId = getInputBuffer().getUnsignedShort();
				resetInterfaceSequence(interfaceId);

				if (invOverlayInterfaceID != -1) {
					invOverlayInterfaceID = -1;
					tabAreaAltered = true;
				}

				if (backDialogID != -1) {
					backDialogID = -1;
					inputTaken = true;
				}

				if (inputDialogState != 0) {
					inputDialogState = 0;
					inputTaken = true;
				}

				openInterfaceID = interfaceId;
				dialogueOptionsShowing = false;
				currentPacketOpcode = -1;
				return true;

			case 218:
				int i8 = getInputBuffer().method438();
				dialogID = i8;
				inputTaken = true;
				currentPacketOpcode = -1;
				return true;

			case 87:
				int conigId = getInputBuffer().getShortBigEndian();
				int configValue = getInputBuffer().method439();
				settings[conigId] = configValue;

				switch (conigId) {
				case 2000:
					updateBankInterface();
					break;
				}

				if (conigId < 2000) {
					if (variousSettings[conigId] != configValue) {
						variousSettings[conigId] = configValue;
						updateConfig(conigId);

						if (dialogID != -1) {
							inputTaken = true;
						}
					}
				}

				currentPacketOpcode = -1;
				return true;

			case 36:
				int settingId = getInputBuffer().getShortBigEndian();
				byte settingValue = getInputBuffer().getSignedByte();
				if (settingId == -55) {
					for (int i : RSInterface.interfaceCache[3213].children) {
						RSInterface.interfaceCache[i].invSpritePadY = settingValue >= 1 ? 0 : 6;
					}
					if (settingValue >= 1) {
						RSInterface.interfaceCache[16546].message = settingValue == 1 ? "Add to bag" : "View bag contents";
						lootingBag = true;
					} else {
						lootingBag = false;
					}
					currentPacketOpcode = -1;
					return true;
				}
				settings[settingId] = settingValue;
				switch (settingId) {
				case 2000:
					updateBankInterface();
					break;
				case 19:
					LOOP_MUSIC = settingValue == 1 ? true : false;
					break;
				case 293:
					int sprite = settingValue == 0 ? 607 : settingValue == 1 ? 606 : settingValue == 2 ? 608 : settingValue == 3 ? 609 : 610;
					RSInterface.interfaceCache[12348].sprite1 = Client.cacheSprite[sprite];
					break;
				}
				if (settingId < 2000) {
					if (variousSettings[settingId] != settingValue) {
						variousSettings[settingId] = settingValue;
						updateConfig(settingId);
						if (dialogID != -1) {
							inputTaken = true;
						}
					}
				}
				currentPacketOpcode = -1;
				return true;

			case 61:
				anInt1055 = getInputBuffer().getUnsignedByte();
				currentPacketOpcode = -1;
				return true;

			case 200:
				int l8 = getInputBuffer().getUnsignedShort();
				int animId = getInputBuffer().getSignedShort();
				RSInterface class9_4 = RSInterface.interfaceCache[l8];
				class9_4.anInt257 = animId;
				class9_4.modelZoom = 2000;

				if (animId == -1) {
					class9_4.anInt246 = 0;
					class9_4.anInt208 = 0;
				}

				currentPacketOpcode = -1;
				return true;

			case 219:
				if (invOverlayInterfaceID != -1) {
					invOverlayInterfaceID = -1;
					tabAreaAltered = true;
				}

				if (backDialogID != -1) {
					backDialogID = -1;
					inputTaken = true;
				}

				if (inputDialogState != 0) {
					inputDialogState = 0;
					inputTaken = true;
				}

				openInterfaceID = -1;
				dialogueOptionsShowing = false;
				currentPacketOpcode = -1;
				return true;

			case 34:
				int rsIntId = getInputBuffer().getUnsignedShort();
				RSInterface rsInt = RSInterface.interfaceCache[rsIntId];

				while (getInputBuffer().position < pktSize) {
					int itemSlot = getInputBuffer().getSmart();
					int itemInvId = getInputBuffer().getUnsignedShort();
					int itemAmount = getInputBuffer().getUnsignedByte();

					if (itemAmount == 255) {
						itemAmount = getInputBuffer().getIntLittleEndian();
					}

					if (itemSlot >= 0 && itemSlot < rsInt.inv.length) {
						rsInt.inv[itemSlot] = itemInvId;
						rsInt.invStackSizes[itemSlot] = itemAmount;
					}
				}

				currentPacketOpcode = -1;
				return true;

			case 4:
			case 44:
			case 84:
			case 101:
			case 105:
			case 117:
			case 147:
			case 151:
			case 156:
			case 160:
			case 215:
				method137(getInputBuffer(), currentPacketOpcode);
				currentPacketOpcode = -1;
				return true;

			case 106:
				tabID = getInputBuffer().method427();
				tabAreaAltered = true;
				currentPacketOpcode = -1;
				return true;

			case 164:
				interfaceId = getInputBuffer().getShortBigEndian();
				if (chatArea.componentHidden()) {
					chatArea.setHideComponent(false);
				}
				resetInterfaceSequence(interfaceId);

				if (invOverlayInterfaceID != -1) {
					invOverlayInterfaceID = -1;
					tabAreaAltered = true;
				}

				backDialogID = interfaceId;
				inputTaken = true;
				openInterfaceID = -1;
				dialogueOptionsShowing = false;
				currentPacketOpcode = -1;
				return true;

			}

			Signlink.reportError("T1 - " + currentPacketOpcode + "," + pktSize + " - " + anInt842 + "," + anInt843);
			resetLogout();
		} catch (IOException _ex) {
			// logger.info("IO Exception processing packets. Dropping client.");
			// _ex.printStackTrace();
			dropClient();
		} catch (Exception exception) {
			String s2 = "T2 - " + currentPacketOpcode + "," + anInt842 + "," + anInt843 + " - " + pktSize + "," + (baseX + myPlayer.smallX[0]) + "," + (baseY + myPlayer.smallY[0]) + " - ";

			for (int j15 = 0; j15 < pktSize && j15 < 50; j15++) {
				s2 = s2 + getInputBuffer().buffer[j15] + ",";
			}

			Signlink.reportError(s2);
			exception.printStackTrace();
		}

		currentPacketOpcode = -1;
		return true;
	}

	public static int getChatColor(String hex) {
		int convertHexCode = Integer.parseInt(hex, 16);
		return convertHexCode;
	}

	public static void processLoadingError(String... msgs) {
		Runtime.getRuntime().addShutdownHook(new Thread() {
			@Override
			public void run() {
				try {
					Signlink.release();
					FileUtilities.delete(Signlink.getDataDirectory().toString());
				} catch (IOException e) {
					e.printStackTrace();
					showErrorScreen(instance, "A fatal error occured while attempting to fix the previous loading error", "Please screenshot this message and report it to the developers immediately",
							e.getMessage());
				}
			}
		});

		showErrorScreen(instance, msgs);

		try {
			Thread.sleep(10_000L);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.exit(0);
	}

	@Override
	public void processDrawing() {
		if (loadingError) {
			processLoadingError("An internal error occured whilst loading the Zamorak client", "The client's common error quick fix system is attempting to repair the cause",
					"The client will automatically close in 10 seconds...");
			return;
		}

		if (!loggedIn) {
			drawLoginScreen(false);
		} else {
			drawGameScreen();
		}

		anInt1213 = 0;
	}

	@Override
	public void processGameLoop() {
		if (loadingError) {
			return;
		}

		loopCycle++;
		if (!loggedIn) {
			processLoginScreenInput();
		} else {
			mainGameProcessor();
		}

		processOnDemandQueue();
		//checkSize();
		//method49();
		//handleSounds();
	}

	private void processLoginScreenInput() {
		int centerX = getScreenWidth() / 2;
		int centerY = getScreenHeight() / 2;
		int boxX = centerX - 360 / 2;
		int boxY = centerY - 250;
		// System.out.println(centerX + " X: " + " Y: " + centerY +
		// " : mouseX: " + super.mouseX + " mouseY: " +
		// super.mouseY);

		if (getLoginScreenState() == 0) {
			/*
			 * Password click
			 */
			if (inSprite(true, cacheSprite[466], boxX + 69, boxY + 232)) {
				setLoginScreenCursorPos(1);
			}

			/*
			 * Username click
			 */
			if (inSprite(true, cacheSprite[466], boxX + 69, boxY + 176)) {
				setLoginScreenCursorPos(0);
			}
			/*
			 * Click login button
			 */

			if (inSprite(true, cacheSprite[463], boxX + 39, boxY + 318)) {
				setLoginFailures(0);
				login(getPassword(), false, getMyUsername());
				setClickMode2(0);

				if (loggedIn) {
					return;
				}
			}
			if (inSprite(true, cacheSprite[467], boxX + 91, boxY + 278)) {
				Constants.REMEMBER_ME_SELECTED = !Constants.REMEMBER_ME_SELECTED;
				setClickMode2(0);
				savePlayerData();
			}

			accountManager.processClick();

			do {
				int keyChar = readChar(-796);

				if (keyChar == -1) {
					return;
				}

				if (keyChar == 96) {
					return;
				}
				if (consoleOpen) {
					if (keyChar == 8 && consoleInput.length() > 0) {
						consoleInput = consoleInput.substring(0, consoleInput.length() - 1);
					}
					if (keyChar >= 32 && keyChar <= 122 && consoleInput.length() < 80) {
						consoleInput += (char) keyChar;
					}

					if ((keyChar == 13 || keyChar == 10) && consoleInput.length() > 0) {
						printConsoleMessage(consoleInput, 0);
						sendCommandPacket(consoleInput);
						consoleInput = "";
						inputTaken = true;
					}
					return;
				}

				boolean validCharacter = false;

				for (int i2 = 0; i2 < validUserPassChars.length(); i2++) {
					if (keyChar != validUserPassChars.charAt(i2)) {
						continue;
					}

					validCharacter = true;
					break;
				}

				if (getLoginScreenCursorPos() == 0) {
					if (keyChar == 8 && getMyUsername().length() > 0) {
						setMyUsername(getMyUsername().substring(0, getMyUsername().length() - 1));
					}

					if (keyChar == 9 || keyChar == 10 || keyChar == 13) {
						setLoginScreenCursorPos(1);
					}

					if (validCharacter && getMyUsername().length() < 12) {
						setMyUsername(getMyUsername() + (char) keyChar);
					}

				} else if (getLoginScreenCursorPos() == 1) {
					if (keyChar == 8 && getPassword().length() > 0) {
						setPassword(getPassword().substring(0, getPassword().length() - 1));
					}

					if (keyChar == 9 || keyChar == 10 || keyChar == 13) {
						if (getLoginScreenCursorPos() == 0) {
							setLoginScreenCursorPos(1);
						} else if (getLoginScreenCursorPos() == 1 && getMyUsername().length() < 1) {
							setLoginScreenCursorPos(0);
						} else if (getLoginScreenCursorPos() == 1 && getPassword().length() < 5) {
							setLoginMessage1("");
							setLoginMessage2("");
						} else {
							if (!loggedIn) {
								login(getPassword(), false, getMyUsername());
							}
							setLoginScreenCursorPos(0);
						}
					}

					if (validCharacter && getPassword().length() < 20) {
						setPassword(getPassword() + (char) keyChar);
					}

				}
			} while (true);

		}
	}

	/**
	 * Handles the login for the player
	 *
	 * @param username
	 *            The username of the player
	 * @param password
	 *            The password if the player
	 * @param reconnecting
	 *            The player is reconnecting
	 */
	private void login(String password, boolean reconnecting, String username) {

		try {

			if (username.length() < 1 || password.length() < 5) {
				setLoginMessage1("Please enter a valid username & password");
				setLoginMessage2("");
				return;
			}
			if (!reconnecting) {
				setLoginMessage1("");
				setLoginMessage2("Connecting to server...");
				drawLoginScreen(true);
			}

			/**
			 * Write our handshake with the server
			 */
			setConnection(new Connection(this, createGameServerSocket(Constants.connectionStatus.getPort())));
			getOut().position = 0;
			getOut().putShortBigEndian(25);
			getOut().putShortBigEndian(0);
			getConnection().queueBytes(2, getOut().buffer);

			/**
			 * Read the response from the server
			 */
			int responseCode = getConnection().read();
			int initialResponseCode = responseCode;

			/**
			 * We received a connection to the server, finish the login header
			 */
			if (responseCode == 0) {
				getConnection().flushInputStream(getInputBuffer().buffer, 8);
				getInputBuffer().position = 0;

				long serverSeed = getInputBuffer().getLong();
				setServerSeed(serverSeed);
				int[] seed = new int[4];
				seed[0] = (int) (Math.random() * 99999999D);
				seed[1] = (int) (Math.random() * 99999999D);
				seed[2] = (int) (getServerSeed() >> 32);
				seed[3] = (int) getServerSeed();

				getOut().position = 0;
				getOut().putShortBigEndian(15);
				getOut().putInt(seed[0]);
				getOut().putInt(seed[1]);
				getOut().putInt(seed[2]);
				getOut().putInt(seed[3]);
				getOut().putString(password);
				getOut().putLong(Signlink.uid);
				getOut().putString(username);
				// getOut().putString(GenerateSerial.serialNumber);
				getOut().encryptRSAContent();

				getLoginBuffer().position = 0;
				getLoginBuffer().putShortBigEndian(reconnecting ? 24 : 22);
				getLoginBuffer().putShortBigEndian(getOut().position + 1 + 1 + 2);
				getLoginBuffer().putInt(Constants.CLIENT_VERSION);
				getLoginBuffer().putShort(255);
				getLoginBuffer().putShortBigEndian(isLowDetail() ? 1 : 0);
				getLoginBuffer().putBytes(getOut().buffer, getOut().position, 0);

				getOut().cipher = new ISAACCipher(seed);

				for (int i = 0; i < 4; i++) {
					seed[i] += 50;
				}

				setConnectionCipher(new ISAACCipher(seed));
				getConnection().queueBytes(getLoginBuffer().position, getLoginBuffer().buffer);
				responseCode = getConnection().read();

			}

			if (responseCode == 1) {
				try {
					Thread.sleep(2000L);
				} catch (Exception _ex) {
				}

				login(password, reconnecting, username);
				return;
			}

			/**
			 * we've been registered to the server, finish our login
			 */
			if (responseCode == 2) {
				finishLogin(this);
				PlayerHandler.load(this);
				sendSettingConfigs();
				if (Constants.REMEMBER_ME_SELECTED)
					accountManager.addAccount(myUsername, password);
				return;
			}

			/**
			 * Start our checks for invalid login attempts
			 */
			if (responseCode == 3) {
				setLoginMessage1("");
				setLoginMessage2("Invalid username or password.");
				return;
			}

			if (responseCode == 4) {
				setLoginMessage1("");
				setLoginMessage2("Your account has been disabled.");
				return;
			}

			if (responseCode == 5) {
				setLoginMessage1("Your account is already logged in.");
				setLoginMessage2("Try again in 60 secs...");
				return;
			}

			if (responseCode == 6) {
				setLoginMessage1(Constants.CLIENT_NAME + " has been updated!");
				setLoginMessage2("Please reload this page.");
				return;
			}

			if (responseCode == 7) {
				setLoginMessage1("This world is full.");
				setLoginMessage2("Please use a different World.getWorld().");
				return;
			}

			if (responseCode == 9) {
				setLoginMessage1("Login limit exceeded.");
				setLoginMessage2("Too many connections from your address.");
				return;
			}

			if (responseCode == 10) {
				loginMessage1 = "Unable to connect.";
				loginMessage2 = "Bad session id.";
				return;
			}

			if (responseCode == 11) {
				setLoginMessage2("Login server rejected session.");
				setLoginMessage2("Please try again.");
				return;
			}

			if (responseCode == 12) {
				setLoginMessage1("");
				setLoginMessage2("Your username must include a number or letter.");
				return;
			}

			if (responseCode == 13) {
				setLoginMessage1("Could not complete login.");
				setLoginMessage2("Please try using a different World.getWorld().");
				return;
			}

			if (responseCode == 14) {
				setLoginMessage1("The server is being updated.");
				setLoginMessage2("Please wait 1 minute and try again.");
				return;
			}

			if (responseCode == 15) {
				setLoginMessage1("");
				setLoginMessage2("This username is already taken.");
				return;
			}

			if (responseCode == 16) {
				setLoginMessage1("Login attempts exceeded.");
				setLoginMessage2("Please wait 1 minute and try again.");
				return;
			}

			if (responseCode == 17) {
				setLoginMessage1("");
				setLoginMessage2("Please fill all the details out.");
				return;
			}

			if (responseCode == 18) {
				setLoginMessage1("");
				setLoginMessage2("Please type a valid email address.");
				return;
			}

			if (responseCode == 19) {
				setLoginMessage1("");
				setLoginMessage2("Please type a shorter email address.");
				return;
			}

			if (responseCode == 20) {
				setLoginMessage1("");
				setLoginMessage2("Please choose a shorter username.");
				return;
			}

			if (responseCode == 21) {
				setLoginMessage1("");
				setLoginMessage2("Please choose a valid email address.");
				return;
			}

			if (responseCode == 22) {
				setLoginMessage1("");
				setLoginMessage2("Your username contains invalid characters.");
				return;
			}

			if (responseCode == 23) {
				setLoginMessage1("");
				setLoginMessage2("Your uid has been disabled.");
				return;
			}

			if (responseCode == 24) {
				setLoginMessage1("");
				setLoginMessage2("This email address is already taken.");
				return;
			}

			if (responseCode == 25) {
				setLoginMessage1(Constants.CLIENT_NAME + " is being updated");
				setLoginMessage2("You will be able to login shortly.");
				return;
			}

			if (responseCode == 26) {
				setLoginMessage1(Constants.CLIENT_NAME + " has experienced an unexpected");
				setLoginMessage2("error, it will be back online again shortly.");
				return;
			}

			if (responseCode == 27) {
				setLoginMessage1("The name of that account is currently");
				setLoginMessage2("being changed.");
				return;
			}

			if (responseCode == 28) {
				setLoginMessage1("That username is currently unavailable.");
				setLoginMessage2("");
				return;
			}

			if (responseCode == 29) {
				setLoginMessage1("Your account is currently unavailable.");
				setLoginMessage2("Merge is in progress.");
				return;
			}

			if (responseCode == 30) {
				setLoginMessage2("");
				setLoginMessage1("Your account has been created!");
				setPassword("");
				setLoginScreenCursorPos(0);
				setLoginState(1);
				setLoginScreenState(2);
				return;
			}

			if (responseCode == 31) {
				for (int k1 = getConnection().read(); k1 >= 0; k1--) {
					setLoginMessage1("You have only just left another world");
					setLoginMessage2("Your profile will be transferred in: " + k1 + " seconds");
					drawLoginScreen(true);

					try {
						Thread.sleep(1000L);
					} catch (Exception _ex) {
					}
				}

				login(password, reconnecting, username);
				return;
			}

			/**
			 * We didn't receive a connection from the server
			 */
			if (responseCode == -1) {
				if (initialResponseCode == 0) {
					if (getLoginFailures() < 2) {
						try {
							Thread.sleep(1000L);
						} catch (Exception _ex) {
						}

						setLoginFailures(getLoginFailures() + 1);
						login(password, reconnecting, username);
					} else {
						setLoginMessage1("No response from loginserver");
						setLoginMessage2("Please wait 1 minute and try again.");
					}
				} else {
					setLoginMessage1("No response from server");
					setLoginMessage2("Please try using a different World.getWorld().");
				}
			} else {
				setLoginMessage1("Unexpected server response");
				setLoginMessage2("Please try using a different World.getWorld().");
			}
		} catch (IOException _ex) {
			setLoginMessage1("");
			setLoginMessage2("Failed to connect to the server...");

		}
	}

	/**
	 * Finishes the successful login for the player
	 *
	 * @throws IOException
	 */
	public void finishLogin(Client client) throws IOException {
		client.myRights = client.getConnection().read();
		Client.flagged = client.getConnection().read() == 1;
		client.mouseDetection.coordsIndex = 0;
		client.awtFocus = true;
		client.aBoolean954 = true;
		Client.loggedIn = true;
		Client.getOut().position = 0;
		client.getInputBuffer().position = 0;
		client.currentPacketOpcode = -1;
		client.anInt841 = -1;
		client.anInt842 = -1;
		client.anInt843 = -1;
		client.pktSize = 0;
		client.timeSinceLastPacket = 0;
		client.systemUpdateTimer = 0;
		client.idleStatus = 0;
		client.anInt855 = 0;
		client.menuActionRow = 0;
		client.menuOpen = false;
		client.idleTime = 0;
		client.itemSelected = 0;
		client.spellSelected = 0;
		client.loadingStage = 0;
		client.soundCount = 0;
		client.setNorth();
		client.setScriptManager(null);
		client.anInt1021 = 0;
		client.setAnInt985(-1);
		client.destX = 0;
		client.destY = 0;
		client.playerCount = 0;
		client.npcCount = 0;

		for (int i = 0; i < client.getMaxPlayers(); i++) {
			client.playerArray[i] = null;
			client.getaStreamArray895s()[i] = null;
		}

		for (int i = 0; i < 16384; i++) {
			client.npcArray[i] = null;
		}

		Client.myPlayer = client.playerArray[client.getMyPlayerIndex()] = new Player();
		client.getaClass19_1013().removeAll();
		client.getaClass19_1056().removeAll();

		for (int l2 = 0; l2 < 4; l2++) {
			for (int i3 = 0; i3 < 104; i3++) {
				for (int k3 = 0; k3 < 104; k3++) {
					client.groundArray[l2][i3][k3] = null;
				}
			}
		}

		client.setaClass19_1179(new Deque());
		client.setFullscreenInterfaceID(-1);
		client.setAnInt900(0);
		client.friendCount = 0;
		client.dialogID = -1;
		client.backDialogID = -1;
		Client.openInterfaceID = -1;
		client.invOverlayInterfaceID = -1;
		client.setWalkableInterface(-1);
		client.dialogueOptionsShowing = false;
		Client.tabID = 3;
		client.inputDialogState = 0;
		client.menuOpen = false;
		client.messagePromptRaised = false;
		client.aString844 = null;
		client.anInt1055 = 0;
		client.anInt1054 = -1;
		client.aBoolean1047 = true;
		client.method45();

		for (int j3 = 0; j3 < 5; j3++) {
			client.anIntArray990[j3] = 0;
		}

		for (int l3 = 0; l3 < 5; l3++) {
			client.atPlayerActions[l3] = null;
			client.atPlayerArray[l3] = false;
		}

		Client.setAnInt1175(0);
		Client.setAnInt1134(0);
		Client.setAnInt986(0);
		Client.setAnInt1288(0);
		Client.setAnInt924(0);
		Client.setAnInt1188(0);
		Client.setAnInt1155(0);
		Client.setAnInt1226(0);
		client.chatTypes = new int[500];
		client.chatNames = new String[500];
		client.chatMessages = new String[500];
		client.resetImageProducers2();
		client.updateGraphics(true);
		mapArea.prayer.setOrbState(false);
		if (GameFrame.getScreenMode() == ScreenMode.FIXED) {
			client.updateGameArea();
		}
		DateFormat format = new SimpleDateFormat();
		Date date = new Date();
		if (jFrame != null)
			jFrame.setTitle(Constants.CLIENT_NAME + " Official | Logged In: " + TextClass.fixName(getMyUsername()) + " " + format.format(date));
	}

	private void processMainScreenClick() {
		if (anInt1021 != 0) {
			return;
		}

		if (super.clickMode3 == 1) {
			int clickX = super.saveClickX - (GameFrame.getScreenMode() == ScreenMode.FIXED ? 553 : getMapArea().getOffSetX() + 14);
			int clickY = super.saveClickY - (GameFrame.getScreenMode() == ScreenMode.FIXED ? 9 : 5);

			if (inCircle(0, 0, clickX, clickY, 76)) {
				clickX -= 73;
				clickY -= 75;
				int k = viewRotation + minimapRotation & 0x7ff;
				int i1 = Rasterizer.SINE[k];
				int j1 = Rasterizer.COSINE[k];
				i1 = i1 * (minimapZoom + 256) >> 8;
				j1 = j1 * (minimapZoom + 256) >> 8;
				int k1 = clickY * i1 + clickX * j1 >> 11;
				int l1 = clickY * j1 - clickX * i1 >> 11;
				int i2 = myPlayer.x + k1 >> 7;
				int j2 = myPlayer.y - l1 >> 7;
				boolean flag1 = doWalkTo(1, 0, 0, 0, myPlayer.smallY[0], 0, 0, j2, myPlayer.smallX[0], true, i2);

				if (flag1) {
					getOut().getByte(clickX);
					getOut().getByte(clickY);
					getOut().putShort(viewRotation);
					getOut().putShortBigEndian(57);
					getOut().putShortBigEndian(minimapRotation);
					getOut().putShortBigEndian(minimapZoom);
					getOut().getByte(89);
					getOut().putShort(myPlayer.x);
					getOut().putShort(myPlayer.y);
					getOut().getByte(anInt1264);
					getOut().getByte(63);
				}
			}

			anInt1117++;

			if (anInt1117 > 1151) {
				anInt1117 = 0;
				getOut().putOpcode(246);
				getOut().getByte(0);
				int l = getOut().position;

				if ((int) (Math.random() * 2D) == 0) {
					getOut().getByte(101);
				}

				getOut().getByte(197);
				getOut().putShort((int) (Math.random() * 65536D));
				getOut().getByte((int) (Math.random() * 256D));
				getOut().getByte(67);
				getOut().putShort(14214);

				if ((int) (Math.random() * 2D) == 0) {
					getOut().putShort(29487);
				}

				getOut().putShort((int) (Math.random() * 65536D));

				if ((int) (Math.random() * 2D) == 0) {
					getOut().getByte(220);
				}

				getOut().getByte(180);
				getOut().putVariableSizeByte(getOut().position - l);
			}
		}
	}

	private boolean processMenuClick() {
		if (activeInterfaceType != 0) {
			return false;
		}

		int clickType = super.clickMode3;

		if (spellSelected == 1 && super.saveClickX >= 516 && super.saveClickY >= 160 && super.saveClickX <= 765 && super.saveClickY <= 205) {
			clickType = 0;
		}

		if (menuOpen) {
			if (clickType != 1) {
				int clickX = super.mouseX;
				int clickY = super.mouseY;

				if (menuScreenArea == 0) {
					clickX -= GameFrame.getScreenMode() == ScreenMode.FIXED ? 4 : 0;
					clickY -= GameFrame.getScreenMode() == ScreenMode.FIXED ? 4 : 0;
				}

				if (menuScreenArea == 1) {
					clickX -= 519;
					clickY -= 168;
				}

				if (menuScreenArea == 2) {
					clickX -= 17;
					clickY -= 338;
				}

				if (menuScreenArea == 3) {
					clickX -= 519;
					clickY -= 0;
				}

				if (clickX < menuOffsetX - 10 || clickX > menuOffsetX + menuWidth + 10 || clickY < menuOffsetY - 10 || clickY > menuOffsetY + menuHeight + 10) {
					menuOpen = false;
					// if (menuScreenArea == 1)
					// {
					// needDrawTabArea = true;
					// }
					if (menuScreenArea == 2) {
						inputTaken = true;
					}
				}
			}

			if (clickType == 1) {
				int xOffset = menuOffsetX;
				int yOffset = menuOffsetY;
				int width = menuWidth;
				int clickX = super.saveClickX;
				int clickY = super.saveClickY;

				if (menuScreenArea == 0) {
					clickX -= GameFrame.getScreenMode() == ScreenMode.FIXED ? 4 : 0;
					clickY -= GameFrame.getScreenMode() == ScreenMode.FIXED ? 4 : 0;
				}

				if (menuScreenArea == 1) {
					clickX -= 519;
					clickY -= 168;
				}

				if (menuScreenArea == 2) {
					clickX -= 17;
					clickY -= 338;
				}

				if (menuScreenArea == 3) {
					clickX -= 519;
					clickY -= 0;
				}

				int actionIndex = -1;

				for (int index = 0; index < menuActionRow; index++) {
					int row = yOffset + 31 + (menuActionRow - 1 - index) * 15;

					if (clickX > xOffset && clickX < xOffset + width && clickY > row - 11 && clickY < row + 5) {
						actionIndex = index;
					}
				}

				if (actionIndex != -1) {
					doAction(actionIndex);
				}

				menuOpen = false;

				if (menuScreenArea == 2) {
					inputTaken = true;
				}
			}

			return true;
		} else {
			if (clickType == 1 && menuActionRow > 0) {
				int actionId = menuActionID[menuActionRow - 1];

				if (actionId == 632 || actionId == 78 || actionId == 867 || actionId == 431 || actionId == 53 || actionId == 74 || actionId == 454 || actionId == 539 || actionId == 493
						|| actionId == 847 || actionId == 447 || actionId == 1125) {
					int actionOne = menuActionCmd2[menuActionRow - 1];
					int actionTwo = menuActionCmd3[menuActionRow - 1];
					RSInterface rsi = RSInterface.interfaceCache[actionTwo];

					if (rsi.allowSwapItems || rsi.deletesTargetSlot) {
						aBoolean1242 = false;
						anInt989 = 0;
						anInt1084 = actionTwo;
						anInt1085 = actionOne;
						activeInterfaceType = 2;
						anInt1087 = super.saveClickX;
						anInt1088 = super.saveClickY;

						if (RSInterface.interfaceCache[actionTwo].parentID == openInterfaceID) {
							activeInterfaceType = 1;
						}

						if (RSInterface.interfaceCache[actionTwo].parentID == backDialogID) {
							activeInterfaceType = 3;
						}

						return true;
					}
				}
			}

			if (clickType == 1 && (anInt1253 == 1 || menuHasAddFriend(menuActionRow - 1)) && menuActionRow > 2) {
				clickType = 2;
			}

			if (clickType == 1 && menuActionRow > 0) {
				doAction(menuActionRow - 1);
			}

			if (clickType == 2 && menuActionRow > 0) {
				determineMenuSize();
			}

			return false;
		}
	}

	private void processOnDemandQueue() {
		do {
			OnDemandRequest onDemandData;

			do {
				onDemandData = onDemandFetcher.getNextNode();

				if (onDemandData == null) {
					return;
				}

				if (onDemandData.getDataType() == 0) {
					Model.method460(onDemandData.getBuffer(), onDemandData.getId());
					// needDrawTabArea = true;

					if (backDialogID != -1) {
						setInputTaken(true);
					}
				}

				if (onDemandData.getDataType() == 1) {
					FrameReader.load(onDemandData.getId(), onDemandData.getBuffer());
				}

				if (onDemandData.getDataType() == 2 && onDemandData.getId() == nextSong && onDemandData.getBuffer() != null) {
					musicData = new byte[onDemandData.getBuffer().length];
					ArrayUtils.arraycopy(onDemandData.getBuffer(), 0, musicData, 0, musicData.length);
					fetchMusic = true;
				}

				if (onDemandData.getDataType() == 3 && loadingStage == 1) {
					for (int i = 0; i < aByteArrayArray1183.length; i++) {
						if (floorMap[i] == onDemandData.getId()) {
							aByteArrayArray1183[i] = onDemandData.getBuffer();

							if (onDemandData.getBuffer() == null) {
								floorMap[i] = -1;
							}

							break;
						}

						if (objectMap[i] != onDemandData.getId()) {
							continue;
						}

						aByteArrayArray1247[i] = onDemandData.getBuffer();

						if (onDemandData.getBuffer() == null) {
							objectMap[i] = -1;
						}

						break;
					}
				}
				if (onDemandData.getDataType() == 4) {
					Texture.decode(onDemandData.getId(), onDemandData.getBuffer());
				}
			} while (onDemandData.getDataType() != 93 || !onDemandFetcher.method564(onDemandData.getId()));

			ObjectManager.method173(new ByteBuffer(onDemandData.getBuffer()), onDemandFetcher);
		} while (true);
	}

	private void processRightClick() {
		if (activeInterfaceType != 0) {
			return;
		}

		menuActionName[0] = "Cancel";
		menuActionID[0] = 1107;
		menuActionRow = 1;

		int splitBoxX = 495;
		int splitBoxY = 122 + (GameFrame.getScreenMode() == ScreenMode.FIXED ? 0 : 2);

		if (getFullscreenInterfaceID() != -1) {
			anInt886 = 0;
			anInt1315 = 0;
			buildInterfaceMenu(GameFrame.getScreenMode() == ScreenMode.FIXED ? 8 : getScreenWidth() / 2 - RSInterface.interfaceCache[getFullscreenInterfaceID()].width / 2,
					RSInterface.interfaceCache[getFullscreenInterfaceID()], super.mouseX,
					GameFrame.getScreenMode() == ScreenMode.FIXED ? 8 : getScreenHeight() / 2 - RSInterface.interfaceCache[getFullscreenInterfaceID()].height / 2, super.mouseY, 0);

			if (anInt886 != anInt1026) {
				anInt1026 = anInt886;
			}

			if (anInt1315 != anInt1129) {
				anInt1129 = anInt1315;
			}

			return;
		}

		if (!chatArea.componentHidden() && isGameFrameVisible()) {
			buildSplitPrivateChatMenu();
		}

		boolean inSplitChatSelectionBox = mouseX >= splitBoxX && mouseX <= splitBoxX + 15 && mouseY >= splitBoxY + chatArea.getyPos() && mouseY <= splitBoxY + chatArea.getyPos() + 13;
		if (inSplitChatSelectionBox) {
			chatArea.channel.processChatModeActions(this, GameFrame.getScreenMode());
			return;
		}

		anInt886 = 0;
		anInt1315 = 0;
		int width = GameFrame.getScreenMode() != ScreenMode.FIXED ? getScreenWidth() : 516;
		int height = GameFrame.getScreenMode() != ScreenMode.FIXED ? getScreenHeight() : 338;

		if (super.mouseX > gameScreenDrawX && super.mouseY > gameScreenDrawY && super.mouseX < width && super.mouseY < height) {
			if (openInterfaceID != -1 && isGameFrameVisible()) {
				RSInterface rsInterface = RSInterface.interfaceCache[openInterfaceID];

				if (GameFrame.getScreenMode() != ScreenMode.FIXED) {
					int interfaceWidth = GameFrame.getScreenMode() != ScreenMode.FIXED ? getScreenWidth() : 516;
					int interfaceHeight = GameFrame.getScreenMode() != ScreenMode.FIXED ? getScreenHeight() : 338;
					buildInterfaceMenu(gameScreenDrawX + (interfaceWidth - 765) / 2, rsInterface, super.mouseX, gameScreenDrawY + (interfaceHeight - 503) / 2, super.mouseY, 0);
				} else {
					buildInterfaceMenu(4, rsInterface, super.mouseX, 4, super.mouseY, 0);
				}
			} else {
				try {
					if (GameFrame.getScreenMode() != ScreenMode.FIXED) {
						if (!getMapArea().isHovering(this, GameFrame.getScreenMode()) && !chatArea.isHovering(this, GameFrame.getScreenMode())
								&& !tabArea.isHovering(this, GameFrame.getScreenMode())) {
							build3dScreenMenu();
						}
					} else {
						build3dScreenMenu();
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}

		chatArea.channel.processChatModeActions(this, GameFrame.getScreenMode());

		if (anInt886 != anInt1026) {
			anInt1026 = anInt886;
		}

		if (anInt1315 != anInt1129) {
			anInt1129 = anInt1315;
		}

		anInt886 = 0;
		anInt1315 = 0;

		if (tabArea.isHovering(this, GameFrame.getScreenMode()) && !tabArea.componentHidden()) {
			if (invOverlayInterfaceID != -1) {
				buildInterfaceMenu(tabArea.getxPos() + (GameFrame.getScreenMode() == ScreenMode.FIXED ? 31 : 40), RSInterface.interfaceCache[invOverlayInterfaceID], super.mouseX,
						tabArea.getyPos() + (GameFrame.getScreenMode() == ScreenMode.FIXED ? 36 : getScreenWidth() <= GameFrameConstants.smallTabs ? -6 : 30), super.mouseY, 0);
			} else if (tabInterfaceIDs[tabID] != -1) {
				buildInterfaceMenu(tabArea.getxPos() + (GameFrame.getScreenMode() == ScreenMode.FIXED ? 31 : 40), RSInterface.interfaceCache[tabInterfaceIDs[tabID]], super.mouseX,
						tabArea.getyPos() + (GameFrame.getScreenMode() == ScreenMode.FIXED ? 36 : getScreenWidth() <= GameFrameConstants.smallTabs ? -6 : 30), super.mouseY, 0);
			}
		}

		if (anInt886 != anInt1048) {
			// needDrawTabArea = true;
			tabAreaAltered = true;
			anInt1048 = anInt886;
		}

		if (anInt1315 != anInt1044) {
			// needDrawTabArea = true;
			tabAreaAltered = true;
			anInt1044 = anInt1315;
		}

		anInt886 = 0;
		anInt1315 = 0;

		if (super.mouseX > chatArea.getxPos() && super.mouseY > chatArea.getyPos() && super.mouseX < chatArea.getxPos() + 490 && super.mouseY < chatArea.getyPos() + 125) {
			if (backDialogID != -1) {
				buildInterfaceMenu(20, RSInterface.interfaceCache[backDialogID], super.mouseX, chatArea.getyPos() + 20, super.mouseY, chatArea.getxPos());
			} else if (super.mouseY < chatArea.getyPos() + 125 && super.mouseX < chatArea.getxPos() + 490) {
				buildChatAreaMenu(super.mouseY - chatArea.getyPos());
			}
		}

		if (backDialogID != -1 && anInt886 != anInt1039) {
			setInputTaken(true);
			anInt1039 = anInt886;
		}

		if (backDialogID != -1 && anInt1315 != anInt1500) {
			setInputTaken(true);
			anInt1500 = anInt1315;
		}

		getMapArea().processMinimapActions(this);
		boolean flag = false;

		while (!flag) {
			flag = true;

			for (int j = 0; j < menuActionRow - 1; j++) {
				if (menuActionID[j] < 1000 && menuActionID[j + 1] > 1000) {
					String s = menuActionName[j];
					menuActionName[j] = menuActionName[j + 1];
					menuActionName[j + 1] = s;
					int k = menuActionID[j];
					menuActionID[j] = menuActionID[j + 1];
					menuActionID[j + 1] = k;
					k = menuActionCmd2[j];
					menuActionCmd2[j] = menuActionCmd2[j + 1];
					menuActionCmd2[j + 1] = k;
					k = menuActionCmd3[j];
					menuActionCmd3[j] = menuActionCmd3[j + 1];
					menuActionCmd3[j + 1] = k;
					k = menuActionCmd4[j];
					menuActionCmd4[j] = menuActionCmd4[j + 1];
					menuActionCmd4[j + 1] = k;
					k = menuActionCmd1[j];
					menuActionCmd1[j] = menuActionCmd1[j + 1];
					menuActionCmd1[j + 1] = k;
					flag = false;
				}
			}
		}
	}

	private boolean promptUserForInput(RSInterface rsinterface) {
		int id = rsinterface.contentType;

		if (getAnInt900() == 2) {
			if (id == 201) {
				inputTaken = true;
				inputDialogState = 0;
				messagePromptRaised = true;
				promptInput = "";
				friendsListAction = 1;
				promptMessage = "Enter name of friend to add to list";
			}

			if (id == 202) {
				inputTaken = true;
				inputDialogState = 0;
				messagePromptRaised = true;
				promptInput = "";
				friendsListAction = 2;
				promptMessage = "Enter name of friend to delete from list";
			}
		}

		if (id == 205) {
			// logger.info("Settting idle status: " + id);
			idleStatus = 250;
			return true;
		}

		if (id == 501) {
			inputTaken = true;
			inputDialogState = 0;
			messagePromptRaised = true;
			promptInput = "";
			friendsListAction = 4;
			promptMessage = "Enter the name of a player to add to the list";
		}

		if (id == 502) {
			inputTaken = true;
			inputDialogState = 0;
			messagePromptRaised = true;
			promptInput = "";
			friendsListAction = 5;
			promptMessage = "Enter the name of a player to delete from the list";
		}

		if (id == 550) {
			if (RSInterface.interfaceCache[18135].message.startsWith("Join")) {
				inputTaken = true;
				inputDialogState = 0;
				messagePromptRaised = true;
				promptInput = "";
				friendsListAction = 6;
				promptMessage = "Enter the name of the chat you wish to join";
			} else {
				getOut().putOpcode(243);
				getOut().putShort(49627);
			}
		}

		if (id == 22222) {
			inputTaken = true;
			messagePromptRaised = true;
			amountOrNameInput = "";
			promptInput = "";
			inputDialogState = 0;
			interfaceButtonAction = 6199;
			promptMessage = "Enter a name for the clan chat.";
		}

		if (id == 677) {
			inputTaken = true;
			messagePromptRaised = true;
			amountOrNameInput = "";
			promptInput = "";
			inputDialogState = 0;
			interfaceButtonAction = 6200;
			promptMessage = "Enter name of the player you would like kicked.";
		}

		if (id >= 300 && id <= 313) {
			int k = (id - 300) / 2;
			int j1 = id & 1;
			int i2 = anIntArray1065[k];

			if (i2 != -1) {
				do {
					if (j1 == 0 && --i2 < 0) {
						i2 = IdentityKit.getLength() - 1;
					}

					if (j1 == 1 && ++i2 >= IdentityKit.getLength()) {
						i2 = 0;
					}
				} while (IdentityKit.cache[i2].isaBoolean662() || IdentityKit.cache[i2].getAnInt657() != k + (aBoolean1047 ? 0 : 7));

				anIntArray1065[k] = i2;
				aBoolean1031 = true;
			}
		}

		if (id >= 314 && id <= 323) {
			int l = (id - 314) / 2;
			int k1 = id & 1;
			int j2 = anIntArray990[l];

			if (k1 == 0 && --j2 < 0) {
				j2 = anIntArrayArray1003[l].length - 1;
			}

			if (k1 == 1 && ++j2 >= anIntArrayArray1003[l].length) {
				j2 = 0;
			}

			anIntArray990[l] = j2;
			aBoolean1031 = true;
		}

		if (id == 324 && !aBoolean1047) {
			aBoolean1047 = true;
			method45();
		}

		if (id == 325 && aBoolean1047) {
			aBoolean1047 = false;
			method45();
		}

		if (id == 326) {
			getOut().putOpcode(106);
			getOut().putShortBigEndian(aBoolean1047 ? 0 : 1);

			for (int i = 0; i < 7; i++) {
				getOut().putShortBigEndian(anIntArray1065[i]);
			}

			for (int i = 0; i < 5; i++) {
				getOut().putShortBigEndian(anIntArray990[i]);
			}

			return true;
		}

		return false;
	}

	public final int[] chatColor = new int[500];

	public void pushMessage(String chatMessage, int chatType, String chatName, String title, int color, int position) {
		if (chatType == 0 && dialogID != -1) {
			aString844 = chatMessage;
			super.clickMode3 = 0;
		}

		if (backDialogID == -1) {
			inputTaken = true;
		}

		for (int j = 499; j > 0; j--) {
			chatTypes[j] = chatTypes[j - 1];
			chatNames[j] = chatNames[j - 1];
			chatMessages[j] = chatMessages[j - 1];
			chatRights[j] = chatRights[j - 1];
			chatTitles[j] = chatTitles[j - 1];
			chatPosition[j] = chatPosition[j - 1];
			chatColor[j] = chatColor[j - 1];
		}

		chatTypes[0] = chatType;
		chatNames[0] = chatName;
		chatMessages[0] = chatMessage.trim();
		chatRights[0] = rights;
		chatTitles[0] = title;
		chatColor[0] = color;
		chatPosition[0] = position;
	}

	public void pushMessage(String chatMessage, int chatType, String chatName) {
		if (chatType == 0 && dialogID != -1) {
			aString844 = chatMessage;
			super.clickMode3 = 0;
		}

		if (backDialogID == -1) {
			inputTaken = true;
		}

		for (int j = 499; j > 0; j--) {
			chatTypes[j] = chatTypes[j - 1];
			chatNames[j] = chatNames[j - 1];
			chatMessages[j] = chatMessages[j - 1];
			chatRights[j] = chatRights[j - 1];
			chatTitles[j] = chatTitles[j - 1];
			chatPosition[j] = chatPosition[j - 1];
			chatColor[j] = chatColor[j - 1];
		}

		chatTypes[0] = chatType;
		chatNames[0] = chatName;
		chatMessages[0] = chatMessage.trim();
		chatRights[0] = rights;
		chatTitles[0] = "";
		chatColor[0] = 0;
		chatPosition[0] = 0;
	}

	@Override
	public void raiseWelcomeScreen() {
		welcomeScreenRaised = true;
	}

	private void resetAllImageProducers() {
		if (super.fullGameScreen != null) {
			return;
		}

		chatAreaIP = null;
		mapAreaIP = null;
		tabAreaIP = null;
		gameScreenIP = null;
		aRSImageProducer_1125 = null;
		aRSImageProducer_1107 = null;
		titleScreenIP = null;
		super.fullGameScreen = constructGraphicsBuffer(getScreenWidth(), getScreenHeight(), getGameComponent());
		welcomeScreenRaised = true;
	}

	private void resetImageProducers() {
		if (aRSImageProducer_1107 != null) {
			return;
		}
		super.fullGameScreen = null;
		chatAreaIP = null;
		mapAreaIP = null;
		tabAreaIP = null;
		gameScreenIP = null;
		aRSImageProducer_1125 = null;
		aRSImageProducer_1107 = constructGraphicsBuffer(509, 171, getGameComponent());
		DrawingArea.setAllPixelsToZero();
		titleScreenIP = constructGraphicsBuffer(getScreenWidth(), getScreenHeight(), getGameComponent());
		DrawingArea.setAllPixelsToZero();
		constructGraphicsBuffer(203, 238, getGameComponent());
		DrawingArea.setAllPixelsToZero();
		constructGraphicsBuffer(74, 94, getGameComponent());
		DrawingArea.setAllPixelsToZero();
		if (titleStreamLoader != null) {
			drawLogo();
			loadTitleScreen();
		}
		welcomeScreenRaised = true;
	}

	public void resetImageProducers2() {
		if (chatAreaIP != null) {
			return;
		}
		nullLoader();
		super.fullGameScreen = null;
		aRSImageProducer_1107 = null;
		titleScreenIP = null;
		chatAreaIP = constructGraphicsBuffer(516, 165, getGameComponent());
		mapAreaIP = constructGraphicsBuffer(249, 168, getGameComponent());
		DrawingArea.setAllPixelsToZero();
		if (GameFrame.getScreenMode() == ScreenMode.FIXED) {
			cacheSprite[14].drawSprite(0, 0);
		}
		tabAreaIP = constructGraphicsBuffer(250, 335, getGameComponent());
		gameScreenIP = constructGraphicsBuffer(GameFrame.getScreenMode() == ScreenMode.FIXED && isGameFrameVisible() ? 512 : getScreenWidth(),
				GameFrame.getScreenMode() == ScreenMode.FIXED && isGameFrameVisible() ? 334 : getScreenHeight(), getGameComponent());
		DrawingArea.setAllPixelsToZero();
		aRSImageProducer_1125 = constructGraphicsBuffer(249, 45, getGameComponent());
		welcomeScreenRaised = true;
	}

	public void resetLogout() {
		try {
			if (getConnection() != null) {
				getConnection().close();
			}
		} catch (Exception _ex) {
		}
		CLAN_CHAT_USERS.clear();
		CONFIGURE_INTERFACE_USERS.clear();
		lootingBag = false;
		setConnection(null);
		loggedIn = false;
		setLoginScreenState(0);
		setLoginScreenCursorPos(0);

		setLoginMessage1("Enter your username & password.");
		setLoginMessage2("");
		unlinkMRUNodes();
		worldController.initToNull();

		for (int i = 0; i < 4; i++) {
			aClass11Array1230[i].method210();
		}

		synchronized (tasks) {
			tasks.clear();
		}

		if (!Constants.REMEMBER_ME_SELECTED) {
			myUsername = password = "";
		}

		System.gc();
		stopMidi();
		currentSong = -1;
		nextSong = -1;
		prevSong = 0;
		method58(10, 0, false, 0);
		updateGraphics(true);
		savePlayerData();
		if (jFrame != null)
			jFrame.setTitle(Constants.CLIENT_NAME + " Official");

		// logger.info("Resetting logout.");
	}

	public void resetWorld(int stage) {
		if (stage == 0) {
			soundCount = 0;
			cameraOffsetX = 0;
			cameraOffsetY = 0;
			viewRotationOffset = 0;
			minimapRotation = 0;
			minimapZoom = 0;
			viewRotation = 0;
			anInt1021 = 0;
			loadingStage = 1;
		} else if (stage == 1) {
			aBoolean1080 = false;
		}
	}

	@Override
	public void run() {
		try {
			if (drawFlames) {
				drawFlames();
			} else {
				super.run();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void sendFrame248(int interfaceID, int sideInterfaceID) {
		if (backDialogID != -1) {
			backDialogID = -1;
			inputTaken = true;
		}
		if (inputDialogState != 0) {
			inputDialogState = 0;
			inputTaken = true;
		}
		openInterfaceID = interfaceID;
		invOverlayInterfaceID = sideInterfaceID;
		tabAreaAltered = true;
		dialogueOptionsShowing = false;
	}

	private void sendFrame36(int id, int state) {
		settings[id] = state;

		if (variousSettings[id] != state) {
			variousSettings[id] = state;
			updateConfig(id);

			if (dialogID != -1) {
				inputTaken = true;
			}
		}
	}

	private void sendPacket(int packet) {
		if (packet == 103) {
			getOut().putOpcode(103);
			getOut().putShortBigEndian(inputString.length() - 1);
			getOut().putString(inputString.substring(2));
			inputString = "";
			promptInput = "";
			interfaceButtonAction = 0;
		} else if (packet == 1003) {
			getOut().putOpcode(103);
			inputString = "::" + inputString;
			getOut().putShortBigEndian(inputString.length() - 1);
			getOut().putString(inputString.substring(2));
			inputString = "";
			promptInput = "";
			interfaceButtonAction = 0;
		} else if (packet == 107 || packet == 110) {
			long amount = 0;
			try {
				amount = Long.parseLong(inputString);
			} catch (NumberFormatException e) {
				pushMessage("Please enter a valid amount.", 0, "");
				amount = -1;
			}

			if (amount > Long.MAX_VALUE) {
				amount = Long.MAX_VALUE;
			}

			if (amount != -1) {
				getOut().putOpcode(packet);
				getOut().putLong(amount);
			}
			inputString = "";
			promptInput = "";
			interfaceButtonAction = 0;
			if (packet == 107) {
				MapArea.pouchModifyType = PouchModifyType.ADD;
			} else if (packet == 110) {
				MapArea.pouchModifyType = PouchModifyType.REMOVE;
			}
			MapArea.moneyPouchFlash = 100;
		} else if (packet == 108) {
			getOut().putOpcode(packet);
		}
	}

	private void setCameraPos(int j, int k, int l, int i1, int j1, int k1) {
		int l1 = 2048 - k & 0x7ff;
		int i2 = 2048 - j1 & 0x7ff;
		int j2 = 0;
		int k2 = 0;
		int l2 = j;
		if (l1 != 0) {
			int i3 = Model.modelIntArray1[l1];
			int k3 = Model.modelIntArray2[l1];
			int i4 = k2 * k3 - l2 * i3 >> 16;
			l2 = k2 * i3 + l2 * k3 >> 16;
			k2 = i4;
		}
		if (i2 != 0) {
			int j3 = Model.modelIntArray1[i2];
			int l3 = Model.modelIntArray2[i2];
			int j4 = l2 * j3 + j2 * l3 >> 16;
			l2 = l2 * l3 - j2 * j3 >> 16;
			j2 = j4;
		}
		xCameraPos = l - j2;
		zCameraPos = i1 - k2;
		yCameraPos = k1 - l2;
		yCameraCurve = k;
		xCameraCurve = j1;
	}

	public void setDebugMode(boolean debugMode) {
		this.debugMode = debugMode;
	}

	private void setGameFrameVisible(boolean visible, GameFrame[] area) {
		for (GameFrame a : area) {
			a.setVisible(visible);
		}

		gameAreaWidth = GameFrame.getScreenMode() == ScreenMode.FIXED && visible ? 512 : getScreenWidth();
		gameAreaHeight = GameFrame.getScreenMode() == ScreenMode.FIXED && visible ? 334 : getScreenHeight();
		gameFrameVisible = visible;
	}

	public void setInputTaken(boolean inputTaken) {
		this.inputTaken = inputTaken;
	}

	/**
	 * The line ids in order
	 */
	private static int[] lines = { 640, 663, 7332, 7333, 7334, 7336, 7383, 7339, 7338, 7340, 7346, 7341, 7342, 7337, 7343, 7335, 7344, 7345, 7347, 7348, 682, 12772, 673, 7352, 17510, 7353, 12129,
			8438, 12852, 15841, 7354, 7355, 7356, 8679, 7459, 16149, 6987, 7357, 12836, 7358, 7359, 14169, 10115, 14604, 7360, 12282, 13577, 12839, 7361, 16128, 11857, 7362, 7363, 7364, 10135, 4508,
			18517, 11907, 7365, 7366, 7367, 13389, 15487, 7368, 11132, 7369, 12389, 13974, 6027, 7370, 8137, 7371, 12345, 7372, 8115, 18684, 15499, 18306, 668, 8576, 12139, 14912, 7373, 7374, 8969,
			15352, 7375, 7376, 15098, 15592, 249, 1740, 15235, 3278, 7378, 6518, 7379, 7380, 7381, 11858, 191, 9927, 6024, 7349, 7350, 7351, 13356

	};

	public void setInterfaceText(String str, int i) {
		try {
			RSInterface _interface = RSInterface.interfaceCache[i];
			_interface.message = str;

			// if (_interface.parentID == tabInterfaceIDs[tabID])
			// {
			// needDrawTabArea = true;
			// }

			if (_interface.type == 9) {
				_interface.tooltipBoxText = str;
			}

			if (_interface.secondaryText != null && _interface.secondaryText.length() > 0) {
				_interface.secondaryText = "";
			}

			for (int li : lines) {
				if (i == li) {
					_interface.tooltip = str;
					break;
				}
			}
		} catch (Exception exception) {
			exception.getStackTrace();
			// System.out.println(i);
		}
	}

	private String setMessage(int level) {
		String[] messages = new String[4];
		String message = "";
		int[] stuff = { 0, 3, 14, 2, 16, 13, 1, 15, 10, 4, 17, 7, 5, 12, 11, 6, 9, 8, 20, 18, 19, 21, 22, 23 };

		messages[1] = skillNames[level] + " XP: " + NumberFormat.getIntegerInstance().format(currentExp[stuff[level]]) + "\\n";
		messages[2] = "Remainder: " + NumberFormat.getIntegerInstance().format(getExperienceForLevel(maxStats[stuff[level]] + 1) - getExperienceForLevel(maxStats[stuff[level]])) + "\\n";
		messages[3] = "Next level: " + NumberFormat.getIntegerInstance().format(getExperienceForLevel(maxStats[stuff[level]] + 1));
		message = messages[1] + messages[2] + messages[3];

		if (maxStats[stuff[level]] >= 99) {
			message = messages[1];
		}

		return message;
	}

	public void setNorth() {
		cameraOffsetX = 0;
		cameraOffsetY = 0;
		viewRotationOffset = 0;
		viewRotation = 0;
		minimapRotation = 0;
		minimapZoom = 0;
	}

	private static void showErrorScreen(Client client, String... messages) {
		client.method4(1);
		Graphics g = client.getGameComponent().getGraphics();
		Color titleTextColor = new Color(205, 50, 50);
		Color textColor = new Color(191, 30, 30);
		g.setColor(Color.BLACK);
		g.fillRect(0, 0, 765, 503);
		g.setFont(new Font("Verdana", 1, 18));
		g.setColor(titleTextColor);
		g.drawString("Sorry, an error has occured whilst starting up Zamorak", 30, 35);
		g.drawLine(30, 40, 645, 40);
		g.setFont(new Font("Arial", 1, 90));
		g.setColor(textColor);
		g.setFont(new Font("Verdana", 1, 16));
		int startingX = 30, startingY = 40;
		for (String message : messages) {
			startingY += 40;
			g.drawString(message, startingX, startingY);
		}
	}

	private void spawnGroundItem(int i, int j) {
		Deque groundItems = groundArray[plane][i][j];
		if (groundItems == null) {
			worldController.method295(plane, i, j);
			return;
		}
		int k = 0xfa0a1f01;
		Object obj = null;
		for (Item item = (Item) groundItems.reverseGetFirst(); item != null; item = (Item) groundItems.reverseGetNext()) {
			ItemDefinition itemDef = ItemDefinition.get(item.id);
			int l = itemDef.value;
			if (itemDef.stackable) {
				l *= item.amount + 1;
			}
			if (l > k) {
				k = l;
				obj = item;
			}
		}

		groundItems.insertTail((Node) obj);
		Object obj1 = null;
		Object obj2 = null;
		for (Item groundItem = (Item) groundItems.reverseGetFirst(); groundItem != null; groundItem = (Item) groundItems.reverseGetNext()) {
			if (groundItem.id != ((Item) obj).id && obj1 == null) {
				obj1 = groundItem;
			}
			if (groundItem.id != ((Item) obj).id && groundItem.id != ((Item) obj1).id && obj2 == null) {
				obj2 = groundItem;
			}
		}

		int i1 = i + (j << 7) + 0x60000000;
		worldController.method281(i, i1, (Animable) obj1, method42(plane, j * 128 + 64, i * 128 + 64), (Animable) obj2, (Animable) obj, plane, j);
	}

	@Override
	public void startRunnable(Runnable runnable, int i) {
		if (i > 10) {
			i = 10;
		}
		if (Signlink.mainapp != null) {
			Signlink.startthread(runnable, i);
		} else {
			super.startRunnable(runnable, i);
		}
	}

	public static int TotalRead = 0;

	public static int clientZoom;

	public void preloadModels() {
		System.out.println(Signlink.getCacheDirectory());
		File file = new File(Signlink.getCacheDirectory() + "/raw/");
		File[] fileArray = file.listFiles();
		for (File element : fileArray) {
			String sss = element.getName();
			System.out.println("Parsing model file " + sss);
			byte[] buffer = ReadFile(Signlink.getCacheDirectory() + "/raw/" + sss);
			Model.method460(buffer, Integer.parseInt(getFileNameWithoutExtension(sss)));
		}
	}

	public static final byte[] ReadFile(String s) {
		try {
			byte abyte0[];
			File file = new File(s);
			int i = (int) file.length();
			abyte0 = new byte[i];
			DataInputStream datainputstream = new DataInputStream(new BufferedInputStream(new FileInputStream(s)));
			datainputstream.readFully(abyte0, 0, i);
			datainputstream.close();
			TotalRead++;
			return abyte0;
		} catch (Exception e) {
			System.out.println(new StringBuilder().append("Read Error: ").append(s).toString());
			return null;
		}
	}

	@Override
	void startUp() {

		drawSmoothLoading(0, "Starting up");

		new Thread() {
			@Override
			public void run() {
				System.gc();
				System.runFinalization();
				try {
					Thread.sleep(15000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}.start();

		if (!Constants.LOCAL_CLIENT) {
			CacheDownloader.start(this, FileType.CACHE);
			CacheDownloader.start(this, FileType.IMAGES);
			CacheDownloader.start(this, FileType.FILEDATA);
		} else {
			CacheDownloader.start(this, FileType.IMAGES);
			CacheDownloader.start(this, FileType.FILEDATA);
		}

		SpriteLoader.loadSprites();
		cacheSprite = SpriteLoader.sprites;
		SpriteLoader.sprites = null;

		if (Signlink.sunjava) {
			super.minDelay = 5;
		}
		getDocumentBaseHost();

		if (Signlink.cache_dat != null) {
			for (int i = 0; i < Client.CACHE_INDEX_COUNT; i++) {
				decompressors[i] = new Decompressor(Signlink.cache_dat, Signlink.cache_idx[i], i + 1);
			}
		}
		try {

			if (Constants.JAGCACHED_ENABLED) {
				compareCrcValues();
			}

			drawLogo();
			loadTitleScreen();
			aClass3_Sub7_Sub1_1493 = method407(instance);
			aClass25_1948 = new Class25(22050, anInt197);
			Archive streamLoader = getArchive(2, "config", "config", expectedCRCs[2], 30);
			Archive streamLoader_1 = getArchive(3, "interface", "interface", expectedCRCs[3], 35);
			Archive mediaArchive = getArchive(4, "2d graphics", "media", expectedCRCs[4], 40);
			Archive streamLoader_3 = getArchive(6, "textures", "textures", expectedCRCs[6], 45);
			Archive streamLoader_4 = getArchive(7, "chat system", "wordenc", expectedCRCs[7], 50);
			Archive soundArchive = getArchive(8, "sound effects", "sounds", expectedCRCs[8], 55);

			titleStreamLoader = getArchive(1, "title screen", "title", expectedCRCs[1], 25);
			smallText = new TextDrawingArea(false, "p11_full", titleStreamLoader);
			normalText = new TextDrawingArea(false, "p12_full", titleStreamLoader);
			chatTextDrawingArea = new TextDrawingArea(false, "b12_full", titleStreamLoader);
			TextDrawingArea aTextDrawingArea_1273 = new TextDrawingArea(true, "q8_full", titleStreamLoader);
			newSmallFont = new RSFontSystem(false, "p11_full", titleStreamLoader);
			newRegularFont = new RSFontSystem(false, "p12_full", titleStreamLoader);
			newBoldFont = new RSFontSystem(false, "b12_full", titleStreamLoader);
			newFancyFont = new RSFontSystem(true, "q8_full", titleStreamLoader);

			testFont = new JFont("Augusta.ttf", 20, true);
			byteGroundArray = new byte[4][104][104];
			intGroundArray = new int[4][105][105];
			worldController = new WorldController(intGroundArray);

			for (int j = 0; j < 4; j++) {
				aClass11Array1230[j] = new CollisionMap();
			}

			miniMapRegions = new Sprite(512, 512);
			Archive streamLoader_6 = getArchive(5, "update list", "versionlist", expectedCRCs[5], 60);
			drawSmoothLoading(60, "Unpacking archives");
			onDemandFetcher = new OnDemandFetcher();
			onDemandFetcher.start(streamLoader_6, this);
			Model.method459(onDemandFetcher.getFileCount(0), onDemandFetcher);

			CacheUpdater.update(this, FileType.MODELS);

			// repackCacheIndex(1, false);
			// repackCacheIndex(2, false);
			// repackCacheIndex(4);

			drawSmoothLoading(65, "Unpacking music data");
			constructMusic();
			drawSmoothLoading(80, "Unpacking media");

			for (int i = 0; i < multiOverlay.length; i++) {
				multiOverlay[i] = new Sprite(mediaArchive, "overlay_multiway", i);
			}

			mapBack = new Background(mediaArchive, "mapback", 0);

			for (int j3 = 0; j3 <= 14; j3++) {
				sideIcons[j3] = new Sprite(mediaArchive, "sideicons", j3);
			}

			mapEdge = new Sprite(mediaArchive, "mapedge", 0);
			mapEdge.method345();

			try {
				for (int k3 = 0; k3 < 100; k3++) {
					mapScenes[k3] = new Background(mediaArchive, "mapscene", k3);
				}
			} catch (Exception _ex) {
			}

			try {
				for (int l3 = 0; l3 < 100; l3++) {
					if (l3 < 75) {
						mapFunctions[l3] = new Sprite(mediaArchive, "mapfunction", l3);
					} else {
						mapFunctions[l3] = new Sprite(mediaArchive, "mapfunctions2", l3 - 76);
					}
				}
			} catch (Exception _ex) {
			}

			try {
				for (int i4 = 0; i4 < 20; i4++) {
					hitMarks[i4] = new Sprite(mediaArchive, "hitmarks", i4);
				}
			} catch (Exception _ex) {
			}

			try {
				for (int j4 = 0; j4 <= 8; j4++) {
					headIcons[j4] = new Sprite(mediaArchive, "headicons_prayer", j4);
				}

				for (int j6 = 9; j6 < 18; j6++) {
					headIcons[j6] = Client.cacheSprite[j6 + 357 - 9];
				}

				for (int j45 = 0; j45 < 7; j45++) {
					skullIcons[j45] = new Sprite(mediaArchive, "headicons_pk", j45);
				}
			} catch (Exception _ex) {
			}

			mapFlag = new Sprite(mediaArchive, "mapmarker", 0);
			mapMarker = new Sprite(mediaArchive, "mapmarker", 1);

			for (int k4 = 0; k4 < 8; k4++) {
				crosses[k4] = new Sprite(mediaArchive, "cross", k4);
			}

			mapDotItem = new Sprite(mediaArchive, "mapdots", 0);
			mapDotNPC = new Sprite(mediaArchive, "mapdots", 1);
			mapDotPlayer = new Sprite(mediaArchive, "mapdots", 2);
			mapDotFriend = new Sprite(mediaArchive, "mapdots", 3);
			mapDotTeam = new Sprite(mediaArchive, "mapdots", 4);
			mapDotClan = cacheSprite[398];

			for (int j3 = 0; j3 < 12; j3++) {
				scrollPart[j3] = new Sprite(mediaArchive, "scrollpart", j3);
			}

			for (int id = 0; id < 6; id++) {
				scrollBar[id] = new Sprite(mediaArchive, "scrollbar", id);
			}

			int startId = 631;
			for (int l4 = 0; l4 < 13; l4++) {
				// modIcons[l4] = new Sprite(mediaArchive, "mod_icons", l4);
				modIcons[l4] = cacheSprite[startId++];
			}

			newSmallFont.unpackChatImages(modIcons);
			newRegularFont.unpackChatImages(modIcons);
			newBoldFont.unpackChatImages(modIcons);
			newFancyFont.unpackChatImages(modIcons);
			Sprite sprite = new Sprite(mediaArchive, "screenframe", 0);
			leftFrame = constructGraphicsBuffer(sprite.myWidth, sprite.myHeight, getGameComponent());
			sprite.method346(0, 0);
			sprite = new Sprite(mediaArchive, "screenframe", 1);
			topFrame = constructGraphicsBuffer(sprite.myWidth, sprite.myHeight, getGameComponent());
			sprite.method346(0, 0);
			sprite = new Sprite(mediaArchive, "screenframe", 2);
			rightFrame = constructGraphicsBuffer(sprite.myWidth, sprite.myHeight, getGameComponent());
			sprite.method346(0, 0);
			sprite = new Sprite(mediaArchive, "mapedge", 0);
			constructGraphicsBuffer(sprite.myWidth, sprite.myHeight, getGameComponent());
			sprite.method346(0, 0);
			compass = new Sprite(mediaArchive, "compass", 0);
			drawSmoothLoading(83, "Unpacking textures");
			Rasterizer.method368(streamLoader_3);
			Rasterizer.method372(0.80000000000000004D);
			Rasterizer.method367();
			drawSmoothLoading(86, "Unpacking config");
			Animation.load(streamLoader);
			ObjectDefinition.unpackConfig(streamLoader);
			Flo.unpackConfig(streamLoader);
			OverLayFlo317.load(streamLoader);
			ItemDefinition.unpackConfig(streamLoader);
			MobDefinition.load(streamLoader);
			IdentityKit.unpackConfig(streamLoader);
			SpotAnimDefinition.load(streamLoader);
			Varp.load(streamLoader);
			VarBit.unpackConfig(streamLoader);

			// ItemDefinition.dumpItemModelsForId(13653);
			// onDemandFetcher.dump();

			// ItemDefinition.dumpItemModelsForId(21373);

			// for (int i : Hardcode.IDS) {
			// ItemDefinition.dumpItemModelsForId(i);
			// }

			if (!isLowDetail()) {
				byte[] data = soundArchive.get("sounds.dat");
				ByteBuffer buffer = new ByteBuffer(data);
				Sound.unpack(buffer);

			}

			drawSmoothLoading(95, "Unpacking interfaces");
			TextDrawingArea[] aclass30_sub2_sub1_sub4s = { smallText, normalText, chatTextDrawingArea, aTextDrawingArea_1273 };

			try {
				RSInterface.unpack(streamLoader_1, aclass30_sub2_sub1_sub4s, mediaArchive);
			} catch (Exception e) {
			}

			drawSmoothLoading(100, "Preparing game engine");

			try {
				for (int j6 = 0; j6 < 33; j6++) {
					int k6 = 999;
					int i7 = 0;

					for (int k7 = 0; k7 < 34; k7++) {
						if (mapBack.imgPixels[k7 + j6 * mapBack.imgWidth] == 0) {
							if (k6 == 999) {
								k6 = k7;
							}

							continue;
						}

						if (k6 == 999) {
							continue;
						}

						i7 = k7;
						break;
					}

					compassArray1[j6] = k6;
					compassArray2[j6] = i7 - k6;
				}

				for (int l6 = 4; l6 < 157; l6++) {
					int j7 = 999;
					int l7 = 0;

					for (int j8 = 20; j8 < 172; j8++) {
						if (mapBack.imgPixels[j8 + l6 * mapBack.imgWidth] == 0 && (j8 > 34 || l6 > 34)) {
							if (j7 == 999) {
								j7 = j8;
							}

							continue;
						}

						if (j7 == 999) {
							continue;
						}

						l7 = j8;
						break;
					}

					mapImagePixelCutLeft[l6 - 4] = j7 - 20;
					mapImagePixelCutRight[l6 - 4] = l7 - j7;

					if (mapImagePixelCutRight[l6 - 4] == -20) {
						mapImagePixelCutRight[l6 - 4] = 152;
					}
				}
			} catch (Exception _ex) {
			}

			updateGameArea();
			Censor.loadConfig(streamLoader_4);
			mouseDetection = new MouseDetection(this);
			startRunnable(mouseDetection, 10);
			Animable_Sub5.clientInstance = this;
			ObjectDefinition.clientInstance = this;
			MobDefinition.clientInstance = this;
			isLoading = false;
			// onDemandFetcher.dump();
			loadPlayerData();
			// onDemandFetcher.dump();
			return;
		} catch (Exception exception) {
			isLoading = false;
			exception.printStackTrace();
			Signlink.reportError("loaderror " + startupMessage + " " + anInt1079);
		}

		loadingError = true;
	}

	public void dumpArchive(int archive) {
		int[] ids = new int[] {};
		for (int i : ids) {
			try {
				byte abyte[] = decompressors[archive].decompress(onDemandFetcher.getModelIndex(i));
				File map = new File(Signlink.getCacheDirectory() + "/itemdata/" + onDemandFetcher.getModelIndex(i) + ".gz");
				FileOutputStream fos = new FileOutputStream(map);
				fos.write(abyte);
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	private void stopMidi() {
		// Signlink.midifade = 0;
		// Signlink.midi = "stop";
	}

	private void tabToReplyPm() {
		String name = null;

		for (int k = 0; k < 100; k++) {
			if (chatMessages[k] == null) {
				continue;
			}

			int l = chatTypes[k];

			if (l == 3 || l == 7) {
				name = chatNames[k];
				break;
			}
		}

		if (name == null) {
			pushMessage("You haven't received any messages to which you can reply.", 0, "");
			return;
		}

		if (name != null) {
			if (name.indexOf("@") == 0) {
				name = name.substring(5);
			}
		}

		long nameAsLong = TextClass.longForName(name.trim());

		if (nameAsLong != -1) {
			inputTaken = true;
			inputDialogState = 0;
			messagePromptRaised = true;
			promptInput = "";
			friendsListAction = 3;
			aLong953 = nameAsLong;
			promptMessage = "Enter message to send to " + TextClass.fixName(TextClass.nameForLong(nameAsLong));
		}
	}

	private void updateScreen() {
		gameAreaWidth = GameFrame.isFixed() ? 512 : getScreenWidth();
		gameAreaHeight = GameFrame.isFixed() ? 334 : getScreenHeight();
		if (gameScreenIP == null || gameScreenIP.width != gameAreaWidth || gameScreenIP.height != gameAreaHeight) {
			gameScreenIP = constructGraphicsBuffer(gameAreaWidth, gameAreaHeight, getGameComponent());
		}
		updateGameArea();
		updateGraphics(false);
	}

	public void setResizing(boolean resizing) {
		if (resizing) {
			this.resizing = true;
			if (loggedIn) {
				if (gameScreenIP != null) {
					gameScreenIP.initDrawingArea();
				}
			} else {
				if (titleScreenIP != null) {
					titleScreenIP.initDrawingArea();
				}
			}
		} else {
			this.resizing = false;
			if (loggedIn) {
				if (gameScreenIP != null) {
					gameScreenIP.drawGraphics(gameScreenDrawY, graphics, GameFrame.isFixed() ? 4 : gameScreenDrawX);
				}
			} else {
				if (titleScreenIP != null) {
					titleScreenIP.drawGraphics(gameScreenDrawY, graphics, GameFrame.isFixed() ? 4 : gameScreenDrawX);
				}
			}
		}
	}

	public void toggleSize(ScreenMode mode) {
		try {

			if (GameFrame.getScreenMode() != mode) {
				setResizing(true);
				super.setClickMode2(0);
				if (mode == ScreenMode.FIXED) {
					GameFrame.setScreenMode(mode);
					gameScreenDrawX = 4;
					gameScreenDrawY = 4;
					forceWidth = clientWidth = REGULAR_WIDTH;
					forceHeight = clientHeight = REGULAR_HEIGHT;
					sendFrame36(652, 0);
					recreateClientFrame(false, 765, 503, false, 1, false);
					if (jFrame != null) {
						jFrame.resize(mode);
					}
					welcomeScreenRaised = true;
				} else if (mode == ScreenMode.RESIZABLE) {
					GameFrame.setScreenMode(mode);
					gameScreenDrawX = 0;
					gameScreenDrawY = 0;
					forceWidth = forceHeight = -1;
					if (jFrame != null) {
						jFrame.resize(mode);
					}
					sendFrame36(652, 2);
					recreateClientFrame(false, RESIZABLE_WIDTH, RESIZABLE_HEIGHT, true, 0, true);
				} else {
					GameFrame.setScreenMode(ScreenMode.FULLSCREEN);
					gameScreenDrawX = 0;
					gameScreenDrawY = 0;
					sendFrame36(652, 1);
					Dimension size = Toolkit.getDefaultToolkit().getScreenSize();
					clientWidth = size.width;
					clientHeight = size.height;
					recreateClientFrame(true, size.width, size.height, false, 0, true);
					forceWidth = forceHeight = -1;
					super.myWidth = size.width;
					super.myHeight = size.height;
				}

				if (mode == ScreenMode.FIXED) {
					inputTaken = true;
				}

				clientZoom = 0;

				if (!loggedIn) {
					resetImageProducers();
				} else {
					resetImageProducers2();
				}
				chatArea.setHideComponent(false);
				tabArea.setHideComponent(false);
				updateScreen();

				setResizing(false);
				System.gc();
				System.runFinalization();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void unlinkMRUNodes() {
		ObjectDefinition.mruNodes1.unlinkAll();
		ObjectDefinition.mruNodes2.unlinkAll();
		MobDefinition.mruNodes.unlinkAll();
		ItemDefinition.mruNodes2.unlinkAll();
		ItemDefinition.mruNodes1.unlinkAll();
		Player.mruNodes.unlinkAll();
		SpotAnimDefinition.list.unlinkAll();
	}

	private void updateConfig(int configId) {
		try {
			int j = Varp.getCache()[configId].getAnInt709();

			// System.out.println("config id: " + configId + " ; value: " + j);

			if (j == 0) {
				return;
			}

			int k = variousSettings[configId];

			if (j == 1) {
				if (k == 1) {
					Rasterizer.method372(0.90000000000000002D);
				} else if (k == 2) {
					Rasterizer.method372(0.80000000000000004D);
				} else if (k == 3) {
					Rasterizer.method372(0.69999999999999996D);
				} else if (k == 4) {
					Rasterizer.method372(0.59999999999999998D);
				}

				ItemDefinition.mruNodes1.unlinkAll();
				welcomeScreenRaised = true;
			} else if (j == 3) {
				int volume = 0;

				if (k == 0) {
					volume = 255;
				} else if (k == 1) {
					volume = 192;
				} else if (k == 2) {
					volume = 128;
				} else if (k == 3) {
					volume = 64;
				} else if (k == 4) {
					volume = 0;
				}

				if (volume != musicVolume) {
					if (musicVolume != 0 || currentSong == -1) {
						if (volume != 0) {
							setVolume(volume);
						} else {
							method55(false);
							prevSong = 0;
						}
					} else {
						method56(volume, false, currentSong);
						prevSong = 0;
					}

					musicVolume = volume;
				}
			} else if (j == 4) {
				if (k == 0) {
					soundEffectVolume = 127;
				} else if (k == 1) {
					soundEffectVolume = 96;
				} else if (k == 2) {
					soundEffectVolume = 64;
				} else if (k == 3) {
					soundEffectVolume = 32;
				} else if (k == 4) {
					soundEffectVolume = 0;
				}
			} else if (j == 5) {
				anInt1253 = k;
			} else if (j == 6) {
				anInt1249 = k;
			} else if (j == 7) {
				running = !running;
				final boolean run = running;
				getMapArea().run.setOrbState(run);
			} else if (j == 8) {
				splitPrivateChat = k;
				inputTaken = true;
			} else if (j == 9) {
				anInt913 = k;
			}
		} catch (Exception e) {
		}
	}

	private void updateEntities() {

		try {
			int anInt974 = 0;
			for (int j = -1; j < playerCount + npcCount; j++) {
				Object obj;
				if (j == -1) {
					obj = myPlayer;
				} else if (j < playerCount) {
					obj = playerArray[playerIndices[j]];
				} else {
					obj = npcArray[npcIndices[j - playerCount]];
				}
				if (obj == null || !((Entity) obj).isVisible()) {
					continue;
				}
				if (obj instanceof NPC) {
					MobDefinition entityDef = ((NPC) obj).definitionOverride;
					if (entityDef.childrenIDs != null) {
						entityDef = entityDef.method161();
					}
					if (entityDef == null) {
						continue;
					}
				}
				if (j < playerCount) {
					int l = getConfig().getStatus(ConfigType.HP_ABOVE_HEAD) || getConfig().getStatus(ConfigType.NAMES_ABOVE_HEAD) ? 42 : 32;
					if (getConfig().getStatus(ConfigType.HP_ABOVE_HEAD)) {
						l += 20;
					}
					if (getConfig().getStatus(ConfigType.NAMES_ABOVE_HEAD)) {
						l += 10;
					}
					Player player = (Player) obj;
					if (player.headIcon >= 0) {
						npcScreenPos((Entity) obj, ((Entity) obj).height + 15);
						if (spriteDrawX > -1) {
							if (player.skullIcon < 7) {
								skullIcons[player.skullIcon].drawSprite(spriteDrawX - 12, spriteDrawY - l);
								l += 25;
							}
							if (player.headIcon < 18) {
								headIcons[player.headIcon].drawSprite(spriteDrawX - 12, spriteDrawY - l);
								l += 18;
							}
							if (getConfig().getStatus(ConfigType.NAMES_ABOVE_HEAD)) {
								newSmallFont.drawCenteredString("{" + (player.name != null ? player.name : "null username") + "}", spriteDrawX, spriteDrawY - 10, 0x15FF00, 0x000000);
							}
						}
					}
					if (j >= 0 && anInt855 == 10 && anInt933 == playerIndices[j]) {
						npcScreenPos((Entity) obj, ((Entity) obj).height + 15);
						if (spriteDrawX > -1) {
							headIcons[7].drawSprite(spriteDrawX - 12, spriteDrawY - l);
						}
					}
				} else {
					MobDefinition entityDef_1 = ((NPC) obj).definitionOverride;
					if (entityDef_1.headIcon >= 0 && entityDef_1.headIcon < headIcons.length) {
						npcScreenPos((Entity) obj, ((Entity) obj).height + 15);
						if (spriteDrawX > -1) {
							headIcons[entityDef_1.headIcon].drawSprite(spriteDrawX - 12, spriteDrawY - 30);
						}
					}
					if (anInt855 == 1 && anInt1222 == npcIndices[j - playerCount] && loopCycle % 20 < 10) {
						npcScreenPos((Entity) obj, ((Entity) obj).height + 15);
						if (spriteDrawX > -1) {
							headIcons[2].drawSprite(spriteDrawX - 12, spriteDrawY - 28);
						}
					}
				}
				if (((Entity) obj).textSpoken != null && (j >= playerCount || publicChatMode == 0 || publicChatMode == 3 || publicChatMode == 1 && isFriendOrSelf(((Player) obj).name))) {
					npcScreenPos((Entity) obj, ((Entity) obj).height);
					if (spriteDrawX > -1 && anInt974 < anInt975) {
						anIntArray979[anInt974] = chatTextDrawingArea.method384(((Entity) obj).textSpoken) / 2;
						anIntArray978[anInt974] = chatTextDrawingArea.anInt1497;
						anIntArray976[anInt974] = spriteDrawX;
						anIntArray977[anInt974] = spriteDrawY;
						anIntArray980[anInt974] = ((Entity) obj).anInt1513;
						anIntArray981[anInt974] = ((Entity) obj).anInt1531;
						anIntArray982[anInt974] = ((Entity) obj).textCycle;
						aStringArray983[anInt974++] = ((Entity) obj).textSpoken;
						if (anInt1249 == 0 && ((Entity) obj).anInt1531 >= 1 && ((Entity) obj).anInt1531 <= 3) {
							anIntArray978[anInt974] += 10;
							anIntArray977[anInt974] += 5;
						}
						if (anInt1249 == 0 && ((Entity) obj).anInt1531 == 4) {
							anIntArray979[anInt974] = 60;
						}
						if (anInt1249 == 0 && ((Entity) obj).anInt1531 == 5) {
							anIntArray978[anInt974] += 5;
						}
					}
				}
				if (((Entity) obj).loopCycleStatus > loopCycle) {

					try {
						npcScreenPos((Entity) obj, ((Entity) obj).height + 15);
						if (spriteDrawX > -1) {
							if (config.getStatus(ConfigType.NEW_HITBARS)) {
								int i1 = ((Entity) obj).currentHealth * 30 / ((Entity) obj).maxHealth;
								if (i1 > 30) {
									i1 = 30;
								}
								int hpPercent = ((Entity) obj).currentHealth * 90 / ((Entity) obj).maxHealth;
								if (hpPercent > 90) {
									hpPercent = 90;
								}
								int HpPercent = ((Entity) obj).currentHealth * 56 / ((Entity) obj).maxHealth;
								if (HpPercent > 56) {
									HpPercent = 56;
								}

								if ((Entity) obj != null && ((Entity) obj).maxHealth >= 250) {
									cacheSprite[396].drawSprite(spriteDrawX - 44, spriteDrawY - 5);
									Sprite HPBarFull = Sprite.getCutted(cacheSprite[397], (int) (HpPercent * 1.615), cacheSprite[397].maxHeight);
									HPBarFull.drawSprite(spriteDrawX - 44, spriteDrawY - 5);
									HPBarFull = null;
								} else {
									cacheSprite[349].drawSprite(spriteDrawX - 28, spriteDrawY - 5);
									Sprite HPBarFull = Sprite.getCutted(cacheSprite[348], HpPercent, cacheSprite[348].maxHeight);
									HPBarFull.drawSprite(spriteDrawX - 28, spriteDrawY - 5);
									HPBarFull = null;
								}
							} else {

								int i1 = ((Entity) obj).currentHealth * 30 / ((Entity) obj).maxHealth;
								if (i1 > 30) {
									i1 = 30;
								}
								DrawingArea.drawPixels(5, spriteDrawY - 3, spriteDrawX - 15, 65280, i1);
								DrawingArea.drawPixels(5, spriteDrawY - 3, spriteDrawX - 15 + i1, 0xff0000, 30 - i1);
							}
							Entity o = (Entity) obj;
							double currentHitpoints = o.currentHealth * (config.getStatus(ConfigType.X10_DAMAGE) ? 10 : 1);
							double maxHitpoints = o.maxHealth * (config.getStatus(ConfigType.X10_DAMAGE) ? 10 : 1);
							double percentage = (int) ((currentHitpoints / maxHitpoints * 100) * 1.23);
							if (config.getStatus(ConfigType.DISPLAY_COMBAT_OVERLAY)) {
								boolean display = false;
								if (interactingWith != null && o == interactingWith) {
									/*
									 * Draw the background
									 */
									DrawingArea.drawAlphaPixels(0, 17, 125, 45, 0x000000, 100);
									String name = "null";
									if (o instanceof Player) {
										name = ((Player) o).name;
									} else if (o instanceof NPC) {
										MobDefinition entityDef_1 = ((NPC) obj).definitionOverride;
										if (entityDef_1 != null)
											name = entityDef_1.name;
									}
									newRegularFont.drawCenteredString(name, 62, 29, 0xFFFFFF, 0);
									int i1 = ((Entity) obj).currentHealth * 30 / ((Entity) obj).maxHealth;
									if (i1 > 30) {
										i1 = 30;
									}
									if (percentage > 123) {
										percentage = 123;
									}
									DrawingArea.drawAlphaPixels(1, 34, 123, 15, 0xC0303E, 130);
									DrawingArea.drawAlphaPixels(1, 34, (int) percentage, 15, 0x00A000, 170);
									newRegularFont.drawCenteredString((int) currentHitpoints + "/" + (int) maxHitpoints, 62, 47, 0xFFFFFF, 0);
									display = false;
								}
								if (display)
									newRegularFont.drawCenteredString(myPlayer.name, 30, 61, 0xFFFFFF, 0);

							}
							if (config.getStatus(ConfigType.HP_ABOVE_HEAD)) {
								int color = calculateHitpointsColor((int) Math.round(percentage));
								newRegularFont.drawCenteredString(new StringBuilder().append((int) currentHitpoints).append("/").append((int) maxHitpoints).toString(), spriteDrawX, spriteDrawY - 22,
										color, 0x000000);
							}
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
				/**
				 * Hitmarks
				 */
				for (int j1 = 0; j1 < 4; j1++) {
					if (((Entity) obj).hitsLoopCycle[j1] > loopCycle) {
						Entity entity = (Entity) obj;
						npcScreenPos(entity, entity.height / 2);
						if (spriteDrawX > -1) {
							if (!config.getStatus(ConfigType.HITMARKS)) {
								if (j1 == 1) {
									spriteDrawY -= 20;
								}
								if (j1 == 2) {
									spriteDrawX -= 15;
									spriteDrawY -= 10;
								}
								if (j1 == 3) {
									spriteDrawX += 15;
									spriteDrawY -= 10;
								}
								if (entity.hitArray[j1] < 1) {
									// damage is 0
									entity.hitMarkTypes[j1] = 0;
								} else if (entity.hitMarkTypes[j1] == 2) {
									// critical hit is normal hit
									entity.hitMarkTypes[j1] = 1;
								}
								if (entity.hitMarkTypes[j1] < 3) {
									// not a poison mask so we choose our hit
									cacheSprite[399 + entity.hitMarkTypes[j1]].drawSprite(spriteDrawX - 12, spriteDrawY - 12);
								} else {
									// poison and curse mask
									hitMarks[entity.hitMarkTypes[j1] - 1].drawSprite(spriteDrawX - 12, spriteDrawY - 12);
								}
								smallText.drawText(0, String.valueOf(entity.hitArray[j1]), spriteDrawY + 4, spriteDrawX);
								smallText.drawText(0xffffff, String.valueOf(entity.hitArray[j1]), spriteDrawY + 3, spriteDrawX - 1);
							} else {
								switch (j1) {
								case 1:
									spriteDrawY += 20;
									break;
								case 2:
									spriteDrawY += 25;
									break;
								case 3:
									spriteDrawY += 45;
									break;
								}
								Entity e = (Entity) obj;
								if (e.hitmarkMove[j1] > -30) {
									e.hitmarkMove[j1]--;
									if (e.hitmarkTrans[j1] > 0) {
										e.hitmarkTrans[j1] -= 5;
									}
									hitmarkDraw(e, String.valueOf(e.hitArray[j1]).length(), e.hitMarkTypes[j1], e.hitIcon[j1], e.hitArray[j1], e.hitmarkMove[j1], e.hitmarkTrans[j1]);
								}
							}
						}
					}
				}
			}

			for (int k = 0; k < anInt974; k++) {
				int k1 = anIntArray976[k];
				int l1 = anIntArray977[k];
				int j2 = anIntArray979[k];
				int k2 = anIntArray978[k];
				boolean flag = true;

				while (flag) {
					flag = false;

					for (int l2 = 0; l2 < k; l2++) {
						if (l1 + 2 > anIntArray977[l2] - anIntArray978[l2] && l1 - k2 < anIntArray977[l2] + 2 && k1 - j2 < anIntArray976[l2] + anIntArray979[l2]
								&& k1 + j2 > anIntArray976[l2] - anIntArray979[l2] && anIntArray977[l2] - anIntArray978[l2] < l1) {
							l1 = anIntArray977[l2] - anIntArray978[l2];
							flag = true;
						}
					}
				}

				spriteDrawX = anIntArray976[k];
				spriteDrawY = anIntArray977[k] = l1;
				String s = aStringArray983[k];

				if (anInt1249 == 0) {
					int i3 = 0xffff00;

					if (anIntArray980[k] < 6) {
						i3 = anIntArray965[anIntArray980[k]];
					}

					if (anIntArray980[k] == 6) {
						i3 = anInt1265 % 20 >= 10 ? 0xffff00 : 0xff0000;
					}

					if (anIntArray980[k] == 7) {
						i3 = anInt1265 % 20 >= 10 ? 65535 : 255;
					}

					if (anIntArray980[k] == 8) {
						i3 = anInt1265 % 20 >= 10 ? 0x80ff80 : 45056;
					}

					if (anIntArray980[k] == 9) {
						int j3 = 150 - anIntArray982[k];

						if (j3 < 50) {
							i3 = 0xff0000 + 1280 * j3;
						} else if (j3 < 100) {
							i3 = 0xffff00 - 0x50000 * (j3 - 50);
						} else if (j3 < 150) {
							i3 = 65280 + 5 * (j3 - 100);
						}
					}

					if (anIntArray980[k] == 10) {
						int k3 = 150 - anIntArray982[k];

						if (k3 < 50) {
							i3 = 0xff0000 + 5 * k3;
						} else if (k3 < 100) {
							i3 = 0xff00ff - 0x50000 * (k3 - 50);
						} else if (k3 < 150) {
							i3 = 255 + 0x50000 * (k3 - 100) - 5 * (k3 - 100);
						}
					}

					if (anIntArray980[k] == 11) {
						int l3 = 150 - anIntArray982[k];

						if (l3 < 50) {
							i3 = 0xffffff - 0x50005 * l3;
						} else if (l3 < 100) {
							i3 = 65280 + 0x50005 * (l3 - 50);
						} else if (l3 < 150) {
							i3 = 0xffffff - 0x50000 * (l3 - 100);
						}
					}

					if (anIntArray981[k] == 0) {
						chatTextDrawingArea.drawText(0, s, spriteDrawY + 1, spriteDrawX + 1);
						chatTextDrawingArea.drawText(i3, s, spriteDrawY, spriteDrawX);
					}

					if (anIntArray981[k] == 1) {
						chatTextDrawingArea.method386(0, s, spriteDrawX + 1, anInt1265, spriteDrawY + 1);
						chatTextDrawingArea.method386(i3, s, spriteDrawX, anInt1265, spriteDrawY);
					}

					if (anIntArray981[k] == 2) {
						chatTextDrawingArea.method387(spriteDrawX + 1, s, anInt1265, spriteDrawY + 1, 0);
						chatTextDrawingArea.method387(spriteDrawX, s, anInt1265, spriteDrawY, i3);
					}

					if (anIntArray981[k] == 3) {
						chatTextDrawingArea.method388(150 - anIntArray982[k], s, anInt1265, spriteDrawY + 1, spriteDrawX + 1, 0);
						chatTextDrawingArea.method388(150 - anIntArray982[k], s, anInt1265, spriteDrawY, spriteDrawX, i3);
					}

					if (anIntArray981[k] == 4) {
						int i4 = chatTextDrawingArea.method384(s);
						int k4 = (150 - anIntArray982[k]) * (i4 + 100) / 150;
						DrawingArea.setBounds(spriteDrawX - 50, 0, spriteDrawX + 50, 334);
						chatTextDrawingArea.method385(0, s, spriteDrawY + 1, spriteDrawX + 51 - k4);
						chatTextDrawingArea.method385(i3, s, spriteDrawY, spriteDrawX + 50 - k4);
						DrawingArea.defaultDrawingAreaSize();
					}

					if (anIntArray981[k] == 5) {
						int j4 = 150 - anIntArray982[k];
						int l4 = 0;

						if (j4 < 25) {
							l4 = j4 - 25;
						} else if (j4 > 125) {
							l4 = j4 - 125;
						}

						DrawingArea.setBounds(0, spriteDrawY - chatTextDrawingArea.anInt1497 - 1, 512, spriteDrawY + 5);
						chatTextDrawingArea.drawText(0, s, spriteDrawY + 1 + l4, spriteDrawX + 1);
						chatTextDrawingArea.drawText(i3, s, spriteDrawY + l4, spriteDrawX);
						DrawingArea.defaultDrawingAreaSize();
					}
				} else {
					chatTextDrawingArea.drawText(0, s, spriteDrawY + 1, spriteDrawX + 1);
					chatTextDrawingArea.drawText(0xffff00, s, spriteDrawY, spriteDrawX);
				}
			}
		} catch (Exception e) {
		}
	}

	private int calculateHitpointsColor(int percentage) {
		int[] colorArray = new int[] { 0x01DF01, 0x3ADF00, 0x74DF00, 0xA5DF00, 0xD7DF01, 0xDBA901, 0xDF7401, 0xDF3A01, 0xFA5858, 0xFE2E2E, 0xDF0101, };
		int color = colorArray[0];
		for (int i = 0; i < colorArray.length; i++) {
			if (percentage >= 100 - i * 10) {
				color = colorArray[i];
				break;
			}
		}
		return color;
	}

	public void updateGameArea() {
		try {
			Rasterizer.setBounds(getScreenWidth(), getScreenHeight());
			fullScreenTextureArray = Rasterizer.lineOffsets;
			Rasterizer.setBounds(GameFrame.getScreenMode() == ScreenMode.FIXED && isGameFrameVisible() ? chatAreaIP != null ? chatAreaIP.width : 519 : getScreenWidth(),
					GameFrame.getScreenMode() == ScreenMode.FIXED && isGameFrameVisible() ? chatAreaIP != null ? chatAreaIP.height : 165 : getScreenHeight());
			anIntArray1180 = Rasterizer.lineOffsets;
			Rasterizer.setBounds(GameFrame.getScreenMode() == ScreenMode.FIXED && isGameFrameVisible() ? tabAreaIP != null ? tabAreaIP.width : 346 : getScreenWidth(),
					GameFrame.getScreenMode() == ScreenMode.FIXED && isGameFrameVisible() ? tabAreaIP != null ? tabAreaIP.height : 335 : getScreenHeight());
			anIntArray1181 = Rasterizer.lineOffsets;
			Rasterizer.setBounds(gameAreaWidth, gameAreaHeight);
			anIntArray1182 = Rasterizer.lineOffsets;
			int ai[] = new int[9];

			for (int i8 = 0; i8 < 9; i8++) {
				int k8 = 128 + i8 * 32 + 15;
				int l8 = 600 + k8 * 3;
				int i9 = Rasterizer.SINE[k8];
				ai[i8] = l8 * i9 >> 16;
			}

			WorldController.method310(500, 800, !loggedIn ? getScreenWidth() : gameAreaWidth, !loggedIn ? getScreenHeight() : gameAreaHeight, ai);

			if (loggedIn) {
				gameScreenIP = constructGraphicsBuffer(gameAreaWidth, gameAreaHeight, getGameComponent());
			} else {
				titleScreenIP = constructGraphicsBuffer(getScreenWidth(), getScreenHeight(), getGameComponent());
			}
			updateGraphics(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void updateNPCs(ByteBuffer buffer, int i) {
		anInt839 = 0;
		anInt893 = 0;
		method139(buffer);
		method46(i, buffer);
		method86(buffer);

		for (int k = 0; k < anInt839; k++) {
			int l = anIntArray840[k];

			if (npcArray[l].anInt1537 != loopCycle) {
				npcArray[l].definitionOverride = null;
				npcArray[l] = null;
			}
		}

		if (buffer.position != i) {
			Signlink.reportError(getMyUsername() + " size mismatch in getnpcpos - pos:" + buffer.position + " psize:" + i);
			throw new RuntimeException("eek");
		}

		for (int i1 = 0; i1 < npcCount; i1++) {
			if (npcArray[npcIndices[i1]] == null) {
				Signlink.reportError(getMyUsername() + " null entry in npc list - pos:" + i1 + " size:" + npcCount);
				throw new RuntimeException("eek");
			}
		}
	}

	private void updatePlayers(int i, ByteBuffer buffer) {
		anInt839 = 0;
		anInt893 = 0;
		processMovementBuffer(buffer);
		method134(buffer);
		method91(buffer, i);
		method49(buffer);

		for (int k = 0; k < anInt839; k++) {
			int l = anIntArray840[k];

			if (playerArray[l].anInt1537 != loopCycle) {
				playerArray[l] = null;
			}
		}

		if (buffer.position != i) {
			Signlink.reportError("Error packet size mismatch in getplayer pos:" + buffer.position + " psize:" + i);
			throw new RuntimeException("eek");
		}

		for (int i1 = 0; i1 < playerCount; i1++) {
			if (playerArray[playerIndices[i1]] == null) {
				Signlink.reportError(getMyUsername() + " null entry in pl list - pos:" + i1 + " size:" + playerCount);
				throw new RuntimeException("eek");
			}
		}

	}

	private void updateSkillInterface(int id) {
		switch (id) {
		case 0:// attack
			setInterfaceText(currentStats[0] + "", 31114);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[0]) + "", 31115);
			break;

		case 1:// defence
			setInterfaceText(currentStats[1] + "", 31124);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[1]) + "", 31125);
			break;

		case 2:// strength
			setInterfaceText(currentStats[2] + "", 31119);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[2]) + "", 31120);
			break;

		case 3:// hitpoints
			setInterfaceText(currentStats[3] + "", 31159);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[3]) + "", 31160);
			break;

		case 4:// ranged
			setInterfaceText(currentStats[4] + "", 31129);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[4]) + "", 31130);
			break;

		case 5:// prayer
			setInterfaceText(currentStats[5] + "", 31134);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[5]) + "", 31135);
			break;

		case 6:// magic
			setInterfaceText(currentStats[6] + "", 31139);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[6]) + "", 31140);
			break;

		case 7:// cooking
			setInterfaceText(currentStats[7] + "", 31219);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[7]) + "", 31220);
			break;

		case 8:// woodcutting
			setInterfaceText(currentStats[8] + "", 31229);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[8]) + "", 31230);
			break;

		case 9:// fletching
			setInterfaceText(currentStats[9] + "", 31184);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[9]) + "", 31185);
			break;

		case 10:// fishing
			setInterfaceText(currentStats[10] + "", 31214);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[10]) + "", 31215);
			break;

		case 11:// firemaking
			setInterfaceText(currentStats[11] + "", 31224);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[11]) + "", 31225);
			break;

		case 12:// crafting
			setInterfaceText(currentStats[12] + "", 31179);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[12]) + "", 31180);
			break;

		case 13:// smithing
			setInterfaceText(currentStats[13] + "", 31209);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[13]) + "", 31210);
			break;

		case 14:// mining
			setInterfaceText(currentStats[14] + "", 31204);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[14]) + "", 31205);
			break;

		case 15:// herblore
			setInterfaceText(currentStats[15] + "", 31169);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[15]) + "", 31170);
			break;

		case 16:// agility
			setInterfaceText(currentStats[16] + "", 31164);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[16]) + "", 31165);
			break;

		case 17:// thieving
			setInterfaceText(currentStats[17] + "", 31174);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[17]) + "", 31175);
			break;

		case 18:// slayer
			setInterfaceText(currentStats[18] + "", 31189);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[18]) + "", 31190);
			break;

		case 19:// farming
			setInterfaceText(currentStats[19] + "", 31234);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[19]) + "", 31235);
			break;

		case 20:// runecrafating
			setInterfaceText(currentStats[20] + "", 31144);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[20]) + "", 31145);
			break;

		/*
		 * case 21:// dungeoneering setInterfaceText(currentStats[21] + "",
		 * 31154); setInterfaceText(getLevelForXP(currentExp[21]) + "", 31155);
		 * setInterfaceText("Exp: " + currentExp[21] + "", 31153); break;
		 *
		 * case 22:// hunter setInterfaceText(currentStats[22] + "", 31194);
		 * setInterfaceText(getLevelForXP(currentExp[22]) + "", 31195);
		 * setInterfaceText("Exp: " + currentExp[22] + "", 31193); break;
		 */

		case 23:// summoning
			setInterfaceText(currentStats[23] + "", 31239);
			setInterfaceText(PlayerHandler.getLevelForXP(currentExp[23]) + "", 31240);
			break;

		/*
		 * case 24:// construction setInterfaceText(currentStats[24] + "",
		 * 31149); setInterfaceText(getLevelForXP(currentExp[24]) + "", 31150);
		 * setInterfaceText("Exp: " + currentExp[24] + "", 31148); break;
		 */
		}

		setInterfaceText("Total Level:", 31199);
		setInterfaceText(formatValue(PlayerHandler.getTotalLevel(this), 0), 31200);
	}

	private void updateStrings(String str, int i) {
		switch (i) {
		case 1675:
			setInterfaceText(str, 17508);
			break;// Stab

		case 1676:
			setInterfaceText(str, 17509);
			break;// Slash

		case 1677:
			setInterfaceText(str, 17510);
			break;// Cursh

		case 1678:
			setInterfaceText(str, 17511);
			break;// Magic

		case 1679:
			setInterfaceText(str, 17512);
			break;// Range

		case 1680:
			setInterfaceText(str, 17513);
			break;// Stab

		case 1681:
			setInterfaceText(str, 17514);
			break;// Slash

		case 1682:
			setInterfaceText(str, 17515);
			break;// Crush

		case 1683:
			setInterfaceText(str, 17516);
			break;// Magic

		case 1684:
			setInterfaceText(str, 17517);
			break;// Range

		case 1686:
			setInterfaceText(str, 17518);
			break;// Strength

		case 1687:
			setInterfaceText(str, 17519);
		}
	}

	public String getLoginMessage1() {
		return loginMessage1;
	}

	public void setLoginMessage1(String loginMessage1) {
		this.loginMessage1 = loginMessage1;
	}

	public String getLoginMessage2() {
		return loginMessage2;
	}

	public void setLoginMessage2(String loginMessage2) {
		this.loginMessage2 = loginMessage2;
	}

	public Connection getConnection() {
		return connection;
	}

	public void setConnection(Connection connection) {
		this.connection = connection;
	}

	public int getLoginState() {
		return loginState;
	}

	public void setLoginState(int loginState) {
		this.loginState = loginState;
	}

	public int getLoginScreenState() {
		return loginScreenState;
	}

	public void setLoginScreenState(int loginScreenState) {
		this.loginScreenState = loginScreenState;
	}

	public int getLoginScreenCursorPos() {
		return loginScreenCursorPos;
	}

	public void setLoginScreenCursorPos(int loginScreenCursorPos) {
		this.loginScreenCursorPos = loginScreenCursorPos;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public ByteBuffer getInputBuffer() {
		return inputBuffer;
	}

	public void setInputBuffer(ByteBuffer inputBuffer) {
		this.inputBuffer = inputBuffer;
	}

	public long getServerSeed() {
		return serverSeed;
	}

	public void setServerSeed(long serverSeed) {
		this.serverSeed = serverSeed;
	}

	public static ByteBuffer getOut() {
		return out;
	}

	public static void setOut(ByteBuffer out) {
		Client.out = out;
	}

	public ByteBuffer getLoginBuffer() {
		return loginBuffer;
	}

	public void setLoginBuffer(ByteBuffer loginBuffer) {
		this.loginBuffer = loginBuffer;
	}

	public static boolean isLowDetail() {
		return lowDetail;
	}

	public static void setLowDetail(boolean lowDetail) {
		Client.lowDetail = lowDetail;
	}

	public ISAACCipher getConnectionCipher() {
		return connectionCipher;
	}

	public void setConnectionCipher(ISAACCipher connectionCipher) {
		this.connectionCipher = connectionCipher;
	}

	public int getLoginFailures() {
		return loginFailures;
	}

	public void setLoginFailures(int loginFailures) {
		this.loginFailures = loginFailures;
	}

	public static int getAnInt1226() {
		return anInt1226;
	}

	public static void setAnInt1226(int anInt1226) {
		Client.anInt1226 = anInt1226;
	}

	public static int getAnInt1155() {
		return anInt1155;
	}

	public static void setAnInt1155(int anInt1155) {
		Client.anInt1155 = anInt1155;
	}

	public static int getAnInt1188() {
		return anInt1188;
	}

	public static void setAnInt1188(int anInt1188) {
		Client.anInt1188 = anInt1188;
	}

	public static int getAnInt924() {
		return anInt924;
	}

	public static void setAnInt924(int anInt924) {
		Client.anInt924 = anInt924;
	}

	public static int getAnInt1288() {
		return anInt1288;
	}

	public static void setAnInt1288(int anInt1288) {
		Client.anInt1288 = anInt1288;
	}

	public static int getAnInt986() {
		return anInt986;
	}

	public static void setAnInt986(int anInt986) {
		Client.anInt986 = anInt986;
	}

	public static int getAnInt1134() {
		return anInt1134;
	}

	public static void setAnInt1134(int anInt1134) {
		Client.anInt1134 = anInt1134;
	}

	public static int getAnInt1175() {
		return anInt1175;
	}

	public static void setAnInt1175(int anInt1175) {
		Client.anInt1175 = anInt1175;
	}

	public int getWalkableInterface() {
		return walkableInterface;
	}

	public void setWalkableInterface(int walkableInterface) {
		this.walkableInterface = walkableInterface;
	}

	public int getAnInt900() {
		return anInt900;
	}

	public void setAnInt900(int anInt900) {
		this.anInt900 = anInt900;
	}

	public int getFullscreenInterfaceID() {
		return fullscreenInterfaceID;
	}

	public void setFullscreenInterfaceID(int fullscreenInterfaceID) {
		this.fullscreenInterfaceID = fullscreenInterfaceID;
	}

	public Deque getaClass19_1179() {
		return aClass19_1179;
	}

	public void setaClass19_1179(Deque aClass19_1179) {
		this.aClass19_1179 = aClass19_1179;
	}

	public int getAnInt985() {
		return anInt985;
	}

	public void setAnInt985(int anInt985) {
		this.anInt985 = anInt985;
	}

	public int getMyPlayerIndex() {
		return myPlayerIndex;
	}

	public Deque getaClass19_1013() {
		return aClass19_1013;
	}

	public void setaClass19_1013(Deque aClass19_1013) {
		this.aClass19_1013 = aClass19_1013;
	}

	public ByteBuffer[] getaStreamArray895s() {
		return aStreamArray895s;
	}

	public void setaStreamArray895s(ByteBuffer[] aStreamArray895s) {
		this.aStreamArray895s = aStreamArray895s;
	}

	public int getMaxPlayers() {
		return maxPlayers;
	}

	public Deque getaClass19_1056() {
		return aClass19_1056;
	}

	public void setaClass19_1056(Deque aClass19_1056) {
		this.aClass19_1056 = aClass19_1056;
	}

	public ScriptManager getScriptManager() {
		return scriptManager;
	}

	public void setScriptManager(ScriptManager scriptManager) {
		this.scriptManager = scriptManager;
	}

	public static String getMyUsername() {
		return myUsername;
	}

	public static void setMyUsername(String myUsername) {
		Client.myUsername = myUsername;
	}

	public MapArea getMapArea() {
		return mapArea;
	}

}