|
一个纯内存操作的脚本,实现挂机区域打怪,自动补给买药,过滤打怪,过滤捡物,HP,MP保护。供大家学习。
源码如下:
#import "dm.dmsoft" DM
空间 测试
逻辑型 a,b
整型 线程句柄,线程句柄1
功能 逻辑型 按钮0_点击()
整型 进程句柄,hwnd,基址,一级偏移,二级偏移,数组开始,物品数量,物品最大数组,物品首地址,物品基址,f,物品基址1,物品名,ID,ID2
字符型 物品,距离,坐标,坐标x,坐标y
浮点型 物品距离x,物品距离y,物品x坐标,物品y坐标
进程句柄=进程.获取进程句柄("Element Client")
hwnd=window.findwindow("Element Client")
列表框.清空("列表框0")
列表框.清空("列表框1")
列表框.清空("列表框2")
基址=进程.读4byte(进程句柄,#b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#0c)
数组开始=进程.读4byte(进程句柄,二级偏移+#24)
物品数量=进程.读4byte(进程句柄,数组开始+#14)
物品最大数组=进程.读4byte(进程句柄,数组开始+#24)
物品首地址=进程.读4byte(进程句柄,数组开始+#18)
f=0
循环(f<物品最大数组)
物品基址=进程.读4byte(进程句柄,物品首地址+f*4)
如果(物品基址>0)
物品基址1=进程.读4byte(进程句柄,物品基址+#4)
物品名=进程.读4byte(进程句柄,物品基址1+#168)
物品=进程.读stringunicode(进程句柄,物品名,10)
列表框.增加文本("列表框0",物品)
物品距离x=进程.读float(进程句柄,物品基址1+#158)
物品距离y=进程.读float(进程句柄,物品基址1+#15c)
距离=字符串.截取(转换.浮点型转字符型(物品距离x),0,字符串.查找字符(转换.浮点型转字符型(物品距离x),46))
列表框.增加文本("列表框2",距离)
物品x坐标=进程.读float(进程句柄,物品基址1+#3c)
物品y坐标=进程.读float(进程句柄,物品基址1+#44)
坐标x=字符串.截取(转换.浮点型转字符型(物品x坐标),0,字符串.查找字符(转换.浮点型转字符型(物品x坐标),46))
坐标y=字符串.截取(转换.浮点型转字符型(物品y坐标),0,字符串.查找字符(转换.浮点型转字符型(物品y坐标),46))
坐标=字符串.连接(字符串.连接(坐标x,","),坐标y)
列表框.增加文本("列表框1",坐标)
f=f+1
否则
f=f+1
如果结束
循环结束
返回 真
功能结束
功能 逻辑型 按钮1_点击()
整型 基址,一级偏移,二级偏移,三级偏移,物品数组,物品名,物品数量,进程句柄,物品基址,物品基址1,背包格
字符型 物品名字
进程句柄=进程.获取进程句柄("Element Client")
列表框.清空("列表框3")
列表框.清空("列表框4")
基址=进程.读4byte(进程句柄,#00b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#28)
三级偏移=进程.读4byte(进程句柄,二级偏移+#0b14)
物品基址1=进程.读4byte(进程句柄,三级偏移+#0c)
背包格=进程.读4byte(进程句柄,三级偏移+#10)
物品数组=0
循环(物品数组<背包格)
物品基址=进程.读4byte(进程句柄,物品基址1+物品数组*4)
物品名=进程.读4byte(进程句柄,物品基址+#74)
物品名字=进程.读stringunicode(进程句柄,物品名+#0c,20)
如果(字符串.长度(物品名字)==0)
物品名=进程.读4byte(进程句柄,物品基址+#6c)
物品名字=进程.读stringunicode(进程句柄,物品名+#4,20)
如果结束
列表框.增加文本("列表框3",物品名字)
物品数量=进程.读4byte(进程句柄,物品基址+#1c)
列表框.增加文本("列表框4",转换.整型转字符型(物品数量))
物品数组=物品数组+1
循环结束
返回 真
功能结束
功能 逻辑型 按钮2_点击()
整型 进程句柄,基址,一级偏移,二级偏移,三级偏移,怪物首地址,怪物最大数组,数组,怪物基址,血偏移,等级,种类,最大血,魔法,最大魔法,怪物名,怪物基址1
字符型 怪物名字,x,y,距离1
浮点型 x坐标,y坐标,距离
列表框.清空("列表框5")
列表框.清空("列表框6")
列表框.清空("列表框7")
列表框.清空("列表框8")
列表框.清空("列表框9")
列表框.清空("列表框10")
进程句柄=进程.获取进程句柄("Element Client")
基址=进程.读4byte(进程句柄,#00b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#0c)
三级偏移=进程.读4byte(进程句柄,二级偏移+#20)
怪物首地址=进程.读4byte(进程句柄,三级偏移+#18)
怪物最大数组=进程.读4byte(进程句柄,三级偏移+#24)
数组=0
循环(数组<怪物最大数组)
怪物基址=进程.读4byte(进程句柄,怪物首地址+数组*4)
如果(怪物基址>0)
怪物基址1=进程.读4byte(进程句柄,怪物基址+#4)
血偏移=进程.读4byte(进程句柄,怪物基址1+#138)
最大血=进程.读4byte(进程句柄,怪物基址1+#154)
// 如果(血偏移>0)
// 辅助.消息框(转换.整型转字符型(数组*4))
// 如果结束
列表框.增加文本("列表框6",字符串.连接(字符串.连接(转换.整型转字符型(血偏移),"/"),转换.整型转字符型(最大血)))
魔法=进程.读4byte(进程句柄,怪物基址1+#13c)
最大魔法=进程.读4byte(进程句柄,怪物基址1+#158)
列表框.增加文本("列表框7",字符串.连接(字符串.连接(转换.整型转字符型(魔法),"/"),转换.整型转字符型(最大魔法)))
等级=进程.读4byte(进程句柄,怪物基址1+#128)
列表框.增加文本("列表框8",转换.整型转字符型(等级))
x坐标=进程.读float(进程句柄,怪物基址1+#3c)
y坐标=进程.读float(进程句柄,怪物基址1+#44)
x=字符串.截取(转换.浮点型转字符型(x坐标),0,字符串.查找字符(转换.浮点型转字符型(x坐标),46))
y=字符串.截取(转换.浮点型转字符型(y坐标),0,字符串.查找字符(转换.浮点型转字符型(y坐标),46))
列表框.增加文本("列表框9",字符串.连接(字符串.连接(x,","),y))
距离=进程.读float(进程句柄,怪物基址1+#2e8)
距离1=字符串.截取(转换.浮点型转字符型(距离),0,字符串.查找字符(转换.浮点型转字符型(距离),46))
列表框.增加文本("列表框10",距离1)
怪物名=进程.读4byte(进程句柄,怪物基址1+#2c0)
怪物名字=进程.读stringunicode(进程句柄,怪物名,20)
列表框.增加文本("列表框5",怪物名字)
数组=数组+1
否则
数组=数组+1
如果结束
循环结束
返回 真
功能结束
功能 逻辑型 按钮4_点击()
整型 进程句柄,基址,一级偏移,二级偏移,三级偏移,玩家首地址,数组,玩家基址,玩家基址1,玩家最大数组,玩家名,玩家血,玩家最大血,玩家魔,玩家最大魔,玩家等级
字符型 玩家名字,x,y,距离1
浮点型 x坐标,y坐标,距离
列表框.清空("列表框11")
列表框.清空("列表框12")
列表框.清空("列表框13")
列表框.清空("列表框14")
列表框.清空("列表框15")
列表框.清空("列表框16")
进程句柄=进程.获取进程句柄("Element Client")
基址=进程.读4byte(进程句柄,#00b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#28)
三级偏移=进程.读4byte(进程句柄,二级偏移+#138)
玩家首地址=进程.读4byte(进程句柄,三级偏移+#18)
玩家最大数组=进程.读4byte(进程句柄,三级偏移+#24)
数组=0
循环(数组<玩家最大数组)
玩家基址=进程.读4byte(进程句柄,玩家首地址+数组*4)
如果(玩家基址>0)
玩家基址1=进程.读4byte(进程句柄,玩家基址+#4)
玩家名=进程.读4byte(进程句柄,玩家基址1+#518)
玩家名字=进程.读stringunicode(进程句柄,玩家名,20)
列表框.增加文本("列表框11",玩家名字)
玩家血=进程.读4byte(进程句柄,玩家基址1+#264)
玩家最大血=进程.读4byte(进程句柄,玩家基址1+#280)
列表框.增加文本("列表框12",字符串.连接(字符串.连接(转换.整型转字符型(玩家血),"/"),转换.整型转字符型(玩家最大血)))
玩家魔=进程.读4byte(进程句柄,玩家基址1+#268)
玩家最大魔=进程.读4byte(进程句柄,玩家基址1+#284)
列表框.增加文本("列表框13",字符串.连接(字符串.连接(转换.整型转字符型(玩家魔),"/"),转换.整型转字符型(玩家最大魔)))
玩家等级=进程.读4byte(进程句柄,玩家基址1+#254)
列表框.增加文本("列表框14",转换.整型转字符型(玩家等级))
x坐标=进程.读float(进程句柄,玩家基址1+#3c)
y坐标=进程.读float(进程句柄,玩家基址1+#44)
x=字符串.截取(转换.浮点型转字符型(x坐标),0,字符串.查找字符(转换.浮点型转字符型(x坐标),46))
y=字符串.截取(转换.浮点型转字符型(y坐标),0,字符串.查找字符(转换.浮点型转字符型(y坐标),46))
列表框.增加文本("列表框15",字符串.连接(字符串.连接(x,","),y))
距离=进程.读float(进程句柄,玩家基址1+#69c)
距离1=字符串.截取(转换.浮点型转字符型(距离),0,字符串.查找字符(转换.浮点型转字符型(距离),46))
列表框.增加文本("列表框16",距离1)
数组=数组+1
否则
数组=数组+1
如果结束
循环结束
返回 真
功能结束
功能 逻辑型 按钮3_点击()
整型 进程句柄,基址,一级偏移,二级偏移,名字,血,最大血,魔,最大魔,命中,躲闪,防御,小攻击,大攻击
字符型 名,血量,魔法,攻击
进程句柄=进程.获取进程句柄("Element Client")
基址=进程.读4byte(进程句柄,#00b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#28)
名字=进程.读4byte(进程句柄,二级偏移+#518)
名=进程.读stringunicode(进程句柄,名字,20)
标签.设置文本("标签7",名)
血=进程.读4byte(进程句柄,二级偏移+#264)
最大血=进程.读4byte(进程句柄,二级偏移+#280)
血量=字符串.连接(字符串.连接(转换.整型转字符型(血),"/"),转换.整型转字符型(最大血))
标签.设置文本("标签9",血量)
魔=进程.读4byte(进程句柄,二级偏移+#268)
最大魔=进程.读4byte(进程句柄,二级偏移+#284)
魔法=字符串.连接(字符串.连接(转换.整型转字符型(魔),"/"),转换.整型转字符型(最大魔))
标签.设置文本("标签10",魔法)
命中=进程.读4byte(进程句柄,二级偏移+#2c0)
标签.设置文本("标签12",转换.整型转字符型(命中))
躲闪=进程.读4byte(进程句柄,二级偏移+#2c8)
标签.设置文本("标签13",转换.整型转字符型(躲闪))
防御=进程.读4byte(进程句柄,二级偏移+#2c4)
标签.设置文本("标签11",转换.整型转字符型(防御))
小攻击=进程.读4byte(进程句柄,二级偏移+#2b8)
大攻击=进程.读4byte(进程句柄,二级偏移+#2bc)
攻击=字符串.连接(字符串.连接(转换.整型转字符型(小攻击),"/"),转换.整型转字符型(大攻击))
标签.设置文本("标签8",攻击)
返回 真
功能结束
功能 逻辑型 按钮5_点击()
返回 真
功能结束
功能 逻辑型 按钮6_点击()
整型 进程句柄,基址,一级偏移,二级偏移
浮点型 x,y,h
string 内容,X,Y
进程句柄=进程.获取进程句柄("Element Client")
基址=进程.读4byte(进程句柄,#00b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#28)
x=进程.读float(进程句柄,二级偏移+#3c)
y=进程.读float(进程句柄,二级偏移+#44)
h=进程.读float(进程句柄,二级偏移+#40)
X=字符串.截取(转换.浮点型转字符型(x),0,字符串.查找字符(转换.浮点型转字符型(x),46))
Y=字符串.截取(转换.浮点型转字符型(y),0,字符串.查找字符(转换.浮点型转字符型(y),46))
内容=字符串.连接(字符串.连接(X,","),Y)
标签.设置文本("标签24",内容)
标签.设置文本("标签31",转换.浮点型转字符型(h))
返回 真
功能结束
功能 逻辑型 按钮7_点击()
字符型 内容
内容=编辑框.获得文本("编辑框4")
列表框.增加文本("列表框17",内容)
返回 真
功能结束
功能 逻辑型 按钮8_点击()
整型 序号
序号=列表框.得到选中序号("列表框17")
列表框.删除文本("列表框17",序号)
返回 真
功能结束
功能 逻辑型 按钮9_点击()
字符型 内容
内容=编辑框.获得文本("编辑框8")
列表框.增加文本("列表框18",内容)
返回 真
功能结束
功能 逻辑型 按钮10_点击()
整型 序号
序号=列表框.得到选中序号("列表框18")
列表框.删除文本("列表框18",序号)
返回 真
功能结束
功能 逻辑型 补给()
整型 hwnd,基址,一级偏移,二级偏移,三级偏移,基址1,一级偏移1,二级偏移1,三级偏移1,物品数组,物品名,物品数量,进程句柄,物品基址,物品基址1,背包格,怪物首地址,怪物最大数组,怪物基址,怪物基址1,怪物名,数组,怪物ID,物品ID
字符型 物品名字,坐标,ID,怪物名字,内容,x,y,h
浮点型 x坐标,y坐标,h坐标
hwnd=window.findwindow("Element Client")
进程句柄=进程.获取进程句柄("Element Client")
基址=进程.读4byte(进程句柄,#00b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#28)
三级偏移=进程.读4byte(进程句柄,二级偏移+#0b14)
物品基址1=进程.读4byte(进程句柄,三级偏移+#0c)
背包格=进程.读4byte(进程句柄,三级偏移+#10)
物品数组=0
循环(物品数组<背包格)
物品基址=进程.读4byte(进程句柄,物品基址1+物品数组*4)
物品名=进程.读4byte(进程句柄,物品基址+#74)
物品名字=进程.读stringunicode(进程句柄,物品名+#0c,20)
如果(字符串.长度(物品名字)==0)
物品名=进程.读4byte(进程句柄,物品基址+#6c)
物品名字=进程.读stringunicode(进程句柄,物品名+#4,20)
如果结束
如果(字符串.比较(物品名字,下拉框.获得内容("下拉框2",下拉框.得到选项("下拉框2")))==0)
物品数量=进程.读4byte(进程句柄,物品基址+#1c)
如果(物品数量<转换.字符型转整型(编辑框.获得文本("编辑框5"),0))
循环(DM.ReadInt(hwnd,"[[[[00b1a1d0]+1c]+28]+b90]+18",0)==1)
循环结束
辅助.等待(100)
DM.AsmClear()
DM.AsmAdd("mov ecx,[00B1A1D0]")
DM.AsmAdd("mov ecx,[ecx+1c]")
DM.AsmAdd("mov ecx,[ecx+28]")
DM.AsmAdd("mov eax,4e")
DM.AsmAdd("push 0")
DM.AsmAdd("push 0")
DM.AsmAdd("push -1")
DM.AsmAdd("push 0")
DM.AsmAdd("push 0")
DM.AsmAdd("push eax")
DM.AsmAdd("call 0046F2D0")
DM.AsmCall(hwnd,1)
辅助.等待(1000)
循环(DM.ReadInt(hwnd,"[[[[[[00b1a1d0]+1c]+28]+13c]+154]+8]+24",0)==1)
循环结束
辅助.等待(100)
基址1=进程.读4byte(进程句柄,#00b1a1d0)
一级偏移1=进程.读4byte(进程句柄,基址1+#1c)
二级偏移1=进程.读4byte(进程句柄,一级偏移1+#0c)
三级偏移1=进程.读4byte(进程句柄,二级偏移1+#20)
怪物首地址=进程.读4byte(进程句柄,三级偏移1+#18)
怪物最大数组=进程.读4byte(进程句柄,三级偏移1+#24)
数组=0
循环(数组<怪物最大数组)
怪物基址=进程.读4byte(进程句柄,怪物首地址+数组*4)
如果(怪物基址>0)
怪物基址1=进程.读4byte(进程句柄,怪物基址+#4)
h坐标=进程.读float(进程句柄,怪物基址1+#40)
x坐标=进程.读float(进程句柄,怪物基址1+#3c)
y坐标=进程.读float(进程句柄,怪物基址1+#44)
怪物名=进程.读4byte(进程句柄,怪物基址1+#2c0)
怪物名字=进程.读stringunicode(进程句柄,怪物名,20)
怪物ID=进程.读4byte(进程句柄,怪物基址1+#11c)
如果(字符串.查找字符串(怪物名字,"药师")!=-1)
跳出
如果结束
数组=数组+1
否则
数组=数组+1
如果结束
循环结束
DM.AsmClear()
DM.WriteFloat(hwnd,"00b29518",x坐标)
DM.WriteFloat(hwnd,"00b2951c",h坐标)
DM.WriteFloat(hwnd,"00b29520",y坐标) //三行为目的地坐标赋值
DM.AsmAdd("mov eax,[00b1a1d0]")
DM.AsmAdd("mov eax,[eax+1c]")
DM.AsmAdd("mov eax,[eax+0c]")
DM.AsmAdd("mov esi,[eax+8c]")
DM.AsmAdd("push esi")
DM.AsmAdd("mov eax,[00b1a1d0]")
DM.AsmAdd("mov eax,[eax+1c]")
DM.AsmAdd("mov eax,[eax+28]")
DM.AsmAdd("lea edx,[eax+3c]")
DM.AsmAdd("push 00B29518") //讲目的地坐标压入堆载
DM.AsmAdd("push edx") //edx为当前x坐标,并压入堆载
DM.AsmAdd("mov ecx,00b1a188")
DM.AsmAdd("call 0042c700")
DM.AsmCall(hwnd,1)
循环(DM.ReadInt(hwnd,"[[[[00b1a1d0]+1c]+28]+b90]+18",0)==1)
循环结束
ID=字符串.连接("mov ecx,0",字符串.格式化("%x",怪物ID))
DM.AsmClear()
DM.AsmAdd(ID)
DM.AsmAdd("mov edx,[00b1a1d0]")
DM.AsmAdd("push ecx")
DM.AsmAdd("mov ecx,[edx+20]")
DM.AsmAdd("add ecx,0d4")
DM.AsmAdd("call 006267A0")
DM.AsmCall(hwnd,1)
辅助.等待(1000)
物品ID=进程.读4byte(进程句柄,物品基址+#8)
DM.WriteInt(hwnd,"16BE1788",0,物品ID)
DM.WriteInt(hwnd,"16BE178C",0,下拉框.得到选项("下拉框2"))
DM.WriteInt(hwnd,"16BE1790",0,转换.字符型转整型(编辑框.获得文本("编辑框6"),0))
DM.AsmClear()
DM.AsmAdd("push 16BE1788")
DM.AsmAdd("push 1")
DM.AsmAdd("call 00663c20")
DM.AsmAdd("add esp,8")
DM.AsmCall(hwnd,1)
辅助.等待(200)
DM.WriteInt(hwnd,"[[[00b1a1d0]+1c]+28]+a10",0,0)
辅助.等待(100)
内容=标签.获得文本("标签24")
x=字符串.截取(内容,0,字符串.查找字符(内容,44))
y=字符串.移除(内容,字符串.长度(x)+1,真)
h=标签.获得文本("标签31")
DM.AsmClear()
DM.WriteFloat(hwnd,"00b29518",转换.字符型转浮点型(x))
DM.WriteFloat(hwnd,"00b2951c",转换.字符型转浮点型(h))
DM.WriteFloat(hwnd,"00b29520",转换.字符型转浮点型(y)) //三行为目的地坐标赋值
DM.AsmAdd("mov eax,[00b1a1d0]")
DM.AsmAdd("mov eax,[eax+1c]")
DM.AsmAdd("mov eax,[eax+0c]")
DM.AsmAdd("mov esi,[eax+8c]")
DM.AsmAdd("push esi")
DM.AsmAdd("mov eax,[00b1a1d0]")
DM.AsmAdd("mov eax,[eax+1c]")
DM.AsmAdd("mov eax,[eax+28]")
DM.AsmAdd("lea edx,[eax+3c]")
DM.AsmAdd("push 00B29518") //讲目的地坐标压入堆载
DM.AsmAdd("push edx") //edx为当前x坐标,并压入堆载
DM.AsmAdd("mov ecx,00b1a188")
DM.AsmAdd("call 0042c700")
DM.AsmCall(hwnd,1)
辅助.等待(1000)
循环(DM.ReadInt(hwnd,"[[[[00b1a1d0]+1c]+28]+b90]+18",0)==1)
循环结束
跳出
如果结束
如果结束
物品数组=物品数组+1
循环结束
返回 真
功能结束
功能 逻辑型 过滤打怪()
整型 hwnd,进程句柄,基址,一级偏移,二级偏移,三级偏移,怪物首地址,怪物最大数组,数组,怪物基址,血偏移,最大血,怪物名,怪物基址1,个数,计数,怪物ID,怪物种类
字符型 ID,距离1,怪物名字,内容
浮点型 距离
个数=列表框.得到个数("列表框18")
内容=列表框.获得文本("列表框18",0)
计数=1
循环(计数<个数)
内容=字符串.连接(字符串.连接(内容,"|"),列表框.获得文本("列表框18",计数))
计数=计数+1
循环结束
进程句柄=进程.获取进程句柄("Element Client")
hwnd=window.findwindow("Element Client")
进程句柄=进程.获取进程句柄("Element Client")
基址=进程.读4byte(进程句柄,#00b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#0c)
三级偏移=进程.读4byte(进程句柄,二级偏移+#20)
怪物首地址=进程.读4byte(进程句柄,三级偏移+#18)
怪物最大数组=进程.读4byte(进程句柄,三级偏移+#24)
数组=0
循环(数组<怪物最大数组)
怪物基址=进程.读4byte(进程句柄,怪物首地址+数组*4)
如果(怪物基址>0)
怪物基址1=进程.读4byte(进程句柄,怪物基址+#4)
血偏移=进程.读4byte(进程句柄,怪物基址1+#138)
最大血=进程.读4byte(进程句柄,怪物基址1+#154)
距离=进程.读float(进程句柄,怪物基址1+#2e8)
距离1=字符串.截取(转换.浮点型转字符型(距离),0,字符串.查找字符(转换.浮点型转字符型(距离),46))
怪物名=进程.读4byte(进程句柄,怪物基址1+#2c0)
怪物名字=进程.读stringunicode(进程句柄,怪物名,20)
怪物ID=进程.读4byte(进程句柄,怪物基址1+#11c)
怪物种类=进程.读4byte(进程句柄,怪物基址1+#b4)
如果(怪物种类==6)
如果(转换.字符型转整型(距离1,0)<=20)
如果(字符串.查找字符串(内容,怪物名字)==-1)
ID=字符串.连接("push 0",字符串.格式化("%x",怪物ID))
DM.AsmClear()
DM.AsmAdd("mov ecx,[00b1a1d0]")
DM.AsmAdd(ID)
DM.AsmAdd("mov ecx,[ecx+20]")
DM.AsmAdd("add ecx,0d4")
DM.AsmAdd("call 00626400")
DM.AsmCall(hwnd,1)
跳出
如果结束
如果结束
如果结束
数组=数组+1
否则
数组=数组+1
如果结束
循环结束
返回 真
功能结束
功能 逻辑型 过滤捡物()
整型 进程句柄,hwnd,基址,一级偏移,二级偏移,数组开始,物品数量,物品最大数组,物品首地址,物品基址,f,物品基址1,物品名,个数,计数,物品ID,系统ID
字符型 物品,距离,内容,ID,ID1
浮点型 物品距离x
个数=列表框.得到个数("列表框17")
内容=列表框.获得文本("列表框17",0)
计数=1
循环(计数<个数)
内容=字符串.连接(字符串.连接(内容,"|"),列表框.获得文本("列表框17",计数))
计数=计数+1
循环结束
进程句柄=进程.获取进程句柄("Element Client")
hwnd=window.findwindow("Element Client")
基址=进程.读4byte(进程句柄,#b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#0c)
数组开始=进程.读4byte(进程句柄,二级偏移+#24)
物品数量=进程.读4byte(进程句柄,数组开始+#14)
物品最大数组=进程.读4byte(进程句柄,数组开始+#24)
物品首地址=进程.读4byte(进程句柄,数组开始+#18)
f=0
循环(f<物品最大数组)
物品基址=进程.读4byte(进程句柄,物品首地址+f*4)
如果(物品基址>0)
物品基址1=进程.读4byte(进程句柄,物品基址+#4)
物品名=进程.读4byte(进程句柄,物品基址1+#168)
物品=进程.读stringunicode(进程句柄,物品名,10)
物品距离x=进程.读float(进程句柄,物品基址1+#158)
距离=字符串.截取(转换.浮点型转字符型(物品距离x),0,字符串.查找字符(转换.浮点型转字符型(物品距离x),46))
物品ID=进程.读4byte(进程句柄,物品基址1+#110)
系统ID=进程.读4byte(进程句柄,物品基址1+#10c)
如果(转换.字符型转整型(距离,0)<=10)
如果(字符串.查找字符串(内容,物品)==-1)
ID=字符串.连接("push 0",字符串.格式化("%x",物品ID))
ID1=字符串.连接("push 0",字符串.格式化("%x",系统ID))
DM.AsmClear()
DM.AsmAdd("mov edx,[00b1a1d0]")
DM.AsmAdd(ID)
DM.AsmAdd(ID1)
DM.AsmAdd("mov ecx,[edx+20]")
DM.AsmAdd("add ecx,0d4")
DM.AsmAdd("call 00626390")
DM.AsmCall(hwnd,1)
如果结束
如果结束
f=f+1
否则
f=f+1
如果结束
循环结束
返回 真
功能结束
功能 逻辑型 只捡过滤()
整型 进程句柄,hwnd,基址,一级偏移,二级偏移,数组开始,物品数量,物品最大数组,物品首地址,物品基址,f,物品基址1,物品名,个数,计数,物品ID,系统ID
字符型 物品,距离,内容,ID,ID1
浮点型 物品距离x
个数=列表框.得到个数("列表框17")
内容=列表框.获得文本("列表框17",0)
计数=1
循环(计数<个数)
内容=字符串.连接(字符串.连接(内容,"|"),列表框.获得文本("列表框17",计数))
计数=计数+1
循环结束
进程句柄=进程.获取进程句柄("Element Client")
hwnd=window.findwindow("Element Client")
基址=进程.读4byte(进程句柄,#b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#0c)
数组开始=进程.读4byte(进程句柄,二级偏移+#24)
物品数量=进程.读4byte(进程句柄,数组开始+#14)
物品最大数组=进程.读4byte(进程句柄,数组开始+#24)
物品首地址=进程.读4byte(进程句柄,数组开始+#18)
f=0
循环(f<物品最大数组)
物品基址=进程.读4byte(进程句柄,物品首地址+f*4)
如果(物品基址>0)
物品基址1=进程.读4byte(进程句柄,物品基址+#4)
物品名=进程.读4byte(进程句柄,物品基址1+#168)
物品=进程.读stringunicode(进程句柄,物品名,10)
物品距离x=进程.读float(进程句柄,物品基址1+#158)
距离=字符串.截取(转换.浮点型转字符型(物品距离x),0,字符串.查找字符(转换.浮点型转字符型(物品距离x),46))
物品ID=进程.读4byte(进程句柄,物品基址1+#110)
系统ID=进程.读4byte(进程句柄,物品基址1+#10c)
如果(转换.字符型转整型(距离,0)<=7)
如果(字符串.查找字符串(内容,物品)!=-1)
ID=字符串.连接("push 0",字符串.格式化("%x",物品ID))
ID1=字符串.连接("push 0",字符串.格式化("%x",系统ID))
DM.AsmClear()
DM.AsmAdd("mov edx,[00b1a1d0]")
DM.AsmAdd(ID)
DM.AsmAdd(ID1)
DM.AsmAdd("mov ecx,[edx+20]")
DM.AsmAdd("add ecx,0d4")
DM.AsmAdd("call 00626390")
DM.AsmCall(hwnd,1)
如果结束
如果结束
f=f+1
否则
f=f+1
如果结束
循环结束
返回 真
功能结束
功能 逻辑型 捡物()
整型 进程句柄,hwnd,基址,一级偏移,二级偏移,数组开始,物品数量,物品最大数组,物品首地址,物品基址,f,物品基址1,物品名,物品ID,系统ID
字符型 物品,距离,ID,ID1
浮点型 物品距离x
进程句柄=进程.获取进程句柄("Element Client")
hwnd=window.findwindow("Element Client")
基址=进程.读4byte(进程句柄,#b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#0c)
数组开始=进程.读4byte(进程句柄,二级偏移+#24)
物品数量=进程.读4byte(进程句柄,数组开始+#14)
物品最大数组=进程.读4byte(进程句柄,数组开始+#24)
物品首地址=进程.读4byte(进程句柄,数组开始+#18)
f=0
循环(f<物品最大数组)
物品基址=进程.读4byte(进程句柄,物品首地址+f*4)
如果(物品基址>0)
物品基址1=进程.读4byte(进程句柄,物品基址+#4)
物品名=进程.读4byte(进程句柄,物品基址1+#168)
物品=进程.读stringunicode(进程句柄,物品名,10)
物品距离x=进程.读float(进程句柄,物品基址1+#158)
距离=字符串.截取(转换.浮点型转字符型(物品距离x),0,字符串.查找字符(转换.浮点型转字符型(物品距离x),46))
物品ID=进程.读4byte(进程句柄,物品基址1+#110)
系统ID=进程.读4byte(进程句柄,物品基址1+#10c)
如果(转换.字符型转整型(距离,0)<=7)
ID=字符串.连接("push 0",字符串.格式化("%x",物品ID))
ID1=字符串.连接("push 0",字符串.格式化("%x",系统ID))
DM.AsmClear()
DM.AsmAdd("mov edx,[00b1a1d0]")
DM.AsmAdd(ID)
DM.AsmAdd(ID1)
DM.AsmAdd("mov ecx,[edx+20]")
DM.AsmAdd("add ecx,0d4")
DM.AsmAdd("call 00626390")
DM.AsmCall(hwnd,1)
如果结束
f=f+1
否则
f=f+1
如果结束
循环结束
返回 真
功能结束
功能 逻辑型 区域打怪()
整型 进程句柄,基址,一级偏移,二级偏移,hwnd
浮点型 x,y
string X,Y,内容,h
进程句柄=进程.获取进程句柄("Element Client")
hwnd=window.findwindow("Element Client")
基址=进程.读4byte(进程句柄,#00b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#28)
x=进程.读float(进程句柄,二级偏移+#3c)
y=进程.读float(进程句柄,二级偏移+#44)
内容=标签.获得文本("标签24")
X=字符串.截取(内容,0,字符串.查找字符(内容,44))
Y=字符串.移除(内容,字符串.长度(X)+1,真)
如果(数学.绝对值(转换.浮点型转整型(x)-转换.字符型转整型(X,0))>转换.字符型转整型(编辑框.获得文本("编辑框3"),0)||数学.绝对值(转换.浮点型转整型(y)-转换.字符型转整型(Y,0))>转换.字符型转整型(编辑框.获得文本("编辑框3"),0))
h=标签.获得文本("标签31")
DM.AsmClear()
DM.WriteFloat(hwnd,"00b29518",转换.字符型转浮点型(X))
DM.WriteFloat(hwnd,"00b2951c",转换.字符型转浮点型(h))
DM.WriteFloat(hwnd,"00b29520",转换.字符型转浮点型(Y)) //三行为目的地坐标赋值
DM.AsmAdd("mov eax,[00b1a1d0]")
DM.AsmAdd("mov eax,[eax+1c]")
DM.AsmAdd("mov eax,[eax+0c]")
DM.AsmAdd("mov esi,[eax+8c]")
DM.AsmAdd("push esi")
DM.AsmAdd("mov eax,[00b1a1d0]")
DM.AsmAdd("mov eax,[eax+1c]")
DM.AsmAdd("mov eax,[eax+28]")
DM.AsmAdd("lea edx,[eax+3c]")
DM.AsmAdd("push 00B29518") //讲目的地坐标压入堆载
DM.AsmAdd("push edx") //edx为当前x坐标,并压入堆载
DM.AsmAdd("mov ecx,00b1a188")
DM.AsmAdd("call 0042c700")
DM.AsmCall(hwnd,1)
辅助.等待(1000)
循环(DM.ReadInt(hwnd,"[[[[00b1a1d0]+1c]+28]+b90]+18",0)==1)
循环结束
DM.AsmClear()
DM.AsmAdd("push 0d42fe50")
DM.AsmAdd("mov eax,[00b1a1d0]")
DM.AsmAdd("mov ebx,[eax+1c]")
DM.AsmAdd("mov ecx,[ebx+28]")
DM.AsmAdd("call 00465D20")
DM.AsmCall(hwnd,1)
help.sleep(500)
如果结束
返回 真
功能结束
功能 逻辑型 吃HP()
int hwnd,基址,一级偏移,二级偏移,三级偏移,物品数组,物品名,进程句柄,物品基址,物品基址1,背包格,物品ID
字符型 物品名字,药品ID,背包格子
进程句柄=进程.获取进程句柄("Element Client")
hwnd=window.findwindow("Element Client")
DM.DownCpu(50)
循环(真&&a)
如果((DM.ReadInt(hwnd,"[[[00b1a1d0]+1c]+28]+264",0)*100/DM.ReadInt(hwnd,"[[[00b1a1d0]+1c]+28]+280",0))<(转换.字符型转整型(编辑框.获得文本("编辑框1"),0)))
基址=进程.读4byte(进程句柄,#00b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#28)
三级偏移=进程.读4byte(进程句柄,二级偏移+#0b14)
物品基址1=进程.读4byte(进程句柄,三级偏移+#0c)
背包格=进程.读4byte(进程句柄,三级偏移+#10)
物品数组=0
循环(物品数组<背包格)
物品基址=进程.读4byte(进程句柄,物品基址1+物品数组*4)
物品名=进程.读4byte(进程句柄,物品基址+#74)
物品名字=进程.读stringunicode(进程句柄,物品名+#0c,20)
如果(字符串.长度(物品名字)==0)
物品名=进程.读4byte(进程句柄,物品基址+#6c)
物品名字=进程.读stringunicode(进程句柄,物品名+#4,20)
如果结束
如果(字符串.比较(物品名字,下拉框.获得内容("下拉框0",下拉框.得到选项("下拉框0")))==0)
物品ID=进程.读4byte(进程句柄,物品基址+#8)
药品ID=字符串.连接("push 0",字符串.格式化("%x",物品ID))
背包格子=字符串.连接("push 0",字符串.格式化("%x",物品数组))
DM.AsmClear()
DM.AsmAdd("push 1")
DM.AsmAdd(药品ID)
DM.AsmAdd(背包格子)
DM.AsmAdd("push 0")
DM.AsmAdd("mov eax,[00b1a1d0]")
DM.AsmAdd("mov edi,[eax+20]")
DM.AsmAdd("lea ecx,[edi+0d4]")
DM.AsmAdd("call 006261C0")
DM.AsmCall(hwnd,1)
跳出
如果结束
物品数组=物品数组+1
循环结束
如果(字符串.长度(编辑框.获得文本("编辑框0"))==0)
辅助.等待(6000)
否则
辅助.等待(转换.字符型转整型(编辑框.获得文本("编辑框0"),0))
如果结束
如果结束
循环结束
返回 真
功能结束
功能 逻辑型 吃MP()
int hwnd,基址,一级偏移,二级偏移,三级偏移,物品数组,物品名,进程句柄,物品基址,物品基址1,背包格,物品ID
字符型 物品名字,药品ID,背包格子
进程句柄=进程.获取进程句柄("Element Client")
hwnd=window.findwindow("Element Client")
DM.DownCpu(50)
循环(真&&b)
如果((DM.ReadInt(hwnd,"[[[00b1a1d0]+1c]+28]+268",0)*100/DM.ReadInt(hwnd,"[[[00b1a1d0]+1c]+28]+284",0))<(转换.字符型转整型(编辑框.获得文本("编辑框2"),0)))
基址=进程.读4byte(进程句柄,#00b1a1d0)
一级偏移=进程.读4byte(进程句柄,基址+#1c)
二级偏移=进程.读4byte(进程句柄,一级偏移+#28)
三级偏移=进程.读4byte(进程句柄,二级偏移+#0b14)
物品基址1=进程.读4byte(进程句柄,三级偏移+#0c)
背包格=进程.读4byte(进程句柄,三级偏移+#10)
物品数组=0
循环(物品数组<背包格)
物品基址=进程.读4byte(进程句柄,物品基址1+物品数组*4)
物品名=进程.读4byte(进程句柄,物品基址+#74)
物品名字=进程.读stringunicode(进程句柄,物品名+#0c,20)
如果(字符串.长度(物品名字)==0)
物品名=进程.读4byte(进程句柄,物品基址+#6c)
物品名字=进程.读stringunicode(进程句柄,物品名+#4,20)
如果结束
如果(字符串.比较(物品名字,下拉框.获得内容("下拉框1",下拉框.得到选项("下拉框1")))==0)
物品ID=进程.读4byte(进程句柄,物品基址+#8)
药品ID=字符串.连接("push 0",字符串.格式化("%x",物品ID))
背包格子=字符串.连接("push 0",字符串.格式化("%x",物品数组))
DM.AsmClear()
DM.AsmAdd("push 1")
DM.AsmAdd(药品ID)
DM.AsmAdd(背包格子)
DM.AsmAdd("push 0")
DM.AsmAdd("mov eax,[00b1a1d0]")
DM.AsmAdd("mov edi,[eax+20]")
DM.AsmAdd("lea ecx,[edi+0d4]")
DM.AsmAdd("call 006261C0")
DM.AsmCall(hwnd,1)
跳出
如果结束
物品数组=物品数组+1
循环结束
如果(字符串.长度(编辑框.获得文本("编辑框7"))==0)
辅助.等待(6000)
否则
辅助.等待(转换.字符型转整型(编辑框.获得文本("编辑框7"),0))
如果结束
如果结束
循环结束
返回 真
功能结束
功能 逻辑型 挂机()
DM.DownCpu(50)
int hwnd,基址,一级偏移,二级偏移,三级偏移,物品数组,物品名,物品数量,进程句柄,物品基址,物品基址1,背包格,物品ID
字符型 物品名字,药品ID,背包格子
进程句柄=进程.获取进程句柄("Element Client")
hwnd=window.findwindow("Element Client")
如果(复选框.获得状态("复选框1"))
a=真
线程.开启("测试.吃HP")//吃红药
如果结束
如果(复选框.获得状态("复选框2"))
b=真
线程.开启("测试.吃MP")//吃蓝药
如果结束
while(true)
if(DM.ReadInt(hwnd,"[[[[00b1a1d0]+1c]+28]+0c1c]+38",0)==1)
DM.AsmClear()
DM.AsmAdd("mov ecx,[00B1A1D0]")
DM.AsmAdd("mov ecx,[ecx+1c]")
DM.AsmAdd("mov ecx,[ecx+28]")
DM.AsmAdd("mov eax,3")
DM.AsmAdd("push 0")
DM.AsmAdd("push 0")
DM.AsmAdd("push -1")
DM.AsmAdd("push 0")
DM.AsmAdd("push 0")
DM.AsmAdd("push eax")
DM.AsmAdd("call 0046F2D0")
DM.AsmCall(hwnd,1)
help.sleep(100)
DM.AsmClear()
DM.AsmAdd("push -1")
DM.AsmAdd("push 0")
DM.AsmAdd("push 0")
DM.AsmAdd("push 0")
DM.AsmAdd("mov eax,[00b1a1d0]")
DM.AsmAdd("mov eax,[eax+1c]")
DM.AsmAdd("mov esi,[eax+28]")
DM.AsmAdd("mov ecx,esi")
DM.AsmAdd("call 00458720")
DM.AsmCall(hwnd,1)
help.sleep(200)
else
if(复选框.获得状态("复选框6"))
测试.过滤捡物()
else
if(复选框.获得状态("复选框7"))
测试.只捡过滤()
else
测试.捡物()
endif
endif
if(复选框.获得状态("复选框5"))
测试.过滤打怪()
else
DM.AsmClear()
DM.AsmAdd("push 0d42fe50")
DM.AsmAdd("mov eax,[00b1a1d0]")
DM.AsmAdd("mov ebx,[eax+1c]")
DM.AsmAdd("mov ecx,[ebx+28]")
DM.AsmAdd("call 00465D20")
DM.AsmCall(hwnd,1)
help.sleep(500)
endif
endif
如果(复选框.获得状态("复选框4"))
测试.补给()
如果结束
如果(复选框.获得状态("复选框3"))
测试.区域打怪()
如果结束
endwhile
返回 真
功能结束
功能 逻辑型 按钮11_点击()
线程句柄=线程.开启("测试.挂机")
返回 真
功能结束
功能 逻辑型 按钮12_点击()
a=假
b=假
线程.关闭(线程句柄)
返回 真
功能结束
功能 逻辑型 初始化()
辅助.设置托盘("Element Client",假)
选项卡.激活("选项卡0",0)
控件.可见("标签31",假)
返回 真
功能结束
空间结束
附件如下:
|
本帖子中包含更多资源
您需要 登录 才可以下载或查看,没有帐号?立即注册
x
|