import java.util.Map;

import java.util.Map.Entry;

import java.util.TreeMap;

/**

* Trades supplies and banks loot.

* <p>

* Instructions:

* Start script at Edgeville Bank with an empty inventory.

* <p>

* Banked (multiple):

* runechain, runelegs, antidshield, charged dstone amulet,

* sharks, regular/super set pots, cure/anti poison pots

* <p>

* Required Parameter:

* name of player running AA_KBDMaster script

* <p>

* Notes:

* Modify the Equipment enum directly to change item ids.

* <p>

*

* @Author Chomp

*/

public class AA_KBDMule extends AA_Script {

private static final Coordinate[] PATH_TO_KBD = new Coordinate[]{

new Coordinate(239, 432),

new Coordinate(240, 396),

new Coordinate(266, 363),

new Coordinate(279, 336),

new Coordinate(299, 288),

new Coordinate(296, 241),

new Coordinate(285, 193),

new Coordinate(285, 185)

};

private static final Coordinate[] PATH_TO_EDGEVILLE = new Coordinate[]{

new Coordinate(285, 234),

new Coordinate(284, 283),

new Coordinate(277, 332),

new Coordinate(272, 381),

new Coordinate(240, 422),

new Coordinate(217, 447)

};

private static final Coordinate

COORDINATE_DEATH_WALK_LUMBRIDGE = new Coordinate(120, 648),

COORDINATE_DEATH_WALK_EDGEVILLE = new Coordinate(220, 446),

COORDINATE_TRADE_SPOT = new Coordinate(565, 3331);

/**

* Excluded drops:

* 10 (coins)

* 91 (Mithril battle Axe)

* 157, 158, 159, 160 (gems)

* 204 (Adamantite Axe)

**/

private static final int[] ITEM_IDS_LOOT = new int[]{

11, 31, 33, 38, 40, 42,

75, 81, 93, 120, 174,

316, 403, 404, 405, 408,

517, 518, 520, 523, 526, 527, 546,

619, 638, 711, 793, 795, 814, 1092, 1277

};

private static final int[] ITEM_IDS_LOOT_NOTABLE = new int[]{

38, 75, 81, 93,

403, 404, 405, 408,

523, 526, 527, 619,

711, 795, 814, 1092, 1277

};

private static final int

NPC_ID_POISON_SPIDER = 292,

NPC_ID_LESSER_DEMON = 22,

ITEM_ID_CHARGED_DRAGONSTONE_AMULET = 597,

ITEM_ID_DRAGONSTONE_AMULET = 522,

ITEM_ID_EMPTY_VIAL = 465,

MINIMUM_SHARKS = 10,

PAINT_OFFSET_X_ALT = 185;

private final Map<Integer, Integer> notableLoot = new TreeMap<>();

private String master;

private State state;

private SupplyRequest supplyRequest;

private PathWalker pathWalker;

private long startTime;

private long actionTimeout, withdrawFoodTimeout, optionMenuTimeout, tradeOfferTimeout;

private int playerX, playerY, eatAt, deaths;

private String

sharksRemaining = "n/a",

amuletsRemaining = "n/a",

antidotesRemaining = "n/a",

superSetsRemaining = "n/a";

private boolean poisoned, died, idle, abort;

public AA_KBDMule(final Extension extension) {

super(extension);

combatStyle = CombatStyle.DEFENSE;

}

@Override

public void init(final String parameters) {

if (parameters.isEmpty()) printInstructions();

master = parameters.replace('_', ' ');

final State initialState;

if (Area.BANK.contains(getX(), getY())) {

initialState = State.BANK;

} else if (Area.DRAGON.contains(getX(), getY())) {

initialState = State.TRADE;

} else {

initialState = State.WALK_TO_DRAGON;

}

setCombatStyle(combatStyle.getIndex());

eatAt = getBaseHits() / 2;

startTime = System.currentTimeMillis();

setState(initialState);

}

@Override

public int main() {

if (died) {

if (isDead() || (pathWalker != null && pathWalker.walkPath())) {

return 0;

}

pathWalker = null;

died = false;

}

playerX = getX();

playerY = getY();

if (bot.getCombatStyle() != combatStyle.getIndex()) setCombatStyle(combatStyle.getIndex());

switch (state) {

case BANK:

return bank();

case WALK_TO_DRAGON:

return walkToDragon();

case TRADE:

return trade();

case TELEPORT_TO_BANK:

return teleportToBank();

case WALK_TO_BANK:

return walkToBank();

default:

return exit("Invalid script state.");

}

}

@Override

public void onServerMessage(final String message) {

if (message.endsWith("shark")) {

actionTimeout = System.currentTimeMillis() + TIMEOUT_ONE_TICK;

} else if (message.endsWith("poison potion") || message.endsWith("antidote potion")) {

poisoned = false;

} else if (message.endsWith("left") ||

message.startsWith("finished", 9) ||

message.endsWith("Vial")) {

actionTimeout = System.currentTimeMillis() + TIMEOUT_ONE_TICK;

} else if (message.startsWith("poisioned", 23)) {

poisoned = true;

} else if (message.startsWith("declined", 17) || message.endsWith("successfully")) {

supplyRequest = null;

} else if (message.endsWith("area")) {

idle = true;

} else {

super.onServerMessage(message);

}

}

@Override

public void onDeath() {

if (pathWalker == null) {

pathWalker = new PathWalker(bot);

pathWalker.init(null);

}

final PathWalker.Path path = pathWalker.calcPath(COORDINATE_DEATH_WALK_LUMBRIDGE.getX(),

COORDINATE_DEATH_WALK_LUMBRIDGE.getY(),

COORDINATE_DEATH_WALK_EDGEVILLE.getX(),

COORDINATE_DEATH_WALK_EDGEVILLE.getY());

if (path == null) {

abort("Failed to calculate path from Lumbridge to Edgeville.");

}

pathWalker.setPath(path);

setState(State.BANK);

died = true;

deaths++;

idle = false;

poisoned = false;

}

private void abort(final String reason) {

sendPrivateMessage("abort", master);

exit(reason);

}

private void setState(final State state) {

this.state = state;

if (this.state == State.BANK) {

if (abort) {

exit("Trip aborted.");

return;

}

updateNotableLoot();

}

}

private void updateNotableLoot() {

for (int index = 0; index < getInventoryCount(); index++) {

final int itemId = getInventoryId(index);

if (!inArray(ITEM_IDS_LOOT_NOTABLE, itemId)) {

continue;

}

notableLoot.merge(itemId, getInventoryStack(index), Integer::sum);

}

}

@Override

public void paint() {

int y = PAINT_OFFSET_Y;

drawString("@yel@King Black Dragon", PAINT_OFFSET_X, y, 1, 0);

drawString(String.format("@yel@State: @cya@%s", state),

PAINT_OFFSET_X, y += PAINT_OFFSET_Y_INCREMENT, 1, 0);

drawString(String.format("@yel@Runtime: @whi@%s", toDuration(startTime)),

PAINT_OFFSET_X, y += PAINT_OFFSET_Y_INCREMENT, 1, 0);

if (!notableLoot.isEmpty()) {

drawString("", PAINT_OFFSET_X, y += PAINT_OFFSET_Y_INCREMENT, 1, 0);

for (final Entry<Integer, Integer> entry : notableLoot.entrySet()) {

drawString(String.format("@gr1@%s: @whi@%d", getItemNameId(entry.getKey()), entry.getValue()),

PAINT_OFFSET_X, y += PAINT_OFFSET_Y_INCREMENT, 1, 0);

}

}

y = 0;

drawString("@yel@Supplies Remaining",

PAINT_OFFSET_X_ALT, y += PAINT_OFFSET_Y_INCREMENT, 1, 0);

drawString(String.format("@or1@Sharks: @whi@%s", sharksRemaining),

PAINT_OFFSET_X_ALT, y += PAINT_OFFSET_Y_INCREMENT, 1, 0);

drawString(String.format("@ora@Amulets: @whi@%s", amuletsRemaining),

PAINT_OFFSET_X_ALT, y += PAINT_OFFSET_Y_INCREMENT, 1, 0);

drawString(String.format("@or2@Antidotes: @whi@%s", antidotesRemaining),

PAINT_OFFSET_X_ALT, y += PAINT_OFFSET_Y_INCREMENT, 1, 0);

drawString(String.format("@or3@Super sets: @whi@%s", superSetsRemaining),

PAINT_OFFSET_X_ALT, y + PAINT_OFFSET_Y_INCREMENT, 1, 0);

}

@Override

public void onTradeRequest(final String playerName) {

if (state != State.TRADE || !playerName.equalsIgnoreCase(master)) {

return;

}

final int[] master = getPlayerByName(this.master);

if (master[0] == -1) {

return;

}

supplyRequest = null;

sendTradeRequest(getPlayerPID(master[0]));

}

@Override

public void onPrivateMessage(final String message, final String playerName, final boolean moderator,

final boolean administrator) {

if (!playerName.equalsIgnoreCase(master)) {

return;

}

if (message.equalsIgnoreCase("abort")) {

abort = true;

return;

}

try {

supplyRequest = SupplyRequest.from(message);

} catch (final IllegalArgumentException e) {

System.err.println(e.getMessage());

}

}

private int bank() {

if (getCurrentHits() != getBaseHits()) {

final int sharkIndex = getInventoryIndex(Food.SHARK.getId());

if (sharkIndex != -1) {

return consume(sharkIndex);

}

}

if (poisoned) {

final int potionIndex = getInventoryIndex(Potion.ANTIDOTE.ids);

if (potionIndex != -1) {

return consume(potionIndex);

}

}

if (!isBanking()) {

return openBank();

}

for (int index = 0; index < getInventoryCount(); index++) {

final int itemId = getInventoryId(index);

if (itemId == Food.SHARK.getId()) {

continue;

}

if (inArray(ITEM_IDS_LOOT, itemId) ||

itemId == ITEM_ID_DRAGONSTONE_AMULET ||

itemId == ITEM_ID_EMPTY_VIAL) {

deposit(itemId, getInventoryCount(itemId));

return SLEEP_ONE_TICK;

}

}

for (final Equipment equipment : Equipment.VALUES) {

if (hasInventoryItem(equipment.id)) {

continue;

}

if (System.currentTimeMillis() <= equipment.timeout) {

return 0;

}

if (!hasBankItem(equipment.id)) {

abort(String.format("Out of item: %s.", getItemNameId(equipment.id)));

}

withdraw(equipment.id, 1);

equipment.timeout = System.currentTimeMillis() + TIMEOUT_TWO_SECONDS;

return 0;

}

for (final Potion potion : Potion.VALUES) {

final int potionCount = getInventoryCount(potion.ids);

if (potionCount == 1) {

continue;

}

if (System.currentTimeMillis() <= potion.timeout) {

return 0;

}

if (potionCount == 0) {

for (final int id : potion.ids) {

if (!hasBankItem(id)) {

continue;

}

withdraw(id, 1);

potion.timeout = System.currentTimeMillis() + TIMEOUT_TWO_SECONDS;

return 0;

}

} else {

for (final int id : potion.ids) {

if (!hasInventoryItem(id)) {

continue;

}

deposit(id, 1);

potion.timeout = System.currentTimeMillis() + TIMEOUT_TWO_SECONDS;

return 0;

}

}

}

if (!isInventoryFull()) {

if (System.currentTimeMillis() <= withdrawFoodTimeout) {

return 0;

}

if (!hasBankItem(Food.SHARK.getId())) {

abort(String.format("Out of item: %s.", Food.SHARK));

}

withdraw(Food.SHARK.getId(), getInventoryEmptyCount());

withdrawFoodTimeout = System.currentTimeMillis() + TIMEOUT_THREE_SECONDS;

return 0;

}

updateSuppliesRemaining();

setState(State.WALK_TO_DRAGON);

return 0;

}

private int walkToDragon() {

if (Area.DRAGON.contains(playerX, playerY)) {

setState(State.TRADE);

return 0;

}

if (!inCombat()) {

if (poisoned) {

final int potionIndex = getInventoryIndex(Potion.ANTIDOTE.ids);

if (potionIndex != -1) {

return consume(potionIndex);

}

}

if (getCurrentHits() <= eatAt) {

final int sharkIndex = getInventoryIndex(Food.SHARK.getId());

if (sharkIndex != -1) {

return consume(sharkIndex);

}

}

}

if (Area.SPIDERS.contains(playerX, playerY)) {

if (distanceTo(Object.LEVER_SPIDER.coordinate.getX(), Object.LEVER_SPIDER.coordinate.getY()) <= 1) {

if (inCombat()) {

walkTo(playerX, playerY);

return SLEEP_ONE_TICK;

}

useObject1(Object.LEVER_SPIDER.coordinate.getX(), Object.LEVER_SPIDER.coordinate.getY());

return SLEEP_ONE_SECOND;

}

if (!inCombat()) {

final int poisonSpider = getBlockingPoisonSpider();

if (poisonSpider != -1) {

attackNpc(poisonSpider);

return SLEEP_ONE_TICK;

}

}

walkTo(Object.LEVER_SPIDER.coordinate.getX(), Object.LEVER_SPIDER.coordinate.getY());

return SLEEP_ONE_TICK;

}

if (Area.LESSERS.contains(playerX, playerY)) {

if (distanceTo(Object.LADDER_DOWN.coordinate.getX(),

Object.LADDER_DOWN.coordinate.getY()) <= 1) {

if (inCombat()) {

walkTo(playerX, playerY);

return SLEEP_ONE_TICK;

}

useObject1(Object.LADDER_DOWN.coordinate.getX(), Object.LADDER_DOWN.coordinate.getY());

return SLEEP_ONE_SECOND;

}

if (!inCombat()) {

final int lesserDemon = getBlockingLesserDemon();

if (lesserDemon != -1) {

attackNpc(lesserDemon);

return SLEEP_ONE_TICK;

}

}

walkTo(Object.LADDER_DOWN.coordinate.getX() + 1, Object.LADDER_DOWN.coordinate.getY());

return SLEEP_ONE_TICK;

}

if (distanceTo(Object.GATE.coordinate.getX(), Object.GATE.coordinate.getY()) <= 1) {

if (inCombat()) {

walkTo(playerX, playerY);

return SLEEP_ONE_TICK;

}

useObject1(Object.GATE.coordinate.getX(), Object.GATE.coordinate.getY());

return SLEEP_ONE_SECOND;

}

if (Area.BANK.contains(playerX, playerY)) {

if (wieldEquipment()) {

return SLEEP_ONE_TICK;

}

if (getObjectIdFromCoords(Object.DOORS.coordinate.getX(), Object.DOORS.coordinate.getY()) ==

Object.DOORS.id) {

atObject(Object.DOORS.coordinate.getX(), Object.DOORS.coordinate.getY());

return SLEEP_ONE_SECOND;

}

}

for (final Coordinate coordinate : PATH_TO_KBD) {

if (playerY > coordinate.getY()) {

walkTo(coordinate.getX(), coordinate.getY());

break;

}

}

return SLEEP_ONE_TICK;

}

private boolean wieldEquipment() {

for (final Equipment equipment : Equipment.VALUES) {

final int equipmentIndex = getInventoryIndex(equipment.id);

if (equipmentIndex != -1 && !isItemEquipped(equipmentIndex)) {

wearItem(equipmentIndex);

return true;

}

}

return false;

}

private int trade() {

final int sharkCount = getInventoryCount(Food.SHARK.getId());

if (sharkCount == 0) {

setState(State.TELEPORT_TO_BANK);

return 0;

}

final boolean lowOnSupplies = sharkCount < MINIMUM_SHARKS ||

!hasInventoryItem(Potion.SUPER_ATTACK.ids) ||

!hasInventoryItem(Potion.SUPER_DEFENSE.ids) ||

!hasInventoryItem(Potion.SUPER_STRENGTH.ids);

if (lowOnSupplies) {

final int[] master = getPlayerByName(this.master);

if (master[0] == -1 || !Area.TRADE.contains(master[1], master[2])) {

setState(State.TELEPORT_TO_BANK);

return 0;

}

}

if (inCombat()) {

walkTo(playerX, playerY);

return 0;

}

if (poisoned) {

final int potionIndex = getInventoryIndex(Potion.ANTIDOTE.ids);

if (potionIndex != -1) {

return consume(potionIndex);

}

}

if (getCurrentHits() <= eatAt) {

final int sharkIndex = getInventoryIndex(Food.SHARK.getId());

if (sharkIndex != -1) {

return consume(sharkIndex);

}

}

final int vialIndex = getInventoryIndex(ITEM_ID_EMPTY_VIAL);

if (vialIndex != -1) {

if (System.currentTimeMillis() <= actionTimeout) {

return 0;

}

dropItem(vialIndex);

actionTimeout = System.currentTimeMillis() + TIMEOUT_TWO_SECONDS;

return 0;

}

if (isInTradeConfirm()) {

if (!bot.hasLocalConfirmedTrade()) {

confirmTrade();

}

return 0;

}

if (isInTradeOffer()) {

return handleAcceptTrade();

}

if (idle) {

if (playerY == COORDINATE_TRADE_SPOT.getY()) {

walkTo(COORDINATE_TRADE_SPOT.getX(), COORDINATE_TRADE_SPOT.getY() - 1);

return SLEEP_ONE_TICK;

}

idle = false;

}

if (playerX != COORDINATE_TRADE_SPOT.getX() || playerY != COORDINATE_TRADE_SPOT.getY()) {

walkTo(COORDINATE_TRADE_SPOT.getX(), COORDINATE_TRADE_SPOT.getY());

}

if (abort) {

setState(State.TELEPORT_TO_BANK);

}

return SLEEP_ONE_TICK;

}

private int handleAcceptTrade() {

if (hasLocalAcceptedTrade() || supplyRequest == null) {

return 0;

}

for (final Potion potion : Potion.values()) {

if (!supplyRequest.isPotionRequested(potion) || !hasInventoryItem(potion.ids)) {

continue;

}

if (hasTradeItem(potion.ids)) {

continue;

}

if (System.currentTimeMillis() <= potion.timeout) {

return 0;

}

offerItemTrade(getInventoryIndex(potion.ids), 1);

potion.timeout = System.currentTimeMillis() + TIMEOUT_TWO_SECONDS;

return 0;

}

final int sharkTradeCount = getTradeItemIdCount(Food.SHARK.getId());

final int sharkInvCount = getInventoryCount(Food.SHARK.getId());

final int requiredCount = Math.min(sharkInvCount, supplyRequest.sharks);

if (sharkTradeCount == requiredCount) {

acceptTrade();

return 0;

}

if (System.currentTimeMillis() <= tradeOfferTimeout) {

return 0;

}

if (sharkTradeCount > requiredCount) {

removeTradeItemId(Food.SHARK.getId(), sharkTradeCount - requiredCount);

} else {

offerTradeItemId(Food.SHARK.getId(), requiredCount - sharkTradeCount);

}

tradeOfferTimeout = System.currentTimeMillis() + TIMEOUT_TWO_SECONDS;

return 0;

}

private int teleportToBank() {

if (Area.BANK.contains(playerX, playerY)) {

setState(State.BANK);

return 0;

}

if (Area.DRAGON.contains(playerX, playerY)) {

if (isQuestMenu()) {

answer(0);

optionMenuTimeout = System.currentTimeMillis() + TIMEOUT_TWO_SECONDS;

return 0;

}

if (inCombat()) {

walkTo(playerX, playerY);

return SLEEP_ONE_TICK;

}

if (getCurrentHits() <= eatAt) {

final int sharkIndex = getInventoryIndex(Food.SHARK.getId());

if (sharkIndex != -1) {

return consume(sharkIndex);

}

}

if (System.currentTimeMillis() <= optionMenuTimeout) {

return 0;

}

final int amuletIndex = getInventoryIndex(ITEM_ID_CHARGED_DRAGONSTONE_AMULET);

if (amuletIndex == -1) {

setState(State.WALK_TO_BANK);

return 0;

}

useItem(amuletIndex);

optionMenuTimeout = System.currentTimeMillis() + TIMEOUT_THREE_SECONDS;

return 0;

}

if (distanceTo(Object.DOORS.coordinate.getX(), Object.DOORS.coordinate.getY()) <= 1) {

if (getObjectIdFromCoords(Object.DOORS.coordinate.getX(),

Object.DOORS.coordinate.getY()) == Object.DOORS.id) {

useObject1(Object.DOORS.coordinate.getX(), Object.DOORS.coordinate.getY());

return SLEEP_ONE_SECOND;

}

walkTo(Object.DOORS.coordinate.getX(), Object.DOORS.coordinate.getY() + 1);

return SLEEP_ONE_TICK;

}

walkTo(Object.DOORS.coordinate.getX(), Object.DOORS.coordinate.getY());

return SLEEP_ONE_TICK;

}

private int walkToBank() {

if (Area.BANK.contains(playerX, playerY)) {

setState(State.BANK);

return 0;

}

if (distanceTo(Object.DOORS.coordinate.getX(), Object.DOORS.coordinate.getY()) <= 1) {

if (getObjectIdFromCoords(Object.DOORS.coordinate.getX(),

Object.DOORS.coordinate.getY()) == Object.DOORS.id) {

useObject1(Object.DOORS.coordinate.getX(), Object.DOORS.coordinate.getY());

return SLEEP_ONE_SECOND;

}

walkTo(Object.DOORS.coordinate.getX(), Object.DOORS.coordinate.getY() + 1);

return SLEEP_ONE_TICK;

}

if (!inCombat()) {

if (poisoned) {

final int potionIndex = getInventoryIndex(Potion.ANTIDOTE.ids);

if (potionIndex != -1) {

return consume(potionIndex);

}

}

if (getCurrentHits() <= eatAt) {

final int sharkIndex = getInventoryIndex(Food.SHARK.getId());

if (sharkIndex != -1) {

return consume(sharkIndex);

}

}

}

if (Area.LESSERS.contains(playerX, playerY)) {

if (distanceTo(Object.GATE.coordinate.getX(), Object.GATE.coordinate.getY()) <= 1) {

if (inCombat()) {

walkTo(playerX, playerY);

return SLEEP_ONE_TICK;

}

useObject1(Object.GATE.coordinate.getX(), Object.GATE.coordinate.getY());

return SLEEP_ONE_SECOND;

}

if (!inCombat()) {

final int lesserDemon = getBlockingLesserDemon();

if (lesserDemon != -1) {

attackNpc(lesserDemon);

return SLEEP_ONE_TICK;

}

}

walkTo(Object.GATE.coordinate.getX() - 1, Object.GATE.coordinate.getY() + 1);

return SLEEP_ONE_TICK;

}

if (Area.SPIDERS.contains(playerX, playerY)) {

if (distanceTo(Object.LADDER_UP.coordinate.getX(), Object.LADDER_UP.coordinate.getY()) <= 1) {

if (inCombat()) {

walkTo(playerX, playerY);

return SLEEP_ONE_TICK;

}

useObject1(Object.LADDER_UP.coordinate.getX(), Object.LADDER_UP.coordinate.getY());

return SLEEP_ONE_SECOND;

}

if (!inCombat()) {

final int poisonSpider = getBlockingPoisonSpider();

if (poisonSpider != -1) {

attackNpc(poisonSpider);

return SLEEP_ONE_TICK;

}

}

walkTo(Object.LADDER_UP.coordinate.getX(), Object.LADDER_UP.coordinate.getY() + 1);

return SLEEP_ONE_TICK;

}

if (Area.DRAGON.contains(playerX, playerY)) {

if (distanceTo(Object.LEVER_DRAGON.coordinate.getX(), Object.LEVER_DRAGON.coordinate.getY()) <= 1) {

if (inCombat()) {

walkTo(playerX, playerY);

return SLEEP_ONE_TICK;

}

useObject1(Object.LEVER_DRAGON.coordinate.getX(), Object.LEVER_DRAGON.coordinate.getY());

return SLEEP_ONE_SECOND;

}

walkTo(Object.LEVER_DRAGON.coordinate.getX(), Object.LEVER_DRAGON.coordinate.getY());

return SLEEP_ONE_TICK;

}

for (final Coordinate coordinate : PATH_TO_EDGEVILLE) {

if (playerY < coordinate.getY()) {

walkTo(coordinate.getX(), coordinate.getY());

break;

}

}

return SLEEP_ONE_TICK;

}

private int getBlockingPoisonSpider() {

for (int index = 0; index < bot.getNpcCount(); index++) {

final java.lang.Object npc = bot.getNpc(index);

if (bot.getNpcId(npc) != NPC_ID_POISON_SPIDER || bot.isMobInCombat(npc)) {

continue;

}

final int npcX = getNpcX(index);

final int npcY = getNpcY(index);

if (npcX != playerX) {

continue;

}

if (npcY == playerY + (state == State.WALK_TO_DRAGON ? 1 : -1)) {

return index;

}

}

return -1;

}

private int getBlockingLesserDemon() {

for (int index = 0; index < bot.getNpcCount(); index++) {

final java.lang.Object npc = bot.getNpc(index);

if (bot.getNpcId(npc) != NPC_ID_LESSER_DEMON || bot.isMobInCombat(npc)) {

continue;

}

final int npcX = getNpcX(index);

final int npcY = getNpcY(index);

if (npcY != playerY) {

continue;

}

if (npcX == playerX + (state == State.WALK_TO_DRAGON ? -1 : 1)) {

return index;

}

}

return -1;

}

private int consume(final int inventoryIndex) {

if (System.currentTimeMillis() <= actionTimeout) {

return 0;

}

useItem(inventoryIndex);

actionTimeout = System.currentTimeMillis() + TIMEOUT_THREE_SECONDS;

return 0;

}

private void updateSuppliesRemaining() {

int antidoteCount = 0, supAtkCount = 0, supStrCount = 0, supDefCount = 0;

int itemId;

for (int index = 0; index < getBankSize(); index++) {

itemId = getBankId(index);

if (itemId == Food.SHARK.getId()) {

sharksRemaining = DECIMAL_FORMAT.format(getBankStack(index));

} else if (itemId == Equipment.AMULET.id) {

amuletsRemaining = DECIMAL_FORMAT.format(getBankStack(index));

} else if (inArray(Potion.ANTIDOTE.ids, itemId)) {

antidoteCount += getBankStack(index);

} else if (inArray(Potion.SUPER_ATTACK.ids, itemId)) {

supAtkCount += getBankStack(index);

} else if (inArray(Potion.SUPER_DEFENSE.ids, itemId)) {

supDefCount += getBankStack(index);

} else if (inArray(Potion.SUPER_STRENGTH.ids, itemId)) {

supStrCount += getBankStack(index);

}

}

antidotesRemaining = DECIMAL_FORMAT.format(antidoteCount);

superSetsRemaining = DECIMAL_FORMAT.format(Math.min(supAtkCount, Math.min(supDefCount, supStrCount)));

}

private enum State {

BANK("Bank"),

WALK_TO_DRAGON("Walk to Dragon"),

TRADE("Trade"),

TELEPORT_TO_BANK("Teleport to Bank"),

WALK_TO_BANK("Walk to Bank");

private final String description;

State(final String description) {

this.description = description;

}

@Override

public String toString() {

return description;

}

}

private enum Area implements RSArea {

BANK(new Coordinate(212, 448), new Coordinate(220, 453)),

LESSERS(new Coordinate(278, 181), new Coordinate(284, 187)) {

@Override

public boolean contains(final int x, final int y) {

return super.contains(x, y) || (x >= 280 && x <= 283 && y >= 188 && y <= 189);

}

},

SPIDERS(new Coordinate(279, 3014), new Coordinate(283, 3020)),

TRADE(new Coordinate(565, 3329), new Coordinate(569, 3331)),

DRAGON(new Coordinate(563, 3315), new Coordinate(571, 3331));

private final Coordinate lowerBoundingCoordinate;

private final Coordinate upperBoundingCoordinate;

Area(final Coordinate lowerBoundingCoordinate, final Coordinate upperBoundingCoordinate) {

this.lowerBoundingCoordinate = lowerBoundingCoordinate;

this.upperBoundingCoordinate = upperBoundingCoordinate;

}

public Coordinate getLowerBoundingCoordinate() {

return lowerBoundingCoordinate;

}

public Coordinate getUpperBoundingCoordinate() {

return upperBoundingCoordinate;

}

}

private enum Object implements RSObject {

DOORS(64, new Coordinate(217, 447)),

GATE(508, new Coordinate(285, 185)),

LADDER_DOWN(6, new Coordinate(282, 185)),

LADDER_UP(5, new Coordinate(282, 3017)),

LEVER_SPIDER(487, new Coordinate(282, 3020)),

LEVER_DRAGON(488, new Coordinate(567, 3331));

private final int id;

private final Coordinate coordinate;

Object(final int id, final Coordinate coordinate) {

this.id = id;

this.coordinate = coordinate;

}

public int getId() {

return id;

}

public Coordinate getCoordinate() {

return coordinate;

}

}

private enum Potion {

ANTIDOTE(new int[]{568, 571, 567, 570, 566, 569}),

SUPER_ATTACK(new int[]{486, 487, 488, 474, 475, 476}),

SUPER_DEFENSE(new int[]{495, 496, 497, 480, 481, 482}),

SUPER_STRENGTH(new int[]{492, 493, 494, 221, 222, 223, 224});

private static final Potion[] VALUES = Potion.values();

private final int[] ids;

private long timeout;