當(dāng)前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

几何基础,多种矩阵的学习,世界坐标到屏幕坐标的两种转换方法,三种绘制方框的原理,hookd3d,hookopengl,骨骼透视,主播的秘密,FPS各种BT功能的原理和检测对抗原理,UE4引擎,U3D

發(fā)布時間：2023/12/20 编程问答 29 豆豆

生活随笔收集整理的這篇文章主要介紹了几何基础,多种矩阵的学习,世界坐标到屏幕坐标的两种转换方法,三种绘制方框的原理,hookd3d,hookopengl,骨骼透视,主播的秘密,FPS各种BT功能的原理和检测对抗原理,UE4引擎,U3D 小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.

為了方便大家可以系統(tǒng)性的學(xué)習(xí) 和了解FPS游戲相關(guān)知識,

導(dǎo)致本帖包含的內(nèi)容比較繁多.如果沒有耐心全部看完的話,也可以直接跳到自己需要的知識點進行學(xué)習(xí)

下面介紹下

本帖主要內(nèi)容包含:

幾何基礎(chǔ),多種矩陣的學(xué)習(xí),世界坐標(biāo)到屏幕坐標(biāo)的兩種轉(zhuǎn)換方法,三種繪制方框的原理,hookd3d,hookopengl,骨骼透視,主播的秘密,FPS各種BT功能的原理和檢測對抗原理,UE4引擎,U3D引擎的逆向和實戰(zhàn) ,

游戲安全的建議策略方針 , 反外掛的思路和檢測對抗等等.

同時公眾號任鳥飛逆向后續(xù)會給大家專門開設(shè)一個FPS安全的版塊,進行檢測對抗的討論.

學(xué)習(xí)這套課程的基礎(chǔ)包含少量的匯編知識和編程知識,一定的數(shù)學(xué)知識和內(nèi)存知識.

基礎(chǔ)建立在任鳥飛逆向前100課的前提下即毫無壓力的學(xué)習(xí).(公眾號有免費抽取贈送基礎(chǔ)課的名額)

當(dāng)然我們要從最簡單的概念開始學(xué)習(xí),請勿急躁

這個課題本著最簡單易懂,從本質(zhì)完全解析的態(tài)度,所以有任何細節(jié)不懂,哪怕是三角函數(shù),都可以找我探討

好,我們正式開始

? ? ? ? ? 向量

可能大家問為什么要學(xué)習(xí)向量, 原因是向量是矩陣的元素,而矩陣是幫助我們快速計算的朋友

所以就算不能完全掌握,了解一下是必要的.

指具有大小和方向的量.

一維向量,例如 1 ? ? 對應(yīng)的就是從0到1的向量,大小是1,方向X正軸方向

我們說向量只有大小和方向, 不存在其他屬性,所以 ?一維向量 1 也可以表示從1到2 從-1到0

向量可以進行算數(shù)運算的.例如 1+1 =2 ? 2個大小是1,方向X正軸方向的向量

相加等于1個大小是2,方向X正軸方向的向量

1*3 = 3 ?給向量放大3倍

二維向量,例如 ?2,3 書寫格式為[2,3]

對應(yīng)的是從原點0,0 到坐標(biāo) 2,3 的向量, 大小就需要計算了

根據(jù)三角函數(shù),大小等于 ? sqrt(2*2+3*3) ,同樣這也是計算二維空間2點的距離公式

(三角函數(shù):直角三角形,斜邊的平方 = ?底邊平方+高平方 , 知道任意2邊可以計算出另外一個邊的長度)

距離 = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));

方向如圖所示,我們下面再講

向量只有大小和方向,同樣二維向量 [2,3] 也可以表示從3,0到5,3 ,可以任意位置開始

二維向量也可以進行算數(shù)運算.

例如 [2,3]+[2,1] = [4,4]

向量的乘法 [2,3]*[3,3] = 6+9= 15 ?向量的內(nèi)積

向量的減法可以把空間2點的絕對坐標(biāo)轉(zhuǎn)化為相對坐標(biāo)

[X1,Y1] - [X2,Y2]= [X1-X2, Y1 - Y2],相當(dāng)于把向量移動到原點

三角函數(shù)角度的問題

在游戲圖像計算中角度是必不可少的部分

例如我們知道了,如下三角形高為3 ?底邊為2

那么tanA = 3/2 ? 我們想求A的角度怎么辦呢? ? ?C++給我們提供API函數(shù)

A = atan(3,2); ?這樣就計算出來 ? A的角度了

不過atan()的返回值是弧度,我們?nèi)绻朕D(zhuǎn)為真正的角度 ?還是需要轉(zhuǎn)換的

什么是弧度呢?你可以簡單的理解為 ?正常角度如果是0-180的話 ?弧度就是 0- π

那么 atan(3,2) *180 / π ? 就把弧度轉(zhuǎn)換成角度了

最終

A = atan(3,2)*180 / π;

另外一種情況,

知道了角度,想求邊長

例如一個向量[?,5] 角度是東偏北 60度

我們怎么計算向量值呢?

很簡單,

tan 60 = 5/底邊

底邊 = 5/ tan60,當(dāng)然這里的角度參數(shù)也是弧度 ?,如果你的是真實角度,我們又要把角度轉(zhuǎn)換成弧度

最終

底邊 = 5 / ?tan (60*π/180) ;

其他的 sin ? cos ?也是同理,我們不是學(xué)習(xí)數(shù)學(xué),所以暫時了解即可,后面用到再說.

三維向量??

例如 2,1,3 ? 格式[2,1,3]

向量寫成行或則列都可以

行向量 ? [2,1,3]

列向量

[ 2

3 ]

三維向量對應(yīng)的是三維空間 2,1,3對應(yīng)的是x,y,z

(注: 三維坐標(biāo)系,很多書本是Y 為高度軸,切記X,Y,Z只是個符號,你可以起名叫a b ?c 也沒問題

調(diào)轉(zhuǎn)一下坐標(biāo)系X,就變成了Y ,所以沒有區(qū)別,不要死記名字,按照自己習(xí)慣來)

[2,1,3]就是從原點到坐標(biāo)2,1,3的向量

大小計算就更加復(fù)雜一點了

先看懂下圖的輔助線

根據(jù)三角函數(shù),向量的大小等于 ? sqrt(1*1+2*2+3*3) ,同樣這也是計算三維空間2點的距離公式

距離 = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)+(z1-z2)*(z1-z2));

而方向不再單純是一個角度了,他包含水平角度和高低角度,這個我們后面再講

向量的減法可以把三維空間2點的絕對坐標(biāo)轉(zhuǎn)化為相對坐標(biāo)

[X1,Y1,Z1] - [X2,Y2,Z2]= [X1-X2, Y1 - Y2,Z1-Z2],相當(dāng)于把向量移動到原點

同樣三維向量也可以進行加法 ?乘法等運算

例如[x1,y1,z1] * [1,2,3] ?= x1+y1*2+z1*3 ? 向量的內(nèi)積

到這里是不是對幾何和線性代數(shù)的基礎(chǔ)知識不再陌生了,其實就這點東西,很簡單.

? ? ? ? ? 矩陣

為什么要學(xué)習(xí)矩陣,對于我們研究的課題來說,就是為了方便計算以及精準(zhǔn)計算的,當(dāng)然你可以不用.

多個向量組合成一個矩陣

矩陣可以看做一個特殊的向量，而向量也可以看做一個特殊的矩陣。

只有一行的矩陣 ? 為行向量 ?行矩陣

只有一列的矩陣 ? 為列向量 ? 列矩陣

格式為 ?行*列

例如 3*3 矩陣:

1 ? 2 ?3

5 ? 7 ?1

2 ? 2 ?1

例如 3*4 矩陣

1 ? 2 ?3 ? 5

5 ? 7 ?1 ? 1

2 ? 2 ?1 ? 2

同形矩陣 ?可以相加減(畢竟如果不是同型的話,沒有辦法對應(yīng)相加減 ?這很好理解)

稍微有點難度的是矩陣相乘除

那么大家要注意的是:

1.矩陣是多個向量的組合,矩陣的乘除就是向量的乘除,而不是單獨元素的乘除

2.兩個矩陣相乘,用第一個矩陣的行乘第二個矩陣的列的方式計算

由于使用方法的區(qū)別 ? ?A*B ?!= ? B*A ? 而且 A* 不同的矩陣 ?結(jié)果可能相同

3.計算結(jié)果的存放

例如 2個2*2 矩陣相乘

第一行*第一列放到 ?第一行第一列

第一行*第二列 ?放到 ?第一行第二列

第二行*第一列 ?放到 ?第二行第一列

第二行*第二列 ?放到 ?第二行第二列

a1 ? a2 ? ? ? ? ? 乘 ? ? ? b1 ? ?b2 ? ? ? ? = ? ?a1*b1 + a2*b3 ? ? ? ? ? ?a1*b2 + a2*b4

a3 ? a4 ? ? ? ? ? ? ? ? ? ? b3 ? ? b4 ? ? ? ? ? ? ? a3*b1 +a4*b3 ? ? ? ? ? ? a3*b2 + a4*b4

m*n 矩陣 ?和 i*j 矩陣 ?由于是行 *列 ?所以

m*n 矩陣一行的元素 ?要和 ?i*j 矩陣一列的元素 ? 必須相同

也就是 ?n ?== i

主要滿足這個條件就可以相乘 ?否則不可以

矩陣特性

矩陣對于我們來說就是為了方便計算而生,并不是無可取代

舉個例子

只有對角線為1 ?其他都是0的矩陣 ? ?單位矩陣

1 ? 0 ? 0 ? ? 0

0 ? ?1 ? 0 ? ?0

0 ? ?0 ? 1 ? ?0

0 ? ?0 ? 0 ? ?1

任何矩陣乘以 ?單位矩陣都為原來矩陣把 1換成2 ? 就是 ?放大2倍

比你一個元素一個元素的*2方便很多吧?

矩陣取一列

1 ? 0 ? 0 ? ? X ? ? ? ? ?乘 ? ? 0 ? ? ?= ? ? X ? ? ? 取X ?Y ? Z ?向量

0 ? ?1 ? 0 ? ?Y ? ? ? ? ? ? ? ? ? 0 ? ? ? ? ? ? Y

0 ? ?0 ? 1 ? ?Z ? ? ? ? ? ? ? ? ? 0 ? ? ? ? ? ? Z

0 ? ?0 ? 0 ? ?1 ? ? ? ? ? ? ? ? ? 1 ? ? ? ? ? ? 1

單獨放大某個元素

X ? 0 ? 0 ? ? 0 ? ? ? ? ?乘 ? ? 0 ? ? ?= ? ?0 ? ? ? ? Z 擴大10倍

0 ? ?Y ? 0 ? ?0 ? ? ? ? ? ? ? ? ? 0 ? ? ? ? ? ?0

0 ? ?0 ? Z ? ?0 ? ? ? ? ? ? ? ? ? 10 ? ? ? ? 10Z

0 ? ?0 ? 0 ? ?1 ? ? ? ? ? ? ? ? ? 1 ? ? ? ? ? ?1

矩陣的乘法可以實現(xiàn)很多的功能

看起來是不是很方便,很強大?!

? ? ? ? ? 不借助矩陣把游戲坐標(biāo)轉(zhuǎn)換成屏幕坐標(biāo)

無論是在窗口上繪制窗體,還是畫各種方框,最核心的功能就是在于如何把游戲坐標(biāo)也就是世界坐標(biāo)轉(zhuǎn)換成屏幕坐標(biāo).

這里我們先不借助于強大好用的矩陣,單純用幾何算法轉(zhuǎn)換一下坐標(biāo)

圖看起來有點亂,我們慢慢來

這是游戲上方俯視的平面圖:

1.水平可視角度一般為90度, 也就是FOV 或則第一人稱視角

但是這個值只是約值,可能不精準(zhǔn)也是導(dǎo)致后面不精準(zhǔn)的原因之一

2.我們準(zhǔn)星一直在屏幕正中心的,所以向前做一個垂線,左右各45度

3.我們把三角形補全,等腰三角形的斜邊就是我們的可視范圍,任何游戲中的物品敵人和我們的連線只有和這個斜邊有交單才會顯示到我們的屏幕中

如圖中敵人和我們連線焦點就是紅色圓圈

4.角度A 可以根據(jù)具體朝向值簡單分析出來,后面數(shù)據(jù)分析的時候再說

5.紅色圓圈在 AB 這條線上的位置

就是敵人在我們屏幕X坐標(biāo)的等比例位置

所以這樣就可以計算出來屏幕坐標(biāo)X了

tanA = ?X差/ (AB/2);

那么 ?X差 = tanA*(AB/2);

X差/(AB/2) = ?屏幕坐標(biāo)差/ (分辨率_寬度/2)

繼續(xù)替換

tanA = 屏幕坐標(biāo)差/ (分辨率_寬度/2)

角度還要轉(zhuǎn)換一下成弧度

最終

屏幕坐標(biāo)差 = ?tan(A*π/180) ?*(分辨率_寬度/2);

屏幕坐標(biāo) = ?屏幕坐標(biāo)差 + 分辨率_寬度/2;

int 水平差 = (int)(tan(水平角度差 * 3.1416 / 180) * ((m_分辨率寬) / 2));

屏幕坐標(biāo).x = (float)(m_分辨率寬 / 2 + 水平差);

屏幕坐標(biāo).y 也是同樣的計算方法,不過屏幕寬高是不相同的,所以可視角也是有區(qū)別的

屏幕分辨率_高/屏幕分辨率_寬 = 高低可視角度 / 水平可視角度

int 高度差 = (int)(tan(高低角度差 * 3.1416 / 180) * ((m_分辨率寬) / 2));// 這里也是m_分辨率寬

因為可視角度不是45了,而是分辨率計算出來的角度

屏幕坐標(biāo).y = (float)(m_分辨率高 / 2 + 高度差);

最終代碼如下:

bool 繪制::世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)_非矩陣(坐標(biāo)結(jié)構(gòu)_2& 屏幕坐標(biāo), FLOAT 水平角度差, FLOAT 高低角度差){ 取窗口信息(); FLOAT 高低可視角度 = (FLOAT)((double)atan2(m_分辨率高, m_分辨率寬)*180/3.1415); if (fabs(水平角度差) > 45 || fabs(高低角度差) > 高低可視角度) { return false;// 不在屏幕范圍內(nèi) } int 水平差 = (int)(tan(水平角度差 * 3.1416 / 180) * ((m_分辨率寬) / 2)); 屏幕坐標(biāo).x = (float)(m_分辨率寬 / 2 + 水平差); int 高度差 = (int)(tan(高低角度差 * 3.1416 / 180) * ((m_分辨率寬) / 2)); 屏幕坐標(biāo).y = (float)(m_分辨率高 / 2 + 高度差); return true;}

但是我們發(fā)現(xiàn)這樣計算出來的畫框是不精準(zhǔn)的

主要2個原因一個是角度是約值,一個是計算過程中數(shù)值的溢出,盡量使用double 可以減少

也可以通過微調(diào)度數(shù)等等的方式把他修正比較準(zhǔn)確

? ? ? ? ? 數(shù)據(jù)部分

本文章中均以單機游戲為例,每一種功能僅提供給網(wǎng)絡(luò)安全工作者反外掛建議和安全對抗方法.請勿用作非法用途

另外提示對于此類游戲安全和反外掛研究,單機和網(wǎng)絡(luò)游戲的原理毫無區(qū)別,區(qū)別僅僅在于個別數(shù)據(jù)網(wǎng)絡(luò)驗證部分,如果想研討網(wǎng)絡(luò)游的安全防護,可觀看視頻版,以及公眾號任鳥飛逆向探討.

先整理cs1.6數(shù)據(jù)如下:

(屬于基礎(chǔ)范疇,任鳥飛逆向前100課即可輕松搞定這里不贅述)

矩陣地址 ?hl.exe+1820100//這個暫時先不要管,下文會有詳細講解的地方

高低朝向值 hl.exe+19E10C4 //從低到高 ?89 ?到 ?-89

水平朝向值 hl.exe+19E10C8 // ?逆時針從 0 到 360

朝向值找到以后我們發(fā)現(xiàn)水平轉(zhuǎn)一圈 ?是0-360的變化規(guī)律

其中朝向算法需要我們詳細分析一下

方法很簡單,

把朝向?qū)懭? ?然后W走路看看坐標(biāo)的變化規(guī)律發(fā)現(xiàn)是X增加其他不變,那么0對應(yīng)X正軸

把朝向?qū)懭?0 ?然后W走路看看坐標(biāo)的變化規(guī)律發(fā)現(xiàn)是Y增加其他不變,那么0對應(yīng)Y正軸

把朝向?qū)懭?80 ?然后W走路看看坐標(biāo)的變化規(guī)律發(fā)現(xiàn)是X減少其他不變,那么0對應(yīng)X負軸

把朝向?qū)懭?70 ?然后W走路看看坐標(biāo)的變化規(guī)律發(fā)現(xiàn)是Y減少其他不變,那么0對應(yīng)Y負軸

最終得到結(jié)果

也就是我們不同朝向的值

人物X坐標(biāo):hl.exe+195fe58

人物Y坐標(biāo):hl.exe+195fe5C

人物Z坐標(biāo):hl.exe+195fe60

周圍數(shù)組

數(shù)組最大數(shù)量1F ?以下n 通用 ?0為自己

hl.exe+1B5A5C4+24C*n+0???????等于0 ?數(shù)組結(jié)束

hl.exe+1B5A5C4+24C*n+190 ?DWORD ?==0 ?跳過有可能數(shù)組不是順序存放

對象X坐標(biāo)?hl.exe+1B5A5C4+24C*n+18C??

對象Y坐標(biāo) hl.exe+1B5A5C4+24C*n+18C

對象Z坐標(biāo) hl.exe+1B5A5C4+24C*n+190

1為土匪???2為警察 hl.exe+62565C+n*68+4E????

血量 hl.exe+62565C+n*68+68

死亡標(biāo)志位 hl.exe+62565C+n*68+60

得到的結(jié)果就可以提供給我們封裝數(shù)據(jù)所用了,這已經(jīng)足夠了

? ? ? ? ? FPS類型的游戲安全性和反外掛

說到這,

我們來聊聊為什么FPS類型的游戲安全性及不高和 ?反外掛

主要的2個原因

第一設(shè)計簡單,數(shù)據(jù)少,通過上面的需要數(shù)據(jù)就已經(jīng)知道了,真的很少

第二個原因是特性導(dǎo)致,透視和自瞄等功能都是服務(wù)器無法驗證的本地操作

所以加大了反外掛的難度.

那么其實針對于FPS的外掛特征,反外掛可以做的事情也是不少的

第一,加大對周圍數(shù)據(jù)的保護,尤其獲取范圍,不要在極大范圍就像玩家投遞全地圖數(shù)據(jù)

第二,對hookd3d的檢測應(yīng)該是比較容易的

第三,對繪制函數(shù)的檢測,當(dāng)然如果是窗口的覆蓋窗口那是存在一定檢測難度的

第四,自瞄準(zhǔn)星的數(shù)據(jù)寫入檢測

第五,鼠標(biāo)準(zhǔn)星移動軌跡的檢測

第六,不定時截圖上傳

等等.

這些我們后面再詳細探討,現(xiàn)在還沒有了解所有實現(xiàn)過程, 所以無法透徹的談 ?反外掛

? ? ? ? ? 數(shù)據(jù)封裝

按照正常的數(shù)據(jù)封裝方法,

封裝代碼如下,因為這里我都使用了中文命名

相信大家都可以看懂了,如果有什么不懂可以 ,可以找我(任鳥飛)探討

struct 坐標(biāo)結(jié)構(gòu)_3{ float x, y, z;}; struct 朝向結(jié)構(gòu)_2{ float 水平朝向; float 高低朝向;}; struct 對象結(jié)構(gòu){ float X_j; float Y_j; float Z_j; float X_H; float Y_H; float Z_H; int Hp; BYTE 死亡標(biāo)志位; BYTE 陣營; 朝向結(jié)構(gòu)_2 角度_j; 朝向結(jié)構(gòu)_2 角度_H; 朝向結(jié)構(gòu)_2 角度差_j; 朝向結(jié)構(gòu)_2 角度差_H;}; class 周圍對象{public: 對象結(jié)構(gòu) 對象列表[0x100]; DWORD 對象數(shù)量;public: void 刷新周圍數(shù)據(jù)_Cs();private: void 計算朝向_Cs(坐標(biāo)結(jié)構(gòu)_3 目標(biāo), 朝向結(jié)構(gòu)_2& 角度, 朝向結(jié)構(gòu)_2& 角度差);};

DWORD Cs_周圍基地址 = (DWORD)GetModuleHandleA("hl.exe") + 0x1B5A5C4;DWORD Cs_周圍基地址2 = (DWORD)GetModuleHandleA("hl.exe") + 0x62565C;void 周圍對象::刷新周圍數(shù)據(jù)_Cs(){ 對象數(shù)量 = 0; for (int i = 1; i < 0x20; i++)// 第一個位置空出來 { if (*(DWORD*)(Cs_周圍基地址 + 0x24C * i + 0) == 0)// 直接結(jié)束 { break; } if (*(DWORD*)(Cs_周圍基地址 + 0x24C * i + 0x190) == 0)// 碰到空坐標(biāo)對象跳過 { continue; } // 哪里不懂可以加我2217777779 探討對象列表[對象數(shù)量].X_j = *(FLOAT*)(Cs_周圍基地址 + 0x24C * i + 0x188); 對象列表[對象數(shù)量].Y_j = *(FLOAT*)(Cs_周圍基地址 + 0x24C * i + 0x18C); 對象列表[對象數(shù)量].Z_j = *(FLOAT*)(Cs_周圍基地址 + 0x24C * i + 0x190) - 40; 對象列表[對象數(shù)量].X_H = *(FLOAT*)(Cs_周圍基地址 + 0x24C * i + 0x188); 對象列表[對象數(shù)量].Y_H = *(FLOAT*)(Cs_周圍基地址 + 0x24C * i + 0x18C); 對象列表[對象數(shù)量].Z_H = *(FLOAT*)(Cs_周圍基地址 + 0x24C * i + 0x190) + 23; 對象列表[對象數(shù)量].陣營 = *(BYTE*)(Cs_周圍基地址2 + 0x68 * i + 0x4E); 對象列表[對象數(shù)量].Hp = *(DWORD*)(Cs_周圍基地址2 + 0x68 * i + 0x68); 對象列表[對象數(shù)量].死亡標(biāo)志位 = (BYTE)*(DWORD*)(Cs_周圍基地址2 + 0x68 * i + 0x60); 坐標(biāo)結(jié)構(gòu)_3 目標(biāo); 朝向結(jié)構(gòu)_2 角度; 朝向結(jié)構(gòu)_2 角度差; 目標(biāo).x = 對象列表[對象數(shù)量].X_j; 目標(biāo).y = 對象列表[對象數(shù)量].Y_j; 目標(biāo).z = 對象列表[對象數(shù)量].Z_j; 計算朝向_Cs(目標(biāo), 角度, 角度差); 對象列表[對象數(shù)量].角度_j = 角度; 對象列表[對象數(shù)量].角度差_j = 角度差; 目標(biāo).x = 對象列表[對象數(shù)量].X_H; 目標(biāo).y = 對象列表[對象數(shù)量].Y_H; 目標(biāo).z = 對象列表[對象數(shù)量].Z_H; 計算朝向_Cs(目標(biāo), 角度, 角度差); 對象列表[對象數(shù)量].角度_H = 角度; 對象列表[對象數(shù)量].角度差_H = 角度差; 對象數(shù)量 += 1; }}

朝向值 ?和角度差的計算過程,根據(jù)上面已經(jīng)得到的朝向數(shù)據(jù)

我們編寫如下代碼,為了讓理解更簡單 ?這里我分成了4個象限來講解

如果還是不能完全理解的話,建議翻看我們之前的 ?關(guān)于朝向的課程,當(dāng)然朝向有很多種這里屬于最簡單的一種

大家可能問算出來的角度差是干什么用的,還記得上篇文章,不用矩陣轉(zhuǎn)換屏幕坐標(biāo)嗎,里面我們是需要用到這個角度差的

void 周圍對象::計算朝向_Cs(坐標(biāo)結(jié)構(gòu)_3 目標(biāo), 朝向結(jié)構(gòu)_2& 角度, 朝向結(jié)構(gòu)_2& 角度差){ FLOAT FOV_x = *(FLOAT*)((DWORD)GetModuleHandleA("hl.exe") + 0x195fe58); FLOAT FOV_y = *(FLOAT*)((DWORD)GetModuleHandleA("hl.exe") + 0x195fe5C); FLOAT FOV_z = *(FLOAT*)((DWORD)GetModuleHandleA("hl.exe") + 0x195fe60); FLOAT 水平朝向 = *(FLOAT*)((DWORD)GetModuleHandleA("hl.exe") + 0x19E10C8); FLOAT 高低朝向 = *(FLOAT*)((DWORD)GetModuleHandleA("hl.exe") + 0x19E10C4); if (目標(biāo).x > FOV_x && 目標(biāo).y >= FOV_y)//第一象限 { 角度.水平朝向 = (FLOAT)((double)atan2(目標(biāo).y - FOV_y, 目標(biāo).x - FOV_x) * 180 / 3.1415); } if (目標(biāo).x <= FOV_x && 目標(biāo).y > FOV_y)//第二象限 { 角度.水平朝向 = 180 - (FLOAT)((double)atan2(目標(biāo).y - FOV_y, FOV_x - 目標(biāo).x) * 180 / 3.1415); } if (目標(biāo).x < FOV_x && 目標(biāo).y <= FOV_y)//第三象限 { 角度.水平朝向 = 180 + (FLOAT)((double)atan2(FOV_y - 目標(biāo).y, FOV_x - 目標(biāo).x) * 180 / 3.1415); } if (目標(biāo).x >= FOV_x && 目標(biāo).y < FOV_y)//第四象限 { 角度.水平朝向 = 360 - (FLOAT)((double)atan2(FOV_y - 目標(biāo).y, 目標(biāo).x - FOV_x) * 180 / 3.1415); } FLOAT 平面距離 = sqrt((目標(biāo).x - FOV_x) * (目標(biāo).x - FOV_x) + (FOV_y - 目標(biāo).y) * (FOV_y - 目標(biāo).y)); if (目標(biāo).z > FOV_z)//上方 { 角度.高低朝向 = (FLOAT)(-(double)atan2(目標(biāo).z - FOV_z, 平面距離) * 180 / 3.1415); } if (目標(biāo).z < FOV_z)//下方 { 角度.高低朝向 = (FLOAT)((double)atan2(FOV_z - 目標(biāo).z, 平面距離) * 180 / 3.1415); } 角度差.水平朝向 = 水平朝向 - 角度.水平朝向; if (角度差.水平朝向 <= -180)//跨0軸的兩種情況 { 角度差.水平朝向 += 360; } if (角度差.水平朝向 >= 180) { 角度差.水平朝向 -= 360; } 角度差.高低朝向 = 角度.高低朝向 - 高低朝向;}

? ? ? ? ? 繪制類

萬事俱備,我們來寫個繪制類

數(shù)據(jù)全部完畢我們開始寫代碼繪制了,這部分是固定的代碼,很簡單

完全中文編程,代碼已經(jīng)很清晰了

大家跟著我敲寫一遍即可

當(dāng)然第一種是最粗糙的, 由奢入簡易 ?由儉入奢易難我們先來粗糙的

struct 坐標(biāo)結(jié)構(gòu)_2{ float x, y;};struct 坐標(biāo)結(jié)構(gòu)_3{ float x, y, z;};struct 坐標(biāo)結(jié)構(gòu)_4{ float x, y, z, w;}; class 繪制{public: HWND m_窗口句柄; RECT m_窗口; int m_分辨率寬; int m_分辨率高; RECT m_外窗口; int m_外窗口寬; int m_外窗口高; float m_矩陣[16]; DWORD m_矩陣地址; public: 繪制(HWND 窗口句柄, DWORD 矩陣地址); 繪制() { }private: void 取窗口信息();public: void 繪制矩形(HDC HDC句柄, HBRUSH 畫刷句柄, int x, int y, int w, int h); void 畫框(HDC HDC句柄, HBRUSH 畫刷句柄, int x, int y, int w, int h, int 厚度); void 畫線(HDC HDC句柄, int X, int Y);//Q2217777779探討 void 繪制字符串(HDC HDC句柄, int x, int y, COLORREF color, const char* text); //還沒講矩陣?yán)L制這個函數(shù)請忽略 //bool 世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(坐標(biāo)結(jié)構(gòu)_3 游戲坐標(biāo), 坐標(biāo)結(jié)構(gòu)_2& 屏幕坐標(biāo)); bool 世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)_非矩陣(坐標(biāo)結(jié)構(gòu)_2& 屏幕坐標(biāo), FLOAT 水平角度差, FLOAT 高低角度差);//傳遞真實角度};

繪制::繪制(HWND 窗口句柄, DWORD 矩陣地址){ m_窗口句柄 = 窗口句柄; m_矩陣地址 = 矩陣地址; memcpy(&m_矩陣, (PBYTE*)(m_矩陣地址), sizeof(m_矩陣)); 取窗口信息();} void 繪制::取窗口信息(){ GetClientRect(m_窗口句柄, &m_窗口); m_分辨率寬 = m_窗口.right - m_窗口.left; m_分辨率高 = m_窗口.bottom - m_窗口.top; GetWindowRect(m_窗口句柄, &m_外窗口); //含有邊框及全屏幕坐標(biāo) m_外窗口寬 = m_外窗口.right - m_外窗口.left; m_外窗口高 = m_外窗口.bottom - m_外窗口.top;} void 繪制::繪制矩形(HDC HDC句柄, HBRUSH 畫刷句柄, int x, int y, int w, int h){ RECT 矩形 = { x,y,x + w,y + h }; FillRect(HDC句柄, &矩形, 畫刷句柄);//繪制矩形} void 繪制::畫框(HDC HDC句柄, HBRUSH 畫刷句柄, int x, int y, int w, int h, int 厚度){ 繪制矩形(HDC句柄, 畫刷句柄, x, y, w, 厚度);//頂邊繪制矩形(HDC句柄, 畫刷句柄, x, y + 厚度, 厚度, h - 厚度);//左邊繪制矩形(HDC句柄, 畫刷句柄, (x + w) - 厚度, y + 厚度, 厚度, h - 厚度);//右邊繪制矩形(HDC句柄, 畫刷句柄, x + 厚度, y + h - 厚度, w - 厚度 * 2, 厚度);//底邊} void 繪制::畫線(HDC HDC句柄, int X, int Y){ 取窗口信息(); MoveToEx(HDC句柄, m_分辨率寬 / 2, m_分辨率高, NULL); LineTo(HDC句柄, X, Y);} HFONT 字體屬性;void 繪制::繪制字符串(HDC HDC句柄, int x, int y, COLORREF color, const char* text){ SetTextAlign(HDC句柄, TA_CENTER | TA_NOUPDATECP); SetBkColor(HDC句柄, RGB(0, 0, 0)); SetBkMode(HDC句柄, TRANSPARENT); SetTextColor(HDC句柄, color); SelectObject(HDC句柄, 字體屬性); TextOutA(HDC句柄, x, y, text, strlen(text)); DeleteObject(字體屬性);}//還沒講矩陣?yán)L制這個函數(shù)請忽略/*bool 繪制::世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(坐標(biāo)結(jié)構(gòu)_3 游戲坐標(biāo), 坐標(biāo)結(jié)構(gòu)_2& 屏幕坐標(biāo)){ 取窗口信息(); memcpy(&m_矩陣, (PBYTE*)(m_矩陣地址), sizeof(m_矩陣)); 坐標(biāo)結(jié)構(gòu)_4 裁剪坐標(biāo); 裁剪坐標(biāo).x = 游戲坐標(biāo).x * m_矩陣[0] + 游戲坐標(biāo).y * m_矩陣[4] + 游戲坐標(biāo).z * m_矩陣[8] + m_矩陣[12]; 裁剪坐標(biāo).y = 游戲坐標(biāo).x * m_矩陣[1] + 游戲坐標(biāo).y * m_矩陣[5] + 游戲坐標(biāo).z * m_矩陣[9] + m_矩陣[13]; 裁剪坐標(biāo).z = 游戲坐標(biāo).x * m_矩陣[2] + 游戲坐標(biāo).y * m_矩陣[6] + 游戲坐標(biāo).z * m_矩陣[10] + m_矩陣[14]; 裁剪坐標(biāo).w = 游戲坐標(biāo).x * m_矩陣[3] + 游戲坐標(biāo).y * m_矩陣[7] + 游戲坐標(biāo).z * m_矩陣[11] + m_矩陣[15]; if (裁剪坐標(biāo).w < 0.0f) return false; 坐標(biāo)結(jié)構(gòu)_3 NDC; NDC.x = 裁剪坐標(biāo).x / 裁剪坐標(biāo).w; NDC.y = 裁剪坐標(biāo).y / 裁剪坐標(biāo).w; NDC.z = 裁剪坐標(biāo).z / 裁剪坐標(biāo).w; 屏幕坐標(biāo).x = (m_分辨率寬 / 2 * NDC.x) + m_分辨率寬 / 2; 屏幕坐標(biāo).y = -(m_分辨率高 / 2 * NDC.y) + m_分辨率高 / 2; return true;}*/ bool 繪制::世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)_非矩陣(坐標(biāo)結(jié)構(gòu)_2& 屏幕坐標(biāo), FLOAT 水平角度差, FLOAT 高低角度差){ 取窗口信息(); FLOAT 高低可視角度 = (FLOAT)((double)atan2(m_分辨率高, m_分辨率寬)*180/3.1415); if (fabs(水平角度差) > 45 || fabs(高低角度差) > 高低可視角度) { return false;// 不在屏幕范圍內(nèi) int 水平差 = (int)(tan(水平角度差 * 3.1416 / 180) * ((m_分辨率寬) / 2)); 屏幕坐標(biāo).x = (float)(m_分辨率寬 / 2 + 水平差); // 哪里不懂可以v hdlw312 int 高度差 = (int)(tan(高低角度差 * 3.1416 / 180) * ((m_分辨率寬) / 2)); 屏幕坐標(biāo).y = (float)(m_分辨率高 / 2 + 高度差); return true;}

到這里 ?非矩陣?yán)L制的所有準(zhǔn)備工作都已經(jīng)完畢了 ? ?,就看你要怎么調(diào)用了

? ? ? ? ? 非矩陣?yán)L制方框

編寫循環(huán)繪制代碼

通過上面的編寫我們終于可以調(diào)用觀看效果了

if (GetKeyState(VK_F2) & 1)

這里面學(xué)習(xí)一個快捷鍵指令 GetKeyState

每次按下切換他的狀態(tài) ? 大于0 或則小于0

從而可以實現(xiàn)開關(guān)的功能

微調(diào)

發(fā)現(xiàn)效果是有了,但是并不精準(zhǔn)

優(yōu)點是:不需要矩陣 ,完全的數(shù)學(xué)公式可以計算出來,而且公式是固定的,

缺點:

但是不精準(zhǔn)

有可視角的關(guān)系,運算的誤差等等導(dǎo)致的,算出來的誤差雖然不是特別大

而且也可以通過調(diào)整的方式讓其精確,但是不夠完美.

我們可以選擇微調(diào)可視角度,微調(diào)屏幕X,Y坐標(biāo)等等方式來處理

反正這種方法想要完全的精密是不太可能的

但是達到基本效果是沒問題的,雖然達到精密沒有那么的重要,但是完美主義者

是一定會使用矩陣來計算的

那么我們繼續(xù)學(xué)習(xí)矩陣,用矩陣的方式 ?繪制方框

? ? ? ? ? 繪制的幾種方法和反外掛建議

我們非矩陣的方式繪制是沒有那么的精確的

在學(xué)習(xí)矩陣?yán)L制之前,我們先來了解下繪制的幾種方法

第一種 hook ?d3d/opengl

優(yōu)點:不閃 ,代碼簡單

缺點:非常容易被檢測

第二種窗口上自行繪制,但是會閃

優(yōu)缺點適中

第三種自建透明窗口,覆蓋游戲窗口,透明窗口上繪制

優(yōu)點:穩(wěn)定

確定:代碼復(fù)雜,會閃

反外掛:無非就是針對外掛使用的函數(shù)進行檢測

第四種,分屏透視,一個窗口正常游戲,另外一個窗口顯示透視信息,主播一般用的

不要說很少一部分,我對陪玩代練主播等了解較多,大部分都是這樣.

反外掛思路,同樣是針對實現(xiàn)原理,很輕松的應(yīng)對

只是后2種屬于外部繪制,檢測比較困難

下面我們對幾種方法一一了解

? ? ? ? ? 深入學(xué)習(xí)矩陣 (總結(jié)所有游戲矩陣特點找到矩陣)

對象的世界坐標(biāo)列向量

w(w為了兼容4*4矩陣以及可以NDC坐標(biāo)轉(zhuǎn)化而設(shè)計存在的,大家可以暫且不管)

可以通過被一個游戲矩陣(以后我們就叫他游戲矩陣吧) ?乘 ?從而獲得?剪輯坐標(biāo),也可以叫裁剪坐標(biāo),都是翻譯而來(暫且當(dāng)成屏幕坐標(biāo)也沒問題,因為他到屏幕坐標(biāo)轉(zhuǎn)換及其簡單)

在學(xué)習(xí)這個矩陣之前呢我們先來了解

行主序和列主序

行主序就是拿4*4矩陣的行來* 后面的矩陣,我們前面的例子 ?都是這樣

a1 ?a2 ?a3 ?a4 ? ? ?* ? ? x ? ?= ? ?a1 *x+ a2*y+ a3*z + a4*w

b1 ?b2 ?b3 ? b4 ? ? ? ? ? ?y ? ? ? ? ?b1 *x+ b2*y+ b3*z + b4*w

c1 ? c2 ? c3 ? c4 ? ? ? ? ? z ? ? ? ? ?c1 *x+ c2*y+ c3*z + c4*w

d1 ?d2 ? d3 ? d4 ? ? ? ? ? ?w ? ? ? ?d1 *x+ d2*y+ d3*z + d4*w

而列主序就是拿4*4 矩陣的列來* 后面的矩陣,這個前面沒有出現(xiàn)過

a1 ?b1 ?c1 ?d1 ? ? * ? ? x ? ?= ? ?a1 *x+ a2*y+ a3*z + a4*w

a2 ?b2 ?c2 ? d2 ? ? ? ? ? y ? ? ? ? ?b1 *x+ b2*y+ b3*z + b4*w

a3 ? b3 ?c3 ?d3 ? ? ? ? ? z ? ? ? ? ?c1 *x+ c2*y+ c3*z + c4*w

a4 ?b4 ?c4 ? d4 ? ? ? ? ? ?w ? ? ? ?d1 *x+ d2*y+ d3*z + d4*w

那么我們現(xiàn)在了解下這個游戲矩陣都能對我們干嘛,給他拆分成幾個功能

最后他是這幾個功能的結(jié)合體而已

縮放位移矩陣

如果是行主序矩陣的話就是

(1不是固定的 ?應(yīng)該寫成Tw ? )

如果是列主序矩陣的話就是

Sx ?0 ? ?0 ? ?0

0 ? ?Sy ?0 ? ?0

0 ? ?0 ? ?Sz ?0

Tx ?Ty ?Tz ? Tw

乘

等于

x*Sx+w*Tx

y*Sy+w*Ty

z*Sz+w*Tz

w*Tw

對矩陣 ? x ?y ?z ?w ?進行了 ?縮放和位移

所以我們在這里知道 ? 矩陣移動影響的主要是

Tx ?Ty ?Tz ?Tw

結(jié)論一: 我們在走路做位移的情況下,行主序最后一列 ?列主序最后一行 Tx ?Ty ?Tz ?Tw 會改變

當(dāng)然不一定只有走路的時候會變

原因很簡單,這個矩陣是各種操作的結(jié)合體

如以下例子:

? ?

只改變Y的情況下

只改變X的情況下

只改變Z的情況下

XYZ混合改變的情況下

? ?

旋轉(zhuǎn)矩陣

簡單證明下結(jié)論

假設(shè)旋轉(zhuǎn)45度

用極限驗證法,驗證結(jié)果正確

圍繞Z軸轉(zhuǎn)動

結(jié)論二:只轉(zhuǎn)動水平朝向的時候 ?行主序第三列不變 ,列主序第三行不變化

列主序如下

圍繞X 軸轉(zhuǎn)動

結(jié)論三:只轉(zhuǎn)動高低朝向的時候 ?行主序第一行不變 ,列主序第一列不變化

列主序如下

圍繞Y 軸轉(zhuǎn)動 ?我們沒有這種情況的時候

開倍鏡

總結(jié)矩陣6條結(jié)論

第一結(jié)論: ? 行主序最后一列 ? 列主序最后一行走路跳的狀態(tài)會改變,不代表別的動作不改變

第二結(jié)論: ? 水平轉(zhuǎn)動的情況 ?行主序第三列不變 ? 列主序的話第三行不變

第三結(jié)論: ? 高低朝向改變的時候 ? 行主序第一行不變 ? 列主序的第一列不變

第四結(jié)論: ? 矩陣第一個值 ?-1 到1 的, 這個絕對嗎 ?不絕對!

第五結(jié)論: ? 行主序第一個行第3個元素是固定的0 ? ?列主序第一列的第三個元素是0 ?不絕對!

第六結(jié)論: ? 我們開倍鏡第一個值 ?會* 相應(yīng)的倍數(shù) ?不絕對!

通過找到的矩陣可以進一步完善結(jié)論

通過以上的規(guī)律 ?CE 搜到如下矩陣地址

矩陣地址

hl.exe+1820100

這個過程文字很啰嗦,只能視頻里見了,無非根據(jù)以上結(jié)論掃描而已

如果這個都掃不到,說明CE基礎(chǔ)薄弱,看看公眾號任鳥飛逆向?qū)W習(xí)下免費CE基礎(chǔ)

? ? ? ? ? 世界坐標(biāo) ->剪輯坐標(biāo)->NDC坐標(biāo)->屏幕坐標(biāo)

那么我們來了解下坐標(biāo)的轉(zhuǎn)換過程

通過以上的矩陣

世界坐標(biāo) ?----> 剪輯坐標(biāo)

矩陣乘法

a0 ? ?a1 ? ? a2 ? ? a 3

a4 ? ?a5 ? ?a6 ? ? a7

a8 ? ? a9 ? ?a10 ? a11

a12 ? a13 ?a14 ? ?a15

得到:

剪輯坐標(biāo) x ?= a0*x +a4*y + a8*z + a12*w

剪輯坐標(biāo) y ?= a1*x +a5*y + a9*z + a13*w

剪輯坐標(biāo) z ?= a2*x +a6*y + a10*z + a14*w

剪輯坐標(biāo) w ?= a3*x +a7*y + a11*z + a15*w

世界坐標(biāo)按照我們之前的矩陣法則轉(zhuǎn)換成了平面的剪輯坐標(biāo)

但是剪輯坐標(biāo)是和分辨率沒有直接關(guān)系的 ,需要我們進一步轉(zhuǎn)換

剪輯坐標(biāo)坐標(biāo)系如下 ?正中心為0,0

剪輯坐標(biāo)---->NDC坐標(biāo)

矩陣的設(shè)計中w 是可以讓剪輯坐標(biāo)范圍到-1和1的 ?也就成了NDC坐標(biāo)

所以NDC坐標(biāo)很好理解,就是 -1到1的平面坐標(biāo)系 ? ? 中心點為0,0

NDC .x = ?剪輯坐標(biāo) x/剪輯坐標(biāo) w

NDC.y ?=剪輯坐標(biāo)y/剪輯坐標(biāo) w

NDC.z ?=剪輯坐標(biāo)z/剪輯坐標(biāo) w

DNC坐標(biāo)---->屏幕坐標(biāo)

有了DNC坐標(biāo)我們可以很容易轉(zhuǎn)換成屏幕坐標(biāo)了

當(dāng)然屏幕坐標(biāo)不止一種形式

我們現(xiàn)在只以CS為例

后面會有其他類型

DNC.x / 1 ? = ?屏幕坐標(biāo)差.x ?/ ? ?分辨率_寬 /2

屏幕坐標(biāo)差.x ? = ?(分辨率_寬 /2) * DNC.x

屏幕坐標(biāo).x ?= ?(分辨率_寬 /2) * DNC.x ? ?+ ?分辨率_寬/2

DNC.y / 1 ? = ?屏幕坐標(biāo)差.y ?/ ? ?分辨率_高 /2

屏幕坐標(biāo)差.y = ? -(分辨率_高 /2)*DNC.y

屏幕坐標(biāo).y= ? -(分辨率_高 /2)*DNC.y + 分辨率_高 /2

? ? ? ? ? 矩陣?yán)L制

最終代碼如下

再用之前的代碼 ? 只把世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)_非矩陣() 改成世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)() ?就可以實現(xiàn)功能了

其實也是我們之前的代碼設(shè)計的比較合理

這樣只要替換一句命令,其他指令完全不影響

bool 繪制::世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(坐標(biāo)結(jié)構(gòu)_3 游戲坐標(biāo), 坐標(biāo)結(jié)構(gòu)_2& 屏幕坐標(biāo)){ 取窗口信息(); memcpy(&m_矩陣, (PBYTE*)(m_矩陣地址), sizeof(m_矩陣)); 坐標(biāo)結(jié)構(gòu)_4 裁剪坐標(biāo); 裁剪坐標(biāo).x = 游戲坐標(biāo).x * m_矩陣[0] + 游戲坐標(biāo).y * m_矩陣[4] + 游戲坐標(biāo).z * m_矩陣[8] + m_矩陣[12]; 裁剪坐標(biāo).y = 游戲坐標(biāo).x * m_矩陣[1] + 游戲坐標(biāo).y * m_矩陣[5] + 游戲坐標(biāo).z * m_矩陣[9] + m_矩陣[13]; 裁剪坐標(biāo).z = 游戲坐標(biāo).x * m_矩陣[2] + 游戲坐標(biāo).y * m_矩陣[6] + 游戲坐標(biāo).z * m_矩陣[10] + m_矩陣[14]; 裁剪坐標(biāo).w = 游戲坐標(biāo).x * m_矩陣[3] + 游戲坐標(biāo).y * m_矩陣[7] + 游戲坐標(biāo).z * m_矩陣[11] + m_矩陣[15]; if (裁剪坐標(biāo).w < 0.0f) return false; 坐標(biāo)結(jié)構(gòu)_3 NDC; NDC.x = 裁剪坐標(biāo).x / 裁剪坐標(biāo).w; NDC.y = 裁剪坐標(biāo).y / 裁剪坐標(biāo).w; NDC.z = 裁剪坐標(biāo).z / 裁剪坐標(biāo).w; 屏幕坐標(biāo).x = (m_分辨率寬 / 2 * NDC.x) + m_分辨率寬 / 2; 屏幕坐標(biāo).y = -(m_分辨率高 / 2 * NDC.y) + m_分辨率高 / 2; return true;}

這次不用微調(diào)就已經(jīng) 精確了吧?

所以證明矩陣確實算的比較準(zhǔn)確而且?guī)臀覀兪〉袅舜罅坑嬎愕臅r間

到這里,你的基礎(chǔ)算過了

迎接后面真正的學(xué)習(xí)吧!

? ? ? ? ? 單機口袋西游和單機突襲進一步熟悉相關(guān)數(shù)據(jù),矩陣,以及繪制

游戲不分類型

RPG也好,回合制也好,FPS也好

其實只是一個操作的區(qū)別而已,本質(zhì)沒有任何區(qū)別

FPS的自瞄相當(dāng)于Rpg的朝向怪物

FPS的繪制相當(dāng)于RPG的計算碰撞體 ?以方便躲避或則自寫尋路等等

所以

看到RPG 這樣意外嗎?

所以要明白本質(zhì)是一樣的,沒有區(qū)別

口袋西游:

用到的數(shù)據(jù)很簡單，跟著2020的課程很容易學(xué)會。

這是一款普通的RPG類游戲，不設(shè)計到射擊相關(guān)的功能，我們只是拿來做畫框繪制練習(xí)。

人物數(shù)據(jù):

[[[單機版基地址]+1C]+28]+3C X

[[[單機版基地址]+1C]+28]+40 Y

[[[單機版基地址]+1C]+28]+44 Z

[[[單機版基地址]+1C]+28]+560 X中心點

[[[單機版基地址]+1C]+28]+564 Y中心店

[[[單機版基地址]+1C]+28]+568 Z中心點

[[[單機版基地址]+1C]+28]+56C X中心點到對頂點的X差

[[[單機版基地址]+1C]+28]+570 Y中心點到對頂點的Y差

[[[單機版基地址]+1C]+28]+574 Z中心點到對頂點的Z差

[[[單機版基地址]+1C]+28]+578 立方體下頂點X坐標(biāo)

[[[單機版基地址]+1C]+28]+57C 立方體下頂點Y坐標(biāo)

[[[單機版基地址]+1C]+28]+580 立方體下頂點Z坐標(biāo)

[[[單機版基地址]+1C]+28]+584 立方體上頂點X坐標(biāo)

[[[單機版基地址]+1C]+28]+588 立方體上頂點Y坐標(biāo)

[[[單機版基地址]+1C]+28]+58C 立方體上頂點Z坐標(biāo)

周圍遍歷

[[[[[單機版基地址]+1C]+8]+20]+5C] ?對象數(shù)量

[[[[[[[單機版基地址]+1C]+8]+20]+58]+N*4]+4]+138 周圍對象血量(未被攻擊過是0)

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+3C 周圍對象X

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+40 周圍對象Z

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+44 周圍對象Y

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+ED 死亡標(biāo)志1為死亡BYTE

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+2C4 X中心點

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+2C8 Z中心店

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+2CC Y中心點

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+2D0 X中心點到對頂點的X差

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+2D4 Y中心點到對頂點的Y差

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+2D8 Z中心點到對頂點的Z差

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+2DC 立方體下頂點X坐標(biāo)

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+2E0 立方體下頂點Y坐標(biāo)

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+2E4 立方體下頂點Z坐標(biāo)

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+2E8 立方體上頂點X坐標(biāo)

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+2EC 立方體上頂點Y坐標(biāo)

[[[[[[[單機版基地址]+1C]+8]+20]+1C]+N*4]+4]+2F0 立方體上頂點Z坐標(biāo)

突襲:

這是一款類似于CS的單機游戲，在設(shè)計上相對于CS更加簡單一些，數(shù)據(jù)也比較簡單，適合新手練習(xí)。

這款游戲也可以聯(lián)網(wǎng)，有一些數(shù)據(jù)需要在聯(lián)網(wǎng)狀態(tài)下才能精確的分析出來，在新課程中也做了詳細的講解。

人物數(shù)據(jù):

[0x00587C0C]+28???X???

[0x00587C0C]+2C??Y

[0x00587C0C]+30???Z

[0x00587C0C]+34???水平朝向順時針遞增360??

[0x00587C0C]+38???豎直朝向-90到90???從下到上

[0x00587C0C]+EC????角色血量

周圍遍歷

00587C18?????玩家數(shù)量

[[00587C10]+n*4]+4???X_head

[[00587C10]+n*4]+8? ?Y_head

[[00587C10]+n*4]+C???Z_head

[[00587C10]+n*4]+28???X???

[[00587C10]+n*4]+2C??Y

[[00587C10]+n*4]+30???Z

[[00587C10]+n*4]+50???身高

[[00587C10]+n*4]+34???水平朝向順時針遞增360??

[[00587C10]+n*4]+38???豎直朝向-90到90???從下到上

[[00587C10]+n*4]+EC????角色血量

在周圍遍歷中我們發(fā)現(xiàn)多了一個頭部坐標(biāo)，這也是其相對于CS設(shè)計的更加完善的地方。

游戲不分類型

RPG也好,回合制也好,FPS也好。

其實只是一個操作的區(qū)別而已,本質(zhì)沒有任何區(qū)別。

FPS的自瞄相當(dāng)于Rpg的朝向怪物。

FPS的繪制相當(dāng)于RPG的計算碰撞體 ?以方便躲避或則自寫尋路等等。

通過已有的數(shù)據(jù)，我們可以實現(xiàn)以下效果。

看到RPG游戲這樣意外嗎?

因為游戲很古老，引擎也很古老，所以能夠得到資源只允許我們做一個3D的立方體模型，

但是不管如何，RPG和FPS的本質(zhì)是一樣的,沒有任何區(qū)別，只是我們研究的角度不同，要達到的效果也不同。

矩陣

下面我們來看看這兩款游戲的矩陣數(shù)據(jù)

口袋西游矩陣 ?[D2E5D0]+E8

突襲矩陣 ? 57AFE0

這都是標(biāo)準(zhǔn)的4*4矩陣，具體的分析方法在上面我們已經(jīng)提到了，下面我們來看看封裝數(shù)據(jù)的過程。

數(shù)據(jù)封裝

DWORD 口袋西游_周圍基地址 = 0xD0DF1C;void 周圍對象::刷新周圍數(shù)據(jù)_口袋西游(){ DWORD Temp = *(DWORD*)(*(DWORD*)(*(DWORD*)(*(DWORD*)口袋西游_周圍基地址 + 0x1C) + 0x8) + 0x20); 對象數(shù)量 = *(DWORD*)(Temp + 0x5C); DWORD 怪物基地址 = *(DWORD*)(Temp + 0x58); for (int i = 0; i < (int)對象數(shù)量; i++) { 對象列表[i].X_j = *(FLOAT*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0x2DC); 對象列表[i].Y_j = *(FLOAT*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0x2E0); 對象列表[i].Z_j = *(FLOAT*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0x2E4); 對象列表[i].X_H = *(FLOAT*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0x2E8); 對象列表[i].Y_H = *(FLOAT*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0x2EC); 對象列表[i].Z_H = *(FLOAT*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0x2F0); 對象列表[i].陣營 = 1; 對象列表[i].Hp = *(DWORD*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0x138); 對象列表[i].死亡標(biāo)志位 = 0; } 對象數(shù)量++; 對象列表[對象數(shù)量-1].X_j = *(FLOAT*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x578); 對象列表[對象數(shù)量-1].Y_j = *(FLOAT*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x57C); 對象列表[對象數(shù)量-1].Z_j = *(FLOAT*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x580); 對象列表[對象數(shù)量-1].X_H = *(FLOAT*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x584); 對象列表[對象數(shù)量-1].Y_H = *(FLOAT*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x588); 對象列表[對象數(shù)量-1].Z_H = *(FLOAT*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x58C); 對象列表[對象數(shù)量-1].陣營 = 2; 對象列表[對象數(shù)量-1].Hp = *(DWORD*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x288); 對象列表[對象數(shù)量-1].死亡標(biāo)志位 = 0;} DWORD 突襲_周圍基地址 = 0x00587C10;void 周圍對象::刷新周圍數(shù)據(jù)_突襲(){ 對象數(shù)量 = *(DWORD*)0x00587C18; DWORD 怪物基地址 = *(DWORD*)突襲_周圍基地址; for (int i = 1; i < (int)對象數(shù)量; i++) { 對象列表[i].X_j = *(FLOAT*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0x28); 對象列表[i].Y_j = *(FLOAT*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0x2C); 對象列表[i].Z_j = *(FLOAT*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0x30); 對象列表[i].X_H = *(FLOAT*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0x4); 對象列表[i].Y_H = *(FLOAT*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0x8); 對象列表[i].Z_H = *(FLOAT*)(*(DWORD*)(怪物基地址 + 0x4 * i) + 0xC); 對象列表[i].陣營 = 2; 對象列表[i].Hp = 100; 對象列表[i].死亡標(biāo)志位 = 0; }}

基本數(shù)據(jù)的封裝，我們單獨來完成，而后面的整體調(diào)用我們也進行了設(shè)計和修改，可以同時支持西游，CS和突襲這3款游戲。

HBRUSH 畫刷句柄;HDC HDC句柄;COLORREF 文本顏色_亮紅 = RGB(255, 0, 0);COLORREF 文本顏色_紅 = RGB(128, 0, 0);COLORREF 文本顏色_黃 = RGB(200, 200, 0);COLORREF 文本顏色_黑 = RGB(0, 0, 0);COLORREF 文本顏色_白 = RGB(255, 255, 255);COLORREF 文本顏色_常用 = RGB(158, 255, 0);坐標(biāo)結(jié)構(gòu)_2 屏幕坐標(biāo)_j;坐標(biāo)結(jié)構(gòu)_2 屏幕坐標(biāo)_H;周圍對象周圍;DWORD 編號 = 0;繪制 FPS_繪制;int mainThread(){ if (FindWindow(L"Valve001", 0) != 0) { 繪制 FPS_繪制_2(FindWindow(L"Valve001", 0), (DWORD)GetModuleHandleA("hl.exe") + 0x1820100); FPS_繪制 = FPS_繪制_2; 編號 = 1; } else if (FindWindow(L"XYElementClient Window", 0) != 0) { 繪制 FPS_繪制_2(FindWindow(L"XYElementClient Window", 0), *(DWORD*)0xD2E5D0 + 0xE8); FPS_繪制 = FPS_繪制_2; 編號 = 2; } else { 繪制 FPS_繪制_2(FindWindow(0, L"AssaultCube"), 0x57AFE0); FPS_繪制 = FPS_繪制_2; 編號 = 3; } while (true) { HDC句柄 = GetDC(FPS_繪制.m_窗口句柄); if (編號 == 1) { 周圍.刷新周圍數(shù)據(jù)_Cs(); } if (編號 == 2) { 周圍.刷新周圍數(shù)據(jù)_口袋西游(); } if (編號 == 3) { 周圍.刷新周圍數(shù)據(jù)_突襲(); } for (int i = 0; i < (int)周圍.對象數(shù)量; i++) { if (周圍.對象列表[i].死亡標(biāo)志位== 1) { continue; } 坐標(biāo)結(jié)構(gòu)_3 坐標(biāo)_j = { 周圍.對象列表[i].X_j ,周圍.對象列表[i].Y_j ,周圍.對象列表[i].Z_j }; if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(坐標(biāo)_j, 屏幕坐標(biāo)_j)) //if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)_非矩陣(屏幕坐標(biāo)_j, 周圍.對象列表[i].角度差_j.水平朝向, 周圍.對象列表[i].角度差_j.高低朝向)) { 坐標(biāo)結(jié)構(gòu)_3 坐標(biāo)_H = { 周圍.對象列表[i].X_H ,周圍.對象列表[i].Y_H ,周圍.對象列表[i].Z_H }; if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(坐標(biāo)_H, 屏幕坐標(biāo)_H)) // if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)_非矩陣(屏幕坐標(biāo)_H, 周圍.對象列表[i].角度差_H.水平朝向, 周圍.對象列表[i].角度差_H.高低朝向)) { if (周圍.對象列表[i].陣營 == 2) { 畫刷句柄 = CreateSolidBrush(文本顏色_常用); } else { 畫刷句柄 = CreateSolidBrush(文本顏色_亮紅); } if (編號 == 1 || 編號 == 3) { float head = 屏幕坐標(biāo)_H.y - 屏幕坐標(biāo)_j.y;// 負數(shù)高度 float width = head / 2; // 負數(shù)寬度 float center = width / -2; // 一半寬度 float extra = head / -6; // 三分之一寬度 FPS_繪制.畫框(HDC句柄, 畫刷句柄, (int)(屏幕坐標(biāo)_j.x + center), (int)屏幕坐標(biāo)_j.y, (int)width, (int)(head - extra), 1); } if (編號 == 2) { 口袋西游模型坐標(biāo)結(jié)構(gòu)_2 屏幕點1, 屏幕點2, 屏幕點3, 屏幕點4, 屏幕點5, 屏幕點6, 屏幕點7, 屏幕點8; //點求的順序不能亂,我就不簡化代碼了坐標(biāo)結(jié)構(gòu)_3 點1 = { 周圍.對象列表[i].X_j ,周圍.對象列表[i].Y_j ,周圍.對象列表[i].Z_j }; 坐標(biāo)結(jié)構(gòu)_3 點2 = { 周圍.對象列表[i].X_H ,周圍.對象列表[i].Y_j ,周圍.對象列表[i].Z_j }; 坐標(biāo)結(jié)構(gòu)_3 點3 = { 周圍.對象列表[i].X_H ,周圍.對象列表[i].Y_H ,周圍.對象列表[i].Z_j }; 坐標(biāo)結(jié)構(gòu)_3 點4 = { 周圍.對象列表[i].X_j ,周圍.對象列表[i].Y_H ,周圍.對象列表[i].Z_j }; 坐標(biāo)結(jié)構(gòu)_3 點5 = { 周圍.對象列表[i].X_j ,周圍.對象列表[i].Y_j ,周圍.對象列表[i].Z_H }; 坐標(biāo)結(jié)構(gòu)_3 點6 = { 周圍.對象列表[i].X_H ,周圍.對象列表[i].Y_j ,周圍.對象列表[i].Z_H }; 坐標(biāo)結(jié)構(gòu)_3 點7 = { 周圍.對象列表[i].X_H ,周圍.對象列表[i].Y_H ,周圍.對象列表[i].Z_H }; 坐標(biāo)結(jié)構(gòu)_3 點8 = { 周圍.對象列表[i].X_j ,周圍.對象列表[i].Y_H ,周圍.對象列表[i].Z_H }; if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(點1, 屏幕點1) == 0) continue; if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(點1, 屏幕點1) == 0) continue; if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(點2, 屏幕點2) == 0) continue; if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(點3, 屏幕點3) == 0) continue; if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(點4, 屏幕點4) == 0) continue; if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(點5, 屏幕點5) == 0) continue; if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(點6, 屏幕點6) == 0) continue; if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(點7, 屏幕點7) == 0) continue; if (FPS_繪制.世界坐標(biāo)轉(zhuǎn)屏幕坐標(biāo)(點8, 屏幕點8) == 0) continue; // 我連的腦袋疼,就不簡化代碼了 FPS_繪制.兩點畫線(HDC句柄, 屏幕點1.x, 屏幕點1.y, 屏幕點2.x, 屏幕點2.y); FPS_繪制.兩點畫線(HDC句柄, 屏幕點2.x, 屏幕點2.y, 屏幕點3.x, 屏幕點3.y); FPS_繪制.兩點畫線(HDC句柄, 屏幕點3.x, 屏幕點3.y, 屏幕點4.x, 屏幕點4.y); FPS_繪制.兩點畫線(HDC句柄, 屏幕點4.x, 屏幕點4.y, 屏幕點1.x, 屏幕點1.y); FPS_繪制.兩點畫線(HDC句柄, 屏幕點5.x, 屏幕點5.y, 屏幕點6.x, 屏幕點6.y); FPS_繪制.兩點畫線(HDC句柄, 屏幕點6.x, 屏幕點6.y, 屏幕點7.x, 屏幕點7.y); FPS_繪制.兩點畫線(HDC句柄, 屏幕點7.x, 屏幕點7.y, 屏幕點8.x, 屏幕點8.y); FPS_繪制.兩點畫線(HDC句柄, 屏幕點8.x, 屏幕點8.y, 屏幕點5.x, 屏幕點5.y); FPS_繪制.兩點畫線(HDC句柄, 屏幕點1.x, 屏幕點1.y, 屏幕點5.x, 屏幕點5.y); FPS_繪制.兩點畫線(HDC句柄, 屏幕點2.x, 屏幕點2.y, 屏幕點6.x, 屏幕點6.y); FPS_繪制.兩點畫線(HDC句柄, 屏幕點3.x, 屏幕點3.y, 屏幕點7.x, 屏幕點7.y); FPS_繪制.兩點畫線(HDC句柄, 屏幕點4.x, 屏幕點4.y, 屏幕點8.x, 屏幕點8.y); /// } DeleteObject(畫刷句柄); char healthChar[255]; sprintf_s(healthChar, sizeof(healthChar), "%d", 周圍.對象列表[i].Hp); FPS_繪制.繪制字符串(HDC句柄,(int)屏幕坐標(biāo)_j.x, (int)屏幕坐標(biāo)_j.y, 文本顏色_常用, healthChar); if (GetKeyState(VK_F2) & 1) { FPS_繪制.畫線(HDC句柄, (int)屏幕坐標(biāo)_j.x, (int)屏幕坐標(biāo)_j.y); } } } } Sleep(1); DeleteObject(HDC句柄); }}

? ? ? ? ? 骨骼繪制和模型繪制

不同的游戲，不同的引擎，骨骼的設(shè)計理念也不同，找到的數(shù)據(jù)和最終達到的效果也不同。

新款的引擎相對于老款引擎設(shè)計的骨骼也更加的細膩，完善。

骨骼不一定有絕對坐標(biāo)，但是一般都有相對坐標(biāo)。

比如口袋西游，Y坐標(biāo)是高度，

他的骨骼由一個中心點，和兩個固定的頂點組成，還需要結(jié)合朝向來決定立方體在空間的方位

中心點 X0,Y0,Z0

底點 X1,Y1,Z1

頂點 X2,Y2,Z2

下面是定點坐標(biāo)的計算公式推算

距離 = ?sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));

藍 = ? 距離/2

tanA ?= ? (y2-y1)/（x2-x1） = 綠/藍

綠 ?= ? 距離/2*(y2-y1)/（x2-x1）

粉 ?= ?sqrt（藍平方 + ?綠平方）

紫 = 藍 - 綠

橙 = 紫* ?藍/粉

黑 = 綠* 橙/ 藍

右下坐標(biāo)：

x = 粉+黑

y = - 橙

灰 / (距離/2 ?+ 綠) ?= ?藍/ 粉

灰 = (距離/2 ?+ 綠) ?* 藍/ 粉

勾股定理求粉的右部分

黃 = 粉 - 粉的右分部

左上坐標(biāo)：

x = 黃

y = 灰

但是這個里面不用這么復(fù)雜的計算，如果仔細的觀察數(shù)據(jù)變化，可以發(fā)現(xiàn)它是

X,Y等比增量 ?說明他是 45°角度固定的

所有 8個點

逆時針順序分別是

底點 (X1,Y1,Z1)

點1：X1,Y1,Z1

點2：X2,Y1,Z1

點3：X2,Y2,Z1

點4：X1,Y2,Z1

頂點 (X2,Y2,Z2)

點5：X1,Y1,Z2

點6：X2,Y1,Z2

點7：X2,Y2,Z2

點8：X1,Y2,Z2

連線方式

1-2 ? 2-3 ?3-4 ?4-1

5-6 ?6-7 ?7-8 ?8-5

1-5 ?2-6 ?3-7 ?4 -8

這樣做起來就容易多了。

? ? ? ? ? ?自瞄

自瞄第一步，自然是分清敵我，

繪制和瞄準(zhǔn)隊友是毫無意義的。

在前面代碼中添加一斷陣營判斷，

如下

DWORD 自己陣營 = *(BYTE*)(Cs_周圍基地址2 + 0x68 * 0 + 0x4E);

對象列表[對象數(shù)量].陣營 = *(BYTE*)(Cs_周圍基地址2 + 0x68 * i + 0x4E); if (對象列表[對象數(shù)量].陣營 == 自己陣營) { 對象列表[對象數(shù)量].陣營 = 2; } else// 公眾號任鳥飛逆向 { 對象列表[對象數(shù)量].陣營 = 1; }

常量是幾 ?，自己定，方便調(diào)用即可

第二步

自瞄應(yīng)該設(shè)置成距離準(zhǔn)星最近的敵人,而不是距離人物最近的

所以我們要計算一下準(zhǔn)星最近敵人

添加一個成員

這里面我們就粗略計算,大家可以自己用三角函數(shù)計算的更精確,不贅述了

if (fabs(對象列表[對象數(shù)量].角度差_H.水平朝向) < 45 && fabs(對象列表[對象數(shù)量].角度差_H.高低朝向) < 35&& 對象列表[對象數(shù)量].陣營==1&& 對象列表[對象數(shù)量].死亡標(biāo)志位!=1){ if (fabs(對象列表[對象數(shù)量].角度差_H.水平朝向) + fabs(對象列表[對象數(shù)量].角度差_H.高低朝向) < 最小角度和) { 最小角度和 = fabs(對象列表[對象數(shù)量].角度差_H.水平朝向) + fabs(對象列表[對象數(shù)量].角度差_H.高低朝向); 準(zhǔn)星最近對象 = 對象列表[對象數(shù)量]; } }

這樣最近的就計算出來了,當(dāng)然我們只是簡單的算和, 應(yīng)該根據(jù)角度算距離的

第三步

我們就可以到 ?循環(huán)線程加入自瞄代碼了

把計算出來的最近朝向?qū)懭氲??我們的準(zhǔn)星數(shù)據(jù)中

高低朝向值 hl.exe+19E10C4 //從低到高 ?89 ?到 ?-89

水平朝向值 hl.exe+19E10C8 // ?逆時針從 0 到 360

if (GetKeyState(VK_F3) & 1)//啟動自瞄 { if (編號 == 1) { *(FLOAT*)((DWORD)GetModuleHandleA("hl.exe") + 0x19E10C4) = 周圍.準(zhǔn)星最近對象.角度_H.高低朝向; * (FLOAT*)((DWORD)GetModuleHandleA("hl.exe") + 0x19E10C8) = 周圍.準(zhǔn)星最近對象.角度_H.水平朝向; } } Sleep(1); DeleteObject(HDC句柄);

但是準(zhǔn)星秒在敵人頭頂了

我們之前為了畫框 ? 其實給的坐標(biāo) ?是不夠準(zhǔn)確的

我們調(diào)整下,自瞄的坐標(biāo)

另外視野內(nèi)沒有敵人,我們也要判斷一下

這樣就可以槍槍爆頭,甩狙等等騷操作都可以了

? ? ? ? ? UE4引擎學(xué)習(xí)

吃雞模擬器為例

根據(jù)ue4引擎世界對象數(shù)組的特點，我們可以采取以下方式來進行掃描，

打中敵人數(shù)組對象+1，拿出手雷+1或者+2，

也就是說出現(xiàn)新物品+不定數(shù)量，例如手雷增加，原本手雷不在模型上顯示，打出的子彈也是有對象的，所以子彈打中某個碰撞體也會增加。

[["BattleRoyaleTrainer-Win64-Shipping.exe"+2AF0FB8] ?+138 ]+ b8

[["BattleRoyaleTrainer-Win64-Shipping.exe"+2AF0FB8 ] +30 ]+ b8

坐標(biāo)數(shù)組

CTRL+A

X ? ? ? ? ? ? ? ? ? ? ? Y ? ? ? ? ? ? ? ? ? ?Z ? ? 00000000

3F800000 ?3F800000 ?3F800000 ? 00000000

Q2217777779

?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? 00 00 00 00 ?00 00 80 3F ?00 00 80 3F ?00 00 80 3F ?00 00 00 00

UE4 ?矩陣特征

00 00 00 00 ?00 00 00 00 ? ?00 00 80 3F ? 00 00 80 3F

00 00 80 3F ?00 00 80 3F ? 00 00 00 00 ?00 00 00 00

00 00 80 3F ? 00 00 00 00 ?00 00 00 00 ? 00 00 80 3F

00 00 80 3F ? ?00 00 00 00

UE4的矩陣有他自己的特點

下訪問斷

r8+280

rbx+280

來源于上面某個CALL

F7 往里追

[["BattleRoyaleTrainer-Win64-Shipping.exe"+2ADA268]+24D08*8+8] +280

也可以掃描 ? rbx+280的 rbx 然后挨個下斷

"BattleRoyaleTrainer-Win64-Shipping.exe"+2887630

[["BattleRoyaleTrainer-Win64-Shipping.exe"+2887630]+ 3*8 +8]+280

深入繼續(xù)學(xué)習(xí)可以公眾號任鳥飛逆向 ?進行討論學(xué)習(xí)

跳或則沿著 XY軸走，2個值改變，亂走路3個值改變。

第一個值范圍是-1.19到1.19，準(zhǔn)星可以放大絕對值是否確定?

這是一個列主序的矩陣，

第三列 0 ?0 ?0 1，其中的1可能是其他數(shù)值，

第一列的第三3個數(shù)值為0。

實戰(zhàn)操作部分 ?公眾號任鳥飛逆向視頻中提供試看和分享

游戲中畫面受限制不能上傳

Unity3D游戲

u3d游戲的數(shù)據(jù)有一個特點，那就是公式特別長，所以很多人都不習(xí)慣直接取分析，而是通過dnspy等工具去正向分析。這類分析方式我們放到下一個專題來說，下面我們看看u3d數(shù)據(jù)。

1.朝向

這是從無模塊的代碼開始分析出來的角色朝向，簡單的一個朝向數(shù)據(jù)，用了一個二叉樹，和十多層的偏移。

在分析過程中還有各種坑需要我們跳，比如在函數(shù)頭部加入一些遠跳轉(zhuǎn)，以達到隱藏偏移的目的。

2.周圍對象及骨骼遍歷

這款u3d單機游戲的骨骼是以數(shù)組的形式掛在周圍對象下的，通過一些字符串以及ID來確定骨骼的類型，并且其坐標(biāo)是絕對坐標(biāo)，而非像UE4一樣的相對坐標(biāo)。

這里是獲取骨骼剛體信息的關(guān)鍵代碼，而周圍對象的遍歷方式也是以數(shù)組套數(shù)組層層嵌套的方式獲取的，這也是u3d代碼的特點。

在每一層數(shù)組對象的固定偏移內(nèi)，會有該對象的信息字符串，可能是名字，也可能是類型

只要找到了基地址，我們就可以通過這些字符串來確定每一層對象的信息，并完成整體的遍歷。

u3d的數(shù)據(jù)我們做一個簡單的了解即可，目前主流的引擎更加偏向于UE4等虛幻引擎。

? ? ? ? ? 第二種透視方式 ?HOOK OPENGL/ D3D 方式透視

了解OpenGL 和D3D

OpenGL?開放式圖形庫,?具有非常強的可移植性,CS中?OpenGL?模式比D3D模式效果好

Direct3D 簡稱D3D,由微軟公司所制定的3D規(guī)格界面與windows兼容性更好,微軟親兒子,優(yōu)點游戲運行效率更高

3D繪圖和渲染用到他們其中之一

/* BeginMode */

#define GL_POINTS ? ? ? ? ? ? ? ? ? ? ? ? 0x0000

#define GL_LINES ? ? ? ? ? ? ? ? ? ? ? ? ?0x0001

#define GL_LINE_LOOP ? ? ? ? ? ? ? ? ? ? ?0x0002

#define GL_LINE_STRIP ? ? ? ? ? ? ? ? ? ? 0x0003

#define GL_TRIANGLES ? ? ? ? ? ? ? ? ? ? ?0x0004

#define GL_TRIANGLE_STRIP ? ? ? ? ? ? ? ? 0x0005

#define GL_TRIANGLE_FAN ? ? ? ? ? ? ? ? ? 0x0006

#define GL_QUADS ? ? ? ? ? ? ? ? ? ? ? ? ?0x0007

#define GL_QUAD_STRIP ? ? ? ? ? ? ? ? ? ? 0x0008

#define GL_POLYGON ? ? ? ? ? ? ? ? ? ? ? ?0x0009

GL_POINTS：把每一個頂點作為一個點進行處理，頂點n即定義了點n，共繪制N個點

GL_LINES：把每一個頂點作為一個獨立的線段，頂點2n－1和2n之間的是第n條線段，總共繪制N/2條線段

GL_LINE_STRIP：繪制從第一個頂點到最后一個頂點依次相連的一組線段，第n和n+1個頂點定義了第n線段，總共繪制 N－1條線段

GL_LINE_LOOP：繪制從第一個頂點到最后一個頂點依次相連的一組線段，然后最后一個頂點和第一個頂點相連，第n和n+1個頂點定義了線段n，總共繪制N條線段

GL_TRIANGLES：把每個頂點作為一個獨立的三角形，頂點3n－2、3n－1和3n定義了第n個三角形，總共繪制N/3個三角形

GL_TRIANGLE_STRIP：繪制一組相連的三角形，對于奇數(shù)n，頂點n、n+1和n+2定義了第n個三角形；對于偶數(shù)n，頂點n+1、n和n+2定義了第n個三角形，總共繪制N-2個三角形

GL_TRIANGLE_FAN：繪制一組相連的三角形，三角形是由第一個頂點及其后給定的頂點確定，頂點1、n+1和n+2定義了第n個三角形，總共N-2個三角形

GL_QUADS：繪制由四個頂點組成的一組單獨的四邊形。頂點4n－3、4n－2、4n－1和4n定義了第n個四邊形?？偣怖L制N/4個四邊形

GL_QUAD_STRIP：繪制一組相連的四邊形。每個四邊形是由一對頂點及其后給定的一對頂點共同確定的。頂點2n－1、2n、2n+2和2n+1定義了第n個四邊形，總共繪制N/2-1個四邊形

GL_POLYGON：繪制一個凸多邊形。頂點1到n定義了這個多邊形。

#define GL_DEPTH_TEST ? ? ? ? ? ? ? ? ? ? 0x0B71

如果啟用，則進行深度比較并更新深度緩沖區(qū)。參見glDepthFunc和glDepthRange。

拿OPENGL 為例

首先知道兩個函數(shù)? openGL32.DLL 中的 glBegin(枚舉模式)?

glDisable(ID) 關(guān)閉渲染,關(guān)閉服務(wù)器端GL功能

我們 Hook ?glBegin ,判斷是否是人物ID,如果是, 直接讓他調(diào)用 glDisable 關(guān)閉渲染,就可以實現(xiàn)透視

OD 附加 CS

直接跳到 ? opengl32 模塊的 ? glBegin 函數(shù)

參數(shù)是 ? 渲染ID

當(dāng)ID 等于 5或則6的時候是人物, 當(dāng)然你可以每個ID ?都測試下看看是什么,種類并不多

總結(jié)

以上是生活随笔為你收集整理的几何基础,多种矩阵的学习,世界坐标到屏幕坐标的两种转换方法,三种绘制方框的原理,hookd3d,hookopengl,骨骼透视,主播的秘密,FPS各种BT功能的原理和检测对抗原理,UE4引擎,U3D的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。

上一篇： mysql返回上一层_mysql常用命令
下一篇： Postgres主进程文件—postma

编程问答

几何基础,多种矩阵的学习,世界坐标到屏幕坐标的两种转换方法,三种绘制方框的原理,hookd3d,hookopengl,骨骼透视,主播的秘密,FPS各种BT功能的原理 和检测对抗原理,UE4引擎,U3D

總結(jié)

几何基础,多种矩阵的学习,世界坐标到屏幕坐标的两种转换方法,三种绘制方框的原理,hookd3d,hookopengl,骨骼透视,主播的秘密,FPS各种BT功能的原理和检测对抗原理,UE4引擎,U3D