prqnUK7j

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