升级
   100%
UID1
金钱23755965
交易币0
贡献262
|
.版本 2
.支持库 spec
.子程序 _按钮2_被单击
.局部变量 遍历, 遍历结构
遍历.基址 ＝ 读长整数 (#司南背包 ＋ 0)
遍历.首址 ＝ 读长整数 (遍历.基址 ＋ #背包指针)
遍历.尾址 ＝ 读长整数 (遍历.基址 ＋ #背包指针 ＋ 8)
遍历.数量 ＝ (遍历.尾址 － 遍历.首址) ÷ 24
.计次循环首 (遍历.数量, 遍历.计次)
遍历.地址 ＝ 读长整数 (遍历.首址 ＋ 24 × (遍历.计次 － 1))
.如果真 (遍历.地址 ＞ 0)
遍历.地址 ＝ 读长整数 (遍历.地址 ＋ 16)
遍历.名称 ＝ ReadString (遍历.地址 ＋ 72)
调试输出 (遍历.名称, 十到十六 (遍历.地址), 遍历.计次, 解密读取 (遍历.地址 ＋ 1448), 读整数型 (遍历.地址 ＋ 64), 读整数型 (遍历.地址 ＋ #物品交易类型))
' 10317421
.如果真结束
.计次循环尾 ()
.版本 2
.子程序 创建CALL, 长整数型
.参数 物品代码, 长整数型
.局部变量 局_CALL字节, 字节集
局_CALL字节 ＝ 局_CALL字节 ＋ { 69, 51, 201 }
局_CALL字节 ＝ 局_CALL字节 ＋ { 65, 176, 1 }
局_CALL字节 ＝ 局_CALL字节 ＋ { 72, 199, 194, 0, 0, 0, 0 }
局_CALL字节 ＝ 局_CALL字节 ＋ { 185 } ＋ 到字节集 (物品代码)
局_CALL字节 ＝ 局_CALL字节 ＋ 转字节集 (“FF 15 02 00 00 00 EB 08”) ＋ 到字节集 (到长整数 (#创建CALL))
返回 (CallBack.调用函数_自动堆栈 (局_CALL字节))
.版本 2
.子程序 丢技能call, , , 伤害低一点 也可以搬砖升级用 我看ct普遍都是带团的
.参数 主人指针, 长整数型
.参数 被攻击指针, 长整数型
.参数 技能代码, 整数型
.参数 白图伤害, 整数型
.参数 团本伤害, 整数型
.参数 X, 整数型
.参数 Y, 整数型
.参数 Z, 整数型
.参数 动作id, 整数型
.参数 技能大小, 整数型
.局部变量 s, 字节集
.局部变量 没分析的基址1, 长整数型
.局部变量 没分析的基址2, 长整数型
.局部变量 没分析的基址3, 长整数型
.局部变量 没分析的偏移1, 整数型
没分析的基址1 ＝ #丢技能CALL_Rcx
没分析的基址2 ＝ #丢技能CALL_1
没分析的基址3 ＝ #丢技能CALL_2
没分析的偏移1 ＝ #丢技能CALL偏移
s ＝ { 51, 192 }
s ＝ s ＋ { 186 } ＋ 到字节集 (技能大小)
s ＝ s ＋ { 72, 163 } ＋ 到字节集 (到长整数 (没分析的基址1 ＋ 16))
s ＝ s ＋ { 72, 187 } ＋ 到字节集 (到长整数 (没分析的基址1 ＋ 8))
s ＝ s ＋ { 72, 184 } ＋ 到字节集 (到长整数 (没分析的基址1 ＋ 16))
s ＝ s ＋ { 72, 99, 8, 72, 139, 3, 102, 137, 20, 1 }
s ＝ s ＋ { 161 } ＋ 到字节集 (到长整数 (没分析的基址1 ＋ 16))
s ＝ s ＋ { 131, 192, 2 }
s ＝ s ＋ { 163 } ＋ 到字节集 (到长整数 (没分析的基址1 ＋ 16))
s ＝ s ＋ { 72, 99, 200 }
s ＝ s ＋ { 72, 161 } ＋ 到字节集 (到长整数 (没分析的基址1 ＋ 8))
s ＝ s ＋ { 199, 4, 1 } ＋ 到字节集 (团本伤害)
s ＝ s ＋ { 72, 141, 76, 36, 32 }
s ＝ s ＋ { 161 } ＋ 到字节集 (到长整数 (没分析的基址1 ＋ 16))
s ＝ s ＋ { 131, 192, 4 }
s ＝ s ＋ { 163 } ＋ 到字节集 (到长整数 (没分析的基址1 ＋ 16))
s ＝ s ＋ { 72, 184 } ＋ 到字节集 (没分析的基址2)
s ＝ s ＋ { 255, 208 }
s ＝ s ＋ { 199, 68, 36, 48 } ＋ 到字节集 (技能代码)
s ＝ s ＋ { 72, 184 } ＋ 到字节集 (主人指针)
s ＝ s ＋ { 72, 137, 68, 36, 32 }
s ＝ s ＋ { 72, 185 } ＋ 到字节集 (被攻击指针)
s ＝ s ＋ { 199, 68, 36, 52 } ＋ 到字节集 (白图伤害)
s ＝ s ＋ { 199, 68, 36, 64 } ＋ 到字节集 (X)
s ＝ s ＋ { 199, 68, 36, 68 } ＋ 到字节集 (Y)
s ＝ s ＋ { 199, 68, 36, 72 } ＋ 到字节集 (Z)
s ＝ s ＋ { 72, 161 } ＋ 到字节集 (被攻击指针)
s ＝ s ＋ { 72, 139, 144 } ＋ 到字节集 (没分析的偏移1)
s ＝ s ＋ { 255, 210, 137, 68, 36, 92, 72, 141, 76, 36, 32 }
s ＝ s ＋ { 161 } ＋ 到字节集 (到长整数 (没分析的基址1 ＋ 16))
s ＝ s ＋ { 137, 68, 36, 120, 72, 99, 3, 72, 137, 132, 36, 128, 0, 0, 0 }
s ＝ s ＋ { 72, 184 } ＋ 到字节集 (没分析的基址3)
s ＝ s ＋ { 198, 132, 36, 165, 0, 0, 0, 1 }
s ＝ s ＋ { 199, 132, 36, 168, 0, 0, 0 } ＋ 到字节集 (动作id)
s ＝ s ＋ { 198, 132, 36, 184, 0, 0, 0, 0, 255, 208 }
' s ＝ { 72, 129, 236, 48, 2, 0, 0 } ＋ s ＋ { 72, 129, 196, 48, 2, 0, 0 }
内存汇编 (s)
.版本 2
.子程序 CD重置CALL
.局部变量 人物指针, 长整数型
.局部变量 汇编数据, 字节集
人物指针 ＝ 读游戏指针 (#人物基址, #GameClassLen)
汇编数据 ＝ 汇编数据 ＋ 还原字节集2 (“48 B9”) ＋ 倒转数据 (长整数据 (人物指针))
汇编数据 ＝ 汇编数据 ＋ 还原字节集2 (“FF 15 02 00 00 00 EB 08”) ＋ 倒转数据 (长整数据 (#CD重置CALL))
CallBack.调用函数_自动堆栈 (汇编数据)
.版本 2
.子程序 Invincible_Hook
.局部变量 btn, 逻辑型, 静态
.局部变量 hook_code, 字节集
.局部变量 hook_base, 长整数型
.局部变量 hook_ret, 长整数型
btn ＝ 取反 (btn)
hook_base ＝ #Hook无敌
hook_ret ＝ hook_base ＋ 535 ' xor al,al
.如果真 (btn ＝ 真)
hook_invincible_basecode ＝ ReadData (hook_base, 18)
hook_code ＝ { 128, 191 } ＋ 到字节集 (#阵营偏移) ＋ { 0 }
hook_code ＝ hook_code ＋ { 116, 13 }
hook_code ＝ hook_code ＋ { 233 } ＋ 到字节集 (到长整数 (hook_ret － hook_base － 取字节集长度 (hook_code) － 5))
WriteData (hook_base, hook_code)
.如果真结束
.如果真 (btn ＝ 假)
WriteData (hook_base, hook_invincible_basecode)
.版本 2
.子程序 材料call
.局部变量 汇编数据, 字节集
.局部变量 物品内存, 整数型
.局部变量 物品地址, 长整数型
物品地址 ＝ 83968
物品内存 ＝ 480
汇编数据 ＝ 还原字节集2 (“48 83 EC 20”)
汇编数据 ＝ 汇编数据 ＋ 还原字节集2 (“48 A1”) ＋ 倒转数据 (长整数据 (#人物基址))
汇编数据 ＝ 汇编数据 ＋ 还原字节集2 (“48 8B 80”) ＋ 倒转数据 (长整数据 (#物品栏))
汇编数据 ＝ 汇编数据 ＋ 还原字节集2 (“48 8B 80”) ＋ 倒转数据 (长整数据 (#物品栏偏移))
汇编数据 ＝ 汇编数据 ＋ 还原字节集2 (“48 8B 78 18”) ' 物品栏一
汇编数据 ＝ 汇编数据 ＋ 还原字节集2 (“48 8B 07”)
汇编数据 ＝ 汇编数据 ＋ 还原字节集2 (“48 8B CF”)
汇编数据 ＝ 汇编数据 ＋ 还原字节集2 (“FF 90”) ＋ 倒转数据 (长整数据 (物品内存))
汇编数据 ＝ 汇编数据 ＋ 还原字节集2 (“48 A3”) ＋ 倒转数据 (长整数据 (物品地址))
汇编数据 ＝ 汇编数据 ＋ 还原字节集2 (“48 83 C4 20 C3”)
内存汇编 (汇编数据)
返回 ()
.子程序 材料拔刀
.局部变量 空白, 整数型
.局部变量 材料开始, 整数型
.局部变量 材料结束, 整数型
材料开始 ＝ #材料开始
材料结束 ＝ #材料结束
材料call ()
超级延时 (500)
读写.写整数型 (进程ID, 读写.读整数型 (进程ID, 83968) ＋ 材料开始, 84224)
读写.写整数型 (进程ID, 读写.读整数型 (进程ID, 83968) ＋ 材料结束, 十六到十 (“14A00”))
读写.写整数型 (进程ID, 84224, 62129)
公告 (“材料准备成功.进图按物品栏1 注意：物品栏1放 生锈的铁皮”)
.版本 2
.子程序 内存BUFF
.参数 buff, buff, 数组
.参数 指针, 长整数型
.局部变量 code, 字节集
.局部变量 i, 整数型
code ＝ { }
code ＝ code ＋ { 185, 99, 0, 0, 0 }
code ＝ code ＋ { 72, 184 } ＋ 到字节集 (到长整q数 (#申请内存))
code ＝ code ＋ { 255, 208 }
code ＝ code ＋ { 72, 137, 68, 36, 72 }
.计次循环首 (取数组成员数 (buff), i)
code ＝ code ＋ { 72, 199, 68, 36, 32 } ＋ 到字节集 (buff [i].加成)
code ＝ code ＋ { 243, 15, 42, 68, 36, 32, 15, 41, 195 }
code ＝ code ＋ { 73, 199, 192 } ＋ 到字节集 (到整数 (buff [i].类型))
code ＝ code ＋ { 186 } ＋ 到字节集 (buff [i].代码)
code ＝ code ＋ { 72, 139, 76, 36, 72 }
code ＝ code ＋ { 72, 139, 1 }
code ＝ code ＋ { 255, 144 } ＋ 到字节集 (#内存Buff_1)
.计次循环尾 ()
code ＝ code ＋ { 72, 141, 68, 36, 88, 72, 139, 248, 51, 192, 185, 16, 0, 0, 0, 243, 170 }
code ＝ code ＋ { 72, 199, 68, 36, 64, 0, 0, 0, 0, 72, 199, 68, 36, 56, 0, 0, 0, 0, 72, 199, 68, 36, 48, 255, 255, 255, 255, 72, 199, 68, 36, 40, 158, 4, 0, 0 }
code ＝ code ＋ { 72, 141, 76, 36, 88 }
code ＝ code ＋ { 72, 137, 76, 36, 32 }
code ＝ code ＋ { 65, 177, 1 }
code ＝ code ＋ { 73, 184 } ＋ 倒转数据 (长整数据 (指针))
code ＝ code ＋ { 72, 186 } ＋ 倒转数据 (长整数据 (指针))
code ＝ code ＋ { 72, 139, 76, 36, 72 }
code ＝ code ＋ { 72, 139, 1 }
code ＝ code ＋ { 255, 144 } ＋ 到字节集 (#内存Buff_2)
code ＝ { 72, 129, 236, 64, 1, 0, 0 } ＋ code ＋ { 72, 129, 196, 64, 1, 0, 0 } ＋ { 195 }
内存汇编 (code)
.子程序 给人物吃buff
.局部变量 无极, buff
.局部变量 buff, buff, , "0"
无极.代码 ＝ 124
无极.类型 ＝ 107
无极.加成 ＝ 到整数 (5000)
加入成员 (buff, 无极)
' 无极.代码 ＝ 124
' 无极.类型 ＝ 1
' 无极.加成 ＝ 到整数 (5000)
' 加入成员 (buff, 无极)
内存BUFF (buff, 驱动.读长整数 (进程ID, #人物基址))
公告 (“内部buff添加成功”)
|
|
发表于 2022-7-18 10:43:07
发表于 2022-7-18 11:26:08
