View difference between Paste ID: jyN2UrVN and cEj6ZCYt

-@ScriptManifest(name = "PowerMiner", authors = "AlphaDog", category = "Mining")
+public enum AgilityCourse {
-public class PowerMiner extends Script implements Painting, EventBlockingOverride, MessageListening07 {
+
-    private static final Color MENU_COLOR = new Color(0, 0, 0, 95);
+    GNOME_COURSE(
             new Obstacle(
-    private static final Filter<RSItem> ORE_FILTER = Filters.Items.nameContains("ore", "Clay");
+                    "Log balance",
-    private static final Filter<RSItem> PICKAXE_FILTER = Filters.Items.nameContains("pickaxe");
+                    new RSArea(new RSTile[]{
                             new RSTile(2468, 3435, 0),
-    private Filter<RSObject> rockFilter = new Filter<RSObject>() {
+                            new RSTile(2491, 3436, 0),
-        @Override
+                            new RSTile(2487, 3441, 0),
-        public boolean accept(RSObject rsObject) {
+                            new RSTile(2472, 3441, 0)
-            for (RSTile tile : rocks.keySet()) {
+                    })
-                if (rsObject.getPosition().equals(tile)) {
+            ),
-                    RSObjectDefinition def = rsObject.getDefinition();
+            new Obstacle(
-                    if (def == null) return false;
+                    "Obstacle net",
-                    short[] colors = def.getModifiedColors();
+                    new RSArea(new RSTile[]{
-                    return colors != null && colors.length > 1 && colors[0] != colors[1] && !smokingRockFilter.accept(rsObject);
+                            new RSTile(2470, 3430, 0),
-                }
+                            new RSTile(2470, 3425, 0),
                             new RSTile(2478, 3425, 0),
                             new RSTile(2478, 3430, 0)
-            return false;
+                    })
             ),
-    };
+            new Obstacle(
                     "Tree branch",
-    private final Filter<RSObject> smokingRockFilter = new Filter<RSObject>() {
+                    new RSArea(new RSTile[]{
-        @Override
+                            new RSTile(2471, 3425, 1),
-        public boolean accept(RSObject rsObject) {
+                            new RSTile(2471, 3422, 1),
-            RSModel model = rsObject.getModel();
+                            new RSTile(2477, 3422, 1),
-            return model != null && Math.abs(rocks.get(rsObject.getPosition()) - model.getVertexCount()) > 20;
+                            new RSTile(2477, 3425, 1)
                     })
-    };
+            ),
             new Obstacle(
-    private final ConcurrentHashMap<RSTile, Integer> rocks = new ConcurrentHashMap<>();
+                    "Balancing rope",
                     new RSArea(new RSTile[]{
-    private AtomicInteger amountMined = new AtomicInteger();
+                            new RSTile(2472, 3422, 2),
-    private RSTile lastLocation;
+                            new RSTile(2472, 3418, 2),
-    private long startTime;
+                            new RSTile(2478, 3418, 2),
-    private int startExp;
+                            new RSTile(2478, 3422, 2)
                     })
-    @Override
+            ),
-    public void run() {
+            new Obstacle(
-        MessageListener.addListener(this);
+                    "Tree branch",
-        Mouse.setSpeed(800);
+                    new RSArea(new RSTile[]{
                             new RSTile(2483, 3418, 2),
-        while (rocks.size() == 0)
+                            new RSTile(2489, 3418, 2),
-            sleep(100);
+                            new RSTile(2489, 3422, 2),
                             new RSTile(2483, 3422, 2)
-        startExp = Skills.getXP(Skills.SKILLS.MINING);
+                    })
-        startTime = System.currentTimeMillis();
+            ),
             new Obstacle(
-        while (true) {
+                    "Obstacle net",
-            if (Inventory.find(PICKAXE_FILTER).length == 0 && !Equipment.isEquipped(PICKAXE_FILTER)) {
+                    new RSArea(new RSTile[]{
-                System.out.println("No pickaxe, logging out");
+                            new RSTile(2483, 3416, 0),
-                Login.logout();
+                            new RSTile(2489, 3416, 0),
-                return;
+                            new RSTile(2488, 3426, 0),
                             new RSTile(2483, 3426, 0)
                     })
-            if (Game.getItemSelectionState() == 1) {
+            ),
-                Interfaces.get(548, 50).click(); //deselect item
+            new Obstacle(
-                sleep(200);
+                    "Obstacle pipe",
-                continue;
+                    new RSArea(new RSTile[]{
                             new RSTile(2483, 3427, 0),
                             new RSTile(2489, 3427, 0),
-            if (Player.getAnimation() != -1) {
+                            new RSTile(2489, 3432, 0),
-                if (!checkSmokingRock()) {
+                            new RSTile(2483, 3432, 0)
-                    sleep(100, 200);
+                    })
-                    continue;
+            )
-                }
+    ),
-                System.out.println("Smoking rock detected!");
+
     DRAYNOR_ROOF(
             new Obstacle(
-            if (Inventory.isFull())
+                    "Rough wall",
-                Inventory.drop(Inventory.find(ORE_FILTER));
+                    new RSArea(new RSTile[] {
-            else if (ChooseOption.isOpen())
+                            new RSTile(3102, 3259, 0),
-                ChooseOption.select(ChooseOption.getOptions()[1]);
+                            new RSTile(3105, 3259, 0),
-            else if (clickRock())
+                            new RSTile(3106, 3282, 0),
-                openDropMenu();
+                            new RSTile(3103, 3282, 0)
-            else sleep(100);
+                    })),
             new Obstacle(
                     "Tightrope",
                     new RSArea(new RSTile[] {
                             new RSTile(3097, 3277, 3),
-     * Checks the last clicked rock is smoking by using the smoking rock filter
+                            new RSTile(3103, 3277, 3),
-     * @return <tt>true</tt> if the rock is smoking
+                            new RSTile(3103, 3282, 3),
                             new RSTile(3097, 3282, 3)
-    private boolean checkSmokingRock() {
+                    })),
-        if (lastLocation == null) return false;
+            new Obstacle(
-        RSObject[] rock = Objects.getAt(lastLocation);
+                    "Tightrope",
-        return rock.length > 0 && smokingRockFilter.accept(rock[0]);
+                    new RSArea(new RSTile[] {
                             new RSTile(3093, 3275, 3),
                             new RSTile(3090, 3278, 3),
                             new RSTile(3087, 3274, 3),
-     * Opens the option menu for any ore in your inventory
+                            new RSTile(3090, 3270, 3)
-     * @return <tt>true</tt> if the option menu is successfully opened
+                    })),
             new Obstacle(
-    private boolean openDropMenu() {
+                    "Narrow wall",
-        RSItem[] ores = Inventory.find(ORE_FILTER);
+                    new RSArea(new RSTile[] {
-        if (ores.length == 0 || !ores[0].hover())
+                            new RSTile(3089, 3265, 3),
-            return false;
+                            new RSTile(3096, 3264, 3),
                             new RSTile(3096, 3269, 3),
-        Mouse.click(MouseEvent.BUTTON3);
+                            new RSTile(3089, 3268, 3)
-        sleep(200);
+                    })),
-        return ChooseOption.isOpen();
+            new Obstacle(
                     "Wall",
                     new RSArea(new RSTile[] {
                             new RSTile(3089, 3262, 3),
-     * Clicks with the nearest rock
+                            new RSTile(3089, 3256, 3),
-     * @return <tt>true</tt> if the rock has successfully been clicked
+                            new RSTile(3087, 3256, 3),
                             new RSTile(3087, 3261, 3)
-    private boolean clickRock() {
+                    })),
-        RSObject[] rock = Objects.findNearest(10, rockFilter);
+            new Obstacle("Gap",
-        if (rock.length == 0 || !rock[0].click())
+                    new RSArea(new RSTile[] {
-            return false;
+                            new RSTile(3087, 3256, 3),
                             new RSTile(3095, 3256, 3),
-        if (!Timing.waitCondition(new Condition() {
+                            new RSTile(3095, 3254, 3),
-            @Override
+                            new RSTile(3087, 3254, 3)
-            public boolean active() {
+                    })),
-                return Game.getCrosshairState() == 2;
+            new Obstacle("Crate",
                     new RSArea(new RSTile[] {
-        }, 300)) {
+                            new RSTile(3096, 3262, 3),
-            Mouse.move(Mouse.getPos().x + General.random(-10, 10), Mouse.getPos().y + General.random(-10, 10));
+                            new RSTile(3102, 3262, 3),
-            return false;
+                            new RSTile(3101, 3256, 3),
                             new RSTile(3096, 3256, 3)
                     }))
-        lastLocation = rock[0].getPosition();
+    ),
-        return Timing.waitCondition(new Condition() {
+
-            @Override
+    AL_KHARID_ROOF(
-            public boolean active() {
+            new Obstacle(
-                return Player.getAnimation() != -1;
+                    "Rough wall",
                     new RSArea(new RSTile[] {
-        }, 3000);
+                            new RSTile(3301, 3195, 0),
                             new RSTile(3298, 3198, 0),
                             new RSTile(3270, 3199, 0),
                             new RSTile(3270, 3195, 0),
-     * Gets the rock under the specified point, by checking the tile polygon of each rock in a radius of 15
+                            new RSTile(3296, 3191, 0)
-     * @param point the point that may be hovering the rock
+                    })),
-     * @return {@link org.tribot.api2007.types.RSObject} that has the name 'Rocks' and contains the specified point
+            new Obstacle(
                     "Tightrope",
-    private RSObject getRockUnderPoint(Point point) {
+                    new RSArea(new RSTile[] {
-        RSObject[] rocks = Objects.find(15, "Rocks");
+                            new RSTile(3270, 3196, 3),
-        for (RSObject rock : rocks) {
+                            new RSTile(3279, 3196, 3),
-            if (Projection.getTileBoundsPoly(rock.getPosition(), 0).contains(point))
+                            new RSTile(3278, 3179, 3),
-                return rock;
+                            new RSTile(3270, 3179, 3)
                     })),
             new Obstacle(
                     "Cable",
                     new RSArea(new RSTile[] {
-    @Override
+                            new RSTile(3273, 3174, 3),
-    public void onPaint(Graphics g) {
+                            new RSTile(3265, 3174, 3),
-        g.setColor(Color.green);
+                            new RSTile(3265, 3161, 3),
-        for (RSTile tile : rocks.keySet()) {
+                            new RSTile(3272, 3161, 3)
-            g.drawPolygon(Projection.getTileBoundsPoly(tile, 0));
+                    })),
             new Obstacle(
                     "Zip line",
-        if (rocks.size() == 0) {
+                    new RSArea(new RSTile[] {
-            g.drawString("Click the rocks you want to mine...", 10, 40);
+                            new RSTile(3303, 3159, 3),
                             new RSTile(3303, 3170, 3),
                             new RSTile(3289, 3169, 3),
-        g.setColor(MENU_COLOR);
+                            new RSTile(3288, 3177, 3),
-        g.fillRect(5, 25, 200, 140);
+                            new RSTile(3283, 3177, 3),
-        g.setColor(Color.WHITE);
+                            new RSTile(3283, 3160, 3)
-        g.drawRect(5, 25, 200, 140);
+                    })),
-        g.drawRect(15, 30, 180, 22);
+            new Obstacle(
-        int expGained = Skills.getXP(Skills.SKILLS.MINING) - startExp;
+                    "Tropical tree",
-        g.drawString("PowerMiner - By AlphaDog", 25, 45);
+                    new RSArea(new RSTile[] {
-        g.drawString("Runtime: " + Timing.msToString(System.currentTimeMillis() - startTime), 25, 70);
+                            new RSTile(3313, 3166, 1),
-        g.drawString("Mined: " + amountMined.get(), 25, 90);
+                            new RSTile(3313, 3160, 1),
-        g.drawString("Mined/Hour: " + getPerHour(amountMined.get()), 25, 110);
+                            new RSTile(3319, 3160, 1),
-        g.drawString("Exp gained: " + expGained, 25, 130);
+                            new RSTile(3319, 3166, 1)
-        g.drawString("Exp/Hour: " + getPerHour(expGained), 25, 150);
+                    })),
             new Obstacle(
                     "Roof top beams",
-    private int getPerHour(final int value) {
+                    new RSArea(new RSTile[] {
-        return (int) (value * 3600000D / (System.currentTimeMillis() - startTime));
+                            new RSTile(3319, 3171, 2),
                             new RSTile(3319, 3180, 2),
                             new RSTile(3311, 3180, 2),
                             new RSTile(3312, 3172, 2)
-     * Overides the mouse event, to make sure that you can enable/disable any rock by clicking on it,
+                    })),
-     * without actually interacting with the rock.
+            new Obstacle(
                     "Tightrope",
-    @Override
+                    new RSArea(new RSTile[] {
-    public OVERRIDE_RETURN overrideMouseEvent(final MouseEvent mouseEvent) {
+                            new RSTile(3319, 3180, 3),
-        if (mouseEvent.getButton() == MouseEvent.BUTTON1) {
+                            new RSTile(3319, 3187, 3),
-            RSObject rock = getRockUnderPoint(mouseEvent.getPoint());
+                            new RSTile(3312, 3187, 3),
-            if (rock != null) {
+                            new RSTile(3312, 3180, 3)
-                if (!rocks.containsKey(rock.getPosition())) {
+                    })),
-                    rocks.put(rock.getPosition(), rock.getModel().getVertexCount());
+            new Obstacle(
-                } else {
+                    "Gap",
-                    rocks.remove(rock.getPosition());
+                    new RSArea(new RSTile[] {
-                }
+                            new RSTile(3306, 3188, 3),
-                return OVERRIDE_RETURN.DISMISS;
+                            new RSTile(3303, 3185, 3),
                             new RSTile(3297, 3191, 3),
                             new RSTile(3301, 3194, 3)
                     }))
-        return OVERRIDE_RETURN.SEND;
+    );
 
     private final Obstacle[] obstacles;
-    @Override
+
-    public OVERRIDE_RETURN overrideKeyEvent(KeyEvent keyEvent) {
+    AgilityCourse(Obstacle... obstacles) {
-        return OVERRIDE_RETURN.SEND;
+        this.obstacles = obstacles;
     }
 
-    @Override
+
-    public void serverMessageReceived(String s) {
+     * Gets the next obstacle by checking if the player is inside the obstacle's area
-        if (s.contains("mine some"))
+     * @return the next {@link scripts.alpharunner.Obstacle}
-            amountMined.getAndIncrement();
+
     public Obstacle getNextObstacle() {
         for (Obstacle obstacle : obstacles) {
-    //I wish we had an adapter for this :/
+            if (obstacle.area.contains(Player.getPosition()) && obstacle.area.plane == Game.getPlane()) {
-    @Override
+                return obstacle;
-    public void clanMessageReceived(String s, String s2) {
+
         }
         return null;
     }
-    @Override
+
-    public void duelRequestReceived(String s, String s2) {
+
      * Gets the nearest obstacle based on the center of the obstacle's area
      * @return the nearest {@link scripts.alpharunner.Obstacle}
      */
-    @Override
+    public Obstacle getNearestObstacle() {
-    public void playerMessageReceived(String s, String s2) {
+        Obstacle nearest = null;
         int distance = Integer.MAX_VALUE;
 
         for (Obstacle obstacle : obstacles) {
-    @Override
+            if (obstacle.area.plane != Game.getPlane()) continue;
-    public void personalMessageReceived(String s, String s2) {
+            final int tempDist = Utility.getCenterTile(obstacle.area).distanceTo(Player.getPosition());
             if (tempDist < distance) {
                 distance = tempDist;
                 nearest = obstacle;
-    @Override
+
-    public void tradeRequestReceived(String s) {
+
         return nearest;
     }
 
     /**
      * @return <tt>true</tt> if the course is a rooftop course
      */
     public boolean isRoof() {
         return toString().toLowerCase().contains("roof");
     }
 }