Advertisement
egor230

sdk plugin gta vice city

Feb 17th, 2019 (edited)
758
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 257.39 KB
  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.     &nb