Minified API

src/org/rev317/Loader.java

@@ -9,7 +9,13 @@ import org.parabot.core.asm.ASMClassLoader;
 import org.parabot.environment.servers.ServerManifest;
 import org.parabot.environment.servers.ServerProvider;
 import org.parabot.environment.servers.Type;
+import org.rev317.accessors.Client;
 
+/**
+ * 
+ * @author Everel
+ *
+ */
 @ServerManifest(author = "Everel", name = "Local Client", type = Type.INJECTION, version = 0.1)
 public class Loader extends ServerProvider {
 	private Applet applet;
@@ -38,5 +44,9 @@ public class Loader extends ServerProvider {
 		}
 		return null;
 	}
+	
+	public static Client getClient() {
+		return (Client) Context.getInstance().getClient();
+	}
 
 }

src/org/rev317/accessors/Character.java

@@ -0,0 +1,20 @@
+package org.rev317.accessors;
+
+public interface Character {
+	
+	public int getX();
+	
+	public int getY();
+	
+	public int getAnimation();
+	
+	public int getLoopCycleStatus();
+	
+	public int getCurrentHealth();
+	
+	public int getMaxHealth();
+	
+	public int getInteractingEntity();
+
+}
+

src/org/rev317/accessors/Client.java

@@ -0,0 +1,39 @@
+package org.rev317.accessors;
+
+public interface Client {
+	
+	public Scene getScene();
+	
+	public Player getMyPlayer();
+	
+	public Interface[] getInterfaceCache();
+	
+	public Npc[] getNpcs();
+	
+	public Player[] getPlayers();
+	
+	public int getOpenInterfaceId();
+	
+	public int getBaseX();
+	
+	public int getBaseY();
+	
+	public void setInterface(int id);
+
+	public int[] getCurrentExp();
+	
+	public Deque[][][] getGroundItems();
+	
+	public int getLoopCycle();
+	
+	public int getBackDialogId();
+	
+	public CollisionMap[] getCollisionMap();
+	
+	// args switched
+	public boolean walkTo(int clickType, int sizeX, int sizeY, int startX, int startY, int destX, int destY, int type, int face, boolean arbitrary, int rotation);
+	
+	public void doAction(int i);
+	
+
+}

src/org/rev317/accessors/CollisionMap.java

@@ -0,0 +1,9 @@
+package org.rev317.accessors;
+
+
+public interface CollisionMap {
+	
+	public int[][] getFlags();
+
+}
+

src/org/rev317/accessors/Deque.java

@@ -0,0 +1,9 @@
+package org.rev317.accessors;
+
+public interface Deque {
+	
+	public Node getHead();
+	
+	public Node getCurrent();
+
+}

src/org/rev317/accessors/Ground.java

@@ -0,0 +1,15 @@
+package org.rev317.accessors;
+
+public interface Ground {
+
+	public SceneObjectTile getWallObject();
+
+	public SceneObjectTile getWallDecoration();
+
+	public SceneObjectTile getGroundDecoration();
+
+	public SceneObjectTile getGroundItem();
+
+	public SceneObjectTile[] getInteractiveObjects();
+
+}

src/org/rev317/accessors/Interface.java

@@ -0,0 +1,9 @@
+package org.rev317.accessors;
+
+public interface Interface {
+	
+	public int[] getItems();
+
+	public int[] getStackSizes();
+
+}

src/org/rev317/accessors/Item.java

@@ -0,0 +1,8 @@
+package org.rev317.accessors;
+
+public interface Item {
+	
+	public int getId();
+
+}
+

src/org/rev317/accessors/Node.java

@@ -0,0 +1,7 @@
+package org.rev317.accessors;
+
+public interface Node {
+	
+	public Node getNext();
+
+}

src/org/rev317/accessors/Npc.java

@@ -0,0 +1,7 @@
+package org.rev317.accessors;
+
+public interface Npc extends Character {
+	
+	public NpcDef getDef();
+
+}

src/org/rev317/accessors/NpcDef.java

@@ -0,0 +1,7 @@
+package org.rev317.accessors;
+
+public interface NpcDef {
+	
+	public int getId();
+
+}

src/org/rev317/accessors/Player.java

@@ -0,0 +1,5 @@
+package org.rev317.accessors;
+
+public interface Player extends Character {
+
+}

src/org/rev317/accessors/Scene.java

@@ -0,0 +1,7 @@
+package org.rev317.accessors;
+
+public interface Scene {
+	
+	public Ground[][][] getGroundArray();
+
+}

src/org/rev317/accessors/SceneObjectTile.java

@@ -0,0 +1,7 @@
+package org.rev317.accessors;
+
+public interface SceneObjectTile {
+	
+	public int getHash();
+
+}

src/org/rev317/api/interfaces/Locatable.java

@@ -0,0 +1,24 @@
+package org.rev317.api.interfaces;
+
+import org.rev317.api.wrappers.Tile;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public interface Locatable {
+	
+	/**
+	 * Gets location of this locatable instance
+	 * @return location
+	 */
+	public Tile getLocation();
+	
+	/**
+	 * Gets distance to this locatable instance
+	 * @return distance from player to locatable
+	 */
+	public int distanceTo();
+
+}

src/org/rev317/api/interfaces/TileFlags.java

@@ -0,0 +1,18 @@
+package org.rev317.api.interfaces;
+
+public interface TileFlags {
+	
+	public int WALL_NORTHWEST  = 0x1; 
+    public int WALL_NORTH      = 0x2; 
+    public int WALL_NORTHEAST  = 0x4; 
+    public int WALL_EAST       = 0x8; 
+    public int WALL_SOUTHEAST  = 0x10; 
+    public int WALL_SOUTH      = 0x20; 
+    public int WALL_SOUTHWEST  = 0x40; 
+    public int WALL_WEST       = 0x80; 
+    public int OBJECT_TILE     = 0x100; 
+    public int UNKNOWN         = 0x80000; 
+    public int BLOCKED_TILE    = 0x200000; 
+    public int UNLOADED_TILE   = 0x1000000;
+
+}

src/org/rev317/api/methods/Bank.java

@@ -0,0 +1,293 @@
+package org.rev317.api.methods;
+
+import java.util.ArrayList;
+
+import org.parabot.environment.api.utils.Filter;
+import org.parabot.environment.api.utils.Time;
+import org.parabot.environment.input.Keyboard;
+import org.rev317.Loader;
+import org.rev317.api.wrappers.Item;
+import org.rev317.api.wrappers.Npc;
+import org.rev317.api.wrappers.SceneObject;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class Bank {
+	public static final int BANK_INTERFACE = 5292;
+	public static final int ITEM_INTERFACE = 5382;
+	public static final int BUTTON_DEPOSIT_ALL = 5386;
+	public static final int INV_PARENT_ID = 5064;
+
+	public static final int[] BANKERS = new int[] { 44, 45, 494, 495, 498, 499,
+			909, 958, 1036, 2271, 2354, 2355, 3824, 5488, 5901, 4456, 4457,
+			4458, 4459, 5912, 5913, 6362, 6532, 6533, 6534, 6535, 7605, 8948,
+			9710, 14367 };
+	public static final int[] BANKS = new int[] { 782, 2213, 2995, 5276, 6084,
+			10517, 11402, 11758, 12759, 14367, 19230, 20325, 24914, 25808,
+			26972, 29085, 52589, 34752, 35647, 36786, 2012, 2015, 2019, 693,
+			4483, 12308, 20607, 21301, 27663, 42192 };
+
+	/**
+	 * Gets nearest banker
+	 * 
+	 * @return nearest banker
+	 */
+	public static Npc getBanker() {
+		return Npcs.getNearest(new Filter<Npc>() {
+
+			@Override
+			public boolean accept(Npc f) {
+				for (int id : BANKERS) {
+					if (id == f.getDef().getId()) {
+						return true;
+					}
+				}
+				return false;
+			}
+
+		})[0];
+	}
+
+	/**
+	 * Gets nearest bank booths
+	 * 
+	 * @return bank booths
+	 */
+	public static SceneObject[] getNearestBanks() {
+		return SceneObjects.getNearest(BANKS);
+	}
+
+	/**
+	 * Gets nearest bank booths
+	 * 
+	 * @return bank booth
+	 */
+	public static SceneObject getBank() {
+		SceneObject[] banks = getNearestBanks();
+		if (banks != null && banks[0] != null) {
+			return banks[0];
+		}
+		return null;
+	}
+
+	/**
+	 * Opens bank using banker or bank booth
+	 * 
+	 * @return <b>true</b> if successfully interacted
+	 */
+	public static boolean open() {
+
+		if (isOpen()) {
+			return false;
+		}
+		SceneObject bank = getBank();
+		Npc banker = getBanker();
+
+		if (bank != null) {
+			bank.interact(1);
+			return true;
+		} else if (banker != null) {
+			banker.interact(1);
+			return true;
+		}
+
+		return false;
+	}
+	
+	/**
+	 * Deposits all items
+	 */
+	public static void depositAll() {
+		Menu.clickButton(BUTTON_DEPOSIT_ALL);
+	}
+
+	/**
+	 * Withdraws items at bank based on given parameters
+	 * 
+	 * @param id
+	 * @param amount
+	 */
+	public static void withdraw(int id, int amount, int sleep) {
+
+		if (!isOpen()) {
+			return;
+		}
+
+		Item b = getItem(id);
+
+		if (b == null) {
+			return;
+		}
+
+		if (amount == 1) {
+			b.transform(0, INV_PARENT_ID);
+		} else if (amount == 5) {
+			b.transform(1, INV_PARENT_ID);
+		} else if (amount == 10) {
+			b.transform(2, INV_PARENT_ID);
+		} else if (amount == 0) {
+			b.transform(3, INV_PARENT_ID);
+		} else {
+			b.transform(4, INV_PARENT_ID);
+			Time.sleep(1500 + sleep);
+			Keyboard.getInstance().sendKeys("" + amount);
+		}
+	}
+
+	/**
+	 * Gets bank item with given id
+	 * 
+	 * @param id
+	 * @return bank item
+	 */
+	public static Item getItem(int id) {
+
+		if (!isOpen()) {
+			return null;
+		}
+
+		for (Item i : Bank.getBankItems()) {
+			if (i.getId() == id) {
+				return i;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Counts the amount of items with given id in bank
+	 * 
+	 * @param id
+	 * @return count
+	 */
+	public static int getCount(int id) {
+		if (!isOpen()) {
+			return 0;
+		}
+		return getItem(id).getStackSize();
+	}
+
+	/**
+	 * Opens the bank
+	 * 
+	 * @param bank
+	 *            booth
+	 */
+	public static void open(SceneObject bank) {
+
+		if (isOpen()) {
+			return;
+		}
+
+		if (bank.getLocation().distanceTo() > 8) {
+			bank.getLocation().walkTo();
+			return;
+		}
+		bank.interact(1);
+	}
+
+
+	/**
+	 * Closes the bank interface
+	 */
+	public static void close() {
+		if (!isOpen()) {
+			return;
+		}
+		//[index: 1, action1: -1, action2: -1, action3: 5384, id: 200]
+		Menu.sendAction(200, -1, -1, 5384);
+	}
+
+	/**
+	 * Deposits all items except the given ids
+	 * 
+	 * @param exceptions
+	 *            the item indexes that will be ignored.
+	 */
+	public static void depositAllExcept(int... exceptions) {
+		if (Bank.isOpen()) {
+			final ArrayList<Integer> ignored = new ArrayList<Integer>();
+			for (int i : exceptions) {
+				ignored.add(i);
+			}
+			for (Item i : Inventory.getItems()) {
+				if (!ignored.contains(i.getId())) {
+					while (Bank.isOpen() && Inventory.getCount(i.getId()) > 0) {
+						i.transform(3, INV_PARENT_ID);
+						ignored.add(i.getId());
+						Time.sleep(50);
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Gets all bank item ids in bank
+	 * 
+	 * @return bank items
+	 */
+	public static int[] getBankItemIDs() {
+		if (!isOpen()) {
+			return null;
+		}
+		return Loader.getClient().getInterfaceCache()[5382].getItems();
+	}
+
+	/**
+	 * Gets all stack sizes in bank
+	 * 
+	 * @return stack sizes
+	 */
+	public static int[] getBankStacks() {
+		if (!isOpen()) {
+			return null;
+		}
+		return Loader.getClient().getInterfaceCache()[5382].getStackSizes();
+	}
+
+	/**
+	 * Gets all bank items in bank
+	 * 
+	 * @return bank items
+	 */
+	public static Item[] getBankItems() {
+		if (!isOpen()) {
+			return null;
+		}
+		ArrayList<Item> items = new ArrayList<Item>();
+		int[] ids = getBankItemIDs();
+		int[] stacks = getBankStacks();
+		for (int i = 0; i < ids.length; i++) {
+			if (ids[i] > 0) {
+				items.add(new Item(ids[i], stacks[i], i));
+			}
+		}
+		return (Item[]) items.toArray(new Item[items.size()]);
+	}
+
+	/**
+	 * Counts total amount of items in bank
+	 * 
+	 * @return total amount of items
+	 */
+	public static int getBankCount() {
+		if (!isOpen()) {
+			return 0;
+		}
+		return getBankItemIDs().length;
+	}
+
+	/**
+	 * Determines if bank is open
+	 * 
+	 * @return <b>true</b> if bank is open
+	 */
+	public static boolean isOpen() {
+		return Loader.getClient().getOpenInterfaceId() == BANK_INTERFACE;
+	}
+
+}

src/org/rev317/api/methods/Calculations.java

@@ -0,0 +1,153 @@
+package org.rev317.api.methods;
+
+import org.rev317.api.wrappers.Tile;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class Calculations {
+	
+	/** 
+	 * Calculates distance between local player and given tile
+	 * 
+	 * @param tile
+	 * @return distance between local player and given tile
+	 */
+	public static final double distanceTo(Tile tile) {
+		return distanceBetween(tile, Players.getMyPlayer().getLocation());
+	}
+	
+	/**
+	 * Calculates distance between two given tiles
+	 * @param a
+	 * @param b
+	 * @return distance between a and b
+	 */
+	public static final double distanceBetween(Tile a, Tile b) {
+		int x = b.getX() - a.getX();
+		int y = b.getY() - a.getY();
+		return Math.sqrt((x * x) + (y * y));
+	}
+	
+	
+	/**
+	 * @param startX       the startX (0 < startX < 104)
+	 * @param startY       the startY (0 < startY < 104)
+	 * @param destX        the destX (0 < destX < 104)
+	 * @param destY        the destY (0 < destY < 104)
+	 * @param findAdjacent if it's an object, it will find path which touches it.
+	 * @return The distance of the shortest path to the destination; or -1 if no valid path to the destination was found.
+	 */
+	public static int dijkstraDist(final int startX, final int startY, final int destX, final int destY, final boolean findAdjacent) {
+		try {
+			final int[][] prev = new int[104][104];
+			final int[][] dist = new int[104][104];
+			final int[] path_x = new int[4000];
+			final int[] path_y = new int[4000];
+			for (int xx = 0; xx < 104; xx++) {
+				for (int yy = 0; yy < 104; yy++) {
+					prev[xx][yy] = 0;
+					dist[xx][yy] = 99999999;
+				}
+			}
+			int curr_x = startX;
+			int curr_y = startY;
+			prev[startX][startY] = 99;
+			dist[startX][startY] = 0;
+			int path_ptr = 0;
+			int step_ptr = 0;
+			path_x[path_ptr] = startX;
+			path_y[path_ptr++] = startY;
+			final int blocks[][] = Game.getCollisionFlags();
+			final int pathLength = path_x.length;
+			boolean foundPath = false;
+			while (step_ptr != path_ptr) {
+				curr_x = path_x[step_ptr];
+				curr_y = path_y[step_ptr];
+				if (Math.abs(curr_x - destX) + Math.abs(curr_y - destY) == (findAdjacent ? 1 : 0)) {
+					foundPath = true;
+					break;
+				}
+				step_ptr = (step_ptr + 1) % pathLength;
+				final int cost = dist[curr_x][curr_y] + 1;
+				// south
+				if (curr_y > 0 && prev[curr_x][curr_y - 1] == 0 && (blocks[curr_x][curr_y - 1] & 0x1280102) == 0) {
+					path_x[path_ptr] = curr_x;
+					path_y[path_ptr] = curr_y - 1;
+					path_ptr = (path_ptr + 1) % pathLength;
+					prev[curr_x][curr_y - 1] = 1;
+					dist[curr_x][curr_y - 1] = cost;
+				}
+				// west
+				if (curr_x > 0 && prev[curr_x - 1][curr_y] == 0 && (blocks[curr_x - 1][curr_y] & 0x1280108) == 0) {
+					path_x[path_ptr] = curr_x - 1;
+					path_y[path_ptr] = curr_y;
+					path_ptr = (path_ptr + 1) % pathLength;
+					prev[curr_x - 1][curr_y] = 2;
+					dist[curr_x - 1][curr_y] = cost;
+				}
+				// north
+				if (curr_y < 104 - 1 && prev[curr_x][curr_y + 1] == 0 && (blocks[curr_x][curr_y + 1] &
+						0x1280120) == 0) {
+					path_x[path_ptr] = curr_x;
+					path_y[path_ptr] = curr_y + 1;
+					path_ptr = (path_ptr + 1) % pathLength;
+					prev[curr_x][curr_y + 1] = 4;
+					dist[curr_x][curr_y + 1] = cost;
+				}
+				// east
+				if (curr_x < 104 - 1 && prev[curr_x + 1][curr_y] == 0 && (blocks[curr_x + 1][curr_y] &
+						0x1280180) == 0) {
+					path_x[path_ptr] = curr_x + 1;
+					path_y[path_ptr] = curr_y;
+					path_ptr = (path_ptr + 1) % pathLength;
+					prev[curr_x + 1][curr_y] = 8;
+					dist[curr_x + 1][curr_y] = cost;
+				}
+				// south west
+				if (curr_x > 0 && curr_y > 0 && prev[curr_x - 1][curr_y - 1] == 0 && (blocks[curr_x - 1][curr_y - 1] &
+						0x128010E) == 0 && (blocks[curr_x - 1][curr_y] & 0x1280108) == 0 && (blocks[curr_x
+						][curr_y - 1] & 0x1280102) == 0) {
+					path_x[path_ptr] = curr_x - 1;
+					path_y[path_ptr] = curr_y - 1;
+					path_ptr = (path_ptr + 1) % pathLength;
+					prev[curr_x - 1][curr_y - 1] = 3;
+					dist[curr_x - 1][curr_y - 1] = cost;
+				}
+				// north west
+				if (curr_x > 0 && curr_y < 104 - 1 && prev[curr_x - 1][curr_y + 1] == 0 && (blocks[curr_x - 1][curr_y + 1] & 0x1280138) == 0 && (blocks[curr_x - 1][curr_y] & 0x1280108) ==
+						0 && (blocks[curr_x][curr_y + 1] & 0x1280120) == 0) {
+					path_x[path_ptr] = curr_x - 1;
+					path_y[path_ptr] = curr_y + 1;
+					path_ptr = (path_ptr + 1) % pathLength;
+					prev[curr_x - 1][curr_y + 1] = 6;
+					dist[curr_x - 1][curr_y + 1] = cost;
+				}
+				// south east
+				if (curr_x < 104 - 1 && curr_y > 0 && prev[curr_x + 1][curr_y - 1] == 0 && (blocks[curr_x +
+						1][curr_y - 1] & 0x1280183) == 0 && (blocks[curr_x + 1][curr_y] & 0x1280180) == 0 && (blocks[curr_x][curr_y - 1] & 0x1280102) == 0) {
+					path_x[path_ptr] = curr_x + 1;
+					path_y[path_ptr] = curr_y - 1;
+					path_ptr = (path_ptr + 1) % pathLength;
+					prev[curr_x + 1][curr_y - 1] = 9;
+					dist[curr_x + 1][curr_y - 1] = cost;
+				}
+				// north east
+				if (curr_x < 104 - 1 && curr_y < 104 - 1 && prev[curr_x + 1][curr_y + 1] == 0 && (blocks[curr_x
+						+ 1][curr_y + 1] & 0x12801E0) == 0 && (blocks[curr_x + 1][curr_y] & 0x1280180) == 0 && (blocks[curr_x][curr_y + 1] & 0x1280120) == 0) {
+					path_x[path_ptr] = curr_x + 1;
+					path_y[path_ptr] = curr_y + 1;
+					path_ptr = (path_ptr + 1) % pathLength;
+					prev[curr_x + 1][curr_y + 1] = 12;
+					dist[curr_x + 1][curr_y + 1] = cost;
+				}
+			}
+			return foundPath ? dist[curr_x][curr_y] : -1;
+		} catch (Exception e) {
+			return -1;
+		}
+	}
+
+}

src/org/rev317/api/methods/Game.java

@@ -0,0 +1,60 @@
+package org.rev317.api.methods;
+
+import org.rev317.Loader;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class Game {
+	
+	/**
+	 * Gets BaseX
+	 * @return baseX
+	 */
+	public static int getBaseX() {
+		return Loader.getClient().getBaseX();
+	}
+	
+	/**
+	 * Gets BaseY
+	 * @return baseY
+	 */
+	public static int getBaseY() {
+		return Loader.getClient().getBaseY();
+	}
+	
+	/**
+	 * Gets open interface id
+	 * @return interface id
+	 */
+	public static int getOpenInterfaceId() {
+		return Loader.getClient().getOpenInterfaceId();
+	}
+	
+	/**
+	 * Get open back dialog id
+	 * @return back dialog id
+	 */
+	public static int getOpenBackDialogId() {
+		return Loader.getClient().getBackDialogId();
+	}
+	
+	/**
+	 * Gets loop cycle
+	 * @return loop cycle
+	 */
+	public static int getLoopCycle() {
+		return Loader.getClient().getLoopCycle();
+	}
+	
+	/**
+	 * Get collision flags
+	 * @return collision flags
+	 */
+	public static int[][] getCollisionFlags() {
+		return Loader.getClient().getCollisionMap()[0].getFlags();
+	}
+
+}

src/org/rev317/api/methods/GroundItems.java

@@ -0,0 +1,155 @@
+package org.rev317.api.methods;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+
+import org.parabot.environment.api.utils.Filter;
+import org.rev317.Loader;
+import org.rev317.accessors.Client;
+import org.rev317.accessors.Deque;
+import org.rev317.accessors.Node;
+import org.rev317.api.wrappers.GroundItem;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class GroundItems {
+	private static Client client;
+
+	private static final Comparator<GroundItem> NEAREST_SORTER = new Comparator<GroundItem>() {
+
+		@Override
+		public int compare(GroundItem n1, GroundItem n2) {
+			return n1.distanceTo() - n2.distanceTo();
+		}
+
+	};
+
+	private static final Filter<GroundItem> ALL_FILTER = new Filter<GroundItem>() {
+
+		@Override
+		public boolean accept(GroundItem item) {
+			return true;
+		}
+
+	};
+
+	/**
+	 * Gets all loaded ground items
+	 * 
+	 * @return ground item array
+	 */
+	public final static GroundItem[] getGroundItems(
+			final Filter<GroundItem> filter) {
+		if (client == null) {
+			client = Loader.getClient();
+		}
+		final ArrayList<GroundItem> items = new ArrayList<GroundItem>();
+		for (int x = 0; x < 104; x++) {
+			for (int y = 0; y < 104; y++) {
+				final GroundItem[] groundItemsAtTile = getGroundItemsAt(x, y);
+				if (groundItemsAtTile != null) {
+					for (final GroundItem item : groundItemsAtTile) {
+						if (filter.accept(item)) {
+							items.add(item);
+						}
+					}
+				}
+			}
+		}
+		return items.toArray(new GroundItem[items.size()]);
+	}
+
+	/**
+	 * Gets a ground item
+	 * 
+	 * @param x
+	 *            - local region x
+	 * @param y
+	 *            - local region y
+	 * @return ground item array
+	 */
+	public static final GroundItem[] getGroundItemsAt(final int x, final int y) {
+		try {
+			if (client == null) {
+				client = Loader.getClient();
+			}
+			final Deque deque = client.getGroundItems()[0][x][y];
+			if (deque == null) {
+				return null;
+			}
+			ArrayList<GroundItem> list = null;
+			final Node holder = deque.getHead();
+			Node curNode = holder.getNext();
+			while (curNode != null && curNode != holder
+					&& curNode != deque.getHead()) {
+				if (list == null) {
+					list = new ArrayList<GroundItem>();
+				}
+				final org.rev317.accessors.Item groundItem = (org.rev317.accessors.Item) curNode;
+				list.add(new GroundItem(groundItem, x, y));
+				curNode = curNode.getNext();
+			}
+			return list.toArray(new GroundItem[list.size()]);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+	/**
+	 * Gets all ground items in game
+	 * 
+	 * @return ground items
+	 */
+	public static final GroundItem[] getGroundItems() {
+		return getGroundItems(ALL_FILTER);
+	}
+
+	/**
+	 * Returns array of GroundItems with the first index to be the nearest
+	 * 
+	 * @param filter
+	 * @return GroundItems
+	 */
+	public static final GroundItem[] getNearest(Filter<GroundItem> filter) {
+		final GroundItem[] objects = getGroundItems(filter);
+		Arrays.sort(objects, NEAREST_SORTER);
+		return objects;
+	}
+
+	/**
+	 * Returns array of GroundItems with the first index to be the nearest
+	 * 
+	 * @return GroundItems
+	 */
+	public static final GroundItem[] getNearest() {
+		return getNearest(ALL_FILTER);
+	}
+
+	/**
+	 * Returns nearest ground items with given id
+	 * 
+	 * @param ids
+	 * @return GroundItems
+	 */
+	public static final GroundItem[] getNearest(final int... ids) {
+		return getNearest(new Filter<GroundItem>() {
+
+			@Override
+			public boolean accept(GroundItem object) {
+				for (final int id : ids) {
+					if (id == object.getId()) {
+						return true;
+					}
+				}
+				return false;
+			}
+
+		});
+	}
+
+}

src/org/rev317/api/methods/Inventory.java

@@ -0,0 +1,186 @@
+package org.rev317.api.methods;
+
+import java.util.ArrayList;
+
+import org.parabot.environment.api.utils.Filter;
+import org.parabot.environment.api.utils.Time;
+import org.rev317.Loader;
+import org.rev317.accessors.Interface;
+import org.rev317.api.wrappers.Item;
+
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class Inventory {
+	public static final int INVENTORY_INDEX = 3214;
+	
+	private static final Filter<Item> ALL_FILTER = new Filter<Item>() {
+
+		@Override
+		public boolean accept(Item i) {
+			return true;
+		}
+		
+	};
+	
+	/**
+	 * Clears the inventory
+	 */
+	public static void clear() {
+		for(Item item : Inventory.getItems()) {
+			item.drop();
+			Time.sleep(60, 80);
+		}
+	}
+
+	/**
+	 * Gets inventory interface
+	 * @return interface of inventory
+	 */
+	public static Interface getInterface() {
+		return Loader.getClient().getInterfaceCache()[INVENTORY_INDEX];
+	}
+	
+	/**
+	 * Gets the amount of items in inventory, excludes the stack sizes
+	 * @return amount of items
+	 */
+	public static final int getCount() {
+		return getCount(false);
+	}
+	
+	/**
+	 *  Gets the amount of items with given ids in inventory, excludes the stack sizes
+	 * @param ids
+	 * @return amount of items
+	 */
+	public static final int getCount(int... ids) {
+		return getCount(false, ids);
+	}
+	
+	/**
+	 * Gets the amount of items in inventory
+	 * @param includeStack - true for including stack sizes to the counting
+	 * @return amount of items
+	 */
+	public static final int getCount(final boolean includeStack) {
+		final Interface inventory = getInterface();
+		if(inventory == null) {
+			return -1;
+		}
+		int count = 0;
+		final int[] items = inventory.getItems();
+		final int[] stackSizes = includeStack ? inventory.getStackSizes() : null;
+		for(int i = 0; i < items.length; i++) {
+			if(items[i] > 0) {
+				count += includeStack ? stackSizes[i] : 1;
+			}
+		}
+		return count;
+	}
+	
+	/**
+	 * Gets the amount of items with given ids in inventory
+	 * @param includeStack - true for including stack sizes to the counting
+	 * @param ids
+	 * @return amount of items
+	 */
+	public static final int getCount(final boolean includeStack, int... ids) {
+		final Interface inventory = getInterface();
+		if(inventory == null) {
+			return -1;
+		}
+		int count = 0;
+		final int[] items = inventory.getItems(); 
+		final int[] stackSizes = includeStack ? inventory.getStackSizes() : null;
+		for(int i = 0; i < items.length; i++) {
+			final int itemId = items[i];
+			if(itemId > 0) {
+				for(final int id : ids) {
+					if(id == itemId) {
+						count += includeStack ? stackSizes[i] : 1;
+						break;
+					}
+				}
+			}
+		}
+		return count;
+	}
+	
+	/**
+	 * Gets every item in inventory
+	 * @return items
+	 */
+	public static final Item[] getItems() {
+		return getItems(ALL_FILTER);
+	}
+	
+	/**
+	 * Gets all items with given ids
+	 * @param ids
+	 * @return items
+	 */
+	public static final Item[] getItems(final int... ids) {
+		return getItems(new Filter<Item>() {
+
+			@Override
+			public boolean accept(Item e) {
+				for(int id : ids) {
+					if(e.getId() == id) {
+						return true;
+					}
+				}
+				return false;
+			}
+			
+		});
+	}
+	
+	/**
+	 * Gets all items accepted by filter
+	 * @param filter
+	 * @return items
+	 */
+	public static final Item[] getItems(final Filter<Item> filter) {
+		final Interface inventory = getInterface();
+		if(inventory == null) {
+			return null;
+		}
+		final int[] items = inventory.getItems();
+		final int[] stackSizes = inventory.getStackSizes();
+		final ArrayList<Item> invItems = new ArrayList<Item>(28);
+		for(int i = 0; i < items.length; i++) {
+			final int itemId = items[i];
+			if(itemId < 1) {
+				continue;
+			}
+			final int stackSize = stackSizes[i];
+			final Item item = new Item(itemId, stackSize, i);
+			if(filter.accept(item)) {
+				invItems.add(item);
+			}
+		}
+		return invItems.toArray(new Item[invItems.size()]);
+	}
+	
+	/**
+	 * Determines if inventory is full
+	 * @return <b>true</b> if inventory is full, otherwise <b>false</b>
+	 */
+	public static final boolean isFull() {
+		return Inventory.getCount() == 28;
+	}
+	
+	/**
+	 * Determines if inventory is empty
+	 * @return <b>true</b> if inventory is empty, otherwise <b>false</b>
+	 */
+	public static final boolean isEmpty() {
+		return Inventory.getCount() == 0;
+	}
+
+}
+

src/org/rev317/api/methods/Menu.java

@@ -0,0 +1,186 @@
+package org.rev317.api.methods;
+
+import java.util.HashMap;
+
+import org.parabot.core.Context;
+import org.rev317.Loader;
+import org.rev317.accessors.Client;
+import org.rev317.api.wrappers.Character;
+import org.rev317.api.wrappers.GroundItem;
+import org.rev317.api.wrappers.Item;
+import org.rev317.api.wrappers.SceneObject;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class Menu {
+	public static final int ACTION_CLICK_BUTTON = 646;
+	public static final int ACTION_DROP_ITEM = 847;
+	public static final int ACTION_TAKE_ITEM = 234;
+
+	private static HashMap<String, String> constants;
+
+	/**
+	 * Interacts with a sceneobject
+	 * @param object
+	 * @param actionIndex
+	 */
+	public static void interact(SceneObject object, int actionIndex) {
+		/*int actionId = 502;
+		switch (actionIndex) {
+		case 0:
+			actionId = 502;
+			break;
+		case 1:
+			actionId = 900;
+			break;
+		case 2:
+			actionId = 113;
+			break;
+		case 3:
+			actionId = 872;
+			break;
+		case 4:
+			actionId = 1062;
+			break;
+		}*/
+		// TODO : send Action
+	}
+
+	/**
+	 * Interacts with a character
+	 * @param character
+	 * @param actionIndex
+	 */
+	public static void interact(Character character, int actionIndex) {
+		int actionId = 20;
+		switch (actionIndex) {
+		case 0:
+			actionId = 20;
+			break;
+		case 1:
+			actionId = 412;
+			break;
+		case 2:
+			actionId = 225;
+			break;
+		case 3:
+			actionId = 965;
+			break;
+		case 4:
+			actionId = 478;
+			break;
+		}
+		sendAction(actionId, character.getIndex(), 0, 0);
+	}
+
+	/**
+	 * Interacts with an item when it has the following menu
+	 * Transform-1
+	 * Transform-5
+	 * Transform-10
+	 * etc..
+	 * @param item
+	 * @param actionIndex
+	 * @param interfaceParentId
+	 */
+	public static void transformItem(Item item, int actionIndex,
+			int interfaceParentId) {
+		int actionId = 632;
+		switch (actionIndex) {
+		case 0:
+			actionId = 632;
+			break;
+		case 1:
+			actionId = 78;
+			break;
+		case 2:
+			actionId = 867;
+			break;
+		case 3:
+			actionId = 431;
+			break;
+		case 4:
+			actionId = 53;
+			break;
+		}
+		sendAction(actionId, (int) item.getId() - 1, item.getSlot(),
+				interfaceParentId);
+	}
+	
+	/**
+	 * Takes grounditem from the ground
+	 * @param item
+	 */
+	public static void take(GroundItem item) {
+		sendAction(ACTION_TAKE_ITEM, item.getId(), item.getX(), item.getY());
+	}
+
+	/**
+	 * Interacts with a ground item
+	 * @param item
+	 * @param action
+	 */
+	public static void interact(GroundItem item, int action) {
+		int actionId = 652;
+		switch (action) {
+		case 0:
+			actionId = 652;
+			break;
+		case 1:
+			actionId = 567;
+			break;
+		case 2:
+			actionId = 234;
+			break;
+		case 3:
+			actionId = 244;
+			break;
+		case 4:
+			actionId = 213;
+			break;
+		}
+		sendAction(actionId, item.getId(), item.getX(), item.getY());
+	}
+
+	/**
+	 * Drops an item
+	 * @param item
+	 */
+	public static void drop(Item item) {
+		sendAction(ACTION_DROP_ITEM, (int) item.getId() - 1, item.getSlot(),
+				Inventory.INVENTORY_INDEX);
+	}
+
+	/**
+	 * Clicks a button
+	 * @param id
+	 */
+	public static void clickButton(int id) {
+		sendAction(ACTION_CLICK_BUTTON, 0, 0, id);
+	}
+
+	/**
+	 * Sends an action the client
+	 * @param action
+	 * @param cmd1
+	 * @param cmd2
+	 * @param cmd3
+	 */
+	public static void sendAction(int action, int cmd1, int cmd2, int cmd3) {
+		if (constants == null) {
+			constants = Context.getInstance().getHookParser().getConstants();
+		}
+
+		int index = 0;
+		Client client = Loader.getClient();
+
+		// TODO : set action
+
+		client.doAction(index);
+	}
+
+}
+

src/org/rev317/api/methods/Npcs.java

@@ -0,0 +1,113 @@
+package org.rev317.api.methods;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+
+import org.parabot.environment.api.utils.Filter;
+import org.rev317.Loader;
+import org.rev317.accessors.Client;
+import org.rev317.api.wrappers.Npc;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class Npcs {
+
+	private static final Comparator<Npc> NEAREST_SORTER = new Comparator<Npc>() {
+
+		@Override
+		public int compare(Npc n1, Npc n2) {
+			return n1.distanceTo() - n2.distanceTo();
+		}
+
+	};
+
+	private static final Filter<Npc> ALL_FILTER = new Filter<Npc>() {
+
+		@Override
+		public boolean accept(Npc n) {
+			return true;
+		}
+
+	};
+
+	/**
+	 * Gets all Npcs except local Npc
+	 * 
+	 * @param filter
+	 * @return all Npcs
+	 */
+	public static final Npc[] getNpcs(final Filter<Npc> filter) {
+		final Client client = Loader.getClient();
+		ArrayList<Npc> npcList = new ArrayList<Npc>();
+		final org.rev317.accessors.Npc[] accNpcs = client.getNpcs();
+		for (int i = 0; i < accNpcs.length; i++) {
+			if(accNpcs[i] == null) {
+				continue;
+			}
+			final Npc npc = new Npc(accNpcs[i], i);
+			if (filter.accept(npc)) {
+				npcList.add(npc);
+			}
+		}
+		return npcList.toArray(new Npc[npcList.size()]);
+	}
+
+	/**
+	 * Gets all Npcs
+	 * 
+	 * @return all Npcs
+	 */
+	public static final Npc[] getNpcs() {
+		return getNpcs(ALL_FILTER);
+	}
+
+	/**
+	 * Returns array with the first index to be the nearest Npc
+	 * 
+	 * @param filter
+	 * @return nearest Npcs
+	 */
+	public static final Npc[] getNearest(final Filter<Npc> filter) {
+		final Npc[] npcs = getNpcs(filter);
+		Arrays.sort(npcs, NEAREST_SORTER);
+		return npcs;
+	}
+
+	/**
+	 * Gets nearest npcs which hold given id(s)
+	 * 
+	 * @param ids
+	 * @return array of npcs with the first index to be the nearest
+	 */
+	public static final Npc[] getNearest(final int... ids) {
+		final Npc[] npcs = getNpcs(new Filter<Npc>() {
+
+			@Override
+			public boolean accept(Npc npc) {
+				for (final int id : ids) {
+					if (id == npc.getDef().getId()) {
+						return true;
+					}
+				}
+				return false;
+			}
+
+		});
+		Arrays.sort(npcs, NEAREST_SORTER);
+		return npcs;
+	}
+
+	/**
+	 * Returns array with the first index to be the nearest Npc
+	 * 
+	 * @return nearest Npcs
+	 */
+	public static final Npc[] getNearest() {
+		return getNearest(ALL_FILTER);
+	}
+
+}

src/org/rev317/api/methods/Players.java

@@ -0,0 +1,93 @@
+package org.rev317.api.methods;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+
+import org.parabot.environment.api.utils.Filter;
+import org.rev317.Loader;
+import org.rev317.accessors.Client;
+import org.rev317.api.wrappers.Player;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class Players {
+	
+	private static final Comparator<Player> NEAREST_SORTER = new Comparator<Player>() {
+
+		@Override
+		public int compare(Player p1, Player p2) {
+			return p1.distanceTo() - p2.distanceTo();
+		}
+		
+	};
+	
+	private static final Filter<Player> ALL_FILTER = new Filter<Player>() {
+
+		@Override
+		public boolean accept(Player p) {
+			return true;
+		}
+		
+	};
+	
+	/**
+	 * Gets all players except local player
+	 * @param filter
+	 * @return all players
+	 */
+	public static final Player[] getPlayers(final Filter<Player> filter) {
+		final Client client = Loader.getClient();
+		ArrayList<Player> playerList = new ArrayList<Player>();
+		final org.rev317.accessors.Player[] accPlayers = client.getPlayers(); 
+		for(int i = 0; i < accPlayers.length; i++) {
+			if(accPlayers[i] == null) {
+				continue;
+			}
+			final Player player = new Player(accPlayers[i], i);
+			if(filter.accept(player)) {
+				playerList.add(player);
+			}
+		}
+		return playerList.toArray(new Player[playerList.size()]);
+	}
+	
+	/**
+	 * Gets all players except local player
+	 * @return all players
+	 */
+	public static final Player[] getPlayers() {
+		return getPlayers(ALL_FILTER);
+	}
+	
+	/**
+	 * Returns array with the first index to be the nearest player
+	 * @param filter
+	 * @return nearest players
+	 */
+	public static final Player[] getNearest(final Filter<Player> filter) {
+		final Player[] players = getPlayers(filter);
+		Arrays.sort(players, NEAREST_SORTER);
+		return players;
+	}
+	
+	/**
+	 * Returns array with the first index to be the nearest player
+	 * @return nearest players
+	 */
+	public static final Player[] getNearest() {
+		return getNearest(ALL_FILTER);
+	}
+	
+	/**
+	 * Gets local player
+	 * @return local player
+	 */
+	public static Player getMyPlayer() {
+		return new Player(Loader.getClient().getMyPlayer(), -1);
+	}
+
+}

src/org/rev317/api/methods/SceneObjects.java

@@ -0,0 +1,219 @@
+package org.rev317.api.methods;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+
+import org.parabot.environment.api.utils.Filter;
+import org.rev317.Loader;
+import org.rev317.accessors.Ground;
+import org.rev317.accessors.SceneObjectTile;
+import org.rev317.api.wrappers.SceneObject;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class SceneObjects {
+	
+	private static final Comparator<SceneObject> NEAREST_SORTER = new Comparator<SceneObject>() {
+
+		@Override
+		public int compare(SceneObject n1,SceneObject n2) {
+			return n1.distanceTo() - n2.distanceTo();
+		}
+
+	};
+	
+	private static final Filter<SceneObject> ALL_FILTER = new Filter<SceneObject>() {
+
+		@Override
+		public boolean accept(SceneObject object) {
+			return true;
+		}
+		
+	};
+	
+	/**
+	 * Gets the most important scene objects in game which can be interacted with, filters out: 'walls, wall decorations, ground decorations'
+	 * @return scene objects
+	 */
+	public static final SceneObject[] getSceneObjects(Filter<SceneObject> filter) {
+		ArrayList<SceneObject> sceneObjects = new ArrayList<SceneObject>();
+		for(int x = 0; x < 104; x++) {
+			for(int y = 0; y < 104; y++) {
+				final SceneObject sceneObjectAtTile = getSceneObjectAtTile(x, y, true);
+				if(sceneObjectAtTile != null && filter.accept(sceneObjectAtTile)) {
+					sceneObjects.add(sceneObjectAtTile);
+				}
+				
+			}
+		}
+		return sceneObjects.toArray(new SceneObject[sceneObjects.size()]);
+	}
+	
+	/**
+	 * Gets the most important scene objects in game which can be interacted with
+	 * @return scene objects
+	 */
+	public static final SceneObject[] getSceneObjects() {
+		return getSceneObjects(ALL_FILTER);
+	}
+	
+	/**
+	 * Returns array of sceneobjects with the first index to be the nearest
+	 * @param filter
+	 * @return sceneobjects
+	 */
+	public static final SceneObject[] getNearest(Filter<SceneObject> filter) {
+		final SceneObject[] objects = getSceneObjects(filter);
+		Arrays.sort(objects, NEAREST_SORTER);
+		return objects;
+	}
+	
+	/**
+	 * Returns array of sceneobjects with the first index to be the nearest
+	 * @return sceneobjects
+	 */
+	public static final SceneObject[] getNearest() {
+		return getNearest(ALL_FILTER);
+	}
+	
+	/**
+	 * Returns nearest objects with given id
+	 * @param ids
+	 * @return sceneobjects
+	 */
+	public static final SceneObject[] getNearest(final int... ids) {
+		return getNearest(new Filter<SceneObject>() {
+
+			@Override
+			public boolean accept(SceneObject object) {
+				for(final int id : ids) {
+					if(id == object.getId()) {
+						return true;
+					}
+				}
+				return false;
+			}
+			
+		});
+	}
+
+    public static final SceneObject getClosest(final int... ids) {
+    	SceneObject[] nearestObjects = getNearest(new Filter<SceneObject>() {
+
+            @Override
+            public boolean accept(SceneObject object) {
+                for(final int id : ids) {
+                    if(id == object.getId()) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+        });
+    	if(nearestObjects == null || nearestObjects.length == 0) {
+    		return null;
+    	}
+    	return nearestObjects[0];
+    }
+	
+	private static SceneObject getSceneObjectAtTile(int x, int y, boolean useCached) {
+		Ground sceneTile = Loader.getClient().getScene().getGroundArray()[0][x][y];
+		if(sceneTile == null) {
+			return null;
+		}
+		final SceneObjectTile[] interactiveObjects = sceneTile.getInteractiveObjects();
+		if(interactiveObjects != null) {
+			for(final SceneObjectTile interactiveObject : interactiveObjects) {
+				// get top
+				if(interactiveObject != null) {
+					return new SceneObject(interactiveObject, SceneObject.TYPE_INTERACTIVE);
+				}
+			}
+		}
+		SceneObjectTile sceneObjectTile = sceneTile.getWallObject();
+		if(sceneObjectTile != null) {
+			return new SceneObject(sceneObjectTile, SceneObject.TYPE_WALL);
+		}
+		return null;
+	}
+
+	/**
+	 * Gets every loaded scene object in game
+	 * @return every loaded scene object in game
+	 */
+	public static final SceneObject[] getAllSceneObjects() {
+		ArrayList<SceneObject> sceneObjects = new ArrayList<SceneObject>();
+		for(int x = 0; x < 104; x++) {
+			for(int y = 0; y < 104; y++) {
+				final Collection<SceneObject> sceneObjectsAtTile = getSceneObjectsAtTile(x, y, true);
+				if(sceneObjectsAtTile != null && !sceneObjectsAtTile.isEmpty()) {
+					sceneObjects.addAll(sceneObjectsAtTile);
+				}
+			}
+		}
+		return sceneObjects.toArray(new SceneObject[sceneObjects.size()]);
+	}
+	
+	/**
+	 * Gets all sceneobjects at a tile
+	 * @param x
+	 * @param y
+	 * @param useCached
+	 * @return array of sceneobjects, or null if there aren't any
+	 */
+	public static final Collection<SceneObject> getSceneObjectsAtTile(int x, int y, boolean useCached) {
+		Ground sceneTile = Loader.getClient().getScene().getGroundArray()[0][x][y];
+		ArrayList<SceneObject> sceneObjects = null;
+		final SceneObjectTile[] interactiveObjects = sceneTile.getInteractiveObjects();
+		if(interactiveObjects != null) {
+			for(final SceneObjectTile interactiveObject : interactiveObjects) {
+				if(interactiveObject != null) {
+					if(sceneObjects == null) {
+						sceneObjects = new ArrayList<SceneObject>();
+					}
+					sceneObjects.add(new SceneObject(interactiveObject, SceneObject.TYPE_INTERACTIVE));
+				}
+			}
+		}
+		SceneObjectTile sceneObjectTile = sceneTile.getWallObject();
+		if(sceneObjectTile != null) {
+			if(sceneObjects == null) {
+				sceneObjects = new ArrayList<SceneObject>();
+			}
+			sceneObjects.add(new SceneObject(sceneObjectTile, SceneObject.TYPE_WALL));
+		}
+		
+		sceneObjectTile = sceneTile.getWallDecoration();
+		if(sceneObjectTile != null) {
+			if(sceneObjects == null) {
+				sceneObjects = new ArrayList<SceneObject>();
+			}
+			sceneObjects.add(new SceneObject(sceneObjectTile, SceneObject.TYPE_WALLDECORATION));
+		}
+		
+		sceneObjectTile = sceneTile.getGroundDecoration();
+		if(sceneObjectTile != null) {
+			if(sceneObjects == null) {
+				sceneObjects = new ArrayList<SceneObject>();
+			}
+			sceneObjects.add(new SceneObject(sceneObjectTile, SceneObject.TYPE_GROUNDDECORATION));
+		}
+		
+		sceneObjectTile = sceneTile.getGroundItem();
+		if(sceneObjectTile != null) {
+			if(sceneObjects == null) {
+				sceneObjects = new ArrayList<SceneObject>();
+			}
+			sceneObjects.add(new SceneObject(sceneObjectTile, SceneObject.TYPE_GROUNDITEM));
+		}
+		return sceneObjects;
+	}
+
+}
+

src/org/rev317/api/methods/Skill.java

@@ -0,0 +1,180 @@
+package org.rev317.api.methods;
+
+import org.rev317.Loader;
+
+/**
+ * 
+ * @author Dane
+ * 
+ */
+public enum Skill {
+
+	ATTACK(0), DEFENSE(1), STRENGTH(2), HITPOINTS(3), CONSTITUTION(3), RANGE(4), PRAYER(
+			5), MAGIC(6), COOKING(7), WOODCUTTING(8), FLETCHING(9), FISHING(10), FIREMAKING(
+			11), CRAFTING(12), SMITHING(13), MINING(14), HERBLORE(15), HERBLAW(
+			15), AGILITY(16), THIEVING(17), SLAYER(18), FARMING(19), RUNECRAFTING(
+			20), HUNTER(21), CONSTRUCTION(22), SUMMONING(23), DUNGEONEERING(24);
+
+	private static final int[] EXPERIENCE = { 0, 0, 83, 174, 276, 388, 512,
+			650, 801, 969, 1154, 1358, 1584, 1833, 2107, 2411, 2746, 3115,
+			3523, 3973, 4470, 5018, 5624, 6291, 7028, 7842, 8740, 9730, 10824,
+			12031, 13363, 14833, 16456, 18247, 20224, 22406, 24815, 27473,
+			30408, 33648, 37224, 41171, 45529, 50339, 55649, 61512, 67983,
+			75127, 83014, 91721, 101333, 111945, 123660, 136594, 150872,
+			166636, 184040, 203254, 224466, 247886, 273742, 302288, 333804,
+			368599, 407015, 449428, 496254, 547953, 605032, 668051, 737627,
+			814445, 899257, 992895, 1096278, 1210421, 1336443, 1475581,
+			1629200, 1798808, 1986068, 2192818, 2421087, 2673114, 2951373,
+			3258594, 3597792, 3972294, 4385776, 4842295, 5346332, 5902831,
+			6517253, 7195629, 7944614, 8771558, 9684577, 10692629, 11805606,
+			13034431, 14391160, 15889109, 17542976, 19368992, 21385073,
+			23611006, 26068632, 28782069, 31777943, 35085654, 38737661,
+			42769801, 47221641, 52136869, 57563718, 63555443, 70170840,
+			77474828, 85539082, 94442737, 104273167 };
+
+	private int index;
+
+	private Skill(int index) {
+		this.index = index;
+	}
+
+	/**
+	 * Returns the skill's index.
+	 */
+	public int getIndex() {
+		return this.index;
+	}
+
+	/**
+	 * Returns the name of the skill.
+	 */
+	public final String getName() {
+		return Character.toUpperCase(name().charAt(0))
+				+ name().toLowerCase().substring(1);
+	}
+
+	/**
+	 * Returns the current experience.
+	 */
+	public final int getExperience() {
+		return Skill.getCurrentExperience(this.getIndex());
+	}
+
+	/**
+	 * Returns the real level.
+	 */
+	public final int getRealLevel() {
+		return Skill.getRealLevel(this.getIndex());
+	}
+
+	public final int getLevel() {
+		return Skill.getRealLevel(this.getIndex());
+	}
+
+	/**
+	 * Returns the remaining experience until the next level.
+	 */
+	public final int getRemaining() {
+		return Skill.getRemainingExperience(this.getIndex());
+	}
+
+	/**
+	 * Returns the percentage until the next level.
+	 */
+	public final int getPercentage() {
+		return Skill.getPercentToNextLevel(this.getIndex());
+	}
+
+	/**
+	 * Returns '[Name, Level / RealLevel]'
+	 */
+	@Override
+	public final String toString() {
+		return "Skill: [" + this.getName() + ": " + this.getLevel() + " / "
+				+ this.getRealLevel() + "]";
+	}
+
+	/**
+	 * Returns the experience of the provided skill.
+	 * 
+	 * @param index
+	 *            the skill index.
+	 * @return the experience.
+	 */
+	public static final int getCurrentExperience(int index) {
+		return Loader.getClient().getCurrentExp()[index];
+	}
+
+	/**
+	 * Returns the real level of the provided skill.
+	 * 
+	 * @param index
+	 *            the skill index.
+	 * @return the real skill level.
+	 */
+	public static final int getRealLevel(int index) {
+		return getLevelByExperience(getCurrentExperience(index));
+	}
+
+	/**
+	 * Returns the exact experience at the provided level.
+	 * 
+	 * @param level
+	 *            the level.
+	 * @return the experience at the provided level.
+	 */
+	public static final int getExperienceByLevel(int level) {
+		if (level > 99 || level < 1) {
+			return 0;
+		}
+		return EXPERIENCE[level];
+	}
+
+	/**
+	 * Returns the exact level with the provided experience.
+	 * 
+	 * @param experience
+	 *            the experience.
+	 * @return the level at the provided experience.
+	 */
+	public static final int getLevelByExperience(int experience) {
+		for (int i = EXPERIENCE.length - 1; i > 0; i--) {
+			if (experience > EXPERIENCE[i]) {
+				return i;
+			}
+		}
+		return 1;
+	}
+
+	/**
+	 * Returns the remaining experience for the provided skill to level up.
+	 * 
+	 * @param index
+	 *            the skill index.
+	 * @return the remaining experience.
+	 */
+	public static final int getRemainingExperience(int index) {
+		int level = getLevelByExperience(getCurrentExperience(index));
+		if (level >= 99 || level < 1) {
+			return 0;
+		}
+		return EXPERIENCE[(level + 1)] - getCurrentExperience(index);
+	}
+
+	/**
+	 * Returns the percentage to the next level for the provided skill.
+	 * 
+	 * @param index
+	 *            the skill index.
+	 * @return the remaining percentage.
+	 */
+	public static final int getPercentToNextLevel(int index) {
+		int currentLevel = getLevelByExperience(getCurrentExperience(index));
+		int nextLevel = currentLevel + 1;
+		if (currentLevel == 99 || nextLevel > 99 || currentLevel < 1
+				|| nextLevel < 1) {
+			return 0;
+		}
+		return (int) (100f * ((float) getCurrentExperience(index) / (float) EXPERIENCE[nextLevel]));
+	}
+}

src/org/rev317/api/methods/Walking.java

@@ -0,0 +1,32 @@
+package org.rev317.api.methods;
+
+import org.rev317.Loader;
+import org.rev317.api.wrappers.Tile;
+import org.rev317.api.wrappers.TilePath;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class Walking {
+	
+	public static void walkTo(Tile from, Tile to) {
+		Loader.getClient().walkTo(0, 0, 0, 0, from.getRegionY(), 0, 0, to.getRegionY(), from.getRegionX(), true, to.getRegionX());
+	}
+	
+	/**
+	 * 
+	 * @param tilePath
+	 * @return <b>true</b> if destination reached, otherwise <b>false</b>
+	 */
+	public static boolean walkDown(TilePath tilePath) {
+		if(tilePath.hasReached()) {
+			return true;
+		}
+		tilePath.traverse();
+		return false;
+	}
+
+}
+

src/org/rev317/api/wrappers/Character.java

@@ -0,0 +1,176 @@
+package org.rev317.api.wrappers;
+
+import org.rev317.Loader;
+import org.rev317.api.interfaces.Locatable;
+import org.rev317.api.methods.Calculations;
+import org.rev317.api.methods.Game;
+import org.rev317.api.methods.Menu;
+import org.rev317.api.methods.Players;
+
+/**
+ * 
+ * @author Everel
+ * 
+ */
+public class Character implements Locatable {
+
+	private org.rev317.accessors.Character accessor;
+	private int index;
+
+	public Character(org.rev317.accessors.Character accessor, int index) {
+		this.index = index;
+	}
+
+	/**
+	 * Gets local region x
+	 * 
+	 * @return x
+	 */
+	public int getX() {
+		return accessor.getX() >> 7;
+	}
+
+	/**
+	 * Gets local region y
+	 * 
+	 * @return y
+	 */
+	public int getY() {
+		return accessor.getY() >> 7;
+	}
+
+	/**
+	 * Index of the character array
+	 * 
+	 * @return index
+	 */
+	public int getIndex() {
+		return this.index;
+	}
+
+	/**
+	 * Animation of this character
+	 * 
+	 * @return animation
+	 */
+	public int getAnimation() {
+		return accessor.getAnimation();
+	}
+
+	/**
+	 * Location of this character
+	 * 
+	 * @return location
+	 */
+	public Tile getLocation() {
+		return new Tile(Game.getBaseX() + getX(), Game.getBaseY() + getY());
+	}
+
+	/**
+	 * Distance to this character
+	 * 
+	 * @return distance
+	 */
+	public int distanceTo() {
+		return (int) Calculations.distanceTo(getLocation());
+	}
+
+	/**
+	 * Interacts with this character
+	 * 
+	 * @param i
+	 */
+	public void interact(int i) {
+		Menu.interact(this, i);
+	}
+
+	/**
+	 * Gets current health
+	 * 
+	 * @return health
+	 */
+	public final int getHealth() {
+		return this.accessor.getCurrentHealth();
+	}
+
+	/**
+	 * Gets maximum health of this character
+	 * 
+	 * @return max health
+	 */
+	public final int getMaxHealth() {
+		return this.accessor.getMaxHealth();
+	}
+
+	/**
+	 * Fetches loop cycle status
+	 * 
+	 * @return loop cycle status
+	 */
+	public final int getLoopCycleStatus() {
+		return this.accessor.getLoopCycleStatus();
+	}
+
+	/**
+	 * Determines if entity is in combat
+	 * 
+	 * @return <b>true</b> if entity is in combat
+	 */
+	public boolean isInCombat() {
+		return accessor.getLoopCycleStatus() > Loader.getClient()
+				.getLoopCycle();
+	}
+
+	/**
+	 * Returns the character this character is interacting with
+	 * 
+	 * @return interacting character
+	 */
+	public final Character getInteractingCharacter() {
+		int index = this.accessor.getInteractingEntity();
+		if (index != -1 && index < 32768) {
+			return new Npc(Loader.getClient().getNpcs()[index], index);
+		} else if (index >= 32768) {
+			index -= 32768;
+			try {
+				if (Loader.getClient().getPlayers()[index] == null) {
+					return Players.getMyPlayer();
+				}
+				return new Player(Loader.getClient().getPlayers()[index], index);
+			} catch (Throwable t) {
+				return Players.getMyPlayer();
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result
+				+ ((accessor == null) ? 0 : accessor.hashCode());
+		result = prime * result + index;
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Character other = (Character) obj;
+		if (accessor == null) {
+			if (other.accessor != null)
+				return false;
+		} else if (!accessor.equals(other.accessor))
+			return false;
+		if (index != other.index)
+			return false;
+		return true;
+	}
+
+}

src/org/rev317/api/wrappers/GroundItem.java

@@ -0,0 +1,79 @@
+package org.rev317.api.wrappers;
+
+import org.rev317.api.interfaces.Locatable;
+import org.rev317.api.methods.Calculations;
+import org.rev317.api.methods.Game;
+import org.rev317.api.methods.Menu;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class GroundItem implements Locatable {
+	private org.rev317.accessors.Item accessor;
+	private int x;
+	private int y;
+	
+	public GroundItem(org.rev317.accessors.Item accessor, int x, int y) {
+		this.accessor = accessor;
+		this.x = x;
+		this.y = y;
+	}
+	
+	/**
+	 * Gets location of this ground item
+	 * @return location
+	 */
+	public Tile getLocation() {
+		return new Tile(Game.getBaseX() + x, Game.getBaseY() + y);
+	}
+	
+	/**
+	 * Gets region X
+	 * @return x
+	 */
+	public int getX() {
+		return x;
+	}
+	
+	/**
+	 * Gets region Y
+	 * @return y
+	 */
+	public int getY() {
+		return y;
+	}
+	
+	/**
+	 * Interacts with this ground item
+	 * @param actionIndex
+	 */
+	public void interact(int actionIndex) {
+		Menu.interact(this, actionIndex);
+	}
+	
+	/**
+	 * Takes this item from the ground
+	 */
+	public void take() {
+		Menu.take(this);
+	}
+
+	/**
+	 * Gets distance between you and this ground item
+	 * @return distance
+	 */
+	public int distanceTo() {
+		return (int) Calculations.distanceTo(getLocation());
+	}
+
+	/**
+	 * Get's ID of this item
+	 * @return ID
+	 */
+	public int getId() {
+		return accessor.getId();
+	}
+
+}

src/org/rev317/api/wrappers/Item.java

@@ -0,0 +1,63 @@
+package org.rev317.api.wrappers;
+
+import org.rev317.api.methods.Menu;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class Item {
+	private int id, stackSize;
+	private int slot;
+	
+	public Item(int id, int stackSize, int slot) {
+		this.id = id;
+		this.stackSize = stackSize;
+		this.slot = slot;
+	}
+	
+	/**
+	 * Get id of this item
+	 * @return id
+	 */
+	public int getId() {
+		return id;
+	}
+	
+	/**
+	 * Gets quantity of this item
+	 * @return stack size
+	 */
+	public int getStackSize() {
+		return stackSize;
+	}
+	
+	/**
+	 * Item slot
+	 * @return slot
+	 */
+	public int getSlot() {
+		return slot;
+	}
+	
+	/**
+	 * Drops this item
+	 */
+	public void drop() {
+		Menu.drop(this);
+	}
+
+	/**
+	 * Interacts with this item
+	 * @param i
+	 */
+	public void interact(int i) {
+		// TODO
+	}
+	
+	public void transform(int actionIndex, int interfaceParentId) {
+		Menu.transformItem(this, actionIndex, interfaceParentId);
+	}
+
+}

src/org/rev317/api/wrappers/Npc.java

@@ -0,0 +1,25 @@
+package org.rev317.api.wrappers;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public final class Npc extends Character {
+	private org.rev317.accessors.Npc accessor;
+
+	public Npc(org.rev317.accessors.Npc accessor, int index) {
+		super(accessor, index);
+		this.accessor = accessor;
+	}
+	
+	
+	/**
+	 * Gets the definition of this npc
+	 * @return npc definitions
+	 */
+	public final NpcDef getDef() {
+		return new NpcDef(this.accessor.getDef());
+	}
+
+}

src/org/rev317/api/wrappers/NpcDef.java

@@ -0,0 +1,24 @@
+package org.rev317.api.wrappers;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class NpcDef {
+	private org.rev317.accessors.NpcDef accessor;
+	
+	public NpcDef(org.rev317.accessors.NpcDef accessor) {
+		this.accessor = accessor;
+	}
+	
+	/**
+	 * Gets id of this item
+	 * @return id of this item
+	 */
+	public int getId() {
+		return accessor.getId();
+	}
+
+}
+

src/org/rev317/api/wrappers/Player.java

@@ -0,0 +1,13 @@
+package org.rev317.api.wrappers;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class Player extends Character {
+	
+	public Player(org.rev317.accessors.Player accessor, int index) {
+		super(accessor, index);
+	}
+}

src/org/rev317/api/wrappers/SceneObject.java

@@ -0,0 +1,102 @@
+package org.rev317.api.wrappers;
+
+import org.rev317.accessors.SceneObjectTile;
+import org.rev317.api.interfaces.Locatable;
+import org.rev317.api.methods.Calculations;
+import org.rev317.api.methods.Game;
+import org.rev317.api.methods.Menu;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class SceneObject implements Locatable {
+	public static final int TYPE_WALL = 0; // object1
+	public static final int TYPE_WALLDECORATION = 1; // object2
+	public static final int TYPE_GROUNDDECORATION = 2; // object3
+	public static final int TYPE_GROUNDITEM = 3; // object4
+	public static final int TYPE_INTERACTIVE = 4; // object5
+
+	public SceneObjectTile accessor;
+	private int type;
+
+	public SceneObject(SceneObjectTile accessor, int type) {
+		this.accessor = accessor;
+		this.type = type;
+	}
+
+	/**
+	 * Gets this object's hash
+	 * 
+	 * @return hash
+	 */
+	public final int getHash() {
+		return accessor.getHash();
+	}
+
+	/**
+	 * Gets location of this tile
+	 * @return location
+	 */
+	public final Tile getLocation() {
+		return new Tile(Game.getBaseX() + getLocalRegionX(), Game.getBaseY() + getLocalRegionY());
+	}
+
+	/**
+	 * Gets region X
+	 * @return region X
+	 */
+	public final int getLocalRegionX() {
+		return accessor.getHash() & 0x7f;
+	}
+
+	/**
+	 * Gets region Y
+	 * @return region Y
+	 */
+	public final int getLocalRegionY() {
+		return accessor.getHash() >> 7 & 0x7f;
+	}
+
+	/**
+	 * Gets this object's id
+	 * 
+	 * @return object id
+	 */
+	public final int getId() {
+		// TODO
+		return -1;
+	}
+
+	/**
+	 * Gets this object's type
+	 * 
+	 * @return type of object
+	 */
+	public final int getType() {
+		return type;
+	}
+
+	/**
+	 * Calculates distance to this object
+	 * @return distance
+	 */
+	public final int distanceTo() {
+		return (int) Calculations.distanceTo(getLocation());
+	}
+	
+	/**
+	 * Interacts with this object
+	 * @param actionIndex
+	 */
+	public void interact(int actionIndex) {
+		Menu.interact(this, actionIndex);
+	}
+	
+	@Override
+	public String toString() {
+		return String.format("[ID: %d, X: %d, Y: %d]", getId(), getLocalRegionX(), getLocalRegionY());
+	}
+
+}

src/org/rev317/api/wrappers/Tile.java

@@ -0,0 +1,141 @@
+package org.rev317.api.wrappers;
+
+import org.rev317.api.interfaces.TileFlags;
+import org.rev317.api.methods.Calculations;
+import org.rev317.api.methods.Game;
+import org.rev317.api.methods.Players;
+import org.rev317.api.methods.Walking;
+
+/**
+ * 
+ * Class which holds a world location
+ * 
+ * @author Everel
+ * 
+ */
+public final class Tile implements TileFlags {
+	private int x;
+	private int y;
+	private int z;
+
+	public Tile(int x, int y) {
+		this.x = x;
+		this.y = y;
+	}
+
+	public Tile(int x, int y, int z) {
+		this.x = x;
+		this.y = y;
+		this.z = z;
+	}
+
+	/**
+	 * Gets x
+	 * 
+	 * @return x
+	 */
+	public final int getX() {
+		return x;
+	}
+
+	/**
+	 * Gets y
+	 * 
+	 * @return y
+	 */
+	public final int getY() {
+		return y;
+	}
+
+	public final int getRegionX() {
+		return x - Game.getBaseX();
+	}
+	
+	public final int getRegionY() {
+		return y - Game.getBaseY();
+	}
+	
+	/**
+	 * Gets z/plane
+	 * 
+	 * @return plane
+	 */
+	public final int getPlane() {
+		return z;
+	}
+
+	public final int distanceTo() {
+		return (int) Calculations.distanceTo(this);
+	}
+
+	/**
+	 * Determines if this tile is on minimap
+	 * 
+	 * @return whether this tile is on minimap
+	 */
+	public final boolean isOnMinimap() {
+		return distanceTo() < 16;
+	}
+
+	@Override
+	public String toString() {
+		return "Tile: [" + getX() + ", " + getY() + "]";
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == null || obj.getClass() != this.getClass()) {
+			return false;
+		}
+		if (obj == this) {
+			return true;
+		}
+
+		final Tile t = (Tile) obj;
+		return t.getX() == this.getX() && t.getY() == this.getY()
+				&& t.getPlane() == this.getPlane();
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = 7;
+		hash = 31 * hash + this.x;
+		hash = 31 * hash + this.y;
+		hash = 31 * hash + this.z;
+		return hash;
+	}
+
+	/**
+	 * Walks to this tile
+	 */
+	public void walkTo() {
+		Walking.walkTo(Players.getMyPlayer().getLocation(), this);
+	}
+	
+	/**
+	 * Determines if this tile is walkable
+	 * @return <b>true</b> if this tile is walkable, otherwise <b>false</b>.
+	 */
+	public boolean isWalkable() {
+		return (Game.getCollisionFlags()[getRegionX()][getRegionY()] & 256) == 0;
+	}
+	
+	/**
+	 * 
+	 * @param isObject
+	 * @return
+	 */
+	public boolean isReachable(boolean isObject) {
+		Tile current = Players.getMyPlayer().getLocation();
+		return Calculations.dijkstraDist(current.getRegionX(), current.getRegionY(), getRegionX(), getRegionY(), isObjectTile()) > -1;
+	}
+	
+	public boolean isReachable() {
+		return isReachable(isObjectTile());
+	}
+	
+	public boolean isObjectTile() {
+		return (Game.getCollisionFlags()[getRegionX()][getRegionY()] & OBJECT_TILE) != 0;
+	}
+
+}

src/org/rev317/api/wrappers/TilePath.java

@@ -0,0 +1,82 @@
+package org.rev317.api.wrappers;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class TilePath {
+
+	private Tile[] tiles;
+
+	public TilePath(Tile[] tiles) {
+		this.tiles = tiles;
+	}
+
+	/**
+	 * Gets this path's tiles
+	 * 
+	 * @return path tiles
+	 */
+	public final Tile[] getTiles() {
+		return tiles;
+	}
+
+	/**
+	 * Gets next tile to walk to
+	 * 
+	 * @return tile
+	 */
+	public final Tile getNextTile() {
+		Tile next = null;
+		for (int x = 0; x < tiles.length; x++) {
+			if (tiles[x].isOnMinimap()) {
+				next = tiles[x];
+			}
+		}
+		return next;
+	}
+
+	/**
+	 * Determines if this path can be walked down
+	 * 
+	 * @return <b>true</b> if path is valid
+	 */
+	public final boolean isValid() {
+		return getNextTile() != null;
+	}
+
+	/**
+	 * Determines if player has reached end of path
+	 * 
+	 * @return <b>true</b> if player has reached end of path
+	 */
+	public final boolean hasReached() {
+		return tiles[tiles.length - 1].distanceTo() < 5;
+	}
+
+	/**
+	 * Walks down the path
+	 */
+	public final void traverse() {
+		final Tile next = getNextTile();
+		if (next == null) {
+			return;
+		}
+		next.walkTo();
+	}
+
+	/**
+	 * Reverses the current path
+	 * 
+	 * @return The reversed path
+	 */
+	public final TilePath reverse() {
+		Tile[] newTiles = new Tile[tiles.length];
+		for (int i = 0; i < tiles.length; i++)
+			newTiles[i] = tiles[tiles.length - i - 1];
+		return new TilePath(newTiles);
+	}
+
+}
+

src/org/rev317/callback/MenuAction.java

@@ -0,0 +1,10 @@
+package org.rev317.callback;
+
+/**
+ * 
+ * @author Everel
+ *
+ */
+public class MenuAction {
+
+}