API tools faq
paste
Advertisement
egor230

sdk plugin gta vice city

egor230
Feb 17th, 2019 (edited)
1,134
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 257.39 KB | None | 0 0
raw download clone embed print report
  1.  
  2. #include<fstream>
  3. #include <windows.h>
  4. #include <winuser.h>
  5. #include<thread> // std::thread
  6. #include<chrono> // std::thread
  7. #include <process.h>
  8.  
  9. #include <sstream>
  10. #include <cstdio>
  11. #include <cstdlib>
  12.  
  13. #include <filesystem>
  14. #include <string>
  15. #include <vector>
  16. #include <list>
  17. #include <queue>
  18. #include <map>
  19. #include <mutex>
  20.  
  21. #include <algorithm>
  22. #include<lua.hpp>
  23.  
  24. #include "common.h"
  25. #include "plugin.h"
  26. #include "CWorld.h"
  27. #include "extensions\KeyCheck.h"
  28. #include "extensions\ScriptCommands.h"
  29. #include "eScriptCommands.h"
  30. #include "CCivilianPed.h"
  31. #include "CMessages.h"
  32. #include "ePedModel.h"
  33. #include "ePedType.h"
  34. #include "CModelInfo.h"
  35.  
  36. #include "CStreaming.h"
  37. #include "CTheScripts.h"
  38. #include "eWeaponType.h"
  39. #include "eWeaponModel.h"
  40. #include "CPickups.h"
  41. #include "CClock.h"
  42. #include "CUserDisplay.h"
  43. #include "CAnimManager.cpp"
  44. #include "CBaseModelInfo.cpp"
  45. #include "CCamera.h"
  46. #include "CWeapon.h"
  47. #include "CPlayerPed.h"
  48. #include "CWeaponInfo.h"
  49. #include "CShotInfo.h"
  50. #include "CMenuManager.h"
  51.  
  52. using namespace plugin;
  53. using namespace std;
  54.  
  55. static unsigned int iters = 0;
  56. mutex mtx;
  57. list<char*>listfile;//Список Lua файлов.
  58.  
  59. list<lua_State*>luastate;// list для lua состояний.
  60. static map<int, lua_State*>markeron;// map для маркеров.
  61. static map<int, lua_State*>spheres;// map для маркеров кругов.
  62. static map<int, lua_State*>pickupsids;// map для пикапов.
  63. static map<int, lua_State*>firesids;// map для огня.
  64.  
  65. static map<CPed*, lua_State*>mappeds;// map для педов.
  66. static map<CVehicle*, lua_State*>mapcars;// map для авто.
  67. static map<CObject*, lua_State*>mapobjs;// map для объектов.
  68.  
  69. static map<int, CPed*>ptr_for_ped;//
  70. static string cheatstr;// символы введенные с клавиатуры.
  71. string getkey(int key);
  72.  
  73.  
  74. map<string, int> car_model_list = { {"MODEL_LANDSTAL", 130}, {"MODEL_IDAHO", 131}, {"MODEL_STINGER", 132}, {"MODEL_LINERUN", 133},
  75.     {"MODEL_PEREN", 134}, {"MODEL_SENTINEL", 135}, {"MODEL_RIO", 136}, {"MODEL_FIRETRUK", 137}, {"MODEL_TRASH", 138},
  76.     {"MODEL_STRETCH", 139}, {"MODEL_MANANA", 140}, {"MODEL_INFERNUS", 141}, {"MODEL_VOODOO", 142}, {"MODEL_PONY", 143},
  77.     {"MODEL_MULE", 144}, {"MODEL_CHEETAH", 145}, {"MODEL_AMBULAN", 146}, {"MODEL_FBICAR", 147}, {"MODEL_MOONBEAM", 148},
  78.     {"MODEL_ESPERANT", 149}, {"MODEL_TAXI", 150}, {"MODEL_WASHING", 151}, {"MODEL_BOBCAT", 152}, {"MODEL_MRWHOOP", 153},
  79.     {"MODEL_BFINJECT", 154}, {"MODEL_HUNTER", 155}, {"MODEL_POLICE", 156}, {"MODEL_ENFORCER", 157}, {"MODEL_SECURICA", 158},
  80.     {"MODEL_BANSHEE", 159}, {"MODEL_PREDATOR", 160}, {"MODEL_BUS", 161}, {"MODEL_RHINO", 162}, {"MODEL_BARRACKS", 163},
  81.     {"MODEL_CUBAN", 164}, {"MODEL_CHOPPER", 165}, {"MODEL_ANGEL", 166}, {"MODEL_COACH", 167}, {"MODEL_CABBIE", 168},
  82.     {"MODEL_STALLION", 169}, {"MODEL_RUMPO", 170}, {"MODEL_RCBANDIT", 171}, {"MODEL_ROMERO", 172}, {"MODEL_PACKER", 173},
  83.     {"MODEL_SENTXS", 174}, {"MODEL_ADMIRAL", 175}, {"MODEL_SQUALO", 176}, {"MODEL_SEASPAR", 177}, {"MODEL_PIZZABOY", 178},
  84.     {"MODEL_GANGBUR", 179}, {"MODEL_AIRTRAIN", 180}, {"MODEL_DEADDODO", 181}, {"MODEL_SPEEDER", 182}, {"MODEL_REEFER", 183},
  85.     {"MODEL_TROPIC", 184}, {"MODEL_FLATBED", 185}, {"MODEL_YANKEE", 186}, {"MODEL_CADDY", 187}, {"MODEL_ZEBRA", 188},
  86.     {"MODEL_TOPFUN", 189}, {"MODEL_SKIMMER", 190}, {"MODEL_PCJ600", 191}, {"MODEL_FAGGIO", 192}, {"MODEL_FREEWAY", 193},
  87.     {"MODEL_RCBARON", 194}, {"MODEL_RCRAIDER", 195}, {"MODEL_GLENDALE", 196}, {"MODEL_OCEANIC", 197}, {"MODEL_SANCHEZ", 198},
  88.     {"MODEL_SPARROW", 199}, {"MODEL_PATRIOT", 200}, {"MODEL_LOVEFIST", 201}, {"MODEL_COASTG", 202}, {"MODEL_DINGHY", 203},
  89.     {"MODEL_HERMES", 204}, {"MODEL_SABRE", 205}, {"MODEL_SABRETUR", 206}, {"MODEL_PHEONIX", 207}, {"MODEL_WALTON", 208},
  90.     {"MODEL_REGINA", 209}, {"MODEL_COMET", 210}, {"MODEL_DELUXO", 211}, {"MODEL_BURRITO", 212}, {"MODEL_SPAND", 213},
  91.     {"MODEL_MARQUIS", 214}, {"MODEL_BAGGAGE", 215}, {"MODEL_KAUFMAN", 216}, {"MODEL_MAVERICK", 217}, {"MODEL_VCNMAV", 218},
  92.     {"MODEL_RANCHER", 219}, {"MODEL_FBIRANCH", 220}, {"MODEL_VIRGO", 221}, {"MODEL_GREENWOO", 222}, {"MODEL_JETMAX", 223},
  93.     {"MODEL_HOTRING", 224}, {"MODEL_SANDKING", 225}, {"MODEL_BLISTAC", 226}, {"MODEL_POLMAV", 227}, {"MODEL_BOXVILLE", 228},
  94.     {"MODEL_BENSON", 229}, {"MODEL_MESA", 230}, {"MODEL_RCGOBLIN", 231}, {"MODEL_HOTRINA", 232}, {"MODEL_HOTRINB", 233},
  95.     {"MODEL_BLOODRA", 234}, {"MODEL_BLOODRB", 235}, {"MODEL_VICECHEE", 236} };
  96.  
  97. map<string, int> name_weapon_list = { {"unarmed", 0}, {"brassknuckle", 259}, {"screwdriver", 260}, {"golfclub", 261},
  98. {"nitestick", 262}, {"knifecur", 263}, {"bat", 264}, {"hammer", 265}, {"cleaver", 266}, {"machete", 267}, {"katana", 268},
  99. {"chnsaw", 269}, {"grenade", 270}, {"teargas", 271}, {"molotov", 272}, {"missile", 273}, {"colt45", 274}, {"python", 275},
  100. {"ruger", 276}, {"chromegun", 277}, {"shotgspa", 278}, {"buddyshot", 279}, {"m4", 280}, {"tec9", 281}, {"uzi", 282},
  101. {"ingramsl", 283}, {"mp5lng", 284}, {"sniper", 285}, {"laser", 286}, {"rocketla", 287}, {"flame", 288}, {"M60", 289},
  102. {"minigun", 290}, {"bomb", 291}, {"camera", 292}, {"fingers", 293}, {"minigun2", 294} };
  103. map<string, int> types_weapon_list = { {"unarmed", 0}, {"brassknuckle", 1}, {"screwdriver", 2}, {"golfclub", 3}, {"nitestick", 4},
  104. {"knifecur", 5}, {"bat", 6}, {"hammer", 7}, {"cleaver", 8}, {"machete", 9}, {"katana", 10}, {"chnsaw", 11}, {"grenade", 12},
  105. {"bomb", 13}, {"teargas", 14}, {"molotov", 15}, {"missile", 16}, {"colt45", 17}, {"python", 18}, {"chromegun", 19}, {"shotgspa", 20},
  106. {"buddyshot", 21}, {"tec9", 22}, {"uzi", 23}, {"ingramsl", 24}, {"mp5lng", 25}, {"m4", 26}, {"ruger", 27}, {"laser", 29},
  107. {"rocketla", 30}, {"flame", 31}, {"M60", 32}, {"sniper", 32}, {"M60", 32}, {"sniper", 32}, {"minigun", 33}, {"fingers", 34},
  108. {"minigun2", 35}, {"camera", 36} };
  109.  
  110. map<string, int> name_peds_list = { {"ARMY", 4}, {"BFOBE", 40}, {"BFORI", 36}, {"BFOST", 32}, {"BFOTR", 44}, {"BFYBE", 38},
  111. {"BFYPR", 43}, {"BFYRI", 35}, {"BFYST", 31}, {"BKA", 93}, {"BKB", 94}, {"BMOBE", 41}, {"BMODK", 29}, {"BMOST", 34}, {"BMOTR", 45},
  112. {"BMYBB", 47}, {"BMYBE", 39}, {"BMYBU", 42}, {"BMYCR", 30}, {"BMYPI", 46}, {"BMYRI", 37}, {"BMYST", 33}, {"CBA", 83}, {"CBB", 84},
  113. {"CLA", 89}, {"CLB", 90}, {"COP", 1}, {"FBI", 3}, {"FIREMAN", 6}, {"GDA", 91}, {"GDB", 92}, {"HFOBE", 18}, {"HFORI", 14},
  114. {"HFOST", 10}, {"HFOTR", 25}, {"HFYBE", 17}, {"HFYBU", 21}, {"HFYCG", 23}, {"HFYMD", 22}, {"HFYPR", 24}, {"HFYRI", 13}, {"HFYST", 9},
  115. {"HMOBE", 20}, {"HMOCA", 28}, {"HMORI", 16}, {"HMOST", 12}, {"HMOTR", 26}, {"HMYAP", 27}, {"HMYBE", 19}, {"HMYRI", 15}, {"HMYST", 11},
  116. {"HNA", 85}, {"HNB", 86}, {"JFOTO", 81}, {"JMOTO", 82}, {"MEDIC", 5}, {"PGA", 95}, {"PGB", 96}, {"SGA", 87}, {"SGB", 88}, {"SWAT", 2},
  117. {"VICE1", 97}, {"VICE2", 98}, {"VICE3", 99}, {"VICE4", 100}, {"VICE5", 101}, {"VICE6", 102}, {"VICE7", 103}, {"VICE8", 104},
  118. {"WFOBE", 59}, {"WFOGO", 63}, {"WFORI", 54}, {"WFOSH", 80}, {"WFOST", 50}, {"WFOTR", 71}, {"WFYBE", 57}, {"WFYBU", 67}, {"WFYG1", 105},
  119. {"WFYG2", 106}, {"WFYJG", 75}, {"WFYLG", 65}, {"WFYPR", 70}, {"WFYRI", 53}, {"WFYSH", 79}, {"WFYSK", 77}, {"WFYST", 49}, {"WMOBE", 60},
  120. {"WMOBU", 69}, {"WMOCA", 74}, {"WMOGO", 64}, {"WMORI", 56}, {"WMOST", 52}, {"WMOTR", 72}, {"WMYBE", 58}, {"WMYBU", 68}, {"WMYCR", 48},
  121. {"WMYCW", 61}, {"WMYGO", 62}, {"WMYJG", 76}, {"WMYLG", 66}, {"WMYPI", 73}, {"WMYRI", 55}, {"WMYSK", 78}, {"WMYST", 51} };
  122.  
  123. map<string, int> type_peds_list = { {"ARMY", 6}, {"BFOBE", 5}, {"BFORI", 5}, {"BFOST", 5}, {"BFOTR", 5}, {"BFYBE", 5}, {"BFYPR", 5},
  124. {"BFYRI", 5}, {"BFYST", 5}, {"BKA", 12}, {"BKB", 12}, {"BMOBE", 4}, {"BMODK", 4}, {"BMOST", 4}, {"BMOTR", 4}, {"BMYBB", 4},
  125. {"BMYBE", 4}, {"BMYBU", 4}, {"BMYCR", 4}, {"BMYPI", 4}, {"BMYRI", 4}, {"BMYST", 4}, {"CBA", 7}, {"CBB", 7}, {"CLA", 10}, {"CLB", 10},
  126. {"COP", 6}, {"FBI", 6}, {"FIREMAN", 17}, {"GDA", 11}, {"GDB", 11}, {"HFOBE", 5}, {"HFORI", 5}, {"HFOST", 5}, {"HFOTR", 5}, {"HFYBE", 5},
  127. {"HFYBU", 5}, {"HFYCG", 5}, {"HFYMD", 5}, {"HFYPR", 5}, {"HFYRI", 5}, {"HFYST", 5}, {"HMOBE", 4}, {"HMOCA", 4}, {"HMORI", 4},
  128. {"HMOST", 4}, {"HMOTR", 4}, {"HMYAP", 4}, {"HMYBE", 4}, {"HMYRI", 4}, {"HMYST", 4}, {"HNA", 8}, {"HNB", 8}, {"JFOTO", 5}, {"JMOTO", 4},
  129. {"MEDIC", 16}, {"PGA", 13}, {"PGB", 13}, {"SGA", 9}, {"SGB", 9}, {"SWAT", 6}, {"VICE1", 18}, {"VICE2", 18}, {"VICE3", 18},
  130. {"VICE4", 18}, {"VICE5", 18}, {"VICE6", 18}, {"VICE7", 18}, {"VICE8", 18}, {"WFOBE", 5}, {"WFOGO", 5}, {"WFORI", 5}, {"WFOSH", 5},
  131. {"WFOST", 5}, {"WFOTR", 5}, {"WFYBE", 5}, {"WFYBU", 5}, {"WFYG1", 5}, {"WFYG2", 6}, {"WFYJG", 5}, {"WFYLG", 5}, {"WFYPR", 5},
  132. {"WFYRI", 5}, {"WFYSH", 5}, {"WFYSK", 5}, {"WFYST", 5}, {"WMOBE", 4}, {"WMOBU", 4}, {"WMOCA", 4}, {"WMOGO", 4}, {"WMORI", 4},
  133. {"WMOST", 4}, {"WMOTR", 4}, {"WMYBE", 4}, {"WMYBU", 4}, {"WMYCR", 4}, {"WMYCW", 4}, {"WMYGO", 4}, {"WMYJG", 4}, {"WMYLG", 4},
  134. {"WMYPI", 4}, {"WMYRI", 4}, {"WMYSK", 4}, {"WMYST", 4} };
  135.  
  136. map<string, int> type_specpeds_list = { {"BGA", 4}, {"BGB", 4}, {"BOUNCA", 4}, {"BURGER", 4}, {"CGONA", 4}, {"CGONB", 4}, {"CGONC", 4},
  137. {"CHEF", 4}, {"CMRAMAN", 4}, {"COURIER", 4}, {"CREWA", 4}, {"CREWB", 4}, {"CSJUGGZ", 5}, {"DGOONA", 4}, {"DGOONB", 4}, {"DGOONC", 4},
  138. {"FLOOZYA", 5}, {"FLOOZYB", 5}, {"FLOOZYC", 5}, {"FSFA", 4}, {"IGALSCB", 4}, {"IGBUDDY", 4}, {"IGBUDY2", 4}, {"IGBUDY3", 4},
  139. {"IGCANDY", 5}, {"IGCOLON", 4}, {"IGDIAZ", 4}, {"IGDICK", 4}, {"IGGONZ", 4}, {"IGHLARY", 4}, {"IGHLRY2", 4}, {"IGJEZZ", 4},
  140. {"IGKEN", 4}, {"IGMERC", 5}, {"IGMERC2", 5}, {"IGMIKE", 4}, {"IGMIKE2", 4}, {"IGPERCY", 4}, {"IGPHIL", 4}, {"IGPHIL2", 4},
  141. {"IGPHIL3", 4}, {"IGSONNY", 4}, {"MBA", 4}, {"MBB", 4}, {"MGOONA", 4}, {"MPORNA", 4}, {"MSERVER", 4}, {"PLAY10", 4}, {"PLAY11", 4},
  142. {"PLAY12", 4}, {"PLAYER2", 4}, {"PLAYER3", 4}, {"PLAYER4", 4}, {"PLAYER5", 4}, {"PLAYER6", 4}, {"PLAYER7", 4}, {"PLAYER8", 4},
  143. {"PLAYER9", 4}, {"PRINTRA", 4}, {"PRINTRB", 4}, {"PRINTRC", 4}, {"PSYCHO", 4}, {"SAM", 4}, {"SGC", 4}, {"SGOONA", 4}, {"SGOONB", 4},
  144. {"SHOOTRA", 5}, {"SHOOTRB", 4}, {"SPANDXA", 5}, {"SPANDXB", 5}, {"STRIPA", 5}, {"S_KEEP", 4} };
  145.  
  146. map<int, int> type_and_model = { {0, 0}, {1, 259}, {2, 260}, {3, 261}, {4, 262}, {5, 263}, {6, 264}, {7, 265},
  147. {8, 266}, {9, 267}, {10, 268}, {11, 269}, {12, 270}, {13, 291}, {14, 271}, {15, 272}, {16, 273}, {17, 274},
  148. {18, 275}, {19, 277}, {20, 278}, {21, 279}, {22, 281}, {23, 282}, {24, 283}, {25, 284}, {26, 280}, {27, 276},
  149. {29, 286}, {30, 287}, {31, 288}, {32, 289}, {32, 285}, {32, 289}, {32, 285}, {33, 290}, {34, 293}, {35, 294},
  150. {36, 292} };
  151.  
  152. map<int, int> model_and_type = { {0, 0}, {259, 1}, {260, 2}, {261, 3}, {262, 4}, {263, 5}, {264, 6}, {265, 7},
  153. {266, 8}, {267, 9}, {268, 10}, {269, 11}, {270, 12}, {271, 14}, {272, 15}, {273, 16}, {274, 17}, {275, 18}, {276, 27},
  154. {277, 19}, {278, 20}, {279, 21}, {280, 26}, {281, 22}, {282, 23}, {283, 24}, {284, 25}, {285, 32}, {286, 29}, {287, 30},
  155. {288, 31}, {289, 32}, {290, 33}, {291, 13}, {292, 36}, {293, 34}, {294, 35} };
  156.  
  157. map<string, int> numbers_keys = { {"VK_A", 65}, {"VK_ABNT_C1", 193}, {"VK_ABNT_C2", 194}, {"VK_ACCEPT", 30},
  158. {"VK_ADD", 107}, {"VK_APPS", 93}, {"VK_ATTN", 246}, {"VK_B", 66}, {"VK_BACK", 8}, {"VK_BROWSER_BACK", 166},
  159. {"VK_BROWSER_FAVORITES", 171}, {"VK_BROWSER_FORWARD", 167}, {"VK_BROWSER_HOME", 172}, {"VK_BROWSER_REFRESH", 168},
  160. {"VK_BROWSER_SEARCH", 170}, {"VK_BROWSER_STOP", 169}, {"VK_C", 67}, {"VK_CANCEL", 3}, {"VK_CAPITAL", 20}, {"VK_CLEAR", 12},
  161. {"VK_CONTROL", 17}, {"VK_CONVERT", 28}, {"VK_CRSEL", 247}, {"VK_D", 68}, {"VK_DECIMAL", 110}, {"VK_DELETE", 46},
  162. {"VK_DIVIDE", 111}, {"VK_DOWN", 40}, {"VK_E", 69}, {"VK_END", 35}, {"VK_EREOF", 249}, {"VK_ESCAPE", 27}, {"VK_EXECUTE", 43},
  163. {"VK_EXSEL", 248}, {"VK_F", 70}, {"VK_F1", 112}, {"VK_F10", 121}, {"VK_F11", 122}, {"VK_F12", 123}, {"VK_F13", 124},
  164. {"VK_F14", 125}, {"VK_F15", 126}, {"VK_F16", 127}, {"VK_F17", 128}, {"VK_F18", 129}, {"VK_F19", 130}, {"VK_F2", 113},
  165. {"VK_F20", 131}, {"VK_F21", 132}, {"VK_F22", 133}, {"VK_F23", 134}, {"VK_F24", 135}, {"VK_F3", 114}, {"VK_F4", 115},
  166. {"VK_F5", 116}, {"VK_F6", 117}, {"VK_F7", 118}, {"VK_F8", 119}, {"VK_F9", 120}, {"VK_FINAL", 24}, {"VK_G", 71},
  167. {"VK_H", 72}, {"VK_HELP", 47}, {"VK_HOME", 36}, {"VK_I", 73}, {"VK_ICO_CLEAR", 230}, {"VK_ICO_HELP", 227},
  168. {"VK_INSERT", 45}, {"VK_J", 74}, {"VK_JUNJA", 23}, {"VK_K", 75}, {"VK_KANA", 21}, {"VK_KANJI", 25}, {"VK_L", 76},
  169. {"VK_LAUNCH_APP1", 182}, {"VK_LAUNCH_APP2", 183}, {"VK_LAUNCH_MAIL", 180}, {"VK_LAUNCH_MEDIA_SELECT", 181},
  170. {"VK_LBUTTON", 1}, {"VK_LCONTROL", 162}, {"VK_LEFT", 37}, {"VK_LMENU", 164}, {"VK_LSHIFT", 160}, {"VK_LWIN", 91},
  171. {"VK_M", 77}, {"VK_MBUTTON", 4}, {"VK_MEDIA_NEXT_TRACK", 176}, {"VK_MEDIA_PLAY_PAUSE", 179}, {"VK_MEDIA_PREV_TRACK", 177},
  172. {"VK_MEDIA_STOP", 178}, {"VK_MENU", 18}, {"VK_MODECHANGE", 31}, {"VK_MULTIPLY", 106}, {"VK_N", 78}, {"VK_NEXT", 34},
  173. {"VK_NONCONVERT", 29}, {"VK_NUMLOCK", 144}, {"VK_NUMPAD0", 96}, {"VK_NUMPAD1", 97}, {"VK_NUMPAD2", 98}, {"VK_NUMPAD3", 99},
  174. {"VK_NUMPAD4", 100}, {"VK_NUMPAD5", 101}, {"VK_NUMPAD6", 102}, {"VK_NUMPAD7", 103}, {"VK_NUMPAD8", 104}, {"VK_NUMPAD9", 105},
  175. {"VK_O", 79}, {"VK_OEM_1", 186}, {"VK_OEM_102", 226}, {"VK_OEM_2", 191}, {"VK_OEM_3", 192}, {"VK_OEM_4", 219},
  176. {"VK_OEM_5", 220}, {"VK_OEM_6", 221}, {"VK_OEM_7", 222}, {"VK_OEM_8", 223}, {"VK_OEM_ATTN", 240}, {"VK_OEM_AUTO", 243},
  177. {"VK_OEM_AX", 225}, {"VK_OEM_BACKTAB", 245}, {"VK_OEM_CLEAR", 254}, {"VK_OEM_COMMA", 188}, {"VK_OEM_COPY", 242},
  178. {"VK_OEM_CUSEL", 239}, {"VK_OEM_ENLW", 244}, {"VK_OEM_FINISH", 241}, {"VK_OEM_FJ_JISHO", 146}, {"VK_OEM_FJ_LOYA", 149},
  179. {"VK_OEM_FJ_MASSHOU", 147}, {"VK_OEM_FJ_ROYA", 150}, {"VK_OEM_FJ_TOUROKU", 148}, {"VK_OEM_JUMP", 234}, {"VK_OEM_MINUS", 189},
  180. {"VK_OEM_PA1", 235}, {"VK_OEM_PA2", 236}, {"VK_OEM_PA3", 237}, {"VK_OEM_PERIOD", 190}, {"VK_OEM_PLUS", 187},
  181. {"VK_OEM_RESET", 233}, {"VK_OEM_WSCTRL", 238}, {"VK_P", 80}, {"VK_PA1", 253}, {"VK_PACKET", 231}, {"VK_PAUSE", 19},
  182. {"VK_PLAY", 250}, {"VK_PRINT", 42}, {"VK_PRIOR", 33}, {"VK_PROCESSKEY", 229}, {"VK_Q", 81}, {"VK_R", 82},
  183. {"VK_RBUTTON", 2}, {"VK_RCONTROL", 163}, {"VK_RETURN", 13}, {"VK_RIGHT", 39}, {"VK_RMENU", 165}, {"VK_RSHIFT", 161},
  184. {"VK_RWIN", 92}, {"VK_S", 83}, {"VK_SCROLL", 145}, {"VK_SELECT", 41}, {"VK_SEPARATOR", 108}, {"VK_SHIFT", 16},
  185. {"VK_SLEEP", 95}, {"VK_SNAPSHOT", 44}, {"VK_SPACE", 32}, {"VK_SUBTRACT", 109}, {"VK_T", 84}, {"VK_TAB", 9},
  186. {"VK_U", 85}, {"VK_UP", 38}, {"VK_V", 86}, {"VK_VOLUME_DOWN", 174}, {"VK_VOLUME_MUTE", 173}, {"VK_VOLUME_UP", 175},
  187. {"VK_W", 87}, {"VK_X", 88}, {"VK_XBUTTON1", 5}, {"VK_XBUTTON2", 6}, {"VK_Y", 89}, {"VK_Z", 90}, {"VK_ZOOM", 251},
  188. {"VK_key0", 48}, {"VK_key1", 49}, {"VK_key2", 50}, {"VK_key3", 51}, {"VK_key4", 52}, {"VK_key5", 53}, {"VK_key6", 54},
  189. {"VK_key7", 55}, {"VK_key8", 56}, {"VK_key9", 57} };
  190.  
  191. int find_in_map(std::map<string, int>& carlist, const char* search);// найти id авто.
  192. int find_model_in_map(std::map<int, int>& type_and_model, int search);// найти модель авто.
  193.  
  194. int& var_$3402 = *(int*)0x8247A8; // глобальнная переменная таймера.
  195.  
  196. CPed* findpedinpool(const void* p); // найти педа в пуле.
  197. CVehicle* findcarinpool(const void* p); // найти авто в пуле.
  198. CObject* findobjinpool(const void* p);// найти объект в пуле.
  199.  
  200. void getkeyenvent(); // считывания символов клавиатуры.
  201. wchar_t* getwchat(const char* c); // перевод в строку.
  202.  
  203. int funs(lua_State* L);// список функций.
  204. void writelog(const char x[]);// запись ошибок в файл.
  205. void dellod(); // удалить лог ошибок.
  206. int cleanstl();// очистка stl.
  207.  
  208. int wait(lua_State* L);// задержка
  209. int findplayer(lua_State* L);// найти педа.
  210. int getpedhealth(lua_State* L);// получить здоровье педа.
  211. int setpedhealth(lua_State* L);// установить здоровье педа.
  212.  
  213. int getpedarmour(lua_State* L); // получить броню педа.
  214. int setarmour(lua_State* L);// установить броню педа.
  215. int getcarhealth(lua_State* L); // получить кол-во здоровья авто.
  216. int setcarhealth(lua_State* L); // установить здоровье авто.
  217.  
  218. int loadmodel(lua_State* L);// загрузить модель.
  219. int createcar(lua_State* L);// создать авто на координатах на координатах.
  220. int availablemodel(lua_State* L);// проверка на загруженность модели.
  221. int releasemodel(lua_State* L);// удалить модель из памяти.
  222.  
  223. int keypress(lua_State* L);// проверка на нажатия клавиши.
  224. int lockstatus(lua_State* L);// статус двери авто.
  225. int givemoney(lua_State* L);// дать денег.
  226. int getpedcoordes(lua_State* L);// получить координаты.
  227.  
  228. int printmessage(lua_State* L);// вывести сообщение на экран.
  229. int randomfindped(lua_State* L);// найти случайнного педа.
  230. int incar(lua_State* L);// пед в авто?
  231. int exitcar(lua_State* L);// выйти из авто.
  232.  
  233. int createped(lua_State* L);// создать педа.
  234. int create_marker_actor(lua_State* L);// создать маркер над педа.
  235. int removemarker(lua_State* L);// удалить маркер.
  236. int ped_sprint_to_point(lua_State* L);//пед делает спринт к точке.
  237.  
  238. int ped_walk_to_point(lua_State* L);// пед идет к точке.
  239. int getpedangle(lua_State* L);// получить угол педа.
  240. int load_requested_models(lua_State* L);// загрузить модель вне очереди.
  241. int giveweaponped(lua_State* L);// дать педу оружие.
  242.  
  243. int ped_aim_at_ped(lua_State* L);// пед целиться в педе.
  244. int is_current_weapon_ped(lua_State* L);// проверить текущее оружие.
  245. int worldcoord(lua_State* L); // Перевод в мировые координаты.
  246. int getpedcoordinates_on_x(lua_State* L); // Получить мировую координату по x для педа.
  247.  
  248. int getpedcoordinates_on_y(lua_State* L); // Получить мировую координату по y для педа.
  249. int kill_ped_on_foot(lua_State* L);// убить педа пешком.
  250. int kill_char_any_means(lua_State* L);// убить педа любыми средствами.
  251.  
  252. int create_sphere(lua_State* L); //создать сферу.
  253. int remove_sphere(lua_State* L); // удалить сферу.
  254. int remove_ped(lua_State* L); // удалить педа.
  255. int remove_car(lua_State* L); // удалить авто.
  256.  
  257. int car_in_water(lua_State* L); // проверка авто в воде?.
  258. int set_wanted(lua_State* L); // уcтановить уровень розыска.
  259. int clear_wanted(lua_State* L);// убрать уровень розыска.
  260. int kill_ped(lua_State* L); // убить педа.
  261.  
  262. int setpedcoordes(lua_State* L); // установить координаты для педа.
  263. int ped_in_point_in_radius(lua_State* L); // проверить находится пед в координатах с радиусом.
  264. int cardrive(lua_State* L); // авто едет в точку.
  265.  
  266. int setcarspeed(lua_State* L); // установить скорость авто.
  267. int getflagmission(lua_State* L); // проверка флага миссии.
  268. int setflagmission(lua_State* L); // уcтановить флага миссии.
  269. int showtext(lua_State* L);// Вывод особого текста на экран.
  270.  
  271. int remove_blip(lua_State* L);// удалить метку с карты.
  272. int createblip(lua_State* L); // создать метку на карте.
  273. int play_sound(lua_State* L);// проиграть мелодию.
  274. int isped(lua_State* L); // проверка это пед?.
  275.  
  276. int isvehicle(lua_State* L); // проверка это транспорт?.
  277. int opendoorcar(lua_State* L); // открыть дверь авто.
  278. int randomfindcar(lua_State* L); //Найти случайное авто.
  279. int create_money_pickup(lua_State* L); //создать пачку денег.
  280.  
  281. int getcarcoordes(lua_State* L); // получить координаты авто.
  282. int getcarcoordinates_on_x(lua_State* L);// Получить мировую координату по x для авто.
  283. int getcarcoordinates_on_y(lua_State* L); // Получить мировую координату по y для авто.
  284. int car_in_point_in_radius(lua_State* L); // проверить находится авто в координатах с радиусом.
  285.  
  286. int setdrivingstyle(lua_State* L); // установить стиль езды авто.
  287. int findped(lua_State* L); // найти педа в пуле.
  288. int create_weapon_pickup(lua_State* L); //создать пикап оружие.
  289. int create_pickup(lua_State* L); //создать пикап.
  290.  
  291. int picked_up(lua_State* L); // проверка пикап подобран.
  292. int remove_pickup(lua_State* L); // удалить пикап.
  293. int play_voice(lua_State* L); // Проиграть голос(реплику).
  294. int fade(lua_State* L);//затенение, просветления.
  295.  
  296. int draw_corona(lua_State* L); // создать корону(гоночный чекпойнт).
  297. int sound_coordinate(lua_State* L); // Проиграть звук в координатах
  298. int show_text_styled(lua_State* L); // вывести игровой текст.
  299. int setcarangle(lua_State* L); // установить угол авто.
  300.  
  301. int createmarker(lua_State* L); // создать маркер на карте.
  302. int setsizemarker(lua_State* L); // установить размер отображение маркера на карте.
  303. int checkcheat(lua_State* L); // чит код введен?.
  304. int destroy(lua_State* L); // удаления объектов из памяти при перезагрузки скрипта.
  305.  
  306. int my_yield(lua_State* L); // приостановить выполнение скрипта.
  307. int setcardrive(lua_State* L); //  установить водителя для авто.
  308. int setcarpassenger(lua_State* L); // установить пассажира для авто.
  309. int setcarfirstcolor(lua_State* L); // установить первый цвет авто.
  310.  
  311. int setcarseconscolor(lua_State* L);// установить второй цвет авто.
  312. int set_traffic(lua_State* L); // установить плотность трафика транспорта.
  313. int create_marker_car(lua_State* L); //создать маркер над авто.
  314. int car_explode(lua_State* L); // взорвать авто.
  315.  
  316. int is_car_stopped(lua_State* L); // авто остановилось.
  317. int create_explosion(lua_State* L); // Создать взрыв на координатах.
  318. int set_status_engine(lua_State* L); // установить состояние двигателя авто.
  319. int player_defined(lua_State* L); // пед существует?
  320.  
  321. int setclock(lua_State* L); // задать время.
  322. int arrested(lua_State* L); // пед арестован?
  323. int create_marker_pickup(lua_State* L);// создать маркер над пикапом.
  324. int createobj(lua_State* L); // создать объект.
  325.  
  326. int remove_obj(lua_State* L); // удалить объект.
  327. int getobjcoordes(lua_State* L); // получить координаты объекта.
  328. int create_marker_obj(lua_State* L); //создать маркер над объектом.
  329.  
  330. int isobject(lua_State* L); // проверка это объект?.
  331. int setpedangle(lua_State* L); // установить угол педа.
  332. int setcaraction(lua_State* L);// установить поведение авто.
  333. int move_obj(lua_State* L); //двигать объект.
  334.  
  335. int move_rotate(lua_State* L); // вращать объект.
  336. int getobjangle(lua_State* L); // получить угол объекта.
  337. int findcar(lua_State* L); // Найти авто.
  338. int setcartask(lua_State* L);// установить задачу авто.
  339.  
  340. int setcarcoordes(lua_State* L);// установить координаты авто.
  341. int is_car_stuck(lua_State* L);//03CE: car 12@ stuck если машина застряла.
  342. int is_car_upsidedown(lua_State* L); //01F4: car 12@ flipped если машина перевернута.
  343. int is_car_upright(lua_State* L); // 020D: car 12@ flipped если указанный автомобиль перевернут.
  344.  
  345. int find_road_for_car(lua_State* L); // найти дорогу.
  346. int setcarstrong(lua_State* L); // сделать авто устойчивым.
  347. int putincar(lua_State* L);// переместить педа в авто.
  348. int game_font_print(lua_State* L); // вывести особенный игровой текст.
  349.  
  350. int star_timer(lua_State* L); // включить таймер.
  351. int stop_timer(lua_State* L); // остановить таймер.
  352.  
  353. int timer_donw(lua_State* L); //  таймер на уменьшение.
  354. int ped_attack_car(lua_State* L); // пед атакует авто.
  355. int ped_frozen(lua_State* L); // заморозить игpока.
  356. int hold_cellphone(lua_State* L); // поднять телефон.
  357.  
  358. int car_lastweapondamage(lua_State* L); // номер оружие, которое нанесло урон авто.
  359. int car_currentgear(lua_State* L); // текущая передача авто.
  360. int getcar_model(lua_State* L); // получить модель авто.
  361. int setcarsiren(lua_State* L); // установить сирену для авто.
  362.  
  363. int ped_car_as_driver(lua_State* L); // пед садится в авто как водитель.
  364. int ped_car_as_passenger(lua_State* L); // пед садится в авто как пассажир.
  365. int show_text_gtx(lua_State* L); // вывести игровой текст.
  366. int camera_at_point(lua_State* L); //переместить камеру в координатах.
  367.  
  368. int set_camera_position(lua_State* L); //установить камеру в координатах.
  369. int restore_camera(lua_State* L); // восстановить камеру.
  370. int is_wanted_level(lua_State* L); // проверить уровень розыска.
  371. int ped_atack(lua_State* L); // пед бьет.
  372.  
  373. int flash_hud(lua_State* L); // Мигание элементов HUD.
  374. int set_radio(lua_State* L); // установить радио.
  375. int set_car_tires(lua_State* L); // проколоть шину авто.
  376.  
  377. int create_spec_ped(lua_State* L); // создать спец педа.
  378. int set_wheel_status(lua_State* L); // установить состояния шин авто.
  379. int set_skin(lua_State* L); // установить скин педа.
  380. int remove_spec_ped(lua_State* L);  // удалить спец педа.
  381.  
  382. int go_to_route(lua_State* L); //установить маршрут авто.
  383. int add_stuck_car_check(lua_State* L); // условия для того, чтобы авто считалась застрявшей.
  384. int load_scene(lua_State* L); // загрузить модели на координатах заранее.
  385. int ped_anim(lua_State* L); // анимация.
  386.  
  387. int del_anim(lua_State* L); // удалить анимацию.
  388. int get_current_name_luascript(lua_State* L); // получить имя текущего lua файла.
  389. int star_mission_marker(lua_State* L); // создать маркер для миссии.
  390. int getobjcoordinates_on_x(lua_State* L); // Получить мировую координату по x для объекта.
  391.  
  392. int getobjcoordinates_on_y(lua_State* L); // Получить мировую координату по y для объекта.
  393. int set_widescreen(lua_State* L); // вкл/выкл широкий экран.
  394. int follow_the_leader(lua_State* L); //01DE / 01DF  следовать за лидером.
  395. int getcarspeed(lua_State* L); // получить скорость авто.
  396.  
  397. int Getcameracoordes(lua_State* L);// получить координаты камеры.
  398. int remove_all_weapons_ped(lua_State* L); // удалить все оружия педа.
  399. int Getweaponslot(lua_State* L); // получить номер слота по типу оружия.
  400. int get_damage_weapon_ped(lua_State* L); // получить последний урон педа от оружия.
  401.  
  402. int get_aimgun_ped(lua_State* L); // получить показатель цели педа.
  403. int get_ammo_weapon_ped(lua_State* L);// получить кол-во патроны текущего оружие педа.
  404. int createfireonped(lua_State* L);// создать огонь на педе.
  405. int createfireoncar(lua_State* L);// создать огонь на авто.
  406.  
  407. int createfireoncords(lua_State* L); // создать огонь на координатах.
  408. int remove_fire(lua_State* L); // удалить огонь.
  409. int ped_shutdown(lua_State* L);
  410. int is_ped_damage_from_ped(lua_State* L); // получил ли пед урон от педа.
  411.  
  412. int is_targetting_in_ped(lua_State* L); // игрок целиться в педа.
  413. int Remove_weapon_model(lua_State* L); // удалить оружие у педа.
  414. int Createped(lua_State* L); // макрос создать педа.
  415. int Createcar(lua_State* L); // макрос создать авто на координатах.
  416.  
  417. int Giveweaponped(lua_State* L); // макрос дать педу оружие и патроны.
  418. int Opendoorcar(lua_State* L); // Макрос открыть все двери авто.
  419. int Create_weapon_pickup(lua_State* L); // макрос создать пикап оружие.
  420. int Create_pickup(lua_State* L); // макрос создать пикап.
  421.  
  422. int Get_model_and_type_current_weapon_ped(lua_State* L); // макрос получить модель и тип текущего оружие педа.
  423. int is_ped_in_car(lua_State* L); // игрок в авто?
  424. int ped_car(lua_State* L); // авто педа.
  425. int wanted_level(lua_State* L); // получить уровень розыска.
  426.  
  427. int get_model_current_weapon_ped(lua_State* L); // макрос получить модель текущего оружие педа.
  428. int get_type_current_weapon_ped(lua_State* L); // макрос получить тип текущего оружие педа.
  429. int set_camera_and_point(lua_State* L); // установить и переместить камеру в координатах.
  430. int get_damage_current_weapon(lua_State* L); // получить уровень урона текущего оружие.
  431.  
  432. int set_damage_current_weapon(lua_State* L); // установить уровень урона текущего оружие педа.
  433. int ped_in_targetting(lua_State* L); // пед на прицеле.
  434. int Ped_in_targetting(lua_State* L); // Макрос пед на прицеле.
  435. int Get_model_and_type_ped(lua_State* L); // макрос получить модель и тип педа.
  436.  
  437. int get_model_ped(lua_State* L); // получить модель педа.
  438. int get_type_ped(lua_State* L); // получить тип педа.
  439. int ped_clear_investigate_event(lua_State* L); // пед уходит, опустить педа.
  440. int ped_clear_objective(lua_State* L); // снять задачи с педа.
  441.  
  442. int setbomb_in_car(lua_State* L); // установить бомбу в авто.
  443. int getbomb_in_car(lua_State* L); // получить тип бомбы в авто.
  444. int activetbomb(lua_State* L); // активировать бомбу в авто.
  445. int is_ped_in_this_car(lua_State* L); // игрок в этом авто?
  446.  
  447. int ishorncar(lua_State* L); // проверить гудит ли авто.
  448. int getcarfirstcolor(lua_State* L); // получить первый цвет авто.
  449. int getcarseconscolor(lua_State* L); // получить второй цвет авто.
  450. int ped_char_spotted_player(lua_State* L); // если пед увидел игрока.   
  451.  
  452. int set_timer_bomb_car(lua_State* L); // установить таймер на взрыв бомбы в авто.
  453. int is_ped_objective(lua_State* L); // если пед выполнил задачу.  
  454. int set_time_scale(lua_State* L); // установить ход времени в игре.
  455. int is_ped_in_air(lua_State* L); // если пед в воздухе. 
  456.  
  457. int kill_peds_in_car(lua_State* L); // убить педов в авто.
  458. int getstamina_ped(lua_State* L); // получить выносливость педа.
  459. int setstamina_ped(lua_State* L); // установить выносливость педа.
  460. int get_radio_car(lua_State* L); // получить текущую радиостанцию авто.
  461.  
  462. int is_ped_passenger_car(lua_State* L); // пед пассажир авто.
  463. int is_ped_driver_car(lua_State* L); // пед пассажир авто.
  464. int ped_in_turret_on_car(lua_State* L); // переместить педа в турель авто.
  465. int ped_from_turret_on_car(lua_State* L); // убрать педа из турели авто.
  466.  
  467. int is_button_pressed(lua_State* L); // если спец клавиша нажата. 
  468. int getmoney_ped(lua_State* L); // получить кол-во деньги педа.
  469. int setmoney_ped(lua_State* L); // установить кол-во деньги педа.
  470. int addmoney_ped(lua_State* L); // добавить кол-во деньги педа.
  471.  
  472. int getgravity(lua_State* L); // получить значения гравитации.
  473. int setgravity(lua_State* L); // установить значения гравитации.
  474. int gravity_default(lua_State* L); // вернуть значения по умолчанию гравитации.
  475. int create_shots_on_ped(lua_State* L); // создать выстрелы.
  476.  
  477. int get_wheel_status(lua_State* L); // получить состояния шины авто.
  478. int create_shots_on_car(lua_State* L); // создать выстрелы.
  479. int ped_save_pos_attack(lua_State* L); // пед сохраняет ли свою позицию при атаке.
  480. int ped_rebuff(lua_State* L); // пед атакует любого, кто нападает на него.
  481.  
  482. int ped_search_threat(lua_State* L); // пед ищет угрозу.  
  483. int ped_clean_threat(lua_State* L); // очистить угрозы для педа.
  484. int save_car_color(lua_State* L); // авто сохраняет цвет при перекраске. 
  485. int is_car_passenger_free(lua_State* L); // Проверяет, свободно ли место пассажира в авто.
  486.  
  487. int set_ped_bleeding(lua_State* L); // вкл\выкл крованные у педа. 
  488. int all_exit_from_car(lua_State* L); // все педы выходят из авто.
  489. int is_ped_duck(lua_State* L); // Проверяет, пед присел.
  490. int set_car_tank(lua_State* L); // установить способность танка детонировать авто при контакте.
  491.  
  492. int set_display_radar(lua_State* L); // показать скрывать радар.
  493. int set_ped_in_car(lua_State* L); // установить педа в авто как водителя или пассажира.
  494. int set_ped_traffic(lua_State* L); // установить плотноcть трафика педов.
  495. int heli_to_fly(lua_State* L); // вертолет летит на координаты.
  496.  
  497. int set_ped_immunities(lua_State* L); // уст иммунитеты педу.
  498. int set_car_immunities(lua_State* L); // уст иммунитеты авто.
  499. int setcolourmarker(lua_State* L); // установить цвет маркера.
  500.  
  501. int set_camera_on_car(lua_State* L); // уст камеру на авто.
  502. int ped_run_to_point(lua_State* L); // пед бежит к точке пешком.
  503. int select_interiour(lua_State* L); // уcтановить интерьер.
  504. int set_ped_stats_to(lua_State* L); // уст поведения педа. 
  505.  
  506. int ped_maintain_position_when_attacked(lua_State* L); // пед удерживает позицию при атаке.    
  507. int set_timer_ped_attack(lua_State* L); // установить таймер атаки педа.      
  508. int set_cops_ignored(lua_State* L); // установить игнор копов.
  509. int set_camera_near_clip(lua_State* L); // установить обрезку камеры.
  510.  
  511. int setpedcrouch(lua_State* L); // пед сел.
  512. int is_ped_incar(lua_State* L);  // пед в авто или нет?
  513. int delete_entity(lua_State* L); // удалить сущность сразу.
  514. int clean_leader(lua_State* L); // перестать следовать за лидером.
  515.  
  516. int show_save_menu(lua_State* L); // показать меню сохранения.
  517. int is_ped_shooting(lua_State* L); // пед стреляет?.
  518. int set_ped_visible(lua_State* L); // уст невидимость педу.
  519. int set_player_mod(lua_State* L); // уст настроения игрока.
  520.  
  521. int setped_damaged_player(lua_State* L); // педу может нанести ущерб только игрок.
  522. int set_ped_reaction_threat(lua_State* L); // уст реакцию педа на ответную угрозу.
  523. int obj_target(lua_State* L); // в объект можно целиться.
  524. int clean_ped_wait(lua_State* L); // пед больше не ждет.
  525.  
  526. int set_ped_accuracy(lua_State* L); // уст меткость педу.
  527. int textbox(lua_State* L); // вывести сообщение в textbox.
  528. int remove_textbox(lua_State* L); // удалить сообщение на textbox.
  529. int get_controller(lua_State* L); // получить контролер от игрока.
  530.  
  531. int create_pickup_clothes(lua_State* L); // создать пикап одежды.
  532. int set_riot_intensity(lua_State* L); // уст уровень шума беспорядков.
  533. int set_ped_walk_style(lua_State* L); // установить стиль ходьбы педа.
  534. int check_car_resray(lua_State* L); // проверить авто игрока было перекрашена в гараже.
  535.  
  536. int set_car_range(lua_State* L); // установить множитель диапазона на угрозу для автомобиля.
  537. int set_ped_range(lua_State* L); // установить множитель диапазона на угрозу для педа.
  538. int getcarangle(lua_State* L); // получить угол авто.
  539. int cleanarea(lua_State* L); //очистить арену.
  540.  
  541. int set_brakes_car(lua_State* L); //уст тормоза авто игрока.
  542. int setmarker_brightness(lua_State* L); // уст яркость маркера.
  543.  
  544. int set_path_to_module(lua_State* L);// уст путь к модулю.
  545. int load_and_start_luascript(lua_State* L, char* luafile, string res); // загрузка и запуск скрипта.
  546.  
  547. int newthread(lua_State* L);// запуск функции в новом потоке.
  548.  
  549. void reversestack(lua_State* L); // реверс стека.
  550. void showstack(lua_State* L);
  551. void showstack1(lua_State* L);
  552.  
  553. int my_yield(lua_State* L) { return lua_yield(L, 0); }; //приостановить выполнение скрипта.
  554.  
  555. void writelog1(int x);
  556. int timerstar();
  557.  
  558. int findplayer(lua_State* L) {// получить указатель на педа.
  559.     CPed* player = FindPlayerPed();// найти томми.
  560.     lua_pushlightuserdata(L, player);// отправить в стек указатель на педа.
  561.     return 1;
  562. };
  563.  
  564. int cardrive(lua_State* L) {// авто едет в точку.
  565.     try {
  566.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  567.             && LUA_TNUMBER == lua_type(L, 4)) {// значение число.
  568.  
  569.             const void* p1 = lua_topointer(L, 1);
  570.             CVehicle* car = findcarinpool(p1);//  получить указатель на авто.
  571.             float x = lua_tonumber(L, 2); float y = lua_tonumber(L, 3);
  572.             float z = lua_tonumber(L, 4); CVector pos = { x, y, z };// вектор координат.
  573.             Command<COMMAND_CAR_GOTO_COORDINATES>(car, pos.x, pos.y, pos.z);// авто едет на координаты.
  574.             return 0;
  575.         }// int
  576.  
  577.         else { throw "bad argument in function cardrive"; }
  578.     }
  579.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  580.     return 0;
  581. };
  582.  
  583. int wait(lua_State* L) {
  584.     static int delay = 0;
  585.     try {
  586.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  587.             int time = lua_tointeger(L, 1); // время задержки.
  588.             this_thread::sleep_for(chrono::milliseconds(time));
  589.             return 0;
  590.         }// int
  591.         if (LUA_TSTRING == lua_type(L, 1) || LUA_TBOOLEAN == lua_type(L, 1)) {
  592.             throw "bad argument in function wait";
  593.         }
  594.         if (LUA_TBOOLEAN == lua_type(L, 1)) {
  595.             throw "bad argument in function wait";
  596.         }
  597.         else {
  598.             this_thread::sleep_for(chrono::milliseconds(1)); return 0;
  599.             /*  delay = iters;
  600.                 while (true)
  601.                 {
  602.                 if (iters- delay >1){
  603.                     delay = 0;
  604.                     break;
  605.                 }
  606.                 }*/
  607.         }
  608.     }
  609.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  610.     return 0;
  611. };
  612.  
  613. int setpedhealth(lua_State* L) {// установить здоровье педу.
  614.     try {
  615.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  616.             if (LUA_TNUMBER == lua_type(L, 2)) {
  617.                 const void* p = lua_topointer(L, 1);
  618.  
  619.                 CPed* ped = findpedinpool(p);// получить указатель на педа.
  620.  
  621.                 float health = lua_tonumber(L, 2);// если число.
  622.  
  623.                 health += 0.99f; ped->m_fHealth = health;
  624.                 return 0;
  625.             }// установить здоровье педа.
  626.             else { throw "bad argument in function setpedhealth option health"; }
  627.         }
  628.         else { throw "bad argument in function setpedhealth option of the player"; }
  629.     }
  630.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  631.     return 0;
  632. };
  633.  
  634. int setarmour(lua_State* L) {// установить броню педу.
  635.     try {
  636.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  637.             if (LUA_TNUMBER == lua_type(L, 2)) {
  638.                 const void* p = lua_topointer(L, 1);
  639.  
  640.                 CPed* ped = findpedinpool(p);// получить указатель на педа.
  641.                 float armour = lua_tonumber(L, 2);
  642.                 armour += 0.10f; ped->m_fArmour = armour; return 0;
  643.             }// установить броню педа.
  644.             else { throw "bad argument in function setarmour option health"; }
  645.         }
  646.         else { throw "bad argument in function setarmour option of the player"; }
  647.     }
  648.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  649.     return 0;
  650. };
  651.  
  652. int getpedarmour(lua_State* L) {
  653.     try {
  654.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  655.             const void* p = lua_topointer(L, 1);
  656.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  657.             float armour = ped->m_fArmour;
  658.  
  659.             lua_pushinteger(L, armour);// отправить в стек.  
  660.             return 1;
  661.         }// получить броню педа.
  662.         else { throw "bad argument in function getpedarmour option of the player"; }
  663.     }
  664.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  665.     return 0;
  666. };
  667.  
  668. int getpedhealth(lua_State* L) {
  669.     try {
  670.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  671.             const void* p = lua_topointer(L, 1);
  672.  
  673.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  674.             int health = ped->m_fHealth; // получить кол-во здоровья педа.
  675.             lua_pushinteger(L, health);// отправить в стек.  
  676.             return 1;
  677.         }
  678.         else { throw "bad argument in function getpedhealth option of the player"; }
  679.     }
  680.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  681.     return 0;
  682. };
  683.  
  684. int getcarhealth(lua_State* L) { // получить кол-во здоровья авто.
  685.     try {
  686.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  687.             const void* p = lua_topointer(L, 1);
  688.             CVehicle* car = findcarinpool(p);// получить указатель на авто.
  689.  
  690.             int health = car->m_fHealth; // получить кол-во здоровья авто.
  691.             lua_pushinteger(L, health);// отправить в стек.  
  692.             return 1;
  693.         }
  694.         else { throw "bad argument in function getcarhealth option of the vehicle"; }
  695.     }
  696.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  697.     return 0;
  698. };
  699.  
  700.  
  701. int setcarhealth(lua_State* L) {// установить здоровье авто.
  702.     try {
  703.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  704.             if (LUA_TNUMBER == lua_type(L, 2)) {// здоровье авто.
  705.                 const void* p = lua_topointer(L, 1);
  706.                 CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  707.  
  708.                 float health = lua_tonumber(L, 2);// если число.
  709.                 health += 0.99f; car->m_fHealth = health; return 0;
  710.             }// установить здоровье авто.
  711.             else { throw "bad argument in function setcarhealth option health"; }
  712.         }
  713.         else { throw "bad argument in function setcarhealth option of the vehicle"; }
  714.     }
  715.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  716.     return 0;
  717. };
  718.  
  719. int setcarangle(lua_State* L) {// установить угол авто.
  720.     try {
  721.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  722.             if (LUA_TNUMBER == lua_type(L, 2)) {
  723.  
  724.                 const void* p = lua_topointer(L, 1);
  725.                 CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  726.  
  727.                 float angle = lua_tonumber(L, 2);// угол авто.
  728.                
  729.                 Command<COMMAND_SET_CAR_HEADING>(CPools::GetVehicleRef(car), angle);
  730.            
  731.                 return 0;
  732.             }
  733.             else { throw "bad argument in function setcarangle option angle"; }
  734.         }
  735.         else { throw "bad argument in function setcarangle option of the vehicle"; }
  736.     }
  737.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  738.     return 0;
  739. };
  740.  
  741. int setpedangle(lua_State* L) {// установить угол педа.
  742.     try {
  743.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на авто.
  744.  
  745.             const void* p = lua_topointer(L, 1);
  746.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  747.             float angle = lua_tonumber(L, 2);// угол авто.
  748.             CPed* player = FindPlayerPed();// найти игрока.
  749.             if (ped == player) {
  750.                 Command<COMMAND_SET_PLAYER_HEADING>(CWorld::PlayerInFocus, angle);
  751.                 return 0;
  752.             }
  753.             else {
  754.                 Command<COMMAND_SET_CHAR_HEADING>(CPools::GetPedRef(ped), angle);
  755.                 return 0;
  756.             }
  757.         }
  758.         else { throw "bad argument in function setcarangle option of the vehicle"; }
  759.     }
  760.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  761.     return 0;
  762. };
  763.  
  764. int setdrivingstyle(lua_State* L) {// установить стиль езды авто.
  765.     try {
  766.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  767.             if (LUA_TNUMBER == lua_type(L, 2)) {
  768.  
  769.                 const void* p = lua_topointer(L, 1);
  770.                 CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  771.  
  772.                 int style = lua_tointeger(L, 2);// если число.
  773.                 switch (style) {
  774.                 case 0: {car->m_autoPilot.m_nDrivingStyle = DRIVINGSTYLE_STOP_FOR_CARS;
  775.                     break; }// ОСТАНОВКА СТИЛЯ ВОЖДЕНИЯ ДЛЯ АВТОМОБИЛЕЙ;
  776.                 case 1: {car->m_autoPilot.m_nDrivingStyle = DRIVINGSTYLE_SLOW_DOWN_FOR_CARS;
  777.                     break; }// СТИЛЬ ВОЖДЕНИЯ ЗАМЕДЛИТЬ ДЛЯ АВТОМОБИЛЕЙ;,
  778.                 case 2: {car->m_autoPilot.m_nDrivingStyle = DRIVINGSTYLE_AVOID_CARS;
  779.                     break; }// СТИЛЬ ВОЖДЕНИЯ ИЗБЕГАЙТЕ АВТОМОБИЛЕЙ;,
  780.                 case 3: {car->m_autoPilot.m_nDrivingStyle = DRIVINGSTYLE_PLOUGH_THROUGH;
  781.                     break; }//  СТИЛЬ ВОЖДЕНИЯ ПЛУГ ЧЕРЕЗ;,
  782.                 case 4: {car->m_autoPilot.m_nDrivingStyle = DRIVINGSTYLE_STOP_FOR_CARS_IGNORE_LIGHTS;
  783.                     break; }//  СТИЛЬ ВОЖДЕНИЯ СТОП ДЛЯ АВТОМОБИЛЕЙ ИГНОРИРОВАТЬ ОГНИ;
  784.                 default: {}
  785.                 }
  786.                 return 0;
  787.             }// установить стиль езды авто.
  788.             else { throw "bad argument in function setdrivingstyle option style"; }
  789.         }
  790.         else { throw "bad argument in function setdrivingstyle option of the vehicle"; }
  791.     }
  792.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  793.     return 0;
  794. };
  795.  
  796. int setcaraction(lua_State* L) {// установить поведение авто.
  797.     try {
  798.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  799.             if (LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)) {
  800.  
  801.                 const void* p = lua_topointer(L, 1);
  802.                 CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  803.  
  804.                 int style = lua_tointeger(L, 2);// действие авто.
  805.                 unsigned int t = lua_tointeger(L, 3);// время выполнение действия авто.
  806.                 unsigned int time = t * 10;
  807.  
  808.                 for (int i = 0; i < CPools::ms_pVehiclePool->m_nSize; i++) {
  809.                     CVehicle* vehicle = CPools::ms_pVehiclePool->GetAt(i);
  810.                     if (vehicle == car) {
  811.  
  812.                         if (style == 0) {
  813.                             Command<COMMAND_SET_CAR_TEMP_ACTION>(CPools::GetVehicleRef(vehicle), TEMPACT_NONE, time);
  814.                             return 0;
  815.                         }
  816.                         if (style == 1) {
  817.                             Command<COMMAND_SET_CAR_TEMP_ACTION>(CPools::GetVehicleRef(vehicle), TEMPACT_WAIT, time);
  818.                             return 0;
  819.                         }
  820.                         if (style == 2) {
  821.                             Command<COMMAND_SET_CAR_TEMP_ACTION>(CPools::GetVehicleRef(vehicle), TEMPACT_REVERSE, time);
  822.                             return 0;
  823.                         }
  824.                         if (style == 3) {
  825.                             Command<COMMAND_SET_CAR_TEMP_ACTION>(CPools::GetVehicleRef(vehicle), TEMPACT_HANDBRAKETURNLEFT, time);
  826.                             return 0;
  827.                         }
  828.                         if (style == 4) {
  829.                             Command<COMMAND_SET_CAR_TEMP_ACTION>(CPools::GetVehicleRef(vehicle), TEMPACT_HANDBRAKETURNRIGHT, time);
  830.                             return 0;
  831.                         }
  832.                         if (style == 5) {
  833.                             Command<COMMAND_SET_CAR_TEMP_ACTION>(CPools::GetVehicleRef(vehicle), TEMPACT_HANDBRAKESTRAIGHT, time);
  834.                             return 0;
  835.                         }
  836.                         if (style == 6) {//влево.
  837.                             Command<COMMAND_SET_CAR_TEMP_ACTION>(CPools::GetVehicleRef(vehicle), TEMPACT_TURNLEFT, time);
  838.                             return 0;
  839.                         }
  840.                         if (style == 7) {// вправо.
  841.                             Command<COMMAND_SET_CAR_TEMP_ACTION>(CPools::GetVehicleRef(vehicle), TEMPACT_TURNRIGHT, time);
  842.                             return 0;
  843.                         }
  844.                         if (style == 8) {// вперед.
  845.                             Command<COMMAND_SET_CAR_TEMP_ACTION>(CPools::GetVehicleRef(vehicle), TEMPACT_GOFORWARD, time);
  846.                             return 0;
  847.                         }
  848.                         if (style == 9) {
  849.                             Command<COMMAND_SET_CAR_TEMP_ACTION>(CPools::GetVehicleRef(vehicle), TEMPACT_SWERVELEFT, time);
  850.                             return 0;
  851.                         }
  852.                         if (style == 10) {
  853.                             Command<COMMAND_SET_CAR_TEMP_ACTION>(CPools::GetVehicleRef(vehicle), TEMPACT_SWERVERIGHT, time);
  854.                             return 0;
  855.                         }
  856.                     }
  857.                 }
  858.             }// установить действие авто.
  859.             else { throw "bad argument in function setcaraction"; }
  860.         }
  861.         else { throw "bad argument in function setcaraction option of the vehicle"; }
  862.     }
  863.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  864.     return 0;
  865. };
  866.  
  867. int setcarspeed(lua_State* L) {// установить скорость авто.
  868.     try {
  869.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  870.             if (LUA_TNUMBER == lua_type(L, 2)) {
  871.  
  872.                 const void* p = lua_topointer(L, 1);
  873.                 CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  874.  
  875.                 float speed = lua_tonumber(L, 2);// переменная хранить скорость авто.
  876.                 Command<COMMAND_SET_CAR_CRUISE_SPEED>(CPools::GetVehicleRef(car), speed);
  877.                 return 0;
  878.             }
  879.             else { throw "bad argument in function setcarspeed option speed"; }
  880.         }
  881.         else { throw "bad argument in function setcarspeed option of the vehicle"; }
  882.     }
  883.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  884.     return 0;
  885. };
  886.  
  887. int setcartask(lua_State* L) {// установить задачу авто.
  888.     try {
  889.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  890.             if (LUA_TNUMBER == lua_type(L, 2)) {
  891.                 const void* p = lua_topointer(L, 1);
  892.  
  893.                 CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  894.  
  895.                 int task = lua_tointeger(L, 2);// задача авто.
  896.                 if (task == 0) {
  897.                     car->m_autoPilot.m_nCarMission = MISSION_NONE;
  898.                     return 0;
  899.                 }
  900.                 if (task == 1) {
  901.                     car->m_autoPilot.m_nCarMission = MISSION_CRUISE;
  902.                     return 0;
  903.                 }
  904.                 if (task == 2) {
  905.                     car->m_autoPilot.m_nCarMission = MISSION_RAMPLAYER_FARAWAY;
  906.                     return 0;
  907.                 }
  908.                 if (task == 3) {
  909.                     car->m_autoPilot.m_nCarMission = MISSION_RAMPLAYER_CLOSE;//ехать за педом
  910.                     return 0;
  911.                 }
  912.                 if (task == 4) {
  913.                     car->m_autoPilot.m_nCarMission = MISSION_BLOCKPLAYER_FARAWAY;
  914.                     return 0;
  915.                 }
  916.                 if (task == 5) {
  917.                     car->m_autoPilot.m_nCarMission = MISSION_BLOCKPLAYER_CLOSE;// подъехать к педу.
  918.                     return 0;
  919.                 }
  920.                 if (task == 6) {//влево.
  921.                     car->m_autoPilot.m_nCarMission = MISSION_BLOCKPLAYER_HANDBRAKESTOP;
  922.                     return 0;
  923.                 }
  924.                 if (task == 7) {// вправо.
  925.                     car->m_autoPilot.m_nCarMission = MISSION_WAITFORDELETION;
  926.                     return 0;
  927.                 }
  928.                 if (task == 8) {// вперед.
  929.                     car->m_autoPilot.m_nCarMission = MISSION_GOTOCOORDS;
  930.                     return 0;
  931.                 }
  932.                 if (task == 9) {
  933.                     car->m_autoPilot.m_nCarMission = MISSION_GOTOCOORDS_STRAIGHT;
  934.                     return 0;
  935.                 }
  936.                 if (task == 10) {
  937.                     car->m_autoPilot.m_nCarMission = MISSION_EMERGENCYVEHICLE_STOP;
  938.                     return 0;
  939.                 }
  940.                 if (task == 11) {
  941.                     car->m_autoPilot.m_nCarMission = MISSION_STOP_FOREVER;
  942.                     return 0;
  943.                 }
  944.                 if (task == 12) {
  945.                     car->m_autoPilot.m_nCarMission = MISSION_GOTOCOORDS_ACCURATE;
  946.                     return 0;
  947.                 }
  948.                 if (task == 13) {
  949.                     car->m_autoPilot.m_nCarMission = MISSION_GOTO_COORDS_STRAIGHT_ACCURATE;
  950.                     return 0;
  951.                 }
  952.                 if (task == 14) {
  953.                     car->m_autoPilot.m_nCarMission = MISSION_GOTOCOORDS_ASTHECROWSWIMS;
  954.                     return 0;
  955.                 }
  956.                 if (task == 15) {
  957.                     car->m_autoPilot.m_nCarMission = MISSION_RAMCAR_FARAWAY;
  958.                     return 0;
  959.                 }
  960.                 if (task == 16) {
  961.                     car->m_autoPilot.m_nCarMission = MISSION_RAMCAR_CLOSE;
  962.                     return 0;
  963.                 }
  964.                 if (task == 17) {
  965.                     car->m_autoPilot.m_nCarMission = MISSION_BLOCKCAR_FARAWAY;
  966.                     return 0;
  967.                 }
  968.                 if (task == 18) {
  969.                     car->m_autoPilot.m_nCarMission = MISSION_BLOCKCAR_CLOSE;
  970.                     return 0;
  971.                 }
  972.                 if (task == 19) {
  973.                     car->m_autoPilot.m_nCarMission = MISSION_BLOCKCAR_HANDBRAKESTOP;
  974.                     return 0;
  975.                 }
  976.                 if (task == 20) {
  977.                     car->m_autoPilot.m_nCarMission = MISSION_HELI_FLYTOCOORS;
  978.                     return 0;
  979.                 }
  980.                 if (task == 21) {
  981.                     car->m_autoPilot.m_nCarMission = MISSION_ATTACKPLAYER;
  982.                     return 0;
  983.                 }
  984.                 if (task == 22) {
  985.                     car->m_autoPilot.m_nCarMission = MISSION_PLANE_FLYTOCOORS;
  986.                     return 0;
  987.                 }
  988.                 if (task == 23) {
  989.                     car->m_autoPilot.m_nCarMission = MISSION_HELI_LAND;
  990.                     return 0;
  991.                 }
  992.                 if (task == 24) {
  993.                     car->m_autoPilot.m_nCarMission = MISSION_SLOWLY_DRIVE_TOWARDS_PLAYER_1;
  994.                     return 0;
  995.                 }
  996.                 if (task == 25) {
  997.                     car->m_autoPilot.m_nCarMission = MISSION_SLOWLY_DRIVE_TOWARDS_PLAYER_2;
  998.                     return 0;
  999.                 }
  1000.                 if (task == 26) {
  1001.                     car->m_autoPilot.m_nCarMission = MISSION_BLOCKPLAYER_FORWARDANDBACK;
  1002.                     return 0;
  1003.                 }
  1004.                 return 0;
  1005.             }
  1006.             else { throw "bad argument in function setcartask option task"; }
  1007.         }
  1008.         else { throw "bad argument in function setcartask option of the vehicle"; }
  1009.     }
  1010.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1011.     return 0;
  1012. };
  1013.  
  1014. int keypress(lua_State* L) {// проверка нажата ли клавиша?
  1015.     try {
  1016.         if (LUA_TSTRING == lua_type(L, 1)) {// значение строка.
  1017.             const char* namekey = lua_tostring(L, 1);
  1018.             int key = find_in_map(numbers_keys, namekey);// номер клавиши.
  1019.  
  1020.             if (GetAsyncKeyState(key) == -32767) {
  1021.                 lua_pushboolean(L, true);// клавиша нажата.
  1022.                 return 1;
  1023.             }
  1024.             else {
  1025.                 lua_pushboolean(L, false);
  1026.                 return 1;
  1027.             }
  1028.         }
  1029.         else { throw "bad argument in function keypress"; }
  1030.     }
  1031.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1032.     return 0;
  1033. };
  1034.  
  1035. int lockstatus(lua_State* L) {// статус двери авто.
  1036.     try {
  1037.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на авто.
  1038.  
  1039.             const void* p = lua_topointer(L, 1);
  1040.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  1041.             /*
  1042.             0   CARLOCK_NONE
  1043.             1   CARLOCK_UNLOCKED разблокированная машина
  1044.             2   CARLOCK_LOCKED  запертая машина - свойства включают двери не могут упасть, никто не может войти, но может выйти, любой может войти, если дверь оставлена ​​широко открытой или упала
  1045.             3   CARLOCK_LOCKOUT_PLAYER_ONLY заблокирован для игрока, не заблокирован для NPC
  1046.             4   CARLOCK_LOCKED_PLAYER_INSIDE заблокирован, игрок застрял в машине
  1047.             5   CARLOCK_LOCKED_INITIALLY заблокирован, когда не в машине, разблокирован, когда в машине
  1048.             6   CARLOCK_FORCE_SHUT_DOORS анимация никогда не оставит дверь открытой, всегда закрывает дверь
  1049.             7   CARLOCK_LOCKED_BUT_CAN_BE_DAMAGED заперт, но двери могут упасть
  1050.             */
  1051.             int status = lua_tointeger(L, 2);// статус двери авто.
  1052.             car->m_nLockStatus = status;
  1053.             return 0;
  1054.         }
  1055.         else { throw "bad argument in function lockstatus"; }
  1056.     }
  1057.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1058.     return 0;
  1059. };
  1060.  
  1061. int givemoney(lua_State* L) {// дать денег игроку.
  1062.     try {
  1063.         if (LUA_TNUMBER == lua_type(L, 1)) {//кол-во денег.
  1064.             int money = lua_tointeger(L, 1);
  1065.             CWorld::Players[CWorld::PlayerInFocus].m_nMoney += money;// дать денег  
  1066.         }
  1067.         else { throw "bad argument in function givemoney"; }
  1068.     }
  1069.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1070.     return 0;
  1071. };
  1072.  
  1073. int getpedcoordes(lua_State* L) {// получить координаты педа.
  1074.     try {
  1075.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  1076.             const void* p = lua_topointer(L, 1);
  1077.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1078.  
  1079.             lua_pushnumber(L, ped->GetPosition().x);// отправить в стек.
  1080.             lua_pushnumber(L, ped->GetPosition().y);// отправить в стек.
  1081.             lua_pushnumber(L, ped->GetPosition().z);// отправить в стек.
  1082.             return 3;
  1083.         }   // получить координаты педа.
  1084.  
  1085.         else { throw "bad argument in function getpedcoordes option of the player"; }
  1086.     }
  1087.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1088. };
  1089.  
  1090. int getcarcoordes(lua_State* L) {// получить координаты авто.
  1091.     try {
  1092.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  1093.  
  1094.             const void* p = lua_topointer(L, 1);
  1095.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  1096.  
  1097.             lua_pushnumber(L, car->GetPosition().x);// отправить в стек.
  1098.             lua_pushnumber(L, car->GetPosition().y);// отправить в стек.
  1099.             lua_pushnumber(L, car->GetPosition().z);// отправить в стек.
  1100.             return 3;
  1101.         }   // получить координаты авто.
  1102.  
  1103.         else { throw "bad argument in function getcarcoordes"; }
  1104.     }
  1105.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1106. };
  1107.  
  1108. int printmessage(lua_State* L) {// аргументы текст и и время вывода на экран.
  1109.     try {
  1110.         if (LUA_TSTRING == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)) {//строка.
  1111.             const char* c = lua_tostring(L, 1);// строка.
  1112.             int time = lua_tointeger(L, 2);// время вывода текста.
  1113.             int style = lua_tointeger(L, 3);// стиль вывода текста.
  1114.             wchar_t* str = getwchat(c);
  1115.             CMessages::AddMessageJumpQ(str, time, style);// вывести сообщение на экран.
  1116.             return 0;
  1117.         }
  1118.         else { throw "bad argument in function printmessage"; }
  1119.     }
  1120.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1121.     return 0;
  1122. };
  1123.  
  1124. int randomfindped(lua_State* L) {// найти педа в радиусе.
  1125.     try {
  1126.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {
  1127.  
  1128.             const void* p1 = lua_topointer(L, 1);
  1129.  
  1130.             CPed* p = findpedinpool(p1);//  получить указатель на педа.
  1131.             double radius = lua_tonumber(L, 2);
  1132.             CVehicle* v = NULL;
  1133.  
  1134.             if (p->m_bInVehicle && p->m_pVehicle != NULL) {// в авто пед?
  1135.                 CVehicle* v = p->m_pVehicle;
  1136.             }// получить указатель на хенлд авто в котором сидит томии.
  1137.  
  1138.             for (auto car : CPools::ms_pVehiclePool) {
  1139.                 if (car != v && DistanceBetweenPoints(car->GetPosition(), p->GetPosition()) < radius && car->m_fHealth > 50) {
  1140.                     car->CanPedExitCar(true);
  1141.                     if (CPed * p1 = car->m_pDriver) {
  1142.                         if (p1 != NULL && p1 != p) {
  1143.                             lua_pushboolean(L, true); lua_pushlightuserdata(L, p1);// отправить в стек и получить из стека можно
  1144.                             return 2;
  1145.                         }
  1146.                     }
  1147.                 }
  1148.             }
  1149.             for (auto ped : CPools::ms_pPedPool) {
  1150.                 if (ped != p && DistanceBetweenPoints(ped->GetPosition(), p->GetPosition()) < radius && ped->m_fHealth > 50) {
  1151.                     lua_pushboolean(L, true); lua_pushlightuserdata(L, ped);// отправить в стек и получить из стека можно
  1152.                     return 2;
  1153.                 }
  1154.             }//    
  1155.             CPed* p2 = NULL; lua_pushboolean(L, false);
  1156.             lua_pushlightuserdata(L, p2);// отправить в стек и получить из стека можно
  1157.             return 2;
  1158.         }
  1159.         else { throw "bad argument in function randomfindped"; }
  1160.     }
  1161.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1162. };
  1163.  
  1164. int randomfindcar(lua_State* L) {//Найти случайное авто в радиусе.
  1165.     try {
  1166.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {
  1167.  
  1168.             const void* p1 = lua_topointer(L, 1);
  1169.             CPed* p = findpedinpool(p1);//  получить указатель на авто.
  1170.  
  1171.             double radius = lua_tointeger(L, 2);// радиус.
  1172.             CVehicle* v = NULL;
  1173.  
  1174.             if (p->m_bInVehicle && p->m_pVehicle != NULL) {// в авто пед?
  1175.                 CVehicle* v = p->m_pVehicle;
  1176.             }// получить указатель на хенлд авто в котором сидит томии.
  1177.             for (auto car : CPools::ms_pVehiclePool) {
  1178.                 if (car != v && DistanceBetweenPoints(car->GetPosition(), p->GetPosition()) < radius && car->m_fHealth > 50) {
  1179.  
  1180.                     lua_pushboolean(L, true); lua_pushlightuserdata(L, car);// отправить в стек и получить из стека можно
  1181.                     return 2;
  1182.                 }
  1183.             }
  1184.         }
  1185.         else { throw "bad argument in function randomfindcar"; }
  1186.     }
  1187.     catch (const char* x) {
  1188.         writelog(x);// записать ошибку в файл.
  1189.     }
  1190. };
  1191.  
  1192. int findcar(lua_State* L) {//Найти авто.
  1193.     try {
  1194.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {
  1195.  
  1196.             const void* p = lua_topointer(L, 1);
  1197.             CVehicle* v = findcarinpool(p);//  получить указатель на авто.
  1198.             for (auto car : CPools::ms_pVehiclePool) {
  1199.                 if (car == v) {
  1200.                     lua_pushlightuserdata(L, car);// отправить в стек и получить из стека можно
  1201.                     return 1;
  1202.                 }
  1203.             }
  1204.         }
  1205.         else { throw "bad argument in function findcar"; }
  1206.     }
  1207.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1208. };
  1209.  
  1210. int findped(lua_State* L) {
  1211.     try {
  1212.         lua_newtable(L);
  1213.         luaL_newmetatable(L, "mt");
  1214.         for (auto ped : CPools::ms_pPedPool) {
  1215.             lua_pushlightuserdata(L, ped);
  1216.             lua_pushlightuserdata(L, ped);// отправить в стек и получить из стека можно
  1217.             lua_rawset(L, -3);
  1218.             luaL_setmetatable(L, "mt");
  1219.         }
  1220.         return 1;
  1221.     }
  1222.  
  1223.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1224. };
  1225.  
  1226. int incar(lua_State* L) {// пед в авто?
  1227.     try {
  1228.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  1229.  
  1230.             const void* p = lua_topointer(L, 1);
  1231.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1232.             if (ped->m_bInVehicle && ped->m_pVehicle != NULL) {// в авто пед?
  1233.                 CVehicle* v = ped->m_pVehicle;
  1234.                 lua_pushboolean(L, true);
  1235.                 lua_pushlightuserdata(L, v);// отправить в стек true и указатель на авто.
  1236.                 return 2;
  1237.             }
  1238.             else {
  1239.                 CVehicle* v = NULL;//если пед не в авто вернуть null;
  1240.                 lua_pushboolean(L, false);
  1241.                 lua_pushlightuserdata(L, v);// отправить в стек и получить из стека можно
  1242.                 return 2;// получить указатель на хенлд авто в котором сидит пед.
  1243.             }
  1244.         }
  1245.         else { throw "bad argument in function incar"; }
  1246.     }
  1247.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1248. };
  1249.  
  1250. int exitcar(lua_State* L) {// пед выходит из машины.
  1251.     try {
  1252.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  1253.             const void* p = lua_topointer(L, 1);
  1254.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1255.             ped->SetObjective(OBJECTIVE_LEAVE_CAR);
  1256.             return 0;
  1257.         } // выйти из авто.
  1258.         else { throw "bad argument in function exitcar"; }
  1259.     }
  1260.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1261. };
  1262.  
  1263. int loadmodel(lua_State* L) {//Загрузка моделей.
  1264.     try {
  1265.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число(модель).
  1266.             int model = lua_tointeger(L, 1);
  1267.             Command<COMMAND_REQUEST_MODEL>(model);
  1268.             return 0;
  1269.         }// int
  1270.  
  1271.         else { throw "bad argument in function loadmodel"; }
  1272.     }
  1273.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1274.     return 0;
  1275. };
  1276.  
  1277. int releasemodel(lua_State* L) {// Удалить модель из памяти.
  1278.     try {
  1279.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение id модели.
  1280.             int model = lua_tointeger(L, 1);
  1281.             Command<COMMAND_MARK_MODEL_AS_NO_LONGER_NEEDED>(model);
  1282.             return 0;
  1283.         }// int
  1284.         else { throw "bad argument in function releasemodel"; }
  1285.     }
  1286.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1287.     return 0;
  1288. };
  1289.  
  1290. int availablemodel(lua_State* L) {// проверка на загруженность модели.
  1291.     try {
  1292.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение id модели.
  1293.             int model = lua_tointeger(L, 1);
  1294.             bool ava = Command<COMMAND_HAS_MODEL_LOADED>(model);
  1295.             lua_pushboolean(L, ava);
  1296.             return 1;
  1297.         }// int
  1298.  
  1299.         else { throw "bad argument in function availablemodel"; }
  1300.     }
  1301.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1302.     return 0;
  1303. };
  1304.  
  1305. int createcar(lua_State* L) {// создать авто на координатах.
  1306.     try {
  1307.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)
  1308.             && LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 4)) {// значение число.
  1309.             int model = lua_tointeger(L, 1);// модель авто.
  1310.             float x = lua_tonumber(L, 2); float y = lua_tonumber(L, 3);
  1311.             float z = lua_tonumber(L, 4); CVector pos = { x, y, z };
  1312.             CVehicle* vehicle = NULL;
  1313.             Command<COMMAND_CREATE_CAR>(model, pos.x, pos.y, pos.z, &vehicle);
  1314.             mapcars.emplace(vehicle, L);// добавить в map для авто.
  1315.             lua_pushlightuserdata(L, vehicle);// отправить в стек указатель на авто.
  1316.             return 1;
  1317.         }// int
  1318.  
  1319.         else { throw "bad argument in function createcar"; }
  1320.     }
  1321.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1322.     return 0;
  1323. };
  1324.  
  1325. int createobj(lua_State* L) {// создать объект.
  1326.     try {
  1327.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  1328.             && LUA_TNUMBER == lua_type(L, 4)) {// значение число.
  1329.             int model = lua_tointeger(L, 1);// модель авто.
  1330.             float x = lua_tonumber(L, 2); float y = lua_tonumber(L, 3);
  1331.             float z = lua_tonumber(L, 4); CVector pos = { x, y, z };
  1332.             CObject* obj = NULL;
  1333.             Command<COMMAND_CREATE_OBJECT>(model, pos.x, pos.y, pos.z, &obj);
  1334.             mapobjs.emplace(obj, L);// добавить в map для авто.
  1335.             lua_pushlightuserdata(L, obj);// отправить в стек указатель на объект.
  1336.             return 1;
  1337.         }// int
  1338.  
  1339.         else { throw "bad argument in function createobj"; }
  1340.     }
  1341.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1342.     return 0;
  1343. };
  1344.  
  1345. int create_marker_actor(lua_State* L) {//создать маркер над педом.
  1346.     int marker;// храним id маркера.
  1347.     try {
  1348.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  1349.             const void* p = lua_topointer(L, 1);
  1350.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1351.             Command<COMMAND_ADD_BLIP_FOR_CHAR>(CPools::GetPedRef(ped), &marker);
  1352.             markeron.emplace(marker, L);// добавить в map для маркеров.
  1353.             lua_pushinteger(L, marker);// отправить в стек.  
  1354.             return 1;
  1355.         }
  1356.         else { throw "bad argument in function create_marker_actor"; }
  1357.     }
  1358.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1359.     return 0;
  1360. };
  1361.  
  1362. int create_marker_car(lua_State* L) {//создать маркер над авто.
  1363.     int marker;// храним id маркера.
  1364.     try {
  1365.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  1366.  
  1367.             const void* p = lua_topointer(L, 1);
  1368.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  1369.             Command<COMMAND_ADD_BLIP_FOR_CAR>(CPools::GetVehicleRef(car), &marker);
  1370.  
  1371.             markeron.emplace(marker, L);// добавить в map для маркеров.
  1372.             lua_pushinteger(L, marker);// отправить в стек.  
  1373.             return 1;
  1374.         }
  1375.         else { throw "bad argument in function create_marker_car"; }
  1376.     }
  1377.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1378.     return 0;
  1379. };
  1380.  
  1381. int removemarker(lua_State* L) {// удалить маркер.
  1382.     try {
  1383.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  1384.             int marker = lua_tointeger(L, 1);// получить id маркера.
  1385.             Command<COMMAND_REMOVE_BLIP>(marker);
  1386.             return 0;
  1387.         }
  1388.         else { throw "bad argument in function removemarker option of the player"; }
  1389.     }
  1390.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1391.     return 0;
  1392. };
  1393.  
  1394. int ped_sprint_to_point(lua_State* L) {// пед делает спринт к точке.
  1395.     try {
  1396.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) &&
  1397.             LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 4)) {// указатель на педа.
  1398.  
  1399.             const void* p = lua_topointer(L, 1);
  1400.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  1401.  
  1402.             float x = lua_tonumber(L, 2); float y = lua_tonumber(L, 3);
  1403.             float z = lua_tonumber(L, 4); CVector pos = { x, y, z };// вектор для координат.
  1404.             ped->SetObjective(OBJECTIVE_SPRINT_TO_AREA, pos);// пед делает спринт к точке.
  1405.         }
  1406.         else { throw "bad argument in function ped_run_to_point"; }
  1407.     }
  1408.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1409. };
  1410.  
  1411. int ped_walk_to_point(lua_State* L) {// пед идет пешком.
  1412.     try {
  1413.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) &&
  1414.             LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 4)) {// указатель на педа.
  1415.  
  1416.             const void* p = lua_topointer(L, 1);
  1417.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1418.             float x = lua_tonumber(L, 2);   float y = lua_tonumber(L, 3);
  1419.             float z = lua_tonumber(L, 4);
  1420.             CVector pos = { x, y, z };
  1421.             ped->SetObjective(OBJECTIVE_GOTO_AREA_ON_FOOT, pos);// пед идет пешком.
  1422.         }
  1423.         else { throw "bad argument in function ped_walk_to_point"; }
  1424.     }
  1425.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1426. };
  1427.  
  1428. int ped_run_to_point(lua_State* L) {// пед бежит к точке пешком.
  1429.     try {
  1430.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) &&
  1431.             LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 4)) {// указатель на педа.
  1432.  
  1433.             const void* p = lua_topointer(L, 1);
  1434.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1435.             float x = lua_tonumber(L, 2);   float y = lua_tonumber(L, 3);
  1436.             float z = lua_tonumber(L, 4);
  1437.             CVector pos = { x, y, z };
  1438.             ped->SetObjective(OBJECTIVE_RUN_TO_AREA, pos);// пед бежит к точке пешком.
  1439.         }
  1440.         else { throw "bad argument in function ped_run_to_point"; }
  1441.     }
  1442.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1443. };
  1444.  
  1445. int getobjangle(lua_State* L) {// получить угол объекта.
  1446.     try {
  1447.         float angle;
  1448.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на объект.
  1449.  
  1450.             const void* p = lua_topointer(L, 1);
  1451.             CObject* obj = findobjinpool(p);// получить указатель на педа.
  1452.             angle = obj->GetHeading();
  1453.             //Command<COMMAND_GET_OBJECT_HEADING>(CPools::GetObjectRef(obj), angle);
  1454.             lua_pushnumber(L, angle);// отправить в стек.
  1455.             return 1;
  1456.         }// получить угол объекта.
  1457.  
  1458.         else { throw "bad argument in function getobjangle"; }
  1459.     }
  1460.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1461.     return 0;
  1462. };
  1463.  
  1464. int getpedangle(lua_State* L) {// получить угол педа
  1465.     try {
  1466.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  1467.  
  1468.             const void* p = lua_topointer(L, 1);
  1469.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1470.             float angle;// переменная хранить угол педа.
  1471.             angle = ped->GetHeading();// получить угол педа
  1472.             lua_pushinteger(L, angle);// отправить в стек.  
  1473.             return 1;
  1474.             /*CPed* player = FindPlayerPed();// найти игрока.
  1475.             if (ped == player) {
  1476.                 Command<COMMAND_GET_PLAYER_HEADING>(CWorld::PlayerInFocus, &angle);//  получить угол педа.
  1477.                 lua_pushinteger(L, angle);// отправить в стек.
  1478.                 return 1;
  1479.             }
  1480.             else {
  1481.                 Command<COMMAND_GET_CHAR_HEADING>(CPools::GetPedRef(ped), &angle);//  получить угол педа.
  1482.                 lua_pushinteger(L, angle);// отправить в стек.
  1483.                 return 1;
  1484.             }*/
  1485.         }
  1486.         else { throw "bad argument in function getpedangle option of the player"; }
  1487.     }
  1488.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1489.     return 0;
  1490. };
  1491.  
  1492. int getpedcoordinates_on_x(lua_State* L) {// Получить мировую координату по x для педа.
  1493.     try {
  1494.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  1495.  
  1496.             const void* p = lua_topointer(L, 1);
  1497.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1498.             float x = lua_tonumber(L, 2);
  1499.             CVector pos = ped->m_placement.pos;
  1500.             pos += ped->m_placement.right * x;
  1501.             lua_pushnumber(L, pos.x); lua_pushnumber(L, pos.y); lua_pushnumber(L, pos.z);
  1502.             return 3;
  1503.         }
  1504.         else { throw "bad argument in function getpedcoordinates_on_x"; }
  1505.     }
  1506.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1507. };
  1508.  
  1509. int getpedcoordinates_on_y(lua_State* L) {// // Получить мировую координату по y для педа.
  1510.     try {
  1511.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  1512.  
  1513.             const void* p = lua_topointer(L, 1);
  1514.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1515.  
  1516.             float y = lua_tonumber(L, 2);
  1517.             CVector pos = ped->m_placement.pos;
  1518.             pos += ped->m_placement.up * y;   lua_pushnumber(L, pos.x);
  1519.             lua_pushnumber(L, pos.y);   lua_pushnumber(L, pos.z);
  1520.             return 3;
  1521.         }
  1522.         else { throw "bad argument in function getpedcoordinates_on_y"; }
  1523.     }
  1524.     catch (const char* x) {
  1525.         writelog(x);
  1526.     }
  1527. };
  1528.  
  1529. int getcarcoordinates_on_x(lua_State* L) {// Получить мировую координату по x для авто.
  1530.     try {
  1531.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на авто.
  1532.  
  1533.             const void* p = lua_topointer(L, 1);
  1534.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  1535.  
  1536.             float x = lua_tonumber(L, 2);
  1537.             CVector pos = car->m_placement.pos;
  1538.             pos += car->m_placement.right * x;
  1539.             lua_pushnumber(L, pos.x); lua_pushnumber(L, pos.y); lua_pushnumber(L, pos.z);
  1540.             return 3;
  1541.         }
  1542.         else { throw "bad argument in function getcarcoordinates_on_x"; }
  1543.     }
  1544.     catch (const char* x) { writelog(x); }
  1545. };
  1546.  
  1547. int getcarcoordinates_on_y(lua_State* L) {// Получить мировую координату по y для авто.
  1548.     try {
  1549.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на авто.
  1550.  
  1551.             const void* p = lua_topointer(L, 1);
  1552.             CVehicle* car = findcarinpool(p);// получить указатель на авто.
  1553.  
  1554.             float y = lua_tonumber(L, 2);
  1555.             CVector pos = car->m_placement.pos;
  1556.             pos += car->m_placement.up * y; lua_pushnumber(L, pos.x);
  1557.             lua_pushnumber(L, pos.y); lua_pushnumber(L, pos.z);
  1558.             return 3;
  1559.         }
  1560.         else { throw "bad argument in function getcarcoordinates_on_y"; }
  1561.     }
  1562.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1563. };
  1564.  
  1565. int worldcoord(lua_State* L) {// Перевод в мировые координаты.
  1566.     try {
  1567.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)
  1568.             && LUA_TNUMBER == lua_type(L, 3)) {// указатель на педа.
  1569.  
  1570.             const void* p = lua_topointer(L, 1);
  1571.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1572.  
  1573.             float x = lua_tonumber(L, 2); float y = lua_tonumber(L, 3);
  1574.             CVector pos = ped->m_placement.pos + ped->m_placement.right * x + ped->m_placement.up * y;
  1575.             lua_pushnumber(L, pos.x);   lua_pushnumber(L, pos.y);
  1576.             return 2;
  1577.         }
  1578.         else { throw "bad argument in function worldcoord"; }
  1579.     }
  1580.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1581. };
  1582.  
  1583. int load_requested_models(lua_State* L) {// Загрузка модели в не очереди.
  1584.     Command<COMMAND_LOAD_ALL_MODELS_NOW>(false);
  1585.     return 0;
  1586. };
  1587.  
  1588. int giveweaponped(lua_State* L) {// Дать оружие педу.
  1589.     try {
  1590.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  1591.             if (LUA_TNUMBER == lua_type(L, 2) && (LUA_TNUMBER == lua_type(L, 3)) && (LUA_TNUMBER == lua_type(L, 4))) {
  1592.  
  1593.                 const void* p = lua_topointer(L, 1);
  1594.                 CPed* ped = findpedinpool(p);// получить указатель на педа.
  1595.  
  1596.                 unsigned int model = lua_tointeger(L, 2);// модель оружие.
  1597.                 unsigned int WEAPONTYPE = lua_tointeger(L, 3);// тип оружи.
  1598.                 int ammo = lua_tointeger(L, 4);// число патронов.
  1599.  
  1600.                 CPed* player = FindPlayerPed();// найти педа
  1601.                 if (ped == player) { Command<COMMAND_GIVE_WEAPON_TO_PLAYER>(CWorld::PlayerInFocus, WEAPONTYPE, ammo); }
  1602.                 else {
  1603.                     Command<COMMAND_GIVE_WEAPON_TO_CHAR>(CPools::GetPedRef(ped), WEAPONTYPE, ammo);// Дать оружие педу.
  1604.                 }
  1605.             }
  1606.             else { throw "bad argument in function giveweaponped option weapons"; }
  1607.         }
  1608.         else { throw "bad argument in function giveweaponped option of the player"; }
  1609.     }
  1610.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1611.     return 0;
  1612. };
  1613.  
  1614. int kill_ped_on_foot(lua_State* L) {
  1615.     try {
  1616.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2)) {//указатель на педа.
  1617.  
  1618.             const void* p = lua_topointer(L, 1);
  1619.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  1620.             const void* p1 = lua_topointer(L, 2);
  1621.             CPed* ped1 = findpedinpool(p1);//  получить указатель на педа.
  1622.             ped->SetObjective(OBJECTIVE_KILL_CHAR_ON_FOOT, ped1);
  1623.         }
  1624.         else { throw "bad argument in function kill_ped_on_foot option of the player"; }
  1625.     }
  1626.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1627.     return 0;
  1628. };
  1629.  
  1630. int kill_char_any_means(lua_State* L) {
  1631.     try {
  1632.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2)) {//указатель на педа.
  1633.  
  1634.             const void* p = lua_topointer(L, 1);
  1635.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  1636.             const void* p1 = lua_topointer(L, 2);
  1637.             CPed* ped1 = findpedinpool(p1);//  получить указатель на педа.
  1638.             ped->SetObjective(OBJECTIVE_KILL_CHAR_ANY_MEANS, ped1);
  1639.         }
  1640.         else { throw "bad argument in function kill_char_any_means option of the ped"; }
  1641.     }
  1642.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1643.     return 0;
  1644. };
  1645.  
  1646. int ped_aim_at_ped(lua_State* L) {//Пед целиться в педа.
  1647.     try {
  1648.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2)) {// указатель на педа.
  1649.  
  1650.             const void* p = lua_topointer(L, 1);
  1651.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1652.             const void* p1 = lua_topointer(L, 2);
  1653.             CPed* ped2 = findpedinpool(p1);// получить указатель на педа.
  1654.             ped->SetObjective(OBJECTIVE_AIM_GUN_AT, ped2);// заставить педа целиться в другого педа.
  1655.             return 0;
  1656.         }
  1657.         else { throw "bad argument in function ped_aim_at_ped option of the ped"; }
  1658.     }
  1659.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1660.     return 0;
  1661. };
  1662.  
  1663. int is_current_weapon_ped(lua_State* L) {
  1664.     try {
  1665.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  1666.  
  1667.             const void* p = lua_topointer(L, 1);
  1668.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1669.             CPed* player = FindPlayerPed();// найти педа
  1670.             int weapon_type = lua_tointeger(L, 2);// тип оружие.
  1671.  
  1672.             if (ped != player) {
  1673.                 bool charweapontype = Command<COMMAND_IS_CURRENT_CHAR_WEAPON>(CPools::GetPedRef(ped), weapon_type);
  1674.                 lua_pushboolean(L, charweapontype);
  1675.                 return 1;
  1676.             }
  1677.             else {
  1678.                 bool playerweapontype = Command<COMMAND_IS_CURRENT_PLAYER_WEAPON>(CWorld::PlayerInFocus, weapon_type);
  1679.                 lua_pushboolean(L, playerweapontype);// отправить булевое значение сравнением с текущим оружие педа.
  1680.                 return 1;
  1681.             }
  1682.         }
  1683.         else { throw "bad argument in function is_current_weapon_ped"; }
  1684.     }
  1685.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1686.     return 0;
  1687. };
  1688.  
  1689. int create_sphere(lua_State* L) {//создать сферу.
  1690.     try {
  1691.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) &&
  1692.             LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 4)) {
  1693.             float x = lua_tonumber(L, 1);  float y = lua_tonumber(L, 2);
  1694.             float z = lua_tonumber(L, 3);  float radius = lua_tonumber(L, 4);// радиус.
  1695.             int sphere;// переменная, которая хранить id сферы.  
  1696.             CVector pos = { x, y, z };
  1697.             Command<COMMAND_ADD_SPHERE>(pos.x, pos.y, pos.z, radius, &sphere); //создать, удалить, создать сферу  
  1698.             Command<COMMAND_REMOVE_SPHERE>(sphere);// нужно, чтобы обойти глюк.
  1699.             Command<COMMAND_ADD_SPHERE>(pos.x, pos.y, pos.z, radius, &sphere);  //lua_settop(L, 0);// очистить стек.
  1700.             spheres.emplace(sphere, L);
  1701.             lua_pushinteger(L, sphere);// отправить id сферы в стек.  
  1702.             return 1;
  1703.         }
  1704.         else { throw "bad argument in function create_sphere "; }
  1705.     }
  1706.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1707.     return 0;
  1708. };
  1709.  
  1710. int create_money_pickup(lua_State* L) {//создать пачку денег.
  1711.     try {
  1712.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) &&
  1713.             LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 4)) {
  1714.             int money = lua_tointeger(L, 1); // количество денег в пикапе
  1715.             float x = lua_tonumber(L, 2);
  1716.             float y = lua_tonumber(L, 3); float z = lua_tonumber(L, 4);
  1717.             int idpickup;// переменная, которая хранить id пикапа денег.  
  1718.             CVector pos = { x, y, z };
  1719.             Command<COMMAND_CREATE_MONEY_PICKUP>(pos.x, pos.y, pos.z, money, &idpickup);
  1720.             pickupsids.emplace(idpickup, L);
  1721.             lua_pushinteger(L, idpickup);// отправить id пикапа в стек.  
  1722.             return 1;
  1723.         }
  1724.         else { throw "bad argument in function create_money_pickup"; }
  1725.     }
  1726.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1727.     return 0;
  1728. };
  1729.  
  1730. int create_weapon_pickup(lua_State* L) {//создать пикап оружие.
  1731.     try {
  1732.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  1733.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5) && LUA_TNUMBER == lua_type(L, 6)) {
  1734.             int model = lua_tointeger(L, 1);// модель оружие.
  1735.             int type = lua_tointeger(L, 2);// тип пикапа.
  1736.             int ammo = lua_tointeger(L, 3); // начальное кол-во патронов в оружие.
  1737.             float x = lua_tonumber(L, 4);
  1738.             float y = lua_tonumber(L, 5); float z = lua_tonumber(L, 6);
  1739.             int idpickup;// переменная, которая хранить id пикапа.  
  1740.             CVector pos = { x, y, z };
  1741.             Command<COMMAND_CREATE_PICKUP_WITH_AMMO>(model, type, ammo, pos.x, pos.y, pos.z, &idpickup);
  1742.             pickupsids.emplace(idpickup, L);// добавить в map пикапов.
  1743.             lua_pushinteger(L, idpickup);// отправить id пикапа в стек.  
  1744.             return 1;
  1745.         }
  1746.         else { throw "bad argument in function create_weapon_pickup"; }
  1747.     }
  1748.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1749.     return 0;
  1750. };
  1751.  
  1752. int create_pickup(lua_State* L) {//создать пикап.
  1753.     try {
  1754.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  1755.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5)) {
  1756.  
  1757.             int model = lua_tointeger(L, 1); // модель пикапа.
  1758.             int type = lua_tointeger(L, 2);// тип пикапа.
  1759.             float x = lua_tonumber(L, 3);   float y = lua_tonumber(L, 4);
  1760.             float z = lua_tonumber(L, 5);
  1761.             int idpickup;// переменная, которая хранить id пикапа.  
  1762.             CVector pos = { x, y, z };
  1763.             Command<COMMAND_CREATE_PICKUP>(model, type, pos.x, pos.y, pos.z, &idpickup);
  1764.             pickupsids.emplace(idpickup, L);// добавить в map пикапов.
  1765.             lua_pushinteger(L, idpickup);// отправить id пикапа в стек.  
  1766.             return 1;
  1767.         }
  1768.         else { throw "bad argument in function create_weapon_pickup"; }
  1769.     }
  1770.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1771.     return 0;
  1772. };
  1773.  
  1774. int remove_sphere(lua_State* L) {// удалить сферу.
  1775.     try {
  1776.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  1777.             int sphere = lua_tointeger(L, 1);
  1778.             Command<COMMAND_REMOVE_SPHERE>(sphere);// удалить сферу.
  1779.             return 0;
  1780.         }
  1781.         else { throw "bad argument in function remove_sphere"; }
  1782.     }
  1783.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1784.     return 0;
  1785. };
  1786.  
  1787. int picked_up(lua_State* L) {// проверка пикап подобран.
  1788.     try {
  1789.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение id пикапа.
  1790.             int pickup = lua_tointeger(L, 1);
  1791.             bool checkpickup = Command<COMMAND_HAS_PICKUP_BEEN_COLLECTED>(pickup);
  1792.             lua_pushboolean(L, checkpickup);
  1793.             return 1;
  1794.         }
  1795.         else { throw "bad argument in function picked_up"; }
  1796.     }
  1797.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1798.     return 0;
  1799. };
  1800.  
  1801. int remove_pickup(lua_State* L) {// удалить пикап.
  1802.     try {
  1803.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение id пикапа.
  1804.             int pickup = lua_tointeger(L, 1);
  1805.             Command<COMMAND_REMOVE_PICKUP>(pickup);// удалить пикап.
  1806.             return 0;
  1807.         }
  1808.         else { throw "bad argument in function remove_pickup"; }
  1809.     }
  1810.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1811.     return 0;
  1812. };
  1813.  
  1814. int remove_car(lua_State* L) {// удалить авто.
  1815.     try {
  1816.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  1817.  
  1818.             const void* p = lua_topointer(L, 1);
  1819.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  1820.  
  1821.             Command<COMMAND_MARK_CAR_AS_NO_LONGER_NEEDED>(CPools::GetVehicleRef(car));// удалить авто.
  1822.             return 0;
  1823.         }
  1824.         else { throw "bad argument in function remove_car"; }
  1825.     }
  1826.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1827.     return 0;
  1828. };
  1829.  
  1830. int remove_obj(lua_State* L) {// удалить объект.
  1831.     try {
  1832.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// значение объект.
  1833.             const void* p = lua_topointer(L, 1);
  1834.             CObject* obj = findobjinpool(p);// получить указатель на объект.
  1835.             if (obj != NULL) {//obj->Remove();
  1836.                 Command<COMMAND_DELETE_OBJECT>(CPools::GetObjectRef(obj));// удалить объект.
  1837.             }
  1838.             return 0;
  1839.         }
  1840.         else { throw "bad argument in function remove_obj"; }
  1841.     }
  1842.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1843.     return 0;
  1844. };
  1845.  
  1846. int car_in_water(lua_State* L) {// проверка авто в воде.
  1847.     try {
  1848.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  1849.  
  1850.             const void* p = lua_topointer(L, 1);
  1851.             CVehicle* car = findcarinpool(p); // получить указатель на авто.
  1852.  
  1853.             bool check_in_wanter = Command<COMMAND_IS_CAR_IN_WATER>(CPools::GetVehicleRef(car));
  1854.             lua_pushboolean(L, check_in_wanter);
  1855.             return 1;
  1856.         }
  1857.         else { throw "bad argument in function car_in_water"; }
  1858.     }
  1859.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1860.     return 0;
  1861. };
  1862.  
  1863. int set_wanted(lua_State* L) {// уcтановить уровень розыска.
  1864.     try {
  1865.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  1866.             int wanted = lua_tointeger(L, 1);// кол-во звезд розыска.
  1867.             Command<COMMAND_SET_MAX_WANTED_LEVEL>(wanted);
  1868.  
  1869.             CPlayerPed& player1 = *FindPlayerPed();
  1870.             player1.SetWantedLevel(wanted);
  1871.             player1.SetWantedLevelNoDrop(wanted);
  1872.             return 0;
  1873.         }
  1874.         else { throw "bad argument in function set_wanted"; }
  1875.     }
  1876.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1877.     return 0;
  1878. };
  1879.  
  1880. int set_widescreen(lua_State* L) {// вкл/выкл широкий экран.
  1881.     try {
  1882.         if (LUA_TBOOLEAN == lua_type(L, 1)) {// значение булевое.
  1883.             bool switc = lua_toboolean(L, 1);//
  1884.             Command<COMMAND_SWITCH_WIDESCREEN>(switc);
  1885.             return 0;
  1886.         }
  1887.         else { throw "bad argument in function set_widescreen"; }
  1888.     }
  1889.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1890.     return 0;
  1891. };
  1892.  
  1893. int is_wanted_level(lua_State* L) {// проверить уровень розыска.
  1894.     static int delay = 0;
  1895.     try {
  1896.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  1897.             int wanted = lua_tointeger(L, 1); wanted--;
  1898.             if (delay == 0) {
  1899.                 delay = iters;
  1900.                 lua_pushboolean(L, false);
  1901.                 return 1;
  1902.             }
  1903.             else {
  1904.                 if (iters - delay > 5) {
  1905.                     delay = 0;
  1906.                     lua_pushboolean(L, Command<COMMAND_IS_WANTED_LEVEL_GREATER>(CWorld::PlayerInFocus, wanted));
  1907.                     return 1;
  1908.                 }
  1909.             }
  1910.         }
  1911.         else { throw "bad argument in function is_wanted_level"; }
  1912.     }
  1913.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1914.  
  1915.     return 0;
  1916. };
  1917.  
  1918. int wanted_level(lua_State* L) {// получить уровень розыска.
  1919.  
  1920.     CPlayerPed& player1 = *FindPlayerPed();
  1921.     int wanted = player1.GetWantedLevel();
  1922.     lua_pushinteger(L, wanted);
  1923.     return 1;
  1924. };
  1925.  
  1926. int clear_wanted(lua_State* L) {// убрать уровень розыска.
  1927.     CPlayerPed& player1 = *FindPlayerPed();
  1928.     player1.SetWantedLevel(0);
  1929.     //Command<COMMAND_CLEAR_WANTED_LEVEL>(CWorld::PlayerInFocus);
  1930.     return 0;
  1931. };
  1932.  
  1933. int remove_ped(lua_State* L) {// удалить педа.
  1934.     try {
  1935.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  1936.  
  1937.             const void* p = lua_topointer(L, 1);
  1938.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1939.             ped->ClearInvestigateEvent();// пед уходит, опустить педа.
  1940.             Command<COMMAND_MARK_CHAR_AS_NO_LONGER_NEEDED>(CPools::GetPedRef(ped));// удалить педа.
  1941.             return 0;
  1942.         }
  1943.         else { throw "bad argument in function remove_ped"; }
  1944.     }
  1945.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1946.     return 0;
  1947. };
  1948.  
  1949. int remove_spec_ped(lua_State* L) {// удалить спец педа.
  1950.     try {
  1951.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение пед.
  1952.  
  1953.             int idped = lua_tointeger(L, 1);
  1954.             CStreaming::SetMissionDoesntRequireSpecialChar(idped); // 0296: unload_special_actor 21
  1955.             return 0;
  1956.         }
  1957.         else { throw "bad argument in function remove_spec_ped"; }
  1958.     }
  1959.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1960.     return 0;
  1961. };
  1962.  
  1963. int kill_ped(lua_State* L) {// убить педа.
  1964.     try {
  1965.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// значение число.
  1966.  
  1967.             const void* p = lua_topointer(L, 1);
  1968.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1969.             Command<COMMAND_EXPLODE_CHAR_HEAD>(CPools::GetPedRef(ped));// убить педа.
  1970.             return 0;
  1971.         }
  1972.         else { throw "bad argument in function kill_ped"; }
  1973.     }
  1974.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  1975.     return 0;
  1976. };
  1977.  
  1978. int setpedcoordes(lua_State* L) {// установить координаты для педа.
  1979.     try {
  1980.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  1981.             && LUA_TNUMBER == lua_type(L, 4)) {//число.
  1982.  
  1983.             const void* p = lua_topointer(L, 1);
  1984.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  1985.  
  1986.             float x = lua_tonumber(L, 2);
  1987.             float y = lua_tonumber(L, 3);
  1988.             float z = lua_tonumber(L, 4);
  1989.             CPed* player = FindPlayerPed();// найти педа  
  1990.             if (ped != player) {
  1991.                 Command<COMMAND_SET_CHAR_COORDINATES>(CPools::GetPedRef(ped), x, y, z);
  1992.                 return 0;
  1993.             }
  1994.             else {
  1995.                 Command<COMMAND_SET_PLAYER_COORDINATES>(CWorld::PlayerInFocus, x, y, z);
  1996.                 return 0;
  1997.             }
  1998.         }
  1999.         else { throw "bad argument in function setpedcoordes"; }
  2000.     }
  2001.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2002.     return 0;
  2003. };
  2004.  
  2005. int create_marker_obj(lua_State* L) {//создать маркер над объектом.
  2006.     int marker;// id маркера.
  2007.     try {
  2008.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на объект.
  2009.             const void* p = lua_topointer(L, 1);
  2010.             CObject* obj = findobjinpool(p);// получить указатель на педа.
  2011.  
  2012.             Command<COMMAND_ADD_BLIP_FOR_OBJECT>(CPools::GetObjectRef(obj), &marker);//создать маркер над объектом.
  2013.             markeron.emplace(marker, L);// добавить в map для маркеров.
  2014.             lua_pushinteger(L, marker);// отправить в стек.  
  2015.             return 1;
  2016.         }
  2017.         else { throw "bad argument in function create_marker_obj"; }
  2018.     }
  2019.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2020.     return 0;
  2021. };
  2022.  
  2023. int move_obj(lua_State* L) {//двигать объект.
  2024.     try {
  2025.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  2026.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5) && LUA_TNUMBER == lua_type(L, 6)
  2027.             && LUA_TNUMBER == lua_type(L, 7) && LUA_TNUMBER == lua_type(L, 8)) {// указатель на объект.
  2028.             const void* p = lua_topointer(L, 1);
  2029.             CObject* obj = findobjinpool(p);// получить указатель на объект.
  2030.             float x = lua_tonumber(L, 2); float y = lua_tonumber(L, 3);
  2031.             float z = lua_tonumber(L, 4);
  2032.             float speedx = lua_tonumber(L, 5);//
  2033.             float speedy = lua_tonumber(L, 6);// скорости по осам.
  2034.             float speedz = lua_tonumber(L, 7);//
  2035.             int collision_check = lua_tointeger(L, 8);// вкл/выкл коллизию объекта.
  2036.             Command<COMMAND_SLIDE_OBJECT>(CPools::GetObjectRef(obj), x, y, z, speedx, speedy, speedz, collision_check);
  2037.  
  2038.             return 0;
  2039.         }
  2040.         else { throw "bad argument in function move_obj"; }
  2041.     }
  2042.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2043.     return 0;
  2044. };
  2045.  
  2046. int move_rotate(lua_State* L) {//вращать объект.
  2047.     try {
  2048.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на объект.
  2049.             lua_settop(L, 4);
  2050.  
  2051.             const void* p = lua_topointer(L, 1);
  2052.             CObject* obj = findobjinpool(p);// получить указатель на педа.
  2053.             float Angle1 = lua_tonumber(L, 2); float Angle2 = lua_tonumber(L, 3);// углы вращения объекта.
  2054.             int flag = lua_tointeger(L, 4);
  2055.             Command<COMMAND_ROTATE_OBJECT>(CPools::GetObjectRef(obj), Angle1, Angle1, flag);
  2056.  
  2057.             lua_settop(L, 0);
  2058.             return 0;
  2059.         }
  2060.         else { throw "bad argument in function move_obj"; }
  2061.     }
  2062.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2063.     return 0;
  2064. };
  2065.  
  2066. int getobjcoordes(lua_State* L) {// получить координаты объекта.
  2067.     try {
  2068.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  2069.  
  2070.             const void* p = lua_topointer(L, 1);
  2071.             CObject* obj = findobjinpool(p);// получить указатель на объект.
  2072.  
  2073.             lua_pushnumber(L, obj->GetPosition().x);// отправить в стек.
  2074.             lua_pushnumber(L, obj->GetPosition().y);// отправить в стек.
  2075.             lua_pushnumber(L, obj->GetPosition().z);// отправить в стек.
  2076.             return 3;
  2077.         }// получить координаты автоа.
  2078.  
  2079.         else { throw "bad argument in function getcarcoordes"; }
  2080.     }
  2081.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2082. };
  2083.  
  2084. int getobjcoordinates_on_x(lua_State* L) {// Получить мировую координату по x для объекта.
  2085.     try {
  2086.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на объекта.
  2087.  
  2088.             const void* p = lua_topointer(L, 1);
  2089.             CObject* obj = findobjinpool(p);// получить указатель на объект.
  2090.  
  2091.             float x = lua_tonumber(L, 2);
  2092.             CVector pos = obj->m_placement.pos;
  2093.             pos += obj->m_placement.right * x;
  2094.             lua_pushnumber(L, pos.x); lua_pushnumber(L, pos.y); lua_pushnumber(L, pos.z);
  2095.             return 3;
  2096.         }
  2097.         else { throw "bad argument in function getobjcoordinates_on_x"; }
  2098.     }
  2099.     catch (const char* x) {
  2100.         writelog(x);
  2101.     }
  2102. };
  2103.  
  2104. int getobjcoordinates_on_y(lua_State* L) {// Получить мировую координату по y для объекта.
  2105.     try {
  2106.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на объект.
  2107.  
  2108.             const void* p = lua_topointer(L, 1);
  2109.             CObject* obj = findobjinpool(p);// получить указатель на объект.
  2110.  
  2111.             float y = lua_tonumber(L, 2);
  2112.             CVector pos = obj->m_placement.pos;
  2113.             pos += obj->m_placement.up * y; lua_pushnumber(L, pos.x);
  2114.             lua_pushnumber(L, pos.y);   lua_pushnumber(L, pos.z);
  2115.             return 3;
  2116.         }
  2117.         else { throw "bad argument in function getobjcoordinates_on_y"; }
  2118.     }
  2119.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2120. };
  2121.  
  2122. int ped_in_point_in_radius(lua_State* L) {// проверить находится пед в координатах с радиусом.   
  2123.     static int delay = 0;
  2124.     try {
  2125.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  2126.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5) && LUA_TNUMBER == lua_type(L, 6)
  2127.             && LUA_TNUMBER == lua_type(L, 6)) {//строка.
  2128.  
  2129.             const void* p = lua_topointer(L, 1);
  2130.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  2131.  
  2132.             float x1 = lua_tonumber(L, 2);  float y1 = lua_tonumber(L, 3);  float z1 = lua_tonumber(L, 4);
  2133.             float rx = lua_tonumber(L, 5);  float ry = lua_tonumber(L, 6);  float rz = lua_tonumber(L, 7);
  2134.  
  2135.             this_thread::sleep_for(chrono::milliseconds(10));
  2136.             double x = ped->GetPosition().x;
  2137.             double y = ped->GetPosition().y;
  2138.             double z = ped->GetPosition().z;
  2139.             double r2 = rx * rx + ry * ry + rz * rz;
  2140.             x = x - x1; y = y - y1; z = z - z1;
  2141.             double res = x * x + y * y + z * z;
  2142.             if (res < r2) {
  2143.  
  2144.                 lua_pushboolean(L, true);
  2145.                 return 1;
  2146.             }
  2147.             else {
  2148.                 lua_pushboolean(L, false);
  2149.                 return 1;
  2150.             }
  2151.         }
  2152.         else { throw "bad argument in function ped_in_point_in_radius"; }
  2153.     }
  2154.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2155.     return 0;
  2156. };
  2157.  
  2158. int car_in_point_in_radius(lua_State* L) {// проверить находится авто в координатах с радиусом.
  2159.     try {
  2160.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  2161.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5)) {//строка.
  2162.  
  2163.             const void* p = lua_topointer(L, 1);
  2164.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2165.  
  2166.             float x = lua_tonumber(L, 2);
  2167.             float y = lua_tonumber(L, 3);
  2168.             float z = lua_tonumber(L, 4);
  2169.             float radius = lua_tonumber(L, 5);// радиус.      //lua_pop(L, lua_gettop(L));
  2170.             lua_pushboolean(L, car->IsSphereTouchingVehicle(x, y, z, radius));      //lua_pushboolean(L, Command<COMMAND_LOCATE_CAR_3D>(CPools::GetVehicleRef(car), x, y, z, rx, ry, rz));
  2171.             return 1;
  2172.         }
  2173.         else { throw "bad argument in function car_in_point_in_radius"; }
  2174.     }
  2175.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2176.     return 0;
  2177. };
  2178.  
  2179. void dellod() {// удалить лог ошибок.
  2180.     string path = "lualoader\\log.txt";
  2181.     fstream f1; {f1.open(path, fstream::in | fstream::out | fstream::app);
  2182.     if (f1.is_open()) {// если файл есть удалить.
  2183.         f1.close(); remove("lualoader\\log.txt");
  2184.     }
  2185.     }
  2186. };
  2187.  
  2188. int cleanstl() {//удаления объектов из всех stl.
  2189.     if (!markeron.empty()) {// если не пусть.
  2190.         markeron.clear();// маркеры
  2191.     }
  2192.     if (!spheres.empty()) {// если не пусть.
  2193.         spheres.clear();// сферы.
  2194.     }
  2195.     if (!pickupsids.empty()) {// если не пусть.
  2196.         pickupsids.clear();//пикапы.
  2197.     }
  2198.     if (!firesids.empty()) {// если не пусть.
  2199.         firesids.clear();//огонь.
  2200.     }
  2201.     if (!mapcars.empty()) {// если не пусть.
  2202.         mapcars.clear();//авто.
  2203.     }
  2204.     if (!mapobjs.empty()) {// если не пусть.
  2205.         mapobjs.clear();//объект.
  2206.     }
  2207.  
  2208.     return 0;
  2209. };
  2210.  
  2211. int getflagmission(lua_State* L) {// проверка флага миссии.
  2212.     unsigned int& OnAMissionFlag = *(unsigned int*)0x978748;
  2213.     bool getflagmission = (CTheScripts::ScriptSpace[OnAMissionFlag]);
  2214.     lua_pushboolean(L, getflagmission);// получить флаг миссии.
  2215.     return 1;
  2216. };
  2217.  
  2218. int setflagmission(lua_State* L) {// уcтановить флага миссии.
  2219.     unsigned int& OnAMissionFlag = *(unsigned int*)0x978748;
  2220.     try {
  2221.         if (LUA_TBOOLEAN == lua_type(L, 1)) {// значение число.
  2222.             bool flag = lua_toboolean(L, 1);
  2223.             CTheScripts::ScriptSpace[OnAMissionFlag] = flag;
  2224.             return 0;
  2225.         }
  2226.         else { throw "bad argument in function setflagmission"; }
  2227.     }
  2228.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2229.     return 0;
  2230. };
  2231.  
  2232. int showtext(lua_State* L) {// Вывод особого текста на экран.
  2233.     try {
  2234.         if (LUA_TSTRING == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)) {//строка.
  2235.             const char* c = lua_tostring(L, 1);
  2236.             int time = lua_tointeger(L, 2);// время вывода текста.
  2237.             int style = lua_tointeger(L, 3);// стиль текста.
  2238.             wchar_t* str = getwchat(c);
  2239.             CMessages::AddBigMessage(str, time, style);/*0 большими, розовые как миссии пройдена,
  2240.             1 надпись как названия миссии, 2 зеленым большими*/
  2241.             return 0;
  2242.         }
  2243.         else { throw "bad argument in function showtext"; }
  2244.     }
  2245.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2246.     return 0;
  2247. };
  2248.  
  2249. int remove_blip(lua_State* L) {// удалить метку с карты.
  2250.     try {
  2251.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  2252.             int blip = lua_tointeger(L, 1);// получить id метки.
  2253.             Command<COMMAND_REMOVE_BLIP>(blip);// удалить метку на карте.
  2254.             map<int, lua_State*>::iterator it;
  2255.  
  2256.             for (auto it = markeron.begin(); it != markeron.end(); ++it) {
  2257.                 if (L == it->second && blip== it->first) {
  2258.                     markeron.erase(blip);
  2259.                 }
  2260.             }
  2261.  
  2262.             return 0;
  2263.         }
  2264.         else { throw "bad argument in function remove_blip"; }
  2265.     }
  2266.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2267.     return 0;
  2268. };
  2269.  
  2270. int createblip(lua_State* L) {// создать метку карте.
  2271.     try {
  2272.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) &&
  2273.             LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 4)) {// значение число.
  2274.             int point;// id метке.
  2275.             int t = lua_tointeger(L, 1);// id метки на карте.
  2276.             float x = lua_tonumber(L, 2); float y = lua_tonumber(L, 3);
  2277.             float z = lua_tonumber(L, 4); CVector p = { x, y, z };
  2278.             Command<COMMAND_ADD_SHORT_RANGE_SPRITE_BLIP_FOR_CONTACT_POINT>(p.x, p.y, p.z, t, &point);
  2279.             lua_pushinteger(L, point);// отправить в стек и получить из стека можно
  2280.             markeron.emplace(point, L);// добавить в map для маркеров.
  2281.             return 1;
  2282.         }// int
  2283.  
  2284.         else { throw "bad argument in function createblip"; }
  2285.     }
  2286.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2287.     return 0;
  2288. };
  2289.  
  2290. int createmarker(lua_State* L) {// создать маркер на карте.
  2291.     try {
  2292.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  2293.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5)) {// значение число.
  2294.             int point; //id маркера.
  2295.             int t = lua_tointeger(L, 1);// тип маркер.
  2296.             int size = lua_tointeger(L, 2);// размер маркера на карте.
  2297.             float x = lua_tonumber(L, 3); float y = lua_tonumber(L, 4);
  2298.             float z = lua_tonumber(L, 5); CVector p = { x, y, z };
  2299.             Command<COMMAND_ADD_BLIP_FOR_COORD_OLD>(p.x, p.y, p.z, t, size, &point);
  2300.             markeron.emplace(point, L);// добавить в map для маркеров.
  2301.             lua_pushinteger(L, point);// отправить в стек и получить из стека можно
  2302.             return 1;
  2303.         }// int
  2304.  
  2305.         else { throw "bad argument in function createmarker"; }
  2306.     }
  2307.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2308.     return 0;
  2309. };
  2310.  
  2311. int play_sound(lua_State* L) {// проиграть мелодию.
  2312.     try {
  2313.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  2314.             int music = lua_tointeger(L, 1);// получить id мелодии.
  2315.             Command<COMMAND_PLAY_MISSION_PASSED_TUNE>(music);
  2316.             return 0;
  2317.         }
  2318.         else { throw "bad argument in function play_sound"; }
  2319.     }
  2320.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2321.     return 0;
  2322. };
  2323.  
  2324. int create_marker_pickup(lua_State* L) {// создать маркер над пикапом.
  2325.     try {
  2326.         int marker;//id маркера.
  2327.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  2328.             int pickup = lua_tointeger(L, 1);// получить id пикапа.
  2329.             Command<COMMAND_ADD_BLIP_FOR_PICKUP>(pickup, &marker);
  2330.             markeron.emplace(marker, L);// добавить в map для маркеров.
  2331.             lua_pushinteger(L, marker);// отправить в стек и получить из стека можно
  2332.             return 1;
  2333.         }
  2334.         else { throw "bad argument in function play_sound"; }
  2335.     }
  2336.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2337.     return 0;
  2338. };
  2339.  
  2340. int play_voice(lua_State* L) {// проиграть реплику педа.
  2341.     try {
  2342.         if (LUA_TSTRING == lua_type(L, 1)) {// значение число.
  2343.             const char* voice = lua_tostring(L, 1);
  2344.             Command<COMMAND_LOAD_MISSION_AUDIO>(1, voice);// загрузить реплику.
  2345.             while (true) {
  2346.                 this_thread::sleep_for(chrono::milliseconds(1));
  2347.                 if (Command<COMMAND_HAS_MISSION_AUDIO_LOADED>(1)) {
  2348.                     Command<COMMAND_PLAY_MISSION_AUDIO>(1);
  2349.                     if (Command<COMMAND_HAS_MISSION_AUDIO_FINISHED>(1)) {
  2350.                         Command<COMMAND_CLEAR_MISSION_AUDIO>(1);
  2351.                         break;
  2352.                     }
  2353.                 }
  2354.             }
  2355.             return 0;
  2356.         }
  2357.         else { throw "bad argument in function play_voice"; }
  2358.     }
  2359.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2360.     return 0;
  2361. };
  2362.  
  2363. int createped(lua_State* L) {// создать педа.
  2364.     try {
  2365.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  2366.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5)) {// значение число.
  2367.             int model = lua_tointeger(L, 1);// модель педа
  2368.             int type = lua_tointeger(L, 2);// тип педа.
  2369.             float x = lua_tonumber(L, 3); float y = lua_tonumber(L, 4); float z = lua_tonumber(L, 5);
  2370.             CVector pos = { x, y, z };
  2371.             CPed* ped = nullptr;
  2372.             Command<COMMAND_CREATE_CHAR>(type, model, pos.x, pos.y, pos.z, &ped);
  2373.             mappeds.emplace(ped, L);// добавить map для педов.
  2374.             lua_pushlightuserdata(L, ped);// отправить в стек и получить из стека можно.
  2375.             return 1;
  2376.         }// int
  2377.  
  2378.         else { throw "bad argument in function createped"; }
  2379.     }
  2380.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2381.     return 0;
  2382. };
  2383.  
  2384. void load_model_before_avalible(int model) {
  2385.     Command<COMMAND_LOAD_ALL_MODELS_NOW>(false);
  2386.     Command<COMMAND_REQUEST_MODEL>(model);
  2387.     Command<COMMAND_LOAD_ALL_MODELS_NOW>(false);
  2388.     while (!Command<COMMAND_HAS_MODEL_LOADED>(model)) {
  2389.         this_thread::sleep_for(chrono::milliseconds(1));// задержка
  2390.         Command<COMMAND_REQUEST_MODEL>(model);
  2391.     }
  2392. };
  2393.  
  2394. int create_spec_ped(lua_State* L) {// создать спец педа.
  2395.     try {
  2396.         if (LUA_TSTRING == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) &&
  2397.             LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 4)) {// значение число.
  2398.             //int idmodel = lua_tointeger(L, -7);// спец id пед.
  2399.             //int specmodel = lua_tointeger(L, -6);// модель педа.
  2400.             //int type = lua_tointeger(L, -5);// тип педа.
  2401.             //int slot  = lua_tointeger(L, -4);// слот педа.
  2402.             CPed* ped = NULL;
  2403.             char const* model = lua_tostring(L, 1);// модель, например, "sam".
  2404.             float x = lua_tonumber(L, 2); float y = lua_tonumber(L, 3);
  2405.             float z = lua_tonumber(L, 4);
  2406.             CVector pos = { x, y, z };
  2407.             int idped = 0;
  2408.             load_model_before_avalible(idped);
  2409.             Command<COMMAND_CREATE_CHAR>(4, idped, pos.x, pos.y, pos.z, &ped);
  2410.             //Command<COMMAND_CREATE_PLAYER>(0, pos.x, pos.y, pos.z, &ped);
  2411.            
  2412.             CPed* p = findpedinpool(ped);// получить указатель на педа.
  2413.  
  2414.             Command<COMMAND_MARK_MODEL_AS_NO_LONGER_NEEDED>(idped);
  2415.             mappeds.emplace(ped, L);// добавить map для педов.
  2416.  
  2417.  
  2418.             Command<COMMAND_LOAD_ALL_MODELS_NOW>(false);
  2419.             Command<COMMAND_UNDRESS_CHAR>(CPools::GetPedRef(p), model);
  2420.             Command<COMMAND_LOAD_ALL_MODELS_NOW>(false);
  2421.             Command<COMMAND_DRESS_CHAR>(CPools::GetPedRef(p));
  2422.             lua_pushlightuserdata(L, ped);// отправить в стек.
  2423.             return 1;
  2424.         }
  2425.         else { throw "bad argument in function create_spec_ped"; }
  2426.     }
  2427.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2428.     return 0;
  2429. };
  2430.  
  2431. int isped(lua_State* L) {// проверка это пед?.
  2432.     try {
  2433.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// значение число.
  2434.             const void* p = lua_topointer(L, 1);
  2435.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  2436.  
  2437.             if (ped != NULL) {
  2438.                 lua_pushboolean(L, true);
  2439.                 return 1;
  2440.             }
  2441.  
  2442.             else {
  2443.                 lua_pushboolean(L, false);
  2444.                 return 1;
  2445.             }
  2446.         }
  2447.         else { throw "bad argument in function isped"; }
  2448.     }
  2449.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2450.     return 0;
  2451. };
  2452.  
  2453. int isvehicle(lua_State* L) {// проверка это транспорт?.
  2454.     try {
  2455.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// значение число.
  2456.             const void* p = lua_topointer(L, 1);
  2457.             CVehicle* car = findcarinpool(p);// получить указатель на педа.
  2458.  
  2459.             if (car != NULL) {
  2460.                 lua_pushboolean(L, true);
  2461.                 return 1;
  2462.             }
  2463.  
  2464.             else {
  2465.                 lua_pushboolean(L, false);
  2466.                 return 1;
  2467.             }
  2468.  
  2469.         }
  2470.         else { throw "bad argument in function isvehicle"; }
  2471.     }
  2472.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2473.     return 0;
  2474. };
  2475.  
  2476. int isobject(lua_State* L) {// проверка это объект?.
  2477.     try {
  2478.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// значение число.
  2479.             const void* p = lua_topointer(L, 1);
  2480.             CObject* obj = findobjinpool(p);// получить указатель на объект.
  2481.  
  2482.             if (obj != NULL) {
  2483.                 lua_pushboolean(L, true);
  2484.                 return 1;
  2485.             }
  2486.  
  2487.             else {
  2488.                 lua_pushboolean(L, false);
  2489.                 return 1;
  2490.             }
  2491.         }
  2492.         else { throw "bad argument in function isobject"; }
  2493.     }
  2494.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2495.     return 0;
  2496. };
  2497.  
  2498. int fade(lua_State* L) {//затенение, просветления.
  2499.     try {
  2500.         if (LUA_TNUMBER == lua_type(L, 1) && (LUA_TNUMBER == lua_type(L, 2))) {
  2501.             int lihgt = lua_tointeger(L, 1);// Время.
  2502.             int time = lua_tointeger(L, 2);// свет = 1 тьма = 0.
  2503.             Command<COMMAND_DO_FADE>(time, lihgt);// затенение.
  2504.  
  2505.             //CCamera* cam;
  2506.             //cam = (CCamera*)0x7E4688;
  2507.             //cam->Fade(time, lihgt);// затенение.
  2508.             return 0;
  2509.         }
  2510.         else { throw "bad argument in function fade"; }
  2511.     }
  2512.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2513.     return 0;
  2514. };
  2515.  
  2516. int setsizemarker(lua_State* L) {// установить размер маркера.
  2517.     try {
  2518.         if (LUA_TNUMBER == lua_type(L, 1) && (LUA_TNUMBER == lua_type(L, 2))) {
  2519.             int marker = lua_tointeger(L, 1);// Время.
  2520.             int size = lua_tointeger(L, 2);// размер маркера.
  2521.             Command<COMMAND_CHANGE_BLIP_SCALE>(marker, size);
  2522.             return 0;
  2523.         }
  2524.         else { throw "bad argument in function setsizemarker"; }
  2525.     }
  2526.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2527.     return 0;
  2528. };
  2529.  
  2530. int sound_coordinate(lua_State* L) {// Проиграть звук в координатах
  2531.     try {
  2532.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) &&
  2533.             LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 4)) {// значение число.
  2534.  
  2535.             int sound = lua_tointeger(L, 1);// id звука.
  2536.             float x = lua_tonumber(L, 2); float y = lua_tonumber(L, 3);
  2537.             float z = lua_tonumber(L, 4);
  2538.             Command<COMMAND_ADD_ONE_OFF_SOUND>(x, y, z, sound);// Проиграть звук в координатах.  lua_settop(L, 0);
  2539.             return 0;
  2540.         }// int
  2541.  
  2542.         else { throw "bad argument in function sound_coordinate"; }
  2543.     }
  2544.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2545.     return 0;
  2546. };
  2547.  
  2548. int load_scene(lua_State* L) {// загрузить модели на координатах заранее.
  2549.     try {
  2550.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)
  2551.             && LUA_TNUMBER == lua_type(L, 3)) {// значение число.
  2552.  
  2553.             float x = lua_tonumber(L, 1); float y = lua_tonumber(L, 2);
  2554.             float z = lua_tonumber(L, 3);
  2555.             Command<COMMAND_LOAD_SCENE>(x, y, z);// загрузить область в координатах
  2556.             lua_settop(L, 0);
  2557.             return 0;
  2558.         }// int
  2559.  
  2560.         else { throw "bad argument in function load_scene"; }
  2561.     }
  2562.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2563.     return 0;
  2564. };
  2565.  
  2566. int show_text_styled(lua_State* L) {// вывести игровой текст.
  2567.     try {
  2568.         if (LUA_TSTRING == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)
  2569.             && LUA_TNUMBER == lua_type(L, 3)) {// значение число.
  2570.             const char* text = lua_tostring(L, 1);// текст.
  2571.             int time = lua_tointeger(L, 2); int type = lua_tointeger(L, 3);
  2572.             Command<COMMAND_PRINT_BIG>(text, time, type);// числа для старта гонки.
  2573.             lua_settop(L, 0);// очистить стек. 
  2574.             return 0;
  2575.         }
  2576.  
  2577.         else { throw "bad argument in function show_text_styled"; }
  2578.     }
  2579.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2580.     return 0;
  2581. };
  2582.  
  2583. int show_text_gtx(lua_State* L) {// вывести игровой текст.
  2584.     try {
  2585.         if (LUA_TSTRING == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)
  2586.             && LUA_TNUMBER == lua_type(L, 3)) {// значение число.
  2587.             const char* text = lua_tostring(L, 1);// текст.
  2588.             int time = lua_tointeger(L, 2); int type = lua_tointeger(L, 3);
  2589.             Command<COMMAND_LOAD_MISSION_TEXT>("GENERA1");
  2590.             Command<COMMAND_PRINT_NOW>(text, time, type);// числа для старта гонки.
  2591.             lua_settop(L, 0);// очистить стек. 
  2592.             return 0;
  2593.         }
  2594.  
  2595.         else { throw "bad argument in function show_text_gtx"; }
  2596.     }
  2597.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2598.     return 0;
  2599. };
  2600.  
  2601. int setcardrive(lua_State* L) {// установить водителя для авто.
  2602.     try {
  2603.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)) {//строка.
  2604.  
  2605.             const void* p = lua_topointer(L, 1);
  2606.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2607.  
  2608.             int model = lua_tointeger(L, 2);// модель педа.
  2609.             int type = lua_tointeger(L, 3);// тип педа.
  2610.             CPed* ped = nullptr;
  2611.             Command<COMMAND_CREATE_CHAR_INSIDE_CAR>(CPools::GetVehicleRef(car), type, model, &ped);
  2612.             car->m_autoPilot.m_nCarMission = MISSION_NONE;
  2613.             lua_pushlightuserdata(L, ped);// отправить в стек и получить из стека можно.
  2614.             return 1;
  2615.         }
  2616.         else { throw "bad argument in function setcardrive"; }
  2617.     }
  2618.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2619.     return 0;
  2620. };
  2621.  
  2622. int setcarpassenger(lua_State* L) {// установить пассажира для авто.
  2623.     try {
  2624.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)
  2625.             && LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 3)) {//число.
  2626.  
  2627.             const void* p = lua_topointer(L, 1);
  2628.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2629.  
  2630.             int model = lua_tointeger(L, 2);
  2631.             int type = lua_tointeger(L, 3);
  2632.             int place = lua_tointeger(L, 4);//место пассажира.
  2633.             CPed* ped = nullptr;
  2634.             Command<COMMAND_CREATE_CHAR_AS_PASSENGER>(CPools::GetVehicleRef(car), type, model, place, &ped);
  2635.             lua_pushlightuserdata(L, ped);
  2636.             return 1;
  2637.         }
  2638.         else { throw "bad argument in function setcarpassenger"; }
  2639.     }
  2640.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2641.     return 0;
  2642. };
  2643.  
  2644. int setcarfirstcolor(lua_State* L) {// установить первый цвет авто.
  2645.     try {
  2646.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {
  2647.  
  2648.             const void* p = lua_topointer(L, 1);
  2649.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2650.  
  2651.             int firstcolor = lua_tointeger(L, 2);
  2652.             car->m_nPrimaryColor = firstcolor;// установить первый цвет авто.
  2653.             return 0;
  2654.         }
  2655.         else { throw "bad argument in function setcarfirstcolor"; }
  2656.     }
  2657.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2658.     return 0;
  2659. };
  2660.  
  2661. int setcarseconscolor(lua_State* L) {// установить второй цвет авто.
  2662.     try {
  2663.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {
  2664.             const void* p = lua_topointer(L, 1);
  2665.  
  2666.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2667.             int secondcolor = lua_tointeger(L, 2);
  2668.             car->m_nSecondaryColor = secondcolor;
  2669.             return 0;
  2670.         }// установить второй цвет авто.
  2671.  
  2672.         else { throw "bad argument in function setcarseconscolor"; }
  2673.     }
  2674.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2675.     return 0;
  2676. };
  2677.  
  2678. int set_traffic(lua_State* L) {// установить плотноcть трафика транспорта.
  2679.     try {//01EB
  2680.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  2681.             float trafic = lua_tonumber(L, 1);
  2682.             Command<COMMAND_SET_CAR_DENSITY_MULTIPLIER>(trafic);
  2683.             return 0;
  2684.         }
  2685.         else { throw "bad argument in function set_traffic"; }
  2686.     }
  2687.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2688.     return 0;
  2689. };
  2690.  
  2691. int car_explode(lua_State* L) {// взрывать авто.
  2692.     try {
  2693.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  2694.  
  2695.             const void* p = lua_topointer(L, 1);
  2696.             CVehicle* car = findcarinpool(p);// получить указатель на авто.
  2697.  
  2698.             Command<COMMAND_EXPLODE_CAR>(CPools::GetVehicleRef(car));
  2699.             return 0;
  2700.         }
  2701.         else { throw "bad argument in function car_explode"; }
  2702.     }
  2703.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2704.     return 0;
  2705. };
  2706.  
  2707. int is_car_stopped(lua_State* L) {// авто остановилось?
  2708.     try {
  2709.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  2710.  
  2711.             const void* p = lua_topointer(L, 1);
  2712.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2713.  
  2714.             lua_pushboolean(L, Command<COMMAND_IS_CAR_STOPPED>(CPools::GetVehicleRef(car)));
  2715.             return 1;
  2716.         }
  2717.         else { throw "bad argument in function is_car_stopped"; }
  2718.     }
  2719.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2720.     return 0;
  2721. };
  2722.  
  2723. int setclock(lua_State* L) {// задать время.
  2724.     try {
  2725.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {//числа.
  2726.  
  2727.             int hours = lua_tointeger(L, 1);// часы.
  2728.             int minutes = lua_tointeger(L, 2);// минуты.
  2729.  
  2730.             CClock::SetGameClock(hours, minutes);// задать время.
  2731.             return 0;
  2732.         }
  2733.         else { throw "bad argument in function setclock"; }
  2734.     }
  2735.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2736.     return 0;
  2737. }
  2738.  
  2739. int create_explosion(lua_State* L) {// Создать взрыв на координатах.
  2740.     try {
  2741.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)
  2742.             && LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 1)) {// тип взрыва и координаты.
  2743.  
  2744.             int tipe = lua_tointeger(L, 1);// тип взрыва.
  2745.             double x = lua_tonumber(L, 2);
  2746.             double y = lua_tonumber(L, 3);
  2747.             double z = lua_tonumber(L, 4);
  2748.             /*
  2749.             0 Стандартный средний взрыв, используется чаще всего Highslide JS
  2750.             1 Взрыв как от коктейля Молотова. По-этому после него появлятся много огня и звук тихий. Следует также учитывать то, что именно этот взрыв визуально появляется вне зависимости высоты у самой земли. Highslide JS
  2751.             2 Похож на тип 0 Highslide JS
  2752.             3 Похож на тип 0 Highslide JS
  2753.             4 Один-три взрывных линий. Следует иметь в виду, что в типах 4 и 5 не звучит грохот взрыва. Так что комбинируйте этот тип с другими типами или создавайте звук отдельно опкодом 0565 (описан выше) Highslide JS
  2754.             5 Похоже на тип 4 Highslide JS
  2755.             6 Большой взрыв, один из самых больших Highslide JS
  2756.             7 Чуть покороче чем тип 6 Highslide JS
  2757.             8 Звука нет, эффекта нет, трясение камеры есть, здоровье отнимает. Highslide JS
  2758.             9 То же самое, что и тип 8 Highslide JS
  2759.             10 Наряду с типом 6 самый большой взрыв Highslide JS
  2760.             11 Как тип 0, но чуть пожиже Highslide JS
  2761.             12 Самый маленький взрыв, как от взрыва RC-машинки. Highslide JS
  2762.             13+ Тринадцатый и последующие типы, по-видимому, не поддерживаются игрой: взрывы без звука, без эффекта.
  2763.             */
  2764.             Command<COMMAND_ADD_EXPLOSION>(x, y, z, tipe);
  2765.             return 0;
  2766.         }
  2767.         else { throw "bad argument in function create_explosion"; }
  2768.     }
  2769.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2770.     return 0;
  2771. };
  2772.  
  2773. int set_status_engine(lua_State* L) {// установить состояние двигателя авто.
  2774.     try {
  2775.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {
  2776.  
  2777.             const void* p = lua_topointer(L, 1);
  2778.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2779.  
  2780.             int switcher = lua_tointeger(L, 2);
  2781.             Command<COMMAND_BOAT_STOP>(CPools::GetVehicleRef(car), switcher);//
  2782.             return 0;
  2783.         }//
  2784.  
  2785.         else { throw "bad argument in function set_status_engine"; }
  2786.     }
  2787.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2788.     return 0;
  2789. };
  2790.  
  2791. int player_defined(lua_State* L) {// пед существует.
  2792.     try {
  2793.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  2794.  
  2795.             const void* p = lua_topointer(L, 1);
  2796.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  2797.  
  2798.             float health = ped->m_fHealth;
  2799.             if (health > 1.0f) {
  2800.                 lua_pushboolean(L, true);
  2801.                 return 1;
  2802.             }
  2803.             else {
  2804.                 lua_pushboolean(L, false);
  2805.                 return 1;
  2806.             }
  2807.         }
  2808.         else { throw "bad argument in function player_defined"; }
  2809.     }
  2810.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2811.     return 0;
  2812. };
  2813.  
  2814. int follow_the_leader(lua_State* L) {// //01DE / 01DF следовать за лидером
  2815.     try {
  2816.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2)) {// указатель на педа.
  2817.  
  2818.             const void* p = lua_topointer(L, 1);
  2819.             CPed* ped = findpedinpool(p);//  получить указатель на авто.
  2820.             p = lua_topointer(L, 2);
  2821.             CPed* ped2 = findpedinpool(p);//  получить указатель на авто.
  2822.             ped->SetObjective(OBJECTIVE_SET_LEADER, ped2);
  2823.             return 0;
  2824.         }
  2825.         else { throw "bad argument in function follow_the_leader"; }
  2826.     }
  2827.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2828.     return 0;
  2829. };
  2830.  
  2831. int arrested(lua_State* L) { // пед арестован?
  2832.     if (CWorld::Players[CWorld::PlayerInFocus].m_nPlayerState == PLAYERSTATE_HASBEENARRESTED) {
  2833.         lua_pushboolean(L, true);
  2834.         return 1;
  2835.     }
  2836.     else {
  2837.         lua_pushboolean(L, false);
  2838.         return 1;
  2839.     }
  2840. };
  2841.  
  2842. int setcarcoordes(lua_State* L) {// установить координаты авто.
  2843.     try {
  2844.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  2845.             && LUA_TNUMBER == lua_type(L, 4)) {//число.
  2846.             const void* p = lua_topointer(L, 1);
  2847.             float x = lua_tonumber(L, 2);
  2848.             float y = lua_tonumber(L, 3);
  2849.             float z = lua_tonumber(L, 4);
  2850.  
  2851.             CVector pos = { x, y, z };
  2852.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2853.  
  2854.             Command<COMMAND_SET_CAR_COORDINATES>(CPools::GetVehicleRef(car), pos.x, pos.y, pos.z);// установить координаты авто.
  2855.         }
  2856.         else { throw "bad argument in function setcarcoordes"; }
  2857.     }
  2858.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2859.     return 0;
  2860. };
  2861.  
  2862. int is_car_stuck(lua_State* L) {//03CE: car 12@ stuck если машина застряла.
  2863.     try {
  2864.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  2865.  
  2866.             const void* p = lua_topointer(L, 1);
  2867.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2868.  
  2869.             bool check_car_stuck = Command<COMMAND_IS_CAR_STUCK>(CPools::GetVehicleRef(car));
  2870.             lua_pushboolean(L, check_car_stuck);
  2871.             return 1;
  2872.         }
  2873.         else { throw "bad argument in function is_car_stuck"; }
  2874.     }
  2875.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2876.     return 0;
  2877. };
  2878.  
  2879. int is_car_upsidedown(lua_State* L) {//01F4: car 12@ flipped если машина перевернута.
  2880.     try {
  2881.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// значение число.
  2882.  
  2883.             const void* p = lua_topointer(L, 1);
  2884.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2885.  
  2886.             bool check_car_upsidedown = Command<COMMAND_IS_CAR_UPSIDEDOWN>(CPools::GetVehicleRef(car));
  2887.             lua_pushboolean(L, check_car_upsidedown);
  2888.             return 1;
  2889.         }
  2890.         else { throw "bad argument in function is_car_upsidedown"; }
  2891.     }
  2892.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2893.     return 0;
  2894. };
  2895.  
  2896. int is_car_upright(lua_State* L) {// 020D: car 12@ flipped если указанный автомобиль перевернут.
  2897.     try {
  2898.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// значение число.
  2899.  
  2900.             const void* p = lua_topointer(L, 1);
  2901.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2902.  
  2903.             bool check_car_upright = Command<COMMAND_IS_CAR_UPRIGHT>(CPools::GetVehicleRef(car));
  2904.             lua_pushboolean(L, check_car_upright);
  2905.             return 1;
  2906.         }
  2907.         else { throw "bad argument in function is_car_upright"; }
  2908.     }
  2909.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2910.     return 0;
  2911. };
  2912.  
  2913. int find_road_for_car(lua_State* L) {// найти дорогу.
  2914.     try {
  2915.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)
  2916.             && LUA_TNUMBER == lua_type(L, 1)) {//число.
  2917.  
  2918.             float x1 = lua_tonumber(L, 1);
  2919.             float y1 = lua_tonumber(L, 2);
  2920.             float z1 = lua_tonumber(L, 3);
  2921.             float x, y, z;
  2922.             Command<COMMAND_GET_CLOSEST_CAR_NODE>(x1, y1, z1, &x, &y, &z);// найти дорогу.
  2923.             lua_pushnumber(L, x);   lua_pushnumber(L, y);   lua_pushnumber(L, z);
  2924.             return 3;
  2925.         }
  2926.         else { throw "bad argument in function find_road_for_car"; }
  2927.     }
  2928.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2929.     return 0;
  2930. };
  2931.  
  2932. int add_stuck_car_check(lua_State* L) {// условия для того, чтобы авто считалась застрявшей.
  2933.     try {
  2934.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)
  2935.             && LUA_TNUMBER == lua_type(L, 3)) {//число.
  2936.  
  2937.             const void* p = lua_topointer(L, 1);
  2938.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2939.             float distance = lua_tonumber(L, 2);// дистанция.
  2940.             int time = lua_tointeger(L, 3);// время.
  2941.             Command<COMMAND_ADD_STUCK_CAR_CHECK>(time, distance, CPools::GetVehicleRef(car));// условия для того, чтобы авто считалась застрявшей.
  2942.             return 0;
  2943.         }
  2944.         else { throw "bad argument in function add_stuck_car_check"; }
  2945.     }
  2946.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2947.     return 0;
  2948. };
  2949.  
  2950. int setcarstrong(lua_State* L) {// сделать авто устойчивым.
  2951.     try {
  2952.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {//указатель на авто.
  2953.  
  2954.             const void* p = lua_topointer(L, 1);
  2955.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  2956.  
  2957.             int value = lua_tointeger(L, 2);
  2958.             if (value == 1) {
  2959.                 Command<COMMAND_SET_CAR_STRONG>(CPools::GetVehicleRef(car), true);// авто устойчивое - да.
  2960.                 return 0;
  2961.             }
  2962.             if (value == 0) {
  2963.                 Command<COMMAND_SET_CAR_STRONG>(CPools::GetVehicleRef(car), false);// авто устойчивым - нет.
  2964.                 return 0;
  2965.             }
  2966.         }
  2967.         else { throw "bad argument in function setcarstrong"; }
  2968.     }
  2969.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  2970.     return 0;
  2971. };
  2972.  
  2973. int putincar(lua_State* L) {// переместить педа в авто.
  2974.     try {
  2975.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2)) {// указатели на педа и авто.
  2976.  
  2977.             const void* p = lua_topointer(L, 1);
  2978.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  2979.  
  2980.             const void* p1 = lua_topointer(L, 2);
  2981.             CVehicle* car = findcarinpool(p1);//  получить указатель на авто.
  2982.  
  2983.             float x = car->GetPosition().x; // отправить в стек.
  2984.             float y = car->GetPosition().y; // отправить в стек.
  2985.             float z = car->GetPosition().z; // отправить в стек.
  2986.             float angle = car->GetHeading();// получить угол авто
  2987.             ped->SetObjective(OBJECTIVE_ENTER_CAR_AS_DRIVER, car);
  2988.             ped->WarpPedIntoCar(car); // переместить педа в авто
  2989.             this_thread::sleep_for(chrono::milliseconds(20));
  2990.             Command<COMMAND_SET_CAR_COORDINATES>(CPools::GetVehicleRef(car), x, y, z);// установить координаты авто.
  2991.  
  2992.             Command<COMMAND_SET_CAR_HEADING>(CPools::GetVehicleRef(car), angle);
  2993.  
  2994.             //CPed* player = FindPlayerPed();// найти педа  
  2995.             //if (ped != player) {
  2996.             //  Command<COMMAND_WARP_CHAR_INTO_CAR>(CPools::GetPedRef(ped), CPools::GetVehicleRef(car));
  2997.             //  return 0;
  2998.             //}
  2999.             //else {
  3000.             //  Command<COMMAND_WARP_PLAYER_INTO_CAR>(CWorld::PlayerInFocus, CPools::GetVehicleRef(car));}
  3001.             return 0;
  3002.  
  3003.         }
  3004.         else { throw "bad argument in function putincar"; }
  3005.     }
  3006.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3007.     return 0;
  3008. };
  3009.  
  3010. int ped_attack_car(lua_State* L) {// пед атакует авто.
  3011.     try {
  3012.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2)) {// указатели на педа и авто.
  3013.  
  3014.             const void* p = lua_topointer(L, 1);
  3015.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  3016.  
  3017.             const void* p1 = lua_topointer(L, 2);
  3018.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  3019.  
  3020.             ped->SetObjective(OBJECTIVE_DESTROY_CAR, car); //уничтожить машину 01D9
  3021.             return 0;
  3022.  
  3023.         }
  3024.         else { throw "bad argument in function ped_attack_car"; }
  3025.     }
  3026.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3027.     return 0;
  3028. };
  3029.  
  3030. int checkcheat(lua_State* L) {//чит код введен?.
  3031.     try {
  3032.         if (LUA_TSTRING == lua_type(L, 1)) {// если строка
  3033.             string cheat = lua_tostring(L, 1);//
  3034.             if (-1 != cheatstr.find(cheat)) {
  3035.                 cheatstr.clear();
  3036.                 lua_pushboolean(L, true); cheatstr.erase(0, 1);
  3037.                 return 1;
  3038.             }
  3039.             else {
  3040.                 lua_pushboolean(L, false);
  3041.                 return 1;
  3042.             }
  3043.         }
  3044.         else { throw "bad argument in function getpedarmour option of the player"; }
  3045.     }
  3046.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3047.     return 0;
  3048. }
  3049.  
  3050.  
  3051. int star_timer(lua_State* L) {
  3052.     try {
  3053.         if (LUA_TSTRING == lua_type(L, 1)) {// если число
  3054.             const char* str = lua_tostring(L, 1);// строка.
  3055.             Command<COMMAND_DISPLAY_ONSCREEN_TIMER_WITH_STRING>(str);
  3056.             lua_pushstring(L, str);
  3057.             return 1;
  3058.         }
  3059.         else { throw "bad argument in function  star_timer"; }
  3060.     }
  3061.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3062.     return 0;
  3063. };
  3064.  
  3065. int stop_timer(lua_State* L) {// остановить таймер.
  3066.     try {
  3067.         if (LUA_TSTRING == lua_type(L, 1)) {// если число
  3068.             const char* str = lua_tostring(L, 1);// строка.
  3069.             static int timer = 13608;
  3070.             CUserDisplay::OnscnTimer.ClearClock(timer); //014F: stop_timer $3402
  3071.             Command<COMMAND_CLEAR_ONSCREEN_TIMER>(str);
  3072.             var_$3402 = 0;
  3073.             return 0;
  3074.         }
  3075.         else { throw "bad argument in function stop_timer"; }
  3076.     }
  3077.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3078.     return 0;
  3079. };
  3080.  
  3081. int timer_donw(lua_State* L) {// таймер на уменьшение.
  3082.     try {
  3083.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TSTRING == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)) {
  3084.             int time = lua_tointeger(L, 1);// если число
  3085.             const char* str1 = lua_tostring(L, 2);// строка.
  3086.             char* str = (char*)str1;
  3087.             var_$3402 = 1000 * time; //in CLEO $3402 = 120000
  3088.  
  3089.             int tipe = lua_tointeger(L, 3);// если число
  3090.             static int timer = 13608;
  3091.             CUserDisplay::OnscnTimer.AddClock(timer, str, tipe);
  3092.             return 0;
  3093.         }
  3094.         else { throw "bad argument in function timer_donw"; }
  3095.     }
  3096.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3097.     return 0;
  3098. };
  3099.  
  3100. int ped_frozen(lua_State* L) {// заморозить игpока.
  3101.     try {
  3102.         if (LUA_TNUMBER == lua_type(L, 1)) {
  3103.             int status = lua_tointeger(L, 1);// если число
  3104.  
  3105.             Command<COMMAND_SET_PLAYER_CONTROL>(CWorld::PlayerInFocus, status);
  3106.  
  3107.             return 0;
  3108.         }
  3109.         else { throw "bad argument in function timer_donw"; }
  3110.     }
  3111.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3112.     return 0;
  3113. };
  3114.  
  3115. int hold_cellphone(lua_State* L) {// поднять телефон.
  3116.     try {
  3117.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {
  3118.             const void* p = lua_topointer(L, 1);
  3119.  
  3120.             CPed* ped = findpedinpool(p);//  получить указатель на авто.
  3121.             int status = lua_tointeger(L, 2);// если число.
  3122.             Command<COMMAND_SET_CHAR_ANSWERING_MOBILE>(ped, status);
  3123.             return 0;
  3124.         }
  3125.         else { throw "bad argument in function hold_cellphone"; }
  3126.     }
  3127.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3128.     return 0;
  3129. };
  3130.  
  3131. int car_lastweapondamage(lua_State* L) {// номер оружие, которое нанесло урон авто.
  3132.     try {
  3133.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {//число.
  3134.             const void* p = lua_topointer(L, 1);
  3135.  
  3136.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  3137.             unsigned char c = car->m_nLastWeaponDamage;
  3138.  
  3139.             int d = (int)c;
  3140.             lua_pushinteger(L, d);
  3141.             return 1;
  3142.         }
  3143.         else { throw "bad argument in function car_lastweapondamage"; }
  3144.     }
  3145.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3146.     return 0;
  3147. };
  3148.  
  3149. int car_currentgear(lua_State* L) {// текущая передача авто.
  3150.     try {
  3151.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  3152.  
  3153.             const void* p = lua_topointer(L, 1);
  3154.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  3155.  
  3156.             unsigned char c = car->m_nCurrentGear;
  3157.             int d = (int)c;
  3158.             lua_pushinteger(L, d);
  3159.             return 1;
  3160.         }
  3161.         else { throw "bad argument in function car_currentgear"; }
  3162.     }
  3163.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3164.     return 0;
  3165. };
  3166.  
  3167. int getcar_model(lua_State* L) {// получить модель авто.
  3168.     try {
  3169.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {//число.
  3170.  
  3171.             const void* p = lua_topointer(L, -1);
  3172.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  3173.  
  3174.             unsigned char c = car->m_nModelIndex;
  3175.             int d = (int)c;
  3176.             lua_pushinteger(L, d);
  3177.             return 1;
  3178.         }
  3179.         else { throw "bad argument in function car_currentgear"; }
  3180.     }
  3181.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3182.     return 0;
  3183. };
  3184.  
  3185. int setcarsiren(lua_State* L) {// установить сирену для авто.
  3186.     try {
  3187.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {
  3188.  
  3189.             const void* p = lua_topointer(L, -1);
  3190.  
  3191.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  3192.  
  3193.             int tipe = lua_tointeger(L, 2);
  3194.             car->m_nSirenOrAlarm = tipe;
  3195.             //car->m_bSirenOrAlarm = tipe;
  3196.             return 0;
  3197.         }
  3198.         else { throw "bad argument in function setcarsiren"; }
  3199.     }
  3200.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3201.     return 0;
  3202. };
  3203.  
  3204. int ped_car_as_passenger(lua_State* L) {// пед садится в авто как пассажир.
  3205.     try {
  3206.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2)) {//число.
  3207.  
  3208.             const void* p = lua_topointer(L, 1);
  3209.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3210.  
  3211.             const void* p1 = lua_topointer(L, 2);
  3212.             CVehicle* car = findcarinpool(p1);//  получить указатель на авто.
  3213.  
  3214.             ped->SetObjective(OBJECTIVE_ENTER_CAR_AS_PASSENGER, car); //сьесть в машину. 01D9
  3215.             return 0;
  3216.  
  3217.         }
  3218.         else { throw "bad argument in function ped_car_as_passenger"; }
  3219.     }
  3220.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3221.     return 0;
  3222. };
  3223.  
  3224. int ped_car_as_driver(lua_State* L) {// пед садится в авто как водитель.
  3225.     try {
  3226.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2)) {//число.
  3227.  
  3228.             const void* p = lua_topointer(L, 1);
  3229.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  3230.  
  3231.             const void* p1 = lua_topointer(L, 2);
  3232.  
  3233.             CVehicle* car = findcarinpool(p1);//  получить указатель на авто.
  3234.             ped->SetObjective(OBJECTIVE_ENTER_CAR_AS_DRIVER, car); //пед садится в авто как водитель.
  3235.             return 0;
  3236.         }
  3237.         else { throw "bad argument in function ped_car_as_driver"; }
  3238.     }
  3239.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3240.     return 0;
  3241. };
  3242.  
  3243. int camera_at_point(lua_State* L) {//переместить камеру в координатах.
  3244.     try {
  3245.         if (LUA_TNUMBER == lua_type(L, -4) && LUA_TNUMBER == lua_type(L, -3) &&
  3246.             LUA_TNUMBER == lua_type(L, -2) && LUA_TNUMBER == lua_type(L, -1)) {
  3247.             float x = lua_tonumber(L, 1);  float y = lua_tonumber(L, 2);
  3248.             float z = lua_tonumber(L, 3);  int tipe = lua_tointeger(L, 4);
  3249.             CVector pos = { x, y, z };
  3250.  
  3251.             Command<COMMAND_POINT_CAMERA_AT_POINT>(pos.x, pos.y, pos.z, tipe); //  
  3252. /*          CCamera* cam;
  3253.             cam = (CCamera*)0x7E4688;
  3254.             cam->TakeControlNoEntity(pos, 1, tipe); */  //  POINT_CAMERA_AT_POINT  
  3255.             return 0;
  3256.         }
  3257.         else { throw "bad argument in function camera_at_point"; }
  3258.     }
  3259.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3260.     return 0;
  3261. };
  3262.  
  3263. int set_camera_position(lua_State* L) {//установить камеру в координатах.
  3264.     try {
  3265.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  3266.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5) && LUA_TNUMBER == lua_type(L, 6)) {
  3267.             float x = lua_tonumber(L, 1);  float y = lua_tonumber(L, 2);
  3268.             float z = lua_tonumber(L, 3);  float rx = lua_tonumber(L, 4);
  3269.             float ry = lua_tonumber(L, 5); float rz = lua_tonumber(L, 6);
  3270.             CVector pos = { x, y, z };
  3271.  
  3272.             CVector r = { rx, ry, rz };
  3273.             //Command<COMMAND_SET_FIXED_CAMERA_POSITION>(pos.x, pos.y, pos.z, rx, ry, rz); //  
  3274.             CCamera* cam;
  3275.             cam = (CCamera*)0x7E4688;
  3276.             cam->SetCamPositionForFixedMode(pos, r); // SET_FIXED_CAMERA_POSITION opcode_015F
  3277.             return 0;
  3278.         }
  3279.         else { throw "bad argument in function set_camera_position"; }
  3280.     }
  3281.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3282.     return 0;
  3283. };
  3284.  
  3285. int set_camera_and_point(lua_State* L) {// установить и переместить камеру в координатах.
  3286.     try {
  3287.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  3288.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5) && LUA_TNUMBER == lua_type(L, 6)) {
  3289.             float x = lua_tonumber(L, 1);  float y = lua_tonumber(L, 2);
  3290.             float z = lua_tonumber(L, 3);
  3291.             float x1 = lua_tonumber(L, 4);  float y1 = lua_tonumber(L, 5);
  3292.             float z1 = lua_tonumber(L, 6);
  3293.  
  3294.             CVector pos = { x, y, z };
  3295.             CVector pos1 = { x1, y1, z1 };
  3296.             CVector r = { 0.0, 0.0, 0.0 };
  3297.             CCamera* cam;
  3298.             cam = (CCamera*)0x7E4688;
  3299.             cam->SetCamPositionForFixedMode(pos, r); // SET_FIXED_CAMERA_POSITION opcode_015F
  3300.             //Command<COMMAND_POINT_CAMERA_AT_POINT>(pos.x, pos.y, pos.z, tipe); //  
  3301.             cam->TakeControlNoEntity(pos1, 1, 1); // POINT_CAMERA_AT_POINT  
  3302.             return 0;
  3303.         }
  3304.         else { throw "bad argument in function set_camera_and_point"; }
  3305.     }
  3306.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3307.     return 0;
  3308. };
  3309.  
  3310. static int getcord(queue<double>q, const void* p) {
  3311.     CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  3312.     while (!q.empty()) {
  3313.         this_thread::sleep_for(chrono::milliseconds(1));
  3314.         double x = q.front(); q.pop();
  3315.         double y = q.front(); q.pop();
  3316.         double z = q.front(); q.pop();
  3317.  
  3318.         Command<COMMAND_CAR_GOTO_COORDINATES>(car, x, y, z);// авто едет на координаты.
  3319.         while (!car->IsSphereTouchingVehicle(x, y, z, 3.0)) {
  3320.             this_thread::sleep_for(chrono::milliseconds(1));
  3321.             //if (car->m_fHealth < 100){
  3322.             //  break;
  3323.             //}
  3324.         };
  3325.     };
  3326.     return 0;
  3327. };
  3328. void writelog1(double x) {// запись ошибок в файл.
  3329.     string path = "queqe.txt";
  3330.     fstream f1; {f1.open(path, fstream::in | fstream::out | fstream::app);
  3331.     f1 << x;  f1 << "\n"; }
  3332.     f1.close();
  3333. };
  3334.  
  3335. void writelog1(int x) {// запись ошибок в файл.
  3336.     string path = "queqe.txt";
  3337.     fstream f1; {f1.open(path, fstream::in | fstream::out | fstream::app);
  3338.     f1 << x;  f1 << "\n"; }
  3339.     f1.close();
  3340. };
  3341. int go_to_route(lua_State* L) {//установить маршрут авто.
  3342.     try {
  3343.         if (LUA_TTABLE == lua_type(L, 2) && LUA_TLIGHTUSERDATA == lua_type(L, 1)) {
  3344.             lua_State* L1 = luaL_newstate();
  3345.             luaL_openlibs(L1);// открыть допю. библиотеки.
  3346.             int stacksize = lua_gettop(L);// кол-во элементов в  стек.  
  3347.             stacksize++;
  3348.             for (int i = 1; i < stacksize; i++) {
  3349.                 lua_xmove(L, L1, 1);
  3350.             };
  3351.             if (LUA_TLIGHTUSERDATA == lua_type(L1, -1)) {
  3352.                 const void* p = lua_topointer(L1, -1);
  3353.                 lua_pop(L1, 1); int counts = luaL_len(L1, 1);
  3354.                 counts += 2; queue<double>q = {};// очередь для хранение всех значение координат из файла.
  3355.                 for (int i = 1; i < counts; i++) {
  3356.                     lua_pushinteger(L1, i);
  3357.                     lua_gettable(L1, -2);
  3358.                     if (LUA_TNUMBER == lua_type(L1, -1)) {
  3359.                         double cord = lua_tonumber(L1, -1);
  3360.                         q.push(cord); lua_pop(L1, 1);
  3361.                     }
  3362.                 };
  3363.                 lua_close(L1);
  3364.                 std::thread(getcord, q, p).detach();
  3365.                 return 0;
  3366.             }
  3367.         }
  3368.         else { throw "bad argument in function go_to_route"; }
  3369.     }
  3370.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3371.     return 0;
  3372. };
  3373.  
  3374. int get_current_name_luascript(lua_State* L) {// получить имя текущего lua файла.
  3375.     lua_pushlightuserdata(L, L);  /*отправить адрес, который является ключом в стек. */
  3376.     lua_gettable(L, LUA_REGISTRYINDEX);  /* получить таблицу и значение ключа будет в -1 */
  3377.     char const* luaname = lua_tostring(L, -1);//имя lua скрипта.
  3378.     lua_pushstring(L, luaname);
  3379.     return 1;
  3380. };
  3381.  
  3382. int restore_camera(lua_State* L) {// восстановить камеру.
  3383.  
  3384.     CCamera* cam;
  3385.     cam = (CCamera*)0x7E4688;
  3386.     cam->Restore();
  3387.     cam->RestoreWithJumpCut();
  3388.     //Command<COMMAND_RESTORE_CAMERA>();
  3389.     //Command<COMMAND_RESTORE_CAMERA_JUMPCUT>();
  3390.     return 0;
  3391. };
  3392.  
  3393. int ped_atack(lua_State* L) {// пед бьет.
  3394.     try {
  3395.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {
  3396.  
  3397.             const void* p1 = lua_topointer(L, 1);
  3398.  
  3399.             CPed* p = findpedinpool(p1);//  получить указатель на педа.
  3400.  
  3401.             for (auto ped : CPools::ms_pPedPool) {
  3402.                 if (ped == p) {
  3403.                     //ped->Attack();
  3404.                     this_thread::sleep_for(chrono::milliseconds(1));
  3405.                     //spite::active(true, ped);
  3406.                     //this_thread::sleep_for(chrono::milliseconds(1000));
  3407.                     //unsigned int x =  ped->Attack();// правой рукой.
  3408.                     return 0;
  3409.                 }
  3410.             }
  3411.         }
  3412.         else { throw "bad argument in function ped_atack"; }
  3413.     }
  3414.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3415.     return 0;
  3416. };
  3417.  
  3418. int flash_hud(lua_State* L) {// Мигание элементов HUD.
  3419.     try {
  3420.         if (LUA_TNUMBER == lua_type(L, 1)) {
  3421.             int status = lua_tointeger(L, 1);// если число
  3422.  
  3423.             Command<COMMAND_FLASH_HUD_OBJECT>(status);
  3424.             //Мигание элементов HUD'а номер 8
  3425.             //  Номера элементов :
  3426.             //10 - полоса воздуха
  3427.             //  8 - радар
  3428.             //  4 - полоса здоровья
  3429.             //  "-1" - убрать мигание
  3430.             return 0;
  3431.         }
  3432.         else { throw "bad argument in function flash_hud"; }
  3433.     }
  3434.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3435.     return 0;
  3436. };
  3437.  
  3438. int set_radio(lua_State* L) {// установить радио.
  3439.     try {//041E: set_radio_station 9 -1 .
  3440.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {
  3441.             int status = lua_tointeger(L, 1);// если число
  3442.             int type = lua_tointeger(L, 2);// если число
  3443.             //Указатель радиостанции - 1 = не начинать с начала файла станции, 0 = начинать с начала
  3444.             //Этот код операции устанавливает текущую радиостанцию ​​для воспроизведения в автомобиле, который поддерживает эту станцию.
  3445.             //В vc индекс станции тесно связан со списком радиостанций, за исключением индекса 9. Если используется индекс 9,
  3446.             // станция устанавливает себя на 10, предотвращая воспроизведение станции MP3 с этим кодом операции.
  3447.             Command<COMMAND_SET_RADIO_CHANNEL>(status, type);
  3448.             return 0;
  3449.         }
  3450.         else { throw "bad argument in function set_radio"; }
  3451.     }
  3452.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3453.     return 0;
  3454. };
  3455.  
  3456. int set_car_tires(lua_State* L) {// проколоть шину.
  3457.     try {
  3458.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {//строка.
  3459.  
  3460.             const void* p1 = lua_topointer(L, 1);
  3461.  
  3462.             CVehicle* car = findcarinpool(p1);//  получить указатель на авто.
  3463.             int wheel = lua_tointeger(L, 2);// номер колеса.
  3464.             Command<COMMAND_BURST_CAR_TYRE>(CPools::GetVehicleRef(car), wheel);
  3465.             return 0;
  3466.         }
  3467.         else { throw "bad argument in function set_car_tires"; }
  3468.     }
  3469.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3470.     return 0;
  3471. };
  3472.  
  3473. int get_wheel_status(lua_State* L) {// получить состояния шины авто.
  3474.     try {
  3475.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// первый указатель на авто.
  3476.             //второй параметр номер колесо.
  3477.  
  3478.             const void* p = lua_topointer(L, 1);
  3479.  
  3480.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  3481.             int wheel = lua_tointeger(L, 2);
  3482.  
  3483.             if (car && car->m_nVehicleClass == VEHICLE_AUTOMOBILE) {
  3484.                 CAutomobile* automobile = reinterpret_cast<CAutomobile*>(car);
  3485.                 int status = automobile->m_carDamage.GetWheelStatus(wheel);
  3486.                 return 1;
  3487.             }
  3488.         }
  3489.         else { throw "bad argument in function get_car_tires"; }
  3490.     }
  3491.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3492.     return 0;
  3493. };
  3494.  
  3495. int set_wheel_status(lua_State* L) {// установить состояния шин авто.
  3496.     try {
  3497.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)){
  3498.         // первый указатель на авто. второй параметр номер колесf. третий статус, 0 = починка.
  3499.  
  3500.             const void* p = lua_topointer(L, 1);
  3501.  
  3502.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  3503.             int wheel = lua_tointeger(L, 2);
  3504.             int status = lua_tointeger(L, 3);
  3505.             if (car && car->m_nVehicleClass == VEHICLE_AUTOMOBILE) {
  3506.                 CAutomobile* automobile = reinterpret_cast<CAutomobile*>(car);
  3507.                 automobile->m_carDamage.SetWheelStatus(wheel, status);
  3508.                 return 0;
  3509.             }
  3510.         }
  3511.         else { throw "bad argument in function set_car_tires"; }
  3512.     }
  3513.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3514.     return 0;
  3515. };
  3516.  
  3517. int set_skin(lua_State* L) {// установить скин педа.
  3518.     try {
  3519.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TSTRING == lua_type(L, 2)) {
  3520.  
  3521.             const void* p = lua_topointer(L, 1);
  3522.  
  3523.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3524.             char const* model = lua_tostring(L, 2);// модель скина
  3525.  
  3526.             Command<COMMAND_LOAD_ALL_MODELS_NOW>(false);
  3527.             Command<COMMAND_UNDRESS_CHAR>(CPools::GetPedRef(ped), model);
  3528.             Command<COMMAND_LOAD_ALL_MODELS_NOW>(false);
  3529.             Command<COMMAND_DRESS_CHAR>(CPools::GetPedRef(ped));
  3530.             this_thread::sleep_for(chrono::milliseconds(1));
  3531.             return 0;
  3532.         }
  3533.         else { throw "bad argument in function ped_atack"; }
  3534.     }
  3535.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3536.     return 0;
  3537. };
  3538.  
  3539. int del_anim(lua_State* L) {// удалить анимацию.
  3540.     try {
  3541.         if (LUA_TNUMBER == lua_type(L, 1)) {//число.
  3542.             //const void* p = lua_topointer(L, 1);
  3543.             //CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3544.             //
  3545.             int tipe = lua_tointeger(L, 1);
  3546.  
  3547.             //CAnimManager::RemoveAnimBlockRef(tipe);
  3548.             //b->RemoveAnimBlockRefWithoutDelete(tipe);
  3549.             return 0;
  3550.         }
  3551.         else { throw "bad argument in function del_anim"; }
  3552.     }
  3553.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3554.     return 0;
  3555. };
  3556.  
  3557. int getcarspeed(lua_State* L) {// получить скорость авто.
  3558.     try {
  3559.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  3560.             const void* p = lua_topointer(L, 1);
  3561.             float speed;// переменная хранить скорость авто.
  3562.             CVehicle* car = findcarinpool(p);// получить указатель на авто.
  3563.             //speed = car->m_fTotSpeed;
  3564.             Command<COMMAND_GET_CAR_SPEED>(CPools::GetVehicleRef(car), &speed);// получить скорость авто.
  3565.             lua_pushnumber(L, speed);// отправить в стек.  
  3566.             return 1;
  3567.         }
  3568.         else { throw "bad argument in function getcarspeed"; }
  3569.     }
  3570.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3571.     return 0;
  3572. };
  3573.  
  3574. int remove_all_weapons_ped(lua_State* L) {// удалить все оружия педа.
  3575.     try {
  3576.         if (LUA_TLIGHTUSERDATA == lua_type(L, -1)) {// указатель на педа.
  3577.             const void* p = lua_topointer(L, -1);
  3578.  
  3579.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  3580.             ped->ClearWeapons();
  3581.             return 0;
  3582.         }
  3583.         else { throw "bad argument in function remove_all_weapons_ped"; }
  3584.     }
  3585.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3586.     return 0;
  3587. };
  3588.  
  3589. int Getweaponslot(lua_State* L) {// получить номер слота по типу оружия.
  3590.     try {
  3591.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {//число.
  3592.  
  3593.             const void* p = lua_topointer(L, 1);
  3594.             int weapontype = lua_tointeger(L, 2);
  3595.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3596.             eWeaponType w = (eWeaponType)weapontype;
  3597.             int shot = ped->GetWeaponSlot(w);// номер слота оружие.
  3598.             lua_pushinteger(L, shot);
  3599.             return 1;
  3600.         }
  3601.         else { throw "bad argument in function Getweaponslot"; }
  3602.     }
  3603.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3604.     return 0;
  3605. };
  3606.  
  3607. int get_damage_weapon_ped(lua_State* L) {// получить последний урон педа от оружия.
  3608.     try {
  3609.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {//число.
  3610.  
  3611.             const void* p = lua_topointer(L, 1);
  3612.  
  3613.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3614.             int damageweapon = ped->m_nLastDamWep;
  3615.             lua_pushinteger(L, damageweapon);
  3616.             return 1;
  3617.         }
  3618.         else { throw "bad argument in function get_damage_weapon_ped"; }
  3619.     }
  3620.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3621.     return 0;
  3622. };
  3623.  
  3624. int get_aimgun_ped(lua_State* L) {// получить показатель цели педа.
  3625.     try {
  3626.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {//число.
  3627.  
  3628.             const void* p = lua_topointer(L, 1);
  3629.  
  3630.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3631.             int aimgun = ped->AimGun();
  3632.             lua_pushinteger(L, aimgun);
  3633.             return 1;
  3634.         }
  3635.         else { throw "bad argument in function get_aimgun_ped"; }
  3636.     }
  3637.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3638.     return 0;
  3639. };
  3640.  
  3641. int get_ammo_weapon_ped(lua_State* L) {// получить кол-во патроны текущего оружие педа.
  3642.     try {
  3643.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {//число.
  3644.  
  3645.             const void* p = lua_topointer(L, 1);
  3646.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3647.  
  3648.             CWeapon weapon = ped->m_aWeapons[ped->m_nActiveWeaponSlot];
  3649.             int ammo = weapon.m_nTotalAmmo; // кол-во патроны текущего оружие.
  3650.             lua_pushinteger(L, ammo);
  3651.             return 1;
  3652.         }
  3653.         else { throw "bad argument in function get_ammo_weapon_ped"; }
  3654.     }
  3655.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3656.     return 0;
  3657. };
  3658.  
  3659. int createfireonped(lua_State* L) {// создать огонь на педе.
  3660.     try {
  3661.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  3662.             const void* p = lua_topointer(L, 1);
  3663.             int fire;// переменная хранить id огня.
  3664.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3665.             Command<COMMAND_START_CHAR_FIRE>(CPools::GetPedRef(ped), &fire);// создать огонь на педе.
  3666.             firesids.emplace(fire, L); // добавить id огня в map.
  3667.  
  3668.             lua_pushinteger(L, fire);// отправить в стек.  
  3669.             return 1;
  3670.         }
  3671.         else { throw "bad argument in function createfireonped"; }
  3672.     }
  3673.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3674.     return 0;
  3675. };
  3676.  
  3677. int createfireoncar(lua_State* L) {// создать огонь на авто.
  3678.     try {
  3679.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  3680.             const void* p = lua_topointer(L, 1);
  3681.             int fire;// переменная хранить id огоня.
  3682.  
  3683.             CVehicle* car = findcarinpool(p);// получить указатель на авто.
  3684.             Command<COMMAND_START_CAR_FIRE>(CPools::GetVehicleRef(car), &fire);// создать огонь на авто.
  3685.             firesids.emplace(fire, L); // добавить id огня в map.
  3686.             lua_pushinteger(L, fire);// отправить в стек.  
  3687.             return 1;
  3688.         }
  3689.         else { throw "bad argument in function createfireoncar"; }
  3690.     }
  3691.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3692.     return 0;
  3693. };
  3694.  
  3695. int createfireoncords(lua_State* L) {// создать огонь на координатах.
  3696.     try {
  3697.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)) {
  3698.             float x = lua_tonumber(L, 1);
  3699.             float y = lua_tonumber(L, 2); float z = lua_tonumber(L, 3);
  3700.             int fire;// переменная хранить id огоня.
  3701.             CVector pos = { x,y,z };
  3702.  
  3703.             Command<COMMAND_START_SCRIPT_FIRE>(pos.x, pos.y, pos.z, &fire);// создать огонь на координатах.
  3704.             firesids.emplace(fire, L); // id map
  3705.             lua_pushinteger(L, fire);// отправить в стек.  
  3706.             return 1;
  3707.         }
  3708.         else { throw "bad argument in function createfireoncords"; }
  3709.     }
  3710.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3711.     return 0;
  3712. };
  3713.  
  3714. int remove_fire(lua_State* L) {// удалить огонь.
  3715.     try {
  3716.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение id огня.
  3717.             int fire = lua_tointeger(L, 1);
  3718.             Command<COMMAND_REMOVE_SCRIPT_FIRE>(fire);// удалить огонь.
  3719.             return 0;
  3720.         }
  3721.         else { throw "bad argument in function remove_fire"; }
  3722.     }
  3723.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3724.     return 0;
  3725. };
  3726.  
  3727. int ped_shutdown(lua_State* L) {// отключение текущего оружие педа.
  3728.     try {
  3729.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {//число.
  3730.  
  3731.             const void* p = lua_topointer(L, 1);
  3732.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3733.  
  3734.             CWeapon weapon = ped->m_aWeapons[ped->m_nActiveWeaponSlot];// получить оружие текущего слота.
  3735.             //weapon.InitialiseWeapons();
  3736.             weapon.Shutdown();
  3737.             //weapon.ShutdownWeapons();
  3738.             //weapon.Reload();
  3739.             //lua_pushinteger(L, ammo);
  3740.             return 0;
  3741.         }
  3742.         else { throw "bad argument in function ped_shutdown"; }
  3743.     }
  3744.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3745.     return 0;
  3746. };
  3747.  
  3748. int is_ped_damage_from_ped(lua_State* L) {// получил ли пед урон от педа.
  3749.     try {
  3750.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2)) {//указатель на педа.
  3751.  
  3752.             const void* p = lua_topointer(L, 1);
  3753.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3754.             const void* p1 = lua_topointer(L, 2);
  3755.             CPed* ped1 = findpedinpool(p1);//  получить указатель на педа.
  3756.             bool check_damage = Command<COMMAND_HAS_CHAR_BEEN_DAMAGED_BY_CHAR>(CPools::GetPedRef(ped), CPools::GetPedRef(ped1));
  3757.             lua_pushboolean(L, check_damage);
  3758.             return 1;
  3759.         }
  3760.         else { throw "bad argument in function is_ped_damage_from_ped"; }
  3761.     }
  3762.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3763.     return 0;
  3764. };
  3765.  
  3766. int is_ped_passenger_car(lua_State* L) {// пед пассажир авто.
  3767.     try {
  3768.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2)) {//указатель на педа.
  3769.  
  3770.             const void* p = lua_topointer(L, 1);
  3771.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3772.  
  3773.             const void* p1 = lua_topointer(L, 2);
  3774.             CVehicle* car = findcarinpool(p1);//  получить указатель на авто.
  3775.             bool check_passenger = car->IsPassenger(ped);
  3776.  
  3777.             lua_pushboolean(L, check_passenger);
  3778.             return 1;
  3779.         }
  3780.         else { throw "bad argument in function is_ped_passenger_car"; }
  3781.     }
  3782.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3783.     return 0;
  3784. };
  3785.  
  3786. int is_ped_driver_car(lua_State* L) {// пед водитель авто.
  3787.     try {
  3788.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2)) {//указатель на педа.
  3789.  
  3790.             const void* p = lua_topointer(L, 1);
  3791.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3792.  
  3793.             const void* p1 = lua_topointer(L, 2);
  3794.             CVehicle* car = findcarinpool(p1);//  получить указатель на авто.
  3795.             bool check_driver = car->IsDriver(ped); // проверить водитель авто?
  3796.  
  3797.             lua_pushboolean(L, check_driver);
  3798.             return 1;
  3799.         }
  3800.         else { throw "bad argument in function is_ped_passenger_car"; }
  3801.     }
  3802.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3803.     return 0;
  3804. };
  3805.  
  3806. int is_targetting_in_ped(lua_State* L) {// игрок целиться в педа.
  3807.     try {
  3808.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {//указатель на педа.
  3809.  
  3810.             const void* p = lua_topointer(L, 1);
  3811.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3812.             bool check_target = Command<COMMAND_IS_PLAYER_TARGETTING_CHAR>(CWorld::PlayerInFocus, CPools::GetPedRef(ped));
  3813.             lua_pushboolean(L, check_target);
  3814.             return 1;
  3815.         }
  3816.         else { throw "bad argument in function is_targetting_in_ped"; }
  3817.     }
  3818.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3819.     return 0;
  3820. };
  3821.  
  3822. int Remove_weapon_model(lua_State* L) {// удалить оружие у педа.
  3823.     try {
  3824.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {//число.
  3825.             const void* p = lua_topointer(L, 1);
  3826.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3827.             int idweapon = lua_tointeger(L, 2);
  3828.  
  3829.             int tipe = find_model_in_map(model_and_type, idweapon);// тип оружие.
  3830.  
  3831.             ped->SetAmmo((eWeaponType)tipe, 0);// обнулить кол-во патронов.
  3832.             CWeapon weapon = ped->m_aWeapons[ped->m_nActiveWeaponSlot];// получить оружие из текущего слота.
  3833.             ped->RemoveWeaponModel(idweapon); // удалить модель оружие.
  3834.             weapon.Shutdown();// отключить оружие.
  3835.             weapon.UpdateWeapons();// обновить оружия.
  3836.             return 0;
  3837.         }
  3838.         else { throw "bad argument in function Remove_weapon_model"; }
  3839.     }
  3840.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3841.     return 0;
  3842. };
  3843.  
  3844. int Createped(lua_State* L) {// макрос создать педа.
  3845.     try {
  3846.         if (LUA_TSTRING == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) &&
  3847.             LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 4)) {// значение число.
  3848.             const char* name_ped = lua_tostring(L, 1);
  3849.  
  3850.             int model = find_in_map(name_peds_list, name_ped);// модель педа.    
  3851.             int type = find_in_map(type_peds_list, name_ped);// тип педа.
  3852.  
  3853.             float x = lua_tonumber(L, 2); float y = lua_tonumber(L, 3); float z = lua_tonumber(L, 4);
  3854.             CVector pos = { x, y, z };
  3855.             CPed* ped = NULL; load_model_before_avalible(model);   
  3856.             //CWorld::Players[CWorld::PlayerInFocus].m_nMoney += type;// дать денег
  3857.             Command<COMMAND_CREATE_CHAR>(type, model, pos.x, pos.y, pos.z, &ped);
  3858.             Command<COMMAND_MARK_MODEL_AS_NO_LONGER_NEEDED>(model);
  3859.             mappeds.emplace(ped, L);// добавить map для педов.
  3860.             lua_pushlightuserdata(L, ped);// отправить в стек и получить из стека можно.
  3861.             return 1;
  3862.         }// int
  3863.  
  3864.         else { throw "bad argument in function Createped"; }
  3865.     }
  3866.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3867.     return 0;
  3868. };
  3869. int expectations(int model, CVehicle* car) {
  3870.     while (true) {
  3871.         this_thread::sleep_for(chrono::milliseconds(10));// задержка
  3872.         if (car->IsVisible()) {
  3873.  
  3874.             Command<COMMAND_MARK_MODEL_AS_NO_LONGER_NEEDED>(model);
  3875.             break;
  3876.         }
  3877.     };
  3878.     return 0;
  3879. };
  3880.  
  3881. int Createcar(lua_State* L) {// макрос создать авто на координатах.
  3882.     try {
  3883.         if (LUA_TSTRING == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)
  3884.             && LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 4)) {// значение число.
  3885.             CVehicle* car = NULL;
  3886.             const char* name_model = lua_tostring(L, 1);// модель авто.
  3887.  
  3888.             int model = find_in_map(car_model_list, name_model);
  3889.             float x = lua_tonumber(L, 2); float y = lua_tonumber(L, 3);
  3890.             float z = lua_tonumber(L, 4); CVector pos = { x, y, z };
  3891.             load_model_before_avalible(model); // загрузить модель полносттью.
  3892.  
  3893.             Command<COMMAND_CREATE_CAR>(model, pos.x, pos.y, pos.z, &car);
  3894.             //std::thread(expectations, model, std::ref(car)).detach();
  3895.  
  3896.             while (true) {
  3897.                 this_thread::sleep_for(chrono::milliseconds(10));// задержка
  3898.                 if (car->IsVisible()) {
  3899.  
  3900.                     Command<COMMAND_MARK_MODEL_AS_NO_LONGER_NEEDED>(model);
  3901.                     break;
  3902.                 }
  3903.             };
  3904.             car->m_nLockStatus = 1;
  3905.             mapcars.emplace(car, L);// добавить в map для авто.
  3906.             lua_pushlightuserdata(L, car);// отправить в стек указатель на авто.
  3907.             return 1;
  3908.         }// int
  3909.  
  3910.         else { throw "bad argument in function Createcar"; }
  3911.     }
  3912.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3913.     return 0;
  3914. };
  3915.  
  3916. //--function Giveweaponped(ped, ammo, ...)--дать педу оружие и патроны.
  3917. void ped_weapon_give(CPed* ped, int typemodel, int ammo) {
  3918.     CPed* player = FindPlayerPed();// найти педа
  3919.     if (ped == player) { Command<COMMAND_GIVE_WEAPON_TO_PLAYER>(CWorld::PlayerInFocus, typemodel, ammo); }
  3920.     else {
  3921.         Command<COMMAND_GIVE_WEAPON_TO_CHAR>(CPools::GetPedRef(ped), typemodel, ammo);// Дать оружие педу.
  3922.     }
  3923. };
  3924.  
  3925. int Giveweaponped(lua_State* L) {// макрос дать педу оружие и патроны.
  3926.     try {
  3927.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TSTRING == lua_type(L, 3)) {
  3928.  
  3929.             const void* p = lua_topointer(L, 1);
  3930.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  3931.             int ammo = lua_tointeger(L, 2);
  3932.             lua_remove(L, 2); lua_remove(L, 1);
  3933.             int size = lua_gettop(L); size++;
  3934.  
  3935.             for (int i = 1; i < size; i++) {
  3936.                 const char* name_weapon = lua_tostring(L, i);
  3937.                 int model = find_in_map(name_weapon_list, name_weapon);// модель оружие
  3938.                 load_model_before_avalible(model); // загрузить модель полносттью.
  3939.                 int type = find_in_map(types_weapon_list, name_weapon);// тип оружие.
  3940.                 ped_weapon_give(ped, type, ammo);
  3941.                 Command<COMMAND_MARK_MODEL_AS_NO_LONGER_NEEDED>(model);
  3942.             }
  3943.  
  3944.             lua_pop(L, lua_gettop(L));// удалить n элементы из стека.
  3945.             return 0;
  3946.         }
  3947.         else { throw "bad argument in function Giveweaponped"; }
  3948.     }
  3949.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3950.     return 0;
  3951. };
  3952.  
  3953. //--function Create_weapon_pickup(m, typepickup, ammo, x, y, z)  --создать пикап оружие.
  3954. int Create_weapon_pickup(lua_State* L) {// макрос создать пикап оружие.
  3955.     try {
  3956.         if (LUA_TSTRING == lua_type(L, 1) || LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)
  3957.             && LUA_TNUMBER == lua_type(L, 3) && LUA_TNUMBER == lua_type(L, 4) &&
  3958.             LUA_TNUMBER == lua_type(L, 5) && LUA_TNUMBER == lua_type(L, 6)) {
  3959.  
  3960.             int typepick = lua_tointeger(L, 2);// тип пикапа.
  3961.             int ammo = lua_tointeger(L, 3); // начальное кол-во патронов в оружие.
  3962.             float x = lua_tonumber(L, 4);
  3963.             float y = lua_tonumber(L, 5); float z = lua_tonumber(L, 6);
  3964.             int idpickup;// переменная, которая хранить id пикапа.  
  3965.             CVector pos = { x, y, z };  int model;
  3966.             if (LUA_TSTRING == lua_type(L, 1)) {
  3967.                 const char* name_weapon = lua_tostring(L, 1); // имя оружие если строка.
  3968.                 model = find_in_map(name_weapon_list, name_weapon);// модель оружие
  3969.             }
  3970.             else {
  3971.                 if (LUA_TNUMBER == lua_type(L, 1)) { model = lua_tointeger(L, 1); }
  3972.             }
  3973.             load_model_before_avalible(model); // загрузить модель полносттью.
  3974.             Command<COMMAND_CREATE_PICKUP_WITH_AMMO>(model, typepick, ammo, pos.x, pos.y, pos.z, &idpickup);
  3975.             pickupsids.emplace(idpickup, L);// добавить в map пикапов.
  3976.             lua_pushinteger(L, idpickup);// отправить id пикапа в стек.  
  3977.             Command<COMMAND_MARK_MODEL_AS_NO_LONGER_NEEDED>(model);
  3978.             return 1;
  3979.         }
  3980.         else { throw "bad argument in function Create_weapon_pickup"; }
  3981.     }
  3982.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  3983.     return 0;
  3984. };
  3985.  
  3986. //function Create_pickup(model, typepickup, x, y, z) --создать пикап.
  3987.  
  3988. int Create_pickup(lua_State* L) {// макрос создать пикап.
  3989.     try {
  3990.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  3991.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5)) {
  3992.             int model = lua_tointeger(L, 1); // модель пикапа.
  3993.  
  3994.             load_model_before_avalible(model); // загрузить модель полносттью.
  3995.             int type = lua_tointeger(L, 2);// тип пикапа.
  3996.             float x = lua_tonumber(L, 3);   float y = lua_tonumber(L, 4);
  3997.             float z = lua_tonumber(L, 5);// координаты.
  3998.  
  3999.             int idpickup;// переменная, которая хранить id пикапа.  
  4000.             CVector pos = { x, y, z };
  4001.             Command<COMMAND_CREATE_PICKUP>(model, type, pos.x, pos.y, pos.z, &idpickup);
  4002.             Command<COMMAND_MARK_MODEL_AS_NO_LONGER_NEEDED>(model);
  4003.             pickupsids.emplace(idpickup, L);// добавить в map пикапов.
  4004.             lua_pushinteger(L, idpickup);// отправить id пикапа в стек.  
  4005.             return 1;
  4006.         }
  4007.         else { throw "bad argument in function Create_pickup"; }
  4008.     }
  4009.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4010.     return 0;
  4011. };
  4012.  
  4013. int Get_model_and_type_current_weapon_ped(lua_State* L) {// макрос получить модель и тип текущего оружие педа.
  4014.     try {
  4015.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {//число.
  4016.  
  4017.             const void* p = lua_topointer(L, 1);
  4018.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  4019.  
  4020.             CWeapon weapon = ped->m_aWeapons[ped->m_nActiveWeaponSlot];
  4021.             eWeaponType type = weapon.m_nType;
  4022.             CWeaponInfo* winfo = CWeaponInfo::GetWeaponInfo(type);
  4023.  
  4024.             int idweapon = winfo->m_nModelId;
  4025.  
  4026.             lua_pushinteger(L, idweapon);
  4027.             lua_pushinteger(L, type);
  4028.             return 2;
  4029.         }
  4030.         else { throw "bad argument in function Get_model_and_type_current_weapon_ped"; }
  4031.     }
  4032.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4033.     return 0;
  4034. };
  4035.  
  4036. int is_ped_in_car(lua_State* L) {// игрок в авто?
  4037.     try {
  4038.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  4039.  
  4040.             const void* p = lua_topointer(L, 1);
  4041.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  4042.             if (ped->m_bInVehicle && ped->m_pVehicle != NULL) {// в авто пед?
  4043.                 lua_pushboolean(L, true);
  4044.                 return 1;
  4045.             }
  4046.             else {
  4047.                 lua_pushboolean(L, false);
  4048.                 return 1;// получить указатель на хенлд авто в котором сидит пед.
  4049.             }
  4050.         }
  4051.         else { throw "bad argument in function is_ped_in_car"; }
  4052.     }
  4053.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4054. };
  4055.  
  4056. int ped_car(lua_State* L) {// авто педа.
  4057.     try {
  4058.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  4059.  
  4060.             const void* p = lua_topointer(L, 1);
  4061.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  4062.             if (ped->m_bInVehicle && ped->m_pVehicle != NULL) {// в авто пед?
  4063.                 CVehicle* car = ped->m_pVehicle;
  4064.                 lua_pushlightuserdata(L, car);// отправить в стек true и указатель на авто.
  4065.                 return 1;
  4066.             }
  4067.             else {
  4068.                 CVehicle* car = NULL;//если пед не в авто вернуть null;
  4069.                 lua_pushlightuserdata(L, car);// отправить в стек и получить из стека можно
  4070.                 return 1;// получить указатель на null.
  4071.             }
  4072.         }
  4073.         else { throw "bad argument in function ped_car"; }
  4074.     }
  4075.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4076. };
  4077.  
  4078. int get_model_current_weapon_ped(lua_State* L) {// макрос получить модель текущего оружие педа.
  4079.     try {
  4080.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {//число.
  4081.  
  4082.             const void* p = lua_topointer(L, 1);
  4083.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  4084.  
  4085.             CWeapon weapon = ped->m_aWeapons[ped->m_nActiveWeaponSlot];
  4086.             eWeaponType type = weapon.m_nType;
  4087.             CWeaponInfo* winfo = CWeaponInfo::GetWeaponInfo(type);
  4088.             int idweapon = winfo->m_nModelId;
  4089.  
  4090.             lua_pushinteger(L, idweapon);
  4091.             return 1;
  4092.         }
  4093.         else { throw "bad argument in function get_model_current_weapon_ped"; }
  4094.     }
  4095.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4096.     return 0;
  4097. };
  4098. int get_type_current_weapon_ped(lua_State* L) {// макрос получить тип текущего оружие педа.
  4099.     try {
  4100.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {//число.
  4101.  
  4102.             const void* p = lua_topointer(L, 1);
  4103.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  4104.  
  4105.             CWeapon weapon = ped->m_aWeapons[ped->m_nActiveWeaponSlot];
  4106.             int type = weapon.m_nType;
  4107.             lua_pushinteger(L, type);
  4108.             return 1;
  4109.         }
  4110.         else { throw "bad argument in function get_type_current_weapon_ped"; }
  4111.     }
  4112.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4113.     return 0;
  4114. };
  4115.  
  4116. int get_damage_current_weapon(lua_State* L) {// получить уровень урона текущего оружие.
  4117.     try {
  4118.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {//число.
  4119.  
  4120.             const void* p = lua_topointer(L, 1);
  4121.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  4122.  
  4123.             CWeapon weapon = ped->m_aWeapons[ped->m_nActiveWeaponSlot];
  4124.             eWeaponType type = weapon.m_nType;
  4125.             CWeaponInfo* w = CWeaponInfo::GetWeaponInfo(type);
  4126.             int damage = w->m_nDamage;
  4127.             lua_pushinteger(L, damage);
  4128.             return 1;
  4129.         }
  4130.         else { throw "bad argument in function get_damage_current_weapon"; }
  4131.     }
  4132.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4133.     return 0;
  4134. };
  4135.  
  4136. int set_damage_current_weapon(lua_State* L) {// установить уровень урона текущего оружие педа.
  4137.     try {
  4138.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {//число.
  4139.  
  4140.             const void* p = lua_topointer(L, 1);
  4141.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  4142.             int damage = lua_tointeger(L, 2);
  4143.             CWeapon weapon = ped->m_aWeapons[ped->m_nActiveWeaponSlot];
  4144.  
  4145.             eWeaponType type = weapon.m_nType;
  4146.             CWeaponInfo* w = CWeaponInfo::GetWeaponInfo(type);
  4147.             w->m_nDamage = damage;
  4148.             return 0;
  4149.         }
  4150.         else { throw "bad argument in function set_damage_current_weapon"; }
  4151.     }
  4152.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4153.     return 0;
  4154. };
  4155.  
  4156. int ped_in_targetting(lua_State* L) {// пед на прицеле.
  4157.     CPed* player = FindPlayerPed();// найти игрока
  4158.     for (auto ped : CPools::ms_pPedPool) {
  4159.         if (Command<COMMAND_IS_PLAYER_TARGETTING_CHAR>(CWorld::PlayerInFocus, CPools::GetPedRef(ped)) && ped != player) {
  4160.             lua_pushlightuserdata(L, ped);
  4161.             return 1;
  4162.         }
  4163.     }
  4164. };
  4165.  
  4166. int Ped_in_targetting(lua_State* L) {// Макрос пед на прицеле.
  4167.  
  4168.     CPed* player = FindPlayerPed();// найти игрока
  4169.     for (auto ped : CPools::ms_pPedPool) {
  4170.         if (Command<COMMAND_IS_PLAYER_TARGETTING_CHAR>(CWorld::PlayerInFocus, CPools::GetPedRef(ped)) && ped != player) {
  4171.             lua_pushboolean(L, true);
  4172.             lua_pushlightuserdata(L, ped);
  4173.             return 2;
  4174.         }
  4175.     }
  4176.  
  4177.     lua_pushboolean(L, false);
  4178.     lua_pushnil(L);
  4179.     return 2;
  4180. };
  4181.  
  4182. int Get_model_and_type_ped(lua_State* L) {// макрос получить модель и тип педа.
  4183.     try {
  4184.         if (LUA_TSTRING == lua_type(L, 1)) {
  4185.             const char* name_ped = lua_tostring(L, 1); // имя педа
  4186.             int model = find_in_map(name_peds_list, name_ped);// модель педа.
  4187.             int type = find_in_map(type_peds_list, name_ped);// тип педа.
  4188.             lua_pushinteger(L, model);//
  4189.             lua_pushinteger(L, type);//
  4190.  
  4191.             return 2;
  4192.         }
  4193.         else { throw "bad argument in function Get_model_and_type_ped"; }
  4194.     }
  4195.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4196.     return 0;
  4197. };
  4198.  
  4199. int get_model_ped(lua_State* L) {// получить модель педа.
  4200.     try {
  4201.         if (LUA_TSTRING == lua_type(L, 1)) {
  4202.             const char* name_ped = lua_tostring(L, 1); // имя педа
  4203.             int model = find_in_map(name_peds_list, name_ped);// модель педа.
  4204.             lua_pushinteger(L, model);//
  4205.             return 1;
  4206.         }
  4207.         else { throw "bad argument in function get_model_ped"; }
  4208.     }
  4209.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4210.     return 0;
  4211. };
  4212.  
  4213. int get_type_ped(lua_State* L) {// получить тип педа.
  4214.     try {
  4215.         if (LUA_TSTRING == lua_type(L, 1)) {
  4216.             const char* name_ped = lua_tostring(L, 1); // имя педа.
  4217.             int type = find_in_map(type_peds_list, name_ped);// тип педа.
  4218.             lua_pushinteger(L, type);//
  4219.             return 1;
  4220.         }
  4221.         else { throw "bad argument in function get_type_ped"; }
  4222.     }
  4223.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4224.     return 0;
  4225. };
  4226.  
  4227. int ped_clear_investigate_event(lua_State* L) {// пед уходит, опустить педа.
  4228.     try {
  4229.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  4230.  
  4231.             const void* p = lua_topointer(L, 1);
  4232.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  4233.  
  4234.             ped->ClearInvestigateEvent();// пед уходит, опустить педа.
  4235.             return 0;
  4236.         }
  4237.         else { throw "bad argument in function ped_clear_investigate_event"; }
  4238.     }
  4239.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4240.     return 0;
  4241. };
  4242.  
  4243. int ped_clear_objective(lua_State* L) {// снять задачи с педа.
  4244.     try {//  011C: actor $PLAYER_ACTOR clear_objective .
  4245.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  4246.  
  4247.             const void* p = lua_topointer(L, 1);
  4248.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  4249.             ped->ClearObjective(); // снять задачи с педа.
  4250.             return 0;
  4251.         }
  4252.         else { throw "bad argument in function ped_clear_objective"; }
  4253.     }
  4254.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4255.     return 0;
  4256. };
  4257.  
  4258. int Getcameracoordes(lua_State* L) {// получить координаты камеры.
  4259.     float x = patch::GetFloat(0x7E46B8);
  4260.     float y = patch::GetFloat(0x7E46BC);
  4261.     float z = patch::GetFloat(0x7E46C0);
  4262.     lua_pushnumber(L, x);// отправить в стек.
  4263.     lua_pushnumber(L, y);// отправить в стек.
  4264.     lua_pushnumber(L, z);// отправить в стек.
  4265.     return 3;
  4266. };
  4267.  
  4268. int setbomb_in_car(lua_State* L) { // установить бомбу в авто.
  4269.     try {
  4270.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на авто.
  4271.             const void* p = lua_topointer(L, 1);
  4272.             CVehicle* car = findcarinpool(p);//  получить указатель на авто..
  4273.             int typebobm = lua_tointeger(L, 2);
  4274.             int strt = (int)car;
  4275.             strt += 0x1FE;
  4276.             patch::SetChar(strt, typebobm, true);
  4277.             /*
  4278.             0 -0  CARBOMB_NONE    Без бомбы
  4279.             1     CARBOMB_TIMED   Неактивная бомба, рассчитанная по времени, может быть получена из гаражного типа 2
  4280.             2     CARBOMB_ONIGNITION  Неактивная зажигательная бомба может быть получена из гаражного типа 3
  4281.             3     CARBOMB_REMOTE  Удаленная детонационная бомба может быть получена из гаражного типа 4
  4282.             4     CARBOMB_TIMEDACTIVE Активная импульсная бомба, активированная из бомбы типа 1
  4283.             5     CARBOMB_ONIGNITIONACTIVE   Активная зажигательная бомба, активированная из бомбы типа 2
  4284.             */
  4285.  
  4286.             return 0;
  4287.         }
  4288.         else { throw "bad argument in function setbomb_in_car"; }
  4289.     }
  4290.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4291.     return 0;
  4292. };
  4293.  
  4294. int getbomb_in_car(lua_State* L) { // получить тип бомбы в авто.
  4295.     try {
  4296.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  4297.             const void* p = lua_topointer(L, 1);
  4298.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  4299.             int strt = (int)car;
  4300.             strt += 0x1FE;
  4301.  
  4302.             int typebomb = patch::GetUChar(strt);
  4303.             lua_pushinteger(L, typebomb);
  4304.             return 1;
  4305.         }
  4306.         else { throw "bad argument in function getbomb_in_car"; }
  4307.     }
  4308.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4309.     return 0;
  4310. };
  4311.  
  4312. int activetbomb(lua_State* L) { // активировать бомбу в авто.
  4313.     try {
  4314.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  4315.             const void* p = lua_topointer(L, 1);
  4316.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  4317.             car->ActivateBomb();
  4318.             return 0;
  4319.         }
  4320.         else { throw "bad argument in function activetbomb"; }
  4321.     }
  4322.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4323.     return 0;
  4324. };
  4325.  
  4326. int is_ped_in_this_car(lua_State* L) {// игрок в этом авто?
  4327.     try {
  4328.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2)) {// указатель на педа.
  4329.  
  4330.             const void* p = lua_topointer(L, 1);
  4331.             CPed* ped = findpedinpool(p);// получить указатель на педа
  4332.  
  4333.             const void* p1 = lua_topointer(L, 2);
  4334.             CVehicle* car = findcarinpool(p1);//  получить указатель на авто.
  4335.             if (ped->m_pVehicle == car) {// в авто пед?
  4336.                 lua_pushboolean(L, true);
  4337.                 return 1;
  4338.             }
  4339.             else {
  4340.                 lua_pushboolean(L, false);
  4341.                 return 1;// получить указатель на авто в котором сидит пед.
  4342.             }
  4343.         }
  4344.         else { throw "bad argument in function is_ped_in_this_car"; }
  4345.     }
  4346.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4347. };
  4348.  
  4349. int ishorncar(lua_State* L) { // проверить гудит ли авто.
  4350.     try {
  4351.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  4352.             const void* p = lua_topointer(L, 1);
  4353.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  4354.             int horn = car->m_bHornEnabled;
  4355.             if (horn == 1)
  4356.             {
  4357.                 lua_pushboolean(L, true);
  4358.                 return 1;
  4359.             }
  4360.             else {
  4361.                 lua_pushboolean(L, false);
  4362.                 return 1;
  4363.             }
  4364.         }
  4365.         else { throw "bad argument in function ishorncar"; }
  4366.     }
  4367.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4368.     return 0;
  4369. };
  4370.  
  4371. int getcarfirstcolor(lua_State* L) {// получить первый цвет авто.
  4372.     try {
  4373.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {
  4374.  
  4375.             const void* p = lua_topointer(L, 1);
  4376.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  4377.  
  4378.             int firstcolor = car->m_nPrimaryColor;// получить первый цвет авто.
  4379.  
  4380.             lua_pushinteger(L, firstcolor);
  4381.             return 1;
  4382.         }
  4383.         else { throw "bad argument in function getcarfirstcolor"; }
  4384.     }
  4385.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4386.     return 0;
  4387. };
  4388.  
  4389. int getcarseconscolor(lua_State* L) {// получить второй цвет авто.
  4390.     try {
  4391.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {
  4392.             const void* p = lua_topointer(L, 1);
  4393.  
  4394.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  4395.             int secondcolor = car->m_nSecondaryColor;
  4396.             lua_pushinteger(L, secondcolor);
  4397.             return 1;
  4398.         }
  4399.  
  4400.         else { throw "bad argument in function getcarseconscolor"; }
  4401.     }
  4402.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4403.     return 0;
  4404. };
  4405.  
  4406. int ped_char_spotted_player(lua_State* L) {// если пед увидел игрока.   
  4407.     try {
  4408.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  4409.  
  4410.             const void* p = lua_topointer(L, 1);
  4411.             CPed* ped = findpedinpool(p);// получить указатель на педа
  4412.  
  4413.             CPed* player = FindPlayerPed();// найти игрока
  4414.             if (Command<COMMAND_HAS_CHAR_SPOTTED_PLAYER>(CWorld::PlayerInFocus, CPools::GetPedRef(ped))) {
  4415.                 lua_pushboolean(L, true);
  4416.                 return 1;
  4417.             }
  4418.             else {
  4419.                 lua_pushboolean(L, false);
  4420.                 return 1;
  4421.             }
  4422.         }
  4423.         else { throw "bad argument in function ped_char_spotted_player"; }
  4424.     }
  4425.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4426.     return 0;
  4427. };
  4428.  
  4429. int set_timer_bomb_car(lua_State* L) { // установить таймер на взрыв бомбы в авто.
  4430.     try {
  4431.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на авто.
  4432.             const void* p = lua_topointer(L, 1);
  4433.             CVehicle* car = findcarinpool(p);// получить указатель на авто.
  4434.             int time = lua_tointeger(L, 2); // время.
  4435.             car->m_wBombTimer = time;
  4436.             return 0;
  4437.         }
  4438.         else { throw "bad argument in function set_timer_bomb_car"; }
  4439.     }
  4440.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4441.     return 0;
  4442. };
  4443.  
  4444. int is_ped_objective(lua_State* L) {// если пед выполнил задачу.  
  4445.     try {
  4446.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  4447.  
  4448.             const void* p = lua_topointer(L, 1);
  4449.             CPed* ped = findpedinpool(p);// получить указатель на педа
  4450.             if (Command<COMMAND_IS_CHAR_OBJECTIVE_PASSED>(CPools::GetPedRef(ped))) {
  4451.                 lua_pushboolean(L, true);
  4452.                 return 1;
  4453.             }
  4454.             else {
  4455.                 lua_pushboolean(L, false);
  4456.                 return 1;
  4457.             }
  4458.         }
  4459.         else { throw "bad argument in function is_ped_objective"; }
  4460.     }
  4461.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4462.     return 0;
  4463. };
  4464.  
  4465. int set_time_scale(lua_State* L) { // установить ход времени в игре.
  4466.     try {
  4467.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение.
  4468.             float time = lua_tonumber(L, 1); // время.
  4469.             Command<COMMAND_SET_TIME_SCALE>(time);
  4470.             return 0;
  4471.         }
  4472.         else { throw "bad argument in function set_time_scale"; }
  4473.     }
  4474.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4475.     return 0;
  4476. };
  4477.  
  4478. int is_ped_in_air(lua_State* L) {// если пед в воздухе. 
  4479.     try {
  4480.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  4481.  
  4482.             const void* p = lua_topointer(L, 1);
  4483.             CPed* ped = findpedinpool(p);// получить указатель на педа
  4484.             if (ped->CheckIfInTheAir()) {
  4485.                 lua_pushboolean(L, true);
  4486.                 return 1;
  4487.             }
  4488.             else {
  4489.                 lua_pushboolean(L, false);
  4490.                 return 1;
  4491.             }
  4492.         }
  4493.         else { throw "bad argument in function is_ped_in_air"; }
  4494.     }
  4495.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4496.     return 0;
  4497. };
  4498.  
  4499. int kill_peds_in_car(lua_State* L) {// убить педов в авто.  
  4500.     try {
  4501.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  4502.  
  4503.             const void* p = lua_topointer(L, 1);
  4504.             CVehicle* car = findcarinpool(p);// получить указатель на авто.
  4505.             car->KillPedsInVehicle();
  4506.             return 0;
  4507.  
  4508.         }
  4509.         else { throw "bad argument in function kill_peds_in_car"; }
  4510.     }
  4511.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4512.     return 0;
  4513. };
  4514.  
  4515. int getstamina_ped(lua_State* L) { // получить выносливость педа.
  4516.     try {
  4517.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  4518.             const void* p = lua_topointer(L, 1);
  4519.  
  4520.             CPed* ped = findpedinpool(p);// получить указатель на педа
  4521.             int strt = (int)ped;
  4522.             strt += 0x600;
  4523.  
  4524.             float stamina = patch::GetFloat(strt);
  4525.             lua_pushnumber(L, stamina);
  4526.             return 1;
  4527.         }
  4528.         else { throw "bad argument in function getstamina_ped"; }
  4529.     }
  4530.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4531.     return 0;
  4532. };
  4533.  
  4534. int setstamina_ped(lua_State* L) { // установить выносливость педа.
  4535.     try {
  4536.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  4537.             const void* p = lua_topointer(L, 1);
  4538.  
  4539.             CPed* ped = findpedinpool(p);// получить указатель на педа
  4540.             int strt = (int)ped;
  4541.             strt += 0x600;
  4542.  
  4543.             float value = lua_tonumber(L, 2); // значение.
  4544.             patch::SetFloat(strt, value);
  4545.             return 0;
  4546.         }
  4547.         else { throw "bad argument in function setstamina_ped"; }
  4548.     }
  4549.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4550.     return 0;
  4551. };
  4552.  
  4553. int get_radio_car(lua_State* L) { // получить текущую радиостанцию авто.
  4554.     try {
  4555.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  4556.             const void* p = lua_topointer(L, 1);
  4557.             CVehicle* car = findcarinpool(p);//  получить указатель на авто.
  4558.             int strt = (int)car;
  4559.             //Cuban exhaust on / off
  4560.             //0x58BCA8 - [byte] - кубинский выхлоп
  4561.             //0x58B958 - [байт] - кубинский выхлоп
  4562.             //0x58BCB5 - [byte] - кубинский выхлоп вкл / выкл
  4563.             //0x69A60C - [float] - кубинская шкала выхлопных газов
  4564.             strt += 0x23C;
  4565.             int station = patch::GetChar(strt);
  4566.             lua_pushinteger(L, station);
  4567.             return 1;
  4568.         }
  4569.         else { throw "bad argument in function get_radio_car"; }
  4570.     }
  4571.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4572.     return 0;
  4573. };
  4574.  
  4575. int ped_in_turret_on_car(lua_State* L) { // переместить педа в турель авто.
  4576.     try {
  4577.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TLIGHTUSERDATA == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  4578.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5) && LUA_TNUMBER == lua_type(L, 6) &&
  4579.             LUA_TNUMBER == lua_type(L, 7) && LUA_TNUMBER == lua_type(L, 8)) {
  4580.  
  4581.             const void* p = lua_topointer(L, 1);
  4582.             CPed* ped = findpedinpool(p);// получить указатель на педа
  4583.  
  4584.             const void* p1 = lua_topointer(L, 2);
  4585.             CVehicle* car = findcarinpool(p1);//  получить указатель на авто.
  4586.             float x = lua_tonumber(L, 3);   float y = lua_tonumber(L, 4);
  4587.             float z = lua_tonumber(L, 5);
  4588.  
  4589.             int place = lua_tointeger(L, 6);
  4590.             float angle = lua_tonumber(L, 7);
  4591.             int typeweapon = lua_tointeger(L, 8);
  4592.  
  4593.             Command<COMMAND_ATTACH_CHAR_TO_CAR>(CPools::GetPedRef(ped), CPools::GetVehicleRef(car), x, y, z, place, angle, typeweapon);
  4594.             //this_thread::sleep_for(chrono::milliseconds(10));
  4595.             //0464: put_actor 4@ into_turret_on_car 3@ at_car_offset 0.4242 - 0.0679 1.1322 position 0 angle 360.0 with_weapon 26
  4596.             return 0;
  4597.         }
  4598.         else { throw "bad argument in function ped_in_turret_on_car"; }
  4599.     }
  4600.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4601.     return 0;
  4602. };
  4603.  
  4604. int ped_from_turret_on_car(lua_State* L) { // убрать педа из турели авто.
  4605.     try {
  4606.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {
  4607.  
  4608.             const void* p = lua_topointer(L, 1);
  4609.             CPed* ped = findpedinpool(p);// получить указатель на педа
  4610.            
  4611.             Command<COMMAND_DETACH_CHAR_FROM_CAR>(CPools::GetPedRef(ped));
  4612.             return 0;
  4613.         }
  4614.         else { throw "bad argument in function ped_from_turret_on_car"; }
  4615.     }
  4616.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4617.     return 0;
  4618. };
  4619.  
  4620. int is_button_pressed(lua_State* L) {// если спец клавиша нажата. 
  4621.     try {
  4622.         if (LUA_TNUMBER == lua_type(L, 1)) {// указатель на педа.
  4623.  
  4624.             int button = lua_tointeger(L, 1);/*
  4625.                 0 [*] LEFTSTICKX    Лево право  Влево / вправо
  4626.                 1 [*] LEFTSTICKY    Вперед / назад    Вперед / назад
  4627.                 2 [*] RIGHTSTICKX   Специальные клавиши Ctrl / Вправо  Башня влево / вправо
  4628.                 3 [*] RIGHTSTICKY   Специальный Ctrl Вверх /  Вниз Turret Up / Down, Lean Up     / Down
  4629.                 4 LEFTSHOULDER1     действие  Радио  вторичный огонь
  4630.                 5 LEFTSHOULDER2     Предыдущее оружие      Посмотри налево
  4631.                 6 RIGHTSHOULDER1     цель      Handbrake
  4632.                 7 RIGHTSHOULDER2     Следующее оружие      Смотреть прямо
  4633.                 8 DPADUP      Переслать   Ctrl Ctrl   Следующая радиостанция
  4634.                 9 DPADDOWN    Обратная    группа Ctrl Вперед     Предыдущая радиостанция
  4635.                 10 DPADLEFT      Страф Левый    разговор ­ нет     Рулевое управление слева     Нет
  4636.                 11 DPADRIGHT   Прямой   разговор Страфе ­ Да      Правильно,       да, проезд
  4637.                 12 НАЧАЛО
  4638.                 13 ВЫБРАТЬ      Поменяй камеру
  4639.                 14 КВАДРАТ   прыжок Перейти / Увеличить      Тормоз / Реверс
  4640.                 15 ТРЕУГОЛЬНИК      Ввод / Выход
  4641.                 16 ПЕРЕСЕКАТЬ      Спринт / Уменьшить      ускоряться
  4642.                 17 КРУГ      Атака огонь
  4643.                 18 LEFTSHOCK    пресмыкаться      рожок
  4644.                 19 RIGHTSHOCK   Смотреть за      Суб­миссия
  4645.                 */
  4646.  
  4647.             if (Command<COMMAND_IS_BUTTON_PRESSED>(0, button)) {
  4648.                 lua_pushboolean(L, true);
  4649.                 return 1;
  4650.             }
  4651.             else {
  4652.                 lua_pushboolean(L, false);
  4653.                 return 1;
  4654.             }
  4655.         }
  4656.         else { throw "bad argument in function is_button_pressed"; }
  4657.     }
  4658.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4659.     return 0;
  4660. };
  4661.  
  4662.  
  4663. int getmoney_ped(lua_State* L) { // получить кол-во деньги педа.
  4664.     try {
  4665.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  4666.             const void* p = lua_topointer(L, 1);
  4667.  
  4668.             CPed* ped = findpedinpool(p);// получить указатель на педа
  4669.             int money = ped->m_nPedMoney;
  4670.             lua_pushinteger(L, money);
  4671.             return 1;
  4672.         }
  4673.         else { throw "bad argument in function getmoney_ped"; }
  4674.     }
  4675.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4676.     return 0;
  4677. };
  4678.  
  4679. int setmoney_ped(lua_State* L) { // установить кол-во деньги педа.
  4680.     try {
  4681.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  4682.             const void* p = lua_topointer(L, 1);
  4683.  
  4684.             CPed* ped = findpedinpool(p);// получить указатель на педа
  4685.             int money = lua_tointeger(L, 2); // значение.
  4686.  
  4687.             CPed* player = FindPlayerPed();// найти педа
  4688.  
  4689.             if (ped != player) {
  4690.  
  4691.                 ped->m_nPedFlags.bMoneyHasBeenGivenByScript = false;
  4692.                 //Command<COMMAND_SET_CHAR_MONEY>(CPools::GetPedRef(ped), 0);
  4693.                 //ped->m_nPedMoney = 0; //ped->CreateDeadPedMoney();
  4694.                 //this_thread::sleep_for(chrono::milliseconds(1));
  4695.                 //ped->m_nPedMoney = money;
  4696.                 //this_thread::sleep_for(chrono::milliseconds(1));
  4697.                 Command<COMMAND_SET_CHAR_MONEY>(CPools::GetPedRef(ped), money);
  4698.                 //ped->CreateDeadPedMoney();
  4699.  
  4700.                 return 0;
  4701.             }
  4702.             else {
  4703.                 Command<COMMAND_SET_CHAR_MONEY>(CPools::GetPedRef(ped), money);
  4704.                 return 0;
  4705.             }
  4706.             return 0;
  4707.         }
  4708.         else { throw "bad argument in function setmoney_ped"; }
  4709.     }
  4710.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4711.     return 0;
  4712. };
  4713.  
  4714. int addmoney_ped(lua_State* L) { // добавить кол-во деньги педа.
  4715.     try {
  4716.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  4717.             const void* p = lua_topointer(L, 1);
  4718.  
  4719.             CPed* ped = findpedinpool(p);// получить указатель на педа
  4720.             int money = ped->m_nPedMoney;
  4721.  
  4722.             int money1 = lua_tointeger(L, 2); // значение.
  4723.             int money2 = money1 + money;
  4724.             Command<COMMAND_SET_CHAR_MONEY>(CPools::GetPedRef(ped), 0);
  4725.             this_thread::sleep_for(chrono::milliseconds(1));
  4726.             ped->m_nPedMoney = money2;
  4727.             //Command<COMMAND_SET_CHAR_MONEY>(CPools::GetPedRef(ped), money);
  4728.             return 0;
  4729.         }
  4730.         else { throw "bad argument in function addmoney_ped"; }
  4731.     }
  4732.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4733.     return 0;
  4734. };
  4735.  
  4736. int getgravity(lua_State* L) {// получить значения гравитации.
  4737.     float x = patch::GetFloat(0x68F5F0);
  4738.     lua_pushnumber(L, x);// отправить в стек.
  4739.     return 1;
  4740. };
  4741.  
  4742. int setgravity(lua_State* L) {// установить значения гравитации.
  4743.     try {
  4744.         if (LUA_TNUMBER == lua_type(L, 1)) {// число.
  4745.  
  4746.             float value = lua_tonumber(L, 1); // значение.
  4747.             patch::SetFloat(0x68F5F0, value);
  4748.             return 0;
  4749.         }
  4750.         else { throw "bad argument in function setgravity"; }
  4751.     }
  4752.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4753.     return 0;
  4754. };
  4755.  
  4756. int gravity_default(lua_State* L) {// вернуть значения по умолчанию гравитации.
  4757.  
  4758.     patch::SetFloat(0x68F5F0, 0.008);
  4759.     return 0;
  4760. };
  4761.  
  4762. int get_clip_current_weapon(lua_State* L) {// получить кол-во патронов в обойме текущего оружие.
  4763.     try {
  4764.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {//число.
  4765.  
  4766.             const void* p = lua_topointer(L, 1);
  4767.             CPed* ped = findpedinpool(p);//  получить указатель на педа.
  4768.  
  4769.             CWeapon w = ped->m_aWeapons[ped->m_nActiveWeaponSlot];
  4770.             int clip = w.m_nAmmoInClip;
  4771.             lua_pushinteger(L, clip);
  4772.             return 1;
  4773.         }
  4774.         else { throw "bad argument in function get_clip_current_weapon"; }
  4775.     }
  4776.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4777.     return 0;
  4778. };
  4779.  
  4780. int create_shots_on_ped(lua_State* L) {// создать выстрелы.
  4781.     try {
  4782.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  4783.  
  4784.             const void* p = lua_topointer(L, 1);
  4785.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  4786.  
  4787.             CPed* player = FindPlayerPed();// найти педа
  4788.             CWeapon weapon = player->m_aWeapons[player->m_nActiveWeaponSlot];
  4789.             CVector pos1 = { ped->GetPosition().x, ped->GetPosition().y, float(ped->GetPosition().z + 1.5) };
  4790.             //CWeapon weapon = ped->m_aWeapons[ped->m_nActiveWeaponSlot];
  4791.             CVector* pos0 = (CVector*)& pos1;
  4792.             //Command<COMMAND_SET_CHAR_STAY_IN_SAME_PLACE>(CPools::GetPedRef(ped), 1);// сохранять свою позицию при атаке.                                                                                   
  4793.             for (int i = 0; i < 10000; i++)
  4794.             {
  4795.                 this_thread::sleep_for(chrono::milliseconds(i * 10));
  4796.                 weapon.Fire(ped, pos0);
  4797.                 //weapon.Update(54, ped);
  4798.                 weapon.Reload();
  4799.             }
  4800.             return 0;
  4801.         }
  4802.         else { throw "bad argument in function create_shots_on_ped"; }
  4803.     }
  4804.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4805.     return 0;
  4806. };
  4807.  
  4808. int create_shots_on_car(lua_State* L) {// создать выстрелы.
  4809.     try {
  4810.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)
  4811.             && LUA_TNUMBER == lua_type(L, 3)) {// указатель на педа.
  4812.             const void* p = lua_topointer(L, 1); CVehicle* car = findcarinpool(p);// получить указатель на авто.
  4813.  
  4814.             float height = lua_tonumber(L, 2);
  4815.  
  4816.             int time = lua_tointeger(L, 3);
  4817.             CPed* player = FindPlayerPed();// найти педа
  4818.             CWeapon weapon = player->m_aWeapons[player->m_nActiveWeaponSlot];
  4819.  
  4820.             for (int i = 0; i < 100000; i++) {
  4821.                 float x = car->GetPosition().x;
  4822.                 float y = car->GetPosition().y;
  4823.                 float z = car->GetPosition().z;
  4824.  
  4825.                 CVector pos1 = { x, y, float(z + height) };
  4826.                 CVector* pos0 = (CVector*)& pos1;
  4827.                 weapon.Fire(car, pos0);
  4828.                 //              weapon.Update(54, player);
  4829.                 weapon.Reload();
  4830.                 this_thread::sleep_for(chrono::milliseconds(1));
  4831.             }
  4832.             return 0;
  4833.         }
  4834.         else { throw "bad argument in function create_shots_on_car"; }
  4835.     }
  4836.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4837.     return 0;
  4838. };
  4839.  
  4840. int ped_save_pos_attack(lua_State* L) {// пед сохраняет ли свою позицию при атаке.
  4841.     try {
  4842.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  4843.  
  4844.             const void* p = lua_topointer(L, 1);
  4845.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  4846.             int status = lua_tointeger(L, 2);// 0 или 1.
  4847.             Command<COMMAND_SET_CHAR_STAY_IN_SAME_PLACE>(CPools::GetPedRef(ped), status);// сохранять свою позицию при атаке.                        
  4848.             return 0;
  4849.  
  4850.         }
  4851.         else { throw "bad argument in function ped_save_pos_attack"; }
  4852.     }
  4853.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4854.     return 0;
  4855. };
  4856.  
  4857. int ped_rebuff(lua_State* L) {// пед атакует любого, кто нападает на него.    
  4858.     try {
  4859.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  4860.  
  4861.             const void* p = lua_topointer(L, 1);
  4862.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  4863.             int status = lua_tointeger(L, 2);
  4864.             Command<COMMAND_SET_CHAR_HEED_THREATS>(CPools::GetPedRef(ped), status);// пед атакует любого, кто нападает на него.                                                                         
  4865.             /*
  4866.             0 = не учитывать угрозы, 1 = учитывать угрозы. Вновь порожденный персонаж не реагирует, когда ему угрожает большинство
  4867.             событий, например, его ударили кулаком или собирались сбить машиной. Этот код операции заставляет персонажа учитывать
  4868.             угрозы и реагировать на них соответствующим   образом, например, убегать, атаковать или уклоняться от машины. Игра может
  4869.             заставить персонажа учитывать угрозы самостоятельно в зависимости от условий. Альтернативные документы описывают этот
  4870.             код операции как настройку символа для атаки при провокации.
  4871.             */
  4872.             return 0;
  4873.  
  4874.         }
  4875.         else { throw "bad argument in function ped_rebuff"; }
  4876.     }
  4877.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4878.     return 0;
  4879. };
  4880.  
  4881. int ped_search_threat(lua_State* L) {// пед ищет угрозу.      
  4882.     try {
  4883.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  4884.  
  4885.             const void* p = lua_topointer(L, 1);
  4886.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  4887.             int status = lua_tointeger(L, 2);
  4888.             Command<COMMAND_SET_CHAR_THREAT_SEARCH>(CPools::GetPedRef(ped), status);// пед ищет угрозу.                                                                             
  4889.             /*
  4890. Устанавливает враждебность персонажа к другим типам педов
  4891. Синтаксис 011A: set_actor [ char handle ] search_threat [ int ]
  4892. Параметр[ дескриптор символа ]
  4893. Ручка персонажа [ int ]
  4894. Угроза педа в представлении поля флага
  4895. Этот код операции устанавливает враждебность персонажа по отношению к другим типам педов
  4896. и атакует опасный тип педа при появлении. Действие этого кода операции можно очистить с помощью кода операции 01ED .
  4897. */
  4898.             return 0;
  4899.  
  4900.         }
  4901.         else { throw "bad argument in function ped_search_threat"; }
  4902.     }
  4903.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4904.     return 0;
  4905. };
  4906.  
  4907.  
  4908. int ped_clean_threat(lua_State* L) {// очистить угрозы для педа.      
  4909.     try {
  4910.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  4911.  
  4912.             const void* p = lua_topointer(L, 1);
  4913.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  4914.             Command<COMMAND_CLEAR_CHAR_THREAT_SEARCH>(CPools::GetPedRef(ped));//  очистить угрозы для педа.                                                                         
  4915.  
  4916.             return 0;
  4917.         }
  4918.         else { throw "bad argument in function ped_clean_threat"; }
  4919.     }
  4920.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4921.     return 0;
  4922. };
  4923. int save_car_color(lua_State* L) {// авто сохраняет цвет при перекраске.     
  4924.     try {
  4925.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  4926.  
  4927.             const void* p = lua_topointer(L, 1); CVehicle* car = findcarinpool(p);// получить указатель на авто.
  4928.             int status = lua_tointeger(L, 2);
  4929.             Command<COMMAND_SET_CAN_RESPRAY_CAR>(CPools::GetVehicleRef(car), status);// пед атакует любого, кто нападает на него.                                                                       
  4930.             /*
  4931.              0 = не распыляется, 1 = распыляется
  4932.              Этот код операции позволяет автомобилю сохранять свои цвета при использовании аэрозольного магазина.
  4933.              Распылительный цех не будет генерировать частицы при распылении. Такое поведение эквивалентно перебрасыванию
  4934.              транспортных средств только с одной определенной парой цветов, как Sabre Turbo. Этот код операции не влияет
  4935.              на транспортные средства только с одной определенной парой цветов; поведение не может быть изменено.
  4936.             */
  4937.             return 0;
  4938.  
  4939.         }
  4940.         else { throw "bad argument in function save_car_color"; }
  4941.     }
  4942.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4943.     return 0;
  4944. };
  4945.  
  4946. int is_car_passenger_free(lua_State* L) {// Проверяет, свободно ли место пассажира в авто.
  4947.     try {
  4948.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на авто.
  4949.  
  4950.             const void* p = lua_topointer(L, 1); CVehicle* car = findcarinpool(p);// получить указатель на авто.
  4951.             int place = lua_tointeger(L, 2);
  4952.             bool check = Command<COMMAND_IS_CAR_PASSENGER_SEAT_FREE>(CPools::GetVehicleRef(car), place);//Проверяет, свободно ли место пассажира.
  4953.             lua_pushboolean(L, check);
  4954.             return 1;
  4955.             /*
  4956.             Проверяет, свободно ли место пассажира транспортного средства
  4957.             Синтаксис
  4958.             0431: автомобиль [ ручка автомобиля ] car_passenger_seat_free [ int ]
  4959.             параметр    [ ручка автомобиля ] Ручка транспортного средства
  4960.             [ int ] Номер места   Родной аналог IS_CAR_PASSENGER_SEAT_FREE Этот условный код операции возвращает true,
  4961.             когда пассажирское сиденье транспортного средства свободно. Он возвращает false, когда он не свободен или
  4962.             номер места недействителен.
  4963.  
  4964.             сиденье  Четыре сиденья Двухместная
  4965.             0   переднее правое сиденье    заднее сидение
  4966.             1   заднее левое сиденье
  4967.             2   заднее правое сиденье
  4968.  
  4969.             */
  4970.         }
  4971.         else { throw "bad argument in function is_car_passenger_free"; }
  4972.     }
  4973.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4974.     return 0;
  4975. };
  4976.  
  4977. int set_ped_bleeding(lua_State* L) {// вкл\выкл крованные у педа.     
  4978.     try {
  4979.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  4980.  
  4981.             const void* p = lua_topointer(L, 1);
  4982.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  4983.             int status = lua_tointeger(L, 2);
  4984.             Command<COMMAND_SET_CHAR_BLEEDING>(CPools::GetPedRef(ped), status);// пед ищет угрозу.                                                                          
  4985.             /*
  4986.              0 = отключить (по умолчанию), 1 = включить
  4987.              Этот код операции позволяет персонажу постоянно кровоточить. Текстуры крови размещаются у ног персонажа.
  4988.              Кровь не течет и здоровье персонажа не уменьшается; это просто визуальный эффект.
  4989.             */
  4990.             return 0;
  4991.  
  4992.         }
  4993.         else { throw "bad argument in function set_ped_bleeding"; }
  4994.     }
  4995.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  4996.     return 0;
  4997. };
  4998.  
  4999. int all_exit_from_car(lua_State* L) {// все педы выходят из авто.
  5000.     try {
  5001.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на авто.
  5002.  
  5003.             const void* p = lua_topointer(L, 1); CVehicle* car = findcarinpool(p);// получить указатель на авто.
  5004.             int place = lua_tointeger(L, 2);
  5005.             Command<COMMAND_SET_ALL_OCCUPANTS_OF_CAR_LEAVE_CAR>(CPools::GetVehicleRef(car), place); //все педы выходят из авто.
  5006.             return 0;
  5007.         }
  5008.         else { throw "bad argument in function all_exit_from_car"; }
  5009.     }
  5010.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5011.     return 0;
  5012. };
  5013.  
  5014. int is_ped_duck(lua_State* L) {// Проверяет, пед присел.
  5015.     try {
  5016.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  5017.  
  5018.             const void* p = lua_topointer(L, 1);
  5019.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5020.             bool check = Command<COMMAND_IS_CHAR_DUCKING>(CPools::GetPedRef(ped)); //Проверяет, пед присел.
  5021.             lua_pushboolean(L, check);
  5022.             return 1;
  5023.         }
  5024.         else { throw "bad argument in function is_ped_duck"; }
  5025.     }
  5026.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5027.     return 0;
  5028. };
  5029.  
  5030. int set_car_tank(lua_State* L) {// установить способность танка детонировать авто при контакте.
  5031.     try {
  5032.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на авто.
  5033.  
  5034.             const void* p = lua_topointer(L, 1); CVehicle* car = findcarinpool(p);// получить указатель на авто.
  5035.             int switc = lua_tointeger(L, 2);
  5036.             /*
  5037.             Устанавливает способность танка взрывать транспортные средства при контакте
  5038.             0493: set_tank [ автомобильная ручка ] contact_explosion [ int ] параметр
  5039.             [ ручка автомобиля ] Ручка цистерны [ int ]
  5040.             0 = не детонировать транспортные средства, 1 = детонировать транспортные средства (по умолчанию)
  5041.             Этот код операции устанавливает способность Rhino детонировать другие транспортные средства при контакте.
  5042.             Код операции не влияет на другие транспортные средства.
  5043.             */
  5044.             Command<COMMAND_SET_TANK_DETONATE_CARS>(CPools::GetVehicleRef(car), switc); // установить способность танка на авто.
  5045.             return 0;
  5046.         }
  5047.         else { throw "bad argument in function all_exit_from_car"; }
  5048.     }
  5049.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5050.     return 0;
  5051. };
  5052.  
  5053. int set_display_radar(lua_State* L) {// показать скрывать радар.
  5054.     try {
  5055.         if (LUA_TNUMBER == lua_type(L, 1)) {// радар.
  5056.  
  5057.             int radar = lua_tointeger(L, 1);
  5058.  
  5059.             Command<COMMAND_DISPLAY_RADAR>(radar); // показать скрывать радар.
  5060.             return 0;
  5061.         }
  5062.         else { throw "bad argument in function set_display_radar"; }
  5063.     }
  5064.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5065.     return 0;
  5066. };
  5067. /*
  5068. function set_ped_in_car(car, ped, place)  -- уст водителя авто.
  5069.  local place = place or nil
  5070.  local m, t = Get_model_and_type_ped(ped)
  5071.  loadmodel(m)
  5072.  load_requested_models()
  5073. while not availablemodel(m) do wait(1) loadmodel(m) end
  5074.  if place == nil
  5075.   then local driver = setcardrive(car,m,t)
  5076.   else local driver = setcarpassenger(car,m,t,place)
  5077. end
  5078. releasemodel(m)
  5079. return driver
  5080. end
  5081. */
  5082. CVehicle* func_auxiliary_set_ped_in_car(lua_State* L, int& model, int& type) {//вспомогательная функция.
  5083.  
  5084.     const void* p = lua_topointer(L, 1);  CVehicle* car = findcarinpool(p);// получить указатель на авто.
  5085.     const char* name_ped = lua_tostring(L, 2); // имя педа
  5086.     model = find_in_map(name_peds_list, name_ped);// модель педа.
  5087.     type = find_in_map(type_peds_list, name_ped);// тип педа.
  5088.     //CWorld::Players[CWorld::PlayerInFocus].m_nMoney += model;// дать денег
  5089.     this_thread::sleep_for(chrono::milliseconds(1));
  5090.     load_model_before_avalible(model); // загрузить модель полносттью.
  5091.     return car;
  5092. };
  5093.  
  5094. int set_ped_in_car(lua_State* L) {// установить педа в авто как водителя или пассажира.
  5095.     int size_agrs = lua_gettop(L);// кол-во аргументов.
  5096.     CPed* ped = NULL; CVehicle* car = NULL; int model; int type;
  5097.     if (size_agrs == 2) {
  5098.         try {// установить водителя.
  5099.             if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TSTRING == lua_type(L, 2)) {// указатель на авто и имя педа.
  5100.                 car = func_auxiliary_set_ped_in_car(L, model, type);
  5101.                 Command<COMMAND_CREATE_CHAR_INSIDE_CAR>(CPools::GetVehicleRef(car), type, model, &ped);
  5102.                 car->m_autoPilot.m_nCarMission = MISSION_NONE;
  5103.                 lua_pushlightuserdata(L, ped);
  5104.                 Command<COMMAND_MARK_MODEL_AS_NO_LONGER_NEEDED>(model);
  5105.                 return 1;
  5106.             }
  5107.             else { throw "bad argument in function set_ped_in_car"; }
  5108.         }
  5109.         catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5110.     }
  5111.     if (size_agrs == 3) {
  5112.         try {// установить пассажира.
  5113.             if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TSTRING == lua_type(L, 2)
  5114.                 && LUA_TNUMBER == lua_type(L, 3)) {// указатель на авто и имя педа.
  5115.                 int place = lua_tointeger(L, 3);// место в авто.
  5116.                 car = func_auxiliary_set_ped_in_car(L, model, type);
  5117.  
  5118.                 Command<COMMAND_CREATE_CHAR_AS_PASSENGER>(CPools::GetVehicleRef(car), type, model, place, &ped);
  5119.                 lua_pushlightuserdata(L, ped);
  5120.                 Command<COMMAND_MARK_MODEL_AS_NO_LONGER_NEEDED>(model);
  5121.                 return 1;
  5122.             }
  5123.             else { throw "bad argument in function set_ped_in_car"; }
  5124.         }
  5125.         catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5126.     }
  5127.     return 0;
  5128. };
  5129.  
  5130. int set_ped_traffic(lua_State* L) {// установить плотноcть трафика педов.
  5131.     try {//03DE
  5132.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  5133.             float trafic = lua_tonumber(L, 1);
  5134.             Command<COMMAND_SET_PED_DENSITY_MULTIPLIER>(trafic);
  5135.             return 0;
  5136.         }
  5137.         else { throw "bad argument in function set_ped_traffic"; }
  5138.     }
  5139.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5140.     return 0;
  5141. };
  5142.  
  5143. int heli_to_fly(lua_State* L) {// вертолет летит на координаты.
  5144.     try {// 04A2 heli $1379 fly_to - 1721.964 - 275.942 40.959 speed 40
  5145.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  5146.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5)) {// значение число.
  5147.  
  5148.             const void* p1 = lua_topointer(L, 1);
  5149.             CVehicle* car = findcarinpool(p1);//  получить указатель на авто.
  5150.             float x = lua_tonumber(L, 2); float y = lua_tonumber(L, 3);
  5151.             float z = lua_tonumber(L, 4); int speed = lua_tonumber(L, 4);
  5152.             CVector pos = { x, y, z };// вектор координат.
  5153.             Command<COMMAND_HELI_GOTO_COORDS>(CPools::GetVehicleRef(car), pos.x, pos.y, pos.z, speed);// вертолет летит на координаты.
  5154.             return 0;
  5155.         }// int
  5156.  
  5157.         else { throw "bad argument in function heli_to_fly"; }
  5158.     }
  5159.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5160.     return 0;
  5161. };
  5162.  
  5163. int set_ped_immunities(lua_State* L) {// уст иммунитеты педу.
  5164.     try {// 02AB: set_actor $1375 immunities BP 1 FP 1 EP 1 CP 1 MP 1
  5165.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  5166.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5) && LUA_TNUMBER == lua_type(L, 6)) {// значение число.
  5167.            
  5168.             const void* p = lua_topointer(L, 1);
  5169.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5170.  
  5171.             int bu = lua_tonumber(L, 2); int fi = lua_tonumber(L, 3);
  5172.             int ex = lua_tonumber(L, 4); int col = lua_tonumber(L, 5);  int cw = lua_tonumber(L, 6);
  5173.     /*
  5174.         0@ [byte] - иммунитет на пули(true/false)
  5175.         1@ [byte] - иммунитет на огонь(true/false)
  5176.         2@ [byte] - иммунитет на взрывы(true/false)
  5177.         3@ [byte] - иммунитет на столкновения/падения(true/false)
  5178.         4@ [byte] - иммунитет на холодное оружие/кулаки(true/false)
  5179.     */
  5180.  
  5181.             Command<COMMAND_SET_CHAR_PROOFS>(CPools::GetPedRef(ped), bu, fi, col, cw);// уст иммунитеты педу.
  5182.             return 0;
  5183.         }// int
  5184.  
  5185.         else { throw "bad argument in function set_ped_immunities"; }
  5186.     }
  5187.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5188.     return 0;
  5189. };
  5190.  
  5191. int set_car_immunities(lua_State* L) {// уст иммунитеты авто.
  5192.     try {// 02AC: set_car 0@ immunities 1 1 1 1 1
  5193.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  5194.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TNUMBER == lua_type(L, 5) && LUA_TNUMBER == lua_type(L, 6)) {// значение число.
  5195.  
  5196.             const void* p1 = lua_topointer(L, 1);
  5197.             CVehicle* car = findcarinpool(p1);//  получить указатель на авто.
  5198.            
  5199.             int bu = lua_tonumber(L, 2); int fi = lua_tonumber(L, 3);
  5200.             int ex = lua_tonumber(L, 4); int col = lua_tonumber(L, 5);  int cw = lua_tonumber(L, 6);
  5201.             /*
  5202.                 0@ [byte] - иммунитет на пули(true/false)
  5203.                 1@ [byte] - иммунитет на огонь(true/false)
  5204.                 2@ [byte] - иммунитет на взрывы(true/false)
  5205.                 3@ [byte] - иммунитет на столкновения/падения(true/false)
  5206.                 4@ [byte] - иммунитет на холодное оружие/кулаки(true/false)
  5207.             */
  5208.  
  5209.             Command<COMMAND_SET_CAR_PROOFS>(CPools::GetVehicleRef(car), bu, fi, col, cw);// уст иммунитеты авто.
  5210.             return 0;
  5211.         }// int
  5212.  
  5213.         else { throw "bad argument in function set_car_immunities"; }
  5214.     }
  5215.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5216.     return 0;
  5217. };
  5218.  
  5219. int set_camera_on_car(lua_State* L) {// уст камеру на авто.
  5220.     try {// 0158: camera_on_vehicle $789 mode 15 switchstyle 2
  5221.  
  5222.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)) {// значение число.
  5223.  
  5224.             const void* p1 = lua_topointer(L, 1);
  5225.             CVehicle* car = findcarinpool(p1);//  получить указатель на авто.
  5226.  
  5227.             int mode = lua_tonumber(L, 2); int style = lua_tonumber(L, 3);
  5228.        
  5229.  
  5230.             Command<COMMAND_POINT_CAMERA_AT_CAR>(CPools::GetVehicleRef(car), mode, style);//  уст камеру на авто.
  5231.             return 0;
  5232.         }// int
  5233.  
  5234.         else { throw "bad argument in function set_camera_on_car"; }
  5235.     }
  5236.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5237.     return 0;
  5238. };
  5239.  
  5240. int setcolourmarker(lua_State* L) {// установить цвет маркера.
  5241.     try {
  5242.         if (LUA_TNUMBER == lua_type(L, 1) && (LUA_TNUMBER == lua_type(L, 2))) {
  5243.             int marker = lua_tointeger(L, 1);// Время.
  5244.             int colour = lua_tointeger(L, 2);// размер маркера.
  5245.             Command<COMMAND_CHANGE_BLIP_COLOUR>(marker, colour);
  5246.             return 0;
  5247.         }
  5248.         else { throw "bad argument in function setcolourmarker"; }
  5249.     }
  5250.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5251.     return 0;
  5252. };
  5253.  
  5254. int select_interiour(lua_State* L) {// уcтановить интерьер.
  5255.     try {// 04BB: select_interiour 0 // select render area.
  5256.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  5257.             int interior = lua_tointeger(L, 1);// интерьер.
  5258.             Command<COMMAND_SET_AREA_VISIBLE>(interior);
  5259.             return 0;
  5260.         }
  5261.         else { throw "bad argument in function select_interiour"; }
  5262.     }
  5263.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5264.     return 0;
  5265. };
  5266.  
  5267. int set_ped_stats_to(lua_State* L) {// уст поведения педа.     
  5268.     try {// 0243: set_actor $1374 ped_stats_to 16.
  5269.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  5270.  
  5271.             const void* p = lua_topointer(L, 1);
  5272.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5273.             int status = lua_tointeger(L, 2);
  5274.             Command<COMMAND_SET_CHAR_PERSONALITY>(CPools::GetPedRef(ped), status);// уст поведения педа.       
  5275.             return 0;
  5276.  
  5277.         }
  5278.         else { throw "bad argument in function set_ped_stats_to"; }
  5279.     }
  5280.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5281.     return 0;
  5282. };
  5283.  
  5284. int ped_maintain_position_when_attacked(lua_State* L) {// пед удерживает позицию при атаке.    
  5285.     try {// 0350: set_actor $1374 maintain_position_when_attacked 1.
  5286.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  5287.  
  5288.             const void* p = lua_topointer(L, 1);
  5289.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5290.             int status = lua_tointeger(L, 2);
  5291.             Command<COMMAND_SET_CHAR_STAY_IN_SAME_PLACE>(CPools::GetPedRef(ped), status);// уст поведения педа.    
  5292.             return 0;
  5293.  
  5294.         }
  5295.         else { throw "bad argument in function ped_maintain_position_when_attacked"; }
  5296.     }
  5297.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5298.     return 0;
  5299. };
  5300.  
  5301. int set_timer_ped_attack(lua_State* L) {// установить таймер атаки педа.      
  5302.     try {// 0483: set_actor $1374 cease_attack_timer 1500
  5303.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  5304.  
  5305.             const void* p = lua_topointer(L, 1);
  5306.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5307.             int time = lua_tointeger(L, 2);
  5308.             Command<COMMAND_SET_CHAR_CEASE_ATTACK_TIMER>(CPools::GetPedRef(ped), time);// установить таймер атаки педа.           
  5309.             return 0;
  5310.  
  5311.         }
  5312.         else { throw "bad argument in function set_timer_ped_attack"; }
  5313.     }
  5314.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5315.     return 0;
  5316. };
  5317.  
  5318. int set_path_to_module(lua_State* L) {// уст путь к модулю.
  5319.  
  5320.     char str123[255];
  5321.     auto j = std::experimental::filesystem::current_path();
  5322.     string c1 = j.string(); c1 = c1 + "\\?.lua"; strcpy(str123, c1.c_str());
  5323.     lua_pushstring(L, str123);  lua_setglobal(L, "fullpath");
  5324.     luaL_dostring(L, "package.path = fullpath");
  5325.     return 0;
  5326. };
  5327.  
  5328. int load_and_start_luascript(lua_State* L, char* luafile, string res) {// загрузка и запуск скрипта.
  5329.  
  5330.     listfile.push_back(luafile);// добавить текущий lua файл в list.
  5331.     lua_gc(L, LUA_GCSTOP, 1);// отключить сборщик мусора.
  5332.     lua_pushlightuserdata(L, L); // ключ в реестр указатель на L.
  5333.     lua_pushstring(L, luafile); // отправить имя текущего lua файла в реестр.
  5334.     lua_settable(L, LUA_REGISTRYINDEX); // установить ключа и значение таблице реестре.
  5335.  
  5336.     string er0 = "loaded " + res;// перед имени текущего lua файла добавить loaded.
  5337.     char* x = strdup(er0.c_str());// преобразовать строку в char*.
  5338.     writelog(x);// запись резуальтат проверки на ошибки.
  5339.     lua_pcall(L, 0, 0, 0);// запуск файла.
  5340.  
  5341.     return 0;
  5342. };
  5343.  
  5344. int set_cops_ignored(lua_State* L) {// установить игнор копов.
  5345.     try {//03BF: set_player $PLAYER_CHAR ignored_by_everyone_to 0
  5346.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  5347.             int status = lua_toboolean(L, 1);
  5348.  
  5349.             Command<COMMAND_SET_EVERYONE_IGNORE_PLAYER>(CWorld::PlayerInFocus, status);
  5350.             return 0;
  5351.         }
  5352.         else { throw "bad argument in function set_cops_ignored"; }
  5353.     }
  5354.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5355.     return 0;
  5356. };
  5357.  
  5358. int set_camera_near_clip(lua_State* L) {// установить обрезку камеры.
  5359.     try {// 041D: set_camera_near_clip 0.1 .
  5360.         if (LUA_TNUMBER == lua_type(L, 1)) {
  5361.             float value = lua_tonumber(L, 1);
  5362.             Command<COMMAND_SET_NEAR_CLIP>(value);  /*
  5363.             Значение возле клипа, по умолчанию 0,9 Этот код операции устанавливает ближний клип камеры.
  5364.             Все, что ближе к камере, чем указанное значение, будет обрезано игрой, как показано на рисунке ниже.
  5365.             Эффект этого кода операции сбрасывается до значения по умолчанию 0,9 каждый раз, когда очищается заставка.
  5366.             Небольшие значения, близкие или равные 0,0 , вызовут странные графические сбои, а отрицательные значения
  5367.             обрезают все, что может быть обрезано, поэтому эти значения не рекомендуются. Код операции обычно используется
  5368.             во время кат-сцен, но его можно использовать в любое время.  */
  5369.             return 0;
  5370.         }
  5371.         else { throw "bad argument in function set_camera_near_clip"; }
  5372.     }
  5373.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5374.     return 0;
  5375. };
  5376.  
  5377. int setpedcrouch(lua_State* L) {// пед сел.
  5378.     try {
  5379.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TBOOLEAN == lua_type(L, 2)
  5380.             && LUA_TNUMBER == lua_type(L, 3)) {// указатель на педа.
  5381.  
  5382.             const void* p = lua_topointer(L, 1);
  5383.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5384.             bool sw = lua_toboolean(L, 2);
  5385.             int time = lua_tonumber(L, 3);//
  5386.             Command<COMMAND_SET_CHAR_CROUCH>(CPools::GetPedRef(ped), sw, time);
  5387.             return 0;
  5388.         /*
  5389.         Описание    Заставляет персонажа приседать.
  5390.         Параметры (v2) 1) Дескриптор актора (Целое число) (INT)
  5391.         2) Логическое значение (1 или 0) (INT)
  5392.         Vice City
  5393.         sascm.ini   04EB = 3, от set_char_crouch% 1d% до% 2h% set_char_crouch% 3d%
  5394.         пример    04EB: set_char_crouch $ 854 до 0 раз 9999999
  5395.         */
  5396.         }
  5397.         else { throw "bad argument in function setpedcrouch"; }
  5398.     }
  5399.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5400.     return 0;
  5401. };
  5402. int is_ped_incar(lua_State* L) {// пед в авто или нет?
  5403.     try {
  5404.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  5405.  
  5406.             const void* p = lua_topointer(L, 1);
  5407.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5408.             if (ped->m_bInVehicle ) {// в авто пед?
  5409.                
  5410.                 lua_pushboolean(L, true);
  5411.                 return 1;
  5412.             }
  5413.             else {
  5414.                     lua_pushboolean(L, false);
  5415.                 return 1;// получить указатель на хенлд авто в котором сидит пед.
  5416.             }
  5417.         }
  5418.         else { throw "bad argument in function is_ped_in_car"; }
  5419.     }
  5420.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5421. };
  5422. int delete_entity(lua_State* L) {// удалить сущность сразу.
  5423.     try {
  5424.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// значение объект.
  5425.             const void* p = lua_topointer(L, 1);
  5426.             CEntity* p1 = (CEntity*)p;
  5427.             if (p1 != NULL) {//obj->Remove();
  5428.                 CWorld::Remove(p1);
  5429.             }
  5430.             return 0;
  5431.         }
  5432.         else { throw "bad argument in function remove_obj"; }
  5433.     }
  5434.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5435.     return 0;
  5436. };
  5437.  
  5438. int clean_leader(lua_State* L) {// перестать следовать за лидером.
  5439.     try {
  5440.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  5441.  
  5442.             const void* p = lua_topointer(L, 1);
  5443.             CPed* ped = findpedinpool(p);//  получить указатель на авто.
  5444.             Command<COMMAND_LEAVE_GROUP>(CPools::GetPedRef(ped));
  5445.             return 0;
  5446.         }
  5447.         else { throw "bad argument in function clean_leader"; }
  5448.     }
  5449.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5450.     return 0;
  5451. };
  5452.  
  5453. int show_save_menu(lua_State* L) {// показать меню сохранения.
  5454.  
  5455.     Command<COMMAND_ACTIVATE_SAVE_MENU>();
  5456.  
  5457.     return 0;
  5458. };
  5459.  
  5460. int is_ped_shooting(lua_State* L) {// пед стреляет?.
  5461.     try {
  5462.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на педа.
  5463.  
  5464.             const void* p = lua_topointer(L, 1);
  5465.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5466.             CPed* player = FindPlayerPed();// найти игрока.
  5467.    
  5468.             if (ped != player) {
  5469.                 bool res = Command<COMMAND_IS_CHAR_SHOOTING>(CPools::GetPedRef(ped));
  5470.                 lua_pushboolean(L, res);
  5471.                 return 1;
  5472.             }
  5473.             else {
  5474.                 bool res = Command<COMMAND_IS_PLAYER_SHOOTING>(CWorld::PlayerInFocus);
  5475.                 lua_pushboolean(L, res);
  5476.                 return 1;
  5477.             }
  5478.         }
  5479.         else { throw "bad argument in function is_ped_shooting"; }
  5480.     }
  5481.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5482.     return 0;
  5483. };
  5484.  
  5485. int set_ped_visible(lua_State* L) {// уст невидимость педу.
  5486.     try {
  5487.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  5488.  
  5489.             const void* p = lua_topointer(L, 1);
  5490.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5491.             CPed* player = FindPlayerPed();// найти педа
  5492.             int status = lua_tointeger(L, 2);// тип оружие.
  5493.  
  5494.             if (ped != player) {
  5495.                 Command<COMMAND_SET_CHAR_VISIBLE>(CPools::GetPedRef(ped), status);
  5496.                 return 0;
  5497.             }
  5498.             else {
  5499.                 Command<COMMAND_SET_PLAYER_VISIBLE>(CWorld::PlayerInFocus, status);
  5500.                 return 0;
  5501.             }
  5502.         }
  5503.         else { throw "bad argument in function set_ped_visible"; }
  5504.     }
  5505.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5506.     return 0;
  5507. };
  5508.  
  5509. int set_player_mod(lua_State* L) {// уст настроения игрока.
  5510.     try {
  5511.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  5512.  
  5513.             int tip = lua_tointeger(L, 1);  int time = lua_tointeger(L, 2);
  5514.             /*  04E3
  5515.                 Описание    Устанавливает настроение игроков, влияя на диалоги, которые произносит игрок.
  5516.                 Первый параметр (индекс игрока) игнорируется.
  5517.                 Применимые режимы: 1, 5, 7 и 9.
  5518.  
  5519.                 1 - Angry
  5520.                 5 - Calm
  5521.                 7 - Pissed
  5522.                 9 - Wisecrack
  5523.                 Параметры (v2) 1) Дескриптор проигрывателя (Целое число) (INT)
  5524.                 2) Целое число (INT)
  5525.                 3) Время в мс (Целое число) (INT)
  5526.             */
  5527.  
  5528.             Command<COMMAND_SET_PLAYER_MOOD>(CWorld::PlayerInFocus, tip, time);;//
  5529.         }
  5530.         else { throw "bad argument in function set_player_mod"; }
  5531.     }
  5532.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5533. };
  5534.  
  5535. int setped_damaged_player(lua_State* L) {// педу может нанести ущерб только игрок.
  5536.     try {
  5537.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TBOOLEAN == lua_type(L, 2)) {// указатель на педа.
  5538.  
  5539.             const void* p = lua_topointer(L, 1);
  5540.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5541.             bool sw = lua_toboolean(L, 2);
  5542.             Command<COMMAND_SET_CHAR_ONLY_DAMAGED_BY_PLAYER>(CPools::GetPedRef(ped), 0);
  5543.             return 0;
  5544.             /*
  5545.          Делает актера неуязвимым для всего, кроме игрока.
  5546.          Параметры (v2)    1) Дескриптор актора (Целое число) (INT)
  5547.         2) Логическое значение (1 или 0) (INT)
  5548.             */
  5549.         }
  5550.         else { throw "bad argument in function setped_damaged_player"; }
  5551.     }
  5552.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5553.     return 0;
  5554. };
  5555.  
  5556. int set_ped_reaction_threat(lua_State* L) {// уст реакцию педа на ответную угрозу.
  5557.     try {
  5558.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TBOOLEAN ==(L, 2)) {// указатель на педа.
  5559.  
  5560.             const void* p = lua_topointer(L, 1);
  5561.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5562.             bool sw = lua_toboolean(L, 2);
  5563.             Command<COMMAND_SET_CHAR_THREAT_REACTION>(CPools::GetPedRef(ped),sw);// уст реакцию педа на ответную угрозу.
  5564.  
  5565.             return 0;
  5566.         }
  5567.         else { throw "bad argument in function set_ped_reaction_threat"; }
  5568.     }
  5569.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5570.     return 0;
  5571. };
  5572.  
  5573. int obj_target(lua_State* L) {// в объект можно целиться.
  5574.     try {
  5575.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TBOOLEAN == (L, 2)) {// значение объект.
  5576.             const void* p = lua_topointer(L, 1);
  5577.             CObject* obj = findobjinpool(p);// получить указатель на объект.
  5578.             bool sw = lua_toboolean(L, 2);
  5579.             Command<COMMAND_MAKE_OBJECT_TARGETTABLE>(CPools::GetObjectRef(obj), sw);// удалить объект.
  5580.  
  5581.             return 0;
  5582.         }
  5583.         else { throw "bad argument in function obj_target"; }
  5584.     }
  5585.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5586.     return 0;
  5587. };
  5588.  
  5589. int clean_ped_wait(lua_State* L) {// пед больше не ждет.
  5590.     try {
  5591.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TBOOLEAN == (L, 2)) {// указатель на педа.
  5592.  
  5593.             const void* p = lua_topointer(L, 1);
  5594.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5595.             Command<COMMAND_CLEAR_CHAR_WAIT_STATE>(CPools::GetPedRef(ped));// пед больше не ждет.
  5596.  
  5597.             return 0;
  5598.         }
  5599.         else { throw "bad argument in function clean_ped_wait"; }
  5600.     }
  5601.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5602.     return 0;
  5603. };
  5604.  
  5605. int set_ped_accuracy(lua_State* L) {// уст меткость педу.
  5606.     try {
  5607.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на педа.
  5608.  
  5609.             const void* p = lua_topointer(L, 1);
  5610.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5611.             CPed* player = FindPlayerPed();// найти педа
  5612.             int accuracy = lua_tointeger(L, 2);// тип меткость.
  5613.             Command<COMMAND_SET_CHAR_ACCURACY>(CPools::GetPedRef(ped), accuracy);
  5614.             return 0;
  5615.         }
  5616.         else { throw "bad argument in function set_ped_accuracy"; }
  5617.     }
  5618.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5619.     return 0;
  5620. };
  5621.  
  5622. int textbox(lua_State* L) {// вывести сообщение в textbox.
  5623.     try {
  5624.         if (LUA_TSTRING == lua_type(L, 1) ) {//строка.
  5625.             const char* c = lua_tostring(L, 1);// строка.
  5626.             wchar_t* str = getwchat(c);
  5627.  
  5628.             Command<COMMAND_PRINT_HELP>(c);// вывести сообщение в textbox.
  5629.             return 0;
  5630.         }
  5631.         else { throw "bad argument in function textbox"; }
  5632.     }
  5633.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5634.     return 0;
  5635. };
  5636.  
  5637. int remove_textbox(lua_State* L) {// удалить сообщение на textbox.
  5638.  
  5639.     Command<COMMAND_CLEAR_HELP>();// удалить сообщение на textbox.
  5640.    
  5641.     return 0;
  5642. };
  5643.  
  5644. int get_controller(lua_State* L) {// получить контролер от игрока.
  5645.     int mod;
  5646.     Command<COMMAND_GET_CONTROLLER_MODE>(mod);
  5647.     lua_pushinteger(L, mod);
  5648.     return 1;
  5649. };
  5650.  
  5651. int create_pickup_clothes(lua_State* L) {// создать пикап одежды.
  5652.     try {
  5653.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  5654.             && LUA_TNUMBER == lua_type(L, 4)) {
  5655.             int model = lua_tointeger(L, 1); // модель пикапа.
  5656.              
  5657.             float x = lua_tonumber(L, 2);   float y = lua_tonumber(L, 3);
  5658.             float z = lua_tonumber(L, 4);// координаты.
  5659.             int idpickup;
  5660.             CVector pos = { x, y, z };
  5661.             Command<COMMAND_CREATE_CLOTHES_PICKUP>(model, pos.x, pos.y, pos.z, &idpickup);
  5662.             pickupsids.emplace(idpickup, L);// добавить в map пикапов.
  5663.             lua_pushinteger(L, idpickup);// отправить id пикапа в стек.  
  5664.             return 1;
  5665.         }
  5666.         else { throw "bad argument in function create_pickup_clothes"; }
  5667.     }
  5668.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5669.     return 0;
  5670. };
  5671.  
  5672. int set_riot_intensity(lua_State* L) {// уст уровень шума беспорядков.
  5673.     try {
  5674.         if (LUA_TNUMBER == lua_type(L, 1)) {
  5675.             int level = lua_tointeger(L, 1); // модель пикапа.
  5676.             /*Устанавливает интенсивность шума беспорядков
  5677. Синтаксис
  5678. 0552: set_riot_noise [ int ]
  5679. Параметр
  5680. [ int ]
  5681. Интенсивность от 0 до 255
  5682. Этот код операции устанавливает интенсивность шума бунта, который воспроизводится Law4Riot.mp3 аудиофайлом.
  5683. Шум беспорядков можно услышать только в жестко запрограммированном месте с центром в точках x = 300,7, y = -322,0, z = 12,0
  5684. в радиусе 65,0 единиц . Шум не слышен в автомобиле или в салоне, за исключением салона 13. Интенсивность устанавливается на 0,
  5685. когда выполняется очистка миссии . Оригинальный сценарий называется этот опкод во время «Riot».
  5686.             */
  5687.             Command<COMMAND_SET_RIOT_INTENSITY>(level);
  5688.              
  5689.             return 0;
  5690.         }
  5691.         else { throw "bad argument in function set_riot_intensity"; }
  5692.     }
  5693.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5694.     return 0;
  5695. };
  5696.  
  5697. int set_ped_walk_style(lua_State* L) {// установить стиль ходьбы педа.
  5698.     try {// 0245: set_actor $2251 walk_style_to 50
  5699.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2)) {// указатель на авто.
  5700.  
  5701.             const void* p = lua_topointer(L, 1);
  5702.             CPed* ped = findpedinpool(p);// получить указатель на педа.
  5703.             int style = lua_tonumber(L, 2);// стиль ходьбы авто.
  5704.             CPed* player = FindPlayerPed();// найти игрока.
  5705.             if (ped == player) {
  5706.                 Command<COMMAND_SET_ANIM_GROUP_FOR_PLAYER>(CWorld::PlayerInFocus, style);
  5707.                 return 0;
  5708.             }
  5709.             else {
  5710.                 Command<COMMAND_SET_ANIM_GROUP_FOR_CHAR>(CPools::GetPedRef(ped), style);
  5711.                 return 0;
  5712.             }
  5713.         }
  5714.         else { throw "bad argument in function set_ped_walk_style"; }
  5715.     }
  5716.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5717.     return 0;
  5718. };
  5719.  
  5720. int check_car_resray(lua_State* L) {// проверить авто игрока было перекрашена в гараже.
  5721.     try {//0329:   garage $684 respray_done .
  5722.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  5723.             int number = lua_tointeger(L, 1);// номер гаража.
  5724.             //Возвращает истину, если машина игрока была перекрашена в гараже.
  5725.             bool check = Command<COMMAND_HAS_RESPRAY_HAPPENED>(number);
  5726.             lua_pushboolean(L, check);
  5727.             return 1;
  5728.         }
  5729.         else { throw "bad argument in function check_car_resray"; }
  5730.     }
  5731.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5732.     return 0;
  5733. };
  5734.  
  5735. int set_car_range(lua_State* L) {// установить множитель диапазона на угрозу для автомобиля.
  5736.     try {//0481: set_enter_car_range_multiplier 6.0
  5737.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  5738.              float force = lua_tointeger(L, 1);// номер гаража.
  5739.              Command<COMMAND_SET_ENTER_CAR_RANGE_MULTIPLIER>(force);
  5740.             return 0;
  5741.         }
  5742.         else { throw "bad argument in function set_car_range"; }
  5743.     }
  5744.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5745.     return 0;
  5746. };
  5747.  
  5748. int set_ped_range(lua_State* L) {// установить множитель диапазона на угрозу для педа.
  5749.     try {//0481: set_enter_car_range_multiplier 6.0
  5750.         if (LUA_TNUMBER == lua_type(L, 1)) {// значение число.
  5751.             float force = lua_tointeger(L, 1);// номер гаража.
  5752.             Command<COMMAND_SET_THREAT_REACTION_RANGE_MULTIPLIER>(force);
  5753.             return 0;
  5754.         }
  5755.         else { throw "bad argument in function set_ped_range"; }
  5756.     }
  5757.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5758.     return 0;
  5759. };
  5760.  
  5761. int getcarangle(lua_State* L) {// получить угол авто
  5762.     try {
  5763.         if (LUA_TLIGHTUSERDATA == lua_type(L, 1)) {// указатель на авто.
  5764.  
  5765.             const void* p = lua_topointer(L, 1);
  5766.             CVehicle* car= findcarinpool(p);// получить указатель на авто.
  5767.             float angle;// переменная хранить угол авто.
  5768.             angle = car->GetHeading();// получить угол авто
  5769.             lua_pushinteger(L, angle);// отправить в стек.  
  5770.             return 1;
  5771.         }
  5772.         else { throw "bad argument in function getcarangle option of the car"; }
  5773.     }
  5774.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5775.     return 0;
  5776. };
  5777.  
  5778. int cleanarea(lua_State* L) {//очистить арену.
  5779.     try {
  5780.         //0395: clear_area 0 at 473.713 - 149.895 10.546 range 1.0
  5781.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TNUMBER == lua_type(L, 2) && LUA_TNUMBER == lua_type(L, 3)
  5782.             && LUA_TNUMBER == lua_type(L, 4) && LUA_TBOOLEAN == lua_type(L, 5)) {
  5783.             /*  Очищает область с указанными координатами, удаляя все транспортные средства и пешеходов.
  5784.             Если первый логический параметр установлен на 1, все снаряды и частицы удаляются, даже если они не находятся в указанной области.
  5785. Параметры (v2) 1) Координата X (Float) (FLOAT)
  5786. 2) Координата Y (Float) (FLOAT)
  5787. 3) Координата Z (Float) (FLOAT)
  5788. 4) Радиус (Float) (FLOAT)
  5789. 5) Логическое значение (1 или 0) (INT)*/
  5790.             float x = lua_tonumber(L, 1); float y = lua_tonumber(L, 2);
  5791.             float z = lua_tonumber(L, 3);
  5792.             float r = lua_tonumber(L, 4);
  5793.             bool s = lua_toboolean(L, 5);  
  5794.             CVector pos = { x, y, z };
  5795.             Command<COMMAND_CLEAR_AREA>(s, r, pos.x, pos.y, pos.z);
  5796.             return 0;
  5797.         }
  5798.         else { throw "bad argument in function cleanarea"; }
  5799.     }
  5800.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5801.     return 0;
  5802. };
  5803.  
  5804. int set_brakes_car(lua_State* L) {//уст тормоза авто игрока.
  5805.     try {
  5806.         //0221: set_player $PLAYER_CHAR apply_brakes_to_car 1
  5807.         if (LUA_TBOOLEAN == lua_type(L, 1)) {
  5808.             /*  Описание    Применяет тормоза к машине игрока.
  5809. Параметры (v2) 1) Дескриптор игрока (целое число) (INT)
  5810. 2) логическое значение (1 или 0) (INT)
  5811. Игры    са vc iii
  5812. */
  5813.             bool s = lua_toboolean(L, 1);
  5814.             Command<COMMAND_APPLY_BRAKES_TO_PLAYERS_CAR>(CWorld::PlayerInFocus, s);
  5815.             return 0;
  5816.         }
  5817.         else { throw "bad argument in function set_brakes_car"; }
  5818.     }
  5819.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5820.     return 0;
  5821. };
  5822.  
  5823. int setmarker_brightness(lua_State* L) {// уст яркость маркера.
  5824.     try {// 0166: set_marker $4082 brightness_to 1.
  5825.         if (LUA_TNUMBER == lua_type(L, 1) && LUA_TBOOLEAN == lua_type(L, 2)) {// значение число.
  5826.             /* Описание Устанавливает, должна ли метка отображаться затемненной.
  5827. Параметры (v2) 1) Дескриптор метки (целое число) (INT)
  5828. 2) логическое значение (1 или 0) (INT)
  5829.             */
  5830.             int marker = lua_tointeger(L, 1);// маркер.
  5831.             bool s = lua_toboolean(L, 2);// размер маркера на карте.
  5832.            
  5833.             Command<COMMAND_DIM_BLIP>(s, marker);
  5834.             return 0;
  5835.         }// int
  5836.  
  5837.         else { throw "bad argument in function setmarker_brightness"; }
  5838.     }
  5839.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5840.     return 0;
  5841. };
  5842.  
  5843.  
  5844.  
  5845.  
  5846. //  catch (const char* x) { writelog(x); }// записать ошибку в файл.
  5847. //  return 0;
  5848. //};
  5849. //COMMAND_SET_ANIM_GROUP_FOR_CHAR
  5850. //
  5851. //
  5852.  
  5853.  
  5854.  
  5855.  
  5856. CPed* findpedinpool(const void* p) {// найти педа в пуле.
  5857.     for (auto ped : CPools::ms_pPedPool) {
  5858.         if (ped == p) {
  5859.             this_thread::sleep_for(chrono::milliseconds(1));
  5860.             return ped;
  5861.         }
  5862.     };
  5863.     CPed* ped2 = NULL;
  5864.     return ped2;
  5865. };
  5866.  
  5867. CVehicle* findcarinpool(const void* p) {// найти авто в пуле.
  5868.     for (auto car : CPools::ms_pVehiclePool) {
  5869.         if (car == p) {
  5870.             this_thread::sleep_for(chrono::milliseconds(1));
  5871.             return car;
  5872.         }
  5873.     };
  5874.     CVehicle* car2 = NULL;
  5875.     return car2;
  5876. };
  5877. CObject* findobjinpool(const void* p) {// найти объект в пуле.
  5878.     for (auto obj : CPools::ms_pObjectPool) {
  5879.         if (obj == p) {
  5880.             this_thread::sleep_for(chrono::milliseconds(1));
  5881.             return obj;
  5882.         }
  5883.     };
  5884.     CObject* obj2 = NULL;
  5885.     return obj2;
  5886. };
  5887. int find_in_map(std::map<string, int>& carlist, const char* search) {
  5888.  
  5889.     auto it = carlist.find(search);
  5890.     if (it == carlist.end()) {
  5891.         return 0;
  5892.     }
  5893.     else {
  5894.         int m = it->second;
  5895.         return m;
  5896.     }
  5897. };
  5898. int find_model_in_map(std::map<int, int>& type_and_model, int search) {
  5899.  
  5900.     auto it = type_and_model.find(search);
  5901.     if (it == type_and_model.end()) {
  5902.         return 0;
  5903.     }
  5904.     else {
  5905.         int m = it->second;
  5906.         return m;
  5907.     }
  5908. };
  5909. void showstack(lua_State* L) {
  5910.     int i = lua_gettop(L);/* получаем количество элементов в стеке.*/
  5911.     string path = "stack.txt";
  5912.     fstream f2; {f2.open("stack.txt", fstream::in | fstream::out | fstream::app);
  5913.     if (f2.is_open()) {// если файл есть удалить.
  5914.         f2.close(); remove("stack.txt");
  5915.     }}
  5916.     fstream f1; {f1.open(path, fstream::in | fstream::out | fstream::app);
  5917.     int j = (i) * -1 - 1;
  5918.     i = -1;
  5919.     for (i; i > j; i--) {
  5920.         int t = lua_type(L, i);
  5921.         if (LUA_TSTRING == t) {
  5922.             f1 << "str ";
  5923.             f1 << i; f1 << "\n";
  5924.         }
  5925.         if (LUA_TNUMBER == t) {
  5926.             f1 << "number ";
  5927.             f1 << i; f1 << "\n";
  5928.         }
  5929.  
  5930.         if (LUA_TBOOLEAN == t) {
  5931.             f1 << "LUA_TBOOLEAN ";
  5932.             f1 << i; f1 << "\n";
  5933.         }
  5934.         if (LUA_TLIGHTUSERDATA == t) {
  5935.             f1 << "LIGHTUSERDATA ";
  5936.             f1 << i; f1 << "\n";
  5937.         }
  5938.         if (LUA_TTABLE == t) {
  5939.             f1 << "LUA_TTABLE ";
  5940.             f1 << i; f1 << "\n";
  5941.         }
  5942.         if (LUA_TFUNCTION == t) {
  5943.  
  5944.             f1 << "funs ";
  5945.             f1 << i; f1 << "\n";
  5946.         }
  5947.         if (LUA_TLIGHTUSERDATA == t) {
  5948.             f1 << "user ";
  5949.             f1 << i; f1 << "\n";
  5950.         }
  5951.         if (LUA_TTHREAD == t) {
  5952.             f1 << "LUA_TTHREAD "; f1 << "\n";
  5953.         }
  5954.         if (LUA_TNIL == t) {
  5955.             f1 << "LUA_TNIL "; f1 << "\n";
  5956.         }
  5957.     }
  5958.     f1.close(); }
  5959. };
  5960.  
  5961. void showstack1(lua_State* L) {
  5962.     int i = lua_gettop(L);/* получаем количество элементов в стеке.*/
  5963.     string path = "stack1.txt";
  5964.     fstream f1; {f1.open(path, fstream::in | fstream::out | fstream::app);
  5965.     int j = (i) * -1 - 1;
  5966.     i = -1;
  5967.     for (i; i > j; i--) {
  5968.         int t = lua_type(L, i);
  5969.         if (LUA_TSTRING == t) {
  5970.             f1 << "str ";
  5971.             f1 << i; f1 << "\n";
  5972.         }
  5973.         if (LUA_TNUMBER == t) {
  5974.             f1 << "number ";
  5975.             f1 << i; f1 << "\n";
  5976.         }
  5977.  
  5978.         if (LUA_TBOOLEAN == t) {
  5979.             f1 << "LUA_TBOOLEAN ";
  5980.             f1 << i; f1 << "\n";
  5981.         }
  5982.         if (LUA_TLIGHTUSERDATA == t) {
  5983.             f1 << "LIGHTUSERDATA ";
  5984.             f1 << i; f1 << "\n";
  5985.         }
  5986.         if (LUA_TTABLE == t) {
  5987.             f1 << "LUA_TTABLE ";
  5988.             f1 << i; f1 << "\n";
  5989.         }
  5990.         if (LUA_TFUNCTION == t) {
  5991.             f1 << "funs ";
  5992.             f1 << i; f1 << "\n";
  5993.         }
  5994.         if (LUA_TLIGHTUSERDATA == t) {
  5995.             f1 << "user ";
  5996.             f1 << i; f1 << "\n";
  5997.         }
  5998.         if (LUA_TTHREAD == t) {
  5999.             f1 << "LUA_TTHREAD "; f1 << "\n";
  6000.         }
  6001.         if (LUA_TNIL == t) {
  6002.             f1 << "LUA_TNIL "; f1 << "\n";
  6003.         }
  6004.     }
  6005.     f1.close(); }
  6006. };// кол-во аргументов.
  6007. void reversestack(lua_State* L) {// реверс стека.
  6008.     int stacksize = lua_gettop(L);
  6009.     stacksize++;
  6010.     for (int i = 1; i < stacksize; i++) { lua_insert(L, i); }
  6011. };
  6012. string getkey(int key) {
  6013.  
  6014.     if (GetAsyncKeyState(0x30)) {
  6015.         return "0";
  6016.     }
  6017.     if (GetAsyncKeyState(0x31)) {
  6018.         return "1";
  6019.     }
  6020.     if (GetAsyncKeyState(0x32)) {
  6021.         return "2";
  6022.     }
  6023.     if (GetAsyncKeyState(0x33)) {
  6024.         return "3";
  6025.     }
  6026.     if (GetAsyncKeyState(0x34)) {
  6027.         return "4";
  6028.     }
  6029.     if (GetAsyncKeyState(0x35)) {
  6030.         return "5";
  6031.     }
  6032.     if (GetAsyncKeyState(0x36)) {
  6033.         return "6";
  6034.     }
  6035.     if (GetAsyncKeyState(0x37)) {
  6036.         return "7";
  6037.     }
  6038.     if (GetAsyncKeyState(0x38)) {
  6039.         return "8";
  6040.     }
  6041.     if (GetAsyncKeyState(0x39)) {
  6042.         return "9";
  6043.     }
  6044.     if (GetAsyncKeyState(0x41)) {
  6045.         return "a";
  6046.     }
  6047.     if (GetAsyncKeyState(0x42)) {
  6048.         return "b";
  6049.     }
  6050.     if (GetAsyncKeyState(0x43)) {
  6051.         return "c";
  6052.     }
  6053.     if (GetAsyncKeyState(0x44)) {
  6054.         return "d";
  6055.     }
  6056.     if (GetAsyncKeyState(0x45)) {
  6057.         return "e";
  6058.     }
  6059.     if (GetAsyncKeyState(0x46)) {
  6060.         return "f";
  6061.     }
  6062.     if (GetAsyncKeyState(0x47)) {
  6063.         return "g";
  6064.     }
  6065.     if (GetAsyncKeyState(0x48)) {
  6066.         return "h";
  6067.     }
  6068.     if (GetAsyncKeyState(0x49)) {
  6069.         return "i";
  6070.     }
  6071.     if (GetAsyncKeyState(0x4a)) {
  6072.         return "j";
  6073.     }
  6074.     if (GetAsyncKeyState(0x4b)) {
  6075.         return "k";
  6076.     }
  6077.     if (GetAsyncKeyState(0x4c)) {
  6078.         return "l";
  6079.     }
  6080.     if (GetAsyncKeyState(0x4d)) {
  6081.         return "m";
  6082.     }
  6083.     if (GetAsyncKeyState(0x4e)) {
  6084.         return "n";
  6085.     }
  6086.     if (GetAsyncKeyState(0x4f)) {
  6087.         return "o";
  6088.     }
  6089.     if (GetAsyncKeyState(0x50)) {
  6090.         return "p";
  6091.     }
  6092.     if (GetAsyncKeyState(0x51)) {
  6093.         return "q";
  6094.     }
  6095.     if (GetAsyncKeyState(0x52)) {
  6096.         return "r";
  6097.     }
  6098.     if (GetAsyncKeyState(0x53)) {
  6099.         return "s";
  6100.     }
  6101.     if (GetAsyncKeyState(0x54)) {
  6102.         return "t";
  6103.     }
  6104.     if (GetAsyncKeyState(0x55)) {
  6105.         return "u";
  6106.     }
  6107.     if (GetAsyncKeyState(0x56)) {
  6108.         return "v";
  6109.     }
  6110.     if (GetAsyncKeyState(0x57)) {
  6111.         return "w";
  6112.     }
  6113.     if (GetAsyncKeyState(0x58)) {
  6114.         return "x";
  6115.     }
  6116.     if (GetAsyncKeyState(0x59)) {
  6117.         return "y";
  6118.     }
  6119.     if (GetAsyncKeyState(0x5a)) {
  6120.         return "z";
  6121.     }
  6122.     if (GetAsyncKeyState(0x0d)) {
  6123.         return "\n";
  6124.     }
  6125.     if (GetAsyncKeyState(0x20)) {
  6126.         return " ";
  6127.     }
  6128.     return "";
  6129. };
  6130. int newthread(lua_State* L) {// новый поток.
  6131.     try {
  6132.         if (LUA_TFUNCTION == lua_type(L, 1)) {
  6133.             int stacksize = lua_gettop(L);
  6134.             //lua_pushinteger(L, stacksize);
  6135.             return lua_yield(L, stacksize);
  6136.         }
  6137.         else { throw "bad argument in function newthread"; }
  6138.     }
  6139.     catch (const char* x) { writelog(x); }// записать ошибку в файл.
  6140.     return 0;
  6141. };
  6142.  
  6143. wchar_t* getwchat(const char* c) {// перевод в строку.
  6144.     const size_t cSize = strlen(c) + 1;
  6145.     wchar_t* wc = new wchar_t[cSize]; mbstowcs(wc, c, cSize);
  6146.     return wc;// вернуть строку.
  6147. };
  6148.  
  6149.  
  6150. bool getstatusmission() {// проверка флага миссии.
  6151.     unsigned int& OnAMissionFlag = *(unsigned int*)0x978748;
  6152.     bool getflagmission = (CTheScripts::ScriptSpace[OnAMissionFlag]);// получить флаг миссии.
  6153.     return getflagmission;
  6154. };
  6155.  
  6156. int setstatusmission(bool flag) { // уcтановить флага миссии.
  6157.     unsigned int& OnAMissionFlag = *(unsigned int*)0x978748;
  6158.     CTheScripts::ScriptSpace[OnAMissionFlag] = flag;
  6159.     return 0;
  6160. };
  6161.  
  6162. void writelog(const char x[]) {// запись ошибок в файл.
  6163.    
  6164.     string path = "lualoader\\log.txt";// куда пишем ошибки.
  6165.     fstream f1; {f1.open(path, fstream::in | fstream::out | fstream::app);
  6166.     f1 << x; time_t rawtime; struct tm* timeinfo;
  6167.     char buffer[120]; time(&rawtime); timeinfo = localtime(&rawtime);
  6168.     strftime(buffer, sizeof(buffer), " %d-%m-%Y %I:%M:%S ", timeinfo);// датируем загрузки скриптов.
  6169.     string er2(buffer); f1 << er2 << "\n"; }
  6170.     f1.close();
  6171. };
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!