CVSBKR0q

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