From ab56f1c536b64263e6d2af92faec8e927118b4fe Mon Sep 17 00:00:00 2001 From: Clisprail Date: Thu, 13 Mar 2014 01:12:33 +0100 Subject: [PATCH] Minified API --- src/org/rev317/Loader.java | 10 + src/org/rev317/accessors/Character.java | 20 ++ src/org/rev317/accessors/Client.java | 39 +++ src/org/rev317/accessors/CollisionMap.java | 9 + src/org/rev317/accessors/Deque.java | 9 + src/org/rev317/accessors/Ground.java | 15 + src/org/rev317/accessors/Interface.java | 9 + src/org/rev317/accessors/Item.java | 8 + src/org/rev317/accessors/Node.java | 7 + src/org/rev317/accessors/Npc.java | 7 + src/org/rev317/accessors/NpcDef.java | 7 + src/org/rev317/accessors/Player.java | 5 + src/org/rev317/accessors/Scene.java | 7 + src/org/rev317/accessors/SceneObjectTile.java | 7 + src/org/rev317/api/interfaces/Locatable.java | 24 ++ src/org/rev317/api/interfaces/TileFlags.java | 18 ++ src/org/rev317/api/methods/Bank.java | 293 ++++++++++++++++++ src/org/rev317/api/methods/Calculations.java | 153 +++++++++ src/org/rev317/api/methods/Game.java | 60 ++++ src/org/rev317/api/methods/GroundItems.java | 155 +++++++++ src/org/rev317/api/methods/Inventory.java | 186 +++++++++++ src/org/rev317/api/methods/Menu.java | 186 +++++++++++ src/org/rev317/api/methods/Npcs.java | 113 +++++++ src/org/rev317/api/methods/Players.java | 93 ++++++ src/org/rev317/api/methods/SceneObjects.java | 219 +++++++++++++ src/org/rev317/api/methods/Skill.java | 180 +++++++++++ src/org/rev317/api/methods/Walking.java | 32 ++ src/org/rev317/api/wrappers/Character.java | 176 +++++++++++ src/org/rev317/api/wrappers/GroundItem.java | 79 +++++ src/org/rev317/api/wrappers/Item.java | 63 ++++ src/org/rev317/api/wrappers/Npc.java | 25 ++ src/org/rev317/api/wrappers/NpcDef.java | 24 ++ src/org/rev317/api/wrappers/Player.java | 13 + src/org/rev317/api/wrappers/SceneObject.java | 102 ++++++ src/org/rev317/api/wrappers/Tile.java | 141 +++++++++ src/org/rev317/api/wrappers/TilePath.java | 82 +++++ src/org/rev317/callback/MenuAction.java | 10 + 37 files changed, 2586 insertions(+) create mode 100644 src/org/rev317/accessors/Character.java create mode 100644 src/org/rev317/accessors/Client.java create mode 100644 src/org/rev317/accessors/CollisionMap.java create mode 100644 src/org/rev317/accessors/Deque.java create mode 100644 src/org/rev317/accessors/Ground.java create mode 100644 src/org/rev317/accessors/Interface.java create mode 100644 src/org/rev317/accessors/Item.java create mode 100644 src/org/rev317/accessors/Node.java create mode 100644 src/org/rev317/accessors/Npc.java create mode 100644 src/org/rev317/accessors/NpcDef.java create mode 100644 src/org/rev317/accessors/Player.java create mode 100644 src/org/rev317/accessors/Scene.java create mode 100644 src/org/rev317/accessors/SceneObjectTile.java create mode 100644 src/org/rev317/api/interfaces/Locatable.java create mode 100644 src/org/rev317/api/interfaces/TileFlags.java create mode 100644 src/org/rev317/api/methods/Bank.java create mode 100644 src/org/rev317/api/methods/Calculations.java create mode 100644 src/org/rev317/api/methods/Game.java create mode 100644 src/org/rev317/api/methods/GroundItems.java create mode 100644 src/org/rev317/api/methods/Inventory.java create mode 100644 src/org/rev317/api/methods/Menu.java create mode 100644 src/org/rev317/api/methods/Npcs.java create mode 100644 src/org/rev317/api/methods/Players.java create mode 100644 src/org/rev317/api/methods/SceneObjects.java create mode 100644 src/org/rev317/api/methods/Skill.java create mode 100644 src/org/rev317/api/methods/Walking.java create mode 100644 src/org/rev317/api/wrappers/Character.java create mode 100644 src/org/rev317/api/wrappers/GroundItem.java create mode 100644 src/org/rev317/api/wrappers/Item.java create mode 100644 src/org/rev317/api/wrappers/Npc.java create mode 100644 src/org/rev317/api/wrappers/NpcDef.java create mode 100644 src/org/rev317/api/wrappers/Player.java create mode 100644 src/org/rev317/api/wrappers/SceneObject.java create mode 100644 src/org/rev317/api/wrappers/Tile.java create mode 100644 src/org/rev317/api/wrappers/TilePath.java create mode 100644 src/org/rev317/callback/MenuAction.java diff --git a/src/org/rev317/Loader.java b/src/org/rev317/Loader.java index b414080..58b539d 100644 --- a/src/org/rev317/Loader.java +++ b/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(); + } } diff --git a/src/org/rev317/accessors/Character.java b/src/org/rev317/accessors/Character.java new file mode 100644 index 0000000..946aca6 --- /dev/null +++ b/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(); + +} + diff --git a/src/org/rev317/accessors/Client.java b/src/org/rev317/accessors/Client.java new file mode 100644 index 0000000..41d57f8 --- /dev/null +++ b/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); + + +} diff --git a/src/org/rev317/accessors/CollisionMap.java b/src/org/rev317/accessors/CollisionMap.java new file mode 100644 index 0000000..258583f --- /dev/null +++ b/src/org/rev317/accessors/CollisionMap.java @@ -0,0 +1,9 @@ +package org.rev317.accessors; + + +public interface CollisionMap { + + public int[][] getFlags(); + +} + diff --git a/src/org/rev317/accessors/Deque.java b/src/org/rev317/accessors/Deque.java new file mode 100644 index 0000000..ffd4f66 --- /dev/null +++ b/src/org/rev317/accessors/Deque.java @@ -0,0 +1,9 @@ +package org.rev317.accessors; + +public interface Deque { + + public Node getHead(); + + public Node getCurrent(); + +} diff --git a/src/org/rev317/accessors/Ground.java b/src/org/rev317/accessors/Ground.java new file mode 100644 index 0000000..2cad588 --- /dev/null +++ b/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(); + +} diff --git a/src/org/rev317/accessors/Interface.java b/src/org/rev317/accessors/Interface.java new file mode 100644 index 0000000..846ea2d --- /dev/null +++ b/src/org/rev317/accessors/Interface.java @@ -0,0 +1,9 @@ +package org.rev317.accessors; + +public interface Interface { + + public int[] getItems(); + + public int[] getStackSizes(); + +} diff --git a/src/org/rev317/accessors/Item.java b/src/org/rev317/accessors/Item.java new file mode 100644 index 0000000..3e39ffb --- /dev/null +++ b/src/org/rev317/accessors/Item.java @@ -0,0 +1,8 @@ +package org.rev317.accessors; + +public interface Item { + + public int getId(); + +} + diff --git a/src/org/rev317/accessors/Node.java b/src/org/rev317/accessors/Node.java new file mode 100644 index 0000000..90289d4 --- /dev/null +++ b/src/org/rev317/accessors/Node.java @@ -0,0 +1,7 @@ +package org.rev317.accessors; + +public interface Node { + + public Node getNext(); + +} diff --git a/src/org/rev317/accessors/Npc.java b/src/org/rev317/accessors/Npc.java new file mode 100644 index 0000000..3ab0c66 --- /dev/null +++ b/src/org/rev317/accessors/Npc.java @@ -0,0 +1,7 @@ +package org.rev317.accessors; + +public interface Npc extends Character { + + public NpcDef getDef(); + +} \ No newline at end of file diff --git a/src/org/rev317/accessors/NpcDef.java b/src/org/rev317/accessors/NpcDef.java new file mode 100644 index 0000000..b751dee --- /dev/null +++ b/src/org/rev317/accessors/NpcDef.java @@ -0,0 +1,7 @@ +package org.rev317.accessors; + +public interface NpcDef { + + public int getId(); + +} diff --git a/src/org/rev317/accessors/Player.java b/src/org/rev317/accessors/Player.java new file mode 100644 index 0000000..0628eac --- /dev/null +++ b/src/org/rev317/accessors/Player.java @@ -0,0 +1,5 @@ +package org.rev317.accessors; + +public interface Player extends Character { + +} diff --git a/src/org/rev317/accessors/Scene.java b/src/org/rev317/accessors/Scene.java new file mode 100644 index 0000000..10ea2a9 --- /dev/null +++ b/src/org/rev317/accessors/Scene.java @@ -0,0 +1,7 @@ +package org.rev317.accessors; + +public interface Scene { + + public Ground[][][] getGroundArray(); + +} diff --git a/src/org/rev317/accessors/SceneObjectTile.java b/src/org/rev317/accessors/SceneObjectTile.java new file mode 100644 index 0000000..0cee4e8 --- /dev/null +++ b/src/org/rev317/accessors/SceneObjectTile.java @@ -0,0 +1,7 @@ +package org.rev317.accessors; + +public interface SceneObjectTile { + + public int getHash(); + +} \ No newline at end of file diff --git a/src/org/rev317/api/interfaces/Locatable.java b/src/org/rev317/api/interfaces/Locatable.java new file mode 100644 index 0000000..b67ff93 --- /dev/null +++ b/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(); + +} diff --git a/src/org/rev317/api/interfaces/TileFlags.java b/src/org/rev317/api/interfaces/TileFlags.java new file mode 100644 index 0000000..bc00b85 --- /dev/null +++ b/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; + +} diff --git a/src/org/rev317/api/methods/Bank.java b/src/org/rev317/api/methods/Bank.java new file mode 100644 index 0000000..f2f015a --- /dev/null +++ b/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() { + + @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 true 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 ignored = new ArrayList(); + 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 items = new ArrayList(); + 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 true if bank is open + */ + public static boolean isOpen() { + return Loader.getClient().getOpenInterfaceId() == BANK_INTERFACE; + } + +} diff --git a/src/org/rev317/api/methods/Calculations.java b/src/org/rev317/api/methods/Calculations.java new file mode 100644 index 0000000..e6a61c2 --- /dev/null +++ b/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; + } + } + +} diff --git a/src/org/rev317/api/methods/Game.java b/src/org/rev317/api/methods/Game.java new file mode 100644 index 0000000..1359f57 --- /dev/null +++ b/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(); + } + +} diff --git a/src/org/rev317/api/methods/GroundItems.java b/src/org/rev317/api/methods/GroundItems.java new file mode 100644 index 0000000..2abc679 --- /dev/null +++ b/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 NEAREST_SORTER = new Comparator() { + + @Override + public int compare(GroundItem n1, GroundItem n2) { + return n1.distanceTo() - n2.distanceTo(); + } + + }; + + private static final Filter ALL_FILTER = new Filter() { + + @Override + public boolean accept(GroundItem item) { + return true; + } + + }; + + /** + * Gets all loaded ground items + * + * @return ground item array + */ + public final static GroundItem[] getGroundItems( + final Filter filter) { + if (client == null) { + client = Loader.getClient(); + } + final ArrayList items = new ArrayList(); + 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 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(); + } + 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 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() { + + @Override + public boolean accept(GroundItem object) { + for (final int id : ids) { + if (id == object.getId()) { + return true; + } + } + return false; + } + + }); + } + +} \ No newline at end of file diff --git a/src/org/rev317/api/methods/Inventory.java b/src/org/rev317/api/methods/Inventory.java new file mode 100644 index 0000000..7b3f80c --- /dev/null +++ b/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 ALL_FILTER = new Filter() { + + @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() { + + @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 filter) { + final Interface inventory = getInterface(); + if(inventory == null) { + return null; + } + final int[] items = inventory.getItems(); + final int[] stackSizes = inventory.getStackSizes(); + final ArrayList invItems = new ArrayList(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 true if inventory is full, otherwise false + */ + public static final boolean isFull() { + return Inventory.getCount() == 28; + } + + /** + * Determines if inventory is empty + * @return true if inventory is empty, otherwise false + */ + public static final boolean isEmpty() { + return Inventory.getCount() == 0; + } + +} + diff --git a/src/org/rev317/api/methods/Menu.java b/src/org/rev317/api/methods/Menu.java new file mode 100644 index 0000000..6a2c650 --- /dev/null +++ b/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 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); + } + +} + diff --git a/src/org/rev317/api/methods/Npcs.java b/src/org/rev317/api/methods/Npcs.java new file mode 100644 index 0000000..91a695f --- /dev/null +++ b/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 NEAREST_SORTER = new Comparator() { + + @Override + public int compare(Npc n1, Npc n2) { + return n1.distanceTo() - n2.distanceTo(); + } + + }; + + private static final Filter ALL_FILTER = new Filter() { + + @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 filter) { + final Client client = Loader.getClient(); + ArrayList npcList = new ArrayList(); + 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 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() { + + @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); + } + +} diff --git a/src/org/rev317/api/methods/Players.java b/src/org/rev317/api/methods/Players.java new file mode 100644 index 0000000..440b961 --- /dev/null +++ b/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 NEAREST_SORTER = new Comparator() { + + @Override + public int compare(Player p1, Player p2) { + return p1.distanceTo() - p2.distanceTo(); + } + + }; + + private static final Filter ALL_FILTER = new Filter() { + + @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 filter) { + final Client client = Loader.getClient(); + ArrayList playerList = new ArrayList(); + 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 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); + } + +} \ No newline at end of file diff --git a/src/org/rev317/api/methods/SceneObjects.java b/src/org/rev317/api/methods/SceneObjects.java new file mode 100644 index 0000000..1a31995 --- /dev/null +++ b/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 NEAREST_SORTER = new Comparator() { + + @Override + public int compare(SceneObject n1,SceneObject n2) { + return n1.distanceTo() - n2.distanceTo(); + } + + }; + + private static final Filter ALL_FILTER = new Filter() { + + @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 filter) { + ArrayList sceneObjects = new ArrayList(); + 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 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() { + + @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() { + + @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 sceneObjects = new ArrayList(); + for(int x = 0; x < 104; x++) { + for(int y = 0; y < 104; y++) { + final Collection 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 getSceneObjectsAtTile(int x, int y, boolean useCached) { + Ground sceneTile = Loader.getClient().getScene().getGroundArray()[0][x][y]; + ArrayList sceneObjects = null; + final SceneObjectTile[] interactiveObjects = sceneTile.getInteractiveObjects(); + if(interactiveObjects != null) { + for(final SceneObjectTile interactiveObject : interactiveObjects) { + if(interactiveObject != null) { + if(sceneObjects == null) { + sceneObjects = new ArrayList(); + } + sceneObjects.add(new SceneObject(interactiveObject, SceneObject.TYPE_INTERACTIVE)); + } + } + } + SceneObjectTile sceneObjectTile = sceneTile.getWallObject(); + if(sceneObjectTile != null) { + if(sceneObjects == null) { + sceneObjects = new ArrayList(); + } + sceneObjects.add(new SceneObject(sceneObjectTile, SceneObject.TYPE_WALL)); + } + + sceneObjectTile = sceneTile.getWallDecoration(); + if(sceneObjectTile != null) { + if(sceneObjects == null) { + sceneObjects = new ArrayList(); + } + sceneObjects.add(new SceneObject(sceneObjectTile, SceneObject.TYPE_WALLDECORATION)); + } + + sceneObjectTile = sceneTile.getGroundDecoration(); + if(sceneObjectTile != null) { + if(sceneObjects == null) { + sceneObjects = new ArrayList(); + } + sceneObjects.add(new SceneObject(sceneObjectTile, SceneObject.TYPE_GROUNDDECORATION)); + } + + sceneObjectTile = sceneTile.getGroundItem(); + if(sceneObjectTile != null) { + if(sceneObjects == null) { + sceneObjects = new ArrayList(); + } + sceneObjects.add(new SceneObject(sceneObjectTile, SceneObject.TYPE_GROUNDITEM)); + } + return sceneObjects; + } + +} + diff --git a/src/org/rev317/api/methods/Skill.java b/src/org/rev317/api/methods/Skill.java new file mode 100644 index 0000000..b9f4f30 --- /dev/null +++ b/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])); + } +} diff --git a/src/org/rev317/api/methods/Walking.java b/src/org/rev317/api/methods/Walking.java new file mode 100644 index 0000000..569ed63 --- /dev/null +++ b/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 true if destination reached, otherwise false + */ + public static boolean walkDown(TilePath tilePath) { + if(tilePath.hasReached()) { + return true; + } + tilePath.traverse(); + return false; + } + +} + diff --git a/src/org/rev317/api/wrappers/Character.java b/src/org/rev317/api/wrappers/Character.java new file mode 100644 index 0000000..f0223cd --- /dev/null +++ b/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 true 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; + } + +} diff --git a/src/org/rev317/api/wrappers/GroundItem.java b/src/org/rev317/api/wrappers/GroundItem.java new file mode 100644 index 0000000..c073b0e --- /dev/null +++ b/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(); + } + +} diff --git a/src/org/rev317/api/wrappers/Item.java b/src/org/rev317/api/wrappers/Item.java new file mode 100644 index 0000000..b90e4bf --- /dev/null +++ b/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); + } + +} diff --git a/src/org/rev317/api/wrappers/Npc.java b/src/org/rev317/api/wrappers/Npc.java new file mode 100644 index 0000000..ba6c23f --- /dev/null +++ b/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()); + } + +} diff --git a/src/org/rev317/api/wrappers/NpcDef.java b/src/org/rev317/api/wrappers/NpcDef.java new file mode 100644 index 0000000..832acd4 --- /dev/null +++ b/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(); + } + +} + diff --git a/src/org/rev317/api/wrappers/Player.java b/src/org/rev317/api/wrappers/Player.java new file mode 100644 index 0000000..cdedb53 --- /dev/null +++ b/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); + } +} diff --git a/src/org/rev317/api/wrappers/SceneObject.java b/src/org/rev317/api/wrappers/SceneObject.java new file mode 100644 index 0000000..e4503db --- /dev/null +++ b/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()); + } + +} diff --git a/src/org/rev317/api/wrappers/Tile.java b/src/org/rev317/api/wrappers/Tile.java new file mode 100644 index 0000000..17da420 --- /dev/null +++ b/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 true if this tile is walkable, otherwise false. + */ + 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; + } + +} diff --git a/src/org/rev317/api/wrappers/TilePath.java b/src/org/rev317/api/wrappers/TilePath.java new file mode 100644 index 0000000..53821ae --- /dev/null +++ b/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 true if path is valid + */ + public final boolean isValid() { + return getNextTile() != null; + } + + /** + * Determines if player has reached end of path + * + * @return true 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); + } + +} + diff --git a/src/org/rev317/callback/MenuAction.java b/src/org/rev317/callback/MenuAction.java new file mode 100644 index 0000000..51dc1a5 --- /dev/null +++ b/src/org/rev317/callback/MenuAction.java @@ -0,0 +1,10 @@ +package org.rev317.callback; + +/** + * + * @author Everel + * + */ +public class MenuAction { + +}