精华内容
下载资源
问答
  • java开发外挂 千次阅读
    2020-02-25 23:37:32

    本文分享外挂思路,不提供具体代码,被游戏爪牙搞怕了。使用了阴阳师(痒痒鼠)和跳一跳作为实验体,成功实践。内容仅供编程学习

    java也能写外挂?

    java可以写部分外挂,但是仅限于简单的外挂,操作内存的外挂机就十分难搞了,不适合,但理论也可以,以后实践了再过来补充。

     

    两个思路

    电脑上面运行的游戏

    java可以使用jdk提供的Robot工具,来实现模拟键盘点击事件和监听键盘的点击事件。基于此,就可以编写一些脚本,自动点击键盘。

    手机上面的游戏

    java可以使用adb工具和cmd工具,通过程序操控手机。基于此,可以模拟很多人为操作:手指滑动、手指点击、截屏等等。

    adb工具可以实现安卓设备通过数据线或者wifi连接电脑。

    cmd工具可以实现java执行cmd命令。

    截屏是一个很关键的地方,可以配合游戏界面的识别,实现一些自动判断,比如游戏进行到什么地方了,游戏是否结束等等。

    更多相关内容
  • ##起初是想使用按键精灵脚本程序控制,但还是选择熟悉的java。我这里使用了工具,造成延迟问题。也求教:java控制安卓的正确姿势,参考了.NET玩跳一跳,思路都是一样的...

    640?wx_fmt=jpeg


    ##起初是想使用按键精灵脚本程序控制,但还是选择熟悉的java。我这里使用了工具,造成延迟问题。也求教:java控制安卓的正确姿势,

    参考了.NET玩跳一跳,思路都是一样的,只不过使用ADB控制安卓的方式更好,博主也贴出了adb命令,解决了我一大问题。

    先看效果图:

    640?wx_fmt=png

    设计思路:

      java识别小人和目标物,计算距离,计算时间,触发按键时长。

    主要解决问题:

    1、java操作安卓手机。

      ##本人对安卓不懂,只能使用工具了,手机连接电脑使用“手机控”软件把手机屏幕显示到电脑上,就能鼠标玩跳一跳,然后java识别小人和目标物,控制点击时长。

      使用ADB发送命令操作手机。ADB版本选择1.0.32以上,才能识别安卓5.0。ADB下载地址:http://www.cr173.com/soft/205142.html

      1、截图。2、上传电脑。3、退出

      可以把命令写成BAT文件。

    adb shell screencap -p /sdcard/1.png
    adb pull /sdcard/1.png E:/adb
    exit

     

    2、如何识别目标。

      ##java截取手机屏幕部分,对图片进行像素点识别。通过像素点占百分比数,最多的为目标颜色,设计识别正方形像素点的算法。

      ##具体识别方法:小人颜色固定,去除背景色,识别小人位置以上像素点,去除小人底座颜色防止与目标颜色相同,计算百分比,得到目标颜色,通过目标颜色的最大最小xy坐标(颜色边界),计算出中心点,在计算出中心点与小人的距离,推算时间。使用Robot控制截图并鼠标点击.。

      并没有准确的找到目标物的中心点,而是找到目标物的顶点,通过小人最底部的颜色确定小人的位置,如果使用OpenCV会更好。

    3、还存在的问题:

      1、小人和目标物的距离和按键时长的关系,好像是指数形式,并不是简单的直线

      2、不同手机的分辨率不同,需要调整按键时长系数和始扫描行。

        3、代码优化,方法全部放在了main里面了,摘出来发现有线程问题,未做优化。待解决也希望指正。

     

    直接复制以下代码即可运行,另外需要写好的批处理文件:

    package com.cyd.util;

    import java.awt.AWTException;
    import java.awt.Graphics2D;
    import java.awt.MouseInfo;
    import java.awt.Point;
    import java.awt.Robot;
    import java.awt.Transparency;
    import java.awt.image.BufferedImage;
    import java.io.File;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.LineNumberReader;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Map.Entry;

    import javax.imageio.ImageIO;

    public class RobotT1T_2 {

    static String file1 = "E:\\adb\\1.png";
       static String file2 = "E:\\adb\\2.png";

       //始 扫描行,针对不同的手机分辨率可能不一样,需要修改
       static int start_y = 300;

       //按键时长系数,针对不同的手机按键时长可能不一样,需要680.6258244648354的值
       static final double time_out = (680.6258244648354 / 563.8129122324177);

       static boolean istest = false;
       static boolean is_qz = false;
       static boolean is_qz_1 = false;
       static boolean is_qz_2 = false;

       public static void main(String[] args) throws AWTException, InterruptedException, IOException {
    istest = true;

           // is_qz=true;
           // is_qz_1 = true;
           is_qz_2 = true;
           while (true) {
    System.out.println("+++++++++++++");
               if (istest) {
    cmd_java("cmd /c start adb.bat ", "E:\\adb\\cofface_adb\\cofface_adb_windows_v5.1");//批处理文件
               }
    BufferedImage bi = (BufferedImage) ImageIO.read(new File(file1));
               Map<String, String> map = new HashMap<String, String>();

               // 获取图像的宽度和高度
               int width = bi.getWidth();
               int height = bi.getHeight();

               int poix = 0;
               int poiy = 0;

               BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
               Graphics2D g2d = img.createGraphics();
               // 设置画布为透明
               img = g2d.getDeviceConfiguration().createCompatibleImage(width, height, Transparency.TRANSLUCENT);
               // 扫描图片
               for (int i = start_y; i < height; i++) {
    for (int j = 0; j < width; j++) {// 行扫描
                       int dip = bi.getRGB(j, i);
                       int p = dip;
                       int red = 0xff & (p >> 16);
                       int green = 0xff & (p >> 8);
                       int blue = 0xff & p;
                       // 目标人图形
                       if (i < (height / 1.5)) {
    if ((red > 30 && red < 70) && (green > 40 && green < 70) && (blue > 60 && blue < 110)) {// 获取小人颜色
                               int cyd = 6;
                               RGB rgb_1 = dipToRgb(bi, j + cyd, i + cyd);
                               RGB rgb_2 = dipToRgb(bi, j - cyd, i - cyd);
                               RGB rgb_3 = dipToRgb(bi, j - cyd, i + cyd);
                               RGB rgb_4 = dipToRgb(bi, j + cyd, i - cyd);
                               if (istrueren(rgb_1) && istrueren(rgb_2) && istrueren(rgb_3) && istrueren(rgb_4)) {
    img.setRGB(j, i, dip);
                                   if (poiy < i) {
    if (red == 54 && green == 60 && blue == 102) {
    if (bi.getRGB(j + 1, i) == dip) {
    poix = j;
                                               poiy = i;
                                           }
    }

    }

    }
    }
    }

    }
    }

    for (int rgb_ox = 0; rgb_ox < 10; rgb_ox++) {
    for (int rgb_ox_y = 0; rgb_ox_y < 10; rgb_ox_y++) {
    try {
    img.setRGB(poix + rgb_ox, poiy + rgb_ox_y, -2559242);
                       } catch (Exception e) {
    }
    }
    }

    int fd_rgb = 10;// 颜色差
               int qs_rgb_x = 0;
               int qs_rgb_y = 0;
               int qs_index = 0;
               int rgb_oxrgb = -13091994;
               boolean is_mbh = false;
               System.out.println();
               for (int y = start_y; y < poiy; y++) {// 行扫描
                   RGB rgb_0 = dipToRgb(bi, 0, y);
                   for (int x = 1; x < width; x++) {
    /***** 去掉目标人颜色 */

                       int dip = bi.getRGB(x, y);
                       int p = dip;
                       int red = 0xff & (p >> 16);
                       int green = 0xff & (p >> 8);
                       int blue = 0xff & p;
                       // 目标人图形
                       if (y < (height / 1.5)) {
    if ((red > 30 && red < 70) && (green > 40 && green < 70) && (blue > 60 && blue < 110)) {// 获取小人颜色
                               int cyd = 6;
                               RGB rgb_1 = dipToRgb(bi, x + cyd, y + cyd);
                               RGB rgb_2 = dipToRgb(bi, x - cyd, y - cyd);
                               RGB rgb_3 = dipToRgb(bi, x - cyd, y + cyd);
                               RGB rgb_4 = dipToRgb(bi, x + cyd, y - cyd);
                               if (istrueren(rgb_1) && istrueren(rgb_2) && istrueren(rgb_3) && istrueren(rgb_4)) {
    //img.setRGB(x, y, dip);
                                   continue;
                               }
    }
    }
    if (x < (poix + 55) && x > (poix - 55) && y > (poiy - 240))
    continue;
                       /***** 去掉目标人颜色 */

                       RGB rgb_1 = dipToRgb(bi, x, y);
                       img.setRGB(x, y, bi.getRGB(x, y));
                       if (rgb_cz(rgb_0, rgb_1, fd_rgb)) {// 同一种颜色
                           continue;
                       } else {
    qs_rgb_y = y;
                           if (!is_mbh) {
    qs_rgb_x = x;
                           }

    qs_index++;
                           is_mbh = true;

                           for (int rgb_ox = 0; rgb_ox < 10; rgb_ox++) {
    for (int rgb_ox_y = 0; rgb_ox_y < 10; rgb_ox_y++) {
    try {
    img.setRGB(x + rgb_ox, y + rgb_ox_y, rgb_oxrgb);
                                   } catch (Exception e) {
    }
    }
    }
    }

    }
    if (is_mbh) {
    break;
                   }
    }
    qs_rgb_x = qs_rgb_x + (qs_index / 2);
               // System.out.println("目标物坐标:"+qs_rgb_x+" "+qs_rgb_y);
               int ox_x = qs_rgb_x;
               int ox_y = qs_rgb_y + 40;
               poiy -= 10;
               // System.out.println("目标人:" + poix + "\t" + poiy);
               // System.out.println("中心点:" + ox_x + "\t" + ox_y);

               for (int rgb_ox = 0; rgb_ox < 10; rgb_ox++) {
    for (int rgb_ox_y = 0; rgb_ox_y < 10; rgb_ox_y++) {
    img.setRGB(ox_x + rgb_ox, ox_y + rgb_ox_y, rgb_oxrgb);
                   }
    }
    int z_i = (poix - ox_x) * (poix - ox_x) + (ox_y - poiy) * (ox_y - poiy);
               double math_i = (double) Math.sqrt(z_i);
               System.out.println("最终距离:" + math_i);
               ImageIO.write(img, "png", new File(file2));
               double end_time_out = (math_i * time_out);
               if (math_i < 250) {
    end_time_out += 13;
               }
    System.out.println("按键时长:" + end_time_out);
               if (istest) {
    cmd_java("cmd /c start adb shell input swipe " + 500 + " " + 1650 + " " + 510 + " " + 1650 + " "
                           + (int) end_time_out);
               }
    Thread.sleep(1000);
           }
    }

    /**
        * 判断小人颜色
        *
        * @param rgb
        * @return
        */
       public static boolean istrueren(RGB rgb) {
    if (rgb == null) {
    return true;
           }
    int red = rgb.getRed();
           int green = rgb.getGreen();
           int blue = rgb.getBlue();
           if ((red > 30 && red < 70) && (green > 40 && green < 70) && (blue > 60 && blue < 110)) {// 获取小人颜色
               return true;
           }
    return false;
       }

    static InputStreamReader ir = null;
       static LineNumberReader input = null;

       public static void cmd_java(String cmd) throws IOException {
    Process process = Runtime.getRuntime().exec(cmd, null, new File("C:\\Users\\chenyd\\adb"));
           ir = new InputStreamReader(process.getInputStream());
           input = new LineNumberReader(ir);
           while (input.readLine() != null) {
    }
    input.close();
           ir.close();
       }

    public static void cmd_java(String cmd, String url) throws IOException {
    Process process = Runtime.getRuntime().exec(cmd, null, new File(url));
           ir = new InputStreamReader(process.getInputStream());
           input = new LineNumberReader(ir);
           while (input.readLine() != null) {
    }
    input.close();
           ir.close();
       }

    /**
        * 颜色的差值
        */
       public static boolean rgb_cz(RGB rgb_1, RGB rgb_2, int fd_rgb) {
    if (Math.abs(rgb_1.getRed() - rgb_2.getRed()) > fd_rgb || Math.abs(rgb_1.getGreen() - rgb_2.getGreen()) > fd_rgb
    || Math.abs(rgb_1.getBlue() - rgb_2.getBlue()) > fd_rgb) {
    return false;
           }
    return true;
       }

    public static RGB dipToRgb(BufferedImage bi, int j, int i) {
    try {
    int dip = bi.getRGB(j, i);
               int p = dip;
               int red = 0xff & (p >> 16);
               int green = 0xff & (p >> 8);
               int blue = 0xff & p;
               return new RGB(j, i, red, green, blue);
           } catch (Exception e) {

    }
    return null;
       }

    }

    class RGB {

    public RGB() {
    }

    public RGB(int x, int y, int red, int green, int blue) {
    super();
           X = x;
           Y = y;
           this.red = red;
           this.green = green;
           this.blue = blue;
       }

    public int X;
       public int Y;
       public int red;
       public int green;
       public int blue;

       public int getRed() {
    return red;
       }

    public void setRed(int red) {
    this.red = red;
       }

    public int getGreen() {
    return green;
       }

    public void setGreen(int green) {
    this.green = green;
       }

    public int getBlue() {
    return blue;
       }

    public void setBlue(int blue) {
    this.blue = blue;
       }

    public int getX() {
    return X;
       }

    public void setX(int x) {
    X = x;
       }

    public int getY() {
    return Y;
       }

    public void setY(int y) {
    Y = y;
       }

    }

     

    END


    作者:litblack

    来源:https://www.cnblogs.com/litblank/p/8267526.html

    本文版权归原作者所有。转载文章仅为传播更多信息之目的,如有侵权请与我们联系,我们将及时处理。


    文末福利:关注java工会后台回复

    “加群”:阿里大神和资深HR为你答疑解惑

    “粉丝群”:加小编微信拉你进粉丝群

    “视频”:100G+免费学习视频,近期有更新

    “书籍”:1000+册技术电子书,最近新增30本电子书


    精彩文章推荐

    640?wx_fmt=jpeg

    展开全文
  • 新中国象棋外挂java语言) 工作原理: 1.抓取屏幕信息 2.象棋引擎信息处理 3.点击屏幕 4.重复以上步骤 使用的开源框架: openimaj 使用: 目前只适用于14寸的笔记本,先打开新中国棋盘(注意不要移动棋盘,棋盘不...
  • 欢迎下载研究交流,使用步骤:打开进程->输入搜索的数据->开始搜索->改变游戏中的数据->搜索变化->内存修改! 解压后,包含三个文件: ...第三个是打包好的EXE安装包,可以在没有Java环境的电脑上运行
  • Java游戏外挂基础

    千次阅读 2020-10-15 14:25:40
    import java.awt.*; import java.awt.event.InputEvent; import java.awt.event.KeyEvent;... * 游戏外挂基础 * @param args * @throws AWTException */ public static void main(String[] args) thr
    package com.robit.test;
    
    import java.awt.*;
    import java.awt.event.InputEvent;
    import java.awt.event.KeyEvent;
    
    public class Test1 {
    
        /**
         * 游戏外挂基础
         * @param args
         * @throws AWTException
         */
        public static void main(String[] args) throws AWTException {
            keyTest();
            mouseTest();
            colorTest();
        }
    
        /**
         * 模拟键盘点击,弹起
         * @throws AWTException
         */
        public static void keyTest() throws AWTException {
            Robot robot = new Robot();
            while(true){
                robot.delay(500);
                robot.keyPress(KeyEvent.VK_K);//按下键盘 K键
                robot.keyRelease(KeyEvent.VK_K);//释放键盘 K键
            }
        }
        /**
         * 模拟鼠标移动,点击,释放
         */
        public static void mouseTest() throws AWTException {
            Robot robot = new Robot();
            robot.mouseMove(0,0);//鼠标移动到(0,0)
            robot.delay(500);
            robot.mouseMove(500,600);
            robot.delay(500);
            robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);//按下鼠标左键
            robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);//释放鼠标左键
        }
    
        /**
         * 获得颜色
         */
        public static void colorTest() throws AWTException {
            Robot robot = new Robot();
            Color pixelColor = robot.getPixelColor(500, 600);
            System.out.println(pixelColor);
        }
    }
    
    
    
    展开全文
  • java中的并发工具类一:等待多线程完成的CountDownLatchCountDownLatch允许一个或多个线程等待其他线程完成操作。package com.fuzhulei;import java.util.concurrent.*;​/*** 减法计数器,主要是countDown(计数器1)...

    java中的并发工具类

    一:等待多线程完成的CountDownLatch

    CountDownLatch允许一个或多个线程等待其他线程完成操作。

    package com.fuzhulei;

    import java.util.concurrent.*;

    /**

    * 减法计数器,主要是countDown(计数器1) 和 await(阻塞)方法,只有当计数器减为0的时候,当前线程才可以往下继续执行。

    * 主要用于允许一个或多个线程等待其他线程完成操作

    * @author Huxudong

    * @createTime 2020-04-05 00:04:36

    **/

    public class CountDownDemo {

    public static void main(String[] args) throws InterruptedException {

    /** 使用其构造函数,创建一个数值为6的计数器 */

    CountDownLatch countDownLatch = new CountDownLatch(6);

    /** 自定义线程池使用 */

    ExecutorService pool = new ThreadPoolExecutor(

    6, // 核心线程池大小

    9, // 最大线程池的大小(根据是IO密集型,还是CPU密集型来确定大小)

    3L, // 超时等待时间

    TimeUnit.SECONDS, // 时间的单位

    new LinkedBlockingQueue<>(5), // 阻塞队列是哪一种

    Executors.defaultThreadFactory(), // 默认线程创建工厂

    new ThreadPoolExecutor.AbortPolicy() // 四大拒绝策略,选择一种

    );

    try{

    for (int i = 0; i < 6; i++) {

    /** 这个线程的提交,没有返回值的任务 */

    pool.execute(()->{

    countDownLatch.countDown();

    System.out.println(Thread.currentThread().getName()+"执行一次减法");

    });

    }

    } catch(Exception e) {

    e.printStackTrace();

    } finally {

    /** 关闭线程池 */

    pool.shutdown();

    }

    countDownLatch.await();

    System.out.println("执行完成了");

    }

    }

    正确执行结果:

    fe534562ed6bf7cafad9ad8ffa8b9dee.png

    但是如果我们设置计数器的容量大于6的话(相对于我的程序而言),就会被阻塞在那里

    6eb51f7b35dba8157e3ab288fdf043b5.png

    会发现执行完成了 没有被打印出来,而且程序一直没有停止,这个时候就是因为计数器没有归0,所以当前线程被阻塞,不能向下面继续进行。

    二:同步屏障CyclicBarrier

    CyclicBarrier的翻译大致就是可循环的屏障。它主要的作用就是让一组线程到达一个屏障(也可以叫做同步点)时被阻塞,直到最后一份线程到达屏障时,屏障才会开门,所有被屏障拦截的线程才会继续运行。

    package com.fuzhulei;

    import java.util.concurrent.BrokenBarrierException;

    import java.util.concurrent.CyclicBarrier;

    /**

    * CyclicBarrier是一个加法计数器,即同步屏障,可循环的屏障,让一组线程到达一个屏障(也可以叫做同步点)时被阻塞,直到最后一个线程到达屏障,达到了一开始初始化的屏障的数值,

    * 屏障才可以打开门,所有被拦截的线程才可以继续工作,主要是通过调用await方法来实现的

    * @author Huxudong

    * @createTime 2020-04-04 22:53:50

    **/

    public class CyclicBarrierDemo {

    public static void main(String[] args) {

    CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

    new Thread(()->{

    try {

    cyclicBarrier.await();

    } catch (InterruptedException e) {

    e.printStackTrace();

    } catch (BrokenBarrierException e) {

    e.printStackTrace();

    }

    System.out.println("线程A已经到达屏障");

    },"A").start();

    new Thread(()->{

    try {

    cyclicBarrier.await();

    } catch (InterruptedException e) {

    e.printStackTrace();

    } catch (BrokenBarrierException e) {

    e.printStackTrace();

    }

    System.out.println("线程B已经到达屏障");

    },"B").start();

    new Thread(()->{

    try {

    cyclicBarrier.await();

    } catch (InterruptedException e) {

    e.printStackTrace();

    } catch (BrokenBarrierException e) {

    e.printStackTrace();

    }

    System.out.println("线程C已经到达屏障");

    },"C").start();

    }

    }

    执行的结果如下:

    d30cb4b86b755dd51a0fcffc25d49dee.png

    但是如果把定义的容量大于3(相对于我的程序而言),就会发现什么都不会输出了,看截图

    3bd60502f01474fa57b0a0893a220f8f.png

    并且程序一直还没有停止,这就是屏障起到了作用,因为屏障要求至少需要4个(假设),但是此时只有三个线程到达,所以不满足,屏障就一直阻拦不放路,那么所有的线程也就被阻塞不能向下面继续运行,除非知道第四个过来,满足条件才会运行。

    三:控制并发线程数的Semaphore

    用来控制同时访问特定资源的线程数量,通过协调各个线程,以保证合理的使用公用的资源。

    package com.fuzhulei;

    import java.util.concurrent.*;

    /**

    * 用来控制同时访问特定资源的线程数量,通过协调各个线程,以保证合理的使用公用的资源

    * @author Huxudong

    * @createTime 2020-04-04 23:45:29

    **/

    public class SemaphoreDemo {

    public static void main(String[] args) {

    Semaphore semaphore = new Semaphore(5);

    ExecutorService pool = new ThreadPoolExecutor(

    10,

    20,

    3L,

    TimeUnit.SECONDS,

    new LinkedBlockingQueue<>(20),

    Executors.defaultThreadFactory(),

    new ThreadPoolExecutor.AbortPolicy());

    try{

    for (int i = 0; i < 60; i++) {

    pool.execute(() ->{

    try {

    semaphore.acquire();

    System.out.println(Thread.currentThread().getName()+"限流成功");

    semaphore.release();

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    });

    }

    } catch(Exception e) {

    e.printStackTrace();

    } finally {

    pool.shutdown();

    }

    }

    }

    执行的结果如下:

    7a8cceeccc48aff48557085f9d9e650e.png

    例如:数据库资源,假如需要读取几十万个数据的文件,因为都是IO密集型任务,所以开了2倍的处理器+1个线程数(IO密集型,所以线程可以多一些,让cpu忙起来,因为IO操作的时候,很少操作Cpu)

    但是如果读到内存后,还需要存储到数据库中,但是数据库连接我们设置的加入就10个,所以我们必须控制只有10个线程可以同时访问数据库连接保存数据,否则会报错无法连接数据库异常。

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • RobotUtil 是基于 java 自带的 Robot API 封装的一个工具类,用于方便模拟鼠标和键盘操作,对鼠标的移动、按下、释放,键盘的按下、释放、输入,屏幕颜色的判断等做了封装。
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼class Test{public static void main(String[] args){TixingMainji t = new TixingMainji(8.3, 6, 3.5);double mianji = t.getMianji();System.out.println("面积是:" +...
  • Linux JDK 编译安装

    2021-03-08 09:08:21
    [Linux] JDK 编译安装概述我们在java开发时基本会使用Oracle或者一些权威的开源组织提供的JDK,很少使用自己编译的版本.但是如果你想学习JVM或者自己做一些特殊的用途,自己会编译JDK是有必要学习的.环境...
  • java游戏脚本吗?

    千次阅读 2021-02-12 11:37:18
    java游戏脚本。Java是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征,可以做到编译游戏脚本。java游戏脚本...
  • 我用Java写的象棋外挂成功了

    千次阅读 热门讨论 2017-06-12 20:53:31
    首先要想办法获得当前棋局的fen序列 FEN(Forsyth-Edwards Notation)是专门用来表示象棋局面的记录规范,在这个规范下,一个局面可以简单地用一行“FEN格式串”来表示,而不必烦琐地说:“红帅在四路次底线,黑将在5...
  • LOL-Cat:Java脚本

    2021-02-12 14:27:39
    LOL-Cat:Java脚本
  • 本篇文章主要运用java中的Robot类,实现Microsoft Store微软商店中《别踩白块-钢琴大师》游戏的全自动脚本功能,原理非常简单,十分适合初学者学习。 Robot类的介绍 Robot类用于为测试自动化、自运行演示程序...
  • 1)编写mytest.py完成一个简单加法计算# coding:utf8#def 表示一个方法 adderdef adder(a, b):return a+b#这里执行adder方法并打印出...3)java调用python脚本的两种方式Process process = Runtime.getRuntime().ex...
  • 主要介绍了秒杀京东手机的程序,实现了下面三个功能,大家参考使用吧
  • Java实现DDD中UnitOfWorkdnf卡盟Java的泛型详解泛型的利益编写的代码可以被差别类型的工具所重用。由于上面的一个优点,泛型也可以削减代码的编写。泛型的使用简朴泛型类public class Pair {private T first;private...
  • //此处为我的包名删除即可//以下三个包需要导入JNA库,JNA的官网:https://github.com/java-native-access/jna#jna//JNA的安装链接:https://pan.baidu.com/s/1qNRGLU06V1oAx3gp0uKBBg 密码:pfbz 该链接有效时间为7...
  • java外挂

    千次阅读 2016-07-22 21:17:25
    import java.io.*; public class Main { public static void main(String[] args) throws IOException // in.nextTokenizer可能抛出这个异常 { StreamTokenizer in = new StreamTokenizer(new Buff
  • 这两天学了面向对象 并在今天练习了封装 回来再看这个外挂代码恍然大悟 原来这个代码的dalao用了封装这个操作 这两张图片中用橙色圈起来的 根据这两天所学知识 作者定义了类之后 使用了FKset BMP等方法 而在上一...
  • 关于利用JAVA开发游戏外挂的几点思考

    万次阅读 热门讨论 2007-10-27 20:51:00
    能够利用JAVA来编游戏外挂,这真的是一个让人很感兴趣的话题。在讨论这个题目之前,我们首先来给不玩网络游戏的人补一下课,首先网络游戏的概念大家应该都是知道了,从虾米最早接触的文字MUD《重出江湖》,一直到...
  • 数字证书:从文件中读取数字证书,生成文件输入流,输入文件为c:/mycert.cer,获取一个处理X.509证书的证书工厂…… Java+ajax的登录实例 1个目标文件 内容索引:Java源码,初学实例,ajax,登录 一个Java+ajax的...
  • 自己当时学Java时,的一个类似于QQ的软件,希望对初学者有用!
  • Java外挂开发之内存修改器(类似CE)

    万次阅读 多人点赞 2016-12-09 21:44:55
    当然我只会Java,C++嘛,了解了解,嘿嘿,所以这个工具也是用Java写的 这个工具在写内存搜索时,简直累死了,最开始暴力搜索,效率慢的要死,经过三天的不懈努力,终于搞定这搜索功能!这也是整个工具最难的部分,...
  • Java语言,为“新寻仙”网游的一款辅助工具,主要功能为自动打怪、交易自动扫货,附属一些键盘连按、鼠标连点、等等小功能。 用Java实现Windows平台下的模拟鼠标、按键、找图找色,实现按键精灵的功能。 目录...
  • java开源包101

    2016-07-13 10:11:08
    PortGroper 是一款java写的开源拒绝服务测试工具,它不是僵尸网络类的ddos,而是使用大量的代理作为bots发起DDOS。Port Groper可以与用测试防火墙,干扰web 统计脚本的跟踪,为网站增加流量..往好了用什么都能干,就是...
  • java写外挂因为有虚拟机的原因所以不容易被游戏检查到; 这里我们用到awt的一个机器人类 Robot robot = new Robot(); 一、键盘按下抬起api robot.keyPress(KeyEvent.VK_K); robot.keyRelease(KeyEvent.VK_K); ...
  • 疯狂JAVA讲义

    2017-11-25 17:14:29
    当笔者开始写作本书之前,已经接触了非常多刚刚毕业...于是笔者告诉他们:如果我来上C语言,至少讲到可以编写出一个简单的游戏外挂,如果再深入一点,可以结合操作系统理论,编写一个操作系统的雏形——这才叫程序。
  • 简介网上说的有两种比较公平的算法,一种是二倍均值法,一种是线段切割法。下面我们介绍下两种算法的实现:二倍均值法原理剩余红包金额M,剩余人数N,那么:每次抢到金额=随机(0,M/N*2)保证了每次随机金额的平均值...
  • Java内存模型

    2021-03-16 21:31:29
    Java内存模型Why 为什么要有内存模型1 CPU和缓存一致性问题当程序在运行过程中,会将运算需要的数据从主存复制一份到CPU的高速缓存当中,那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据,当...
  • Java外挂开发入门示例

    2009-01-09 20:37:33
    "Java外挂开发入门示例" );   this .setLocationRelativeTo( null );   this .addWindowListener( new WindowAdapter() {   public void windowClosing(WindowEvent e) {  System.exit(0);  }  });  }  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,018
精华内容 2,407
关键字:

java写外挂

java 订阅