DNF最新纯图色脚本框架2022-4-27

DNF最新纯图色脚本框架2022-4-27 易语言源码开源发布

1脚本相关代码如下

程序入口

.版本 2

.程序集 入口

.子程序 _启动子程序, 整数型, , 请在本子程序中放置动态链接库初始化代码

.如果真 (是否为调试版 ())
    jjkmain ()
.如果真结束
返回 (0)

.子程序 jjkmain, , 公开

载入 (jjk, , 真)

窗口程序集_jjk

.版本 2
.支持库 iext2
.支持库 spec

.程序集 窗口程序集_jjk

.子程序 _jjk_创建完毕

jjk.左边 ＝ 0
jjk.顶边 ＝ 610
初始化大漠 ()
线程_启动 (&线程循环, , )

.子程序 _超级按钮1_被单击



.子程序 _超级按钮2_被单击

结束 ()

.子程序 _超级按钮3_被单击

启动 ()

.子程序 启动

固定游戏坐标 ()
.如果真 (取反 (启动))
    线程_启动 (&主线程, , 主线程句柄)
    线程_启动 (&副线程, , 副线程句柄)
    启动 ＝ 真
.如果真结束


.子程序 _超级按钮4_被单击

暂停和恢复 ()

.子程序 暂停和恢复

.如果真 (启动)
    .判断开始 (暂停和恢复)
        辅助延时 (500, )
        暂停和恢复 ＝ 假
        线程_恢复 (主线程句柄)
        线程_恢复 (副线程句柄)
        jjk.超级按钮4.标题 ＝ “暂停F6”
        调试输出 (“已恢复脚本”)
    .默认
        辅助延时 (500, )
        暂停和恢复 ＝ 真
        线程_挂起 (主线程句柄)
        线程_挂起 (副线程句柄)
        jjk.超级按钮4.标题 ＝ “继续F6”
        调试输出 (“已暂停脚本”)
    .判断结束
    调试输出 (主线程句柄)
    调试输出 (副线程句柄)
.如果真结束


.子程序 _超级按钮5_被单击

停止 ()

.子程序 停止

.如果真 (启动)
    调试输出 (“已停止脚本”)
    线程_结束 (副线程句柄)
    线程_结束 (主线程句柄)
    初始化变量 ()
.如果真结束


.子程序 _超级按钮6_被单击

退出 ()

.子程序 退出

结束 ()

.子程序 初始化变量

jjk.超级按钮4.标题 ＝ “暂停F6”
启动 ＝ 假
暂停和恢复 ＝ 假

.子程序 _超级按钮7_被单击

载入 (set, , 真)

其他

.版本 2

.程序集 其他

.子程序 初始化大漠

免注册调用大漠 (取运行目录 () ＋ “\jjk\资源\3.1233.dll”)
dm.创建对象 ()
dm.SetPath (取运行目录 () ＋ “\jjk\资源\”)
dm.SetDict (0, “7k.txt”)
dm.SetDict (1, “数字.txt”)
dm.SetDict (2, “汉字.txt”)

.子程序 固定游戏坐标
.局部变量 dnfhwnd, 整数型, 静态

dnfhwnd ＝ dm.FindWindow (“地下城与勇士”, “地下城与勇士”)
.如果真 (dnfhwnd ＞ 0)
    dm.MoveWindow (dnfhwnd, 0, 0)
.如果真结束

键鼠

.版本 2

.程序集 键鼠

.子程序 鼠标到右下
.局部变量 x, 整数型, 静态
.局部变量 y, 整数型, 静态

dm.UseDict (0)
.如果真 (dm.FindStr (498, 462, 800, 598, “确认”, “e3d49a-000000|b99460-000000”, 1, x, y) ≥ 0)
    移动左键单击 (x ＋ 10, y ＋ 5, 1, 80)
    辅助延时 (500, )
.如果真结束
dm.UseDict (0)
.如果真 (dm.FindStr (498, 462, 800, 598, “完成”, “b99460-000000”, 1, x, y) ≥ 0)
    移动左键单击 (x ＋ 10, y ＋ 5, 1, 80)
    辅助延时 (500, )
.如果真结束
dm.UseDict (0)
.如果真 (dm.FindStr (331, 433, 472, 479, “关闭”, “b99460-000000|e3d49a-000000”, 1, x, y) ≥ 0)
    移动左键单击 (400, 457, 1, 80)
    辅助延时 (500, )
.如果真结束
移动左键单击 (594, 591, 1, 80)

.子程序 左键按下

dm.LeftDown ()

.子程序 左键弹起

dm.LeftUp ()

.子程序 左键点击
.参数 次数, 整数型
.参数 时间, 整数型

.计次循环首 (次数, )
    左键按下 ()
    置随机数种子 ()
    辅助延时 (取随机数 (时间, 时间 ＋ 10), )
    左键弹起 ()
.计次循环尾 ()

.子程序 右键按下

dm.RightDown ()

.子程序 右键弹起

dm.RightUp ()

.子程序 右键点击
.参数 次数, 整数型
.参数 时间, 整数型

.计次循环首 (次数, )
    右键按下 ()
    置随机数种子 ()
    辅助延时 (取随机数 (时间, 时间 ＋ 20), )
    右键弹起 ()
.计次循环尾 ()

.子程序 绝对移动
.参数 x, 整数型
.参数 y, 整数型

置随机数种子 ()
dm.MoveTo (取随机数 (x － 4, x ＋ 4), 取随机数 (y, y ＋ 2))

.子程序 相对移动
.参数 x, 整数型
.参数 y, 整数型

dm.MoveR (x, y)

.子程序 移动左键单击
.参数 x, 整数型
.参数 y, 整数型
.参数 次数, 整数型
.参数 时间, 整数型

绝对移动 (x, y)
辅助延时 (时间, )
左键点击 (次数, 时间)

.子程序 移动左键按下
.参数 x, 整数型
.参数 y, 整数型
.参数 时间, 整数型

绝对移动 (x, y)
辅助延时 (时间, )
左键按下 ()
辅助延时 (时间, )

.子程序 移动左键弹起
.参数 x, 整数型
.参数 y, 整数型
.参数 时间, 整数型

绝对移动 (x, y)
辅助延时 (时间, )
左键弹起 ()
辅助延时 (时间, )

.子程序 移动右键单击
.参数 x, 整数型
.参数 y, 整数型
.参数 次数, 整数型
.参数 时间, 整数型

绝对移动 (x, y)
辅助延时 (时间, )
右键点击 (次数, 时间)

.子程序 移动右键按下
.参数 x, 整数型
.参数 y, 整数型
.参数 时间, 整数型

绝对移动 (x, y)
辅助延时 (时间, )
右键按下 ()
辅助延时 (时间, )

.子程序 移动右键弹起
.参数 x, 整数型
.参数 y, 整数型
.参数 时间, 整数型

绝对移动 (x, y)
辅助延时 (时间, )
右键弹起 ()
辅助延时 (时间, )

.子程序 左键拖动对象
.参数 起始x, 整数型
.参数 起始y, 整数型
.参数 目标x, 整数型
.参数 目标y, 整数型

移动左键按下 (起始x, 起始y, 100)
辅助延时 (600, )
移动左键弹起 (目标x, 目标y, 100)

.子程序 右键拖动对象
.参数 起始x, 整数型
.参数 起始y, 整数型
.参数 目标x, 整数型
.参数 目标y, 整数型

移动右键按下 (起始x, 起始y, 100)
辅助延时 (350, )
移动右键弹起 (目标x, 目标y, 100)

.子程序 按下
.参数 键代码, 整数型

dm.KeyDown (键代码)

.子程序 弹起
.参数 键代码, 整数型

dm.KeyUp (键代码)

.子程序 按键
.参数 键代码, 整数型
.参数 时间, 整数型

.如果真 (键代码 ＝ 37)
    弹起 (39)
.如果真结束
.如果真 (键代码 ＝ 39)
    弹起 (37)
.如果真结束
.如果真 (键代码 ＝ 38)
    弹起 (40)
.如果真结束
.如果真 (键代码 ＝ 40)
    弹起 (38)
.如果真结束

按下 (键代码)
置随机数种子 ()
辅助延时 (取随机数 (时间, 时间 ＋ 15), )
弹起 (键代码)

.子程序 字符按键
.参数 字符, 文本型

dm.KeyDownChar (字符)
辅助延时 (60, )
dm.KeyUpChar (字符)
辅助延时 (60, )

.子程序 弹起方向键

弹起 (37)
弹起 (38)
弹起 (39)
弹起 (40)

.子程序 弹起左右键

弹起 (37)
弹起 (39)

.子程序 弹起上下键

弹起 (38)
弹起 (40)

窗口程序集_set

.版本 2

.程序集 窗口程序集_set

.子程序 _set关闭_被单击

set.销毁 ()

.子程序 _set_创建完毕

set.左边 ＝ jjk.左边 ＋ jjk.宽度
set.顶边 ＝ jjk.顶边 － set.高度 ＋ jjk.高度

算法

.版本 2
.支持库 spec

.程序集 算法

.子程序 计算角色坐标, 逻辑型
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断循环首 (真)
    .如果真 (dm.FindPic (0, 0, 800, 600, “右上.bmp”, “000000”, 1, 0, x, y) ≥ 0)  ' 偏移x -72 偏移y +197
        角色信息.角色坐标x ＝ x － 72
        角色信息.角色坐标y ＝ y ＋ 197
        ' 调试输出 (“角色坐标”, x － 72, y ＋ 角色信息.角色身高上)
        返回 (真)
    .如果真结束
    .如果真 (dm.FindPic (0, 0, 800, 600, “右下.bmp”, “000000”, 1, 0, x, y) ≥ 0)  ' 偏移x -72 偏移y +139
        角色信息.角色坐标x ＝ x － 72
        角色信息.角色坐标y ＝ y ＋ 139
        ' 调试输出 (“角色坐标”, x － 72, y ＋ 角色信息.角色身高下)
        返回 (真)
    .如果真结束
    .如果真 (dm.FindPic (0, 0, 800, 600, “左上.bmp”, “000000”, 1, 0, x, y) ≥ 0)  ' 偏移x +77 偏移y +197
        角色信息.角色坐标x ＝ x ＋ 77
        角色信息.角色坐标y ＝ y ＋ 197
        ' 调试输出 (“角色坐标”, x ＋ 77, y ＋ 角色信息.角色身高上)
        返回 (真)
    .如果真结束
    .如果真 (dm.FindPic (0, 0, 800, 600, “左下.bmp”, “000000”, 1, 0, x, y) ≥ 0)  ' 偏移x +77 偏移y +139
        角色信息.角色坐标x ＝ x ＋ 77
        角色信息.角色坐标y ＝ y ＋ 139
        ' 调试输出 (“角色坐标”, x ＋ 77, y ＋ 角色信息.角色身高下)
        返回 (真)
    .如果真结束
    跳出循环 ()
.判断循环尾 ()
返回 (假)

.子程序 计算角色身高
.局部变量 x, 整数型
.局部变量 y, 整数型

.如果真 (dm.FindPic (0, 0, 800, 600, “右上.bmp|左上.bmp”, “000000”, 1, 0, x, y) ≥ 0)  ' 偏移x -72 偏移y +197
    角色信息.角色身高上 ＝ 432 － y
    调试输出 (“角色身高上”, 432 － y)
.如果真结束
.如果真 (dm.FindPic (0, 0, 800, 600, “右下.bmp|左下.bmp”, “000000”, 1, 0, x, y) ≥ 0)  ' 偏移x +77 偏移y +139
    角色信息.角色身高下 ＝ 432 － y
    调试输出 (“角色身高下”, 432 － y)
.如果真结束


.子程序 取角色名望

dm.UseDict (1)
角色信息.角色名望 ＝ 到整数 (dm.Ocr (264, 278, 313, 296, “4aa256-000000”, 1))
调试输出 (角色信息.角色名望)

.子程序 取角色等级
.局部变量 x, 整数型
.局部变量 y, 整数型

dm.UseDict (1)
.如果真 (dm.FindStr (171, 241, 327, 256, “Lv”, “ffffff-000000”, 1, x, y) ≥ 0)
    角色信息.角色等级 ＝ 到整数 (dm.Ocr (x ＋ 14, y － 4, x ＋ 34, y ＋ 10, “ffffff-000000”, 1))
    调试输出 (角色信息.角色等级)
.如果真结束


.子程序 取角色移动速度
.局部变量 x, 整数型
.局部变量 y, 整数型
.局部变量 速度值, 文本型

dm.UseDict (1)
速度值 ＝ dm.Ocr (190, 448, 250, 472, “937639-000000|4aa256-000000|bc3232-000000”, 1)
.如果真 (速度值 ≠ “”)
    角色信息.角色速度x ＝ 0.000253 × (到整数 (速度值) ＋ 1000)
    角色信息.角色速度y ＝ 0.00013 × (到整数 (速度值) ＋ 1000)
    调试输出 (“角色速度x ” ＋ 到文本 (角色信息.角色速度x))
    调试输出 (“角色速度y ” ＋ 到文本 (角色信息.角色速度y))
.如果真结束


.子程序 取职业属性类型
.局部变量 属性, 文本型
.局部变量 攻击, 文本型

dm.UseDict (1)
.如果真 (dm.Ocr (346, 343, 382, 361, “4aa256-000000”, 1) ≠ “”)
    属性 ＝ “智力”
.如果真结束
.如果真 (dm.Ocr (206, 343, 250, 361, “4aa256-000000”, 1) ≠ “”)
    属性 ＝ “力量”
.如果真结束

.如果真 (dm.Ocr (213, 378, 248, 399, “4aa256-000000”, 1) ≠ “”)
    攻击 ＝ “物理”
.如果真结束
.如果真 (dm.Ocr (351, 378, 382, 399, “4aa256-000000”, 1) ≠ “”)
    攻击 ＝ “魔法”
.如果真结束
.如果真 (dm.Ocr (209, 416, 249, 435, “4aa256-000000”, 1) ≠ “”)
    攻击 ＝ “独立”
.如果真结束

角色信息.角色职业类型 ＝ 属性 ＋ 攻击
调试输出 (角色信息.角色职业类型)

.子程序 取角色职业

dm.UseDict (0)
角色信息.角色职业 ＝ dm.Ocr (210, 256, 301, 271, “ffffff-000000”, 1)
调试输出 (“角色职业 ” ＋ 角色信息.角色职业)

.子程序 取角色名

dm.UseDict (2)
角色信息.角色名 ＝ dm.Ocr (168, 240, 331, 257, “ffffff-000000”, 1)
调试输出 (“角色名 ” ＋ 角色信息.角色名)

.子程序 取角色信息


鼠标到右下 ()
.如果真 (取反 (角色信息.取角色信息))
    回到赛丽亚房间 ()
    计算角色身高 ()
    计算角色坐标 ()
    打开个人信息 ()
    取冒险团信息 ()
    取角色名望 ()
    取角色等级 ()
    取职业属性类型 ()
    取角色职业 ()
    取角色名 ()
    取角色移动速度 ()
    关闭个人信息 ()
    角色信息.取角色信息 ＝ 真
.如果真结束


.子程序 取背包金币
.局部变量 x, 整数型
.局部变量 y, 整数型

辅助延时 (500)
dm.UseDict (0)
.如果真 (dm.FindStr (464, 303, 723, 586, “金币”, “937639-000000”, 1, x, y) ≥ 0)
    dm.UseDict (1)
    背包信息.金币 ＝ 到整数 (dm.Ocr (x － 72, y － 5, x, y ＋ 14, “937639-000000”, 1))
    调试输出 (“背包金币 ” ＋ 到文本 (背包信息.金币))
.如果真结束


.子程序 取背包点券
.局部变量 x, 整数型
.局部变量 y, 整数型

辅助延时 (500)
dm.UseDict (0)
.如果真 (dm.FindStr (464, 303, 723, 586, “点券”, “937639-000000”, 1, x, y) ≥ 0)
    dm.UseDict (1)
    背包信息.点券 ＝ 到整数 (dm.Ocr (x － 72, y － 5, x, y ＋ 14, “937639-000000”, 1))
    调试输出 (“背包点券 ” ＋ 到文本 (背包信息.点券))
.如果真结束


.子程序 取背包信息

打开装备栏 ()
取背包金币 ()
取背包点券 ()
关闭装备栏 ()

.子程序 取账号冒险团名

dm.UseDict (0)
账号信息.冒险团名 ＝ dm.Ocr (203, 212, 306, 253, “a9ffab-050505”, 1)
调试输出 (“冒险团名 ” ＋ 账号信息.冒险团名)

.子程序 取账号冒险团等级

dm.UseDict (1)
账号信息.冒险团等级 ＝ 到整数 (dm.Ocr (576, 570, 593, 585, “d2cc80-050505”, 1))
调试输出 (“冒险团等级 ” ＋ 到文本 (账号信息.冒险团等级))

.子程序 取冒险团信息

取账号冒险团名 ()
取账号冒险团等级 ()

.子程序 计算物品坐标, 逻辑型
.局部变量 x, 整数型
.局部变量 y, 整数型
.局部变量 史诗物品, 文本型
.局部变量 传说物品, 文本型
.局部变量 神器物品, 文本型
.局部变量 稀有物品, 文本型
.局部变量 高级物品, 文本型
.局部变量 普通物品, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 索引, 双精度小数型
.局部变量 坐标组, 文本型, , "0"
.局部变量 长度, 双精度小数型
.局部变量 位置, 整数型

物品信息.物品坐标x ＝ 0
物品信息.物品坐标y ＝ 0
dm.UseDict (2)
史诗物品 ＝ dm.OcrEx (0, 115, 800, 534, “ffb400”, 1)
传说物品 ＝ dm.OcrEx (0, 115, 800, 534, “ff7800”, 1)
神器物品 ＝ dm.OcrEx (0, 115, 800, 534, “ff00ff”, 1)
稀有物品 ＝ dm.OcrEx (0, 115, 800, 534, “b36bff”, 1)
高级物品 ＝ dm.OcrEx (0, 115, 800, 534, “68d5ed”, 1)
' 普通物品 ＝ dm.OcrEx (0, 115, 800, 534, “ffffff”, 1)
.判断开始 (史诗物品 ≠ “”)
    组 ＝ 分割文本 (史诗物品, “|”, )
.判断 (传说物品 ≠ “”)
    组 ＝ 分割文本 (传说物品, “|”, )
.判断 (神器物品 ≠ “”)
    组 ＝ 分割文本 (神器物品, “|”, )
.判断 (稀有物品 ≠ “”)
    组 ＝ 分割文本 (稀有物品, “|”, )
.判断 (高级物品 ≠ “”)
    组 ＝ 分割文本 (高级物品, “|”, )
.判断 (普通物品 ≠ “”)
    组 ＝ 分割文本 (普通物品, “|”, )
.默认

.判断结束
.判断开始 (取数组成员数 (组) ＞ 0)
    删除成员 (组, 1, )
    .判断开始 (到整数 (取数组成员数 (组) ％ 2) ＝ 0)
        索引 ＝ 到整数 (取数组成员数 (组) ÷ 2)
        坐标组 ＝ 分割文本 (组 [索引], “,”, )
        物品信息.物品坐标x ＝ 到整数 (坐标组 [1]) ＋ 12
        物品信息.物品坐标y ＝ 到整数 (坐标组 [2]) ＋ 30
    .默认
        索引 ＝ 取整 (取数组成员数 (组) ÷ 2) ＋ 1
        坐标组 ＝ 分割文本 (组 [索引], “,”, )
        物品信息.物品坐标x ＝ 到整数 (坐标组 [1])
        物品信息.物品坐标y ＝ 到整数 (坐标组 [2]) ＋ 30
    .判断结束

.判断 (dm.FindPic (0, 115, 800, 534, “物品右上.bmp|物品左上.bmp|物品右下.bmp|物品左下.bmp”, “000000”, 1, 1, x, y) ≥ 0)
    物品信息.物品坐标x ＝ x
    物品信息.物品坐标y ＝ y ＋ 30
.默认
    物品信息.物品坐标x ＝ 0
    物品信息.物品坐标y ＝ 0
.判断结束

.判断开始 (物品信息.物品坐标x ＞ 0 且 物品信息.物品坐标y ＞ 0)
    ' 绝对移动 (物品信息.物品坐标x, 物品信息.物品坐标y)
    ' 调试输出 (“物品坐标”, 物品信息.物品坐标x, 物品信息.物品坐标y)
    返回 (真)
.默认
    返回 (假)
.判断结束


.子程序 计算怪物坐标, 逻辑型
.参数 怪物表, 文本型, 可空
.参数 偏色, 文本型, 可空
.局部变量 x, 整数型
.局部变量 y, 整数型

.' 如果真 (dm.FindPic (0, 0, 800, 600, “怪物左上.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    ' ’调试输出 (x, y)
    ' 怪物信息.怪物坐标x ＝ x ＋ 180
    ' 怪物信息.怪物坐标y ＝ y ＋ 135
.如果真结束
.' 如果真 (dm.FindPic (0, 0, 800, 600, “怪物右上.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    ' ’调试输出 (x, y)
    ' 怪物信息.怪物坐标x ＝ x － 180
    ' 怪物信息.怪物坐标y ＝ y ＋ 135
.如果真结束
.' 如果真 (dm.FindPic (0, 0, 800, 600, “怪物中上.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    ' ’调试输出 (x, y)
    ' 怪物信息.怪物坐标x ＝ x ＋ 10
    ' 怪物信息.怪物坐标y ＝ y ＋ 135
.如果真结束

.判断开始 (dm.FindPic (0, 300, 800, 480, 怪物表, 偏色, 1, 1, x, y) ≥ 0 或 dm.FindPic (0, 140, 800, 600, 怪物表, 偏色, 1, 1, x, y) ≥ 0)
    怪物信息.怪物坐标x ＝ x
    怪物信息.怪物坐标y ＝ y
    返回 (真)
.判断 (dm.FindPic (0, 300, 800, 480, “怪物左上.bmp”, “000000”, 1, 0, x, y) ≥ 0 或 dm.FindPic (0, 140, 800, 600, “怪物左上.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    ' 调试输出 (x, y)
    怪物信息.怪物坐标x ＝ x ＋ 180
    怪物信息.怪物坐标y ＝ y ＋ 135
    返回 (真)
.判断 (dm.FindPic (0, 300, 800, 480, “怪物右上.bmp”, “000000”, 1, 0, x, y) ≥ 0 或 dm.FindPic (0, 140, 800, 600, “怪物右上.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    ' 调试输出 (x, y)
    怪物信息.怪物坐标x ＝ x － 180
    怪物信息.怪物坐标y ＝ y ＋ 135
    返回 (真)
.判断 (dm.FindPic (0, 300, 800, 480, “怪物中上.bmp”, “000000”, 1, 0, x, y) ≥ 0 或 dm.FindPic (0, 140, 800, 600, “怪物中上.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    ' 调试输出 (x, y)
    怪物信息.怪物坐标x ＝ x ＋ 10
    怪物信息.怪物坐标y ＝ y ＋ 135
    返回 (真)
.默认
    返回 (假)
.判断结束

线程

.版本 2
.支持库 spec

.程序集 线程

.子程序 主线程

.判断循环首 (真)
    取角色信息 ()
    无底坑道 ()
    切换下个角色 ()
.判断循环尾 ()
调试输出 (“ok”)

.子程序 副线程



.子程序 线程循环

.判断循环首 (真)
    .如果真 (dm.GetKeyState (116) ＝ 1)
        启动 ()
    .如果真结束
    .如果真 (dm.GetKeyState (117) ＝ 1)
        暂停和恢复 ()
    .如果真结束
    .如果真 (dm.GetKeyState (118) ＝ 1)
        停止 ()
    .如果真结束
    .如果真 (dm.GetKeyState (119) ＝ 1)
        退出 ()
    .如果真结束
    辅助延时 (10)
.判断循环尾 ()

功能

.版本 2
.支持库 spec

.程序集 功能

.子程序 打开个人信息
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断循环首 (真)
    .判断开始 (dm.FindPic (0, 0, 800, 600, “个人信息.bmp”, “000000”, 1, 0, x, y) ≥ 0)
        .判断开始 (dm.FindPic (0, 0, 800, 600, “角色信息.bmp”, “000000”, 1, 0, x, y) ≥ 0)
            跳出循环 ()
        .默认
            按键 (#Tab键, 70)
        .判断结束

    .默认
        按键 (#M键, 70)
    .判断结束
    辅助延时 (500, )
.判断循环尾 ()

.子程序 关闭个人信息
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断循环首 (真)
    .判断开始 (dm.FindPic (0, 0, 800, 600, “个人信息.bmp”, “000000”, 1, 0, x, y) ＜ 0)
        跳出循环 ()
    .默认
        按键 (#M键, 70)
    .判断结束
    辅助延时 (500, )
.判断循环尾 ()

.子程序 打开装备栏
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断循环首 (真)
    .判断开始 (dm.FindPic (0, 0, 800, 600, “物品栏特征.bmp”, “000000”, 1, 0, x, y) ≥ 0)
        跳出循环 ()
    .默认
        按键 (#I键, 70)
    .判断结束
    辅助延时 (500, )
.判断循环尾 ()

.子程序 关闭装备栏
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断循环首 (真)
    .判断开始 (dm.FindPic (0, 0, 800, 600, “物品栏特征.bmp”, “000000”, 1, 0, x, y) ＜ 0)
        跳出循环 ()
    .默认
        按键 (#I键, 70)
    .判断结束
    辅助延时 (500, )
.判断循环尾 ()

.子程序 进入游戏
.局部变量 x, 整数型
.局部变量 y, 整数型

.计次循环首 (5, )
    .如果 (取是否在赛丽亚房间 ())
        辅助延时 (1000)
        跳出循环 ()
    .否则
        移动左键单击 (405, 570, 1, 80)
        辅助延时 (3000)
    .如果结束

.计次循环尾 ()

.子程序 取是否在赛丽亚房间, 逻辑型
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断开始 (dm.FindPic (0, 0, 800, 600, “事务所的黛娜.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    调试输出 (“在赛丽亚房间”)
    返回 (真)
.默认
    返回 (假)
.判断结束


.子程序 回到赛丽亚房间

.如果真 (取是否在赛丽亚房间 () ＝ 假)
    切换到选择角色界面 ()
    进入游戏 ()
.如果真结束


.子程序 切换到选择角色界面
.局部变量 x, 整数型
.局部变量 y, 整数型

打开菜单 ()
.判断循环首 (真)
    dm.UseDict (0)
    .判断开始 (dm.FindStr (0, 0, 800, 600, “选择角色”, “e6c89b-000000”, 1, x, y) ≥ 0)
        移动左键单击 (x ＋ 10, y ＋ 5, 1, 80)
        辅助延时 (350)
    .默认
        dm.UseDict (1)
        .如果真 (dm.FindStr (0, 0, 800, 600, “Lv”, “d1b994-000000”, 1, x, y) ≥ 0)
            跳出循环 ()
        .如果真结束

    .判断结束

.判断循环尾 ()

.子程序 打开菜单
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断循环首 (真)
    dm.UseDict (0)
    .如果 (dm.FindStr (0, 0, 800, 600, “游戏设置|我的信息”, “e6c89b-000000”, 1, x, y) ≥ 0)
        跳出循环 ()
    .否则
        鼠标到右下 ()
        按键 (#Esc键, 70)
    .如果结束
    辅助延时 (500, )
.判断循环尾 ()


.子程序 关闭菜单
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断循环首 (真)
    dm.UseDict (0)
    .如果 (dm.FindStr (0, 0, 800, 600, “游戏设置|我的信息”, “e6c89b-000000”, 1, x, y) ＜ 0)
        跳出循环 ()
    .否则
        鼠标到右下 ()
        按键 (#Esc键, 70)
    .如果结束
    辅助延时 (500, )
.判断循环尾 ()

.子程序 关闭窗口
.局部变量 x, 整数型
.局部变量 y, 整数型

dm.UseDict (0)
.判断循环首 (真)
    .判断开始 (计算角色坐标 ())
        跳出循环 ()
    .默认
        按键 (#Esc键, 70)
    .判断结束
    辅助延时 (500, )
.判断循环尾 ()

.子程序 德洛斯矿山进图
.局部变量 x, 整数型
.局部变量 y, 整数型

按下 (39)
.判断循环首 (真)
    .如果真 (dm.FindPic (0, 0, 800, 600, “德洛斯矿山.bmp”, “000000”, 0.9, 0, x, y) ≥ 0)
        弹起方向键 ()
        移动右键单击 (383, 511, 1, 80)
        辅助延时 (1500, )
        跳出循环 ()
    .如果真结束

.判断循环尾 ()
搬砖进图 (39)

.子程序 搬砖进图
.参数 方向, 整数型
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断开始 (方向 ＝ 37)
    按键 (39, 100)
.判断 (方向 ＝ 39)
    按键 (37, 100)
.默认

.判断结束
辅助延时 (350, )
按下 (方向)
.判断循环首 (真)
    dm.UseDict (0)
    .如果真 (dm.FindStr (715, 538, 781, 566, “返回城镇”, “b99460-000000”, 1, x, y) ≥ 0)
        辅助延时 (350, )
        弹起 (方向)
        弹起方向键 ()
        调试输出 (“已进入到选择副本界面”)
        跳出循环 ()
    .如果真结束

.判断循环尾 ()

.子程序 选择副本
.参数 副本名, 文本型
.局部变量 x, 整数型
.局部变量 y, 整数型
.局部变量 次数, 整数型

.判断循环首 (真)
    dm.UseDict (0)
    .如果 (dm.FindStr (623, 476, 803, 513, 副本名, “ddc593-000000”, 1, x, y) ≥ 0)
        辅助延时 (350, )
        跳出循环 ()
    .否则
        次数 ＝ 次数 ＋ 1
        .如果 (次数 ≥ 10)
            按键 (38, 60)
            辅助延时 (350, )
            按键 (39, 60)
            辅助延时 (350, )
            按键 (37, 60)
            辅助延时 (350, )
            .如果 (次数 ≥ 20)
                次数 ＝ 0
            .否则

            .如果结束

        .否则
            按键 (40, 60)
            辅助延时 (350, )
            按键 (39, 60)
            辅助延时 (350, )
            按键 (37, 60)
            辅助延时 (350, )
        .如果结束

    .如果结束

.判断循环尾 ()
副本信息.副本名 ＝ 副本名
调试输出 (“已选择副本 ” ＋ 副本信息.副本名)
辅助延时 (350, )

.子程序 选择副本难度
.参数 副本难度, 文本型
.局部变量 x, 整数型
.局部变量 y, 整数型

辅助延时 (1000, )
.判断开始 (副本难度 ＝ “普通级”)
    .计次循环首 (6, )
        按键 (37, 60)
        辅助延时 (60, )
    .计次循环尾 ()
.判断 (副本难度 ＝ “冒险级”)
    .计次循环首 (6, )
        按键 (37, 60)
        辅助延时 (60, )
    .计次循环尾 ()
    按键 (39, 60)
    辅助延时 (60, )
.判断 (副本难度 ＝ “勇士级”)
    .计次循环首 (6, )
        按键 (37, 60)
        辅助延时 (60, )
    .计次循环尾 ()
    .计次循环首 (2, )
        按键 (39, 60)
        辅助延时 (60, )
    .计次循环尾 ()
.判断 (副本难度 ＝ “王者级”)
    .计次循环首 (6, )
        按键 (37, 60)
        辅助延时 (60, )
    .计次循环尾 ()
    .计次循环首 (3, )
        按键 (39, 60)
        辅助延时 (60, )
    .计次循环尾 ()
.判断 (副本难度 ＝ “噩梦级”)
    .计次循环首 (6, )
        按键 (37, 60)
        辅助延时 (60, )
    .计次循环尾 ()
    .计次循环首 (4, )
        按键 (39, 60)
        辅助延时 (60, )
    .计次循环尾 ()
.默认

.判断结束
辅助延时 (350, )
副本信息.副本难度 ＝ 副本难度
调试输出 (“已选择副本难度 ” ＋ 副本难度)
.计次循环首 (4, )
    按键 (32, 60)
.计次循环尾 ()

.子程序 卡房间一
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断循环首 (真)
    .如果真 (dm.FindPic (619, 18, 800, 164, “小地图角色图标.bmp”, “000000”, 1, 0, x, y) ≥ 0)
        调试输出 (“进入副本”)
        图内取速度 ()
        跳出循环 ()
    .如果真结束

.判断循环尾 ()

.子程序 取是否开门, 逻辑型
.参数 x1, 整数型
.参数 y1, 整数型
.参数 x2, 整数型
.参数 y2, 整数型
.局部变量 x, 整数型
.局部变量 y, 整数型

.如果真 (dm.FindPic (x1, y1, x2, y2, “开门特征1.bmp”, “000000”, 1, 0, x, y) ≥ 0 或 dm.FindPic (x1, y1, x2, y2, “开门特征.bmp”, “000000”, 1, 0, x, y) ≥ 0 且 dm.FindPic (x1, y1, x2, y2, “开门提示.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    调试输出 (“已开门”)
    返回 (真)
.如果真结束
返回 (假)

.子程序 取是否开门A
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断循环首 (真)
    .判断开始 (dm.FindPic (0, 0, 800, 500, “boss开门提示.bmp”, “000000”, 1, 0, x, y) ＜ 0)
        全_开门 ＝ 真
    .默认
        全_开门 ＝ 假
    .判断结束
    .如果真 (取反 (全_开门线程信号))
        跳出循环 ()
    .如果真结束
    打面前的怪 ()
.判断循环尾 ()
全_开门 ＝ 假

.子程序 判断捡物
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断循环首 (真)
    .如果真 (dm.FindPic (0, 0, 800, 600, #值钱拾取特征表, “000000”, 1, 0, x, y) ≥ 0)
        弹起左右键 ()
        辅助延时 (50, )
        按键 (88, 60)
    .如果真结束
    .如果真 (dm.FindPic (0, 0, 800, 600, #垃圾拾取特征表, “000000”, 1, 0, x, y) ≥ 0)
        弹起左右键 ()
        辅助延时 (50, )
        按键 (88, 60)
    .如果真结束
    .如果真 (角色动作.拾取完毕)
        角色动作.拾取完毕 ＝ 假
        跳出循环 ()
    .如果真结束

.判断循环尾 ()

.子程序 图内取速度

.如果真 (取反 (角色信息.取角色图内速度))
    打开个人信息 ()
    取角色移动速度 ()
    关闭个人信息 ()
    角色信息.取角色图内速度 ＝ 真
.如果真结束


.子程序 拾取物品
.局部变量 x, 整数型
.局部变量 y, 整数型

线程_启动 (&判断捡物, , )
.判断循环首 (真)
    .如果 (计算角色坐标 () 且 计算物品坐标 ())
        移动到目标点 (角色信息.角色坐标x, 角色信息.角色坐标y, 物品信息.物品坐标x, 物品信息.物品坐标y)
        物品信息.物品坐标x ＝ 0
        物品信息.物品坐标y ＝ 0
    .否则
        .如果真 (dm.FindPic (0, 0, 800, 600, #值钱拾取特征表, “000000”, 1, 0, x, y) ＜ 0 且 dm.FindPic (0, 0, 800, 600, #垃圾拾取特征表, “000000”, 1, 0, x, y) ＜ 0)
            跳出循环 ()
        .如果真结束

    .如果结束
    .如果真 (取反 (全_开门))
        跳出循环 ()
    .如果真结束

.判断循环尾 ()
弹起方向键 ()
角色动作.拾取完毕 ＝ 真

.子程序 加血
.局部变量 颜色a, 文本型
.局部变量 颜色b, 文本型

颜色a ＝ dm.GetColor (254, 558)
颜色b ＝ dm.GetColor (254, 588)
.如果真 (颜色a ≠ “ff0000” 且 颜色a ≠ “f30000”)
    .如果真 (颜色b ＝ “ff0000” 或 颜色b ＝ “f30000”)
        按键 (49, 70)
    .如果真结束

.如果真结束


.子程序 移动到怪点, 逻辑型
.参数 怪物表, 文本型, 可空
.参数 偏色, 文本型, 可空
.局部变量 x, 整数型
.局部变量 y, 整数型

.如果真 (计算角色坐标 () 且 计算怪物坐标 (怪物表, 偏色) 且 取反 (全_开门))
    .判断开始 (角色信息.角色坐标x ＞ 怪物信息.怪物坐标x)
        .判断开始 (角色信息.角色坐标x ＞ 怪物信息.怪物坐标x ＋ 170)
            移动到目标点 (角色信息.角色坐标x, 角色信息.角色坐标y, 怪物信息.怪物坐标x ＋ 160, 怪物信息.怪物坐标y)
            返回 (真)
        .判断 (角色信息.角色坐标y ＜ 怪物信息.怪物坐标y)
            .如果真 (怪物信息.怪物坐标y － 角色信息.角色坐标y ＞ 5)
                移动到目标点 (角色信息.角色坐标x, 角色信息.角色坐标y, 怪物信息.怪物坐标x ＋ 160, 怪物信息.怪物坐标y)
                按键 (37, 70)
                返回 (真)
            .如果真结束

        .判断 (角色信息.角色坐标y ＞ 怪物信息.怪物坐标y)
            .如果真 (角色信息.角色坐标y － 怪物信息.怪物坐标y ＞ 20)
                移动到目标点 (角色信息.角色坐标x, 角色信息.角色坐标y, 怪物信息.怪物坐标x ＋ 160, 怪物信息.怪物坐标y)
                按键 (37, 70)
                返回 (真)
            .如果真结束

        .默认

        .判断结束

    .判断 (角色信息.角色坐标x ＜ 怪物信息.怪物坐标x)
        .判断开始 (角色信息.角色坐标x ＜ 怪物信息.怪物坐标x － 150)
            移动到目标点 (角色信息.角色坐标x, 角色信息.角色坐标y, 怪物信息.怪物坐标x － 140, 怪物信息.怪物坐标y)
            返回 (真)
        .判断 (角色信息.角色坐标y ＜ 怪物信息.怪物坐标y)
            .如果真 (怪物信息.怪物坐标y － 角色信息.角色坐标y ＞ 5)
                移动到目标点 (角色信息.角色坐标x, 角色信息.角色坐标y, 怪物信息.怪物坐标x － 140, 怪物信息.怪物坐标y)
                按键 (39, 70)
                返回 (真)
            .如果真结束

        .判断 (角色信息.角色坐标y ＞ 怪物信息.怪物坐标y)
            .如果真 (角色信息.角色坐标y － 怪物信息.怪物坐标y ＞ 20)
                移动到目标点 (角色信息.角色坐标x, 角色信息.角色坐标y, 怪物信息.怪物坐标x － 140, 怪物信息.怪物坐标y)
                按键 (39, 70)
                返回 (真)
            .如果真结束

        .默认

        .判断结束

    .默认
        返回 (真)
    .判断结束

.如果真结束
返回 (假)

.子程序 打面前的怪, 逻辑型
.局部变量 x, 整数型
.局部变量 y, 整数型
.局部变量 x1, 整数型

.如果真 (计算角色坐标 () 且 取反 (全_开门))
    x1 ＝ 角色信息.角色坐标x － 250
    .如果真 (x1 ＜ 0)
        x1 ＝ 0
    .如果真结束
    .如果真 (dm.FindPic (x1, 角色信息.角色坐标y － 40, 角色信息.角色坐标x, 角色信息.角色坐标y ＋ 20, 全_怪物表, 全_偏色, 1, 1, x, y) ≥ 0)
        弹起方向键 ()
        按键 (37, 70)
        释放技能 ()
        返回 (真)
    .如果真结束
    .如果真 (dm.FindPic (角色信息.角色坐标x, 角色信息.角色坐标y － 40, 角色信息.角色坐标x ＋ 250, 角色信息.角色坐标y ＋ 20, 全_怪物表, 全_偏色, 1, 1, x, y) ≥ 0)
        弹起方向键 ()
        按键 (39, 70)
        释放技能 ()
        返回 (真)
    .如果真结束

.如果真结束
返回 (假)

.子程序 智能打怪, 逻辑型
.参数 怪物表, 文本型, 可空
.参数 偏色, 文本型, 可空
.参数 boss, 逻辑型, 可空
.局部变量 x, 整数型
.局部变量 y, 整数型

加血 ()
打面前的怪 ()
.如果真 (移动到怪点 (怪物表, 偏色))
    .如果真 (boss)
        释放大招 ()
    .如果真结束
    释放技能 ()
    返回 (真)
.如果真结束
返回 (假)

.子程序 释放技能, 逻辑型
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 x, 整数型
.局部变量 y, 整数型

.如果真 (全_开门)
    返回 (真)
.如果真结束
i ＝ 0
j ＝ 0
dm.UseDict (1)
.计次循环首 (6, )
    .如果真 (dm.Ocr (300 ＋ i × 31, 534, 328 ＋ i × 31, 560, “ffffff”, 1) ＝ “”)
        .判断开始 (i ＝ 0)
            按键 (#Q键, 60)
        .判断 (i ＝ 1)
            按键 (#W键, 60)
        .判断 (i ＝ 2)
            按键 (#E键, 60)
        .判断 (i ＝ 3)
            按键 (#R键, 60)
        .判断 (i ＝ 4)
            按键 (#T键, 60)
        .判断 (i ＝ 5)
            按键 (#Y键, 60)
        .默认

        .判断结束
        返回 (真)
    .如果真结束
    i ＝ i ＋ 1
.计次循环尾 ()
.计次循环首 (6, )
    .如果真 (dm.Ocr (300 ＋ j × 31, 565, 330 ＋ j × 31, 594, “ffffff”, 1) ＝ “”)
        .判断开始 (j ＝ 0)
            按键 (#A键, 60)
        .判断 (j ＝ 1)
            按键 (#S键, 60)
        .判断 (j ＝ 2)
            按键 (#D键, 60)
        .判断 (j ＝ 3)
            按键 (#F键, 60)
        .判断 (j ＝ 4)
            按键 (#G键, 60)
        .判断 (j ＝ 5)
            按键 (#H键, 60)
        .默认

        .判断结束
        返回 (真)
    .如果真结束
    j ＝ j ＋ 1
.计次循环尾 ()
.计次循环首 (6, )
    按键 (88, 60)
.计次循环尾 ()
返回 (假)

.子程序 释放大招

.如果真 (全_开门)
    返回 ()
.如果真结束
dm.UseDict (1)
.如果真 (dm.Ocr (486, 568, 514, 592, “ffffff”, 1) ＝ “”)
    按键 (#Alt键, 60)
.如果真结束
返回 ()

.子程序 boss聚物

弹起方向键 ()
.计次循环首 (3, )
    按键 (96, 70)
.计次循环尾 ()
按键 (32, 70)
辅助延时 (500)
按键 (88, 2500)
弹起 (88)

.子程序 快速翻牌
.局部变量 x, 整数型
.局部变量 y, 整数型

.如果真 (dm.FindPic (0, 0, 800, 600, “跳过.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    弹起左右键 ()
    按键 (#Esc键, 70)
    辅助延时 (1500, )
.如果真结束


.子程序 再次挑战

按键 (#Esc键, 70)
关闭窗口 ()
.计次循环首 (3, )
    按键 (#F10键, 70)
.计次循环尾 ()

.子程序 识别职业名

' dm.UseDict (2)
' set.编辑框1.加入文本 (取文本右边 (dm.Ocr (665, 451, 776, 479, “e4af22-202020|7a6f5c-202020”, 1), 取文本长度 (dm.Ocr (665, 451, 776, 479, “e4af22-202020|7a6f5c-202020”, 1)) － 4) ＋ “=” ＋ #换行符)

' set.编辑框1.加入文本 (dm.Ocr (450, 451, 561, 473, “e4af22-202020|7a6f5c-202020”, 1) ＋ “=” ＋ #换行符)
' set.编辑框1.加入文本 (dm.Ocr (570, 450, 665, 479, “e4af22-202020|7a6f5c-202020”, 1) ＋ “=” ＋ #换行符)
' set.编辑框1.加入文本 (dm.Ocr (665, 451, 776, 479, “e4af22-202020|7a6f5c-202020”, 1) ＋ “=” ＋ #换行符)
' set.编辑框1.加入文本 (#换行符)

.子程序 取角色疲劳, 整数型
.局部变量 x, 整数型
.局部变量 y, 整数型
.局部变量 疲劳组, 文本型, , "0"
.局部变量 失败次数, 整数型

.判断循环首 (真)
    鼠标到右下 ()
    辅助延时 (150)
    绝对移动 (730, 594)
    辅助延时 (300)
    dm.UseDict (0)
    .判断开始 (dm.FindStr (385, 516, 800, 598, “疲劳值”, “ffffff-000000”, 1, x, y) ≥ 0)
        dm.UseDict (1)
        疲劳组 ＝ 分割文本 (dm.Ocr (x ＋ 44, y － 2, x ＋ 88, y ＋ 12, “ffffff-000000”, 1), “/”, )
        .判断开始 (疲劳组 [2] ＝ “156”)
            调试输出 (“无黑钻”)
        .默认
            调试输出 (“有黑钻”)
        .判断结束
        角色信息.角色疲劳 ＝ 到整数 (疲劳组 [1])
        调试输出 (“角色疲劳 ” ＋ 到文本 (角色信息.角色疲劳))
        ' 如果真 (角色信息.角色疲劳 ≤ 预留疲劳 且 取是否预留疲劳 ())
        ' 返回 (0)
        返回 (角色信息.角色疲劳)
    .默认
        失败次数 ＝ 失败次数 ＋ 1
        .如果真 (失败次数 ＞ 10)
            关闭窗口 ()
        .如果真结束

    .判断结束

.判断循环尾 ()
返回 (-1)

.子程序 副本返回城镇
.局部变量 x, 整数型
.局部变量 y, 整数型

调试输出 (“返回城镇”)
.判断循环首 (真)
    .如果真 (取反 (取是否城镇 ()))
        dm.UseDict (0)
        按键 (27, 70)
        辅助延时 (500)
        .如果真 (dm.FindStr (190, 140, 637, 495, “返回城镇”, “e6c89b-000000”, 1, x, y) ≥ 0)
            移动左键单击 (x ＋ 20, y － 20, 1, 70)
            辅助延时 (500)
        .如果真结束
        .如果真 (dm.FindStr (0, 0, 800, 600, “确认|完成”, “e3d49a-000000|b99460-000000”, 1, x, y) ≥ 0)
            移动左键单击 (x ＋ 10, y ＋ 5, 1, 70)
            辅助延时 (500)
        .如果真结束
        辅助延时 (500)
    .如果真结束

    .如果真 (取是否城镇 ())
        调试输出 (“在城镇”)
        跳出循环 ()
    .如果真结束

.判断循环尾 ()

.子程序 取是否城镇, 逻辑型
.局部变量 x, 整数型
.局部变量 y, 整数型

辅助延时 (1000)
dm.UseDict (1)
.判断开始 (dm.FindStr (608, 4, 623, 18, “ch”, “e1c593-001515”, 1, x, y) ≥ 0)
    返回 (真)
.默认
    返回 (假)
.判断结束


.子程序 打开城镇商店
.局部变量 x, 整数型
.局部变量 y, 整数型

调试输出 (“打开城镇商店”)
.判断循环首 (真)
    dm.UseDict (0)
    .如果 (dm.FindStr (0, 0, 800, 600, “商店”, “e6c89b-000000”, 1, x, y) ≥ 0)
        辅助延时 (500)
        移动左键单击 (x ＋ 20, y ＋ 5, 1, 75)
        辅助延时 (500)
    .否则
        打开城镇分解机 ()
    .如果结束
    .如果真 (dm.FindStr (143, 504, 385, 560, “出售”, “b99460-000000”, 1, x, y) ≥ 0)
        跳出循环 ()
    .如果真结束

.判断循环尾 ()

.子程序 打开城镇分解机
.局部变量 x, 整数型
.局部变量 y, 整数型

.如果真 (dm.FindPic (0, 0, 800, 600, “城镇分解机.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    辅助延时 (500)
    移动左键单击 (x ＋ 50, y, 1, 75)
    辅助延时 (500)
.如果真结束


.子程序 城镇出售
.局部变量 x, 整数型
.局部变量 y, 整数型

打开城镇商店 ()
dm.UseDict (0)
.判断循环首 (真)
    .判断开始 (dm.FindStr (122, 182, 444, 290, “出售”, “b99460-000000”, 1, x, y) ≥ 0)
        跳出循环 ()
    .默认
        辅助延时 (500)
        移动左键单击 (146, 524, 1, 75)
        辅助延时 (500)
    .判断结束

.判断循环尾 ()
辅助延时 (500)
绝对移动 (204, 232)
辅助延时 (500)
.如果真 (dm.FindPic (153, 304, 178, 323, “√.bmp”, “000000”, 1, 0, x, y) ＜ 0)
    辅助延时 (500)
    移动左键单击 (164, 314, 1, 75)
    辅助延时 (500)
    绝对移动 (204, 232)
    辅助延时 (500)
.如果真结束
.如果真 (dm.FindPic (152, 321, 175, 341, “√.bmp”, “000000”, 1, 0, x, y) ＜ 0)
    辅助延时 (500)
    移动左键单击 (164, 330, 1, 75)
    辅助延时 (500)
    绝对移动 (204, 232)
    辅助延时 (500)
.如果真结束
.如果真 (dm.FindPic (154, 338, 181, 357, “√.bmp”, “000000”, 1, 0, x, y) ＜ 0)
    辅助延时 (500)
    移动左键单击 (164, 347, 1, 75)
    辅助延时 (500)
    绝对移动 (204, 232)
    辅助延时 (500)
.如果真结束
.如果真 (dm.FindPic (153, 358, 174, 381, “√.bmp”, “000000”, 1, 0, x, y) ＜ 0)
    辅助延时 (500)
    移动左键单击 (164, 367, 1, 75)
    辅助延时 (500)
    绝对移动 (204, 232)
    辅助延时 (500)
.如果真结束
左键点击 (1, 75)
辅助延时 (500)
移动左键单击 (263, 415, 1, 75)
辅助延时 (500)
移动左键单击 (204, 414, 1, 75)
辅助延时 (500)
关闭窗口 ()

.子程序 切换下个角色
.局部变量 背包金币, 整数型
.局部变量 x, 整数型
.局部变量 y, 整数型

切换到选择角色界面 ()
辅助延时 (4000)
按键 (39, 60)
辅助延时 (500)
进入游戏 ()

城镇移动

.版本 2
.支持库 spec

.程序集 城镇移动

.子程序 取城镇名

dm.UseDict (0)
城镇信息.城镇名 ＝ dm.Ocr (666, 29, 774, 47, “e6c89b-050505|cfb48b-050505”, 1)
调试输出 (城镇信息.城镇名)

.子程序 赛丽亚房间快速传送, 逻辑型
.参数 地点, 文本型
.局部变量 x, 整数型, 静态
.局部变量 y, 整数型, 静态

鼠标到右下 ()
按下 (39)
.判断循环首 (真)
    .如果真 (dm.FindPic (0, 0, 800, 600, 地点 ＋ “.bmp”, “151515”, 0.9, 0, x, y) ≥ 0)
        跳出循环 ()
    .如果真结束

.判断循环尾 ()
.如果真 (dm.FindPic (0, 0, 800, 600, 地点 ＋ “.bmp”, “151515”, 0.9, 0, x, y) ≥ 0)
    弹起方向键 ()
    移动左键单击 (x ＋ 20, y ＋ 10, 1, 70)
    按键 (32, 60)
    .判断循环首 (真)
        取城镇名 ()
        .如果真 (城镇信息.城镇名 ≠ “艾尔文防线” 且 城镇信息.城镇名 ≠ “” 且 地点 ≠ “艾尔文防线”)
            跳出循环 ()
        .如果真结束
        .如果真 (地点 ＝ “艾尔文防线”)
            .如果真 (城镇信息.城镇名 ＝ “艾尔文防线” 且 取是否在赛丽亚房间 () ＝ 假)
                跳出循环 ()
            .如果真结束

        .如果真结束

    .判断循环尾 ()
    返回 (真)
.如果真结束
返回 (假)

.子程序 城镇移动, 逻辑型
.参数 目的地, 文本型
.局部变量 x, 整数型
.局部变量 y, 整数型

取城镇名 ()
.如果真 (城镇信息.城镇名 ≠ 目的地)
    .如果真 (取反 (取是否在赛丽亚房间 ()))
        回到赛丽亚房间 ()
    .如果真结束
    .如果真 (目的地 ＝ “艾尔罗斯-风---一航”)
        赛丽亚房间快速传送 (“比拉谢尔号”)
        移动右键单击 (193, 317, 1, 80)
        .判断循环首 (真)
            .如果真 (dm.FindPic (0, 0, 800, 600, “风暴航路.bmp”, “202020”, 1, 0, x, y) ≥ 0)
                跳出循环 ()
            .如果真结束

        .判断循环尾 ()
        .如果真 (dm.FindPic (0, 0, 800, 600, “风暴航路.bmp”, “202020”, 1, 0, x, y) ≥ 0)
            移动左键单击 (x ＋ 20, y ＋ 10, 1, 80)
            按键 (32, 60)
        .如果真结束
        .判断循环首 (真)
            取城镇名 ()
            .如果真 (城镇信息.城镇名 ＝ “艾尔罗斯-风---一航”)
                弹起方向键 ()
                调试输出 (“到达艾尔罗斯-风暴航路”)
                跳出循环 ()
            .如果真结束

        .判断循环尾 ()
        返回 (真)
    .如果真结束

    .如果真 (目的地 ＝ “切斯特小镇”)
        赛丽亚房间快速传送 (“艾尔文防线”)
        移动右键单击 (500, 455, 5, 75)
        按下 (39)
        .判断循环首 (真)
            取城镇名 ()
            .如果真 (城镇信息.城镇名 ＝ “切斯特小镇”)
                弹起方向键 ()
                调试输出 (“到达切斯特小镇”)
                跳出循环 ()
            .如果真结束

        .判断循环尾 ()
        返回 (真)
    .如果真结束
    .如果真 (目的地 ＝ “黑市”)
        赛丽亚房间快速传送 (“西海岸港口码头”)
        取城镇名 ()
        .如果真 (城镇信息.城镇名 ＝ “西海岸”)
            调试输出 (“到达西海岸港口码头”)
        .如果真结束
        移动右键单击 (400, 270, 1, 80)
        辅助延时 (3000, )
        .计次循环首 (3, )
            移动左键单击 (624, 65, 1, 70)
            辅助延时 (100, )
        .计次循环尾 ()
        .判断循环首 (真)
            取城镇名 ()
            .如果真 (城镇信息.城镇名 ＝ “黑市”)
                弹起方向键 ()
                调试输出 (“到达黑市”)
                跳出循环 ()
            .如果真结束

        .判断循环尾 ()
        返回 (真)
    .如果真结束

.如果真结束
返回 (假)

.子程序 到风暴航路

城镇移动 (“艾尔罗斯-风---一航”)

.子程序 到切斯特小镇

城镇移动 (“切斯特小镇”)

.子程序 到黑市

城镇移动 (“黑市”)

无底坑道

.版本 2
.支持库 spec

.程序集 无底坑道

.子程序 无底坑道
.局部变量 i, 整数型

.计次循环首 (2, )
    执行搬砖进图选图 (“无底坑道”)
    i ＝ 0
    .判断循环首 (真)
        i ＝ i ＋ 1
        无底坑道副本 ()
        取角色疲劳 ()
        .如果真 (角色信息.角色疲劳 ＜ 8)
            跳出循环 ()
        .如果真结束
        .如果真 (i ＜ 12)
            再次挑战 ()
        .如果真结束
        .如果真 (i ＝ 12)
            跳出循环 ()
        .如果真结束

    .判断循环尾 ()
    副本返回城镇 ()
    城镇出售 ()
    .如果真 (角色信息.角色疲劳 ＜ 8)
        跳出循环 ()
    .如果真结束

.计次循环尾 ()

.子程序 无底坑道取房间号, 整数型
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断开始 (dm.FindPic (667, 47, 685, 65, “小地图角色图标.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    返回 (1)
.判断 (dm.FindPic (685, 47, 703, 65, “小地图角色图标.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    返回 (2)
.判断 (dm.FindPic (703, 47, 721, 65, “小地图角色图标.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    返回 (3)
.判断 (dm.FindPic (721, 47, 739, 65, “小地图角色图标.bmp|深渊图标.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    返回 (4)
.判断 (dm.FindPic (739, 47, 757, 65, “小地图角色图标.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    返回 (5)
.判断 (dm.FindPic (757, 47, 775, 65, “小地图角色图标.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    返回 (6)
.判断 (dm.FindPic (757, 47, 776, 64, “boss房间.bmp”, “000000”, 1, 0, x, y) ≥ 0)
    全_开门线程信号 ＝ 假
    返回 (0)
.默认
    dm.UseDict (0)
    .如果真 (dm.FindStr (13, 491, 314, 546, “出售”, “b99460-050505”, 1, x, y) ≥ 0)
        全_开门线程信号 ＝ 假
        返回 (0)
    .如果真结束
    返回 (-1)
.判断结束


.子程序 无底坑道过图, 逻辑型
.参数 房间号, 整数型
.局部变量 x, 整数型
.局部变量 y, 整数型
.局部变量 偏移x, 整数型
.局部变量 i, 整数型

.判断开始 (房间号 ＞ 0)
    .计次循环首 (2, )
        .如果真 (dm.FindPic (0, 0, 800, 600, “横坐标轴1.bmp”, “000000”, 1, 0, x, y) ≥ 0)
            .判断开始 (角色信息.角色坐标x ＞ 552)
                偏移x ＝ -200
            .判断 (角色信息.角色坐标x ＜ 200)
                偏移x ＝ 200
            .默认
                偏移x ＝ 10
            .判断结束
            .如果真 (计算角色坐标 () 且 移动到目标点 (角色信息.角色坐标x, 角色信息.角色坐标y, 角色信息.角色坐标x ＋ 偏移x, y ＋ 190))
                i ＝ i ＋ 1
            .如果真结束

        .如果真结束

    .计次循环尾 ()
    .如果真 (i ＝ 2)
        角色跑动 (39)
        返回 (无底坑道过图判断 (房间号))
    .如果真结束

.默认
    返回 (假)
.判断结束
返回 (假)

.子程序 无底坑道过图判断, 逻辑型
.参数 房间号, 整数型
.局部变量 局_房间号, 整数型

.计次循环首 (50, )
    局_房间号 ＝ 无底坑道取房间号 ()
    .如果 (局_房间号 ≥ 0 且 局_房间号 ≠ 房间号)
        弹起方向键 ()
        调试输出 (“过图成功”)
        返回 (真)
    .否则
        辅助延时 (25, )
    .如果结束
    .如果真 (取反 (全_开门))
        弹起方向键 ()
        调试输出 (“过图成功”)
        返回 (真)
    .如果真结束

.计次循环尾 ()
返回 (假)

.子程序 无底坑道寻怪
.参数 寻怪方向, 逻辑型
.参数 怪物表, 文本型
.参数 偏色, 文本型

.如果真 (计算角色坐标 () 且 取反 (全_开门))
    移动到目标点 (角色信息.角色坐标x, 角色信息.角色坐标y, 400, 417)
    调试输出 (“寻找怪物”)
    .判断开始 (寻怪方向)
        角色跑动 (39)
        .计次循环首 (5, )
            .如果真 (计算角色坐标 () 且 角色信息.角色坐标x ＞ 450 或 全_开门)
                弹起方向键 ()
                返回 ()
            .如果真结束
            .如果真 (计算怪物坐标 (怪物表, 偏色))
                弹起方向键 ()
                返回 ()
            .如果真结束

        .计次循环尾 ()
    .默认
        角色跑动 (37)
        .计次循环首 (5, )
            .如果真 (计算角色坐标 () 且 角色信息.角色坐标x ＜ 150 或 全_开门)
                弹起方向键 ()
                返回 ()
            .如果真结束
            .如果真 (计算怪物坐标 (怪物表, 偏色))
                弹起方向键 ()
                返回 ()
            .如果真结束

        .计次循环尾 ()
    .判断结束

.如果真结束


.子程序 无底坑道副本
.局部变量 房间号, 整数型
.局部变量 x, 整数型
.局部变量 y, 整数型
.局部变量 寻怪方向, 逻辑型

卡房间一 ()
全_开门线程信号 ＝ 真
线程_启动 (&取是否开门A, , )
.判断循环首 (真)
    房间号 ＝ 无底坑道取房间号 ()
    调试输出 (房间号)
    .判断开始 (房间号 ＞ 0)
        全_怪物表 ＝ “ff0099.bmp”
        全_偏色 ＝ “000000”
        .判断循环首 (真)
            .判断开始 (全_开门)
                拾取物品 ()
                .如果真 (无底坑道过图 (房间号))
                    跳出循环 ()
                .如果真结束

            .默认
                .如果真 (取反 (智能打怪 (“ff0099.bmp”, “000000”, )))
                    .判断开始 (寻怪方向)
                        寻怪方向 ＝ 假
                    .默认
                        寻怪方向 ＝ 真
                    .判断结束
                    无底坑道寻怪 (寻怪方向, “ff0099.bmp”, “000000”)
                .如果真结束

            .判断结束
            .如果真 (无底坑道取房间号 () ＝ 0)
                弹起方向键 ()
                跳出循环 ()
            .如果真结束

        .判断循环尾 ()
    .判断 (房间号 ＝ 0)
        全_开门线程信号 ＝ 假
        全_开门 ＝ 假
        .判断循环首 (真)
            .如果真 (无底坑道取房间号 () ≠ 0)
                弹起方向键 ()
            .如果真结束
            智能打怪 (“00ff10.bmp”, “000000”, 真)
            dm.UseDict (0)
            .如果真 (dm.FindStr (13, 491, 314, 546, “出售”, “b99460-050505”, 1, x, y) ≥ 0)
                调试输出 (“已通关无底坑道”)
                boss聚物 ()
                返回 ()
            .如果真结束
            快速翻牌 ()
        .判断循环尾 ()
    .默认

    .判断结束

.判断循环尾 ()
返回 ()

搬砖

.版本 2

.程序集 搬砖

.子程序 执行搬砖进图选图
.参数 副本名, 文本型

.判断开始 (副本名 ＝ “无底坑道” 或 副本名 ＝ “记忆之地” 或 副本名 ＝ “黑暗神殿” 或 副本名 ＝ “痛苦地下室”)
    到切斯特小镇 ()
.默认

.判断结束


.判断开始 (副本名 ＝ “无底坑道”)
    德洛斯矿山进图 ()
    选择副本 (副本名)
    .判断开始 (角色信息.角色名望 ≥ 11000)
        选择副本难度 (“冒险级”)
    .默认
        选择副本难度 (“普通级”)
    .判断结束

.判断 (副本名 ＝ “记忆之地”)

.判断 (副本名 ＝ “黑暗神殿”)

.判断 (副本名 ＝ “痛苦地下室”)

.默认

.判断结束

移动算法

.版本 2

.程序集 移动算法

.子程序 移动到目标点, 逻辑型, , 速度时间公式移动
.参数 起始x, 整数型
.参数 起始y, 整数型
.参数 目标x, 整数型
.参数 目标y, 整数型
.局部变量 x, 整数型
.局部变量 y, 整数型

.如果真 (起始x ＞ 0 且 起始y ＞ 0 且 目标x ＞ 0 且 目标y ＞ 0)
    角色动作.横向 ＝ 假
    角色动作.纵向 ＝ 假
    取x方向 (起始x, 目标x)
    取y方向 (起始y, 目标y)
    角色动作.跑动延时x ＝ 取绝对值 (起始x － 目标x) ÷ 角色信息.角色速度x
    角色动作.跑动延时y ＝ 取绝对值 (起始y － 目标y) ÷ 角色信息.角色速度y
    线程_启动 (&横向移动, , )
    线程_启动 (&纵向移动, , )
    .判断循环首 (真)
        .如果真 (角色动作.横向 且 角色动作.纵向)
            角色动作.横向 ＝ 假
            角色动作.纵向 ＝ 假
            返回 (真)
        .如果真结束

    .判断循环尾 ()
.如果真结束
返回 (假)

.子程序 纵向移动

.如果真 (角色动作.移动方向y ＝ 38)
    弹起 (40)
.如果真结束
.如果真 (角色动作.移动方向y ＝ 40)
    弹起 (38)
.如果真结束
按键 (角色动作.移动方向y, 角色动作.跑动延时y)
角色动作.纵向 ＝ 真

.子程序 横向移动

.如果真 (角色动作.移动方向x ＝ 37)
    弹起 (39)
.如果真结束
.如果真 (角色动作.移动方向x ＝ 39)
    弹起 (37)
.如果真结束
角色跑动 (角色动作.移动方向x)
辅助延时 (角色动作.跑动延时x, )
' 弹起 (角色动作.移动方向x)
角色动作.横向 ＝ 真

.子程序 角色跑动
.参数 方向, 整数型
.局部变量 x, 整数型
.局部变量 y, 整数型

.判断循环首 (真)
    .如果真 (dm.FindPic (0, 0, 800, 600, “跑动特征.bmp”, “000000”, 1, 0, x, y) ≥ 0)
        返回 ()
    .如果真结束
    按键 (方向, 20)
    辅助延时 (60, )
    按下 (方向)
    辅助延时 (100, )
.判断循环尾 ()

.子程序 取x方向
.参数 起始x, 整数型
.参数 目标x, 整数型

.判断开始 (起始x ＞ 目标x)
    角色动作.移动方向x ＝ 37
.默认
    角色动作.移动方向x ＝ 39
.判断结束


.子程序 取y方向
.参数 起始y, 整数型
.参数 目标y, 整数型

.判断开始 (起始y ＞ 目标y)
    角色动作.移动方向y ＝ 38
.默认
    角色动作.移动方向y ＝ 40
.判断结束

全局变量

.版本 2

.全局变量 dm, 大漠英文版
.全局变量 账号信息, 账号信息
.全局变量 角色信息, 角色信息
.全局变量 背包信息, 背包信息
.全局变量 城镇信息, 城镇信息
.全局变量 副本信息, 副本信息
.全局变量 物品信息, 物品信息
.全局变量 怪物信息, 怪物信息
.全局变量 角色动作, 角色动作
.全局变量 启动, 逻辑型
.全局变量 暂停和恢复, 逻辑型
.全局变量 主线程句柄, 整数型
.全局变量 副线程句柄, 整数型
.全局变量 全_开门, 逻辑型
.全局变量 全_开门线程信号, 逻辑型
.全局变量 全_怪物表, 文本型
.全局变量 全_偏色, 文本型

自定义数据类型

.版本 2

.数据类型 怪物信息
    .成员 怪物坐标x, 整数型
    .成员 怪物坐标y, 整数型

启动窗口

设置窗口

模块和资源

项目结构和资源文件





**

需要的请点赞关注私我

**