MycF4Xyh

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