TC官方合作论坛

标题: 【有源码】武林外传内存辅助，供大家学习,最新版本，1月1号 [打印本页]

作者: lyf1314 时间: 2012-1-1 16:35
标题: 【有源码】武林外传内存辅助，供大家学习,最新版本，1月1号
[attach]1931[/attach]
一个纯内存操作的脚本，实现挂机区域打怪，自动补给买药，过滤打怪，过滤捡物，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",假)
返回真
功能结束
空间结束
附件如下：

作者: lyf1314 时间: 2012-1-1 16:36
还有一些细节没完善，号等级太低，哎，沙发

作者: qq06314488 时间: 2012-1-1 16:42
看看呗

作者: fdvmyb 时间: 2012-1-1 16:43
前排~~~~沙发~！！！！无良哥~~~~~崇拜你！！！！！:*

作者: tangq886 时间: 2012-1-1 16:46
沙发

作者: TC 时间: 2012-1-1 16:51
TC内存CALL技术极少的介绍帖子,单从技术层面来评论,一个字:强. :strong:

作者: 小西 时间: 2012-1-1 16:55
板凳，虽然看不懂，顶蛋蛋一下:D

作者: ksap787523 时间: 2012-1-1 17:20
顶一个啊太长了

作者: lyf1314 时间: 2012-1-2 16:26
这么好的贴都沉了

作者: egmsky 时间: 2012-1-2 16:34
学习

作者: z8566313 时间: 2012-1-5 16:16
小弟佩服的五体投地

作者: sz8082009 时间: 2012-1-6 15:31
回复了看有源码没，免得复制，学习学习

作者: 3227111 时间: 2012-1-6 15:59
:-|11111111111111111111111

作者: lmx198444 时间: 2012-1-6 23:27
dddddddddddddddddddd

作者: lmx198444 时间: 2012-1-6 23:32
什么权限可以下载啊

作者: hxeyh 时间: 2012-1-7 11:18
dfjkdi~:~

作者: 菲菲 时间: 2012-1-15 20:15
看看\\\

作者: lmx198444 时间: 2012-1-22 16:08
内存好强大正在努力学习中顶起来

作者: wangcaigavin 时间: 2012-1-22 16:48
太强大了光找这些内存基址就让人头大还能直接把动作都汇编化了:| 这个弄起来很难吧

作者: wuping2809 时间: 2012-1-24 15:25
回复 1楼lyf1314的帖子

超级厉害。

作者: zsw1021 时间: 2012-1-25 14:30
强大

作者: zhaichangtong 时间: 2012-1-29 12:31
楼主辛苦了 ~！

作者: wzjwydhy 时间: 2012-1-30 18:21
这么好的贴都沉了

作者: dzh 时间: 2012-2-3 20:34
回复 1楼lyf1314的帖子

想跟兄弟理解一下，CE如何过保护呢

作者: lyf1314 时间: 2012-2-12 13:38
回复 24楼dzh的帖子

调成内核模式一般的保护就能过了，至于更高级的保护，我也不是很会

作者: 梧桐树下雨 时间: 2012-2-12 18:16
:(:-o:#:D

作者: tiexuegongch 时间: 2012-2-12 18:57
牛！佩服啊！

作者: dzh 时间: 2012-2-13 19:38
回复 25楼lyf1314的帖子

y一般的我倒是可以，就是更高级的，他们说有更高级的CE

作者: lyf1314 时间: 2012-2-13 20:17
高级个鸡毛- -更高级就是自己修改过内部的CE了，也就这样~。~

作者: dzh 时间: 2012-2-14 09:06
回复 29楼lyf1314的帖子

我给你发个他们修改过的过程，

这方法比较麻烦，不过是一劳永逸的~ 怕麻烦的就不用看了
首先我来说下 TC是怎么检测到我们使用 OE CE什么的
只是搜素关键的函数变量，像CE OE ME 的关键函数变量
都是加入检测系统的
我们现在要做的，就是修改函数变量，让NP不认识你这个新程序。这个关键变量当然是你说了算啦
只要没流传，检测系统是不知道你这个函数变量的。
只要自己用，基本上永远都能改图。
下面正式开始：
1、我们先要准备几个软件
1）、CE的源码，这个我在网上找了很久才找到个能用的，我会传上来。地址在帖子最后。
（2）、CE源码的编译软件 DELPHI
Delphi7 : http://www.skycn.com/soft/2121.html
中文补丁: http://www.skycn.com/soft/2123.html
Delphi7直接下载 : 迅雷专用高速下载
迅雷专用高速下载 http://zjTELe2.skycn.com/down/BorlandDelphi7.zip
中文补丁直接下载 : 迅雷专用高速下载
迅雷专用高速下载 http://zjTELe1.skycn.com/down/HF_Delphi7_chs.rar
（3）Actual Search and Replace 一个查找及替换软件，这个网上很容易能下到
下载地址：
直接迅雷下载
thunder://QUFodHRwOi8vZnRwLnBjb25saW5lLmNvbS5jbi9wdWIvZG93bmxvYWQvMjAwNzEwL2FjdHVhbHNyX1BDb25saW5lLnppcFpa
（4）Windows DDK (Windows DDK (包含在 KMDF，核心模式驱动架构中) 上微软网站下吧，可能改改名字了，找不到DDK 用WDK 也行
迅雷专用高速下载 http://download.microsoft.com/download/9/0/f/90f019ac-8243-48d3-91cf-81fc4093ecfd/1830_usa_ddk.iso （参考下载地址，不知道现在能不能用了）
2.创造DBK32.sys
2a.用记事本代开CE主目录里面的driver.dat ，做如下修改：
CEDRIVER53 >> string1 （这里的string1，代表你自己的关键字，把CEDRIVER53改成你需要的东西，比如：外猴子岛1，下面一样，不多说了）
DBKProclist53 >> string2 （这就是
外猴子岛2喽~ ）
DBKThreadList53 >> string3
dbk32.sys >> string.sys
2b. 用记事本打开DBKKernel文件夹下面的DBKDrvr.c，查找： hideme，跳过第一处，来到第
二处，你会看到这样的句子： //hideme (DriverObject). 然后将hideme前面的 // 去掉。
2C. 用记事本打开打开DBKKernel 文件夹下面的sources.ce，做如下修改：
TARGETNAME=DBK32 >> TARGETNAME=string
2D. 现在编译 String.sys (也就是以前的DBK32.sys).
把你的DBKKernel文件夹所在目录的地址复制下来(等会用)。
打开window DDK，从开始菜单>>程序里面打开(确定你已经安装了KMDF)
打开之后是一个CMD界面，输入 cd ××（××既你刚才复制的地址，现在粘贴到这里）
输入ce，确定
如果一切正常，你将会看到“files compiled. 1 Executable built”的字样，String.sys
也已经出现在你的CE主目录里面。
3. 替换已被检测字符
3a.用delphi 7(中文版) 打开dbk32文件夹下的dbk32.dpr。
查看>>工程管理器，然后展开dbk32.dll，双击DBK32functions打开它，做如下修改：
CEDRIVER52 >> String1(跟CEDRIVER53是同一个东西)
DBKProcList51 >> String2 (跟DBKProcList53是同一个)
DBKThreadList51 >> String3 (跟DBKThreadList53是同一个)
都做完了么？然后保存，可以关掉delphi7了
然后打开文字替换工具(也就是Actual Search and Replace)
File> Settings > Editor,找到你的delphi 7目录的delphi运行文件，也就是delphi32.exe,
类似于"C:\Program Files\Borland\Delphi7\Bin\delphi32.exe" ，确定
点到 options 标签，确定"include subfolders"(包含子文件)已经被选上。
点到 Search and Replace标签，
在 "Masks" 里面，键入: newkernelhandler.pas; DBK32functions.pas; DBK32.dpr
在 "Path" 里面加入：CE主目录
然后把whole words 选上。
开始进行字符替换，在"to search"里填要替换的字符，在"to Replace or insert"填上要替换成的字符。
被替换和替换成的字符如下：
VQE >> string4
OP >> string5
OT >> string6
RPM>> string7
WPM >> string8
VAE >> string9
3b. 现在我们将newkernelhandler.pas, DBK32functions.pas, 和DBK32.dpr改名.
用Delphi 7打开上面3个文件. Newkernelhandler 在CE主目录，另外两个文件在DBK32文件夹. 打开，
然后执行“文件 ”> “另存为”，3个文件分别另存为：
DBK32.dpr >> String.dpr
DBK32functions.pas >> Stringfunctions.pas
New KernelHandler.pas >> StringHandler.pas
然后保存，退出。
现在，打开查找和替换工具，把 mask 改成 " *.* ". (Include Subfolders要选中)
做如下替换。
dbk32.sys >> string.sys
dbk32.dll >> string.dll
现在用delphi 7打开string.dpr . 我们将编译 string.dll. 执行 Project > compile string. 如果正常你将会
看到"警告"和"提示"窗口，否则你将看到"错误"窗口. 如果得到错误，那么检查你的步骤。
好的，如果一切正常，你就可以在CE主目录看到string.dll了
3c. 制作 CEHook
再次用到查找和替换工具，“Mask”里键入 CEHook.dpr;hypermode.pas
替换：myhook >> string54
用delphi7打开CEHOOK文件夹下面的CEHook.dpr ,然后将user下面的system注释掉，也就是在system
前面加入“ // ”。
3d. 创造 Stealth - 打开stealth.dpr（在Stealth目录下）
并且编译它，这里什么都不需要变（HOHO…）
3e. 重新命名 NewKernelHandler 和 CeFuncProc
打开cheatengine.dpr（CE 主目录下）.来到
工程管理器
，再次打开NewKernelHandler.pas 和
CeFuncProc.pas 执行文件 > 另存为". 保存到CE主目录，两文件分别保存为：
NewKernelHandler.pas >> StringHandler.pas (replace? Yes!)
CeFuncProc.pas >> String55.pas
保存，退出。
然后查找替换，Mask填：*.*，（取消 include subfolders）
NewKernelHandler >> Stringhandler (改变所有文件除了Newkernelhandler.pas)
CeFuncProc >> String55
3f. 改变数值字符 (十六进制数值)
需要改变3个数值：00400000 , 7FFFFFFF , 80000000
可以给3个数值加上同样的数，比如说加5他们就变成：00400005，80000004，80000005
然后查找替换，(Include subfolders)，Mask："*.*"
00400000 >> 00400005
7FFFFFFF >> 80000004
80000000 >> 80000005
3g. 改变CheatEngine 图形界面里面的单词
再次查找和替换， (取消 include subfolders) ，Mask："*.*"
nextscanbutton >> String56
scanvalue >> String57
scanvalue2 >> String58
ScanType >> String59
VarType >> String60
newscan >> String61
ScanText >> String62
syndic.com/ce >> myspace.com (你可以改变为任何网站)
3h. 再次查找和替换，(取消 include subfolders). mask："*.pas "
CheatEngine >> StringEngine
cheat engine >> String Engine
3i.配置Cheat Engine 图形界面
打开CE主目录下的cheatengine.bpg. 然后工程管理器, 打开 MainUnit . 双击Cheat Engine图形界面就
弹出来了.
查找灰色显示的单词： "scan type" 和"value type",单击该下拉框来到scantype，这一步的目的就是检查你修改的字符是否正确，然后看左边的工程树和工程检测器，希望工程树下的 String59 是高亮显示的，现在向下滚动工程检测器，知道你看到"name"，希望它的下一格也是String59
如果你这一步做正确了，那么继续重复做单词的检查。
最后，点击红色箭头下面的"ProtectMe2" 和"crash me"，转到工程监测器，把它的标题上的单词删掉
这样，它们是存在的，可是我们却看不到它们了。
下面，是一些有关个性化你的UCE的方法：
改变版本信息：用工程管理器打开Cheatengine.exe，右键>选项，点击"版本信息"标签，自由发挥吧
改变应用程序名，帮助，和图标，同上，然后点击“应用程序”标签。
改变设置和关于…部分，分别用工程管理器打开formsettingsunit" 和 "aboutunit"
3j. 编译 cheatengine.exe
查看工程管理器，确定你现在选择的是cheatengine.exe而不是cheatengine.DEU / NLD / RUS
最小化DelPhi，然后用wendows资源管理器打开CE主目录，建立一个文本文件，然后改名为：
trainerwithassembler.exe（这里非常重要，没有不行哦）
现在回到delphi，编译，这将会是很长的一步（但也是令人高兴的，因为你正接近成功）
当你尝试编译的时候，你也许会得到错误，类似：
[Error] autoassembler.pas(531): Undeclared identifier: 'KernelAlloc'
希望你已将你的改变如我要求的那样记录到一张纸上，现在去看你的记录，你将KernelAlloc变成了什么，
在该教程里，我改变为 String50
再次编译，如果你再次得到错误，处理它，再编译，直到没有错误。
（这是很长的一步，却是关键的一步）
4. 完成接触
4a. 编译UCE需要的文件
打开Delphi.
编译systemcallsignal.dpr (在 SystemcallRetriever 文件夹下).
编译Systemcallretriever.dpr(在 SystemcallRetriever 文件夹下).
编译Kernelmoduleunloader.dpr ( dbk32\kernelmodule unloader文件夹下)
4b. 另外的填充
首先.. 在你进行打包搞遭前，制作一个源文件的拷贝.
现在打开主目录下的cheatengine.bpg ，另存为stringengine.bpg
再次打开cheatengine.bpg，在cheatengine.exe 上右击，选择"查看源文件"，
另存 cheatengine.dpr 为 stringengine.dpr 然后
编译它，你就会得到StringEngine.exe. !! (CE主文件，在这里已经变成SE了）
4c. 希望现在你有了所有下面的文件..
创造一个新的文件夹把他们放进去。
stringengine.exe
driver.dat
string.sys
string.dll
stealth.dll
cehook.dll
systemcallsignal.exe
systemcallretriever.exe
kernelmoduleunloader.exe
所所所所…有的事情已经做好!! 现在你仅需要去测试它。
只要按步骤来，一定可以的，中间可能有什么错误，多试几次吧。我弄了1天半才弄好的。
好了
现在来到我们的最后一步，设置你的修改器。
打开你们的修改器
进入设置

作者: 九先生 时间: 2012-2-14 10:11
仔细揣摩思路！！！

作者: iceangellion 时间: 2012-2-24 12:00
太强大了

作者: 寻星 时间: 2012-3-18 14:19
好贴是不怕沉得，总有人会帮着顶起来！我也是一个顶哥的人

作者: jie820090428 时间: 2012-3-18 14:34
看看

作者: popo014 时间: 2012-3-19 12:22
我就回复一下吧

作者: zdy77233647 时间: 2012-5-29 22:29
回复 1楼lyf1314的帖子

MISS 我找到额

作者: 木耳 时间: 2012-5-30 13:04
好厉害啊。。。。。。。。。。

作者: jianghai1977 时间: 2012-5-30 16:09
牛a------c之间的人啊

作者: fang2018 时间: 2012-6-1 00:10
学习中

作者: a287238839 时间: 2012-6-1 00:57
武林外传的我喜欢

作者: zou0804 时间: 2012-6-22 00:39
mark，先标记好，再在查看

作者: qbaby 时间: 2012-6-22 06:57
膜拜啊~~~~

作者: jinzong2 时间: 2012-6-24 11:07
又一位大神

作者: normanu 时间: 2012-7-2 21:01
回复 1楼lyf1314的帖子

超级厉害。

作者: 最爱念 时间: 2012-7-4 16:25
蛋蛋是内存高手哎，下一步试着学习一下，会不会还要一些修改器查找内存地址的呀？

作者: qskyer 时间: 2012-7-4 16:30
强！！！！

作者: j3312270 时间: 2012-7-8 15:36
虽然不懂但是还是要顶起~~

作者: hongying1120 时间: 2012-7-14 23:26
学习中~~ 参考下,思路

作者: jinkeli 时间: 2012-7-15 09:05
漂亮。。。。。

作者: lianyao0002 时间: 2012-7-15 09:13
学习下

作者: lianyao0002 时间: 2012-7-15 09:14
别沉了

作者: smallduck218 时间: 2012-8-6 08:42
神人也哦天那

作者: zhangxsfang 时间: 2012-8-29 10:44

作者: lhj2012008 时间: 2012-8-29 12:10
路过路过路过路过路过

作者: 13390946205 时间: 2012-9-20 23:57
as打扫打扫打扫的

作者: 舍我其谁 时间: 2012-10-29 08:06
内存不懂啊

作者: 76432956 时间: 2012-10-29 13:16
学习学习

作者: 187144831 时间: 2012-11-2 22:13
321302103210

作者: viyor 时间: 2012-11-3 22:03
gggggg

作者: a271843 时间: 2012-11-3 22:10
撒旦法撒旦发射点发射得分

作者: stevenxiexie 时间: 2012-11-4 17:02

这么长就得几个注释...

作者: shouyiren 时间: 2012-11-5 08:36
学习

作者: lslaoxu 时间: 2012-11-6 12:17
学习学习学习

作者: sport431 时间: 2012-11-7 14:43
必须顶

作者: zzz8zzz 时间: 2012-11-12 21:01
你好厉害啊

作者: chengnhi 时间: 2012-11-13 02:20
新手看不懂呀

作者: w31317348 时间: 2012-11-14 11:26
纯内存啊，大神啊。膜拜下，然后放着慢慢学习。。现在看不动。。

作者: ro897321 时间: 2012-11-21 08:52
huifu

作者: windforce 时间: 2012-12-20 10:04
solo solo 学习谢谢LZ

作者: lgsex 时间: 2012-12-20 10:47
学习学习

作者: qq910950471 时间: 2012-12-20 11:04
你发的源码真多

作者: lyqing55 时间: 2012-12-24 14:02
回复 1楼lyf1314的帖子

高手啊!,膜拜

作者: 1051785287 时间: 2013-1-1 18:09
ewfewttgetew

作者: MCyouxi 时间: 2013-1-3 09:56
回复 1楼lyf1314的帖子

不错要学习啊

作者: wudongdonghehe 时间: 2013-1-10 19:49
下载，学习一下，谢谢蛋蛋老师。

作者: 菜B 时间: 2013-1-13 15:40
have a look

作者: 开心小鱼 时间: 2013-1-16 00:17
哇，我要能学会这个，我……

作者: panking 时间: 2013-1-16 15:44
回复 1楼lyf1314的帖子

好评

作者: q123789 时间: 2013-1-16 18:07
回复 1楼lyf1314的帖子

好东西~！大家来顶

作者: qiuqian139 时间: 2013-1-16 23:28
一般的游戏都已经有保护了，还怎么写内存挂啊！就像鹿鼎记，神话这些游戏，都保护什么时候能把保护破了，在学内存挂吧！

作者: q79985718 时间: 2013-1-21 19:41
学习，学习

作者: 小0武 时间: 2013-1-22 03:30
太崇拜你了···

作者: gdlwolf 时间: 2013-1-24 22:19
5555555555555555

作者: TC谢亮 时间: 2013-1-25 10:29
学习

作者: lzq5628989 时间: 2013-1-28 08:36
必须看

作者: armlin 时间: 2013-1-28 20:01
膜拜啊！！！！！！！！

作者: paiang 时间: 2013-1-28 20:34
adadsadsa

作者: 13963634376 时间: 2013-1-28 23:00
学习学习

作者: 357996943 时间: 2013-1-30 00:53
dddddddddddddd

作者: fanghui0632 时间: 2013-1-30 16:40
一定要顶，就是想学习一下内存的东东

作者: alukaduo09 时间: 2013-1-31 01:47
学习

作者: edolie 时间: 2013-2-1 15:18
此贴不收藏，天理难容啊，有空慢慢看

作者: die13719076310 时间: 2013-2-3 23:52

作者: a9995999 时间: 2013-2-4 23:17
看了慢慢研究了

作者: yzbtonicity 时间: 2013-2-6 17:06
一级厉害，学习

作者: goodbest87 时间: 2013-2-6 19:08
大神

作者: xzp 时间: 2013-2-7 17:21
最强的帖子，代码好几百行

作者: liumangdayi 时间: 2013-2-11 12:11
看一看了

作者: 拜师学艺 时间: 2013-2-20 17:41
好难呀

作者: 13755281481 时间: 2013-2-25 19:53
回复 1楼lyf1314的帖子

有源码】武林外传内存辅助，供大家学习,最新版本，1月1号

欢迎光临 TC官方合作论坛 (http://bbs.52tc.co/)