天龙心动

啊冲

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

.程序集 窗口程序集1

.子程序 __启动窗口_创建完毕

进程ID ＝ 进程取ID (“Game.exe”)
窗口句柄 ＝ 取句柄 (“Game.exe”, , )
提升进程权限 ()
.判断开始 (进程ID ＝ -1)
    信息框 (“请打开天龙游戏”, 0, )
.默认

.判断结束

基址 ＝ 读内存整数型 (进程ID, 十六到十 (#基址))

一级基址 ＝ 读内存整数型 (进程ID, 基址 ＋ 十六到十 (“64”))
二级基址 ＝ 读内存整数型 (进程ID, 一级基址 ＋ 十六到十 (“154”))
技能基址 ＝ 读内存整数型 (进程ID, 一级基址 ＋ 十六到十 (“160”))
人物偏移 ＝ 读内存整数型 (进程ID, 二级基址 ＋ 十六到十 (“04”))

宝宝基址 ＝ 读内存整数型 (进程ID, 十六到十 (#宠物基址))
宝宝基址 ＝ 读内存整数型 (进程ID, 宝宝基址 ＋ 十六到十 (“45E34”))

当前宝宝基址 ＝ 读内存整数 (进程ID, 十六到十 (#当前宠物基址))
防挂窗口 ＝ 读内存整数 (进程ID, 十六到十 (#防挂窗口基址))
防挂窗口 ＝ 读内存整数 (进程ID, 防挂窗口 ＋ 0)
防挂窗口 ＝ 读内存整数 (进程ID, 防挂窗口 ＋ 十六到十 (“C”))




' 人物目标ID=读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“5c”))



.子程序 _人物时钟_周期事件
.局部变量 宝宝循环, 整数型
.局部变量 宝宝ID, 整数型
.局部变量 宝宝等级, 整数型
.局部变量 宝宝经验, 整数型
.局部变量 宝宝总血, 整数型
.局部变量 宝宝快乐, 整数型

人物当前血 ＝ 读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“6d4”))
人物最大血 ＝ 读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“73c”))
人物当前蓝 ＝ 读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“6d8”))
人物最大蓝 ＝ 读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“740”))
人物名称 ＝ 读内存文本型 (进程ID, 人物偏移 ＋ 十六到十 (“30”))
人物ID ＝ 读内存整数 (进程ID, 一级基址 ＋ 十六到十 (“34”))
人物X坐标 ＝ 到整数 (读内存小数 (进程ID, 一级基址 ＋ 十六到十 (“44”)))
人物Y坐标 ＝ 到整数 (读内存小数 (进程ID, 一级基址 ＋ 十六到十 (“4c”)))
人物Z坐标 ＝ 到整数 (读内存小数 (进程ID, 一级基址 ＋ 十六到十 (“48”)))
人物等级 ＝ 读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“5c”))

当前宝宝 ＝ 读内存整数 (进程ID, 当前宝宝基址 ＋ 十六到十 (“5c”))

宝宝循环 ＝ 宝宝基址 ＋ 当前宝宝 × 十六到十 (“F0”)

宝宝ID ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“c”))
宝宝名称 ＝ 读内存文本 (进程ID, 宝宝循环 ＋ 十六到十 (“1c”), 10)

宝宝等级 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“34”))
宝宝经验 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“38”))
宝宝血 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“3c”))

宝宝总血 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“40”))
宝宝快乐 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“4c”))

人物名.标题 ＝ “人物名:” ＋ 人物名称
当前经验.标题 ＝ “当前经验:” ＋ 到文本 (读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“6dc”)))
当前血.标题 ＝ “当前血量:” ＋ 到文本 (人物当前血) ＋ “/” ＋ 到文本 (人物最大血)
当前蓝.标题 ＝ “当前蓝量:” ＋ 到文本 (人物当前蓝) ＋ “/” ＋ 到文本 (人物最大蓝)
外攻.标题 ＝ “当前外攻:” ＋ 到文本 (读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“72c”)))
内攻.标题 ＝ “当前内攻:” ＋ 到文本 (读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“730”)))
外防.标题 ＝ “当前外防:” ＋ 到文本 (读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“734”)))
内防.标题 ＝ “当前内防:” ＋ 到文本 (读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“738”)))
命中.标题 ＝ “当前命中:” ＋ 到文本 (读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“74c”)))
闪避.标题 ＝ “当前闪避:” ＋ 到文本 (读内存整数型 (进程ID, 人物偏移 ＋ 十六到十 (“750”)))
等级.标题 ＝ “当前等级:” ＋ 到文本 (人物等级) ＋ “级”
坐标.标题 ＝ “当前坐标:” ＋ 到文本 (人物X坐标) ＋ “/” ＋ 到文本 (人物Y坐标) ＋ “/” ＋ 到文本 (人物Z坐标)
人ID.标题 ＝ “人物ID:” ＋ 到文本 (人物ID)


宝宝名称标签.标题 ＝ “宝宝名称:” ＋ 宝宝名称
宝宝等级标签.标题 ＝ “宝宝等级:” ＋ 到文本 (宝宝等级)
宝宝血量标签.标题 ＝ “宝宝血量:” ＋ 到文本 (宝宝血) ＋ “/” ＋ 到文本 (宝宝总血)
宝宝快乐标签.标题 ＝ “宝宝快乐:” ＋ 到文本 (宝宝快乐)
宝宝ID标签.标题 ＝ “宝宝ID:” ＋ 到文本 (宝宝ID)
宝宝经验标签.标题 ＝ “宝宝经验:” ＋ 到文本 (宝宝经验)
.如果真 (加血选择框.选中 ＝ 真)
    .如果真 (人物当前血 ＜ 到整数 (加血编辑框.内容))
        ' 按键 ()
        按键消息 (窗口句柄, 加血组合框.取项目数值 (加血组合框.现行选中项), )
    .如果真结束

    .如果真 (人物当前蓝 ＜ 到整数 (加蓝编辑框.内容))
        按键消息 (窗口句柄, 加蓝组合框.取项目数值 (加蓝组合框.现行选中项))

    .如果真结束

    .如果真 (宝宝血 ＜ 到整数 (宝宝加血编辑框.内容))
        按键消息 (窗口句柄, 宝宝加血组合框.取项目数值 (宝宝加血组合框.现行选中项))
    .如果真结束

.如果真结束


防挂窗口 ＝ 读内存整数 (进程ID, 防挂窗口 ＋ 十六到十 (“64”))
.如果真 (防挂窗口 ＝ 1)
    播放MP3 (1, “warn.mp3”)

.如果真结束


.子程序 _捡物时钟_周期事件

地面包 ()

.子程序 遍历怪物
.局部变量 总数, 整数型
.局部变量 计次, 整数型
.局部变量 怪物名字, 文本型
.局部变量 怪物基址, 整数型
.局部变量 怪物x, 整数型
.局部变量 怪物y, 整数型
.局部变量 坐标, 文本型
.局部变量 索引, 整数型
.局部变量 怪物id
.局部变量 怪物类型
.局部变量 距离X, 整数型
.局部变量 距离Y, 整数型
.局部变量 距离, 文本型
.局部变量 找到, 整数型

' ---------------------------------------------------------
怪物基址 ＝ 读内存整数 (进程ID, 十六到十 (#怪物基址))
总数 ＝ 读内存整数 (进程ID, 怪物基址 ＋ 十六到十 (“407C”))
超级列表框1.全部删除 ()
.变量循环首 (0, 总数, 1, 计次)
    怪物名字 ＝ 读内存文本 (进程ID, 怪物基址 ＋ 十六到十 (“7C”) ＋ 计次 × 十六到十 (“40”) ＋ 十六到十 (“14”), 16)
    怪物x ＝ 读内存小数 (进程ID, 怪物基址 ＋ 十六到十 (“7C”) ＋ 计次 × 十六到十 (“40”) ＋ 十六到十 (“0”))
    怪物y ＝ 读内存小数 (进程ID, 怪物基址 ＋ 十六到十 (“7C”) ＋ 计次 × 十六到十 (“40”) ＋ 十六到十 (“8”))
    怪物id ＝ 读内存整数 (进程ID, 怪物基址 ＋ 十六到十 (“7C”) ＋ 计次 × 十六到十 (“40”) ＋ 十六到十 (“2c”))
    怪物类型 ＝ 读内存整数 (进程ID, 怪物基址 ＋ 十六到十 (“7C”) ＋ 计次 × 十六到十 (“40”) ＋ 十六到十 (“30”))
    坐标 ＝ 到文本 (怪物x) ＋ “：” ＋ 到文本 (怪物y)
    距离X ＝ 人物X坐标 － 怪物x
    距离Y ＝ 人物Y坐标 － 怪物y
    距离 ＝ 到文本 (到整数 (求平方根 (距离X × 距离X ＋ 距离Y × 距离Y)))
    .如果真 (到整数 (距离) ＜ 10)
        距离 ＝ “0” ＋ 距离
    .如果真结束

    .如果真 (怪物类型 ＝ 0 且 怪物名字 ≠ 宝宝名称)
        .如果真 (怪物id ＝ 上次怪ID 且 上次怪ID ≠ 0)
            找到 ＝ 1
        .如果真结束
        索引 ＝ 超级列表框1.插入表项 (, , , , , )
        超级列表框1.置标题 (索引, 0, 到文本 (怪物id))
        超级列表框1.置标题 (索引, 1, 坐标)
        超级列表框1.置标题 (索引, 2, 怪物名字)
        超级列表框1.置标题 (索引, 3, 到文本 (怪物类型))
        超级列表框1.置标题 (索引, 4, 距离)

    .如果真结束

.变量循环尾 ()
.如果真 (超级列表框1.取表项数 () ＞ 0)
    超级列表框排序 (超级列表框1, 4, , , )
    输出调试文本 (上次怪ID)
.如果真结束

.如果 (找到 ＝ 1 且 上次怪ID ≠ 0)
    技能攻击 (上次怪ID, 技能1组合框.取项目数值 (技能1组合框.现行选中项))
.否则

    技能攻击 (到数值 (超级列表框1.取标题 (0, 0)), 技能1组合框.取项目数值 (技能1组合框.现行选中项))
    上次怪ID ＝ 到数值 (超级列表框1.取标题 (0, 0))
.如果结束


.子程序 排除怪物
.局部变量 总数, 整数型
.局部变量 计次, 整数型
.局部变量 怪物基址, 整数型
.局部变量 怪物id
.局部变量 怪物类型
.局部变量 找到, 整数型

' ---------------------------------------------------------
怪物基址 ＝ 读内存整数 (进程ID, 十六到十 (#怪物基址))
总数 ＝ 读内存整数 (进程ID, 怪物基址 ＋ 十六到十 (“407C”))
清除数组 (数组怪ID)
.变量循环首 (0, 总数, 1, 计次)
    怪物id ＝ 读内存整数 (进程ID, 怪物基址 ＋ 十六到十 (“7C”) ＋ 计次 × 十六到十 (“40”) ＋ 十六到十 (“2c”))
    怪物类型 ＝ 读内存整数 (进程ID, 怪物基址 ＋ 十六到十 (“7C”) ＋ 计次 × 十六到十 (“40”) ＋ 十六到十 (“30”))
    .如果真 (怪物类型 ≠ 5 且 怪物类型 ≠ 9)
        加入成员 (数组怪ID, 怪物id)
    .如果真结束

.变量循环尾 ()

.子程序 地面包
.局部变量 地面一级基址, 整数型
.局部变量 地面二级基址, 整数型

地面一级基址 ＝ 读内存整数型 (进程ID, 基址 ＋ 十六到十 (“54”) ＋ 4)
地面二级基址 ＝ 读内存整数型 (进程ID, 地面一级基址 ＋ 十六到十 (“4”))
' 输出调试文本 (地面二级基址)
' 清除数组 (数组包ID)
' 超级列表框2.全部删除 ()
遍历地面 (地面二级基址)

.子程序 遍历地面
.参数 地面基址, 整数型
.局部变量 地面标志, 字节型
.局部变量 物品ID, 整数型
.局部变量 左子树, 整数型
.局部变量 右子树, 整数型
.局部变量 索引, 整数型
.局部变量 计次, 整数型
.局部变量 是否找到, 整数型
.局部变量 物品类别, 整数型
.局部变量 物品类别2, 整数型
.局部变量 包X, 整数型
.局部变量 包Z, 整数型
.局部变量 包Y, 整数型

地面标志 ＝ 到字节 (读内存整数型 (进程ID, 地面基址 ＋ 十六到十 (“15”)))
.如果真 (地面标志 ＝ 0)
    物品ID ＝ 读内存整数型 (进程ID, 地面基址 ＋ 十六到十 (“C”))
    物品类别 ＝ 读内存整数 (进程ID, 地面基址 ＋ 十六到十 (“10”))
    物品类别2 ＝ 读内存整数 (进程ID, 物品类别)  ' 包6274080  怪6205168  宝箱6277552 人6282048 宠6205168
    左子树 ＝ 读内存整数型 (进程ID, 地面基址 ＋ 十六到十 (“0”))
    右子树 ＝ 读内存整数型 (进程ID, 地面基址 ＋ 十六到十 (“8”))
    ' 输出调试文本 (物品ID)
    .如果 (物品类别 ＝ 6274080 或 物品类别 ＝ 6277552)
        包X ＝ 到整数 (读内存小数 (进程ID, 物品类别 ＋ 十六到十 (“44”)))
        包Z ＝ 到整数 (读内存小数 (进程ID, 物品类别 ＋ 十六到十 (“48”)))
        包Y ＝ 到整数 (读内存小数 (进程ID, 物品类别 ＋ 十六到十 (“4C”)))
    .否则

        包X ＝ 到整数 (读内存小数 (进程ID, 物品类别 ＋ 十六到十 (“5C”)))
        包Z ＝ 到整数 (读内存小数 (进程ID, 物品类别 ＋ 十六到十 (“60”)))
        包Y ＝ 到整数 (读内存小数 (进程ID, 物品类别 ＋ 十六到十 (“64”)))
    .如果结束


    .如果真 (物品类别2 ＝ 6274080)  ' 6277552
        打开包 (物品ID)
        延迟 (100)
        全捡 ()
        ' 加入成员 (数组包ID, 物品ID)
        ' 索引 ＝ 超级列表框2.插入表项 (, , , , , )
        ' 超级列表框2.置标题 (索引, 0, 到文本 (物品ID))
        ' 超级列表框2.置标题 (索引, 1, 到文本 (物品类别2))
        ' 超级列表框2.置标题 (索引, 2, 到文本 (包X) ＋ “\” ＋ 到文本 (包Y) ＋ “\” ＋ 到文本 (包Z))
    .如果真结束
    遍历地面 (左子树)
    遍历地面 (右子树)
.如果真结束


.子程序 地面包排序
.局部变量 计次

.如果 (取数组成员数 (数组包ID) ＞ 0)
    时钟挂机.时钟周期 ＝ 0
    ' 打开包 (数组包ID [1])
    立刻开包 (数组包ID [1])
    全捡 ()
.否则

    时钟挂机.时钟周期 ＝ 500
.如果结束



.子程序 _停止挂机_被单击

' 遍历怪物 ()
走路CALL (70, 51)

时钟挂机.时钟周期 ＝ 0
捡物时钟.时钟周期 ＝ 0
技能时钟2.时钟周期 ＝ 0
技能时钟3.时钟周期 ＝ 0
状态技能时钟.时钟周期 ＝ 0


.子程序 包是否打开
.局部变量 目标包ID, 整数型
.局部变量 窗体基址, 整数型
.局部变量 窗体一级基址, 整数型
.局部变量 窗体二级基址, 整数型
.局部变量 怪物窗体, 整数型

窗体基址 ＝ 读内存整数 (进程ID, 十六到十 (#窗体基址))
窗体一级基址 ＝ 读内存整数 (进程ID, 窗体基址 ＋ 十六到十 (“3c”) ＋ 4)
窗体二级基址 ＝ 读内存整数 (进程ID, 窗体一级基址 ＋ 4)
怪物窗体 ＝ 读内存整数 (进程ID, 窗体二级基址)
怪物窗体 ＝ 读内存整数 (进程ID, 怪物窗体 ＋ 8)
怪物窗体 ＝ 读内存整数 (进程ID, 怪物窗体 ＋ 十六到十 (“10”))
怪物窗体 ＝ 读内存整数 (进程ID, 怪物窗体 ＋ 十六到十 (“10”))
是否打开 ＝ 读内存整数 (进程ID, 怪物窗体)
是否打开 ＝ 读内存整数 (进程ID, 是否打开 ＋ 十六到十 (“C”))
是否打开 ＝ 读内存整数 (进程ID, 是否打开 ＋ 十六到十 (“64”))

正在打开 ＝ 读内存整数 (进程ID, 一级基址 ＋ 十六到十 (“274”))
' 目标包ID ＝ 读内存整数 (进程ID, 技能基址 ＋ 十六到十 (“B4”))
输出调试文本 (是否打开)




.子程序 是否右键先中
.局部变量 窗体基址, 整数型
.局部变量 窗体一级基址, 整数型
.局部变量 窗体二级基址, 整数型
.局部变量 怪物窗体, 整数型
.局部变量 是否选中, 整数型

窗体基址 ＝ 读内存整数 (进程ID, 十六到十 (#窗体基址))
窗体一级基址 ＝ 读内存整数 (进程ID, 窗体基址 ＋ 十六到十 (“3c”) ＋ 4)
窗体二级基址 ＝ 读内存整数 (进程ID, 窗体一级基址 ＋ 4)
怪物窗体 ＝ 读内存整数 (进程ID, 窗体二级基址)
怪物窗体 ＝ 读内存整数 (进程ID, 怪物窗体)
怪物窗体 ＝ 读内存整数 (进程ID, 怪物窗体)
怪物窗体 ＝ 读内存整数 (进程ID, 怪物窗体)
怪物窗体 ＝ 读内存整数 (进程ID, 怪物窗体 ＋ 8)
怪物窗体 ＝ 读内存整数 (进程ID, 怪物窗体 ＋ 十六到十 (“10”))
怪物窗体 ＝ 读内存整数 (进程ID, 怪物窗体 ＋ 十六到十 (“10”))
是否选中 ＝ 读内存整数 (进程ID, 怪物窗体)
是否选中 ＝ 读内存整数 (进程ID, 是否选中 ＋ 十六到十 (“C”))
是否选中 ＝ 读内存整数 (进程ID, 是否选中 ＋ 十六到十 (“64”))
输出调试文本 (是否选中)


.子程序 打怪线程

遍历怪物 ()

.子程序 _选择框捡物_被单击

.如果 (选择框捡物.选中 ＝ 真)
    捡物时钟.时钟周期 ＝ 500
.否则

    捡物时钟.时钟周期 ＝ 0
.如果结束



.子程序 _挂机选择框_被单击

.如果 (挂机选择框.选中 ＝ 真)
    时钟挂机.时钟周期 ＝ 1000
.否则

    时钟挂机.时钟周期 ＝ 0
.如果结束



.子程序 _时钟挂机_周期事件

遍历怪物 ()


.子程序 _按钮宠物_被单击
.局部变量 宝宝血, 整数型
.局部变量 计次
.局部变量 宝宝ID, 整数型
.局部变量 宝宝名称, 文本型
.局部变量 宝宝等级, 整数型
.局部变量 宝宝总血, 整数型
.局部变量 宝宝快乐, 整数型
.局部变量 索引
.局部变量 宝宝循环, 整数型
.局部变量 宝宝经验, 整数型
.局部变量 宝宝寿命, 整数型
.局部变量 宝宝内攻, 整数型
.局部变量 宝宝外攻, 整数型

超级列表框宠物.全部删除 ()
.变量循环首 (0, 8, 1, 计次)
    宝宝循环 ＝ 宝宝基址 ＋ 计次 × 十六到十 (“F0”)
    宝宝ID ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“c”))
    宝宝名称 ＝ 读内存文本 (进程ID, 宝宝循环 ＋ 十六到十 (“1c”), 10)
    宝宝等级 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“34”))
    宝宝经验 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“38”))
    宝宝血 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“3c”))
    宝宝总血 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“40”))
    宝宝寿命 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“44”))
    宝宝快乐 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“4c”))
    宝宝内攻 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“60”))
    宝宝外攻 ＝ 读内存整数 (进程ID, 宝宝循环 ＋ 十六到十 (“64”))
    .如果 (宝宝名称 ≠ “”)
        索引 ＝ 超级列表框宠物.插入表项 (, , , , , )
        超级列表框宠物.置标题 (索引, 0, 宝宝名称)
        超级列表框宠物.置标题 (索引, 1, 到文本 (宝宝ID))
        超级列表框宠物.置标题 (索引, 2, 到文本 (宝宝血) ＋ “/” ＋ 到文本 (宝宝总血))
        超级列表框宠物.置标题 (索引, 3, 到文本 (宝宝快乐))
        超级列表框宠物.置标题 (索引, 4, 到文本 (宝宝经验))
        超级列表框宠物.置标题 (索引, 5, 到文本 (宝宝寿命))
        超级列表框宠物.置标题 (索引, 6, 到文本 (宝宝内攻))
        超级列表框宠物.置标题 (索引, 7, 到文本 (宝宝外攻))
    .否则
        跳出循环 ()
    .如果结束

.变量循环尾 ()


.子程序 _走路测试_被单击

走路CALL (到整数 (编辑框X.内容), 到整数 (编辑框Y.内容))


.子程序 _技能2选择框_被单击

.如果真 (技能2选择框.选中 ＝ 真)
    技能时钟2.时钟周期 ＝ 到整数 (技能2编辑框.内容) × 1000
.如果真结束


.子程序 _技能3选择框_被单击

.如果真 (技能3选择框.选中 ＝ 真)
    技能时钟3.时钟周期 ＝ 到整数 (技能3编辑框.内容) × 1000
.如果真结束


.子程序 _状态技能选择框_被单击

.如果真 (状态技能选择框.选中 ＝ 真)
    状态技能时钟.时钟周期 ＝ 到整数 (状态技能编辑框.内容) × 1000
.如果真结束


.子程序 _技能时钟2_周期事件

.如果真 (上次怪ID ≠ 0)
    技能攻击 (上次怪ID, 技能2组合框.取项目数值 (技能2组合框.现行选中项))
.如果真结束



.子程序 _技能时钟3_周期事件

.如果真 (上次怪ID ≠ 0)
    技能攻击 (上次怪ID, 技能3组合框.取项目数值 (技能3组合框.现行选中项))
.如果真结束


.子程序 _技能时钟4_周期事件

.如果真 (上次怪ID ≠ 0)
    技能攻击 (上次怪ID, 技能4组合框.取项目数值 (技能4组合框.现行选中项))
.如果真结束


.子程序 _状态技能时钟_周期事件

技能攻击 (人物ID, 状态技能组合框.取项目数值 (状态技能组合框.现行选中项))


.子程序 _测试_被单击



遍历怪物 ()


.子程序 _技能4选择框_被单击


.如果真 (技能4选择框.选中 ＝ 真)
    技能时钟4.时钟周期 ＝ 到整数 (技能4编辑框.内容) × 1000
.如果真结束

http://yunpan.cn/QX2LRcbqA2RwA