Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

Untitled

By: a guest on May 2nd, 2012  |  syntax: None  |  size: 16.67 KB  |  hits: 15  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. import java.awt.Color;
  2. import java.awt.Font;
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.Point;
  6. import java.awt.RenderingHints;
  7. import java.text.DecimalFormat;
  8. import java.util.Map;
  9.  
  10. import org.rsbot.accessors.Model;
  11. import org.rsbot.accessors.RSAnimable;
  12. import org.rsbot.bot.Bot;
  13. import org.rsbot.bot.input.Mouse;
  14. import org.rsbot.event.events.ServerMessageEvent;
  15. import org.rsbot.event.listeners.PaintListener;
  16. import org.rsbot.event.listeners.ServerMessageListener;
  17. import org.rsbot.script.Calculations;
  18. import org.rsbot.script.Constants;
  19. import org.rsbot.script.Script;
  20. import org.rsbot.script.ScriptManifest;
  21. import org.rsbot.script.wrappers.RSObject;
  22. import org.rsbot.script.wrappers.RSTile;
  23.  
  24. @ScriptManifest(authors = { "PkerThatOwnz, Gribonn53" }, category = "Woodcutting", name = "TnTOaksChopper", version = 1.1, description = ("<html><center><font size ='7'>TnTOakChopper made by PkerThatOwnz!</font></center>"
  25.                 + "<center>Start the script at Varrock West Bank or near the Oaks!<center></html>"))
  26. public class TnTOaksChopper extends Script implements PaintListener,
  27.                 ServerMessageListener {
  28.  
  29.         public int[] axeID = { 1349, 1351, 1353, 1355, 1357, 1359, 1361, 6739,
  30.                         13470 };
  31.         public RSTile[] treesToBank = { new RSTile(3169, 3423),
  32.                         new RSTile(3175, 3428), new RSTile(3185, 3430),
  33.                         new RSTile(3182, 3436) };
  34.         public RSTile[] bankToTrees = reversePath(treesToBank);
  35.         public RSTile bankTile = new RSTile(3182, 3436);
  36.         public RSTile treeTileNW = new RSTile(3158, 3422);
  37.         public RSTile treeTileSE = new RSTile(3171, 3409);
  38.         public RSTile treeTile = new RSTile(3169, 3423);
  39.         public int oakID = 1281;
  40.         public int oaksChopped;
  41.         public int nextrandomenergy;
  42.         public int[] bankBooth = { 11402 };
  43.  
  44.         protected int getMouseSpeed() {
  45.                 return random(3, 5);
  46.         }
  47.  
  48.         public boolean onStart(Map<String, String> args) {
  49.                 log("Thank you for using my script! :D");
  50.                 nextrandomenergy = random(35, 50);
  51.                 y = 4;
  52.                 yMenu = 28;
  53.                 paintTop = true;
  54.                 // checkUpdate();
  55.                 startTime = System.currentTimeMillis();
  56.                 setCameraAltitude(false);
  57.                 return true;
  58.         }
  59.  
  60.         public int antiBan() {
  61.                 final int gamble = random(1, 15);
  62.                 final int x = random(0, 750);
  63.                 final int y = random(0, 500);
  64.                 final int xx = random(554, 710);
  65.                 final int yy = random(230, 444);
  66.                 final int screenx = random(1, 510);
  67.                 final int screeny = random(1, 450);
  68.                 switch (gamble) {
  69.                 case 1:
  70.                         return random(500, 750);
  71.                 case 2:
  72.                         moveMouse(x, y);
  73.                         return random(500, 750);
  74.                 case 3:
  75.                         openTab(Constants.TAB_INVENTORY);
  76.                         return random(200, 400);
  77.                 case 4:
  78.                         if (getMyPlayer().isMoving()) {
  79.                                 return random(750, 1000);
  80.                         }
  81.                 case 5:
  82.                         moveMouse(x, y);
  83.                         int checkTime = 0;
  84.                         long lastCheck = 0;
  85.                         if (System.currentTimeMillis() - lastCheck >= checkTime) {
  86.                                 lastCheck = System.currentTimeMillis();
  87.                                 checkTime = random(60000, 180000);
  88.                         }
  89.                 case 6:
  90.                         if (getCurrentTab() != Constants.TAB_STATS) {
  91.                                 openTab(Constants.TAB_STATS);
  92.                                 moveMouse(xx, yy);
  93.                                 return random(500, 800);
  94.                         }
  95.                 case 7:
  96.                         if (random(1, 8) == 2) {
  97.                                 int angle = getCameraAngle() + random(-90, 90);
  98.                                 if (angle < 0) {
  99.                                         angle = 0;
  100.                                 }
  101.                                 if (angle > 359) {
  102.                                         angle = 0;
  103.                                 }
  104.                                 setCameraRotation(angle);
  105.                         }
  106.                         return random(500, 750);
  107.                 case 8:
  108.                         moveMouse(screenx, screeny);
  109.                         return random(100, 320);
  110.                 case 9:
  111.                         moveMouse(screenx, screeny);
  112.                         return random(100, 320);
  113.                 case 10:
  114.                         randomTab();
  115.                         wait(random(4000, 6000));
  116.                         return random(120, 250);
  117.                 case 11:
  118.                         wait(random(4000, 6000));
  119.                         moveMouse(screenx, screeny);
  120.                         return random(100, 320);
  121.                 case 12:
  122.                         wait(random(4000, 6000));
  123.                         moveMouse(screenx, screeny);
  124.                         return random(100, 320);
  125.                 case 13:
  126.                         wait(random(4500, 7000));
  127.                         moveMouse(screenx, screeny);
  128.                         return random(100, 320);
  129.                 }
  130.                 return random(500, 750);
  131.  
  132.         }
  133.  
  134.         public int randomTab() {
  135.                 final int random1 = random(1, 23);
  136.                 switch (random1) {
  137.                 case 1:
  138.                         openTab(Constants.TAB_STATS);
  139.                         return random(100, 500);
  140.                 case 2:
  141.                         openTab(Constants.TAB_ATTACK);
  142.                         return random(100, 500);
  143.                 case 3:
  144.                         openTab(Constants.TAB_QUESTS);
  145.                         return random(100, 500);
  146.                 case 4:
  147.                         openTab(Constants.TAB_EQUIPMENT);
  148.                         return random(100, 500);
  149.                 case 5:
  150.                         openTab(Constants.TAB_INVENTORY);
  151.                         return random(100, 500);
  152.                 case 6:
  153.                         openTab(Constants.TAB_PRAYER);
  154.                         return random(100, 500);
  155.                 case 7:
  156.                         openTab(Constants.TAB_MAGIC);
  157.                         return random(100, 500);
  158.                 case 8:
  159.                         openTab(Constants.TAB_SUMMONING);
  160.                         return random(100, 500);
  161.                 case 9:
  162.                         openTab(Constants.TAB_FRIENDS);
  163.                         return random(100, 500);
  164.                 case 10:
  165.                         openTab(Constants.TAB_IGNORE);
  166.                         return random(100, 500);
  167.                 case 11:
  168.                         openTab(Constants.TAB_CLAN);
  169.                         return random(100, 500);
  170.                 case 12:
  171.                         openTab(Constants.TAB_CONTROLS);
  172.                         return random(100, 500);
  173.                 case 13:
  174.                         openTab(Constants.TAB_MUSIC);
  175.                         return random(100, 500);
  176.                 case 14:
  177.                         openTab(Constants.TAB_OPTIONS);
  178.                         return random(100, 500);
  179.                 }
  180.                 return random(100, 300);
  181.  
  182.         }
  183.  
  184.         @Override
  185.         public int loop() {
  186.                 setCameraAltitude(true);
  187.                 if (getEnergy() > nextrandomenergy) {
  188.                         setRun(true);
  189.                         nextrandomenergy = random(35, 50);
  190.                 }
  191.                 if (isInventoryFull()) {
  192.                         if (atBank()) {
  193.                                 status = "Banking";
  194.                                 useBank();
  195.                         } else {
  196.                                 status = "Walking to bank";
  197.                                 walk(treesToBank);
  198.                                 useBank();
  199.                         }
  200.                 } else {
  201.  
  202.                         if (atTree()) {
  203.                                 status = "Chopping";
  204.                                 chopping();
  205.                         } else {
  206.                                 status = "Walking to trees";
  207.                                 walk(bankToTrees);
  208.                                 chopping();
  209.                         }
  210.  
  211.                 }
  212.                 return random(50, 150);
  213.         }
  214.  
  215.         public boolean atBank() {
  216.                 return distanceTo(bankTile) <= 5;
  217.         }
  218.  
  219.         public boolean atTree() {
  220.                 return isInArea(treeTileNW, treeTileSE);
  221.         }
  222.  
  223.         private boolean isEmpty() {
  224.                 return getInventoryCount() == 0;
  225.         }
  226.  
  227.         public boolean isInArea(RSTile NW, RSTile SE) {
  228.                 final int playerX = getMyPlayer().getLocation().getX();
  229.                 final int playerY = getMyPlayer().getLocation().getY();
  230.                 return playerX >= NW.getX() && playerX <= SE.getX()
  231.                                 && playerY >= SE.getY() && playerY <= NW.getY();
  232.         }
  233.        
  234.         boolean clickObjectTree(RSObject obj1,String action) {
  235.                   if (!(obj1.getObject() instanceof RSAnimable)) {
  236.                            return atTree(obj1, action);
  237.                   }else{
  238.                           moveMouse(getModelPoint(obj1), 3, 3);
  239.                           return atMenu(action);
  240.                   }
  241.         }
  242.        
  243.         private Point getModelPoint(RSObject obj) {
  244.                 Model model = obj.getModel();
  245.                 RSAnimable animable = (RSAnimable) obj.getObject();
  246.                 Point[] screenCoords = new Point[model.getXPoints().length];
  247.                 for (int i = 0; i < screenCoords.length; i++) {
  248.                         int x = model.getXPoints()[i] + animable.getX();
  249.                         int z = model.getZPoints()[i] + animable.getY();
  250.                         int y = model.getYPoints()[i]
  251.                                         + Calculations.tileHeight(animable.getX(), animable.getY());
  252.                         screenCoords[i] = Calculations.w2s(x, y, z);
  253.                 }
  254.                 return screenCoords[random(0, screenCoords.length)];
  255.         }
  256.  
  257.         public boolean chopping() {
  258.                 if (getMyPlayer().getAnimation() == -1) {
  259.                         final RSObject Tree = getNearestObjectByID(oakID);
  260.                         if (Tree != null) {
  261.                                 if (distanceTo(Tree) <= 5) {
  262.                                         at4Tiles(Tree, "Chop");
  263.                                 } else {
  264.                                         walkTo(Tree.getLocation());
  265.                                 }
  266.                         }
  267.                 } else {
  268.                         antiBan();
  269.                 }
  270.                 return true;
  271.  
  272.         }
  273.  
  274.         public int walk(RSTile[] path) {
  275.                 if (distanceTo(getDestination()) < random(5, 12)
  276.                                 || distanceTo(getDestination()) > 40) {
  277.                         if (!walkPathMM(path)) {
  278.                                 walkToClosestTile(randomizePath(path, 2, 2));
  279.                                 return random(100, 200);
  280.                         }
  281.                 }
  282.                 return 0;
  283.         }
  284.  
  285.         public boolean at4Tiles(RSObject obj, String action) {
  286.                 RSTile map[][] = new RSTile[5][5];
  287.                 for (int x = 0; x < 4; x++) {
  288.                         for (int y = 0; y < 4; y++) {
  289.                                 RSObject fObj = getObjectAt(obj.getLocation().getX() - 2 + x,
  290.                                                 obj.getLocation().getY() - 2 + y);
  291.                                 if (fObj != null && fObj.getID() == obj.getID()) {
  292.                                         map[x][y] = fObj.getLocation();
  293.                                 }
  294.                         }
  295.                 }
  296.                 RSTile tTile = null;
  297.                 int tx = 0;
  298.                 int ty = 0;
  299.                 for (int x = 0; x <= 3; x++) {
  300.                         for (int y = 0; y <= 3; y++) {
  301.                                 if (map[x][y] != null && map[x + 1][y] != null
  302.                                                 && map[x][y + 1] != null && map[x + 1][y + 1] != null) {
  303.                                         if (map[x][y].equals(obj.getLocation())
  304.                                                         || map[x + 1][y].equals(obj.getLocation())
  305.                                                         || map[x][y + 1].equals(obj.getLocation())
  306.                                                         || map[x + 1][y + 1].equals(obj.getLocation())) {
  307.                                                 tTile = map[x][y];
  308.                                                 tx = x;
  309.                                                 ty = y;
  310.                                                 break;
  311.                                         }
  312.                                 }
  313.                         }
  314.                 }
  315.  
  316.                 if (tTile == null) {
  317.                         return false;
  318.                 }
  319.                 int xSum = 0;
  320.                 int ySum = 0;
  321.  
  322.                 for (int x = 0; x <= 1; x++) {
  323.                         for (int y = 0; y <= 1; y++) {
  324.                                 xSum += (int) map[tx + x][ty + y].getScreenLocation().getX();
  325.                                 ySum += (int) map[tx + x][ty + y].getScreenLocation().getY();
  326.                         }
  327.                 }
  328.                 moveMouse(xSum / 4 + random(-2, 2), ySum / 4 + random(-2, 2));
  329.                 return atMenu(action);
  330.         }
  331.  
  332.         private boolean useBank() {
  333.  
  334.                 if (!isEmpty()) {
  335.                         bank.depositAllExcept(axeID);
  336.                 }
  337.  
  338.                 final RSObject banker = getNearestObjectByID(bankBooth);
  339.                 if (banker != null) {
  340.                         if (distanceTo(banker.getLocation()) <= 7) {
  341.                                 if (bank.isOpen()) {
  342.                                         bank.depositAllExcept(axeID);
  343.                                         wait(random(150, 250));
  344.                                 } else {
  345.                                         bank.open();
  346.                                         wait(random(150, 250));
  347.                                 }
  348.                         } else {
  349.                                 if (getEnergy() >= nextrandomenergy) {
  350.                                         setRun(true);
  351.                                 }
  352.                                 if (distanceTo(getDestination()) < random(5, 12))
  353.                                         ;
  354.  
  355.                                 return true;
  356.                         }
  357.                 }
  358.                 return true;
  359.         }
  360.  
  361.         // Paint stuff
  362.         public DecimalFormat df = new DecimalFormat("#");
  363.         public boolean showPaint = true, showAveraging, showGained, showStatInfo,
  364.                         paintTop = true, added = false, end = false;
  365.         public int startXP;
  366.         public long startTime;
  367.         public int oakXP;
  368.         public int y;
  369.         public int yMenu;
  370.         public int oaksHour;
  371.         public int levelsGained;
  372.         public int oaks = 0;
  373.         public String status;
  374.  
  375.         @Override
  376.         public void onRepaint(Graphics g) {
  377.                 ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  378.                                 RenderingHints.VALUE_ANTIALIAS_ON);
  379.                 if (showPaint == true) {
  380.                         if (isLoggedIn()) {
  381.                                 int xpGained = 0;
  382.                                 if (startXP == 0) {
  383.                                         startXP = skills
  384.                                                         .getCurrentSkillExp(Constants.STAT_WOODCUTTING);
  385.                                 }
  386.                                 int xpLeft = skills
  387.                                                 .getXPToNextLevel(Constants.STAT_WOODCUTTING);
  388.                                 xpGained = skills
  389.                                                 .getCurrentSkillExp(Constants.STAT_WOODCUTTING)
  390.                                                 - startXP;
  391.                                 long millis = System.currentTimeMillis() - startTime;
  392.                                 long hours = millis / (1000 * 60 * 60);
  393.                                 millis -= hours * (1000 * 60 * 60);
  394.                                 long minutes = millis / (1000 * 60);
  395.                                 millis -= minutes * (1000 * 60);
  396.                                 long seconds = millis / 1000;
  397.                                 float xpsec = 0;
  398.                                 if ((minutes > 0 || hours > 0 || seconds > 0) && xpGained > 0) {
  399.                                         xpsec = ((float) xpGained)
  400.                                                         / (float) (seconds + (minutes * 60) + (hours * 60 * 60));
  401.                                 }
  402.                                 float xpmin = xpsec * 60;
  403.                                 float xphour = xpmin * 60;
  404.                                 final int oaksHour = (int) ((oaks) * 3600000D / (System
  405.                                                 .currentTimeMillis() - startTime));
  406.                                 g.setFont(new Font("Trebuchet MS", Font.PLAIN, 14));
  407.                                 if (showGained == true) {
  408.                                         if (paintTop) {
  409.                                                 g.setColor(new Color(0, 0, 0, 150));
  410.                                                 g.fillRoundRect(200, yMenu, 150, 82, 0, 0);
  411.                                                 g.setColor(Color.white);
  412.                                                 g.drawString("XP Gained: " + xpGained, 208, yMenu + 18);
  413.                                                 g.drawString("Levels Gained: " + levelsGained, 208,
  414.                                                                 yMenu + 36);
  415.                                                 g
  416.                                                                 .drawString(
  417.                                                                                 "Current level: "
  418.                                                                                                 + skills
  419.                                                                                                                 .getCurrentSkillLevel(Constants.STAT_WOODCUTTING),
  420.                                                                                 208, yMenu + 54);
  421.                                                 g.drawString("Oaks chopped: " + oaksChopped, 208,
  422.                                                                 yMenu + 72);
  423.                                         } else {
  424.                                                 g.setColor(new Color(0, 0, 0, 150));
  425.                                                 g.fillRoundRect(200, yMenu - 18, 150, 82, 0, 0);
  426.                                                 g.setColor(Color.white);
  427.                                                 g.drawString("XP Gained: " + xpGained, 208, yMenu);
  428.                                                 g.drawString("Levels Gained: " + levelsGained, 208,
  429.                                                                 yMenu + 18);
  430.                                                 g
  431.                                                                 .drawString(
  432.                                                                                 "Current level: "
  433.                                                                                                 + skills
  434.                                                                                                                 .getCurrentSkillLevel(Constants.STAT_WOODCUTTING),
  435.                                                                                 208, yMenu + 36);
  436.                                                 g.drawString("Oaks chopped: " + oaksChopped, 208,
  437.                                                                 yMenu + 54);
  438.                                         }
  439.                                 }
  440.                                 if (showAveraging == true) {
  441.                                         g.setColor(new Color(0, 0, 0, 150));
  442.                                         g.fillRoundRect(286, yMenu, 200, 64, 0, 0);
  443.                                         g.setColor(Color.white);
  444.                                         g.drawString("Time running: " + hours + ":" + minutes + ":"
  445.                                                         + seconds, 294, yMenu + 18);
  446.                                         g.drawString("XP Hour: " + (int) xphour, 294, yMenu + 36);
  447.                                         g.drawString("Oaks/Hour: " + oaksHour, 294, yMenu + 54);
  448.                                 }
  449.                                 final int percent = skills
  450.                                                 .getPercentToNextLevel(Constants.STAT_WOODCUTTING);
  451.                                 g.setColor(new Color(0, 0, 0, 150));
  452.                                 g.fillRoundRect(4, y, 511, 24, 0, 0);
  453.                                 g.setColor(Color.white);
  454.                                 g.draw3DRect(4, y, 511, 24, true);
  455.                                 g.setColor(new Color(149, 7, 17, 200));
  456.                                 g.fillRoundRect(7, y + 2, 100, 20, 0, 0);
  457.                                 g.setColor(new Color(0, 79, 0, 200));
  458.                                 g.fillRoundRect(7, y + 2, percent, 20, 0, 0);
  459.                                 g.setColor(Color.black);
  460.                                 g.drawRect(7, y + 2, 100, 20);
  461.                                 g.setColor(Color.white);
  462.                                 g.drawString(percent + "% Done", 117, y + 17);
  463.                                 g.draw3DRect(200, y, 1, 24, true);
  464.                                 g.drawString("Gained", 220, y + 17);
  465.                                 g.draw3DRect(285, y, 1, 24, true);
  466.                                 g.drawString("Averaging", 305, y + 17);
  467.                                 g.draw3DRect(390, y, 1, 24, true);
  468.                                 g.setFont(new Font("Trebuchet MS", Font.BOLD, 14));
  469.                                 g.drawString("" + status, 400, y + 17);
  470.                                 if (showStatInfo == true) {
  471.                                         g.setFont(new Font("Trebuchet MS", Font.PLAIN, 14));
  472.                                         int oaksTillNextLevel = 0;
  473.                                         Mouse m = Bot.getClient().getMouse();
  474.                                         if (oakXP != 0) {
  475.                                                 oaksTillNextLevel = Integer.parseInt(df.format(xpLeft
  476.                                                                 / oakXP));
  477.                                                 if ((xpLeft / oakXP) > oaksTillNextLevel) {
  478.                                                         oaksTillNextLevel += 1;
  479.                                                 }
  480.                                         }
  481.                                         g.setColor(new Color(0, 0, 0, 205));
  482.                                         if (paintTop) {
  483.                                                 g.fillRect(m.x, m.y, 200, 115);
  484.                                                 g.setColor(Color.white);
  485.                                                 g.drawString("WOODCUTTING", m.x + 15, m.y + 30);
  486.                                                 g
  487.                                                                 .drawString(
  488.                                                                                 "Level: "
  489.                                                                                                 + skills
  490.                                                                                                                 .getCurrentSkillLevel(Constants.STAT_WOODCUTTING),
  491.                                                                                 m.x + 15, m.y + 45);
  492.                                                 g
  493.                                                                 .drawString(
  494.                                                                                 "Xp: "
  495.                                                                                                 + skills
  496.                                                                                                                 .getCurrentSkillExp(Constants.STAT_WOODCUTTING),
  497.                                                                                 m.x + 15, m.y + 60);
  498.                                                 g.drawString("Xp Till Next level: " + xpLeft, m.x + 15,
  499.                                                                 m.y + 75);
  500.                                                 g
  501.                                                                 .drawString(
  502.                                                                                 "% Till Next Level: "
  503.                                                                                                 + skills
  504.                                                                                                                 .getPercentToNextLevel(Constants.STAT_WOODCUTTING),
  505.                                                                                 m.x + 15, m.y + 90);
  506.                                                 g.drawString("Oaks Till Next Level: "
  507.                                                                 + oaksTillNextLevel, m.x + 15, m.y + 105);
  508.                                         } else {
  509.                                                 g.fillRect(m.x, m.y - 115, 200, 115);
  510.                                                 g.setColor(Color.white);
  511.                                                 g.drawString("WOODCUTTING", m.x + 15, m.y - 90);
  512.                                                 g
  513.                                                                 .drawString(
  514.                                                                                 "Level: "
  515.                                                                                                 + skills
  516.                                                                                                                 .getCurrentSkillLevel(Constants.STAT_WOODCUTTING),
  517.                                                                                 m.x + 15, m.y - 75);
  518.                                                 g
  519.                                                                 .drawString(
  520.                                                                                 "Xp: "
  521.                                                                                                 + skills
  522.                                                                                                                 .getCurrentSkillExp(Constants.STAT_WOODCUTTING),
  523.                                                                                 m.x + 15, m.y - 60);
  524.                                                 g.drawString("Xp Till Next level: " + xpLeft, m.x + 15,
  525.                                                                 m.y - 45);
  526.                                                 g
  527.                                                                 .drawString(
  528.                                                                                 "% To Next Level: "
  529.                                                                                                 + skills
  530.                                                                                                                 .getPercentToNextLevel(Constants.STAT_WOODCUTTING),
  531.                                                                                 m.x + 15, m.y - 30);
  532.                                                 g.drawString("Oaks Till Next Level: "
  533.                                                                 + oaksTillNextLevel, m.x + 15, m.y - 15);
  534.                                         }
  535.                                 }
  536.                                 Mouse m = Bot.getClient().getMouse();
  537.                                 if (m.x >= 200 && m.x < 200 + 85 && m.y >= y && m.y < y + 24) {
  538.                                         showGained = true;
  539.                                 } else {
  540.                                         if (end == false) {
  541.                                                 showGained = false;
  542.                                         }
  543.                                 }
  544.                                 if (m.x >= 286 && m.x < 286 + 105 && m.y >= y && m.y < y + 24) {
  545.                                         showAveraging = true;
  546.                                 } else {
  547.                                         showAveraging = false;
  548.                                 }
  549.                                 if (m.x >= 7 && m.x < 7 + 100 && m.y >= y + 2
  550.                                                 && m.y < y + 2 + 20) {
  551.                                         showStatInfo = true;
  552.                                 } else {
  553.                                         showStatInfo = false;
  554.                                 }
  555.                         }
  556.                         if (oakXP == 0
  557.                                         && !added
  558.                                         && skills.getCurrentSkillExp(Constants.STAT_WOODCUTTING)
  559.                                                         - startXP != 0) {
  560.                                 oakXP = skills.getCurrentSkillExp(Constants.STAT_WOODCUTTING)
  561.                                                 - startXP;
  562.                                 added = true;
  563.                         }
  564.                 }
  565.         }
  566.  
  567.         public void onFinish() {
  568.                 log("Sell your oaks and get some $$$!");
  569.                 long millis = System.currentTimeMillis() - startTime;
  570.                 long hours = millis / (1000 * 60 * 60);
  571.                 millis -= hours * (1000 * 60 * 60);
  572.                 long minutes = millis / (1000 * 60);
  573.                 millis -= minutes * (1000 * 60);
  574.                 long seconds = millis / 1000;
  575.  
  576.         }
  577.  
  578.         @Override
  579.         public void serverMessageRecieved(final ServerMessageEvent e) {
  580.                 final String serverString = e.getMessage();
  581.                 if (serverString.contains("You get some")) {
  582.                         oaksChopped++;
  583.                 }
  584.                 if (serverString.contains("You've just advanced")) {
  585.                         levelsGained++;
  586.                 }
  587.  
  588.         }
  589.  
  590. }
create a new version of this paste RAW Paste Data