DXF技能xxx秒杀易语言写法

admin

.版本 2

.程序集 XXX

.子程序 技能结构call, , , XXX秒
.参数 获取人物指针, 长整数型
.参数 对象指针, 长整数型
.参数 技能代码, 整数型
.参数 白图伤害, 整数型
.参数 团本伤害, 整数型
.参数 X轴, 整数型
.参数 Y轴, 整数型
.参数 Z轴, 整数型
.参数 动作id, 整数型
.参数 技能大小, 整数型
.局部变量 汇编, 字节集
.局部变量 技能参数, 长整数型
.局部变量 技能结构CALL, 长整数型
.局部变量 技能结构参数, 长整数型
.局部变量 技能结构偏移, 整数型

置入代码 (#VM开始)
技能大小 ＝ 到整数 (700)
技能参数 ＝ #丢技能CALL_Rcx
技能结构CALL ＝ #丢技能CALL_1
技能结构参数 ＝ #丢技能CALL_2
技能结构偏移 ＝ #丢技能CALL偏移
汇编 ＝ { 51, 192 }
汇编 ＝ 汇编 ＋ { 186 } ＋ 到字节集 (技能大小)
汇编 ＝ 汇编 ＋ { 72, 163 } ＋ 到字节集 (到长整数 (技能参数 ＋ 16))
汇编 ＝ 汇编 ＋ { 72, 187 } ＋ 到字节集 (到长整数 (技能参数 ＋ 8))
汇编 ＝ 汇编 ＋ { 72, 184 } ＋ 到字节集 (到长整数 (技能参数 ＋ 16))
汇编 ＝ 汇编 ＋ { 72, 99, 8, 72, 139, 3, 102, 137, 20, 1 }
汇编 ＝ 汇编 ＋ { 161 } ＋ 到字节集 (到长整数 (技能参数 ＋ 16))
汇编 ＝ 汇编 ＋ { 131, 192, 2 }
汇编 ＝ 汇编 ＋ { 163 } ＋ 到字节集 (到长整数 (技能参数 ＋ 16))
汇编 ＝ 汇编 ＋ { 72, 99, 200 }
汇编 ＝ 汇编 ＋ { 72, 161 } ＋ 到字节集 (到长整数 (技能参数 ＋ 8))
汇编 ＝ 汇编 ＋ { 199, 4, 1 } ＋ 到字节集 (团本伤害)
汇编 ＝ 汇编 ＋ { 72, 141, 76, 36, 32 }
汇编 ＝ 汇编 ＋ { 161 } ＋ 到字节集 (到长整数 (技能参数 ＋ 16))
汇编 ＝ 汇编 ＋ { 131, 192, 4 }
汇编 ＝ 汇编 ＋ { 163 } ＋ 到字节集 (到长整数 (技能参数 ＋ 16))
汇编 ＝ 汇编 ＋ { 72, 184 } ＋ 到字节集 (技能结构CALL)
汇编 ＝ 汇编 ＋ { 255, 208 }
汇编 ＝ 汇编 ＋ { 199, 68, 36, 48 } ＋ 到字节集 (技能代码)
汇编 ＝ 汇编 ＋ { 72, 184 } ＋ 到字节集 (获取人物指针)
汇编 ＝ 汇编 ＋ { 72, 137, 68, 36, 32 }
汇编 ＝ 汇编 ＋ { 72, 185 } ＋ 到字节集 (对象指针)
汇编 ＝ 汇编 ＋ { 199, 68, 36, 52 } ＋ 到字节集 (白图伤害)
汇编 ＝ 汇编 ＋ { 199, 68, 36, 64 } ＋ 到字节集 (X轴)
汇编 ＝ 汇编 ＋ { 199, 68, 36, 68 } ＋ 到字节集 (Y轴)
汇编 ＝ 汇编 ＋ { 199, 68, 36, 72 } ＋ 到字节集 (Z轴)
汇编 ＝ 汇编 ＋ { 72, 161 } ＋ 到字节集 (对象指针)
汇编 ＝ 汇编 ＋ { 72, 139, 144 } ＋ 到字节集 (技能结构偏移)
汇编 ＝ 汇编 ＋ { 255, 210, 137, 68, 36, 92, 72, 141, 76, 36, 32 }
汇编 ＝ 汇编 ＋ { 161 } ＋ 到字节集 (到长整数 (技能参数 ＋ 16))
汇编 ＝ 汇编 ＋ { 137, 68, 36, 120, 72, 99, 3, 72, 137, 132, 36, 128, 0, 0, 0 }
汇编 ＝ 汇编 ＋ { 72, 184 } ＋ 到字节集 (技能结构参数)
汇编 ＝ 汇编 ＋ { 198, 132, 36, 165, 0, 0, 0, 1 }
汇编 ＝ 汇编 ＋ { 199, 132, 36, 168, 0, 0, 0 } ＋ 到字节集 (动作id)
汇编 ＝ 汇编 ＋ { 198, 132, 36, 184, 0, 0, 0, 0, 255, 208 }
汇编 ＝ { 72, 129, 236, 48, 2, 0, 0 } ＋ 汇编 ＋ { 72, 129, 196, 48, 2, 0, 0 }
内存汇编 (汇编)
置入代码 (#VM结束)

.子程序 XXX秒杀

.如果真 (取对象动作 () ＝ 8)  ' \\8是攻击动作
    技能结构遍历 ()
.如果真结束


.子程序 自动XXX

技能结构遍历 ()

.子程序 XXX秒开关
.局部变量 技能开关, 逻辑型, 静态

技能开关 ＝ 取反 (技能开关)
.如果 (技能开关)
    辅助.时钟1.时钟周期 ＝ 500
    公告 (“XXX秒杀—[开启]”)
.否则
    辅助.时钟1.时钟周期 ＝ 0
    公告 (“XXX秒杀—[关闭]”)
.如果结束


.子程序 技能结构遍历
.局部变量 人物指针, 长整数型
.局部变量 地图指针, 长整数型
.局部变量 遍历指针, 长整数型
.局部变量 首部指针, 长整数型
.局部变量 尾部指针, 长整数型
.局部变量 遍历血量, 长整数型
.局部变量 物品指针, 长整数型
.局部变量 物品代码, 长整数型
.局部变量 遍历数量, 整数型
.局部变量 遍历阵营, 整数型
.局部变量 遍历类型B, 整数型
.局部变量 遍历类型, 整数型
.局部变量 怪物坐标, 坐标型
.局部变量 怪物地址, 长整数型
.局部变量 计次, 整数型
.局部变量 遍历代码, 整数型

置入代码 (#VM开始)
人物指针 ＝ 取人物指针 ()
地图指针 ＝ 读长整型 (读长整型 (人物指针 ＋ #地图偏移) ＋ 16)
首部指针 ＝ 读长整型 (地图指针 ＋ #地图开始2)
尾部指针 ＝ 读长整型 (地图指针 ＋ #地图结束2)
遍历数量 ＝ (尾部指针 － 首部指针) ÷ 32
.计次循环首 (遍历数量, 计次)
    遍历指针 ＝ 读长整型 (首部指针 ＋ 计次 × 32)
    遍历指针 ＝ 读长整型 (遍历指针 ＋ 16) － 32
    遍历血量 ＝ 读长整型 (遍历指针 ＋ #怪物血量)
    遍历类型 ＝ 读长整型 (遍历指针 ＋ #类型偏移)
    遍历类型B ＝ 读长整型 (遍历指针 ＋ #类型偏移 ＋ 4)
    遍历阵营 ＝ 读长整型 (遍历指针 ＋ #阵营偏移)
    遍历代码 ＝ 读长整型 (遍历指针 ＋ #代码偏移)
    .如果真 (遍历类型 ＝ 529 或 遍历类型 ＝ 273 或 遍历类型 ＝ 545 或 遍历代码 ＝ 61440 或 遍历代码 ＝ 817 或 遍历代码 ＝ 490002230)
        .如果真 (遍历阵营 ≠ 0 且 人物指针 ≠ 遍历指针 且 遍历类型B ≠ 33 或 遍历代码 ＝ 8104 或 遍历代码 ＝ 817 或 遍历代码 ＝ 490002230)
            .如果真 (遍历血量 ＞ 0 或 遍历代码 ＝ 8104 或 遍历代码 ＝ 817 或 遍历代码 ＝ 490002230)
                怪物坐标 ＝ 读怪物坐标 (遍历指针)

                技能结构call (人物指针, 遍历指针, 到整数 (辅助.XXX代码.内容), 到整数 (辅助.XXX伤害.内容) × 50000, 到整数 (辅助.XXX伤害.内容) × 50000, 怪物坐标.x, 怪物坐标.y, 怪物坐标.z, 取对象动作 (), 到整数 (辅助.XXX大小.内容))
                跳出循环 ()
            .如果真结束

        .如果真结束

    .如果真结束


.计次循环尾 ()
置入代码 (#VM结束)

.子程序 取技能代码, 整数型
.局部变量 代码, 整数型, , "5"
.局部变量 技能代码, 整数型

' 技能代码 ＝ 到整数 (辅助.XXX代码.内容)
' 代码 ＝ { 24261, 24262, 24263, 24264, 24265 }
' 置随机数种子 ()
' 返回 (代码 [取随机数 (1, 5)])
' 返回 (0)

.子程序 取对象动作, 整数型

返回 (解密 (取人物指针 () ＋ #动作ID))

.子程序 取人物指针, 长整数型, , 取人物指针
.局部变量 code, 字节集
.局部变量 空白地址, 长整数型

空白地址 ＝ 辅助空白 ＋ 1800
code ＝ Sub_Rsp (100) ＋ Call (#人物CALL) ＋ { 72, 163 } ＋ 倒转数据 (长整数据 (空白地址)) ＋ Add_Rsp (100)
内存汇编 (code)
返回 (读长整型 (空白地址))

.子程序 读怪物坐标, 坐标型
.参数 参_指针, 长整数型
.局部变量 局_指针, 长整数型
.局部变量 局_坐标, 坐标型

.判断开始 (读整数型 (参_指针 ＋ #类型偏移) ＝ 273)
    局_指针 ＝ 读长整型 (参_指针 ＋ #X坐标)
    局_坐标.x ＝ 到整数 (读小数型 (局_指针 ＋ 0))
    局_坐标.y ＝ 到整数 (读小数型 (局_指针 ＋ 4))
    局_坐标.z ＝ 到整数 (读小数型 (局_指针 ＋ 8))
.默认
    局_指针 ＝ 读长整型 (参_指针 ＋ #方向偏移)
    局_坐标.x ＝ 到整数 (读小数型 (局_指针 ＋ 32))
    局_坐标.y ＝ 到整数 (读小数型 (局_指针 ＋ 36))
    局_坐标.z ＝ 到整数 (读小数型 (局_指针 ＋ 40))
.判断结束
返回 (局_坐标)

.子程序 读人物坐标, 坐标型
.参数 读取指针, 长整数型
.局部变量 坐标, 坐标型
.局部变量 指针, 整数型

指针 ＝ 读长整型 (读取指针 ＋ #X坐标)
坐标.x ＝ 到整数 (读小数型 (指针 ＋ 0))
坐标.y ＝ 到整数 (读小数型 (指针 ＋ 4))
坐标.z ＝ 到整数 (读小数型 (指针 ＋ 8))
返回 (坐标)


.子程序 Sub_Rsp, 字节集
.参数 i, 整数型

.如果真 (i ＞ 127)
    返回 ({ 72, 129, 236 } ＋ 到字节集 (i))
.如果真结束
返回 ({ 72, 131, 236 } ＋ 到字节集 (到字节 (i)))

.子程序 Add_Rsp, 字节集
.参数 i, 整数型

.如果真 (i ＞ 127)
    返回 ({ 72, 129, 196 } ＋ 到字节集 (i))
.如果真结束
返回 ({ 72, 131, 196 } ＋ 到字节集 (到字节 (i)))

.子程序 Call, 字节集
.参数 地址, 长整数型

返回 ({ 255, 21, 2, 0, 0, 0, 235, 8 } ＋ 倒转数据 (长整数据 (地址)))

wo79419877

楼主太厉害了！楼主，I*老*虎*U！我觉得3SWG论坛真是个好地方！

___Cc

楼主发贴辛苦了，谢谢楼主分享！我觉得3SWG论坛是注册对了！