nice

build.gradle

@@ -18,6 +18,8 @@ def runeLiteVersion = 'latest.release'
 dependencies {
     compileOnly group: 'net.runelite', name: 'client', version: runeLiteVersion
 
+    implementation 'org.roaringbitmap:RoaringBitmap:0.9.44'
+
     compileOnly 'org.projectlombok:lombok:1.18.20'
     annotationProcessor 'org.projectlombok:lombok:1.18.20'
 
@@ -26,7 +28,7 @@ dependencies {
     testImplementation group: 'net.runelite', name: 'jshell', version: runeLiteVersion
 }
 
-group = 'com.toofifty'
+group = 'ee.futur'
 version = '1.0.11'
 
 tasks.withType(JavaCompile).configureEach {
@@ -38,7 +40,7 @@ tasks.register('shadowJar', Jar) {
     dependsOn configurations.testRuntimeClasspath
     manifest {
         attributes('Main-Class':
-                'com.toofifty.easygiantsfoundry.EasyGiantsFoundryPluginTest',
+                'ee.futur.easygiantsfoundry.EasyGiantsFoundryPluginTest',
                 'Multi-Release': true)
     }
 
@@ -67,6 +69,6 @@ task runClient(type: JavaExec) {
     group = 'application'
     description = 'Run the PluginTester main class to launch RuneLite with plugins'
     classpath = sourceSets.test.runtimeClasspath
-    mainClass = 'com.toofifty.easygiantsfoundry.EasyGiantsFoundryPluginTest'
+    mainClass = 'ee.futur.easygiantsfoundry.EasyGiantsFoundryPluginTest'
     jvmArgs '-ea'
 }

runelite-plugin.properties

@@ -3,4 +3,4 @@ author=Toofifty
 support=https://github.com/Toofifty/easy-giantsfoundry
 description=Helpful overlays for the Giants' Foundry minigame
 tags=smithing,giant,foundry,giantsfoundry,minigame,ez,easy,smith
-plugins=com.toofifty.easygiantsfoundry.EasyGiantsFoundryPlugin
+plugins=ee.futur.easygiantsfoundry.EasyGiantsFoundryPlugin

src/main/java/ee/futur/baseapi/collections/Bank.java

@@ -0,0 +1,82 @@
+package ee.futur.baseapi.collections;
+
+
+import ee.futur.baseapi.collections.query.ItemQuery;
+import ee.futur.baseapi.BaseApiPlugin;
+import net.runelite.api.Client;
+import net.runelite.api.GameState;
+import net.runelite.api.InventoryID;
+import net.runelite.api.Item;
+import net.runelite.api.events.GameStateChanged;
+import net.runelite.api.widgets.Widget;
+import net.runelite.api.widgets.WidgetInfo;
+import net.runelite.client.RuneLite;
+import net.runelite.client.eventbus.Subscribe;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.ExecutionException;
+import java.util.stream.Collectors;
+
+public class Bank {
+    private static final int WITHDRAW_MODE = 3958;
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    static List<Widget> bankItems = new ArrayList<>();
+    boolean bankUpdate = true;
+    static int lastUpdateTick = 0;
+
+    public static ItemQuery search() {
+        if (lastUpdateTick < client.getTickCount()) {
+            Bank.bankItems.clear();
+            int i = 0;
+            if (client.getItemContainer(InventoryID.BANK) == null) {
+                return new ItemQuery(new ArrayList<>());
+            }
+            for (Item item : client.getItemContainer(InventoryID.BANK).getItems()) {
+                try {
+                    if (item == null) {
+                        i++;
+                        continue;
+                    }
+                    if (BaseApiPlugin.itemDefs.get(item.getId()).getPlaceholderTemplateId() == 14401) {
+                        i++;
+                        continue;
+                    }
+                    Bank.bankItems.add(new BankItemWidget(BaseApiPlugin.itemDefs.get(item.getId()).getName(), item.getId(), item.getQuantity(), i));
+                } catch (NullPointerException | ExecutionException ex) {
+                    //todo fix this
+                }
+                i++;
+            }
+            lastUpdateTick = client.getTickCount();
+        }
+        return new ItemQuery(bankItems.stream().filter(Objects::nonNull).collect(Collectors.toList()));
+    }
+
+    public static boolean isOpen() {
+        return client.getWidget(WidgetInfo.BANK_ITEM_CONTAINER) != null && !client.getWidget(WidgetInfo.BANK_ITEM_CONTAINER).isHidden();
+    }
+
+
+    @Subscribe
+    public void onGameStateChanged(GameStateChanged gameStateChanged) {
+        if (gameStateChanged.getGameState() == GameState.HOPPING || gameStateChanged.getGameState() == GameState.LOGIN_SCREEN || gameStateChanged.getGameState() == GameState.CONNECTION_LOST) {
+            Bank.bankItems.clear();
+        }
+    }
+
+    public static boolean isNotedMode() {
+        return client.getVarbitValue(WITHDRAW_MODE) == 1;
+    }
+
+    public static void setWithdrawMode(boolean noted) {
+        if (noted && !isNotedMode()) {
+            //MousePackets.queueClickPacket();
+            //WidgetPackets.queueWidgetActionPacket(1, 786458, -1, -1);
+        } else if (!noted && isNotedMode()) {
+            //MousePackets.queueClickPacket();
+            //WidgetPackets.queueWidgetActionPacket(1, 786456, -1, -1);
+        }
+    }
+}

src/main/java/ee/futur/baseapi/collections/BankInventory.java

@@ -0,0 +1,41 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.collections.query.ItemQuery;
+import net.runelite.api.Client;
+import net.runelite.api.GameState;
+import net.runelite.api.events.GameStateChanged;
+import net.runelite.api.widgets.Widget;
+import net.runelite.api.widgets.WidgetInfo;
+import net.runelite.client.RuneLite;
+import net.runelite.client.eventbus.Subscribe;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class BankInventory {
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    static List<Widget> bankInventoryItems = new ArrayList<>();
+    static int lastUpdateTick = 0;
+
+    public static ItemQuery search() {
+        if (lastUpdateTick < client.getTickCount()) {
+            if (client.getWidget(WidgetInfo.BANK_INVENTORY_ITEMS_CONTAINER) == null) {
+                return new ItemQuery(new ArrayList<>());
+            }
+            BankInventory.bankInventoryItems =
+                    Arrays.stream(client.getWidget(WidgetInfo.BANK_INVENTORY_ITEMS_CONTAINER).getDynamicChildren()).filter(Objects::nonNull).filter(x -> x.getItemId() != 6512 && x.getItemId() != -1).collect(Collectors.toList());
+            lastUpdateTick = client.getTickCount();
+        }
+        return new ItemQuery(bankInventoryItems.stream().filter(Objects::nonNull).collect(Collectors.toList()));
+    }
+
+    @Subscribe
+    public void onGameStateChanged(GameStateChanged gameStateChanged) {
+        if (gameStateChanged.getGameState() == GameState.HOPPING || gameStateChanged.getGameState() == GameState.LOGIN_SCREEN || gameStateChanged.getGameState() == GameState.CONNECTION_LOST) {
+            BankInventory.bankInventoryItems.clear();
+        }
+    }
+}

src/main/java/ee/futur/baseapi/collections/BankItemWidget.java

@@ -0,0 +1,882 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.BaseApiPlugin;
+import net.runelite.api.FontTypeFace;
+import net.runelite.api.Point;
+import net.runelite.api.gameval.VarbitID;
+import net.runelite.api.widgets.Widget;
+import net.runelite.api.widgets.WidgetInfo;
+
+import javax.annotation.Nullable;
+import java.awt.*;
+
+public class BankItemWidget implements Widget {
+
+    int index;
+    String name;
+    int itemid;
+    int quantity;
+
+    BankItemWidget(String name, int itemid, int quantity, int index) {
+        this.name = name;
+        this.itemid = itemid;
+        this.quantity = quantity;
+        this.index = index;
+    }
+
+    @Override
+    public int getId() {
+        return WidgetInfo.BANK_ITEM_CONTAINER.getPackedId();
+    }
+
+    @Override
+    public int getType() {
+        return 0;
+    }
+
+    @Override
+    public void setType(int type) {
+
+    }
+
+    @Override
+    public void clearActions() {
+    }
+
+    ;
+
+    @Override
+    public int getContentType() {
+        return 0;
+    }
+
+    @Override
+    public Widget setContentType(int contentType) {
+        return null;
+    }
+
+    @Override
+    public int getClickMask() {
+        return 0;
+    }
+
+    @Override
+    public Widget setClickMask(int mask) {
+        return null;
+    }
+
+    @Override
+    public Widget getParent() {
+        return null;
+    }
+
+    @Override
+    public int getParentId() {
+        return 0;
+    }
+
+    @Override
+    public Widget getChild(int index) {
+        return null;
+    }
+
+    @Nullable
+    @Override
+    public Widget[] getChildren() {
+        return new Widget[0];
+    }
+
+    @Override
+    public void setChildren(Widget[] children) {
+
+    }
+
+    @Override
+    public Widget[] getDynamicChildren() {
+        return new Widget[0];
+    }
+
+    @Override
+    public Widget[] getStaticChildren() {
+        return new Widget[0];
+    }
+
+    @Override
+    public Widget[] getNestedChildren() {
+        return new Widget[0];
+    }
+
+    @Override
+    public int getRelativeX() {
+        return 0;
+    }
+
+    @Override
+    public void setRelativeX(int x) {
+
+    }
+
+    @Override
+    public int getRelativeY() {
+        return 0;
+    }
+
+    @Override
+    public void setRelativeY(int y) {
+
+    }
+
+    @Override
+    public void setForcedPosition(int x, int y) {
+
+    }
+
+    @Override
+    public String getText() {
+        return null;
+    }
+
+    @Override
+    public Widget setText(String text) {
+        return null;
+    }
+
+    @Override
+    public int getTextColor() {
+        return 0;
+    }
+
+    @Override
+    public Widget setTextColor(int textColor) {
+        return null;
+    }
+
+    @Override
+    public int getOpacity() {
+        return 0;
+    }
+
+    @Override
+    public Widget setOpacity(int transparency) {
+        return null;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public Widget setName(String name) {
+        return null;
+    }
+
+    @Override
+    public int getModelId() {
+        return 0;
+    }
+
+    @Override
+    public Widget setModelId(int id) {
+        return null;
+    }
+
+    @Override
+    public int getModelType() {
+        return 0;
+    }
+
+    @Override
+    public Widget setModelType(int type) {
+        return null;
+    }
+
+    @Override
+    public int getAnimationId() {
+        return 0;
+    }
+
+    @Override
+    public Widget setAnimationId(int animationId) {
+        return null;
+    }
+
+    @Override
+    public int getRotationX() {
+        return 0;
+    }
+
+    @Override
+    public Widget setRotationX(int modelX) {
+        return null;
+    }
+
+    @Override
+    public int getRotationY() {
+        return 0;
+    }
+
+    @Override
+    public Widget setRotationY(int modelY) {
+        return null;
+    }
+
+    @Override
+    public int getRotationZ() {
+        return 0;
+    }
+
+    @Override
+    public Widget setRotationZ(int modelZ) {
+        return null;
+    }
+
+    @Override
+    public int getModelZoom() {
+        return 0;
+    }
+
+    @Override
+    public Widget setModelZoom(int modelZoom) {
+        return null;
+    }
+
+    @Override
+    public int getSpriteId() {
+        return 0;
+    }
+
+    @Override
+    public boolean getSpriteTiling() {
+        return false;
+    }
+
+    @Override
+    public Widget setSpriteTiling(boolean tiling) {
+        return null;
+    }
+
+    @Override
+    public Widget setSpriteId(int spriteId) {
+        return null;
+    }
+
+    @Override
+    public boolean isHidden() {
+        return false;
+    }
+
+    @Override
+    public boolean isSelfHidden() {
+        return false;
+    }
+
+    @Override
+    public Widget setHidden(boolean hidden) {
+        return null;
+    }
+
+    @Override
+    public int getIndex() {
+        return index;
+    }
+
+    @Override
+    public Point getCanvasLocation() {
+        return null;
+    }
+
+    @Override
+    public int getWidth() {
+        return 0;
+    }
+
+    @Override
+    public void setWidth(int width) {
+
+    }
+
+    @Override
+    public int getHeight() {
+        return 0;
+    }
+
+    @Override
+    public void setHeight(int height) {
+
+    }
+
+    @Override
+    public Rectangle getBounds() {
+        return null;
+    }
+
+    @Override
+    public int getItemId() {
+        return itemid;
+    }
+
+    @Override
+    public Widget setItemId(int itemId) {
+        return null;
+    }
+
+    @Override
+    public int getItemQuantity() {
+        return quantity;
+    }
+
+    @Override
+    public Widget setItemQuantity(int quantity) {
+        return null;
+    }
+
+    @Override
+    public boolean contains(Point point) {
+        return false;
+    }
+
+    @Override
+    public int getScrollX() {
+        return 0;
+    }
+
+    @Override
+    public Widget setScrollX(int scrollX) {
+        return null;
+    }
+
+    @Override
+    public int getScrollY() {
+        return 0;
+    }
+
+    @Override
+    public Widget setScrollY(int scrollY) {
+        return null;
+    }
+
+    @Override
+    public int getScrollWidth() {
+        return 0;
+    }
+
+    @Override
+    public Widget setScrollWidth(int width) {
+        return null;
+    }
+
+    @Override
+    public int getScrollHeight() {
+        return 0;
+    }
+
+    @Override
+    public Widget setScrollHeight(int height) {
+        return null;
+    }
+
+    @Override
+    public int getOriginalX() {
+        return 0;
+    }
+
+    @Override
+    public Widget setOriginalX(int originalX) {
+        return null;
+    }
+
+    @Override
+    public int getOriginalY() {
+        return 0;
+    }
+
+    @Override
+    public Widget setOriginalY(int originalY) {
+        return null;
+    }
+
+    @Override
+    public Widget setPos(int x, int y) {
+        return null;
+    }
+
+    @Override
+    public Widget setPos(int x, int y, int xMode, int yMode) {
+        return null;
+    }
+
+    @Override
+    public int getOriginalHeight() {
+        return 0;
+    }
+
+    @Override
+    public Widget setOriginalHeight(int originalHeight) {
+        return null;
+    }
+
+    @Override
+    public int getOriginalWidth() {
+        return 0;
+    }
+
+    @Override
+    public Widget setOriginalWidth(int originalWidth) {
+        return null;
+    }
+
+    @Override
+    public Widget setSize(int width, int height) {
+        return null;
+    }
+
+    @Override
+    public Widget setSize(int width, int height, int widthMode, int heightMode) {
+        return null;
+    }
+
+    @Nullable
+    @Override
+    public String[] getActions() {
+        int xQuantity = BaseApiPlugin.getClient().getVarbitValue(VarbitID.BANK_REQUESTEDQUANTITY);
+        String[] actions = new String[10];
+        switch (BaseApiPlugin.getClient().getVarbitValue(VarbitID.BANK_QUANTITY_TYPE)) {
+            default:
+            case 0:
+                actions[0] = "Withdraw-1";
+                actions[1] = "Withdraw-5";
+                actions[2] = "Withdraw-10";
+                if (xQuantity > 0) {
+                    actions[3] = "Withdraw-" + xQuantity;
+                    actions[4] = "Withdraw-X";
+                    actions[5] = "Withdraw-All";
+                    actions[6] = "Withdraw-All-but-1";
+                } else {
+                    actions[3] = "Withdraw-X";
+                    actions[4] = "Withdraw-All";
+                    actions[5] = "Withdraw-All-but-1";
+                }
+                break;
+            case 1:
+                actions[0] = "Withdraw-5";
+                actions[1] = "Withdraw-1";
+                actions[2] = "Withdraw-10";
+                if (xQuantity > 0) {
+                    actions[3] = "Withdraw-" + xQuantity;
+                    actions[4] = "Withdraw-X";
+                    actions[5] = "Withdraw-All";
+                    actions[6] = "Withdraw-All-but-1";
+                } else {
+                    actions[3] = "Withdraw-X";
+                    actions[4] = "Withdraw-All";
+                    actions[5] = "Withdraw-All-but-1";
+                }
+                break;
+            case 2:
+                actions[0] = "Withdraw-10";
+                actions[1] = "Withdraw-1";
+                actions[2] = "Withdraw-5";
+                if (xQuantity > 0) {
+                    actions[3] = "Withdraw-" + xQuantity;
+                    actions[4] = "Withdraw-X";
+                    actions[5] = "Withdraw-All";
+                    actions[6] = "Withdraw-All-but-1";
+                } else {
+                    actions[3] = "Withdraw-X";
+                    actions[4] = "Withdraw-All";
+                    actions[5] = "Withdraw-All-but-1";
+                }
+                break;
+            case 3:
+                // this can't ever be a thing while this is set to 0
+                actions[0] = "Withdraw-" + xQuantity;
+                actions[1] = "Withdraw-1";
+                actions[2] = "Withdraw-5";
+                actions[3] = "Withdraw-10";
+                actions[4] = "Withdraw-X";
+                actions[5] = "Withdraw-All";
+                actions[6] = "Withdraw-All-but-1";
+                break;
+            case 4:
+                actions[0] = "Withdraw-All";
+                actions[1] = "Withdraw-1";
+                actions[2] = "Withdraw-5";
+                actions[3] = "Withdraw-10";
+                if (xQuantity > 0) {
+                    actions[4] = "Withdraw-" + xQuantity;
+                    actions[5] = "Withdraw-X";
+                    actions[6] = "Withdraw-All-but-1";
+                } else {
+                    actions[4] = "Withdraw-X";
+                    actions[5] = "Withdraw-All-but-1";
+                }
+                break;
+        }
+
+        if (BaseApiPlugin.getClient().getVarbitValue(VarbitID.BANK_LEAVEPLACEHOLDERS) == 0) {
+            actions[7] = "Placeholder";
+        }
+        // these are null normally, 7 can be placeholder
+        // actions[7] = null;
+        // actions[8] = null;
+
+        actions[9] = "Examine";
+        return actions;
+    }
+
+    @Override
+    public Widget createChild(int index, int type) {
+        return null;
+    }
+
+    @Override
+    public Widget createChild(int type) {
+        return null;
+    }
+
+    @Override
+    public void deleteAllChildren() {
+
+    }
+
+    @Override
+    public void setAction(int index, String action) {
+
+    }
+
+    @Override
+    public void setOnOpListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnDialogAbortListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnKeyListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnMouseOverListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnMouseRepeatListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnMouseLeaveListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnTimerListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnTargetEnterListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnTargetLeaveListener(Object... args) {
+
+    }
+
+    @Override
+    public boolean hasListener() {
+        return false;
+    }
+
+    @Override
+    public Widget setHasListener(boolean hasListener) {
+        return null;
+    }
+
+    @Override
+    public boolean isIf3() {
+        return false;
+    }
+
+    @Override
+    public void revalidate() {
+
+    }
+
+    @Override
+    public void revalidateScroll() {
+
+    }
+
+    @Override
+    public Object[] getOnOpListener() {
+        return new Object[0];
+    }
+
+    @Override
+    public Object[] getOnKeyListener() {
+        return new Object[0];
+    }
+
+    @Override
+    public Object[] getOnLoadListener() {
+        return new Object[0];
+    }
+
+    @Override
+    public Object[] getOnInvTransmitListener() {
+        return new Object[0];
+    }
+
+    @Override
+    public int getFontId() {
+        return 0;
+    }
+
+    @Override
+    public Widget setFontId(int id) {
+        return null;
+    }
+
+    @Override
+    public int getBorderType() {
+        return 0;
+    }
+
+    @Override
+    public void setBorderType(int thickness) {
+
+    }
+
+    @Override
+    public boolean getTextShadowed() {
+        return false;
+    }
+
+    @Override
+    public Widget setTextShadowed(boolean shadowed) {
+        return null;
+    }
+
+    @Override
+    public int getDragDeadZone() {
+        return 0;
+    }
+
+    @Override
+    public void setDragDeadZone(int deadZone) {
+
+    }
+
+    @Override
+    public int getDragDeadTime() {
+        return 0;
+    }
+
+    @Override
+    public void setDragDeadTime(int deadTime) {
+
+    }
+
+    @Override
+    public int getItemQuantityMode() {
+        return 0;
+    }
+
+    @Override
+    public Widget setItemQuantityMode(int itemQuantityMode) {
+        return null;
+    }
+
+    @Override
+    public int getXPositionMode() {
+        return 0;
+    }
+
+    @Override
+    public Widget setXPositionMode(int xpm) {
+        return null;
+    }
+
+    @Override
+    public int getYPositionMode() {
+        return 0;
+    }
+
+    @Override
+    public Widget setYPositionMode(int ypm) {
+        return null;
+    }
+
+    @Override
+    public int getLineHeight() {
+        return 0;
+    }
+
+    @Override
+    public Widget setLineHeight(int lineHeight) {
+        return null;
+    }
+
+    @Override
+    public int getXTextAlignment() {
+        return 0;
+    }
+
+    @Override
+    public Widget setXTextAlignment(int xta) {
+        return null;
+    }
+
+    @Override
+    public int getYTextAlignment() {
+        return 0;
+    }
+
+    @Override
+    public Widget setYTextAlignment(int yta) {
+        return null;
+    }
+
+    @Override
+    public int getWidthMode() {
+        return 0;
+    }
+
+    @Override
+    public Widget setWidthMode(int widthMode) {
+        return null;
+    }
+
+    @Override
+    public int getHeightMode() {
+        return 0;
+    }
+
+    @Override
+    public Widget setHeightMode(int heightMode) {
+        return null;
+    }
+
+    @Override
+    public FontTypeFace getFont() {
+        return null;
+    }
+
+    @Override
+    public boolean isFilled() {
+        return false;
+    }
+
+    @Override
+    public Widget setFilled(boolean filled) {
+        return null;
+    }
+
+    @Override
+    public String getTargetVerb() {
+        return null;
+    }
+
+    @Override
+    public void setTargetVerb(String targetVerb) {
+
+    }
+
+    @Override
+    public int getTargetPriority() {
+        return 0;
+    }
+
+    @Override
+    public void setTargetPriority(int priority) {
+
+    }
+
+    @Override
+    public boolean getNoClickThrough() {
+        return false;
+    }
+
+    @Override
+    public void setNoClickThrough(boolean noClickThrough) {
+
+    }
+
+    @Override
+    public boolean getNoScrollThrough() {
+        return false;
+    }
+
+    @Override
+    public void setNoScrollThrough(boolean noScrollThrough) {
+
+    }
+
+    @Override
+    public int[] getVarTransmitTrigger() {
+        return null;
+    }
+
+    @Override
+    public void setVarTransmitTrigger(int... trigger) {
+
+    }
+
+    @Override
+    public void setOnClickListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnHoldListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnReleaseListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnDragCompleteListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnDragListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnScrollWheelListener(Object... args) {
+
+    }
+
+    @Override
+    public Widget getDragParent() {
+        return null;
+    }
+
+    @Override
+    public Widget setDragParent(Widget dragParent) {
+        return null;
+    }
+
+    @Override
+    public Object[] getOnVarTransmitListener() {
+        return new Object[0];
+    }
+
+    @Override
+    public void setOnVarTransmitListener(Object... args) {
+
+    }
+}

src/main/java/ee/futur/baseapi/collections/DepositBox.java

@@ -0,0 +1,68 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.collections.query.ItemQuery;
+import net.runelite.api.Client;
+import net.runelite.api.GameState;
+import net.runelite.api.events.GameStateChanged;
+import net.runelite.api.widgets.Widget;
+import net.runelite.api.widgets.WidgetInfo;
+import net.runelite.client.RuneLite;
+import net.runelite.client.eventbus.Subscribe;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class DepositBox {
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    static List<Widget> depositBoxItems = new ArrayList<>();
+    static int lastUpdateTick = 0;
+
+    public static ItemQuery search() {
+        if (lastUpdateTick < client.getTickCount()) {
+            DepositBox.depositBoxItems =
+                    Arrays.stream(client.getWidget(WidgetInfo.DEPOSIT_BOX_INVENTORY_ITEMS_CONTAINER).getDynamicChildren()).filter(Objects::nonNull).filter(x -> x.getItemId() != 6512 && x.getItemId() != -1).collect(Collectors.toList());
+            lastUpdateTick = client.getTickCount();
+        }
+        return new ItemQuery(depositBoxItems);
+    }
+
+//    @Subscribe
+//    public void onWidgetLoaded(WidgetLoaded e) {
+//        if (e.getGroupId() == WidgetID.DEPOSIT_BOX_GROUP_ID) {
+//            try {
+//                DepositBox.depositBoxItems =
+//                        Arrays.stream(client.getWidget(WidgetInfo.DEPOSIT_BOX_INVENTORY_ITEMS_CONTAINER).getDynamicChildren()).filter(Objects::nonNull).filter(x -> x.getItemId() != 6512 && x.getItemId() != -1).collect(Collectors.toList());
+//            } catch (NullPointerException err) {
+//                DepositBox.depositBoxItems.clear();
+//            }
+//        }
+//    }
+
+//    @Subscribe
+//    public void onItemContainerChanged(ItemContainerChanged e) {
+//        if (e.getContainerId() == 93) {
+//            if (client.getWidget(WidgetInfo.DEPOSIT_BOX_INVENTORY_ITEMS_CONTAINER) == null) {
+//                DepositBox.depositBoxItems.clear();
+//                return;
+//            }
+//            try {
+//                DepositBox.depositBoxItems =
+//                        Arrays.stream(client.getWidget(WidgetInfo.DEPOSIT_BOX_INVENTORY_ITEMS_CONTAINER).getDynamicChildren()).filter(Objects::nonNull).filter(x -> x.getItemId() != 6512 && x.getItemId() != -1).collect(Collectors.toList());
+//                return;
+//            } catch (NullPointerException err) {
+//                DepositBox.depositBoxItems.clear();
+//                return;
+//            }
+//        }
+//    }
+
+    @Subscribe
+    public void onGameStateChanged(GameStateChanged gameStateChanged) {
+        if (gameStateChanged.getGameState() == GameState.HOPPING || gameStateChanged.getGameState() == GameState.LOGIN_SCREEN || gameStateChanged.getGameState() == GameState.CONNECTION_LOST) {
+            DepositBox.depositBoxItems.clear();
+        }
+    }
+}

src/main/java/ee/futur/baseapi/collections/ETileItem.java

@@ -0,0 +1,34 @@
+package ee.futur.baseapi.collections;
+
+import net.runelite.api.TileItem;
+import net.runelite.api.coords.WorldPoint;
+
+import static net.runelite.api.TileItem.OWNERSHIP_GROUP;
+import static net.runelite.api.TileItem.OWNERSHIP_SELF;
+
+public class ETileItem {
+    public WorldPoint location;
+    public TileItem tileItem;
+
+    public ETileItem(WorldPoint worldLocation, TileItem tileItem) {
+        this.location = worldLocation;
+        this.tileItem = tileItem;
+    }
+
+    public WorldPoint getLocation() {
+        return location;
+    }
+
+    public TileItem getTileItem() {
+        return tileItem;
+    }
+
+    public boolean isMine() {
+        return tileItem.getOwnership() == OWNERSHIP_SELF || tileItem.getOwnership() == OWNERSHIP_GROUP;
+    }
+
+    public void interact(boolean ctrlDown) {
+        //MousePackets.queueClickPacket();
+        //TileItemPackets.queueTileItemAction(this, ctrlDown);
+    }
+}

src/main/java/ee/futur/baseapi/collections/Equipment.java

@@ -0,0 +1,105 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.collections.query.EquipmentItemQuery;
+import net.runelite.api.Client;
+import net.runelite.api.InventoryID;
+import net.runelite.api.Item;
+import net.runelite.api.widgets.Widget;
+import net.runelite.api.widgets.WidgetInfo;
+import net.runelite.client.RuneLite;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class Equipment {
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    static List<EquipmentItemWidget> equipment = new ArrayList<>();
+    static HashMap<Integer, Integer> equipmentSlotWidgetMapping = new HashMap<>();
+    static HashMap<Integer, Integer> mappingToIterableIntegers = new HashMap<>();
+    static int lastUpdateTick = 0;
+
+    static {
+        equipmentSlotWidgetMapping.put(0, 15);
+        equipmentSlotWidgetMapping.put(1, 16);
+        equipmentSlotWidgetMapping.put(2, 17);
+        equipmentSlotWidgetMapping.put(3, 18);
+        equipmentSlotWidgetMapping.put(4, 19);
+        equipmentSlotWidgetMapping.put(5, 20);
+        equipmentSlotWidgetMapping.put(7, 21);
+        equipmentSlotWidgetMapping.put(9, 22);
+        equipmentSlotWidgetMapping.put(10, 23);
+        equipmentSlotWidgetMapping.put(12, 24);
+        equipmentSlotWidgetMapping.put(13, 25);
+
+
+        mappingToIterableIntegers.put(0, 0);
+        mappingToIterableIntegers.put(1, 1);
+        mappingToIterableIntegers.put(2, 2);
+        mappingToIterableIntegers.put(3, 3);
+        mappingToIterableIntegers.put(4, 4);
+        mappingToIterableIntegers.put(5, 5);
+        mappingToIterableIntegers.put(6, 7);
+        mappingToIterableIntegers.put(7, 9);
+        mappingToIterableIntegers.put(8, 10);
+        mappingToIterableIntegers.put(9, 12);
+        mappingToIterableIntegers.put(10, 13);
+    }
+
+    public static EquipmentItemQuery search() {
+        if (lastUpdateTick < client.getTickCount()) {
+            int x = 25362447;
+            for (int i = 0; i < 11; i++) {
+                client.runScript(545, (x + i), mappingToIterableIntegers.get(i), 1, 1, 2);
+            }
+            equipment.clear();
+            int i = -1;
+            if (client.getItemContainer(InventoryID.EQUIPMENT.getId()) == null) {
+                return new EquipmentItemQuery(equipment);
+            }
+            for (Item item : client.getItemContainer(InventoryID.EQUIPMENT.getId()).getItems()) {
+                i++;
+                if (item == null) {
+                    continue;
+                }
+                if (item.getId() == 6512 || item.getId() == -1) {
+                    continue;
+                }
+                Widget w = client.getWidget(WidgetInfo.EQUIPMENT.getGroupId(), equipmentSlotWidgetMapping.get(i));
+                if (w == null || w.getActions() == null) {
+                    continue;
+                }
+                equipment.add(new EquipmentItemWidget(w.getName(), item.getId(), w.getId(), -1, w.getActions()));
+            }
+            lastUpdateTick = client.getTickCount();
+        }
+        return new EquipmentItemQuery(equipment);
+    }
+
+//    @SneakyThrows
+//    @Subscribe
+//    public void onItemContainerChanged(ItemContainerChanged e) {
+//        if (e.getContainerId() == InventoryID.EQUIPMENT.getId()) {
+//            int x = 25362447;
+//            for (int i = 0; i < 11; i++) {
+//                client.runScript(545, (x + i), mappingToIterableIntegers.get(i), 1, 1, 2);
+//            }
+//            equipment.clear();
+//            int i = -1;
+//            for (Item item : e.getItemContainer().getItems()) {
+//                i++;
+//                if (item == null) {
+//                    continue;
+//                }
+//                if (item.getId() == 6512 || item.getId() == -1) {
+//                    continue;
+//                }
+//                Widget w = client.getWidget(WidgetInfo.EQUIPMENT.getGroupId(), equipmentSlotWidgetMapping.get(i));
+//                if (w == null || w.getActions() == null) {
+//                    continue;
+//                }
+//                equipment.add(new EquipmentItemWidget(w.getName(), item.getId(), w.getId(), i, w.getActions()));
+//            }
+//        }
+//    }
+}

src/main/java/ee/futur/baseapi/collections/EquipmentItemWidget.java

@@ -0,0 +1,812 @@
+package ee.futur.baseapi.collections;
+
+import net.runelite.api.FontTypeFace;
+import net.runelite.api.Point;
+import net.runelite.api.widgets.Widget;
+
+import javax.annotation.Nullable;
+import java.awt.*;
+
+public class EquipmentItemWidget implements Widget {
+    String name;
+    String[] actions;
+    int packedId;
+    static final int EQUIPMENT_INVENTORY_ITEMS_CONTAINER = 25362449;
+    int equipmentItemId;
+    int index;
+
+    EquipmentItemWidget(String name, int itemId, int packedId, int index, String[] actions) {
+        this.equipmentItemId = itemId;
+        this.name = name;
+        this.actions = actions;
+        this.packedId = packedId;
+        this.index = index;
+    }
+
+
+    public void interact(String... actions) {
+        //MousePackets.queueClickPacket();
+        //WidgetPackets.queueWidgetAction(BaseApiPlugin.getClient().getWidget(packedId), actions);
+    }
+
+    public int getEquipmentItemId() {
+        return equipmentItemId;
+    }
+
+    public int getEquipmentIndex() {
+        return index;
+    }
+
+    @Override
+    public int getId() {
+        return packedId;
+    }
+
+    @Override
+    public int getType() {
+        return 0;
+    }
+
+    @Override
+    public void setType(int type) {
+
+    }
+
+    @Override
+    public void clearActions() {
+    }
+
+    ;
+
+    @Override
+    public int getContentType() {
+        return 0;
+    }
+
+    @Override
+    public Widget setContentType(int contentType) {
+        return null;
+    }
+
+    @Override
+    public int getClickMask() {
+        return 0;
+    }
+
+    @Override
+    public Widget setClickMask(int mask) {
+        return null;
+    }
+
+    @Override
+    public Widget getParent() {
+        return null;
+    }
+
+    @Override
+    public int getParentId() {
+        return 0;
+    }
+
+    @Override
+    public Widget getChild(int index) {
+        return null;
+    }
+
+    @Nullable
+    @Override
+    public Widget[] getChildren() {
+        return new Widget[0];
+    }
+
+    @Override
+    public void setChildren(Widget[] children) {
+
+    }
+
+    @Override
+    public Widget[] getDynamicChildren() {
+        return new Widget[0];
+    }
+
+    @Override
+    public Widget[] getStaticChildren() {
+        return new Widget[0];
+    }
+
+    @Override
+    public Widget[] getNestedChildren() {
+        return new Widget[0];
+    }
+
+    @Override
+    public int getRelativeX() {
+        return 0;
+    }
+
+    @Override
+    public void setRelativeX(int x) {
+
+    }
+
+    @Override
+    public int getRelativeY() {
+        return 0;
+    }
+
+    @Override
+    public void setRelativeY(int y) {
+
+    }
+
+    @Override
+    public void setForcedPosition(int x, int y) {
+
+    }
+
+    @Override
+    public String getText() {
+        return null;
+    }
+
+    @Override
+    public Widget setText(String text) {
+        return null;
+    }
+
+    @Override
+    public int getTextColor() {
+        return 0;
+    }
+
+    @Override
+    public Widget setTextColor(int textColor) {
+        return null;
+    }
+
+    @Override
+    public int getOpacity() {
+        return 0;
+    }
+
+    @Override
+    public Widget setOpacity(int transparency) {
+        return null;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public Widget setName(String name) {
+        return null;
+    }
+
+    @Override
+    public int getModelId() {
+        return 0;
+    }
+
+    @Override
+    public Widget setModelId(int id) {
+        return null;
+    }
+
+    @Override
+    public int getModelType() {
+        return 0;
+    }
+
+    @Override
+    public Widget setModelType(int type) {
+        return null;
+    }
+
+    @Override
+    public int getAnimationId() {
+        return 0;
+    }
+
+    @Override
+    public Widget setAnimationId(int animationId) {
+        return null;
+    }
+
+    @Override
+    public int getRotationX() {
+        return 0;
+    }
+
+    @Override
+    public Widget setRotationX(int modelX) {
+        return null;
+    }
+
+    @Override
+    public int getRotationY() {
+        return 0;
+    }
+
+    @Override
+    public Widget setRotationY(int modelY) {
+        return null;
+    }
+
+    @Override
+    public int getRotationZ() {
+        return 0;
+    }
+
+    @Override
+    public Widget setRotationZ(int modelZ) {
+        return null;
+    }
+
+    @Override
+    public int getModelZoom() {
+        return 0;
+    }
+
+    @Override
+    public Widget setModelZoom(int modelZoom) {
+        return null;
+    }
+
+    @Override
+    public int getSpriteId() {
+        return 0;
+    }
+
+    @Override
+    public boolean getSpriteTiling() {
+        return false;
+    }
+
+    @Override
+    public Widget setSpriteTiling(boolean tiling) {
+        return null;
+    }
+
+    @Override
+    public Widget setSpriteId(int spriteId) {
+        return null;
+    }
+
+    @Override
+    public boolean isHidden() {
+        return false;
+    }
+
+    @Override
+    public boolean isSelfHidden() {
+        return false;
+    }
+
+    @Override
+    public Widget setHidden(boolean hidden) {
+        return null;
+    }
+
+    @Override
+    public int getIndex() {
+        return index;
+    }
+
+    @Override
+    public Point getCanvasLocation() {
+        return null;
+    }
+
+    @Override
+    public int getWidth() {
+        return 0;
+    }
+
+    @Override
+    public void setWidth(int width) {
+
+    }
+
+    @Override
+    public int getHeight() {
+        return 0;
+    }
+
+    @Override
+    public void setHeight(int height) {
+
+    }
+
+    @Override
+    public Rectangle getBounds() {
+        return null;
+    }
+
+    @Override
+    public int getItemId() {
+        return equipmentItemId;
+    }
+
+    @Override
+    public Widget setItemId(int itemId) {
+        return null;
+    }
+
+    @Override
+    public int getItemQuantity() {
+        return 1;
+    }
+
+    @Override
+    public Widget setItemQuantity(int quantity) {
+        return null;
+    }
+
+    @Override
+    public boolean contains(Point point) {
+        return false;
+    }
+
+    @Override
+    public int getScrollX() {
+        return 0;
+    }
+
+    @Override
+    public Widget setScrollX(int scrollX) {
+        return null;
+    }
+
+    @Override
+    public int getScrollY() {
+        return 0;
+    }
+
+    @Override
+    public Widget setScrollY(int scrollY) {
+        return null;
+    }
+
+    @Override
+    public int getScrollWidth() {
+        return 0;
+    }
+
+    @Override
+    public Widget setScrollWidth(int width) {
+        return null;
+    }
+
+    @Override
+    public int getScrollHeight() {
+        return 0;
+    }
+
+    @Override
+    public Widget setScrollHeight(int height) {
+        return null;
+    }
+
+    @Override
+    public int getOriginalX() {
+        return 0;
+    }
+
+    @Override
+    public Widget setOriginalX(int originalX) {
+        return null;
+    }
+
+    @Override
+    public int getOriginalY() {
+        return 0;
+    }
+
+    @Override
+    public Widget setOriginalY(int originalY) {
+        return null;
+    }
+
+    @Override
+    public Widget setPos(int x, int y) {
+        return null;
+    }
+
+    @Override
+    public Widget setPos(int x, int y, int xMode, int yMode) {
+        return null;
+    }
+
+    @Override
+    public int getOriginalHeight() {
+        return 0;
+    }
+
+    @Override
+    public Widget setOriginalHeight(int originalHeight) {
+        return null;
+    }
+
+    @Override
+    public int getOriginalWidth() {
+        return 0;
+    }
+
+    @Override
+    public Widget setOriginalWidth(int originalWidth) {
+        return null;
+    }
+
+    @Override
+    public Widget setSize(int width, int height) {
+        return null;
+    }
+
+    @Override
+    public Widget setSize(int width, int height, int widthMode, int heightMode) {
+        return null;
+    }
+
+    @Nullable
+    @Override
+    public String[] getActions() {
+        return actions;
+    }
+
+    @Override
+    public Widget createChild(int index, int type) {
+        return null;
+    }
+
+    @Override
+    public Widget createChild(int type) {
+        return null;
+    }
+
+    @Override
+    public void deleteAllChildren() {
+
+    }
+
+    @Override
+    public void setAction(int index, String action) {
+
+    }
+
+    @Override
+    public void setOnOpListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnDialogAbortListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnKeyListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnMouseOverListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnMouseRepeatListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnMouseLeaveListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnTimerListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnTargetEnterListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnTargetLeaveListener(Object... args) {
+
+    }
+
+    @Override
+    public boolean hasListener() {
+        return false;
+    }
+
+    @Override
+    public Widget setHasListener(boolean hasListener) {
+        return null;
+    }
+
+    @Override
+    public boolean isIf3() {
+        return false;
+    }
+
+    @Override
+    public void revalidate() {
+
+    }
+
+    @Override
+    public void revalidateScroll() {
+
+    }
+
+    @Override
+    public Object[] getOnOpListener() {
+        return new Object[0];
+    }
+
+    @Override
+    public Object[] getOnKeyListener() {
+        return new Object[0];
+    }
+
+    @Override
+    public Object[] getOnLoadListener() {
+        return new Object[0];
+    }
+
+    @Override
+    public Object[] getOnInvTransmitListener() {
+        return new Object[0];
+    }
+
+    @Override
+    public int getFontId() {
+        return 0;
+    }
+
+    @Override
+    public Widget setFontId(int id) {
+        return null;
+    }
+
+    @Override
+    public int getBorderType() {
+        return 0;
+    }
+
+    @Override
+    public void setBorderType(int thickness) {
+
+    }
+
+    @Override
+    public boolean getTextShadowed() {
+        return false;
+    }
+
+    @Override
+    public Widget setTextShadowed(boolean shadowed) {
+        return null;
+    }
+
+    @Override
+    public int getDragDeadZone() {
+        return 0;
+    }
+
+    @Override
+    public void setDragDeadZone(int deadZone) {
+
+    }
+
+    @Override
+    public int getDragDeadTime() {
+        return 0;
+    }
+
+    @Override
+    public void setDragDeadTime(int deadTime) {
+
+    }
+
+    @Override
+    public int getItemQuantityMode() {
+        return 0;
+    }
+
+    @Override
+    public Widget setItemQuantityMode(int itemQuantityMode) {
+        return null;
+    }
+
+    @Override
+    public int getXPositionMode() {
+        return 0;
+    }
+
+    @Override
+    public Widget setXPositionMode(int xpm) {
+        return null;
+    }
+
+    @Override
+    public int getYPositionMode() {
+        return 0;
+    }
+
+    @Override
+    public Widget setYPositionMode(int ypm) {
+        return null;
+    }
+
+    @Override
+    public int getLineHeight() {
+        return 0;
+    }
+
+    @Override
+    public Widget setLineHeight(int lineHeight) {
+        return null;
+    }
+
+    @Override
+    public int getXTextAlignment() {
+        return 0;
+    }
+
+    @Override
+    public Widget setXTextAlignment(int xta) {
+        return null;
+    }
+
+    @Override
+    public int getYTextAlignment() {
+        return 0;
+    }
+
+    @Override
+    public Widget setYTextAlignment(int yta) {
+        return null;
+    }
+
+    @Override
+    public int getWidthMode() {
+        return 0;
+    }
+
+    @Override
+    public Widget setWidthMode(int widthMode) {
+        return null;
+    }
+
+    @Override
+    public int getHeightMode() {
+        return 0;
+    }
+
+    @Override
+    public Widget setHeightMode(int heightMode) {
+        return null;
+    }
+
+    @Override
+    public FontTypeFace getFont() {
+        return null;
+    }
+
+    @Override
+    public boolean isFilled() {
+        return false;
+    }
+
+    @Override
+    public Widget setFilled(boolean filled) {
+        return null;
+    }
+
+    @Override
+    public String getTargetVerb() {
+        return null;
+    }
+
+    @Override
+    public void setTargetVerb(String targetVerb) {
+
+    }
+
+    @Override
+    public int getTargetPriority() {
+        return 0;
+    }
+
+    @Override
+    public void setTargetPriority(int priority) {
+
+    }
+
+    @Override
+    public boolean getNoClickThrough() {
+        return false;
+    }
+
+    @Override
+    public void setNoClickThrough(boolean noClickThrough) {
+
+    }
+
+    @Override
+    public boolean getNoScrollThrough() {
+        return false;
+    }
+
+    @Override
+    public void setNoScrollThrough(boolean noScrollThrough) {
+
+    }
+
+    @Override
+    public int[] getVarTransmitTrigger() {
+        return null;
+    }
+
+    @Override
+    public void setVarTransmitTrigger(int... trigger) {
+
+    }
+
+    @Override
+    public void setOnClickListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnHoldListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnReleaseListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnDragCompleteListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnDragListener(Object... args) {
+
+    }
+
+    @Override
+    public void setOnScrollWheelListener(Object... args) {
+
+    }
+
+    @Override
+    public Widget getDragParent() {
+        return null;
+    }
+
+    @Override
+    public Widget setDragParent(Widget dragParent) {
+        return null;
+    }
+
+    @Override
+    public Object[] getOnVarTransmitListener() {
+        return new Object[0];
+    }
+
+    @Override
+    public void setOnVarTransmitListener(Object... args) {
+
+    }
+}

src/main/java/ee/futur/baseapi/collections/Inventory.java

@@ -0,0 +1,55 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.collections.query.ItemQuery;
+import net.runelite.api.Client;
+import net.runelite.api.GameState;
+import net.runelite.api.events.GameStateChanged;
+import net.runelite.api.widgets.Widget;
+import net.runelite.api.widgets.WidgetInfo;
+import net.runelite.client.RuneLite;
+import net.runelite.client.eventbus.Subscribe;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class Inventory {
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    static List<Widget> inventoryItems = new ArrayList<>();
+    static int lastUpdateTick = 0;
+
+    public static ItemQuery search() {
+        if (lastUpdateTick < client.getTickCount()) {
+            client.runScript(6009, 9764864, 28, 1, -1);
+            Inventory.inventoryItems =
+                    Arrays.stream(client.getWidget(WidgetInfo.INVENTORY).getDynamicChildren()).filter(Objects::nonNull).filter(x -> x.getItemId() != 6512 && x.getItemId() != -1).collect(Collectors.toList());
+            lastUpdateTick = client.getTickCount();
+        }
+        return new ItemQuery(inventoryItems);
+    }
+
+    public static int getEmptySlots() {
+        return 28 - search().result().size();
+    }
+
+    public static boolean full() {
+        return getEmptySlots() == 0;
+    }
+
+    public static int getItemAmount(int itemId) {
+        return search().withId(itemId).result().size();
+    }
+
+    public static int getItemAmount(String itemName) {
+        return search().withName(itemName).result().size();
+    }
+
+    @Subscribe
+    public void onGameStateChanged(GameStateChanged gameStateChanged) {
+        if (gameStateChanged.getGameState() == GameState.HOPPING || gameStateChanged.getGameState() == GameState.LOGIN_SCREEN || gameStateChanged.getGameState() == GameState.CONNECTION_LOST) {
+            Inventory.inventoryItems.clear();
+        }
+    }
+}

src/main/java/ee/futur/baseapi/collections/NPCs.java

@@ -0,0 +1,32 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.collections.query.NPCQuery;
+import net.runelite.api.Client;
+import net.runelite.api.NPC;
+import net.runelite.api.events.GameTick;
+import net.runelite.client.RuneLite;
+import net.runelite.client.eventbus.Subscribe;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class NPCs {
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    private static final List<NPC> npcList = new ArrayList<>();
+
+    public static NPCQuery search() {
+        return new NPCQuery(npcList);
+    }
+
+    @Subscribe(priority = 10000)
+    public void onGameTick(GameTick e) {
+        npcList.clear();
+        for (NPC npc : client.getNpcs()) {
+            if (npc == null)
+                continue;
+            if (npc.getId() == -1)
+                continue;
+            npcList.add(npc);
+        }
+    }
+}

src/main/java/ee/futur/baseapi/collections/Players.java

@@ -0,0 +1,30 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.collections.query.PlayerQuery;
+import net.runelite.api.Client;
+import net.runelite.api.Player;
+import net.runelite.api.events.GameTick;
+import net.runelite.client.RuneLite;
+import net.runelite.client.eventbus.Subscribe;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Players {
+    static List<Player> players = new ArrayList<>();
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+
+    public static PlayerQuery search() {
+        return new PlayerQuery(players);
+    }
+
+    @Subscribe
+    public void onGameTick(GameTick e) {
+        players.clear();
+        for (Player player : client.getPlayers()) {
+            if (player == null)
+                continue;
+            players.add(player);
+        }
+    }
+}

src/main/java/ee/futur/baseapi/collections/Shop.java

@@ -0,0 +1,64 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.collections.query.ItemQuery;
+import net.runelite.api.Client;
+import net.runelite.api.widgets.Widget;
+import net.runelite.client.RuneLite;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class Shop {
+    private static final int SHOP_ITEM_CONTAINER_PACKED_ID = 19660816;
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    static List<Widget> shopItems = new ArrayList<>();
+    static int lastUpdateTick = 0;
+
+    public static ItemQuery search() {
+        if (lastUpdateTick < client.getTickCount()) {
+            shopItems =
+                    Arrays.stream(client.getWidget(SHOP_ITEM_CONTAINER_PACKED_ID).getDynamicChildren()).filter(Objects::nonNull).filter(x -> x.getItemId() != 6512 && x.getItemId() != -1).collect(Collectors.toList());
+            lastUpdateTick = client.getTickCount();
+        }
+        return new ItemQuery(shopItems.stream().filter(Objects::nonNull).collect(Collectors.toList()));
+    }
+
+//    @Subscribe
+//    public void onWidgetLoaded(WidgetLoaded e)
+//    {
+//        if (e.getGroupId() == WidgetID.SHOP_GROUP_ID)
+//        {
+//            try
+//            {
+//                shopItems =
+//                        Arrays.stream(client.getWidget(SHOP_ITEM_CONTAINER_PACKED_ID).getDynamicChildren()).filter(Objects::nonNull).filter(x -> x.getItemId() != 6512 && x.getItemId() != -1).collect(Collectors.toList());
+//            }
+//            catch (NullPointerException err)
+//            {
+//                shopItems.clear();
+//            }
+//        }
+//    }
+//
+//    @Subscribe
+//    public void onItemContainerChanged(ItemContainerChanged e)
+//    {
+//        if (client.getWidget(SHOP_ITEM_CONTAINER_PACKED_ID) == null)
+//        {
+//            shopItems.clear();
+//            return;
+//        }
+//        try
+//        {
+//            shopItems =
+//                    Arrays.stream(client.getWidget(SHOP_ITEM_CONTAINER_PACKED_ID).getDynamicChildren()).filter(Objects::nonNull).filter(x -> x.getItemId() != 6512 && x.getItemId() != -1).collect(Collectors.toList());
+//        }
+//        catch (NullPointerException err)
+//        {
+//            shopItems.clear();
+//        }
+//    }
+}

src/main/java/ee/futur/baseapi/collections/ShopInventory.java

@@ -0,0 +1,79 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.collections.query.ItemQuery;
+import net.runelite.api.Client;
+import net.runelite.api.GameState;
+import net.runelite.api.events.GameStateChanged;
+import net.runelite.api.widgets.Widget;
+import net.runelite.api.widgets.WidgetInfo;
+import net.runelite.client.RuneLite;
+import net.runelite.client.eventbus.Subscribe;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class ShopInventory {
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    static List<Widget> shopInventoryItems = new ArrayList<>();
+    static int lastUpdateTick = 0;
+
+    public static ItemQuery search() {
+        if (lastUpdateTick < client.getTickCount()) {
+            shopInventoryItems =
+                    Arrays.stream(client.getWidget(WidgetInfo.SHOP_INVENTORY_ITEMS_CONTAINER).getDynamicChildren()).filter(Objects::nonNull).filter(x -> x.getItemId() != 6512 && x.getItemId() != -1).collect(Collectors.toList());
+            lastUpdateTick = client.getTickCount();
+        }
+        return new ItemQuery(shopInventoryItems.stream().filter(Objects::nonNull).collect(Collectors.toList()));
+    }
+
+//	@Subscribe
+//	public void onWidgetLoaded(WidgetLoaded e)
+//	{
+//		if (e.getGroupId() == WidgetID.SHOP_INVENTORY_GROUP_ID)
+//		{
+//			try
+//			{
+//				ShopInventory.shopInventoryItems =
+//					Arrays.stream(client.getWidget(WidgetInfo.SHOP_INVENTORY_ITEMS_CONTAINER).getDynamicChildren()).filter(Objects::nonNull).filter(x -> x.getItemId() != 6512 && x.getItemId() != -1).collect(Collectors.toList());
+//			}
+//			catch (NullPointerException err)
+//			{
+//				ShopInventory.shopInventoryItems.clear();
+//			}
+//		}
+//	}
+//
+//	@Subscribe
+//	public void onItemContainerChanged(ItemContainerChanged e)
+//	{
+//		if (e.getContainerId() == 256)
+//		{
+//			if (client.getWidget(WidgetInfo.SHOP_INVENTORY_ITEMS_CONTAINER) == null)
+//			{
+//				ShopInventory.shopInventoryItems.clear();
+//				return;
+//			}
+//			try
+//			{
+//				ShopInventory.shopInventoryItems =
+//					Arrays.stream(client.getWidget(WidgetInfo.SHOP_INVENTORY_ITEMS_CONTAINER).getDynamicChildren()).filter(Objects::nonNull).filter(x -> x.getItemId() != 6512 && x.getItemId() != -1).collect(Collectors.toList());
+//				return;
+//			}
+//			catch (NullPointerException err)
+//			{
+//				ShopInventory.shopInventoryItems.clear();
+//				return;
+//			}
+//		}
+//	}
+
+    @Subscribe
+    public void onGameStateChanged(GameStateChanged gameStateChanged) {
+        if (gameStateChanged.getGameState() == GameState.HOPPING || gameStateChanged.getGameState() == GameState.LOGIN_SCREEN || gameStateChanged.getGameState() == GameState.CONNECTION_LOST) {
+            ShopInventory.shopInventoryItems.clear();
+        }
+    }
+}

src/main/java/ee/futur/baseapi/collections/TileItems.java

@@ -0,0 +1,14 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.collections.query.TileItemQuery;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TileItems {
+    public static List<ETileItem> tileItems = new ArrayList<>();
+
+    public static TileItemQuery search() {
+        return new TileItemQuery(tileItems);
+    }
+}

src/main/java/ee/futur/baseapi/collections/TileObjects.java

@@ -0,0 +1,77 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.collections.query.TileObjectQuery;
+import net.runelite.api.*;
+import net.runelite.api.events.GameTick;
+import net.runelite.client.RuneLite;
+import net.runelite.client.eventbus.Subscribe;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+public class TileObjects {
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    static List<TileObject> tileObjects = new ArrayList<>();
+
+    public static TileObjectQuery search() {
+        return new TileObjectQuery(tileObjects);
+    }
+
+    @Subscribe(priority = 10000)
+    public void onGameTick(GameTick e) {
+        HashSet<TileObject> tileObjectHashSet = new HashSet<>();
+        tileObjects.clear();
+        TileItems.tileItems.clear();
+        for (Tile[] tiles : client.getScene().getTiles()[client.getPlane()]) {
+            if (tiles == null) {
+                continue;
+            }
+            for (Tile tile : tiles) {
+                if (tile == null) {
+                    continue;
+                }
+                if (tile.getGroundItems() != null) {
+                    for (TileItem groundItem : tile.getGroundItems()) {
+                        if (groundItem == null) {
+                            continue;
+                        }
+                        TileItems.tileItems.add(new ETileItem(tile.getWorldLocation(), groundItem));
+                    }
+                }
+                for (GameObject gameObject : tile.getGameObjects()) {
+                    if (gameObject == null) {
+                        continue;
+                    }
+                    if (gameObject.getId() == -1) {
+                        continue;
+                    }
+                    tileObjectHashSet.add(gameObject);
+                    //tileObjects.add(gameObject);
+                }
+                if (tile.getGroundObject() != null) {
+                    if (tile.getGroundObject().getId() == -1) {
+                        continue;
+                    }
+                    tileObjectHashSet.add(tile.getGroundObject());
+                    //tileObjects.add(tile.getGroundObject());
+                }
+                if (tile.getWallObject() != null) {
+                    if (tile.getWallObject().getId() == -1) {
+                        continue;
+                    }
+                    tileObjectHashSet.add(tile.getWallObject());
+                    //tileObjects.add(tile.getWallObject());
+                }
+                if (tile.getDecorativeObject() != null) {
+                    if (tile.getDecorativeObject().getId() == -1) {
+                        continue;
+                    }
+                    tileObjectHashSet.add(tile.getDecorativeObject());
+                    //tileObjects.add(tile.getDecorativeObject());
+                }
+            }
+        }
+        tileObjects.addAll(tileObjectHashSet);
+    }
+}

src/main/java/ee/futur/baseapi/collections/TradeInventory.java

@@ -0,0 +1,41 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.collections.query.ItemQuery;
+import net.runelite.api.Client;
+import net.runelite.api.GameState;
+import net.runelite.api.events.GameStateChanged;
+import net.runelite.api.widgets.Widget;
+import net.runelite.client.RuneLite;
+import net.runelite.client.eventbus.Subscribe;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class TradeInventory {
+    private static final int TRADE_INVENTORY_PACKED_ID = 22020096;
+
+    static int lastUpdateTick = 0;
+
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    static List<Widget> tradeInventoryItems = new ArrayList<>();
+
+    public static ItemQuery search() {
+        if (lastUpdateTick < client.getTickCount()) {
+            client.runScript(6009, 9764864, 28, 1, -1);
+            tradeInventoryItems =
+                    Arrays.stream(client.getWidget(TRADE_INVENTORY_PACKED_ID).getDynamicChildren()).filter(Objects::nonNull).filter(x -> x.getItemId() != 6512 && x.getItemId() != -1).collect(Collectors.toList());
+            lastUpdateTick = client.getTickCount();
+        }
+        return new ItemQuery(tradeInventoryItems);
+    }
+
+    @Subscribe
+    public void onGameStateChanged(GameStateChanged gameStateChanged) {
+        if (gameStateChanged.getGameState() == GameState.HOPPING || gameStateChanged.getGameState() == GameState.LOGIN_SCREEN || gameStateChanged.getGameState() == GameState.CONNECTION_LOST) {
+            tradeInventoryItems.clear();
+        }
+    }
+}

src/main/java/ee/futur/baseapi/collections/Widgets.java

@@ -0,0 +1,76 @@
+package ee.futur.baseapi.collections;
+
+import ee.futur.baseapi.collections.query.WidgetQuery;
+import net.runelite.api.Client;
+import net.runelite.api.widgets.Widget;
+import net.runelite.client.RuneLite;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+public class Widgets {
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    static int lastSearchIdleTicks = -10;
+    static HashSet<Widget> cachedWidgets = new HashSet<>();
+
+    //It is important to note that this method will return all widgets, including hidden ones.
+    //Some widgets are not updated while hidden so there is a chance that the widgets returned contain outdated
+    // information.
+    //for update critical information make sure the widget is not hidden or use the other query types like inventory,
+    // equipment ect as they will only return up-to-date information.
+    public static WidgetQuery search() {
+        if (lastSearchIdleTicks == client.getKeyboardIdleTicks()) {
+            return new WidgetQuery(cachedWidgets);
+        }
+        HashSet<Widget> returnList = new HashSet<>();
+        Widget[] currentQueue;
+        ArrayList<Widget> buffer = new ArrayList<>();
+        currentQueue = client.getWidgetRoots();
+        while (currentQueue.length != 0) {
+            for (Widget widget : currentQueue) {
+                if (widget == null) {
+                    continue;
+                }
+                returnList.add(widget);
+                if (widget.getDynamicChildren() != null) {
+                    for (Widget dynamicChild : widget.getDynamicChildren()) {
+                        if (dynamicChild == null) {
+                            continue;
+                        }
+                        buffer.add(dynamicChild);
+                        returnList.add(dynamicChild);
+                    }
+                }
+                if (widget.getNestedChildren() != null) {
+                    for (Widget nestedChild : widget.getNestedChildren()) {
+                        if (nestedChild == null) {
+                            continue;
+                        }
+                        buffer.add(nestedChild);
+                        returnList.add(nestedChild);
+                    }
+                }
+                Widget[] staticChildren;
+                try {
+                    staticChildren = widget.getStaticChildren();
+                } catch (NullPointerException e) {
+                    continue;
+                }
+                if (staticChildren != null) {
+                    for (Widget staticChild : staticChildren) {
+                        if (staticChild == null) {
+                            continue;
+                        }
+                        buffer.add(staticChild);
+                        returnList.add(staticChild);
+                    }
+                }
+            }
+            currentQueue = buffer.toArray(new Widget[]{});
+            buffer.clear();
+        }
+        lastSearchIdleTicks = client.getKeyboardIdleTicks();
+        cachedWidgets = returnList;
+        return new WidgetQuery(returnList);
+    }
+}

src/main/java/ee/futur/baseapi/collections/query/EquipmentItemQuery.java

@@ -0,0 +1,88 @@
+package ee.futur.baseapi.collections.query;
+
+import ee.futur.baseapi.collections.EquipmentItemWidget;
+import net.runelite.api.widgets.Widget;
+import net.runelite.client.util.Text;
+import net.runelite.client.util.WildcardMatcher;
+
+import java.util.*;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class EquipmentItemQuery {
+    private List<EquipmentItemWidget> items;
+
+    public EquipmentItemQuery(List<EquipmentItemWidget> items) {
+        this.items = new ArrayList(items);
+    }
+
+    public EquipmentItemQuery filter(Predicate<? super Widget> predicate) {
+        items = items.stream().filter(predicate).collect(Collectors.toList());
+        return this;
+    }
+
+    public EquipmentItemQuery withAction(String action) {
+        items = items.stream().filter(item -> Arrays.asList(item.getActions()).contains(action)).collect(Collectors.toList());
+        return this;
+    }
+
+    public EquipmentItemQuery withId(int id) {
+        items = items.stream().filter(item -> item.getEquipmentItemId() == id).collect(Collectors.toList());
+        return this;
+    }
+
+    public EquipmentItemQuery withName(String name) {
+        items = items.stream().filter(item -> item.getName().equals(name)).collect(Collectors.toList());
+        return this;
+    }
+
+    public EquipmentItemQuery nameContains(String name) {
+        items = items.stream().filter(item -> item.getName().contains(name)).collect(Collectors.toList());
+        return this;
+    }
+
+    public EquipmentItemQuery nameContainsNoCase(String name) {
+        items =
+                items.stream().filter(item -> item.getName().toLowerCase().contains(name.toLowerCase())).collect(Collectors.toList());
+        return this;
+    }
+
+    public EquipmentItemQuery idInList(List<Integer> ids) {
+        items = items.stream().filter(item -> ids.contains(item.getEquipmentItemId())).collect(Collectors.toList());
+        return this;
+    }
+
+    public EquipmentItemQuery indexIs(int index) {
+        items = items.stream().filter(item -> item.getIndex() == index).collect(Collectors.toList());
+        return this;
+    }
+
+    public EquipmentItemQuery matchesWildCardNoCase(String input) {
+        items =
+                items.stream().
+                        filter(item -> WildcardMatcher.matches(input.toLowerCase(), Text.removeTags(item.getName().toLowerCase()))).
+                        collect(Collectors.toList());
+        return this;
+    }
+
+    public boolean empty() {
+        return items.size() == 0;
+    }
+
+    public EquipmentItemQuery filterUnique() {
+        items = items.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparingInt(Widget::getItemId))), ArrayList::new));
+        return this;
+    }
+
+    public List<EquipmentItemWidget> result() {
+        return items;
+    }
+
+    public Optional<EquipmentItemWidget> first() {
+        Widget returnWidget = null;
+        if (items.size() == 0) {
+            return Optional.ofNullable(null);
+        }
+        return Optional.ofNullable(items.get(0));
+    }
+}

src/main/java/ee/futur/baseapi/collections/query/ItemQuery.java

@@ -0,0 +1,157 @@
+package ee.futur.baseapi.collections.query;
+
+import ee.futur.baseapi.BaseApiPlugin;
+import lombok.SneakyThrows;
+import net.runelite.api.Client;
+import net.runelite.api.ItemComposition;
+import net.runelite.api.widgets.Widget;
+import net.runelite.client.RuneLite;
+import net.runelite.client.game.ItemManager;
+import net.runelite.client.util.Text;
+import net.runelite.client.util.WildcardMatcher;
+
+import java.util.*;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class ItemQuery {
+    private List<Widget> items;
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    static ItemManager itemManager = RuneLite.getInjector().getInstance(ItemManager.class);
+
+    public ItemQuery(List<Widget> items) {
+        this.items = new ArrayList(items);
+    }
+
+    public ItemQuery filter(Predicate<? super Widget> predicate) {
+        items = items.stream().filter(predicate).collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery withAction(String action) {
+        items = items.stream().filter(item -> Arrays.asList(item.getActions()).contains(action)).collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery tradeAble() {
+        items = items.stream().filter(item -> itemManager.getItemComposition(item.getItemId()).isTradeable()).collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery differenceInValueLessThan(int difference) {
+        items = items.stream().filter(item -> Math.abs(itemManager.getItemComposition(item.getItemId()).getHaPrice() - itemManager.getItemPriceWithSource(item.getItemId(), true)) < difference).collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery priceOver(int price) {
+        items = items.stream().filter(item -> itemManager.getItemComposition(item.getItemId()).getHaPrice() >= price).collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery withSet(Set<Integer> ids) {
+        items = items.stream()
+                .filter(item -> ids.contains(item.getItemId()))
+                .collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery withId(int id) {
+        items = items.stream().filter(item -> item.getItemId() == id).collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery withName(String name) {
+        items = items.stream().filter(item -> Text.removeTags(item.getName()).equals(Text.removeTags(name))).collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery quantityGreaterThan(int quanity) {
+        items = items.stream().filter(item -> item.getItemQuantity() > quanity).collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery nameContains(String name) {
+        items = items.stream().filter(item -> item.getName().contains(name)).collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery nonPlaceHolder() {
+        return quantityGreaterThan(0);
+    }
+
+    public ItemQuery idInList(List<Integer> ids) {
+        items = items.stream().filter(item -> ids.contains(item.getItemId())).collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery nameInList(List<String> names) {
+        items = items.stream()
+                .filter(item -> names.stream()
+                        .map(String::toLowerCase)
+                        .anyMatch(name -> Text.removeTags(item.getName()).equalsIgnoreCase(name)))
+                .collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery indexIs(int index) {
+        items = items.stream().filter(item -> item.getIndex() == index).collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery matchesWildCardNoCase(String input) {
+        items =
+                items.stream().
+                        filter(item -> WildcardMatcher.matches(input.toLowerCase(), Text.removeTags(item.getName().toLowerCase()))).
+                        collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery onlyNoted() {
+        items = items.stream().filter(this::isNoted).collect(Collectors.toList());
+        return this;
+    }
+
+    public ItemQuery onlyStackable() {
+        items = items.stream().filter(this::isStackable).collect(Collectors.toList());
+        return this;
+    }
+
+
+    public ItemQuery onlyUnnoted() {
+        items = items.stream().filter(item -> !isNoted(item)).collect(Collectors.toList());
+        return this;
+    }
+
+    public boolean empty() {
+        return items.size() == 0;
+    }
+
+    public ItemQuery filterUnique() {
+        items = items.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparingInt(Widget::getItemId))), ArrayList::new));
+        return this;
+    }
+
+    public List<Widget> result() {
+        return items;
+    }
+
+    public Optional<Widget> first() {
+        Widget returnWidget = null;
+        if (items.size() == 0) {
+            return Optional.ofNullable(null);
+        }
+        return Optional.ofNullable(items.get(0));
+    }
+
+    @SneakyThrows
+    public boolean isNoted(Widget item) {
+        ItemComposition itemComposition = BaseApiPlugin.itemDefs.get(item.getItemId());
+        return itemComposition.getNote() != -1;
+    }
+
+    @SneakyThrows
+    public boolean isStackable(Widget item) {
+        ItemComposition itemComposition = BaseApiPlugin.itemDefs.get(item.getItemId());
+        return itemComposition.isStackable();
+    }
+}

src/main/java/ee/futur/baseapi/collections/query/NPCQuery.java

@@ -0,0 +1,232 @@
+package ee.futur.baseapi.collections.query;
+
+import ee.futur.baseapi.collections.Players;
+import ee.futur.baseapi.BaseApiPlugin;
+import ee.futur.baseapi.utils.WorldAreaUtility;
+import net.runelite.api.Actor;
+import net.runelite.api.Client;
+import net.runelite.api.NPC;
+import net.runelite.api.NPCComposition;
+import net.runelite.api.coords.WorldArea;
+import net.runelite.api.coords.WorldPoint;
+import net.runelite.client.RuneLite;
+
+import java.util.*;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class NPCQuery {
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    private List<NPC> npcs;
+
+    public NPCQuery(List<NPC> npcs) {
+        this.npcs = new ArrayList(npcs.stream().filter(Objects::nonNull).collect(Collectors.toList()));
+    }
+
+    public NPCQuery filter(Predicate<? super NPC> predicate) {
+        npcs = npcs.stream().filter(predicate).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery atLocation(WorldPoint wp) {
+        npcs = npcs.stream().filter(npc -> npc.getWorldLocation().equals(wp)).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery withAction(String action) {
+        npcs = npcs.stream().filter(npc -> {
+            NPCComposition npcComposition = getNPCComposition(npc);
+            if (npcComposition == null)
+                return false;
+            String[] actions = getNPCComposition(npc).getActions();
+            return Arrays.stream(actions).filter(Objects::nonNull).anyMatch(a -> a.equalsIgnoreCase(action));
+        }).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery withId(int id) {
+        npcs = npcs.stream().filter(npc -> npc.getId() == id).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery withName(String name) {
+        npcs = npcs.stream().filter(npcs -> npcs.getName() != null && npcs.getName().equals(name)).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery nameContains(String name) {
+        npcs = npcs.stream().filter(npcs -> npcs.getName() != null && npcs.getName().contains(name)).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery interactingWithLocal() {
+        List<NPC> filteredNPCs = new ArrayList<>();
+        for (NPC npc : npcs) {
+            if (!npc.isInteracting())
+                continue;
+            if (npc.getInteracting() == client.getLocalPlayer())
+                filteredNPCs.add(npc);
+        }
+        npcs = filteredNPCs;
+        return this;
+    }
+
+    public NPCQuery interactingWith(Actor actor) {
+        List<NPC> filteredNPCs = new ArrayList<>();
+        for (NPC npc : npcs) {
+            if (!npc.isInteracting())
+                continue;
+            if (npc.getInteracting() == actor)
+                filteredNPCs.add(npc);
+        }
+        npcs = filteredNPCs;
+        return this;
+    }
+
+    public NPCQuery idInList(List<Integer> ids) {
+        npcs = npcs.stream().filter(npcs -> ids.contains(npcs.getId())).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery withinWorldArea(WorldArea area) {
+        npcs = npcs.stream().filter(npcs -> area.contains(npcs.getWorldLocation())).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery withinBounds(WorldPoint min, WorldPoint max) {
+        int x1 = min.getX();
+        int x2 = max.getX();
+        int y1 = min.getY();
+        int y2 = max.getY();
+
+        npcs = npcs.stream().filter(npc -> {
+            int x3 = npc.getWorldLocation().getX();
+            int y3 = npc.getWorldLocation().getY();
+
+            if (x3 > Math.max(x1, x2) || x3 < Math.min(x1, x2)) {
+                return false;
+            }
+
+            return y3 <= Math.max(y1, y2) && y3 >= Math.min(y1, y2);
+        }).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery indexIs(int index) {
+        npcs = npcs.stream().filter(npcs -> npcs.getIndex() == index).collect(Collectors.toList());
+        return this;
+    }
+
+    public boolean empty() {
+        return npcs.size() == 0;
+    }
+
+    public NPCQuery filterUnique() {
+        npcs =
+                npcs.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparingInt(NPC::getId))), ArrayList::new));
+        return this;
+    }
+
+    public List<NPC> result() {
+        return npcs;
+    }
+
+    public NPCQuery walkable() {
+        npcs = npcs.stream().filter(npc -> BaseApiPlugin.canPathToTile(npc.getWorldLocation()).isReachable()).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery interacting() {
+        npcs = npcs.stream().filter(Actor::isInteracting).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery notInteracting() {
+        npcs = npcs.stream().filter(npc -> !npc.isInteracting()).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery noOneInteractingWith() {
+        npcs = npcs.stream().filter(npc -> Players.search().interactingWith(npc).isEmpty()).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery playerInteractingWith() {
+        npcs = npcs.stream().filter(npc -> client.getLocalPlayer().isInteracting() && client.getLocalPlayer().getInteracting() == npc).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery playerNotInteractingWith() {
+        npcs = npcs.stream().filter(npc -> !client.getLocalPlayer().isInteracting() || client.getLocalPlayer().getInteracting() != npc).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery meleeable() {
+        List<WorldPoint> meleeTiles = new ArrayList<>();
+        meleeTiles.add(client.getLocalPlayer().getWorldLocation().dx(1));
+        meleeTiles.add(client.getLocalPlayer().getWorldLocation().dx(-1));
+        meleeTiles.add(client.getLocalPlayer().getWorldLocation().dy(1));
+        meleeTiles.add(client.getLocalPlayer().getWorldLocation().dy(-1));
+        npcs =
+                npcs.stream().filter(npc -> !Collections.disjoint(meleeTiles, npc.getWorldArea().toWorldPointList()) && npc.getWorldArea().distanceTo(client.getLocalPlayer().getWorldLocation()) == 1).collect(Collectors.toList());
+        return this;
+    }
+
+    public NPCQuery alive() {
+        npcs = npcs.stream().filter(npc -> !npc.isDead() && npc.getHealthRatio() != 0).collect(Collectors.toList());
+        return this;
+    }
+
+    public Optional<NPC> nearestToPlayer() {
+        if (npcs.size() == 0) {
+            return Optional.ofNullable(null);
+        }
+        return npcs.stream().min(Comparator.comparingInt(npc -> npc.getWorldLocation().distanceTo(client.getLocalPlayer().getWorldLocation())));
+    }
+
+    public Optional<NPC> nearestToPoint(WorldPoint point) {
+        if (npcs.size() == 0) {
+            return Optional.ofNullable(null);
+        }
+        return npcs.stream().min(Comparator.comparingInt(npc -> npc.getWorldLocation().distanceTo(point)));
+    }
+
+    public Optional<NPC> first() {
+        if (npcs.size() == 0) {
+            return Optional.ofNullable(null);
+        }
+        return Optional.ofNullable(npcs.get(0));
+    }
+
+    public static NPCComposition getNPCComposition(NPC npc) {
+        if (npc.getComposition().getConfigs() == null || npc.getTransformedComposition() == null) {
+            return npc.getComposition();
+        }
+        return npc.getTransformedComposition();
+    }
+
+    public Optional<NPC> nearestByPath() {
+        HashMap<WorldPoint, NPC> npcMap = new HashMap<>();
+        for (NPC npc : npcs) {
+            for (WorldPoint wp : npc.getWorldArea().toWorldPointList()) {
+                npcMap.put(wp, npc);
+            }
+
+            for (WorldPoint wp : WorldAreaUtility.objectInteractableTiles(npc)) {
+                npcMap.put(wp, npc);
+            }
+        }
+        List<WorldPoint> path = BaseApiPlugin.pathToGoalSetFromPlayerNoCustomTiles(new HashSet<>(npcMap.keySet()));
+        if (path == null) {
+            return Optional.empty();
+        }
+        if (path.isEmpty()) {
+            if (npcMap.containsKey(client.getLocalPlayer().getWorldLocation())) {
+                return Optional.ofNullable(npcMap.get(client.getLocalPlayer().getWorldLocation()));
+            } else {
+                return Optional.empty();
+            }
+        }
+        return Optional.ofNullable(npcMap.get(path.get(path.size() - 1)));
+    }
+}

src/main/java/ee/futur/baseapi/collections/query/PlayerQuery.java

@@ -0,0 +1,131 @@
+package ee.futur.baseapi.collections.query;
+
+import ee.futur.baseapi.BaseApiPlugin;
+import ee.futur.baseapi.utils.WorldAreaUtility;
+import net.runelite.api.Actor;
+import net.runelite.api.Client;
+import net.runelite.api.Player;
+import net.runelite.api.coords.WorldArea;
+import net.runelite.api.coords.WorldPoint;
+import net.runelite.client.RuneLite;
+
+import java.util.*;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class PlayerQuery {
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    private List<Player> players;
+
+    public PlayerQuery(List<Player> players) {
+        this.players = new ArrayList<>(players);
+    }
+
+    public PlayerQuery withName(String name) {
+        List<Player> filteredPlayers = new ArrayList<>();
+        for (Player player : players) {
+            if (player.getName().equals(name))
+                filteredPlayers.add(player);
+        }
+        players = filteredPlayers;
+        return this;
+    }
+
+    public PlayerQuery withinWorldArea(WorldArea area) {
+        players = players.stream().filter(player -> area.contains(player.getWorldLocation())).collect(Collectors.toList());
+        return this;
+    }
+
+    public PlayerQuery filter(Predicate<? super Player> predicate) {
+        players = players.stream().filter(predicate).collect(Collectors.toList());
+        return this;
+    }
+
+    public PlayerQuery interactingWithLocal() {
+        List<Player> filteredPlayers = new ArrayList<>();
+        for (Player player : players) {
+            if (!player.isInteracting())
+                continue;
+            if (player.getInteracting() == client.getLocalPlayer())
+                filteredPlayers.add(player);
+        }
+        players = filteredPlayers;
+        return this;
+    }
+
+    public PlayerQuery interactingWith(Actor actor) {
+        List<Player> filteredPlayers = new ArrayList<>();
+        for (Player player : players) {
+            if (!player.isInteracting())
+                continue;
+            if (player.getInteracting() == actor)
+                filteredPlayers.add(player);
+        }
+        players = filteredPlayers;
+        return this;
+    }
+
+    public PlayerQuery nameContains(String name) {
+        List<Player> filteredPlayers = new ArrayList<>();
+        for (Player player : players) {
+            if (player.getName().contains(name))
+                filteredPlayers.add(player);
+        }
+        players = filteredPlayers;
+        return this;
+    }
+
+    public PlayerQuery notLocalPlayer() {
+        players.remove(client.getLocalPlayer());
+        return this;
+    }
+
+    public PlayerQuery withinLevel(int low, int high) {
+        List<Player> filteredPlayers = new ArrayList<>();
+        for (Player player : players) {
+            if (player.getCombatLevel() >= low && player.getCombatLevel() <= high)
+                filteredPlayers.add(player);
+        }
+        players = filteredPlayers;
+        return this;
+    }
+
+    public boolean isEmpty() {
+        return players.isEmpty();
+    }
+
+    public Optional<Player> first() {
+        if (players.isEmpty())
+            return Optional.empty();
+        return Optional.ofNullable(players.get(0));
+    }
+
+    public List<Player> result() {
+        return players;
+    }
+
+    public Optional<Player> nearestByPath() {
+        HashMap<WorldPoint, Player> playerMap = new HashMap<>();
+        for (Player player : players) {
+            for (WorldPoint wp : player.getWorldArea().toWorldPointList()) {
+                playerMap.put(wp, player);
+            }
+
+            for (WorldPoint wp : WorldAreaUtility.objectInteractableTiles(player)) {
+                playerMap.put(wp, player);
+            }
+        }
+        List<WorldPoint> path = BaseApiPlugin.pathToGoalSetFromPlayerNoCustomTiles(new HashSet<>(playerMap.keySet()));
+        if (path == null) {
+            return Optional.empty();
+        }
+        if (path.isEmpty()) {
+            if (playerMap.containsKey(client.getLocalPlayer().getWorldLocation())) {
+                return Optional.ofNullable(playerMap.get(client.getLocalPlayer().getWorldLocation()));
+            } else {
+                return Optional.empty();
+            }
+        }
+        return Optional.ofNullable(playerMap.get(path.get(path.size() - 1)));
+    }
+}

src/main/java/ee/futur/baseapi/collections/query/QuickPrayer.java

@@ -0,0 +1,44 @@
+package ee.futur.baseapi.collections.query;
+
+public enum QuickPrayer {
+    THICK_SKIN(0),
+    BURST_OF_STRENGTH(1),
+    CLARITY_OF_THOUGHT(2),
+    SHARP_EYE(18),
+    MYSTIC_WILL(19),
+    ROCK_SKIN(3),
+    SUPERHUMAN_STRENGTH(4),
+    IMPROVED_REFLEXES(5),
+    RAPID_RESTORE(6),
+    RAPID_HEAL(7),
+    PROTECT_ITEM(8),
+    HAWK_EYE(20),
+    MYSTIC_LORE(21),
+    STEEL_SKIN(9),
+    ULTIMATE_STRENGTH(10),
+    INCREDIBLE_REFLEXES(11),
+    PROTECT_FROM_MAGIC(12),
+    PROTECT_FROM_MISSILES(13),
+    PROTECT_FROM_MELEE(14),
+    EAGLE_EYE(22),
+    MYSTIC_MIGHT(23),
+    RETRIBUTION(15),
+    REDEMPTION(16),
+    SMITE(17),
+    PRESERVE(28),
+    CHIVALRY(25),
+    PIETY(26),
+    RIGOUR(24),
+    AUGURY(27);
+    private final int index;
+    private int varbit;
+
+    QuickPrayer(int index) {
+        this.varbit = varbit;
+        this.index = index;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+}

src/main/java/ee/futur/baseapi/collections/query/TileItemQuery.java

@@ -0,0 +1,219 @@
+package ee.futur.baseapi.collections.query;
+
+import ee.futur.baseapi.collections.ETileItem;
+import ee.futur.baseapi.BaseApiPlugin;
+import lombok.SneakyThrows;
+import net.runelite.api.Client;
+import net.runelite.api.ItemComposition;
+import net.runelite.api.coords.WorldPoint;
+import net.runelite.client.RuneLite;
+import net.runelite.client.game.ItemManager;
+import net.runelite.client.util.Text;
+import net.runelite.client.util.WildcardMatcher;
+
+import java.util.*;
+import java.util.concurrent.ExecutionException;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class TileItemQuery {
+    public List<ETileItem> tileItems;
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    static ItemManager itemManager = RuneLite.getInjector().getInstance(ItemManager.class);
+
+    public TileItemQuery(List<ETileItem> tileItems) {
+        this.tileItems = new ArrayList<ETileItem>(tileItems);
+    }
+
+    public TileItemQuery withId(int id) {
+        tileItems = this.tileItems.stream().filter(tileItem -> tileItem.tileItem.getId() == id).collect(Collectors.toList());
+        return this;
+    }
+
+    @SneakyThrows
+    public TileItemQuery withName(String name) {
+        tileItems = tileItems.stream().filter(tileItem ->
+        {
+            try {
+                return BaseApiPlugin.itemDefs.get(tileItem.tileItem.getId()).getName().equals(name);
+            } catch (ExecutionException e) {
+                throw new RuntimeException(e);
+            }
+        }).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileItemQuery nameContains(String name) {
+        tileItems = tileItems.stream().filter(tileItem ->
+        {
+            try {
+                return BaseApiPlugin.itemDefs.get(tileItem.tileItem.getId()).getName().contains(name);
+            } catch (ExecutionException e) {
+                throw new RuntimeException(e);
+            }
+        }).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileItemQuery filter(Predicate<? super ETileItem> predicate) {
+        tileItems = tileItems.stream().filter(predicate).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileItemQuery onlyNoted() {
+        tileItems = tileItems.stream().filter(this::isNoted).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileItemQuery onlyUnnoted() {
+        tileItems = tileItems.stream().filter(item -> !isNoted(item)).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileItemQuery matchesWildCardNoCase(String input) {
+        tileItems =
+                tileItems.stream().
+                        filter(item ->
+                        {
+                            try {
+                                return WildcardMatcher.matches(input.toLowerCase(),
+                                        Text.removeTags(BaseApiPlugin.itemDefs.get(item.tileItem.getId()).getName().toLowerCase()));
+                            } catch (ExecutionException e) {
+                                throw new RuntimeException(e);
+                            }
+                        }).
+                        collect(Collectors.toList());
+        return this;
+    }
+
+    public TileItemQuery eachItemAboveXValue(int value) {
+        tileItems = tileItems.stream().filter(item -> itemManager.getItemPrice(item.getTileItem().getId()) > value).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileItemQuery stackAboveXValue(int value) {
+        tileItems = tileItems.stream().filter(item -> item.getTileItem().getQuantity() * itemManager.getItemPrice(item.getTileItem().getId()) > value).collect(Collectors.toList());
+        return this;
+    }
+
+    //the 3 methods below are ugly af and might not work
+    public TileItemQuery doesNotMatchWildCardNoCase(String input) {
+        tileItems =
+                tileItems.stream().
+                        filter(item ->
+                        {
+                            try {
+                                return !WildcardMatcher.matches(input.toLowerCase(),
+                                        Text.removeTags(BaseApiPlugin.itemDefs.get(item.tileItem.getId()).getName().toLowerCase()));
+                            } catch (ExecutionException e) {
+                                throw new RuntimeException(e);
+                            }
+                        }).
+                        collect(Collectors.toList());
+        return this;
+    }
+
+    public TileItemQuery itemsMatchingWildcardsNoCase(String... input) {
+        List<ETileItem> tileItemsTemp = new ArrayList<>();
+        for (String s : input) {
+            tileItemsTemp.addAll(tileItems.stream().
+                    filter(item ->
+                    {
+                        try {
+                            return WildcardMatcher.matches(s.toLowerCase(),
+                                    Text.removeTags(BaseApiPlugin.itemDefs.get(item.tileItem.getId()).getName().toLowerCase()));
+                        } catch (ExecutionException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }).
+                    collect(Collectors.toList()));
+        }
+        tileItems = tileItemsTemp;
+        return this;
+    }
+
+    public TileItemQuery itemsExcludingMatchingWildcardsNoCase(String... input) {
+        List<ETileItem> tileItemsTemp = new ArrayList<>();
+        for (String s : input) {
+            tileItemsTemp.addAll(tileItems.stream().
+                    filter(item ->
+                    {
+                        try {
+                            return WildcardMatcher.matches(s.toLowerCase(),
+                                    Text.removeTags(BaseApiPlugin.itemDefs.get(item.tileItem.getId()).getName().toLowerCase()));
+                        } catch (ExecutionException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }).
+                    collect(Collectors.toList()));
+        }
+        tileItems.removeAll(tileItemsTemp);
+        return this;
+    }
+
+
+    public boolean empty() {
+        return tileItems.size() == 0;
+    }
+
+    public List<ETileItem> result() {
+        return tileItems;
+    }
+
+    public Optional<ETileItem> first() {
+        if (tileItems.size() == 0) {
+            return Optional.empty();
+        }
+        return Optional.ofNullable(tileItems.get(0));
+    }
+
+    public TileItemQuery withinDistance(int distance) {
+        tileItems = tileItems.stream().filter(tileItem -> tileItem.getLocation().distanceTo(client.getLocalPlayer().getWorldLocation()) <= distance).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileItemQuery withinDistanceToPoint(int distance, WorldPoint point) {
+        tileItems = tileItems.stream().filter(tileItem -> tileItem.getLocation().distanceTo(point) <= distance).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileItemQuery alchValueAbove(int value) {
+        tileItems = tileItems.stream().filter(tileItem -> itemManager.getItemComposition(tileItem.getTileItem().getId()).getHaPrice() > value).collect(Collectors.toList());
+        return this;
+    }
+
+    public Optional<ETileItem> nearestToPlayer() {
+        return nearestToPoint(client.getLocalPlayer().getWorldLocation());
+    }
+
+    public Optional<ETileItem> nearestToPoint(WorldPoint point) {
+        if (tileItems.size() == 0) {
+            return Optional.empty();
+        }
+        return tileItems.stream().min(Comparator.comparingInt(tileItem -> tileItem.location.distanceTo(point)));
+    }
+
+    @SneakyThrows
+    public boolean isNoted(ETileItem item) {
+        ItemComposition itemComposition = BaseApiPlugin.itemDefs.get(item.tileItem.getId());
+        return itemComposition.getNote() != -1;
+    }
+
+    public Optional<ETileItem> nearestByPath() {
+        HashSet<WorldPoint> tiles = new HashSet<>();
+        HashMap<WorldPoint, ETileItem> map = new HashMap<>();
+        WorldPoint playerLoc = client.getLocalPlayer().getWorldLocation();
+        for (var t : tileItems) {
+            if (playerLoc.equals(t.getLocation())) {
+                return Optional.of(t);
+            }
+            map.put(t.getLocation(), t);
+            tiles.add(t.getLocation());
+        }
+        List<WorldPoint> path = BaseApiPlugin.pathToGoalSetFromPlayerNoCustomTiles(new HashSet<>(tiles));
+        if (path == null || path.isEmpty()) {
+            return Optional.empty();
+        }
+        return Optional.ofNullable(map.get(path.get(path.size() - 1)));
+    }
+}

src/main/java/ee/futur/baseapi/collections/query/TileObjectQuery.java

@@ -0,0 +1,179 @@
+package ee.futur.baseapi.collections.query;
+
+import ee.futur.baseapi.BaseApiPlugin;
+import ee.futur.baseapi.utils.WorldAreaUtility;
+import net.runelite.api.Client;
+import net.runelite.api.ObjectComposition;
+import net.runelite.api.TileObject;
+import net.runelite.api.coords.WorldPoint;
+import net.runelite.client.RuneLite;
+
+import java.util.*;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class TileObjectQuery {
+    private List<TileObject> tileObjects;
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+
+    public TileObjectQuery(List<TileObject> tileObjects) {
+        this.tileObjects = new ArrayList(tileObjects);
+    }
+
+    public TileObjectQuery withName(String name) {
+        tileObjects =
+                tileObjects.stream().filter(tileObject -> {
+                    ObjectComposition objectComposition = getObjectComposition(tileObject);
+                    if (objectComposition == null)
+                        return false;
+                    return objectComposition.getName().equals(name);
+                }).collect(Collectors.toList());
+        return this;
+    }
+//    public TileObjectQuery withActions(String... actions){
+//tileObjects =
+//                tileObjects.stream().filter(tileObject -> {
+//                    ObjectComposition objectComposition = getObjectComposition(tileObject);
+//                    if (objectComposition == null)
+//                        return false;
+//                    String[] objectActions = objectComposition.getActions();
+//                    for (String action : actions) {
+//                        if (Arrays.stream(objectActions).filter(Objects::nonNull).anyMatch(a -> a.equalsIgnoreCase(action))) {
+//                            return true;
+//                        }
+//                    }
+//                    return false;
+//                }).collect(Collectors.toList());
+//        return this;
+//    }
+
+    public TileObjectQuery withId(int id) {
+        tileObjects = tileObjects.stream().filter(tileObject -> tileObject.getId() == id).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileObjectQuery withAction(String action) {
+        tileObjects =
+                tileObjects.stream().filter(tileObject ->
+                {
+                    ObjectComposition objectComposition = getObjectComposition(tileObject);
+                    if (objectComposition == null)
+                        return false;
+                    String[] actions = getObjectComposition(tileObject).getActions();
+                    return Arrays.stream(actions).filter(Objects::nonNull).anyMatch(a -> a.equalsIgnoreCase(action));
+                }).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileObjectQuery atLocation(WorldPoint location) {
+        tileObjects = tileObjects.stream().filter(tileObject -> tileObject.getWorldLocation().equals(location)).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileObjectQuery withinDistance(int distance) {
+        tileObjects = tileObjects.stream().filter(tileObject -> tileObject.getWorldLocation().distanceTo(client.getLocalPlayer().getWorldLocation()) <= distance).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileObjectQuery withinBounds(WorldPoint min, WorldPoint max) {
+        int x1 = min.getX();
+        int x2 = max.getX();
+        int y1 = min.getY();
+        int y2 = max.getY();
+
+        tileObjects = tileObjects.stream().filter(tileObject -> {
+            int x3 = tileObject.getWorldLocation().getX();
+            int y3 = tileObject.getWorldLocation().getY();
+
+            if (x3 > Math.max(x1, x2) || x3 < Math.min(x1, x2)) {
+                return false;
+            }
+
+            return y3 <= Math.max(y1, y2) && y3 >= Math.min(y1, y2);
+        }).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileObjectQuery atLocation(int x, int y, int plane) {
+        WorldPoint p = new WorldPoint(x, y, plane);
+        tileObjects =
+                tileObjects.stream().filter(tileObject -> tileObject.getWorldLocation().equals(p)).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileObjectQuery filter(Predicate<? super TileObject> predicate) {
+        tileObjects = tileObjects.stream().filter(predicate).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileObjectQuery nameContains(String name) {
+        tileObjects =
+                tileObjects.stream().filter(tileObject -> {
+                    ObjectComposition comp = getObjectComposition(tileObject);
+                    if (comp == null)
+                        return false;
+                    return comp.getName().contains(name);
+                }).collect(Collectors.toList());
+        return this;
+    }
+
+    public TileObjectQuery idInList(List<Integer> ids) {
+        tileObjects = tileObjects.stream().filter(tileObject -> ids.contains(tileObject.getId())).collect(Collectors.toList());
+        return this;
+    }
+
+    public boolean empty() {
+        return tileObjects.size() == 0;
+    }
+
+    public List<TileObject> result() {
+        return tileObjects;
+    }
+
+    public Optional<TileObject> first() {
+        return tileObjects.stream().findFirst();
+    }
+
+    public Optional<TileObject> nearestToPlayer() {
+        return tileObjects.stream().min(Comparator.comparingInt(o -> client.getLocalPlayer().getWorldLocation().distanceTo(o.getWorldLocation())));
+    }
+
+    public Optional<TileObject> nearestByPath() {
+        HashMap<WorldPoint, TileObject> map = new HashMap<>();
+        var playerLoc = client.getLocalPlayer().getWorldLocation();
+        for (TileObject tileObject : tileObjects) {
+            List<WorldPoint> adjacentTiles = WorldAreaUtility.objectInteractableTiles(tileObject);
+            for (WorldPoint worldPoint : adjacentTiles) {
+                if (playerLoc.equals(worldPoint)) {
+                    return Optional.of(tileObject);
+                }
+                map.put(worldPoint, tileObject);
+            }
+        }
+
+        List<WorldPoint> path = BaseApiPlugin.pathToGoalSetFromPlayerNoCustomTiles(new HashSet<>(map.keySet()));
+        if (path == null || path.isEmpty()) {
+            return Optional.empty();
+        }
+
+        return Optional.ofNullable(map.get(path.get(path.size() - 1)));
+    }
+
+    public Optional<TileObject> nearestToPoint(WorldPoint point) {
+        return tileObjects.stream().min(Comparator.comparingInt(o -> point.distanceTo(o.getWorldLocation())));
+    }
+
+    public static ObjectComposition getObjectComposition(TileObject tileObject) {
+        if (client.getObjectDefinition(tileObject.getId()).getImpostorIds() == null || client.getObjectDefinition(tileObject.getId()).getImpostor() == null) {
+            return client.getObjectDefinition(tileObject.getId());
+        }
+        return client.getObjectDefinition(tileObject.getId()).getImpostor();
+    }
+
+    public static ObjectComposition getObjectComposition(int id) {
+        if (client.getObjectDefinition(id).getImpostorIds() == null || client.getObjectDefinition(id).getImpostor() == null) {
+            return client.getObjectDefinition(id);
+        }
+        return client.getObjectDefinition(id).getImpostor();
+    }
+}

src/main/java/ee/futur/baseapi/collections/query/WidgetQuery.java

@@ -0,0 +1,120 @@
+package ee.futur.baseapi.collections.query;
+
+import net.runelite.api.widgets.Widget;
+import net.runelite.client.util.Text;
+import net.runelite.client.util.WildcardMatcher;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class WidgetQuery {
+    List<Widget> widgets;
+
+    public WidgetQuery(HashSet<Widget> widgets) {
+        this.widgets = new ArrayList<>(widgets);
+    }
+
+    public List<Widget> result() {
+        return widgets;
+    }
+
+    public WidgetQuery filter(Predicate<? super Widget> predicate) {
+        widgets = widgets.stream().filter(predicate).collect(Collectors.toList());
+        return this;
+    }
+
+    public WidgetQuery withAction(String action) {
+        widgets = widgets.stream().filter(x -> {
+            String[] actions = x.getActions();
+            if (actions == null) {
+                return false;
+            }
+            for (String s : actions) {
+                if (s == null) {
+                    continue;
+                }
+                if (Text.removeTags(s).equalsIgnoreCase(action)) {
+                    return true;
+                }
+            }
+            return false;
+        }).collect(Collectors.toList());
+        return this;
+    }
+
+    public boolean empty() {
+        return widgets.isEmpty();
+    }
+
+    public WidgetQuery hiddenState(boolean hidden) {
+        widgets = widgets.stream().filter(widget -> widget.isHidden() == hidden).collect(java.util.stream.Collectors.toList());
+        return this;
+    }
+
+    public WidgetQuery withId(int id) {
+        widgets = widgets.stream().filter(widget -> widget.getId() == id).collect(java.util.stream.Collectors.toList());
+        return this;
+    }
+
+    public WidgetQuery withItemId(int itemId) {
+        widgets = widgets.stream().filter(widget -> widget.getItemId() == itemId).collect(java.util.stream.Collectors.toList());
+        return this;
+    }
+
+    public Optional<Widget> first() {
+        return widgets.stream().findFirst();
+    }
+
+    public WidgetQuery nonPlaceHolder() {
+        return quantityGreaterThan(0);
+    }
+
+    public WidgetQuery itemIdInList(List<Integer> ids) {
+        widgets = widgets.stream().filter(item -> ids.contains(item.getItemId())).collect(Collectors.toList());
+        return this;
+    }
+
+    public WidgetQuery quantityGreaterThan(int quanity) {
+        widgets = widgets.stream().filter(item -> item.getItemQuantity() > quanity).collect(Collectors.toList());
+        return this;
+    }
+
+    public WidgetQuery nameContains(String name) {
+        widgets =
+                widgets.stream().filter(item -> item.getName() != null && item.getName().contains(name)).collect(Collectors.toList());
+        return this;
+    }
+
+    public WidgetQuery withName(String name) {
+        widgets = widgets.stream().filter(item -> item.getName() != null && Text.removeTags(item.getName()).equals(name)).collect(Collectors.toList());
+        return this;
+    }
+
+    public WidgetQuery withText(String text) {
+        widgets = widgets.stream().filter(item -> item.getText() != null && item.getText().equals(text)).collect(Collectors.toList());
+        return this;
+    }
+
+    public WidgetQuery withTextContains(String text) {
+        widgets = widgets.stream().filter(item -> item.getText() != null && item.getText().contains(text)).collect(Collectors.toList());
+        return this;
+    }
+
+    public WidgetQuery withParentId(int parentId) {
+        widgets = widgets.stream().filter(item -> item.getParentId() == parentId).collect(Collectors.toList());
+        return this;
+    }
+
+    public WidgetQuery nameMatchesWildCardNoCase(String input) {
+        widgets =
+                widgets.stream().
+                        filter(item -> item.getName() != null && WildcardMatcher.matches(input.toLowerCase(),
+                                Text.removeTags(item.getName().toLowerCase()))).
+                        collect(Collectors.toList());
+        return this;
+    }
+}

src/main/java/ee/futur/baseapi/nono/interaction/TileObjectInteraction.java

@@ -0,0 +1,43 @@
+package ee.futur.baseapi.nono.interaction;
+
+import ee.futur.baseapi.collections.TileObjects;
+import ee.futur.baseapi.collections.query.TileObjectQuery;
+import ee.futur.baseapi.nono.packets.MousePackets;
+import ee.futur.baseapi.nono.packets.ObjectPackets;
+import net.runelite.api.ObjectComposition;
+import net.runelite.api.TileObject;
+
+import java.util.Optional;
+
+public class TileObjectInteraction {
+    public static boolean interact(String name, String... actions) {
+        return TileObjects.search().withName(name).first().flatMap(tileObject ->
+        {
+            MousePackets.queueClickPacket();
+            ObjectPackets.queueObjectAction(tileObject, false, actions);
+            return Optional.of(true);
+        }).orElse(false);
+    }
+
+    public static boolean interact(int id, String... actions) {
+        return TileObjects.search().withId(id).first().flatMap(tileObject ->
+        {
+            MousePackets.queueClickPacket();
+            ObjectPackets.queueObjectAction(tileObject, false, actions);
+            return Optional.of(true);
+        }).orElse(false);
+    }
+
+    public static boolean interact(TileObject tileObject, String... actions) {
+        if (tileObject == null) {
+            return false;
+        }
+        ObjectComposition comp = TileObjectQuery.getObjectComposition(tileObject);
+        if (comp == null) {
+            return false;
+        }
+        MousePackets.queueClickPacket();
+        ObjectPackets.queueObjectAction(tileObject, false, actions);
+        return true;
+    }
+}

src/main/java/ee/futur/baseapi/nono/packets/BufferMethods.java

@@ -0,0 +1,106 @@
+package ee.futur.baseapi.nono.packets;
+
+
+import ee.futur.utils.ObfuscatedNames;
+
+import java.lang.reflect.Field;
+
+public class BufferMethods {
+
+    public static void setOffset(Object bufferInstance, int offset) {
+        try {
+            Field offsetField = bufferInstance.getClass().getField(ObfuscatedNames.bufferOffsetField);
+            offsetField.setAccessible(true);
+            offsetField.setInt(bufferInstance, offset);
+            offsetField.setAccessible(false);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static int getOffset(Object bufferInstance) {
+        try {
+            Field offsetField = bufferInstance.getClass().getField(ObfuscatedNames.bufferOffsetField);
+            offsetField.setAccessible(true);
+            int offset = offsetField.getInt(bufferInstance);
+            offsetField.setAccessible(false);
+            return offset;
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        return -1;
+    }
+
+    public static void setArray(Object bufferInstance, byte[] array) {
+        try {
+            Field arrayField = bufferInstance.getClass().getField(ObfuscatedNames.bufferArrayField);
+            arrayField.setAccessible(true);
+            arrayField.set(bufferInstance, array);
+            arrayField.setAccessible(false);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static byte[] getArray(Object bufferInstance) {
+        try {
+            Field arrayField = bufferInstance.getClass().getField(ObfuscatedNames.bufferArrayField);
+            arrayField.setAccessible(true);
+            byte[] array = (byte[]) arrayField.get(bufferInstance);
+            arrayField.setAccessible(false);
+            return array;
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static void writeValue(String writeDescription, int value, Object bufferInstance) {
+        int writeTypeMagnitude = writeDescription.contains("v") ? 0 : Integer.parseInt(writeDescription.substring(1).trim());
+        byte[] arr = getArray(bufferInstance);
+        int index = nextIndex(getOffset(bufferInstance));
+        setOffset(bufferInstance, index);
+        index = index * Integer.parseInt(ObfuscatedNames.indexMultiplier) - 1;
+        //System.out.println("Index: " + index);
+        switch (writeDescription.charAt(0)) {
+            case 's':
+                setArray(bufferInstance, writeSub(writeTypeMagnitude, value, arr, index));
+                break;
+            case 'a':
+                setArray(bufferInstance, writeAdd(writeTypeMagnitude, value, arr, index));
+                break;
+            case 'r':
+                setArray(bufferInstance, writeRightShifted(writeTypeMagnitude, value, arr, index));
+                break;
+            case 'v':
+                setArray(bufferInstance, writeVar(value, arr, index));
+                break;
+        }
+    }
+
+    static byte[] writeSub(int subValue, int value, byte[] arr, int index) {
+        arr[index] = (byte) (subValue - value);
+        return arr;
+    }
+
+    static byte[] writeAdd(int addValue, int value, byte[] arr, int index) {
+        arr[index] = (byte) (addValue + value);
+        return arr;
+    }
+
+    static byte[] writeRightShifted(int shiftAmount, int value, byte[] arr, int index) {
+        arr[index] = (byte) (value >> shiftAmount);
+        return arr;
+    }
+
+    static byte[] writeVar(int value, byte[] arr, int index) {
+        arr[index] = (byte) (value);
+        return arr;
+    }
+
+    static public int nextIndex(int offset) {
+        offset += (int) Long.parseLong(ObfuscatedNames.offsetMultiplier);
+        return offset;
+    }
+
+}

src/main/java/ee/futur/baseapi/nono/packets/MousePackets.java

@@ -0,0 +1,127 @@
+package ee.futur.baseapi.nono.packets;
+
+import ee.futur.baseapi.nono.packets.utils.PacketDef;
+import ee.futur.baseapi.nono.packets.utils.PacketReflection;
+import ee.futur.utils.ObfuscatedNames;
+import lombok.SneakyThrows;
+import net.runelite.api.Client;
+import net.runelite.client.RuneLite;
+
+import java.awt.event.KeyEvent;
+import java.lang.reflect.Field;
+import java.math.BigInteger;
+import java.util.Random;
+import java.util.concurrent.Executors;
+
+import static java.awt.event.InputEvent.BUTTON1_DOWN_MASK;
+
+public class MousePackets {
+
+    static Client client = RuneLite.getInjector().getInstance(Client.class);
+    private static final Random random = new Random();
+    private static long randomDelay = randomDelay();
+
+    public static BigInteger modInverse(BigInteger val, int bits) {
+        try {
+            BigInteger shift = BigInteger.ONE.shiftLeft(bits);
+            return val.modInverse(shift);
+        } catch (ArithmeticException e) {
+            return val;
+        }
+    }
+
+    public static long modInverse(long val) {
+        return modInverse(BigInteger.valueOf(val), 64).longValue();
+    }
+
+    @SneakyThrows
+    public static void queueClickPacket(int x, int y) {
+        long mouseHandlerMS = System.currentTimeMillis();
+        setMouseHandlerLastMillis(mouseHandlerMS);
+        long clientMS = getClientLastMillis();
+        long deltaMs = mouseHandlerMS - clientMS;
+        setClientLastMillis(mouseHandlerMS);
+        if (deltaMs < 0) {
+            deltaMs = 0L;
+        }
+        if (deltaMs > 32767) {
+            deltaMs = 32767L;
+        }
+        int mouseInfo = ((int) deltaMs << 1);
+        PacketReflection.sendPacket(PacketDef.getEventMouseClick(), mouseInfo, x, y, 0);
+        if (checkIdleLogout()) {
+            randomDelay = randomDelay();
+            Executors.newSingleThreadExecutor()
+                    .submit(MousePackets::pressKey);
+        }
+    }
+
+    public static void queueClickPacket() {
+        queueClickPacket(0, 0);
+    }
+
+    private static boolean checkIdleLogout() {
+        int idleClientTicks = client.getKeyboardIdleTicks();
+
+        if (client.getMouseIdleTicks() < idleClientTicks) {
+            idleClientTicks = client.getMouseIdleTicks();
+        }
+
+        return idleClientTicks >= randomDelay;
+    }
+
+    private static long randomDelay() {
+        return (long) clamp(
+                Math.round(random.nextGaussian() * 8000)
+        );
+    }
+
+    private static double clamp(double val) {
+        return Math.max(1, Math.min(13000, val));
+    }
+
+    private static void pressKey() {
+        KeyEvent keyPress = new KeyEvent(client.getCanvas(), KeyEvent.KEY_PRESSED, System.currentTimeMillis(), BUTTON1_DOWN_MASK, KeyEvent.VK_BACK_SPACE);
+        client.getCanvas().dispatchEvent(keyPress);
+        KeyEvent keyRelease = new KeyEvent(client.getCanvas(), KeyEvent.KEY_RELEASED, System.currentTimeMillis(), 0, KeyEvent.VK_BACK_SPACE);
+        client.getCanvas().dispatchEvent(keyRelease);
+        KeyEvent keyTyped = new KeyEvent(client.getCanvas(), KeyEvent.KEY_TYPED, System.currentTimeMillis(), 0, KeyEvent.VK_UNDEFINED);
+        client.getCanvas().dispatchEvent(keyTyped);
+    }
+
+    @SneakyThrows
+    public static long getMouseHandlerLastMillis() {
+        Class<?> mouseHandler = client.getClass().getClassLoader().loadClass(ObfuscatedNames.MouseHandler_lastPressedTimeMillisClass);
+        Field mouseHandlerLastPressedTime = mouseHandler.getDeclaredField(ObfuscatedNames.MouseHandler_lastPressedTimeMillisField);
+        mouseHandlerLastPressedTime.setAccessible(true);
+        long retValue = mouseHandlerLastPressedTime.getLong(null) * Long.parseLong(ObfuscatedNames.mouseHandlerMillisMultiplier);
+        mouseHandlerLastPressedTime.setAccessible(false);
+        return retValue;
+    }
+
+    @SneakyThrows
+    public static long getClientLastMillis() {
+        Field clientLastPressedTimeMillis = client.getClass().getDeclaredField(ObfuscatedNames.clientMillisField);
+        clientLastPressedTimeMillis.setAccessible(true);
+        long retValue = clientLastPressedTimeMillis.getLong(client) * Long.parseLong(ObfuscatedNames.clientMillisMultiplier);
+        clientLastPressedTimeMillis.setAccessible(false);
+        return retValue;
+    }
+
+    @SneakyThrows
+    public static void setMouseHandlerLastMillis(long time) {
+        Class<?> mouseHandler = client.getClass().getClassLoader().loadClass(ObfuscatedNames.MouseHandler_lastPressedTimeMillisClass);
+        Field mouseHandlerLastPressedTime = mouseHandler.getDeclaredField(ObfuscatedNames.MouseHandler_lastPressedTimeMillisField);
+        mouseHandlerLastPressedTime.setAccessible(true);
+        mouseHandlerLastPressedTime.setLong(null, time * modInverse(Long.parseLong(ObfuscatedNames.mouseHandlerMillisMultiplier)));
+        mouseHandlerLastPressedTime.setAccessible(false);
+    }
+
+    @SneakyThrows
+    public static void setClientLastMillis(long time) {
+        Field clientLastPressedTimeMillis = client.getClass().getDeclaredField(ObfuscatedNames.clientMillisField);
+        clientLastPressedTimeMillis.setAccessible(true);
+        clientLastPressedTimeMillis.setLong(client, time * modInverse(Long.parseLong(ObfuscatedNames.clientMillisMultiplier)));
+        clientLastPressedTimeMillis.setAccessible(false);
+    }
+}

src/main/java/ee/futur/baseapi/nono/packets/MovementPackets.java

@@ -0,0 +1,16 @@
+package ee.futur.baseapi.nono.packets;
+
+import ee.futur.baseapi.nono.packets.utils.PacketDef;
+import ee.futur.baseapi.nono.packets.utils.PacketReflection;
+import net.runelite.api.coords.WorldPoint;
+
+public class MovementPackets {
+    public static void queueMovement(int worldPointX, int worldPointY, boolean ctrlDown) {
+        int ctrl = ctrlDown ? 1 : 0;
+        PacketReflection.sendPacket(PacketDef.getMoveGameClick(), worldPointX, worldPointY, ctrl, 5);
+    }
+
+    public static void queueMovement(WorldPoint location) {
+        queueMovement(location.getX(), location.getY(), false);
+    }
+}

src/main/java/ee/futur/baseapi/nono/packets/NPCPackets.java

@@ -0,0 +1,81 @@
+package ee.futur.baseapi.nono.packets;
+
+import ee.futur.baseapi.collections.query.NPCQuery;
+import ee.futur.baseapi.nono.packets.utils.PacketDef;
+import ee.futur.baseapi.nono.packets.utils.PacketReflection;
+import lombok.SneakyThrows;
+import net.runelite.api.NPC;
+import net.runelite.api.NPCComposition;
+import net.runelite.api.widgets.Widget;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class NPCPackets {
+
+    @SneakyThrows
+    public static void queueNPCAction(int actionFieldNo, int npcIndex, boolean ctrlDown) {
+        int ctrl = ctrlDown ? 1 : 0;
+        switch (actionFieldNo) {
+            case 1:
+                PacketReflection.sendPacket(PacketDef.getOpNpc1(), npcIndex, ctrl);
+                break;
+            case 2:
+                PacketReflection.sendPacket(PacketDef.getOpNpc2(), npcIndex, ctrl);
+                break;
+            case 3:
+                PacketReflection.sendPacket(PacketDef.getOpNpc3(), npcIndex, ctrl);
+                break;
+            case 4:
+                PacketReflection.sendPacket(PacketDef.getOpNpc4(), npcIndex, ctrl);
+                break;
+            case 5:
+                PacketReflection.sendPacket(PacketDef.getOpNpc5(), npcIndex, ctrl);
+                break;
+        }
+    }
+
+    @SneakyThrows
+    public static void queueNPCAction(NPC npc, String... actionList) {
+        if (npc == null) {
+            return;
+        }
+        NPCComposition comp = NPCQuery.getNPCComposition(npc);
+        if (comp == null) {
+            return;
+        }
+        if (comp.getActions() == null) {
+            return;
+        }
+        List<String> actions = Arrays.stream(comp.getActions()).collect(Collectors.toList());
+        for (int i = 0; i < actions.size(); i++) {
+            if (actions.get(i) == null)
+                continue;
+            actions.set(i, actions.get(i).toLowerCase());
+        }
+        int num = -1;
+        for (String action : actions) {
+            for (String action2 : actionList) {
+                if (action != null && action.equalsIgnoreCase(action2)) {
+                    num = actions.indexOf(action.toLowerCase()) + 1;
+                }
+            }
+        }
+
+        if (num < 1 || num > 10) {
+            return;
+        }
+        queueNPCAction(num, npc.getIndex(), false);
+    }
+
+    public static void queueWidgetOnNPC(int npcIndex, int sourceItemId, int sourceSlot, int sourceWidgetId,
+                                        boolean ctrlDown) {
+        int ctrl = ctrlDown ? 1 : 0;
+        PacketReflection.sendPacket(PacketDef.getOpNpcT(), npcIndex, sourceItemId, sourceSlot, sourceWidgetId, ctrl);
+    }
+
+    public static void queueWidgetOnNPC(NPC npc, Widget widget) {
+        queueWidgetOnNPC(npc.getIndex(), widget.getItemId(), widget.getIndex(), widget.getId(), false);
+    }
+}

src/main/java/ee/futur/baseapi/nono/packets/ObjectPackets.java

@@ -0,0 +1,107 @@
+package ee.futur.baseapi.nono.packets;
+
+import ee.futur.baseapi.collections.query.TileObjectQuery;
+import ee.futur.baseapi.nono.packets.utils.PacketDef;
+import ee.futur.baseapi.nono.packets.utils.PacketReflection;
+import lombok.SneakyThrows;
+import net.runelite.api.GameObject;
+import net.runelite.api.ObjectComposition;
+import net.runelite.api.Point;
+import net.runelite.api.TileObject;
+import net.runelite.api.coords.LocalPoint;
+import net.runelite.api.coords.WorldPoint;
+import net.runelite.api.widgets.Widget;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ObjectPackets {
+    @SneakyThrows
+    public static void queueObjectAction(int actionFieldNo, int objectId, int worldPointX, int worldPointY,
+                                         boolean ctrlDown) {
+        int ctrl = ctrlDown ? 1 : 0;
+        switch (actionFieldNo) {
+            case 1:
+                PacketReflection.sendPacket(PacketDef.getOpLoc1(), objectId, worldPointX, worldPointY, ctrl);
+                break;
+            case 2:
+                PacketReflection.sendPacket(PacketDef.getOpLoc2(), objectId, worldPointX, worldPointY, ctrl);
+                break;
+            case 3:
+                PacketReflection.sendPacket(PacketDef.getOpLoc3(), objectId, worldPointX, worldPointY, ctrl);
+                break;
+            case 4:
+                PacketReflection.sendPacket(PacketDef.getOpLoc4(), objectId, worldPointX, worldPointY, ctrl);
+                break;
+            case 5:
+                PacketReflection.sendPacket(PacketDef.getOpLoc5(), objectId, worldPointX, worldPointY, ctrl);
+                break;
+        }
+    }
+
+    @SneakyThrows
+    public static void queueObjectAction(TileObject object, boolean ctrlDown, String... actionlist) {
+        if (object == null) {
+            return;
+        }
+        ObjectComposition comp = TileObjectQuery.getObjectComposition(object);
+        if (comp == null) {
+            return;
+        }
+        if (comp.getActions() == null) {
+            return;
+        }
+        List<String> actions = Arrays.stream(comp.getActions()).collect(Collectors.toList());
+        for (int i = 0; i < actions.size(); i++) {
+            if (actions.get(i) == null)
+                continue;
+            actions.set(i, actions.get(i).toLowerCase());
+        }
+        Point p;
+        if (object instanceof GameObject) {
+            GameObject gameObject = (GameObject) object;
+            p = gameObject.getSceneMinLocation();
+        } else {
+            p = new Point(object.getLocalLocation().getSceneX(), object.getLocalLocation().getSceneY());
+        }
+        LocalPoint lp = new LocalPoint(p.getX(), p.getY());
+        WorldPoint wp = WorldPoint.fromScene(PacketReflection.getClient(), lp.getX(), lp.getY(), object.getPlane());
+        int num = -1;
+        for (String action : actions) {
+            for (String action2 : actionlist) {
+                if (action != null && action.equalsIgnoreCase(action2.toLowerCase())) {
+                    num = actions.indexOf(action) + 1;
+                }
+            }
+        }
+
+        if (num < 1 || num > 10) {
+            return;
+        }
+        queueObjectAction(num, object.getId(), wp.getX(), wp.getY(), ctrlDown);
+    }
+
+    public static void queueWidgetOnTileObject(int objectId, int worldPointX, int worldPointY, int sourceSlot,
+                                               int sourceItemId, int sourceWidgetId, boolean ctrlDown) {
+        int ctrl = ctrlDown ? 1 : 0;
+        PacketReflection.sendPacket(PacketDef.getOpLocT(), objectId, worldPointX, worldPointY, sourceSlot, sourceItemId,
+                sourceWidgetId, ctrl);
+    }
+
+    public static void queueWidgetOnTileObject(Widget widget, TileObject object) {
+        Point p;
+        if (object instanceof GameObject) {
+            GameObject gameObject = (GameObject) object;
+            p = gameObject.getSceneMinLocation();
+        } else {
+            p = new Point(object.getLocalLocation().getSceneX(), object.getLocalLocation().getSceneY());
+        }
+        LocalPoint lp = new LocalPoint(p.getX(), p.getY());
+        WorldPoint wp = WorldPoint.fromScene(PacketReflection.getClient(), lp.getX(), lp.getY(), object.getPlane());
+        queueWidgetOnTileObject(object.getId(), wp.getX(), wp.getY(), widget.getIndex(),
+                widget.getItemId(),
+                widget.getId(),
+                false);
+    }
+}

src/main/java/ee/futur/baseapi/nono/packets/PlayerPackets.java

@@ -0,0 +1,77 @@
+package ee.futur.baseapi.nono.packets;
+
+import ee.futur.baseapi.nono.packets.utils.PacketDef;
+import ee.futur.baseapi.nono.packets.utils.PacketReflection;
+import lombok.SneakyThrows;
+import net.runelite.api.Player;
+import net.runelite.api.widgets.Widget;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class PlayerPackets {
+    @SneakyThrows
+    public static void queuePlayerAction(int actionFieldNo, int playerIndex, boolean ctrlDown) {
+        int ctrl = ctrlDown ? 1 : 0;
+        switch (actionFieldNo) {
+            case 1:
+                PacketReflection.sendPacket(PacketDef.getOpPlayer1(), playerIndex, ctrl);
+                break;
+            case 2:
+                PacketReflection.sendPacket(PacketDef.getOpPlayer2(), playerIndex, ctrl);
+                break;
+            case 3:
+                PacketReflection.sendPacket(PacketDef.getOpPlayer3(), playerIndex, ctrl);
+                break;
+            case 4:
+                PacketReflection.sendPacket(PacketDef.getOpPlayer4(), playerIndex, ctrl);
+                break;
+            case 5:
+                PacketReflection.sendPacket(PacketDef.getOpPlayer5(), playerIndex, ctrl);
+                break;
+            case 6:
+                PacketReflection.sendPacket(PacketDef.getOpPlayer6(), playerIndex, ctrl);
+                break;
+            case 7:
+                PacketReflection.sendPacket(PacketDef.getOpPlayer7(), playerIndex, ctrl);
+                break;
+            case 8:
+                PacketReflection.sendPacket(PacketDef.getOpPlayer8(), playerIndex, ctrl);
+                break;
+        }
+    }
+
+    @SneakyThrows
+    public static void queuePlayerAction(Player player, String... actionlist) {
+        List<String> actions = Arrays.stream(PacketReflection.getClient().getPlayerOptions()).collect(Collectors.toList());
+        for (int i = 0; i < actions.size(); i++) {
+            if (actions.get(i) == null)
+                continue;
+            actions.set(i, actions.get(i).toLowerCase());
+        }
+        int num = -1;
+        for (String action : actions) {
+            for (String action2 : actionlist) {
+                if (action != null && action.equalsIgnoreCase(action2)) {
+                    num = actions.indexOf(action.toLowerCase()) + 1;
+                }
+            }
+        }
+
+        if (num < 1 || num > 10) {
+            return;
+        }
+        queuePlayerAction(num, player.getId(), false);
+    }
+
+    public static void queueWidgetOnPlayer(int playerIndex, int sourceItemId, int sourceSlot, int sourceWidgetId,
+                                           boolean ctrlDown) {
+        int ctrl = ctrlDown ? 1 : 0;
+        PacketReflection.sendPacket(PacketDef.getOpPlayerT(), playerIndex, sourceItemId, sourceSlot, sourceWidgetId, ctrl);
+    }
+
+    public static void queueWidgetOnPlayer(Player player, Widget widget) {
+        queueWidgetOnPlayer(player.getId(), widget.getItemId(), widget.getIndex(), widget.getId(), false);
+    }
+}

src/main/java/ee/futur/baseapi/nono/packets/TileItemPackets.java

@@ -0,0 +1,50 @@
+package ee.futur.baseapi.nono.packets;
+
+import ee.futur.baseapi.collections.ETileItem;
+import ee.futur.baseapi.nono.packets.utils.PacketDef;
+import ee.futur.baseapi.nono.packets.utils.PacketReflection;
+import lombok.SneakyThrows;
+import net.runelite.api.widgets.Widget;
+
+public class TileItemPackets {
+    @SneakyThrows
+    public static void queueTileItemAction(int actionFieldNo, int objectId, int worldPointX, int worldPointY,
+                                           boolean ctrlDown) {
+        int ctrl = ctrlDown ? 1 : 0;
+        switch (actionFieldNo) {
+            case 1:
+                PacketReflection.sendPacket(PacketDef.getOpObj1(), objectId, worldPointX, worldPointY, ctrl);
+                break;
+            case 2:
+                PacketReflection.sendPacket(PacketDef.getOpObj2(), objectId, worldPointX, worldPointY, ctrl);
+                break;
+            case 3:
+                PacketReflection.sendPacket(PacketDef.getOpObj3(), objectId, worldPointX, worldPointY, ctrl);
+                break;
+            case 4:
+                PacketReflection.sendPacket(PacketDef.getOpObj4(), objectId, worldPointX, worldPointY, ctrl);
+                break;
+            case 5:
+                PacketReflection.sendPacket(PacketDef.getOpObj5(), objectId, worldPointX, worldPointY, ctrl);
+                break;
+        }
+    }
+
+    public static void queueWidgetOnTileItem(int objectId, int worldPointX, int worldPointY, int sourceSlot,
+                                             int sourceItemId, int sourceWidgetId, boolean ctrlDown) {
+        int ctrl = ctrlDown ? 1 : 0;
+        PacketReflection.sendPacket(PacketDef.getOpObjT(), objectId, worldPointX, worldPointY, sourceSlot, sourceItemId,
+                sourceWidgetId, ctrl);
+    }
+
+    public static void queueTileItemAction(ETileItem item, boolean ctrlDown) {
+        queueTileItemAction(3, item.getTileItem().getId(), item.getLocation().getX(), item.getLocation().getY(),
+                ctrlDown);
+    }
+
+    public static void queueWidgetOnTileItem(ETileItem item, Widget w,
+                                             boolean ctrlDown) {
+        queueWidgetOnTileItem(item.getTileItem().getId(), item.getLocation().getX(), item.getLocation().getY(),
+                w.getIndex(), w.getItemId(), w.getId(), ctrlDown);
+    }
+}

src/main/java/ee/futur/baseapi/nono/packets/WidgetPackets.java

@@ -0,0 +1,118 @@
+package ee.futur.baseapi.nono.packets;
+
+import ee.futur.baseapi.BaseApiPlugin;
+import ee.futur.baseapi.nono.packets.utils.PacketDef;
+import ee.futur.baseapi.nono.packets.utils.PacketReflection;
+import lombok.SneakyThrows;
+import net.runelite.api.ItemComposition;
+import net.runelite.api.widgets.Widget;
+import net.runelite.client.util.Text;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class WidgetPackets {
+    @SneakyThrows
+    public static void queueWidgetActionPacket(int actionFieldNo, int widgetId, int itemId, int childId) {
+        PacketReflection.sendPacket(PacketDef.getIfButtonX(), widgetId, childId, itemId, actionFieldNo & 65535);
+    }
+
+    @SneakyThrows
+    public static void queueWidgetSubAction(Widget widget, String menu, String action) {
+        if (widget == null || widget.getItemId() == -1) {
+            return;
+        }
+
+        ItemComposition composition = BaseApiPlugin.getClient().getItemDefinition(widget.getItemId());
+        String[][] subOps = composition.getSubops();
+        List<String> actions = Arrays.stream(widget.getActions()).collect(Collectors.toList());
+
+        int menuIndex = -1;
+        int actionIndex = -1;
+
+        if (subOps == null) {
+            return;
+        }
+
+        for (String[] subOp : subOps) {
+            if (actionIndex != -1) {
+                break;
+            }
+            if (subOp != null) {
+                for (int i = 0; i < subOp.length; i++) {
+                    String op = subOp[i];
+                    if (op != null && op.equalsIgnoreCase(action)) {
+                        actionIndex = i;
+                        break;
+                    }
+                }
+            }
+        }
+
+        for (int i = 0; i < actions.size(); i++) {
+            String a = actions.get(i);
+            if (a != null && a.equalsIgnoreCase(menu)) {
+                menuIndex = i + 1;
+                break;
+            }
+        }
+
+        if (menuIndex == -1 || actionIndex == -1) {
+            return;
+        }
+
+        PacketReflection.sendPacket(PacketDef.getIfSubOp(), widget.getId(), widget.getIndex(),
+                widget.getItemId(), menuIndex, actionIndex);
+    }
+
+    @SneakyThrows
+    public static void queueWidgetAction(Widget widget, String... actionlist) {
+        if (widget == null) {
+            return;
+        }
+        List<String> actions = Arrays.stream(widget.getActions()).collect(Collectors.toList());
+        for (int i = 0; i < actions.size(); i++) {
+            if (actions.get(i) == null)
+                continue;
+            actions.set(i, actions.get(i).toLowerCase());
+        }
+        int num = -1;
+        for (String action : actions) {
+            for (String action2 : actionlist) {
+                if (action != null && Text.removeTags(action).equalsIgnoreCase(action2)) {
+                    num = actions.indexOf(action.toLowerCase()) + 1;
+                }
+            }
+        }
+
+        if (num < 1 || num > 10) {
+            return;
+        }
+        queueWidgetActionPacket(num, widget.getId(), widget.getItemId(), widget.getIndex());
+    }
+
+    public static void queueWidgetOnWidget(Widget srcWidget, Widget destWidget) {
+        queueWidgetOnWidget(srcWidget.getId(), srcWidget.getIndex(), srcWidget.getItemId(),
+                destWidget.getId(), destWidget.getIndex(), destWidget.getItemId());
+    }
+
+    public static void queueWidgetOnWidget(int sourceWidgetId, int sourceSlot, int sourceItemId,
+                                           int destinationWidgetId, int destinationSlot, int destinationItemId) {
+        PacketReflection.sendPacket(PacketDef.getIfButtonT(), sourceWidgetId, sourceSlot, sourceItemId, destinationWidgetId,
+                destinationSlot, destinationItemId);
+    }
+
+    public static void queueResumePause(int widgetId, int childId) {
+        PacketReflection.sendPacket(PacketDef.getResumePausebutton(), widgetId, childId);
+    }
+
+    public static void queueResumeCount(int id) {
+        PacketReflection.sendPacket(PacketDef.getResumeCountDialog(), id);
+    }
+
+    public static void queueDragAndDrop(Widget src, Widget dest) {
+        PacketReflection.sendPacket(PacketDef.getOpHeldd(), src.getId(), src.getIndex(),
+                src.getItemId(), dest.getId(), dest.getIndex(), dest.getItemId());
+    }
+}

src/main/java/ee/futur/baseapi/nono/packets/utils/ObfuscatedNames.java

@@ -0,0 +1,523 @@
+package ee.futur.baseapi.nono.packets.utils;
+
+public final class ObfuscatedNames {
+
+//    public static final String EVENT_MOUSE_CLICK_OBFUSCATEDNAME = "cv";
+//    public static final String EVENT_MOUSE_CLICK_WRITE1 = "mouseInfo";
+//    public static final String EVENT_MOUSE_CLICK_METHOD_NAME1 = "xg";
+//    public static final String EVENT_MOUSE_CLICK_WRITE2 = "mouseY";
+//    public static final String EVENT_MOUSE_CLICK_METHOD_NAME2 = "xg";
+//    public static final String EVENT_MOUSE_CLICK_WRITE3 = "mouseX";
+//    public static final String EVENT_MOUSE_CLICK_METHOD_NAME3 = "xg";
+//    public static final String[][] EVENT_MOUSE_CLICK_WRITES = new String[][] {
+//            {"r 8", "v"},
+//            {"r 8", "v"},
+//            {"r 8", "v"}
+//    };
+
+    // when officially live we switch to MOUSE_V2 packet
+    public static final String EVENT_MOUSE_CLICK_OBFUSCATEDNAME = "ch";
+    public static final String EVENT_MOUSE_CLICK_WRITE1 = "mouseX";
+    public static final String EVENT_MOUSE_CLICK_METHOD_NAME1 = "dy";
+    public static final String EVENT_MOUSE_CLICK_WRITE2 = "mouseInfo";
+    public static final String EVENT_MOUSE_CLICK_METHOD_NAME2 = "kl";
+    public static final String EVENT_MOUSE_CLICK_WRITE3 = "0";
+    public static final String EVENT_MOUSE_CLICK_METHOD_NAME3 = "bg";
+    public static final String EVENT_MOUSE_CLICK_WRITE4 = "mouseY";
+    public static final String EVENT_MOUSE_CLICK_METHOD_NAME4 = "kl";
+    public static final String[][] EVENT_MOUSE_CLICK_WRITES = new String[][] {
+            {"v", "r 8"},
+            {"a 128", "r 8"},
+            {"v"},
+            {"a 128", "r 8"},
+    };
+
+    public static final String IF_BUTTONT_OBFUSCATEDNAME = "cn";
+    public static final String IF_BUTTONT_WRITE1 = "destinationItemId";
+    public static final String IF_BUTTONT_METHOD_NAME1 = "kl";
+    public static final String IF_BUTTONT_WRITE2 = "destinationWidgetId";
+    public static final String IF_BUTTONT_METHOD_NAME2 = "eg";
+    public static final String IF_BUTTONT_WRITE3 = "sourceItemId";
+    public static final String IF_BUTTONT_METHOD_NAME3 = "mp";
+    public static final String IF_BUTTONT_WRITE4 = "destinationSlot";
+    public static final String IF_BUTTONT_METHOD_NAME4 = "kl";
+    public static final String IF_BUTTONT_WRITE5 = "sourceWidgetId";
+    public static final String IF_BUTTONT_METHOD_NAME5 = "eg";
+    public static final String IF_BUTTONT_WRITE6 = "sourceSlot";
+    public static final String IF_BUTTONT_METHOD_NAME6 = "mp";
+    public static final String[][] IF_BUTTONT_WRITES = new String[][]{
+            {"a 128", "r 8"},
+            {"r 8", "v", "r 24", "r 16"},
+            {"r 8", "a 128"},
+            {"a 128", "r 8"},
+            {"r 8", "v", "r 24", "r 16"},
+            {"r 8", "a 128"},
+    };
+
+    public static final String IF_BUTTONX_OBFUSCATEDNAME = "al";
+    public static final String IF_BUTTONX_WRITE1 = "widgetId";
+    public static final String IF_BUTTONX_METHOD_NAME_1 = "bu";
+    public static final String IF_BUTTONX_WRITE2 = "slot";
+    public static final String IF_BUTTONX_METHOD_NAME_2 = "bt";
+    public static final String IF_BUTTONX_WRITE3 = "itemId";
+    public static final String IF_BUTTONX_METHOD_NAME_3 = "bt";
+    public static final String IF_BUTTONX_WRITE4 = "opCode";
+    public static final String IF_BUTTONX_METHOD_NAME_4 = "bg";
+    public static final String[][] IF_BUTTONX_WRITES = {
+            {"r 24", "r 16", "r 8", "v"},
+            {"r 8", "v"},
+            {"r 8", "v"},
+            {"v"},
+    };
+
+    public static final String IF_SUBOP_OBFUSCATEDNAME = "dj";
+    public static final String IF_SUBOP_WRITE1 = "widgetId";
+    public static final String IF_SUBOP_METHOD_NAME1 = "bu";
+    public static final String IF_SUBOP_WRITE2 = "slot";
+    public static final String IF_SUBOP_METHOD_NAME2 = "bt";
+    public static final String IF_SUBOP_WRITE3 = "itemId";
+    public static final String IF_SUBOP_METHOD_NAME3 = "bt";
+    public static final String IF_SUBOP_WRITE4 = "menuIndex";
+    public static final String IF_SUBOP_METHOD_NAME4 = "bg";
+    public static final String IF_SUBOP_WRITE5 = "subActionIndex";
+    public static final String IF_SUBOP_METHOD_NAME5 = "bg";
+    public static final String[][] IF_SUBOP_WRITES = new String[][]{
+            {"r 24", "r 16", "r 8", "v"},
+            {"r 8", "v"},
+            {"r 8", "v"},
+            {"v"},
+            {"v"}
+    };
+
+    public static final String MOVE_GAMECLICK_OBFUSCATEDNAME = "bd";
+    public static final String MOVE_GAMECLICK_WRITE1 = "5";
+    public static final String MOVE_GAMECLICK_METHOD_NAME1 = "bg";
+    public static final String MOVE_GAMECLICK_WRITE2 = "worldPointX";
+    public static final String MOVE_GAMECLICK_METHOD_NAME2 = "dy";
+    public static final String MOVE_GAMECLICK_WRITE3 = "worldPointY";
+    public static final String MOVE_GAMECLICK_METHOD_NAME3 = "dy";
+    public static final String MOVE_GAMECLICK_WRITE4 = "ctrlDown";
+    public static final String MOVE_GAMECLICK_METHOD_NAME4 = "bg";
+    public static final String[][] MOVE_GAMECLICK_WRITES = new String[][]{
+            {"v"},
+            {"v", "r 8"},
+            {"v", "r 8"},
+            {"v"},
+    };
+    public static final String OPLOC1_OBFUSCATEDNAME = "bi";
+    public static final String OPLOC1_WRITE1 = "objectId";
+    public static final String OPLOC1_METHOD_NAME1 = "bt";
+    public static final String OPLOC1_WRITE2 = "ctrlDown";
+    public static final String OPLOC1_METHOD_NAME2 = "db";
+    public static final String OPLOC1_WRITE3 = "worldPointX";
+    public static final String OPLOC1_METHOD_NAME3 = "dy";
+    public static final String OPLOC1_WRITE4 = "worldPointY";
+    public static final String OPLOC1_METHOD_NAME4 = "bt";
+    public static final String[][] OPLOC1_WRITES = new String[][]{
+            {"r 8", "v"},
+            {"s 0"},
+            {"v", "r 8"},
+            {"r 8", "v"},
+    };
+    public static final String OPLOC2_OBFUSCATEDNAME = "bw";
+    public static final String OPLOC2_WRITE1 = "worldPointX";
+    public static final String OPLOC2_METHOD_NAME1 = "mp";
+    public static final String OPLOC2_WRITE2 = "objectId";
+    public static final String OPLOC2_METHOD_NAME2 = "bt";
+    public static final String OPLOC2_WRITE3 = "worldPointY";
+    public static final String OPLOC2_METHOD_NAME3 = "mp";
+    public static final String OPLOC2_WRITE4 = "ctrlDown";
+    public static final String OPLOC2_METHOD_NAME4 = "dg";
+    public static final String[][] OPLOC2_WRITES = new String[][]{
+            {"r 8", "a 128"},
+            {"r 8", "v"},
+            {"r 8", "a 128"},
+            {"a 128"},
+    };
+    public static final String OPLOC3_OBFUSCATEDNAME = "by";
+    public static final String OPLOC3_WRITE1 = "worldPointY";
+    public static final String OPLOC3_METHOD_NAME1 = "dy";
+    public static final String OPLOC3_WRITE2 = "ctrlDown";
+    public static final String OPLOC3_METHOD_NAME2 = "dg";
+    public static final String OPLOC3_WRITE3 = "worldPointX";
+    public static final String OPLOC3_METHOD_NAME3 = "kl";
+    public static final String OPLOC3_WRITE4 = "objectId";
+    public static final String OPLOC3_METHOD_NAME4 = "kl";
+    public static final String[][] OPLOC3_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"a 128"},
+            {"a 128", "r 8"},
+            {"a 128", "r 8"},
+    };
+    public static final String OPLOC4_OBFUSCATEDNAME = "dk";
+    public static final String OPLOC4_WRITE1 = "objectId";
+    public static final String OPLOC4_METHOD_NAME1 = "bt";
+    public static final String OPLOC4_WRITE2 = "worldPointX";
+    public static final String OPLOC4_METHOD_NAME2 = "bt";
+    public static final String OPLOC4_WRITE3 = "ctrlDown";
+    public static final String OPLOC4_METHOD_NAME3 = "bg";
+    public static final String OPLOC4_WRITE4 = "worldPointY";
+    public static final String OPLOC4_METHOD_NAME4 = "mp";
+    public static final String[][] OPLOC4_WRITES = new String[][]{
+            {"r 8", "v"},
+            {"r 8", "v"},
+            {"v"},
+            {"r 8", "a 128"},
+    };
+    public static final String OPLOC5_OBFUSCATEDNAME = "cl";
+    public static final String OPLOC5_WRITE1 = "objectId";
+    public static final String OPLOC5_METHOD_NAME1 = "bt";
+    public static final String OPLOC5_WRITE2 = "ctrlDown";
+    public static final String OPLOC5_METHOD_NAME2 = "db";
+    public static final String OPLOC5_WRITE3 = "worldPointY";
+    public static final String OPLOC5_METHOD_NAME3 = "kl";
+    public static final String OPLOC5_WRITE4 = "worldPointX";
+    public static final String OPLOC5_METHOD_NAME4 = "bt";
+    public static final String[][] OPLOC5_WRITES = new String[][]{
+            {"r 8", "v"},
+            {"s 0"},
+            {"a 128", "r 8"},
+            {"r 8", "v"},
+    };
+    public static final String OPLOCT_OBFUSCATEDNAME = "ah";
+    public static final String OPLOCT_WRITE1 = "ctrlDown";
+    public static final String OPLOCT_METHOD_NAME1 = "dh";
+    public static final String OPLOCT_WRITE2 = "slot";
+    public static final String OPLOCT_METHOD_NAME2 = "dy";
+    public static final String OPLOCT_WRITE3 = "worldPointX";
+    public static final String OPLOCT_METHOD_NAME3 = "dy";
+    public static final String OPLOCT_WRITE4 = "objectId";
+    public static final String OPLOCT_METHOD_NAME4 = "kl";
+    public static final String OPLOCT_WRITE5 = "worldPointY";
+    public static final String OPLOCT_METHOD_NAME5 = "bt";
+    public static final String OPLOCT_WRITE6 = "itemId";
+    public static final String OPLOCT_METHOD_NAME6 = "dy";
+    public static final String OPLOCT_WRITE7 = "widgetId";
+    public static final String OPLOCT_METHOD_NAME7 = "eg";
+    public static final String[][] OPLOCT_WRITES = new String[][]{
+            {"s 128"},
+            {"v", "r 8"},
+            {"v", "r 8"},
+            {"a 128", "r 8"},
+            {"r 8", "v"},
+            {"v", "r 8"},
+            {"r 8", "v", "r 24", "r 16"},
+    };
+    public static final String OPNPC1_OBFUSCATEDNAME = "ac";
+    public static final String OPNPC1_WRITE1 = "npcIndex";
+    public static final String OPNPC1_METHOD_NAME1 = "dy";
+    public static final String OPNPC1_WRITE2 = "ctrlDown";
+    public static final String OPNPC1_METHOD_NAME2 = "dh";
+    public static final String[][] OPNPC1_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"s 128"},
+    };
+    public static final String OPNPC2_OBFUSCATEDNAME = "cr";
+    public static final String OPNPC2_WRITE1 = "ctrlDown";
+    public static final String OPNPC2_METHOD_NAME1 = "bg";
+    public static final String OPNPC2_WRITE2 = "npcIndex";
+    public static final String OPNPC2_METHOD_NAME2 = "kl";
+    public static final String[][] OPNPC2_WRITES = new String[][]{
+            {"v"},
+            {"a 128", "r 8"},
+    };
+    public static final String OPNPC3_OBFUSCATEDNAME = "dw";
+    public static final String OPNPC3_WRITE1 = "npcIndex";
+    public static final String OPNPC3_METHOD_NAME1 = "dy";
+    public static final String OPNPC3_WRITE2 = "ctrlDown";
+    public static final String OPNPC3_METHOD_NAME2 = "dh";
+    public static final String[][] OPNPC3_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"s 128"},
+    };
+    public static final String OPNPC4_OBFUSCATEDNAME = "ar";
+    public static final String OPNPC4_WRITE1 = "npcIndex";
+    public static final String OPNPC4_METHOD_NAME1 = "mp";
+    public static final String OPNPC4_WRITE2 = "ctrlDown";
+    public static final String OPNPC4_METHOD_NAME2 = "dh";
+    public static final String[][] OPNPC4_WRITES = new String[][]{
+            {"r 8", "a 128"},
+            {"s 128"},
+    };
+    public static final String OPNPC5_OBFUSCATEDNAME = "ab";
+    public static final String OPNPC5_WRITE1 = "npcIndex";
+    public static final String OPNPC5_METHOD_NAME1 = "dy";
+    public static final String OPNPC5_WRITE2 = "ctrlDown";
+    public static final String OPNPC5_METHOD_NAME2 = "dg";
+    public static final String[][] OPNPC5_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"a 128"},
+    };
+    public static final String OPNPCT_OBFUSCATEDNAME = "cf";
+    public static final String OPNPCT_WRITE1 = "slot";
+    public static final String OPNPCT_METHOD_NAME1 = "kl";
+    public static final String OPNPCT_WRITE2 = "widgetId";
+    public static final String OPNPCT_METHOD_NAME2 = "es";
+    public static final String OPNPCT_WRITE3 = "itemId";
+    public static final String OPNPCT_METHOD_NAME3 = "dy";
+    public static final String OPNPCT_WRITE4 = "npcIndex";
+    public static final String OPNPCT_METHOD_NAME4 = "bt";
+    public static final String OPNPCT_WRITE5 = "ctrlDown";
+    public static final String OPNPCT_METHOD_NAME5 = "db";
+    public static final String[][] OPNPCT_WRITES = new String[][]{
+            {"a 128", "r 8"},
+            {"r 16", "r 24", "v", "r 8"},
+            {"v", "r 8"},
+            {"r 8", "v"},
+            {"s 0"},
+    };
+    public static final String OPOBJ1_OBFUSCATEDNAME = "ct";
+    public static final String OPOBJ1_WRITE1 = "ctrlDown";
+    public static final String OPOBJ1_METHOD_NAME1 = "dg";
+    public static final String OPOBJ1_WRITE2 = "worldPointY";
+    public static final String OPOBJ1_METHOD_NAME2 = "dy";
+    public static final String OPOBJ1_WRITE3 = "objectId";
+    public static final String OPOBJ1_METHOD_NAME3 = "dy";
+    public static final String OPOBJ1_WRITE4 = "worldPointX";
+    public static final String OPOBJ1_METHOD_NAME4 = "bt";
+    public static final String[][] OPOBJ1_WRITES = new String[][]{
+            {"a 128"},
+            {"v", "r 8"},
+            {"v", "r 8"},
+            {"r 8", "v"},
+    };
+    public static final String OPOBJ2_OBFUSCATEDNAME = "be";
+    public static final String OPOBJ2_WRITE1 = "worldPointX";
+    public static final String OPOBJ2_METHOD_NAME1 = "mp";
+    public static final String OPOBJ2_WRITE2 = "worldPointY";
+    public static final String OPOBJ2_METHOD_NAME2 = "dy";
+    public static final String OPOBJ2_WRITE3 = "ctrlDown";
+    public static final String OPOBJ2_METHOD_NAME3 = "bg";
+    public static final String OPOBJ2_WRITE4 = "objectId";
+    public static final String OPOBJ2_METHOD_NAME4 = "bt";
+    public static final String[][] OPOBJ2_WRITES = new String[][]{
+            {"r 8", "a 128"},
+            {"v", "r 8"},
+            {"v"},
+            {"r 8", "v"},
+    };
+    public static final String OPOBJ3_OBFUSCATEDNAME = "cu";
+    public static final String OPOBJ3_WRITE1 = "worldPointY";
+    public static final String OPOBJ3_METHOD_NAME1 = "mp";
+    public static final String OPOBJ3_WRITE2 = "ctrlDown";
+    public static final String OPOBJ3_METHOD_NAME2 = "bg";
+    public static final String OPOBJ3_WRITE3 = "worldPointX";
+    public static final String OPOBJ3_METHOD_NAME3 = "kl";
+    public static final String OPOBJ3_WRITE4 = "objectId";
+    public static final String OPOBJ3_METHOD_NAME4 = "mp";
+    public static final String[][] OPOBJ3_WRITES = new String[][]{
+            {"r 8", "a 128"},
+            {"v"},
+            {"a 128", "r 8"},
+            {"r 8", "a 128"},
+    };
+    public static final String OPOBJ4_OBFUSCATEDNAME = "ao";
+    public static final String OPOBJ4_WRITE1 = "worldPointX";
+    public static final String OPOBJ4_METHOD_NAME1 = "dy";
+    public static final String OPOBJ4_WRITE2 = "ctrlDown";
+    public static final String OPOBJ4_METHOD_NAME2 = "dh";
+    public static final String OPOBJ4_WRITE3 = "worldPointY";
+    public static final String OPOBJ4_METHOD_NAME3 = "dy";
+    public static final String OPOBJ4_WRITE4 = "objectId";
+    public static final String OPOBJ4_METHOD_NAME4 = "dy";
+    public static final String[][] OPOBJ4_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"s 128"},
+            {"v", "r 8"},
+            {"v", "r 8"},
+    };
+    public static final String OPOBJ5_OBFUSCATEDNAME = "cy";
+    public static final String OPOBJ5_WRITE1 = "worldPointY";
+    public static final String OPOBJ5_METHOD_NAME1 = "bt";
+    public static final String OPOBJ5_WRITE2 = "objectId";
+    public static final String OPOBJ5_METHOD_NAME2 = "dy";
+    public static final String OPOBJ5_WRITE3 = "worldPointX";
+    public static final String OPOBJ5_METHOD_NAME3 = "mp";
+    public static final String OPOBJ5_WRITE4 = "ctrlDown";
+    public static final String OPOBJ5_METHOD_NAME4 = "db";
+    public static final String[][] OPOBJ5_WRITES = new String[][]{
+            {"r 8", "v"},
+            {"v", "r 8"},
+            {"r 8", "a 128"},
+            {"s 0"},
+    };
+    public static final String OPOBJT_OBFUSCATEDNAME = "cd";
+    public static final String OPOBJT_WRITE1 = "itemId";
+    public static final String OPOBJT_METHOD_NAME1 = "dy";
+    public static final String OPOBJT_WRITE2 = "worldPointY";
+    public static final String OPOBJT_METHOD_NAME2 = "kl";
+    public static final String OPOBJT_WRITE3 = "ctrlDown";
+    public static final String OPOBJT_METHOD_NAME3 = "db";
+    public static final String OPOBJT_WRITE4 = "worldPointX";
+    public static final String OPOBJT_METHOD_NAME4 = "mp";
+    public static final String OPOBJT_WRITE5 = "objectId";
+    public static final String OPOBJT_METHOD_NAME5 = "kl";
+    public static final String OPOBJT_WRITE6 = "widgetId";
+    public static final String OPOBJT_METHOD_NAME6 = "eg";
+    public static final String OPOBJT_WRITE7 = "slot";
+    public static final String OPOBJT_METHOD_NAME7 = "mp";
+    public static final String[][] OPOBJT_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"a 128", "r 8"},
+            {"s 0"},
+            {"r 8", "a 128"},
+            {"a 128", "r 8"},
+            {"r 8", "v", "r 24", "r 16"},
+            {"r 8", "a 128"},
+    };
+    public static final String OPPLAYER1_OBFUSCATEDNAME = "am";
+    public static final String OPPLAYER1_WRITE1 = "playerIndex";
+    public static final String OPPLAYER1_METHOD_NAME1 = "dy";
+    public static final String OPPLAYER1_WRITE2 = "ctrlDown";
+    public static final String OPPLAYER1_METHOD_NAME2 = "bg";
+    public static final String[][] OPPLAYER1_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"v"},
+    };
+    public static final String OPPLAYER2_OBFUSCATEDNAME = "bx";
+    public static final String OPPLAYER2_WRITE1 = "playerIndex";
+    public static final String OPPLAYER2_METHOD_NAME1 = "bt";
+    public static final String OPPLAYER2_WRITE2 = "ctrlDown";
+    public static final String OPPLAYER2_METHOD_NAME2 = "dg";
+    public static final String[][] OPPLAYER2_WRITES = new String[][]{
+            {"r 8", "v"},
+            {"a 128"},
+    };
+    public static final String OPPLAYER3_OBFUSCATEDNAME = "cc";
+    public static final String OPPLAYER3_WRITE1 = "playerIndex";
+    public static final String OPPLAYER3_METHOD_NAME1 = "mp";
+    public static final String OPPLAYER3_WRITE2 = "ctrlDown";
+    public static final String OPPLAYER3_METHOD_NAME2 = "db";
+    public static final String[][] OPPLAYER3_WRITES = new String[][]{
+            {"r 8", "a 128"},
+            {"s 0"},
+    };
+    public static final String OPPLAYER4_OBFUSCATEDNAME = "bv";
+    public static final String OPPLAYER4_WRITE1 = "ctrlDown";
+    public static final String OPPLAYER4_METHOD_NAME1 = "bg";
+    public static final String OPPLAYER4_WRITE2 = "playerIndex";
+    public static final String OPPLAYER4_METHOD_NAME2 = "mp";
+    public static final String[][] OPPLAYER4_WRITES = new String[][]{
+            {"v"},
+            {"r 8", "a 128"},
+    };
+    public static final String OPPLAYER5_OBFUSCATEDNAME = "bc";
+    public static final String OPPLAYER5_WRITE1 = "ctrlDown";
+    public static final String OPPLAYER5_METHOD_NAME1 = "bg";
+    public static final String OPPLAYER5_WRITE2 = "playerIndex";
+    public static final String OPPLAYER5_METHOD_NAME2 = "kl";
+    public static final String[][] OPPLAYER5_WRITES = new String[][]{
+            {"v"},
+            {"a 128", "r 8"},
+    };
+    public static final String OPPLAYER6_OBFUSCATEDNAME = "ai";
+    public static final String OPPLAYER6_WRITE1 = "playerIndex";
+    public static final String OPPLAYER6_METHOD_NAME1 = "kl";
+    public static final String OPPLAYER6_WRITE2 = "ctrlDown";
+    public static final String OPPLAYER6_METHOD_NAME2 = "bg";
+    public static final String[][] OPPLAYER6_WRITES = new String[][]{
+            {"a 128", "r 8"},
+            {"v"},
+    };
+    public static final String OPPLAYER7_OBFUSCATEDNAME = "ce";
+    public static final String OPPLAYER7_WRITE1 = "playerIndex";
+    public static final String OPPLAYER7_METHOD_NAME1 = "kl";
+    public static final String OPPLAYER7_WRITE2 = "ctrlDown";
+    public static final String OPPLAYER7_METHOD_NAME2 = "dg";
+    public static final String[][] OPPLAYER7_WRITES = new String[][]{
+            {"a 128", "r 8"},
+            {"a 128"},
+    };
+    public static final String OPPLAYER8_OBFUSCATEDNAME = "bp";
+    public static final String OPPLAYER8_WRITE1 = "ctrlDown";
+    public static final String OPPLAYER8_METHOD_NAME1 = "bg";
+    public static final String OPPLAYER8_WRITE2 = "playerIndex";
+    public static final String OPPLAYER8_METHOD_NAME2 = "kl";
+    public static final String[][] OPPLAYER8_WRITES = new String[][]{
+            {"v"},
+            {"a 128", "r 8"},
+    };
+    public static final String OPPLAYERT_OBFUSCATEDNAME = "ds";
+    public static final String OPPLAYERT_WRITE1 = "playerIndex";
+    public static final String OPPLAYERT_METHOD_NAME1 = "mp";
+    public static final String OPPLAYERT_WRITE2 = "slot";
+    public static final String OPPLAYERT_METHOD_NAME2 = "dy";
+    public static final String OPPLAYERT_WRITE3 = "widgetId";
+    public static final String OPPLAYERT_METHOD_NAME3 = "es";
+    public static final String OPPLAYERT_WRITE4 = "ctrlDown";
+    public static final String OPPLAYERT_METHOD_NAME4 = "dh";
+    public static final String OPPLAYERT_WRITE5 = "itemId";
+    public static final String OPPLAYERT_METHOD_NAME5 = "kl";
+    public static final String[][] OPPLAYERT_WRITES = new String[][]{
+            {"r 8", "a 128"},
+            {"v", "r 8"},
+            {"r 16", "r 24", "v", "r 8"},
+            {"s 128"},
+            {"a 128", "r 8"},
+    };
+
+    public static final String OPHELDD_OBFUSCATEDNAME = "di";
+    public static final String OPHELDD_WRITE1 = "selectedItemId";
+    public static final String OPHELDD_METHOD_NAME1 = "bt";
+    public static final String OPHELDD_WRITE2 = "destChildIndex";
+    public static final String OPHELDD_METHOD_NAME2 = "dy";
+    public static final String OPHELDD_WRITE3 = "destItemId";
+    public static final String OPHELDD_METHOD_NAME3 = "dy";
+    public static final String OPHELDD_WRITE4 = "selectedId";
+    public static final String OPHELDD_METHOD_NAME4 = "en";
+    public static final String OPHELDD_WRITE5 = "selectedChildIndex";
+    public static final String OPHELDD_METHOD_NAME5 = "kl";
+    public static final String OPHELDD_WRITE6 = "destId";
+    public static final String OPHELDD_METHOD_NAME6 = "eg";
+    public static final String[][] OPHELDD_WRITES = new String[][] {
+            {"r 8", "v"},
+            {"v", "r 8"},
+            {"v", "r 8"},
+            {"v", "r 8", "r 16", "r 24"},
+            {"a 128", "r 8"},
+            {"r 8", "v", "r 24", "r 16"}
+    };
+    public static final String RESUME_COUNTDIALOG_OBFUSCATEDNAME = "au";
+    public static final String RESUME_COUNTDIALOG_WRITE1 = "var0";
+    public static final String RESUME_COUNTDIALOG_METHOD_NAME1 = "bu";
+    public static final String[][] RESUME_COUNTDIALOG_WRITES = new String[][]{
+            {"r 24", "r 16", "r 8", "v"},
+    };
+    public static final String RESUME_PAUSEBUTTON_OBFUSCATEDNAME = "bj";
+    public static final String RESUME_PAUSEBUTTON_WRITE1 = "var1";
+    public static final String RESUME_PAUSEBUTTON_METHOD_NAME1 = "kl";
+    public static final String RESUME_PAUSEBUTTON_WRITE2 = "var0";
+    public static final String RESUME_PAUSEBUTTON_METHOD_NAME2 = "es";
+    public static final String[][] RESUME_PAUSEBUTTON_WRITES = new String[][]{
+            {"a 128", "r 8"},
+            {"r 16", "r 24", "v", "r 8"}
+    };
+
+    public static final String offsetMultiplier = "944624261";
+    public static final String indexMultiplier = "-602712499";
+    public static final String addNodeGarbageValue = "-41";
+    public static final String getPacketBufferNodeGarbageValue = "-26977627";
+    public static final String packetWriterFieldName = "cv";
+    public static final String isaacCipherFieldName = "av";
+    public static final String addNodeMethodName = "ac";
+    public static final String clientPacketClassName = "mi";
+    public static final String packetWriterClassName = "dw";
+    public static final String classContainingGetPacketBufferNodeName = "lh";
+    public static final String packetBufferNodeClassName = "mb";
+    public static final String packetBufferFieldName = "ap";
+    public static final String bufferOffsetField = "aa";
+    public static final String bufferArrayField = "ay";
+    public static final String MouseHandler_lastPressedTimeMillisClass = "bx";
+    public static final String MouseHandler_lastPressedTimeMillisField = "ag";
+    public static final String clientMillisField = "jp";
+    public static final String mouseHandlerMillisMultiplier = "4013550640572753771";
+    public static final String clientMillisMultiplier = "7881463686914378693";
+    public static final int getAnimationMultiplier = 2116322795;
+    public static final int skullIconMultiplier = 0;
+    public static final String skullIconField = "null";
+
+    public static final int pathLengthMultiplier = 0;
+    public static final String pathLengthFieldName = "null";
+    public static final String doActionClassName = "fy";
+    public static final String doActionMethodName = "lu";
+}

src/main/java/ee/futur/baseapi/nono/packets/utils/ObjectAndType.java

@@ -0,0 +1,11 @@
+package ee.futur.baseapi.nono.packets.utils;
+
+public class ObjectAndType {
+    Object object;
+    Class type;
+
+    public ObjectAndType(Object object, Class type) {
+        this.object = object;
+        this.type = type;
+    }
+}

src/main/java/ee/futur/baseapi/nono/packets/utils/PacketDef.java

@@ -0,0 +1,232 @@
+package ee.futur.baseapi.nono.packets.utils;
+
+public class PacketDef {
+    public final String name;
+    public final String[] writeData;
+    public final String[][] writeMethods;
+    public final PacketType type;
+    PacketDef(String var1, String[] writeData, String[][] writeMethods, PacketType type) {
+        this.name = var1;
+        this.writeData = writeData;
+        this.writeMethods = writeMethods;
+        this.type = type;
+    }
+
+    public static PacketDef getOpObj1() {
+        String[] writeData = new String[]{ObfuscatedNames.OPOBJ1_WRITE1, ObfuscatedNames.OPOBJ1_WRITE2, ObfuscatedNames.OPOBJ1_WRITE3, ObfuscatedNames.OPOBJ1_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.OPOBJ1_WRITES;
+        return new PacketDef(ObfuscatedNames.OPOBJ1_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPOBJ);
+    }
+
+    public static PacketDef getOpObj5() {
+        String[] writeData = new String[]{ObfuscatedNames.OPOBJ5_WRITE1, ObfuscatedNames.OPOBJ5_WRITE2, ObfuscatedNames.OPOBJ5_WRITE3, ObfuscatedNames.OPOBJ5_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.OPOBJ5_WRITES;
+        return new PacketDef(ObfuscatedNames.OPOBJ5_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPOBJ);
+    }
+
+
+    public static PacketDef getOpObj4() {
+        String[] writeData = new String[]{ObfuscatedNames.OPOBJ4_WRITE1, ObfuscatedNames.OPOBJ4_WRITE2, ObfuscatedNames.OPOBJ4_WRITE3, ObfuscatedNames.OPOBJ4_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.OPOBJ4_WRITES;
+        return new PacketDef(ObfuscatedNames.OPOBJ4_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPOBJ);
+    }
+
+
+    public static PacketDef getOpObj3() {
+        String[] writeData = new String[]{ObfuscatedNames.OPOBJ3_WRITE1, ObfuscatedNames.OPOBJ3_WRITE2, ObfuscatedNames.OPOBJ3_WRITE3, ObfuscatedNames.OPOBJ3_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.OPOBJ3_WRITES;
+        return new PacketDef(ObfuscatedNames.OPOBJ3_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPOBJ);
+    }
+
+
+    public static PacketDef getOpObj2() {
+        String[] writeData = new String[]{ObfuscatedNames.OPOBJ2_WRITE1, ObfuscatedNames.OPOBJ2_WRITE2, ObfuscatedNames.OPOBJ2_WRITE3, ObfuscatedNames.OPOBJ2_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.OPOBJ2_WRITES;
+        return new PacketDef(ObfuscatedNames.OPOBJ2_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPOBJ);
+    }
+
+
+    public static PacketDef getOpLocT() {
+        String[] writeData = new String[]{ObfuscatedNames.OPLOCT_WRITE1, ObfuscatedNames.OPLOCT_WRITE2, ObfuscatedNames.OPLOCT_WRITE3, ObfuscatedNames.OPLOCT_WRITE4, ObfuscatedNames.OPLOCT_WRITE5, ObfuscatedNames.OPLOCT_WRITE6, ObfuscatedNames.OPLOCT_WRITE7};
+        String[][] writeMethods = ObfuscatedNames.OPLOCT_WRITES;
+        return new PacketDef(ObfuscatedNames.OPLOCT_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPLOCT);
+    }
+
+    public static PacketDef getOpNpcT() {
+        String[] writeData = new String[]{ObfuscatedNames.OPNPCT_WRITE1, ObfuscatedNames.OPNPCT_WRITE2, ObfuscatedNames.OPNPCT_WRITE3,ObfuscatedNames.OPNPCT_WRITE4,ObfuscatedNames.OPNPCT_WRITE5};
+        String[][] writeMethods = ObfuscatedNames.OPNPCT_WRITES;
+        return new PacketDef(ObfuscatedNames.OPNPCT_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPNPCT);
+    }
+
+    public static PacketDef getOpPlayerT() {
+        String[] writeData = new String[]{ObfuscatedNames.OPPLAYERT_WRITE1, ObfuscatedNames.OPPLAYERT_WRITE2, ObfuscatedNames.OPPLAYERT_WRITE3, ObfuscatedNames.OPPLAYERT_WRITE4, ObfuscatedNames.OPPLAYERT_WRITE5};
+        String[][] writeMethods = ObfuscatedNames.OPPLAYERT_WRITES;
+        return new PacketDef(ObfuscatedNames.OPPLAYERT_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPPLAYERT);
+    }
+
+    public static PacketDef getOpObjT() {
+        String[] writeData = new String[]{ObfuscatedNames.OPOBJT_WRITE1, ObfuscatedNames.OPOBJT_WRITE2, ObfuscatedNames.OPOBJT_WRITE3, ObfuscatedNames.OPOBJT_WRITE4, ObfuscatedNames.OPOBJT_WRITE5, ObfuscatedNames.OPOBJT_WRITE6, ObfuscatedNames.OPOBJT_WRITE7};
+        String[][] writeMethods = ObfuscatedNames.OPOBJT_WRITES;
+        return new PacketDef(ObfuscatedNames.OPOBJT_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPOBJT);
+    }
+
+    public static PacketDef getIfButtonT() {
+        String[] writeData = new String[]{ObfuscatedNames.IF_BUTTONT_WRITE1, ObfuscatedNames.IF_BUTTONT_WRITE2, ObfuscatedNames.IF_BUTTONT_WRITE3, ObfuscatedNames.IF_BUTTONT_WRITE4, ObfuscatedNames.IF_BUTTONT_WRITE5, ObfuscatedNames.IF_BUTTONT_WRITE6};
+        String[][] writeMethods = ObfuscatedNames.IF_BUTTONT_WRITES;
+        return new PacketDef(ObfuscatedNames.IF_BUTTONT_OBFUSCATEDNAME, writeData, writeMethods, PacketType.IF_BUTTONT);
+    }
+
+    public static PacketDef getOpNpc2() {
+        String[] writeData = new String[]{ObfuscatedNames.OPNPC2_WRITE1, ObfuscatedNames.OPNPC2_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPNPC2_WRITES;
+        return new PacketDef(ObfuscatedNames.OPNPC2_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPNPC);
+    }
+
+    public static PacketDef getOpPlayer6() {
+        String[] writeData = new String[]{ObfuscatedNames.OPPLAYER6_WRITE1, ObfuscatedNames.OPPLAYER6_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPPLAYER6_WRITES;
+        return new PacketDef(ObfuscatedNames.OPPLAYER6_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPPLAYER);
+    }
+
+    public static PacketDef getOpNpc3() {
+        String[] writeData = new String[]{ObfuscatedNames.OPNPC3_WRITE1, ObfuscatedNames.OPNPC3_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPNPC3_WRITES;
+        return new PacketDef(ObfuscatedNames.OPNPC3_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPNPC);
+    }
+
+    public static PacketDef getOpPlayer7() {
+        String[] writeData = new String[]{ObfuscatedNames.OPPLAYER7_WRITE1, ObfuscatedNames.OPPLAYER7_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPPLAYER7_WRITES;
+        return new PacketDef(ObfuscatedNames.OPPLAYER7_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPPLAYER);
+    }
+
+    public static PacketDef getOpLoc2() {
+        String[] writeData = new String[]{ObfuscatedNames.OPLOC2_WRITE1, ObfuscatedNames.OPLOC2_WRITE2, ObfuscatedNames.OPLOC2_WRITE3, ObfuscatedNames.OPLOC2_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.OPLOC2_WRITES;
+        return new PacketDef(ObfuscatedNames.OPLOC2_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPLOC);
+    }
+
+    public static PacketDef getOpPlayer8() {
+        String[] writeData = new String[]{ObfuscatedNames.OPPLAYER8_WRITE1, ObfuscatedNames.OPPLAYER8_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPPLAYER8_WRITES;
+        return new PacketDef(ObfuscatedNames.OPPLAYER8_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPPLAYER);
+    }
+
+    public static PacketDef getOpLoc1() {
+        String[] writeData = new String[]{ObfuscatedNames.OPLOC1_WRITE1, ObfuscatedNames.OPLOC1_WRITE2, ObfuscatedNames.OPLOC1_WRITE3, ObfuscatedNames.OPLOC1_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.OPLOC1_WRITES;
+        return new PacketDef(ObfuscatedNames.OPLOC1_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPLOC);
+    }
+
+    public static PacketDef getOpNpc1() {
+        String[] writeData = new String[]{ObfuscatedNames.OPNPC1_WRITE1, ObfuscatedNames.OPNPC1_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPNPC1_WRITES;
+        return new PacketDef(ObfuscatedNames.OPNPC1_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPNPC);
+    }
+
+    public static PacketDef getOpLoc4() {
+        String[] writeData = new String[]{ObfuscatedNames.OPLOC4_WRITE1, ObfuscatedNames.OPLOC4_WRITE2, ObfuscatedNames.OPLOC4_WRITE3, ObfuscatedNames.OPLOC4_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.OPLOC4_WRITES;
+        return new PacketDef(ObfuscatedNames.OPLOC4_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPLOC);
+    }
+
+    public static PacketDef getOpPlayer2() {
+        String[] writeData = new String[]{ObfuscatedNames.OPPLAYER2_WRITE1, ObfuscatedNames.OPPLAYER2_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPPLAYER2_WRITES;
+        return new PacketDef(ObfuscatedNames.OPPLAYER2_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPPLAYER);
+    }
+
+    public static PacketDef getOpLoc3() {
+        String[] writeData = new String[]{ObfuscatedNames.OPLOC3_WRITE1, ObfuscatedNames.OPLOC3_WRITE2, ObfuscatedNames.OPLOC3_WRITE3, ObfuscatedNames.OPLOC3_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.OPLOC3_WRITES;
+        return new PacketDef(ObfuscatedNames.OPLOC3_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPLOC);
+    }
+
+    public static PacketDef getOpPlayer3() {
+        String[] writeData = new String[]{ObfuscatedNames.OPPLAYER3_WRITE1, ObfuscatedNames.OPPLAYER3_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPPLAYER3_WRITES;
+        return new PacketDef(ObfuscatedNames.OPPLAYER3_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPPLAYER);
+    }
+
+    public static PacketDef getOpNpc4() {
+        String[] writeData = new String[]{ObfuscatedNames.OPNPC4_WRITE1, ObfuscatedNames.OPNPC4_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPNPC4_WRITES;
+        return new PacketDef(ObfuscatedNames.OPNPC4_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPNPC);
+    }
+
+    public static PacketDef getOpPlayer4() {
+        String[] writeData = new String[]{ObfuscatedNames.OPPLAYER4_WRITE1, ObfuscatedNames.OPPLAYER4_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPPLAYER4_WRITES;
+        return new PacketDef(ObfuscatedNames.OPPLAYER4_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPPLAYER);
+    }
+
+    public static PacketDef getOpNpc5() {
+        String[] writeData = new String[]{ObfuscatedNames.OPNPC5_WRITE1, ObfuscatedNames.OPNPC5_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPNPC5_WRITES;
+        return new PacketDef(ObfuscatedNames.OPNPC5_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPNPC);
+    }
+
+    public static PacketDef getOpPlayer5() {
+        String[] writeData = new String[]{ObfuscatedNames.OPPLAYER5_WRITE1, ObfuscatedNames.OPPLAYER5_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPPLAYER5_WRITES;
+        return new PacketDef(ObfuscatedNames.OPPLAYER5_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPPLAYER);
+    }
+
+    public static PacketDef getOpLoc5() {
+        String[] writeData = new String[]{ObfuscatedNames.OPLOC5_WRITE1, ObfuscatedNames.OPLOC5_WRITE2, ObfuscatedNames.OPLOC5_WRITE3, ObfuscatedNames.OPLOC5_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.OPLOC5_WRITES;
+        return new PacketDef(ObfuscatedNames.OPLOC5_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPLOC);
+    }
+
+    public static PacketDef getOpPlayer1() {
+        String[] writeData = new String[]{ObfuscatedNames.OPPLAYER1_WRITE1, ObfuscatedNames.OPPLAYER1_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.OPPLAYER1_WRITES;
+        return new PacketDef(ObfuscatedNames.OPPLAYER1_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPPLAYER);
+    }
+
+    public static PacketDef getMoveGameClick() {
+        String[] writeData = new String[]{ObfuscatedNames.MOVE_GAMECLICK_WRITE1, ObfuscatedNames.MOVE_GAMECLICK_WRITE2, ObfuscatedNames.MOVE_GAMECLICK_WRITE3, ObfuscatedNames.MOVE_GAMECLICK_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.MOVE_GAMECLICK_WRITES;
+        return new PacketDef(ObfuscatedNames.MOVE_GAMECLICK_OBFUSCATEDNAME, writeData, writeMethods, PacketType.MOVE_GAMECLICK);
+    }
+
+    public static PacketDef getEventMouseClick() {
+        String[] writeData = new String[]{ObfuscatedNames.EVENT_MOUSE_CLICK_WRITE1, ObfuscatedNames.EVENT_MOUSE_CLICK_WRITE2, ObfuscatedNames.EVENT_MOUSE_CLICK_WRITE3, ObfuscatedNames.EVENT_MOUSE_CLICK_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.EVENT_MOUSE_CLICK_WRITES;
+        return new PacketDef(ObfuscatedNames.EVENT_MOUSE_CLICK_OBFUSCATEDNAME, writeData, writeMethods, PacketType.EVENT_MOUSE_CLICK);
+    }
+
+
+    public static PacketDef getIfSubOp() {
+        String[] writeData = new String[]{ObfuscatedNames.IF_SUBOP_WRITE1, ObfuscatedNames.IF_SUBOP_WRITE2, ObfuscatedNames.IF_SUBOP_WRITE3,
+                ObfuscatedNames.IF_SUBOP_WRITE4, ObfuscatedNames.IF_SUBOP_WRITE5};
+        String[][] writeMethods = ObfuscatedNames.IF_SUBOP_WRITES;
+        return new PacketDef(ObfuscatedNames.IF_SUBOP_OBFUSCATEDNAME, writeData, writeMethods, PacketType.IF_SUBOP);
+    }
+
+    public static PacketDef getResumePausebutton() {
+        String[] writeData = new String[]{ObfuscatedNames.RESUME_PAUSEBUTTON_WRITE1, ObfuscatedNames.RESUME_PAUSEBUTTON_WRITE2};
+        String[][] writeMethods = ObfuscatedNames.RESUME_PAUSEBUTTON_WRITES;
+        return new PacketDef(ObfuscatedNames.RESUME_PAUSEBUTTON_OBFUSCATEDNAME, writeData, writeMethods, PacketType.RESUME_PAUSEBUTTON);
+    }
+
+    public static PacketDef getResumeCountDialog() {
+        String[] writeData = new String[]{ObfuscatedNames.RESUME_COUNTDIALOG_WRITE1};
+        String[][] writeMethods = ObfuscatedNames.RESUME_COUNTDIALOG_WRITES;
+        return new PacketDef(ObfuscatedNames.RESUME_COUNTDIALOG_OBFUSCATEDNAME, writeData, writeMethods, PacketType.RESUME_COUNTDIALOG);
+    }
+
+    public static PacketDef getOpHeldd() {
+        String[] writeData = new String[]{ObfuscatedNames.OPHELDD_WRITE1, ObfuscatedNames.OPHELDD_WRITE2, ObfuscatedNames.OPHELDD_WRITE3,
+                ObfuscatedNames.OPHELDD_WRITE4, ObfuscatedNames.OPHELDD_WRITE5, ObfuscatedNames.OPHELDD_WRITE6};
+        String[][] writeMethods = ObfuscatedNames.OPHELDD_WRITES;
+        return new PacketDef(ObfuscatedNames.OPHELDD_OBFUSCATEDNAME, writeData, writeMethods, PacketType.OPHELDD);
+    }
+
+    public static PacketDef getIfButtonX() {
+        String[] writeData = new String[]{ObfuscatedNames.IF_BUTTONX_WRITE1, ObfuscatedNames.IF_BUTTONX_WRITE2, ObfuscatedNames.IF_BUTTONX_WRITE3,
+                ObfuscatedNames.IF_BUTTONX_WRITE4};
+        String[][] writeMethods = ObfuscatedNames.IF_BUTTONX_WRITES;
+        return new PacketDef(ObfuscatedNames.IF_BUTTONX_OBFUSCATEDNAME, writeData, writeMethods, PacketType.IF_BUTTONX);
+    }
+}

src/main/java/ee/futur/baseapi/nono/packets/utils/PacketReflection.java

@@ -0,0 +1,290 @@
+package ee.futur.baseapi.nono.packets.utils;
+
+import ee.futur.baseapi.nono.packets.BufferMethods;
+import lombok.extern.slf4j.Slf4j;
+import net.runelite.api.Client;
+import net.runelite.client.RuneLite;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Slf4j
+public class PacketReflection {
+    public static Client getClient() {
+        return RuneLite.getInjector().getInstance(Client.class);
+    }
+
+    public static Class loadClassFromClientClassLoader(String name) {
+        try {
+            ClassLoader clientLoader = getClient().getClass().getClassLoader();
+            return clientLoader.loadClass(name);
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static Class getClassWithGetPacketBufferNode() {
+        return loadClassFromClientClassLoader(ObfuscatedNames.classContainingGetPacketBufferNodeName);
+    }
+
+    public static Method getGetPacketBufferNode() {
+        try {
+            return Arrays.stream(getClassWithGetPacketBufferNode().getDeclaredMethods()).filter(m -> m.getReturnType().equals(getPacketBufferNodeClass())).collect(Collectors.toList()).get(0);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static Class getClientPacketClass() {
+        return loadClassFromClientClassLoader(ObfuscatedNames.clientPacketClassName);
+    }
+
+    public static Field getPacketWriterField() {
+        try {
+            return getClient().getClass().getDeclaredField(ObfuscatedNames.packetWriterFieldName);
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static Class getPacketWriterClass() {
+        try {
+            Field packetWriterField = getPacketWriterField();
+            packetWriterField.setAccessible(true);
+            Class packetWriterClass = packetWriterField.get(null).getClass();
+            packetWriterField.setAccessible(false);
+            return packetWriterClass;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static Object getIsaacObject() {
+        try {
+            Field isaacField = getPacketWriterClass().getDeclaredField(ObfuscatedNames.isaacCipherFieldName);
+            isaacField.setAccessible(true);
+            Object isaacObject = isaacField.get(getPacketWriteObject());
+            isaacField.setAccessible(false);
+            return isaacObject;
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static Class getIsaacClass() {
+        return getIsaacObject().getClass();
+    }
+
+    public static Class getPacketBufferNodeClass() {
+        return loadClassFromClientClassLoader(ObfuscatedNames.packetBufferNodeClassName);
+    }
+
+    public static Object getPacketWriteObject() {
+        Field packetWriterField = getPacketWriterField();
+        packetWriterField.setAccessible(true);
+        try {
+            Object packetWriter = packetWriterField.get(null);
+            packetWriterField.setAccessible(false);
+            return packetWriter;
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+
+    public static void sendPacket(PacketDef def, Object... objects) {
+        Object packetBufferNode = null;
+        Method getPacketBufferNode = getGetPacketBufferNode();
+        Class ClientPacket = getClientPacketClass();
+        Object isaac = getIsaacObject();
+        getPacketBufferNode.setAccessible(true);
+        long garbageValue = Math.abs(Long.parseLong(ObfuscatedNames.getPacketBufferNodeGarbageValue));
+        if (garbageValue < 256) {
+            try {
+                packetBufferNode = getPacketBufferNode.invoke(null, fetchPacketField(def.name).get(ClientPacket),
+                        isaac, Byte.parseByte(ObfuscatedNames.getPacketBufferNodeGarbageValue));
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                e.printStackTrace();
+            }
+        } else if (garbageValue < 32768) {
+            try {
+                //System.out.println("getPacketBufferNode: "+getPacketBufferNode);
+                //System.out.println("isaac: "+isaac);
+                packetBufferNode = getPacketBufferNode.invoke(null, fetchPacketField(def.name).get(ClientPacket),
+                        isaac, Short.parseShort(ObfuscatedNames.getPacketBufferNodeGarbageValue));
+                //System.out.println("packetBufferNode: "+packetBufferNode);
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                e.printStackTrace();
+            }
+        } else if (garbageValue < Integer.MAX_VALUE) {
+            try {
+                packetBufferNode = getPacketBufferNode.invoke(null, fetchPacketField(def.name).get(ClientPacket),
+                        isaac, Integer.parseInt(ObfuscatedNames.getPacketBufferNodeGarbageValue));
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                e.printStackTrace();
+            }
+        }
+        Object buffer = null;
+        try {
+            buffer = packetBufferNode.getClass().getDeclaredField(ObfuscatedNames.packetBufferFieldName).get(packetBufferNode);
+        } catch (IllegalAccessException | NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        getPacketBufferNode.setAccessible(false);
+        List<String> params = null;
+        if (def.type == PacketType.OPHELDD) {
+            params = List.of("selectedId", "selectedChildIndex", "selectedItemId", "destId", "destChildIndex", "destItemId");
+        }
+        if (def.type == PacketType.RESUME_COUNTDIALOG) {
+            params = List.of("var0");
+        }
+        if (def.type == PacketType.RESUME_PAUSEBUTTON) {
+            params = List.of("var0", "var1");
+        }
+        if (def.type == PacketType.IF_BUTTON) {
+            params = List.of("widgetId", "slot", "itemId");
+        }
+        if (def.type == PacketType.IF_BUTTONX) {
+            params = List.of("widgetId", "slot", "itemId", "opCode");
+        }
+        if (def.type == PacketType.IF_SUBOP) {
+            params = List.of("widgetId", "slot", "itemId", "menuIndex", "subActionIndex");
+        }
+        if (def.type == PacketType.OPLOC) {
+            params = List.of("objectId", "worldPointX", "worldPointY", "ctrlDown");
+        }
+        if (def.type == PacketType.OPNPC) {
+            params = List.of("npcIndex", "ctrlDown");
+        }
+        if (def.type == PacketType.OPPLAYER) {
+            params = List.of("playerIndex", "ctrlDown");
+        }
+        if (def.type == PacketType.OPOBJ) {
+            params = List.of("objectId", "worldPointX", "worldPointY", "ctrlDown");
+        }
+        if (def.type == PacketType.OPOBJT) {
+            params = List.of("objectId", "worldPointX", "worldPointY", "slot", "itemId", "widgetId",
+                    "ctrlDown");
+        }
+        if (def.type == PacketType.EVENT_MOUSE_CLICK) {
+            params = List.of("mouseInfo", "mouseX", "mouseY", "0");
+        }
+        if (def.type == PacketType.MOVE_GAMECLICK) {
+            params = List.of("worldPointX", "worldPointY", "ctrlDown", "5");
+        }
+        if (def.type == PacketType.IF_BUTTONT) {
+            params = List.of("sourceWidgetId", "sourceSlot", "sourceItemId", "destinationWidgetId",
+                    "destinationSlot", "destinationItemId");
+        }
+        if (def.type == PacketType.OPLOCT) {
+            params = List.of("objectId", "worldPointX", "worldPointY", "slot", "itemId", "widgetId",
+                    "ctrlDown");
+        }
+        if (def.type == PacketType.OPPLAYERT) {
+            params = List.of("playerIndex", "itemId", "slot", "widgetId", "ctrlDown");
+        }
+        if (def.type == PacketType.OPNPCT) {
+            params = List.of("npcIndex", "itemId", "slot", "widgetId", "ctrlDown");
+        }
+        if (params != null) {
+            for (int i = 0; i < def.writeData.length; i++) {
+                int index = params.indexOf(def.writeData[i]);
+                Object writeValue = objects[index];
+                for (String s : def.writeMethods[i]) {
+//                    System.out.println("Writing " + s + " " + writeValue);
+                    BufferMethods.writeValue(s, (Integer) writeValue, buffer);
+                }
+            }
+            Field PACKETWRITER = getPacketWriterField();
+            PACKETWRITER.setAccessible(true);
+            try {
+                //System.out.println(PACKETWRITER);
+                //System.out.println(PACKETWRITER.get(null));
+                addNode(PACKETWRITER.get(null), packetBufferNode);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            PACKETWRITER.setAccessible(false);
+        }
+    }
+
+    public static void addNode(Object packetWriter, Object packetBufferNode) {
+        if (PacketUtilsPlugin.usingClientAddNode) {
+            try {
+                Method addNode = null;
+                long garbageValue = Math.abs(Long.parseLong(ObfuscatedNames.addNodeGarbageValue));
+                if (garbageValue < 256) {
+                    addNode = packetWriter.getClass().getDeclaredMethod(ObfuscatedNames.addNodeMethodName, packetBufferNode.getClass(), byte.class);
+                    addNode.setAccessible(true);
+                    addNode.invoke(packetWriter, packetBufferNode, Byte.parseByte(ObfuscatedNames.addNodeGarbageValue));
+                } else if (garbageValue < 32768) {
+                    addNode = packetWriter.getClass().getDeclaredMethod(ObfuscatedNames.addNodeMethodName, packetBufferNode.getClass(), short.class);
+                    addNode.setAccessible(true);
+                    addNode.invoke(packetWriter, packetBufferNode, Short.parseShort(ObfuscatedNames.addNodeGarbageValue));
+                } else if (garbageValue < Integer.MAX_VALUE) {
+                    addNode = packetWriter.getClass().getDeclaredMethod(ObfuscatedNames.addNodeMethodName, packetBufferNode.getClass(), int.class);
+                    //System.out.println("addnode: "+addNode);
+                    addNode.setAccessible(true);
+                    addNode.invoke(packetWriter, packetBufferNode, Integer.parseInt(ObfuscatedNames.addNodeGarbageValue));
+                }
+                if (addNode != null) {
+                    addNode.setAccessible(false);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        } else {
+            try {
+                Method addNode = PacketUtilsPlugin.addNodeMethod;
+                addNode.setAccessible(true);
+                if (addNode.getParameterCount() == 2) {
+                    addNode.invoke(null, packetWriter, packetBufferNode);
+                } else {
+                    long garbageValue = Math.abs(Long.parseLong(ObfuscatedNames.addNodeGarbageValue));
+                    if (garbageValue < 256) {
+                        addNode.invoke(null, packetWriter, packetBufferNode, Byte.parseByte(ObfuscatedNames.addNodeGarbageValue));
+                    } else if (garbageValue < 32768) {
+                        addNode.invoke(null, packetWriter, packetBufferNode, Short.parseShort(ObfuscatedNames.addNodeGarbageValue));
+                    } else if (garbageValue < Integer.MAX_VALUE) {
+                        addNode.invoke(null, packetWriter, packetBufferNode, Integer.parseInt(ObfuscatedNames.addNodeGarbageValue));
+                    }
+                }
+                addNode.setAccessible(false);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+
+    static Field fetchPacketField(String name) {
+        try {
+            Class ClientPacket = getClientPacketClass();
+            return ClientPacket.getDeclaredField(name);
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+
+    private static BigInteger modInverse(BigInteger val) {
+        BigInteger shift = BigInteger.ONE.shiftLeft(32);
+        return val.modInverse(shift);
+    }
+
+    private static int modInverse(int val) {
+        return modInverse(BigInteger.valueOf(val)).intValue();
+    }
+}

src/main/java/ee/futur/baseapi/nono/packets/utils/PacketType.java

@@ -0,0 +1,21 @@
+package ee.futur.baseapi.nono.packets.utils;
+
+public enum PacketType {
+    OPHELDD,
+    RESUME_COUNTDIALOG,
+    RESUME_PAUSEBUTTON,
+    IF_BUTTON,
+    IF_SUBOP,
+    IF_BUTTONX,
+    OPNPC,
+    OPPLAYER,
+    OPOBJ,
+    OPLOC,
+    MOVE_GAMECLICK,
+    EVENT_MOUSE_CLICK,
+    IF_BUTTONT,
+    OPNPCT,
+    OPPLAYERT,
+    OPOBJT,
+    OPLOCT
+}

src/main/java/ee/futur/baseapi/nono/packets/utils/PacketUtilsConfig.java

@@ -0,0 +1,27 @@
+package ee.futur.baseapi.nono.packets.utils;
+
+import net.runelite.client.config.Config;
+import net.runelite.client.config.ConfigGroup;
+import net.runelite.client.config.ConfigItem;
+
+@ConfigGroup("PacketUtils")
+public interface PacketUtilsConfig extends Config {
+    @ConfigItem(
+            keyName = "debug",
+            name = "debug",
+            description = "enable menuaction debug output"
+    )
+    default boolean debug() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "alwaysOn",
+            name = "Always enabled.",
+            description = "Makes this plugin always enabled on startup if the revision matches."
+    )
+    default boolean alwaysOn() {
+        return false;
+    }
+
+}

src/main/java/ee/futur/baseapi/nono/packets/utils/PacketUtilsPlugin.java

@@ -0,0 +1,336 @@
+package ee.futur.baseapi.nono.packets.utils;
+
+import com.google.inject.Provides;
+import com.google.inject.Singleton;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.runelite.api.ChatMessageType;
+import net.runelite.api.Client;
+import net.runelite.api.events.MenuOptionClicked;
+import net.runelite.client.RuneLite;
+import net.runelite.client.RuneLiteProperties;
+import net.runelite.client.config.ConfigManager;
+import net.runelite.client.eventbus.Subscribe;
+import net.runelite.client.plugins.Plugin;
+import net.runelite.client.plugins.PluginDescriptor;
+import net.runelite.client.plugins.PluginInstantiationException;
+import net.runelite.client.plugins.PluginManager;
+
+import javax.inject.Inject;
+import javax.swing.*;
+import java.io.*;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.*;
+import java.util.jar.JarFile;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Singleton
+@PluginDescriptor(
+        name = "Packet Utils",
+        description = "Packet Utils for Plugins",
+        enabledByDefault = true,
+        tags = {"ethan"}
+)
+public class PacketUtilsPlugin extends Plugin {
+    @Inject
+    PacketUtilsConfig config;
+    @Inject
+    Client client;
+    static Client staticClient;
+    public static Method addNodeMethod;
+    public static boolean usingClientAddNode = false;
+    public static final int CLIENT_REV = 232;
+    private static String loadedConfigName = "";
+    @Inject
+    private PluginManager pluginManager;
+
+    @Provides
+    public PacketUtilsConfig getConfig(ConfigManager configManager) {
+        return configManager.getConfig(PacketUtilsConfig.class);
+    }
+
+    @Subscribe
+    public void onMenuOptionClicked(MenuOptionClicked e) {
+        if (config.debug()) {
+            client.addChatMessage(ChatMessageType.GAMEMESSAGE, "Packet Utils", e.toString(), null);
+            System.out.println(e);
+        }
+    }
+
+
+    @Override
+    @SneakyThrows
+    public void startUp() {
+        staticClient = client;
+        if (client.getRevision() != CLIENT_REV) {
+            SwingUtilities.invokeLater(() ->
+            {
+                JOptionPane.showMessageDialog(null, "PacketUtils not updated for this rev please " +
+                        "wait for " +
+                        "plugin update");
+                try {
+                    pluginManager.setPluginEnabled(this, false);
+                    pluginManager.stopPlugin(this);
+                } catch (PluginInstantiationException ignored) {
+                }
+            });
+            return;
+        }
+        //setupNeverlog();
+        int feature = Runtime.version().feature();
+        if (feature != 11) {
+            for (int i = 0; i < 10; i++) {
+                log.error("ETHAN VANN PLUGINS LOADED ON JAVA != 11 THIS IS NOT SUPPORTED");
+                log.error("DEVELOPERS SHOULD IGNORE BUG REPORTS CONTAINING THIS LINE UNTIL THIS ISSUE IS RESOLVED");
+            }
+        } else {
+            log.info("Ethan Vann Plugins loaded on Java 11");
+        }
+        //setupRuneliteUpdateHandling(RuneLiteProperties.getVersion());
+        cleanup();
+        SwingUtilities.invokeLater(() ->
+        {
+            for (Plugin plugin : pluginManager.getPlugins()) {
+                if (plugin.getName().equals("BaseApiPlugin")) {
+                    if (pluginManager.isPluginEnabled(plugin)) {
+                        continue;
+                    }
+                    try {
+                        pluginManager.setPluginEnabled(plugin, true);
+                        pluginManager.startPlugin(plugin);
+                    } catch (PluginInstantiationException e) {
+                        //e.printStackTrace();
+                    }
+                }
+            }
+        });
+    }
+
+    @SneakyThrows
+    public static void setupNeverlog() {
+        staticClient.setIdleTimeout(42069);
+        for (Field declaredField : staticClient.getClass().getDeclaredFields()) {
+            if (declaredField.getType() == int.class && Modifier.isStatic(declaredField.getModifiers())) {
+                declaredField.setAccessible(true);
+                int value = declaredField.getInt(null);
+                if (value != 42069) {
+                    declaredField.setAccessible(false);
+                    continue;
+                }
+                System.out.println("found idle ticks field: " + declaredField.getName());
+                declaredField.setInt(null, Integer.MAX_VALUE);
+                declaredField.setAccessible(false);
+            }
+        }
+    }
+
+    @SneakyThrows
+    public void cleanup() {
+        if (!loadedConfigName.equals(makeString())) {
+            for (int i = 0; i < 10; i++) {
+                log.error("ETHAN VANN PLUGINS LOADED WITH INCORRECT CONFIG DATA THIS IS NOT SUPPORTED");
+                log.error("DEVELOPERS SHOULD IGNORE BUG REPORTS CONTAINING THIS LINE UNTIL THIS ISSUE IS RESOLVED");
+            }
+        } else {
+            log.info("config loaded from correct path");
+        }
+        Path codeSource = RuneLite.RUNELITE_DIR.toPath().resolve("PacketUtils");
+        List<Path> toDelete = new ArrayList<>();
+        toDelete.add(codeSource.resolve("vanilla.jar"));
+        toDelete.add(codeSource.resolve("patched.jar"));
+        toDelete.add(codeSource.resolve("doAction.class"));
+        toDelete.add(codeSource.resolve("decompiled.txt"));
+        for (Path path : toDelete) {
+            Files.deleteIfExists(path);
+        }
+    }
+
+    @SneakyThrows
+    public void setupRuneliteUpdateHandling(String version) {
+        Path codeSource = RuneLite.RUNELITE_DIR.toPath().resolve("PacketUtils");
+        if (Files.exists(codeSource.resolve(version + "-" + client.getRevision() + ".txt"))) {
+            Path f = codeSource.resolve(version + "-" + client.getRevision() + ".txt");
+            List<String> lines = Files.readAllLines(f);
+            loadedConfigName = f.getFileName().toString();
+            System.out.println("config name: " + loadedConfigName);
+            if (lines.size() < 2) {
+                return;
+            }
+            usingClientAddNode = Boolean.parseBoolean(lines.get(0));
+            if (usingClientAddNode) {
+                log.info("loaded addNode config from file");
+                log.info("usingClientAddNode: " + usingClientAddNode);
+                log.info("addNodeMethod: " + "N/A");
+                return;
+            }
+            String[] split = lines.get(1).split("\\.");
+            Class<?> addNodeClassName = client.getClass().getClassLoader().loadClass(split[0]);
+            for (Method declaredMethod : addNodeClassName.getDeclaredMethods()) {
+                if (declaredMethod.getName().equals(split[1]) && declaredMethod.getParameterCount() > 0 && declaredMethod.getParameterTypes()[0].getSimpleName().equals(ObfuscatedNames.packetWriterClassName)) {
+                    addNodeMethod = declaredMethod;
+                }
+            }
+            log.info("loaded addNode config from file");
+            log.info("usingClientAddNode: " + usingClientAddNode);
+            log.info("addNodeMethod: " + addNodeMethod);
+            return;
+        }
+        String doActionClassName = ObfuscatedNames.doActionClassName;
+        String doActionMethodName = ObfuscatedNames.doActionMethodName;
+        System.out.print("finished");
+        final String doActionFinalClassName = doActionClassName;
+        final String doActionFinalMethodName = doActionMethodName;
+        System.out.println(doActionFinalClassName);
+        System.out.println(doActionFinalMethodName);
+        URL rlConfigURL = new URL("https://static.runelite.net/jav_config.ws");
+        if (!codeSource.toFile().isDirectory()) {
+            Files.createDirectory(codeSource);
+        }
+        Path vanillaOutputPath = codeSource.resolve("vanilla.jar");
+        Path patchedOutputPath = codeSource.resolve("patched.jar");
+        Path doActionOutputPath = codeSource.resolve("doAction.class");
+        Path decompilationOutputPath = codeSource.resolve("decompiled.txt");
+        System.out.println("Downloading vanilla client");
+        downloadVanillaJar(vanillaOutputPath, rlConfigURL);
+        File vanilla = vanillaOutputPath.toFile();
+        if (vanilla.exists()) {
+            log.info("Vanilla jar exists");
+        } else {
+            log.info("Vanilla jar does not exist");
+        }
+
+        if (version.contains("SNAPSHOT")) {
+            log.info("replacing snapshot version");
+            version = version.replace("-SNAPSHOT", "");
+        }
+
+        String[] versionSplits = version.split("\\.");
+        int length = versionSplits.length;
+
+        if ((length > 0 && Integer.parseInt(versionSplits[0]) > 1 || (length > 1) && (Integer.parseInt(versionSplits[1]) > 10) )|| (length > 2 && Integer.parseInt(versionSplits[2]) > 34)) {
+            String url = "https://repo.runelite.net/net/runelite/injected-client/" + version + "/injected-client-" + version + ".jar";
+            URL injectedURL = new URL(url);
+            log.info("Downloading injected client from " + injectedURL);
+            try (InputStream clientStream = injectedURL.openStream()) {
+                Files.copy(clientStream, patchedOutputPath, StandardCopyOption.REPLACE_EXISTING);
+            }
+        } else {
+            System.out.println("unsupported rl version");
+            throw new UnsupportedOperationException("unsupported rl version");
+        }
+        System.out.println(doActionFinalClassName);
+        try (JarFile patchedJar = new JarFile(patchedOutputPath.toFile())) {
+            patchedJar.entries().asIterator().forEachRemaining(jarEntry -> {
+                //System.out.println("jar entry: " + jarEntry.getName());
+                if (jarEntry.getName().equals(doActionFinalClassName + ".class")) {
+                    try (InputStream inputStream = patchedJar.getInputStream(jarEntry)) {
+                        Files.copy(inputStream, doActionOutputPath, StandardCopyOption.REPLACE_EXISTING);
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            });
+        }
+        OutputStream decompilationOutputStream = Files.newOutputStream(decompilationOutputPath);
+        PrintStream s = new PrintStream(decompilationOutputStream);
+        System.setOut(s);
+        //Main.main(new String[]{doActionOutputPath.toAbsolutePath().toString(), "--methodname", doActionFinalMethodName});
+        s.flush();
+        s.close();
+        decompilationOutputStream.close();
+        System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out)));
+        File output = decompilationOutputPath.toFile();
+        BufferedReader reader = new BufferedReader(new FileReader(output));
+        List<String> lines = reader.lines().collect(Collectors.toList());
+        String previousLine = null;
+        ArrayList<String> methodCalls = new ArrayList<>();
+        for (String line : lines) {
+            if (line.length() < 300) {
+                if (line.contains("}")) {
+                    if (previousLine != null && previousLine.contains("(")) {
+                        methodCalls.add(previousLine.split("\\(")[0].trim());
+                    }
+                }
+                previousLine = line;
+            }
+        }
+        reader.close();
+        String mostUsedMethod = methodCalls.stream()
+                .filter(str -> !str.contains("** while"))
+                .collect(Collectors.groupingBy(str -> str, Collectors.counting()))
+                .entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
+                .findFirst().get().getKey();
+        if (mostUsedMethod.contains("client")) {
+            usingClientAddNode = true;
+        } else {
+            String[] split = mostUsedMethod.split("\\.");
+            Class<?> addNodeClassName = client.getClass().getClassLoader().loadClass(split[0]);
+            for (Method declaredMethod : addNodeClassName.getDeclaredMethods()) {
+                if (declaredMethod.getName().equals(split[1]) && declaredMethod.getParameterTypes()[0].getSimpleName().equals(ObfuscatedNames.packetWriterClassName)) {
+                    addNodeMethod = declaredMethod;
+                }
+            }
+        }
+        for (String line : lines) {
+            if (line.contains(mostUsedMethod)) {
+                log.info("found addNode method call example " + line.trim());
+                String stringOutput = usingClientAddNode +
+                        "\n" +
+                        mostUsedMethod;
+                Path config = Files.write(Files.createFile(codeSource.resolve(version + "-" + client.getRevision() + ".txt")), stringOutput.getBytes(StandardCharsets.UTF_8));
+                loadedConfigName = config.getFileName().toString();
+                break;
+            }
+        }
+    }
+
+    public static void downloadVanillaJar(Path vanillaOutputPath, URL rlConfigURL) throws IOException {
+        BufferedReader configReader = new BufferedReader(new InputStreamReader(rlConfigURL.openConnection().getInputStream()));
+        while (configReader.ready()) {
+            String line = configReader.readLine();
+            if (line == null) {
+                continue;
+            }
+            if (line.contains("runelite.gamepack")) {
+                URL clientURL = new URL(line.split("=")[1]);
+                log.info("Downloading vanilla client from " + clientURL);
+                try (InputStream clientStream = clientURL.openStream()) {
+                    Files.copy(clientStream, vanillaOutputPath, StandardCopyOption.REPLACE_EXISTING);
+                }
+            }
+        }
+        configReader.close();
+    }
+
+    @Override
+    public void shutDown() {
+        log.info("Shutdown");
+    }
+
+    @Inject
+    private void init() {
+        if (config.alwaysOn() && client.getRevision() == CLIENT_REV) {
+            SwingUtilities.invokeLater(() ->
+            {
+                try {
+                    RuneLite.getInjector().getInstance(PluginManager.class).setPluginEnabled(this, true);
+                    RuneLite.getInjector().getInstance(PluginManager.class).startPlugin(this);
+                } catch (PluginInstantiationException e) {
+                    e.printStackTrace();
+                }
+            });
+        }
+    }
+
+    public String makeString() {
+        return RuneLiteProperties.getVersion() + "-" + client.getRevision() + ".txt";
+    }
+}

src/main/java/ee/futur/baseapi/pathfinding/GlobalCollisionMap.java

@@ -0,0 +1,104 @@
+package ee.futur.baseapi.pathfinding;
+
+import ee.futur.baseapi.BaseApiPlugin;
+import net.runelite.api.coords.WorldPoint;
+import org.roaringbitmap.RoaringBitmap;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.*;
+import java.util.zip.GZIPInputStream;
+
+public class GlobalCollisionMap {
+    static RoaringBitmap bitmap = init();
+
+    static byte[] load() {
+        try {
+            InputStream is = GlobalCollisionMap.class.getResourceAsStream("map");
+            return new GZIPInputStream(is).readAllBytes();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static RoaringBitmap init() {
+        RoaringBitmap bitmap = new RoaringBitmap();
+        try {
+            bitmap.deserialize(ByteBuffer.wrap(load()));
+            bitmap.runOptimize();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        return bitmap;
+    }
+
+    public static boolean east(WorldPoint wp) {
+        return bitmap.contains(packed(wp) | (1 << 30));
+    }
+
+    public static boolean north(WorldPoint wp) {
+        return bitmap.contains(packed(wp));
+    }
+
+    public static boolean south(WorldPoint wp) {
+        return north(wp.dy(-1));
+    }
+
+    public static boolean west(WorldPoint wp) {
+        return east(wp.dx(-1));
+    }
+
+    public static int packed(int x, int y, int plane) {
+        return (x & 16383) | ((y & 16383) << 14) | (plane << 28);
+    }
+
+    public static WorldPoint unpack(int packed) {
+        return new WorldPoint(packed & 16383, (packed >> 14) & 16383, packed >> 28);
+    }
+
+    public static int packed(WorldPoint wp) {
+        return (wp.getX() & 16383) | ((wp.getY() & 16383) << 14) | (wp.getPlane() << 28);
+    }
+
+    public static List<WorldPoint> findPath(WorldPoint p) {
+        long start = System.currentTimeMillis();
+        WorldPoint starting = BaseApiPlugin.getClient().getLocalPlayer().getWorldLocation();
+        HashSet<WorldPoint> visited = new HashSet<>();
+        ArrayDeque<Node> queue = new ArrayDeque<Node>();
+        queue.add(new Node(starting));
+        while (!queue.isEmpty()) {
+            Node current = queue.poll();
+            WorldPoint currentData = current.getData();
+            if (currentData.equals(p)) {
+                List<WorldPoint> ret = new ArrayList<>();
+                while (current != null) {
+                    ret.add(current.getData());
+                    current = current.getPrevious();
+                }
+                Collections.reverse(ret);
+                ret.remove(0);
+                System.out.println("Path took " + (System.currentTimeMillis() - start) + "ms");
+                return ret;
+            }
+            //west
+            if (west(currentData) && visited.add(currentData.dx(-1))) {
+                queue.add(new Node(currentData.dx(-1), current));
+            }
+            //east
+            if (east(currentData) && visited.add(currentData.dx(1))) {
+                queue.add(new Node(currentData.dx(1), current));
+            }
+            //south
+            if (south(currentData) && visited.add(currentData.dy(-1))) {
+                queue.add(new Node(currentData.dy(-1), current));
+            }
+            //north
+            if (north(currentData) && visited.add(currentData.dy(1))) {
+                queue.add(new Node(currentData.dy(1), current));
+            }
+        }
+        return null;
+    }
+}

src/main/java/ee/futur/baseapi/pathfinding/Node.java

@@ -0,0 +1,35 @@
+package ee.futur.baseapi.pathfinding;
+
+import net.runelite.api.coords.WorldPoint;
+
+public class Node {
+    WorldPoint data;
+    Node previous;
+
+    public Node(WorldPoint data) {
+        this.data = data;
+    }
+
+    Node() {
+        this.data = null;
+        this.previous = null;
+    }
+
+    public Node(WorldPoint data, Node previous) {
+        this.data = data;
+        this.previous = previous;
+    }
+
+    public WorldPoint getData() {
+        return data;
+    }
+
+    public Node getPrevious() {
+        return previous;
+    }
+
+    public void setNode(WorldPoint data, Node previous) {
+        this.data = data;
+        this.previous = previous;
+    }
+}

src/main/java/ee/futur/baseapi/utils/WorldAreaUtility.java

@@ -0,0 +1,110 @@
+package ee.futur.baseapi.utils;
+
+import ee.futur.baseapi.nono.packets.utils.PacketReflection;
+import net.runelite.api.*;
+import net.runelite.api.coords.LocalPoint;
+import net.runelite.api.coords.WorldArea;
+import net.runelite.api.coords.WorldPoint;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class WorldAreaUtility {
+    public static List<WorldPoint> objectInteractableTiles(TileObject e) {
+        Point p;
+        int width = 1;
+        int height = 1;
+        if (e instanceof GameObject) {
+            GameObject gameObject = (GameObject) e;
+            width = gameObject.sizeX();
+            height = gameObject.sizeY();
+            p = gameObject.getSceneMinLocation();
+        } else {
+            p = new Point(e.getLocalLocation().getSceneX(), e.getLocalLocation().getSceneY());
+        }
+        LocalPoint objectMinLocation = new LocalPoint(p.getX(), p.getY());
+        WorldPoint objectMinWorldPoint = WorldPoint.fromScene(PacketReflection.getClient(), objectMinLocation.getX(), objectMinLocation.getY(), e.getPlane());
+        int xSW = objectMinWorldPoint.getX();
+        int ySW = objectMinWorldPoint.getY();
+        int xNE = xSW + width - 1;
+        int yNE = ySW + height - 1;
+        List<WorldPoint> surroundingTiles = new ArrayList<>();
+        for (int x = xSW - 1; x <= xNE + 1; x++) {
+            for (int y = ySW - 1; y <= yNE + 1; y++) {
+                // Check if the tile is a corner
+                boolean isCorner = (x == xSW - 1 && y == ySW - 1) || (x == xNE + 1 && y == ySW - 1) ||
+                        (x == xSW - 1 && y == yNE + 1) || (x == xNE + 1 && y == yNE + 1);
+
+                // Exclude tiles that are within the object or are corner tiles
+                if ((x >= xSW && x <= xNE && y >= ySW && y <= yNE) || isCorner) {
+                    continue;
+                }
+                surroundingTiles.add(new WorldPoint(x, y, objectMinWorldPoint.getPlane()));
+            }
+        }
+        CollisionData[] collisionData = PacketReflection.getClient().getCollisionMaps();
+        if (collisionData == null) {
+            return surroundingTiles;
+        }
+
+        int[][] planeData = collisionData[PacketReflection.getClient().getPlane()].getFlags();
+
+        var iter = surroundingTiles.iterator();
+
+        while (iter.hasNext()) {
+            WorldPoint testPoint = iter.next();
+            LocalPoint localScenePoint = LocalPoint.fromWorld(PacketReflection.getClient(), testPoint);
+            if (localScenePoint == null) {
+                continue;
+            }
+
+            int flags = planeData[localScenePoint.getSceneX()][localScenePoint.getSceneY()];
+            if ((flags & CollisionDataFlag.BLOCK_MOVEMENT_FULL) != 0) {
+                iter.remove();
+            }
+        }
+        return surroundingTiles;
+    }
+
+    public static List<WorldPoint> objectInteractableTiles(Actor e) {
+        int x = 1;
+        int y = 1;
+        if (e instanceof NPC) {
+            NPC gameObject = (NPC) e;
+            x = gameObject.getComposition().getSize();
+            y = gameObject.getComposition().getSize();
+        }
+        WorldPoint areaMinCornerWorldPoint = new WorldPoint(e.getWorldLocation().getX() - 1, e.getWorldLocation().getY() - 1, e.getWorldLocation().getPlane());
+        List<WorldPoint> objectArea = e.getWorldArea().toWorldPointList();
+        int sx = x + 2;
+        int sy = y + 2;
+        ArrayList<WorldPoint> grownArea = new ArrayList<>(new WorldArea(areaMinCornerWorldPoint, sx, sy).toWorldPointList());
+        grownArea.remove(grownArea.size() - 1);
+        grownArea.remove((sx * sy) - sx);
+        grownArea.remove(sx - 1);
+        grownArea.remove(0);
+        grownArea.removeAll(objectArea);
+
+        CollisionData[] collisionData = PacketReflection.getClient().getCollisionMaps();
+        if (collisionData == null) {
+            return grownArea;
+        }
+
+        int[][] planeData = collisionData[PacketReflection.getClient().getPlane()].getFlags();
+
+        for (int i = grownArea.size() - 1; i >= 0; i--) {
+            WorldPoint testPoint = grownArea.get(i);
+            LocalPoint localScenePoint = LocalPoint.fromWorld(PacketReflection.getClient(), testPoint);
+            if (localScenePoint == null) {
+                continue;
+            }
+
+            int flags = planeData[localScenePoint.getSceneX()][localScenePoint.getSceneY()];
+            if ((flags & CollisionDataFlag.BLOCK_MOVEMENT_FULL) != 0) {
+                grownArea.remove(testPoint);
+            }
+        }
+
+        return grownArea;
+    }
+}

src/main/java/ee/futur/baseapi/utils/WorldPointUtility.java

@@ -0,0 +1,23 @@
+package ee.futur.baseapi.utils;
+
+import net.runelite.api.coords.WorldPoint;
+
+public class WorldPointUtility {
+    public static boolean arePointsAdjacent(WorldPoint reference, WorldPoint target) {
+        int x1 = reference.getX();
+        int x2 = target.getX();
+
+        int y1 = reference.getY();
+        int y2 = target.getY();
+
+        if (x1 != x2 && y1 != y2) {
+            return false;
+        }
+
+        if (x1 == x2 && Math.abs(y1 - y2) == 1) {
+            return true;
+        }
+
+        return y1 == y2 && Math.abs(x1 - x2) == 1;
+    }
+}

src/main/java/ee/futur/easygiantsfoundry/BonusWidget.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
 import net.runelite.api.Client;
 import net.runelite.api.widgets.Widget;

src/main/java/ee/futur/easygiantsfoundry/EasyGiantsFoundryClientIDs.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
 public class EasyGiantsFoundryClientIDs
 {

src/main/java/ee/futur/easygiantsfoundry/EasyGiantsFoundryConfig.java

@@ -1,8 +1,8 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
 import java.awt.Color;
 
-import com.toofifty.easygiantsfoundry.enums.FontType;
+import ee.futur.easygiantsfoundry.enums.FontType;
 import net.runelite.client.config.Alpha;
 import net.runelite.client.config.Config;
 import net.runelite.client.config.ConfigGroup;

src/main/java/ee/futur/easygiantsfoundry/EasyGiantsFoundryHelper.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
 import lombok.extern.slf4j.Slf4j;
 import net.runelite.api.Point;

src/main/java/ee/futur/easygiantsfoundry/EasyGiantsFoundryPlugin.java

@@ -1,10 +1,10 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
 import com.google.inject.Provides;
 
-import static com.toofifty.easygiantsfoundry.EasyGiantsFoundryClientIDs.VARBIT_GAME_STAGE;
-import static com.toofifty.easygiantsfoundry.EasyGiantsFoundryClientIDs.VARBIT_HEAT;
-import com.toofifty.easygiantsfoundry.enums.Stage;
+import static ee.futur.easygiantsfoundry.EasyGiantsFoundryClientIDs.VARBIT_GAME_STAGE;
+import static ee.futur.easygiantsfoundry.EasyGiantsFoundryClientIDs.VARBIT_HEAT;
+import ee.futur.easygiantsfoundry.enums.Stage;
 
 import javax.inject.Inject;
 

src/main/java/ee/futur/easygiantsfoundry/EasyGiantsFoundryState.java

@@ -1,13 +1,13 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
-import static com.toofifty.easygiantsfoundry.MathUtil.max1;
-import static com.toofifty.easygiantsfoundry.EasyGiantsFoundryClientIDs.*;
+import static ee.futur.easygiantsfoundry.MathUtil.max1;
+import static ee.futur.easygiantsfoundry.EasyGiantsFoundryClientIDs.*;
 
-import com.toofifty.easygiantsfoundry.enums.Heat;
-import com.toofifty.easygiantsfoundry.enums.Stage;
-import static com.toofifty.easygiantsfoundry.enums.Stage.GRINDSTONE;
-import static com.toofifty.easygiantsfoundry.enums.Stage.POLISHING_WHEEL;
-import static com.toofifty.easygiantsfoundry.enums.Stage.TRIP_HAMMER;
+import ee.futur.easygiantsfoundry.enums.Heat;
+import ee.futur.easygiantsfoundry.enums.Stage;
+import static ee.futur.easygiantsfoundry.enums.Stage.GRINDSTONE;
+import static ee.futur.easygiantsfoundry.enums.Stage.POLISHING_WHEEL;
+import static ee.futur.easygiantsfoundry.enums.Stage.TRIP_HAMMER;
 
 import lombok.Getter;
 import lombok.Setter;

src/main/java/ee/futur/easygiantsfoundry/FoundryOverlay2D.java

@@ -1,8 +1,8 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
-import com.toofifty.easygiantsfoundry.enums.Heat;
-import com.toofifty.easygiantsfoundry.enums.MetalBarType;
-import com.toofifty.easygiantsfoundry.enums.Stage;
+import ee.futur.easygiantsfoundry.enums.Heat;
+import ee.futur.easygiantsfoundry.enums.MetalBarType;
+import ee.futur.easygiantsfoundry.enums.Stage;
 import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Graphics2D;

src/main/java/ee/futur/easygiantsfoundry/FoundryOverlay3D.java

@@ -1,14 +1,14 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
-import static com.toofifty.easygiantsfoundry.EasyGiantsFoundryClientIDs.*;
-import static com.toofifty.easygiantsfoundry.EasyGiantsFoundryHelper.getHeatColor;
-import static com.toofifty.easygiantsfoundry.EasyGiantsFoundryHelper.renderTextLocation;
-import static com.toofifty.easygiantsfoundry.MouldHelper.SWORD_TYPE_1_VARBIT;
-import static com.toofifty.easygiantsfoundry.MouldHelper.SWORD_TYPE_2_VARBIT;
-import com.toofifty.easygiantsfoundry.enums.CommissionType;
-import com.toofifty.easygiantsfoundry.enums.FontType;
-import com.toofifty.easygiantsfoundry.enums.Heat;
-import com.toofifty.easygiantsfoundry.enums.Stage;
+import static ee.futur.easygiantsfoundry.EasyGiantsFoundryClientIDs.*;
+import static ee.futur.easygiantsfoundry.EasyGiantsFoundryHelper.getHeatColor;
+import static ee.futur.easygiantsfoundry.EasyGiantsFoundryHelper.renderTextLocation;
+import static ee.futur.easygiantsfoundry.MouldHelper.SWORD_TYPE_1_VARBIT;
+import static ee.futur.easygiantsfoundry.MouldHelper.SWORD_TYPE_2_VARBIT;
+import ee.futur.easygiantsfoundry.enums.CommissionType;
+import ee.futur.easygiantsfoundry.enums.FontType;
+import ee.futur.easygiantsfoundry.enums.Heat;
+import ee.futur.easygiantsfoundry.enums.Stage;
 
 import java.awt.Color;
 import java.awt.Dimension;

src/main/java/ee/futur/easygiantsfoundry/HeatActionSolver.java

@@ -1,9 +1,9 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
 //import java.util.ArrayList;
 //import java.util.List;
 
-import com.toofifty.easygiantsfoundry.enums.Stage;
+import ee.futur.easygiantsfoundry.enums.Stage;
 import lombok.Value;
 
 /**

src/main/java/ee/futur/easygiantsfoundry/HeatActionStateMachine.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
 import lombok.Data;
 import lombok.extern.slf4j.Slf4j;

src/main/java/ee/futur/easygiantsfoundry/HighlightStyle.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
 public enum HighlightStyle
 {

src/main/java/ee/futur/easygiantsfoundry/MathUtil.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
 public class MathUtil
 {

src/main/java/ee/futur/easygiantsfoundry/MetalBarCounter.java

@@ -1,7 +1,7 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
-import com.toofifty.easygiantsfoundry.enums.MetalBarSource;
-import com.toofifty.easygiantsfoundry.enums.MetalBarType;
+import ee.futur.easygiantsfoundry.enums.MetalBarSource;
+import ee.futur.easygiantsfoundry.enums.MetalBarType;
 import lombok.Getter;
 import lombok.Value;
 import net.runelite.api.Item;

src/main/java/ee/futur/easygiantsfoundry/MetalBarValues.java

@@ -1,7 +1,7 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
-import com.toofifty.easygiantsfoundry.enums.MetalBarSource;
-import com.toofifty.easygiantsfoundry.enums.MetalBarType;
+import ee.futur.easygiantsfoundry.enums.MetalBarSource;
+import ee.futur.easygiantsfoundry.enums.MetalBarType;
 import lombok.Value;
 import net.runelite.api.gameval.ItemID;
 

src/main/java/ee/futur/easygiantsfoundry/MouldHelper.java

@@ -1,7 +1,7 @@
-package com.toofifty.easygiantsfoundry;
+package ee.futur.easygiantsfoundry;
 
-import com.toofifty.easygiantsfoundry.enums.CommissionType;
-import com.toofifty.easygiantsfoundry.enums.Mould;
+import ee.futur.easygiantsfoundry.enums.CommissionType;
+import ee.futur.easygiantsfoundry.enums.Mould;
 
 import java.util.LinkedHashMap;
 import java.util.Map;

src/main/java/ee/futur/easygiantsfoundry/enums/CommissionType.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry.enums;
+package ee.futur.easygiantsfoundry.enums;
 
 public enum CommissionType
 {

src/main/java/ee/futur/easygiantsfoundry/enums/FontType.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry.enums;
+package ee.futur.easygiantsfoundry.enums;
 
 import lombok.AllArgsConstructor;
 import lombok.Getter;

src/main/java/ee/futur/easygiantsfoundry/enums/Heat.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry.enums;
+package ee.futur.easygiantsfoundry.enums;
 
 import java.awt.Color;
 

src/main/java/ee/futur/easygiantsfoundry/enums/MetalBarSource.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry.enums;
+package ee.futur.easygiantsfoundry.enums;
 
 public enum MetalBarSource
 {

src/main/java/ee/futur/easygiantsfoundry/enums/MetalBarType.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry.enums;
+package ee.futur.easygiantsfoundry.enums;
 
 public enum MetalBarType
 {

src/main/java/ee/futur/easygiantsfoundry/enums/Mould.java

@@ -1,12 +1,12 @@
-package com.toofifty.easygiantsfoundry.enums;
+package ee.futur.easygiantsfoundry.enums;
 
 import com.google.common.collect.ImmutableMap;
 import lombok.AllArgsConstructor;
 
 import java.util.Map;
 
-import static com.toofifty.easygiantsfoundry.enums.CommissionType.*;
-import static com.toofifty.easygiantsfoundry.enums.MouldType.*;
+import static ee.futur.easygiantsfoundry.enums.CommissionType.*;
+import static ee.futur.easygiantsfoundry.enums.MouldType.*;
 
 @AllArgsConstructor
 public enum Mould

src/main/java/ee/futur/easygiantsfoundry/enums/MouldType.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry.enums;
+package ee.futur.easygiantsfoundry.enums;
 
 public enum MouldType
 {

src/main/java/ee/futur/easygiantsfoundry/enums/Stage.java

@@ -1,4 +1,4 @@
-package com.toofifty.easygiantsfoundry.enums;
+package ee.futur.easygiantsfoundry.enums;
 
 import lombok.AllArgsConstructor;
 import lombok.Getter;

src/main/java/ee/futur/gotr/AutoRiftsConfig.java

@@ -0,0 +1,277 @@
+package ee.futur.gotr;
+
+import net.runelite.client.config.*;
+
+@ConfigGroup("AutoRifts")
+public interface AutoRiftsConfig extends Config {
+    @ConfigItem(
+            keyName = "Toggle",
+            name = "Toggle",
+            description = "",
+            position = 0
+    )
+    default Keybind toggle() {
+        return Keybind.NOT_SET;
+    }
+
+    @ConfigSection(
+            name = "Auto Rifts Configuration",
+            description = "Configure your settings for the AutoRifts plugin",
+            position = 1,
+            closedByDefault = true
+    )
+    String autoRiftsConfig = "autoRiftsConfig";
+
+    @ConfigItem(
+            keyName = "prioritizeBloodDeath",
+            name = "Always use blood/death altars",
+            description = "Will ignore point balance for these altars and always use them if available.",
+            position = 2,
+            section = autoRiftsConfig
+    )
+    default boolean prioritizeBloodDeath() {
+        return true;
+    }
+
+    @ConfigItem(
+            keyName = "dropRunes",
+            name = "Drop Runes",
+            description = "Drop Runes instead of depositing (kek uim)",
+            position = 3,
+            section = autoRiftsConfig
+    )
+    default boolean dropRunes() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "dropRunesFilter",
+            name = "Drop Runes Filter",
+            description = "If Drop Runes is not enabled and this has runes entered, the type of rune entered here will still get dropped, others will get deposited (ex: air, Mind, Body). Add runes with full name, air rune, mind rune , cosmic rune, etc... and split with comma ','",
+            position = 5,
+            section = autoRiftsConfig
+    )
+    default String dropRunesFilter() {
+        return "";
+    }
+
+    @ConfigItem(
+            keyName = "usePouches",
+            name = "Use Essence Pouches?",
+            description = "Requires NPC Contact runes in Rune Pouch or Redwood lit Lantern",
+            position = 6,
+            section = autoRiftsConfig
+    )
+    default boolean usePouches() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "hasBook",
+            name = "Abyssal Book in bank? (IMPORTANT FOR NPC CONTACT)",
+            description = "IMPORTANT TO USE NPC CONTACT",
+            position = 7,
+            section = autoRiftsConfig
+    )
+    default boolean hasBook() {
+        return true;
+    }
+
+    @ConfigItem(
+            keyName = "startFrags",
+            name = "Starting Fragments (0 to wait for first portal)",
+            description = "How many fragments you should get before leaving the starting zone",
+            position = 8,
+            section = autoRiftsConfig
+    )
+    default int startingFrags() {
+        return 0;
+    }
+
+    @ConfigSection(
+            name = "Altar Ignore Configuration",
+            description = "",
+            position = 60,
+            closedByDefault = true
+    )
+    String ignoreSection = "ignoreSection";
+
+    @ConfigItem(
+            keyName = "ignoreAir",
+            name = "Ignore Air Altar",
+            description = "",
+            position = 61,
+            section = ignoreSection
+    )
+    default boolean ignoreAir() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "ignoreMind",
+            name = "Ignore Mind Altar",
+            description = "",
+            position = 62,
+            section = ignoreSection
+    )
+    default boolean ignoreMind() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "ignoreWater",
+            name = "Ignore Water Altar",
+            description = "",
+            position = 63,
+            section = ignoreSection
+    )
+    default boolean ignoreWater() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "ignoreEarth",
+            name = "Ignore Earth Altar",
+            description = "",
+            position = 64,
+            section = ignoreSection
+    )
+    default boolean ignoreEarth() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "ignoreFire",
+            name = "Ignore Fire Altar",
+            description = "",
+            position = 65,
+            section = ignoreSection
+    )
+    default boolean ignoreFire() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "ignoreBody",
+            name = "Ignore Body Altar",
+            description = "",
+            position = 66,
+            section = ignoreSection
+    )
+    default boolean ignoreBody() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "ignoreCosmic",
+            name = "Ignore Cosmic Altar",
+            description = "",
+            position = 67,
+            section = ignoreSection
+    )
+    default boolean ignoreCosmic() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "ignoreChaos",
+            name = "Ignore Chaos Altar",
+            description = "",
+            position = 68,
+            section = ignoreSection
+    )
+    default boolean ignoreChaos() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "ignoreNature",
+            name = "Ignore Nature Altar",
+            description = "",
+            position = 69,
+            section = ignoreSection
+    )
+    default boolean ignoreNature() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "ignoreLaw",
+            name = "Ignore Law Altar",
+            description = "",
+            position = 70,
+            section = ignoreSection
+    )
+    default boolean ignoreLaw() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "ignoreDeath",
+            name = "Ignore Death Altar",
+            description = "",
+            position = 71,
+            section = ignoreSection
+    )
+    default boolean ignoreDeath() {
+        return false;
+    }
+
+    @ConfigItem(
+            keyName = "ignoreBlood",
+            name = "Ignore Blood Altar",
+            description = "",
+            position = 72,
+            section = ignoreSection
+    )
+    default boolean ignoreBlood() {
+        return false;
+    }
+
+    @ConfigSection(
+            name = "Game Tick Configuration",
+            description = "Configure how to handles game tick delays, 1 game tick equates to roughly 600ms",
+            position = 100,
+            closedByDefault = true
+    )
+    String delayTickConfig = "delayTickConfig";
+
+    @Range(
+            max = 10
+    )
+    @ConfigItem(
+            keyName = "tickDelayMin",
+            name = "Game Tick Min",
+            description = "",
+            position = 101,
+            section = delayTickConfig
+    )
+    default int tickDelayMin() {
+        return 1;
+    }
+
+    @Range(
+            max = 10
+    )
+    @ConfigItem(
+            keyName = "tickDelayMax",
+            name = "Game Tick Max",
+            description = "",
+            position = 102,
+            section = delayTickConfig
+    )
+    default int tickDelayMax() {
+        return 3;
+    }
+
+    @ConfigItem(
+            keyName = "tickDelayEnabled",
+            name = "Tick delay",
+            description = "enables some tick delays",
+            position = 103,
+            section = delayTickConfig
+    )
+    default boolean tickDelay() {
+        return false;
+    }
+}

src/main/java/ee/futur/gotr/AutoRiftsOverlay.java

@@ -0,0 +1,70 @@
+package ee.futur.gotr;
+
+import net.runelite.api.Client;
+import net.runelite.client.ui.overlay.OverlayPanel;
+import net.runelite.client.ui.overlay.OverlayPosition;
+import net.runelite.client.ui.overlay.components.LineComponent;
+import net.runelite.client.ui.overlay.components.TitleComponent;
+
+import javax.inject.Inject;
+import java.awt.*;
+
+import static org.apache.commons.lang3.time.DurationFormatUtils.formatDuration;
+
+public class AutoRiftsOverlay extends OverlayPanel {
+
+    private final Client client;
+    private final AutoRiftsPlugin plugin;
+    public String overlayState = "";
+
+    @Inject
+    private AutoRiftsOverlay(Client client, AutoRiftsPlugin plugin) {
+        this.client = client;
+        this.plugin = plugin;
+        setPosition(OverlayPosition.BOTTOM_LEFT);
+    }
+
+    @Override
+    public Dimension render(Graphics2D graphics) {
+        String timeFormat = (plugin.runningDuration.toHours() < 1) ? "mm:ss" : "HH:mm:ss";
+        panelComponent.getChildren().add(TitleComponent.builder()
+                .text("AutoRifts")
+                .color(plugin.started ? Color.GREEN : Color.RED)
+                .build());
+
+        if (plugin.started) {
+            panelComponent.getChildren().add(LineComponent.builder()
+                    .left("Time running:")
+                    .leftColor(Color.WHITE)
+                    .right(formatDuration(plugin.runningDuration.toMillis(), timeFormat))
+                    .rightColor(Color.WHITE)
+                    .build());
+            panelComponent.getChildren().add(LineComponent.builder()
+                    .left("Status:")
+                    .leftColor(Color.WHITE)
+                    .right(overlayState)
+                    .rightColor(Color.WHITE)
+                    .build());
+            panelComponent.getChildren().add(LineComponent.builder()
+                    .left("Game Started:")
+                    .leftColor(Color.WHITE)
+                    .right(String.valueOf(plugin.riftState.isGameStarted()))
+                    .rightColor(Color.WHITE)
+                    .build());
+            panelComponent.getChildren().add(LineComponent.builder()
+                    .left("Portal Spawned:")
+                    .leftColor(Color.WHITE)
+                    .right(String.valueOf(plugin.riftState.isPortalSpawned()))
+                    .rightColor(Color.WHITE)
+                    .build());
+            panelComponent.getChildren().add(LineComponent.builder()
+                    .left("First Portal Spawned:")
+                    .leftColor(Color.WHITE)
+                    .right(String.valueOf(plugin.riftState.hasFirstPortalSpawned))
+                    .rightColor(Color.WHITE)
+                    .build());
+            panelComponent.setPreferredSize(new Dimension(250, 250));
+        }
+        return super.render(graphics);
+    }
+}

src/main/java/ee/futur/gotr/AutoRiftsPlugin.java

@@ -0,0 +1,994 @@
+package ee.futur.gotr;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.inject.Inject;
+import com.google.inject.Provides;
+import ee.futur.baseapi.collections.*;
+import ee.futur.baseapi.collections.query.TileObjectQuery;
+import ee.futur.baseapi.BaseApiPlugin;
+import ee.futur.gotr.data.CellMapper;
+import ee.futur.gotr.data.Constants;
+import ee.futur.utils.InventoryUtil;
+import lombok.extern.slf4j.Slf4j;
+import net.runelite.api.*;
+import net.runelite.api.events.ChatMessage;
+import net.runelite.api.events.GameTick;
+import net.runelite.api.widgets.Widget;
+import net.runelite.client.callback.ClientThread;
+import net.runelite.client.config.ConfigManager;
+import net.runelite.client.eventbus.Subscribe;
+import net.runelite.client.input.KeyManager;
+import net.runelite.client.plugins.Plugin;
+import net.runelite.client.plugins.PluginDescriptor;
+import net.runelite.client.ui.overlay.OverlayManager;
+import net.runelite.client.util.HotkeyListener;
+import org.apache.commons.lang3.RandomUtils;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+
+@PluginDescriptor(
+        name = "<html><font color=\"#FF9DF9\">[PP]</font> GOTR Helper</html>",
+        description = "Guardians of the Rift",
+        enabledByDefault = false,
+        tags = {"gotr", "helper", "k4rli"}
+)
+@Slf4j
+public class AutoRiftsPlugin extends Plugin {
+    @Inject
+    private Client client;
+    @Inject
+    private AutoRiftsConfig config;
+    @Inject
+    private AutoRiftsOverlay overlay;
+    @Inject
+    private KeyManager keyManager;
+    @Inject
+    private OverlayManager overlayManager;
+    @Inject
+    private PouchManager pouchManager;
+    @Inject
+    public GOTRState riftState;
+    @Inject
+    private ClientThread clientThread;
+
+    //@Inject
+    //private ReflectBreakHandler breakHandler;
+
+    public Instant timer;
+    public Duration runningDuration = Duration.ZERO;
+    private static final Set<Integer> MiningAnimationIDs = ImmutableSet.of(AnimationID.MINING_BRONZE_PICKAXE, AnimationID.MINING_IRON_PICKAXE, AnimationID.MINING_STEEL_PICKAXE, AnimationID.MINING_BLACK_PICKAXE, AnimationID.MINING_MITHRIL_PICKAXE, AnimationID.MINING_ADAMANT_PICKAXE, AnimationID.MINING_RUNE_PICKAXE, AnimationID.MINING_GILDED_PICKAXE, AnimationID.MINING_DRAGON_PICKAXE, AnimationID.MINING_DRAGON_PICKAXE_UPGRADED, AnimationID.MINING_DRAGON_PICKAXE_OR, AnimationID.MINING_DRAGON_PICKAXE_OR_TRAILBLAZER, AnimationID.MINING_INFERNAL_PICKAXE, AnimationID.MINING_3A_PICKAXE, AnimationID.MINING_CRYSTAL_PICKAXE, AnimationID.MINING_TRAILBLAZER_PICKAXE, AnimationID.MINING_TRAILBLAZER_PICKAXE_2, AnimationID.MINING_TRAILBLAZER_PICKAXE_3);
+    private final List<Integer> RunePouchList = ImmutableList.of(ItemID.RUNE_POUCH, ItemID.DIVINE_RUNE_POUCH, ItemID.RUNE_POUCH_L, ItemID.DIVINE_RUNE_POUCH_L);
+    private final List<Integer> RuneList = ImmutableList.of(
+            ItemID.AIR_RUNE,
+            ItemID.WATER_RUNE,
+            ItemID.EARTH_RUNE,
+            ItemID.FIRE_RUNE,
+            ItemID.MIND_RUNE,
+            ItemID.CHAOS_RUNE,
+            ItemID.DEATH_RUNE,
+            ItemID.BLOOD_RUNE,
+            ItemID.COSMIC_RUNE,
+            ItemID.NATURE_RUNE,
+            ItemID.LAW_RUNE,
+            ItemID.BODY_RUNE,
+            ItemID.SOUL_RUNE,
+            ItemID.ASTRAL_RUNE,
+            ItemID.MIST_RUNE,
+            ItemID.MUD_RUNE,
+            ItemID.DUST_RUNE,
+            ItemID.LAVA_RUNE,
+            ItemID.STEAM_RUNE,
+            ItemID.SMOKE_RUNE,
+            ItemID.WRATH_RUNE);
+
+    private final List<Integer> PickaxeIDs = ImmutableList.of(ItemID.BRONZE_PICKAXE,
+            ItemID.IRON_PICKAXE,
+            ItemID.STEEL_PICKAXE,
+            ItemID.BLACK_PICKAXE,
+            ItemID.MITHRIL_PICKAXE,
+            ItemID.ADAMANT_PICKAXE,
+            ItemID.RUNE_PICKAXE,
+            ItemID.GILDED_PICKAXE,
+            ItemID.DRAGON_PICKAXE,
+            ItemID.DRAGON_PICKAXE_OR,
+            ItemID.DRAGON_PICKAXE_OR_25376,
+            ItemID.DRAGON_PICKAXE_12797,
+            ItemID.INFERNAL_PICKAXE,
+            ItemID._3RD_AGE_PICKAXE,
+            ItemID.CRYSTAL_PICKAXE,
+            ItemID.CRYSTAL_PICKAXE_INACTIVE,
+            ItemID.INFERNAL_PICKAXE_OR);
+    private final List<Integer> PoweredCellList = ImmutableList.of(ItemID.WEAK_CELL, ItemID.OVERCHARGED_CELL, ItemID.STRONG_CELL, ItemID.MEDIUM_CELL);
+    public boolean started = false;
+    public int timeout = 0;
+    private boolean startingRun = false;
+    private boolean needsMoreStartingFragments = false;
+
+    private boolean canEnterBarrier = false;
+
+    @Provides
+    private AutoRiftsConfig getConfig(ConfigManager configManager) {
+        return configManager.getConfig(AutoRiftsConfig.class);
+    }
+
+    @Override
+    protected void startUp() throws Exception {
+        keyManager.registerKeyListener(toggle);
+        overlayManager.add(overlay);
+        timeout = 0;
+        timer = Instant.now();
+        pouchManager.register();
+        riftState.register();
+    }
+
+    @Override
+    protected void shutDown() throws Exception {
+        keyManager.unregisterKeyListener(toggle);
+        overlayManager.remove(overlay);
+        pouchManager.deregister();
+        riftState.deregister();
+        timeout = 0;
+        toggle();
+        timer = Instant.now();
+    }
+
+    @Subscribe
+    private void onGameTick(GameTick event) {
+        if (timeout > 0) {
+            timeout--;
+            return;
+        }
+        if (client.getGameState() != GameState.LOGGED_IN || !started) {
+            return;
+        }
+
+        if (Inventory.search().idInList(PickaxeIDs).first().isEmpty() && Equipment.search().idInList(PickaxeIDs).first().isEmpty()) {
+            addMessage("No pickaxe found");
+            setStarted(false);
+            return;
+        }
+
+        if (config.usePouches() && !hasDegradePrevention() && (!hasNPCContactRunes() || !isOnLunar())) {
+            addMessage("Must have a rune pouch with NPC contact runes or some form of prevention to use essence pouches");
+            setStarted(false);
+            return;
+        }
+
+        runningDuration = runningDuration.plus(Duration.between(timer, Instant.now()));
+        timer = Instant.now();
+
+        if (Inventory.full()
+                && config.usePouches()
+                && pouchManager.hasEmptyPouches()
+                && Inventory.getItemAmount(ItemID.GUARDIAN_ESSENCE) > 0
+                && !riftState.isInAltar()) {
+            pouchManager.fillPouches();
+            if (riftState.isInHugeMine()) {
+                mineHugeGuardians();
+            } else {
+                craftEssence();
+            }
+            return;
+        }
+
+        AutoRiftsState state = getState();
+        overlay.overlayState = state.toString();
+
+        if (BaseApiPlugin.isMoving()) {
+            //Attempt to put runes in pouch where possible
+            getInventoryRunes().ifPresent(widget -> {
+                Optional<Widget> optPouch = getRunePouch();
+                if (optPouch.isEmpty()) {
+                    return;
+                }
+
+                if (!canDepositRune(widget.getItemId())) {
+                    return;
+                }
+
+                Widget pouch = optPouch.get();
+                //MousePackets.queueClickPacket();
+                //MousePackets.queueClickPacket();
+                //WidgetPackets.queueWidgetOnWidget(widget, pouch);
+            });
+
+            dropRunes();
+
+            //Handle moving to the altar differently (allow for re-tasking)
+            if (state != AutoRiftsState.ENTER_ALTAR) {
+                return;
+            }
+        }
+
+        switch (state) {
+            case WAITING_FOR_GAME:
+                waitForGame();
+                break;
+            case MOVE_TO_EAST_MINE:
+            case LEAVE_EAST_MINE:
+                climbLargeMine();
+                break;
+            case ENTER_PORTAL:
+                enterPortal();
+                break;
+            case LEAVE_ALTAR:
+                exitAltar();
+                break;
+            case GET_CELLS:
+                getCells();
+                break;
+            case CRAFT_ESSENCE:
+                craftEssence();
+                break;
+            case REPAIR_POUCH:
+                repairPouch();
+                break;
+            case POWER_GUARDIAN:
+                powerGuardian();
+                break;
+            case MINE_HUGE_GUARDIANS:
+                mineHugeGuardians();
+                break;
+            case MINE_LARGE_GUARDIANS:
+                mineLargeGuardians();
+                break;
+            case MINE_REGULAR_GUARDIANS:
+                mineGameGuardians();
+                break;
+            case CRAFTING_ESSENCE:
+                break;
+            case DEPOSIT_RUNES:
+                depositRunes();
+                break;
+            case USE_CELL:
+                usePowerCell();
+                break;
+            case CRAFT_RUNES:
+                craftRunes();
+                break;
+            case ENTER_ALTAR:
+                enterRift();
+                break;
+            case ENTER_GAME:
+                enterGame();
+                break;
+            case GAME_BUSY:
+                gameBusy();
+                break;
+            case BREAK:
+                // @TODO
+                break;
+        }
+    }
+
+    private AutoRiftsState getState() {
+        if (config.startingFrags() > 0 && getFragmentCount() > config.startingFrags()) {
+            needsMoreStartingFragments = false;
+        } else if (config.startingFrags() == 0) {
+            needsMoreStartingFragments = true;
+        }
+
+        if (!riftState.isGameStarted() && !riftState.isInAltar()) {
+            return AutoRiftsState.BREAK;
+        }
+
+        if (riftState.isGameBusy()) {
+            return AutoRiftsState.GAME_BUSY;
+        }
+
+        if (riftState.isOutsideBarrier()) {
+            return AutoRiftsState.ENTER_GAME;
+        } else {
+            canEnterBarrier = false;
+        }
+
+        if (pouchManager.hasDegradedPouches()) {
+            return AutoRiftsState.REPAIR_POUCH;
+        }
+
+        if (!riftState.isGameStarted()) {
+            return getPregameState();
+        }
+
+        if (!riftState.hasFirstPortalSpawned && needsMoreStartingFragments) {
+            return getPreFirstPortalState();
+        }
+
+        if (riftState.isGameEnding) {
+            return getGameEndingState();
+        }
+
+        //After the first portal has spawned, we should always be leaving the east mine
+        if (riftState.isInLargeMine()) {
+            return AutoRiftsState.LEAVE_EAST_MINE;
+        }
+
+        //If we're in the huge mine, we should mine until inventory is full and then leave
+        if (riftState.isInHugeMine()) {
+            if (Inventory.full()) {
+                return AutoRiftsState.ENTER_PORTAL;
+            }
+
+            if (isMining()) {
+                return AutoRiftsState.MINING;
+            }
+
+            return AutoRiftsState.MINE_HUGE_GUARDIANS;
+        }
+
+        if (riftState.isInAltar()) {
+            startingRun = false;
+            if (Inventory.getItemAmount(ItemID.GUARDIAN_ESSENCE) > 0 || pouchManager.hasFullPouch()) {
+                return AutoRiftsState.CRAFT_RUNES;
+            }
+
+            return AutoRiftsState.LEAVE_ALTAR;
+        }
+
+        //If we're here, were in the game area
+        if (riftState.isPortalSpawned() && (pouchManager.hasEmptyPouches() || Inventory.getEmptySlots() > 15)) {
+            return AutoRiftsState.ENTER_PORTAL;
+        }
+
+        if (Inventory.full() || startingRun) {
+            startingRun = true;
+            if (hasPowerEssence()) {
+                return AutoRiftsState.POWER_GUARDIAN;
+            }
+
+            if (hasPowerCell()) {
+                return AutoRiftsState.USE_CELL;
+            }
+
+            return AutoRiftsState.ENTER_ALTAR;
+        }
+
+        if (client.getLocalPlayer().getAnimation() == 9365) {
+            return AutoRiftsState.CRAFTING_ESSENCE;
+        }
+
+        if (getCellCount() == 0) {
+            return AutoRiftsState.GET_CELLS;
+        }
+
+        if (getInventoryRunes().isPresent() && !config.dropRunes() && getDroppableRunes().isEmpty()) {
+            return AutoRiftsState.DEPOSIT_RUNES;
+        }
+
+        if (getFragmentCount() < neededFrags()) {
+            if (isMining()) {
+                return AutoRiftsState.MINING;
+            }
+            return AutoRiftsState.MINE_REGULAR_GUARDIANS;
+        }
+
+        return AutoRiftsState.CRAFT_ESSENCE;
+    }
+
+    private AutoRiftsState getGameEndingState() {
+        if (riftState.isInAltar()) {
+            if (pouchManager.getEssenceInPouches() > 0 || Inventory.getItemAmount(ItemID.GUARDIAN_ESSENCE) > 0) {
+                return AutoRiftsState.CRAFT_RUNES;
+            }
+
+            return AutoRiftsState.LEAVE_ALTAR;
+        }
+
+        if (riftState.isInHugeMine()) {
+            return AutoRiftsState.ENTER_PORTAL;
+        }
+
+        if (hasPowerEssence()) {
+            return AutoRiftsState.POWER_GUARDIAN;
+        }
+
+        if (hasPowerCell()) {
+            return AutoRiftsState.USE_CELL;
+        }
+
+        int essence = pouchManager.getEssenceInPouches() + Inventory.getItemAmount(ItemID.GUARDIAN_ESSENCE);
+
+        if (essence > 20) {
+            return AutoRiftsState.ENTER_ALTAR;
+        }
+
+        if (getInventoryRunes().isPresent()) {
+            return AutoRiftsState.DEPOSIT_RUNES;
+        }
+
+        return AutoRiftsState.CRAFT_ESSENCE;
+    }
+
+
+    private AutoRiftsState getPreFirstPortalState() {
+        //Safety
+        if (riftState.isInAltar()) {
+            return AutoRiftsState.LEAVE_ALTAR;
+        }
+        //We're starting the game in the portal area
+        if (riftState.isInHugeMine()) {
+            if (Inventory.full()) {
+                return AutoRiftsState.ENTER_PORTAL;
+            }
+
+            if (isMining()) {
+                return AutoRiftsState.MINING;
+            }
+
+            return AutoRiftsState.MINE_HUGE_GUARDIANS;
+        }
+
+        if (riftState.isInLargeMine()) {
+            if (hasPowerCell()) {
+                Inventory.search().idInList(PoweredCellList).first().ifPresent(widget -> {
+                    //InventoryInteraction.useItem(widget, "Drop");
+                });
+            }
+            if (isMining()) {
+                return AutoRiftsState.MINING;
+            }
+
+            return AutoRiftsState.MINE_LARGE_GUARDIANS;
+        }
+
+        //If we get here, we're probably walking to east from the portal.
+        //Make a quick stop at cells if we need too
+        if (getCellCount() < 10) {
+            return AutoRiftsState.GET_CELLS;
+        }
+
+        return AutoRiftsState.MOVE_TO_EAST_MINE;
+    }
+
+    private AutoRiftsState getPregameState() {
+        if (config.startingFrags() > 0) {
+            needsMoreStartingFragments = true;
+        }
+
+        if (riftState.isInHugeMine()) {
+            return AutoRiftsState.ENTER_PORTAL;
+        }
+        if (riftState.isInLargeMine()) {
+            return AutoRiftsState.WAITING_FOR_GAME;
+        }
+
+        if (riftState.isInAltar()) {
+            if (pouchManager.getEssenceInPouches() > 0 || Inventory.getItemAmount(ItemID.GUARDIAN_ESSENCE) > 0) {
+                return AutoRiftsState.CRAFT_RUNES;
+            }
+            return AutoRiftsState.LEAVE_ALTAR;
+        }
+
+        if (getInventoryRunes().isPresent()) {
+            return AutoRiftsState.DEPOSIT_RUNES;
+        }
+
+        if (getCellCount() < 10) {
+            return AutoRiftsState.GET_CELLS;
+        }
+
+        return AutoRiftsState.MOVE_TO_EAST_MINE;
+    }
+
+    private int getCellCount() {
+        return Inventory.search().withId(ItemID.UNCHARGED_CELL).first().map(Widget::getItemQuantity).orElse(0);
+    }
+
+    private void waitForGame() {
+        if (client.getLocalPlayer().getWorldLocation().getX() == Constants.LARGE_MINE_X) {
+            if (tickDelay() % 2 == 0) {
+                //MousePackets.queueClickPacket();
+                //MovementPackets.queueMovement(3639, 9500, false);
+            } else {
+                //MousePackets.queueClickPacket();
+                //MovementPackets.queueMovement(3640, 9500, false);
+            }
+        }
+    }
+
+    @Subscribe
+    private void onChatMessage(ChatMessage event) {
+        if (client.getGameState() != GameState.LOGGED_IN || !started) {
+            return;
+        }
+
+        if (event.getType() != ChatMessageType.SPAM && event.getType() != ChatMessageType.GAMEMESSAGE) return;
+
+        if (client.getGameState() != GameState.LOGGED_IN) {
+            return;
+        }
+
+        if (event.getMessage().contains("5 seconds.")) {
+            int attempt = RandomUtils.nextInt(0, 10);
+            if (attempt > 7) {
+                activatePickSpecial();
+            }
+        }
+
+        if (event.getMessage().contains("3..")) {
+            int attempt = RandomUtils.nextInt(0, 5);
+            if (attempt > 2) {
+                activatePickSpecial();
+            }
+        }
+
+        if (event.getMessage().contains("2..")) {
+            activatePickSpecial();
+        }
+
+        if (event.getMessage().contains("already enough adventurers")) {
+            timeout = 3;
+        }
+    }
+
+    private void activatePickSpecial() {
+        if (client.getVarpValue(VarPlayer.SPECIAL_ATTACK_PERCENT) == 1000) {
+            if (!Equipment.search().matchesWildCardNoCase("*Dragon pickaxe*").empty() || !Equipment.search().matchesWildCardNoCase("*infernal pickaxe*").empty()) {
+                //MousePackets.queueClickPacket();
+                //WidgetPackets.queueWidgetActionPacket(1, 38862885, -1, -1);
+            }
+        }
+    }
+
+    private void climbLargeMine() {
+        if (BaseApiPlugin.isMoving()) {
+            return;
+        }
+        Optional<TileObject> tileObject = TileObjects.search().withAction("Climb").nearestToPlayer();
+        if (tileObject.isEmpty()) {
+            return;
+        }
+
+        //TileObject rubble = tileObject.get();
+        //TileObjectInteraction.interact(rubble, "Climb");
+        timeout = tickDelay();
+    }
+
+    private void getCells() {
+        if (Inventory.full() && Inventory.getItemAmount(ItemID.UNCHARGED_CELL) == 0) {
+            Inventory.search().withId(ItemID.GUARDIAN_ESSENCE).first().ifPresent(widget -> {
+                //InventoryInteraction.useItem(widget, "Drop");
+            });
+        }
+
+        if (BaseApiPlugin.isMoving()) {
+            return;
+        }
+
+        TileObjects.search().withName("Uncharged cells").first().ifPresent(tileObject -> {
+            //TileObjectInteraction.interact(tileObject, "Take-10");
+            timeout = tickDelay();
+        });
+    }
+
+    private void craftEssence() {
+        if (riftState.isGameStarted()) {
+            Optional<TileObject> tileObject = TileObjects.search().nameContains(Constants.WORKBENCH).nearestToPlayer();
+            if (tileObject.isEmpty()) {
+                return;
+            }
+            TileObject workbench = tileObject.get();
+            //TileObjectInteraction.interact(workbench, "Work-at");
+            timeout = tickDelay();
+        }
+    }
+
+    private void mineHugeGuardians() {
+        Optional<TileObject> tileObject = TileObjects.search().nameContains(Constants.HUGE_REMAINS).nearestToPlayer();
+        if (tileObject.isEmpty()) {
+            return;
+        }
+        TileObject remains = tileObject.get();
+        //TileObjectInteraction.interact(remains, "Mine");
+        timeout = tickDelay();
+    }
+
+    private void mineLargeGuardians() {
+        if (Inventory.full() && Inventory.getItemAmount(ItemID.GUARDIAN_FRAGMENTS) == 0) {
+            Inventory.search().withId(ItemID.GUARDIAN_ESSENCE).first().ifPresent(widget -> {
+                //InventoryInteraction.useItem(widget, "Drop");
+            });
+        }
+
+        Optional<TileObject> tileObject = TileObjects.search().nameContains(Constants.LARGE_REMAINS).nearestToPlayer();
+        if (tileObject.isEmpty()) {
+            return;
+        }
+        if (client.getLocalPlayer().getAnimation() == -1) {
+            TileObject remains = tileObject.get();
+            //TileObjectInteraction.interact(remains, "Mine");
+            timeout = tickDelay();
+        }
+    }
+
+    private Optional<Widget> getInventoryRunes() {
+        return Inventory.search().idInList(RuneList).first();
+    }
+
+    private void mineGameGuardians() {
+        Optional<TileObject> tileObject = nameContainsNoCase(Constants.GAME_PARTS).nearestToPlayer();
+        if (tileObject.isEmpty()) {
+            return;
+        }
+        if (client.getLocalPlayer().getAnimation() == -1) {
+            TileObject remains = tileObject.get();
+            //TileObjectInteraction.interact(remains, "Mine");
+            timeout = tickDelay();
+        }
+    }
+
+    private void gameBusy() {
+        if (BaseApiPlugin.isMoving()) {
+            return;
+        }
+
+        if (riftState.getElementalPoints() < 0 && riftState.getCatalyticPoints() < 0) {
+            TileObjects.search().withId(43695).first().ifPresent(tileObject -> {
+                //TileObjectInteraction.interact(tileObject, "Check");
+            });
+            timeout = tickDelay();
+            return;
+        }
+
+        if (RandomUtils.nextInt(0, 100) == 30) {
+            TileObjects.search().withId(Constants.BARRIER_BUSY_ID).first().ifPresent(tileObject -> {
+                // TileObjectInteraction.interact(tileObject, "Peek");
+            });
+        }
+    }
+
+    private void enterGame() {
+        if (canEnterBarrier) {
+            //TileObjects.search().withName("Barrier").first().ifPresent(tileObject -> TileObjectInteraction.interact(tileObject, "Quick-pass"));
+            timeout = 1;
+            return;
+        }
+
+        Optional<Widget> dialog = Widgets.search().withId(15007475).hiddenState(false).first();
+        if (dialog.isEmpty()) {
+            //TileObjects.search().withName("Barrier").first().ifPresent(tileObject -> TileObjectInteraction.interact(tileObject, "Quick-pass"));
+            return;
+        }
+
+        String dialogText = dialog.get().getText();
+        if (dialogText.contains("the rift is already being guarded")) {
+            timeout = 10;
+            clickContinue();
+            return;
+        }
+
+        if (dialogText.contains("the adventurers within are just finishing up.")) {
+            canEnterBarrier = true;
+            timeout = 1;
+        }
+    }
+
+    private void clickContinue() {
+        Widgets.search().withTextContains("Click here to continue").first().ifPresent(widget -> {
+            //MousePackets.queueClickPacket();
+            //WidgetPackets.queueResumePause(widget.getId(), -1);
+        });
+    }
+
+    private void setStarted(boolean started) {
+        this.started = started;
+        riftState.setStarted(started);
+        pouchManager.setStarted(started);
+        if (started) {
+            timer = Instant.now();
+            if (config.usePouches()) {
+                clientThread.invokeLater(() -> pouchManager.refreshPouches());
+            }
+
+            //breakHandler.startPlugin(this);
+        } else {
+            //breakHandler.stopPlugin(this);
+        }
+    }
+
+    private final HotkeyListener toggle = new HotkeyListener(() -> config.toggle()) {
+        @Override
+        public void hotkeyPressed() {
+            toggle();
+        }
+    };
+
+    public void toggle() {
+        if (client.getGameState() != GameState.LOGGED_IN) {
+            return;
+        }
+        setStarted(!started);
+    }
+
+    private int tickDelay() {
+        return config.tickDelay() ? ThreadLocalRandom.current().nextInt(config.tickDelayMin(), config.tickDelayMax()) : 0;
+    }
+
+    private boolean isMining() {
+        return MiningAnimationIDs.contains(client.getLocalPlayer().getAnimation());
+    }
+
+    private void addMessage(String message) {
+        client.addChatMessage(ChatMessageType.GAMEMESSAGE, "", message, null);
+    }
+
+    private boolean hasRuneAmount(int runeId, int amount) {
+        return (client.getVarbitValue(Varbits.RUNE_POUCH_RUNE1) == runeId
+                && client.getVarbitValue(Varbits.RUNE_POUCH_AMOUNT1) >= amount)
+                || (client.getVarbitValue(Varbits.RUNE_POUCH_RUNE2) == runeId
+                && client.getVarbitValue(Varbits.RUNE_POUCH_AMOUNT2) >= amount)
+                || (client.getVarbitValue(Varbits.RUNE_POUCH_RUNE3) == runeId
+                && client.getVarbitValue(Varbits.RUNE_POUCH_AMOUNT3) >= amount)
+                || (client.getVarbitValue(Varbits.RUNE_POUCH_RUNE4) == runeId
+                && client.getVarbitValue(Varbits.RUNE_POUCH_AMOUNT4) >= amount);
+    }
+
+    private boolean canDepositRune(int runeId) {
+        return (client.getVarbitValue(Varbits.RUNE_POUCH_RUNE1) == runeId
+                && client.getVarbitValue(Varbits.RUNE_POUCH_AMOUNT1) < 16000)
+                || (client.getVarbitValue(Varbits.RUNE_POUCH_RUNE2) == runeId
+                && client.getVarbitValue(Varbits.RUNE_POUCH_AMOUNT2) < 16000)
+                || (client.getVarbitValue(Varbits.RUNE_POUCH_RUNE3) == runeId
+                && client.getVarbitValue(Varbits.RUNE_POUCH_AMOUNT3) < 16000)
+                || (client.getVarbitValue(Varbits.RUNE_POUCH_RUNE4) == runeId
+                && client.getVarbitValue(Varbits.RUNE_POUCH_AMOUNT4) < 16000);
+    }
+
+    private boolean isOnLunar() {
+        return client.getVarbitValue(4070) == 2;
+    }
+
+    private boolean hasNPCContactRunes() {
+        return hasRuneAmount(1, 2) && hasRuneAmount(14, 1) && hasRuneAmount(9, 1);
+    }
+
+    private boolean hasPowerEssence() {
+        return Inventory.getItemAmount(ItemID.CATALYTIC_GUARDIAN_STONE) > 0 || Inventory.getItemAmount(ItemID.ELEMENTAL_GUARDIAN_STONE) > 0;
+    }
+
+    private boolean hasPowerCell() {
+        return Inventory.search().idInList(PoweredCellList).first().isPresent();
+    }
+
+    private void enterPortal() {
+        if (BaseApiPlugin.isMoving()) {
+            return;
+        }
+        Optional<TileObject> tileObject = nameContainsNoCase(Constants.PORTAL).filter(to -> to.getWorldLocation().getY() >= Constants.OUTSIDE_BARRIER_Y).nearestToPlayer();
+        if (tileObject.isEmpty()) {
+            //MousePackets.queueClickPacket();
+            //MovementPackets.queueMovement(new WorldPoint(3615, 9499, 0));
+            return;
+        }
+
+        TileObject portal = tileObject.get();
+        //TileObjectInteraction.interact(portal, "Enter", "Exit", "Use");
+        timeout = tickDelay();
+    }
+
+    private void exitAltar() {
+        lastAltar = null;
+        if (BaseApiPlugin.isMoving()) {
+            return;
+        }
+        Optional<TileObject> tileObject = TileObjects.search().nameContains(Constants.PORTAL).nearestToPlayer();
+        if (tileObject.isEmpty()) {
+            return;
+        }
+
+        TileObject portal = tileObject.get();
+        //TileObjectInteraction.interact(portal, "Use");
+        timeout = tickDelay();
+    }
+
+    private void powerGuardian() {
+        Optional<NPC> npc = NPCs.search().nameContains(Constants.GREAT_GUARDIAN).nearestToPlayer();
+        if (npc.isEmpty()) {
+            return;
+        }
+
+        NPC guardian = npc.get();
+        //NPCInteraction.interact(guardian, "Power-up");
+        timeout = tickDelay();
+    }
+
+    private void repairPouch() {
+        if (!Widgets.search().withTextContains("What do you want?").hiddenState(false).empty() || !Widgets.search().withTextContains("Can you repair").hiddenState(false).empty()) {
+            //MousePackets.queueClickPacket();
+            //WidgetPackets.queueResumePause(15138821, -1);
+            //MousePackets.queueClickPacket();
+            //WidgetPackets.queueResumePause(14352385, config.hasBook() ? 1 : 2);
+            //MousePackets.queueClickPacket();
+            //WidgetPackets.queueResumePause(14221317, -1);
+            //MousePackets.queueClickPacket();
+            BaseApiPlugin.invoke(-1, -1, 26, -1, -1, -1, "", "", -1, -1);
+            timeout = 0;
+            if (config.usePouches()) {
+                clientThread.invokeLater(() -> pouchManager.refreshPouches());
+            }
+        } else {
+            //MousePackets.queueClickPacket();
+            //WidgetPackets.queueWidgetActionPacket(2, WidgetInfoExtended.SPELL_NPC_CONTACT.getPackedId(), -1, -1);
+            timeout = 15;
+        }
+    }
+
+    private Optional<Widget> getRunePouch() {
+        return Inventory.search().idInList(RunePouchList).first();
+    }
+
+    private void depositRunes() {
+        Optional<TileObject> tileObject = TileObjects.search().withAction("Deposit-runes").nearestToPlayer();
+        if (tileObject.isEmpty()) {
+            return;
+        }
+
+        TileObject runeDeposit = tileObject.get();
+        //TileObjectInteraction.interact(runeDeposit, "Deposit-runes");
+        timeout = tickDelay();
+    }
+
+    private int neededFrags() {
+        return Inventory.getEmptySlots() + pouchManager.getAvailableSpace() + 5;
+    }
+
+    private void usePowerCell() {
+        if (BaseApiPlugin.isMoving()) {
+            return;
+        }
+
+        Optional<Widget> optCell = Inventory.search().idInList(PoweredCellList).first();
+        if (optCell.isEmpty()) {
+            return;
+        }
+
+        Widget cell = optCell.get();
+        TileObject nextAltar = riftState.getNextAltar();
+        int cellTier = CellMapper.GetCellTier(cell.getItemId());
+        List<TileObject> shieldCells = TileObjects.search().nameContains("cell tile").result();
+        //Prioritize upgrading shield cells
+        for (TileObject c : shieldCells) {
+            if (CellMapper.GetShieldTier(c.getId()) < cellTier) {
+                log.info("Upgrading power cell at " + c.getWorldLocation());
+                //TileObjectInteraction.interact(c, "Place-cell");
+                timeout = tickDelay();
+                return;
+            }
+        }
+
+        if (nextAltar == null) {
+            Optional<NPC> bestBarrier = NPCs.search()
+                    .filter(x -> x.getId() <= 11425 && x.getId() >= 11418)
+                    .result().stream().min(Comparator.comparingDouble(this::getBarrierHealth));
+
+            if (bestBarrier.isPresent()) {
+                Optional<TileObject> tile = TileObjects.search().nameContains("cell tile").nearestToPoint(bestBarrier.get().getWorldLocation());
+                if (tile.isPresent()) {
+                    //tile.ifPresent(tileObject -> TileObjectInteraction.interact(tileObject, "Place-cell"));
+                    log.info("Placing power cell at " + tile.get().getWorldLocation() + " with no altar present");
+                    timeout = tickDelay();
+                }
+            }
+        } else {
+            Optional<NPC> damagedBarrier = NPCs.search().filter(x -> x.getId() <= 11425 && x.getId() >= 11418 && getBarrierHealth(x) <= 50).first();
+            if (damagedBarrier.isPresent()) {
+                Optional<TileObject> tile = TileObjects.search().nameContains("cell tile").nearestToPoint(damagedBarrier.get().getWorldLocation());
+                if (tile.isPresent()) {
+                    log.info("Placing power cell at " + tile.get().getWorldLocation() + " to repair barrier");
+                    //TileObjectInteraction.interact(tile.get(), "Place-cell");
+                    timeout = tickDelay();
+                    return;
+                }
+            }
+
+            Optional<NPC> bestBarrier = NPCs.search()
+                    .filter(x -> x.getId() <= 11425 && x.getId() >= 11418)
+                    .result().stream().min(Comparator.comparingInt(x -> x.getWorldLocation().distanceTo(nextAltar.getWorldLocation())));
+
+            if (bestBarrier.isPresent()) {
+                Optional<TileObject> tile = TileObjects.search().nameContains("cell tile").nearestToPoint(bestBarrier.get().getWorldLocation());
+                if (tile.isPresent()) {
+                    log.info("Placing power cell at " + tile.get().getWorldLocation() + " nearest to next altar");
+                    //TileObjectInteraction.interact(tile.get(), "Place-cell");
+                    timeout = tickDelay();
+                }
+            }
+        }
+    }
+
+    private List<Widget> getDroppableRunes() {
+        List<Widget> runesToDrop = new ArrayList<>();
+        String[] runeFilterConfig = config.dropRunesFilter().split(",");
+        for (String rune : runeFilterConfig) {
+            rune = rune.trim();
+            Inventory.search().matchesWildCardNoCase(rune).first().ifPresent(runesToDrop::add);
+        }
+        return runesToDrop;
+    }
+
+    private void dropRunes() {
+        if (!config.dropRunes() && config.dropRunesFilter().isEmpty()) {
+            return;
+        }
+
+        if (config.dropRunes()) {
+            Optional<Widget> itemWidget = InventoryUtil.nameContainsNoCase("rune").filter(item -> !item.getName().contains("pickaxe")).first();
+            if (itemWidget.isEmpty()) {
+                return;
+            }
+
+            Widget item = itemWidget.get();
+            //InventoryInteraction.useItem(item, "Drop");
+        } else {
+            for (Widget rune : getDroppableRunes()) {
+                // InventoryInteraction.useItem(rune, "Drop");
+            }
+        }
+    }
+
+    private double getBarrierHealth(NPC barrier) {
+        if (barrier.getHealthScale() == -1) {
+            return 100;
+        }
+
+        return (double) barrier.getHealthRatio() / (double) barrier.getHealthScale() * 100;
+    }
+
+    private void craftRunes() {
+        Optional<TileObject> tileObject = TileObjects.search().withAction(Constants.CRAFT_RUNES).nearestToPlayer();
+        if (tileObject.isEmpty()) {
+            return;
+        }
+        if (pouchManager.getEssenceInPouches() > 0 && Inventory.getEmptySlots() > 0) {
+            pouchManager.emptyPouches();
+            TileObject altar = tileObject.get();
+            //TileObjectInteraction.interact(altar, Constants.CRAFT_RUNES);
+            timeout = tickDelay();
+            return;
+        }
+        if (Inventory.getItemAmount(ItemID.GUARDIAN_ESSENCE) > 0) {
+            TileObject altar = tileObject.get();
+            //TileObjectInteraction.interact(altar, Constants.CRAFT_RUNES);
+            timeout = tickDelay();
+        }
+    }
+
+    private TileObject lastAltar = null;
+
+    private void enterRift() {
+        TileObject nextAltar = riftState.getNextAltar();
+        if (nextAltar == null) {
+            return;
+        }
+        //This allows us to redirect to a new altar if the state switches
+        if (nextAltar == lastAltar && BaseApiPlugin.isMoving()) {
+            return;
+        }
+
+        lastAltar = nextAltar;
+        //TileObjectInteraction.interact(nextAltar, "Enter");
+        timeout = tickDelay();
+    }
+
+    public static TileObjectQuery nameContainsNoCase(String name) {
+        return TileObjects.search().filter(tileObject -> {
+            ObjectComposition comp = TileObjectQuery.getObjectComposition(tileObject);
+            if (comp == null)
+                return false;
+            return comp.getName().toLowerCase().contains(name.toLowerCase());
+        });
+    }
+
+    private boolean hasDegradePrevention() {
+        return Equipment.search().withId(ItemID.ABYSSAL_LANTERN_REDWOOD_LOGS).first().isPresent() || Equipment.search().withId(ItemID.RUNECRAFT_CAPE).first().isPresent() || Equipment.search().withId(ItemID.RUNECRAFT_CAPET).first().isPresent();
+    }
+
+    private int getFragmentCount() {
+        Optional<Widget> frags = Inventory.search().withId(ItemID.GUARDIAN_FRAGMENTS).first();
+        return frags.map(Widget::getItemQuantity).orElse(0);
+    }
+}

src/main/java/ee/futur/gotr/AutoRiftsState.java

@@ -0,0 +1,25 @@
+package ee.futur.gotr;
+
+public enum AutoRiftsState {
+    GET_CELLS,
+    MOVE_TO_EAST_MINE,
+    WAITING_FOR_GAME,
+    ENTER_PORTAL,
+    MINE_HUGE_GUARDIANS,
+    MINE_LARGE_GUARDIANS,
+    MINE_REGULAR_GUARDIANS,
+    REPAIR_POUCH,
+    CRAFTING_ESSENCE,
+    CRAFT_ESSENCE,
+    DEPOSIT_RUNES,
+    CRAFT_RUNES,
+    LEAVE_EAST_MINE,
+    LEAVE_ALTAR,
+    POWER_GUARDIAN,
+    USE_CELL,
+    ENTER_ALTAR,
+    MINING,
+    ENTER_GAME,
+    GAME_BUSY,
+    BREAK
+}

src/main/java/ee/futur/gotr/GOTRState.java

@@ -0,0 +1,442 @@
+package ee.futur.gotr;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.inject.Inject;
+import ee.futur.baseapi.collections.Inventory;
+import ee.futur.baseapi.collections.TileObjects;
+import ee.futur.baseapi.collections.Widgets;
+import ee.futur.gotr.data.Constants;
+import ee.futur.gotr.data.Utility;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import net.runelite.api.*;
+import net.runelite.api.events.ChatMessage;
+import net.runelite.api.events.GameTick;
+import net.runelite.api.widgets.Widget;
+import net.runelite.client.eventbus.EventBus;
+import net.runelite.client.eventbus.Subscribe;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+@Slf4j
+public class GOTRState {
+    public static final int AIR_ALTAR = 43701;
+    public static final int WATER_ALTAR = 43702;
+    public static final int EARTH_ALTAR = 43703;
+    public static final int FIRE_ALTAR = 43704;
+    public static final int MIND_ALTAR = 43705;
+    public static final int CHAOS_ALTAR = 43706;
+    public static final int DEATH_ALTAR = 43707;
+    public static final int BLOOD_ALTAR = 43708;
+    public static final int BODY_ALTAR = 43709;
+    public static final int COSMIC_ALTAR = 43710;
+    public static final int NATURE_ALTAR = 43711;
+    public static final int LAW_ALTAR = 43712;
+    @Getter
+    private int elementalPoints = -1;
+    @Getter
+    private int catalyticPoints = -1;
+    @Getter
+    private boolean gameStarted;
+    @Setter
+    private boolean started;
+    public boolean hasFirstPortalSpawned = false;
+    @Inject
+    private Client client;
+    private final EventBus eventBus;
+    private final AutoRiftsConfig config;
+    private static final String CHECK_POINT_REGEX = "You have (\\d+) catalytic energy and (\\d+) elemental energy";
+    private static final Pattern CHECK_POINT_PATTERN = Pattern.compile(CHECK_POINT_REGEX);
+    private static final String REWARD_POINT_REGEX = "Total elemental energy:[^>]+>([\\d,]+).*Total catalytic energy:[^>]+>([\\d,]+).";
+    private static final Pattern REWARD_POINT_PATTERN = Pattern.compile(REWARD_POINT_REGEX);
+    private static final Pattern PERCENT_PATTERN = Pattern.compile("(\\d+)%");
+    private Set<Integer> accessibleAltars = new HashSet<>();
+    private static final Set<Integer> GOTR_REGIONS = ImmutableSet.of(14483, 14484);
+    private static final int PORTAL_WIDGET_ID = 48889884;
+    int timeout = 0;
+    int gameEndTimeout = 10;
+    public boolean isGameEnding = false;
+
+    @Inject
+    public GOTRState(EventBus eventBus, AutoRiftsConfig config) {
+        eventBus.register(this);
+        this.eventBus = eventBus;
+        this.config = config;
+    }
+
+    public void register() {
+        eventBus.register(this);
+    }
+
+    public void deregister() {
+        eventBus.unregister(this);
+    }
+
+    @Subscribe
+    private void onGameTick(GameTick event) {
+        if (client.getGameState() != GameState.LOGGED_IN || !started) {
+            return;
+        }
+
+        if (timeout > 0) {
+            timeout--;
+            return;
+        }
+
+        if (this.accessibleAltars.isEmpty()) {
+            this.accessibleAltars = Utility.getAccessibleAltars(client.getRealSkillLevel(Skill.RUNECRAFT),
+                    Quest.LOST_CITY.getState(client), Quest.TROLL_STRONGHOLD.getState(client),
+                    Quest.MOURNINGS_END_PART_II.getState(client), Quest.SINS_OF_THE_FATHER.getState(client));
+        }
+
+        Optional<Widget> frags = Inventory.search().withId(ItemID.GUARDIAN_FRAGMENTS).first();
+
+        if (!hasFirstPortalSpawned && (isPortalSpawned() || getPower() > 15 || (frags.isPresent() && frags.get().getItemQuantity() >= 250))) {
+            hasFirstPortalSpawned = true;
+        }
+
+        if (!gameStarted && isWidgetVisible()) {
+            gameStarted = true;
+        }
+
+        if (!isInAltar() && !isWidgetVisible()) {
+            gameEndTimeout--;
+            if (gameEndTimeout == 0) {
+                log.info("Setting game to ended");
+                gameStarted = false;
+                isGameEnding = false;
+                hasFirstPortalSpawned = false;
+            }
+        } else {
+            gameEndTimeout = 10;
+        }
+    }
+
+    private int getPower() {
+        Optional<Widget> pWidget = Widgets.search().withId(48889874).first();
+        if (pWidget.isEmpty()) {
+            return 0;
+        }
+
+        Matcher matcher = PERCENT_PATTERN.matcher(pWidget.get().getText());
+        if (matcher.find()) {
+            return Integer.parseInt(matcher.group(1));
+        } else {
+            return 0;
+        }
+    }
+
+    @Subscribe
+    private void onChatMessage(ChatMessage event) {
+        if (client.getGameState() != GameState.LOGGED_IN || !started) {
+            return;
+        }
+
+        if (event.getType() != ChatMessageType.SPAM && event.getType() != ChatMessageType.GAMEMESSAGE && event.getType() != ChatMessageType.MESBOX) {
+            return;
+        }
+
+        if (client.getGameState() != GameState.LOGGED_IN) {
+            return;
+        }
+
+        if (event.getMessage().contains(ee.futur.gotr.data.Constants.GAME_STARTED)) {
+            gameStarted = true;
+        }
+
+        if (event.getType() == ChatMessageType.MESBOX) {
+            Matcher checkPointMatcher = CHECK_POINT_PATTERN.matcher(event.getMessage());
+            if (checkPointMatcher.find()) {
+                catalyticPoints = Integer.parseInt(checkPointMatcher.group(1));
+                elementalPoints = Integer.parseInt(checkPointMatcher.group(2));
+            }
+        }
+
+        if (event.getMessage().contains("successfully closed the rift")) {
+            gameStarted = false;
+            hasFirstPortalSpawned = false;
+            isGameEnding = false;
+        }
+
+        if (event.getMessage().contains("Guardian was defeated")) {
+            gameStarted = false;
+            hasFirstPortalSpawned = false;
+            isGameEnding = false;
+        }
+
+        if (event.getMessage().contains("is fully charged")) {
+            isGameEnding = true;
+        }
+
+        Matcher rewardPointMatcher = REWARD_POINT_PATTERN.matcher(event.getMessage());
+        if (rewardPointMatcher.find()) {
+            elementalPoints = Integer.parseInt(rewardPointMatcher.group(1).replaceAll(",", ""));
+            catalyticPoints = Integer.parseInt(rewardPointMatcher.group(2).replaceAll(",", ""));
+        }
+    }
+
+    private boolean isWidgetVisible() {
+        Optional<Widget> widget = Widgets.search().withId(ee.futur.gotr.data.Constants.PARENT_WIDGET).first();
+        return widget.isPresent() && !widget.get().isHidden();
+    }
+
+
+    public boolean isInAltar() {
+        for (int region : client.getMapRegions()) {
+            if (GOTR_REGIONS.contains(region)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean isOutsideBarrier() {
+        return client.getLocalPlayer().getWorldLocation().getY() <= ee.futur.gotr.data.Constants.OUTSIDE_BARRIER_Y && !isInAltar();
+    }
+
+    public boolean isInLargeMine() {
+        return !isInAltar() && client.getLocalPlayer().getWorldLocation().getX() >= ee.futur.gotr.data.Constants.LARGE_MINE_X;
+    }
+
+    public boolean isInHugeMine() {
+        return !isInAltar() && client.getLocalPlayer().getWorldLocation().getX() <= ee.futur.gotr.data.Constants.HUGE_MINE_X;
+    }
+
+    public boolean isGameBusy() {
+        return !isInAltar() && isOutsideBarrier() && TileObjects.search().withId(Constants.BARRIER_BUSY_ID).nearestToPlayer().isPresent();
+    }
+
+    public boolean isPortalSpawned() {
+        Widget portalWidget = client.getWidget(PORTAL_WIDGET_ID);
+        return portalWidget != null && !portalWidget.isHidden();
+    }
+
+    public TileObject getNextAltar() {
+        int catalytic;
+        int elemental;
+        TileObject catalyticAltar = null;
+        TileObject elementalAltar = null;
+        List<TileObject> guardians = TileObjects.search().nameContains("Guardian of").result();
+        for (TileObject guardian : guardians) {
+            GameObject gameObject = (GameObject) guardian;
+            Animation animation = ((DynamicObject) gameObject.getRenderable()).getAnimation();
+            //Active guardians
+            if (animation.getId() == 9363) {
+                if (isCatalytic(guardian)) {
+                    if (accessibleAltars.contains(guardian.getId()) && isAltarBetter(catalyticAltar, guardian)) {
+                        catalyticAltar = guardian;
+                    }
+                } else if (isAltarBetter(elementalAltar, guardian)) {
+                    elementalAltar = guardian;
+                }
+            } else {
+                if (!hasTalisman(guardian)) {
+                    continue;
+                }
+
+                if (isCatalytic(guardian)) {
+                    if (accessibleAltars.contains(guardian.getId()) && isAltarBetter(catalyticAltar, guardian)) {
+                        catalyticAltar = guardian;
+                    }
+                } else {
+                    if (isAltarBetter(elementalAltar, guardian)) {
+                        elementalAltar = guardian;
+                    }
+                }
+            }
+        }
+
+        if (catalyticPoints < 0 && elementalPoints < 0) {
+            elemental = client.getVarbitValue(13686);
+            catalytic = client.getVarbitValue(13685);
+        } else {
+            elemental = elementalPoints;
+            catalytic = catalyticPoints;
+            elemental += (int) Math.floor((double) client.getVarbitValue(13686) / 100);
+            catalytic += (int) Math.floor((double) client.getVarbitValue(13685) / 100);
+        }
+
+        //log.info("Catalytic: " + catalytic + " Elemental: " + elemental);
+
+        if (catalytic == 0 && elemental == 0) {
+            elemental = 1;
+        }
+
+        Widget catalyticWidget = client.getWidget(48889879);
+        Widget elementalWidget = client.getWidget(48889876);
+
+        if (elementalWidget == null || catalyticWidget == null) {
+            return null;
+        }
+
+        if (catalyticAltar == null) {
+            return elementalAltar;
+        }
+
+        if (elementalAltar == null) {
+            return catalyticAltar;
+        }
+
+        if (config.prioritizeBloodDeath() && isBloodDeath(catalyticAltar)) {
+            return catalyticAltar;
+        }
+
+        if (isAltarIgnored(catalyticAltar)) {
+            if (isAltarIgnored(elementalAltar)) {
+                if (catalytic > elemental) {
+                    return elementalAltar;
+                } else {
+                    return catalyticAltar;
+                }
+            }
+
+            return elementalAltar;
+        }
+
+        if (isAltarIgnored(elementalAltar)) {
+            return catalyticAltar;
+        }
+
+        if (catalytic > elemental) {
+            return elementalAltar;
+        }
+
+        return catalyticAltar;
+    }
+
+    private boolean isBloodDeath(TileObject altar) {
+        switch (altar.getId()) {
+            case BLOOD_ALTAR:
+            case DEATH_ALTAR:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    private boolean isAltarBetter(TileObject oldAltar, TileObject candidate) {
+        if (oldAltar == null) {
+            return true;
+        }
+
+        if (getAltarPriority(oldAltar) < getAltarPriority(candidate)) {
+            return true;
+        }
+
+        if (getAltarPriority(oldAltar) == getAltarPriority(candidate) && hasTalisman(candidate)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    private boolean isAltarIgnored(TileObject altar) {
+        switch (altar.getId()) {
+            case AIR_ALTAR:
+                return config.ignoreAir();
+            case MIND_ALTAR:
+                return config.ignoreMind();
+            case BODY_ALTAR:
+                return config.ignoreBody();
+            case WATER_ALTAR:
+                return config.ignoreWater();
+            case COSMIC_ALTAR:
+                return config.ignoreCosmic();
+            case CHAOS_ALTAR:
+                return config.ignoreChaos();
+            case EARTH_ALTAR:
+                return config.ignoreEarth();
+            case NATURE_ALTAR:
+                return config.ignoreNature();
+            case LAW_ALTAR:
+                return config.ignoreLaw();
+            case FIRE_ALTAR:
+                return config.ignoreFire();
+            case DEATH_ALTAR:
+                return config.ignoreDeath();
+            case BLOOD_ALTAR:
+                return config.ignoreBlood();
+        }
+
+        return false;
+    }
+
+    private int getAltarPriority(TileObject altar) {
+        switch (altar.getId()) {
+            case AIR_ALTAR:
+            case MIND_ALTAR:
+            case BODY_ALTAR:
+                return 1;
+            case WATER_ALTAR:
+            case COSMIC_ALTAR:
+            case CHAOS_ALTAR:
+                return 2;
+            case EARTH_ALTAR:
+            case NATURE_ALTAR:
+            case LAW_ALTAR:
+                return 3;
+            case FIRE_ALTAR:
+            case DEATH_ALTAR:
+                return 4;
+            case BLOOD_ALTAR:
+                return 5;
+        }
+
+        return -1;
+    }
+
+    private boolean hasTalisman(TileObject altar) {
+        int talismanID = 0;
+        switch (altar.getId()) {
+            case AIR_ALTAR:
+                talismanID = ItemID.PORTAL_TALISMAN_AIR;
+                break;
+            case WATER_ALTAR:
+                talismanID = ItemID.PORTAL_TALISMAN_WATER;
+                break;
+            case EARTH_ALTAR:
+                talismanID = ItemID.PORTAL_TALISMAN_EARTH;
+                break;
+            case FIRE_ALTAR:
+                talismanID = ItemID.PORTAL_TALISMAN_FIRE;
+                break;
+            case MIND_ALTAR:
+                talismanID = ItemID.PORTAL_TALISMAN_MIND;
+                break;
+            case CHAOS_ALTAR:
+                talismanID = ItemID.PORTAL_TALISMAN_CHAOS;
+                break;
+            case DEATH_ALTAR:
+                talismanID = ItemID.PORTAL_TALISMAN_DEATH;
+                break;
+            case BLOOD_ALTAR:
+                talismanID = ItemID.PORTAL_TALISMAN_BLOOD;
+                break;
+            case BODY_ALTAR:
+                talismanID = ItemID.PORTAL_TALISMAN_BODY;
+                break;
+            case COSMIC_ALTAR:
+                talismanID = ItemID.PORTAL_TALISMAN_COSMIC;
+                break;
+            case NATURE_ALTAR:
+                talismanID = ItemID.PORTAL_TALISMAN_NATURE;
+                break;
+            case LAW_ALTAR:
+                talismanID = ItemID.PORTAL_TALISMAN_LAW;
+                break;
+        }
+
+        return Inventory.getItemAmount(talismanID) > 0;
+    }
+
+    private boolean isCatalytic(TileObject altar) {
+        Set<Integer> catalyticAltars = Set.of(43705, 43709, 43706, 43710, 43711, 43708, 43712, 43707);
+        return catalyticAltars.contains(altar.getId());
+    }
+}

src/main/java/ee/futur/gotr/PouchManager.java

@@ -0,0 +1,214 @@
+package ee.futur.gotr;
+
+import com.google.common.collect.ImmutableList;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import ee.futur.baseapi.collections.Inventory;
+import ee.futur.gotr.data.Constants;
+import ee.futur.gotr.data.Pouch;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import net.runelite.api.*;
+import net.runelite.api.events.ChatMessage;
+import net.runelite.api.widgets.Widget;
+import net.runelite.client.eventbus.EventBus;
+import net.runelite.client.eventbus.Subscribe;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+@Slf4j
+@Singleton
+public class PouchManager {
+    private final List<Pouch> pouches = new ArrayList<>();
+    @Inject
+    private Client client;
+    private final EventBus eventBus;
+    @Setter
+    private boolean started;
+    private final List<Integer> DEGRADED_POUCH_IDS = ImmutableList.of(ItemID.MEDIUM_POUCH_5511, ItemID.LARGE_POUCH_5513, ItemID.GIANT_POUCH_5515,
+            ItemID.COLOSSAL_POUCH_26786);
+
+    @Inject
+    public PouchManager(EventBus eventBus) {
+        this.eventBus = eventBus;
+    }
+
+    public void register() {
+        eventBus.register(this);
+    }
+
+    public void deregister() {
+        eventBus.unregister(this);
+    }
+
+    public void refreshPouches() {
+        //pouches.clear();
+        Optional<Widget> smallpouch = Inventory.search().withId(ItemID.SMALL_POUCH).first();
+        Optional<Widget> medpouch = Inventory.search().withId(ItemID.MEDIUM_POUCH).first();
+        Optional<Widget> largepouch = Inventory.search().withId(ItemID.LARGE_POUCH).first();
+        Optional<Widget> giantpouch = Inventory.search().withId(ItemID.GIANT_POUCH).first();
+        Optional<Widget> collosalpouch = Inventory.search().withId(ItemID.COLOSSAL_POUCH).first();
+        if (smallpouch.isPresent()) {
+            Pouch smallEssPouch = new Pouch(ItemID.SMALL_POUCH, 3);
+            pouches.removeIf(p -> p.getPouchID() == ItemID.SMALL_POUCH);
+            pouches.add(smallEssPouch);
+        }
+
+        if (medpouch.isPresent() && client.getRealSkillLevel(Skill.RUNECRAFT) >= 25) {
+            Pouch medEssPouch = new Pouch(ItemID.MEDIUM_POUCH, 6);
+            pouches.removeIf(p -> p.getPouchID() == ItemID.MEDIUM_POUCH);
+            pouches.add(medEssPouch);
+        }
+
+        if (largepouch.isPresent() && client.getRealSkillLevel(Skill.RUNECRAFT) >= 50) {
+            Pouch largeEssPouch = new Pouch(ItemID.LARGE_POUCH, 9);
+            pouches.removeIf(p -> p.getPouchID() == ItemID.LARGE_POUCH);
+            pouches.add(largeEssPouch);
+        }
+
+        if (giantpouch.isPresent() && client.getRealSkillLevel(Skill.RUNECRAFT) >= 75) {
+            Pouch giantEssPouch = new Pouch(ItemID.GIANT_POUCH, 12);
+            pouches.removeIf(p -> p.getPouchID() == ItemID.GIANT_POUCH);
+            pouches.add(giantEssPouch);
+        }
+
+        if (collosalpouch.isPresent() && client.getRealSkillLevel(Skill.RUNECRAFT) >= 85) {
+            Pouch colossalEssPouch = new Pouch(ItemID.COLOSSAL_POUCH, 40);
+            pouches.removeIf(p -> p.getPouchID() == ItemID.COLOSSAL_POUCH);
+            pouches.add(colossalEssPouch);
+        }
+
+        log.info("Setting Pouches: " + pouches);
+    }
+
+
+    @Subscribe
+    private void onChatMessage(ChatMessage event) {
+        //log.info(pouches.toString());
+        if (client.getGameState() != GameState.LOGGED_IN || !started) {
+            return;
+        }
+
+        if (event.getType() != ChatMessageType.SPAM && event.getType() != ChatMessageType.GAMEMESSAGE) return;
+
+        if (client.getGameState() != GameState.LOGGED_IN) {
+            return;
+        }
+
+        if (event.getMessage().contains(ee.futur.gotr.data.Constants.GAME_STARTED)) {
+            setEssenceInPouches(0);
+        }
+
+        if (event.getMessage().contains(ee.futur.gotr.data.Constants.GAME_WIN)) {
+            setEssenceInPouches(0);
+        }
+
+        if (event.getMessage().contains(Constants.GAME_OVER)) {
+            setEssenceInPouches(0);
+        }
+    }
+
+    public List<Pouch> getFullPouches() {
+        List<Pouch> result = new ArrayList<>();
+        for (Pouch pouch : pouches) {
+            if (pouch.getCurrentEssence() > 0) {
+                result.add(pouch);
+            }
+        }
+        return result;
+    }
+
+    public boolean hasFullPouch() {
+        for (Pouch pouch : pouches) {
+            if (pouch.getCurrentEssence() > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void fillPouches() {
+        int essenceAmount = Inventory.getItemAmount(ItemID.GUARDIAN_ESSENCE);
+        List<Pouch> result = getEmptyPouches();
+        for (Pouch pouch : result) {
+            Optional<Widget> emptyPouch = Inventory.search().withId(pouch.getPouchID()).first();
+            if (emptyPouch.isPresent()) {
+                Widget p = emptyPouch.get();
+                //InventoryInteraction.useItem(p, "Fill");
+                int essenceWithdrawn = pouch.getEssenceTotal() - pouch.getCurrentEssence();
+                if (essenceAmount - essenceWithdrawn >= 0) {
+                    essenceAmount -= essenceWithdrawn;
+                    pouch.setCurrentEssence(pouch.getEssenceTotal());
+                } else {
+                    pouch.setCurrentEssence(pouch.getCurrentEssence() + essenceAmount);
+                    essenceAmount = 0;
+                }
+                if (essenceAmount == 0) {
+
+                    break;
+                }
+            }
+        }
+    }
+
+    public void emptyPouches() {
+        int spaces = Inventory.getEmptySlots();
+        List<Pouch> result = getFullPouches();
+        for (Pouch pouch : result) {
+            Optional<Widget> emptyPouch = Inventory.search().withId(pouch.getPouchID()).first();
+            if (emptyPouch.isPresent()) {
+                //InventoryInteraction.useItem(emptyPouch.get(), "Empty");
+                if (pouch.getCurrentEssence() - spaces < 0) {
+                    spaces -= pouch.getCurrentEssence();
+                    pouch.setCurrentEssence(0);
+                } else {
+                    pouch.setCurrentEssence(pouch.getCurrentEssence() - spaces);
+                    break;
+                }
+            }
+        }
+    }
+
+    public List<Pouch> getEmptyPouches() {
+        List<Pouch> result = new ArrayList<>();
+        for (Pouch pouch : pouches) {
+            if (!isPouchFull(pouch)) {
+                result.add(pouch);
+            }
+        }
+        return result;
+    }
+
+    public boolean hasEmptyPouches() {
+        for (Pouch pouch : pouches) {
+            if (!isPouchFull(pouch)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isPouchFull(Pouch pouch) {
+        return pouch.getCurrentEssence() == pouch.getEssenceTotal();
+    }
+
+    private void setEssenceInPouches(int amount) {
+        for (Pouch curr : pouches) {
+            curr.setCurrentEssence(amount);
+        }
+    }
+
+    public boolean hasDegradedPouches() {
+        return Inventory.search().idInList(DEGRADED_POUCH_IDS).first().isPresent();
+    }
+
+    public int getAvailableSpace() {
+        return pouches.stream().mapToInt(pouch -> pouch.getEssenceTotal() - pouch.getCurrentEssence()).sum();
+    }
+
+    public int getEssenceInPouches() {
+        return pouches.stream().mapToInt(Pouch::getCurrentEssence).sum();
+    }
+}

src/main/java/ee/futur/gotr/README.md

@@ -0,0 +1,32 @@
+AutoRifts 
+
+Automation plugins for runelite
+
+# Discord
+https://discord.gg/kwYBYEg4uu
+
+# [PP]AutoRifts
+
+**How to setup**:
+
+- Starting Fragments
+  - How many fragments to mine before leaving the starting area
+- Minimum Fragments
+  - Amount in inventory to start mining more fragments
+- Ignore Portal Ess
+  - Ignores the portal if you have at least this many essence in inventory
+- Drop Runes
+  - Check to drop all runes instead of depositing
+- Drop Runes Filter
+  - Comma delimited, rune names to drop - the rest will be deposited
+- Use Essence Pouches?
+  - Requires NPC Contact runes or redwood lit lantern
+- Abyssal Book in bank? (IMPORTANT FOR NPC CONTACT)
+  - Check if you have the abyssal book in the bank
+  - This is required because owning the abyssal book changes the dialogue option
+- Prioritize Catalytic Energy
+  - Will try to balance points if not checked
+- Prioritize Higher Tier Runes (BETA)
+  - Prioritizes Nature/Law/Death/Blood runes even if points aren't balanced - Expect some bugs
+- Prioritize Portal (BETA)
+  - Prioritizes the portal, mainly affects when to drop/deposit runes - Expect some bugs

src/main/java/ee/futur/gotr/data/Altar.java

@@ -0,0 +1,45 @@
+package ee.futur.gotr.data;
+
+import lombok.Getter;
+
+@Getter
+public enum Altar {
+    AIR(43701, Constants.AIR_SPRITE),
+    MIND(43705, Constants.MIND_SPRITE),
+    WATER(43702, Constants.WATER_SPRITE),
+    EARTH(43703, Constants.EARTH_SPRITE),
+    FIRE(43704, Constants.FIRE_SPRITE),
+    BODY(43709, Constants.BODY_SPRITE),
+    COSMIC(43710, Constants.COSMIC_SPRITE),
+    CHAOS(43706, Constants.CHAOS_SPRITE),
+    NATURE(43711, Constants.NATURE_SPRITE),
+    LAW(43712, Constants.LAW_SPRITE),
+    DEATH(43707, Constants.DEATH_SPRITE),
+    BLOOD(43708, Constants.BLOOD_SPRITE);
+
+    final int id;
+    final int spriteId;
+
+    Altar(int id, int spriteId) {
+        this.id = id;
+        this.spriteId = spriteId;
+    }
+
+    public static Altar getAltarBySpriteId(int spriteId) {
+        for (Altar altar : Altar.values()) {
+            if (altar.getSpriteId() == spriteId) {
+                return altar;
+            }
+        }
+        return null;
+    }
+
+    public static Altar getAltarByObjectId(int id) {
+        for (Altar altar : Altar.values()) {
+            if (altar.getId() == id) {
+                return altar;
+            }
+        }
+        return null;
+    }
+}

src/main/java/ee/futur/gotr/data/CellMapper.java

@@ -0,0 +1,38 @@
+package ee.futur.gotr.data;
+
+import net.runelite.api.ItemID;
+import net.runelite.api.ObjectID;
+
+public class CellMapper {
+    public static int GetCellTier(int cellID) {
+        switch (cellID) {
+            case ItemID.WEAK_CELL:
+                return 1;
+            case ItemID.MEDIUM_CELL:
+                return 2;
+            case ItemID.STRONG_CELL:
+                return 3;
+            case ItemID.OVERCHARGED_CELL:
+                return 4;
+            default:
+                return -1;
+        }
+    }
+
+    public static int GetShieldTier(int shieldID) {
+        switch (shieldID) {
+            case ObjectID.INACTIVE_CELL_TILE:
+                return 0;
+            case ObjectID.WEAK_CELL_TILE:
+                return 1;
+            case ObjectID.MEDIUM_CELL_TILE:
+                return 2;
+            case ObjectID.STRONG_CELL_TILE:
+                return 3;
+            case ObjectID.OVERPOWERED_CELL_TILE:
+                return 4;
+            default:
+                return -1;
+        }
+    }
+}

src/main/java/ee/futur/gotr/data/Constants.java

@@ -0,0 +1,74 @@
+package ee.futur.gotr.data;
+
+public class Constants {
+    //Locations
+    public static final int OUTSIDE_BARRIER_Y = 9482;
+    public static final int LARGE_MINE_X = 3637;
+    public static final int HUGE_MINE_X = 3592;
+
+    // Game Object IDs
+    public static final int BARRIER_BUSY_ID = 43849;
+    public static final int BARRIER_READY_ID = 43700;
+
+    public static final int ACTIVE_ALTAR = 9363;
+
+    // Widget IDs
+    public static final int PARENT_WIDGET = 48889857;
+    public static final int WIDGET_POWER_PC = 48889874;
+    public static final int MAIN_TIMER = 48889861;
+    public static final int ELEMENTAL_ENERGY_COUNTER = 48889878;
+    public static final int CATALYTIC_ENERGY_COUNTER = 48889878;
+    public static final int GUARDIANS_ALIVE_COUNTER = 48889881;
+    public static final int PORTAL_TIMER = 48889884;
+
+    public static final int WAITING_CATALYTIC_INDICATOR_SPRITE = 4355;
+
+
+    // Widget Text
+    private static final String OUTSIDE_GUARDED = "It looks like the rift is already being guarded. You must wait until they are done to join.";
+    private static final String GREAT_GUARDIAN_POWER = "Great Guardian power: ";
+
+
+    // Chat text
+    public static final String ENTER_ALTAR = "You step through the rift";
+    public static final String EXIT_ALTAR = "You step through the portal and find yourself back in the temple.";
+    public static final String GAME_STARTED = "Creatures from the Abyss will attack in 120 seconds.";
+    public static final String ATTACK_STARTED = "Creatures from the Abyss begin their attack!";
+    public static final String GAME_OVER = "The Great guardian was defeated";
+    public static final String GAME_WIN = "The Great Guardian successfully closed the rift!";
+
+
+    // Game Objects
+    public static final String BARRIER = "Barrier";
+    public static final String WORKBENCH = "Workbench";
+    public static final String WEAK_CELLS = "Weak cell";
+    public static final String UNCHARGED_CELLS = "Uncharged cell";
+    public static final String DEPOSIT_POOL = "Deposit pool";
+    public static final String GAME_PARTS = "Guardian parts";
+    public static final String LARGE_REMAINS = "Large guardian remains";
+    public static final String HUGE_REMAINS = "Huge guardian remains";
+    public static final String FRAGS = "Guardian fragments";
+    public static final String ESS = "Guardian essence";
+    public static final String PORTAL = "Portal";
+    public static final int PORTAL_SPAWN = 43729;
+
+    public static final String CATALYTIC_ENERGY = "Catalytic guardian stone";
+    public static final String ELEMENTAL_ENERGY = "Elemental guardian stone";
+    public static final String GREAT_GUARDIAN = "The Great Guardian";
+
+    public static final String CRAFT_RUNES = "Craft-rune";
+
+    public static final int AIR_SPRITE = 4353;
+    public static final int MIND_SPRITE = 4354;
+    public static final int WATER_SPRITE = 4355;
+    public static final int EARTH_SPRITE = 4356;
+    public static final int FIRE_SPRITE = 4357;
+    public static final int BODY_SPRITE = 4358;
+    public static final int COSMIC_SPRITE = 4359;
+    public static final int CHAOS_SPRITE = 4360;
+    public static final int NATURE_SPRITE = 4361;
+    public static final int LAW_SPRITE = 4362;
+    public static final int DEATH_SPRITE = 4363;
+    public static final int BLOOD_SPRITE = 4364;
+
+}

src/main/java/ee/futur/gotr/data/Pouch.java

@@ -0,0 +1,24 @@
+package ee.futur.gotr.data;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public class Pouch {
+
+    public Pouch(int id, int maxEssence) {
+        this.pouchID = id;
+        this.currentEssence = 0;
+        this.essenceTotal = maxEssence;
+    }
+
+    @Getter
+    @Setter
+    int pouchID;
+
+    @Getter
+    @Setter
+    int currentEssence;
+
+    @Getter
+    int essenceTotal;
+}

src/main/java/ee/futur/gotr/data/Runes.java

@@ -0,0 +1,77 @@
+package ee.futur.gotr.data;
+
+/**
+ * Taken from marcojacobsNL
+ * https://github.com/marcojacobsNL/runelite-plugins/blob/master/src/main/java/com/koffee/KoffeeUtils/Runes.java
+ */
+
+import com.google.common.collect.ImmutableMap;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.awt.image.BufferedImage;
+import java.util.Map;
+
+import static net.runelite.api.ItemID.*;
+
+public enum Runes {
+    AIR(1, AIR_RUNE),
+    WATER(2, WATER_RUNE),
+    EARTH(3, EARTH_RUNE),
+    FIRE(4, FIRE_RUNE),
+    MIND(5, MIND_RUNE),
+    CHAOS(6, CHAOS_RUNE),
+    DEATH(7, DEATH_RUNE),
+    BLOOD(8, BLOOD_RUNE),
+    COSMIC(9, COSMIC_RUNE),
+    NATURE(10, NATURE_RUNE),
+    LAW(11, LAW_RUNE),
+    BODY(12, BODY_RUNE),
+    SOUL(13, SOUL_RUNE),
+    ASTRAL(14, ASTRAL_RUNE),
+    MIST(15, MIST_RUNE),
+    MUD(16, MUD_RUNE),
+    DUST(17, DUST_RUNE),
+    LAVA(18, LAVA_RUNE),
+    STEAM(19, STEAM_RUNE),
+    SMOKE(20, SMOKE_RUNE),
+    WRATH(21, WRATH_RUNE);
+
+    private static final Map<Integer, Runes> runes;
+
+    static {
+        ImmutableMap.Builder<Integer, Runes> builder = new ImmutableMap.Builder<>();
+        for (Runes rune : values()) {
+            builder.put(rune.getId(), rune);
+        }
+        runes = builder.build();
+    }
+
+    @Getter(AccessLevel.PACKAGE)
+    private final int id;
+    @Getter(AccessLevel.PUBLIC)
+    private final int itemId;
+    @Getter(AccessLevel.PACKAGE)
+    @Setter(AccessLevel.PACKAGE)
+    private BufferedImage image;
+
+    Runes(final int id, final int itemId) {
+        this.id = id;
+        this.itemId = itemId;
+    }
+
+    public static Runes getRuneVarbit(int runeID) {
+        return runes.get(runeID);
+    }
+
+    public String getName() {
+        String name = this.name();
+        name = name.substring(0, 1) + name.substring(1).toLowerCase();
+        return name;
+    }
+
+    public static Runes getRune(int varbit) {
+        return runes.get(varbit);
+    }
+}

src/main/java/ee/futur/gotr/data/Utility.java

@@ -0,0 +1,49 @@
+package ee.futur.gotr.data;
+
+import net.runelite.api.QuestState;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Utility {
+
+    public static int getHighestLevelRuneIndex(int level) {
+        if (level < 35) {
+            return 7;
+        } else if (level < 44) {
+            return 8;
+        } else if (level < 54) {
+            return 9;
+        } else if (level < 65) {
+            return 10;
+        } else if (level < 77) {
+            return 11;
+        }
+
+        return 12;
+    }
+
+    public static Set<Integer> getAccessibleAltars(int level, QuestState city, QuestState troll, QuestState mep, QuestState sotf) {
+        Set<Integer> accessibleAltars = new HashSet<>();
+        for (int i = 0; i < getHighestLevelRuneIndex(level); i++) {
+            Altar[] altars = Altar.values();
+            if (altars[i] == Altar.COSMIC && city != QuestState.FINISHED) {
+                continue;
+            }
+            if (altars[i] == Altar.LAW && troll != QuestState.FINISHED) {
+                continue;
+            }
+            if (altars[i] == Altar.DEATH && mep != QuestState.FINISHED) {
+                continue;
+            }
+            if (altars[i] == Altar.BLOOD && sotf != QuestState.FINISHED) {
+                continue;
+            }
+            accessibleAltars.add(altars[i].id);
+        }
+
+        return accessibleAltars;
+    }
+
+
+}

src/main/java/ee/futur/utils/InventoryUtil.java

@@ -0,0 +1,186 @@
+package ee.futur.utils;
+
+
+import ee.futur.baseapi.collections.Inventory;
+import ee.futur.baseapi.collections.query.ItemQuery;
+import ee.futur.baseapi.BaseApiPlugin;
+
+import ee.futur.gotr.data.Runes;
+import net.runelite.api.Varbits;
+import net.runelite.api.widgets.Widget;
+
+import java.util.*;
+
+public class InventoryUtil {
+    public static boolean useItemNoCase(String name, String... actions) {
+        return nameContainsNoCase(name).first().flatMap(item ->
+        {
+            //MousePackets.queueClickPacket();
+            //WidgetPackets.queueWidgetAction(item, actions);
+            return Optional.of(true);
+        }).orElse(false);
+    }
+
+    public static ItemQuery nameContainsNoCase(String name) {
+        return Inventory.search().filter(widget -> widget.getName().toLowerCase().contains(name.toLowerCase()));
+    }
+
+    public static Optional<Widget> getById(int id) {
+        return Inventory.search().withId(id).first();
+    }
+
+    public static Optional<Widget> getItemNameContains(String name, boolean caseSensitive) {
+        if (caseSensitive) {
+            return Inventory.search().filter(widget -> widget.getName().contains(name)).first();
+        } else {
+            return Inventory.search().filter(widget -> widget.getName().toLowerCase().contains(name.toLowerCase())).first();
+        }
+    }
+
+    public static Optional<Widget> getItemNameContains(String name) {
+        return getItemNameContains(name, true);
+    }
+
+    public static Optional<Widget> getItem(String name, boolean caseSensitive) {
+        if (caseSensitive) {
+            return Inventory.search().filter(widget -> widget.getName().equals(name)).first();
+        } else {
+            return Inventory.search().filter(widget -> widget.getName().toLowerCase().equals(name.toLowerCase())).first();
+        }
+    }
+
+    public static Optional<Widget> getItem(String name) {
+        return getItem(name, true);
+    }
+
+    public static int getItemAmount(String name, boolean stacked) {
+        if (stacked) {
+            return nameContainsNoCase(name).first().isPresent() ? nameContainsNoCase(name).first().get().getItemQuantity() : 0;
+        }
+
+        return nameContainsNoCase(name).result().size();
+    }
+
+    public static int getItemAmount(int id) {
+        return getItemAmount(id, false);
+    }
+
+    public static int getItemAmount(int id, boolean stacked) {
+        if (stacked) {
+            return getById(id).isPresent() ? getById(id).get().getItemQuantity() : 0;
+        }
+
+        return Inventory.search().withId(id).result().size();
+    }
+
+    public static boolean hasItem(String name) {
+        return getItemAmount(name, false) > 0;
+    }
+
+    public static boolean hasItem(String name, boolean stacked) {
+        return getItemAmount(name, stacked) > 0;
+    }
+
+    public static boolean hasItem(String name, int amount) {
+        return getItemAmount(name, false) >= amount;
+    }
+
+    public static boolean hasItem(String name, int amount, boolean stacked) {
+        return getItemAmount(name, stacked) >= amount;
+    }
+
+    public static boolean hasItems(String ...names) {
+        for (String name : names) {
+            if (!hasItem(name)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public static boolean hasAnyItems(String ...names) {
+        for (String name : names) {
+            if (hasItem(name)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+    public static boolean hasAnyItems(Collection<Integer> itemIds) {
+        for (Integer id : itemIds) {
+            if (hasItem(id)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean hasItem(int id) {
+        return getItemAmount(id) > 0;
+    }
+
+    public static List<Widget> getItems() {
+        return Inventory.search().result();
+    }
+
+    public static int emptySlots() {
+        return 28 - Inventory.search().result().size();
+    }
+
+    //Credit to marcojacobsNL
+    public static boolean runePouchContains(int id) {
+        Set<Integer> runePouchIds = new HashSet<>();
+        if (BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE1) != 0) {
+            runePouchIds.add(Runes.getRune(BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE1)).getItemId());
+        }
+        if (BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE2) != 0) {
+            runePouchIds.add(Runes.getRune(BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE2)).getItemId());
+        }
+        if (BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE3) != 0) {
+            runePouchIds.add(Runes.getRune(BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE3)).getItemId());
+        }
+        if (BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE4) != 0) {
+            runePouchIds.add(Runes.getRune(BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE4)).getItemId());
+        }
+        for (int runePouchId : runePouchIds) {
+            if (runePouchId == id) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    //Credit to marcojacobsNL
+    public static boolean runePouchContains(Collection<Integer> ids) {
+        for (int runeId : ids) {
+            if (!runePouchContains(runeId)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    //Credit to marcojacobsNL
+    public static int runePouchQuanitity(int id) {
+        Map<Integer, Integer> runePouchSlots = new HashMap<>();
+        if (BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE1) != 0) {
+            runePouchSlots.put(Runes.getRune(BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE1)).getItemId(), BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_AMOUNT1));
+        }
+        if (BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE2) != 0) {
+            runePouchSlots.put(Runes.getRune(BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE2)).getItemId(), BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_AMOUNT2));
+        }
+        if (BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE3) != 0) {
+            runePouchSlots.put(Runes.getRune(BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE3)).getItemId(), BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_AMOUNT3));
+        }
+        if (BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE4) != 0) {
+            runePouchSlots.put(Runes.getRune(BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_RUNE4)).getItemId(), BaseApiPlugin.getClient().getVarbitValue(Varbits.RUNE_POUCH_AMOUNT4));
+        }
+        if (runePouchSlots.containsKey(id)) {
+            return runePouchSlots.get(id);
+        }
+        return 0;
+    }
+
+}

src/main/java/ee/futur/utils/ObfuscatedNames.java

@@ -0,0 +1,523 @@
+package ee.futur.utils;
+
+public final class ObfuscatedNames {
+
+//    public static final String EVENT_MOUSE_CLICK_OBFUSCATEDNAME = "cv";
+//    public static final String EVENT_MOUSE_CLICK_WRITE1 = "mouseInfo";
+//    public static final String EVENT_MOUSE_CLICK_METHOD_NAME1 = "xg";
+//    public static final String EVENT_MOUSE_CLICK_WRITE2 = "mouseY";
+//    public static final String EVENT_MOUSE_CLICK_METHOD_NAME2 = "xg";
+//    public static final String EVENT_MOUSE_CLICK_WRITE3 = "mouseX";
+//    public static final String EVENT_MOUSE_CLICK_METHOD_NAME3 = "xg";
+//    public static final String[][] EVENT_MOUSE_CLICK_WRITES = new String[][] {
+//            {"r 8", "v"},
+//            {"r 8", "v"},
+//            {"r 8", "v"}
+//    };
+
+    // when officially live we switch to MOUSE_V2 packet
+    public static final String EVENT_MOUSE_CLICK_OBFUSCATEDNAME = "ch";
+    public static final String EVENT_MOUSE_CLICK_WRITE1 = "mouseX";
+    public static final String EVENT_MOUSE_CLICK_METHOD_NAME1 = "dy";
+    public static final String EVENT_MOUSE_CLICK_WRITE2 = "mouseInfo";
+    public static final String EVENT_MOUSE_CLICK_METHOD_NAME2 = "kl";
+    public static final String EVENT_MOUSE_CLICK_WRITE3 = "0";
+    public static final String EVENT_MOUSE_CLICK_METHOD_NAME3 = "bg";
+    public static final String EVENT_MOUSE_CLICK_WRITE4 = "mouseY";
+    public static final String EVENT_MOUSE_CLICK_METHOD_NAME4 = "kl";
+    public static final String[][] EVENT_MOUSE_CLICK_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"a 128", "r 8"},
+            {"v"},
+            {"a 128", "r 8"},
+    };
+
+    public static final String IF_BUTTONT_OBFUSCATEDNAME = "cn";
+    public static final String IF_BUTTONT_WRITE1 = "destinationItemId";
+    public static final String IF_BUTTONT_METHOD_NAME1 = "kl";
+    public static final String IF_BUTTONT_WRITE2 = "destinationWidgetId";
+    public static final String IF_BUTTONT_METHOD_NAME2 = "eg";
+    public static final String IF_BUTTONT_WRITE3 = "sourceItemId";
+    public static final String IF_BUTTONT_METHOD_NAME3 = "mp";
+    public static final String IF_BUTTONT_WRITE4 = "destinationSlot";
+    public static final String IF_BUTTONT_METHOD_NAME4 = "kl";
+    public static final String IF_BUTTONT_WRITE5 = "sourceWidgetId";
+    public static final String IF_BUTTONT_METHOD_NAME5 = "eg";
+    public static final String IF_BUTTONT_WRITE6 = "sourceSlot";
+    public static final String IF_BUTTONT_METHOD_NAME6 = "mp";
+    public static final String[][] IF_BUTTONT_WRITES = new String[][]{
+            {"a 128", "r 8"},
+            {"r 8", "v", "r 24", "r 16"},
+            {"r 8", "a 128"},
+            {"a 128", "r 8"},
+            {"r 8", "v", "r 24", "r 16"},
+            {"r 8", "a 128"},
+    };
+
+    public static final String IF_BUTTONX_OBFUSCATEDNAME = "al";
+    public static final String IF_BUTTONX_WRITE1 = "widgetId";
+    public static final String IF_BUTTONX_METHOD_NAME_1 = "bu";
+    public static final String IF_BUTTONX_WRITE2 = "slot";
+    public static final String IF_BUTTONX_METHOD_NAME_2 = "bt";
+    public static final String IF_BUTTONX_WRITE3 = "itemId";
+    public static final String IF_BUTTONX_METHOD_NAME_3 = "bt";
+    public static final String IF_BUTTONX_WRITE4 = "opCode";
+    public static final String IF_BUTTONX_METHOD_NAME_4 = "bg";
+    public static final String[][] IF_BUTTONX_WRITES = {
+            {"r 24", "r 16", "r 8", "v"},
+            {"r 8", "v"},
+            {"r 8", "v"},
+            {"v"},
+    };
+
+    public static final String IF_SUBOP_OBFUSCATEDNAME = "dj";
+    public static final String IF_SUBOP_WRITE1 = "widgetId";
+    public static final String IF_SUBOP_METHOD_NAME1 = "bu";
+    public static final String IF_SUBOP_WRITE2 = "slot";
+    public static final String IF_SUBOP_METHOD_NAME2 = "bt";
+    public static final String IF_SUBOP_WRITE3 = "itemId";
+    public static final String IF_SUBOP_METHOD_NAME3 = "bt";
+    public static final String IF_SUBOP_WRITE4 = "menuIndex";
+    public static final String IF_SUBOP_METHOD_NAME4 = "bg";
+    public static final String IF_SUBOP_WRITE5 = "subActionIndex";
+    public static final String IF_SUBOP_METHOD_NAME5 = "bg";
+    public static final String[][] IF_SUBOP_WRITES = new String[][]{
+            {"r 24", "r 16", "r 8", "v"},
+            {"r 8", "v"},
+            {"r 8", "v"},
+            {"v"},
+            {"v"}
+    };
+
+    public static final String MOVE_GAMECLICK_OBFUSCATEDNAME = "bd";
+    public static final String MOVE_GAMECLICK_WRITE1 = "5";
+    public static final String MOVE_GAMECLICK_METHOD_NAME1 = "bg";
+    public static final String MOVE_GAMECLICK_WRITE2 = "worldPointX";
+    public static final String MOVE_GAMECLICK_METHOD_NAME2 = "dy";
+    public static final String MOVE_GAMECLICK_WRITE3 = "worldPointY";
+    public static final String MOVE_GAMECLICK_METHOD_NAME3 = "dy";
+    public static final String MOVE_GAMECLICK_WRITE4 = "ctrlDown";
+    public static final String MOVE_GAMECLICK_METHOD_NAME4 = "bg";
+    public static final String[][] MOVE_GAMECLICK_WRITES = new String[][]{
+            {"v"},
+            {"v", "r 8"},
+            {"v", "r 8"},
+            {"v"},
+    };
+    public static final String OPLOC1_OBFUSCATEDNAME = "bi";
+    public static final String OPLOC1_WRITE1 = "objectId";
+    public static final String OPLOC1_METHOD_NAME1 = "bt";
+    public static final String OPLOC1_WRITE2 = "ctrlDown";
+    public static final String OPLOC1_METHOD_NAME2 = "db";
+    public static final String OPLOC1_WRITE3 = "worldPointX";
+    public static final String OPLOC1_METHOD_NAME3 = "dy";
+    public static final String OPLOC1_WRITE4 = "worldPointY";
+    public static final String OPLOC1_METHOD_NAME4 = "bt";
+    public static final String[][] OPLOC1_WRITES = new String[][]{
+            {"r 8", "v"},
+            {"s 0"},
+            {"v", "r 8"},
+            {"r 8", "v"},
+    };
+    public static final String OPLOC2_OBFUSCATEDNAME = "bw";
+    public static final String OPLOC2_WRITE1 = "worldPointX";
+    public static final String OPLOC2_METHOD_NAME1 = "mp";
+    public static final String OPLOC2_WRITE2 = "objectId";
+    public static final String OPLOC2_METHOD_NAME2 = "bt";
+    public static final String OPLOC2_WRITE3 = "worldPointY";
+    public static final String OPLOC2_METHOD_NAME3 = "mp";
+    public static final String OPLOC2_WRITE4 = "ctrlDown";
+    public static final String OPLOC2_METHOD_NAME4 = "dg";
+    public static final String[][] OPLOC2_WRITES = new String[][]{
+            {"r 8", "a 128"},
+            {"r 8", "v"},
+            {"r 8", "a 128"},
+            {"a 128"},
+    };
+    public static final String OPLOC3_OBFUSCATEDNAME = "by";
+    public static final String OPLOC3_WRITE1 = "worldPointY";
+    public static final String OPLOC3_METHOD_NAME1 = "dy";
+    public static final String OPLOC3_WRITE2 = "ctrlDown";
+    public static final String OPLOC3_METHOD_NAME2 = "dg";
+    public static final String OPLOC3_WRITE3 = "worldPointX";
+    public static final String OPLOC3_METHOD_NAME3 = "kl";
+    public static final String OPLOC3_WRITE4 = "objectId";
+    public static final String OPLOC3_METHOD_NAME4 = "kl";
+    public static final String[][] OPLOC3_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"a 128"},
+            {"a 128", "r 8"},
+            {"a 128", "r 8"},
+    };
+    public static final String OPLOC4_OBFUSCATEDNAME = "dk";
+    public static final String OPLOC4_WRITE1 = "objectId";
+    public static final String OPLOC4_METHOD_NAME1 = "bt";
+    public static final String OPLOC4_WRITE2 = "worldPointX";
+    public static final String OPLOC4_METHOD_NAME2 = "bt";
+    public static final String OPLOC4_WRITE3 = "ctrlDown";
+    public static final String OPLOC4_METHOD_NAME3 = "bg";
+    public static final String OPLOC4_WRITE4 = "worldPointY";
+    public static final String OPLOC4_METHOD_NAME4 = "mp";
+    public static final String[][] OPLOC4_WRITES = new String[][]{
+            {"r 8", "v"},
+            {"r 8", "v"},
+            {"v"},
+            {"r 8", "a 128"},
+    };
+    public static final String OPLOC5_OBFUSCATEDNAME = "cl";
+    public static final String OPLOC5_WRITE1 = "objectId";
+    public static final String OPLOC5_METHOD_NAME1 = "bt";
+    public static final String OPLOC5_WRITE2 = "ctrlDown";
+    public static final String OPLOC5_METHOD_NAME2 = "db";
+    public static final String OPLOC5_WRITE3 = "worldPointY";
+    public static final String OPLOC5_METHOD_NAME3 = "kl";
+    public static final String OPLOC5_WRITE4 = "worldPointX";
+    public static final String OPLOC5_METHOD_NAME4 = "bt";
+    public static final String[][] OPLOC5_WRITES = new String[][]{
+            {"r 8", "v"},
+            {"s 0"},
+            {"a 128", "r 8"},
+            {"r 8", "v"},
+    };
+    public static final String OPLOCT_OBFUSCATEDNAME = "ah";
+    public static final String OPLOCT_WRITE1 = "ctrlDown";
+    public static final String OPLOCT_METHOD_NAME1 = "dh";
+    public static final String OPLOCT_WRITE2 = "slot";
+    public static final String OPLOCT_METHOD_NAME2 = "dy";
+    public static final String OPLOCT_WRITE3 = "worldPointX";
+    public static final String OPLOCT_METHOD_NAME3 = "dy";
+    public static final String OPLOCT_WRITE4 = "objectId";
+    public static final String OPLOCT_METHOD_NAME4 = "kl";
+    public static final String OPLOCT_WRITE5 = "worldPointY";
+    public static final String OPLOCT_METHOD_NAME5 = "bt";
+    public static final String OPLOCT_WRITE6 = "itemId";
+    public static final String OPLOCT_METHOD_NAME6 = "dy";
+    public static final String OPLOCT_WRITE7 = "widgetId";
+    public static final String OPLOCT_METHOD_NAME7 = "eg";
+    public static final String[][] OPLOCT_WRITES = new String[][]{
+            {"s 128"},
+            {"v", "r 8"},
+            {"v", "r 8"},
+            {"a 128", "r 8"},
+            {"r 8", "v"},
+            {"v", "r 8"},
+            {"r 8", "v", "r 24", "r 16"},
+    };
+    public static final String OPNPC1_OBFUSCATEDNAME = "ac";
+    public static final String OPNPC1_WRITE1 = "npcIndex";
+    public static final String OPNPC1_METHOD_NAME1 = "dy";
+    public static final String OPNPC1_WRITE2 = "ctrlDown";
+    public static final String OPNPC1_METHOD_NAME2 = "dh";
+    public static final String[][] OPNPC1_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"s 128"},
+    };
+    public static final String OPNPC2_OBFUSCATEDNAME = "cr";
+    public static final String OPNPC2_WRITE1 = "ctrlDown";
+    public static final String OPNPC2_METHOD_NAME1 = "bg";
+    public static final String OPNPC2_WRITE2 = "npcIndex";
+    public static final String OPNPC2_METHOD_NAME2 = "kl";
+    public static final String[][] OPNPC2_WRITES = new String[][]{
+            {"v"},
+            {"a 128", "r 8"},
+    };
+    public static final String OPNPC3_OBFUSCATEDNAME = "dw";
+    public static final String OPNPC3_WRITE1 = "npcIndex";
+    public static final String OPNPC3_METHOD_NAME1 = "dy";
+    public static final String OPNPC3_WRITE2 = "ctrlDown";
+    public static final String OPNPC3_METHOD_NAME2 = "dh";
+    public static final String[][] OPNPC3_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"s 128"},
+    };
+    public static final String OPNPC4_OBFUSCATEDNAME = "ar";
+    public static final String OPNPC4_WRITE1 = "npcIndex";
+    public static final String OPNPC4_METHOD_NAME1 = "mp";
+    public static final String OPNPC4_WRITE2 = "ctrlDown";
+    public static final String OPNPC4_METHOD_NAME2 = "dh";
+    public static final String[][] OPNPC4_WRITES = new String[][]{
+            {"r 8", "a 128"},
+            {"s 128"},
+    };
+    public static final String OPNPC5_OBFUSCATEDNAME = "ab";
+    public static final String OPNPC5_WRITE1 = "npcIndex";
+    public static final String OPNPC5_METHOD_NAME1 = "dy";
+    public static final String OPNPC5_WRITE2 = "ctrlDown";
+    public static final String OPNPC5_METHOD_NAME2 = "dg";
+    public static final String[][] OPNPC5_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"a 128"},
+    };
+    public static final String OPNPCT_OBFUSCATEDNAME = "cf";
+    public static final String OPNPCT_WRITE1 = "slot";
+    public static final String OPNPCT_METHOD_NAME1 = "kl";
+    public static final String OPNPCT_WRITE2 = "widgetId";
+    public static final String OPNPCT_METHOD_NAME2 = "es";
+    public static final String OPNPCT_WRITE3 = "itemId";
+    public static final String OPNPCT_METHOD_NAME3 = "dy";
+    public static final String OPNPCT_WRITE4 = "npcIndex";
+    public static final String OPNPCT_METHOD_NAME4 = "bt";
+    public static final String OPNPCT_WRITE5 = "ctrlDown";
+    public static final String OPNPCT_METHOD_NAME5 = "db";
+    public static final String[][] OPNPCT_WRITES = new String[][]{
+            {"a 128", "r 8"},
+            {"r 16", "r 24", "v", "r 8"},
+            {"v", "r 8"},
+            {"r 8", "v"},
+            {"s 0"},
+    };
+    public static final String OPOBJ1_OBFUSCATEDNAME = "ct";
+    public static final String OPOBJ1_WRITE1 = "ctrlDown";
+    public static final String OPOBJ1_METHOD_NAME1 = "dg";
+    public static final String OPOBJ1_WRITE2 = "worldPointY";
+    public static final String OPOBJ1_METHOD_NAME2 = "dy";
+    public static final String OPOBJ1_WRITE3 = "objectId";
+    public static final String OPOBJ1_METHOD_NAME3 = "dy";
+    public static final String OPOBJ1_WRITE4 = "worldPointX";
+    public static final String OPOBJ1_METHOD_NAME4 = "bt";
+    public static final String[][] OPOBJ1_WRITES = new String[][]{
+            {"a 128"},
+            {"v", "r 8"},
+            {"v", "r 8"},
+            {"r 8", "v"},
+    };
+    public static final String OPOBJ2_OBFUSCATEDNAME = "be";
+    public static final String OPOBJ2_WRITE1 = "worldPointX";
+    public static final String OPOBJ2_METHOD_NAME1 = "mp";
+    public static final String OPOBJ2_WRITE2 = "worldPointY";
+    public static final String OPOBJ2_METHOD_NAME2 = "dy";
+    public static final String OPOBJ2_WRITE3 = "ctrlDown";
+    public static final String OPOBJ2_METHOD_NAME3 = "bg";
+    public static final String OPOBJ2_WRITE4 = "objectId";
+    public static final String OPOBJ2_METHOD_NAME4 = "bt";
+    public static final String[][] OPOBJ2_WRITES = new String[][]{
+            {"r 8", "a 128"},
+            {"v", "r 8"},
+            {"v"},
+            {"r 8", "v"},
+    };
+    public static final String OPOBJ3_OBFUSCATEDNAME = "cu";
+    public static final String OPOBJ3_WRITE1 = "worldPointY";
+    public static final String OPOBJ3_METHOD_NAME1 = "mp";
+    public static final String OPOBJ3_WRITE2 = "ctrlDown";
+    public static final String OPOBJ3_METHOD_NAME2 = "bg";
+    public static final String OPOBJ3_WRITE3 = "worldPointX";
+    public static final String OPOBJ3_METHOD_NAME3 = "kl";
+    public static final String OPOBJ3_WRITE4 = "objectId";
+    public static final String OPOBJ3_METHOD_NAME4 = "mp";
+    public static final String[][] OPOBJ3_WRITES = new String[][]{
+            {"r 8", "a 128"},
+            {"v"},
+            {"a 128", "r 8"},
+            {"r 8", "a 128"},
+    };
+    public static final String OPOBJ4_OBFUSCATEDNAME = "ao";
+    public static final String OPOBJ4_WRITE1 = "worldPointX";
+    public static final String OPOBJ4_METHOD_NAME1 = "dy";
+    public static final String OPOBJ4_WRITE2 = "ctrlDown";
+    public static final String OPOBJ4_METHOD_NAME2 = "dh";
+    public static final String OPOBJ4_WRITE3 = "worldPointY";
+    public static final String OPOBJ4_METHOD_NAME3 = "dy";
+    public static final String OPOBJ4_WRITE4 = "objectId";
+    public static final String OPOBJ4_METHOD_NAME4 = "dy";
+    public static final String[][] OPOBJ4_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"s 128"},
+            {"v", "r 8"},
+            {"v", "r 8"},
+    };
+    public static final String OPOBJ5_OBFUSCATEDNAME = "cy";
+    public static final String OPOBJ5_WRITE1 = "worldPointY";
+    public static final String OPOBJ5_METHOD_NAME1 = "bt";
+    public static final String OPOBJ5_WRITE2 = "objectId";
+    public static final String OPOBJ5_METHOD_NAME2 = "dy";
+    public static final String OPOBJ5_WRITE3 = "worldPointX";
+    public static final String OPOBJ5_METHOD_NAME3 = "mp";
+    public static final String OPOBJ5_WRITE4 = "ctrlDown";
+    public static final String OPOBJ5_METHOD_NAME4 = "db";
+    public static final String[][] OPOBJ5_WRITES = new String[][]{
+            {"r 8", "v"},
+            {"v", "r 8"},
+            {"r 8", "a 128"},
+            {"s 0"},
+    };
+    public static final String OPOBJT_OBFUSCATEDNAME = "cd";
+    public static final String OPOBJT_WRITE1 = "itemId";
+    public static final String OPOBJT_METHOD_NAME1 = "dy";
+    public static final String OPOBJT_WRITE2 = "worldPointY";
+    public static final String OPOBJT_METHOD_NAME2 = "kl";
+    public static final String OPOBJT_WRITE3 = "ctrlDown";
+    public static final String OPOBJT_METHOD_NAME3 = "db";
+    public static final String OPOBJT_WRITE4 = "worldPointX";
+    public static final String OPOBJT_METHOD_NAME4 = "mp";
+    public static final String OPOBJT_WRITE5 = "objectId";
+    public static final String OPOBJT_METHOD_NAME5 = "kl";
+    public static final String OPOBJT_WRITE6 = "widgetId";
+    public static final String OPOBJT_METHOD_NAME6 = "eg";
+    public static final String OPOBJT_WRITE7 = "slot";
+    public static final String OPOBJT_METHOD_NAME7 = "mp";
+    public static final String[][] OPOBJT_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"a 128", "r 8"},
+            {"s 0"},
+            {"r 8", "a 128"},
+            {"a 128", "r 8"},
+            {"r 8", "v", "r 24", "r 16"},
+            {"r 8", "a 128"},
+    };
+    public static final String OPPLAYER1_OBFUSCATEDNAME = "am";
+    public static final String OPPLAYER1_WRITE1 = "playerIndex";
+    public static final String OPPLAYER1_METHOD_NAME1 = "dy";
+    public static final String OPPLAYER1_WRITE2 = "ctrlDown";
+    public static final String OPPLAYER1_METHOD_NAME2 = "bg";
+    public static final String[][] OPPLAYER1_WRITES = new String[][]{
+            {"v", "r 8"},
+            {"v"},
+    };
+    public static final String OPPLAYER2_OBFUSCATEDNAME = "bx";
+    public static final String OPPLAYER2_WRITE1 = "playerIndex";
+    public static final String OPPLAYER2_METHOD_NAME1 = "bt";
+    public static final String OPPLAYER2_WRITE2 = "ctrlDown";
+    public static final String OPPLAYER2_METHOD_NAME2 = "dg";
+    public static final String[][] OPPLAYER2_WRITES = new String[][]{
+            {"r 8", "v"},
+            {"a 128"},
+    };
+    public static final String OPPLAYER3_OBFUSCATEDNAME = "cc";
+    public static final String OPPLAYER3_WRITE1 = "playerIndex";
+    public static final String OPPLAYER3_METHOD_NAME1 = "mp";
+    public static final String OPPLAYER3_WRITE2 = "ctrlDown";
+    public static final String OPPLAYER3_METHOD_NAME2 = "db";
+    public static final String[][] OPPLAYER3_WRITES = new String[][]{
+            {"r 8", "a 128"},
+            {"s 0"},
+    };
+    public static final String OPPLAYER4_OBFUSCATEDNAME = "bv";
+    public static final String OPPLAYER4_WRITE1 = "ctrlDown";
+    public static final String OPPLAYER4_METHOD_NAME1 = "bg";
+    public static final String OPPLAYER4_WRITE2 = "playerIndex";
+    public static final String OPPLAYER4_METHOD_NAME2 = "mp";
+    public static final String[][] OPPLAYER4_WRITES = new String[][]{
+            {"v"},
+            {"r 8", "a 128"},
+    };
+    public static final String OPPLAYER5_OBFUSCATEDNAME = "bc";
+    public static final String OPPLAYER5_WRITE1 = "ctrlDown";
+    public static final String OPPLAYER5_METHOD_NAME1 = "bg";
+    public static final String OPPLAYER5_WRITE2 = "playerIndex";
+    public static final String OPPLAYER5_METHOD_NAME2 = "kl";
+    public static final String[][] OPPLAYER5_WRITES = new String[][]{
+            {"v"},
+            {"a 128", "r 8"},
+    };
+    public static final String OPPLAYER6_OBFUSCATEDNAME = "ai";
+    public static final String OPPLAYER6_WRITE1 = "playerIndex";
+    public static final String OPPLAYER6_METHOD_NAME1 = "kl";
+    public static final String OPPLAYER6_WRITE2 = "ctrlDown";
+    public static final String OPPLAYER6_METHOD_NAME2 = "bg";
+    public static final String[][] OPPLAYER6_WRITES = new String[][]{
+            {"a 128", "r 8"},
+            {"v"},
+    };
+    public static final String OPPLAYER7_OBFUSCATEDNAME = "ce";
+    public static final String OPPLAYER7_WRITE1 = "playerIndex";
+    public static final String OPPLAYER7_METHOD_NAME1 = "kl";
+    public static final String OPPLAYER7_WRITE2 = "ctrlDown";
+    public static final String OPPLAYER7_METHOD_NAME2 = "dg";
+    public static final String[][] OPPLAYER7_WRITES = new String[][]{
+            {"a 128", "r 8"},
+            {"a 128"},
+    };
+    public static final String OPPLAYER8_OBFUSCATEDNAME = "bp";
+    public static final String OPPLAYER8_WRITE1 = "ctrlDown";
+    public static final String OPPLAYER8_METHOD_NAME1 = "bg";
+    public static final String OPPLAYER8_WRITE2 = "playerIndex";
+    public static final String OPPLAYER8_METHOD_NAME2 = "kl";
+    public static final String[][] OPPLAYER8_WRITES = new String[][]{
+            {"v"},
+            {"a 128", "r 8"},
+    };
+    public static final String OPPLAYERT_OBFUSCATEDNAME = "ds";
+    public static final String OPPLAYERT_WRITE1 = "playerIndex";
+    public static final String OPPLAYERT_METHOD_NAME1 = "mp";
+    public static final String OPPLAYERT_WRITE2 = "slot";
+    public static final String OPPLAYERT_METHOD_NAME2 = "dy";
+    public static final String OPPLAYERT_WRITE3 = "widgetId";
+    public static final String OPPLAYERT_METHOD_NAME3 = "es";
+    public static final String OPPLAYERT_WRITE4 = "ctrlDown";
+    public static final String OPPLAYERT_METHOD_NAME4 = "dh";
+    public static final String OPPLAYERT_WRITE5 = "itemId";
+    public static final String OPPLAYERT_METHOD_NAME5 = "kl";
+    public static final String[][] OPPLAYERT_WRITES = new String[][]{
+            {"r 8", "a 128"},
+            {"v", "r 8"},
+            {"r 16", "r 24", "v", "r 8"},
+            {"s 128"},
+            {"a 128", "r 8"},
+    };
+
+    public static final String OPHELDD_OBFUSCATEDNAME = "di";
+    public static final String OPHELDD_WRITE1 = "selectedItemId";
+    public static final String OPHELDD_METHOD_NAME1 = "bt";
+    public static final String OPHELDD_WRITE2 = "destChildIndex";
+    public static final String OPHELDD_METHOD_NAME2 = "dy";
+    public static final String OPHELDD_WRITE3 = "destItemId";
+    public static final String OPHELDD_METHOD_NAME3 = "dy";
+    public static final String OPHELDD_WRITE4 = "selectedId";
+    public static final String OPHELDD_METHOD_NAME4 = "en";
+    public static final String OPHELDD_WRITE5 = "selectedChildIndex";
+    public static final String OPHELDD_METHOD_NAME5 = "kl";
+    public static final String OPHELDD_WRITE6 = "destId";
+    public static final String OPHELDD_METHOD_NAME6 = "eg";
+    public static final String[][] OPHELDD_WRITES = new String[][]{
+            {"r 8", "v"},
+            {"v", "r 8"},
+            {"v", "r 8"},
+            {"v", "r 8", "r 16", "r 24"},
+            {"a 128", "r 8"},
+            {"r 8", "v", "r 24", "r 16"}
+    };
+    public static final String RESUME_COUNTDIALOG_OBFUSCATEDNAME = "au";
+    public static final String RESUME_COUNTDIALOG_WRITE1 = "var0";
+    public static final String RESUME_COUNTDIALOG_METHOD_NAME1 = "bu";
+    public static final String[][] RESUME_COUNTDIALOG_WRITES = new String[][]{
+            {"r 24", "r 16", "r 8", "v"},
+    };
+    public static final String RESUME_PAUSEBUTTON_OBFUSCATEDNAME = "bj";
+    public static final String RESUME_PAUSEBUTTON_WRITE1 = "var1";
+    public static final String RESUME_PAUSEBUTTON_METHOD_NAME1 = "kl";
+    public static final String RESUME_PAUSEBUTTON_WRITE2 = "var0";
+    public static final String RESUME_PAUSEBUTTON_METHOD_NAME2 = "es";
+    public static final String[][] RESUME_PAUSEBUTTON_WRITES = new String[][]{
+            {"a 128", "r 8"},
+            {"r 16", "r 24", "v", "r 8"}
+    };
+
+    public static final String offsetMultiplier = "944624261";
+    public static final String indexMultiplier = "-602712499";
+    public static final String addNodeGarbageValue = "-41";
+    public static final String getPacketBufferNodeGarbageValue = "-26977627";
+    public static final String packetWriterFieldName = "cv";
+    public static final String isaacCipherFieldName = "av";
+    public static final String addNodeMethodName = "ac";
+    public static final String clientPacketClassName = "mi";
+    public static final String packetWriterClassName = "dw";
+    public static final String classContainingGetPacketBufferNodeName = "lh";
+    public static final String packetBufferNodeClassName = "mb";
+    public static final String packetBufferFieldName = "ap";
+    public static final String bufferOffsetField = "aa";
+    public static final String bufferArrayField = "ay";
+    public static final String MouseHandler_lastPressedTimeMillisClass = "bx";
+    public static final String MouseHandler_lastPressedTimeMillisField = "ag";
+    public static final String clientMillisField = "jp";
+    public static final String mouseHandlerMillisMultiplier = "4013550640572753771";
+    public static final String clientMillisMultiplier = "7881463686914378693";
+    public static final int getAnimationMultiplier = 2116322795;
+    public static final int skullIconMultiplier = 0;
+    public static final String skullIconField = "null";
+
+    public static final int pathLengthMultiplier = 0;
+    public static final String pathLengthFieldName = "null";
+    public static final String doActionClassName = "fy";
+    public static final String doActionMethodName = "lu";
+}

src/test/java/com/toofifty/easygiantsfoundry/EasyGiantsFoundryPluginTest.java

@@ -1,13 +0,0 @@
-package com.toofifty.easygiantsfoundry;
-
-import net.runelite.client.RuneLite;
-import net.runelite.client.externalplugins.ExternalPluginManager;
-
-public class EasyGiantsFoundryPluginTest
-{
-    public static void main(String[] args) throws Exception
-    {
-        ExternalPluginManager.loadBuiltin(EasyGiantsFoundryPlugin.class);
-        RuneLite.main(args);
-    }
-}

src/test/java/ee/futur/easygiantsfoundry/K4rliPluginsTest.java

@@ -0,0 +1,18 @@
+package ee.futur.easygiantsfoundry;
+
+import ee.futur.baseapi.BaseApiPlugin;
+import ee.futur.gotr.AutoRiftsPlugin;
+import net.runelite.client.RuneLite;
+import net.runelite.client.externalplugins.ExternalPluginManager;
+
+public class K4rliPluginsTest {
+    public static void main(String[] args) throws Exception {
+        ExternalPluginManager.loadBuiltin(
+                BaseApiPlugin.class,
+                //PacketUtilsPlugin.class,
+                EasyGiantsFoundryPlugin.class,
+                AutoRiftsPlugin.class
+        );
+        RuneLite.main(args);
+    }
+}