API tools faq
paste
Guest User

Untitled

a guest
Sep 15th, 2018
144
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 24.44 KB | None | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2. #include "SkinChanger-func.h"
  3. #include <unordered_map>
  4. #include <random>
  5.  
  6. #define INVALID_EHANDLE_INDEX 0xFFFFFFFF
  7. #define RandomIntZ(min, max) (rand() % (max - min + 1) + min)
  8.  
  9. CSkinchanger* g_Skinchanger = new CSkinchanger;
  10.  
  11. void CSkinchanger::ForceItemUpdates()
  12. {
  13. typedef void(*CL_FullUpdate_t) (void);
  14. static CL_FullUpdate_t cl_fullupdate = (CL_FullUpdate_t)(offsets.IDA_FullUpdate);
  15. cl_fullupdate();
  16. }
  17. void CSkinchanger::UpdateModels()
  18. {
  19. //Knifes
  20. this->Knifes.knife_default_ct = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_knife_default_ct.mdl");
  21. this->Knifes.knife_default_t = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_knife_default_t.mdl");
  22. this->Knifes.knife_karam = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_knife_karam.mdl");
  23. this->Knifes.knife_bayonet = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_knife_bayonet.mdl");
  24. this->Knifes.knife_m9_bay = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_knife_m9_bay.mdl");
  25. this->Knifes.knife_tactical = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_knife_tactical.mdl");
  26. this->Knifes.knife_gut = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_knife_gut.mdl");
  27. this->Knifes.knife_falchion_advanced = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_knife_falchion_advanced.mdl");
  28. this->Knifes.knife_push = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_knife_push.mdl");
  29. this->Knifes.knife_butterfly = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_knife_butterfly.mdl");
  30. this->Knifes.knife_flip = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_knife_flip.mdl");
  31. this->Knifes.knife_survival_bowie = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_knife_survival_bowie.mdl");
  32. //Gloves
  33. this->Gloves.glove_bloodhound = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_models/arms/glove_bloodhound/v_glove_bloodhound.mdl");
  34. this->Gloves.glove_sporty = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_models/arms/glove_bloodhound/v_glove_sporty.mdl");
  35. this->Gloves.glove_slick = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_models/arms/glove_bloodhound/v_glove_slick.mdl");
  36. this->Gloves.glove_handwrap_leathery = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_models/arms/glove_bloodhound/v_glove_handwrap_leathery.mdl");
  37. this->Gloves.glove_motorcycle = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_models/arms/glove_bloodhound/v_glove_motorcycle.mdl");
  38. this->Gloves.glove_specialist = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_models/arms/glove_bloodhound/v_glove_specialist.mdl");
  39. this->Gloves.glove_hydra = Interfaces.g_pModelInfo->GetModelIndex("models/weapons/v_models/arms/glove_bloodhound/v_glove_bloodhound_hydra.mdl");
  40.  
  41.  
  42.  
  43. }
  44. int CSkinchanger::GetModelByIndex(int item_def_index)
  45. {
  46. switch (item_def_index)
  47. {
  48. case WEAPON_KNIFE:return this->Knifes.knife_default_ct; break;
  49. case WEAPON_KNIFE_T:return this->Knifes.knife_default_t; break;
  50. case WEAPON_KNIFE_KARAMBIT:return this->Knifes.knife_karam; break;
  51. case WEAPON_KNIFE_BAYONET:return this->Knifes.knife_bayonet; break;
  52. case WEAPON_KNIFE_M9_BAYONET:return this->Knifes.knife_m9_bay; break;
  53. case WEAPON_KNIFE_TACTICAL:return this->Knifes.knife_tactical; break;
  54. case WEAPON_KNIFE_GUT:return this->Knifes.knife_gut; break;
  55. case WEAPON_KNIFE_FALCHION:return this->Knifes.knife_falchion_advanced; break;
  56. case WEAPON_KNIFE_PUSH:return this->Knifes.knife_push; break;
  57. case WEAPON_KNIFE_BUTTERFLY:return this->Knifes.knife_butterfly; break;
  58. case WEAPON_KNIFE_FLIP:return this->Knifes.knife_flip; break;
  59. case WEAPON_KNIFE_SURVIVAL_BOWIE:return this->Knifes.knife_survival_bowie; break;
  60. default:return 0; break;
  61. }
  62. }
  63.  
  64. int knifeItemIndex(int MenuVar, int team)
  65. {
  66. switch (MenuVar)
  67. {
  68. case 0:
  69. default:
  70. switch (team)
  71. {
  72. default:
  73. case 2:return WEAPON_KNIFE_T; break;
  74. case 3:return WEAPON_KNIFE; break;
  75. }break;
  76. case 1: return WEAPON_KNIFE_KARAMBIT; break;
  77. case 2: return WEAPON_KNIFE_BAYONET; break;
  78. case 3: return WEAPON_KNIFE_M9_BAYONET; break;
  79. case 4: return WEAPON_KNIFE_TACTICAL; break;
  80. case 5: return WEAPON_KNIFE_GUT; break;
  81. case 6: return WEAPON_KNIFE_FALCHION; break;
  82. case 7: return WEAPON_KNIFE_PUSH; break;
  83. case 8: return WEAPON_KNIFE_BUTTERFLY; break;
  84. case 9: return WEAPON_KNIFE_FLIP; break;
  85. case 10: return WEAPON_KNIFE_SURVIVAL_BOWIE; break;
  86. }
  87. }
  88.  
  89. void CSkinchanger::CreateMove()
  90. {
  91. if (!G::LocalPlayer)return;
  92. player_info_t localplayer_info;
  93. if (Interfaces.pEngine->GetPlayerInfo(Interfaces.pEngine->GetLocalPlayer(), &localplayer_info))
  94. {
  95. if (g_Options.Skinchanger.glovemodel > 0)
  96. {
  97. this->GloveChanger(localplayer_info);
  98. }
  99.  
  100. CBaseHandle* hWeapons = G::LocalPlayer->GetWeaponsZ();
  101. if (hWeapons)
  102. {
  103. for (CBaseHandle i = 0; hWeapons[i] != INVALID_EHANDLE_INDEX; i++)
  104. {
  105. CBaseAttributableItem* weapon = (CBaseAttributableItem*)Interfaces.pEntList->GetClientEntityFromHandle(hWeapons[i]);
  106. if (!weapon)
  107. continue;
  108. if(*weapon->GetItemDefinitionIndex() < 1)
  109. continue;
  110.  
  111. *weapon->GetItemIDHigh() = -1;
  112. *weapon->GetAccountID() = localplayer_info.xuidlow;
  113. if (weapon->IsKnife())
  114. {
  115. *weapon->GetItemDefinitionIndex() = knifeItemIndex(g_Options.Skinchanger.knifemodel, G::LocalPlayer->GetTeam());
  116. auto WeaponIDMEME = *weapon->GetItemDefinitionIndex();
  117.  
  118. *(int*)((DWORD)weapon + offsets.m_nModeIndex) = this->GetModelByIndex(WeaponIDMEME);
  119.  
  120. auto WorldModel = weapon->GetWorldModel();
  121. if (WorldModel)
  122. {
  123. CBaseAttributableItem *pWorldModel = (CBaseAttributableItem*)Interfaces.pEntList->GetClientEntityFromHandle(WorldModel);
  124. if (pWorldModel)
  125. {
  126. pWorldModel->SetModelIndex(this->GetModelByIndex(WeaponIDMEME) + 1);
  127. }
  128. }
  129. }
  130.  
  131.  
  132. this->ApplyCustomSkin(weapon, localplayer_info);
  133. this->ApplyStickerHooks(weapon);
  134. }
  135. }
  136. }
  137.  
  138. }
  139.  
  140.  
  141. RecvVarProxyFn oRecvnModelIndex;
  142. void ViewModel_Index_Proxy(CRecvProxyData *pDataConst, void *pStruct, void *pOut)
  143. {
  144. // Get local player (just to stop replacing spectators knifes)
  145. if (G::LocalPlayer && g_Options.Skinchanger.EnabledChanger && Interfaces.pEngine->IsInGame() && Interfaces.pEngine->IsConnected())
  146. {
  147.  
  148. // If we are alive and holding a default knife(if we already have a knife don't worry about changing)
  149. if (G::LocalPlayer->isAlive() && (
  150. pDataConst->m_Value.m_Int == g_Skinchanger->Knifes.knife_default_t ||
  151. pDataConst->m_Value.m_Int == g_Skinchanger->Knifes.knife_default_ct ||
  152. pDataConst->m_Value.m_Int == g_Skinchanger->Knifes.knife_bayonet ||
  153. pDataConst->m_Value.m_Int == g_Skinchanger->Knifes.knife_butterfly ||
  154. pDataConst->m_Value.m_Int == g_Skinchanger->Knifes.knife_flip ||
  155. pDataConst->m_Value.m_Int == g_Skinchanger->Knifes.knife_gut ||
  156. pDataConst->m_Value.m_Int == g_Skinchanger->Knifes.knife_karam ||
  157. pDataConst->m_Value.m_Int == g_Skinchanger->Knifes.knife_m9_bay ||
  158. pDataConst->m_Value.m_Int == g_Skinchanger->Knifes.knife_tactical ||
  159. pDataConst->m_Value.m_Int == g_Skinchanger->Knifes.knife_falchion_advanced ||
  160. pDataConst->m_Value.m_Int == g_Skinchanger->Knifes.knife_push ||
  161. pDataConst->m_Value.m_Int == g_Skinchanger->Knifes.knife_survival_bowie) && g_Options.Skinchanger.knifemodel > 0)
  162. {
  163. // Set whatever knife we want
  164. switch (g_Options.Skinchanger.knifemodel)
  165. {
  166. case 0:
  167. pDataConst->m_Value.m_Int = G::LocalPlayer->GetTeam() == 2 ? g_Skinchanger->Knifes.knife_default_t : g_Skinchanger->Knifes.knife_default_ct;
  168. break; case 1: {
  169. pDataConst->m_Value.m_Int = g_Skinchanger->Knifes.knife_karam;
  170. }
  171. break; case 2: {
  172. pDataConst->m_Value.m_Int = g_Skinchanger->Knifes.knife_bayonet;
  173. }
  174. break; case 3: {
  175. pDataConst->m_Value.m_Int = g_Skinchanger->Knifes.knife_m9_bay;
  176. }
  177. break; case 4: {
  178. pDataConst->m_Value.m_Int = g_Skinchanger->Knifes.knife_tactical;
  179. }
  180. break; case 5: {
  181. pDataConst->m_Value.m_Int = g_Skinchanger->Knifes.knife_gut;
  182. }
  183. break; case 6: {
  184. pDataConst->m_Value.m_Int = g_Skinchanger->Knifes.knife_falchion_advanced;
  185. }
  186. break; case 7: {
  187. pDataConst->m_Value.m_Int = g_Skinchanger->Knifes.knife_push;
  188. }
  189. break; case 8: {
  190. pDataConst->m_Value.m_Int = g_Skinchanger->Knifes.knife_butterfly;
  191. }
  192. break; case 9: {
  193. pDataConst->m_Value.m_Int = g_Skinchanger->Knifes.knife_flip;
  194. }
  195. break; case 10: {
  196. pDataConst->m_Value.m_Int = g_Skinchanger->Knifes.knife_survival_bowie;
  197. }
  198. }
  199.  
  200. }
  201. }
  202.  
  203. // Carry on the to original proxy
  204. oRecvnModelIndex(pDataConst, pStruct, pOut);
  205.  
  206. }
  207.  
  208. bool CSkinchanger::ApplyCustomSkin(CBaseAttributableItem* attrib_item, player_info_t pInfo) {
  209. if (attrib_item)
  210. {
  211. int nWeaponIndex = *attrib_item->GetItemDefinitionIndex();
  212. if (g_Options.Skinchanger.SkinMaster[nWeaponIndex].PaintKit > 0)
  213. *attrib_item->GetFallbackPaintKit() = g_Options.Skinchanger.SkinMaster[nWeaponIndex].PaintKit;
  214. *attrib_item->GetFallbackSeed() = g_Options.Skinchanger.SkinMaster[nWeaponIndex].Seed;
  215. if (((CBaseCombatWeapon*)attrib_item)->IsKnife())
  216. if (g_Options.Skinchanger.knifemodel > 0)
  217. *attrib_item->GetEntityQuality() = 3;
  218. else
  219. *attrib_item->GetEntityQuality() = 1;
  220. else
  221. *attrib_item->GetEntityQuality() = g_Options.Skinchanger.SkinMaster[nWeaponIndex].Stattrak ? 4 : 0;
  222. if (g_Options.Skinchanger.SkinMaster[nWeaponIndex].Stattrak)
  223. *attrib_item->GetFallbackStatTrak() = g_Options.Skinchanger.SkinMaster[nWeaponIndex].StattrakValue;
  224. else
  225. *attrib_item->GetFallbackStatTrak() = -1;
  226. if (g_Options.Skinchanger.SkinMaster[nWeaponIndex].Wear == 0.f)
  227. *attrib_item->GetFallbackWear() = 0.00000001f;
  228. else
  229. {
  230. if (g_Options.Skinchanger.SkinMaster[nWeaponIndex].Wear >= 100.f)
  231. *attrib_item->GetFallbackWear() = 1.f;
  232. else
  233. *attrib_item->GetFallbackWear() = g_Options.Skinchanger.SkinMaster[nWeaponIndex].Wear / 100;
  234. }
  235. return true;
  236. }
  237. else return false;
  238. }
  239.  
  240.  
  241.  
  242.  
  243.  
  244.  
  245.  
  246. int GetGloveSkinByMenu(int gloveIndex, int skinIndex)
  247. {
  248. if (gloveIndex == 0) // bloudhound
  249. {
  250. switch (skinIndex)
  251. {
  252. case 0:
  253. return 10006; break;
  254. case 1:
  255. return 10007; break;
  256. case 2:
  257. return 10008; break;
  258. case 3:
  259. return 10039; break;
  260. default:
  261. return 0; break;
  262. }
  263. }
  264. else if (gloveIndex == 1) // Sport
  265. {
  266. switch (skinIndex)
  267. {
  268. case 0:
  269. return 10038; break;
  270. case 1:
  271. return 10037; break;
  272. case 2:
  273. return 10018; break;
  274. case 3:
  275. return 10019; break;
  276. case 4:
  277. return 10048; break;
  278. case 5:
  279. return 10047; break;
  280. case 6:
  281. return 10045; break;
  282. case 7:
  283. return 10046; break;
  284. default:
  285. return 0; break;
  286. }
  287. }
  288. else if (gloveIndex == 2) // Driver
  289. {
  290. switch (skinIndex)
  291. {
  292. case 0:
  293. return 10013; break;
  294. case 1:
  295. return 10015; break;
  296. case 2:
  297. return 10016; break;
  298. case 3:
  299. return 10040; break;
  300. case 4:
  301. return 10043; break;
  302. case 5:
  303. return 10044; break;
  304. case 6:
  305. return 10041; break;
  306. case 7:
  307. return 10042; break;
  308. default:
  309. return 0; break;
  310. }
  311. }
  312. else if (gloveIndex == 3) // Wraps
  313. {
  314. switch (skinIndex)
  315. {
  316. case 0:
  317. return 10009; break;
  318. case 1:
  319. return 10010; break;
  320. case 2:
  321. return 10021; break;
  322. case 3:
  323. return 10036; break;
  324. case 4:
  325. return 10053; break;
  326. case 5:
  327. return 10054; break;
  328. case 6:
  329. return 10055; break;
  330. case 7:
  331. return 10056; break;
  332. default:
  333. return 0; break;
  334. }
  335. }
  336. else if (gloveIndex == 4) // Moto
  337. {
  338. switch (skinIndex)
  339. {
  340. case 0:
  341. return 10024; break;
  342. case 1:
  343. return 10026; break;
  344. case 2:
  345. return 10027; break;
  346. case 3:
  347. return 10028; break;
  348. case 4:
  349. return 10050; break;
  350. case 5:
  351. return 10051; break;
  352. case 6:
  353. return 10052; break;
  354. case 7:
  355. return 10049; break;
  356. default:
  357. return 0; break;
  358. }
  359. }
  360. else if (gloveIndex == 5) // Specialist
  361. {
  362. switch (skinIndex)
  363. {
  364. case 0:
  365. return 10030; break;
  366. case 1:
  367. return 10033; break;
  368. case 2:
  369. return 10034; break;
  370. case 3:
  371. return 10035; break;
  372. case 4:
  373. return 10061; break;
  374. case 5:
  375. return 10062; break;
  376. case 6:
  377. return 10063; break;
  378. case 7:
  379. return 10064; break;
  380. default:
  381. return 0; break;
  382. }
  383. }
  384. else if (gloveIndex == 6) // HYDRA
  385. {
  386. switch (skinIndex)
  387. {
  388. case 0:
  389. return 10057; break;
  390. case 1:
  391. return 10058; break;
  392. case 2:
  393. return 10059; break;
  394. case 3:
  395. return 10060; break;
  396. default:
  397. return 0; break;
  398. }
  399. }
  400. else
  401. return 0;
  402. }
  403. int GetGloveIndexByMenu(int gloveIndexinmenu)
  404. {
  405. switch (gloveIndexinmenu)
  406. {
  407. case 0: default: return 0; break;
  408. case 1: return 5027; break;
  409. case 2: return 5030; break;
  410. case 3: return 5031; break;
  411. case 4: return 5032; break;
  412. case 5: return 5033; break;
  413. case 6: return 5034; break;
  414. case 7: return 5035; break;
  415. }
  416. }
  417.  
  418. int CSkinchanger::GetGloveModelIndexByMenu(int gloveIndexinmenu)
  419. {
  420. switch (gloveIndexinmenu)
  421. {
  422.  
  423. default:
  424. case 0:
  425. return NULL; break;
  426. case 1:return this->Gloves.glove_bloodhound; break;
  427. case 2:return this->Gloves.glove_sporty; break;
  428. case 3:return this->Gloves.glove_slick; break;
  429. case 4:return this->Gloves.glove_handwrap_leathery; break;
  430. case 5:return this->Gloves.glove_motorcycle; break;
  431. case 6:return this->Gloves.glove_specialist; break;
  432. case 7:return this->Gloves.glove_hydra; break;
  433.  
  434. }
  435. }
  436.  
  437. void CSkinchanger::GloveChanger(player_info_t pInfo)
  438. {
  439. static bool glovesUpdated = false;
  440. if (!Interfaces.pEntList->GetClientEntityFromHandle(*G::LocalPlayer->GetWearables()))
  441. {
  442. for (ClientClass *pClass = Interfaces.pClient->GetAllClasses(); pClass; pClass = pClass->m_pNext)
  443. {
  444. if (pClass->m_ClassID != 45)
  445. continue;
  446.  
  447. int entry = (Interfaces.pEntList->GetHighestEntityIndex() + 1), serial = RandomIntZ(0x0, 0xFFF);
  448. pClass->m_pCreateFn(entry, serial);
  449. G::LocalPlayer->GetWearables()[0] = entry | (serial << 16);
  450. glovesUpdated = true;
  451.  
  452. break;
  453. }
  454. }
  455. CBaseAttributableItem* glove = (CBaseAttributableItem*)Interfaces.pEntList->GetClientEntity(G::LocalPlayer->GetWearables()[0] & 0xFFF);
  456.  
  457. if (glove && glovesUpdated)
  458. {
  459. *glove->GetItemIDHigh() = -1;
  460. *glove->GetFallbackStatTrak() = -1;
  461. *glove->GetItemDefinitionIndex() = GetGloveIndexByMenu(g_Options.Skinchanger.glovemodel);
  462. *glove->GetFallbackPaintKit() = GetGloveSkinByMenu(g_Options.Skinchanger.glovemodel - 1, g_Options.Skinchanger.gloveskin);
  463. *glove->GetFallbackWear() = 0.00000001f;
  464. *glove->GetFallbackSeed() = 0;
  465. glove->SetModelIndex(this->GetGloveModelIndexByMenu(g_Options.Skinchanger.glovemodel));
  466. glove->PreDataUpdate(0);
  467. glovesUpdated = false;
  468. }
  469. }
  470.  
  471.  
  472.  
  473.  
  474.  
  475.  
  476.  
  477.  
  478.  
  479.  
  480. enum class EStickerAttributeType
  481. {
  482. Index,
  483. Wear,
  484. Scale,
  485. Rotation
  486. };
  487. DWORD dwEconItemInterfaceWrapper = 0;
  488.  
  489. typedef float(__thiscall* GetStickerAttributeBySlotIndexFloatFn)(void*, int, EStickerAttributeType, float);
  490. GetStickerAttributeBySlotIndexFloatFn oGetStickerAttributeBySlotIndexFloat;
  491. float __fastcall Hooked_GetStickerAttributeBySlotIndexFloat(void* thisptr, void* edx, int iSlot, EStickerAttributeType iAttribute, float flUnknown)
  492. {
  493. auto pItem = reinterpret_cast<CBaseAttributableItem*>(DWORD(thisptr) - dwEconItemInterfaceWrapper);
  494. if (!pItem)
  495. return oGetStickerAttributeBySlotIndexFloat(thisptr, iSlot, iAttribute, flUnknown);
  496.  
  497. int iID = *pItem->GetItemDefinitionIndex();
  498. if (!g_Options.Skinchanger.SkinMaster[iID].StickersEnabled)
  499. return oGetStickerAttributeBySlotIndexFloat(thisptr, iSlot, iAttribute, flUnknown);
  500.  
  501. switch (iAttribute)
  502. {
  503. case EStickerAttributeType::Wear:
  504. return min(1.f, g_Options.Skinchanger.SkinMaster[iID].Stickers[iSlot].flWear + 0.0000000001f);
  505. case EStickerAttributeType::Scale:
  506. return g_Options.Skinchanger.SkinMaster[iID].Stickers[iSlot].flScale;
  507. case EStickerAttributeType::Rotation:
  508. return g_Options.Skinchanger.SkinMaster[iID].Stickers[iSlot].iRotation;
  509. default:
  510. break;
  511. }
  512.  
  513. return oGetStickerAttributeBySlotIndexFloat(thisptr, iSlot, iAttribute, flUnknown);
  514. }
  515.  
  516. typedef UINT(__thiscall* GetStickerAttributeBySlotIndexIntFn)(void*, int, EStickerAttributeType, float);
  517. GetStickerAttributeBySlotIndexIntFn oGetStickerAttributeBySlotIndexInt;
  518. UINT __fastcall Hooked_GetStickerAttributeBySlotIndexInt(void* thisptr, void* edx, int iSlot, EStickerAttributeType iAttribute, UINT iUnknown)
  519. {
  520. auto pItem = reinterpret_cast<CBaseAttributableItem*>(DWORD(thisptr) - dwEconItemInterfaceWrapper);
  521. if (!pItem)
  522. return oGetStickerAttributeBySlotIndexInt(thisptr, iSlot, iAttribute, iUnknown);
  523.  
  524. int iID = *pItem->GetItemDefinitionIndex();
  525. if (!g_Options.Skinchanger.SkinMaster[iID].StickersEnabled)
  526. return oGetStickerAttributeBySlotIndexInt(thisptr, iSlot, iAttribute, iUnknown);
  527.  
  528. return g_Options.Skinchanger.SkinMaster[iID].Stickers[iSlot].iID;
  529. // return Parser::Stickers.List[g_Weapons[iID].Stickers[iSlot].iID].iID; //
  530. }
  531. bool IsCodePtr(void* ptr)
  532. {
  533. constexpr const DWORD protect_flags = PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY;
  534.  
  535. MEMORY_BASIC_INFORMATION out;
  536. VirtualQuery(ptr, &out, sizeof out);
  537.  
  538. return out.Type
  539. && !(out.Protect & (PAGE_GUARD | PAGE_NOACCESS))
  540. && out.Protect & protect_flags;
  541. }
  542. void CSkinchanger::ApplyStickerHooks(CBaseAttributableItem* attrib_item)
  543. {
  544. if (!dwEconItemInterfaceWrapper)
  545. dwEconItemInterfaceWrapper = 0x2DB0 + 0xC;
  546.  
  547. void**& vmt = *reinterpret_cast<void***>(DWORD(attrib_item) + dwEconItemInterfaceWrapper);
  548.  
  549. static void** hooked_vmt = nullptr;
  550. if (!hooked_vmt)
  551. {
  552. size_t size = 0;
  553.  
  554. while (IsCodePtr(vmt[size]))
  555. ++size;
  556.  
  557. hooked_vmt = new void*[size];
  558. memcpy(hooked_vmt, vmt, size * sizeof(void*));
  559.  
  560. oGetStickerAttributeBySlotIndexFloat = (GetStickerAttributeBySlotIndexFloatFn)hooked_vmt[4];
  561. hooked_vmt[4] = reinterpret_cast<void*>(&Hooked_GetStickerAttributeBySlotIndexFloat);
  562.  
  563. oGetStickerAttributeBySlotIndexInt = (GetStickerAttributeBySlotIndexIntFn)hooked_vmt[5];
  564. hooked_vmt[5] = reinterpret_cast<void*>(&Hooked_GetStickerAttributeBySlotIndexInt);
  565. }
  566. vmt = hooked_vmt;
  567. }
  568.  
  569.  
  570. #define SEQUENCE_DEFAULT_DRAW 0
  571. #define SEQUENCE_DEFAULT_IDLE1 1
  572. #define SEQUENCE_DEFAULT_IDLE2 2
  573. #define SEQUENCE_DEFAULT_LIGHT_MISS1 3
  574. #define SEQUENCE_DEFAULT_LIGHT_MISS2 4
  575. #define SEQUENCE_DEFAULT_HEAVY_MISS1 9
  576. #define SEQUENCE_DEFAULT_HEAVY_HIT1 10
  577. #define SEQUENCE_DEFAULT_HEAVY_BACKSTAB 11
  578. #define SEQUENCE_DEFAULT_LOOKAT01 12
  579.  
  580. #define SEQUENCE_BUTTERFLY_DRAW 0
  581. #define SEQUENCE_BUTTERFLY_DRAW2 1
  582. #define SEQUENCE_BUTTERFLY_LOOKAT01 13
  583. #define SEQUENCE_BUTTERFLY_LOOKAT03 15
  584.  
  585. #define SEQUENCE_FALCHION_IDLE1 1
  586. #define SEQUENCE_FALCHION_HEAVY_MISS1 8
  587. #define SEQUENCE_FALCHION_HEAVY_MISS1_NOFLIP 9
  588. #define SEQUENCE_FALCHION_LOOKAT01 12
  589. #define SEQUENCE_FALCHION_LOOKAT02 13
  590.  
  591. #define SEQUENCE_DAGGERS_IDLE1 1
  592. #define SEQUENCE_DAGGERS_LIGHT_MISS1 2
  593. #define SEQUENCE_DAGGERS_LIGHT_MISS5 6
  594. #define SEQUENCE_DAGGERS_HEAVY_MISS2 11
  595. #define SEQUENCE_DAGGERS_HEAVY_MISS1 12
  596.  
  597. #define SEQUENCE_BOWIE_IDLE1 1
  598.  
  599. #define LIFE_ALIVE 0
  600. #include <memory>
  601.  
  602.  
  603.  
  604. class RecvPropHook
  605. {
  606. private:
  607. RecvProp* target_property;
  608. RecvVarProxyFn original_proxy_fn;
  609. public:
  610. RecvPropHook(RecvProp* target_property)
  611. {
  612. this->target_property = target_property;
  613. this->original_proxy_fn = (RecvVarProxyFn)target_property->m_ProxyFn;
  614. }
  615.  
  616. ~RecvPropHook()
  617. {
  618. target_property->m_ProxyFn = this->original_proxy_fn;
  619. }
  620.  
  621. RecvVarProxyFn GetOriginalFunction()
  622. {
  623. return this->original_proxy_fn;
  624. }
  625.  
  626. void SetProxyFunction(RecvVarProxyFn user_proxy_fn)
  627. {
  628. target_property->m_ProxyFn = user_proxy_fn;
  629. }
  630. };
  631.  
  632. std::unique_ptr<RecvPropHook> sequenceHook;
  633.  
  634. RecvVarProxyFn oRecvProxySequence;
  635. void RecvProxy_Sequence(CRecvProxyData* pDataConst, void* pStruct, void* pOut)
  636. {
  637. static int lastSentSeq;
  638. CRecvProxyData* pData = const_cast<CRecvProxyData*>(pDataConst);
  639.  
  640. int iSequence = pData->m_Value.m_Int;
  641.  
  642. CBaseCombatWeapon* Weapon = static_cast<CBaseCombatWeapon*>(pStruct);
  643. CBaseEntity* pLocal = Interfaces.pEntList->GetClientEntity(Interfaces.pEngine->GetLocalPlayer());
  644.  
  645. if (Weapon && Weapon->GetModelIndex() && pLocal)
  646. {
  647. std::string rWeapon = Interfaces.g_pModelInfo->GetModelName(Weapon->GetModel());
  648.  
  649. if (rWeapon.find(("v_knife_push.mdl")) != std::string::npos)
  650. {
  651. switch (iSequence) {
  652. case SEQUENCE_DEFAULT_IDLE2:
  653. iSequence = SEQUENCE_DAGGERS_IDLE1; break;
  654. case SEQUENCE_DEFAULT_LIGHT_MISS1:
  655. case SEQUENCE_DEFAULT_LIGHT_MISS2:
  656. iSequence = RandomIntZ(SEQUENCE_DAGGERS_LIGHT_MISS1, SEQUENCE_DAGGERS_LIGHT_MISS5); break;
  657. case SEQUENCE_DEFAULT_HEAVY_MISS1:
  658. iSequence = RandomIntZ(SEQUENCE_DAGGERS_HEAVY_MISS2, SEQUENCE_DAGGERS_HEAVY_MISS1); break;
  659. case SEQUENCE_DEFAULT_HEAVY_HIT1:
  660. case SEQUENCE_DEFAULT_HEAVY_BACKSTAB:
  661. case SEQUENCE_DEFAULT_LOOKAT01:
  662. iSequence += 3; break;
  663. case SEQUENCE_DEFAULT_DRAW:
  664. case SEQUENCE_DEFAULT_IDLE1:
  665. break;
  666. default:
  667. iSequence += 2;
  668. }
  669. }
  670. else if (rWeapon.find(("v_knife_falchion_advanced.mdl")) != std::string::npos)
  671. {
  672. switch (iSequence) {
  673. case SEQUENCE_DEFAULT_IDLE2:
  674. iSequence = SEQUENCE_FALCHION_IDLE1; break;
  675. case SEQUENCE_DEFAULT_HEAVY_MISS1:
  676. iSequence = RandomIntZ(SEQUENCE_FALCHION_HEAVY_MISS1, SEQUENCE_FALCHION_HEAVY_MISS1_NOFLIP); break;
  677. case SEQUENCE_DEFAULT_LOOKAT01:
  678. iSequence = RandomIntZ(SEQUENCE_FALCHION_LOOKAT01, SEQUENCE_FALCHION_LOOKAT02); break;
  679. case SEQUENCE_DEFAULT_DRAW:
  680. case SEQUENCE_DEFAULT_IDLE1:
  681. break;
  682. default:
  683. iSequence--;
  684. }
  685. }
  686. else if (rWeapon.find(("v_knife_butterfly.mdl")) != std::string::npos)
  687. {
  688. switch (iSequence) {
  689. case SEQUENCE_DEFAULT_DRAW:
  690. iSequence = RandomIntZ(SEQUENCE_BUTTERFLY_DRAW, SEQUENCE_BUTTERFLY_DRAW2); break;
  691. case SEQUENCE_DEFAULT_LOOKAT01:
  692. iSequence = RandomIntZ(SEQUENCE_BUTTERFLY_LOOKAT01, SEQUENCE_BUTTERFLY_LOOKAT03); break;
  693. default:
  694. iSequence++;
  695. }
  696. }
  697. else if (rWeapon.find(("v_knife_survival_bowie.mdl")) != std::string::npos)
  698. {
  699. switch (iSequence) {
  700. case SEQUENCE_DEFAULT_DRAW:
  701. case SEQUENCE_DEFAULT_IDLE1:
  702. break;
  703. case SEQUENCE_DEFAULT_IDLE2:
  704. iSequence = SEQUENCE_BOWIE_IDLE1; break;
  705. default:
  706. iSequence--;
  707. }
  708. }
  709. pData->m_Value.m_Int = iSequence;
  710. }
  711.  
  712. if (!oRecvProxySequence)
  713. oRecvProxySequence = sequenceHook->GetOriginalFunction();
  714.  
  715. oRecvProxySequence(pData, pStruct, pOut);
  716. }
  717.  
  718.  
  719. void CSkinchanger::KnifeEventFire(IGameEvent* event)
  720. {
  721. // if (!g_Options.Skinchanger.EnabledChanger)
  722. // return;
  723.  
  724. if (Interfaces.pEngine->IsInGame() && Interfaces.pEngine->IsConnected() && G::LocalPlayer->isAlive())
  725. {
  726. if (G::LocalPlayer->GetActiveBaseCombatWeapon() && G::LocalPlayer->GetActiveBaseCombatWeapon()->IsKnife())
  727. {
  728. if (event && strcmp(event->GetName(), ("player_death")) == 0)
  729. {
  730.  
  731. if (event->GetInt(("attacker")) && Interfaces.pEngine->GetPlayerForUserID(event->GetInt(("attacker"))) == Interfaces.pEngine->GetLocalPlayer())
  732. {
  733. std::string weapon = event->GetString(("weapon"));
  734.  
  735. std::string wpn = weapon;
  736.  
  737. std::string weaponmy = G::LocalPlayer->GetTeam() == 2 ? ("knife_t") : ("knife_default_ct");
  738.  
  739. if (wpn == ("knife_default_ct") || wpn == ("knife_t") || wpn == ("bayonet") || wpn == ("knife_push") || wpn == ("knife_butterfly") || wpn == ("knife_survival_bowie") || wpn == ("knife_falchion") || wpn == ("knife_tactical") || wpn == ("knife_m9_bayonet") || wpn == ("knife_karambit") || wpn == ("knife_gut") || wpn == ("knife_flip"))
  740. {
  741.  
  742. switch (*G::LocalPlayer->GetActiveBaseCombatWeapon()->GetItemDefinitionIndex())
  743. {
  744. case WEAPON_KNIFE_BAYONET:
  745. weaponmy = ("bayonet");
  746. break;
  747. case WEAPON_KNIFE_FLIP:
  748. weaponmy = ("knife_flip");
  749. break;
  750. case WEAPON_KNIFE_GUT:
  751. weaponmy = ("knife_gut");
  752. break;
  753. case WEAPON_KNIFE_KARAMBIT:
  754. weaponmy = ("knife_karambit");
  755. break;
  756. case WEAPON_KNIFE_M9_BAYONET:
  757. weaponmy = ("knife_m9_bayonet");
  758. break;
  759. case WEAPON_KNIFE_TACTICAL:
  760. weaponmy = ("knife_tactical");
  761. break;
  762. case WEAPON_KNIFE_FALCHION:
  763. weaponmy = ("knife_falchion");
  764. break;
  765. case WEAPON_KNIFE_SURVIVAL_BOWIE:
  766. weaponmy = ("knife_survival_bowie");
  767. break;
  768. case WEAPON_KNIFE_BUTTERFLY:
  769. weaponmy = ("knife_butterfly");
  770. break;
  771. case WEAPON_KNIFE_PUSH:
  772. weaponmy = ("knife_push");
  773. break;
  774. }
  775.  
  776. if (weapon != weaponmy)
  777. event->SetString(("weapon"), weaponmy.c_str());
  778. }
  779. }
  780. }
  781. }
  782. }
  783. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!