无聊DE挂挂

啊冲

.版本 2
.支持库 EThread

.程序集 游戏CAll

.子程序 call程序集初始化
.局部变量 游戏进程标识符, 整数型
.局部变量 ID, 整数型

进程句柄 ＝ _启动窗口.角色选择框.取项目数值 (_启动窗口.角色选择框.现行选中项)
输出调试文本 (“call程序集初始化” ＋ “   进程句柄:” ＋ 到文本 (进程句柄))


.子程序 调用游戏call
.参数 调用函数, 字节集
.局部变量 临时句柄, 整数型
.局部变量 线程ID, 整数型
.局部变量 线程首地址, 整数型

.' 如果真 (取数组成员数 (许可证数组) ＜ 5)
    ' 输出调试文本 (“许可证数小于5.”)
    ' 返回 ()
.如果真结束
' 进入许可区 (许可证数组 [5])
线程首地址 ＝ 分配内存虚拟页 (进程句柄, 0, 4096, 4096, 64)
写字节进内存 (进程句柄, 线程首地址, 调用函数, 4096, 0)
临时句柄 ＝ 远程创建线程 (进程句柄, 0, 0, 线程首地址, 0, 4, 线程ID)
运行线程 (临时句柄)
关闭进程 (临时句柄)
' 退出许可区 (许可证数组 [5])


.子程序 调用函数
.参数 调用函数, 字节集
.局部变量 线程句柄, 整数型
.局部变量 线程ID, 整数型
.局部变量 临时地址, 整数型

.如果真 (取数组成员数 (许可证数组) ＜ 5)
    输出调试文本 (“许可证数小于5.”)
    返回 ()
.如果真结束
进入许可区 (许可证数组 [5])
临时地址 ＝ 分配内存虚拟页 (进程句柄, 0, 取字节集长度 (调用函数), 4096, 64)
.如果真 (临时地址 ＝ 0)
    退出许可区 (许可证数组 [5])
    返回 ()
.如果真结束
.如果真 (写字节集内存 (临时地址, 调用函数) ＝ 假)
    释放内存 (临时地址)
    退出许可区 (许可证数组 [5])
    返回 ()
.如果真结束
线程句柄 ＝ 远程创建线程 (进程句柄, 0, 0, 临时地址, 0, 4, 线程ID)
.如果真 (线程句柄 ＝ 0)
    释放内存 (临时地址)
    退出许可区 (许可证数组 [5])
    返回 ()
.如果真结束
运行线程 (线程句柄)
等待远程线程结束 (线程句柄, 1000)
释放内存 (临时地址)
关闭进程 (线程句柄)
退出许可区 (许可证数组 [5])



.子程序 调用发包
.参数 包, 字节集
.参数 长度, 整数型
.局部变量 临时地址, 整数型

' 输出调试文本 (查看字节集 (包))
.如果真 (取数组成员数 (许可证数组) ＜ 10)
    输出调试文本 (“许可证数小于10.”)
    返回 ()
.如果真结束
进入许可区 (许可证数组 [10])
临时地址 ＝ 分配内存 (取字节集长度 (包))
.如果真 (临时地址 ＝ 0)
    返回 ()
.如果真结束
.如果真 (写字节集内存 (临时地址, 包) ＝ 假)
    释放内存 (临时地址)
.如果真结束
汇编_置代码 ()
汇编_PUSHAD ()
汇编_MOV_寄存器_PTR (“ecx”, 游戏基址.游戏基址)
汇编_MOV_寄存器_PTR_寄存器_ADD (“ecx”, “ecx”, 文本到十进制数 (“20”))
汇编_PUSH_常数 (长度)
汇编_MOV_寄存器_常数 (“edx”, 临时地址)
汇编_PUSH_寄存器 (“edx”)
汇编_MOV_寄存器_常数 (“ebx”, 游戏基址.发包地址)
汇编_CALL_寄存器 (“ebx”)
汇编_POPAD ()
汇编_RET ()
调用函数 (汇编_取代码 ())
释放内存 (临时地址)
退出许可区 (许可证数组 [10])

.子程序 发送封包
.参数 包, 文本型
.参数 长度, 整数型, 可空
.局部变量 临时文本, 文本型
.局部变量 新包, 字节集

临时文本 ＝ 子文本替换 (包, “ ”, “”, , , 真)
' 输出调试文本 (临时文本)
新包 ＝ 文本到字节集 (临时文本)
.如果真 (是否为空 (长度))
    长度 ＝ 取字节集长度 (新包)
.如果真结束
调用发包 (新包, 长度)


.子程序 封包处理, 文本型, , 长度表示此包处理后的长度
.参数 文本, 文本型
.参数 长度, 整数型
.局部变量 临时文本, 文本型
.局部变量 新文本, 文本型
.局部变量 序号, 整数型

临时文本 ＝ 子文本替换 (文本, “ ”, “”, , , 真)
临时文本 ＝ 取文本右边 (“0000000” ＋ 临时文本, 长度)
.计次循环首 (长度 ÷ 2, 序号)
    新文本 ＝ 新文本 ＋ 取文本中间 (临时文本, 长度 ＋ 1 － 2 × 序号, 2)
.计次循环尾 ()
返回 (新文本)


.子程序 发包技能
.参数 技能ID, 整数型, , 4字节
.参数 目标ID, 整数型, , 4字节

发送封包 (“29 00” ＋ 封包处理 (取十六进制文本 (技能ID), 8) ＋ “03 01” ＋ 封包处理 (取十六进制文本 (目标ID), 8))


.子程序 发包选怪
.参数 怪物ID

发送封包 (“02 00” ＋ 封包处理 (取十六进制文本 (怪物ID), 8))


.子程序 发包挖矿
.参数 矿的ID, 整数型
.参数 矿铲的格子号, 整数型

发送封包 (“36 00” ＋ 封包处理 (取十六进制文本 (矿的ID), 8) ＋ “00 00” ＋ 封包处理 (取十六进制文本 (矿铲的格子号), 4) ＋ 封包处理 (“C01”, 8) ＋ “00 00 00 00”)



.子程序 发包打开NPC
.参数 NPCID, 整数型

发送封包 (“23 00” ＋ 封包处理 (取十六进制文本 (NPCID), 8))



.子程序 发包全修

发送封包 (“25 00 03 00 00 00 06 00 00 00 ff ff ff ff 00 00”)



.子程序 发包买药
.参数 药品ID, 整数型
.参数 药品在药店的格子号, 整数型
.参数 药的数量, 整数型

发送封包 (“25 00 01 00 00 00 14 00 00 00 00 00 00 00 01 00 00 00” ＋ 封包处理 (取十六进制文本 (药品ID), 4) ＋ “00 00” ＋ 封包处理 (取十六进制文本 (药品在药店的格子号), 2) ＋ “00 00 00” ＋ 封包处理 (取十六进制文本 (药的数量), 4) ＋ “00 00”)



.子程序 发包回城复活

发送封包 (“0400”)


.子程序 发包卖物
.参数 物品ID, 整数型
.参数 物品在包裹中的格子号, 整数型
.参数 物品数量, 整数型

发送封包 (“25 00 02 00 00 00 10 00 00 00 01 00 00 00” ＋ 封包处理 (取十六进制文本 (物品ID), 4) ＋ “00 00” ＋ 封包处理 (取十六进制文本 (物品在包裹中的格子号), 2) ＋ “00 00 00” ＋ 封包处理 (取十六进制文本 (物品数量), 4) ＋ “00 00”)


.子程序 发包吃药
.参数 物品ID, 整数型, , 4字节
.参数 格子号, 整数型, , 2字节

发送封包 (“28 00 00 01” ＋ 封包处理 (取十六进制文本 (格子号), 4) ＋ 封包处理 (取十六进制文本 (物品ID), 8))


.子程序 发包带F, , , 20红F  21蓝F
.参数 物品ID, 整数型, , 1字节(20红F  21蓝F)
.参数 格子号, 整数型, , 1字节

发送封包 (“11 00” ＋ 封包处理 (取十六进制文本 (格子号), 2) ＋ 封包处理 (取十六进制文本 (物品ID), 2))


.子程序 发包喂宠
.参数 物品格子号, 整数型
.参数 物品ID, 整数型

发送封包 (“2800 0001” ＋ 封包处理 (取十六进制文本 (物品格子号), 4) ＋ 封包处理 (取十六进制文本 (物品ID), 8))


.子程序 发包宠物补血
.参数 宠物ID

发送封包 (“2900 4A01 0000 0001” ＋ 封包处理 (取十六进制文本 (宠物ID), 8))


.子程序 发包抓宠物
.参数 宠物ID

发送封包 (“2900 4801 0000 0001” ＋ 封包处理 (取十六进制文本 (宠物ID), 8))


.子程序 发包复活宠物

发送封包 (“2900 4901 0000 0001 4043 0000”)

.子程序 发包宠物攻击
.参数 怪物ID

发送封包 (“2900 2B01 0000 0001” ＋ 封包处理 (取十六进制文本 (怪物ID), 8))


.子程序 发包唤宠
.参数 格子号, 整数型

发送封包 (“6400” ＋ 封包处理 (取十六进制文本 (格子号), 8))


.子程序 发包收宠

发送封包 (“6500”)


.子程序 发包飞行切换
.参数 飞行器ID, 整数型

发送封包 (“2800 0101 0C00” ＋ 封包处理 (取十六进制文本 (飞行器ID), 8))


.子程序 CALL_普通攻击
.局部变量 代码, 字节集

汇编_置代码 ()
汇编_MOV_寄存器_常数 (“eax”, 文本到十进制数 (“005A80C0”))
汇编_CALL_寄存器 (“eax”)
汇编_RET ()
调用函数 (汇编_取代码 ())

.子程序 CALL_打坐, 字节集
.局部变量 代码, 字节集

汇编_置代码 ()
汇编_MOV_寄存器_常数 (“eax”, 文本到十进制数 (“005A58A0”))
汇编_CALL_寄存器 (“eax”)
汇编_RET ()
调用函数 (汇编_取代码 ())

.子程序 CALL_取消打坐, 字节集
.局部变量 代码, 字节集

汇编_置代码 ()
汇编_MOV_寄存器_常数 (“eax”, 文本到十进制数 (“005A58E0”))
汇编_CALL_寄存器 (“eax”)
汇编_RET ()
调用函数 (汇编_取代码 ())

.子程序 死亡回城CALL

汇编_置代码 ()
汇编_PUSHAD ()
汇编_MOV_寄存器_PTR (“eax”, 游戏基址.游戏基址)
汇编_MOV_寄存器_PTR_寄存器_ADD (“eax”, “eax”, 文本到十进制数 (“20”))
汇编_LEA_寄存器_PTR_寄存器_ADD (“ecx”, “eax”, 文本到十进制数 (“ec”))
汇编_MOV_寄存器_常数 (“ebx”, 文本到十进制数 (“00584640”))
汇编_CALL_寄存器 (“ebx”)
汇编_POPAD ()
汇编_RET ()
调用函数 (汇编_取代码 ())


.子程序 死亡复活CALL

汇编_置代码 ()
汇编_PUSHAD ()
汇编_MOV_寄存器_PTR (“eax”, 游戏基址.游戏基址)
汇编_MOV_寄存器_PTR_寄存器_ADD (“eax”, “eax”, 文本到十进制数 (“20”))
汇编_LEA_寄存器_PTR_寄存器_ADD (“ecx”, “eax”, 文本到十进制数 (“ec”))
汇编_MOV_寄存器_常数 (“ebx”, 文本到十进制数 (“00584640”))
汇编_CALL_寄存器 (“ebx”)
汇编_POPAD ()
汇编_RET ()
调用函数 (汇编_取代码 ())


.子程序 取消选怪CALL

汇编_置代码 ()
汇编_MOV_寄存器_常数 (“eax”, 文本到十进制数 (“005A59C0”))
汇编_CALL_寄存器 (“eax”)
汇编_RET ()
调用函数 (汇编_取代码 ())


.子程序 打开NPC
.参数 NPCID, 整数型

汇编_置代码 ()
汇编_PUSHAD ()
汇编_MOV_寄存器_常数 (“ecx”, NPCID)
汇编_MOV_寄存器_PTR (“edx”, 游戏基址.游戏基址)
汇编_PUSH_寄存器 (“ecx”)
汇编_MOV_寄存器_PTR_寄存器_ADD (“ecx”, “edx”, 文本到十进制数 (“20”))
汇编_ADD_寄存器_常数 (“ecx”, 文本到十进制数 (“0EC”))
汇编_MOV_寄存器_常数 (“eax”, 文本到十进制数 (“00584250”))
汇编_CALL_寄存器 (“eax”)
汇编_POPAD ()
汇编_RET ()
调用函数 (汇编_取代码 ())


.子程序 关闭NPC
.局部变量 临时变量, 整数型

汇编_置代码 ()
汇编_PUSHAD ()
汇编_MOV_寄存器_PTR (“eax”, 游戏基址.游戏基址)
汇编_MOV_寄存器_PTR_寄存器_ADD (“eax”, “eax”, 文本到十进制数 (“1c”))
汇编_MOV_寄存器_PTR_寄存器_ADD (“eax”, “eax”, 文本到十进制数 (“4”))
汇编_MOV_寄存器_PTR_寄存器_ADD (“eax”, “eax”, 文本到十进制数 (“8”))
汇编_MOV_寄存器_PTR_寄存器_ADD (“esi”, “eax”, 文本到十进制数 (“14”))
汇编_PUSH_常数 (文本到十进制数 (“8B5574”))
汇编_MOV_寄存器_寄存器 (“ecx”, “esi”)
汇编_MOV_寄存器_常数 (“eax”, 文本到十进制数 (“006C7B40 ”))
汇编_CALL_寄存器 (“eax”)
汇编_POPAD ()
汇编_RET ()
调用函数 (汇编_取代码 ())


.子程序 选怪CALL
.参数 怪物ID, 整数型
.局部变量 人物基址, 整数型

' 人物基址 ＝ 连续读取内存数值 (游戏基址.游戏基址, 文本到十进制数 (“1c”), 文本到十进制数 (“20”))
写内存整数 (游戏基址.人物基址 ＋ 游戏偏移.角色偏移.目标ID, 怪物ID)
汇编_置代码 ()
汇编_PUSHAD ()
汇编_MOV_寄存器_常数 (“edi”, 怪物ID)
汇编_MOV_寄存器_PTR (“eax”, 游戏基址.游戏基址)
汇编_PUSH_寄存器 (“edi”)
汇编_MOV_寄存器_PTR_寄存器_ADD (“ecx”, “eax”, 文本到十进制数 (“20”))
汇编_ADD_寄存器_常数 (“ecx”, 文本到十进制数 (“ec”))
汇编_MOV_寄存器_常数 (“ebx”, 文本到十进制数 (“00583E90”))
汇编_CALL_寄存器 (“ebx”)
汇编_POPAD ()
汇编_RET ()
调用函数 (汇编_取代码 ())


.子程序 捡物CALL
.参数 物品ID, 整数型
.参数 系统物品ID, 整数型
.局部变量 调用函数, 字节集

' 输出调试文本 (“CALL捡物:” ＋ 到文本 (物品ID) ＋ “,” ＋ 到文本 (系统物品ID))
汇编_置代码 ()
汇编_PUSHAD ()
汇编_MOV_寄存器_常数 (“eax”, 物品ID)
汇编_PUSH_寄存器 (“eax”)
汇编_MOV_寄存器_常数 (“ecx”, 系统物品ID)
汇编_PUSH_寄存器 (“ecx”)
汇编_MOV_寄存器_PTR (“edx”, 游戏基址.游戏基址)
汇编_MOV_寄存器_PTR_寄存器_ADD (“ecx”, “edx”, 文本到十进制数 (“20”))
汇编_ADD_寄存器_常数 (“ecx”, 文本到十进制数 (“ec”))
汇编_MOV_寄存器_常数 (“ebx”, 文本到十进制数 (“00584510”))
汇编_CALL_寄存器 (“ebx”)
汇编_POPAD ()
汇编_RET ()
调用函数 (汇编_取代码 ())


.子程序 飞行CALL
.参数 翅膀ID, 整数型

汇编_置代码 ()
汇编_PUSHAD ()
汇编_MOV_寄存器_常数 (“ecx”, 翅膀ID)
汇编_MOV_寄存器_PTR (“edx”, 游戏基址.游戏基址)
汇编_PUSH_常数 (1)
汇编_PUSH_寄存器 (“ecx”)
汇编_MOV_寄存器_PTR_寄存器_ADD (“ecx”, “edx”, 文本到十进制数 (“20”))
汇编_PUSH_常数 (文本到十进制数 (“c”))
汇编_PUSH_常数 (1)
汇编_ADD_寄存器_常数 (“ecx”, 文本到十进制数 (“ec”))
汇编_MOV_寄存器_常数 (“ebx”, 文本到十进制数 (“00584320”))
汇编_CALL_寄存器 (“ebx”)
汇编_POPAD ()
汇编_RET ()
调用函数 (汇编_取代码 ())


.子程序 全修CALL

汇编_置代码 ()
汇编_PUSHAD ()
汇编_PUSH_常数 (-1)
汇编_PUSH_常数 (0)
汇编_PUSH_常数 (0)
汇编_MOV_寄存器_常数 (“eax”, 文本到十进制数 (“005A6CF0”))
汇编_CALL_寄存器 (“eax”)
汇编_ADD_寄存器_常数 (“esp”, 12)
汇编_POPAD ()
汇编_RET ()
调用函数 (汇编_取代码 ())


.子程序 走路CALL
.参数 X坐标, 双精度小数型
.参数 Y坐标, 双精度小数型
.参数 Z坐标, 双精度小数型
.参数 FLY, 整数型, 可空, 1空中，0地面
.局部变量 EAX, 整数型
.局部变量 ESI, 整数型
.局部变量 ECX, 整数型
.局部变量 鼠标点击地址, 整数型

.如果 (_启动窗口.角色.水陆空 ＝ 0)
    FLY ＝ 0
.否则
    FLY ＝ 1
.如果结束
EAX ＝ 连续读取内存数值 (游戏基址.游戏基址, 文本到十进制数 (“1c”))
ESI ＝ 读内存数值 (EAX ＋ 文本到十进制数 (“20”))
ECX ＝ 读内存数值 (ESI ＋ 文本到十进制数 (“BB8”))  ' BA8 BA0
鼠标点击地址 ＝ 连续读取内存数值 (游戏基址.游戏基址, 文本到十进制数 (“1c”), 文本到十进制数 (“20”), 文本到十进制数 (“BB8”), 文本到十进制数 (“30”))
鼠标点击地址 ＝ 读内存数值 (鼠标点击地址 ＋ 文本到十进制数 (“4”))
' 输出调试文本 (“CALL走路到：” ＋ 到文本 (X坐标) ＋ “,” ＋ 到文本 (Y坐标) ＋ “,” ＋ 到文本 (Z坐标))
写字节进内存 (进程句柄, 鼠标点击地址 ＋ 文本到十进制数 (“20”), 到字节集 (到小数 (到文本 ((X坐标 － 400) × 10))), 4, 0)
写字节进内存 (进程句柄, 鼠标点击地址 ＋ 文本到十进制数 (“24”), 到字节集 (到小数 (到文本 (Z坐标 × 10))), 4, 0)
写字节进内存 (进程句柄, 鼠标点击地址 ＋ 文本到十进制数 (“28”), 到字节集 (到小数 (到文本 ((Y坐标 － 550) × 10))), 4, 0)
汇编_取代码 ()
汇编_PUSHAD ()
汇编_MOV_寄存器_常数 (“eax”, EAX)
汇编_MOV_寄存器_常数 (“esi”, ESI)
汇编_MOV_寄存器_常数 (“ecx”, ECX)
汇编_PUSH_常数 (1)
汇编_MOV_寄存器_常数 (“ebx”, 文本到十进制数 (“45D9F0”))
汇编_CALL_寄存器 (“ebx”)
汇编_MOV_寄存器_寄存器 (“edi”, “eax”)
汇编_PUSH_常数 (鼠标点击地址 ＋ 文本到十进制数 (“20”))
汇编_PUSH_常数 (FLY)
汇编_MOV_寄存器_寄存器 (“ecx”, “edi”)
汇编_MOV_寄存器_常数 (“ebx”, 文本到十进制数 (“461470”))
汇编_CALL_寄存器 (“ebx”)
汇编_PUSH_常数 (0)
汇编_PUSH_常数 (1)
汇编_PUSH_寄存器 (“edi”)
汇编_MOV_寄存器_常数 (“ecx”, ECX)
汇编_PUSH_常数 (1)
汇编_MOV_寄存器_常数 (“ebx”, 文本到十进制数 (“45DDF0”))
汇编_CALL_寄存器 (“ebx”)
汇编_POPAD ()
汇编_RET ()
调用函数 (汇编_取代码 ())

' 置代码 ({  })
' pushad ()
' mov_eax_常数 (EAX)
' mov_esi_常数 (ESI)
' mov_ecx_常数 (ECX)
' push_常数 (1)
' mov_ebx_常数 (十六进制到十进制 (“45D9F0”))  ' 0045E370 45E190
' call_ebx ()
' mov_edi_eax ()
' push_常数 (鼠标点击地址 ＋ 十六进制到十进制 (“20”))
' push_常数 (FLY)
' mov_ecx_edi ()
' mov_ebx_常数 (十六进制到十进制 (“461470”))  ' 00461DF0 461C10
' call_ebx ()
' push_常数 (0)
' push_常数 (1)
' push_edi ()
' mov_ecx_常数 (ECX)
' push_常数 (1)
' mov_ebx_常数 (十六进制到十进制 (“45DDF0”))  ' 0045E770 45E590
' call_ebx ()
' popad ()
' ret ()
' 调用函数 (_取代码 ())


.子程序 技能CALL
.参数 技能ID, 整数型

.如果真 (取数组成员数 (许可证数组) ＜ 7)
    返回 ()
.如果真结束
进入许可区 (许可证数组 [7])
汇编_置代码 ()
汇编_PUSHAD ()
汇编_MOV_寄存器_常数 (“ecx”, 游戏基址.游戏基址)
汇编_MOV_寄存器_常数 (“eax”, 技能ID)
汇编_PUSH_常数 (-1)
汇编_PUSH_常数 (0)
汇编_MOV_寄存器_PTR_寄存器_ADD (“edx”, “ecx”, 文本到十进制数 (“1c”))
汇编_PUSH_常数 (0)
汇编_PUSH_寄存器 (“eax”)
汇编_MOV_寄存器_PTR_寄存器_ADD (“ecx”, “edx”, 文本到十进制数 (“20”))
汇编_MOV_寄存器_常数 (“ebx”, 文本到十进制数 (“004559D0”))
汇编_CALL_寄存器 (“ebx”)
汇编_POPAD ()
汇编_RET ()
退出许可区 (许可证数组 [7])
调用函数 (汇编_取代码 ())

' 置代码 ({  })
' pushad ()
' mov_ecx_ptr (游戏基址.游戏基址)
' mov_eax_常数 (技能ID)
' push_常数 (-1)
' push_常数 (0)
' mov_edx_ptr_ecx加字节 (十六进制到十进制 (“1c”))
' push_常数 (0)
' push_eax ()
' mov_ecx_ptr_edx加字节 (十六进制到十进制 (“20”))
' mov_ebx_常数 (十六进制到十进制 (“004559D0”))  ' 00456110 00456370
' call_ebx ()
' popad ()
' ret ()
' 调用函数 (_取代码 ())

.子程序 挖矿CALL
.参数 矿的基址, 整数型, , 矿的偏移+4
.参数 参数1, 整数型
.参数 矿铲的格子号, 整数型
.局部变量 指针1, 整数型
.局部变量 矿的编号, 整数型
.局部变量 矿的ID, 整数型

' ' 指针1 ＝ _取指针_整数型 (读内存数值 (矿的基址))
' 指针1 ＝ 分配内存 (4)
' 输出调试文本 (写字节集内存 (指针1, 到字节集 (参数1)))
' 矿的编号 ＝ 读内存数值 (读内存数值 (矿的基址) ＋ 文本到十进制数 (“110”))
' 矿的ID ＝ 读内存数值 (读内存数值 (矿的基址) ＋ 文本到十进制数 (“10C”))
' 置代码 ({  })
' pushad ()
' mov_eax_ptr (游戏基址)
' mov_ecx_ptr_eax加字节 (十六进制到十进制 (“188”))
' mov_eax_ptr (矿的基址)  ' [矿的基址]
' ' mov_eax_ptr_eax加字节 (十六进制到十进制 (“110”))  ' 矿的编号
' ' mov_eax_常数 (矿的编号)
' ' mov_edi_eax ()
' mov_edi_常数 (矿的编号)
' mov_edx_常数 (参数1)  ' mov_edx_常数 (物品地址指针)
' push_edx ()
' push_常数 (0)
' push_edi ()
' mov_ebx_常数 (文本到十进制数 (“0060CD70”))  ' 0060CD70 0060B760
' call_ebx ()
' mov_eax_常数 (0)  ' mov_eax_ptr_eax加字节 (十六进制到十进制 (“178”))
' mov_ecx_常数 (文本到十进制数 (“C01”))  ' 矿铲的编号
' mov_edx_常数 (矿铲的格子号)
' push_eax ()
' mov_eax_常数 (0)  ' mov eax,dword ptr ss:[esp+14]
' push_ecx ()
' mov_ecx_ptr (矿的基址)
' mov_ecx_ptr_ecx加字节 (文本到十进制数 (“10c”))  ' 矿的ID
' mov_ecx_常数 (矿的ID)
' push_edx ()
' push_eax ()
' push_ecx ()
' mov_ebx_常数 (十六进制到十进制 (“005A5A40”))  ' 005A5A40 005A5160
' call_ebx ()
' add_esp_字节 (十六进制到十进制 (“14”))
' popad ()
' ret ()
' ' 调用游戏call (_取代码 ())
' 调用函数 (_取代码 ())


.子程序 挖矿
.参数 矿的基址, 整数型, , 矿的偏移+4
.参数 参数1, 整数型
.参数 矿铲的格子号, 整数型
.局部变量 指针1, 整数型
.局部变量 矿的编号, 整数型
.局部变量 矿的ID, 整数型
.局部变量 矿的ID1, 整数型
.局部变量 测试结构体, 测试结构体

' 指针1 ＝ _取指针_整数型 (读内存数值 (矿的基址))
' 测试结构体.物品地址 ＝ 矿的基址
' 测试结构体.工具ID ＝ 十六进制到十进制 (“C01”)
' 测试结构体.工具位置 ＝ 4
' 指针1 ＝ 分配内存 (12)
' 输出调试文本 (写字节集内存 (指针1, 到字节集 (测试结构体.物品地址)))
' 输出调试文本 (写字节集内存 (指针1 ＋ 4, 到字节集 (测试结构体.工具ID)))
' 输出调试文本 (写字节集内存 (指针1 ＋ 8, 到字节集 (测试结构体.工具位置)))
' 矿的编号 ＝ 读内存数值 (读内存数值 (矿的基址) ＋ 十六进制到十进制 (“110”))
' 矿的ID ＝ 读内存数值 (读内存数值 (矿的基址) ＋ 十六进制到十进制 (“10C”))
' ' 矿的ID1 ＝ 读内存数值 (矿的基址) ＋ 十六进制到十进制 (“EC”)
' 置代码 ({  })
' pushad ()
' ' mov_ebx_常数 (指针1)
' ' mov_eax_ptr (十六进制到十进制 (“8F6B3C”))
' ' mov_ecx_ptr_eax加字节 (十六进制到十进制 (“188”))
' ' push_常数 (参数1)
' ' push_常数 (0)
' ' mov_eax_ptr_ebx ()
' ' mov_eax_ptr_eax加字节 (十六进制到十进制 (“110”))
' ' mov_edi_eax ()
' ' mov_eax_ptr (十六进制到十进制 (“8F6B3C”))
' ' push_edi ()
' ' ' call (十六进制到十进制 (“0060CD70”))
' ' mov_ebx_常数 (十六进制到十进制 (“0060CD70”))
' ' call_ebx ()
' ' mov_eax_常数 (十六进制到十进制 (“0060CD70”))
' ' call_eax ()
' ' mov_eax_ptr_eax加字节 (十六进制到十进制 (“178”))
' push_常数 (0)
' ' mov_eax_ebx ()
' ' mov_eax_ptr_eax加字节 (4)
' push_eax ()
' push_常数 (十六进制到十进制 (“c01”))
' mov_esi_常数 (十六进制到十进制 (“06FA3E78”))
' push_常数 (4)
' push_常数 (0)
' push_常数 (矿的ID)
' ' mov_eax_ebx ()
' ' mov_eax_ptr_eax加字节 (8)
' ' push_eax ()
' ' push_常数 (0)
' ' mov_eax_ptr_ebx ()
' ' mov_ecx_ptr_eax加字节 (十六进制到十进制 (“10C”))
' ' push_ecx ()
' ' push_esi ()
' ' push_常数 (十六进制到十进制 (“12”))
' mov_eax_常数 (十六进制到十进制 (“5A5A40”))  ' call 006ED6E0
' call_eax ()
' add_esp_字节 (20)
' popad ()
' ret ()
' ' mov_eax_ptr (游戏基址)
' ' mov_ecx_ptr_eax加字节 (十六进制到十进制 (“188”))
' ' mov_eax_ptr (矿的基址)  ' [矿的基址]
' ' ' mov_eax_ptr_eax加字节 (十六进制到十进制 (“110”))  ' 矿的编号
' ' ' mov_eax_常数 (矿的编号)
' ' ' mov_edi_eax ()
' ' mov_edi_常数 (矿的编号)
' ' mov_edx_常数 (参数1)  ' mov_edx_常数 (物品地址指针)
' ' push_edx ()
' ' push_常数 (0)
' ' push_edi ()
' ' mov_ebx_常数 (十六进制到十进制 (“0060CD70”))  ' 0060CD70 0060B760
' ' call_ebx ()
' ' mov_eax_常数 (0)  ' mov_eax_ptr_eax加字节 (十六进制到十进制 (“178”))
' ' mov_ecx_常数 (十六进制到十进制 (“C01”))  ' 矿铲的编号
' ' mov_edx_常数 (矿铲的格子号)
' ' push_eax ()
' ' mov_eax_常数 (0)  ' mov eax,dword ptr ss:[esp+14]
' ' push_ecx ()
' ' mov_ecx_ptr (矿的基址)
' ' mov_ecx_ptr_ecx加字节 (十六进制到十进制 (“10c”))  ' 矿的ID
' ' mov_ecx_常数 (矿的ID)
' ' push_edx ()
' ' push_eax ()
' ' push_ecx ()
' ' mov_ebx_常数 (十六进制到十进制 (“005A5A40”))  ' 005A5A40 005A5160
' ' call_ebx ()
' ' add_esp_字节 (十六进制到十进制 (“14”))
' ' popad ()
' ' ret ()
' ' 调用游戏call (_取代码 ())
' 调用函数 (_取代码 ())

.子程序 吃药CAll
.参数 物品ID, 整数型
.参数 物品格子号, 整数型

' 输出调试文本 (“CALL吃药：  ID = ” ＋ 到文本 (物品ID) ＋ “  格子：” ＋ 到文本 (物品格子号) ＋ “   ” ＋ 到文本 (取现行时间 ()))
' 置代码 ({  })
' pushad ()
' mov_edx_常数 (物品ID)
' mov_eax_常数 (物品格子号)
' push_常数 (1)
' push_edx ()
' push_eax ()
' push_常数 (0)
' mov_eax_ptr (游戏基址)
' mov_eax_ptr_eax加字节 (十六进制到十进制 (“20”))
' mov_ebx_eax ()
' lea_ecx_ptr_eax加整数 (十六进制到十进制 (“ec”))
' mov_eax_常数 (十六进制到十进制 (“00583C40”))
' call_eax ()
' popad ()
' ret ()
' 调用函数 (_取代码 ())


.子程序 FB飞行
.局部变量 临时, 整数型

临时 ＝ _启动窗口.偏移基址.人物基址 ＋ 文本到十进制数 (“62C”)
.如果 (_启动窗口.功能选择框8.选中 ＝ 假)
    写内存整数 (临时, 40960)
.否则
    写内存整数 (临时, 40976)
.如果结束


.子程序 FB穿墙

.如果 (_启动窗口.功能选择框9.选中 ＝ 假)
    写内存整数 (文本到十进制数 (“405233”), 文本到十进制数 (“890851d9”))
.否则
    写内存整数 (文本到十进制数 (“405233”), 文本到十进制数 (“890851db”))
.如果结束


.子程序 FB飞天

.如果 (_启动窗口.功能选择框9.选中 ＝ 假)
    写内存整数 (4525190, 3905850122)
.否则
    写内存整数 (4525190, 3905850113)
.如果结束


.子程序 FB仙魔
.局部变量 临时变量, 整数型

临时变量 ＝ _启动窗口.偏移基址.人物基址 ＋ 文本到十进制数 (“44C”)
.如果 (_启动窗口.功能选择框10.选中 ＝ 假)
    写内存整数 (临时变量, 32)
.否则
    写内存整数 (临时变量, 32)
.如果结束


.子程序 FB隐藏

.如果 (_启动窗口.功能选择框9.选中 ＝ 假)
    写内存整数 (文本到十进制数 (“421548”), 文本到十进制数 (“44D96575”))
.否则
    写内存整数 (文本到十进制数 (“421548”), 文本到十进制数 (“44D96574”))
.如果结束

http://yunpan.cn/QXMq6YZeYF2U6