Lb8pNkrP

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