API tools faq
paste
Equinox

EquinoxVinesweeper.java

Equinox
Oct 3rd, 2011
153
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 16.41 KB | None | 0 0
raw download clone embed print report
  1. import java.awt.Color;
  2. import java.awt.Graphics;
  3. import java.awt.Point;
  4. import java.awt.Polygon;
  5. import java.util.ArrayList;
  6. import java.util.List;
  7.  
  8. import org.rsbot.event.listeners.PaintListener;
  9. import org.rsbot.script.Script;
  10. import org.rsbot.script.ScriptManifest;
  11. import org.rsbot.script.wrappers.RSComponent;
  12. import org.rsbot.script.wrappers.RSInterface;
  13. import org.rsbot.script.wrappers.RSNPC;
  14. import org.rsbot.script.wrappers.RSObject;
  15. import org.rsbot.script.wrappers.RSTile;
  16. import org.rsbot.util.StringUtil;
  17.  
  18. @ScriptManifest(authors = { "Equinox_" }, name = "Equinox Vinesweeper")
  19. public class EquinoxVinesweeper extends Script implements PaintListener {
  20.  
  21.     private static final int FLAGS_GNOME_ID = 7131;
  22.     private static final int FURROWS_ID = 29479;
  23.     private static final int STILE_ID = 29460;
  24.     private static final int[] RABBIT_ID = { 7125, 7126 };
  25.     private static final int FLAGS_ID = 12625;
  26.     private static final int OGLEROOT_ID = 12624;
  27.     private static final int DIG_ANIM = 8709;
  28.     private static final int FLAG_ANIM = 8711;
  29.     private static final int CLIMB_ANIM = 1560;
  30.  
  31.     private enum Flags {
  32.     N_A,
  33.     ZERO(29447),
  34.     ONE(29448),
  35.     TWO(29449),
  36.     THREE(29450),
  37.     FOUR(29451),
  38.     FIVE(29452),
  39.     SIX(29453),
  40.     SEVEN(29454),
  41.     EIGHT(29455),
  42.     FLAG(29457),
  43.     UNKNOWN(29476, 29477, 29478),
  44.     SEED(29456);
  45.     private int[] ids;
  46.  
  47.     private Flags(int... ids) {
  48.         this.ids = ids;
  49.     }
  50.  
  51.     public byte getVal() {
  52.         return (byte) (ordinal() - 1);
  53.     }
  54.  
  55.     public int[] getIDs() {
  56.         return ids;
  57.     }
  58.     }
  59.  
  60.     private enum State {
  61.     BUY_ROOTS,
  62.     BUY_FLAGS,
  63.     TRANS_STILE,
  64.     FLAG_SEED,
  65.     DIG_HOLE,
  66.     MURDER_RABBIT,
  67.     EXIT_CENTRAL
  68.     }
  69.  
  70.     private int map_size = 15;
  71.     private State state = State.DIG_HOLE;
  72.     private MapHandler mapHandler = new MapHandler();
  73.     private RSTile centralTile = null;
  74.  
  75.     private Point worldToMap(RSTile t) {
  76.     RSTile cent = getCentralTile();
  77.     return new Point(t.getX() - cent.getX() + (map_size / 2), t.getY()
  78.         - cent.getY() + (map_size / 2));
  79.     }
  80.  
  81.     public RSTile getCentralTile() {
  82.     RSObject stile = objects.getNearest(STILE_ID);
  83.     if (centralTile == null && !isCentralArea(getMyPlayer().getLocation())
  84.         && stile != null && calc.distanceTo(stile) > map_size / 2) {
  85.         return centralTile = getMyPlayer().getLocation();
  86.     }
  87.     return centralTile != null ? centralTile : getMyPlayer().getLocation();
  88.     }
  89.  
  90.     private RSTile mapToWorld(Point p) {
  91.     RSTile cent = getCentralTile();
  92.     return new RSTile(p.x - (map_size / 2) + cent.getX(), p.y
  93.         - (map_size / 2) + cent.getY());
  94.     }
  95.  
  96.     public State getState() {
  97.     if (inventory.getCount(true, OGLEROOT_ID) < 10) {
  98.         if (!isCentral(getMyPlayer().getLocation())) {
  99.         return State.TRANS_STILE;
  100.         } else {
  101.         return State.BUY_ROOTS;
  102.         }
  103.     }
  104.     if (!inventory.contains(FLAGS_ID)) {
  105.         if (!isCentral(getMyPlayer().getLocation())) {
  106.         return State.TRANS_STILE;
  107.         } else {
  108.         return State.BUY_FLAGS;
  109.         }
  110.     }
  111.     if ((getChatComponent("Yes, please") != null || interfaces
  112.         .canContinue())
  113.         && inventory.getCount(true, FLAGS_ID) < 10
  114.         && isCentral(getMyPlayer().getLocation())) {
  115.         return State.BUY_FLAGS;
  116.     }
  117.     if (!isCentralArea(getMyPlayer().getLocation())) {
  118.         if (getKillRabbit() != null)
  119.         return State.MURDER_RABBIT;
  120.         if (mapHandler.seeds.size() > 0) {
  121.         return State.FLAG_SEED;
  122.         }
  123.         return State.DIG_HOLE;
  124.     }
  125.     return State.EXIT_CENTRAL;
  126.     }
  127.  
  128.     private boolean isCentral(RSTile t) {
  129.     if (t.getX() == 1632 && (t.getY() == 4697 || t.getY() == 4711))
  130.         return false;
  131.     if (t.getY() == 4704 && (t.getX() == 1622 || t.getX() == 1642))
  132.         return false;
  133.     return t.getX() >= 1622 && t.getY() >= 4697 && t.getX() <= 1642
  134.         && t.getY() <= 4711;
  135.     }
  136.  
  137.     private boolean isCentralArea(RSTile t) {
  138.     return t.getX() >= 1622 && t.getY() >= 4697 && t.getX() <= 1642
  139.         && t.getY() <= 4711;
  140.     }
  141.  
  142.     private RSNPC getKillRabbit() {
  143.     RSNPC rabbit = npcs.getNearest(RABBIT_ID);
  144.     if (rabbit != null) {
  145.         Point p = worldToMap(rabbit.getLocation());
  146.         if (p.x < 0 || p.y < 0 || p.x >= map_size || p.y >= map_size)
  147.         rabbit = null;
  148.     }
  149.     return rabbit;
  150.     }
  151.  
  152.     private RSObject getRSObjectAt(RSTile t) {
  153.     RSObject[] objs = objects.getAllAt(t);
  154.     for (RSObject o : objs) {
  155.         for (Flags flag : Flags.values()) {
  156.         for (int id : flag.getIDs()) {
  157.             if (o.getID() == id) {
  158.             return o;
  159.             }
  160.         }
  161.         }
  162.     }
  163.     return null;
  164.     }
  165.  
  166.     private RSObject getDig() {
  167.     RSObject bst = null;
  168.     double bDist = Double.MAX_VALUE;
  169.     for (RSTile p : mapHandler.crtDig) {
  170.         RSObject o = getRSObjectAt(p);
  171.         if (o != null) {
  172.         double dist = calc.distanceTo(o);
  173.         if (dist < bDist) {
  174.             bDist = dist;
  175.             bst = o;
  176.         }
  177.         }
  178.     }
  179.     if (bst != null)
  180.         return bst;
  181.     for (RSTile p : mapHandler.likeDig) {
  182.         RSObject o = getRSObjectAt(p);
  183.         if (o != null) {
  184.         double dist = calc.distanceTo(o);
  185.         if (dist < bDist) {
  186.             bDist = dist;
  187.             bst = o;
  188.         }
  189.         }
  190.     }
  191.     return bst != null ? bst : objects.getNearest(Flags.UNKNOWN.getIDs());
  192.     }
  193.  
  194.     private RSObject getSeed() {
  195.     RSObject bst = null;
  196.     double bDist = Double.MAX_VALUE;
  197.     for (RSTile p : mapHandler.seeds) {
  198.         RSObject o = getRSObjectAt(p);
  199.         if (o != null) {
  200.         double dist = calc.distanceTo(o);
  201.         if (dist < bDist) {
  202.             bDist = dist;
  203.             bst = o;
  204.         }
  205.         }
  206.     }
  207.     return bst;
  208.     }
  209.  
  210.     @Override
  211.     public int loop() {
  212.     RSObject furrows = objects.getNearest(FURROWS_ID);
  213.     if (furrows == null) {
  214.         log.severe("Unable to find furrows object.  Are you in vinesweeper?");
  215.         stopScript();
  216.     }
  217.     if (isCentralArea(getMyPlayer().getLocation())) {
  218.         centralTile = null;
  219.     }
  220.     switch (state = getState()) {
  221.     case DIG_HOLE:
  222.         RSObject hole = getDig();
  223.         if (hole != null) {
  224.         if (hole.isOnScreen()) {
  225.             hole.interact("Dig");
  226.             for (byte b = 0; b < 50
  227.                 && getMyPlayer().getAnimation() != DIG_ANIM; b++)
  228.             sleep(100);
  229.             if (getMyPlayer().getAnimation() == DIG_ANIM)
  230.             sleep(2000);
  231.         } else {
  232.             step(hole.getLocation());
  233.         }
  234.         }
  235.         break;
  236.     case FLAG_SEED:
  237.         RSObject seed = getSeed();
  238.         if (seed != null) {
  239.         if (seed.isOnScreen()) {
  240.             seed.interact("Flag");
  241.             for (byte b = 0; b < 50
  242.                 && getMyPlayer().getAnimation() != FLAG_ANIM; b++)
  243.             sleep(100);
  244.             if (getMyPlayer().getAnimation() == FLAG_ANIM)
  245.             sleep(2000);
  246.         } else {
  247.             step(seed.getLocation());
  248.         }
  249.         }
  250.         break;
  251.     case MURDER_RABBIT:
  252.         RSNPC rabbit = getKillRabbit();
  253.         if (rabbit != null) {
  254.         if (rabbit.isOnScreen()) {
  255.             if (rabbit.interact("Feed"))
  256.             for (byte b = 0; b < 50 && rabbit.isMoving(); b++)
  257.                 sleep(100);
  258.         } else {
  259.             step(rabbit.getLocation());
  260.         }
  261.         }
  262.         break;
  263.     case TRANS_STILE:
  264.         if (!isCentral(getMyPlayer().getLocation())) {
  265.         RSObject stile = objects.getNearest(STILE_ID);
  266.         if (stile != null) {
  267.             if (stile.isOnScreen()) {
  268.             if (stile.interact("Climb-over"))
  269.                 sleep(1000);
  270.             } else {
  271.             step(stile.getLocation());
  272.             }
  273.         }
  274.         }
  275.         break;
  276.     case EXIT_CENTRAL:
  277.         if (isCentral(getMyPlayer().getLocation())) {
  278.         RSObject stile = objects.getNearest(STILE_ID);
  279.         if (stile != null) {
  280.             if (stile.isOnScreen()) {
  281.             if (stile.interact("Climb-over"))
  282.                 sleep(1000);
  283.             } else {
  284.             step(stile.getLocation());
  285.             }
  286.         }
  287.         } else {
  288.         if (furrows != null) {
  289.             step(furrows.getLocation());
  290.         }
  291.         }
  292.         break;
  293.     case BUY_FLAGS:
  294.         RSComponent chatCom;
  295.         if (interfaces.canContinue()) {
  296.         interfaces.clickContinue();
  297.         } else if ((chatCom = getChatComponent("Yes, please")) != null) {
  298.         chatCom.doClick();
  299.         } else if (isCentral(getMyPlayer().getLocation())) {
  300.         RSNPC gnome = npcs.getNearest(FLAGS_GNOME_ID);
  301.         if (gnome != null) {
  302.             if (gnome.isOnScreen()) {
  303.             if (gnome.interact("Buy-flags"))
  304.                 sleep(1000);
  305.             } else {
  306.             step(gnome.getLocation());
  307.             }
  308.         }
  309.         }
  310.     }
  311.     return 250;
  312.     }
  313.  
  314.     public Polygon getMinimapPolygon(final RSTile t) {
  315.     if (t != null) {
  316.         Polygon poly = new Polygon();
  317.         Point pt = calc.tileToMinimap(t);
  318.         poly.addPoint(pt.x, pt.y);
  319.         pt = calc.tileToMinimap(new RSTile(t.getX(), t.getY() + 1));
  320.         poly.addPoint(pt.x, pt.y);
  321.         pt = calc.tileToMinimap(new RSTile(t.getX() + 1, t.getY() + 1));
  322.         poly.addPoint(pt.x, pt.y);
  323.         pt = calc.tileToMinimap(new RSTile(t.getX() + 1, t.getY()));
  324.         poly.addPoint(pt.x, pt.y);
  325.         for (int i = 0; i < poly.npoints; i++)
  326.         if (poly.xpoints[i] < 0 || poly.ypoints[i] < 0)
  327.             return null;
  328.         return poly;
  329.     }
  330.     return null;
  331.     }
  332.  
  333.     public RSComponent getChatComponent(String inner) {
  334.     inner = inner.toLowerCase();
  335.     final RSInterface[] valid = interfaces.getAll();
  336.     for (final RSInterface iface : valid) {
  337.         if (iface.getIndex() != 137 && iface.getIndex() != 752) {
  338.         final int len = iface.getChildCount();
  339.         for (int i = 0; i < len; i++) {
  340.             final RSComponent child = iface.getComponent(i);
  341.             if (child.getText() != null
  342.                 && child.getText().toLowerCase().contains(inner)
  343.                 && child.isValid() && child.getAbsoluteX() > 10
  344.                 && child.getAbsoluteY() > 300) {
  345.             return child;
  346.             }
  347.         }
  348.         }
  349.     }
  350.     return null;
  351.     }
  352.  
  353.     public void step(RSTile t) {
  354.     RSTile walk = getTileOnMinimap(t);
  355.     if (walking.getDestination() == null
  356.         || calc.distanceBetween(walking.getDestination(), walk) > 4) {
  357.         walking.walkTileMM(walk);
  358.         sleep(1000, 2000);
  359.     }
  360.     }
  361.  
  362.     public RSTile getTileOnMinimap(RSTile base) {
  363.     if (calc.tileOnMap(base))
  364.         return base;
  365.     RSTile me = getMyPlayer().getLocation();
  366.     int deltaX = base.getX() - me.getX();
  367.     int deltaY = base.getY() - me.getY();
  368.     double dist = calc.distanceBetween(base, me);
  369.     double eX = deltaX / dist, eY = deltaY / dist;
  370.     return new RSTile(me.getX() + (int) (eX * 15), me.getY()
  371.         + (int) (eY * 15));
  372.     }
  373.  
  374.     public Polygon getScreenPolygon(final RSTile t) {
  375.     if (t != null) {
  376.         Polygon poly = new Polygon();
  377.         Point pt = calc.tileToScreen(t, 0, 0, 0);
  378.         poly.addPoint(pt.x, pt.y);
  379.         pt = calc.tileToScreen(t, 0, 1, 0);
  380.         poly.addPoint(pt.x, pt.y);
  381.         pt = calc.tileToScreen(t, 1, 1, 0);
  382.         poly.addPoint(pt.x, pt.y);
  383.         pt = calc.tileToScreen(t, 1, 0, 0);
  384.         poly.addPoint(pt.x, pt.y);
  385.         for (int i = 0; i < poly.npoints; i++)
  386.         if (poly.xpoints[i] < 0 || poly.ypoints[i] < 0)
  387.             return null;
  388.         return poly;
  389.     }
  390.     return null;
  391.     }
  392.  
  393.     @Override
  394.     public void onRepaint(Graphics render) {
  395.     for (RSTile tile : mapHandler.seeds) {
  396.         render.setColor(new Color(1f, 0f, 0f, 0.5f));
  397.         Polygon p = getMinimapPolygon(tile);
  398.         if (p != null)
  399.         render.fillPolygon(p);
  400.         render.setColor(new Color(1f, 0f, 0f, 0.25f));
  401.         p = getScreenPolygon(tile);
  402.         if (p != null)
  403.         render.fillPolygon(p);
  404.     }
  405.     for (RSTile tile : mapHandler.crtDig) {
  406.         render.setColor(new Color(0f, 1f, 0f, 0.5f));
  407.         Polygon p = getMinimapPolygon(tile);
  408.         if (p != null)
  409.         render.fillPolygon(p);
  410.         render.setColor(new Color(0f, 1f, 0f, 0.25f));
  411.         p = getScreenPolygon(tile);
  412.         if (p != null)
  413.         render.fillPolygon(p);
  414.     }
  415.     RSNPC rabbit = getKillRabbit();
  416.     if (rabbit != null) {
  417.         RSTile rLoc = rabbit.getLocation();
  418.         render.setColor(Color.BLUE);
  419.         Polygon p = getMinimapPolygon(rLoc);
  420.         if (p != null)
  421.         render.fillPolygon(p);
  422.         p = getScreenPolygon(rLoc);
  423.         render.setColor(new Color(0f, 0f, 1f, 0.5f));
  424.         if (p != null)
  425.         render.fillPolygon(p);
  426.     }
  427.     if (centralTile != null) {
  428.         render.setColor(Color.BLACK);
  429.         Polygon p = getMinimapPolygon(centralTile);
  430.         if (p != null)
  431.         render.fillPolygon(p);
  432.     }
  433.     StringUtil.drawLine(render, 2, "State: " + state.name());
  434.     }
  435.  
  436.     private class MapHandler extends Thread {
  437.     private byte[][] map = new byte[map_size][map_size];
  438.     private List<RSTile> crtDig = new ArrayList<RSTile>();
  439.     private List<RSTile> likeDig = new ArrayList<RSTile>();
  440.     private List<RSTile> seeds = new ArrayList<RSTile>();
  441.  
  442.     private List<RSTile> getSeeds(byte[][] map, int x, int y) {
  443.         if (x > 0 && y > 0 && x < map_size - 1 && y < map_size - 1) {
  444.         int cnt = 0;
  445.         List<RSTile> successors = new ArrayList<RSTile>();
  446.         for (int xD = -1; xD <= 1; xD++)
  447.             for (int yD = -1; yD <= 1; yD++) {
  448.             byte val = map[x + xD][y + yD];
  449.             if (val == Flags.UNKNOWN.getVal()) {
  450.                 successors
  451.                     .add(mapToWorld(new Point(x + xD, y + yD)));
  452.                 cnt++;
  453.             } else if (val == Flags.FLAG.getVal()
  454.                 || val == Flags.SEED.getVal()) {
  455.                 cnt++;
  456.             }
  457.             }
  458.         if (cnt == map[x][y]) {
  459.             return successors;
  460.         }
  461.         }
  462.         return new ArrayList<RSTile>();
  463.     }
  464.  
  465.     private List<RSTile> getMapSeeds(byte[][] map) {
  466.         List<RSTile> pts = new ArrayList<RSTile>();
  467.         for (int x = 0; x < map_size; x++) {
  468.         out: for (int y = 0; y < map_size; y++) {
  469.             Point p = new Point(x, y);
  470.             byte dVal = map[p.x][p.y];
  471.             if (dVal >= Flags.ONE.getVal()
  472.                 && dVal <= Flags.EIGHT.getVal()) {
  473.             List<RSTile> successors = getSeeds(map, p.x, p.y);
  474.             for (RSTile pt : successors) {
  475.                 if (!pts.contains(pt))
  476.                 pts.add(pt);
  477.             }
  478.             } else if (dVal == Flags.UNKNOWN.getVal()) {
  479.             if (!pts.contains(p)) {
  480.                 for (int xD = p.x - 1; xD <= p.x + 1; xD++) {
  481.                 for (int yD = p.y - 1; yD <= p.y + 1; yD++) {
  482.                     List<RSTile> successors = getSeeds(map, xD,
  483.                         yD);
  484.                     for (RSTile pt : successors) {
  485.                     if (!pts.contains(pt))
  486.                         pts.add(pt);
  487.                     }
  488.                     if (pts.contains(p)) {
  489.                     continue out;
  490.                     }
  491.                 }
  492.                 }
  493.             }
  494.             }
  495.         }
  496.         }
  497.         return pts;
  498.     }
  499.  
  500.     private List<RSTile> getMapLikelyDig(byte[][] map, List<RSTile> crtDig) {
  501.         List<RSTile> pts = new ArrayList<RSTile>();
  502.         for (int x = 1; x < map_size - 1; x++)
  503.         out: for (int y = 1; y < map_size - 1; y++) {
  504.             if (map[x][y] == Flags.UNKNOWN.getVal()) {
  505.             for (int xD = -1; xD <= 1; xD++)
  506.                 for (int yD = -1; yD <= 1; yD++) {
  507.                 byte val = map[x + xD][y + yD];
  508.                 if (val != Flags.UNKNOWN.getVal()) {
  509.                     continue out;
  510.                 }
  511.                 }
  512.             RSTile p = mapToWorld(new Point(x, y));
  513.             if (!pts.contains(p) && !crtDig.contains(p))
  514.                 pts.add(p);
  515.             }
  516.         }
  517.         return pts;
  518.     }
  519.  
  520.     private List<RSTile> getMapCertainDig(byte[][] map, List<RSTile> seeds) {
  521.         List<RSTile> pts = new ArrayList<RSTile>();
  522.         for (int x = 0; x < map_size; x++) {
  523.         for (int y = 0; y < map_size; y++) {
  524.             Point p = new Point(x, y);
  525.             byte dVal = map[p.x][p.y];
  526.             if (dVal >= Flags.ZERO.getVal()
  527.                 && dVal < Flags.EIGHT.getVal()) {
  528.             for (int xD = p.x - 1; xD <= p.x + 1; xD++) {
  529.                 for (int yD = p.y - 1; yD <= p.y + 1; yD++) {
  530.                 if (seeds.contains(new Point(xD, yD))) {
  531.                     dVal--;
  532.                 }
  533.                 }
  534.             }
  535.             }
  536.             if (dVal <= 0) {
  537.             for (int xD = p.x - 1; xD <= p.x + 1; xD++) {
  538.                 for (int yD = p.y - 1; yD <= p.y + 1; yD++) {
  539.                 if (xD >= 0 && yD >= 0 && xD < map_size
  540.                     && yD < map_size) {
  541.                     byte val = map[xD][yD];
  542.                     Point pt = new Point(xD, yD);
  543.                     if (val == Flags.UNKNOWN.getVal()
  544.                         && !seeds.contains(pt)) {
  545.                     if (!pts.contains(pt))
  546.                         pts.add(mapToWorld(pt));
  547.                     }
  548.                 }
  549.                 }
  550.             }
  551.             }
  552.         }
  553.         }
  554.         return pts;
  555.     }
  556.  
  557.     private byte[][] updateMap() {
  558.         byte[][] map = new byte[map_size][map_size];
  559.         List<RSTile> update = new ArrayList<RSTile>();
  560.         for (int x = 0; x < map_size; x++) {
  561.         main: for (int y = 0; y < map_size; y++) {
  562.             RSTile tile = mapToWorld(new Point(x, y));
  563.             RSObject[] objs = objects.getAllAt(tile);
  564.             for (RSObject o : objs) {
  565.             for (Flags flag : Flags.values()) {
  566.                 for (int id : flag.getIDs()) {
  567.                 if (o.getID() == id) {
  568.                     if (map[x][y] != flag.getVal())
  569.                     update.add(mapToWorld(new Point(x, y)));
  570.                     map[x][y] = flag.getVal();
  571.                     continue main;
  572.                 }
  573.                 }
  574.             }
  575.             }
  576.             if (map[x][y] != Flags.N_A.getVal())
  577.             update.add(mapToWorld(new Point(x, y)));
  578.             map[x][y] = Flags.N_A.getVal();
  579.         }
  580.         }
  581.         return update.size() > 0 ? map : null;
  582.     }
  583.  
  584.     @Override
  585.     public void run() {
  586.         while (isRunning()) {
  587.         if (!isPaused()) {
  588.             byte[][] n_map = updateMap();
  589.             if (n_map != null) {
  590.             List<RSTile> seeds = getMapSeeds(n_map);
  591.             List<RSTile> crtDig = getMapCertainDig(n_map, seeds);
  592.             List<RSTile> likeDig = getMapLikelyDig(n_map, crtDig);
  593.             this.map = n_map;
  594.             this.seeds = seeds;
  595.             this.crtDig = crtDig;
  596.             this.likeDig = likeDig;
  597.             }
  598.         }
  599.         }
  600.     }
  601.     }
  602. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!