rendered paste bodypackage impsoft.nexus.bots.arga.methods;import java.awt.Rectangle;import com.ms.arga.hooks.*;import com.ms.arga.hooks.Character;import impsoft.nexus.bots.arga.scriptsobjects.Tile;import impsoft.nexus.bots.color.methods.BasicColorMethods;import impsoft.nexus.bots.color.scriptobjects.XY;public abstract class argaMethods extends BasicColorMethods { public Client theClient; public final void setClient(Client client) { theClient = client; } public final Player getPlayer() { return theClient.getMyPlayer(); } public final int getAnimation(Player player) { return player.getAnimation(); } public boolean isMoving() { return (getPlayer().isMoving() > 0); } public final int getFightMode() { return theClient.getSettingsArray()[43]; } public final int getInventoryCount() { try { int rez = 0; for (int i = 0; i < 28; i++) if (getInventoryArray()[i] > 0) rez++; return rez; } catch (Exception e) { return 0; } } public final int getInventoryCount(int itemID) { try { int rez = 0; for (int i = 0; i < 28; i++) if (getInventoryArray()[i] == itemID) rez++; return rez; } catch (Exception e) { return 0; } } public final Tile getTile(Character c) { int x = theClient.getBaseX() + (c.getCharX() >> 7); int y = theClient.getBaseY() + (c.getCharY() >> 7); return (new Tile(x, y)); } public final XY getScreenXY(Character c) { return TileToScreen(getTile(c), (c.getHeight()) / 2); } public final XY getScreenXY(int objectUid) { return TileToScreen(getTile(objectUid), 0); } public final XY TileToScreen(Tile t, int height) { return TileToScreen((t.x - theClient.getBaseX() + 0.5) * 128, (t.y - theClient.getBaseY() + 0.5) * 128, height); } public final int getObjectAt(Tile t) { return getObjectAt(t.x, t.y); } private final int getObjectAt(int x, int y) { for (int i = 0; i < 4; i++) { try { Ground ground = theClient.getWorldClassInstance() .getGroundArray()[i][x - theClient.getBaseX()][y - theClient.getBaseY()]; if (ground != null) { if (ground.getObject5Array() != null) { for (Thing obj : ground.getObject5Array()) if (obj != null && obj.getUID() != -1) return obj.getUID(); } if (ground.getObject4() != null && ground.getObject4().getUID() != -1) return ground.getObject4().getUID(); if (ground.getObject3() != null && ground.getObject3().getUID() != -1) return ground.getObject3().getUID(); if (ground.getObject2() != null && ground.getObject2().getUID() != -1) return ground.getObject2().getUID(); if (ground.getObject1() != null && ground.getObject1().getUID() != -1) return ground.getObject1().getUID(); } } catch (Exception e) { } } return -1; } /** * from SAL Methods */ private final Interface[][] getInterfaceCache() { try { return theClient.getInterfaceCache(); } catch (Exception e) { exception(e); return new Interface[0][0]; } } public int getInterface(){ return theClient.getCurrentInterface(); } /** * from SAL Methods */ public final int[] getInventoryArray() { try { int inv[] = getInterfaceCache()[149][0].getInventoryArray(); int sortOut[] = new int[inv.length]; for (int i = 0; i < inv.length; i++) { sortOut[i] = inv[i] - 1; } return sortOut; } catch (Exception e) { exception(e); return new int[0]; } } /** * from SAL Methods */ public final XY TileToMinimap(Tile tile) { int x = tile.x-theClient.getBaseX(); int y = tile.y-theClient.getBaseY(); int i = (x * 4 + 2) - getPlayer().getCharX() / 32; int j = (y * 4 + 2) - getPlayer().getCharY() / 32; int k = theClient.getMinimapInt1() + theClient.getMinimapInt2() & 0x7ff; int l = j * j + i * i; if (l > 6400) return null; int i1 = theClient.getCurveArray1()[k]; int j1 = theClient.getCurveArray2()[k]; i1 = (i1 * 256) / (theClient.getMinimapInt3() + 256); j1 = (j1 * 256) / (theClient.getMinimapInt3() + 256); int k1 = j * i1 + i * j1 >> 16; int l1 = j * j1 - i * i1 >> 16; int screenx = 550 + ((94 + k1) + 4); int screeny = 4 + (83 - l1 - 4); return new XY(screenx, screeny); } /** * from SAL Methods */ public final XY TileToScreen(double x, double y, int height) { try { int z = terrainCalc(x, y) - (height / 2); x -= theClient.getCamPosX(); y -= theClient.getCamPosY(); z -= theClient.getCamPosZ(); int yCurve1 = theClient.getCurveArray2()[theClient.getCamCurveY()]; int yCurve2 = theClient.getCurveArray1()[theClient.getCamCurveY()]; int xCurve1 = theClient.getCurveArray2()[theClient.getCamCurveX()]; int xCurve2 = theClient.getCurveArray1()[theClient.getCamCurveX()]; int store = (int) (((yCurve1 * x) + (yCurve2 * y))) >> 16; y = (int) (((y * yCurve1) - (yCurve2 * x))) >> 16; x = store; int store2 = (int) (((xCurve1 * z) - (xCurve2 * y))) >> 16; y = (int) (((y * xCurve1) + (z * xCurve2))) >> 16; z = (int) store2; int screenX = (int) (((int) x << 9) / y + 256); int screenY = (int) (int) ((z << 9) / y + 167); if (screenX > 516 || screenY > 337) return null; return new XY(screenX, screenY); } catch (Exception e) { exception(e); } return null; } /** * from SAL Methods */ private final int terrainCalc(double x, double y) { int x1 = (int) x >> 7; int y1 = (int) y >> 7; if (~x1 > -1 || y1 < 0 || x1 > 103 || y1 > 103) return 0; int j1 = theClient.getTerrainInt(); if (j1 < 3 && (2 & theClient.getGroundByteArray()[1][x1][y1]) == 2) j1++; int l1 = 0x7f & (int) y; int k1 = (int) x & 0x7f; int i2 = theClient.getGroundIntArray()[j1][1 + x1][y1] * k1 + (128 + -k1) * theClient.getGroundIntArray()[j1][x1][y1] >> 0xaf78bd87; int j2 = theClient.getGroundIntArray()[j1][1 + x1][1 + y1] * k1 + theClient.getGroundIntArray()[j1][x1][y1 + 1] * (128 - k1) >> 0xbe451847; return j2 * l1 + (-l1 + 128) * i2 >> 0x75faec87; } public final int getObject(int type, int searchConstraints) { return getObject(new int[] { type }, searchConstraints); } public final int objectType(int uid) { return uid >> 14 & 0x7fff; } public final Tile getTile(int objectUid) { return new Tile(theClient.getBaseX() + (objectUid & 0x7f), theClient .getBaseY() + (objectUid >> 7 & 0x7f)); } public final int getObject(int[] types, int searchConstraints) { boolean ON_MINI_MAP = SC.isConstraintSet(searchConstraints, SC.ON_MINI_MAP_BIT_INDEX); boolean ON_SCREEN = SC.isConstraintSet(searchConstraints, SC.ON_SCREEN_BIT_INDEX); boolean NO_PLAYER_WITH_ANIMATION_NEXT_TO = SC.isConstraintSet( searchConstraints, SC.NO_PLAYER_WITH_ANIMATION_NEXT_TO_BIT_INDEX); Tile playerTile = getTile(getPlayer()); Rectangle bounds = new Rectangle(theClient.getBaseX(), theClient .getBaseY(), 104, 104); int startX = playerTile.x; int startY = playerTile.y; int dx = 0; int dy = 0; int relX, relY; int size = 0; int bX = bounds.x; int bY = bounds.y; int bW = bounds.width; int bH = bounds.height; int maxsize = 0; if (maxsize < startX - bX) { maxsize = startX - bX; } if (maxsize < bX + bW - startX) { maxsize = bX + bW - startX; } if (maxsize < startY - bY) { maxsize = startY - bY; } if (maxsize < bY + bH - startY) { maxsize = bY + bH - startY; } int obj = getObjectAt(playerTile); if (obj != -1) for (int typeIdx = 0; typeIdx < types.length; typeIdx++) { if (types[typeIdx] == objectType(obj)) { return obj; } } while (size < maxsize) { if (dy == size && dx < size && dx > 0) dx++; else if (dx == 0 && dy >= 0) { dy++; dx++; size++; } else if (dy == size && dx < 0) dx++; else if (dy == (-1 * size) && dx > (-1 * size)) dx--; else if (dx == size) dy--; else if (dx == -1 * size) dy++; relX = startX + dx; relY = startY + dy; if (bX < relX && relX < bX + bW && bY < relY && relY < bY + bH) { obj = getObjectAt(relX, relY); if (obj != -1) for (int typeIdx = 0; typeIdx < types.length; typeIdx++) { if (types[typeIdx] == objectType(obj)) { if (ON_MINI_MAP && TileToMinimap(getTile(obj)) == null) { continue; } if (ON_SCREEN && TileToScreen(getTile(obj), 0) == null) { continue; } if (NO_PLAYER_WITH_ANIMATION_NEXT_TO) { Tile tileObj = getTile(obj); int[] playerIndexs = theClient.getPlayerIndexArray(); Player[] players = theClient.getPlayerArray(); for (int i = 0; i < players.length; i++) { Player player = players[playerIndexs[i]]; if (player == null) continue; Tile tilePlayer = getTile(player); if (tilePlayer == null) continue; if (distance(tilePlayer, tileObj) < 2 && player.getAnimation() != -1) { continue; } } } return obj; } } } } return -1; } public final NPC getNPC(String name, int searchConstraints) { return getNPC(new String[] { name }, searchConstraints); } public final NPC getNPC(int type, int searchConstraints) { return getNPC(new int[] { type }, searchConstraints); } public final NPC getNPC(int types[], int searchConstraints) { boolean ON_MINI_MAP = SC.isConstraintSet(searchConstraints, SC.ON_MINI_MAP_BIT_INDEX); boolean ON_SCREEN = SC.isConstraintSet(searchConstraints, SC.ON_SCREEN_BIT_INDEX); boolean NOT_IN_COMBAT_BIT_INDEX = SC.isConstraintSet(searchConstraints, SC.NOT_IN_COMBAT); Tile player = getTile(getPlayer()); int winnerDist = 1000; NPC winner = null; int[] npcIndexs = theClient.getNPCIndexArray(); NPC[] npcs = theClient.getNPCArray(); for (int i = 0; i < npcIndexs.length; i++) { try { NPC npc = npcs[npcIndexs[i]]; if (npc == null) continue; Tile tileNpc = getTile(npc); if (tileNpc == null) continue; if (ON_MINI_MAP && TileToMinimap(tileNpc) == null) { continue; } if (ON_SCREEN && TileToScreen(tileNpc, npc.getHeight() / 2) == null) { continue; } if (NOT_IN_COMBAT_BIT_INDEX && npc.getInteractingChar() != -1) { continue; } for (int typeIndex = 0; typeIndex < types.length; typeIndex++) { if (types[typeIndex] != npc.getNPCDef().getNPCType()) continue; int challengerDist = distance(player, getTile(npc)); if (challengerDist < winnerDist) { winnerDist = challengerDist; winner = npc; break; } } } catch (Exception e) { exception(e); } } return winner; } public final NPC getNPC(String names[], int searchConstraints) { boolean ON_MINI_MAP = SC.isConstraintSet(searchConstraints, SC.ON_MINI_MAP_BIT_INDEX); boolean ON_SCREEN = SC.isConstraintSet(searchConstraints, SC.ON_SCREEN_BIT_INDEX); boolean NOT_IN_COMBAT_BIT_INDEX = SC.isConstraintSet(searchConstraints, SC.NOT_IN_COMBAT); Tile player = getTile(getPlayer()); int winnerDist = 1000; NPC winner = null; int[] npcIndexs = theClient.getNPCIndexArray(); NPC[] npcs = theClient.getNPCArray(); for (int i = 0; i < npcIndexs.length; i++) { try { NPC npc = npcs[npcIndexs[i]]; Tile tileNpc = getTile(npc); if (npc == null) continue; if (ON_MINI_MAP && TileToMinimap(tileNpc) == null) { continue; } if (ON_SCREEN && TileToScreen(tileNpc, npc.getHeight() / 2) == null) { continue; } if (NOT_IN_COMBAT_BIT_INDEX && npc.getInteractingChar() != -1) { continue; } for (int nameIndex = 0; nameIndex < names.length; nameIndex++) { if (!names[nameIndex].equals(unwrap(npc.getNPCDef() .getNPCName()))) continue; int challengerDist = distance(player, getTile(npc)); if (challengerDist < winnerDist) { winnerDist = challengerDist; winner = npc; break; } } } catch (Exception e) { exception(e); } } return winner; } public final NPC getNPC(String names[], int types[], int searchConstraints) { boolean ON_MINI_MAP = SC.isConstraintSet(searchConstraints, SC.ON_MINI_MAP_BIT_INDEX); boolean ON_SCREEN = SC.isConstraintSet(searchConstraints, SC.ON_SCREEN_BIT_INDEX); boolean NOT_IN_COMBAT_BIT_INDEX = SC.isConstraintSet(searchConstraints, SC.NOT_IN_COMBAT); Tile player = getTile(getPlayer()); int winnerDist = 1000; NPC winner = null; int[] npcIndexs = theClient.getNPCIndexArray(); NPC[] npcs = theClient.getNPCArray(); for (int i = 0; i < npcIndexs.length; i++) { try { NPC npc = npcs[npcIndexs[i]]; Tile npcTile = getTile(npc); if (npc == null) continue; if (ON_MINI_MAP && TileToMinimap(npcTile) == null) { continue; } if (ON_SCREEN && TileToScreen(npcTile, npc.getHeight() / 2) == null) { continue; } if (NOT_IN_COMBAT_BIT_INDEX && npc.getInteractingChar() != -1) { continue; } for (int nameIndex = 0; nameIndex < names.length; nameIndex++) { if (!names[nameIndex].equals(unwrap(npc.getNPCDef() .getNPCName()))) continue; int challengerDist = distance(player, getTile(npc)); if (challengerDist < winnerDist) { winnerDist = challengerDist; winner = npc; break; } } for (int typeIndex = 0; typeIndex < types.length; typeIndex++) { if (types[typeIndex] != npc.getNPCDef().getNPCType()) continue; int challengerDist = distance(player, getTile(npc)); if (challengerDist < winnerDist) { winnerDist = challengerDist; winner = npc; break; } } } catch (Exception e) { exception(e); } } return winner; } public static final String unwrap(StringWrap sw) { return new String(sw.getBytes()); } public static final int distance(Tile a, Tile b) { return (int) Math.sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)); } public final int walkTime(Tile destination) { if (getRun()) { return distanceTo(destination) * 149 + 550; } else { return distanceTo(destination) * 209 + 550; } } public final int distanceTo(Tile destination) { return distance(getTile(getPlayer()), destination); } public static final Tile[] reversePath(Tile[] path) { Tile[] t = new Tile[path.length]; for (int i = 0; i < t.length; i++) t[i] = path[path.length - 1 - i]; return t; } /** * Finds a tile toward the next nearest point on a path or to the next point * that is within 10 tiles away * * @param path * Tile[] * @return Tile along or to the path, otherwise null. */ public final Tile findTileAlongInvalidPath(Tile[] path) { int MostNear = 0; for (int i = 0; i < path.length; i++) { if (distanceTo(path[i]) < distanceTo(path[MostNear])) { MostNear = i; } } int SecMostNear = MostNear; if (SecMostNear < path.length - 1) { SecMostNear++; } while (SecMostNear < path.length - 1 && distanceTo(path[SecMostNear + 1]) < 11) { SecMostNear++; } if (distanceTo(path[SecMostNear]) < 11) { return path[SecMostNear]; } else { Tile challenger1 = path[MostNear]; Tile challenger2 = path[SecMostNear]; Tile winner = challenger1; int winnerDist = distanceTo(winner); int distanceBetweenChall = distance(challenger1, challenger2); int StartX = challenger1.x; int StartY = challenger1.y; int dx = StartX - challenger2.x; int dy = StartY - challenger2.y; for (int i = 0; i <= distanceBetweenChall; i++) { Tile Challenger = new Tile(StartX + dx * (i / distanceBetweenChall), StartY + dy * (i / distanceBetweenChall)); int challengerDist = distanceTo(Challenger); if (challengerDist < winnerDist) { winnerDist = challengerDist; winner = Challenger; } } return findTileOnWayToTile(winner); } } /** * Finds a tile in the direction of the Destionation * * @param Destination * The tile to walk to * @return Tile in the direction of the Destination, otherwise null. */ public final Tile findTileOnWayToTile(Tile Destination) { if (Destination == null) return null; Tile next = null; int x_difference = Destination.x - getTile(getPlayer()).x; int y_difference = Destination.y - getTile(getPlayer()).y; int abs_x_difference = Math.abs(x_difference); int abs_y_difference = Math.abs(y_difference); int multiple; int x; int y; int x_change = 0; int y_change = 0; int size = 0; if (distanceTo(Destination) > 9 || !(canReach(Destination))) { multiple = 7; x = (getTile(getPlayer()).x + multiple * x_difference / (abs_x_difference + abs_y_difference)); y = (getTile(getPlayer()).y + multiple * y_difference / (abs_x_difference + abs_y_difference)); while (!(canReach(new Tile(x, y)))) { if (size >= 8) break; else if (y_change == size && x_change < size && x_change > 0) x_change++; else if (x_change == 0 && y_change >= 0) { y_change++; x_change++; size++; } else if (y_change == size && x_change < 0) x_change++; else if (y_change == (-1 * size) && x_change > (-1 * size)) x_change--; else if (x_change == size) y_change--; else if (x_change == -1 * size) y_change++; } if (size < 8) { next = new Tile(x + x_change, y + y_change); } } else { next = Destination; } return next; } public boolean canReach(Tile tile) { // TODO (nag ms devs) return true; }}