|
|
.版本 2
.支持库 eAPI
.支持库 xplib
.支持库 eDB
.程序集 窗口程序集1
.程序集变量 人物生命, 整数型
.程序集变量 内存值, 字节集
.程序集变量 进程id, 整数型
.程序集变量 人物地址, 整数型
.程序集变量 红地址, 整数型
.程序集变量 蓝地址, 整数型
.程序集变量 坐标X, 整数型
.程序集变量 经验地址, 整数型
.程序集变量 句柄, 整数型
.程序集变量 顶层, 逻辑型
.程序集变量 答题地址, 整数型
.程序集变量 题目, 字节集
.程序集变量 关联ID, 整数型
.程序集变量 获取文本, 文本型
.程序集变量 操作句柄, 整数型
.程序集变量 主窗口句柄, 整数型
.程序集变量 进程表, 进程信息, , "0"
.程序集变量 聊天内容, 文本型
.程序集变量 聊天内容组, 文本型, , "0"
.程序集变量 聊天变量, 整数型
.程序集变量 分类现行项, 整数型
.程序集变量 聊天计数, 整数型
.程序集变量 人特内, 文本型
.程序集变量 地图地址, 整数型
.程序集变量 城地址, 整数型
.子程序 __启动窗口_创建完毕
.局部变量 名称, 文本型, , "0"
.局部变量 b, 整数型
.局部变量 总偏移, 文本型
.如果 (_提升进程权限 ())
标签3.标题 ＝ “提升进程成功”
.否则
标签3.标题 ＝ “提升进程失败”
.如果结束
XP风格 (1)
_启动窗口.左边 ＝ 805
_启动窗口.顶边 ＝ 0
.如果 (主连接.连接Access (取运行目录 () ＋ “\zhengtu.mdb”, “&e%§№ ◎▲すぬйω”))
主连接.设置权限 (#读写权限)
主记录集.置连接 (主连接)
.否则
鸣叫 ()
信息框 (“打开数据库失败！”, 0, )
.如果结束
组合框2.加入项目 (“开始搜索游戏.....”, )
' 名称 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\fuzhu.ini”, “人物”, “名称”, “”), “-”, )
.' 计次循环首 (取数组下标 (名称, ), b)
' 组合框2.加入项目 (名称 , )
.' 计次循环尾 ()
.如果 (主记录集.打开 (“配置”, #数据表名) ＝ 真)
.如果真 (主记录集.查找 (“项目='偏量'”, #正向搜索))
主记录集.读文本 (“地址”, 总偏移)
名称 ＝ 分割文本 (总偏移, “-”, )
.如果真 (取数组成员数 (名称) ＝ 4)
生命偏编辑框2.内容 ＝ 名称 [1]
魔法偏编辑框4.内容 ＝ 名称 [2]
坐标偏编辑框5.内容 ＝ 名称 [3]
经验偏编辑框6.内容 ＝ 名称 [4]
.如果真结束
.如果真结束
.如果真 (主记录集.查找 (“项目='人特'”, #正向搜索))
主记录集.读文本 (“地址”, 人特内)
输出调试文本 (人特内)
.如果真结束
主记录集.关闭 ()
.否则
标签3.标题 ＝ “读取偏移量失败”
.如果结束
' 名称 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\fuzhu.ini”, “地址”, “数量”, “”), “-”, )
.' 如果真 (取数组成员数 (名称) ＝ 4)
' 生命偏编辑框2.内容 ＝ 名称 [1]
' 魔法偏编辑框4.内容 ＝ 名称 [2]
' 坐标偏编辑框5.内容 ＝ 名称 [3]
' 经验偏编辑框6.内容 ＝ 名称 [4]
.如果真结束
进程表 ＝ 取系统进程列表 ()
.计次循环首 (取数组成员数 (进程表), b)
进程组合框1.加入项目 (进程表 .进程名称 ＋ “[” ＋ 到文本 (进程表 .进程标识符) ＋ “]”, )
.计次循环尾 ()
' _进程组合框1_列表项被选择 ()
.子程序 读取配置
.局部变量 BZ, 文本型
.局部变量 人配, 文本型, , "0"
.如果真 (主记录集.打开 (“配置”, #数据表名))
.如果真 (主记录集.查找 (“项目='” ＋ 分组框1.标题 ＋ “'”, #正向搜索))
主记录集.读文本 (“地址”, BZ)
人配 ＝ 分割文本 (BZ, “-”, )
.如果真 (取数组成员数 (人配) ＝ 16)
魔法1编辑框.内容 ＝ 人配 [1]
魔法1组合框.现行选中项 ＝ 到数值 (人配 [2])
魔法2编辑框.内容 ＝ 人配 [3]
魔法2组合框.现行选中项 ＝ 到数值 (人配 [4])
魔法3编辑框.内容 ＝ 人配 [5]
魔法3组合框.现行选中项 ＝ 到数值 (人配 [6])
魔法4编辑框.内容 ＝ 人配 [7]
魔法4组合框.现行选中项 ＝ 到数值 (人配 [8])
加血编辑框1.内容 ＝ 人配 [9]
加血组合框.现行选中项 ＝ 到数值 (人配 [10])
加血2编辑框.内容 ＝ 人配 [11]
加血2组合框.现行选中项 ＝ 到数值 (人配 [12])
加蓝编辑框1.内容 ＝ 人配 [13]
加蓝组合框.现行选中项 ＝ 到数值 (人配 [14])
加蓝2编辑框.内容 ＝ 人配 [15]
加蓝2组合框.现行选中项 ＝ 到数值 (人配 [16])
.如果真结束
主记录集.关闭 ()
.如果真结束
.如果真结束
' BZ ＝ 分组框1.标题
' 魔法1编辑框.内容 ＝ 读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “自动1”, )
' 魔法1组合框.现行选中项 ＝ 到数值 (读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “自动-1”, ))
' 魔法2编辑框.内容 ＝ 读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “自动2”, )
' 魔法2组合框.现行选中项 ＝ 到数值 (读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “自动-2”, ))
' 魔法3编辑框.内容 ＝ 读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “自动3”, )
' 魔法3组合框.现行选中项 ＝ 到数值 (读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “自动-3”, ))
' 魔法4编辑框.内容 ＝ 读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “自动4”, )
' 魔法4组合框.现行选中项 ＝ 到数值 (读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “自动-4”, ))
' 加血编辑框1.内容 ＝ 读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “加血”, )
' 加血组合框.现行选中项 ＝ 到数值 (读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “加血-”, ))
' 加血2编辑框.内容 ＝ 读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “加血2”, )
' 加血2组合框.现行选中项 ＝ 到数值 (读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “加血2-”, ))
' 加蓝编辑框1.内容 ＝ 读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “加蓝”, )
' 加蓝组合框.现行选中项 ＝ 到数值 (读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “加蓝-”, ))
' 加蓝2编辑框.内容 ＝ 读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “加蓝2”, )
' 加蓝2组合框.现行选中项 ＝ 到数值 (读配置项 (取运行目录 () ＋ “\fuzhu.ini”, BZ, “加蓝2-”, ))
.子程序 _取进程主窗口
枚举窗口 (&枚举窗口过程, 1)
.子程序 枚举窗口过程, 逻辑型
.参数 窗口句柄, 整数型
.参数 参数, 整数型
.局部变量 进程标识2, 整数型
.局部变量 id, 整数型
获取文本 ＝ 取空白文本 (255)
找标题 (窗口句柄, 13, 256, 获取文本)
id ＝ 查找窗口 (0, 获取文本)
取进程ID (id, 进程标识2)
' 输出调试文本 (到文本 (进程id) ＋ “|” ＋ 到文本 (进程标识2))
.如果 (进程id ＝ 进程标识2)
.如果 (找上级窗口 (窗口句柄) ＝ 0)
主窗口句柄 ＝ 窗口句柄
标签3.标题 ＝ 获取文本
' 输出调试文本 (获取文本 ＋ “||||” ＋ 到文本 (取文本长度 (获取文本)))
' 标签4.标题 ＝ “正在运行进程名:” ＋ 进程组合框.取项目文本 (进程组合框.现行选中项) ＋ #换行符 ＋ 获取文本
' 输出调试文本 (获取文本 ＋ “||” ＋ 到文本 (窗口句柄) ＋ “||” ＋ 到文本 (关联ID) ＋ “|||” ＋ 到文本 (进程标识2))
返回 (假)
.否则
' 输出调试文本 (获取文本 ＋ “||” ＋ 到文本 (窗口句柄) ＋ “||” ＋ 到文本 (关联ID) ＋ “|||” ＋ 到文本 (进程标识2))
返回 (真)
.如果结束
.否则
返回 (真)
.如果结束
.子程序 __启动窗口_尺寸被改变
.局部变量 b, rect
.局部变量 新高, 整数型
.' 如果真 (主窗口句柄 ≠ 0)
' 取窗口坐标 (主窗口句柄, b)
.' 如果 (_启动窗口.高度 ＞ 选择夹1.高度)
' 新高 ＝ _启动窗口.高度
.否则
' 新高 ＝ b.b － b.t
.如果结束
' ' _启动窗口.移动 (0, 0, b.r － b.l ＋ 选择夹1.宽度, 新高)
' 移动主窗口 (主窗口句柄, 0, -22, 取用户区宽度 () － 选择夹1.宽度, -1, 1)
' 选择夹1.移动 (取用户区宽度 () － 选择夹1.宽度, , , )
.如果真结束
.子程序 _进程组合框1_列表项被选择
.局部变量 I, 整数型
.局部变量 b, rect
.局部变量 新高1, 整数型
.局部变量 当选进程, 文本型, , "2"
.如果真 (操作句柄 ≠ 0)
CloseHandle (操作句柄)
.如果真结束
当选进程 ＝ 分割文本 (进程组合框1.取项目文本 (进程组合框1.现行选中项), “[”, )
.计次循环首 (取数组成员数 (进程表), I)
.如果真 (进程表 [I].进程名称 ＝ 当选进程 [1] 且 到文本 (进程表 [I].进程标识符) ＝ 取文本左边 (当选进程 [2], 取文本长度 (当选进程 [2]) － 1))
进程id ＝ 进程表 [I].进程标识符
操作句柄 ＝ OpenProcess (#PROCESS_VM_READ ＋ #PROCESS_QUERY_INFORMATION, 0, 进程id)
.如果真 (操作句柄 ＝ 0)
信息框 (“不能打开进程 .”, #信息图标, “提示”)
返回 ()
.如果真结束
标签7.标题 ＝ 到文本 (进程id)
标签11.标题 ＝ 到文本 (操作句柄)
.如果真结束
.计次循环尾 ()
_取进程主窗口 ()
.' 如果真 (主窗口句柄 ≠ 0)
' 载入外窗口 (主窗口句柄, 取窗口句柄 ()) ' 将新程序置为本程序窗口内
' 取窗口坐标 (主窗口句柄, b)
.' 如果 (b.b － b.t ＞ _启动窗口.高度)
' 新高1 ＝ b.b － b.t ＋ 25
.否则
' 新高1 ＝ _启动窗口.高度 ＋ 25
.如果结束
' _启动窗口.移动 (0, 0, b.r － b.l ＋ 选择夹1.宽度, 新高1)
' 移动主窗口 (主窗口句柄, 0, -22, b.r － b.l, b.b － b.t, 1)
' 选择夹1.移动 (b.r － b.l, , , )
.如果真结束
.子程序 _组合框2_列表项被选择
.如果 (进程组合框1.取项目文本 (进程组合框1.现行选中项) ≠ “”)
标签6.可视 ＝ 真
标签6.标题 ＝ “正在搜索请稍候…………”
标签6.刷新显示 ()
时钟1.时钟周期 ＝ 0
时钟2.时钟周期 ＝ 0
人物生命标签.标题 ＝ “0/0”
人物魔法标签.标题 ＝ “0/0”
人物坐标标签.标题 ＝ “0/0”
人物经验标签.标题 ＝ “0/0”
.如果真 (搜索人物 ())
读取配置 ()
.如果真结束
.否则
信息框 (“游戏没有运行啊！！！！！！！！” ＋ #换行符 ＋ “你的脑子有毛病啊！” ＋ #换行符 ＋ “哈哈哈！！嘿嘿！！”, 0 ＋ 48, “傻了”)
.如果结束
.子程序 搜索人物, 逻辑型
.局部变量 地址, 整数型, , "0"
.局部变量 内存地址, 整数型
.局部变量 读取结果, 整数型
.局部变量 内存块长度, 整数型
.局部变量 开始地址, 整数型
.局部变量 结束地址, 整数型
.局部变量 数据缓冲区, 字节集
.局部变量 QQ号码, 文本型
.局部变量 内存块信息, MEMORY_BASIC_INFORMATION
.局部变量 地址偏移, 整数型
.局部变量 其他地址, 整数型
.局部变量 进程快照, 整数型
.局部变量 进程信息, PROCESSENTRY32
.局部变量 进程ID内, 整数型
.局部变量 首字节, 字节集
.局部变量 长度, 整数型
.局部变量 a, 整数型
.局部变量 关键字, 字节集
.局部变量 进程名, 文本型
.局部变量 红, 整数型
.局部变量 红大, 整数型
.局部变量 蓝, 整数型
.局部变量 蓝大, 整数型
.局部变量 标1, 整数型
.局部变量 标2, 整数型
.局部变量 经, 整数型
.局部变量 经大, 整数型
.局部变量 变字节长度, 文本型, , "0"
清除数组 (地址)
.如果 (人特内 ≠ “”)
变字节长度 ＝ 分割文本 (人特内, “,”, )
关键字 ＝ 取空白字节集 (取数组成员数 (变字节长度))
.计次循环首 (取数组成员数 (变字节长度), a)
关键字 [a] ＝ 到数值 (变字节长度 [a])
.计次循环尾 ()
搜索内存 (进程id, 关键字, 地址)
.如果真 (取数组成员数 (地址) ＞ 0)
人物地址 ＝ 地址 [1] ＋ 8
内存值 ＝ 取空白字节集 (20)
.如果真 (字节集_ReadProcessMemory (操作句柄, 人物地址, 内存值, 20, 0) ＝ 0)
信息框 (“读取内存失败！”, 0, )
标签6.可视 ＝ 假
返回 (假)
.如果真结束
组合框2.加入项目 (到文本 (内存值), )
组合框2.现行选中项 ＝ 1
人物地址标签18.标题 ＝ 到文本 (人物地址)
红地址 ＝ 人物地址 ＋ 到数值 (生命偏编辑框2.内容) ' 60
蓝地址 ＝ 人物地址 ＋ 到数值 (魔法偏编辑框4.内容) ' 2202
坐标X ＝ 人物地址 ＋ 到数值 (坐标偏编辑框5.内容) ' 40
经验地址 ＝ 人物地址 ＋ 到数值 (经验偏编辑框6.内容) ' 2250
地图地址 ＝ 人物地址 ＋ 到数值 (坐标偏编辑框5.内容) ＋ 8
城地址 ＝ 19073012
时钟1.时钟周期 ＝ 300
时钟2.时钟周期 ＝ 1000
标签6.可视 ＝ 假
输出调试文本 (“OK”)
返回 (真)
.如果真结束
.否则
.如果真 (角色名搜索编辑框3.内容 ＝ “”)
标签3.标题 ＝ “请输入角色名,再搜索....”
返回 (假)
.如果真结束
搜索内存 (进程id, 到字节集 (角色名搜索编辑框3.内容), 地址)
.计次循环首 (取数组下标 (地址, ), a)
.如果 (到数值 (人物地址标签18.标题) ＞ 0 且 重查找分组框4.可视 ＝ 真)
人物地址 ＝ 到数值 (人物地址标签18.标题)
.否则
人物地址 ＝ 地址 [a]
.如果结束
内存值 ＝ 取空白字节集 (20)
.如果真 (字节集_ReadProcessMemory (操作句柄, 人物地址, 内存值, 20, 0) ＝ 0)
信息框 (“读取内存失败！”, 0, )
标签6.可视 ＝ 假
返回 (假)
.如果真结束
分组框1.标题 ＝ 到文本 (内存值)
红地址 ＝ 人物地址 ＋ 到数值 (生命偏编辑框2.内容) ' 60
蓝地址 ＝ 人物地址 ＋ 到数值 (魔法偏编辑框4.内容) ' 2202
坐标X ＝ 人物地址 ＋ 到数值 (坐标偏编辑框5.内容) ' 40
经验地址 ＝ 人物地址 ＋ 到数值 (经验偏编辑框6.内容) ' 2250
整数_ReadProcessMemory (操作句柄, 红地址, 红, 4, 0)
整数_ReadProcessMemory (操作句柄, 红地址 ＋ 4, 红大, 4, 0)
.如果真 (红 ≥ 1 且 红大 ＝ 红)
人物地址标签18.标题 ＝ 到文本 (地址 [a])
整数_ReadProcessMemory (操作句柄, 蓝地址, 蓝, 4, 0)
整数_ReadProcessMemory (操作句柄, 蓝地址 ＋ 4, 蓝大, 4, 0)
.如果真 (蓝 ≥ 1 且 蓝大 ＝ 蓝)
人物地址标签18.标题 ＝ 到文本 (地址 [a])
整数_ReadProcessMemory (操作句柄, 坐标X, 标1, 4, 0)
整数_ReadProcessMemory (操作句柄, 坐标X ＋ 4, 标2, 4, 0)
.如果真 (标1 ＞ 0 且 标2 ＞ 0)
人物地址标签18.标题 ＝ 到文本 (地址 [a])
整数_ReadProcessMemory (操作句柄, 经验地址, 经, 4, 0)
整数_ReadProcessMemory (操作句柄, 经验地址 ＋ 8, 经大, 4, 0)
.如果真 (经大 ≥ 10)
人物地址标签18.标题 ＝ 到文本 (地址 [a])
关键字 ＝ 读内存_字节集 (操作句柄, 地址 [a] － 512, 512)
QQ号码 ＝ “”
.计次循环首 (取字节集长度 (关键字), a)
QQ号码 ＝ QQ号码 ＋ “,” ＋ 到文本 (关键字 [a])
.计次循环尾 ()
输出调试文本 (QQ号码)
时钟1.时钟周期 ＝ 300
时钟2.时钟周期 ＝ 1000
跳出循环 ()
.如果真结束
.如果真结束
.如果真结束
.如果真结束
.计次循环尾 ()
.如果结束
标签6.可视 ＝ 假
返回 (真)
.子程序 _时钟1_周期事件
.局部变量 红, 整数型
.局部变量 蓝, 整数型
.局部变量 红大, 整数型
.局部变量 蓝大, 整数型
.局部变量 标1, 整数型
.局部变量 标2, 整数型
.局部变量 经, 整数型
.局部变量 经大, 整数型
.局部变量 地图1, 整数型
.局部变量 地图2, 整数型
.局部变量 国家城, 文本型
.局部变量 国家字, 字节集
国家字 ＝ 取空白字节集 (20)
字节集_ReadProcessMemory (操作句柄, 城地址, 国家字, 20, 0)
整数_ReadProcessMemory (操作句柄, 红地址, 红, 4, 0)
整数_ReadProcessMemory (操作句柄, 红地址 ＋ 4, 红大, 4, 0)
整数_ReadProcessMemory (操作句柄, 蓝地址, 蓝, 4, 0)
整数_ReadProcessMemory (操作句柄, 蓝地址 ＋ 4, 蓝大, 4, 0)
整数_ReadProcessMemory (操作句柄, 坐标X, 标1, 4, 0)
整数_ReadProcessMemory (操作句柄, 坐标X ＋ 4, 标2, 4, 0)
整数_ReadProcessMemory (操作句柄, 经验地址, 经, 4, 0)
整数_ReadProcessMemory (操作句柄, 经验地址 ＋ 8, 经大, 4, 0)
整数_ReadProcessMemory (操作句柄, 地图地址, 地图1, 4, 0)
整数_ReadProcessMemory (操作句柄, 地图地址 ＋ 4, 地图2, 4, 0)
人物生命标签.标题 ＝ 到文本 (红) ＋ “/” ＋ 到文本 (红大)
人物魔法标签.标题 ＝ 到文本 (蓝) ＋ “/” ＋ 到文本 (蓝大)
人物坐标标签.标题 ＝ 到文本 (标1) ＋ “/” ＋ 到文本 (标2)
人物经验标签.标题 ＝ 到文本 (经) ＋ “/” ＋ 到文本 (经大)
.如果真 (到文本 (国家字) ≠ 分组框1.标题)
分组框1.标题 ＝ 到文本 (国家字)
.如果真结束
.如果真 (加血2选择框.选中 ＝ 真 且 红 ＜ 到数值 (加血2编辑框.内容) 且 红 ＞ 1)
发送 (加血2组合框.取项目数值 (加血2组合框.现行选中项))
.如果真结束
.如果真 (加血选择框.选中 ＝ 真 且 红 ＜ 红大 × 0.01 × 到数值 (加血编辑框1.内容) 且 红 ＞ 1)
发送 (加血组合框.取项目数值 (加血组合框.现行选中项))
.如果真结束
.如果真 (加蓝2选择框.选中 ＝ 真 且 蓝 ＜ 到数值 (加蓝2编辑框.内容) 且 红 ＞ 1)
发送 (加蓝2组合框.取项目数值 (加蓝2组合框.现行选中项))
.如果真结束
.如果真 (加蓝选择框.选中 ＝ 真 且 蓝 ＜ 蓝大 × 0.01 × 到数值 (加蓝编辑框1.内容) 且 红 ＞ 1)
发送 (加蓝组合框.取项目数值 (加蓝组合框.现行选中项))
.如果真结束
.如果真 (捡物选择框1.选中 ＝ 真)
按键 (192, 0, 0, 0)
延时 (30)
按键 (192, 0, 2, 0)
.如果真结束
.子程序 _选择框1_被单击
.如果 (选择框1.选中 ＝ 真)
_启动窗口.总在最前 ＝ 真
.否则
_启动窗口.总在最前 ＝ 假
.如果结束
.子程序 _时钟2_周期事件
.局部变量 m1, 整数型, 静态
.局部变量 m2, 整数型, 静态
.局部变量 m3, 整数型, 静态
.局部变量 m4, 整数型, 静态
.如果真 (魔法1选择框.选中 ＝ 真)
m1 ＝ m1 ＋ 1
魔法1标签.标题 ＝ 到文本 (m1)
.如果真 (m1 ≥ 到数值 (魔法1编辑框.内容))
.如果 (下马选择框1.选中 ＝ 真)
发送2 (魔法1组合框.取项目数值 (魔法1组合框.现行选中项))
.否则
发送 (魔法1组合框.取项目数值 (魔法1组合框.现行选中项))
.如果结束
m1 ＝ 0
.如果真结束
.如果真结束
.如果真 (魔法2选择框.选中 ＝ 真)
m2 ＝ m2 ＋ 1
魔法2标签.标题 ＝ 到文本 (m2)
.如果真 (m2 ≥ 到数值 (魔法2编辑框.内容))
.如果 (下马选择框2.选中 ＝ 真)
发送2 (魔法2组合框.取项目数值 (魔法2组合框.现行选中项))
.否则
发送 (魔法2组合框.取项目数值 (魔法2组合框.现行选中项))
.如果结束
m2 ＝ 0
.如果真结束
.如果真结束
.如果真 (魔法3选择框.选中 ＝ 真)
m3 ＝ m3 ＋ 1
魔法3标签.标题 ＝ 到文本 (m3)
.如果真 (m3 ≥ 到数值 (魔法3编辑框.内容))
.如果 (下马选择框3.选中 ＝ 真)
发送2 (魔法3组合框.取项目数值 (魔法3组合框.现行选中项))
.否则
发送 (魔法3组合框.取项目数值 (魔法3组合框.现行选中项))
.如果结束
m3 ＝ 0
.如果真结束
.如果真结束
.如果真 (魔法4选择框.选中 ＝ 真)
m4 ＝ m4 ＋ 1
魔法4标签.标题 ＝ 到文本 (m4)
.如果真 (m4 ≥ 到数值 (魔法4编辑框.内容))
.如果 (下马选择框4.选中 ＝ 真)
发送2 (魔法4组合框.取项目数值 (魔法4组合框.现行选中项))
.否则
发送 (魔法4组合框.取项目数值 (魔法4组合框.现行选中项))
.如果结束
m4 ＝ 0
.如果真结束
.如果真结束
.子程序 _选择框2_被单击
.判断开始 (选择框2.选中 ＝ 真)
' 窗口侧边跟随 (句柄, _启动窗口, 真, , )
时钟3.时钟周期 ＝ 1000
.默认
' 取消侧边跟随 ()
时钟3.时钟周期 ＝ 0
.判断结束
.子程序 _保存按钮_被单击
.局部变量 项值, 文本型
.局部变量 角色名称, 文本型
角色名称 ＝ 分组框1.标题
项值 ＝ 魔法1编辑框.内容 ＋ “-” ＋ 到文本 (魔法1组合框.现行选中项) ＋ “-” ＋ 魔法2编辑框.内容 ＋ “-” ＋ 到文本 (魔法2组合框.现行选中项) ＋ “-” ＋ 魔法3编辑框.内容 ＋ “-” ＋ 到文本 (魔法3组合框.现行选中项) ＋ “-” ＋ 魔法4编辑框.内容 ＋ “-” ＋ 到文本 (魔法4组合框.现行选中项) ＋ “-” ＋ 加血编辑框1.内容 ＋ “-” ＋ 到文本 (加血组合框.现行选中项) ＋ “-” ＋ 加血2编辑框.内容 ＋ “-” ＋ 到文本 (加血2组合框.现行选中项) ＋ “-” ＋ 加蓝编辑框1.内容 ＋ “-” ＋ 到文本 (加蓝组合框.现行选中项) ＋ “-” ＋ 加蓝2编辑框.内容 ＋ “-” ＋ 到文本 (加蓝2组合框.现行选中项)
.如果 (主记录集.打开 (“配置”, #数据表名) ＝ 真)
主记录集.到首记录 ()
.如果 (主记录集.查找 (“项目='” ＋ 角色名称 ＋ “'”, #正向搜索) ＝ 真)
主记录集.写文本 (“地址”, 项值)
.否则
主记录集.添加 ()
主记录集.写文本 (“项目”, 角色名称)
主记录集.写文本 (“地址”, 项值)
.如果结束
主记录集.更新 ()
.否则
标签3.标题 ＝ “打开数据库失败,数据没有保存”
.如果结束
主记录集.关闭 ()
' 输出调试文本 (项值)
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “自动1”, 魔法1编辑框.内容)
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “自动-1”, 到文本 (魔法1组合框.现行选中项))
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “自动2”, 魔法2编辑框.内容)
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “自动-2”, 到文本 (魔法2组合框.现行选中项))
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “自动3”, 魔法3编辑框.内容)
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “自动-3”, 到文本 (魔法3组合框.现行选中项))
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “自动4”, 魔法4编辑框.内容)
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “自动-4”, 到文本 (魔法4组合框.现行选中项))
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “加血”, 加血编辑框1.内容)
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “加血-”, 到文本 (加血组合框.现行选中项))
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “加血2”, 加血2编辑框.内容)
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “加血2-”, 到文本 (加血2组合框.现行选中项))
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “加蓝”, 加蓝编辑框1.内容)
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “加蓝-”, 到文本 (加蓝组合框.现行选中项))
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “加蓝2”, 加蓝2编辑框.内容)
' 写配置项 (取运行目录 () ＋ “\fuzhu.ini”, 组合框2.取项目文本 (组合框2.现行选中项), “加蓝2-”, 到文本 (加蓝2组合框.现行选中项))
.子程序 发送
.参数 消息, 整数型
前台窗口 (主窗口句柄)
' ' 激活窗口 (句柄)
模拟按键 (消息, , )
模拟按键 (消息, , )
' 发送消息_ (主窗口句柄, 256, #T键, 0)
' ' 投送消息_ (主窗口句柄, 257, 取代码 (“AAAAAAAAAAAAAAAAAAAAAAAA”, ), 0)
' 发送消息_ (主窗口句柄, 257, #T键, 0)
' ' 输出调试文本 (消息)
' ' 发送消息_ (主窗口句柄, 258, 消息, 0)
' 按键 ()
' 按键 (#Ctrl键, 0, 0, 0)
' 延时 (200)
' 按键 (#Z键, 0, 0, 0)
' 延时 (200)
' 按键 (#Z键, 0, 2, 0)
' 延时 (200)
' 按键 (#Ctrl键, 0, 2, 0)
.子程序 发送2
.参数 消息, 整数型
前台窗口 (主窗口句柄)
' 模拟按键 (消息, , )
延时 (300)
模拟按键 (#T键, , )
延时 (300)
' 模拟按键 (消息, , )
模拟按键 (消息, , )
延时 (300)
模拟按键 (#T键, , )
.子程序 _保存设置_被选择
_保存按钮_被单击 ()
.子程序 _刷新进程_被选择
.局部变量 参数, 整数型
.局部变量 b, 整数型
进程组合框1.清空 ()
进程表 ＝ 取系统进程列表 ()
.计次循环首 (取数组成员数 (进程表), b)
进程组合框1.加入项目 (进程表 .进程名称 ＋ “[” ＋ 到文本 (进程表 .进程标识符) ＋ “]”, )
.计次循环尾 ()
.子程序 _退出_被选择
销毁 ()
.子程序 _重新定位_被选择
.如果真 (进程id ＝ 0)
信息框 (“请选择要操作的程序”, 0, )
返回 ()
.如果真结束
.如果真 (操作句柄 ＝ 0)
信息框 (“没有找到此进程的窗口”, 0, )
返回 ()
.如果真结束
角色名搜索编辑框3.内容 ＝ 组合框2.取项目文本 (组合框2.现行选中项)
时钟1.时钟周期 ＝ 0
时钟2.时钟周期 ＝ 0
重查找分组框4.可视 ＝ 真
.子程序 _隐藏游戏_被选择
隐藏游戏.选中 ＝ 取反 (隐藏游戏.选中)
.如果 (隐藏游戏.选中 ＝ 真)
.否则
.如果结束
信息框 (“这个功能还没做！！”, 0 ＋ 48, )
.子程序 _关于_被选择
载入 (关于窗口, , 真)
.子程序 _时钟3_周期事件
.局部变量 b, rect
.如果真 (主窗口句柄 ＝ 0)
时钟3.时钟周期 ＝ 0
返回 ()
.如果真结束
.如果真 (取活动窗口 () ＝ 主窗口句柄)
取窗口坐标 (主窗口句柄, b)
_启动窗口.移动 (b.r, b.t, , )
.如果真结束
' 如果 (取活动窗口 () ＝ 句柄)
' 如果真 (顶层 ＝ 假)
' 调整 ()
' 顶层 ＝ 假
' '启动窗口.总在最前 ＝ 假
' 输出调试文本 (到文本 (取活动窗口 ()) ＋ “-” ＋ 到文本 (句柄))
.子程序 调整
_启动窗口.总在最前 ＝ 真
顶层 ＝ 真
' 答题程序集**********************************************************************************************************
.子程序 _初始化按钮_被单击
.局部变量 地址, 整数型, , "0"
.局部变量 AA, 字节集
题目编辑框.内容 ＝ “正在搜索...............”
初始化按钮.禁止 ＝ 真
AA ＝ { 3, 0, 0, 88, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 3, 0, 0, 0, 0, 0, 0, 32, 3, 0, 0, 0, 0, 0, 0, 32, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 2, 0, 0, 32, 3, 0, 0, 0, 0, 0, 0, 32, 3, 0, 0, 88, 2, 0, 0, 0, 0, 0, 0, 88, 2, 0, 0, 0, 0, 0, 0, 88, 2, 0, 0, 0, 0, 0, 0, 88, 2, 0, 0, 32, 3, 0, 0, 88, 2, 0, 0, 32, 3, 0, 0, 88, 2, 0, 0, 32, 3, 0, 0, 88, 2, 0, 0, 81, 0, 0, 0, 37 }
.如果真 (进程id ＝ 0)
题目编辑框.内容 ＝ “你还没有选择游戏”
初始化按钮.禁止 ＝ 假
返回 ()
.如果真结束
搜索内存 (进程id, AA, 地址)
.如果 (取数组成员数 (地址) ＞ 0)
答题地址 ＝ 地址 [1] ＋ 559
标签12.标题 ＝ 到文本 (答题地址)
.否则
题目编辑框.内容 ＝ “自动初始化失败,请在上面的框中输入题目的前几个字,然后点<初始化>按钮”
初始化按钮.禁止 ＝ 假
.如果真 (编辑框1.内容 ＝ “”)
返回 ()
.如果真结束
_找答题地址_被单击 ()
.如果真 (答题地址 ＝ 0)
题目编辑框.内容 ＝ “自动手动初始化失败”
初始化按钮.禁止 ＝ 假
返回 ()
.如果真结束
.如果结束
自动读题选择框.禁止 ＝ 假
自动读题选择框.选中 ＝ 真
_刷新按钮_被单击 ()
初始化按钮.禁止 ＝ 假
加答案按钮1.禁止 ＝ 真
_自动读题选择框_被单击 ()
.子程序 _选择夹1_子夹被改变
.局部变量 I, 整数型
.局部变量 N, 文本型
.如果 (选择夹1.现行子夹 ＝ 2)
选择夹1.禁止 ＝ 真
加答案按钮1.标题 ＝ “加答案”
.如果真 (主记录集.打开 (“题库”, #数据表名) ＝ 假)
信息框 (“打开数据库失败”, 0, )
.如果真结束
选择夹1.禁止 ＝ 假
.否则
主记录集.关闭 ()
答题时钟.时钟周期 ＝ 0
.如果 (选择夹1.现行子夹 ＝ 1)
选择夹1.禁止 ＝ 真
.如果真 (主记录集.打开 (“select distinct 分类 from 聊天 ”, #SQL语句) ＝ 真)
主记录集.到首记录 ()
读选择组合框1.清空 ()
.判断循环首 (主记录集.尾记录后 ＝ 假)
主记录集.读文本 (“分类”, N)
读选择组合框1.加入项目 (N, )
主记录集.到下一条 ()
.判断循环尾 ()
.如果真结束
主记录集.关闭 ()
.如果真 (分类现行项 ≥ 0)
读选择组合框1.现行选中项 ＝ 分类现行项
.如果真结束
.如果真 (主记录集.打开 (“聊天”, #数据表名) ＝ 假)
信息框 (“打开数据库失败”, 0, )
.如果真结束
_读选择组合框1_列表项被选择 ()
选择夹1.禁止 ＝ 假
.否则
主记录集.关闭 ()
.如果结束
.如果结束
.子程序 _读选择组合框1_列表项被选择
.局部变量 查询, 文本型
.局部变量 N, 文本型
聊天内容选择列表框1.清空 ()
查询 ＝ “select 内容 from 聊天 WHERE 分类='” ＋ 读选择组合框1.内容 ＋ “'”
主记录集.打开 (查询, #SQL语句)
主记录集.到首记录 ()
.判断循环首 (主记录集.尾记录后 ＝ 假)
主记录集.读文本 (“内容”, N)
聊天内容选择列表框1.加入项目 (N, )
主记录集.到下一条 ()
.判断循环尾 ()
主记录集.关闭 ()
.子程序 _增加按钮1_被单击
增加按钮1.禁止 ＝ 真
主记录集.打开 (“聊天”, #数据表名)
.如果真 (聊天输入编辑框2.内容 ≠ “”)
主记录集.添加 ()
主记录集.写文本 (“分类”, 读选择组合框1.内容)
主记录集.写文本 (“内容”, 聊天输入编辑框2.内容)
.如果真结束
' 主记录集.更新 ()
主记录集.关闭 ()
分类现行项 ＝ 读选择组合框1.现行选中项
_选择夹1_子夹被改变 ()
增加按钮1.禁止 ＝ 假
.子程序 _删除按钮2_被单击
.局部变量 I, 整数型
删除按钮2.禁止 ＝ 真
主记录集.打开 (“聊天”, #数据表名)
.计次循环首 (聊天内容选择列表框1.取项目数 (), I)
.如果真 (聊天内容选择列表框1.是否被选中 (I － 1) ＝ 真)
.如果真 (主记录集.查找 (“内容 LIKE '%” ＋ 聊天内容选择列表框1.取项目文本 (I － 1) ＋ “%'”, #正向搜索))
主记录集.删除 (1)
.如果真结束
主记录集.更新 ()
.如果真结束
.计次循环尾 ()
主记录集.关闭 ()
_选择夹1_子夹被改变 ()
删除按钮2.禁止 ＝ 假
.子程序 _刷新按钮_被单击
.局部变量 题, 文本型
.局部变量 库题, 文本型
.局部变量 d, 整数型
.局部变量 g, 整数型
答案标签.标题 ＝ “无”
g ＝ 答题地址 ＋ 512
题目 ＝ 取空白字节集 (128)
字节集_ReadProcessMemory (操作句柄, g, 题目, 128, 0)
答案1选择框.标题 ＝ 到文本 (题目)
答案1选择框.选中 ＝ 假
g ＝ g ＋ 128
题目 ＝ 取空白字节集 (128)
字节集_ReadProcessMemory (操作句柄, g, 题目, 128, 0)
答案2选择框.标题 ＝ 到文本 (题目)
答案2选择框.选中 ＝ 假
g ＝ g ＋ 128
题目 ＝ 取空白字节集 (128)
字节集_ReadProcessMemory (操作句柄, g, 题目, 128, 0)
答案3选择框.标题 ＝ 到文本 (题目)
答案3选择框.选中 ＝ 假
g ＝ g ＋ 128
题目 ＝ 取空白字节集 (128)
字节集_ReadProcessMemory (操作句柄, g, 题目, 128, 0)
答案4选择框.标题 ＝ 到文本 (题目)
答案4选择框.选中 ＝ 假
g ＝ g ＋ 128
题目 ＝ 取空白字节集 (128)
字节集_ReadProcessMemory (操作句柄, g, 题目, 128, 0)
答案5选择框.标题 ＝ 到文本 (题目)
答案5选择框.选中 ＝ 假
g ＝ g ＋ 128
题目 ＝ 取空白字节集 (128)
字节集_ReadProcessMemory (操作句柄, g, 题目, 128, 0)
答案6选择框.标题 ＝ 到文本 (题目)
答案6选择框.选中 ＝ 假
题目 ＝ 取空白字节集 (512)
字节集_ReadProcessMemory (操作句柄, 答题地址, 题目, 512, 0)
题 ＝ 到文本 (题目)
编辑框1.内容 ＝ 题
主记录集.到首记录 ()
.如果 (主记录集.查找 (“问题 LIKE '%” ＋ 题 ＋ “%'”, #正向搜索) ＝ 真)
主记录集.读文本 (“问题”, 库题)
题目编辑框.内容 ＝ 库题
查题 ()
.否则
题目编辑框.内容 ＝ “没有搜索到该题！”
.如果真 (编辑框1.内容 ≠ “”)
保存该题 ()
.如果真结束
.如果结束
.子程序 查题
.局部变量 库答案, 文本型
.局部变量 库案, 文本型
.局部变量 是否, 逻辑型
主记录集.读逻辑值 (“案1”, 是否)
.如果真 (是否 ＝ 真)
主记录集.读文本 (“1”, 库答案)
对答案 (库答案)
.如果真结束
主记录集.读逻辑值 (“案2”, 是否)
.如果真 (是否 ＝ 真)
主记录集.读文本 (“2”, 库答案)
对答案 (库答案)
.如果真结束
主记录集.读逻辑值 (“案3”, 是否)
.如果真 (是否 ＝ 真)
主记录集.读文本 (“3”, 库答案)
对答案 (库答案)
.如果真结束
主记录集.读逻辑值 (“案4”, 是否)
.如果真 (是否 ＝ 真)
主记录集.读文本 (“4”, 库答案)
对答案 (库答案)
.如果真结束
主记录集.读逻辑值 (“案5”, 是否)
.如果真 (是否 ＝ 真)
主记录集.读文本 (“5”, 库答案)
对答案 (库答案)
.如果真结束
主记录集.读逻辑值 (“案6”, 是否)
.如果真 (是否 ＝ 真)
主记录集.读文本 (“6”, 库答案)
对答案 (库答案)
.如果真结束
.如果真 (答案 () ＝ 假)
答案标签.标题 ＝ “无”
.如果真结束
.子程序 答案, 逻辑型
.局部变量 变量, 逻辑型
.局部变量 i, 整数型
.局部变量 真数, 整数型
.计次循环首 (6, i)
变量 ＝ 多项选择 (i, 答案1选择框.选中, 答案2选择框.选中, 答案3选择框.选中, 答案4选择框.选中, 答案5选择框.选中, 答案6选择框.选中)
.如果真 (变量)
真数 ＝ 真数 ＋ 1
.如果真结束
.计次循环尾 ()
.如果 (真数 ＝ 1)
返回 (真)
.否则
返回 (假)
.如果结束
.子程序 对答案
.参数 库答, 文本型
.如果真 (寻找文本 (库答, 答案1选择框.标题, , 假) ≠ -1)
答案1选择框.选中 ＝ 真
答案标签.标题 ＝ “A”
返回 ()
.如果真结束
.如果真 (寻找文本 (库答, 答案2选择框.标题, , 假) ≠ -1)
答案2选择框.选中 ＝ 真
答案标签.标题 ＝ “B”
返回 ()
.如果真结束
.如果真 (寻找文本 (库答, 答案3选择框.标题, , 假) ≠ -1)
答案3选择框.选中 ＝ 真
答案标签.标题 ＝ “C”
返回 ()
.如果真结束
.如果真 (寻找文本 (库答, 答案4选择框.标题, , 假) ≠ -1)
答案4选择框.选中 ＝ 真
答案标签.标题 ＝ “D”
返回 ()
.如果真结束
.如果真 (寻找文本 (库答, 答案5选择框.标题, , 假) ≠ -1)
答案5选择框.选中 ＝ 真
答案标签.标题 ＝ “E”
返回 ()
.如果真结束
.如果 (寻找文本 (库答, 答案6选择框.标题, , 假) ≠ -1)
答案6选择框.选中 ＝ 真
答案标签.标题 ＝ “F”
返回 ()
.否则
.如果结束
.子程序 _答案1选择框_被单击
修改题库 ()
.子程序 _答案2选择框_被单击
修改题库 ()
.子程序 _答案3选择框_被单击
修改题库 ()
.子程序 _答案4选择框_被单击
修改题库 ()
.子程序 _答案5选择框_被单击
修改题库 ()
.子程序 _答案6选择框_被单击
修改题库 ()
.子程序 修改题库
.如果真 (主记录集.写逻辑值 (“案1”, 答案1选择框.选中) ＝ 假)
信息框 (“写逻辑失败！”, 0, )
.如果真结束
.如果真 (主记录集.写文本 (“1”, 答案1选择框.标题) ＝ 假)
信息框 (“写文本失败！”, 0, )
.如果真结束
.如果真 (答案2选择框.标题 ≠ “”)
主记录集.写逻辑值 (“案2”, 答案2选择框.选中)
主记录集.写文本 (“2”, 答案2选择框.标题)
.如果真结束
.如果真 (答案3选择框.标题 ≠ “”)
主记录集.写逻辑值 (“案3”, 答案3选择框.选中)
主记录集.写文本 (“3”, 答案3选择框.标题)
.如果真结束
.如果真 (答案4选择框.标题 ≠ “”)
主记录集.写逻辑值 (“案4”, 答案4选择框.选中)
主记录集.写文本 (“4”, 答案4选择框.标题)
.如果真结束
.如果真 (答案5选择框.标题 ≠ “”)
主记录集.写逻辑值 (“案5”, 答案5选择框.选中)
主记录集.写文本 (“5”, 答案5选择框.标题)
.如果真结束
.如果真 (答案6选择框.标题 ≠ “”)
主记录集.写逻辑值 (“案6”, 答案6选择框.选中)
主记录集.写文本 (“6”, 答案6选择框.标题)
.如果真结束
主记录集.更新 ()
.子程序 __启动窗口_将被销毁
主记录集.关闭 ()
主连接.关闭 ()
.如果真 (主窗口句柄 ≠ 0)
载入外窗口 (主窗口句柄, 0)
' 程序关闭,但不关内窗口
.如果真结束
.子程序 保存该题
主记录集.到尾记录 ()
.如果真 (主记录集.添加 () ＝ 假)
信息框 (“添加记录失败！”, 0, )
.如果真结束
主记录集.写文本 (“问题”, 编辑框1.内容)
修改题库 ()
.子程序 _自动读题选择框_被单击
.如果 (自动读题选择框.选中 ＝ 真)
答题时钟.时钟周期 ＝ 400
加答案按钮1.禁止 ＝ 真
.否则
答题时钟.时钟周期 ＝ 0
加答案按钮1.禁止 ＝ 假
.如果结束
.子程序 _加答案按钮1_被单击
.局部变量 I, 整数型
.局部变量 AA, 文本型
答题时钟.时钟周期 ＝ 0
自动读题选择框.禁止 ＝ 真
.如果真 (加答案按钮1.标题 ＝ “加答案”)
.如果真 (主记录集.打开 (“select * from 题库 where ((not 案1) and (not 案2) and (not 案3) and (not 案4) and (not 案5) and (not 案6))”, #SQL语句))
主记录集.到首记录 ()
.如果真 (主记录集.记录数量 ＞ 1)
加答案按钮1.标题 ＝ “下一题”
.如果真结束
.如果真结束
标签12.标题 ＝ 到文本 (主记录集.记录数量)
.如果真结束
.如果真 (加答案按钮1.标题 ＝ “下一题”)
答案1选择框.选中 ＝ 假
答案2选择框.选中 ＝ 假
答案3选择框.选中 ＝ 假
答案4选择框.选中 ＝ 假
答案5选择框.选中 ＝ 假
答案6选择框.选中 ＝ 假
主记录集.到下一条 ()
标签12.标题 ＝ 到文本 (到数值 (标签12.标题) － 1)
.如果真 (主记录集.尾记录后)
加答案按钮1.标题 ＝ “加答案”
标签12.标题 ＝ “题库中的题目已全部做完”
自动读题选择框.禁止 ＝ 假
返回 ()
.如果真结束
.如果真结束
主记录集.读文本 (“问题”, AA)
题目编辑框.内容 ＝ AA
主记录集.读文本 (“1”, AA)
答案1选择框.标题 ＝ AA
主记录集.读文本 (“2”, AA)
答案2选择框.标题 ＝ AA
主记录集.读文本 (“3”, AA)
答案3选择框.标题 ＝ AA
主记录集.读文本 (“4”, AA)
答案4选择框.标题 ＝ AA
主记录集.读文本 (“5”, AA)
答案5选择框.标题 ＝ AA
主记录集.读文本 (“6”, AA)
答案6选择框.标题 ＝ AA
.子程序 _答题时钟_周期事件
题目 ＝ 取空白字节集 (512)
字节集_ReadProcessMemory (操作句柄, 答题地址, 题目, 512, 0)
' 读字节集内存 (进程id, 答题地址, 题目, 512)
编辑框1.内容 ＝ 到文本 (题目)
编辑框1.刷新显示 ()
.如果真 (编辑框1.内容 ≠ 题目编辑框.内容)
_刷新按钮_被单击 ()
.如果真结束
.如果真 (编辑框1.内容 ＝ “” 且 题目编辑框.内容 ＝ “”)
返回 ()
.如果真结束
.如果真 (编辑框1.内容 ＝ “”)
自动读题选择框.选中 ＝ 假
_自动读题选择框_被单击 ()
.如果真结束
.子程序 _找答题地址_被单击
.局部变量 地址, 整数型, , "0"
.局部变量 I, 整数型
.局部变量 内存, 字节集
.局部变量 特征码, 文本型
清除数组 (地址)
.如果真 (搜索内存 (操作句柄, 到字节集 (删首尾空 (编辑框1.内容)), 地址) ＝ 假)
标签12.标题 ＝ “没有找到”
返回 ()
.如果真结束
.计次循环首 (取数组下标 (地址, ), I)
内存 ＝ 取空白字节集 (512)
字节集_ReadProcessMemory (操作句柄, 地址 [I], 内存, 512, 0)
.如果真 (到文本 (内存) ≠ “”)
内存 ＝ 取空白字节集 (128)
字节集_ReadProcessMemory (操作句柄, 地址 [I] ＋ 512, 内存, 128, 0)
.如果真 (到文本 (内存) ≠ “”)
内存 ＝ 取空白字节集 (128)
字节集_ReadProcessMemory (操作句柄, 地址 [I] ＋ 512 ＋ 128, 内存, 128, 0)
.如果真 (到文本 (内存) ≠ “”)
答题地址 ＝ 地址 [I]
标签12.标题 ＝ 到文本 (答题地址)
内存 ＝ 取空白字节集 (512)
字节集_ReadProcessMemory (操作句柄, 地址 [I], 内存, 512, 0)
编辑框1.内容 ＝ 到文本 (内存)
内存 ＝ 取空白字节集 (512)
字节集_ReadProcessMemory (操作句柄, 地址 [I] － 559, 内存, 512, 0)
输出调试文本 (“答题地址减559的内存地址内容” ＋ 到文本 (内存))
特征码 ＝ “”
.计次循环首 (取字节集长度 (内存), I)
特征码 ＝ 特征码 ＋ “,” ＋ 到文本 (内存 [I])
.计次循环尾 ()
输出调试文本 (特征码)
跳出循环 ()
.如果真结束
.如果真结束
.如果真结束
.计次循环尾 ()
.子程序 _搜索按钮1_被单击
.局部变量 地址, 整数型, , "0"
.局部变量 角色名地址组, 整数型, , "0"
.局部变量 生命地址组, 整数型, , "0"
.局部变量 魔法地址组, 整数型, , "0"
.局部变量 坐标地址组, 整数型, , "0"
.局部变量 经验地址组, 整数型, , "0"
.局部变量 I, 整数型
.局部变量 内容, 字节集
.局部变量 数, 整数型
.局部变量 地址2, 整数型, , "0"
.局部变量 数2, 整数型
.局部变量 I2, 整数型
.局部变量 I3, 整数型
.局部变量 I4, 整数型
.局部变量 组合地址, 文本型
.局部变量 I5, 整数型
搜索按钮1.禁止 ＝ 真
搜索结果列表框1.清空 ()
清除数组 (角色名地址组)
清除数组 (生命地址组)
清除数组 (魔法地址组)
清除数组 (坐标地址组)
清除数组 (经验地址组)
.如果真 (角色名搜索编辑框3.内容 ≠ “”)
内容 ＝ 到字节集 (角色名搜索编辑框3.内容)
搜索内存 (进程id, 内容, 角色名地址组)
.如果真 (取数组成员数 (角色名地址组) ≠ 0)
数 ＝ 到数值 (生命搜索编辑框1.内容)
.如果 (数 ＞ 0)
清除数组 (地址)
内容 ＝ 到字节集 (数)
.如果真 (搜索内存 (进程id, 内容, 地址))
.计次循环首 (取数组成员数 (地址) － 1, I)
.如果真 (地址 [I] ＋ 4 ＝ 地址 [I ＋ 1])
加入成员 (生命地址组, 地址 [I])
加入成员 (生命地址组, 地址 [I ＋ 1])
.如果真结束
.计次循环尾 ()
.如果真结束
.否则
.如果结束
数 ＝ 到数值 (魔法搜索编辑框2.内容)
.如果 (数 ＞ 0)
清除数组 (地址)
内容 ＝ 到字节集 (数)
.如果真 (搜索内存 (进程id, 内容, 地址))
.计次循环首 (取数组成员数 (地址) － 1, I)
.如果真 (地址 [I] ＋ 4 ＝ 地址 [I ＋ 1])
加入成员 (魔法地址组, 地址 [I])
加入成员 (魔法地址组, 地址 [I ＋ 1])
' 输出调试文本 (到文本 (地址 [I]) ＋ “|tg魔1”)
.如果真结束
.计次循环尾 ()
.如果真结束
.否则
.如果结束
数 ＝ 到数值 (坐标1搜索编辑框7.内容)
.如果 (数 ＞ 0)
清除数组 (地址)
清除数组 (地址2)
内容 ＝ 到字节集 (数)
.如果真 (搜索内存 (进程id, 内容, 地址))
数2 ＝ 到数值 (坐标2搜索编辑框8.内容)
内容 ＝ 到字节集 (数2)
.如果真 (搜索内存 (进程id, 内容, 地址2))
.计次循环首 (取数组成员数 (地址), I)
.计次循环首 (取数组成员数 (地址2), I2)
.如果真 (地址 [I] ＋ 4 ＝ 地址2 [I2])
加入成员 (坐标地址组, 地址 [I])
' 加入成员 (坐标地址组, 地址2 [I2])
.如果真结束
.计次循环尾 ()
.计次循环尾 ()
.如果真结束
.如果真结束
.否则
.如果结束
数 ＝ 到数值 (经验1搜索编辑框4.内容)
.如果 (数 ＞ 0)
清除数组 (地址)
清除数组 (地址2)
内容 ＝ 到字节集 (数)
.如果真 (搜索内存 (进程id, 内容, 地址))
数2 ＝ 到数值 (经验2搜索编辑框6.内容)
内容 ＝ 到字节集 (数2)
.如果真 (搜索内存 (进程id, 内容, 地址2))
.计次循环首 (取数组成员数 (地址), I)
.计次循环首 (取数组成员数 (地址2), I2)
.如果真 (地址 [I] ＋ 8 ＝ 地址2 [I2])
加入成员 (经验地址组, 地址 [I])
' 加入成员 (经验地址组, 地址2 [I2 ＋ 1])
.如果真结束
.计次循环尾 ()
.计次循环尾 ()
.如果真结束
.如果真结束
.否则
.如果结束
.如果真结束
.计次循环首 (取数组成员数 (角色名地址组), I)
' 输出调试文本 (到文本 (I) ＋ “|1”)
组合地址 ＝ 到文本 (角色名地址组 [I]) ＋ “,”
.如果真 (取数组成员数 (生命地址组) ＝ 0)
搜索结果列表框1.加入项目 (组合地址, )
.如果真结束
.变量循环首 (1, 取数组成员数 (生命地址组), 2, I2)
组合地址 ＝ 到文本 (角色名地址组 [I]) ＋ “,”
.如果真 (生命地址组 [I2] － 角色名地址组 [I] ＜ 3000 且 生命地址组 [I2] － 角色名地址组 [I] ＞ 0)
组合地址 ＝ 组合地址 ＋ 到文本 (生命地址组 [I2]) ＋ “,”
.如果真 (取数组成员数 (魔法地址组) ＝ 0)
搜索结果列表框1.加入项目 (组合地址, )
.如果真结束
.变量循环首 (1, 取数组成员数 (魔法地址组), 2, I3)
组合地址 ＝ 到文本 (角色名地址组 [I]) ＋ “,” ＋ 到文本 (生命地址组 [I2]) ＋ “,”
.如果真 (魔法地址组 [I3] － 角色名地址组 [I] ＜ 3000 且 魔法地址组 [I3] － 角色名地址组 [I] ＞ 0)
组合地址 ＝ 组合地址 ＋ 到文本 (魔法地址组 [I3]) ＋ “,”
.如果真 (取数组成员数 (坐标地址组) ＝ 0)
搜索结果列表框1.加入项目 (组合地址, )
.如果真结束
.变量循环首 (1, 取数组成员数 (坐标地址组), 1, I4)
组合地址 ＝ 到文本 (角色名地址组 [I]) ＋ “,” ＋ 到文本 (生命地址组 [I2]) ＋ “,” ＋ 到文本 (魔法地址组 [I3]) ＋ “,”
.如果真 (坐标地址组 [I4] － 角色名地址组 [I] ＜ 3000 且 坐标地址组 [I4] － 角色名地址组 [I] ＞ 0)
组合地址 ＝ 组合地址 ＋ 到文本 (坐标地址组 [I4]) ＋ “,”
.如果真 (取数组成员数 (经验地址组) ＝ 0)
搜索结果列表框1.加入项目 (组合地址, )
.如果真结束
.变量循环首 (1, 取数组成员数 (经验地址组), 1, I5)
组合地址 ＝ 到文本 (角色名地址组 [I]) ＋ “,” ＋ 到文本 (生命地址组 [I2]) ＋ “,” ＋ 到文本 (魔法地址组 [I3]) ＋ “,” ＋ 到文本 (坐标地址组 [I4]) ＋ “,”
.如果真 (经验地址组 [I5] － 角色名地址组 [I] ＜ 3000 且 经验地址组 [I5] － 角色名地址组 [I] ＞ 0)
组合地址 ＝ 组合地址 ＋ 到文本 (经验地址组 [I5]) ＋ “,”
搜索结果列表框1.加入项目 (组合地址, )
' 输出调试文本 (组合地址)
.如果真结束
.变量循环尾 ()
.如果真结束
.变量循环尾 ()
' 输出调试文本 (组合地址)
.如果真结束
.变量循环尾 ()
.如果真结束
.变量循环尾 ()
.计次循环尾 ()
.如果真结束
搜索按钮1.禁止 ＝ 假
.子程序 _定位返回按钮1_被单击
.局部变量 偏移, 文本型
.如果 (信息框 (“是否保存找到的数据”, #是否钮, “提示信息”) ＝ #是钮)
.如果真 (生命偏编辑框2.内容 ＝ “” 或 魔法偏编辑框4.内容 ＝ “” 或 坐标偏编辑框5.内容 ＝ “” 或 人特内 ＝ “”)
标签3.标题 ＝ “不能保存空数据,请找到数据后再保存”
返回 ()
.如果真结束
.如果 (主记录集.打开 (“配置”, #数据表名))
主记录集.到首记录 ()
偏移 ＝ 生命偏编辑框2.内容 ＋ “-” ＋ 魔法偏编辑框4.内容 ＋ “-” ＋ 坐标偏编辑框5.内容 ＋ “-” ＋ 经验偏编辑框6.内容
.如果 (主记录集.查找 (“项目='偏量'”, #正向搜索) ＝ 真)
主记录集.写文本 (“地址”, 偏移)
' 输出调试文本 (偏移 ＋ “写入”)
.否则
主记录集.添加 ()
主记录集.写文本 (“项目”, “偏量”)
主记录集.写文本 (“地址”, 偏移)
.如果结束
主记录集.更新 ()
主记录集.到首记录 ()
.如果真 (人特内 ≠ “”)
.如果 (主记录集.查找 (“项目='人特'”, #正向搜索) ＝ 真)
主记录集.写文本 (“地址”, 人特内)
.否则
主记录集.添加 ()
主记录集.写文本 (“项目”, “人特”)
主记录集.写文本 (“地址”, 人特内)
.如果结束
主记录集.更新 ()
.如果真结束
重查找分组框4.可视 ＝ 假
主记录集.关闭 ()
返回 ()
.否则
标签3.标题 ＝ “打开数据库失败,数据没有保存成功”
返回 ()
.如果结束
.否则
重查找分组框4.可视 ＝ 假
返回 ()
.如果结束
.子程序 _搜索结果列表框1_列表项被选择
.局部变量 选中的文, 文本型, , "0"
.局部变量 人特字, 字节集
.局部变量 I, 整数型
选中的文 ＝ 分割文本 (搜索结果列表框1.取项目文本 (搜索结果列表框1.现行选中项), “,”, )
人特内 ＝ “”
.如果真 (取数组成员数 (选中的文) ＞ 0)
人物地址标签18.标题 ＝ 选中的文 [1]
.如果真结束
.如果真 (取数组成员数 (选中的文) ＞ 1)
生命偏编辑框2.内容 ＝ 到文本 (到数值 (选中的文 [2]) － 到数值 (选中的文 [1]))
.如果真结束
.如果真 (取数组成员数 (选中的文) ＞ 2)
魔法偏编辑框4.内容 ＝ 到文本 (到数值 (选中的文 [3]) － 到数值 (选中的文 [1]))
.如果真结束
.如果真 (取数组成员数 (选中的文) ＞ 3)
坐标偏编辑框5.内容 ＝ 到文本 (到数值 (选中的文 [4]) － 到数值 (选中的文 [1]))
.如果真结束
.如果真 (取数组成员数 (选中的文) ＞ 4)
经验偏编辑框6.内容 ＝ 到文本 (到数值 (选中的文 [5]) － 到数值 (选中的文 [1]))
.如果真结束
人特字 ＝ 取空白字节集 (8)
.如果真 (字节集_ReadProcessMemory (操作句柄, 到数值 (选中的文 [1]) － 8, 人特字, 8, 0) ≠ 0)
.计次循环首 (取字节集长度 (人特字), I)
.如果 (I ＜ 取字节集长度 (人特字))
人特内 ＝ 人特内 ＋ 到文本 (人特字 [I]) ＋ “,”
.否则
人特内 ＝ 人特内 ＋ 到文本 (人特字 [I])
.如果结束
.计次循环尾 ()
.如果真结束
.子程序 _聊天按钮1_被单击
.局部变量 I, 整数型
.局部变量 AA, 整数型
清除数组 (聊天内容组)
聊天计数 ＝ 1
聊天内容 ＝ “”
.计次循环首 (聊天内容选择列表框1.取项目数 (), I)
.如果真 (聊天内容选择列表框1.是否被选中 (I － 1) ＝ 真)
加入成员 (聊天内容组, 聊天内容选择列表框1.取项目文本 (I － 1))
.如果真结束
.计次循环尾 ()
.如果真 (取数组成员数 (聊天内容组) ＝ 0)
聊天输入编辑框2.内容 ＝ “你还没有选择要说的话,请在要说话的句子前面打勾!!!!!!!!!!!”
返回 ()
.如果真结束
.如果 (聊天私聊选择框3.选中 ＝ 真)
聊天内容 ＝ “/” ＋ 聊天对象组合框1.内容 ＋ 取空白文本 (2)
.否则
.如果真 (聊天加名选择框1.选中 ＝ 真)
聊天内容 ＝ 聊天内容 ＋ “<<” ＋ 聊天对象组合框1.内容 ＋ “>>” ＋ 取空白文本 (2)
.如果真结束
.如果结束
前台窗口 (主窗口句柄)
.如果 (聊天按钮1.标题 ＝ “开始聊天” 且 聊天循环选择框1.选中 ＝ 真)
AA ＝ 聊天方式组合框3.取项目数值 (聊天方式组合框3.现行选中项)
增加按钮1.禁止 ＝ 真
删除按钮2.禁止 ＝ 真
_发送组合键 (#Ctrl键, AA)
.如果 (到数值 (聊天周期编辑框2.内容) ＜ 5)
聊天时钟4.时钟周期 ＝ 5000
.否则
聊天时钟4.时钟周期 ＝ 到数值 (聊天周期编辑框2.内容) × 1000
.如果结束
聊天按钮1.标题 ＝ “结束聊天”
.否则
.如果真 (聊天循环选择框1.选中 ＝ 假)
AA ＝ 聊天方式组合框3.取项目数值 (聊天方式组合框3.现行选中项)
_发送组合键 (#Ctrl键, AA)
_聊天时钟4_周期事件 ()
.如果真结束
聊天时钟4.时钟周期 ＝ 0
聊天按钮1.标题 ＝ “开始聊天”
增加按钮1.禁止 ＝ 假
删除按钮2.禁止 ＝ 假
.如果结束
.子程序 _聊天时钟4_周期事件
聊天时钟4.时钟周期 ＝ 聊天时钟4.时钟周期 ＋ 聊天时钟4.时钟周期 × 0.1
.如果真 (聊天时钟4.时钟周期 ＞ 到数值 (聊天周期编辑框2.内容) × 1500)
聊天时钟4.时钟周期 ＝ 到数值 (聊天周期编辑框2.内容) × 1000
.如果真结束
输出调试文本 (聊天时钟4.时钟周期)
聊天变量 ＝ 聊天变量 ＋ 1
聊天计数 ＝ 聊天计数 ＋ 1
.如果 (聊天变量 ＞ 取数组成员数 (聊天内容组))
聊天变量 ＝ 1
.否则
.如果结束
.如果 (取数组成员数 (聊天内容组) ＝ 1)
置剪辑板文本 (聊天内容 ＋ 聊天内容组 [聊天变量] ＋ 到文本 (聊天计数))
.否则
置剪辑板文本 (聊天内容 ＋ 聊天内容组 [聊天变量])
.如果结束
前台窗口 (主窗口句柄)
按键 (#回车键, 0, 0, 0)
延时 (50)
按键 (#回车键, 0, 2, 0)
延时 (50)
按键 (#Ctrl键, 0, 0, 0)
延时 (50)
按键 (#V键, 0, 0, 0)
延时 (50)
按键 (#V键, 0, 2, 0)
延时 (150)
按键 (#Ctrl键, 0, 2, 0)
延时 (150)
按键 (#回车键, 0, 0, 0)
延时 (50)
按键 (#回车键, 0, 2, 0)
延时 (50)
.子程序 _发送组合键
.参数 键1, 整数型
.参数 键2, 整数型
' 前台窗口 (主窗口句柄)
按键 (键1, 0, 0, 0)
按键 (键2, 0, 0, 0)
延时 (50)
按键 (键2, 0, 2, 0)
按键 (键1, 0, 2, 0)
输出调试文本 (键2)
.子程序 _自动打怪_被选择
前台窗口 (主窗口句柄)
_发送组合键 (#Ctrl键, #Z键)
.子程序 _自动打怪按钮1_被单击
_自动打怪_被选择 ()
.子程序 _按钮1_被单击
.局部变量 gg, 字节集
.局部变量 地址22, 整数型, , "0"
.局部变量 a, 整数型
' gg ＝ { 0, 13, 0, 0, 1, 0, 0, 0, 120, 160, 106, 0 }
gg ＝ { 1, 0, 0, 0, 8, 225, 106, 0 }
搜索内存 (进程id, gg, 地址22)
.计次循环首 (取数组成员数 (地址22), a)
输出调试文本 (地址22 [a])
.计次循环尾 ()
.子程序 _聊天内容选择列表框1_列表项被选择
聊天输入编辑框2.内容 ＝ 聊天内容选择列表框1.取项目文本 (聊天内容选择列表框1.现行选中项)
http://yunpan.cn/QXNXMCXhyYjDC |
|
发表于 2013-9-4 07:23:28