為了方便大家可以系統性的學習 和了解FPS游戲相關知識,

導致本帖包含的內容比較繁多.如果沒有耐心全部看完的話,也可以直接跳到自己需要的知識點進行學習

下面介紹下

本帖主要內容包含:

幾何基礎,多種矩陣的學習,世界坐標到屏幕坐標的兩種轉換方法,三種繪制方框的原理,hookd3d,hookopengl,骨骼透視,主播的秘密,FPS各種BT功能的原理 和檢測對抗原理,UE4引擎,U3D引擎的逆向 和實戰 ,

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

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

學習這套課程的基礎包含少量的匯編知識和編程知識,一定的數學知識和內存知識.

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

當然我們要從最簡單的概念開始學習,請勿急躁

這個課題本著最簡單易懂,從本質完全解析的態度,所以有任何細節不懂,哪怕是三角函數,都可以找我探討

好,我們正式開始

? ? ? ? ? 向量

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

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

指具有大小和方向的量.

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

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

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

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

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

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

對應的是 從原點0,0 到 坐標 2,3 的向量, 大小就需要計算了

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

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

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

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

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

二維向量也可以進行算數運算.

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

向量的乘法 [2,3]*[3,3] = 6+9= 15 ?向量的內積

向量的減法可以把空間2點的絕對坐標轉化為相對坐標

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

三角函數角度的問題

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

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

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

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

不過atan()的返回值是弧度,我們如果想轉為真正的角度 ?還是需要轉換的

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

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

最終

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

另外一種情況,

知道了角度,想求邊長

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

我們怎么計算向量值呢?

很簡單,

tan 60 = 5/底邊

底邊 = 5/ tan60,當然這里的角度參數也是弧度 ?,如果你的是真實角度,我們又要把角度轉換成弧度

最終

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

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

三維向量??

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

向量寫成行 或則列都可以

行向量 ? [2,1,3]

列向量

[ 2

1

3 ]

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

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

調轉一下坐標系X,就變成了Y ,所以沒有區別,不要死記名字,按照自己習慣來)

[2,1,3]就是從原點到坐標2,1,3的向量

大小計算就更加復雜一點了

先看懂下圖的輔助線

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

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

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

向量的減法可以把三維空間2點的絕對坐標轉化為相對坐標

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

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

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

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

? ? ? ? ? 矩陣

為什么要學習矩陣,對于我們研究的課題來說,就是為了方便計算以及精準計算的,當然你可以不用.

多個向量組合成一個矩陣

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

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

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

格式為 ?行*列

例如 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

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

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

那么大家要注意的是:

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

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

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

3.計算結果的存放

例如 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

矩陣的乘法可以實現很多的功能

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

? ? ? ? ? 不借助矩陣把游戲坐標轉換成屏幕坐標

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

這里我們先不借助于強大好用的矩陣,單純用幾何算法轉換一下坐標

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

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

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

但是這個值只是約值,可能不精準也是導致后面不精準的原因之一

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

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

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

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

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

就是敵人在我們屏幕X坐標的等比例位置

所以這樣就可以計算出來 屏幕坐標X了

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

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

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

繼續替換

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

角度還要轉換一下成弧度

最終

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

屏幕坐標 = ?屏幕坐標差 + 分辨率_寬度/2;

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

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

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

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

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

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

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

最終代碼如下:

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

但是我們發現這樣計算出來的畫框 是不精準的

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

也可以通過微調度數等等的方式 把他修正比較準確

? ? ? ? ? 數據部分

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

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

先整理cs1.6數據如下:

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

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

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

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

朝向值找到以后我們發現水平轉一圈 ?是0-360的變化規律

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

方法很簡單,

把朝向寫入0 ?然后W走路 看看坐標的變化規律發現是X增加其他不變,那么0對應X正軸

把朝向寫入90 ?然后W走路 看看坐標的變化規律發現是Y增加其他不變,那么0對應Y正軸

把朝向寫入180 ?然后W走路 看看坐標的變化規律發現是X減少其他不變,那么0對應X負軸

把朝向寫入270 ?然后W走路 看看坐標的變化規律發現是Y減少其他不變,那么0對應Y負軸

最終得到結果

也就是我們不同朝向的值

人物X坐標:hl.exe+195fe58

人物Y坐標:hl.exe+195fe5C

人物Z坐標:hl.exe+195fe60

周圍數組

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

hl.exe+1B5A5C4+24C*n+0???????等于0 ?數組結束

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

對象X坐標?hl.exe+1B5A5C4+24C*n+18C??

對象Y坐標 hl.exe+1B5A5C4+24C*n+18C

對象Z坐標 hl.exe+1B5A5C4+24C*n+190

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

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

死亡標志位 hl.exe+62565C+n*68+60

得到的結果 就可以提供給我們封裝數據所用了,這已經足夠了

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

說到這,

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

主要的2個原因

第一設計簡單,數據少,通過上面的需要數據就已經知道了,真的很少

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

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

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

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

第二,對hookd3d的檢測應該是比較容易的

第三,對繪制函數的檢測,當然如果是窗口的覆蓋窗口那是存在一定檢測難度的

第四,自瞄準星的數據寫入檢測

第五,鼠標準星移動軌跡的檢測

第六,不定時截圖上傳

等等.

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

? ? ? ? ? 數據封裝

按照正常的數據封裝方法,

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

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

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

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

朝向值 ?和角度差的計算過程,根據上面已經得到的朝向數據

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

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

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

void 周圍對象::計算朝向_Cs(坐標結構_3 目標, 朝向結構_2& 角度, 朝向結構_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 (目標.x > FOV_x && 目標.y >= FOV_y)//第一象限 { 角度.水平朝向 = (FLOAT)((double)atan2(目標.y - FOV_y, 目標.x - FOV_x) * 180 / 3.1415); } if (目標.x <= FOV_x && 目標.y > FOV_y)//第二象限 { 角度.水平朝向 = 180 - (FLOAT)((double)atan2(目標.y - FOV_y, FOV_x - 目標.x) * 180 / 3.1415); } if (目標.x < FOV_x && 目標.y <= FOV_y)//第三象限 { 角度.水平朝向 = 180 + (FLOAT)((double)atan2(FOV_y - 目標.y, FOV_x - 目標.x) * 180 / 3.1415); } if (目標.x >= FOV_x && 目標.y < FOV_y)//第四象限 { 角度.水平朝向 = 360 - (FLOAT)((double)atan2(FOV_y - 目標.y, 目標.x - FOV_x) * 180 / 3.1415); } FLOAT 平面距離 = sqrt((目標.x - FOV_x) * (目標.x - FOV_x) + (FOV_y - 目標.y) * (FOV_y - 目標.y)); if (目標.z > FOV_z)//上方 { 角度.高低朝向 = (FLOAT)(-(double)atan2(目標.z - FOV_z, 平面距離) * 180 / 3.1415); } if (目標.z < FOV_z)//下方 { 角度.高低朝向 = (FLOAT)((double)atan2(FOV_z - 目標.z, 平面距離) * 180 / 3.1415); } 角度差.水平朝向 = 水平朝向 - 角度.水平朝向; if (角度差.水平朝向 <= -180)//跨0軸的兩種情況 { 角度差.水平朝向 += 360; } if (角度差.水平朝向 >= 180) { 角度差.水平朝向 -= 360; } 角度差.高低朝向 = 角度.高低朝向 - 高低朝向;}

? ? ? ? ? 繪制類

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

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

完全中文編程,代碼已經很清晰了

大家跟著我敲寫一遍即可

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

struct 坐標結構_2{ float x, y;};struct 坐標結構_3{ float x, y, z;};struct 坐標結構_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); //還沒講矩陣繪制 這個函數請忽略 //bool 世界坐標轉屏幕坐標(坐標結構_3 游戲坐標, 坐標結構_2& 屏幕坐標); bool 世界坐標轉屏幕坐標_非矩陣(坐標結構_2& 屏幕坐標, 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_外窗口); //含有邊框及全屏幕坐標 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(字體屬性);}//還沒講矩陣繪制 這個函數請忽略/*bool 繪制::世界坐標轉屏幕坐標(坐標結構_3 游戲坐標, 坐標結構_2& 屏幕坐標){ 取窗口信息(); memcpy(&m_矩陣, (PBYTE*)(m_矩陣地址), sizeof(m_矩陣)); 坐標結構_4 裁剪坐標; 裁剪坐標.x = 游戲坐標.x * m_矩陣[0] + 游戲坐標.y * m_矩陣[4] + 游戲坐標.z * m_矩陣[8] + m_矩陣[12]; 裁剪坐標.y = 游戲坐標.x * m_矩陣[1] + 游戲坐標.y * m_矩陣[5] + 游戲坐標.z * m_矩陣[9] + m_矩陣[13]; 裁剪坐標.z = 游戲坐標.x * m_矩陣[2] + 游戲坐標.y * m_矩陣[6] + 游戲坐標.z * m_矩陣[10] + m_矩陣[14]; 裁剪坐標.w = 游戲坐標.x * m_矩陣[3] + 游戲坐標.y * m_矩陣[7] + 游戲坐標.z * m_矩陣[11] + m_矩陣[15]; if (裁剪坐標.w < 0.0f) return false; 坐標結構_3 NDC; NDC.x = 裁剪坐標.x / 裁剪坐標.w; NDC.y = 裁剪坐標.y / 裁剪坐標.w; NDC.z = 裁剪坐標.z / 裁剪坐標.w; 屏幕坐標.x = (m_分辨率寬 / 2 * NDC.x) + m_分辨率寬 / 2; 屏幕坐標.y = -(m_分辨率高 / 2 * NDC.y) + m_分辨率高 / 2; return true;}*/ bool 繪制::世界坐標轉屏幕坐標_非矩陣(坐標結構_2& 屏幕坐標, FLOAT 水平角度差, FLOAT 高低角度差){ 取窗口信息(); FLOAT 高低可視角度 = (FLOAT)((double)atan2(m_分辨率高, m_分辨率寬)*180/3.1415); if (fabs(水平角度差) > 45 || fabs(高低角度差) > 高低可視角度) { return false;// 不在屏幕范圍內 int 水平差 = (int)(tan(水平角度差 * 3.1416 / 180) * ((m_分辨率寬) / 2)); 屏幕坐標.x = (float)(m_分辨率寬 / 2 + 水平差); // 哪里不懂可以v hdlw312 int 高度差 = (int)(tan(高低角度差 * 3.1416 / 180) * ((m_分辨率寬) / 2)); 屏幕坐標.y = (float)(m_分辨率高 / 2 + 高度差); return true;}

到這里 ?非矩陣繪制的所有準備工作都已經完畢了 ? ?,就看你要怎么調用了

? ? ? ? ? 非矩陣繪制方框

編寫循環繪制代碼

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

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);坐標結構_2 屏幕坐標_j;坐標結構_2 屏幕坐標_H;周圍對象 周圍; int mainThread(){ 繪制 FPS_繪制(FindWindow(L"Valve001", 0), (DWORD)GetModuleHandleA("hl.exe") + 0x1820100); while (true) { HDC句柄 = GetDC(FPS_繪制.m_窗口句柄); 周圍.刷新周圍數據_Cs(); for (int i = 0; i < (int)周圍.對象數量; i++) { if (周圍.對象列表[i].死亡標志位 == 1) { continue; } if (FPS_繪制.世界坐標轉屏幕坐標_非矩陣(屏幕坐標_j, 周圍.對象列表[i].角度差_j.水平朝向, 周圍.對象列表[i].角度差_j.高低朝向)) { if (FPS_繪制.世界坐標轉屏幕坐標_非矩陣(屏幕坐標_H, 周圍.對象列表[i].角度差_H.水平朝向, 周圍.對象列表[i].角度差_H.高低朝向)) { if (周圍.對象列表[i].陣營 == 2) { 畫刷句柄 = CreateSolidBrush(文本顏色_常用); } else { 畫刷句柄 = CreateSolidBrush(文本顏色_亮紅); } float 高度 = 屏幕坐標_j.y - 屏幕坐標_H.y; float 寬度 = 高度 / 2; FPS_繪制.畫框(HDC句柄, 畫刷句柄, (int)(屏幕坐標_H.x - 寬度/2), (int)屏幕坐標_H.y-2, (int)寬度, (int)(高度+4), 1); DeleteObject(畫刷句柄); char healthChar[255]; sprintf_s(healthChar, sizeof(healthChar), "%d", 周圍.對象列表[i].Hp); FPS_繪制.繪制字符串(HDC句柄, (int)屏幕坐標_j.x, (int)屏幕坐標_j.y, 文本顏色_常用, healthChar); if (GetKeyState(VK_F2) & 1) { FPS_繪制.畫線(HDC句柄, (int)屏幕坐標_j.x, (int)屏幕坐標_j.y); } } } } Sleep(1); DeleteObject(HDC句柄); }} BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved){ switch (ul_reason_for_call) { case DLL_PROCESS_ATTACH: DisableThreadLibraryCalls(hModule); CreateThread(0, 0, (LPTHREAD_START_ROUTINE)mainThread, 0, 0, 0); case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: case DLL_PROCESS_DETACH: break; } return TRUE;}

if (GetKeyState(VK_F2) & 1)

這里面學習一個快捷鍵指令 GetKeyState

每次按下切換他的狀態 ? 大于0 或則小于0

從而可以實現開關的功能

微調

發現效果是有了,但是并不精準

優點是:不需要矩陣 ,完全的數學公式可以計算出來,而且公式是固定的,

缺點:

但是不精準

有可視角的關系,運算的誤差等等導致的,算出來的誤差雖然不是特別大

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

我們可以選擇微調可視角度,微調屏幕X,Y坐標等等方式來處理

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

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

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

那么我們繼續學習矩陣,用矩陣的方式 ?繪制方框

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

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

在學習矩陣繪制之前,我們先來了解下繪制的幾種方法

第一種 hook ?d3d/opengl

優點:不閃 ,代碼簡單

缺點:非常容易被檢測

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

優缺點適中

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

優點:穩定

確定:代碼復雜,會閃

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

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

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

反外掛思路,同樣是針對實現原理,很輕松的應對

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

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

? ? ? ? ? 深入學習矩陣 (總結所有游戲矩陣特點 找到矩陣)

對象的世界坐標列向量

x

y

z

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

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

在學習這個矩陣之前呢我們先來了解

行主序和列主序

行主序就是拿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 矩陣的列 來* 后面的矩陣,這個前面沒有出現過

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

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

最后他是這幾個功能的結合體而已

縮放位移矩陣

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

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

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

Sx ?0 ? ?0 ? ?0

0 ? ?Sy ?0 ? ?0

0 ? ?0 ? ?Sz ?0

Tx ?Ty ?Tz ? Tw

乘

x

y

z

w

等于

x*Sx+w*Tx

y*Sy+w*Ty

z*Sz+w*Tz

w*Tw

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

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

Tx ?Ty ?Tz ?Tw

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

當然不一定只有走路的時候會變

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

如以下例子:

? ?

只改變Y的情況下

只改變X的情況下

只改變Z的情況下

XYZ混合改變的情況下

? ?

旋轉矩陣

簡單證明下結論

假設旋轉45度

用極限驗證法,驗證結果正確

圍繞Z軸 轉動

結論二:只轉動水平朝向的時候 ?行主序第三列不變 ,列主序第三行 不變化

列主序如下

圍繞X 軸轉動

結論三:只轉動高低朝向的時候 ?行主序第一行不變 ,列主序第一列 不變化

列主序如下

圍繞Y 軸轉動 ?我們沒有這種情況的時候

開倍鏡

總結矩陣6條結論

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

第二結論: ? 水平轉動的情況 ?行主序第三列不變 ? 列主序的話第三行不變

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

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

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

第六結論: ? 我們開倍鏡 第一個值 ?會* 相應的倍數 ?不絕對!

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

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

矩陣地址

hl.exe+1820100

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

如果這個都掃不到,說明CE基礎薄弱,看看公眾號任鳥飛逆向學習下免費CE基礎

? ? ? ? ? 世界坐標 ->剪輯坐標->NDC坐標->屏幕坐標

那么我們來了解下坐標的轉換過程

通過以上的矩陣

世界坐標 ?----> 剪輯坐標

矩陣乘法

a0 ? ?a1 ? ? a2 ? ? a 3

a4 ? ?a5 ? ?a6 ? ? a7

a8 ? ? a9 ? ?a10 ? a11

a12 ? a13 ?a14 ? ?a15

*

x

y

z

w

得到:

剪輯坐標 x ?= a0*x +a4*y + a8*z + a12*w

剪輯坐標 y ?= a1*x +a5*y + a9*z + a13*w

剪輯坐標 z ?= a2*x +a6*y + a10*z + a14*w

剪輯坐標 w ?= a3*x +a7*y + a11*z + a15*w

世界坐標按照我們之前的矩陣法則轉換成了平面的剪輯坐標

但是剪輯坐標是和分辨率沒有直接關系的 ,需要我們進一步轉換

剪輯坐標坐標系如下 ?正中心為0,0

剪輯坐標---->NDC坐標

矩陣的設計中w 是可以讓剪輯坐標范圍到-1和1的 ?也就成了NDC坐標

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

NDC .x = ?剪輯坐標 x/剪輯坐標 w

NDC.y ?=剪輯坐標y/剪輯坐標 w

NDC.z ?=剪輯坐標z/剪輯坐標 w

DNC坐標---->屏幕坐標

有了DNC坐標我們可以很容易轉換成屏幕坐標了

當然屏幕坐標不止一種形式

我們現在只以CS為例

后面會有其他類型

DNC.x / 1 ? = ?屏幕坐標差.x ?/ ? ?分辨率_寬 /2

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

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

DNC.y / 1 ? = ?屏幕坐標差.y ?/ ? ?分辨率_高 /2

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

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

? ? ? ? ? 矩陣繪制

最終代碼如下

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

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

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

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

這次不用微調就已經 精確了吧?

所以證明矩陣確實算的比較準確而且幫我們省掉了大量計算的時間

到這里,你的基礎算過了

迎接后面真正的學習吧!

? ? ? ? ? 單機口袋西游和單機突襲進一步熟悉相關數據,矩陣,以及繪制

游戲不分類型

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

其實只是一個操作的區別而已,本質沒有任何區別

FPS的自瞄相當于Rpg的朝向怪物

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

所以

看到RPG 這樣 意外嗎?

所以要明白本質是一樣的,沒有區別

口袋西游:

用到的數據很簡單，跟著2020的課程很容易學會。

這是一款普通的RPG類游戲，不設計到射擊相關的功能，我們只是拿來做畫框繪制練習。

人物數據:

[[[單機版基地址]+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坐標

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

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

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

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

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

周圍遍歷

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

[[[[[[[單機版基地址]+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 死亡標志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坐標

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

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

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

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

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

突襲:

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

這款游戲也可以聯網，有一些數據需要在聯網狀態下才能精確的分析出來，在新課程中也做了詳細的講解。

人物數據:

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

[0x00587C0C]+2C??Y

[0x00587C0C]+30???Z

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

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

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

周圍遍歷

00587C18?????玩家數量

[[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????角色血量

在周圍遍歷中我們發現多了一個頭部坐標，這也是其相對于CS設計的更加完善的地方。

游戲不分類型

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

其實只是一個操作的區別而已,本質沒有任何區別。

FPS的自瞄相當于Rpg的朝向怪物。

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

通過已有的數據，我們可以實現以下效果。

看到RPG游戲這樣意外嗎?

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

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

矩陣

下面我們來看看這兩款游戲的矩陣數據

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

突襲矩陣 ? 57AFE0

這都是標準的4*4矩陣，具體的分析方法在上面我們已經提到了，下面我們來看看封裝數據的過程。

數據封裝

DWORD 口袋西游_周圍基地址 = 0xD0DF1C;void 周圍對象::刷新周圍數據_口袋西游(){ DWORD Temp = *(DWORD*)(*(DWORD*)(*(DWORD*)(*(DWORD*)口袋西游_周圍基地址 + 0x1C) + 0x8) + 0x20); 對象數量 = *(DWORD*)(Temp + 0x5C); DWORD 怪物基地址 = *(DWORD*)(Temp + 0x58); for (int i = 0; i < (int)對象數量; 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].死亡標志位 = 0; } 對象數量++; 對象列表[對象數量-1].X_j = *(FLOAT*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x578); 對象列表[對象數量-1].Y_j = *(FLOAT*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x57C); 對象列表[對象數量-1].Z_j = *(FLOAT*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x580); 對象列表[對象數量-1].X_H = *(FLOAT*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x584); 對象列表[對象數量-1].Y_H = *(FLOAT*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x588); 對象列表[對象數量-1].Z_H = *(FLOAT*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x58C); 對象列表[對象數量-1].陣營 = 2; 對象列表[對象數量-1].Hp = *(DWORD*)(*(DWORD*)(*(DWORD*)(*(DWORD*)0xD0DF1C + 0x1C) + 0x28) + 0x288); 對象列表[對象數量-1].死亡標志位 = 0;} DWORD 突襲_周圍基地址 = 0x00587C10;void 周圍對象::刷新周圍數據_突襲(){ 對象數量 = *(DWORD*)0x00587C18; DWORD 怪物基地址 = *(DWORD*)突襲_周圍基地址; for (int i = 1; i < (int)對象數量; 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].死亡標志位 = 0; }}

基本數據的封裝，我們單獨來完成，而后面的整體調用我們也進行了設計和修改，可以同時支持西游，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);坐標結構_2 屏幕坐標_j;坐標結構_2 屏幕坐標_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) { 周圍.刷新周圍數據_Cs(); } if (編號 == 2) { 周圍.刷新周圍數據_口袋西游(); } if (編號 == 3) { 周圍.刷新周圍數據_突襲(); } for (int i = 0; i < (int)周圍.對象數量; i++) { if (周圍.對象列表[i].死亡標志位== 1) { continue; } 坐標結構_3 坐標_j = { 周圍.對象列表[i].X_j ,周圍.對象列表[i].Y_j ,周圍.對象列表[i].Z_j }; if (FPS_繪制.世界坐標轉屏幕坐標(坐標_j, 屏幕坐標_j)) //if (FPS_繪制.世界坐標轉屏幕坐標_非矩陣(屏幕坐標_j, 周圍.對象列表[i].角度差_j.水平朝向, 周圍.對象列表[i].角度差_j.高低朝向)) { 坐標結構_3 坐標_H = { 周圍.對象列表[i].X_H ,周圍.對象列表[i].Y_H ,周圍.對象列表[i].Z_H }; if (FPS_繪制.世界坐標轉屏幕坐標(坐標_H, 屏幕坐標_H)) // if (FPS_繪制.世界坐標轉屏幕坐標_非矩陣(屏幕坐標_H, 周圍.對象列表[i].角度差_H.水平朝向, 周圍.對象列表[i].角度差_H.高低朝向)) { if (周圍.對象列表[i].陣營 == 2) { 畫刷句柄 = CreateSolidBrush(文本顏色_常用); } else { 畫刷句柄 = CreateSolidBrush(文本顏色_亮紅); } if (編號 == 1 || 編號 == 3) { float head = 屏幕坐標_H.y - 屏幕坐標_j.y;// 負數高度 float width = head / 2; // 負數寬度 float center = width / -2; // 一半寬度 float extra = head / -6; // 三分之一 寬度 FPS_繪制.畫框(HDC句柄, 畫刷句柄, (int)(屏幕坐標_j.x + center), (int)屏幕坐標_j.y, (int)width, (int)(head - extra), 1); } if (編號 == 2) { 口袋西游模型 坐標結構_2 屏幕點1, 屏幕點2, 屏幕點3, 屏幕點4, 屏幕點5, 屏幕點6, 屏幕點7, 屏幕點8; //點求的順序不能亂,我就不簡化代碼了 坐標結構_3 點1 = { 周圍.對象列表[i].X_j ,周圍.對象列表[i].Y_j ,周圍.對象列表[i].Z_j }; 坐標結構_3 點2 = { 周圍.對象列表[i].X_H ,周圍.對象列表[i].Y_j ,周圍.對象列表[i].Z_j }; 坐標結構_3 點3 = { 周圍.對象列表[i].X_H ,周圍.對象列表[i].Y_H ,周圍.對象列表[i].Z_j }; 坐標結構_3 點4 = { 周圍.對象列表[i].X_j ,周圍.對象列表[i].Y_H ,周圍.對象列表[i].Z_j }; 坐標結構_3 點5 = { 周圍.對象列表[i].X_j ,周圍.對象列表[i].Y_j ,周圍.對象列表[i].Z_H }; 坐標結構_3 點6 = { 周圍.對象列表[i].X_H ,周圍.對象列表[i].Y_j ,周圍.對象列表[i].Z_H }; 坐標結構_3 點7 = { 周圍.對象列表[i].X_H ,周圍.對象列表[i].Y_H ,周圍.對象列表[i].Z_H }; 坐標結構_3 點8 = { 周圍.對象列表[i].X_j ,周圍.對象列表[i].Y_H ,周圍.對象列表[i].Z_H }; if (FPS_繪制.世界坐標轉屏幕坐標(點1, 屏幕點1) == 0) continue; if (FPS_繪制.世界坐標轉屏幕坐標(點1, 屏幕點1) == 0) continue; if (FPS_繪制.世界坐標轉屏幕坐標(點2, 屏幕點2) == 0) continue; if (FPS_繪制.世界坐標轉屏幕坐標(點3, 屏幕點3) == 0) continue; if (FPS_繪制.世界坐標轉屏幕坐標(點4, 屏幕點4) == 0) continue; if (FPS_繪制.世界坐標轉屏幕坐標(點5, 屏幕點5) == 0) continue; if (FPS_繪制.世界坐標轉屏幕坐標(點6, 屏幕點6) == 0) continue; if (FPS_繪制.世界坐標轉屏幕坐標(點7, 屏幕點7) == 0) continue; if (FPS_繪制.世界坐標轉屏幕坐標(點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)屏幕坐標_j.x, (int)屏幕坐標_j.y, 文本顏色_常用, healthChar); if (GetKeyState(VK_F2) & 1) { FPS_繪制.畫線(HDC句柄, (int)屏幕坐標_j.x, (int)屏幕坐標_j.y); } } } } Sleep(1); DeleteObject(HDC句柄); }}

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

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

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

骨骼不一定有絕對坐標，但是一般都有相對坐標。

比如口袋西游，Y坐標是高度，

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

中心點 X0,Y0,Z0

底點 X1,Y1,Z1

頂點 X2,Y2,Z2

下面是定點坐標的計算公式推算

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

藍 = ? 距離/2

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

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

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

紫 = 藍 - 綠

橙 = 紫* ?藍/粉

黑 = 綠* 橙/ 藍

右下坐標：

x = 粉+黑

y = - 橙

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

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

勾股定理求粉的右部分

黃 = 粉 - 粉的右分部

左上坐標：

x = 黃

y = 灰

但是這個里面不用這么復雜的計算，如果仔細的觀察數據變化，可以發現它是

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

這樣做起來就容易多了。

? ? ? ? ? ?自瞄

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

繪制和瞄準隊友是毫無意義的。

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

如下

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

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

常量是幾 ?，自己定，方便調用即可

第二步

自瞄應該設置成距離準星最近的敵人,而不是距離人物最近的

所以我們要計算一下 準星最近敵人

添加一個成員

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

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

這樣最近的就計算出來了,當然我們只是簡單的算和, 應該根據角度 算距離的

第三步

我們就可以到 ?循環線程加入自瞄代碼了

把計算出來的最近朝向寫入到 ?我們的準星數據中

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

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

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

但是準星秒在敵人頭頂了

我們之前為了畫框 ? 其實給的坐標 ?是不夠準確的

我們調整下,自瞄的坐標

另外視野內沒有敵人,我們也要判斷一下

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

? ? ? ? ? UE4引擎學習

吃雞模擬器為例

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

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

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

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

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

坐標數組

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

深入繼續學習可以 公眾號 任鳥飛逆向 ?進行討論學習

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

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

這是一個列主序的矩陣，

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

第一列的第三3個數值為0。

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

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

Unity3D游戲

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

1.朝向

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

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

2.周圍對象及骨骼遍歷

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

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

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

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

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

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

了解OpenGL 和D3D

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

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

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：繪制一組相連的三角形，對于奇數n，頂點n、n+1和n+2定義了第n個三角形；對于偶數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個四邊形。總共繪制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

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

拿OPENGL 為例

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

glDisable(ID) 關閉渲染,關閉服務器端GL功能

我們 Hook ?glBegin ,判斷是否是人物ID,如果是, 直接讓他調用 glDisable 關閉渲染,就可以實現透視

OD 附加 CS

直接跳到 ? opengl32 模塊的 ? glBegin 函數

參數是 ? 渲染ID

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

總結

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

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。