iTIvies 1.0

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.Rectangle;

import org.powerbot.concurrent.Task;
import org.powerbot.concurrent.strategy.Strategy;
import org.powerbot.game.api.ActiveScript;
import org.powerbot.game.api.Manifest;
import org.powerbot.game.api.methods.Calculations;
import org.powerbot.game.api.methods.Tabs;
import org.powerbot.game.api.methods.Widgets;
import org.powerbot.game.api.methods.input.Mouse;
import org.powerbot.game.api.methods.interactive.Players;
import org.powerbot.game.api.methods.node.GroundItems;
import org.powerbot.game.api.methods.node.SceneEntities;
import org.powerbot.game.api.methods.tab.Skills;
import org.powerbot.game.api.methods.widget.Camera;
import org.powerbot.game.api.util.Filter;
import org.powerbot.game.api.util.Random;
import org.powerbot.game.api.util.Time;
import org.powerbot.game.api.wrappers.Tile;
import org.powerbot.game.api.wrappers.interactive.Player;
import org.powerbot.game.api.wrappers.node.GroundItem;
import org.powerbot.game.api.wrappers.node.SceneObject;
import org.powerbot.game.api.wrappers.widget.WidgetChild;
import org.powerbot.game.bot.event.MessageEvent;
import org.powerbot.game.bot.event.listener.MessageListener;
import org.powerbot.game.bot.event.listener.PaintListener;

@Manifest(authors = { "Flow_HRS" }, name = "iTIvies", description = "Chops ivies for you!", version = 1.0)
public class iTIvies extends ActiveScript implements MessageListener,
        PaintListener {

    private final int[] TREE_IVY = { 46318, 46320, 46322, 46324 },
            BIRD_NESTS = { 5070, 5071, 5072, 5073, 5074, 5075, 7413, 11966 };
    private boolean getNest;
    private int chops, nests, startXp, startLevel;
    private String status = "nothing";
    private WidgetChild wc;
    private long startTime;

    @Override
    protected void setup() {
        provide(new Chop());
        provide(new Nest());
        provide(new Antiban());
        wc = Widgets.get(320, 78);
        startTime = System.currentTimeMillis();
        startXp = Skills.getExperience(Skills.WOODCUTTING);
        startLevel = Skills.getLevel(Skills.WOODCUTTING);
    }

    @Override
    public void messageReceived(MessageEvent me) {
        String msg = me.getMessage();
        if (msg.contains("chop away")) {
            chops++;
        } else if (msg.contains("nest")) {
            getNest = true;
        }
    }

    private SceneObject getIvy() {
        return SceneEntities.getNearest(new Filter<SceneObject>() {
            @Override
            public boolean accept(SceneObject obj) {
                return obj.getId() == TREE_IVY[0] || obj.getId() == TREE_IVY[1]
                        || obj.getId() == TREE_IVY[2]
                        || obj.getId() == TREE_IVY[3];
            }
        });
    }

    private GroundItem getNest() {
        return GroundItems.getNearest(new Filter<GroundItem>() {
            @Override
            public boolean accept(GroundItem item) {
                for (int id : BIRD_NESTS) {
                    return id == item.getId();
                }
                return false;
            }
        });
    }

    private class Chop extends Strategy implements Task {

        @Override
        public boolean validate() {
            return getIvy() != null && getIvy().isOnScreen()
                    && Players.getLocal().getAnimation() == -1
                    && !Players.getLocal().isMoving() && !getNest;
        }

        @Override
        public void run() {
            status = "chopping";
            getIvy().interact("Chop");
            Time.sleep(Random.nextInt(300, 400));
        }
    }

    private class Nest extends Strategy implements Task {

        @Override
        public boolean validate() {
            return getNest;
        }

        @Override
        public void run() {
            if (getNest() != null) {
                status = "taking nest";
                getNest().interact("Take");
                Time.sleep(Random.nextInt(300, 400));
                getNest = false;
                nests++;
            }
        }
    }

    private class Antiban extends Strategy implements Task {

        @Override
        public boolean validate() {
            return true;
        }

        @Override
        public void run() {
            if (Random.nextInt(1, 250) < 14) {
                executeAntiban();
            }
            Time.sleep(Random.nextInt(1000, 2000));
        }

        public void executeAntiban() {
            int dx, dy;
            int r = Random.nextInt(0, 4);
            switch (r) {
            case 0:
                status = "moving camera";
                Camera.setAngle(Random.nextInt(20, 300));
                break;
            case 1:
                if (Tabs.getCurrent() != Tabs.STATS) {
                    Tabs.STATS.open();
                }
                status = "hovering";
                Time.sleep(1000);
                wc.hover();
                break;
            case 2:
                status = "opening tabs";
                if (Tabs.getCurrent() != Tabs.INVENTORY) {
                    Tabs.INVENTORY.open();
                }
                break;
            case 3:
                status = "moving mouse";
                dx = Random.nextInt(-30, 30);
                dy = Random.nextInt(-30, 30);
                Mouse.move(Mouse.getX() + dx, Mouse.getY() + dy);
                Time.sleep(Random.nextInt(20, 150));
                break;
            case 4:
                status = "checking player";
                Player player = Players.getNearest(new Filter<Player>() {
                    @Override
                    public boolean accept(Player p) {
                        return !p.equals(Players.getLocal());
                    }
                });
                if (player != null) {
                    player.click(false);
                    Time.sleep(Random.nextInt(400, 1000));
                    dx = Random.nextInt(-16, 16);
                    dy = Random.nextInt(-60, -20);
                    Mouse.move(Mouse.getX() + dx, Mouse.getY() + dy);
                }
                Time.sleep(Random.nextInt(20, 150));
                break;
            }
            status = "chopping";
        }
    }

    private AlphaComposite makeComposite(float alpha) {
        int type = AlphaComposite.SRC_OVER;
        return (AlphaComposite.getInstance(type, alpha));
    }

    @Override
    public void onRepaint(Graphics g) {
        Graphics2D g2d = (Graphics2D) g;

        Font title = new Font("Monotype Corsiva", Font.PLAIN, 25);
        Font author = new Font("Monotype Corsiva", Font.PLAIN, 16);
        Font info = new Font("Book Antiqua", Font.PLAIN, 15);

        Rectangle bg = new Rectangle(10, 23, 230, 165);
        Rectangle border = new Rectangle(8, 21, 234, 169);
        g2d.setColor(Color.DARK_GRAY);
        g2d.setComposite(makeComposite(0.5f));
        g2d.fill(bg);
        g2d.setColor(Color.BLACK);
        g2d.fill(border);
        g2d.setComposite(makeComposite(1.0f));

        g2d.setColor(Color.WHITE);

        g2d.fill(new Rectangle(Mouse.getX() + 1, Mouse.getY() - 4, 2, 15));
        g2d.fill(new Rectangle(Mouse.getX() - 6, Mouse.getY() + 2, 16, 2));

        int expGained = Skills.getExperiences()[Skills.WOODCUTTING] - startXp;
        int expHour = (int) ((expGained) * 3600000D / (System
                .currentTimeMillis() - startTime));
        int cutHour = (int) ((chops) * 3600000D / (System.currentTimeMillis() - startTime));
        g2d.setFont(title);
        g2d.drawString("iTIvies", 12, 43);
        g2d.setFont(author);
        g2d.drawString("By: Flow_HRS", 12, 58);

        g2d.setFont(info);
        g2d.drawString("WC level: " + Skills.getLevels()[Skills.WOODCUTTING]
                + "/" + startLevel + ".", 12, 78);
        g2d.drawString("WC experience gained: " + expGained + ".", 12, 93);
        g2d.drawString("WC experience/hour: " + expHour + ".", 12, 108);
        g2d.drawString("Chopped " + chops + " ivies.", 12, 123);
        g2d.drawString("Chopping " + cutHour + " ivies per hour.", 12, 138);
        g2d.drawString("Nests: " + nests + ".", 12, 153);
        g2d.drawString("Status: " + status + ".", 12, 168);
        g2d.drawString("Time running: "
                + formatTime(System.currentTimeMillis() - startTime) + ".", 12,
                183);
        drawTile(g2d, Players.getLocal().getLocation(), Color.GREEN);
    }

    private String formatTime(final long milliseconds) {
        final long t_seconds = milliseconds / 1000;
        final long t_minutes = t_seconds / 60;
        final long t_hours = t_minutes / 60;
        final long seconds = t_seconds % 60;
        final long minutes = t_minutes % 60;
        final long hours = t_hours % 500;
        return hours + ":" + minutes + ":" + seconds;
    }

    public void drawTile(Graphics2D g, Tile tile, Color col) {
        for (Polygon poly : tile.getBounds()) {
            boolean drawThisOne = true;
            for (int i = 0; i < poly.npoints; i++) {
                Point p = new Point(poly.xpoints[i], poly.ypoints[i]);
                if (!Calculations.isOnScreen(p)) {
                    drawThisOne = false;
                }
            }
            if (drawThisOne) {
                Color col2 = new Color(col.getRed(), col.getGreen(),
                        col.getBlue(), 80);
                g.setColor(col2);
                g.fillPolygon(poly);
                g.setColor(col);
                g.drawPolygon(poly);
            }
        }
    }
}