求一份最新的过检测和
求一份最新的过检测和 求一份最新的过检测和 求一份最新的过检测和 求一份最新的过检测和求一份最新的过检测和
求一份最新的过检测和
求一份最新的过检测和
求一份最新的过检测和
求一份最新的过检测和
求一份最新的过检测和
qq787003274.版本 2
.程序集 获取数据
.子程序 矩阵搜索
.局部变量 矩阵数组, 整数型, , "0"
.局部变量 tamp, 整数型
.局部变量 n
.局部变量 k, 小数型
.局部变量 k1, 小数型
.局部变量 i, 整数型
.判断循环首 (真)
.如果真 (驱动.读小数型 (矩阵地址 ＋ 56) ＝ 3 且 矩阵地址 ≠ 0)
返回 ()
.如果真结束
内存搜索_极速 (PID, “AB AA AA 3E 00 00 00 80 00 00 00 80 00 00 80 3F 00 00 00 80 61 8B 98 3F”, 十六到十 (“40000000”), 真, , 矩阵数组)
.计次循环首 (取数组成员数 (矩阵数组), i)
.如果真 (驱动.读字节集 (矩阵数组 ＋ 十六到十 (“3B8”), 4) ＝ { 0, 0, 0, 128 })
矩阵地址 ＝ 矩阵数组 ＋ 268 － 56
本人地址 ＝ 矩阵地址 － 16
跳出循环 ()
.如果真结束
.计次循环尾 ()
内存优化 (-1)
.判断循环尾 ()
.子程序 获取地址
.局部变量 Temp, 整数型, , "0"
.局部变量 Temp1, 整数型, , "0"
.局部变量 Temp2, 整数型, , "0"
.判断循环首 (真)
Sleep (3000)
内存搜索_极速 (PID, “B8 07 ?? ?? 00 00 20 00”, 1073741824, 真, , Temp)
对象数组 ＝ Temp
视角地址 ()
模型地址 ()
拍下加速 ()
游戏亮度 ()
傻逼寒冰 ()
.判断循环尾 ()
.子程序 傻逼寒冰
.如果真 (视角Y地址 ≠ 0)
.如果 (驱动.读字节集 (视角Y地址 ＋ 16, 21) ＝ { 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 64, 1, 0, 0, 0, 0, 0, 0, 0 })
返回 ()
.否则
.如果结束
.如果真结束
内存模糊搜索X64 (PID, “FF FF FF FF 00 00 00 00 00 00 00 00 40 01 00 00 00 00 00”, 准心数组, 0, 6442450942)
.如果真 (取数组成员数 (准心数组) ≠ 0)
视角Y地址 ＝ 准心数组 － 16
视角X地址 ＝ 准心数组 － 12
.如果真结束
.子程序 视角地址
.局部变量 n, 整数型
.局部变量 判断, 整数型
.如果 (_启动窗口.模拟器.现行选中项 ＝ 0)
.如果真 (模型地址 ≠ 0)
.如果 (驱动.读整数型 (驱动.读整数型 (模型地址 － 288 ＋ 180) ＋ 20) ＝ 1)
返回 ()
.否则
.如果结束
.如果真结束
内存模糊搜索X64 (PID, “04 C0 ?? ?? 00 00 20 00”, 上帝数组, 0, 6442450942)
.计次循环首 (取数组成员数 (上帝数组), n)
.如果真 (驱动.读整数型 (驱动.读整数型 (上帝数组 ＋ 180) ＋ 20) ＝ 1)
上帝地址 ＝ 上帝数组 ＋ 288
跳出循环 ()
.如果真结束
.计次循环尾 ()
.否则
.如果真 (上帝地址 ≠ 0)
.如果 (驱动.读整数型 (上帝地址 － 104) ＝ -88)
返回 ()
.否则
.如果结束
.如果真结束
内存模糊搜索X64 (PID, “04 C0 ?? ?? 00 00 20 00”, 上帝数组, 0, 6442450942)
.计次循环首 (取数组成员数 (上帝数组), n)
.如果真 (驱动.读整数型 (上帝数组 ＋ 288 － 104) ＝ -88)
上帝地址 ＝ 上帝数组 ＋ 288
跳出循环 ()
.如果真结束
.计次循环尾 ()
.如果结束
.子程序 模型地址
.局部变量 n, 整数型
.局部变量 判断, 整数型
.判断开始 (_启动窗口.模拟器.现行选中项 ＝ 0)
.如果真 (模型地址 ≠ 0)
.如果 (驱动.读整数型 (驱动.读整数型 (模型地址 － 288 ＋ 180) ＋ 20) ＝ 1)
返回 ()
.否则
.如果结束
.如果真结束
内存模糊搜索X64 (PID, “AC 79 ?? ?? 08 00 04 00 ?? ?? ?? 00 00 ?? ?? ?? ?? 72”, 模型数组, 0, 6442450942)
.计次循环首 (取数组成员数 (模型数组), n)
.如果真 (驱动.读整数型 (驱动.读整数型 (模型数组 ＋ 180) ＋ 20) ＝ 1)
模型地址 ＝ 模型数组 ＋ 288
跳出循环 ()
.如果真结束
.计次循环尾 ()
.默认
.如果真 (模型地址 ≠ 0)
.如果 (驱动.读小数型 (模型地址 － 104) ＝ -88)
返回 ()
.否则
.如果结束
.如果真结束
内存模糊搜索X64 (PID, “AC 79 ?? ?? 08 00 04 00 ?? ?? ?? 00 00 ?? ?? ?? ?? 72”, 模型数组, 0, 6442450942)
.计次循环首 (取数组成员数 (模型数组), n)
.如果真 (驱动.读整数型 (模型数组 ＋ 288 － 104) ＝ -88)
模型地址 ＝ 模型数组 ＋ 288
_启动窗口.编辑框3.加入文本 (十到十六 (模型地址) ＋ #换行符)
跳出循环 ()
.如果真结束
.计次循环尾 ()
.判断结束
.子程序 屏幕不晃
.局部变量 n, 整数型
.局部变量 判断, 整数型
.如果真 (超级无后 ≠ 0)
.如果 (驱动.读整数型 (超级无后 ＋ 140) ＝ 10000)
返回 ()
.否则
.如果结束
.如果真结束
内存模糊搜索X64 (PID, “40 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ?? ?? ?? ?? 01 00 00”, 无后数组, 0, 6442450942)
.计次循环首 (取数组成员数 (无后数组), n)
.如果真 (驱动.读整数型 (无后数组 ＋ 140) ＝ 10000)
超级无后 ＝ 无后数组
跳出循环 ()
.如果真结束
.计次循环尾 ()
.子程序 拍下加速
.局部变量 n, 整数型
.局部变量 调试, 整数型
.如果真 (加速地址 ≠ 0)
.如果 (驱动.读小数型 (加速地址 ＋ 1680) ＝ -88)
返回 ()
.否则
.如果结束
.如果真结束
内存搜索_极速 (PID, “00 00 80 3F 00 ?? ?? ?? 00 ?? ?? ?? 00 00 ?? 43 ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? 00 00 00 00 00 00 ?? 40 00 00 80 3F 00 00 00 00”, 268435456, 真, , 加速数组)
.计次循环首 (取数组成员数 (加速数组), n)
.如果真 (驱动.读小数型 (加速数组 ＋ 1680) ＝ -88)
加速地址 ＝ 加速数组
_启动窗口.编辑框3.加入文本 (十到十六 (加速地址) ＋ #换行符)
跳出循环 ()
.如果真结束
.计次循环尾 ()
.子程序 W美无后
.局部变量 W美无后坐, 长整数型, , "0"
.局部变量 n, 整数型
.局部变量 开启无后, 整数型
.局部变量 无抖动, 整数型, , "0"
.局部变量 i, 整数型
.局部变量 抖动1, 长整数型, , "0"
.局部变量 m, 整数型
.局部变量 瞬间击中2, 整数型, , "0"
.局部变量 h, 整数型
.局部变量 无抖动1, 整数型, , "0"
.局部变量 w, 整数型
.局部变量 抖动开启, 整数型
内存模糊搜索X64 (PID, “66 0F ?? ?? 00 66 0F 7E ?? 90 00 00 00 8B ?? 90 00 00 00 89 ?? 30”, W美无后坐, 0, 6442450942)
.计次循环首 (取数组成员数 (W美无后坐), n)
.如果真 (驱动.读字节集 (W美无后坐 ＋ 15, 5) ＝ { 144, 0, 0, 0, 137 })
驱动.写字节集 (W美无后坐 ＋ 15, 4, { 172, 1, 0, 0 })
.如果真结束
.计次循环尾 ()
内存模糊搜索X64 (PID, “88 ?? B0 0E 00 00 8B ?? 10 06 00 00 89 ?? B4 0E 00 00 8B ?? 00”, 抖动1, 0, 6442450942)
.计次循环首 (取数组成员数 (抖动1), m)
.如果真 (驱动.读字节集 (抖动1 ＋ 8, 4) ＝ { 16, 6, 0, 0 })
驱动.写字节集 (抖动1 ＋ 8, 4, { 16, 1, 0, 0 })
.如果真结束
.计次循环尾 ()
.子程序 瞬间击中
.局部变量 开启瞬间, 整数型
.局部变量 瞬间击中2, 长整数型, , "0"
.局部变量 h, 整数型
内存模糊搜索X64 (PID, “8B ?? 90 00 00 00 89 ?? 34 C7 ?? ?? ?? ?? ?? ?? 8B”, 瞬间击中2, 0, 6442450942)
.计次循环首 (取数组成员数 (瞬间击中2), h)
.如果真 (驱动.读字节集 (瞬间击中2 , 6) ＝ { 139, 133, 144, 0, 0, 0 })
驱动.写字节集 (瞬间击中2 , 6, { 184, 0, 36, 116, 73, 144 })
.如果真结束
.如果真 (驱动.读字节集 (瞬间击中2 , 6) ＝ { 139, 157, 144, 0, 0, 0 })
驱动.写字节集 (瞬间击中2 , 6, { 187, 0, 36, 116, 73, 144 })
.如果真结束
.如果真 (驱动.读字节集 (瞬间击中2 , 6) ＝ { 139, 141, 144, 0, 0, 0 })
驱动.写字节集 (瞬间击中2 , 6, { 185, 0, 36, 116, 73, 144 })
.如果真结束
.如果真 (驱动.读字节集 (瞬间击中2 , 6) ＝ { 139, 149, 144, 0, 0, 0 })
驱动.写字节集 (瞬间击中2 , 6, { 186, 0, 36, 116, 73, 144 })
.如果真结束
.计次循环尾 ()
.子程序 游戏亮度
.局部变量 n, 整数型
.如果真 (亮度地址 ≠ 0)
.如果 (驱动.读整数型 (亮度地址 ＋ 56 ＋ 116) ＝ 22)
返回 ()
.否则
.如果结束
.如果真结束
内存模糊搜索X64 (PID, “FF ?? ?? ?? ?? 00 00 80 44 00 00 80 44 00 00 80”, 亮度数组, 0, 6442450942)
.计次循环首 (取数组成员数 (亮度数组), n)
.如果真 (驱动.读整数型 (亮度数组 － 7 ＋ 116) ＝ 22)
亮度地址 ＝ 亮度数组 － 7 － 56
返回亮度 ＝ 驱动.读小数型 (亮度地址)
_启动窗口.编辑框3.加入文本 (十到十六 (亮度地址) ＋ #换行符)
跳出循环 ()
.如果真结束
.计次循环尾 ()
.子程序 鼠标检测
.局部变量 CRC地址, 长整数型, , "0"
.局部变量 n, 整数型
.局部变量 鼠标CRC检测, 整数型
内存模糊搜索X64 (PID, “F3 ?? ?? ?? ?? 02 00 00 66 0F ?? ?? 10 ?? 00 00”, CRC地址, 0, 6442450942)
.计次循环首 (取数组成员数 (CRC地址), n)
鼠标CRC检测 ＝ CRC地址
.如果真 (驱动.读字节集 (鼠标CRC检测 － 9, 2) ＝ { 15, 133 })
驱动.写字节集 (鼠标CRC检测 － 9, 2, { 15, 132 })
.如果真结束
.如果真 (驱动.读字节集 (鼠标CRC检测 － 6, 2) ＝ { 15, 133 })
驱动.写字节集 (鼠标CRC检测 － 6, 2, { 15, 132 })
.如果真结束
.如果真 (驱动.读字节集 (鼠标CRC检测 － 6, 2) ＝ { 15, 133 })
驱动.写字节集 (鼠标CRC检测 － 6, 2, { 15, 132 })
.如果真结束
.如果真 (驱动.读字节集 (鼠标CRC检测 － 4, 2) ＝ { 15, 133 })
驱动.写字节集 (鼠标CRC检测 － 4, 2, { 15, 132 })
.如果真结束
.计次循环尾 ()
页:
[1]
