挂海论坛 › 综合编程 › 求助，有偿求助，这个死循环是咋了？

l1123059710 发表于 2018-5-6 10:50:12

求助，有偿求助，这个死循环是咋了？

本人穷苦学生一枚，偶尔玩玩这个，

求大神告诉我咋办。。。

模型自瞄没效果。。。.版本 2

.子程序 模型自瞄
.局部变量 ViewPort_1, OPENGL_VIEWPORT
.局部变量 ViewWorld, OPENGL_VIEWWORLD
.局部变量 相机偏移, 整数型
.局部变量 矩阵数据, OPENGL_VIEWWORLD
.局部变量 遍历偏移, 整数型
.局部变量 环境数量, 整数型
.局部变量 device, 整数型
.局部变量 Object, 整数型
.局部变量 SightX, 小数型
.局部变量 SightY, 小数型
.局部变量 对象坐标, D3D坐标
.局部变量 ViewW, 小数型
.局部变量 BoxX0, 小数型
.局部变量 BoxY0, 小数型
.局部变量 BoxX1, 小数型
.局部变量 BoxY1, 小数型
.局部变量 Rect, RECT
.局部变量 hNPen, 整数型
.局部变量 Size, 整数型
.局部变量 距离, 小数型
.局部变量 OffsetX, 小数型
.局部变量 OffsetY, 小数型
.局部变量 临时X, 小数型
.局部变量 瞄准X, 整数型
.局部变量 OffsetX1, 小数型
.局部变量 OffsetyY1, 小数型
.局部变量 距离1, 小数型
.局部变量 OffsetY1, 小数型
.局部变量 瞄准Y, 小数型
.局部变量 ebx, 整数型
.局部变量 局_数量地址, 整数型
.局部变量 局_遍历地址, 整数型
.局部变量 _环境数量, 整数型
.局部变量 对象指针, 整数型
.局部变量 i, 整数型
.局部变量 重复数据, 整数型
.局部变量 上次数据, 整数型
.局部变量 对象骨骼偏移, 整数型
.局部变量 模型ID, 整数型
.局部变量 对象偏移, 整数型
.局部变量 骨骼坐标, D3D坐标
.局部变量 骨骼对象, 整数型
.局部变量 x, 整数型
.局部变量 距离变量, 整数型
.局部变量 d, 整数型

打头打屁股 ＝ 真

Sleep (1)
.如果真 (磁性自瞄 ＝ 假)

.如果真结束
ViewPort_1.TopLeftX ＝ 内存.读整数型 (pid, 视窗基址)
ViewPort_1.TopLeftY ＝ 内存.读整数型 (pid, 视窗基址 ＋ 4)
ViewPort_1.Width ＝ 内存.读整数型 (pid, 视窗基址 ＋ 8)
ViewPort_1.Height ＝ 内存.读整数型 (pid, 视窗基址 ＋ 12)
相机偏移 ＝ 内存.读整数型 (pid, 矩阵基址)
相机偏移 ＝ 内存.读整数型 (pid, 相机偏移 ＋ 1640)
相机偏移 ＝ 内存.读整数型 (pid, 相机偏移 ＋ 12)
相机偏移 ＝ 内存.读整数型 (pid, 相机偏移 ＋ 68)
ReadProcessMemoryWorld_1 (进程句柄, 相机偏移 ＋ 196, ViewWorld, 64, Size)

置入代码 ({ 235, 16, 86, 77, 80, 114, 111, 116, 101, 99, 116, 32, 98, 101, 103, 105, 110, 0 })
局_数量地址 ＝ 内存.读整数型 (pid, 骨骼遍历首)' EBX
局_遍历地址 ＝ 内存.读整数型 (pid, 骨骼遍历尾)' ESI
_环境数量 ＝ 右移 (局_数量地址 － 局_遍历地址 ＋ 3, 2)
置入代码 ({ 235, 14, 86, 77, 80, 114, 111, 116, 101, 99, 116, 32, 101, 110, 100, 0 })
SightX ＝ ViewPort_1.Width ÷ 2
SightY ＝ ViewPort_1.Height ÷ 2
.如果真 (_环境数量 ≠ 0)
    .计次循环首 (_环境数量, )
      置入代码 ({ 235, 16, 86, 77, 80, 114, 111, 116, 101, 99, 116, 32, 98, 101, 103, 105, 110, 0 })
      对象指针 ＝ 内存.读整数型 (pid, 局_遍历地址)
      局_遍历地址 ＝ 局_遍历地址 ＋ 4
      对象骨骼偏移 ＝ 内存.读整数型 (pid, 对象指针 ＋ 24)
      对象骨骼偏移 ＝ 内存.读整数型 (pid, 对象骨骼偏移 ＋ 328)
      对象骨骼偏移 ＝ 内存.读整数型 (pid, 对象骨骼偏移 ＋ 4)
      模型ID ＝ 内存.读整数型 (pid, 对象骨骼偏移 ＋ 8)
      置入代码 ({ 235, 14, 86, 77, 80, 114, 111, 116, 101, 99, 116, 32, 101, 110, 100, 0 })
      .' 如果真 (模型ID ＝ 4)
            ' 加入成员 (玩家数组, 到文本 (对象指针))
      .如果真结束

      .' 如果真 (模型ID ＝ 4 或 模型ID ＝ 493 或 模型ID ＝ 726)
            ' 到循环尾 ()
      .如果真结束
      置入代码 ({ 235, 16, 86, 77, 80, 114, 111, 116, 101, 99, 116, 32, 98, 101, 103, 105, 110, 0 })
      .如果 (打头打屁股)
            .如果真 (模型ID ≠ 48 且 模型ID ≠ 63 且 模型ID ≠ 80 且 模型ID ≠ 142 且 模型ID ≠ 153 且 模型ID ≠ 154 且 模型ID ≠ 155 且 模型ID ≠ 156 且 模型ID ≠ 158 且 模型ID ≠ 179 且 模型ID ≠ 189 且 模型ID ≠ 206 且 模型ID ≠ 217 且 模型ID ≠ 240 且 模型ID ≠ 245 且 模型ID ≠ 257 且 模型ID ≠ 260 且 模型ID ≠ 265 且 模型ID ≠ 314 且 模型ID ≠ 473 且 模型ID ≠ 482 且 模型ID ≠ 514 且 模型ID ≠ 582 且 模型ID ≠ 732 且 模型ID ≠ 3810 且 模型ID ≠ 482 且 模型ID ≠ 714 且 模型ID ≠ 726)
                到循环尾 ()' 模型我要了
            .如果真结束

      .否则
            .如果真 (模型ID ≠ 4 且 模型ID ≠ 307 且 模型ID ≠ 511 且 模型ID ≠ 509 且 模型ID ≠ 447 且 模型ID ≠ 261 且 模型ID ≠ 493)' 瞄胸瞄屁股
                到循环尾 ()
            .如果真结束

      .如果结束
      置入代码 ({ 235, 14, 86, 77, 80, 114, 111, 116, 101, 99, 116, 32, 101, 110, 100, 0 })
      置入代码 ({ 235, 16, 86, 77, 80, 114, 111, 116, 101, 99, 116, 32, 98, 101, 103, 105, 110, 0 })' 头
      对象偏移 ＝ 内存.读整数型 (pid, 对象指针 ＋ 80)
      对象偏移 ＝ 内存.读整数型 (pid, 对象偏移 ＋ 12)
      骨骼对象 ＝ 内存.读整数型 (pid, 对象偏移)
      骨骼坐标.X ＝ 内存.读小数型 (pid, 骨骼对象)
      骨骼坐标.Y ＝ 内存.读小数型 (pid, 骨骼对象 ＋ 4)
      骨骼坐标.Z ＝ 内存.读小数型 (pid, 骨骼对象 ＋ 8)
      置入代码 ({ 235, 14, 86, 77, 80, 114, 111, 116, 101, 99, 116, 32, 101, 110, 100, 0 })' 尾
      ViewW ＝ ViewWorld.Data30 × 骨骼坐标.X ＋ ViewWorld.Data31 × 骨骼坐标.Y ＋ ViewWorld.Data32 × 骨骼坐标.Z ＋ ViewWorld.Data33
      .如果真 (ViewW ＜ 0.01)
            到循环尾 ()
      .如果真结束
      ViewW ＝ 1 ÷ ViewW' 一件基址呢
      .如果 (瞄准方式)
            .如果 (位与 (GetAsyncKeyState (2), 32768) ≠ 0)
                骨骼坐标.X ＝ 内存.读小数型 (pid, 骨骼对象)
                骨骼坐标.Y ＝ 内存.读小数型 (pid, 骨骼对象 ＋ 4)
                骨骼坐标.Z ＝ 内存.读小数型 (pid, 骨骼对象 ＋ 8)
                OffsetX ＝ (ViewWorld.Data00 × 骨骼坐标.X ＋ ViewWorld.Data01 × 骨骼坐标.Y ＋ ViewWorld.Data02 × 骨骼坐标.Z ＋ ViewWorld.Data03) × ViewW × SightX ＋ ViewPort_1.TopLeftX ＋ 0.5
                OffsetY ＝ (ViewWorld.Data10 × 骨骼坐标.X ＋ ViewWorld.Data11 × 骨骼坐标.Y ＋ ViewWorld.Data12 × 骨骼坐标.Z ＋ ViewWorld.Data13) × ViewW × SightY ＋ ViewPort_1.TopLeftY － 0.5
                距离 ＝ OffsetX × OffsetX ＋ OffsetY × OffsetY
                ' 瞄准X ＝ SightX ＋ (ViewWorld.Data00 × 骨骼坐标.X ＋ ViewWorld.Data01 × 骨骼坐标.Y ＋ ViewWorld.Data02 × 骨骼坐标.Z ＋ ViewWorld.Data03) × ViewW × SightX ＋ ViewPort_1.TopLeftX － 0.5
                ' 瞄准Y ＝ SightY － (ViewWorld.Data10 × 骨骼坐标.X ＋ ViewWorld.Data11 × 骨骼坐标.Y ＋ ViewWorld.Data12 × 骨骼坐标.Z ＋ ViewWorld.Data13) × ViewW × SightY ＋ ViewPort_1.TopLeftY － 0.5

                .如果 (锁定目标 ≠ 0)
                  距离变量 ＝ 7500
                .否则
                  距离变量 ＝ 1000
                .如果结束

                .如果真 (距离 ＜ 距离变量)
                  .如果 (锁定目标 ＝ 0)
                        锁定目标 ＝ 对象指针
                  .否则
                        .如果真 (对象指针 ＝ 锁定目标)
                            .判断循环首 (真)
                              相机偏移 ＝ 内存.读整数型 (pid, 矩阵基址)
                              .如果真 (相机偏移 ≠ -1)
                                    相机偏移 ＝ 内存.读整数型 (pid, 相机偏移 ＋ 1640)
                                    .如果真 (相机偏移 ≠ -1)
                                        相机偏移 ＝ 内存.读整数型 (pid, 相机偏移 ＋ 12)
                                        .如果真 (相机偏移 ≠ -1)
                                          相机偏移 ＝ 内存.读整数型 (pid, 相机偏移 ＋ 68)
                                          .如果真 (相机偏移 ≠ -1)
                                                ReadProcessMemoryWorld_1 (进程句柄, 相机偏移 ＋ 196, ViewWorld, 64, Size)
                                          .如果真结束

                                        .如果真结束

                                    .如果真结束

                              .如果真结束
                              置入代码 ({ 235, 16, 86, 77, 80, 114, 111, 116, 101, 99, 116, 32, 98, 101, 103, 105, 110, 0 })' 头
                              对象骨骼偏移 ＝ 内存.读整数型 (pid, 锁定目标 ＋ 24)
                              对象骨骼偏移 ＝ 内存.读整数型 (pid, 对象骨骼偏移 ＋ 328)
                              对象骨骼偏移 ＝ 内存.读整数型 (pid, 对象骨骼偏移 ＋ 4)
                              模型ID ＝ 内存.读整数型 (pid, 对象骨骼偏移 ＋ 8)
                              对象偏移 ＝ 内存.读整数型 (pid, 锁定目标 ＋ 80)
                              对象偏移 ＝ 内存.读整数型 (pid, 对象偏移 ＋ 12)
                              骨骼对象 ＝ 内存.读整数型 (pid, 对象偏移)
                              置入代码 ({ 235, 14, 86, 77, 80, 114, 111, 116, 101, 99, 116, 32, 101, 110, 100, 0 })' 尾
                              置入代码 ({ 235, 16, 86, 77, 80, 114, 111, 116, 101, 99, 116, 32, 98, 101, 103, 105, 110, 0 })' 头
                              .判断开始 (模型ID ＝ 217)
                                    骨骼对象 ＝ 骨骼对象 ＋ 2016
                              .判断 (模型ID ＝ 482)
                                    骨骼对象 ＝ 骨骼对象 － 31572
                              .判断 (模型ID ＝ 260)
                                    骨骼对象 ＝ 骨骼对象 ＋ 9792
                              .判断 (模型ID ＝ 153)
                                    骨骼对象 ＝ 骨骼对象 ＋ 432
                              .判断 (模型ID ＝ 514)
                                    骨骼对象 ＝ 骨骼对象 ＋ 36828
                              .判断 (模型ID ＝ 155)
                                    骨骼对象 ＝ 骨骼对象 ＋ 468
                              .判断 (模型ID ＝ 510)
                                    骨骼对象 ＝ 骨骼对象 ＋ 18828
                              .判断 (模型ID ＝ 158)
                                    骨骼对象 ＝ 骨骼对象 ＋ 6372
                              .判断 (模型ID ＝ 314)
                                    骨骼对象 ＝ 骨骼对象 － 4968
                              .判断 (模型ID ＝ 80)
                                    骨骼对象 ＝ 骨骼对象 ＋ 4140
                              .判断 (模型ID ＝ 331)' 1级头
                                    骨骼对象 ＝ 骨骼对象 ＋ 828
                              .判断 (模型ID ＝ 368)' 2级头
                                    骨骼对象 ＝ 骨骼对象 ＋ 1728
                              .默认

                              .判断结束
                              置入代码 ({ 235, 14, 86, 77, 80, 114, 111, 116, 101, 99, 116, 32, 101, 110, 100, 0 })' 尾


                              .如果真 (骨骼对象 ＜ 500000 或 磁性自瞄 ＝ 假)
                                    锁定目标 ＝ 0
                                    锁定目标2 ＝ 0
                                    跳出循环 ()
                              .如果真结束


                              骨骼坐标.X ＝ 内存.读小数型 (pid, 骨骼对象)
                              骨骼坐标.Y ＝ 内存.读小数型 (pid, 骨骼对象 ＋ 4)
                              骨骼坐标.Z ＝ 内存.读小数型 (pid, 骨骼对象 ＋ 8)
                              SightX ＝ ViewPort_1.Width ÷ 2
                              SightY ＝ ViewPort_1.Height ÷ 2
                              ViewW ＝ ViewWorld.Data30 × 骨骼坐标.X ＋ ViewWorld.Data31 × 骨骼坐标.Y ＋ ViewWorld.Data32 × 骨骼坐标.Z ＋ ViewWorld.Data33
                              .如果真 (ViewW ＜ 0.01)
                                    到循环尾 ()
                              .如果真结束
                              ViewW ＝ 1 ÷ ViewW
                              OffsetX ＝ (ViewWorld.Data00 × 骨骼坐标.X ＋ ViewWorld.Data01 × 骨骼坐标.Y ＋ ViewWorld.Data02 × 骨骼坐标.Z ＋ ViewWorld.Data03) × ViewW × SightX ＋ ViewPort_1.TopLeftX ＋ 0.5
                              OffsetY ＝ (ViewWorld.Data10 × 骨骼坐标.X ＋ ViewWorld.Data11 × 骨骼坐标.Y ＋ ViewWorld.Data12 × 骨骼坐标.Z ＋ ViewWorld.Data13) × ViewW × SightY ＋ ViewPort_1.TopLeftY － 0.5
                              距离 ＝ OffsetX × OffsetX ＋ OffsetY × OffsetY
                              瞄准X ＝ SightX ＋ (ViewWorld.Data00 × 骨骼坐标.X ＋ ViewWorld.Data01 × 骨骼坐标.Y ＋ ViewWorld.Data02 × 骨骼坐标.Z ＋ ViewWorld.Data03) × ViewW × SightX ＋ ViewPort_1.TopLeftX
                              瞄准Y ＝ SightY － (ViewWorld.Data10 × 骨骼坐标.X ＋ ViewWorld.Data11 × 骨骼坐标.Y ＋ ViewWorld.Data12 × 骨骼坐标.Z ＋ ViewWorld.Data13) × ViewW × SightY ＋ ViewPort_1.TopLeftY
                              .如果 (锁定目标2 ＝ 0)
                                    锁定目标2 ＝ 锁定目标
                                    距离变量 ＝ 1000
                              .否则
                           

qq1115750247 发表于 2018-5-6 11:04:52

顶帖是一种态度，也是一种尊重。

zxc123 发表于 2018-5-6 11:53:28

加我q 2439115294帮你看一下

查看完整版本: 求助，有偿求助，这个死循环是咋了？