API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 16th, 2019
206
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 54.34 KB | None | 0 0
raw download clone embed print report
  1. #include <sourcemod>
  2. #include <sdkhooks>
  3. #include <sdktools>
  4. #include <cstrike>
  5.  
  6. #define PLUGIN_NAME "Call of Duty: MW Mod"
  7. #define PLUGIN_VERSION "1.1"
  8. #define PLUGIN_AUTHOR "Linux`"
  9. #define PLUGIN_DESCRIPTION "Plugin oparty na kodzie QTM_CodMod by QTM_Peyote"
  10. #define PLUGIN_URL "http://steamcommunity.com/id/linux2006"
  11.  
  12. #define MAKSYMALNA_WARTOSC_ZMIENNEJ 99999
  13. #define MAKSYMALNA_ILOSC_KLAS 100
  14. #define MAKSYMALNA_ILOSC_ITEMOW 120
  15. #define MINIMALNA_ILOSC_GRACZY 4
  16.  
  17. #define MNOZNIK_KONDYCJI 0.004
  18. #define MNOZNIK_GRAWITACJI 0.00208
  19.  
  20. new Handle:sql,
  21. Handle:hud_task[65],
  22. Handle:zapis_task[65],
  23. Handle:cvar_doswiadczenie_za_zabojstwo,
  24. Handle:cvar_doswiadczenie_za_zabojstwo_hs,
  25. Handle:cvar_doswiadczenie_za_wygrana_runde,
  26. Handle:cvar_doswiadczenie_za_cele_mapy,
  27. Handle:cvar_limit_poziomu,
  28. Handle:cvar_proporcja_poziomu,
  29. Handle:cvar_proporcja_punktow,
  30. Handle:cvar_limit_kondycji,
  31. Handle:cvar_limit_grawitacji,
  32. Handle:cvar_limit_niewidzialnosci,
  33. Handle:cvar_wytrzymalosc_itemow,
  34. Handle:cvar_max_wytrzymalosc_itemow,
  35. bool:freezetime;
  36.  
  37. new bool:wczytane_dane[65],
  38. nowa_klasa_gracza[65],
  39. klasa_gracza[65],
  40. zdobyty_poziom_gracza[65],
  41. poziom_gracza[65],
  42. zdobyte_doswiadczenie_gracza[65],
  43. doswiadczenie_gracza[65],
  44. item_gracza[65],
  45. wartosc_itemu_gracza[65],
  46. wytrzymalosc_itemu_gracza[65];
  47.  
  48. new rozdane_punkty_gracza[65],
  49. punkty_gracza[65],
  50. zdobyta_kondycja_gracza[65],
  51. kondycja_gracza[65];
  52. zdobyta_grawitacja_gracza[65],
  53. grawitacja_gracza[65];
  54. zdobyta_niewidzialnosc_gracza[65],
  55. niewidzialnosc_gracza[65];
  56.  
  57. new String:bonusowe_bronie_gracza[65][256],
  58. bonusowa_kondycja_gracza[65];
  59. bonusowa_grawitacja_gracza[65];
  60. bonusowa_niewidzialnosc_gracza[65];
  61.  
  62. new Float:maksymalna_kondycja_gracza[65];
  63. Float:maksymalna_grawitacja_gracza[65];
  64. maksymalna_niewidzialnosc_gracza[65];
  65.  
  66. new lvl_klasy_gracza[65][MAKSYMALNA_ILOSC_KLAS+1],
  67. xp_klasy_gracza[65][MAKSYMALNA_ILOSC_KLAS+1],
  68. kon_klasy_gracza[65][MAKSYMALNA_ILOSC_KLAS+1];
  69. graw_klasy_gracza[65][MAKSYMALNA_ILOSC_KLAS+1];
  70. niew_klasy_gracza[65][MAKSYMALNA_ILOSC_KLAS+1];
  71.  
  72. new String:nazwy_klas[MAKSYMALNA_ILOSC_KLAS+1][64],
  73. String:opisy_klas[MAKSYMALNA_ILOSC_KLAS+1][128],
  74. String:bronie_klas[MAKSYMALNA_ILOSC_KLAS+1][512],
  75. kondycja_klas[MAKSYMALNA_ILOSC_KLAS+1],
  76. grawitacja_klas[MAKSYMALNA_ILOSC_KLAS+1],
  77. niewidzialnosc_klas[MAKSYMALNA_ILOSC_KLAS+1],
  78. Handle:pluginy_klas[MAKSYMALNA_ILOSC_KLAS+1],
  79. ilosc_klas;
  80.  
  81. new String:nazwy_itemow[MAKSYMALNA_ILOSC_ITEMOW+1][64],
  82. String:opisy_itemow[MAKSYMALNA_ILOSC_ITEMOW+1][128],
  83. max_wartosci_itemow[MAKSYMALNA_ILOSC_ITEMOW+1],
  84. min_wartosci_itemow[MAKSYMALNA_ILOSC_ITEMOW+1],
  85. Handle:pluginy_itemow[MAKSYMALNA_ILOSC_ITEMOW+1],
  86. ilosc_itemow;
  87.  
  88. new String:bronie_dozwolone[][] = {"weapon_knife", "weapon_c4"},
  89. punkty_statystyk[] = {1, 10, -1};
  90.  
  91. public Plugin:myinfo =
  92. {
  93. name = PLUGIN_NAME,
  94. author = PLUGIN_AUTHOR,
  95. description = PLUGIN_DESCRIPTION,
  96. version = PLUGIN_VERSION,
  97. url = PLUGIN_URL
  98. };
  99. public OnPluginStart()
  100. {
  101. CreateConVar(PLUGIN_NAME, PLUGIN_VERSION, PLUGIN_AUTHOR);
  102. cvar_doswiadczenie_za_zabojstwo = CreateConVar("cod_xp_kill", "10");
  103. cvar_doswiadczenie_za_zabojstwo_hs = CreateConVar("cod_xp_killhs", "15");
  104. cvar_doswiadczenie_za_wygrana_runde = CreateConVar("cod_xp_winround", "25");
  105. cvar_doswiadczenie_za_cele_mapy = CreateConVar("cod_xp_objectives", "50");
  106. cvar_limit_poziomu = CreateConVar("cod_max_level", "200");
  107. cvar_proporcja_poziomu = CreateConVar("cod_level_ratio", "35");
  108. cvar_proporcja_punktow = CreateConVar("cod_points_level", "2");
  109. cvar_limit_kondycji = CreateConVar("cod_max_trim", "80");
  110. cvar_limit_grawitacji = CreateConVar("cod_max_graw", "50");
  111. cvar_limit_niewidzialnosci = CreateConVar("cod_max_niew", "50");
  112. cvar_wytrzymalosc_itemow = CreateConVar("cod_item_stamina", "20");
  113. cvar_max_wytrzymalosc_itemow = CreateConVar("cod_item_max_stamina", "100");
  114.  
  115. ServerCommand("sv_disable_immunity_alpha 1");
  116.  
  117. RegConsoleCmd("klasa", WybierzKlase);
  118. RegConsoleCmd("class", WybierzKlase);
  119. RegConsoleCmd("klasy", OpisKlas);
  120. RegConsoleCmd("classinfo", OpisKlas);
  121. RegConsoleCmd("items", OpisItemow);
  122. RegConsoleCmd("perks", OpisItemow);
  123. RegConsoleCmd("perki", OpisItemow);
  124. RegConsoleCmd("item", OpisItemu);
  125. RegConsoleCmd("perk", OpisItemu);
  126. RegConsoleCmd("wyrzuc", WyrzucItem);
  127. RegConsoleCmd("useclass", UzyjKlasy);
  128. RegConsoleCmd("useitem", UzyjItemu);
  129. RegConsoleCmd("useperk", UzyjItemu);
  130. RegConsoleCmd("statystyki", PrzydzielPunkty);
  131. RegConsoleCmd("staty", PrzydzielPunkty);
  132. RegConsoleCmd("reset", ResetujPunkty);
  133.  
  134. RegConsoleCmd("buy", BlokujKomende);
  135. RegConsoleCmd("buyequip", BlokujKomende);
  136. RegConsoleCmd("buyammo1", BlokujKomende);
  137. RegConsoleCmd("buyammo2", BlokujKomende);
  138. RegConsoleCmd("rebuy", BlokujKomende);
  139. RegConsoleCmd("autobuy", BlokujKomende);
  140.  
  141. HookEvent("round_freeze_end", PoczatekRundy);
  142. HookEvent("round_start", NowaRunda);
  143. HookEvent("round_end", KoniecRundy);
  144.  
  145. HookEvent("hostage_rescued", ZakladnikUratowany);
  146. HookEvent("bomb_defused", BombaRozbrojona);
  147. HookEvent("bomb_planted", BombaPodlozona);
  148.  
  149. HookEvent("player_spawn", OdrodzenieGracza);
  150. HookEvent("player_death", SmiercGracza);
  151. HookEvent("player_jump", SkokiGracza);
  152.  
  153. HookUserMessage(GetUserMessageId("TextMsg"), TextMessage, true);
  154. LoadTranslations("common.phrases");
  155.  
  156. nazwy_klas[0] = "Brak";
  157. opisy_klas[0] = "Brak dodatkowych uzdolnien";
  158. bronie_klas[0] = "";
  159. kondycja_klas[0] = 100;
  160. grawitacja_klas[0] = 0;
  161. niewidzialnosc_klas[0] = 0;
  162.  
  163. nazwy_itemow[0] = "Brak";
  164. opisy_itemow[0] = "Zabij kogos, aby otrzymac item";
  165. }
  166. public APLRes:AskPluginLoad2(Handle:myself, bool:late, String:error[], err_max)
  167. {
  168. CreateNative("cod_set_user_bonus_weapons", UstawBonusoweBronie);
  169. CreateNative("cod_get_user_bonus_weapons", PobierzBonusoweBronie);
  170.  
  171. CreateNative("cod_set_user_bonus_trim", UstawBonusowaKondycje);
  172. CreateNative("cod_set_user_bonus_graw", UstawBonusowaGrawitacje);
  173. CreateNative("cod_set_user_bonus_niew", UstawBonusowaNiewidzialnosc);
  174.  
  175. CreateNative("cod_get_user_trim", PobierzKondycje);
  176. CreateNative("cod_get_user_graw", PobierzGrawitacje);
  177. CreateNative("cod_get_user_niew", PobierzNiewidzialnosc);
  178. CreateNative("cod_get_user_points", PobierzPunkty);
  179.  
  180. CreateNative("cod_get_user_maks_trim", PobierzMaksymalnaKondycje);
  181. CreateNative("cod_get_user_maks_graw", PobierzMaksymalnaGrawitacje);
  182. CreateNative("cod_get_user_maks_niew", PobierzMaksymalnaNiewidzialnosc);
  183.  
  184. CreateNative("cod_set_user_xp", UstawDoswiadczenie);
  185. CreateNative("cod_set_user_class", UstawKlase);
  186. CreateNative("cod_set_user_item", UstawItem);
  187.  
  188. CreateNative("cod_get_user_xp", PobierzDoswiadczenie);
  189. CreateNative("cod_get_level_xp", PobierzDoswiadczeniePoziomu);
  190. CreateNative("cod_get_user_level", PobierzPoziom);
  191. CreateNative("cod_get_user_level_all", PobierzCalkowityPoziom);
  192. CreateNative("cod_get_user_class", PobierzKlase);
  193. CreateNative("cod_get_user_item", PobierzItem);
  194. CreateNative("cod_get_user_item_skill", PobierzWartoscItemu);
  195. CreateNative("cod_get_user_item_stamina", PobierzWytrzymaloscItemu);
  196.  
  197. CreateNative("cod_get_classes_num", PobierzIloscKlas);
  198. CreateNative("cod_get_classid", PobierzKlasePrzezNazwe);
  199. CreateNative("cod_get_class_name", PobierzNazweKlasy);
  200. CreateNative("cod_get_class_desc", PobierzOpisKlasy);
  201. CreateNative("cod_get_class_weapon", PobierzBronieKlasy);
  202. CreateNative("cod_get_class_trim", PobierzKondycjeKlasy);
  203. CreateNative("cod_get_class_graw", PobierzGrawitacjeKlasy);
  204. CreateNative("cod_get_class_niew", PobierzNiewidzialnoscKlasy);
  205.  
  206. CreateNative("cod_get_items_num", PobierzIloscItemow);
  207. CreateNative("cod_get_itemid", PobierzItemPrzezNazwe);
  208. CreateNative("cod_get_item_name", PobierzNazweItemu);
  209. CreateNative("cod_get_item_desc", PobierzOpisItemu);
  210.  
  211. CreateNative("cod_register_class", ZarejestrujKlase);
  212. CreateNative("cod_register_item", ZarejestrujItem);
  213. }
  214. public OnMapStart()
  215. {
  216. AddFileToDownloadsTable("sound/cod/levelup.mp3");
  217. AutoExecConfig(true, "codmod");
  218. DataBaseConnect();
  219. }
  220. public OnClientAuthorized(client)
  221. {
  222. UsunUmiejetnosci(client);
  223. UsunZadania(client);
  224. }
  225. public OnClientPutInServer(client)
  226. {
  227. SDKHook(client, SDKHook_WeaponCanUse, WeaponCanUse);
  228. WczytajDane(client);
  229. }
  230. public OnClientDisconnect(client)
  231. {
  232. SDKUnhook(client, SDKHook_WeaponCanUse, WeaponCanUse);
  233.  
  234. ZapiszDane_Handler(client);
  235. UsunUmiejetnosci(client);
  236. UsunZadania(client);
  237. }
  238. public Action:UsunUmiejetnosci(client)
  239. {
  240. for(new i = 0; i <= ilosc_klas; i ++)
  241. {
  242. lvl_klasy_gracza[client][i] = 1;
  243. xp_klasy_gracza[client][i] = 0;
  244. kon_klasy_gracza[client][i] = 0;
  245. graw_klasy_gracza[client][i] = 0;
  246. niew_klasy_gracza[client][i] = 0;
  247. }
  248.  
  249. wczytane_dane[client] = false;
  250. rozdane_punkty_gracza[client] = 0;
  251.  
  252. bonusowe_bronie_gracza[client] = "";
  253. bonusowa_kondycja_gracza[client] = 0;
  254. bonusowa_grawitacja_gracza[client] = 0;
  255. bonusowa_niewidzialnosc_gracza[client] = 0;
  256.  
  257. nowa_klasa_gracza[client] = 0;
  258. UstawNowaKlase(client);
  259. UstawNowyItem(client, 0, 0, 0);
  260. }
  261. public Action:UsunZadania(client)
  262. {
  263. if(hud_task[client] != null)
  264. {
  265. KillTimer(hud_task[client]);
  266. hud_task[client] = null;
  267. }
  268. if(zapis_task[client] != null)
  269. {
  270. KillTimer(zapis_task[client]);
  271. zapis_task[client] = null;
  272. }
  273. }
  274. public Action:OnPlayerRunCmd(client, &buttons, &impulse, Float:vel[3], Float:angles[3], &weapons)
  275. {
  276. if(!IsValidClient(client) || !IsPlayerAlive(client))
  277. return Plugin_Continue;
  278.  
  279. static bool:oldbuttons[65];
  280. if(!oldbuttons[client] && buttons & IN_USE)
  281. {
  282. UzyjKlasy(client, 0); // wymusza public odpowiadający za funkcje wywołującą forward użycia klasy
  283. UzyjItemu(client, 0); // wymusza public odpowiadający za funkcje wywołującą forward użycia itemu
  284.  
  285. oldbuttons[client] = true;
  286. }
  287. else if(oldbuttons[client] && !(buttons & IN_USE))
  288. oldbuttons[client] = false;
  289.  
  290. return Plugin_Continue;
  291. }
  292. public Action:WeaponCanUse(client, weapon)
  293. {
  294. if(!IsValidClient(client) || !IsPlayerAlive(client))
  295. return Plugin_Continue;
  296.  
  297. new String:weapons[32];
  298. GetEdictClassname(weapon, weapons, sizeof(weapons));
  299. new weaponindex = GetEntProp(weapon, Prop_Send, "m_iItemDefinitionIndex");
  300. switch(weaponindex)
  301. {
  302. case 60: strcopy(weapons, sizeof(weapons), "weapon_m4a1_silencer");
  303. case 61: strcopy(weapons, sizeof(weapons), "weapon_usp_silencer");
  304. case 63: strcopy(weapons, sizeof(weapons), "weapon_cz75a");
  305. case 64: strcopy(weapons, sizeof(weapons), "weapon_revolver");
  306. case 500: strcopy(weapons, sizeof(weapons), "weapon_bayonet");
  307. case 505: strcopy(weapons, sizeof(weapons), "weapon_knife_flip");
  308. case 506: strcopy(weapons, sizeof(weapons), "weapon_knife_gut");
  309. case 507: strcopy(weapons, sizeof(weapons), "weapon_knife_karambit");
  310. case 508: strcopy(weapons, sizeof(weapons), "weapon_knife_m9_bayonet");
  311. case 509: strcopy(weapons, sizeof(weapons), "weapon_knife_tactical");
  312. case 512: strcopy(weapons, sizeof(weapons), "weapon_knife_falchion");
  313. case 514: strcopy(weapons, sizeof(weapons), "weapon_knife_survival_bowie");
  314. case 515: strcopy(weapons, sizeof(weapons), "weapon_knife_butterfly");
  315. case 516: strcopy(weapons, sizeof(weapons), "weapon_knife_push");
  316. }
  317.  
  318. new String:weaponsclass[10][32];
  319. ExplodeString(bronie_klas[klasa_gracza[client]], "#", weaponsclass, sizeof(weaponsclass), sizeof(weaponsclass[]));
  320. for(new i = 0; i < sizeof(weaponsclass); i ++)
  321. {
  322. if(StrEqual(weaponsclass[i], weapons))
  323. return Plugin_Continue;
  324. }
  325.  
  326. new String:weaponsbonus[5][32];
  327. ExplodeString(bonusowe_bronie_gracza[client], "#", weaponsbonus, sizeof(weaponsbonus), sizeof(weaponsbonus[]));
  328. for(new i = 0; i < sizeof(weaponsbonus); i ++)
  329. {
  330. if(StrEqual(weaponsbonus[i], weapons))
  331. return Plugin_Continue;
  332. }
  333.  
  334. for(new i = 0; i < sizeof(bronie_dozwolone); i ++)
  335. {
  336. if(StrEqual(bronie_dozwolone[i], weapons))
  337. return Plugin_Continue;
  338. }
  339.  
  340. return Plugin_Handled;
  341. }
  342. public Action:PoczatekRundy(Handle:event, const String:name[], bool:dontbroadcast)
  343. {
  344. freezetime = false;
  345. }
  346. public Action:NowaRunda(Handle:event, const String:name[], bool:dontbroadcast)
  347. {
  348. freezetime = true;
  349. }
  350. public Action:KoniecRundy(Handle:event, const String:name[], bool:dontbroadcast)
  351. {
  352. if(IsValidPlayers() < MINIMALNA_ILOSC_GRACZY)
  353. return Plugin_Continue;
  354.  
  355. new doswiadczenie_za_wygrana_runde = GetConVarInt(cvar_doswiadczenie_za_wygrana_runde);
  356. if(doswiadczenie_za_wygrana_runde)
  357. {
  358. new wygrana_druzyna = GetEventInt(event, "winner");
  359. for(new i = 1; i <= MaxClients; i ++)
  360. {
  361. if(!IsClientInGame(i) || !klasa_gracza[i])
  362. continue;
  363.  
  364. if(GetClientTeam(i) != ((wygrana_druzyna == 2)? CS_TEAM_T: CS_TEAM_CT))
  365. continue;
  366.  
  367. if(IsPlayerAlive(i))
  368. {
  369. UstawNoweDoswiadczenie(i, doswiadczenie_gracza[i]+doswiadczenie_za_wygrana_runde);
  370. PrintToChat(i, "[COD:MW] Dostales %i doswiadczenia za wygranie rundy.", doswiadczenie_za_wygrana_runde);
  371. }
  372. else
  373. {
  374. UstawNoweDoswiadczenie(i, doswiadczenie_gracza[i]+doswiadczenie_za_wygrana_runde/2);
  375. PrintToChat(i, "[COD:MW] Dostales %i doswiadczenia za wygranie rundy przez twoja druzyne.", doswiadczenie_za_wygrana_runde/2);
  376. }
  377. }
  378. }
  379.  
  380. return Plugin_Continue;
  381. }
  382. public Action:ZakladnikUratowany(Handle:event, const String:name[], bool:dontbroadcast)
  383. {
  384. if(IsValidPlayers() < MINIMALNA_ILOSC_GRACZY)
  385. return Plugin_Continue;
  386.  
  387. new doswiadczenie_za_cele_mapy = GetConVarInt(cvar_doswiadczenie_za_cele_mapy);
  388. if(doswiadczenie_za_cele_mapy)
  389. {
  390. new client = GetClientOfUserId(GetEventInt(event, "userid"));
  391. for(new i = 1; i <= MaxClients; i ++)
  392. {
  393. if(!IsClientInGame(i) || !klasa_gracza[i])
  394. continue;
  395.  
  396. if(GetClientTeam(i) != CS_TEAM_CT)
  397. continue;
  398.  
  399. if(i == client)
  400. {
  401. UstawNoweDoswiadczenie(i, doswiadczenie_gracza[i]+doswiadczenie_za_cele_mapy);
  402. PrintToChat(i, "[COD:MW] Dostales %i doswiadczenia za uratowanie zakladnika.", doswiadczenie_za_cele_mapy);
  403. }
  404. else
  405. {
  406. UstawNoweDoswiadczenie(i, doswiadczenie_gracza[i]+doswiadczenie_za_cele_mapy/2);
  407. PrintToChat(i, "[COD:MW] Dostales %i doswiadczenia za uratowanie zakladnika przez twoja druzyne.", doswiadczenie_za_cele_mapy/2);
  408. }
  409. }
  410. }
  411.  
  412. return Plugin_Continue;
  413. }
  414. public Action:BombaRozbrojona(Handle:event, const String:name[], bool:dontbroadcast)
  415. {
  416. if(IsValidPlayers() < MINIMALNA_ILOSC_GRACZY)
  417. return Plugin_Continue;
  418.  
  419. new doswiadczenie_za_cele_mapy = GetConVarInt(cvar_doswiadczenie_za_cele_mapy);
  420. if(doswiadczenie_za_cele_mapy)
  421. {
  422. new client = GetClientOfUserId(GetEventInt(event, "userid"));
  423. for(new i = 1; i <= MaxClients; i ++)
  424. {
  425. if(!IsClientInGame(i) || !klasa_gracza[i])
  426. continue;
  427.  
  428. if(GetClientTeam(i) != CS_TEAM_CT)
  429. continue;
  430.  
  431. if(i == client)
  432. {
  433. UstawNoweDoswiadczenie(i, doswiadczenie_gracza[i]+doswiadczenie_za_cele_mapy);
  434. PrintToChat(i, "[COD:MW] Dostales %i doswiadczenia za rozbrojenie bomby.", doswiadczenie_za_cele_mapy);
  435. }
  436. else
  437. {
  438. UstawNoweDoswiadczenie(i, doswiadczenie_gracza[i]+doswiadczenie_za_cele_mapy/2);
  439. PrintToChat(i, "[COD:MW] Dostales %i doswiadczenia za rozbrojenie bomby przez twoja druzyne.", doswiadczenie_za_cele_mapy/2);
  440. }
  441. }
  442. }
  443.  
  444. return Plugin_Continue;
  445. }
  446. public Action:BombaPodlozona(Handle:event, const String:name[], bool:dontbroadcast)
  447. {
  448. if(IsValidPlayers() < MINIMALNA_ILOSC_GRACZY)
  449. return Plugin_Continue;
  450.  
  451. new doswiadczenie_za_cele_mapy = GetConVarInt(cvar_doswiadczenie_za_cele_mapy);
  452. if(doswiadczenie_za_cele_mapy)
  453. {
  454. new client = GetClientOfUserId(GetEventInt(event, "userid"));
  455. for(new i = 1; i <= MaxClients; i ++)
  456. {
  457. if(!IsClientInGame(i) || !klasa_gracza[i])
  458. continue;
  459.  
  460. if(GetClientTeam(i) != CS_TEAM_T)
  461. continue;
  462.  
  463. if(i == client)
  464. {
  465. UstawNoweDoswiadczenie(i, doswiadczenie_gracza[i]+doswiadczenie_za_cele_mapy);
  466. PrintToChat(i, "[COD:MW] Dostales %i doswiadczenia za podlozenie bomby.", doswiadczenie_za_cele_mapy);
  467. }
  468. else
  469. {
  470. UstawNoweDoswiadczenie(i, doswiadczenie_gracza[i]+doswiadczenie_za_cele_mapy/2);
  471. PrintToChat(i, "[COD:MW] Dostales %i doswiadczenia za podlozenie bomby przez twoja druzyne.", doswiadczenie_za_cele_mapy/2);
  472. }
  473. }
  474. }
  475.  
  476. return Plugin_Continue;
  477. }
  478. public Action:OdrodzenieGracza(Handle:event, String:name[], bool:dontbroadcast)
  479. {
  480. new client = GetClientOfUserId(GetEventInt(event, "userid"));
  481. if(!IsValidClient(client))
  482. return Plugin_Continue;
  483.  
  484. if(hud_task[client] == null)
  485. hud_task[client] = CreateTimer(0.5, PokazInformacje, client, TIMER_FLAG_NO_MAPCHANGE);
  486.  
  487. if(zapis_task[client] == null)
  488. zapis_task[client] = CreateTimer(30.0, ZapiszDane, client, TIMER_FLAG_NO_MAPCHANGE);
  489.  
  490. if(nowa_klasa_gracza[client])
  491. UstawNowaKlase(client);
  492.  
  493. if(!klasa_gracza[client])
  494. WybierzKlase(client, 0);
  495. else if(punkty_gracza[client])
  496. PrzydzielPunkty(client, 0);
  497.  
  498. ZastosujAtrybuty(client);
  499. DajBronie(client);
  500.  
  501. return Plugin_Continue;
  502. }
  503. public Action:SmiercGracza(Handle:event, String:name[], bool:dontbroadcast)
  504. {
  505. new client = GetClientOfUserId(GetEventInt(event, "userid"));
  506. new killer = GetClientOfUserId(GetEventInt(event, "attacker"));
  507. new bool:headshot = GetEventBool(event, "headshot");
  508. if(!IsValidClient(client) || !IsValidClient(killer))
  509. return Plugin_Continue;
  510.  
  511. if(klasa_gracza[killer] && GetClientTeam(client) != GetClientTeam(killer))
  512. {
  513. if(headshot)
  514. {
  515. new doswiadczenie_za_zabojstwo_hs = GetConVarInt(cvar_doswiadczenie_za_zabojstwo_hs);
  516. if(doswiadczenie_za_zabojstwo_hs)
  517. {
  518. UstawNoweDoswiadczenie(killer, doswiadczenie_gracza[killer]+doswiadczenie_za_zabojstwo_hs);
  519. PrintToChat(killer, "[COD:MW] Dostales %i doswiadczenia za zabicie przeciwnika w glowe.", doswiadczenie_za_zabojstwo_hs);
  520. }
  521. }
  522. else
  523. {
  524. new doswiadczenie_za_zabojstwo = GetConVarInt(cvar_doswiadczenie_za_zabojstwo);
  525. if(doswiadczenie_za_zabojstwo)
  526. {
  527. UstawNoweDoswiadczenie(killer, doswiadczenie_gracza[killer]+doswiadczenie_za_zabojstwo);
  528. PrintToChat(killer, "[COD:MW] Dostales %i doswiadczenia za zabicie przeciwnika.", doswiadczenie_za_zabojstwo);
  529. }
  530. }
  531. if(!item_gracza[killer])
  532. {
  533. UstawNowyItem(killer, -1, -1, -1);
  534. PrintToChat(killer, "[COD:MW] Zdobyles %s.", nazwy_itemow[item_gracza[killer]]);
  535. }
  536. }
  537.  
  538. new wytrzymalosc_itemow = GetConVarInt(cvar_wytrzymalosc_itemow);
  539. if(wytrzymalosc_itemow && wytrzymalosc_itemu_gracza[client])
  540. {
  541. if(wytrzymalosc_itemu_gracza[client] > wytrzymalosc_itemow)
  542. wytrzymalosc_itemu_gracza[client] -= wytrzymalosc_itemow;
  543. else
  544. {
  545. UstawNowyItem(client, 0, 0, 0);
  546. PrintToChat(client, "[COD:MW] Twoj item ulegl zniszczeniu.");
  547. }
  548. }
  549.  
  550. return Plugin_Continue;
  551. }
  552. public Action:TextMessage(UserMsg:msg_text, Handle:pb, const players[], playersNum, bool:reliable, bool:init)
  553. {
  554. if(!reliable || PbReadInt(pb, "msg_dst") != 3)
  555. return Plugin_Continue;
  556.  
  557. new String:buffer[256];
  558. PbReadString(pb, "params", buffer, sizeof(buffer), 0);
  559. if(StrContains(buffer, "#Player_Cash_Award_") == 0 || StrContains(buffer, "#Team_Cash_Award_") == 0)
  560. return Plugin_Handled;
  561.  
  562. return Plugin_Continue;
  563. }
  564. public Action:WybierzKlase(client, args)
  565. {
  566. if(wczytane_dane[client])
  567. {
  568. lvl_klasy_gracza[client][klasa_gracza[client]] = poziom_gracza[client];
  569. xp_klasy_gracza[client][klasa_gracza[client]] = doswiadczenie_gracza[client];
  570. kon_klasy_gracza[client][klasa_gracza[client]] = kondycja_gracza[client];
  571. graw_klasy_gracza[client][klasa_gracza[client]] = grawitacja_gracza[client];
  572. niew_klasy_gracza[client][klasa_gracza[client]] = niewidzialnosc_gracza[client];
  573.  
  574. new String:menu_item[128];
  575. new Handle:menu = CreateMenu(WybierzKlase_Handler);
  576. SetMenuTitle(menu, "Wybierz Klase:");
  577. for(new i = 1; i <= ilosc_klas; i ++)
  578. {
  579. Format(menu_item, sizeof(menu_item), "%s (Lv: %i)", nazwy_klas[i], lvl_klasy_gracza[client][i]);
  580. AddMenuItem(menu, "", menu_item);
  581. }
  582.  
  583. DisplayMenu(menu, client, 250);
  584. }
  585. else
  586. PrintToChat(client, "[COD:MW] Trwa wczytywanie twoich danych!");
  587.  
  588. return Plugin_Handled;
  589. }
  590. public WybierzKlase_Handler(Handle:classhandle, MenuAction:action, client, position)
  591. {
  592. if(action == MenuAction_Select)
  593. {
  594. new String:item[32];
  595. GetMenuItem(classhandle, position, item, sizeof(item));
  596. position ++;
  597.  
  598. if(position == klasa_gracza[client] && !nowa_klasa_gracza[client])
  599. return;
  600.  
  601. nowa_klasa_gracza[client] = position;
  602. if(klasa_gracza[client])
  603. PrintToChat(client, "[COD:MW] Klasa zostanie zmieniona w nastepnej rundzie.");
  604. else
  605. {
  606. UstawNowaKlase(client);
  607. ZastosujAtrybuty(client);
  608. DajBronie(client);
  609. }
  610. }
  611. else if(action == MenuAction_End)
  612. CloseHandle(classhandle);
  613. }
  614. public Action:OpisKlas(client, args)
  615. {
  616. new Handle:menu = CreateMenu(OpisKlas_Handler);
  617. SetMenuTitle(menu, "Wybierz Klase:");
  618. for(new i = 1; i <= ilosc_klas; i ++)
  619. AddMenuItem(menu, "", nazwy_klas[i]);
  620.  
  621. DisplayMenu(menu, client, 250);
  622. return Plugin_Handled;
  623. }
  624. public OpisKlas_Handler(Handle:classhandle, MenuAction:action, client, position)
  625. {
  626. if(action == MenuAction_Select)
  627. {
  628. new String:item[32];
  629. GetMenuItem(classhandle, position, item, sizeof(item));
  630. position ++;
  631.  
  632. new String:bronie[512];
  633. Format(bronie, sizeof(bronie), "%s", bronie_klas[position]);
  634. ReplaceString(bronie, sizeof(bronie), "#weapon_", "|");
  635.  
  636. new String:opis[1024];
  637. new Function:forward_klasy = GetFunctionByName(pluginy_klas[position], "cod_class_skill_used");
  638. if(forward_klasy != INVALID_FUNCTION)
  639. Format(opis, sizeof(opis), "Klasa: %i\nKondycja: %i\nGrawitacja: %i\nNiewidzialnosc: %i\nBronie: %s\nOpis: %s\nUzycie Umiejetnosci: Useclass", nazwy_klas[position], kondycja_klas[position], grawitacja_klas[position], niewidzialnosc_klas[position], bronie, opisy_klas[position]);
  640. else
  641. Format(opis, sizeof(opis), "Klasa: %i\nKondycja: %i\nGrawitacja: %i\nNiewidzialnosc: %i\nBronie: %s\nOpis: %s", nazwy_klas[position], kondycja_klas[position], grawitacja_klas[position], niewidzialnosc_klas[position], bronie, opisy_klas[position]);
  642.  
  643. new Handle:menu = CreateMenu(OpisKlas2_Handler);
  644. SetMenuTitle(menu, opis);
  645. AddMenuItem(menu, "", "Lista Klas");
  646. DisplayMenu(menu, client, 250);
  647. }
  648. else if(action == MenuAction_End)
  649. CloseHandle(classhandle);
  650. }
  651. public OpisKlas2_Handler(Handle:classhandle, MenuAction:action, client, position)
  652. {
  653. if(action == MenuAction_Select)
  654. OpisKlas(client, 0);
  655. else if(action == MenuAction_End)
  656. CloseHandle(classhandle);
  657. }
  658. public Action:OpisItemow(client, args)
  659. {
  660. new Handle:menu = CreateMenu(OpisItemow_Handler);
  661. SetMenuTitle(menu, "Wybierz Item:");
  662. for(new i = 1; i <= ilosc_itemow; i ++)
  663. AddMenuItem(menu, "", nazwy_itemow[i]);
  664.  
  665. DisplayMenu(menu, client, 250);
  666. return Plugin_Handled;
  667. }
  668. public OpisItemow_Handler(Handle:classhandle, MenuAction:action, client, position)
  669. {
  670. if(action == MenuAction_Select)
  671. {
  672. new String:item[32];
  673. GetMenuItem(classhandle, position, item, sizeof(item));
  674. position ++;
  675.  
  676. new String:opis_itemu[128];
  677. new String:losowa_wartosc[21];
  678. Format(losowa_wartosc, sizeof(losowa_wartosc), "%i-%i", min_wartosci_itemow[position], max_wartosci_itemow[position]);
  679. Format(opis_itemu, sizeof(opis_itemu), opisy_itemow[position]);
  680. ReplaceString(opis_itemu, sizeof(opis_itemu), "LW", losowa_wartosc);
  681.  
  682. new String:opis[512];
  683. new Function:forward_itemu = GetFunctionByName(pluginy_itemow[position], "cod_item_used");
  684. if(forward_itemu != INVALID_FUNCTION)
  685. Format(opis, sizeof(opis), "Item: %s\nOpis: %s\nUzycie Umiejetnosci: Useitem", nazwy_itemow[position], opis_itemu);
  686. else
  687. Format(opis, sizeof(opis), "Item: %s\nOpis: %s", nazwy_itemow[position], opis_itemu);
  688.  
  689. new Handle:menu = CreateMenu(OpisItemow_Handler2);
  690. SetMenuTitle(menu, opis);
  691. AddMenuItem(menu, "", "Lista Itemow");
  692. DisplayMenu(menu, client, 250);
  693. }
  694. else if(action == MenuAction_End)
  695. CloseHandle(classhandle);
  696. }
  697. public OpisItemow_Handler2(Handle:classhandle, MenuAction:action, client, position)
  698. {
  699. if(action == MenuAction_Select)
  700. OpisItemow(client, 0);
  701. else if(action == MenuAction_End)
  702. CloseHandle(classhandle);
  703. }
  704. public Action:OpisItemu(client, args)
  705. {
  706. new String:opis_itemu[128];
  707. new String:losowa_wartosc[10];
  708. IntToString(wartosc_itemu_gracza[client], losowa_wartosc, sizeof(losowa_wartosc));
  709. Format(opis_itemu, sizeof(opis_itemu), opisy_itemow[item_gracza[client]]);
  710. ReplaceString(opis_itemu, sizeof(opis_itemu), "LW", losowa_wartosc);
  711.  
  712. PrintToChat(client, "[COD:MW] Item: %s (%i%%).", nazwy_itemow[item_gracza[client]], wytrzymalosc_itemu_gracza[client]);
  713. PrintToChat(client, "[COD:MW] Opis: %s.", opis_itemu);
  714.  
  715. new Function:forward_itemu = GetFunctionByName(pluginy_itemow[item_gracza[client]], "cod_item_used");
  716. if(forward_itemu != INVALID_FUNCTION)
  717. PrintToChat(client, "[COD:MW] Uzycie Umiejetnosci: Useitem.");
  718.  
  719. return Plugin_Handled;
  720. }
  721. public Action:WyrzucItem(client, args)
  722. {
  723. if(item_gracza[client])
  724. {
  725. UstawNowyItem(client, 0, 0, 0);
  726. PrintToChat(client, "[COD:MW] Wyrzuciles swoj item.");
  727. }
  728. else
  729. PrintToChat(client, "[COD:MW] Nie posiadasz zadnego itemu.");
  730.  
  731. return Plugin_Handled;
  732. }
  733. public Action:UzyjKlasy(client, args)
  734. {
  735. if(!(!IsPlayerAlive(client) || freezetime))
  736. {
  737. new Function:forward_klasy = GetFunctionByName(pluginy_klas[klasa_gracza[client]], "cod_class_skill_used");
  738. if(forward_klasy != INVALID_FUNCTION)
  739. {
  740. Call_StartFunction(pluginy_klas[klasa_gracza[client]], forward_klasy);
  741. Call_PushCell(client);
  742. Call_PushCell(klasa_gracza[client]);
  743. Call_Finish();
  744. }
  745. }
  746.  
  747. return Plugin_Handled;
  748. }
  749. public Action:UzyjItemu(client, args)
  750. {
  751. if(!(!IsPlayerAlive(client) || freezetime))
  752. {
  753. new Function:forward_itemu = GetFunctionByName(pluginy_itemow[item_gracza[client]], "cod_item_used");
  754. if(forward_itemu != INVALID_FUNCTION)
  755. {
  756. Call_StartFunction(pluginy_itemow[item_gracza[client]], forward_itemu);
  757. Call_PushCell(client);
  758. Call_PushCell(item_gracza[client]);
  759. Call_Finish();
  760. }
  761. }
  762.  
  763. return Plugin_Handled;
  764. }
  765. public Action:PrzydzielPunkty(client, args)
  766. {
  767. new proporcja_punktow = GetConVarInt(cvar_proporcja_punktow);
  768. if(!proporcja_punktow)
  769. return Plugin_Continue;
  770.  
  771. new limit_kondycji = GetConVarInt(cvar_limit_kondycji);
  772. if(!limit_kondycji)
  773. limit_kondycji = MAKSYMALNA_WARTOSC_ZMIENNEJ;
  774.  
  775. new limit_grawitacji = GetConVarInt(cvar_limit_grawitacji);
  776. if(!limit_grawitacji)
  777. limit_grawitacji = MAKSYMALNA_WARTOSC_ZMIENNEJ;
  778.  
  779. new limit_niewidzialnosci = GetConVarInt(cvar_limit_niewidzialnosci);
  780. if(!limit_niewidzialnosci)
  781. limit_niewidzialnosci = MAKSYMALNA_WARTOSC_ZMIENNEJ;
  782.  
  783. if(kondycja_gracza[client] > limit_kondycji || grawitacja_gracza[client] > limit_grawitacji || niewidzialnosc_gracza[client] > limit_niewidzialnosci)
  784. ResetujPunkty(client, 0);
  785. else
  786. {
  787. new String:opis[128];
  788. new Handle:menu = CreateMenu(PrzydzielPunkty_Handler);
  789.  
  790. Format(opis, sizeof(opis), "Przydziel Punkty (%i):", punkty_gracza[client]);
  791. SetMenuTitle(menu, opis);
  792.  
  793. if(punkty_statystyk[rozdane_punkty_gracza[client]] == -1)
  794. Format(opis, sizeof(opis), "Ile dodawac: ALL (Po ile punktow dodawac do statystyk)");
  795. else
  796. Format(opis, sizeof(opis), "Ile dodawac: %i (Po ile punktow dodawac do statystyk)", punkty_statystyk[rozdane_punkty_gracza[client]]);
  797.  
  798. AddMenuItem(menu, "1", opis);
  799.  
  800. Format(opis, sizeof(opis), "Kondycja: %i/%i (Zwieksza tempo chodu)", kondycja_gracza[client], limit_kondycji);
  801. AddMenuItem(menu, "2", opis);
  802.  
  803. Format(opis, sizeof(opis), "Grawitacja: %i/%i (Zmniejsza grawitacje)", grawitacja_gracza[client], limit_grawitacji);
  804. AddMenuItem(menu, "3", opis);
  805.  
  806. Format(opis, sizeof(opis), "Niewidzialnosc: %i/%i (Zmniejsza widocznosc)", niewidzialnosc_gracza[client], limit_niewidzialnosci);
  807. AddMenuItem(menu, "4", opis);
  808.  
  809. DisplayMenu(menu, client, 250);
  810. }
  811.  
  812. return Plugin_Handled;
  813. }
  814. public PrzydzielPunkty_Handler(Handle:classhandle, MenuAction:action, client, position)
  815. {
  816. if(action == MenuAction_Select)
  817. {
  818. if(!punkty_gracza[client])
  819. return;
  820.  
  821. new String:item[32];
  822. GetMenuItem(classhandle, position, item, sizeof(item));
  823.  
  824. new wartosc;
  825. if(punkty_statystyk[rozdane_punkty_gracza[client]] == -1)
  826. wartosc = punkty_gracza[client];
  827. else
  828. wartosc = (punkty_statystyk[rozdane_punkty_gracza[client]] > punkty_gracza[client])? punkty_gracza[client]: punkty_statystyk[rozdane_punkty_gracza[client]];
  829.  
  830. if(StrEqual(item, "1"))
  831. {
  832. if(rozdane_punkty_gracza[client] < sizeof(punkty_statystyk)-1)
  833. rozdane_punkty_gracza[client] ++;
  834. else
  835. rozdane_punkty_gracza[client] = 0;
  836. }
  837. else if(StrEqual(item, "2"))
  838. {
  839. new limit_kondycji = GetConVarInt(cvar_limit_kondycji);
  840. if(!limit_kondycji)
  841. limit_kondycji = MAKSYMALNA_WARTOSC_ZMIENNEJ;
  842.  
  843. if(kondycja_gracza[client] < limit_kondycji)
  844. {
  845. if(kondycja_gracza[client]+wartosc <= limit_kondycji)
  846. {
  847. zdobyta_kondycja_gracza[client] += wartosc;
  848. kondycja_gracza[client] += wartosc;
  849. punkty_gracza[client] -= wartosc;
  850. }
  851. else
  852. {
  853. new punktydodania;
  854. punktydodania = limit_kondycji-kondycja_gracza[client];
  855. zdobyta_kondycja_gracza[client] += punktydodania;
  856. kondycja_gracza[client] += punktydodania;
  857. punkty_gracza[client] -= punktydodania;
  858. }
  859. }
  860. else
  861. PrintToChat(client, "[COD:MW] Osiagnales juz maksymalny poziom kondycji!");
  862. }
  863. else if(StrEqual(item, "3"))
  864. {
  865. new limit_grawitacji = GetConVarInt(cvar_limit_grawitacji);
  866. if(!limit_grawitacji)
  867. limit_grawitacji = MAKSYMALNA_WARTOSC_ZMIENNEJ;
  868.  
  869. if(grawitacja_gracza[client] < limit_grawitacji)
  870. {
  871. if(grawitacja_gracza[client]+wartosc <= limit_grawitacji)
  872. {
  873. zdobyta_grawitacja_gracza[client] += wartosc;
  874. grawitacja_gracza[client] += wartosc;
  875. punkty_gracza[client] -= wartosc;
  876. }
  877. else
  878. {
  879. new punktydodania;
  880. punktydodania = limit_grawitacji-grawitacja_gracza[client];
  881. zdobyta_grawitacja_gracza[client] += punktydodania;
  882. grawitacja_gracza[client] += punktydodania;
  883. punkty_gracza[client] -= punktydodania;
  884. }
  885. }
  886. else
  887. PrintToChat(client, "[COD:MW] Osiagnales juz maksymalny poziom grawitacji!");
  888. }
  889. else if(StrEqual(item, "4"))
  890. {
  891. new limit_niewidzialnosci = GetConVarInt(cvar_limit_niewidzialnosci);
  892. if(!limit_niewidzialnosci)
  893. limit_niewidzialnosci = MAKSYMALNA_WARTOSC_ZMIENNEJ;
  894.  
  895. if(niewidzialnosc_gracza[client] < limit_niewidzialnosci)
  896. {
  897. if(niewidzialnosc_gracza[client]+wartosc <= limit_niewidzialnosci)
  898. {
  899. zdobyta_niewidzialnosc_gracza[client] += wartosc;
  900. niewidzialnosc_gracza[client] += wartosc;
  901. punkty_gracza[client] -= wartosc;
  902. }
  903. else
  904. {
  905. new punktydodania;
  906. punktydodania = limit_niewidzialnosci-niewidzialnosc_gracza[client];
  907. zdobyta_niewidzialnosc_gracza[client] += punktydodania;
  908. niewidzialnosc_gracza[client] += punktydodania;
  909. punkty_gracza[client] -= punktydodania;
  910. }
  911. }
  912. else
  913. PrintToChat(client, "[COD:MW] Osiagnales juz maksymalny poziom niewidzialnosci!");
  914. }
  915. if(punkty_gracza[client])
  916. PrzydzielPunkty(client, 0);
  917. }
  918. else if(action == MenuAction_End)
  919. CloseHandle(classhandle);
  920. }
  921. public Action:ResetujPunkty(client, args)
  922. {
  923. zdobyta_kondycja_gracza[client] -= kondycja_gracza[client];
  924. kondycja_gracza[client] = 0;
  925.  
  926. zdobyta_grawitacja_gracza[client] -= grawitacja_gracza[client];
  927. grawitacja_gracza[client] = 0;
  928.  
  929. zdobyta_niewidzialnosc_gracza[client] -= niewidzialnosc_gracza[client];
  930. niewidzialnosc_gracza[client] = 0;
  931.  
  932. punkty_gracza[client] = (GetConVarInt(cvar_proporcja_punktow) < 1)? 0: (poziom_gracza[client]/GetConVarInt(cvar_proporcja_punktow))-kondycja_gracza[client]-grawitacja_gracza[client]-niewidzialnosc_gracza[client];
  933. if(punkty_gracza[client])
  934. PrzydzielPunkty(client, 0);
  935.  
  936. PrintToChat(client, "[COD:MW] Umiejetnosci zostaly zresetowane.");
  937. return Plugin_Handled;
  938. }
  939. public Action:BlokujKomende(client, args)
  940. {
  941. return Plugin_Handled;
  942. }
  943. public Action:ZastosujAtrybuty(client)
  944. {
  945. if(!IsPlayerAlive(client))
  946. return Plugin_Continue;
  947.  
  948. maksymalna_kondycja_gracza[client] = 1.0+(kondycja_gracza[client]+bonusowa_kondycja_gracza[client]+kondycja_klas[klasa_gracza[client]])*MNOZNIK_KONDYCJI;
  949. maksymalna_grawitacja_gracza[client] = 1.0-(grawitacja_gracza[client]+bonusowa_grawitacja_gracza[client]+grawitacja_klas[klasa_gracza[client]])*MNOZNIK_GRAWITACJI;
  950. maksymalna_niewidzialnosc_gracza[client] = 255-(niewidzialnosc_gracza[client]+bonusowa_niewidzialnosc_gracza[client]+niewidzialnosc_klas[klasa_gracza[client]]);
  951.  
  952. SetEntityRenderMode (client, RENDER_TRANSCOLOR);
  953. SetEntityRenderColor(client, 255, 255, 255, maksymalna_niewidzialnosc_gracza[client]);
  954.  
  955. SetEntPropFloat(client, Prop_Data, "m_flLaggedMovementValue", maksymalna_kondycja_gracza[client]);
  956.  
  957. SetEntProp(client, Prop_Send, "m_ArmorValue", 0);
  958. return Plugin_Continue;
  959. }
  960. public Action:SkokiGracza(Event event, char[] name, bool dontbroadcast)
  961. {
  962. int client = GetClientOfUserId(GetEventInt(event, "userid"));
  963. if(!IsValidClient(client))
  964. return Plugin_Continue;
  965. if(!klasa_gracza[client])
  966. return Plugin_Continue;
  967.  
  968. float grawitacja = (maksymalna_grawitacja_gracza[client]*MNOZNIK_GRAWITACJI);
  969. if(grawitacja < 0.0)
  970. grawitacja = 0.01;
  971. SetEntityGravity(client, maksymalna_grawitacja_gracza[client]);
  972.  
  973. return Plugin_Continue;
  974. }
  975. public Action:DajBronie(client)
  976. {
  977. if(!IsPlayerAlive(client))
  978. return Plugin_Continue;
  979.  
  980. new ent = -1;
  981. for(new slot = 0; slot < 4; slot ++)
  982. {
  983. if(slot == 2)
  984. continue;
  985.  
  986. ent = GetPlayerWeaponSlot(client, slot);
  987. if(ent != -1)
  988. RemovePlayerItem(client, ent);
  989. }
  990.  
  991. new String:weapons[10][32];
  992. ExplodeString(bronie_klas[klasa_gracza[client]], "#", weapons, sizeof(weapons), sizeof(weapons[]));
  993. for(new i = 0; i < sizeof(weapons); i ++)
  994. {
  995. if(!StrEqual(weapons[i], ""))
  996. GivePlayerItem(client, weapons[i]);
  997. }
  998.  
  999. new String:weapons2[5][32];
  1000. ExplodeString(bonusowe_bronie_gracza[client], "#", weapons2, sizeof(weapons2), sizeof(weapons2[]));
  1001. for(new i = 0; i < sizeof(weapons2); i ++)
  1002. {
  1003. if(!StrEqual(weapons2[i], ""))
  1004. GivePlayerItem(client, weapons2[i]);
  1005. }
  1006.  
  1007. return Plugin_Continue;
  1008. }
  1009. public Action:SprawdzPoziom(client)
  1010. {
  1011. if(!klasa_gracza[client])
  1012. return Plugin_Continue;
  1013.  
  1014. new bool:zdobyty_poziom = false;
  1015. new bool:stracony_poziom = false;
  1016. new limit_poziomu = GetConVarInt(cvar_limit_poziomu);
  1017. if(!limit_poziomu)
  1018. limit_poziomu = MAKSYMALNA_WARTOSC_ZMIENNEJ;
  1019.  
  1020. while(doswiadczenie_gracza[client] >= SprawdzDoswiadczenie(poziom_gracza[client]) && poziom_gracza[client] < limit_poziomu)
  1021. {
  1022. zdobyty_poziom_gracza[client] ++;
  1023. poziom_gracza[client] ++;
  1024. zdobyty_poziom = true;
  1025. }
  1026. while(doswiadczenie_gracza[client] < SprawdzDoswiadczenie(poziom_gracza[client]-1))
  1027. {
  1028. zdobyty_poziom_gracza[client] --;
  1029. poziom_gracza[client] --;
  1030. stracony_poziom = true;
  1031. }
  1032. if(poziom_gracza[client] > limit_poziomu)
  1033. {
  1034. zdobyty_poziom_gracza[client] -= (poziom_gracza[client]-limit_poziomu);
  1035. poziom_gracza[client] = limit_poziomu;
  1036. stracony_poziom = true;
  1037. }
  1038. if(stracony_poziom)
  1039. ResetujPunkty(client, 0);
  1040. else if(zdobyty_poziom)
  1041. {
  1042. punkty_gracza[client] = (GetConVarInt(cvar_proporcja_punktow) < 1)? 0: (poziom_gracza[client]/GetConVarInt(cvar_proporcja_punktow))-kondycja_gracza[client]-grawitacja_gracza[client]-niewidzialnosc_gracza[client];
  1043. ClientCommand(client, "play *cod/levelup.mp3");
  1044. }
  1045.  
  1046. return Plugin_Continue;
  1047. }
  1048. public Action:PokazInformacje(Handle:timer, any:client)
  1049. {
  1050. if(!IsValidClient(client))
  1051. return;
  1052.  
  1053. if(IsPlayerAlive(client))
  1054. PrintHintText(client, "<font color='#008000'>[Klasa: <b>%s</b>]\n[Xp: <b>%i</b> | Lv: <b>%i</b>]\n[Item: <b>%s</b> [<b>%i%%</b>]]</font>", nazwy_klas[klasa_gracza[client]], doswiadczenie_gracza[client], poziom_gracza[client], nazwy_itemow[item_gracza[client]], wytrzymalosc_itemu_gracza[client]);
  1055. else
  1056. {
  1057. new spect = GetEntProp(client, Prop_Send, "m_iObserverMode");
  1058. if(spect == 4 || spect == 5)
  1059. {
  1060. new target = GetEntPropEnt(client, Prop_Send, "m_hObserverTarget");
  1061. if(target != -1 && IsValidClient(target))
  1062. PrintHintText(client, "<font color='#FFFFFF'>[Klasa: <b>%s</b>]\n[Xp: <b>%i</b> | Lv: <b>%i</b>]\n[Item: <b>%s</b> [<b>%i%%</b>]]</font>", nazwy_klas[klasa_gracza[target]], doswiadczenie_gracza[target], poziom_gracza[target], nazwy_itemow[item_gracza[target]], wytrzymalosc_itemu_gracza[target]);
  1063. }
  1064. }
  1065.  
  1066. hud_task[client] = CreateTimer(0.5, PokazInformacje, client, TIMER_FLAG_NO_MAPCHANGE);
  1067. }
  1068. public Action:DataBaseConnect()
  1069. {
  1070. new String:error[128];
  1071. sql = SQL_Connect("codmod_lvl_sql", true, error, sizeof(error));
  1072. if(sql == INVALID_HANDLE)
  1073. {
  1074. LogError("Could not connect: %s", error);
  1075. return Plugin_Continue;
  1076. }
  1077.  
  1078. new String:zapytanie[1024];
  1079. Format(zapytanie, sizeof(zapytanie), "CREATE TABLE IF NOT EXISTS `codmod` (`authid` VARCHAR(48) NOT NULL, `klasa` VARCHAR(64) NOT NULL, `poziom` INT UNSIGNED NOT NULL DEFAULT 1, `doswiadczenie` INT UNSIGNED NOT NULL DEFAULT 1, PRIMARY KEY(`authid`, `klasa`), ");
  1080. StrCat(zapytanie, sizeof(zapytanie), "`kondycja` INT UNSIGNED NOT NULL DEFAULT 0, `grawitacja` INT UNSIGNED NOT NULL DEFAULT 0, `niewidzialnosc` INT UNSIGNED NOT NULL DEFAULT 0)");
  1081.  
  1082. SQL_LockDatabase(sql);
  1083. SQL_FastQuery(sql, zapytanie);
  1084. SQL_UnlockDatabase(sql);
  1085.  
  1086. return Plugin_Continue;
  1087. }
  1088. public Action:ZapiszDane(Handle:timer, any:client)
  1089. {
  1090. if(!IsValidClient(client))
  1091. return Plugin_Continue;
  1092.  
  1093. ZapiszDane_Handler(client);
  1094. zapis_task[client] = CreateTimer(30.0, ZapiszDane, client, TIMER_FLAG_NO_MAPCHANGE);
  1095.  
  1096. return Plugin_Continue;
  1097. }
  1098. public Action:ZapiszDane_Handler(client)
  1099. {
  1100. if(IsFakeClient(client) || !klasa_gracza[client] || !wczytane_dane[client])
  1101. return Plugin_Continue;
  1102.  
  1103. new String:authid[64];
  1104. GetClientAuthId(client, AuthId_Steam2, authid, sizeof(authid));
  1105.  
  1106. new String:zapytanie[1024];
  1107. Format(zapytanie, sizeof(zapytanie), "UPDATE `codmod` SET `poziom` = (`poziom` + '%i'), `doswiadczenie` = (`doswiadczenie` + '%i'), `kondycja` = (`kondycja` + '%i'), `grawitacja` = (`grawitacja` + '%i'), `niewidzialnosc` = (`niewidzialnosc` + '%i') WHERE `authid` = '%s' AND `klasa` = '%s'",
  1108. zdobyty_poziom_gracza[client], zdobyte_doswiadczenie_gracza[client], zdobyta_kondycja_gracza[client], zdobyta_grawitacja_gracza[client], zdobyta_niewidzialnosc_gracza[client], authid, nazwy_klas[klasa_gracza[client]]);
  1109. SQL_TQuery(sql, HandleIgnore, zapytanie, client);
  1110.  
  1111. zdobyty_poziom_gracza[client] = 0;
  1112. lvl_klasy_gracza[client][klasa_gracza[client]] = poziom_gracza[client];
  1113.  
  1114. zdobyte_doswiadczenie_gracza[client] = 0;
  1115. xp_klasy_gracza[client][klasa_gracza[client]] = doswiadczenie_gracza[client];
  1116.  
  1117. zdobyta_kondycja_gracza[client] = 0;
  1118. kon_klasy_gracza[client][klasa_gracza[client]] = kondycja_gracza[client];
  1119.  
  1120. zdobyta_grawitacja_gracza[client] = 0;
  1121. graw_klasy_gracza[client][klasa_gracza[client]] = grawitacja_gracza[client];
  1122.  
  1123. zdobyta_niewidzialnosc_gracza[client] = 0;
  1124. niew_klasy_gracza[client][klasa_gracza[client]] = niewidzialnosc_gracza[client];
  1125.  
  1126. return Plugin_Continue;
  1127. }
  1128. public Action:WczytajDane(client)
  1129. {
  1130. if(IsClientSourceTV(client))
  1131. return Plugin_Continue;
  1132.  
  1133. if(IsFakeClient(client))
  1134. {
  1135. wczytane_dane[client] = true;
  1136. return Plugin_Continue;
  1137. }
  1138.  
  1139. new String:authid[64];
  1140. GetClientAuthId(client, AuthId_Steam2, authid, sizeof(authid));
  1141.  
  1142. new String:zapytanie[512];
  1143. Format(zapytanie, sizeof(zapytanie), "SELECT `klasa`, `poziom`, `doswiadczenie`, `kondycja`, `grawitacja`, `niewidzialnosc` FROM `codmod` WHERE `authid` = '%s'", authid);
  1144. SQL_TQuery(sql, WczytajDane_Handler, zapytanie, client);
  1145.  
  1146. return Plugin_Continue;
  1147. }
  1148. public WczytajDane_Handler(Handle:owner, Handle:query, const String:error[], any:client)
  1149. {
  1150. if(query == INVALID_HANDLE)
  1151. {
  1152. LogError("Load error: %s", error);
  1153. return;
  1154. }
  1155. if(SQL_GetRowCount(query))
  1156. {
  1157. new String:klasa[64];
  1158. while(SQL_MoreRows(query))
  1159. {
  1160. while(SQL_FetchRow(query))
  1161. {
  1162. SQL_FetchString(query, 0, klasa, sizeof(klasa));
  1163. for(new i = 1; i <= ilosc_klas; i ++)
  1164. {
  1165. if(!StrEqual(nazwy_klas[i], klasa))
  1166. continue;
  1167.  
  1168. lvl_klasy_gracza[client][i] = SQL_FetchInt(query, 1);
  1169. xp_klasy_gracza[client][i] = SQL_FetchInt(query, 2);
  1170. kon_klasy_gracza[client][i] = SQL_FetchInt(query, 3);
  1171. graw_klasy_gracza[client][i] = SQL_FetchInt(query, 4);
  1172. niew_klasy_gracza[client][i] = SQL_FetchInt(query, 5);
  1173. break;
  1174. }
  1175. }
  1176. }
  1177. }
  1178.  
  1179. wczytane_dane[client] = true;
  1180. }
  1181. public Action:ZmienDane(client)
  1182. {
  1183. zdobyty_poziom_gracza[client] = 0;
  1184. poziom_gracza[client] = lvl_klasy_gracza[client][klasa_gracza[client]];
  1185.  
  1186. zdobyte_doswiadczenie_gracza[client] = 0;
  1187. doswiadczenie_gracza[client] = xp_klasy_gracza[client][klasa_gracza[client]];
  1188.  
  1189. zdobyta_kondycja_gracza[client] = 0;
  1190. kondycja_gracza[client] = kon_klasy_gracza[client][klasa_gracza[client]];
  1191.  
  1192. zdobyta_grawitacja_gracza[client] = 0;
  1193. grawitacja_gracza[client] = graw_klasy_gracza[client][klasa_gracza[client]];
  1194.  
  1195. zdobyta_niewidzialnosc_gracza[client] = 0;
  1196. niewidzialnosc_gracza[client] = niew_klasy_gracza[client][klasa_gracza[client]];
  1197.  
  1198. punkty_gracza[client] = (GetConVarInt(cvar_proporcja_punktow) < 1)? 0: (poziom_gracza[client]/GetConVarInt(cvar_proporcja_punktow))-kondycja_gracza[client]-grawitacja_gracza[client]-niewidzialnosc_gracza[client];
  1199. if(!IsFakeClient(client) && wczytane_dane[client] && klasa_gracza[client] && !doswiadczenie_gracza[client])
  1200. {
  1201. new String:authid[64];
  1202. GetClientAuthId(client, AuthId_Steam2, authid, sizeof(authid));
  1203.  
  1204. new String:zapytanie[512];
  1205. Format(zapytanie, sizeof(zapytanie), "INSERT INTO `codmod` (`authid`, `klasa`) VALUES ('%s', '%s')", authid, nazwy_klas[klasa_gracza[client]]);
  1206. SQL_TQuery(sql, HandleIgnore, zapytanie, client);
  1207. UstawNoweDoswiadczenie(client, doswiadczenie_gracza[client]+1);
  1208. }
  1209.  
  1210. return Plugin_Continue;
  1211. }
  1212. public HandleIgnore(Handle:owner, Handle:query, const String:error[], any:client)
  1213. {
  1214. if(query == INVALID_HANDLE)
  1215. {
  1216. LogError("Save error: %s", error);
  1217. return;
  1218. }
  1219. }
  1220. public UstawBonusoweBronie(Handle:plugin, numParams)
  1221. {
  1222. new client = GetNativeCell(1);
  1223. if(IsValidClient(client))
  1224. {
  1225. new String:nazwa[256];
  1226. GetNativeString(2, nazwa, sizeof(nazwa));
  1227. bonusowe_bronie_gracza[client] = nazwa;
  1228. }
  1229.  
  1230. return -1;
  1231. }
  1232. public PobierzBonusoweBronie(Handle:plugin, numParams)
  1233. {
  1234. new client = GetNativeCell(1);
  1235. if(IsValidClient(client))
  1236. {
  1237. SetNativeString(2, bonusowe_bronie_gracza[client], GetNativeCell(3));
  1238. return 1;
  1239. }
  1240.  
  1241. return 0;
  1242. }
  1243. public UstawBonusowaKondycje(Handle:plugin, numParams)
  1244. {
  1245. new client = GetNativeCell(1);
  1246. if(IsValidClient(client))
  1247. {
  1248. new wartosc = GetNativeCell(2);
  1249. maksymalna_kondycja_gracza[client] += float((wartosc-bonusowa_kondycja_gracza[client]))*MNOZNIK_KONDYCJI;
  1250. if(IsPlayerAlive(client))
  1251. SetEntPropFloat(client, Prop_Data, "m_flLaggedMovementValue", maksymalna_kondycja_gracza[client]);
  1252.  
  1253. bonusowa_kondycja_gracza[client] = wartosc;
  1254. }
  1255.  
  1256. return -1;
  1257. }
  1258. public PobierzKondycje(Handle:plugin, numParams)
  1259. {
  1260. new client = GetNativeCell(1);
  1261. if(IsValidClient(client))
  1262. {
  1263. new kondycja;
  1264. if(GetNativeCell(2))
  1265. kondycja += kondycja_gracza[client];
  1266. if(GetNativeCell(3))
  1267. kondycja += bonusowa_kondycja_gracza[client];
  1268. if(GetNativeCell(4))
  1269. kondycja += kondycja_klas[klasa_gracza[client]];
  1270.  
  1271. return kondycja;
  1272. }
  1273.  
  1274. return -1;
  1275. }
  1276. public UstawBonusowaGrawitacje(Handle:plugin, numParams)
  1277. {
  1278. new client = GetNativeCell(1);
  1279. if(IsValidClient(client))
  1280. {
  1281. new wartosc = GetNativeCell(2);
  1282. maksymalna_grawitacja_gracza[client] += float((wartosc-bonusowa_grawitacja_gracza[client]))*MNOZNIK_GRAWITACJI;
  1283. if(IsPlayerAlive(client))
  1284. SetEntityGravity(client, maksymalna_grawitacja_gracza[client]);
  1285.  
  1286. bonusowa_grawitacja_gracza[client] = wartosc;
  1287. }
  1288.  
  1289. return -1;
  1290. }
  1291. public PobierzGrawitacje(Handle:plugin, numParams)
  1292. {
  1293. new client = GetNativeCell(1);
  1294. if(IsValidClient(client))
  1295. {
  1296. new grawitacja;
  1297. if(GetNativeCell(2))
  1298. grawitacja += grawitacja_gracza[client];
  1299. if(GetNativeCell(3))
  1300. grawitacja += bonusowa_grawitacja_gracza[client];
  1301. if(GetNativeCell(4))
  1302. grawitacja += grawitacja_klas[klasa_gracza[client]];
  1303.  
  1304. return grawitacja;
  1305. }
  1306.  
  1307. return -1;
  1308. }
  1309. public UstawBonusowaNiewidzialnosc(Handle:plugin, numParams)
  1310. {
  1311. new client = GetNativeCell(1);
  1312. if(IsValidClient(client))
  1313. {
  1314. new wartosc = GetNativeCell(2);
  1315. maksymalna_niewidzialnosc_gracza[client] += (wartosc-bonusowa_niewidzialnosc_gracza[client]);
  1316. bonusowa_niewidzialnosc_gracza[client] = wartosc;
  1317. }
  1318.  
  1319. return -1;
  1320. }
  1321. public PobierzNiewidzialnosc(Handle:plugin, numParams)
  1322. {
  1323. new client = GetNativeCell(1);
  1324. if(IsValidClient(client))
  1325. {
  1326. new niewidzialnosc;
  1327. if(GetNativeCell(2))
  1328. niewidzialnosc += niewidzialnosc_gracza[client];
  1329. if(GetNativeCell(3))
  1330. niewidzialnosc += bonusowa_niewidzialnosc_gracza[client];
  1331. if(GetNativeCell(4))
  1332. niewidzialnosc += niewidzialnosc_klas[klasa_gracza[client]];
  1333.  
  1334. return niewidzialnosc;
  1335. }
  1336.  
  1337. return -1;
  1338. }
  1339. public PobierzPunkty(Handle:plugin, numParams)
  1340. {
  1341. new client = GetNativeCell(1);
  1342. if(IsValidClient(client))
  1343. return punkty_gracza[client];
  1344.  
  1345. return -1;
  1346. }
  1347. public PobierzMaksymalnaKondycje(Handle:plugin, numParams)
  1348. {
  1349. new client = GetNativeCell(1);
  1350. if(IsValidClient(client))
  1351. {
  1352. new String:kondycja[10];
  1353. FloatToString(maksymalna_kondycja_gracza[client], kondycja, sizeof(kondycja));
  1354.  
  1355. SetNativeString(2, kondycja, GetNativeCell(3));
  1356. return 1;
  1357. }
  1358.  
  1359. return -1;
  1360. }
  1361. public PobierzMaksymalnaGrawitacje(Handle:plugin, numParams)
  1362. {
  1363. new client = GetNativeCell(1);
  1364. if(IsValidClient(client))
  1365. {
  1366. new String:grawitacja[10];
  1367. FloatToString(maksymalna_grawitacja_gracza[client], grawitacja, sizeof(grawitacja));
  1368.  
  1369. SetNativeString(2, grawitacja, GetNativeCell(3));
  1370. return 1;
  1371. }
  1372.  
  1373. return -1;
  1374. }
  1375. public PobierzMaksymalnaNiewidzialnosc(Handle:plugin, numParams)
  1376. {
  1377. new client = GetNativeCell(1);
  1378. if(IsValidClient(client))
  1379. return maksymalna_niewidzialnosc_gracza[client];
  1380.  
  1381. return -1;
  1382. }
  1383. public Action:UstawNoweDoswiadczenie(client, doswiadczenie)
  1384. {
  1385. new nowe_doswiadczenie = doswiadczenie-doswiadczenie_gracza[client];
  1386. zdobyte_doswiadczenie_gracza[client] += nowe_doswiadczenie;
  1387. doswiadczenie_gracza[client] = nowe_doswiadczenie+doswiadczenie_gracza[client];
  1388.  
  1389. SprawdzPoziom(client);
  1390. return Plugin_Continue;
  1391. }
  1392. public UstawDoswiadczenie(Handle:plugin, numParams)
  1393. {
  1394. new client = GetNativeCell(1);
  1395. if(IsValidClient(client))
  1396. UstawNoweDoswiadczenie(client, GetNativeCell(2));
  1397.  
  1398. return -1;
  1399. }
  1400. public Action:UstawNowaKlase(client)
  1401. {
  1402. if(!ilosc_klas)
  1403. return Plugin_Continue;
  1404.  
  1405. new Function:forward_klasy;
  1406. forward_klasy = GetFunctionByName(pluginy_klas[klasa_gracza[client]], "cod_class_disabled");
  1407. if(forward_klasy != INVALID_FUNCTION)
  1408. {
  1409. Call_StartFunction(pluginy_klas[klasa_gracza[client]], forward_klasy);
  1410. Call_PushCell(client);
  1411. Call_PushCell(klasa_gracza[client]);
  1412. Call_Finish();
  1413. }
  1414.  
  1415. new ret;
  1416. forward_klasy = GetFunctionByName(pluginy_klas[nowa_klasa_gracza[client]], "cod_class_enabled");
  1417. if(forward_klasy != INVALID_FUNCTION)
  1418. {
  1419. Call_StartFunction(pluginy_klas[nowa_klasa_gracza[client]], forward_klasy);
  1420. Call_PushCell(client);
  1421. Call_PushCell(nowa_klasa_gracza[client]);
  1422. Call_Finish(ret);
  1423. }
  1424. if(ret == 4)
  1425. {
  1426. nowa_klasa_gracza[client] = klasa_gracza[client];
  1427. UstawNowaKlase(client);
  1428. return Plugin_Continue;
  1429. }
  1430.  
  1431. ZapiszDane_Handler(client);
  1432. klasa_gracza[client] = nowa_klasa_gracza[client];
  1433. nowa_klasa_gracza[client] = 0;
  1434. ZmienDane(client);
  1435.  
  1436. UstawNowyItem(client, item_gracza[client], wartosc_itemu_gracza[client], wytrzymalosc_itemu_gracza[client]);
  1437. return Plugin_Continue;
  1438. }
  1439. public UstawKlase(Handle:plugin, numParams)
  1440. {
  1441. new client = GetNativeCell(1);
  1442. if(IsValidClient(client))
  1443. {
  1444. nowa_klasa_gracza[client] = GetNativeCell(2);
  1445. if(GetNativeCell(3))
  1446. {
  1447. UstawNowaKlase(client);
  1448. DajBronie(client);
  1449. ZastosujAtrybuty(client);
  1450. }
  1451. }
  1452.  
  1453. return -1;
  1454. }
  1455. public Action:UstawNowyItem(client, item, wartosc, wytrzymalosc)
  1456. {
  1457. if(!ilosc_itemow)
  1458. return Plugin_Continue;
  1459.  
  1460. new limit_wytrzymalosci_itemu = GetConVarInt(cvar_max_wytrzymalosc_itemow);
  1461. if(!limit_wytrzymalosci_itemu)
  1462. limit_wytrzymalosci_itemu = MAKSYMALNA_WARTOSC_ZMIENNEJ;
  1463.  
  1464. item = (item < 0 || item > ilosc_itemow)? GetRandomInt(1, ilosc_itemow): item;
  1465. wartosc = (wartosc < min_wartosci_itemow[item] || wartosc > max_wartosci_itemow[item])? GetRandomInt(min_wartosci_itemow[item], max_wartosci_itemow[item]): wartosc;
  1466. wytrzymalosc = (wytrzymalosc < 0 || wytrzymalosc > limit_wytrzymalosci_itemu)? limit_wytrzymalosci_itemu: wytrzymalosc;
  1467.  
  1468. new Function:forward_itemu;
  1469. forward_itemu = GetFunctionByName(pluginy_itemow[item_gracza[client]], "cod_item_disabled");
  1470. if(forward_itemu != INVALID_FUNCTION)
  1471. {
  1472. Call_StartFunction(pluginy_itemow[item_gracza[client]], forward_itemu);
  1473. Call_PushCell(client);
  1474. Call_PushCell(item_gracza[client]);
  1475. Call_Finish();
  1476. }
  1477.  
  1478. new ret;
  1479. forward_itemu = GetFunctionByName(pluginy_itemow[item], "cod_item_enabled");
  1480. if(forward_itemu != INVALID_FUNCTION)
  1481. {
  1482. Call_StartFunction(pluginy_itemow[item], forward_itemu);
  1483. Call_PushCell(client);
  1484. Call_PushCell(wartosc);
  1485. Call_PushCell(item);
  1486. Call_Finish(ret);
  1487. }
  1488.  
  1489. item_gracza[client] = item;
  1490. wartosc_itemu_gracza[client] = wartosc;
  1491. wytrzymalosc_itemu_gracza[client] = wytrzymalosc;
  1492. if(ret == 4)
  1493. UstawNowyItem(client, -1, -1, -1);
  1494.  
  1495. return Plugin_Continue;
  1496. }
  1497. public UstawItem(Handle:plugin, numParams)
  1498. {
  1499. new client = GetNativeCell(1);
  1500. if(IsValidClient(client))
  1501. UstawNowyItem(client, GetNativeCell(2), GetNativeCell(3), GetNativeCell(4));
  1502.  
  1503. return -1;
  1504. }
  1505. public PobierzDoswiadczenie(Handle:plugin, numParams)
  1506. {
  1507. new client = GetNativeCell(1);
  1508. if(IsValidClient(client))
  1509. return doswiadczenie_gracza[client];
  1510.  
  1511. return -1;
  1512. }
  1513. public SprawdzDoswiadczenie(poziom)
  1514. {
  1515. new proporcja_poziomu = GetConVarInt(cvar_proporcja_poziomu);
  1516. if(!proporcja_poziomu)
  1517. proporcja_poziomu = 1;
  1518.  
  1519. return RoundFloat(Pow(float(poziom), 2.0))*proporcja_poziomu;
  1520. }
  1521. public PobierzDoswiadczeniePoziomu(Handle:plugin, numParams)
  1522. {
  1523. return SprawdzDoswiadczenie(GetNativeCell(1));
  1524. }
  1525. public PobierzPoziom(Handle:plugin, numParams)
  1526. {
  1527. new client = GetNativeCell(1);
  1528. if(IsValidClient(client))
  1529. return poziom_gracza[client];
  1530.  
  1531. return -1;
  1532. }
  1533. public PobierzCalkowityPoziom(Handle:plugin, numParams)
  1534. {
  1535. new client = GetNativeCell(1);
  1536. if(IsValidClient(client))
  1537. {
  1538. new poziom;
  1539. for(new i = 1; i <= ilosc_klas; i ++)
  1540. {
  1541. if(lvl_klasy_gracza[client][i] > poziom)
  1542. poziom = lvl_klasy_gracza[client][i];
  1543. }
  1544.  
  1545. return poziom;
  1546. }
  1547.  
  1548. return -1;
  1549. }
  1550. public PobierzKlase(Handle:plugin, numParams)
  1551. {
  1552. new client = GetNativeCell(1);
  1553. if(IsValidClient(client))
  1554. return klasa_gracza[client];
  1555.  
  1556. return -1;
  1557. }
  1558. public PobierzItem(Handle:plugin, numParams)
  1559. {
  1560. new client = GetNativeCell(1);
  1561. if(IsValidClient(client))
  1562. return item_gracza[client];
  1563.  
  1564. return -1;
  1565. }
  1566. public PobierzWartoscItemu(Handle:plugin, numParams)
  1567. {
  1568. new client = GetNativeCell(1);
  1569. if(IsValidClient(client))
  1570. return wartosc_itemu_gracza[client];
  1571.  
  1572. return -1;
  1573. }
  1574. public PobierzWytrzymaloscItemu(Handle:plugin, numParams)
  1575. {
  1576. new client = GetNativeCell(1);
  1577. if(IsValidClient(client))
  1578. return wytrzymalosc_itemu_gracza[client];
  1579.  
  1580. return -1;
  1581. }
  1582. public PobierzIloscKlas(Handle:plugin, numParams)
  1583. {
  1584. if(ilosc_klas)
  1585. return ilosc_klas;
  1586.  
  1587. return -1;
  1588. }
  1589. public PobierzKlasePrzezNazwe(Handle:plugin, numParams)
  1590. {
  1591. new String:nazwa[64];
  1592. GetNativeString(1, nazwa, sizeof(nazwa));
  1593. for(new i = 1; i <= ilosc_klas; i ++)
  1594. {
  1595. if(StrEqual(nazwa, nazwy_klas[i]))
  1596. return i;
  1597. }
  1598.  
  1599. return -1;
  1600. }
  1601. public PobierzNazweKlasy(Handle:plugin, numParams)
  1602. {
  1603. new klasa = GetNativeCell(1);
  1604. if(klasa <= ilosc_klas)
  1605. {
  1606. SetNativeString(2, nazwy_klas[klasa], GetNativeCell(3));
  1607. return 1;
  1608. }
  1609.  
  1610. return -1;
  1611. }
  1612. public PobierzOpisKlasy(Handle:plugin, numParams)
  1613. {
  1614. new klasa = GetNativeCell(1);
  1615. if(klasa <= ilosc_klas)
  1616. {
  1617. SetNativeString(2, opisy_klas[klasa], GetNativeCell(3));
  1618. return 1;
  1619. }
  1620.  
  1621. return -1;
  1622. }
  1623. public PobierzBronieKlasy(Handle:plugin, numParams)
  1624. {
  1625. new klasa = GetNativeCell(1);
  1626. if(klasa <= ilosc_klas)
  1627. {
  1628. SetNativeString(2, bronie_klas[klasa], GetNativeCell(3));
  1629. return 1;
  1630. }
  1631.  
  1632. return 0;
  1633. }
  1634. public PobierzKondycjeKlasy(Handle:plugin, numParams)
  1635. {
  1636. new klasa = GetNativeCell(1);
  1637. if(klasa <= ilosc_klas)
  1638. return kondycja_klas[klasa];
  1639.  
  1640. return -1;
  1641. }
  1642. public PobierzGrawitacjeKlasy(Handle:plugin, numParams)
  1643. {
  1644. new klasa = GetNativeCell(1);
  1645. if(klasa <= ilosc_klas)
  1646. return grawitacja_klas[klasa];
  1647.  
  1648. return -1;
  1649. }
  1650. public PobierzNiewidzialnoscKlasy(Handle:plugin, numParams)
  1651. {
  1652. new klasa = GetNativeCell(1);
  1653. if(klasa <= ilosc_klas)
  1654. return niewidzialnosc_klas[klasa];
  1655.  
  1656. return -1;
  1657. }
  1658. public PobierzIloscItemow(Handle:plugin, numParams)
  1659. {
  1660. if(ilosc_itemow)
  1661. return ilosc_itemow;
  1662.  
  1663. return -1;
  1664. }
  1665. public PobierzItemPrzezNazwe(Handle:plugin, numParams)
  1666. {
  1667. new String:nazwa[64];
  1668. GetNativeString(1, nazwa, sizeof(nazwa));
  1669. for(new i = 1; i <= ilosc_itemow; i ++)
  1670. {
  1671. if(StrEqual(nazwa, nazwy_itemow[i]))
  1672. return i;
  1673. }
  1674.  
  1675. return -1;
  1676. }
  1677. public PobierzNazweItemu(Handle:plugin, numParams)
  1678. {
  1679. new item = GetNativeCell(1);
  1680. if(item <= ilosc_itemow)
  1681. {
  1682. SetNativeString(2, nazwy_itemow[item], GetNativeCell(3));
  1683. return 1;
  1684. }
  1685.  
  1686. return -1;
  1687. }
  1688. public PobierzOpisItemu(Handle:plugin, numParams)
  1689. {
  1690. new item = GetNativeCell(1);
  1691. if(item <= ilosc_itemow)
  1692. {
  1693. SetNativeString(2, opisy_itemow[item], GetNativeCell(3));
  1694. return 1;
  1695. }
  1696.  
  1697. return -1;
  1698. }
  1699. public ZarejestrujKlase(Handle:plugin, numParams)
  1700. {
  1701. if(numParams != 6)
  1702. return -1;
  1703.  
  1704. if(++ilosc_klas > MAKSYMALNA_ILOSC_KLAS)
  1705. return -2;
  1706.  
  1707. pluginy_klas[ilosc_klas] = plugin;
  1708. GetNativeString(1, nazwy_klas[ilosc_klas], sizeof(nazwy_klas[]));
  1709. GetNativeString(2, opisy_klas[ilosc_klas], sizeof(opisy_klas[]));
  1710. GetNativeString(3, bronie_klas[ilosc_klas], sizeof(bronie_klas[]));
  1711. kondycja_klas[ilosc_klas] = GetNativeCell(4);
  1712. grawitacja_klas[ilosc_klas] = GetNativeCell(5);
  1713. niewidzialnosc_klas[ilosc_klas] = GetNativeCell(6);
  1714.  
  1715. return ilosc_klas;
  1716. }
  1717. public ZarejestrujItem(Handle:plugin, numParams)
  1718. {
  1719. if(numParams != 4)
  1720. return -1;
  1721.  
  1722. if(++ilosc_itemow > MAKSYMALNA_ILOSC_ITEMOW)
  1723. return -2;
  1724.  
  1725. pluginy_itemow[ilosc_itemow] = plugin;
  1726. GetNativeString(1, nazwy_itemow[ilosc_itemow], sizeof(nazwy_itemow[]));
  1727. GetNativeString(2, opisy_itemow[ilosc_itemow], sizeof(opisy_itemow[]));
  1728. min_wartosci_itemow[ilosc_itemow] = GetNativeCell(3);
  1729. max_wartosci_itemow[ilosc_itemow] = GetNativeCell(4);
  1730.  
  1731. return ilosc_itemow;
  1732. }
  1733. public IsValidPlayers()
  1734. {
  1735. new gracze;
  1736. for(new i = 1; i <= MaxClients; i ++)
  1737. {
  1738. if(!IsClientInGame(i) || IsFakeClient(i))
  1739. continue;
  1740.  
  1741. gracze ++;
  1742. }
  1743.  
  1744. return gracze;
  1745. }
  1746. public bool:IsValidClient(client)
  1747. {
  1748. if(client >= 1 && client <= MaxClients && IsClientInGame(client))
  1749. return true;
  1750.  
  1751. return false;
  1752. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!