杀手5逆向分析（二）

2025-02-26

这一期主要分析射击函数，分析步骤跟上一期一样先用Cheat Engine来定位函数位置，再通过IDA Pro进行静态分析。大多数FPS游戏中找射击函数是要通过子弹数来定位的，第一步自然而然就是找出内存中的子弹存储地址。再查看此地址被哪个汇编代码所更改来锁定相应的函数。

射击函数的分析

一，定位子弹内存地址

首先把Cheat Engine附加进程到游戏的可执行程序当中，然后搜索随便一个枪械的子弹数量。子弹数量多数情况下会被存储为整数形式，有可能是2字节的也有可能是4字节的。要是没有搜到可以换扫描类型来搜索，一些游戏会对子弹数或者生命值之类的数据进行加密处理，这种情况后续会单独出一期教程来讲解。现在回到主题在4字节搜索的情况下进行多次搜索还是不能定位到子弹数量。切换2字节类型来进行搜索很快就能找到子弹数量，但是有三个搜索结果都是子弹数量。

S1

可以看到其中两个是静态地址，把这其中一个数据进行修改回到游戏查看实际子弹数量有没有发生改变。把三个数据都挨个进行测试之后发现两个静态地址修改后不会发生任何变化。所以可以确定这两个静态地址不是真正的子弹内存地址。

二，找出子弹相关的汇编代码

筛选来子弹地址之后进行 Find out what writes to this address 操作，然后在游戏中几枪就能看到修改子弹的汇编代码了。

S2

点击 Show disassembler 就能看到所有相关的代码了，此时打开IDA把这个段汇编代码的地址复制过去。

三，在IDA中分析此函数

1.UpdateAmmo函数

可以看到这个函数的调用约定为 __thiscall 接受两个参数，其中一个是this指针另一个为当前子弹数。

1
int __thiscall ShootMaybe(_WORD *this, __int16 currentAmmo);

将函数名改为 ShootMaybe ，把存储子弹的变量命名为 currentAmmo 就可以在IDA中慢慢分析了。在代码的第二行就能看到我们的子弹内存地址被传入的参数给写入了。

1
2
this_cpy = *(_DWORD *)this;
this[0x18B] = currentAmmo;                    // this+316h == Ammo

所以说剩余子弹是在上个函数或者更早的函数中被计算好的而这个函数是负责写入的。那可以推断此函数负责弹药值的直接写入并不是负责射击的，因此把函数名改成 UpdateAmmo 。继续往下分析，this指针的某一个地址传给v4变量之后就进行了调用，可以确定是在调用虚函数。

1
2
v4 = *(void (**)(void))(this_cpy + 0x180);		//从虚表偏移0x180获取函数
v4();										 //调用函数

按照正常游戏的逻辑，推测后面调用的基本都是一些子弹射击之后的事件，比如播放射击音效，生成弹道，HUD更新之类的事情。我们需要找到的是真正的计算子弹的部分，所以需要研究调用 UpdateAmmo 函数的函数。

2.Shoot函数

那么为了查看上一层的函数就要回到Cheat Engine，然后对修改内存值的那一行汇编代码加断点，选中代码后按快捷键 F5 就可以加断点操作了。有断点代码行会变成红色表示加断点成功。回到游戏中随便开一枪会发现游戏处于暂停状态了。此时在 Memory Viewer 窗口的右下角出现了一个小窗口记录了栈中的返回地址。

S3

双击第一行就能跳转到调用 UpdateAmmo 函数的调用处，也就是说当前断点出的每一层级的调用都可以在这里看到。调用 UpdateAmmo 是通过eax寄存器记录的值为调用处调用的并不是静态函数地址调用。

1
HMA.NMP::Matrix<float>::postMultiply+F72 - FF D0  - call eax

这种调用方式大概率为虚函数调用，为了验证这一想法在IDA中打开此地址。可以看到这是个相当大并且复杂的函数。把这个函数暂时命名为 callUpdateAmmo 方便后续理解。这个函数接受四个参数，调用方式没有被IDA正确识别显示 __usercall ，但是第一个参数是通过ecx寄存器传递的指针类型，所以大差不差大概率又是个 __thiscall 调用约定。将第一个参数重新命名为 this 打开 Cheat Engine 在函数第一行加入断点查看一下这个 this 到底是啥。

1
int __usercall callUpdateAmmo@<eax>(DWORD this@<ecx>, int a2@<ebp>, int a3@<edi>, int a4@<esi>);

将IDA中把函数的第一行汇编代码的地址复制到 Cheat Engine 当中加入断点，游戏中进行射击击中断点后查看ecx寄存器的值。把这个地址粘贴到 ReClass.NET 当中可以发现是一个 ItemWeapon 类的实例。 ReClass.NET 会自动获取 RTTI信息 重建继承树在右侧用红字显示。

S4

在IDA Pro中通过安装 Class Informer 插件来解析RTTI记录，安装方法以及插件地址可以从此GitHub地址获取。

（1）弹药量识别

在IDA中查看 call eax 的C++伪代码处，确实是一个接受两参数的函数调用。

1
2
3
4
(*(void (__thiscall **)(DWORD, int))(*(_DWORD *)(this + 0xF0) + 0x64))(
 this + 0xF0,
 *(unsigned __int16 *)(this + 0x406) - 1 <= 0 ? 0 : *(unsigned __int16 *)(this + 0x406) - 1);
// this + 0x406 == CurrentAmmo

ReClass.NET中看到 this + 0xF0 指向的也是一个实例，为了弄清楚这些类的结构，在IDA中打开 Class Informer 插件进行解析，解析出来的结果有3000多个类。按快捷键 Ctrl + F 进行搜索类名称或者是类静态地址（在ReClass.NET中显示）。搜索完毕后可以看到 callUpdateAmmo 函数的this指针为一个叫 ZHM5ItemWeapon 的类，继承了很多类。

1
00EBD1D4	33	MA	ZHM5ItemWeapon	ZHM5ItemWeapon: ZHM5Item, ZReusablePropEntity, ZEntityImpl, IEntity, IComponentInterface, IReusableProp, IHM5Item, IComponentInterface, IHM5ItemWeapon, IComponentInterface;

this + 0xF0 指向的是也是叫 ZHM5ItemWeapon 的类，但是只继承了两个类。

1
00E6B1B4	101	MA	ZHM5ItemWeapon	IHM5ItemWeapon: IComponentInterface;

双击打开这个 00E6B1B4 类的虚函数表可以发现我们之前定义的 UpdateAmmo 函数。了解类的结构对我们的分析和理解有很大的帮助。

在分析类似射击函数数优先寻找 – 或 -1 操作，通常对应弹药消耗。**++** 或 +1 操作通常对应总射击次数的递增。回到之前的分析这个函数传入的第一个参数是 ZHM5ItemWeapon 类的是一个实例。第二个参数是个条件表达式，简单来说这段代码的目的是将当前弹药量（ this + 0x406 ）减1，但确保弹药量不会变成负数。这段代码才是真正的子弹数量减少代码，对应的汇编代码为：

1
text:009ECEAD                 dec     eax             ; Decrease Ammo

可以看到函数的前面有一个++操作，WORD 类型（2字节）也符合此游戏的子弹存储大小：

1
++*(_WORD *)(this + 0x40A);                   // 射击总数递增

动态分析确认 this + 0x40A 指向的的确是射击总数。弹药系统的典型特征还包括边界保护类似于：

1
if (新值 <= 0) 设为0;

（2）扩散系数识别

扩散一般跟浮点运算有关，涉及乘除加减的操作通常与弹道物理相关。在函数中可以发现有一个很大的for循环，这个循环大概率是开枪时循环的。

在循环当中有一个关于浮点运算的部分：

1
*(float *)(this + 0x420) = 1.0 / (double)v15 + *(float *)(this + 0x420);// this + 0x420 == 扩散系数

可以发现 this + 0x420 地址的浮点数会随着循环次数会一直叠加，在下面还有个关于边界保护的判断：

1
2
if ( *(float *)(this + 0x420) > 1.0 )     // 扩散限制在 1 以内
*(_DWORD *)(this + 0x420) = 0x3F800000; // 0x3F800000 (float 1.0)

0x3F800000 是1.0的IEEE754编码，根据这些特征可以推测 this + 0x420 是扩散增长系数，通过动态分析发现确定是扩散增长系数。

我们再看函数的第一个if判断分析一下，因为这段也是关于浮点数的加减乘除：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
v5 = (*(int (__thiscall **)(DWORD, int, int))(*(_DWORD *)(this + 0xF0) + 0x180))(this + 0xF0, a3, a4);
  v6 = *(float *)(this + 0x1AC);
  ++*(_WORD *)(this + 0x40A);                   // 射击总数递增
  v73 = v5;
  if ( v6 > 0.0 )
  {
    *(float *)&v76 = (((double (__thiscall *)(DWORD, _DWORD))*(_DWORD *)(*(_DWORD *)(this + 0xF0) + 0x80))(
                        this + 0xF0,
                        0)
                    - *(float *)(v73 + 8))
                   / *(float *)(this + 0x1AC)
                   + *(float *)(this + 0x1B0);
    v7 = *(float *)&v76;
    v8 = flt_11536DC;
    *(float *)(this + 0x1A8) = *(float *)&v76;
    if ( v8 > v7 )
      *(_DWORD *)(this + 0x1A8) = 0;
  }

把这段进行缩短提取关键部分看一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
if ( *(float *)(this + 0x1AC) > 0.0 )  // 判断条件：this + 0x1AC > 0
{
    // 核心计算公式：
    *(float *)(this + 0x1A8) = 
        (某函数计算结果 - *(float *)(v73 + 8)) 
        / *(float *)(this + 0x1AC)  // 分母为 this + 0x1AC
        + *(float *)(this + 0x1B0); // 叠加偏移量值

    // 限制逻辑：
    if (*(float *)(this + 0x1A8) < flt_11536DC ) {
        *(_DWORD *)(this + 0x1A8) = 0; // 重置为0
    }
}

把核心计算公式按照数学公式来分析：
$$
结果 = \frac{Δ}{this+0x1AC}+偏移值
$$
当 this+0x1AC 的值越大，计算结果越小。计算结果 this + 0x1A8 需要小于阈值 flt_11536DC 否则就被清零。典型的FPS武器扩散公式：
$$
扩散值 = 基础扩散 + (\frac{扰动值}{恢复速度})
$$
代码中的 this + 0x1A8 跟这个公式相似为实时扩散值，所以 this+0x1AC 可以为扩散恢复速度， this + 0x1B0 为基础扩散值。

（3）射击循环

来分析函数的关键部分也就是for循环，每一次子弹射击都会执行这个循环：

1
for ( i = 0; i < v76; ++i )		//v76表示本次射击需要发射的子弹数

循环次数表示每次需要发射的子弹数，v76是通过前面的 sub_8F83E0 函数计算得出的：

1
2
3
*(float *)&v10 = COERCE_FLOAT(sub_8F83E0((int *)(this + 0x290), (int)v60, v9));
v76 = v10;
if ( v76 == result )   // 有结果才进入循环

v76一般值可能为1（单发），3（三连发），全自动（根据按下按键的时间来计算）。把v75命名为 shootBullet 。

（4）射击间隔

在循环内计算扩散值之前会先计算射击间隔，前面确定过 this + 0x420 是扩散系数。计算当中有个 v15 的变量参与计算，根据上下文这个变量大概率就是射击间隔：

1
2
3
v15 = *(_BYTE *)(v73 + 0x42);  // v73+0x42 = 射击间隔倒数（如30=每秒30发）
if (v15 < 1) v15 = 1;          // 防止除以0
扩散值 = 1.0/(double)v15 + 扩散值; 	//扩散值 = *(float *)(this + 0x420)

从 v73 + 0x42 这个地址读取射击速率比如10（代表10发/秒），1.0除以射击速率得到一发子弹的射击间隔（如0.01秒）。把这个时间加到扩散系数当中，射速越快扩散增长就越快，v15变量可以改名为 bulletLag 。

（5）特殊射击检测

下一段代码if判断有可能是判断特殊射击的，因为通过 Cheat Engine 把判断对应的汇编指令 Nop 掉发现造成的伤害变低了（原本冲锋枪3发打腿死，Nop 之后需要5发才腿能解决）。根据上下文可以大致猜测一下此判断内容：

1
2
3
4
5
6
7
8
9
10
if (!v14) { // v14表示是否处于特殊射击模式（如狙击开镜）
    // 获取武器配件数据
    v16 = *(int **)(dword_1221358 + 0x74); // 全局武器库指针
    v71[0] = *v16;        // 加载配件基础数据
    v66 = sub_602920(v71, &unk_10C67D8); // 解析配件属性
    
    // 计算配件对扩散的影响
    v20 = 配件对象->GetSpreadModifier(); // 获取配件提供的扩散修正
    v21 = 配件对象->ApplySpreadModifier(修正值 + 1.0/射击间隔);
}

因此 v14 变量可以重新命名为 specialShoot 。后面的操作基本都是SSE指令的解析，进行的操作大概率为弹道向量计算，碰撞检测，子弹实例生成，播放射击音效，触发命中特效等等操作。这里就不一一展开讲解了，需要解析的话可以参考英特尔官方的 SSE指令解析 来辅助解析。

（6）连发计数器

即使把减少子弹代码Nop掉，但是冲锋枪射击一个弹匣子弹之后还是自动停顿了。函数最后能看到有个对地址 this + 0x404 的判断。当我查看这个地址并在游戏中射击时发现每发射一个子弹会让这个地址值增加，当子弹数达到当前弹匣数也就是 this + 0x404 == this + 0x406 时射击就停止了。因此可以猜测这里的判断是计算射击数并强制清空当前后坐力：

1
2
3
if (*(_WORD *)(this + 0x404))      // 检查连发计数器是否非零
  *(_DWORD *)(this + 0x458) = 0;  // 重置后坐力
*(_QWORD *)(this + 0x410) = qword_1224748; // 更新时间戳

在这个判断之前就有一个对连发计数器检测 ( this + 0x404 ) 的增加操作：

1
++*(_WORD *)(this + 0x404);

当把这个对应的汇编代码Nop掉之后发现可以进行无限射击并且不受当前弹匣子弹数限制了。分析到这里就可以知道此函数就是游戏的射击模块，因此可以把函数名称改为 Shoot 。

下面放完整 UpdateAmmo函数 和 Shoot函数 的代码以供参考：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
int __thiscall UpdateAmmo(DWORD this, __int16 currentAmmo)
{
  int v3; // edx
  void (*v4)(void); // eax
  char v5; // bl
  _DWORD *v6; // eax
  void (__thiscall *v7)(DWORD); // eax
  char v9[8]; // [esp+8h] [ebp-1Ch] BYREF
  _BYTE v10[8]; // [esp+10h] [ebp-14h] BYREF
  _DWORD v11[2]; // [esp+18h] [ebp-Ch] BYREF
  int v12; // [esp+20h] [ebp-4h]

  v3 = *(_DWORD *)this;
  *(_WORD *)(this + 0x316) = currentAmmo;       // this+316h == Ammo
  v4 = *(void (**)(void))(v3 + 0x180);
  v12 = 0;
  v4();
  if ( *(_DWORD *)(*(int (__thiscall **)(DWORD))(*(_DWORD *)(this - 0xE0) + 0x64))(this - 0xE0) )
  {
    v7 = *(void (__thiscall **)(DWORD))(*(_DWORD *)(this - 0xE0) + 0x64);
    v12 = 2;
    v7(this - 0xE0);
    v6 = (_DWORD *)sub_8FFCB0((int)v10);
    v5 = v12;
  }
  else
  {
    v5 = 1;
    v11[0] = 0x80000004;
    v11[1] = "NULL";
    v6 = v11;
  }
  sub_7A4BB0((int)v6);
  if ( (v5 & 2) != 0 )
  {
    v5 &= ~2u;
    sub_820460(v10);
  }
  if ( (v5 & 1) != 0 )
    sub_820460(v11);
  return sub_820460(v9);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
int __usercall Shoot@<eax>(DWORD this@<ecx>, int a2@<ebp>, int a3@<edi>, int a4@<esi>)
{
  int v5; // eax
  double v6; // st7
  double v7; // st7
  double v8; // st6
  unsigned int v9; // eax
  int v10; // eax
  int *v11; // ecx
  int v12; // edx
  int result; // eax
  bool specialShoot; // zf
  char bulletLag; // al
  int *v16; // eax
  int (__thiscall *v17)(DWORD, int *); // edx
  int *v18; // eax
  int v19; // eax
  double v20; // st7
  void (__thiscall *v21)(int *, _DWORD); // eax
  __m128 v22; // xmm2
  __m128 v23; // xmm0
  __m128 v24; // xmm0
  __m128 v25; // xmm0
  __m128 v26; // xmm0
  const __m128i *v27; // eax
  __m128 v28; // xmm1
  __m128 v29; // xmm1
  __m128 v30; // xmm0
  __m128 v31; // xmm0
  __m128 v32; // xmm0
  __m128 v33; // xmm1
  __m128i v34; // xmm0
  void (__thiscall *v35)(DWORD, _BYTE *, __m128 *, DWORD, _DWORD); // edx
  __m128 v36; // xmm0
  int *v37; // eax
  int v38; // eax
  int v39; // edx
  bool v40; // al
  int (__thiscall *v41)(DWORD, _BYTE *); // edx
  int v42; // eax
  _DWORD *v43; // ecx
  int v44; // edx
  __m128 v45; // xmm0
  double v46; // st7
  void (__thiscall *v47)(_DWORD, _DWORD); // eax
  double v48; // st7
  float v49; // ecx
  int v50; // ecx
  double v51; // st7
  float v52; // ecx
  int v53; // ecx
  void (__thiscall *v54)(DWORD, _DWORD); // edx
  _BYTE v56[48]; // [esp+64h] [ebp-1DCh] BYREF
  _DWORD v57[20]; // [esp+94h] [ebp-1ACh] BYREF
  __m128 v58; // [esp+E4h] [ebp-15Ch]
  bool v59; // [esp+F4h] [ebp-14Ch]
  _DWORD v60[32]; // [esp+104h] [ebp-13Ch] BYREF
  _BYTE v61[16]; // [esp+184h] [ebp-BCh] BYREF
  __m128 v62; // [esp+194h] [ebp-ACh] BYREF
  __m128 v63; // [esp+1A4h] [ebp-9Ch]
  _BYTE v64[36]; // [esp+1B8h] [ebp-88h] BYREF
  __m128i v65; // [esp+1DCh] [ebp-64h] BYREF
  int *v66; // [esp+1ECh] [ebp-54h]
  int v67; // [esp+1F0h] [ebp-50h] BYREF
  int v68; // [esp+1F4h] [ebp-4Ch] BYREF
  int v69; // [esp+1F8h] [ebp-48h] BYREF
  int v70; // [esp+1FCh] [ebp-44h]
  int v71[2]; // [esp+200h] [ebp-40h] BYREF
  _DWORD v72[2]; // [esp+208h] [ebp-38h] BYREF
  int v73; // [esp+210h] [ebp-30h]
  _DWORD v74[2]; // [esp+214h] [ebp-2Ch] BYREF
  float v75; // [esp+21Ch] [ebp-24h]
  int shootBullet; // [esp+220h] [ebp-20h]
  bool v77; // [esp+227h] [ebp-19h]
  int i; // [esp+228h] [ebp-18h]
  int v79; // [esp+22Ch] [ebp-14h]
  float v80; // [esp+230h] [ebp-10h]
  int v81; // [esp+234h] [ebp-Ch]
  void *retAddr2; // [esp+238h] [ebp-8h]
  void *retaddr; // [esp+240h] [ebp+0h]

  v81 = a2;
  retAddr2 = retaddr;
  v5 = (*(int (__thiscall **)(DWORD, int, int))(*(_DWORD *)(this + 0xF0) + 0x180))(this + 0xF0, a3, a4);
  v6 = *(float *)(this + 0x1AC);                // this + 0x1AC == 扩散恢复速度
  ++*(_WORD *)(this + 0x40A);                   // this + 0x40A == 射击总数递增
  v73 = v5;
  if ( v6 > 0.0 )
  {
    *(float *)&shootBullet = (((double (__thiscall *)(DWORD, _DWORD))*(_DWORD *)(*(_DWORD *)(this + 0xF0) + 0x80))(
                                this + 0xF0,
                                0)
                            - *(float *)(v73 + 8))
                           / *(float *)(this + 0x1AC)
                           + *(float *)(this + 0x1B0);
    v7 = *(float *)&shootBullet;
    v8 = flt_11536DC;
    *(float *)(this + 0x1A8) = *(float *)&shootBullet;
    if ( v8 > v7 )
      *(_DWORD *)(this + 0x1A8) = 0;
  }
  memset(v60, 0, sizeof(v60));
  v9 = (*(int (__thiscall **)(_DWORD))(**(_DWORD **)(this + 0x3DC) + 0x14))(*(_DWORD *)(this + 0x3DC));
  *(float *)&v10 = COERCE_FLOAT(sub_8F83E0((int *)(this + 0x290), (int)v60, v9));
  v11 = *(int **)(this + 0x3DC);
  v12 = *v11;
  shootBullet = v10;
  result = (*(int (__thiscall **)(int *))(v12 + 0x14))(v11);
  if ( shootBullet == result )
  {
    v77 = *(_DWORD *)(*(int (__thiscall **)(DWORD, float))(*(_DWORD *)(this + 0x10) + 0x64))(
                       this + 0x10,
                       COERCE_FLOAT(LODWORD(v80))) == dword_1221354;
    if ( !v77 || (specialShoot = (*(_DWORD *)(dword_1221358 + 0x6EC) & 0x1000) == 0, HIBYTE(v80) = 1, specialShoot) )
      HIBYTE(v80) = 0;
    for ( i = 0; i < shootBullet; ++i )
    {
      bulletLag = *(_BYTE *)(v73 + 0x42);
      if ( bulletLag < 1 )
        bulletLag = 1;
      specialShoot = HIBYTE(v80) == 0;
      LODWORD(v75) = bulletLag;
      *(float *)(this + 0x420) = 1.0 / (double)bulletLag + *(float *)(this + 0x420);// this + 0x420 == 扩散系数
      if ( !specialShoot )                      // 是否处于特殊射击模式（如狙击开镜）
      {
        v16 = *(int **)(dword_1221358 + 0x74);
        v71[0] = 0;
        v71[0] = *v16;
        v71[1] = v16[1];
        v66 = (int *)sub_602920(v71, (int)&unk_10C67D8);
        v17 = *(int (__thiscall **)(DWORD, int *))(*(_DWORD *)this + 0x14);
        v71[0] = 0;
        v18 = (int *)v17(this, &v68);
        v19 = sub_602920(v18, (int)&unk_10C67D8);
        v68 = 0;
        if ( v66 )
        {
          if ( v66 != (int *)v19 )
          {
            v79 = *v66;
            v20 = ((double (__thiscall *)(int *))*(_DWORD *)(v79 + 0xA8))(v66);
            v21 = *(void (__thiscall **)(int *, _DWORD))(v79 + 0xAC);
            v75 = v20 + 1.0 / (double)SLODWORD(v75);
            v21(v66, LODWORD(v75));
          }
        }
      }
      if ( *(float *)(this + 0x420) > 1.0 )     // 扩散限制在 1 以内
        *(_DWORD *)(this + 0x420) = 0x3F800000; // 0x3F800000 (float 1.0)
      sub_82C0C0(v64);
      v22 = (__m128)xmmword_EAAF00;
      v23 = _mm_shuffle_ps((__m128)_mm_loadl_epi64(&v65), (__m128)v65.m128i_u32[2], 4);
      v24 = _mm_sub_ps(
              *(__m128 *)(this + 0x3F0),
              _mm_shuffle_ps(v23, _mm_shuffle_ps((__m128)xmmword_EAAF00, v23, 0xAF), 0x24));
      v25 = _mm_and_ps(_mm_mul_ps(v24, v24), (__m128)xmmword_EBD1A0);
      v26 = _mm_hadd_ps(v25, v25);
      if ( _mm_movemask_ps(
             _mm_cmple_ps(
               _mm_and_ps(_mm_sqrt_ps(_mm_hadd_ps(v26, v26)), (__m128)xmmword_EBD180),
               _mm_shuffle_ps((__m128)(unsigned int)dword_11536E0, (__m128)(unsigned int)dword_11536E0, 0))) == 0xF )
      {
        v27 = (const __m128i *)(*(int (__thiscall **)(DWORD, _BYTE *))(*(_DWORD *)(this + 0xF0) + 0x4C))(
                                 this + 0xF0,
                                 v56);
        v22 = (__m128)xmmword_EAAF00;
        v28 = _mm_shuffle_ps((__m128)_mm_loadl_epi64(v27), (__m128)v27->m128i_u32[2], 4);
        v29 = _mm_shuffle_ps(v28, _mm_shuffle_ps((__m128)xmmword_EAAF00, v28, 0xAF), 0x24);
        v30 = _mm_and_ps(_mm_mul_ps(v29, v29), (__m128)xmmword_EBD1A0);
        v31 = _mm_hadd_ps(v30, v30);
        v32 = _mm_mul_ps(_mm_div_ps((__m128)xmmword_F58720, _mm_sqrt_ps(_mm_hadd_ps(v31, v31))), v29);
        v33 = _mm_shuffle_ps((__m128)_mm_loadl_epi64(&v65), (__m128)v65.m128i_u32[2], 4);
        v63 = _mm_add_ps(
                _mm_mul_ps(v32, _mm_shuffle_ps((__m128)xmmword_EBD260, (__m128)xmmword_EBD260, 0)),
                _mm_shuffle_ps(v33, _mm_shuffle_ps((__m128)xmmword_EAAF00, v33, 0xAF), 0x24));
        v65.m128i_i64[0] = v63.m128_u64[0];
        v65.m128i_i32[2] = v63.m128_i32[2];
      }
      v34 = _mm_loadl_epi64(&v65);
      v35 = *(void (__thiscall **)(DWORD, _BYTE *, __m128 *, DWORD, _DWORD))(*(_DWORD *)(this + 0xF0) + 0x124);
      v80 = *(float *)(this + 0x458);
      v36 = _mm_shuffle_ps((__m128)_mm_move_epi64(v34), (__m128)v65.m128i_u32[2], 4);
      v62 = _mm_shuffle_ps(v36, _mm_shuffle_ps(v22, v36, 0xAF), 0x24);
      v35(this + 0xF0, v61, &v62, this + 0x3F0, LODWORD(v80));
      v37 = (int *)(*(int (__thiscall **)(DWORD, int *))(*(_DWORD *)this + 0x14))(this, &v67);
      v72[0] = 0;
      v72[0] = *v37;
      v38 = sub_602920(v37, (int)&unk_10C67D8);
      v39 = *(_DWORD *)(this + 0x3DC);
      v72[1] = v38;
      sub_54A170((int)v57, (int)v72, v39);
      v72[0] = 0;
      v67 = 0;
      v40 = !v77
         && *(unsigned __int16 *)(this + 0x40A) > (*(int (__thiscall **)(_DWORD))(**(_DWORD **)(this + 0x3DC) + 0x34))(*(_DWORD *)(this + 0x3DC));
      v41 = *(int (__thiscall **)(DWORD, _BYTE *))(*(_DWORD *)(this + 0xF0) + 0x4C);
      v59 = v40;
      v42 = v41(this + 0xF0, v56);
      v43 = (_DWORD *)v60[i];
      v44 = *(_DWORD *)(this + 0xF0);
      v45 = _mm_shuffle_ps(
              (__m128)_mm_loadl_epi64((const __m128i *)(v42 + 0x24)),
              (__m128)*(unsigned int *)(v42 + 0x2C),
              4);
      v58 = _mm_shuffle_ps(v45, _mm_shuffle_ps((__m128)xmmword_EAAF00, v45, 0xAF), 0x24);
      v79 = *v43 + 0x2C;
      v46 = ((double (__thiscall *)(DWORD))*(_DWORD *)(v44 + 0x12C))(this + 0xF0);
      v47 = *(void (__thiscall **)(_DWORD, _DWORD))v79;
      v80 = v46;
      v47(v60[i], LODWORD(v80));
      v79 = *(_DWORD *)v60[i] + 0x34;
      v48 = ((double (__thiscall *)(DWORD))*(_DWORD *)(*(_DWORD *)(this + 0xF0) + 0x130))(this + 0xF0);
      v80 = v49;
      v50 = v60[i];
      v80 = v48;
      (*(void (__thiscall **)(int, float))v79)(v50, COERCE_FLOAT(LODWORD(v80)));
      v79 = *(_DWORD *)v60[i] + 0x3C;
      v51 = ((double (__thiscall *)(DWORD))*(_DWORD *)(*(_DWORD *)(this + 0xF0) + 0x134))(this + 0xF0);
      v80 = v52;
      v53 = v60[i];
      v80 = v51;
      (*(void (__thiscall **)(int, float))v79)(v53, COERCE_FLOAT(LODWORD(v80)));
      (*(void (__thiscall **)(bool, _DWORD *, _BYTE *, _BYTE *, _DWORD, unsigned int, bool, int))(*(_DWORD *)v60[i]
                                                                                                + 0x48))(
        (*(_BYTE *)(this + 0x45C) & 0x40) != 0,
        v57,
        v64,
        v61,
        0,
        0xFFFFFFFF,
        (*(_BYTE *)(this + 0x45C) & 0x40) != 0,
        *(_BYTE *)(this + 0x45C) >> 7);
      if ( v59 )
        *(_WORD *)(this + 0x40A) = 0;
      v69 = *(_DWORD *)(this + 0x80);
      v70 = sub_602920((int *)(this + 0x80), (int)&unk_10C1BDC);
      if ( v70 && sub_602920(&v69, (int)&unk_10C67CC) )
      {
        sub_CC7A90(v74);
        if ( v74[1] )
          sub_5E7820(v57[0xD], 0, v65.m128i_i32[0], v65.m128i_i32[1], v65.m128i_i32[2], 0);
        v74[0] = 0;
      }
      v69 = 0;
    }
    ++*(_WORD *)(this + 0x404);
    v54 = *(void (__thiscall **)(DWORD, _DWORD))(*(_DWORD *)(this + 0xF0) + 0xF4);
    LODWORD(v80) = *(unsigned __int16 *)(this + 0x404);
    v54(this + 0xF0, 0);
    (*(void (__thiscall **)(DWORD, int))(*(_DWORD *)(this + 0xF0) + 0x64))(
      this + 0xF0,
      *(unsigned __int16 *)(this + 0x406) - 1 <= 0 ? 0 : *(unsigned __int16 *)(this + 0x406) - 1);// this + 0x406 == CurrentAmmo
                                                // call ShootMaybe
    if ( *(_WORD *)(this + 0x404) )             // this + 0x404 == BurstCounter
      *(_DWORD *)(this + 0x458) = 0;
    *(_QWORD *)(this + 0x410) = qword_1224748;
    return sub_4AC9A0((char *)this, dword_1153738, (int)v74);
  }
  return result;
}

因为逆向工程大部分都是搞猜测验证来进行的，所以文章中有错误猜测或错误分析的部分请在评论区纠正。有任何私人问题可以联系我的私人邮箱，邮箱地址在首页。谢谢观看！