GTA Builder Форум

GTA Vice City => Справочная информация => Тема начата: graveman от Ноябрь 26, 2013, 03:29:48 pm

Название: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: graveman от Ноябрь 26, 2013, 03:29:48 pm
Думаю, общими усилиями, здесь присутствующие программеры могли бы быстрее разобрать экзешник игры, чтобы делать полноценные моды на плагинах, а не ограничиваться только скриптами. Предлагаю выкладывать сюда свои базы адресов, описания классов и функций движка игры.

Добавлено мной.
Просьба выкладывать наработки в виде .rar или .zip архивов с небольшим пояснением., чтобы легче было ориентироваться.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Sektor от Ноябрь 26, 2013, 04:11:16 pm
Начинал совсем не много возится с оружием и с другими модулями, пока это сырое все. Вообщем строго не судите, я пока-что этим мало занимался. Там есть над чем поработать.

vcWeapon.h

Код: C++
  1. #pragma pack (push, 1)
  2.  
  3. struct CWeaponInfo{
  4.  DWORD weaponType;
  5.  DWORD Range;
  6.  DWORD FiringRate;
  7.  DWORD Reload;
  8.  DWORD AmmoInCLip;
  9.  DWORD Damage;
  10.  DWORD Speed;
  11.  DWORD Radius;
  12.  DWORD LifeSpan;
  13.  DWORD Spread;
  14.  RwV3d FireOffset;
  15.  DWORD AnimIndex;
  16.  DWORD AnimLoopStart;
  17.  DWORD AnimLoopEnd;
  18.  DWORD AnimFire;
  19.  DWORD Anim2LoopStart;
  20.  DWORD Anim2LoopEnd;
  21.  DWORD Anim2Fire;
  22.  DWORD AnimBreakout;
  23.  DWORD mi;
  24.  DWORD mi2;
  25.  DWORD flags;
  26.  DWORD slot;
  27. };
  28.  
  29.  
  30. class CWeaponData{
  31.  
  32. public:
  33.  static CWeaponInfo * GetWeaponInfoByIndex(int weaponIndex);
  34.  static void Init();
  35. };
  36.  
  37.  
  38.  
  39. class CEntity_;
  40.  
  41.  
  42. class CWeaponSlot{
  43.  
  44.  public:
  45.         DWORD weaponIndex;
  46.     DWORD field_4;
  47.     DWORD AmmoInClip;
  48.     DWORD ammo;
  49.     DWORD field_10;
  50.     BYTE field_14;
  51.     BYTE field_15;
  52.     BYTE field_16;
  53.     BYTE field_17;
  54.         void Reload();
  55.         void FireInstantHit(CEntity_ * entity, RwV3d * vector);
  56.         void Fire(CEntity_ * entity, RwV3d * vector);
  57.         void FireShotgun(CEntity_ * entity, RwV3d * vector);
  58.         void FireSniper(CEntity * entity);
  59.         void BlowUpExplosiveThings( CEntity_ *);
  60.  
  61. };
  62.  
  63.  
  64. #pragma pack (pop)
  65.  
  66.  


vcWeapon.cpp


Код: C++
  1. #include "stdafx.h"
  2.  
  3. #include "vcRenderWare.h"
  4. #include "vcCamera.h"
  5. #include "vcPhysic.h"
  6. #include "vcWeapon.h"
  7. #include "vcActors.h"
  8. #include <math.h>
  9.  
  10.  
  11.  
  12. //CWeaponInfo_ WeaponInfo[37];
  13. CWeaponInfo * WeaponsInfo   = (CWeaponInfo*)0x0782A14; //Временно
  14. extern CCamera * _Camera;
  15.  
  16.  
  17. CWeaponInfo * CWeaponData::GetWeaponInfoByIndex(int weaponIndex){
  18.   return &WeaponsInfo[weaponIndex];
  19. };
  20.  
  21.  
  22. //005D5750
  23. void CWeaponData::Init() {
  24.  
  25. //Дописать!
  26.  
  27. for (int i=0; i < 37; i++) {
  28.            WeaponsInfo[i].weaponType     = 1;
  29.            WeaponsInfo[i].Range          = 0;
  30.            WeaponsInfo[i].FiringRate     = 0;
  31.            WeaponsInfo[i].Reload         = 0;
  32.            WeaponsInfo[i].AmmoInCLip     = 0;
  33.            WeaponsInfo[i].Damage         = 0;
  34.            WeaponsInfo[i].Speed          = 0;
  35.            WeaponsInfo[i].Radius         = 0;
  36.            WeaponsInfo[i].LifeSpan       = 0;
  37.            WeaponsInfo[i].Spread         = 0;
  38.            WeaponsInfo[i].FireOffset.x   = 0;
  39.            WeaponsInfo[i].FireOffset.y   = 0;
  40.            WeaponsInfo[i].FireOffset.z   = 0;
  41.            WeaponsInfo[i].AnimIndex      = 7;
  42.            WeaponsInfo[i].AnimLoopStart  = 0;
  43.            WeaponsInfo[i].AnimLoopEnd    = 0;
  44.            WeaponsInfo[i].AnimFire       = 0;
  45.            WeaponsInfo[i].Anim2LoopStart = 0;
  46.            WeaponsInfo[i].Anim2LoopEnd   = 0;
  47.            WeaponsInfo[i].Anim2Fire      = 0;
  48.            WeaponsInfo[i].AnimBreakout   = 0;
  49.            WeaponsInfo[i].flags          = 59;
  50.            WeaponsInfo[i].slot           = 0;
  51.      }
  52.  
  53. };
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60. void RwV3dnormalize(RwV3d * V3d) {
  61.     float inv_lng = 1.0f / sqrt(V3d->x*V3d->x + V3d->y*V3d->y + V3d->z*V3d->z);
  62.         V3d->x = V3d->x * inv_lng;
  63.         V3d->y = V3d->y * inv_lng;
  64.         V3d->z = V3d->z * inv_lng;
  65. }
  66.  
  67.  
  68.  
  69.  
  70. //005CA3C0
  71. void CWeaponSlot::Reload() {
  72.  
  73.  if (ammo) {
  74.         if ((ammo >= CWeaponData::GetWeaponInfoByIndex(weaponIndex)->AmmoInCLip) )
  75.                  AmmoInClip  = CWeaponData::GetWeaponInfoByIndex(weaponIndex)->AmmoInCLip;
  76.         else
  77.                  AmmoInClip = ammo;
  78.     }
  79.  
  80. };
  81.  
  82. //005D1140
  83. void CWeaponSlot::FireInstantHit(CEntity_ * entity, RwV3d * vector){
  84.         auto CWeaponFireInstantHit = (void (__thiscall*)(CWeaponSlot * weaponSlot, CEntity_ * entity, RwV3d * vector))0x05D1140;
  85.         CWeaponFireInstantHit(this,entity,vector);
  86. };
  87.  
  88. //05D45E0
  89. void CWeaponSlot::Fire(CEntity_ * entity, RwV3d * vector){
  90.         auto CWeaponFire = (void (__thiscall*)(CWeaponSlot * weaponSlot, CEntity_ * entity, RwV3d * vector))0x05D45E0;
  91.         CWeaponFire(this,entity,vector);
  92. };
  93.  
  94. //005CD340
  95. void CWeaponSlot::FireShotgun(CEntity_ * entity, RwV3d * vector){
  96.         auto CWeaponFireShotgun = (void (__thiscall*)(CWeaponSlot * weaponSlot, CEntity_ * entity, RwV3d * vector))0x05CD340;
  97.         CWeaponFireShotgun(this,entity,vector);
  98. };
  99.  
  100.  
  101. //
  102. float   flt_69D480 = -0.98f;
  103. float * dword_69D398 =  (float*)0x069D398;
  104. float   flt_69D484 = 0.145f;
  105. float   flt_69D488 = 0.996f;
  106.  
  107. DWORD * dword_695680 = (DWORD*)0x0695680;
  108. float   flt_69D48C = 16.0f;
  109. float * flt_69D394 =  (float*)0x069D394;
  110.  
  111.  
  112.  
  113. //005CC730
  114. void CWeaponSlot::FireSniper(CEntity * entity) {
  115.  bool isPlayer = false;
  116.  
  117.  if ((CEntity*)CPlayerPed::GetPlayerPed() == entity)
  118.           isPlayer = true;
  119.     else
  120.           isPlayer = false;
  121.  
  122.   if (isPlayer == false){
  123.           // CWeaponData::GetWeaponInfoByIndex(weaponIndex); зачем?
  124.  
  125.           if (isPlayer == true) {
  126.                   _Camera->cams[_Camera->activeCam].field_168.y * flt_69D480;
  127.               _Camera->cams[_Camera->activeCam].field_168.x * (*dword_69D398);
  128.                   _Camera->cams[_Camera->activeCam].field_168.z * flt_69D484;
  129.  
  130.              }
  131.  
  132.  
  133.  
  134.                   //  _Camera->cams[_Camera->activeCam].camPos
  135.                   /*
  136.  
  137.  
  138.  
  139.  
  140.  
  141.  
  142.                   */
  143.  
  144.  
  145.  
  146.  
  147.  
  148.      } else {
  149.              switch (_Camera->cams[_Camera->activeCam].field_C)
  150.                         {
  151.                              case 34: break;
  152.                              case  7: break;
  153.                                  case 46: break;
  154.                                  case  8: break;
  155.                  case 42: break;
  156.                                  case 39: break;
  157.                                  case 40: break;
  158.    
  159.                   return;
  160.                         }
  161.  
  162.  
  163.  
  164.     }
  165.  
  166.  
  167.  
  168.  
  169. };
  170.  
  171.  
  172.  
  173. void CWeaponSlot::BlowUpExplosiveThings(CEntity_ * entity) {
  174.         auto CWeaponBlowUpExplosiveThing = (void (__thiscall*)(CWeaponSlot * weaponSlot, CEntity_ * entity))0x05C8AE0;
  175.         CWeaponBlowUpExplosiveThing(this, entity);
  176. };
  177.  
  178.  


vcRenderWare.h

Код: C++
  1. #pragma pack (push, 1)
  2.  
  3. class RwRGBA {
  4. public:
  5.       char red;
  6.           char green;
  7.           char blue;
  8.           char alpha;
  9.      __inline RwRGBA () {}
  10.      __inline RwRGBA (BYTE r, BYTE g, BYTE b, BYTE a) { red = r; green = g; blue = b; alpha = a; }
  11. };
  12.  
  13.  
  14.  
  15.  
  16. struct RwV3d{
  17.   float x;
  18.   float y;
  19.   float z;
  20. };
  21.  
  22. struct RwRect{
  23.         float x;
  24.     float y;
  25.     float w;
  26.     float h;
  27. };
  28.  
  29.  
  30. struct RwMatrix {
  31.   RwV3d right;
  32.   int flags;
  33.   RwV3d top;
  34.   int field_1C;
  35.   RwV3d at;
  36.   int field_2C;
  37.   RwV3d pos;
  38.   int field_3C;
  39. };
  40.  
  41. struct  RwBBox{
  42.  RwV3d sup;
  43.  RwV3d inf;
  44. };
  45.  
  46.  
  47. struct RwSphere{
  48.   RwV3d center;
  49.   float radius;
  50. };
  51.  
  52.  
  53. struct CMatrix {
  54.  RwMatrix __parent;        
  55.  int matrixPtr;                
  56.  int haveRwMatrix;
  57. };
  58.  
  59. struct CPlacable{
  60.  CMatrix matrix;
  61. };
  62.  
  63.  
  64. #pragma pack (pop)


vcPhysic.h

Код: C++
  1. #pragma pack (push, 1)
  2.  
  3. struct CEntity{
  4.  DWORD __vmt;
  5.  CPlacable placable;
  6.  DWORD rwObject;
  7.  BYTE flags;
  8.  BYTE type;
  9.  BYTE field_52;
  10.  BYTE field_53;
  11.  BYTE field_54;
  12.  BYTE field_55;
  13.  BYTE field_56;
  14.  BYTE field_57;
  15.  WORD field_58;
  16.  WORD field_5A;
  17.  WORD modelIndex;
  18.  BYTE buildingIsland;
  19.  BYTE interior;
  20.  DWORD pReference;
  21. };
  22.  
  23.  
  24. struct CPhysical{
  25.  CEntity __parent;
  26.  DWORD audioID;
  27.  DWORD field_68;
  28.  DWORD field_6C;
  29.  RwV3d velocity;
  30.  RwV3d angularVelocity;
  31.  DWORD field_88;
  32.  DWORD field_8C;
  33.  DWORD field_90;
  34.  DWORD field_94;
  35.  DWORD field_98;
  36.  DWORD field_9C;
  37.  DWORD field_A0;
  38.  DWORD field_A4;
  39.  DWORD field_A8;
  40.  DWORD field_AC;
  41.  DWORD field_B0;
  42.  DWORD field_B4;
  43.  DWORD fMass;
  44.  DWORD fTurnMass;
  45.  DWORD field_C0;
  46.  float AirResistance;
  47.  DWORD Elasticy;
  48.  DWORD PercentSubmerged;
  49.  RwV3d CenterOfMass;
  50.  DWORD field_DC;
  51.  DWORD ptrNode;
  52.  BYTE field_E4;
  53.  BYTE field_E5;
  54.  BYTE field_E6;
  55.  BYTE field_E7;
  56.  DWORD field_E8;
  57.  DWORD field_EC;
  58.  DWORD field_F0;
  59.  DWORD field_F4;
  60.  DWORD field_F8;
  61.  DWORD field_FC;
  62.  DWORD field_100;
  63.  DWORD field_104;
  64.  DWORD field_108;
  65.  DWORD field_10C;
  66.  DWORD field_110;
  67.  DWORD field_114;
  68.  WORD field_118;
  69.  BYTE field_11A;
  70.  BYTE field_11B;
  71.  BYTE field_11C;
  72.  BYTE islandNo;
  73.  WORD __padding;
  74. };
  75.  
  76. #pragma pack (pop)
  77.  
  78.  


vcCamera.h

Код: C++
  1. #pragma pack (push, 1)
  2.  
  3.  
  4. struct CCam {
  5.  BYTE field_0;
  6.  BYTE field_1;
  7.  BYTE field_2;
  8.  DWORD field_3;
  9.  BYTE field_7;
  10.  BYTE field_8;
  11.  BYTE field_9;
  12.  BYTE field_A;
  13.  BYTE field_B;
  14.  WORD field_C;
  15.  BYTE field_E;
  16.  BYTE field_F;
  17.  BYTE field_10;
  18.  BYTE field_11;
  19.  BYTE field_12;
  20.  BYTE field_13;
  21.  DWORD field_14;
  22.  DWORD field_18;
  23.  DWORD field_1C;
  24.  DWORD field_20;
  25. BYTE field_24;
  26. BYTE field_25;
  27. BYTE field_26;
  28. BYTE field_27;
  29. DWORD field_28;
  30. DWORD field_2C;
  31. DWORD field_30;
  32. DWORD field_34;
  33. DWORD field_38;
  34. BYTE field_3C;
  35. BYTE field_3D;
  36. BYTE field_3E;
  37. BYTE field_3F;
  38. BYTE field_40;
  39. BYTE field_41;
  40. BYTE field_42;
  41. BYTE field_43;
  42. BYTE field_44;
  43. BYTE field_45;
  44. BYTE field_46;
  45. BYTE field_47;
  46. DWORD field_48;
  47. DWORD field_4C;
  48. DWORD field_50;
  49. DWORD field_54;
  50. BYTE field_58;
  51. BYTE field_59;
  52. BYTE field_5A;
  53. BYTE field_5B;
  54. DWORD field_5C;
  55. DWORD field_60;
  56. DWORD field_64;
  57. DWORD field_68;
  58. DWORD field_6C;
  59. BYTE field_70;
  60. BYTE field_71;
  61. BYTE field_72;
  62. BYTE field_73;
  63. BYTE field_74;
  64. BYTE field_75;
  65. BYTE field_76;
  66. BYTE field_77;
  67. BYTE field_78;
  68. BYTE field_79;
  69. BYTE field_7A;
  70. BYTE field_7B;
  71. DWORD field_7C;
  72. DWORD field_80;
  73. DWORD field_84;
  74. DWORD field_88;
  75. DWORD field_8C;
  76. BYTE field_90;
  77. BYTE field_91;
  78. BYTE field_92;
  79. BYTE field_93;
  80. DWORD field_94;
  81. DWORD field_98;
  82. BYTE field_9C;
  83. BYTE field_9D;
  84. BYTE field_9E;
  85. BYTE field_9F;
  86. BYTE field_A0;
  87. BYTE field_A1;
  88. BYTE field_A2;
  89. BYTE field_A3;
  90. BYTE field_A4;
  91. BYTE field_A5;
  92. BYTE field_A6;
  93. BYTE field_A7;
  94. BYTE field_A8;
  95. BYTE field_A9;
  96. BYTE field_AA;
  97. BYTE field_AB;
  98. BYTE field_AC;
  99. BYTE field_AD;
  100. BYTE field_AE;
  101. BYTE field_AF;
  102. DWORD field_B0;
  103. DWORD field_B4;
  104. BYTE field_B8;
  105. BYTE field_B9;
  106. BYTE field_BA;
  107. BYTE field_BB;
  108. DWORD field_BC;
  109. DWORD field_C0;
  110. DWORD field_C4;
  111. DWORD field_C8;
  112. DWORD field_CC;
  113. DWORD field_D0;
  114. BYTE field_D4;
  115. BYTE field_D5;
  116. BYTE field_D6;
  117. BYTE field_D7;
  118. DWORD field_D8;
  119. DWORD field_DC;
  120. DWORD field_E0;
  121. DWORD field_E4;
  122. DWORD field_E8;
  123. DWORD field_EC;
  124. DWORD field_F0;
  125. DWORD field_F4;
  126. DWORD field_F8;
  127. BYTE field_FC;
  128. BYTE field_FD;
  129. BYTE field_FE;
  130. BYTE field_FF;
  131. BYTE field_100;
  132. BYTE field_101;
  133. BYTE field_102;
  134. BYTE field_103;
  135. BYTE field_104;
  136. BYTE field_105;
  137. BYTE field_106;
  138. BYTE field_107;
  139. BYTE field_108;
  140. BYTE field_109;
  141. BYTE field_10A;
  142. BYTE field_10B;
  143. BYTE field_10C;
  144. BYTE field_10D;
  145. BYTE field_10E;
  146. BYTE field_10F;
  147. BYTE field_110;
  148. BYTE field_111;
  149. BYTE field_112;
  150. BYTE field_113;
  151. BYTE field_114;
  152. BYTE field_115;
  153. BYTE field_116;
  154. BYTE field_117;
  155. BYTE field_118;
  156. BYTE field_119;
  157. BYTE field_11A;
  158. BYTE field_11B;
  159. BYTE field_11C;
  160. BYTE field_11D;
  161. BYTE field_11E;
  162. BYTE field_11F;
  163. BYTE field_120;
  164. BYTE field_121;
  165. BYTE field_122;
  166. BYTE field_123;
  167. BYTE field_124;
  168. BYTE field_125;
  169. BYTE field_126;
  170. BYTE field_127;
  171. BYTE field_128;
  172. BYTE field_129;
  173. BYTE field_12A;
  174. BYTE field_12B;
  175. BYTE field_12C;
  176. BYTE field_12D;
  177. BYTE field_12E;
  178. BYTE field_12F;
  179. BYTE field_130;
  180. BYTE field_131;
  181. BYTE field_132;
  182. BYTE field_133;
  183. BYTE field_134;
  184. BYTE field_135;
  185. BYTE field_136;
  186. BYTE field_137;
  187. BYTE field_138;
  188. BYTE field_139;
  189. BYTE field_13A;
  190. BYTE field_13B;
  191. BYTE field_13C;
  192. BYTE field_13D;
  193. BYTE field_13E;
  194. BYTE field_13F;
  195. BYTE field_140;
  196. BYTE field_141;
  197. BYTE field_142;
  198. BYTE field_143;
  199. BYTE field_144;
  200. BYTE field_145;
  201. BYTE field_146;
  202. BYTE field_147;
  203. BYTE field_148;
  204. BYTE field_149;
  205. BYTE field_14A;
  206. BYTE field_14B;
  207. BYTE field_14C;
  208. BYTE field_14D;
  209. BYTE field_14E;
  210. BYTE field_14F;
  211. BYTE field_150;
  212. BYTE field_151;
  213. BYTE field_152;
  214. BYTE field_153;
  215. BYTE field_154;
  216. BYTE field_155;
  217. BYTE field_156;
  218. BYTE field_157;
  219. BYTE field_158;
  220. BYTE field_159;
  221. BYTE field_15A;
  222. BYTE field_15B;
  223. BYTE field_15C;
  224. BYTE field_15D;
  225. BYTE field_15E;
  226. BYTE field_15F;
  227. BYTE field_160;
  228. BYTE field_161;
  229. BYTE field_162;
  230. BYTE field_163;
  231. BYTE field_164;
  232. BYTE field_165;
  233. BYTE field_166;
  234. BYTE field_167;
  235. RwV3d field_168;
  236. RwV3d camPos;
  237. BYTE field_180;
  238. BYTE field_181;
  239. BYTE field_182;
  240. BYTE field_183;
  241. BYTE field_184;
  242. BYTE field_185;
  243. BYTE field_186;
  244. BYTE field_187;
  245. BYTE field_188;
  246. BYTE field_189;
  247. BYTE field_18A;
  248.  BYTE field_18B;
  249.  DWORD field_18C;
  250.  DWORD field_190;
  251.  DWORD field_194;
  252.  RwV3d field_198[2];
  253.  DWORD targetedEntity;
  254.  BYTE field_1B4;
  255.  BYTE field_1B5;
  256.  BYTE field_1B6;
  257.  BYTE field_1B7;
  258.  BYTE field_1B8;
  259.  BYTE field_1B9;
  260.  BYTE field_1BA;
  261.  BYTE field_1BB;
  262.  DWORD field_1BC;
  263.  DWORD field_1C0;
  264.  DWORD field_1C4;
  265.  BYTE field_1C8;
  266.  BYTE field_1C9;
  267.  BYTE field_1CA;
  268.  BYTE field_1CB;
  269. };
  270.  
  271. struct CCamera {
  272.  CPlacable __parent;
  273.  BYTE field_48;
  274.  BYTE field_49;
  275.  BYTE field_4A;
  276.  BYTE field_4B;
  277.  BYTE field_4C;
  278.  BYTE field_4D;
  279.  BYTE field_4E;
  280.  BYTE field_4F;
  281.  BYTE field_50;
  282.  BYTE field_51;
  283.  BYTE field_52;
  284.  BYTE field_53;
  285. BYTE field_54;
  286. BYTE field_55;
  287. BYTE field_56;
  288. BYTE field_57;
  289. BYTE field_58;
  290. BYTE field_59;
  291. BYTE field_5A;
  292. BYTE field_5B;
  293. BYTE field_5C;
  294. BYTE field_5D;
  295. BYTE field_5E;
  296. BYTE field_5F;
  297. BYTE field_60;
  298. BYTE field_61;
  299. BYTE field_62;
  300. BYTE field_63;
  301. BYTE field_64;
  302. BYTE field_65;
  303. BYTE field_66;
  304. BYTE field_67;
  305. BYTE field_68;
  306. BYTE field_69;
  307. BYTE field_6A;
  308. BYTE field_6B;
  309. BYTE field_6C;
  310. BYTE wideScreen;
  311. BYTE field_6E;
  312. BYTE field_6F;
  313. BYTE field_70;
  314. BYTE field_71;
  315. BYTE field_72;
  316. BYTE field_73;
  317. BYTE field_74;
  318. BYTE field_75;
  319. BYTE activeCam;
  320. BYTE field_77;
  321. DWORD TimeEndShaking;
  322. BYTE field_7C;
  323. BYTE field_7D;
  324. BYTE field_7E;
  325. BYTE field_7F;
  326. DWORD field_80;
  327. BYTE field_84;
  328. BYTE field_85;
  329. BYTE field_86;
  330. BYTE field_87;
  331. BYTE field_88;
  332. BYTE field_89;
  333. BYTE field_8A;
  334. BYTE field_8B;
  335. DWORD field_8C;
  336. DWORD field_90;
  337. DWORD field_94;
  338. DWORD field_98;
  339. BYTE field_9C;
  340. BYTE field_9D;
  341. BYTE field_9E;
  342. BYTE field_9F;
  343. BYTE field_A0;
  344. BYTE field_A1;
  345. BYTE field_A2;
  346. BYTE field_A3;
  347. DWORD field_A4;
  348. DWORD field_A8;
  349. DWORD field_AC;
  350. DWORD field_B0;
  351. DWORD field_B4;
  352. DWORD field_B8;
  353. BYTE field_BC;
  354. BYTE field_BD;
  355. BYTE field_BE;
  356. BYTE field_BF;
  357. DWORD field_C0;
  358. DWORD field_C4;
  359. DWORD field_C8;
  360. DWORD field_CC;
  361. DWORD field_D0;
  362. BYTE field_D4;
  363. BYTE field_D5;
  364. BYTE field_D6;
  365. BYTE field_D7;
  366. BYTE field_D8;
  367. BYTE field_D9;
  368. BYTE field_DA;
  369. BYTE field_DB;
  370. DWORD field_DC;
  371. BYTE field_E0;
  372. BYTE field_E1;
  373. BYTE field_E2;
  374. BYTE field_E3;
  375. DWORD field_E4;
  376. BYTE field_E8;
  377. BYTE field_E9;
  378. BYTE field_EA;
  379. BYTE field_EB;
  380. BYTE field_EC;
  381. BYTE field_ED;
  382. BYTE field_EE;
  383. BYTE field_EF;
  384. DWORD field_F0;
  385. DWORD draw_distance;
  386. BYTE field_F8;
  387. BYTE field_F9;
  388. BYTE field_FA;
  389. BYTE field_FB;
  390. BYTE field_FC;
  391. BYTE field_FD;
  392. BYTE field_FE;
  393. BYTE field_FF;
  394. BYTE field_100;
  395. BYTE field_101;
  396. BYTE field_102;
  397. BYTE field_103;
  398. BYTE field_104;
  399. BYTE field_105;
  400. BYTE field_106;
  401. BYTE field_107;
  402. BYTE field_108;
  403. BYTE field_109;
  404. BYTE field_10A;
  405. BYTE field_10B;
  406. BYTE field_10C;
  407. BYTE field_10D;
  408. BYTE field_10E;
  409. BYTE field_10F;
  410. BYTE field_110;
  411. BYTE field_111;
  412. BYTE field_112;
  413. BYTE field_113;
  414. BYTE field_114;
  415. BYTE field_115;
  416. BYTE field_116;
  417. BYTE field_117;
  418. BYTE field_118;
  419. BYTE field_119;
  420. BYTE field_11A;
  421. BYTE field_11B;
  422. BYTE field_11C;
  423. BYTE field_11D;
  424. BYTE field_11E;
  425. BYTE field_11F;
  426. DWORD zAngle;
  427. DWORD field_124;
  428. DWORD field_128;
  429. DWORD ShakingStrength;
  430. DWORD field_130;
  431. DWORD field_134;
  432. DWORD field_138;
  433. DWORD fNearClipPlain;
  434. BYTE field_140;
  435. BYTE field_141;
  436. BYTE field_142;
  437. BYTE field_143;
  438. BYTE field_144;
  439. BYTE field_145;
  440. BYTE field_146;
  441. BYTE field_147;
  442. DWORD field_148;
  443. DWORD field_14C;
  444. DWORD field_150;
  445. DWORD WidescreenBorderHeight;
  446. DWORD field_158;
  447. BYTE field_15C;
  448. BYTE field_15D;
  449. BYTE field_15E;
  450. BYTE field_15F;
  451. DWORD field_160;
  452. DWORD field_164;
  453. DWORD field_168;
  454. BYTE field_16C;
  455. BYTE field_16D;
  456. BYTE field_16E;
  457. BYTE field_16F;
  458. BYTE field_170;
  459. BYTE field_171;
  460. BYTE field_172;
  461. BYTE field_173;
  462. BYTE field_174;
  463. BYTE field_175;
  464. BYTE field_176;
  465. BYTE field_177;
  466. DWORD field_178;
  467. WORD field_17C;
  468. BYTE field_17E;
  469. BYTE field_17F;
  470. DWORD field_180;
  471. BYTE field_184;
  472. BYTE field_185;
  473. BYTE field_186;
  474. BYTE field_187;
  475. CCam cams[3];
  476. DWORD field_6EC;
  477. DWORD field_6F0;
  478. BYTE field_6F4;
  479. BYTE field_6F5;
  480. BYTE field_6F6;
  481. BYTE field_6F7;
  482. BYTE field_6F8;
  483. BYTE field_6F9;
  484. BYTE field_6FA;
  485. BYTE field_6FB;
  486. BYTE field_6FC;
  487. BYTE field_6FD;
  488. BYTE field_6FE;
  489. BYTE field_6FF;
  490. DWORD field_700;
  491. DWORD field_704;
  492. WORD field_708;
  493. WORD field_70A;
  494. RwV3d field_70C;
  495. RwV3d field_718;
  496. RwV3d field_724;
  497. RwV3d targetPoint;
  498. RwV3d cameraPosition;
  499. RwV3d cameraRotation;
  500. RwV3d field_754;
  501. RwV3d field_760;
  502. RwV3d field_76C;
  503. RwV3d field_778;
  504. RwV3d field_784;
  505. RwV3d field_790;
  506. RwV3d field_79C;
  507. RwV3d field_7A8;
  508. RwV3d field_7B4;
  509. RwV3d field_7C0;
  510. RwV3d field_7CC;
  511. RwV3d field_7D8;
  512. RwV3d field_7E4;
  513. RwV3d field_7F0;
  514. RwV3d field_7FC;
  515. DWORD rwCamera;
  516. DWORD targetedEntity;
  517. DWORD field_810[4];
  518. CMatrix field_820;
  519. BYTE cameraInFreeMode;
  520. BYTE field_869;
  521. BYTE field_86A;
  522. BYTE fading;
  523. BYTE field_86C;
  524. BYTE field_86D;
  525. BYTE field_86E;
  526. BYTE field_86F;
  527. CMatrix viewMatrix;
  528. RwV3d field_8B8;
  529. RwV3d field_8C4;
  530. RwV3d field_8D0;
  531. RwV3d field_8DC;
  532. RwV3d field_8E8;
  533. RwV3d field_8F4;
  534. RwV3d field_900;
  535. BYTE field_90C;
  536. BYTE field_90D;
  537. BYTE field_90E;
  538. BYTE field_90F;
  539. DWORD _fadeAlpha;
  540. DWORD field_914;
  541. DWORD _fadeTimeInSec;
  542. DWORD field_91C;
  543. DWORD field_920;
  544. DWORD field_924;
  545. BYTE field_928;
  546. BYTE field_929;
  547. BYTE field_92A;
  548. BYTE field_92B;
  549. BYTE field_92C;
  550. BYTE field_92D;
  551. BYTE field_92E;
  552. BYTE field_92F;
  553. DWORD field_930;
  554. BYTE field_934;
  555.  BYTE field_935;
  556.  BYTE field_936;
  557.  BYTE field_937;
  558.  BYTE field_938;
  559.  BYTE field_939;
  560.  BYTE field_93A;
  561.  BYTE field_93B;
  562.  BYTE field_93C;
  563.  BYTE field_93D;
  564.  BYTE field_93E;
  565.  BYTE field_93F;
  566.  WORD fadeFlag;
  567.  BYTE field_942;
  568.  BYTE field_943;
  569.  DWORD field_944;
  570.  WORD field_948;
  571.  WORD field_94A;
  572.  WORD field_94C;
  573.  BYTE field_94E;
  574.  BYTE field_94F;
  575.  DWORD timeStartFading;
  576.  DWORD field_954;
  577. };
  578.  
  579.  
  580. #pragma pack (pop)
  581.  
  582.  



vcActors.h
Код: C++
  1. #pragma pack (push, 1)
  2.  
  3.  
  4. struct CColModel{
  5.   RwSphere sphere;
  6.   RwBBox bbox;
  7.   WORD field_28;
  8.   WORD field_2A;
  9.   WORD field_2C;
  10.   BYTE field_2E;
  11.   BYTE field_2F;
  12.   BYTE field_30;
  13.   BYTE field_31;
  14.   BYTE field_32;
  15.   BYTE field_33;
  16.   DWORD field_34;
  17.   DWORD colData;
  18.   DWORD field_3C;
  19.   DWORD field_40;
  20.   DWORD field_44;
  21.   DWORD field_48;
  22. };
  23.  
  24.  
  25.  
  26. struct CRoutePoint{
  27.  WORD field_0;
  28.  WORD field_2;
  29.  WORD _x;
  30.  WORD _y;
  31.  WORD _z;
  32.  BYTE field_A;
  33.  BYTE field_B;
  34.  WORD nextPointIndex;
  35.  BYTE field_E;
  36.  BYTE field_F;
  37.  BYTE flags;
  38.  BYTE field_11;
  39.  BYTE field_12;
  40.  BYTE field_13;
  41. };
  42.  
  43. struct CPedIK{
  44.  DWORD pPed;
  45.  DWORD field_4;
  46.  DWORD field_8;
  47.  DWORD field_C;
  48.  DWORD field_10;
  49.  DWORD field_14;
  50.  DWORD field_18;
  51.  DWORD field_1C;
  52.  DWORD field_20;
  53.  DWORD field_24;
  54. };
  55.  
  56.  
  57. class CPed{
  58.  
  59.  public:
  60.   CPhysical __parent;
  61.   BYTE field_120;
  62.   BYTE field_121;
  63.   BYTE field_122;
  64.   BYTE field_123;
  65.   BYTE field_124;
  66.   BYTE field_125;
  67.   BYTE field_126;
  68.   BYTE field_127;
  69.   BYTE field_128;
  70.   BYTE field_129;
  71.   BYTE field_12A;
  72.   BYTE field_12B;
  73.   BYTE field_12C;
  74.   BYTE field_12D;
  75.   BYTE field_12E;
  76.   BYTE field_12F;
  77.   BYTE field_130;
  78.   BYTE field_131;
  79.   BYTE field_132;
  80.   BYTE field_133;
  81.   BYTE field_134;
  82.   BYTE field_135;
  83.   BYTE field_136;
  84.   BYTE field_137;
  85.   BYTE field_138;
  86.  BYTE field_139;
  87.  BYTE field_13A;
  88.  BYTE field_13B;
  89.  BYTE field_13C;
  90.  BYTE field_13D;
  91.  BYTE field_13E;
  92.  BYTE field_13F;
  93.  BYTE field_140;
  94.  BYTE field_141;
  95.  BYTE field_142;
  96.  BYTE field_143;
  97.  BYTE field_144;
  98.  BYTE field_145;
  99.  BYTE field_146;
  100. BYTE field_147;
  101. BYTE field_148;
  102. BYTE field_149;
  103. BYTE field_14A;
  104. BYTE field_14B;
  105. BYTE field_14C;
  106. BYTE field_14D;
  107. BYTE field_14E;
  108.  BYTE field_Blood;
  109. BYTE field_150;
  110. BYTE flags;
  111. BYTE field_152;
  112. BYTE field_153;
  113. BYTE field_154;
  114. BYTE field_155;
  115. BYTE field_156;
  116. BYTE field_157;
  117. BYTE field_158;
  118. BYTE field_159;
  119. BYTE field_15A;
  120. BYTE field_15B;
  121. BYTE field_15C;
  122. BYTE field_15D;
  123. BYTE field_15E;
  124. BYTE field_15F;
  125. BYTE reference;
  126. BYTE field_161;
  127. BYTE field_162;
  128. BYTE field_163;
  129. DWORD objective;
  130. DWORD field_168;
  131. DWORD field_16C;
  132. DWORD targetEntity;
  133. BYTE field_174;
  134. BYTE field_175;
  135. BYTE field_176;
  136. BYTE field_177;
  137. BYTE field_178;
  138. BYTE field_179;
  139. BYTE field_17A;
  140. BYTE field_17B;
  141. BYTE field_17C;
  142. BYTE field_17D;
  143. BYTE field_17E;
  144. BYTE field_17F;
  145. DWORD field_180;
  146. DWORD damageEntity;
  147. DWORD field_188;
  148. DWORD threatPlayer;
  149. DWORD field_190;
  150. DWORD field_194;
  151. DWORD field_198;
  152. DWORD field_19C;
  153. DWORD field_1A0;
  154. DWORD field_1A4;
  155. DWORD field_1A8;
  156. BYTE field_1AC;
  157. BYTE field_1AD;
  158. BYTE field_1AE;
  159. BYTE field_1AF;
  160. BYTE field_1B0;
  161. BYTE field_1B1;
  162. BYTE field_1B2;
  163. BYTE field_1B3;
  164. BYTE field_1B4;
  165. BYTE field_1B5;
  166. BYTE field_1B6;
  167. BYTE field_1B7;
  168. BYTE field_1B8;
  169. BYTE field_1B9;
  170. BYTE field_1BA;
  171. BYTE field_1BB;
  172. BYTE field_1BC;
  173. BYTE field_1BD;
  174. BYTE field_1BE;
  175. BYTE field_1BF;
  176. BYTE field_1C0;
  177. BYTE field_1C1;
  178. BYTE field_1C2;
  179. BYTE field_1C3;
  180. BYTE field_1C4;
  181. BYTE field_1C5;
  182. BYTE field_1C6;
  183. BYTE field_1C7;
  184. BYTE field_1C8;
  185. BYTE field_1C9;
  186. BYTE field_1CA;
  187. BYTE field_1CB;
  188. BYTE field_1CC;
  189. BYTE field_1CD;
  190. BYTE field_1CE;
  191. BYTE field_1CF;
  192. BYTE field_1D0;
  193. BYTE field_1D1;
  194. BYTE field_1D2;
  195. BYTE field_1D3;
  196. BYTE field_1D4;
  197. BYTE field_1D5;
  198. BYTE field_1D6;
  199. BYTE field_1D7;
  200. BYTE field_1D8;
  201. BYTE field_1D9;
  202. BYTE field_1DA;
  203. BYTE field_1DB;
  204. BYTE field_1DC;
  205. BYTE field_1DD;
  206. BYTE field_1DE;
  207. BYTE field_1DF;
  208. BYTE field_1E0;
  209. BYTE field_1E1;
  210. BYTE field_1E2;
  211. BYTE field_1E3;
  212. BYTE field_1E4;
  213. BYTE field_1E5;
  214. BYTE field_1E6;
  215. BYTE field_1E7;
  216. BYTE field_1E8;
  217. BYTE field_1E9;
  218. BYTE field_1EA;
  219. BYTE field_1EB;
  220. BYTE field_1EC;
  221. BYTE field_1ED;
  222. BYTE field_1EE;
  223. BYTE field_1EF;
  224. DWORD field_1F0;
  225. DWORD field_1F4;
  226. DWORD field_1F8;
  227. DWORD field_1FC;
  228. DWORD field_200;
  229. DWORD field_204;
  230. DWORD field_208;
  231. DWORD field_20C;
  232. CPedIK pedIK;
  233. DWORD field_238;
  234. DWORD field_23C;
  235. DWORD field_240;
  236. DWORD field_244;
  237. DWORD field_248;
  238. DWORD field_24C;
  239. DWORD field_250;
  240. DWORD field_254;
  241. DWORD animationID;
  242. DWORD animationTime;
  243. DWORD field_260;
  244. DWORD field_264;
  245. DWORD field_268;
  246. DWORD field_26C;
  247. DWORD field_270;
  248. DWORD field_274;
  249. DWORD field_278;
  250. DWORD field_27C;
  251. WORD field_280;
  252. WORD field_282;
  253. DWORD field_284;
  254. DWORD field_288;
  255. DWORD field_28C;
  256. CRoutePoint pedRoutes[8];
  257. DWORD field_330;
  258. BYTE field_334;
  259. BYTE field_335;
  260. BYTE field_336;
  261. BYTE field_337;
  262. DWORD field_338;
  263. DWORD field_33C;
  264. DWORD field_340;
  265. DWORD field_344;
  266. DWORD field_348;
  267. DWORD field_34C;
  268. DWORD field_350;
  269. float health;
  270. float armour;
  271. BYTE field_35C;
  272. BYTE field_35D;
  273. BYTE field_35E;
  274. BYTE field_35F;
  275. WORD field_360;
  276. WORD field_362;
  277. WORD field_364;
  278. WORD field_366;
  279. BYTE field_368;
  280. BYTE field_369;
  281. BYTE field_36A;
  282. BYTE field_36B;
  283. DWORD field_36C;
  284. DWORD field_370;
  285. DWORD field_374;
  286. DWORD field_378;
  287. DWORD headingChangeRate;
  288. WORD field_380;
  289. WORD field_382;
  290. DWORD field_384;
  291. DWORD field_388;
  292. DWORD field_38C;
  293. DWORD field_390;
  294. DWORD field_394;
  295. DWORD field_398;
  296. DWORD field_39C;
  297. DWORD field_3A0;
  298. DWORD field_3A4;
  299. DWORD pVehicle;
  300. BYTE inVehicle;
  301. BYTE field_3AD;
  302. BYTE field_3AE;
  303. BYTE field_3AF;
  304. DWORD field_3B0;
  305. DWORD field_3B4;
  306. BYTE field_3B8;
  307. BYTE field_3B9;
  308. BYTE field_3BA;
  309. BYTE field_3BB;
  310. DWORD field_3BC;
  311. DWORD field_3C0;
  312. BYTE field_3C4;
  313. BYTE field_3C5;
  314. WORD field_3C6;
  315. BYTE field_3C8;
  316. BYTE field_3C9;
  317. BYTE field_3CA;
  318. BYTE field_3CB;
  319. DWORD field_3CC;
  320. DWORD field_3D0;
  321. DWORD pedType;
  322. DWORD pedStatsPtr;
  323. DWORD field_3DC;
  324. DWORD field_3E0;
  325. DWORD field_3E4;
  326. DWORD field_3E8;
  327. DWORD field_3EC;
  328. BYTE field_3F0;
  329. BYTE field_3F1;
  330. BYTE field_3F2;
  331. BYTE field_3F3;
  332. DWORD field_3F4;
  333. DWORD field_3F8;
  334. BYTE field_3FC;
  335. BYTE field_3FD;
  336. BYTE field_3FE;
  337. BYTE field_3FF;
  338. DWORD field_400;
  339. DWORD field_404;
  340. CWeaponSlot weaponSlots[10];
  341. DWORD field_4F8;
  342. DWORD currentWeaponId;
  343. DWORD currentWeaponAmmo;
  344. BYTE currentWeapon;
  345. BYTE field_505;
  346. BYTE weaponAccuracy;
  347. BYTE field_507;
  348. DWORD field_508;
  349. BYTE field_50C;
  350. BYTE field_50D;
  351. BYTE field_50E;
  352. BYTE field_50F;
  353. BYTE field_510;
  354. BYTE field_511;
  355. BYTE field_512;
  356. BYTE field_513;
  357. DWORD field_514;
  358. DWORD field_518;
  359. BYTE field_51C;
  360. BYTE field_51D;
  361. BYTE field_51E;
  362. BYTE field_51F;
  363. BYTE field_520;
  364. BYTE field_521;
  365. BYTE field_522;
  366. BYTE field_523;
  367. DWORD fire;
  368. DWORD field_528;
  369. DWORD field_52C;
  370. DWORD field_530;
  371. DWORD field_534;
  372. DWORD field_538;
  373. DWORD field_53C;
  374. DWORD field_540;
  375. DWORD field_544;
  376. DWORD field_548;
  377. DWORD field_54C;
  378. DWORD field_550;
  379. DWORD field_554;
  380. DWORD field_558;
  381. DWORD ClosestPedsTimer;
  382. DWORD field_560;
  383. DWORD field_564;
  384. BYTE field_568;
  385. bool bleeding;
  386. BYTE field_56A;
  387. BYTE field_56B;
  388. DWORD closestPeds[10];
  389. WORD numberOfPeds;
  390. WORD money;
  391. DWORD lastDamageType;
  392. DWORD lastDamageEntity;
  393. DWORD field_5A0;
  394. BYTE field_5A4;
  395. BYTE field_5A5;
  396. BYTE field_5A6;
  397. BYTE field_5A7;
  398. BYTE field_5A8;
  399. BYTE field_5A9;
  400. BYTE field_5AA;
  401. BYTE field_5AB;
  402. BYTE field_5AC;
  403. BYTE field_5AD;
  404. BYTE field_5AE;
  405. BYTE field_5AF;
  406. BYTE field_5B0;
  407. BYTE field_5B1;
  408. BYTE field_5B2;
  409. BYTE field_5B3;
  410. BYTE field_5B4;
  411. BYTE field_5B5;
  412. BYTE field_5B6;
  413. BYTE field_5B7;
  414. DWORD field_5B8;
  415. DWORD field_5BC;
  416. DWORD field_5C0;
  417. DWORD field_5C4;
  418. BYTE field_5C8;
  419. BYTE field_5C9;
  420. BYTE field_5CA;
  421. BYTE field_5CB;
  422. BYTE field_5CC;
  423. BYTE field_5CD;
  424. BYTE field_5CE;
  425. BYTE field_5CF;
  426. DWORD field_5D0;
  427. DWORD field_5D4;
  428. WORD field_5D8;
  429. WORD field_5DA;
  430. BYTE muted;
  431. BYTE field_5DD;
  432. BYTE field_5DE;
  433. BYTE field_5DF;
  434. DWORD field_5E0;
  435. DWORD field_5E4;
  436. DWORD field_5E8;
  437. DWORD field_5EC;
  438. DWORD field_5F0;
  439. };
  440.  
  441. class CPlayerPed{
  442.  
  443. public:
  444.  CPed __parent;
  445.  DWORD wanted;
  446.  DWORD field_5F8;
  447.  DWORD field_5FC;
  448.  DWORD field_600;
  449.  DWORD field_604;
  450.  DWORD field_608;
  451.  BYTE field_60C;
  452.  BYTE field_60D;
  453.  BYTE field_60E;
  454.  BYTE field_60F;
  455.  DWORD field_610;
  456.  DWORD field_614;
  457.  DWORD field_618;
  458.  BYTE field_61C;
  459.  BYTE field_61D;
  460.  BYTE field_61E;
  461.  BYTE field_61F;
  462.  DWORD field_620;
  463.  DWORD targetableObjects[4];
  464.  DWORD field_634;
  465.  BYTE drunkVisuals;
  466.  BYTE field_639;
  467.  BYTE field_63A;
  468.  BYTE field_63B;
  469.  BYTE field_63C;
  470.  BYTE field_63D;
  471.  BYTE field_63E;
  472.  BYTE field_63F;
  473.  RwV3d field_640[6];
  474.  DWORD field_688[6];
  475.  DWORD field_6A0;
  476.  DWORD field_6A4;
  477.  DWORD field_6A8;
  478.  DWORD field_6AC;
  479.  DWORD field_6B0;
  480.  DWORD field_6B4;
  481.  WORD field_6B8;
  482.  BYTE field_6BA;
  483.  BYTE field_6BB;
  484.  DWORD field_6BC;
  485.  DWORD field_6C0;
  486.  DWORD field_6C4;
  487.  DWORD field_6C8;
  488.  DWORD field_6CC;
  489.  DWORD field_6D0;
  490.  DWORD field_6D4;
  491.  static CPed * GetPlayerPed();
  492.  void SetWantedLevelAtLeast(DWORD valueWanted);
  493.  void SetWantedLevel(DWORD valueWanted);
  494. };
  495.  
  496.  
  497.  
  498.  
  499. class CPlayer{
  500.  
  501. public:
  502.   CPlayerPed * pPed;
  503.   DWORD rcBuggy;
  504.   CColModel colModel;
  505.   DWORD field_54;
  506.   DWORD field_58;
  507.   BYTE field_5C;
  508.   BYTE field_5D;
  509.   BYTE field_5E;
  510.   BYTE field_5F;
  511.   BYTE field_60;
  512.   BYTE field_61;
  513.   BYTE field_62;
  514.   BYTE field_63;
  515.   BYTE field_64;
  516.   BYTE field_65;
  517.   BYTE field_66;
  518.   BYTE field_67;
  519.   BYTE field_68;
  520.   BYTE field_69;
  521.   BYTE field_6A;
  522.   BYTE field_6B;
  523.   BYTE field_6C;
  524.   BYTE field_6D;
  525.   BYTE field_6E;
  526.   BYTE field_6F;
  527.   BYTE field_70;
  528.   BYTE field_71;
  529.   BYTE field_72;
  530.   BYTE field_73;
  531.   BYTE field_74;
  532.   BYTE field_75;
  533.   BYTE field_76;
  534.   BYTE field_77;
  535.   BYTE field_78;
  536.   BYTE field_79;
  537.   BYTE field_7A;
  538.   BYTE field_7B;
  539.   BYTE field_7C;
  540.   BYTE field_7D;
  541.   BYTE field_7E;
  542.   BYTE field_7F;
  543.   BYTE field_80;
  544.   BYTE field_81;
  545.   BYTE field_82;
  546.   BYTE field_83;
  547.   BYTE field_84;
  548.   BYTE field_85;
  549.   BYTE field_86;
  550.   BYTE field_87;
  551.   BYTE field_88;
  552.   BYTE field_89;
  553.   BYTE field_8A;
  554.   BYTE field_8B;
  555.   BYTE field_8C;
  556.   BYTE field_8D;
  557.   BYTE field_8E;
  558.   BYTE field_8F;
  559.   BYTE field_90;
  560.   BYTE field_91;
  561.   BYTE field_92;
  562.   BYTE field_93;
  563.   BYTE field_94;
  564.   BYTE field_95;
  565.   BYTE field_96;
  566.   BYTE field_97;
  567.   BYTE field_98;
  568.   BYTE field_99;
  569.   BYTE field_9A;
  570.   BYTE field_9B;
  571.   BYTE field_9C;
  572.   BYTE field_9D;
  573.   BYTE field_9E;
  574.   BYTE field_9F;
  575.   DWORD _money;
  576.   DWORD money;
  577.   DWORD foundHiddenPackages;
  578.   DWORD totalHiddenPackages;
  579.   DWORD field_B0;
  580.   DWORD field_B4;
  581.   DWORD field_B8;
  582.   DWORD field_BC;
  583.   DWORD field_C0;
  584.   DWORD field_C4;
  585.   DWORD field_C8;
  586.   BYTE IsWastedBusted;
  587.   BYTE field_CD;
  588.   BYTE field_CE;
  589.   BYTE field_CF;
  590.   DWORD field_D0;
  591.   BYTE field_D4;
  592.   BYTE field_D5;
  593.   BYTE field_D6;
  594.   BYTE field_D7;
  595.   DWORD field_D8;
  596.   DWORD field_DC;
  597.   DWORD field_E0;
  598.   DWORD field_E4;
  599.   DWORD field_E8;
  600.   DWORD field_EC;
  601.   DWORD field_F0;
  602.   DWORD field_F4;
  603.   DWORD field_F8;
  604.   DWORD field_FC;
  605.   DWORD field_100;
  606.   DWORD field_104;
  607.   DWORD field_108;
  608.   DWORD field_10C;
  609.   DWORD field_110;
  610.   DWORD field_114;
  611.   DWORD field_118;
  612.   DWORD field_11C;
  613.   DWORD field_120;
  614.   DWORD field_124;
  615.   DWORD field_128;
  616.   DWORD field_12C;
  617.   DWORD field_130;
  618.   DWORD field_134;
  619.   DWORD field_138;
  620.   DWORD field_13C;
  621.   BYTE field_140;
  622.   BYTE field_141;
  623.   BYTE fireproof;
  624.   BYTE maxHealth;
  625.   BYTE maxArmour;
  626.   BYTE field_145;
  627.   BYTE single_free_treatment;
  628.   BYTE drive_by;
  629.   BYTE field_148;
  630.   BYTE field_149;
  631.   WORD field_14A;
  632.   BYTE skinPath[32];
  633.   DWORD playerTexture;
  634. };
  635.  
  636.  
  637. #pragma pack (pop)
  638.  
  639.  


vcActors.cpp

Код: C++
  1. #include "stdafx.h"
  2.  
  3. #include "vcRenderWare.h"
  4. #include "vcPhysic.h"
  5. #include "vcWeapon.h"
  6. #include "vcActors.h"
  7.  
  8.  
  9.  
  10. auto _currentPlayer = (BYTE*)0x0A10AFB;
  11. auto _players = (CPlayer*)0x094AD28;
  12.  
  13.  
  14. CPed * CPlayerPed::GetPlayerPed() {
  15.         return (CPed*)_players[*_currentPlayer].pPed;
  16. };
  17.  
  18. //0532070
  19. void CPlayerPed::SetWantedLevelAtLeast(DWORD valueWanted) {
  20.          auto CPlayerPed__SetWantedLevelAtLeast = (void (__thiscall*)(CPlayerPed * pPlayerPed, DWORD vvalueWanted))0x0532070;
  21.          CPlayerPed__SetWantedLevelAtLeast(this, valueWanted);
  22. };
  23.  
  24. //00532090
  25. void CPlayerPed::SetWantedLevel(DWORD valueWanted){
  26.          auto CPlayerPed__SetWantedLevel = (void (__thiscall*)(CPlayerPed * pPlayerPed, DWORD vvalueWanted))0x0532090;
  27.          CPlayerPed__SetWantedLevel(this, valueWanted);
  28. };
  29.  
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: xanser от Ноябрь 26, 2013, 04:34:09 pm
Лучше все-таки кроме обсуждения здесь сделать еще накопительную страницу, где бы все систематизировать, наподобие этой http://www.gtamodding.com/index.php?title=Memory_Addresses_%28VC%29 (http://www.gtamodding.com/index.php?title=Memory_Addresses_%28VC%29)
Иначе тема превратится в подобную этой http://gtaforums.com/topic/117195-documenting-gta3vc-memory-adresses/page-38 (http://gtaforums.com/topic/117195-documenting-gta3vc-memory-adresses/page-38), где неделю будут разыскивать адреса в куче страниц.
Ну вот я когда-то нашел такие адреса, которые там не описаны:
0x690220 - дисстанция прорисовки, в опциях можно настроить максимум 1.8
0x69022C - это максимальное расстояние до LODов, по умолчанию 300.0
(http://s6.postimg.org/ki35wmyv5/scr001.jpg) (http://s6.postimg.org/5an6ca70h/scr002.jpg)
Правда падает производительность
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: graveman от Ноябрь 26, 2013, 04:45:07 pm
Лучше все-таки кроме обсуждения здесь сделать еще накопительную страницу, где бы все систематизировать,
Я так-то думал, что будут выкладывать в виде архивов rar или zip с небольшим описанием. Сектору спасибо за выкладки.
Выкладывайте в виде архивов, пожалуйста, если информации много.
Сам копаю рендер пока. Пока выяснил, что сначала выводятся облака, прозрачные поверхности, постепенно исчезающие (fading) объекты, потом дороги, затем тачки.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Sektor от Ноябрь 26, 2013, 06:09:00 pm
Достаточно, полезные адреса 0x690220 и 0x69022C. Можно хорошо это применить в моддинге. Особенно когда речь идет об улучшении графики.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: xanser от Ноябрь 28, 2013, 04:32:02 pm
Может интересно будет, по-моему это 0x813D10 адресс указателя на полицейский вертолет.
Если он полноценный объект класса CVehicle (или CHeli), то доступны например его координаты:
Код: C++
  1. DWORD* dwPoliceHeli  = (DWORD*) (0x813D10);
  2.  
  3. if (*dwPoliceHeli)
  4. {
  5.         BYTE* bHeliBlock = (BYTE*)(*dwPoliceHeli);
  6.                        
  7.         float* fHeliX = (float*)(bHeliBlock+0x34);
  8.         float* fHeliY = (float*)(bHeliBlock+0x38);
  9.         float* fHeliZ = (float*)(bHeliBlock+0x3C);
  10.                        
  11.         *fHeliZ = max(*fHeliZ,100);     // не дает приближаться ниже 100 метров
  12. }
  13.  

Почему этот адрес никто не искал раньше, лично меня бесит этот тупой хеликоптер, лучше сделать свои вертолеты.
Можно также активировать второй вертолет, например при 6 звездах, это известный адрес 0xA10ADB

(http://s6.postimg.org/st39gls01/scr001.jpg) (http://s6.postimg.org/pxbxl52wx/scr002.jpg)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Sektor от Ноябрь 28, 2013, 06:05:50 pm
Цвет лазера снайперки LASER.
Не знаю, но может быть кому это пригодиться, изменить сам цвет лазера, не точки текстуры. Ниже дам конкретные адреса:

Код: C++
  1. 005CCB76 //Alpha
  2. 005CCB7B //B
  3. 005CCB7D //G
  4. 005CCB7F  //R


Если присвоим такие значение на примере:


Код: C++
  1.   *(BYTE*)0x05CCB7B = 0;
  2.   *(BYTE*)0x05CCB7D = 255;
  3.   *(BYTE*)0x05CCB7F = 0;
  4.  

то получим это:
(http://i017.radikal.ru/1309/57/9ab4383f1ada.png)

Если сделаем так:

Код: C++
  1.   *(BYTE*)0x05CCB7B = 255;
  2.   *(BYTE*)0x05CCB7D = 0;
  3.   *(BYTE*)0x05CCB7F  = 0;
  4.  

То результат будет такой:
(http://i054.radikal.ru/1309/4d/11a8154a3836.png)


Если захотите более подробно рассмотреть код, то кнопка "G" вбить туда адрес 05CCB7B в IDA, и вы окажитесь в нужном месте.

Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: mike43842 от Ноябрь 28, 2013, 06:19:56 pm
так как в ассемблере я понимаю мало,  sektor мог бы ты объяснить как ты определил где именно какой цвет и альфу?
005CCB76 //Alpha
005CCB7B //B
005CCB7D //G
005CCB7F  //R
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Sektor от Ноябрь 28, 2013, 06:38:54 pm
Тут совсем все просто:

Код: ASM
  1. .text:005CCB50 070 FF 35 08 D4 69 00                             push    dword_69D408    ; float
  2. .text:005CCB56 074 6A 00                                         push    0               ; char
  3. .text:005CCB58 078 FF 35 98 D3 69 00                             push    dword_69D398    ; float
  4. .text:005CCB5E 07C 6A 01                                         push    1               ; char
  5. .text:005CCB60 080 6A 00                                         push    0               ; char
  6. .text:005CCB62 084 6A 01                                         push    1               ; char
  7. .text:005CCB64 088 6A 00                                         push    0               ; char
  8. .text:005CCB66 08C 6A 00                                         push    0               ; char
  9. .text:005CCB68 090 FF 35 90 D4 69 00                             push    dword_69D490    ; float
  10. .text:005CCB6E 094 FF 35 94 D4 69 00                             push    dword_69D494    ; float
  11. .text:005CCB74 098 50                                            push    eax             ; int
  12. .text:005CCB75 09C 68 FF 00 00 00                                push    0FFh            ; char
  13. .text:005CCB7A 0A0 6A 00                                         push    0               ; char
  14. .text:005CCB7C 0A4 6A 00                                         push    0               ; char
  15. .text:005CCB7E 0A8 68 80 00 00 00                                push    80h             ; char
  16. .text:005CCB83 0AC 55                                            push    ebp             ; int
  17. .text:005CCB84 0B0 E8 17 5C F7 FF                                call    sub_5427A0
  18.  

call    sub_5427A0, это как раз и есть то, что рисует партиклы (CParticle), так вот первые у нее параметры, кроме push ebp вот эти:

Код: ASM
  1. .text:005CCB75 09C 68 FF 00 00 00                                push    0FFh            ; char
  2. .text:005CCB7A 0A0 6A 00                                         push    0               ; char
  3. .text:005CCB7C 0A4 6A 00                                         push    0               ; char
  4. .text:005CCB7E 0A8 68 80 00 00 00                                push    80h             ; char

Это и есть RGBA. Именно через push, функция при вызове принимает эти параметры как через стек. Хочу довести сведенья что вы можете по играть с этими значениями:

Код: ASM
  1. .text:005CCB50 070 FF 35 08 D4 69 00                    push    dword_69D408    ; float
  2. .text:005CCB58 078 FF 35 98 D3 69 00                             push    dword_69D398    ; float
  3. .text:005CCB68 090 FF 35 90 D4 69 00                             push    dword_69D490    ; float
  4. .text:005CCB6E 094 FF 35 94 D4 69 00                             push    dword_69D494    ; float
  5.  

Это передаются указатели на float значения, сами же значения находятся тут:

Код: ASM
  1. .data:0069D408 00 00 C0 3F                       dword_69D408    dd 3FC00000h
  2. .data:0069D398 00 00 00 00                       dword_69D398    dd 0  
  3. .data:0069D490 00 00 48 42                       dword_69D490    dd 42480000h  
  4. .data:0069D494 9A 99 99 3F                       dword_69D494    dd 3F99999Ah

Что-бы их перевести в более понятный вид float, для этого на примере выделим 3FC00000h это, затем в главном меню IDA, нажмем Edit->Operand type -> Number и наконец Floating Point и наша константа приобретает такой вид:

Код: ASM
  1. .data:0069D408 00 00 C0 3F                       dword_69D408    dd 1.5

Почему я назвал это константой?
потому-что она использовалась только для чтения, когда нажал кнопку X и проверил ее полностью:

(http://cs408217.vk.me/v408217441/775b/Kv73_hDUAz4.jpg)

Обратите внимание, как везде type установлен как r, это и есть просто чтение. Таким образом вы определили что это константа а не переменная, это трюк из реверсивной инженерии.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: graveman от Ноябрь 29, 2013, 07:38:40 am
xanser, Sektor. Да, весьма интересный материал.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: xanser от Декабрь 03, 2013, 12:45:46 pm
Цвет лазера снайперки LASER.
Не знаю, но может быть кому это пригодиться, изменить сам цвет лазера, не точки текстуры. Ниже дам конкретные адреса:

Кстати по снайперке, какие адреса отвечают за размеры оптического прицела, чтобы выровнить под широкий экран?
Нужно изменить длину, чтобы видимая область на втором скрине стала квадратной, тогда на первом будет круглой.

(http://s6.postimg.org/cutmnpzwh/scr000.jpg) (http://s6.postimg.org/ik9v8162p/scr001.jpg)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Sektor от Декабрь 03, 2013, 01:26:39 pm
Что-бы быстренько зацепиться за данный участок, по логике вещей, это находиться где в DrawHud. Сам же спрайт находиться в hud.txd название которого sitelaser.

Пока зацепился за саму загрузку спрайта TXD:

Код: ASM
  1. .text:0055CB75 008 83 3D 30 88 97 00 00                          cmp     ds:sitelaser.rwTexture, 0
  2. .text:0055CB7C 008 75 15                                         jnz     short loc_55CB93
  3. .text:0055CB7E 008 0F 77                                         emms
  4. .text:0055CB80 008 6A 00                                         push    0               ; a2
  5. .text:0055CB82 00C 68 E4 77 69 00                                push    offset aSitelaser ; "sitelaser"
  6. .text:0055CB87 010 E8 84 15 0F 00                                call    _RwReadTexture
  7. .text:0055CB8C 010 A3 30 88 97 00                                mov     ds:sitelaser.rwTexture, eax
  8. .text:0055CB91 010 59                                            pop     ecx
  9. .text:0055CB92 00C 59                                            pop     ecx

Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Август 04, 2016, 08:16:47 pm
Нашел неплохую альтернативу z_ground
Если кто не помнит - это опкод(ну и функция, ессно), которая находит координату z ниже точки X Y Z, которую указываете вы.
В виде опкода это выглядит так:
02CE: $98 = ground_z $953 $954 50.0
где $953 $954 - XY координаты точки, 50.0 - высота, с которой будет начинаться поиск "земли", $98 - полученный уровень земли.
Функция опкода используется аналогично.
Помимо жесткого ограничения(искать можно строго вертикально сверху вниз), функция находила лишь уровень статичной земли, т.е. она "не видела" ни динамические объекты, ни какие-либо другие объекты вообще.

Покопав разные куски кода(пробовал ковырять и устройство пули, и физику объектов и прочее, что пока слишком сложно для меня), вспомнил про лазерный прицел снайперки, который "реагировал" вообще на всё, имеющее COL(и все типы объектов, и транспорт, и педов).
Расковырял функцию:
0AA7: call_function 0x4D92D0 num_params 12 pop 12 0 0 0 0 1 1 1 1 7@ 6@ 5@ 4@ 10@На самом деле, в оригинале пераметры идут в другую сторону, просто в CLEO почему-то нужно делать задом наперед. Оригинал:
Код: C++
  1. CWorld::ProcessLineOfSight(CVector const&,CVector const&,CColPoint &,CEntity *&,bool,bool,bool,bool,bool,bool,bool,bool)
Короче, первый параметр - оффсет матрицы первых координат(x,y,z),
второй - оффсет вторых соответственно,
третий - оффсет вроде дальности действия поиска(если он меньше расстояния между координатами, то вроде как после этого радиуса уже не ищет)
четвертый - этот оффсет должен содержать значение ноль.
далее четыре единицы и четыре нуля.
Функция возвращает BOOL 1, если что-то обнаружено между первыми и вторыми координатами, и 0 - если ничего нет.
В CLEO возращаемое значение записывается в 10@, но не как BOOL(или BYTE), а как Integer, так что приходится преобразовывать(но это мелочи).
Как и лазер снайперки, реагирует на всё, что имеет COL. НО! Мне кажется, судя по другим участкам кода, использующим эту функцию - в тех четырех единицах и четырех нулях кроется детальная настройка того, на что реагирует данная функция, что может сделать её просто божественной заменой ground_z.

Пока ничего внятного(кроме того, что это работает!) сказать не могу, но позже отпишусь, если что-то обнаружу.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: DK от Август 05, 2016, 06:11:04 pm
Эта функция есть и в SA.
Параметры, думаю, такие же.
https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_sa/game_sa/CWorld.cpp#L7
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Август 05, 2016, 06:46:08 pm
Параметры, думаю, такие же.
Круто, ну вот и выяснилось, как это настроить! А то я гадал - если текущий вариант настройки(4 единицы и 4 нуля) реагирует на всё, имеющее кол - что же скрывают эти 4 нуля? Оказалось, что фигню: dummy, невидимые объекты, камеры и объекты без кола :D
Но это фигня лишь для скриптинга. На уровне плагина это может быть полезно при создании каких-нибудь динамических теней или что-то типа того, я думаю..
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 03, 2017, 01:49:08 am
Вам это может показаться глупым, но я столкнулся с проблемой выяснения типа транспорта, в котором не сидит игрок, а поскольку смещение 0x29C не отображает инфу о вертолетах и самолете - пришлось расковырять стандартные опкоды и добыть это:
Код: C++
  1. 005BAA80                         ; CVehicle::GetVehicleAppearance(void)
Отправляем стракт транспорта, получаем его тип:
1 - Car
2 - Bike
3 - Heli
4 - Boat
5 - Plane


Использование в CLEO:
Код: Text
  1. 0A97: 1@ = car 0@ struct
  2. 0AA7: call_function 0x5BAA80 num_params 1 pop 1 1@ 2@
в 2@ записывается тип(см. выше)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 06, 2017, 02:01:43 pm
Расковырял "отрывание" колес, но одно колесо(левое заднее) стабильно не хочет "отрываться".
SCM-функция:
См. обновленную версию ниже (http://forum.gtabuilder.ru/index.php?topic=117.msg2815#msg2815)

Сначала думал, что код неправильный, но после кучи перепроверок ничего не добился, поэтому левое заднее колесо, видимо, так и останется "намертво" прикрученным к транспорту. Ах да! на байках, вертолетах, самолете и лодках не применять! Это может привести к вылету игры.

Применений всему этому делу можно придумать множество, например - "прокачать" аварии транспорта:
! No longer available (http://www.youtube.com/watch?v=2f84z7qgNFw#)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Tommi4kaVar4etti от Июнь 06, 2017, 05:54:02 pm
Нужно просто получить структуру авто и добавить смещение, не нужно вызывать никакой функции. Потом прочитать значение.

в CLEO это выглядит так:
Код: XML
  1. Actor.StorePos($PLAYER_ACTOR, 1@, 2@, 3@)
  2. 05F0: 0@ = random_vehicle_near_point 1@ 2@ 3@ in_radius 5.0 find_next 0 pass_wrecked 0 //IF and SET
  3. 05E7: 4@ = car 0@ struct
  4. 4@ += 0x29C
  5. 05E0: 5@ = read_memory 4@ size 1 virtual_protect 0 // Это значение и есть тип авто
  6. Далее, колёса
  7. 05E7: 4@ = car 0@ struct
  8. 4@ += 0x2A5
  9. 05DF: write_memory 4@ size 1 value 2 virtual_protect 0 // Левое переднее
  10. 05E7: 4@ = car 0@ struct
  11. 4@ += 0x2A6
  12. 05DF: write_memory 4@ size 1 value 2 virtual_protect 0 // Левое заднее
  13. 05E7: 4@ = car 0@ struct
  14. 4@ += 0x2A7
  15. 05DF: write_memory 4@ size 1 value 2 virtual_protect 0 // Правое переднее
  16. 05E7: 4@ = car 0@ struct
  17. 4@ += 0x2A8
  18. 05DF: write_memory 4@ size 1 value 2 virtual_protect 0 // Правое заднее
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Tommi4kaVar4etti от Июнь 06, 2017, 05:55:38 pm
Единственное, что я не знаю как сделать, так это как "обновить" авто. Коллизии на колёсах не будет, но они будут видны.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 06, 2017, 06:29:21 pm
Нужно просто получить структуру авто и добавить смещение, не нужно вызывать никакой функции. Потом прочитать значение.
Я так и сделал для того, чтобы убрать коллизию колес. Но чтобы "заспавнить" оторваное колесо и заставить "исчезнуть" оригинальное - пришлось копошить функции
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: kenking от Июнь 07, 2017, 12:53:19 pm
пришлось копошить функции

В sdk есть же всё это.

(http://savepic.ru/14306444m.png) (http://savepic.ru/14306444.htm) (http://savepic.ru/14351489m.png) (http://savepic.ru/14351489.htm)

Код: C++
  1. #include "plugin_vc.h"
  2. #include "game_vc\common.h"
  3. #include "extensions\KeyCheck.h"
  4. #include "game_vc\CFont.h"
  5.  
  6. using namespace plugin;
  7.  
  8. class MyPlugin {
  9. public:
  10.     MyPlugin() {
  11.         static RwObject *atomic;
  12.  
  13.         Events::drawingEvent += [] {
  14.             CVehicle *vehicle = FindPlayerVehicle();
  15.             if (vehicle && vehicle->m_dwVehicleClass == VEHICLE_AUTOMOBILE) {
  16.                 CAutomobile *automobile = reinterpret_cast<CAutomobile *>(vehicle);
  17.  
  18.                 CFont::SetScale(0.5f, 1.0f);
  19.                 CFont::SetColor(CRGBA(255, 255, 255, 255));
  20.                 CFont::SetJustifyOn();
  21.                 CFont::SetFontStyle(1);
  22.                 CFont::SetPropOn();
  23.                 CFont::SetWrapx(600.0f);
  24.                 wchar_t text[32];
  25.                 swprintf(text, L"LeftFrontWheelStatus %d", automobile->stDamage.GetWheelStatus(0));
  26.                 CFont::PrintString(10.0f, 10.0f, text);
  27.                 swprintf(text, L"LeftRearWheelStatus %d", automobile->stDamage.GetWheelStatus(1));
  28.                 CFont::PrintString(10.0f, 30.0f, text);
  29.                 swprintf(text, L"RightFrontWheelStatus %d", automobile->stDamage.GetWheelStatus(2));
  30.                 CFont::PrintString(10.0f, 50.0f, text);
  31.                 swprintf(text, L"RightRearWheelStatus %d", automobile->stDamage.GetWheelStatus(3));
  32.                 CFont::PrintString(10.0f, 70.0f, text);
  33.                                
  34.                 KeyCheck::Update();
  35.                
  36.                 if (KeyCheck::CheckWithDelay(VK_F6, 500)) {
  37.                     if (vehicle->IsComponentPresent(6)) {
  38.                         automobile->stDamage.SetWheelStatus(1, 2);
  39.                         automobile->SpawnFlyingComponent(6, 1);
  40.                         atomic = 0;
  41.                         RwFrameForAllObjects(automobile->m_aCarNodes[6], reinterpret_cast<RwObjectCallBack >(GetCurrentAtomicObjectCB), &atomic);
  42.                         if (atomic)
  43.                             atomic->flags = 0;
  44.                     }
  45.                 }
  46.  
  47.                 if (KeyCheck::CheckWithDelay(VK_F7, 500)) {
  48.                     if (vehicle->IsComponentPresent(6))
  49.                         automobile->Fix();
  50.                 }
  51.             }
  52.         };
  53.     }
  54. } myPlugin;
  55.  

Коллизия колеса восстанавливается
Код: C++
  1. automobile->stDamage.SetWheelStatus(1, 0);

Только само колесо при этом не появляется. Надо смотреть CAutomobile::Fix. Там есть это, но самому разобрать этот момент не вышло. Надеюсь, что DK подскажет.  ;)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 07, 2017, 01:15:23 pm
В sdk есть же всё это.
Ну, мне нужно было в CLEO и я нашел - no problem ;D Кроме этого самого левого заднего колеса, которое вызывает краш..

Только само колесо при этом не появляется. Надо смотреть CAutomobile::Fix. Там есть это, но самому разобрать этот момент не вышло. Надеюсь, что DK подскажет.  ;)
Так я же раскопал адреса(см. код скрипта). Так же, как колесо скрывается(значение 0), его можно и "вернуть"(1). А еще оно тоже становится видимым при вкл/выкл повтора.

Вопрос лишь в том, почему с тремя колесами всё отлично, а заднее левое вызывает краш? Судя по комменту kenking, при использовании sdk всё работает нормально, но меня это не устраивает(это не дает ответа на вопрос, что с этим колесом/моим кодом не так)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: kenking от Июнь 07, 2017, 02:55:47 pm
У тебя там смещение неправильное для этого колеса. См. здесь https://sannybuilder.com/forums/viewtopic.php?pid=25844#p25844 (https://sannybuilder.com/forums/viewtopic.php?pid=25844#p25844).

И нумерация колёс правильно будет 0-3 
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 07, 2017, 03:17:10 pm
У тебя там смещение неправильное для этого колеса. См. здесь https://sannybuilder.com/forums/viewtopic.php?pid=25844#p25844 (https://sannybuilder.com/forums/viewtopic.php?pid=25844#p25844).

И нумерация колёс правильно будет 0-3 
За смещение спс(осталось найти правильный номер этого колеса, как компонента для создания объекта-клона)

А по поводу нумерации - я её сам выдумал для scm функции(это значения не имеет)

UPD: Нашел!
Номер заднего левого колеса для "клонирования" - 6(очень странно, ибо остальные имеют номера 1, 3, 4).

---------------------------------------------------------------------------------------------------------------

ОБНОВЛЕННАЯ ФУНКЦИЯ(последняя версия 08.06.2017):
Вызов такой же(продублирую):
Код: Text
  1. 0AB1: call_scm_func @DETACHWHEEL 2 0@ 1 1@ // CarHandle, WheelNumber(1 - left front, 2 - left rear, 3 - right front, 4 - right rear), GetDetachedWheelStruct
, где 0@ - хэндл машины, 1 - номер колеса:
1 - left front
2 - left rear
3 - right front
4 - right rear
, а 1@ - struct "оторваного" колеса("клонированного" на самом деле)
Сама функция(спасибо kenking за таблицы компонентов!):
Код: Text
  1. :DETACHWHEEL
  2. 0039:   1@ == 1
  3. jf @DETACHWHEEL_LEFTREARCHECK
  4. 0006: 2@ = 4 // clone left front wheel
  5. 0006: 3@ = 0x2A5 // remove left front wheel's colision
  6. 0006: 4@ = 0x3A4 // hide left front wheel
  7. jump @DETACHWHEEL_DETACHWHEEL
  8.  
  9. :DETACHWHEEL_LEFTREARCHECK
  10. 0039:   1@ == 2
  11. jf @DETACHWHEEL_RIGHTFRONTCHECK
  12. 0006: 2@ = 6 // clone left rear wheel
  13. 0006: 3@ = 0x2A6 // remove left rear wheel's colision
  14. 0006: 4@ = 0x3AC // hide left rear wheel
  15. jump @DETACHWHEEL_DETACHWHEEL
  16.  
  17. :DETACHWHEEL_RIGHTFRONTCHECK
  18. 0039:   1@ == 3
  19. jf @DETACHWHEEL_RIGHTREARCHECK
  20. 0006: 2@ = 1 // clone right front wheel
  21. 0006: 3@ = 0x2A7 // remove right front wheel's colision
  22. 0006: 4@ = 0x398 // hide right front wheel
  23. jump @DETACHWHEEL_DETACHWHEEL
  24.  
  25. :DETACHWHEEL_RIGHTREARCHECK
  26. 0039:   1@ == 4
  27. jf @DETACHWHEEL_RETURN
  28. 0006: 2@ = 3 // clone right rear wheel
  29. 0006: 3@ = 0x2A8 // remove right rear wheel's colision
  30. 0006: 4@ = 0x3A0 // hide right rear wheel
  31.  
  32. :DETACHWHEEL_DETACHWHEEL
  33. ////////Hiding original wheel(getting parameters):
  34. 0A97: 5@ = car 0@ struct
  35. 0085: 6@ = 5@
  36. //Offset:
  37. //0x398______wheel_rf_dummy_________правое переднее колесо
  38. //0x39C______wheel_rm_dummy________правое среднее колесо
  39. //0x3A0______wheel_rb_dummy________правое заднее колесо
  40. //0x3A4______wheel_lf_dummy_________левое переднее колесо
  41. //0x3A8______wheel_lm_dummy________левое среднее колесо
  42. //0x3AC______wheel_lb_dummy________левое заднее колесо
  43. //0x3B0______bump_front_dummy_______передний бампер
  44. //0x3B4______bump_rear_dummy_______задний бампер
  45. //0x3B8______wing_rf_dummy__________правое переднее крыло
  46. //0x3BC______wing_rr_dummy_________правое заднее крыло
  47. //0x3C0______door_rf_dummy_________правая передняя дверь
  48. //0x3C4______door_rr_dummy_________правая задняя дверь
  49. //0x3C8______wing_lf_dummy__________левое переднее крыло
  50. //0x3CC______wing_lr_dummy_________левое заднее крыло
  51. //0x3D0______door_lf_dummy__________левая передняя дверь
  52. //0x3D4______door_lr_dummy__________левая задняя дверь
  53. //0x3D8______bonnet_dummy__________ капот
  54. //0x3DC______boot_dummy___________багажник
  55. //0x3E0______windscreen_dummy_______лобовое стекло
  56. 005A: 6@ += 4@
  57. 0006: 7@ = 0
  58. 0AC7: 8@ = var 7@ offset
  59. 0A8D: 6@ = read_memory 6@ size 4 virtual_protect 1
  60. 0AA5: call 0x6453B0 num_params 3 pop 3 8@ 0x59F1E0 6@
  61. 8039:   NOT 7@ == 0
  62. jf @DETACHWHEEL_RETURN
  63. ////////Making clone of wheel:
  64. //first parameter - collision and physics of component:
  65. //0 - 241, car_bumper
  66. //1 - 245, car_wheel
  67. //2 - 240, car_door
  68. //3 - 243, car_bonnet
  69. //4 - 244, car_boot
  70. //5 - 242, car_panel
  71. //second parameter - vehicle component:
  72. //  CAR_NODE_NONE = 0
  73. //  CAR_WHEEL_RF = 1
  74. //  CAR_WHEEL_RM = 2
  75. //  CAR_WHEEL_RB = 3
  76. //  CAR_WHEEL_LF = 4
  77. //  CAR_WHEEL_LM = 5
  78. //  CAR_WHEEL_LB = 6
  79. //  CAR_BUMP_FRONT = 7
  80. //  CAR_BUMP_REAR = 8
  81. //  CAR_WING_RF = 9
  82. //  CAR_WING_RR = 10
  83. //  CAR_DOOR_RF = 11
  84. //  CAR_DOOR_RR = 12
  85. //  CAR_WING_LF = 13
  86. //  CAR_WING_LR = 14
  87. //  CAR_DOOR_LF = 15
  88. //  CAR_DOOR_LR = 16
  89. //  CAR_BONNET = 17
  90. //  CAR_BOOT = 18
  91. //  CAR_WINDSCREEN = 19
  92. 0AA8: call_function_method 0x59AAA0 struct 5@ num_params 2 pop 0 1 2@ 15@
  93. ////////Hiding original wheel:
  94. 000A: 7@ += 0x02
  95. 0A8C: write_memory 7@ size 1 value 0 virtual_protect 1
  96. ////////Removing original wheel's colision:
  97. 005A: 5@ += 3@
  98. 0A8C: write_memory 5@ size 1 value 2 virtual_protect 1
  99.  
  100. :DETACHWHEEL_RETURN
  101. 0AB2: ret 1 15@
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: kenking от Июнь 07, 2017, 03:36:45 pm
осталось найти правильный номер этого колеса, как компонента для создания объекта-клона
Если я правильно понял, то ты про это:
Код: C++
  1. enum eCarNodes {
  2.     CAR_NODE_NONE = 0,
  3.     CAR_WHEEL_RF = 1,
  4.     CAR_WHEEL_RM = 2,
  5.     CAR_WHEEL_RB = 3,
  6.     CAR_WHEEL_LF = 4,
  7.     CAR_WHEEL_LM = 5,
  8.     CAR_WHEEL_LB = 6,
  9.     CAR_BUMP_FRONT = 7,
  10.     CAR_BUMP_REAR = 8,
  11.     CAR_WING_RF = 9,
  12.     CAR_WING_RR = 10,
  13.     CAR_DOOR_RF = 11,
  14.     CAR_DOOR_RR = 12,
  15.     CAR_WING_LF = 13,
  16.     CAR_WING_LR = 14,
  17.     CAR_DOOR_LF = 15,
  18.     CAR_DOOR_LR = 16,
  19.     CAR_BONNET = 17,
  20.     CAR_BOOT = 18,
  21.     CAR_WINDSCREEN = 19,
  22.     CAR_NUM_NODES
  23. };
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 07, 2017, 03:47:05 pm
Если я правильно понял, то ты про это:
Ох, shi...!
Спасибо, добавил в функцию. Теоретически, теперь через неё можно отделять любой компонент(если добавить варианты, помимо 4х колес)


UPD: Последняя проблема, которую осталось решить - это вопрос "почему, если "отделять" колесо вручную, оторваная версия становится больше в размерах и флипает некоторые фейсы, когда как при взрыве авто таких проблем не наблюдается?". Иначе говоря - с чем связаны эти глюки с рендером колеса и с чего оно такое огромное:
(https://i.gyazo.com/1e59031d7631474e323651ae7f2e5d0f.png)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 08, 2017, 03:36:26 am
Оказывается, функция 0x59AAA0 (создающая "клон" отрываемого компонента) возвращает struct этого "клона", что позволяет в дальнейшем, например, взять под управление оторванное колесо!

Обновил функцию (http://forum.gtabuilder.ru/index.php?topic=117.msg2815#msg2815), а на возможный вопрос "да где это может, блин, пригодиться?" скоро отвечу видеодемонстрацией финальной версии CarRec (http://forum.gtabuilder.ru/index.php?topic=401.msg2818), который, к слову, уже почти закончен.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: kenking от Июнь 08, 2017, 05:23:58 am
Теоретически, теперь через неё можно отделять любой компонент(если добавить варианты, помимо 4х колес)
Не только теоретически, но и практически.

Оказывается, функция 0x59AAA0 (создающая "клон" отрываемого компонента) возвращает struct этого "клона", что позволяет в дальнейшем, например, взять под управление оторванное колесо!
Я же написал уже, что в sdk есть такое дело.
Код: C++
  1. CObject* SpawnFlyingComponent(int nodeIndex, unsigned int collisionType);

Почему бы не посмотреть там? Хотя с другой стороны, так не будет приятных открытий, сделанных самостоятельно.  ;)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 08, 2017, 05:37:57 am
Я же написал уже, что в sdk есть такое дело.
Код: C++
  1. CObject* SpawnFlyingComponent(int nodeIndex, unsigned int collisionType);

Почему бы не посмотреть там? Хотя с другой стороны, так не будет приятных открытий, сделанных самостоятельно.  ;)

Речь не об открытиях функций(так-то в современных idb базах они почти все уже открыты), а об их применении в скриптинге.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: kenking от Июнь 08, 2017, 06:47:04 am
Да я про эту твою фразу  ;)
Цитировать
Оказывается, функция 0x59AAA0 (создающая "клон" отрываемого компонента) возвращает struct этого "клона"

Если бы посмотрел в sdk, то увидел бы сразу функция возвращает что-то и что именно или не возвращает. Да ладно, забей. Это я так просто.  :)

Жду с интересом показа применения в твоём моде.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 08, 2017, 09:55:43 am
Если бы посмотрел в sdk, то увидел бы сразу функция возвращает что-то и что именно или не возвращает.
Не думаю, что я что-то увидел бы в sdk, если я не увидел это в idb базе, хотя там всё было под носом и очевидно. Просто на момент, когда я нашел эту функцию, мне не нужно было знать struct колеса, поэтому я не обратил на это внимания, а потом(когда потребовалось) - обратил. Ставить Visual Studio 2017, чтобы поставить sdk, чтобы проделывать те же операции уже в нем - пока смысла не вижу  :-\
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: kenking от Июнь 08, 2017, 04:37:05 pm
Ставить Visual Studio 2017, чтобы поставить sdk, чтобы проделывать те же операции уже в нем - пока смысла не вижу  :-\
Если просто посмотреть какой-либо класс в sdk, то ставить VS не обязательно. Можно посмотреть на github. Например, класс CAutomobile про функцию которого шла речь https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_vc/game_vc/CAutomobile.h (https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_vc/game_vc/CAutomobile.h)

А так, конечно, хозяин - барин. Смотри где тебе удобно.  :)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 08, 2017, 05:24:44 pm
Например, класс CAutomobile про функцию которого шла речь https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_vc/game_vc/CAutomobile.h (https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_vc/game_vc/CAutomobile.h)
И как мне поможет это, если там описаний функций нет?  :D
Названия есть и в idb базе.
Только в базе можно посмотреть, как функция работает, и понять, например, как сделать это:
Коллизия колеса восстанавливается
...
Только само колесо при этом не появляется.

Единственный плюс использования sdk для меня - это разобранные параметры, типа eCarNodes, а всё остальное всё равно придется
копошить
;D
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 08, 2017, 10:08:04 pm
Не буду говорить, зачем я это ворошил, но вот отключение всех драк в игре(кроме удара кулаком на бегу):
Код: Text
  1. 0A8C: write_memory 0x52AD7D size 742 value 0x90 virtual_protect 1
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июль 07, 2017, 06:04:44 pm
Короче, искал способ проиграть любой звук sfx, разобрал этот опкод:
Код: Text
  1. 018C: play_sound 1 at 0.0 0.0 0.0

Не вдаваясь в подробности, скажу, что для звуков, у которых нет 3d позиционирования, можно применить эту функцию:
Код: C++
  1. 005F9960                         ; int __stdcall cDMAudio::PlayFrontEndSound(__int16, float)
Она проигрывает некоторые sfx звуки, которые не проигрывает опкод 018C(выше).
Использование:
Код: Text
  1. 0AA5: call 0x5F9960 num_params 2 pop 0 0.0 0@

, где 0.0 - неизвестный float параметр(изменения ни к чему не приводят, в опкоде стоит 0.0)
0@ - номер звука(нумерация странная):
59 - Щелчок "Нет боеприпасов" (щелчок снайперской винтовки)
60 - Щелчок "Нет боеприпасов" (щелчок гранатомета)
63-69, 71-73, 77-89, 100, 101, 159-162, 168, 169, 179 - "Action" звуки (например, пикапы)
167 - Звук "Таймер"
176, 177 - Тихие щелчки (выключение радио?)
178 - Порыв ветра
184 - Пуля пролетает справа
185 - Пуля пролетает слева
193 - Звук активации детонатора
194 - Звук смены радиостанции
195-198 - Звуки меню
199 - Шум
Другие значения ни к чему не приводят. В коде игры есть лимит 204, так что дальше проверять нет смысла. Пробовал расширить лимит до 65535 - всё равно после 199 ни одного звука не услышал(проверял до 1000).
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июль 07, 2017, 06:12:59 pm
Заставить актера говорить(не забывайте, что в игре есть дурацкий баг, из-за которого педы редко говорят, так что, чтобы нормально протестить нишенаписанное - поставьте патч, делающий педов и игрока более "разговорчивыми" (http://gtaforums.com/topic/817075-ped-speech-patch-gta-vc/)):

Код: Text
  1. 0A96: 2@ = actor 0@ struct
  2. 2@ += 0x5DA
  3. 0A8C: write_memory 2@ size 2 value 1@ virtual_protect 1
, где 0@ - 2@ struct педа, 1@ - вид фразы:

(проверял только на полицейском!)
103 - крик смерти
107 - крик утопления
108 - продолжительный крик ужаса
110 - фраза угрозы кому-либо(иногда нужно толкнуть педа для фразы)
113 - фразы драки(иногда нужно толкнуть педа для фразы)
120 - панический крик
125 - фразы после боя/драки
129 - фразы напарникам("Попал!", "Он мой!", "Я взял его!", "Я вижу его!" и в таком духе)
130 - фразы противнику("Ты окружен!")
131 - фразы напарникам("Я тебя прикрою!")
132 - фразы противнику("Стоять!")
133 - фразы напарникам("Прикройте")
134 - фразы прохожим
135 - фразы напарникам
138 - фразы начала боя/драки
139 - стихие крики потери сознания/смерти
142 - раздраженные фразы("Не беси меня!", "Отвали!" и т.п.)

Именно благодаря этому оффсету в сцене "360" из папки примеров мода CarRec орет полицейский (https://youtu.be/drvzFYCX7Gk?t=43s)(сам CarRec со всеми примерами тут (http://gtabuilder.ru/gta_vc/mods/cleo_scripts/283-cleocarrecplus-objrec.html))
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июль 08, 2017, 04:21:06 am
Код ниже проверялся только на педах и катсценовых актерах. На авто отображает неправильные значения.
Нужно доработать...
VVVVVVVVVVVVVVVVVVV

Дополняю сообщения xanser-а (http://forum.gtabuilder.ru/index.php?topic=250.msg1525#msg1525) и DK (http://forum.gtabuilder.ru/index.php?topic=363.msg2428#msg2428):
Есть тип 8: катсценовые актеры.

Итого - имеем следующий CLEO-код по выявлению типа Entity:

Код: Text
  1. записываем в 0@ указатель на структуру Entity(объекта, транспорта или педа), затем:
  2. 000A: 0@ += 0x5C // model index offset
  3. 0A8D: 0@ = read_memory 0@ size 2 virtual_protect 1
  4. 0A8D: 1@ = read_memory 0x92D4C8 size 4 virtual_protect 1 // CBaseModelInfo array
  5. 0012: 0@ *= 0x2C // model offset
  6. 005A: 1@ += 0@ // go to model offset
  7. 000A: 1@ += 0x19 // m_ModelType offset
  8. 0A8D: 1@ = read_memory 1@ size 1 virtual_protect 1
, где 1@:
1 - objs
3 - tobj
4 - weap (weapons, 258-294)
5 - hier (cutscene objects, id 295-299)
6 - cars (id 130-236)
7 - peds (peds and IG actors, id 0-129)
8 - peds (CS actors, id 109-129)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Май 20, 2018, 11:32:53 pm
Горящий огонь(пожар в смысле):

0x97F8A0 - количество горящих огней
0x97F8A4 - начало массива огней (максимум - 40 элементов)
каждый огонь состоит из 48 байт. координаты по оффсетам

0x00 [byte] - тип1 огня(0 - потух, 1 - горит)
0x01 [byte] - тип2 огня(0 - самопотухаемый, 1 - вечный)
0x02 [byte] - тип3 огня(0 - обычный, 1 - пед, авто)
0x03 [byte] - тип4 огня (0 - беззвучный, 1 - со звуком)
0x04 [float] - x coord
0x08 [float] - y coord
0x0C [float] - z coord
0x10 [pointer] - указатель на горящий entity
0x14 [pointer] - указатель на "виновника"(если он есть) огня(только для горящих entity)
0x18 [integer] - время затухания(в мировом таймере)
0x1C [integer] - время следующего чего-то?
0x20 [integer] - время следующего отображения партикла огня
0x24 [float] - размер огня
0x28 [float] - всегда 1.0
0x2C [integer] - неизвестно, всегда 0


когда машина горит "своим огнем", т.е. "готовится ко взрыву" - этот огонь не "настоящий" и в пуле отсутствует
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: DK от Май 21, 2018, 12:27:43 am
Shagg_E, структура, скорее всего, идентична той, что в GTA3.
https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_III/game_III/CFire.h
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Май 21, 2018, 01:09:44 am
Shagg_E, структура, скорее всего, идентична той, что в GTA3.
https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_III/game_III/CFire.h
Да, скорее всего. Я доковырял - вроде совпадает
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: DK от Май 22, 2018, 09:03:12 am
Вот что у меня получилось
Код: C++
  1. /* 0x00 */ bool     m_bActive            // существует (т.е. слот занят)
  2. /* 0x01 */ bool     m_bScriptFire        // ручное удаление ("заскриптованный" огонь)
  3. /* 0x02 */ bool     field_2              // возможно не используется, 0 - для огня после взрыва, 1 для всего остального
  4. /* 0x03 */ bool     m_bMakesNoise        // есть звук
  5. /* 0x04 */ CVector  m_vecPosition        // позиция
  6. /* 0x10 */ CEntity *m_pEntityTarget      // жертва
  7. /* 0x14 */ CEntity *m_pEntityCreator     // создатель
  8. /* 0x18 */ int      m_nEndLifeTime       // время затухания
  9. /* 0x1C */ int      field_1C             // какой-то таймер, возможно не используется, обнуляется каждые 400мс
  10. /* 0x20 */ int      m_nParticlesTimer    // таймер для создания партиклов
  11. /* 0x24 */ float    m_fSize              // размер
  12. /* 0x28 */ float    m_fStrength          // интенсивность (повышается при появлении огня и уменьшается при затухании)
  13. /* 0x2C */ bool     m_bBeingExtinguished // флаг "тушения" (водой) - используется, чтобы начать проигрывать какой-то звук, после выключается
  14. /* 0x2D */ char     _pad2D[3]
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Май 22, 2018, 12:11:39 pm
0x02 можно назвать m_bTargetExists

а 0x2D  _pad2D[3] - это просто пустышка, получается?


UPD: черт.. Оказывается, в марте для вайса уже всё разобрали (https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_vc/game_vc/CFire.h). Я с лета не обновлял sdk ;D

UPD2: Вау, теперь есть удобный установщик sdk!
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: DK от Май 22, 2018, 02:23:52 pm
Shagg_E, странно, я сам в упор не видел, что CFire уже есть в sdk для VC.
Ну зато теперь по огням всё разобрано и перепроверено до мелочей.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 12, 2018, 11:28:30 pm
CPointLights (http://forum.gtabuilder.ru/index.php?topic=200.msg2183#msg2183):

0x9751B0 - количество PointLights
0x7E4FE0 - начало массива PointLights (максимум - 32 элемента)
каждый PointLight состоит из 44(0x2С) байт.

Структура совпадает с GTA3 (https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_III/game_III/CPointLights.h), я просто добавлю пояснения.

0x00 [float] - x coord
0x04 [float] - y coord
0x08 [float] - z coord
0x0С [float] - x direction
0x10 [float] - y direction
0x14 [float] - z direction
0x18 [float] - дальность света
0x1С [float] - red(0.0-1.0)
0x20 [float] - green(0.0-1.0)
0x24 [float] - blue(0.0-1.0)
0x28 [byte] - тип света(0 - светит во все стороны из центра, 1 - directional(фары), светят строго по вектору, 2 - не используется(вроде), становятся слабее, если источников этого типа много, 3-4 - хз, не освещают динамику, скорее всего нужны для источников, которые кроме 2dfx никак не проявляют себя)
0x29 [byte] - тип "дымки" вокруг света(0 - нет "дымки", 1 и 2 - есть)
0x2A [bool] - генерация дополнительной тени авто игрока вблизи источника света(0 - нет, 1 - да), работает только для типа света 0, при параметре LightShd в timecyc.dat больше 0
0x2B [byte] - не используется(пустышка)

Продолжаю разбор каждого элемента, пост будет обновляться.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: ilufir от Июнь 13, 2018, 10:50:34 pm
CPointLights ([url]http://forum.gtabuilder.ru/index.php?topic=200.msg2183#msg2183[/url]):

0x9751B0 - количество PointLights
0x7E4FE0 - начало пула PointLights (максимум - 32 элемента)
каждый PointLight состоит из 44(0x2С) байт.

Структура совпадает с GTA3 ([url]https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_III/game_III/CPointLights.h[/url]), я просто добавлю пояснения.

0x00 [float] - x coord
0x04 [float] - y coord
0x08 [float] - z coord
0x0С [float] - x direction
0x10 [float] - y direction
0x14 [float] - z direction
0x18 [float] - дальность света
0x1С [float] - red(0.0-1.0)
0x20 [float] - green(0.0-1.0)
0x24 [float] - blue(0.0-1.0)
0x28 [byte] - тип света(0 - светит во все стороны из центра, 1 - фары, светят строго по вектору, 3-4 - хз, не освещают динамику, скорее всего нужны для источников, которые кроме 2dfx никак не проявляют себя)
0x29 [byte] - тип "дымки" вокруг света(0 - нет "дымки", 1 и 2 - есть)
0x2A [bool] - генерация дополнительной тени авто игрока вблизи тени(0 - нет, 1 - да)
0x2B [byte] - не используется(пустышка)

Продолжаю разбор каждого элемента, пост будет обновляться.


Где то еще должен быть пункт который добавляет к источнику lens-flare
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Июнь 14, 2018, 12:08:33 am
Где то еще должен быть пункт который добавляет к источнику lens-flare
Это уже в 2dfx. PointLight - это чисто сам свет от источника. Т.е. то, что освещает педов, авто, катсценовые и динамические объекты.
Так же у источников есть тот самый 2dfx + "тень"(отрисовка текстуры света на горизонтальной поверхности). Это уже в другом массиве(ах).

Это насколько я это всё понимаю(могу ошибаться, но вроде всё верно).
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Март 09, 2019, 06:11:57 pm
Недавние находки:
Код: Text
  1. 0A8C: write_memory 0x488F94 size 5 value 0x90 virtual_protect 1 // Disable traffic lights
  2. 0A8C: write_memory 0x488FCC size 5 value 0x90 virtual_protect 1 // Disable traffic lights
  3. 0A8C: write_memory 0x488FE3 size 5 value 0x90 virtual_protect 1 // Disable traffic lights
  4. 0A8C: write_memory 0x48901C size 5 value 0x90 virtual_protect 1 // Disable traffic lights
  5. 0A8C: write_memory 0xA10ADC size 1 value 1 virtual_protect 1 // Make all traffic lights green
  6.  
  7. 0A8C: write_memory 0x54F429 size 5 value 0x90 virtual_protect 1 // Disable plane trails
  8.  
  9. 0A8C: write_memory 0x4ABD45 size 4617 value 0x90 virtual_protect 1 // Disable cheat codes
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: egor230 от Март 10, 2019, 12:57:17 pm
Недавние находки:
Код: Text
  1. 0A8C: write_memory 0x488F94 size 5 value 0x90 virtual_protect 1 // Disable traffic lights
  2. 0A8C: write_memory 0x488FCC size 5 value 0x90 virtual_protect 1 // Disable traffic lights
  3. 0A8C: write_memory 0x488FE3 size 5 value 0x90 virtual_protect 1 // Disable traffic lights
  4. 0A8C: write_memory 0x48901C size 5 value 0x90 virtual_protect 1 // Disable traffic lights
  5. 0A8C: write_memory 0xA10ADC size 1 value 1 virtual_protect 1 // Make all traffic lights green
  6.  
  7. 0A8C: write_memory 0x54F429 size 5 value 0x90 virtual_protect 1 // Disable plane trails
  8.  
  9. 0A8C: write_memory 0x4ABD45 size 4617 value 0x90 virtual_protect 1 // Disable cheat codes

очень полезные находки, можно подробные объяснения их.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Март 10, 2019, 01:59:09 pm
очень полезные находки, можно подробные объяснения их.
Первые 5 строк отключают свет светофоров и делают так, чтобы машины стали игнорировать эти светофоры.

Далее строка отключения следов гражданских самолетов в небе(когда сами самолеты(их пути) уже очищены в файлах flight папки data\paths):
(https://i.gyazo.com/015410e4ec5495cfd66047eb9079b927.png)

Вышеописанные строки полезны, если делать постапокалиптичный мод, где необходимо "убить" всю "жизнь" в городе и над ним.

Последняя строка отключает все читы в игре.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: egor230 от Март 10, 2019, 02:41:52 pm
Спасибо большое Shagg_E  теперь  всё  стало понятно.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Апрель 03, 2019, 03:24:48 am
Отключение прицела/атаки у игрока:
Код: Text
  1. 0AC8: 0@ = allocate_memory_size 1898
  2. 0AB1: call_scm_func @COPY_MEMORY 4 0x53497B 0@ 1898 2 // CopyFrom, CopyTo, Size, Step
  3. wait 0 // IMPORTANT WAIT!!!
  4. 0A8C: write_memory 0x53497B size 1898 value 0x90 virtual_protect 1 // Disable Player Aim and Attack
Включение обратно:
Код: Text
  1. 0AB1: call_scm_func @COPY_MEMORY 4 0@ 0x53497B 1898 2 // CopyFrom, CopyTo, Size, Step
  2. 0AC9: free_allocated_memory 0@
SCM-функция COPY_MEMORY:
Код: Text
  1. :COPY_MEMORY
  2. 0006: 6@ = 0
  3.  
  4. :COPY_MEMORY_CYCLE
  5. 001D:   2@ > 6@
  6. jf @COPY_MEMORY_RETURN
  7. 0085: 4@ = 0@
  8. 005A: 4@ += 6@
  9. 0A8D: 5@ = read_memory 4@ size 3@ virtual_protect 1
  10. 0085: 4@ = 1@
  11. 005A: 4@ += 6@
  12. 0A8C: write_memory 4@ size 3@ value 5@ virtual_protect 1
  13. 005A: 6@ += 3@
  14. jump @COPY_MEMORY_CYCLE
  15.  
  16. :COPY_MEMORY_RETURN
  17. 0AB2: ret 0

Суть в чем: чтобы заблочить возможность целиться и атаковать, нужно занопить по адресу 0x53497B 1898 байт. Но чтобы потом вернуть всё обатно - нужно предварительно скопировать оригинальные 1898 байт в свежесозданный буфер, что скрипт и делает.

Где это может пригодиться? Ну например - в некоторых интерьерах или стелс-миссиях, где игрок не должен будет никого атаковать.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Saint от Апрель 17, 2019, 12:25:08 am
Отключение прицела/атаки у игрока:
Код: Text
  1. 0AC8: 0@ = allocate_memory_size 1898
  2. 0AB1: call_scm_func @COPY_MEMORY 4 0x53497B 0@ 1898 2 // CopyFrom, CopyTo, Size, Step
  3. wait 0 // IMPORTANT WAIT!!!
  4. 0A8C: write_memory 0x53497B size 1898 value 0x90 virtual_protect 1 // Disable Player Aim and Attack
Включение обратно:
Код: Text
  1. 0AB1: call_scm_func @COPY_MEMORY 4 0@ 0x53497B 1898 2 // CopyFrom, CopyTo, Size, Step
  2. 0AC9: free_allocated_memory 0@
SCM-функция COPY_MEMORY:
Код: Text
  1. :COPY_MEMORY
  2. 0006: 6@ = 0
  3.  
  4. :COPY_MEMORY_CYCLE
  5. 001D:   2@ > 6@
  6. jf @COPY_MEMORY_RETURN
  7. 0085: 4@ = 0@
  8. 005A: 4@ += 6@
  9. 0A8D: 5@ = read_memory 4@ size 3@ virtual_protect 1
  10. 0085: 4@ = 1@
  11. 005A: 4@ += 6@
  12. 0A8C: write_memory 4@ size 3@ value 5@ virtual_protect 1
  13. 005A: 6@ += 3@
  14. jump @COPY_MEMORY_CYCLE
  15.  
  16. :COPY_MEMORY_RETURN
  17. 0AB2: ret 0

Суть в чем: чтобы заблочить возможность целиться и атаковать, нужно занопить по адресу 0x53497B 1898 байт. Но чтобы потом вернуть всё обатно - нужно предварительно скопировать оригинальные 1898 байт в свежесозданный буфер, что скрипт и делает.

Где это может пригодиться? Ну например - в некоторых интерьерах или стелс-миссиях, где игрок не должен будет никого атаковать.

тоесть если мы будем нажимать кнопку огонь (ЛКМ) то игрок не будет выполнять никаких действий?
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Апрель 17, 2019, 12:35:24 pm
тоесть если мы будем нажимать кнопку огонь (ЛКМ) то игрок не будет выполнять никаких действий?
Да. Будто и нет такой механики. При этом, в отличии от отключения всех драк(ранее в этой теме) - педы не теряют возможности атаковать. Да и игрок под управлением ИИ сможет атаковать.
Т.е. выключается только сама привязка контроллера к атакам.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Апрель 21, 2019, 05:56:54 am
Выключение коллизии для любого entity:

Код: Text
  1. 0A97: 0@ = car 0@ struct // нужна лишь структура, а всё, что ниже будет одинаковым для транспорта, людей и объектов
  2. 000A: 0@ += 0x51
  3. 0A8D: 1@ = read_memory 0@ size 1 virtual_protect 1
  4. 0B17: 1@ AND= 0x80
  5. 0A8C: write_memory 0@ size 1 value 1@ virtual_protect 1

Включение:
Код: Text
  1. 0A8D: 1@ = read_memory 0@ size 1 virtual_protect 1
  2. 0B18: 1@ |= 0x80
  3. 0A8C: write_memory 0@ size 1 value 1@ virtual_protect 1
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: mfisto от Апрель 28, 2019, 05:47:37 am
Я подумал, типа совета, ведь не обязательно нопить всю функцию, достаточно завершить ее также, как она завершается в конце и все. (Совет Шэггги)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Апрель 28, 2019, 04:58:52 pm
Я подумал, типа совета, ведь не обязательно нопить всю функцию, достаточно завершить ее также, как она завершается в конце и все. (Совет Шэггги)
Не знал) Спасибо, надо будет попробовать, как будет время. Но вообще я нуб в подобных операциях и понимании asm кода, так что ничего удивительного, что сделал так колхозно.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Октябрь 06, 2019, 05:41:19 am
Отключение падения с мотоциклов:
Код: Text
  1. 0A8C: write_memory 0x4F4FB9 size 1 value 0x40 virtual_protect 1 // Отключение возможности угона для всех кроме копов. Оригинальное значение 0x84
  2. 0A8C: write_memory 0x691C74 size 4 value -9999.0 virtual_protect 1 // Отключение возможности угона для копов. Оригинальное значение 0.30000001
  3. 0A8C: write_memory 0x694150 size 4 value 9999.0 virtual_protect 1 // Отключение падения с байка при езде назад. Оригинальное значение 0.090000004
  4. 0A8C: write_memory 0x69415C size 4 value 9999.0 virtual_protect 1 // Отключение падения с байка при езде назад. Оригинальное значение 3.5
  5. 0A8C: write_memory 0x694160 size 4 value 9999.0 virtual_protect 1 // Отключение падения с байка при езде назад. Оригинальное значение -0.5
  6. 0A8C: write_memory 0x60A183 size 1 value 255 virtual_protect 1 // Отключение падения с байка при наземных трюках. Оригинальное значение 13
  7. 0A8C: write_memory 0x613663 size 1 value 0xAC virtual_protect 1 // Отключение падения с байка при воздушных трюках. Оригинальное значение 0x80
  8. 0A8C: write_memory 0x6D77BC size 4 value 9999.0 virtual_protect 1 // Отключение падения с байка при воздушных трюках. Оригинальное значение 0.4
  9. 0A8C: write_memory 0x6D7950 size 4 value 9999.0 virtual_protect 1 // Отключение падения с байка при столкновениях. Оригинальное значение 75.0

Теперь единственный способ покинуть транспорт - это если пед/игрок сам захочет его покинуть или если умрет(но это решается прописыванием особого поведения или иммунитетами).
Работает для всех - и педов, и актеров, и игрока. К сожалению, для конкретного одного транспорта сделать не могу на данный момент, т.к. это будет очень времязатратно.
Обратно всё включить можно так:
Код: Text
  1. 0A8C: write_memory 0x4F4FB9 size 1 value 0x84 virtual_protect 1 // Включение возможности угона для всех кроме копов.
  2. 0A8C: write_memory 0x691C74 size 4 value 0.30000001 virtual_protect 1 // Включение возможности угона для копов.
  3. 0A8C: write_memory 0x694150 size 4 value 0.090000004 virtual_protect 1 // Включение падения с байка при езде назад.
  4. 0A8C: write_memory 0x69415C size 4 value 3.5 virtual_protect 1 // Включение падения с байка при езде назад.
  5. 0A8C: write_memory 0x694160 size 4 value -0.5 virtual_protect 1 // Включение падения с байка при езде назад.
  6. 0A8C: write_memory 0x60A183 size 1 value 13 virtual_protect 1 // Включение падения с байка при наземных трюках.
  7. 0A8C: write_memory 0x613663 size 1 value 0x80 virtual_protect 1 // Включение падения с байка при воздушных трюках.
  8. 0A8C: write_memory 0x6D77BC size 4 value 0.4 virtual_protect 1 // Включение падения с байка при воздушных трюках.
  9. 0A8C: write_memory 0x6D7950 size 4 value 75.0 virtual_protect 1 // Включение падения с байка при столкновениях.
Также, код можно юзать как своеобразный "steed" мод(для трюков)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Декабрь 24, 2019, 06:04:43 pm
Список анимаций для способов
Код: Text
  1. 0A96: 4@ = actor $PLAYER_ACTOR struct
  2. 4@ += 76 // integer values
  3. 0A8D: 4@ = read_memory 4@ size 4 virtual_protect 0
  4. 0AA5: call 0x405640 4 pop 4 4.0 0@ 10@ 4@
ИЛИ
Код: Text
  1. 0673: play_animation on actor $PLAYER_ACTOR animgroup 10@ anim 0@ blendfactor 30.0 // play dance animation from cj_dance

следующий(в дальнейшем может обновляться):
Код: Text
  1. TYPES:
  2. R - Repeatable
  3. F - Freezes
  4. All other anims you can replay in cycle.
  5. 10@ - animgroup
  6. 0@ - number of animation:
  7.  
  8. ********************
  9. 10@ = 0
  10. ped.ifp
  11.  
  12. 0@ = Number 1-172: most of all anims
  13.  
  14. 0: walk_civi
  15. 1: run_civi
  16. 2: sprint_panic
  17. 3: idle_stance
  18. 4: walk_start
  19. 5: run_stop
  20. 6: run_stopR
  21. 7: idle_hbhb
  22. 8: idle_hbhb
  23. 9: idle_tired
  24. 10: idle_armed
  25. 11: idle_chat
  26. 12: idle_taxi
  27. 13: KO_shot_front
  28. 14: KO_shot_front
  29. 15: KO_shot_front
  30. 16: KO_shot_front
  31. 17: KO_shot_face
  32. 18: KO_shot_stom
  33. 19: KO_shot_arml
  34. 20: KO_shot_armR
  35. 21: KO_shot_legl
  36. 22: KO_shot_legR
  37. 23: KO_left
  38. 24: KO_right
  39. 25: KO_skid_front
  40. 26: KO_spin_R
  41. 27: KO_skid_back
  42. 28: KO_spin_L
  43. 29: SHOT_partial
  44. 30: SHOT_leftP
  45. 31: SHOT_partial
  46. 32: SHOT_rightP
  47. 33: HIT_front
  48. 34: HIT_L
  49. 35: HIT_back
  50. 36: HIT_R
  51. 37: FLOOR_hit
  52. 38: HIT_bodyblow
  53. 39: HIT_chest
  54. 40: HIT_head
  55. 41: HIT_walk
  56. 42: HIT_wall
  57. 43: FLOOR_hit_f
  58. 44: HIT_behind
  59. 45: FIGHTIDLE
  60. 46: FIGHT2IDLE
  61. 47: FIGHTsh_F
  62. 48: FIGHTbodyblow
  63. 49: FIGHThead
  64. 50: FIGHTkick
  65. 51: FIGHTknee
  66. 52: FIGHTLhook
  67. 53: FIGHTpunch
  68. 54: FIGHTrndhse
  69. 55: FIGHTlngkick
  70. 56: FIGHTppunch
  71. 57: FIGHTjab
  72. 58: FIGHTelbowL
  73. 59: FIGHTelbowR
  74. 60: FIGHTbkickL
  75. 61: FIGHTbkickR
  76. 62: bomber
  77. 63: punchR
  78. 64: FIGHT_ppunch
  79. 65: KICK_floor
  80. 66: WEAPON_throwu
  81. 67: FIGHTsh_back
  82. 68: car_jackedRHS
  83. 69: car_LjackedRHS
  84. 70: car_jackedLHS
  85. 71: car_LjackedLHS
  86. 72: CAR_Qjack
  87. 73: CAR_Qjacked
  88. 74: CAR_align_LHS
  89. 75: CAR_alignHI_LHS
  90. 76: CAR_open_LHS
  91. 77: CAR_doorlocked_LHS
  92. 78: CAR_pullout_LHS
  93. 79: CAR_pulloutL_LHS
  94. 80: CAR_getin_LHS
  95. 81: CAR_getinL_LHS
  96. 82: CAR_closedoor_LHS
  97. 83: CAR_closedoorL_LHS
  98. 84: CAR_rolldoor
  99. 85: CAR_rolldoorL0
  100. 86: CAR_jumpin_LHS
  101. 87: CAR_getout_LHS
  102. 88: CAR_getoutL_LHS
  103. 89: CAR_close_LHS
  104. 90: CAR_align_RHS
  105. 91: CAR_alignHI_RHS
  106. 92: CAR_open_RHS
  107. 93: CAR_doorlocked_RHS
  108. 94: CAR_pullout_RHS
  109. 95: CAR_pulloutL_RHS
  110. 96: CAR_getin_RHS
  111. 97: CAR_getinL_RHS
  112. 98: CAR_closedoor_RHS
  113. 99: CAR_closedoorL_RHS
  114. 100: CAR_shuffle_RHS
  115. 101: CAR_Lshuffle_RHS
  116. 102: CAR_sit
  117. 103: CAR_Lsit
  118. 104: CAR_sitp
  119. 105: CAR_sitpLO
  120. 106: DRIVE_L
  121. 107: Drive_R
  122. 108: Drive_LO_l
  123. 109: Drive_LO_R
  124. 110: Driveby_L
  125. 111: Driveby_R
  126. 112: DrivebyL_L
  127. 113: DrivebyL_R
  128. 114: CAR_LB
  129. 115: DRIVE_BOAT
  130. 116: DRIVE_BOAT_L
  131. 117: DRIVE_BOAT_R
  132. 118: DRIVE_BOAR_back
  133. 119: BIKE_pickupR
  134. 120: BIKE_pickupL
  135. 121: BIKE_pullupR
  136. 122: BIKE_pullupL
  137. 123: BIKE_elbowR
  138. 124: BIKE_elbowL
  139. 125: BIKE_fall_off
  140. 126: BIKE_fallR
  141. 127: CAR_getout_RHS
  142. 128: CAR_getoutL_RHS
  143. 129: CAR_close_RHS
  144. 130: car_hookertalk
  145. 131: idle_stance
  146. 132: idle_stance
  147. 133: CAR_crawloutRHS
  148. 134: CAR_crawloutRHS
  149. 135: CAR_rollout_LHS
  150. 136: CAR_rollout_LHS
  151. 137: Getup
  152. 138: Getup
  153. 139: Getup
  154. 140: Getup_front
  155. 141: JUMP_launch
  156. 142: JUMP_glide
  157. 143: JUMP_land
  158. 144: FALL_fall
  159. 145: FALL_glide
  160. 146: FALL_land
  161. 147: FALL_collapse
  162. 148: FALL_back
  163. 149: FALL_front
  164. 150: EV_step
  165. 151: EV_dive
  166. 152: XPRESSscratch
  167. 153: roadcross
  168. 154: TURN_180
  169. 155: ARRESTgun
  170. 156: DROWN
  171. 157: DUCK_down
  172. 158: DUCK_low
  173. 159: WEAPON_crouch
  174. 160: RBLOCK_Cshoot
  175. 161: handsup
  176. 162: handsCOWER
  177. 163: FUCKU
  178. 164: PHONE_in
  179. 165: PHONE_out
  180. 166: PHONE_talk
  181. 167: SEAT_down
  182. 168: SEAT_up
  183. 169: SEAT_idle
  184. 170: SEAT_down
  185. 171: ATM
  186. 172: abseil
  187.  
  188.  
  189. ********************
  190. 10@ = 1
  191. VAN.ifp
  192. * - VAN
  193.  
  194. 174: *_openL
  195. 175: *_getinL
  196. 176: *_closeL
  197. 177: *_getoutL
  198. 178: *_open
  199. 179: *_getin
  200. 180: *_close
  201. 181: *_getout
  202.  
  203.  
  204. ********************
  205. 10@ = 2
  206. COACH.ifp
  207. * - COACH
  208.  
  209. 182: *_opnL
  210. 183: *_opnL  ?
  211. 184: *_inL
  212. 185: *_inL  ?
  213. 186: *_outL
  214.  
  215.  
  216. ********************
  217. 10@ = 3
  218. BIKEs.ifp
  219. * = BIKEs
  220.  
  221. 187F: *_Still
  222. 188F: *_Still  ?
  223. 189F: *_Left
  224. 190F: *_Right
  225. 191F: *_Back
  226. 192F: *_Fwd
  227. 193R: *_pushes
  228. 194: *_jumponR
  229. 195: *_jumponL
  230. 196: *_kick
  231. 197: *_hit  ?
  232. 198: *_getoffRHS
  233. 199: *_getoffLHS
  234. 200: *_getoffBACK
  235. 201F: *_drivebyLHS
  236. 202F: *_drivebyRHS
  237. 203F: *_drivebyFT
  238. 204F: *_drivebyFT ?
  239.  
  240.  
  241. ********************
  242. 10@ = 4
  243. BIKEv.ifp
  244. * = BIKEv
  245.  
  246. 187F: *_Still
  247. 188F: *_Still  ?
  248. 189F: *_Left
  249. 190F: *_Right
  250. 191F: *_Back
  251. 192F: *_Fwd
  252. 193R: *_pushes
  253. 194: *_jumponR
  254. 195: *_jumponL
  255. 196: *_kick
  256. 197: *_hit  ?
  257. 198: *_getoffRHS
  258. 199: *_getoffLHS
  259. 200: *_getoffBACK
  260. 201F: *_drivebyLHS
  261. 202F: *_drivebyRHS
  262. 203F: *_drivebyFT
  263. 204F: *_drivebyFT ?
  264.  
  265.  
  266. ********************
  267. 10@ = 5
  268. BIKEh.ifp
  269. * = BIKEh
  270.  
  271. 187F: *_Still
  272. 188F: *_Still  ?
  273. 189F: *_Left
  274. 190F: *_Right
  275. 191F: *_Back
  276. 192F: *_Fwd
  277. 193R: *_pushes
  278. 194: *_jumponR
  279. 195: *_jumponL
  280. 196: *_kick
  281. 197: *_hit  ?
  282. 198: *_getoffRHS
  283. 199: *_getoffLHS
  284. 200: *_getoffBACK
  285. 201F: *_drivebyLHS
  286. 202F: *_drivebyRHS
  287. 203F: *_drivebyFT
  288. 204F: *_drivebyFT ?
  289.  
  290.  
  291. ********************
  292. 10@ = 6
  293. BIKEd.ifp
  294. * = BIKEd
  295.  
  296. 187F: *_Still
  297. 188F: *_Still  ?
  298. 189F: *_Left
  299. 190F: *_Right
  300. 191F: *_Back
  301. 192F: *_Fwd
  302. 193R: *_pushes
  303. 194: *_jumponR
  304. 195: *_jumponL
  305. 196: *_kick
  306. 197: *_hit  ?
  307. 198: *_getoffRHS
  308. 199: *_getoffLHS
  309. 200: *_getoffBACK
  310. 201F: *_drivebyLHS
  311. 202F: *_drivebyRHS
  312. 203F: *_drivebyFT
  313. 204F: *_drivebyFT ?
  314.  
  315.  
  316. ********************
  317. 10@ = 8
  318. ped.ifp
  319.  
  320. 205: FIGHTbodyblow
  321. 206: FIGHTbodyblow  ?
  322. 207: FIGHTppunch
  323. 208: FIGHTIDLE
  324. 209: FIGHTbodyblow moving?
  325.  
  326.  
  327. ********************
  328. 10@ = 9
  329. knife.ifp
  330.  
  331. 205: WEAPON_knife_1
  332. 206: WEAPON_knife_2
  333. 207: knife_part
  334. 208: WEAPON_knifeidle
  335. 209: WEAPON_knife_3
  336.  
  337.  
  338. ********************
  339. 10@ = 10
  340. baseball.ifp
  341.  
  342. 205: WEAPON_bat_h
  343. 206: WEAPON_bat_v
  344. 207: BAT_PART
  345. 208: WEAPON_bat_h
  346. 209: WEAPON_golfclub
  347.  
  348.  
  349. ********************
  350. 10@ = 11
  351. baseball.ifp
  352.  
  353. 205: WEAPON_bat_h
  354. 206: WEAPON_golfclub
  355. 207: BAT_PART
  356. 208: WEAPON_bat_h
  357. 209: WEAPON_bat_v
  358.  
  359.  
  360. ********************
  361. 10@ = 13
  362. python.ifp
  363.  
  364. 205: python_fire
  365. 206: python_crouchfire
  366. 207: python_reload
  367. 208: python_crouchreload
  368.  
  369.  
  370. ********************
  371. 10@ = 14
  372. colt45.ifp
  373.  
  374. 205: colt45_fire
  375. 206: colt45_crouchfire
  376. 207: colt45_reload
  377. 208: colt45_crouchreload
  378. 209: colt45_cop
  379.  
  380.  
  381. ********************
  382. 10@ = 17
  383. colt45.ifp  ??
  384.  
  385. 205: colt45_fire
  386. 206: colt45_crouchfire
  387. 207: colt45_reload
  388. 208: colt45_crouchreload
  389. 209: colt45_cop
  390.  
  391.  
  392. ********************
  393. 10@ = 18
  394. uzi.ifp  ??
  395.  
  396. 205: UZI_fire
  397. 206: UZI_crouchfire
  398. 207: UZI_reload
  399. 208: UZI_crouchreload
  400.  
  401.  
  402. ********************
  403. 10@ = 19
  404. rifle.ifp  ??
  405.  
  406. 205: RIFLE_fire
  407. 206: RIFLE_crouchfire
  408. 207: RIFLE_reload
  409. 208: RIFLE_crouchreload
  410.  
  411.  
  412.  
  413.  
  414. ********************
  415. 10@ = 27
  416. RIOT.ifp
  417.  
  418. 219R: RIOT_ANGRY  
  419. 220R: RIOT_ANGRY_B
  420. 221R: RIOT_CHANT
  421. 222R: RIOT_PUNCHES
  422. 223R: RIOT_shout
  423. 224: RIOT_challenge
  424. 225: RIOT_FUKU
  425.  
  426.  
  427. ********************
  428. 10@ = 28
  429. STRIP.ifp
  430.  
  431. 226R: strip_A
  432. 227R: strip_B
  433. 228R: strip_C
  434. 229R: strip_D
  435. 230: strip_E
  436. 231R: strip_F
  437. 232: strip_G
  438.  
  439.  
  440. ********************
  441. 10@ = 29
  442. LANCE.ifp
  443.  
  444. 210: lance
  445.  
  446.  
  447. ********************
  448. 10@ = 33
  449.  
  450. ped.ifp
  451.  
  452. ROCKETLAUNCHER:
  453.  
  454. 228: (funny legs with run)
  455. 229: (funny legs with run)
  456. 230:
  457. 231: IDLE_ROCKET
  458. 232:  
  459.  
  460.  
  461. ********************
  462. 10@ = 34
  463.  
  464. ped.ifp
  465.  
  466. ROCKETLAUNCHER_LEFT:
  467.  
  468. 228: walk left(funny legs with run)
  469. 229: run left(funny legs with run)
  470. 230:
  471. 231: IDLE_ROCKET
  472. 232:  
  473.  
  474.  
  475.  
  476.  
  477. ********************
  478. 10@ = 40???
  479.  
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: daniel_360 от Январь 17, 2020, 01:14:08 pm
Возможно ли сделать так, например записать ночные адреса памяти, и заменить на дневные, чтобы убрать свет и не возиться в файлах игры?
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Январь 17, 2020, 02:37:23 pm
Возможно ли сделать так, например записать ночные адреса памяти, и заменить на дневные, чтобы убрать свет и не возиться в файлах игры?
Время действие timeobj объектов прописано в ide. Игра "не знает", какие из этих объектов дневные, а какие - ночные. Она просто включает/выключает их в зависимости от времени, которое указано в ide.
Ты можешь заменить какую-нибудь погоду в timecyc, чтобы она и днем была темная, а затем включать у себя постоянно эту погоду и дневное время суток. Только игровые часы будут выдавать подвох - нужно искать способ их снести, если будешь использовать этот вариант.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: daniel_360 от Январь 17, 2020, 02:48:33 pm
Помню, как-то пытался сделать по совету =SpitFire=, поставить время 99 99, вроде сработало, но на оушен бич были чёрные текстуры, и я отказался от этой идеи.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Январь 17, 2020, 04:14:30 pm
Не обязательно 99 99 - достаточно 0 0, чтобы отключить объект
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Saint от Март 07, 2020, 08:56:03 pm
тоесть если мы будем нажимать кнопку огонь (ЛКМ) то игрок не будет выполнять никаких действий?
Да. Будто и нет такой механики. При этом, в отличии от отключения всех драк(ранее в этой теме) - педы не теряют возможности атаковать. Да и игрок под управлением ИИ сможет атаковать.
Т.е. выключается только сама привязка контроллера к атакам.

а не подскажешь пожалуйста участок кода который отвечает за посадку игрока в Авто когда он нажимает F
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Март 07, 2020, 10:25:50 pm
а не подскажешь пожалуйста участок кода который отвечает за посадку игрока в Авто когда он нажимает F
Пока это не разбирал, к сожалению. Ты есть на Discord сервере SDK? Там могут помочь найти этот участок.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Saint от Март 08, 2020, 12:34:45 pm
а не подскажешь пожалуйста участок кода который отвечает за посадку игрока в Авто когда он нажимает F
Пока это не разбирал, к сожалению. Ты есть на Discord сервере SDK? Там могут помочь найти этот участок.

пользуюсь только ВК
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Март 09, 2020, 02:03:59 am
пользуюсь только ВК
Жаль. В Дискорде есть много спецов. Целые группы, полные опытными модмейкерами.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: daniel_360 от Май 06, 2020, 11:31:10 pm
Поделюсь тоже, что нашёл:
P.S версия GTA Vice City - 1.0
05DF: write_memory 0x69A1D8 size 4 value 150.0 virtual_protect 1 // LOD людей и машин(70.0 default)
05DF: write_memory 0x687138 size 4 value 150.0 virtual_protect 1 // Удаляет транспорт, когда игрок повёрнут спиной к машине(40.0 default)
05DF: write_memory 0x6871F8 size 4 value 150.0 virtual_protect 1 // Удаляет транспорт, в зоне видимости игрока(120.0 default)
05DF: write_memory 0x687200 size 4 value 150.0 virtual_protect 1 // Удаляет транспорт, когда игрок смотрит под ноги(70.0 default)
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: Shagg_E от Ноябрь 21, 2020, 04:40:05 am
05DF: write_memory 0x69A1D8 size 4 value 150.0 virtual_protect 1 // LOD людей и машин(70.0 default)
05DF: write_memory 0x687138 size 4 value 150.0 virtual_protect 1 // Удаляет транспорт, когда игрок повёрнут спиной к машине(40.0 default)
05DF: write_memory 0x6871F8 size 4 value 150.0 virtual_protect 1 // Удаляет транспорт, в зоне видимости игрока(120.0 default)
05DF: write_memory 0x687200 size 4 value 150.0 virtual_protect 1 // Удаляет транспорт, когда игрок смотрит под ноги(70.0 default)
Тогда не обратил внимание, но сейчас заметил: с этими адресами есть нюанс. Если у всех выставить одинаковое значение - могут возникать ситуации, когда транспорт будет появляться и сразу же исчезать, так что лучше, чтобы первое значение было меньше остальных. Т.е. либо его уменьшить, либо остальные увеличить (хотя бы на 10 юнитов, но разница быть должна).
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: xanser от Март 09, 2021, 01:21:55 pm
Забавный адрес 0x69207C, если поставить значение побольше, например 9999.0, то ущерб от падения с высоты усилится. Можно убиться метров с десяти. Кроме реалистичности особой пользы от этого нет, если только усложнить себе жизнь при прохождении, зато весело сталкивать других. Первоначальное значение тоже расшибает пешехода примерно с высоты 50 метров, есть небольшая рандомность. С вертолета разбиться скорее всего не получится, там анимация не та, но ее можно принудительно переключить на свободное падение, тогда получится. Во вложении плагин с этим адресом побаловаться.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: aleks926820 от Март 10, 2021, 12:31:18 pm
Не знаю может уже кто это знает, но на всякий случай скину сюда.
Нашел способ отключения короны и света практически у всех пикапов.
Прошерстил функцию CPickups::DoPickUpEffects в IDA.
Эти три адреса влияют на размер короны:
0x688308 float
0x688334 float
0x688300 float
Пишем в них 0.0 для отключения короны.
Далее адреса с байтовым значением влияют на свет от некоторых пикапов.
По умолчанию значения в адресах 1. Для отключения света пишем в них 0.
0x43F21F BYTE - отключает свет у пикапа сохранения.
0x43F14F BYTE - отключает свет у пикапа взятки.
0x43F1C1 BYTE - отключает свет у пикапа недоступной недвижимости.
0x43F1DF BYTE - отключает свет у пикапа wMIDBigdollar (пикап вырученных с недвижимости денег?).
0x43f243 BYTE - отключает свет у пикапа одежды.
Эти адреса вроде как тоже отключают свет (но толком не понял где именно) :
0x43f1ac BYTE. ?
0x43F17A BYTE. ?
0x43F11C BYTE. ?
https://sun9-13.userapi.com/impf/wF6081-x17ArfRiNJtBQULTTbfOF2jtu7JQkOA/nmdA8NL0Qz4.jpg?size=1280x1024&quality=96&sign=79e977ad43945502551d7c91f0326d73&type=album
https://sun9-20.userapi.com/impf/RYV5x2lHZG7RgvuWcVGTLciw2fs_fmpP7uJFgw/v7E_uOrX9ag.jpg?size=1280x1024&quality=96&sign=9cea2049f7c8a42af5bd5f699ff544cd&type=album
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: egor230 от Март 15, 2021, 03:41:53 pm
Не знаю может уже кто это знает, но на всякий случай скину сюда.
Нашел способ отключения короны и света практически у всех пикапов.
Прошерстил функцию CPickups::DoPickUpEffects в IDA.
Эти три адреса влияют на размер короны:
0x688308 float
0x688334 float
0x688300 float
Пишем в них 0.0 для отключения короны.
Далее адреса с байтовым значением влияют на свет от некоторых пикапов.
По умолчанию значения в адресах 1. Для отключения света пишем в них 0.
0x43F21F BYTE - отключает свет у пикапа сохранения.
0x43F14F BYTE - отключает свет у пикапа взятки.
0x43F1C1 BYTE - отключает свет у пикапа недоступной недвижимости.
0x43F1DF BYTE - отключает свет у пикапа wMIDBigdollar (пикап вырученных с недвижимости денег?).
0x43f243 BYTE - отключает свет у пикапа одежды.
Эти адреса вроде как тоже отключают свет (но толком не понял где именно) :
0x43f1ac BYTE. ?
0x43F17A BYTE. ?
0x43F11C BYTE. ?
https://sun9-13.userapi.com/impf/wF6081-x17ArfRiNJtBQULTTbfOF2jtu7JQkOA/nmdA8NL0Qz4.jpg?size=1280x1024&quality=96&sign=79e977ad43945502551d7c91f0326d73&type=album
https://sun9-20.userapi.com/impf/RYV5x2lHZG7RgvuWcVGTLciw2fs_fmpP7uJFgw/v7E_uOrX9ag.jpg?size=1280x1024&quality=96&sign=9cea2049f7c8a42af5bd5f699ff544cd&type=album

Круто, что Вы нашли эти адреса. Они пригодятся в модах.
Название: Re: Выкладываем наработки по анализу кода, дизассемблированные базы, адреса
Отправлено: aleks926820 от Март 16, 2021, 04:29:34 pm
0x6954A8 float - скорость вращения облаков. По умолчанию значение 60.0. Для отключения вращения можно прописать 0.0.
0x6954AC float - высота облаков над уровнем моря. По умолчанию значение 40.0.
0x6958A4 float - отвечает за пульсации солнца. По умолчанию 0.0049.
0x6954C8 float - размер всех облаков. По умолчанию 55.0.
0x6954B0 float  - отвечает за прозрачность облаков. По умолчанию  320.0.
0x6954B4 float  - отвечает за прозрачность облаков.  По умолчанию  160.0.
0x6954AC float - тоже влияет на размер больших белых облаков.  По умолчанию  40.0.