API tools faq
paste
Advertisement
Guest User

BroBot

a guest
Dec 13th, 2014
3,088
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 25.29 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. *****************************Cosmo License Agreement*************************************
  3. *You are free to do whatever it is you please with this code.                           *
  4. *You can redistribute it and/or modify it, even claim it as your own.                   *
  5. *It would be nice if you credited me but its not required. :[                           *
  6. *If we someday meet and you found this useful, you can                                  *
  7. *buy me a beer if you so please.                                                        *
  8. *                                                                                       *
  9. *This program is distributed in the hope that it will be useful, but                    *
  10. *WITHOUT ANY WARRANTY; If you run this program and your computer explodes and/or        *
  11. *starts shooting pink dildos at you, I am in no way responsible. Use this at your own   *
  12. *risk.                                                                                  *
  13. *****************************************************************************************
  14. */
  15.  
  16. import java.awt.AWTException;
  17. import java.awt.Color;
  18. import java.awt.Dimension;
  19. import java.awt.MouseInfo;
  20. import java.awt.Robot;
  21. import java.awt.event.InputEvent;
  22. import java.awt.event.KeyEvent;
  23.  
  24. public class BroBot {
  25.  
  26.     private Robot cosmo;
  27.     private int xPosition, yPosition;
  28.     private Color color;
  29.    
  30.     // Create an instance of the Robot class
  31.     public BroBot() {
  32.         try {
  33.             cosmo = new Robot();
  34.         } catch (AWTException e) {
  35.             System.out.println("Your assistant is on his lunch break. Try again later.");
  36.         }
  37.     }
  38.    
  39.     // measurement can be in milliseconds, seconds
  40.     public void chill(int time, String measurement){
  41.         int chillin = 0;
  42.         switch(measurement){
  43.         case "seconds":
  44.             chillin = 1000 * time;
  45.             break;
  46.         case "milliseconds":
  47.             chillin = time;
  48.             break;
  49.         }
  50.         cosmo.delay(chillin);
  51.     }
  52.    
  53.     // Automatically enters the given text
  54.     public void autoType(String string) {
  55.         // Converts string to a char[]
  56.         char text[] = new char[string.length()];
  57.         for (int i = 0; i < string.length(); i++) {
  58.             text[i] = string.charAt(i);
  59.         }
  60.         // Loops through and enters in each letter in char[]
  61.         for (int i = 0; i < text.length; i++) {
  62.             switch (text[i]) {
  63.             case 'a':
  64.                 cosmo.keyPress(KeyEvent.VK_A);
  65.                 cosmo.keyRelease(KeyEvent.VK_A);
  66.                 break;
  67.             case 'A':
  68.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  69.                 cosmo.keyPress(KeyEvent.VK_A);
  70.                 cosmo.keyRelease(KeyEvent.VK_A);
  71.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  72.                 break;
  73.             case 'b':
  74.                 cosmo.keyPress(KeyEvent.VK_B);
  75.                 cosmo.keyRelease(KeyEvent.VK_B);
  76.                 break;
  77.             case 'B':
  78.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  79.                 cosmo.keyPress(KeyEvent.VK_B);
  80.                 cosmo.keyRelease(KeyEvent.VK_B);
  81.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  82.                 break;
  83.             case 'c':
  84.                 cosmo.keyPress(KeyEvent.VK_C);
  85.                 cosmo.keyRelease(KeyEvent.VK_C);
  86.                 break;
  87.             case 'C':
  88.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  89.                 cosmo.keyPress(KeyEvent.VK_C);
  90.                 cosmo.keyRelease(KeyEvent.VK_C);
  91.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  92.                 break;
  93.             case 'd':
  94.                 cosmo.keyPress(KeyEvent.VK_D);
  95.                 cosmo.keyRelease(KeyEvent.VK_D);
  96.                 break;
  97.             case 'D':
  98.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  99.                 cosmo.keyPress(KeyEvent.VK_D);
  100.                 cosmo.keyRelease(KeyEvent.VK_D);
  101.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  102.                 break;
  103.             case 'e':
  104.                 cosmo.keyPress(KeyEvent.VK_E);
  105.                 cosmo.keyRelease(KeyEvent.VK_E);
  106.                 break;
  107.             case 'E':
  108.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  109.                 cosmo.keyPress(KeyEvent.VK_E);
  110.                 cosmo.keyRelease(KeyEvent.VK_E);
  111.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  112.                 break;
  113.             case 'f':
  114.                 cosmo.keyPress(KeyEvent.VK_F);
  115.                 cosmo.keyRelease(KeyEvent.VK_F);
  116.                 break;
  117.             case 'F':
  118.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  119.                 cosmo.keyPress(KeyEvent.VK_F);
  120.                 cosmo.keyRelease(KeyEvent.VK_F);
  121.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  122.                 break;
  123.             case 'g':
  124.                 cosmo.keyPress(KeyEvent.VK_G);
  125.                 cosmo.keyRelease(KeyEvent.VK_G);
  126.                 break;
  127.             case 'G':
  128.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  129.                 cosmo.keyPress(KeyEvent.VK_G);
  130.                 cosmo.keyRelease(KeyEvent.VK_G);
  131.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  132.                 break;
  133.             case 'h':
  134.                 cosmo.keyPress(KeyEvent.VK_H);
  135.                 cosmo.keyRelease(KeyEvent.VK_H);
  136.                 break;
  137.             case 'H':
  138.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  139.                 cosmo.keyPress(KeyEvent.VK_H);
  140.                 cosmo.keyRelease(KeyEvent.VK_H);
  141.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  142.                 break;
  143.             case 'i':
  144.                 cosmo.keyPress(KeyEvent.VK_I);
  145.                 cosmo.keyRelease(KeyEvent.VK_I);
  146.                 break;
  147.             case 'I':
  148.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  149.                 cosmo.keyPress(KeyEvent.VK_I);
  150.                 cosmo.keyRelease(KeyEvent.VK_I);
  151.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  152.                 break;
  153.             case 'j':
  154.                 cosmo.keyPress(KeyEvent.VK_J);
  155.                 cosmo.keyRelease(KeyEvent.VK_J);
  156.                 break;
  157.             case 'J':
  158.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  159.                 cosmo.keyPress(KeyEvent.VK_J);
  160.                 cosmo.keyRelease(KeyEvent.VK_J);
  161.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  162.                 break;
  163.             case 'k':
  164.                 cosmo.keyPress(KeyEvent.VK_K);
  165.                 cosmo.keyRelease(KeyEvent.VK_K);
  166.                 break;
  167.             case 'K':
  168.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  169.                 cosmo.keyPress(KeyEvent.VK_K);
  170.                 cosmo.keyRelease(KeyEvent.VK_K);
  171.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  172.                 break;
  173.             case 'l':
  174.                 cosmo.keyPress(KeyEvent.VK_L);
  175.                 cosmo.keyRelease(KeyEvent.VK_L);
  176.                 break;
  177.             case 'L':
  178.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  179.                 cosmo.keyPress(KeyEvent.VK_L);
  180.                 cosmo.keyRelease(KeyEvent.VK_L);
  181.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  182.                 break;
  183.             case 'm':
  184.                 cosmo.keyPress(KeyEvent.VK_M);
  185.                 cosmo.keyRelease(KeyEvent.VK_M);
  186.                 break;
  187.             case 'M':
  188.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  189.                 cosmo.keyPress(KeyEvent.VK_M);
  190.                 cosmo.keyRelease(KeyEvent.VK_M);
  191.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  192.                 break;
  193.             case 'n':
  194.                 cosmo.keyPress(KeyEvent.VK_N);
  195.                 cosmo.keyRelease(KeyEvent.VK_N);
  196.                 break;
  197.             case 'N':
  198.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  199.                 cosmo.keyPress(KeyEvent.VK_N);
  200.                 cosmo.keyRelease(KeyEvent.VK_N);
  201.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  202.                 break;
  203.             case 'o':
  204.                 cosmo.keyPress(KeyEvent.VK_O);
  205.                 cosmo.keyRelease(KeyEvent.VK_O);
  206.                 break;
  207.             case 'O':
  208.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  209.                 cosmo.keyPress(KeyEvent.VK_O);
  210.                 cosmo.keyRelease(KeyEvent.VK_O);
  211.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  212.                 break;
  213.             case 'p':
  214.                 cosmo.keyPress(KeyEvent.VK_P);
  215.                 cosmo.keyRelease(KeyEvent.VK_P);
  216.                 break;
  217.             case 'P':
  218.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  219.                 cosmo.keyPress(KeyEvent.VK_P);
  220.                 cosmo.keyRelease(KeyEvent.VK_P);
  221.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  222.                 break;
  223.             case 'q':
  224.                 cosmo.keyPress(KeyEvent.VK_Q);
  225.                 cosmo.keyRelease(KeyEvent.VK_Q);
  226.                 break;
  227.             case 'Q':
  228.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  229.                 cosmo.keyPress(KeyEvent.VK_Q);
  230.                 cosmo.keyRelease(KeyEvent.VK_Q);
  231.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  232.                 break;
  233.             case 'r':
  234.                 cosmo.keyPress(KeyEvent.VK_R);
  235.                 cosmo.keyRelease(KeyEvent.VK_R);
  236.                 break;
  237.             case 'R':
  238.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  239.                 cosmo.keyPress(KeyEvent.VK_R);
  240.                 cosmo.keyRelease(KeyEvent.VK_R);
  241.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  242.                 break;
  243.             case 's':
  244.                 cosmo.keyPress(KeyEvent.VK_S);
  245.                 cosmo.keyRelease(KeyEvent.VK_S);
  246.                 break;
  247.             case 'S':
  248.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  249.                 cosmo.keyPress(KeyEvent.VK_S);
  250.                 cosmo.keyRelease(KeyEvent.VK_S);
  251.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  252.                 break;
  253.             case 't':
  254.                 cosmo.keyPress(KeyEvent.VK_T);
  255.                 cosmo.keyRelease(KeyEvent.VK_T);
  256.                 break;
  257.             case 'T':
  258.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  259.                 cosmo.keyPress(KeyEvent.VK_T);
  260.                 cosmo.keyRelease(KeyEvent.VK_T);
  261.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  262.                 break;
  263.             case 'u':
  264.                 cosmo.keyPress(KeyEvent.VK_U);
  265.                 cosmo.keyRelease(KeyEvent.VK_U);
  266.                 break;
  267.             case 'U':
  268.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  269.                 cosmo.keyPress(KeyEvent.VK_U);
  270.                 cosmo.keyRelease(KeyEvent.VK_U);
  271.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  272.                 break;
  273.             case 'v':
  274.                 cosmo.keyPress(KeyEvent.VK_V);
  275.                 cosmo.keyRelease(KeyEvent.VK_V);
  276.                 break;
  277.             case 'V':
  278.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  279.                 cosmo.keyPress(KeyEvent.VK_V);
  280.                 cosmo.keyRelease(KeyEvent.VK_V);
  281.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  282.                 break;
  283.             case 'w':
  284.                 cosmo.keyPress(KeyEvent.VK_W);
  285.                 cosmo.keyRelease(KeyEvent.VK_W);
  286.                 break;
  287.             case 'W':
  288.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  289.                 cosmo.keyPress(KeyEvent.VK_W);
  290.                 cosmo.keyRelease(KeyEvent.VK_W);
  291.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  292.                 break;
  293.             case 'x':
  294.                 cosmo.keyPress(KeyEvent.VK_X);
  295.                 cosmo.keyRelease(KeyEvent.VK_X);
  296.                 break;
  297.             case 'X':
  298.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  299.                 cosmo.keyPress(KeyEvent.VK_X);
  300.                 cosmo.keyRelease(KeyEvent.VK_X);
  301.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  302.                 break;
  303.             case 'y':
  304.                 cosmo.keyPress(KeyEvent.VK_Y);
  305.                 cosmo.keyRelease(KeyEvent.VK_Y);
  306.                 break;
  307.             case 'Y':
  308.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  309.                 cosmo.keyPress(KeyEvent.VK_Y);
  310.                 cosmo.keyRelease(KeyEvent.VK_Y);
  311.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  312.                 break;
  313.             case 'z':
  314.                 cosmo.keyPress(KeyEvent.VK_Z);
  315.                 cosmo.keyRelease(KeyEvent.VK_Z);
  316.                 break;
  317.             case 'Z':
  318.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  319.                 cosmo.keyPress(KeyEvent.VK_Z);
  320.                 cosmo.keyRelease(KeyEvent.VK_Z);
  321.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  322.                 break;
  323.             case '!':
  324.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  325.                 cosmo.keyPress(KeyEvent.VK_1);
  326.                 cosmo.keyRelease(KeyEvent.VK_1);
  327.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  328.                 break;
  329.             case '.':
  330.                 cosmo.keyPress(KeyEvent.VK_PERIOD);
  331.                 cosmo.keyRelease(KeyEvent.VK_PERIOD);
  332.                 break;
  333.             case '_':
  334.                 cosmo.keyPress(KeyEvent.VK_UNDERSCORE);
  335.                 cosmo.keyRelease(KeyEvent.VK_UNDERSCORE);
  336.                 break;
  337.             case ' ':
  338.                 cosmo.keyPress(KeyEvent.VK_SPACE);
  339.                 cosmo.keyRelease(KeyEvent.VK_SPACE);
  340.                 break;
  341.             case '-':
  342.                 cosmo.keyPress(KeyEvent.VK_MINUS);
  343.                 cosmo.keyRelease(KeyEvent.VK_MINUS);
  344.                 break;
  345.             case '+':
  346.                 cosmo.keyPress(KeyEvent.VK_PLUS);
  347.                 cosmo.keyRelease(KeyEvent.VK_PLUS);
  348.                 break;
  349.             case '?':
  350.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  351.                 cosmo.keyPress(KeyEvent.VK_SLASH);
  352.                 cosmo.keyRelease(KeyEvent.VK_SLASH);
  353.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  354.                 break;
  355.             case '/':
  356.                 cosmo.keyPress(KeyEvent.VK_SLASH);
  357.                 cosmo.keyRelease(KeyEvent.VK_SLASH);
  358.                 break;
  359.             case '@':
  360.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  361.                 cosmo.keyPress(KeyEvent.VK_2);
  362.                 cosmo.keyRelease(KeyEvent.VK_2);
  363.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  364.                 break;
  365.             case '0':
  366.                 cosmo.keyPress(KeyEvent.VK_0);
  367.                 cosmo.keyRelease(KeyEvent.VK_0);
  368.                 break;
  369.             case '1':
  370.                 cosmo.keyPress(KeyEvent.VK_1);
  371.                 cosmo.keyRelease(KeyEvent.VK_1);
  372.                 break;
  373.             case '2':
  374.                 cosmo.keyPress(KeyEvent.VK_2);
  375.                 cosmo.keyRelease(KeyEvent.VK_2);
  376.                 break;
  377.             case '3':
  378.                 cosmo.keyPress(KeyEvent.VK_3);
  379.                 cosmo.keyRelease(KeyEvent.VK_3);
  380.                 break;
  381.             case '4':
  382.                 cosmo.keyPress(KeyEvent.VK_4);
  383.                 cosmo.keyRelease(KeyEvent.VK_4);
  384.                 break;
  385.             case '5':
  386.                 cosmo.keyPress(KeyEvent.VK_5);
  387.                 cosmo.keyRelease(KeyEvent.VK_5);
  388.                 break;
  389.             case '6':
  390.                 cosmo.keyPress(KeyEvent.VK_6);
  391.                 cosmo.keyRelease(KeyEvent.VK_6);
  392.                 break;
  393.             case '7':
  394.                 cosmo.keyPress(KeyEvent.VK_7);
  395.                 cosmo.keyRelease(KeyEvent.VK_7);
  396.                 break;
  397.             case '8':
  398.                 cosmo.keyPress(KeyEvent.VK_8);
  399.                 cosmo.keyRelease(KeyEvent.VK_8);
  400.                 break;
  401.             case '9':
  402.                 cosmo.keyPress(KeyEvent.VK_9);
  403.                 cosmo.keyRelease(KeyEvent.VK_9);
  404.                 break;
  405.             }
  406.         }
  407.         cosmo.keyPress(KeyEvent.VK_ENTER);
  408.         cosmo.keyRelease(KeyEvent.VK_ENTER);
  409.  
  410.     }
  411.    
  412.     public void pressEnter(){
  413.         cosmo.keyPress(KeyEvent.VK_ENTER);
  414.         cosmo.keyRelease(KeyEvent.VK_ENTER);
  415.     }
  416.    
  417.     // You can choose not to have the program automatially entering in the text by passing a false value as its second argument
  418.     public void autoType(String string, boolean pressEnter) {
  419.  
  420.         // Converts string to a char[]
  421.         char text[] = new char[string.length()];
  422.         for (int i = 0; i < string.length(); i++) {
  423.             text[i] = string.charAt(i);
  424.         }
  425.  
  426.         // Loops through and enters in each letter in char[]
  427.         for (int i = 0; i < text.length; i++) {
  428.             switch (text[i]) {
  429.             case 'a':
  430.                 cosmo.keyPress(KeyEvent.VK_A);
  431.                 cosmo.keyRelease(KeyEvent.VK_A);
  432.                 break;
  433.             case 'A':
  434.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  435.                 cosmo.keyPress(KeyEvent.VK_A);
  436.                 cosmo.keyRelease(KeyEvent.VK_A);
  437.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  438.                 break;
  439.             case 'b':
  440.                 cosmo.keyPress(KeyEvent.VK_B);
  441.                 cosmo.keyRelease(KeyEvent.VK_B);
  442.                 break;
  443.             case 'B':
  444.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  445.                 cosmo.keyPress(KeyEvent.VK_B);
  446.                 cosmo.keyRelease(KeyEvent.VK_B);
  447.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  448.                 break;
  449.             case 'c':
  450.                 cosmo.keyPress(KeyEvent.VK_C);
  451.                 cosmo.keyRelease(KeyEvent.VK_C);
  452.                 break;
  453.             case 'C':
  454.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  455.                 cosmo.keyPress(KeyEvent.VK_C);
  456.                 cosmo.keyRelease(KeyEvent.VK_C);
  457.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  458.                 break;
  459.             case 'd':
  460.                 cosmo.keyPress(KeyEvent.VK_D);
  461.                 cosmo.keyRelease(KeyEvent.VK_D);
  462.                 break;
  463.             case 'D':
  464.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  465.                 cosmo.keyPress(KeyEvent.VK_D);
  466.                 cosmo.keyRelease(KeyEvent.VK_D);
  467.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  468.                 break;
  469.             case 'e':
  470.                 cosmo.keyPress(KeyEvent.VK_E);
  471.                 cosmo.keyRelease(KeyEvent.VK_E);
  472.                 break;
  473.             case 'E':
  474.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  475.                 cosmo.keyPress(KeyEvent.VK_E);
  476.                 cosmo.keyRelease(KeyEvent.VK_E);
  477.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  478.                 break;
  479.             case 'f':
  480.                 cosmo.keyPress(KeyEvent.VK_F);
  481.                 cosmo.keyRelease(KeyEvent.VK_F);
  482.                 break;
  483.             case 'F':
  484.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  485.                 cosmo.keyPress(KeyEvent.VK_F);
  486.                 cosmo.keyRelease(KeyEvent.VK_F);
  487.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  488.                 break;
  489.             case 'g':
  490.                 cosmo.keyPress(KeyEvent.VK_G);
  491.                 cosmo.keyRelease(KeyEvent.VK_G);
  492.                 break;
  493.             case 'G':
  494.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  495.                 cosmo.keyPress(KeyEvent.VK_G);
  496.                 cosmo.keyRelease(KeyEvent.VK_G);
  497.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  498.                 break;
  499.             case 'h':
  500.                 cosmo.keyPress(KeyEvent.VK_H);
  501.                 cosmo.keyRelease(KeyEvent.VK_H);
  502.                 break;
  503.             case 'H':
  504.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  505.                 cosmo.keyPress(KeyEvent.VK_H);
  506.                 cosmo.keyRelease(KeyEvent.VK_H);
  507.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  508.                 break;
  509.             case 'i':
  510.                 cosmo.keyPress(KeyEvent.VK_I);
  511.                 cosmo.keyRelease(KeyEvent.VK_I);
  512.                 break;
  513.             case 'I':
  514.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  515.                 cosmo.keyPress(KeyEvent.VK_I);
  516.                 cosmo.keyRelease(KeyEvent.VK_I);
  517.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  518.                 break;
  519.             case 'j':
  520.                 cosmo.keyPress(KeyEvent.VK_J);
  521.                 cosmo.keyRelease(KeyEvent.VK_J);
  522.                 break;
  523.             case 'J':
  524.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  525.                 cosmo.keyPress(KeyEvent.VK_J);
  526.                 cosmo.keyRelease(KeyEvent.VK_J);
  527.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  528.                 break;
  529.             case 'k':
  530.                 cosmo.keyPress(KeyEvent.VK_K);
  531.                 cosmo.keyRelease(KeyEvent.VK_K);
  532.                 break;
  533.             case 'K':
  534.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  535.                 cosmo.keyPress(KeyEvent.VK_K);
  536.                 cosmo.keyRelease(KeyEvent.VK_K);
  537.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  538.                 break;
  539.             case 'l':
  540.                 cosmo.keyPress(KeyEvent.VK_L);
  541.                 cosmo.keyRelease(KeyEvent.VK_L);
  542.                 break;
  543.             case 'L':
  544.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  545.                 cosmo.keyPress(KeyEvent.VK_L);
  546.                 cosmo.keyRelease(KeyEvent.VK_L);
  547.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  548.                 break;
  549.             case 'm':
  550.                 cosmo.keyPress(KeyEvent.VK_M);
  551.                 cosmo.keyRelease(KeyEvent.VK_M);
  552.                 break;
  553.             case 'M':
  554.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  555.                 cosmo.keyPress(KeyEvent.VK_M);
  556.                 cosmo.keyRelease(KeyEvent.VK_M);
  557.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  558.                 break;
  559.             case 'n':
  560.                 cosmo.keyPress(KeyEvent.VK_N);
  561.                 cosmo.keyRelease(KeyEvent.VK_N);
  562.                 break;
  563.             case 'N':
  564.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  565.                 cosmo.keyPress(KeyEvent.VK_N);
  566.                 cosmo.keyRelease(KeyEvent.VK_N);
  567.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  568.                 break;
  569.             case 'o':
  570.                 cosmo.keyPress(KeyEvent.VK_O);
  571.                 cosmo.keyRelease(KeyEvent.VK_O);
  572.                 break;
  573.             case 'O':
  574.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  575.                 cosmo.keyPress(KeyEvent.VK_O);
  576.                 cosmo.keyRelease(KeyEvent.VK_O);
  577.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  578.                 break;
  579.             case 'p':
  580.                 cosmo.keyPress(KeyEvent.VK_P);
  581.                 cosmo.keyRelease(KeyEvent.VK_P);
  582.                 break;
  583.             case 'P':
  584.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  585.                 cosmo.keyPress(KeyEvent.VK_P);
  586.                 cosmo.keyRelease(KeyEvent.VK_P);
  587.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  588.                 break;
  589.             case 'q':
  590.                 cosmo.keyPress(KeyEvent.VK_Q);
  591.                 cosmo.keyRelease(KeyEvent.VK_Q);
  592.                 break;
  593.             case 'Q':
  594.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  595.                 cosmo.keyPress(KeyEvent.VK_Q);
  596.                 cosmo.keyRelease(KeyEvent.VK_Q);
  597.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  598.                 break;
  599.             case 'r':
  600.                 cosmo.keyPress(KeyEvent.VK_R);
  601.                 cosmo.keyRelease(KeyEvent.VK_R);
  602.                 break;
  603.             case 'R':
  604.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  605.                 cosmo.keyPress(KeyEvent.VK_R);
  606.                 cosmo.keyRelease(KeyEvent.VK_R);
  607.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  608.                 break;
  609.             case 's':
  610.                 cosmo.keyPress(KeyEvent.VK_S);
  611.                 cosmo.keyRelease(KeyEvent.VK_S);
  612.                 break;
  613.             case 'S':
  614.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  615.                 cosmo.keyPress(KeyEvent.VK_S);
  616.                 cosmo.keyRelease(KeyEvent.VK_S);
  617.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  618.                 break;
  619.             case 't':
  620.                 cosmo.keyPress(KeyEvent.VK_T);
  621.                 cosmo.keyRelease(KeyEvent.VK_T);
  622.                 break;
  623.             case 'T':
  624.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  625.                 cosmo.keyPress(KeyEvent.VK_T);
  626.                 cosmo.keyRelease(KeyEvent.VK_T);
  627.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  628.                 break;
  629.             case 'u':
  630.                 cosmo.keyPress(KeyEvent.VK_U);
  631.                 cosmo.keyRelease(KeyEvent.VK_U);
  632.                 break;
  633.             case 'U':
  634.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  635.                 cosmo.keyPress(KeyEvent.VK_U);
  636.                 cosmo.keyRelease(KeyEvent.VK_U);
  637.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  638.                 break;
  639.             case 'v':
  640.                 cosmo.keyPress(KeyEvent.VK_V);
  641.                 cosmo.keyRelease(KeyEvent.VK_V);
  642.                 break;
  643.             case 'V':
  644.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  645.                 cosmo.keyPress(KeyEvent.VK_V);
  646.                 cosmo.keyRelease(KeyEvent.VK_V);
  647.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  648.                 break;
  649.             case 'w':
  650.                 cosmo.keyPress(KeyEvent.VK_W);
  651.                 cosmo.keyRelease(KeyEvent.VK_W);
  652.                 break;
  653.             case 'W':
  654.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  655.                 cosmo.keyPress(KeyEvent.VK_W);
  656.                 cosmo.keyRelease(KeyEvent.VK_W);
  657.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  658.                 break;
  659.             case 'x':
  660.                 cosmo.keyPress(KeyEvent.VK_X);
  661.                 cosmo.keyRelease(KeyEvent.VK_X);
  662.                 break;
  663.             case 'X':
  664.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  665.                 cosmo.keyPress(KeyEvent.VK_X);
  666.                 cosmo.keyRelease(KeyEvent.VK_X);
  667.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  668.                 break;
  669.             case 'y':
  670.                 cosmo.keyPress(KeyEvent.VK_Y);
  671.                 cosmo.keyRelease(KeyEvent.VK_Y);
  672.                 break;
  673.             case 'Y':
  674.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  675.                 cosmo.keyPress(KeyEvent.VK_Y);
  676.                 cosmo.keyRelease(KeyEvent.VK_Y);
  677.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  678.                 break;
  679.             case 'z':
  680.                 cosmo.keyPress(KeyEvent.VK_Z);
  681.                 cosmo.keyRelease(KeyEvent.VK_Z);
  682.                 break;
  683.             case 'Z':
  684.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  685.                 cosmo.keyPress(KeyEvent.VK_Z);
  686.                 cosmo.keyRelease(KeyEvent.VK_Z);
  687.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  688.                 break;
  689.             case '!':
  690.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  691.                 cosmo.keyPress(KeyEvent.VK_1);
  692.                 cosmo.keyRelease(KeyEvent.VK_1);
  693.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  694.                 break;
  695.             case '.':
  696.                 cosmo.keyPress(KeyEvent.VK_PERIOD);
  697.                 cosmo.keyRelease(KeyEvent.VK_PERIOD);
  698.                 break;
  699.             case '_':
  700.                 cosmo.keyPress(KeyEvent.VK_UNDERSCORE);
  701.                 cosmo.keyRelease(KeyEvent.VK_UNDERSCORE);
  702.                 break;
  703.             case ' ':
  704.                 cosmo.keyPress(KeyEvent.VK_SPACE);
  705.                 cosmo.keyRelease(KeyEvent.VK_SPACE);
  706.                 break;
  707.             case '-':
  708.                 cosmo.keyPress(KeyEvent.VK_MINUS);
  709.                 cosmo.keyRelease(KeyEvent.VK_MINUS);
  710.                 break;
  711.             case '+':
  712.                 cosmo.keyPress(KeyEvent.VK_PLUS);
  713.                 cosmo.keyRelease(KeyEvent.VK_PLUS);
  714.                 break;
  715.             case '?':
  716.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  717.                 cosmo.keyPress(KeyEvent.VK_SLASH);
  718.                 cosmo.keyRelease(KeyEvent.VK_SLASH);
  719.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  720.                 break;
  721.             case '/':
  722.                 cosmo.keyPress(KeyEvent.VK_SLASH);
  723.                 cosmo.keyRelease(KeyEvent.VK_SLASH);
  724.                 break;
  725.             case '@':
  726.                 cosmo.keyPress(KeyEvent.VK_SHIFT);
  727.                 cosmo.keyPress(KeyEvent.VK_2);
  728.                 cosmo.keyRelease(KeyEvent.VK_2);
  729.                 cosmo.keyRelease(KeyEvent.VK_SHIFT);
  730.                 break;
  731.             case '0':
  732.                 cosmo.keyPress(KeyEvent.VK_0);
  733.                 cosmo.keyRelease(KeyEvent.VK_0);
  734.                 break;
  735.             case '1':
  736.                 cosmo.keyPress(KeyEvent.VK_1);
  737.                 cosmo.keyRelease(KeyEvent.VK_1);
  738.                 break;
  739.             case '2':
  740.                 cosmo.keyPress(KeyEvent.VK_2);
  741.                 cosmo.keyRelease(KeyEvent.VK_2);
  742.                 break;
  743.             case '3':
  744.                 cosmo.keyPress(KeyEvent.VK_3);
  745.                 cosmo.keyRelease(KeyEvent.VK_3);
  746.                 break;
  747.             case '4':
  748.                 cosmo.keyPress(KeyEvent.VK_4);
  749.                 cosmo.keyRelease(KeyEvent.VK_4);
  750.                 break;
  751.             case '5':
  752.                 cosmo.keyPress(KeyEvent.VK_5);
  753.                 cosmo.keyRelease(KeyEvent.VK_5);
  754.                 break;
  755.             case '6':
  756.                 cosmo.keyPress(KeyEvent.VK_6);
  757.                 cosmo.keyRelease(KeyEvent.VK_6);
  758.                 break;
  759.             case '7':
  760.                 cosmo.keyPress(KeyEvent.VK_7);
  761.                 cosmo.keyRelease(KeyEvent.VK_7);
  762.                 break;
  763.             case '8':
  764.                 cosmo.keyPress(KeyEvent.VK_8);
  765.                 cosmo.keyRelease(KeyEvent.VK_8);
  766.                 break;
  767.             case '9':
  768.                 cosmo.keyPress(KeyEvent.VK_9);
  769.                 cosmo.keyRelease(KeyEvent.VK_9);
  770.                 break;
  771.             }
  772.         }
  773.         if (pressEnter) {
  774.             cosmo.keyPress(KeyEvent.VK_ENTER);
  775.             cosmo.keyRelease(KeyEvent.VK_ENTER);
  776.         }
  777.     }
  778.    
  779.     public void leftClickOn(int x, int y) {
  780.         cosmo.mouseMove(x, y);
  781.         cosmo.mousePress(InputEvent.BUTTON1_MASK);
  782.         cosmo.mouseRelease(InputEvent.BUTTON1_MASK);
  783.     }
  784.    
  785.     public void multipleLeftClicksOn(int x, int y, int numOfTimes) {
  786.         int clicks = 0;
  787.         cosmo.mouseMove(x, y);
  788.         while(clicks != numOfTimes){
  789.             cosmo.mousePress(InputEvent.BUTTON1_MASK);
  790.             cosmo.mouseRelease(InputEvent.BUTTON1_MASK);
  791.             clicks++;
  792.         }
  793.     }
  794.  
  795.     public void rightClickOn(int x, int y) {
  796.         cosmo.mouseMove(x, y);
  797.         cosmo.mousePress(InputEvent.BUTTON3_MASK);
  798.         cosmo.mouseRelease(InputEvent.BUTTON3_MASK);
  799.     }
  800.    
  801.     public void searchScreenForColor(Color color, int xSpeed, int ySpeed) {
  802.         int xPos = 0, yPos = 0;
  803.         Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
  804.         double screenWidth = screenSize.getWidth();
  805.         double screenHeight = screenSize.getHeight();
  806.  
  807.         boolean notFound = true;
  808.  
  809.         while (xPos != screenWidth && yPos != screenHeight && notFound == true) {
  810.             for (int x = 0; x <= screenWidth + 1; x += xSpeed) {
  811.                 xPos = x;
  812.                 if (x >= screenWidth) {
  813.                     x = 0;
  814.                     yPos += ySpeed;
  815.                 } else if (cosmo.getPixelColor(xPos, yPos).equals(color)) {
  816.                     System.out.println("Color was found at X: " + xPos + " Y:" + yPos);
  817.                     notFound = false;
  818.                     xPosition = xPos;
  819.                     yPosition = yPos;
  820.                     break;
  821.                 }
  822.             }
  823.             if (notFound)
  824.                 System.out.println("Unable to find color.");
  825.         }
  826.  
  827.     }
  828.    
  829.     public void searchWindowForColor(Color color, int xPosTopLeftCorner, int yPosTopLeftCorner, int xPosBottomRightCorner, int yPosBottomRightCorner, int xSpeed, int ySpeed){
  830.         boolean found = false;
  831.         int x = xPosTopLeftCorner, y = yPosTopLeftCorner;
  832.        
  833.         while(!found){
  834.                
  835.             if(x >= xPosBottomRightCorner){
  836.                 x = xPosTopLeftCorner;
  837.                 y += ySpeed;
  838.             }
  839.             else if(x >= (xPosBottomRightCorner - xSpeed - 1) && y >= yPosBottomRightCorner){
  840.                 x = xPosTopLeftCorner;
  841.                 y = yPosTopLeftCorner;
  842.             }
  843.             else if(cosmo.getPixelColor(x, y).equals(color)){
  844.                 found = true;
  845.                 xPosition = x;
  846.                 yPosition = y;
  847.                 break;
  848.             }
  849.            
  850.             x+= xSpeed;        
  851.         }
  852.     }
  853.  
  854.     public void searchEntireScreenForColor(Color color) {
  855.         int xPos = 0, yPos = 0;
  856.         Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
  857.         double screenWidth = screenSize.getWidth();
  858.         double screenHeight = screenSize.getHeight();
  859.        
  860.         boolean notFound = true;
  861.        
  862.         while (xPos != screenWidth && yPos != screenHeight && notFound == true) {
  863.             for (int x = 0; x <= screenWidth + 1; x++) {
  864.                 xPos = x;
  865.                 if (x == screenWidth) {
  866.                     x = 0;
  867.                     yPos++;
  868.                 } else if (cosmo.getPixelColor(xPos, yPos).equals(color)) {
  869.                     System.out.println("Color was found at X: " + xPos + " Y:" + yPos);
  870.                     notFound = false;
  871.                     xPosition = xPos;
  872.                     yPosition = yPos;
  873.                     break;
  874.                 }
  875.             }
  876.             if(notFound)
  877.                 System.out.println("Unable to find color.");
  878.         }
  879.  
  880.     }
  881.  
  882.     public void moveMouseTo(int x, int y) {
  883.         cosmo.mouseMove(x, y);
  884.     }
  885.  
  886.     public void getPixelInfo() {
  887.         java.util.Scanner input = new java.util.Scanner(System.in);
  888.         String key = "";
  889.         int xPos = 0, yPos = 0;
  890.  
  891.         while (!key.equalsIgnoreCase("p"))
  892.             key = input.nextLine();
  893.  
  894.         if (key.equalsIgnoreCase("P")) {
  895.             xPos = MouseInfo.getPointerInfo().getLocation().x;
  896.             yPos = MouseInfo.getPointerInfo().getLocation().y;
  897.         }
  898.         Color temp = cosmo.getPixelColor(xPos, yPos);
  899.  
  900.         System.out.println("Color: " + temp);
  901.         System.out.println("Position of x: " + xPos);
  902.         System.out.println("Position of y: " + yPos);
  903.        
  904.         color = temp;
  905.         xPosition = xPos;
  906.         yPosition = yPos;
  907.     }
  908.    
  909.     public int getX(){
  910.         return xPosition;
  911.     }
  912.    
  913.     public int getY(){
  914.         return yPosition;
  915.     }
  916.    
  917.     public Color getColor(){
  918.         return color;
  919.     }
  920.    
  921.     public boolean compareColors(Color color1, Color color2){
  922.         boolean match = false;
  923.        
  924.         if(color1.equals(color2)){
  925.             match = true;
  926.         }
  927.        
  928.         return match;
  929.     }
  930. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!