DNF最新350全屏写法 只供研究交流 请勿用于非法用途

内容回复可见：

.版本 2

.程序集 窗口程序集1

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

.判断开始 (文件是否存在 (“C:\蕾界.ini”) ＝ 假)
    写到文件 (“C:\蕾界.ini”, #蕾界配置)
.默认

.判断结束
加载一路发驱动 ()
进程ID ＝ 取进程ID (“DNF.exe”)
监视热键 (&全屏, #F1键)

.子程序 __启动窗口_将被销毁

卸载一路发驱动 ()


.子程序 _全屏_周期事件
.局部变量 怪物数量, 整数型
.局部变量 首次地址, 整数型
.局部变量 一级偏移, 整数型
.局部变量 二级偏移, 整数型
.局部变量 递加偏移, 整数型
.局部变量 怪ESI, 整数型
.局部变量 x, 整数型
.局部变量 y, 整数型
.局部变量 z, 整数型
.局部变量 临时变量, 整数型
.局部变量 计次, 整数型
.局部变量 次数, 整数型
.局部变量 触发ESI1, 整数型
.局部变量 异步处理, 逻辑型, 静态
.局部变量 技能代码, 整数型
.局部变量 个数, 整数型
.局部变量 地图, 整数型
.局部变量 怪物地址, 整数型
.局部变量 hook地址, 整数型

Vm ()
' 伤害 ＝ 到整数 (读配置项 (“C:\蕾界.ini”, “伤害配置”, “伤害”, ))
' 频率 ＝ 到整数 (读配置项 (“C:\蕾界.ini”, “频率配置”, “频率”, ))
' 代码 ＝ 到整数 (读配置项 (“C:\蕾界.ini”, “代码配置”, “代码”, ))
一级偏移 ＝ 读内存整数型 (进程ID, 十六到十 (#人物基址))
二级偏移 ＝ 读内存整数型 (进程ID, 一级偏移 ＋ 十六到十 (“B4”))
首次地址 ＝ 读内存整数型 (进程ID, 二级偏移 ＋ 十六到十 (“B0”))
.变量循环首 (0, 256, 1, 计次)
    递加偏移 ＝ 4 ＋ 4 × 计次
    怪ESI ＝ 读内存整数型 (进程ID, 首次地址 ＋ 递加偏移)
    临时变量 ＝ 读内存整数型 (进程ID, 怪ESI ＋ 1760)
    .如果真 (临时变量 ＝ 0 或 临时变量 ＝ 200)
        到循环尾 ()
    .如果真结束
    临时变量 ＝ 读内存整数型 (进程ID, 怪ESI ＋ 144)
    .如果真 (临时变量 ≠ 529 且 临时变量 ≠ 273 且 临时变量 ≠ 545)
        到循环尾 ()
    .如果真结束
    .如果真 (解密 (怪ESI ＋ 12668) ＝ 1)
        到循环尾 ()
    .如果真结束
    x ＝ 读内存小数型 (进程ID, 怪ESI ＋ 396)
    y ＝ 读内存小数型 (进程ID, 怪ESI ＋ 400)
    z ＝ 读内存小数型 (进程ID, 怪ESI ＋ 404)
    触发ESI1 ＝ 读内存整数型 (进程ID, 十六到十 (#人物基址))
    .如果真 (触发ESI1 ＜ 1000)
        到循环尾 ()
    .如果真结束
    .如果真 (异步处理 ＝ 假)
        异步处理 ＝ 真
        蕾界CALL (读内存代码 (进程ID, #人物基址), x, y, z, 到整数 (伤害.内容) × 100, 到整数 (代码.内容), 11313840)  ' 10086‘24012’39002
        Vm ()
        异步处理 ＝ 假
    .如果真结束
    次数 ＝ 次数 ＋ 1
    .如果真 (次数 ≥ 10)
        跳出循环 ()
    .如果真结束

.变量循环尾 ()


.子程序 全屏
.局部变量 频率, 整数型

.如果 (全屏.时钟周期 ＝ 0)
    全屏.时钟周期 ＝ 到整数 (频率.内容)
    公告 (“全屏开启”)
.否则
    全屏.时钟周期 ＝ 0
    公告 (“全屏关闭！”)
.版本 2
.支持库 spec
.支持库 iext5

.程序集 蕾界CALL

.子程序 加密
.参数 加密地址, 整数型
.参数 加密数值, 整数型
.局部变量 edi, 整数型
.局部变量 ecx, 整数型
.局部变量 ebx, 整数型
.局部变量 eax, 整数型
.局部变量 esi, 整数型
.局部变量 edx, 整数型
.局部变量 ss, 整数型

进程ID ＝ 取进程ID (“DNF.exe”)
ecx ＝ 加密地址
eax ＝ 读内存整数型 (进程ID, 十六到十 (#加密基址))
eax ＝ eax ＋ 1
读内存整数型 (进程ID, 十六到十 (#加密基址), eax)
edx ＝ eax
edx ＝ 右移 (edx, 8)
edx ＝ 左移 (edx, 24)
edx ＝ 右移 (edx, 24)
edx ＝ 读内存整数型 (进程ID, edx × 2 ＋ 十六到十 (#加密参数1))
edx ＝ 取双字节 (edx)
eax ＝ 左移 (eax, 24)
eax ＝ 右移 (eax, 24)
ss ＝ 读内存整数型 (进程ID, eax × 2 ＋ 十六到十 (#加密参数2))
ss ＝ 取双字节 (ss)
edx ＝ 位异或 (edx, ss)
eax ＝ edx
eax ＝ 取双字节 (eax)
esi ＝ 加密数值
edx ＝ 右移 (esi, 16)
超级延时 (10)
ss ＝ 取双字节 (esi)
edx ＝ edx ＋ ss
edx ＝ 位异或 (edx, eax)
edi ＝ edx
edx ＝ eax
eax ＝ 左移 (eax, 16)
eax ＝ eax ＋ edx
esi ＝ 加密数值
eax ＝ 位异或 (eax, esi)
esi ＝ 加密地址 ＋ 8
写内存整数型 (进程ID, esi, eax)
eax ＝ 读内存整数型 (进程ID, 加密地址)
esi ＝ 读内存整数型 (进程ID, 十六到十 (#解密基址))
ecx ＝ edi
ecx ＝ 左移 (ecx, 16)
ecx ＝ ecx ＋ edx
edx ＝ eax
edx ＝ 右移 (edx, 16)
edx ＝ 读内存整数型 (进程ID, esi ＋ edx × 4 ＋ 36)
eax ＝ 取双字节 (eax)
写内存整数型 (进程ID, edx ＋ eax × 4 ＋ 8468, ecx)
VMP保护标记结尾 ()

.子程序 解密, 整数型
.参数 地址, 整数型
.局部变量 edi, 整数型
.局部变量 ecx, 整数型
.局部变量 ebx, 整数型
.局部变量 eax, 整数型
.局部变量 esi, 整数型
.局部变量 edx, 整数型
.局部变量 ss, 整数型

进程ID ＝ 取进程ID (“DNF.exe”)
eax ＝ 读内存整数型 (进程ID, 地址)
esi ＝ 读内存整数型 (进程ID, 十六到十 (#解密基址))
edx ＝ eax
edx ＝ 右移 (edx, 16)
edx ＝ 读内存整数型 (进程ID, esi ＋ edx × 4 ＋ 36)
eax ＝ 取双字节 (eax)
eax ＝ 读内存整数型 (进程ID, edx ＋ eax × 4 ＋ 8468)
eax ＝ 取双字节 (eax)
edx ＝ eax
esi ＝ edx
esi ＝ 左移 (esi, 16)
esi ＝ esi ＋ edx
edx ＝ 读内存整数型 (进程ID, 地址 ＋ 8)
eax ＝ 位异或 (esi, edx)
返回 (eax)
VMP保护标记结尾 ()

.子程序 取双字节, 整数型
.参数 数值, 整数型
.局部变量 取舍, 整数型

取舍 ＝ 十六到十 (取文本右边 (十到十六 (数值), 4))
返回 (取舍)

.子程序 整数到浮点, 整数型
.参数 待转换整数, 文本型
.局部变量 a, 小数型
.局部变量 b, 整数型

a ＝ 到小数 (待转换整数)
写到内存 (到字节集 (a), 取变量地址 (b), 取数据类型尺寸 (#整数型))
返回 (b)

.子程序 浮点到整数, 文本型
.参数 待转换浮点, 整数型
.局部变量 c, 整数型

c ＝ 待转换浮点
.如果 (c ＞ 10000)
    返回 (到文本 (读内存小数型 (-1, 取变量数据地址 (c))))
.否则
    返回 (到文本 (c))
.如果结束


.子程序 Pass_动态
.参数 Pass_地址, 整数型
.局部变量 Pass_头部, 整数型

进程ID ＝ 取进程ID (“DNF.exe”)
Pass_头部 ＝ 读内存整数型 (进程ID, Pass_地址)
Pass_头部 ＝ 读内存整数型 (进程ID, Pass_头部 ＋ 十六到十 (“C”))
Pass_头部 ＝ Pass_头部 ＋ 十六到十 (“400”)
写内存字节集 (进程ID, Pass_头部, { 195 })

.子程序 Pass_静态
.参数 地址, 整数型
.局部变量 定位静态, 整数型
.局部变量 静态地址, 整数型
.局部变量 镜像, 字节集
.局部变量 镜像地址, 整数型

进程ID ＝ 取进程ID (“DNF.exe”)
定位静态 ＝ 地址
镜像 ＝ 读内存字节集 (打开进程 (进程ID), 4194304, 62914560)
镜像地址 ＝ 申请内存 (十六到十3 (“04000000”) － 十六到十3 (“00400000”), )
写内存字节集 (进程ID, 镜像地址, 镜像)
静态地址 ＝ 位异或 (右移 (镜像地址, 16), 1)
.计次循环首 (4, )
    定位静态 ＝ 读内存整数型 (进程ID, 定位静态)
.计次循环尾 ()
定位静态 ＝ 读内存整数型 (进程ID, 定位静态 ＋ 8)
写内存整数型 (进程ID, 定位静态 ＋ 8, 静态地址)

.子程序 返回BOSS地址, 整数型
.参数 类型, 整数型, , 529是怪物 273是APC 1057是普通建筑 33是特殊建筑
.参数 阵营, 整数型, 可空, 默认为队友,-1为不限 100为敌人 200为建筑 0为队友
.局部变量 a, 整数型
.局部变量 怪物数量, 整数型
.局部变量 怪物首地址, 整数型


.判断循环首 (是否指定怪物 (读内存整数型 (进程ID, 怪物首地址), 阵营, 类型) ＝ 0)
    a ＝ a ＋ 1
    怪物首地址 ＝ 读内存整数型 (进程ID, 读内存整数型 (进程ID, 读内存整数型 (进程ID, 十六到十 (#人物基址)) ＋ 176) ＋ 20) ＋ a × 4
    .如果真 (a ＝ 273)
        返回 (0)
    .如果真结束

.判断循环尾 ()
返回 (怪物首地址)
VMP保护标记结尾 ()

.子程序 是否指定怪物, 整数型
.参数 地址, 整数型
.参数 阵营, 整数型
.参数 类型, 整数型
.局部变量 临时变量, 整数型

临时变量 ＝ 读内存整数型 (进程ID, 地址 ＋ 140)
.如果真 (临时变量 ＝ 类型 且 地址 ≠ 读内存整数型 (进程ID, 十六到十 (#人物基址)))
    .如果真 (阵营 ＝ -1)
        返回 (1)
    .如果真结束
    .如果真 (读内存整数型 (进程ID, 地址 ＋ 1560) ＝ 阵营)
        返回 (1)
    .如果真结束

.如果真结束
返回 (0)

.子程序 模拟378
.参数 对象指针, 整数型
.参数 X, 整数型
.参数 Y, 整数型
.参数 Z, 整数型
.参数 伤害, 整数型
.参数 代码, 整数型
.参数 参数1, 整数型
.参数 参数2, 整数型

' 模拟378 (十六到十 (#人物基址), x, y, z, 到整数 (伤害), 到整数 (代码), 十六到十 (#技能参数1), 十六到十 (#技能参数2))  ' 378
写内存字节集 (进程ID, 十六到十 (“7C921166”), { 141, 68, 36, 16, 137, 68, 36, 4 })
置汇编代码 ({  })
Pushad ()
Mov_ESI_Ptr (对象指针)
Mov_ECX_ESI ()
Mov_EDX_Ptr_ECX_Add (0)
Mov_EAX_EDX ()
Add_EAX (888)
Mov_EAX_Ptr_EAX_Add (0)
Mov_EDX_Ptr (参数1)
Mov_ECX_Ptr (参数2)
Push (0)
Push (0)
Push (0)
Push_EDX ()
Push_ECX ()
Push (0)
Push (4)
Push (Z)
Push (Y)
Push (X)
Push (0)
Push (0)
Push (伤害)
Push (代码)
Mov_ECX_ESI ()
Call_EAX ()
Popad ()
ret ()
调用函数 (进程ID, 取汇编代码 ())

.子程序 过图CALL
.参数 方向, 整数型

' 其版权归该软件和程序源码的合法拥有者所有
' 不得用于任何商业用途。如果由于以上原因造成的版权纠纷本站概不负责！
' 本源码均有网络搜集！

写内存字节集 (进程ID, 十六到十 (“7C921166”), { 141, 68, 36, 16, 137, 68, 36, 4 })
置汇编代码 ({  })
清空汇编代码 ()
Pushad ()
Mov_ECX_Ptr (十六到十 (#商店基址) － 8)
Mov_ECX_Ptr_ECX_Add (十六到十 (#时间基址))
Mov_ECX_Ptr_ECX_Add (十六到十 (“4C”))
Push (进程ID)
Push (进程ID)
Push (0)
Push (0)
Push (0)
Push (0)
Push (0)
Push (方向)
Mov_EAX (十六到十 (#过图CALL))
Call_EAX ()
Popad ()
ret ()
调用函数 (取进程ID (“DNF.exe”), 取汇编代码 ())

.子程序 蕾界CALL
.参数 人物基址, 整数型
.参数 X轴, 整数型
.参数 Y轴, 整数型
.参数 Z轴, 整数型
.参数 全屏伤害, 整数型
.参数 全屏代码, 整数型
.参数 CALL地址, 整数型
.局部变量 代码, 字节集


置汇编代码 ({  })
清空汇编代码 ()
Pushad ()
Mov_ECX (人物基址)
Push (0)
Push (0)
Push (0)
Push (0)
Push (0)
Push (0)
Push (4)
Push (0)
Push (0)
Push (Z轴)
Push (Y轴)
Push (X轴)
Push (全屏伤害)
Push (全屏代码)
Push_ECX ()
Mov_EAX (CALL地址)
Call_EAX ()
Popad ()
ret ()
代码 ＝ 取汇编代码 ()
写内存字节集 (进程ID, 十六到十 (“7C921166”), { 141, 68, 36, 16, 137, 68, 36, 4 })
调用函数 (进程ID, 代码)  ' 注入是   调用代码（代码）

.子程序 sdf
.局部变量 首地址, 整数型
.局部变量 地址, 整数型

首地址 ＝ 十六到十 (“06000000”)
.变量循环首 (首地址, 首地址 ＋ 52428800, 65536, 地址)
    .如果真 (读内存字节集 (进程ID, 地址, 4) ＝ { 139, 4, 36, 195 })
        写内存字节集 (进程ID, 地址, { 195, 144, 144 })
        跳出循环 ()
    .如果真结束

.变量循环尾 ()

.子程序 af
.局部变量 首地址11, 整数型
.局部变量 地址1, 整数型
.局部变量 地址2, 整数型
.局部变量 地址3, 整数型

首地址11 ＝ 十六到十 (“04000000”)
.变量循环首 (首地址11, 首地址11 ＋ 55806496, 65536, 地址1)
    .如果真 (读内存字节集 (进程ID, 地址1, 4) ＝ { 139, 4, 36, 195 })
        写内存字节集 (进程ID, 地址2, { 195, 144, 144 })
        跳出循环 ()
    .如果真结束

.变量循环尾 ()

.子程序 sdfdh
.局部变量 首地址, 整数型
.局部变量 地址, 整数型

首地址 ＝ 十六到十 (“06000000”)
.变量循环首 (首地址, 首地址 ＋ 首地址 ＋ 十六到十 (“06000000”), 十六到十 (“10000”), 地址)
    .如果真 (读内存字节集 (进程ID, 地址, 4) ＝ { 139, 4, 36, 195 })
        写内存字节集 (进程ID, 地址, { 195, 144, 144 })
        跳出循环 ()
    .如果真结束

.变量循环尾 ()

.子程序 公告, , 公开
.参数 内容, 文本型
.局部变量 DNF, 坐标型

DNF ＝ 取窗口内顶点 (取句柄 (“DNF.exe”, , “地下城与勇士”))
_启动窗口.气球提示框1.弹出提示框 (DNF.x ＋ 190, DNF.y ＋ 410, 内容, -1, 真)

.子程序 Vm

写内存字节集 (进程ID, 十六到十 (“024DE7F0”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE803”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE816”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE852”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE863”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE876”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE89C”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE8D7”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE8E7”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE8FA”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE921”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE938”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE94F”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE966”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE98D”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE9A4”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE9CF”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DE9F6”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEA0A”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEA1E”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEA32”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEA45”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEA59”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEA6C”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEA7F”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEA96”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEABC”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEAD2”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEAE5”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEAF5”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEB0C”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEB20”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEB4A”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEB5A”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEB97”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEBBF”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEBD2”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEBFA”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEC28”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEC3C”), 还原字节集2 (“C3”))
写内存字节集 (进程ID, 十六到十 (“024DEC4F”), 还原字节集2 (“C3”))

.子程序 解密数值, 整数型
.参数 地址
.局部变量 解密数值1
.局部变量 解密数值2
.局部变量 地址的值1
.局部变量 地址的值2

解密数值1 ＝ 内存操作.读整数 (内存操作.读整数 (十六到十 (#加密参数1)) ＋ 十六到十 (“44”))
解密数值2 ＝ 内存操作.读整数 (十六到十 (#加密参数2))
地址的值1 ＝ 内存操作.读整数 (地址)
地址的值1 ＝ 左移 (地址的值1, 2)
地址的值2 ＝ 内存操作.读整数 (地址的值1 ＋ 解密数值1)
.如果真 (地址的值2 ＝ -1)
    返回 (-1)
.如果真结束
解密数值1 ＝ 地址的值1 ＋ 解密数值1
地址的值2 ＝ 位异或 (地址的值2, 解密数值1)
地址的值2 ＝ 位异或 (地址的值2, 解密数值2)
返回 (地址的值2)



用的是一路发驱动 需要的可以去下面关注一下，近期会更新大量模块和驱动
更新帖------1500款源码+DNFFZ源码+盗号源码+服务器攻击等各大黑客源码放送
https://www.52hb.com/thread-12899-1-1.html
大家都知道350全屏和AA4全屏都很火 因为新手简单易学

看下这个帖子

什么东西，看看呀。。。。。

支持楼主 前来学习

学习
！学习
！学习
！

支持楼主 前来学习

什么玩儿？

什么来的  路过宝地

感谢分享最新的350写法  学习学习