#include <amxmodx>
#include <amxmisc>
#include <cstrike>
#include <fakemeta>
#include <hamsandwich>
#include <nvault>
#include <fun>
#include <colorchat>
#include <codmod>

#define PLUGIN "Call of Duty MOD"
#define VERSION "UnlimiteD"
#define AUTHOR "NERO31"

#define MAX_WIELKOSC_NAZWY 32
#define MAX_WIELKOSC_OPISU 256
#define MAX_ILOSC_PERKOW 120
#define MAX_ILOSC_KLAS 100

#define STANDARDOWA_SZYBKOSC 250.0

#define ZADANIE_POKAZ_INFORMACJE 672
#define ZADANIE_POKAZ_REKLAME 768
#define ZADANIE_USTAW_SZYBKOSC 832

#define ZADANIE_POKAZ_CELOWNIK 896

#define MAXEXP 1400000

#define ZADANIE_POKAZ_WYTRZYMALOSC 35200

#define MAX_WIELKOSC_FRAKCJA 64
new frakcja_klas[MAX_ILOSC_KLAS+1][MAX_WIELKOSC_FRAKCJA+1]

native cod_set_perk_durability(id, wytrzymalosc);
native cod_get_perk_durability(id);


new const maxAmmo[31] = {0, 52, 0, 90, 1, 31, 1, 100, 90, 1, 120, 100, 100, 90, 90, 90, 100, 120, 30, 120, 200, 31, 90, 120,
 90, 2, 35, 90, 90,0, 100};

new const co_ile[] = { 1, 2, 5, 10, 25, 50, 100 } // Szybkosc rozdawania punktow np. po 1 punkcje, po 2, po 5 itp w daną statystyke.
new szybkosc_rozdania[33];


new pCvarPrefixy;

new MsgScreenfade;

new vault;

new SyncHudObj, SyncHudObj2;
 
new cvar_doswiadczenie_za_zabojstwo,
    cvar_doswiadczenie_za_obrazenia,
    cvar_doswiadczenie_za_wygrana,
    cvar_typ_zapisu,
    cvar_limit_poziomu,
    cvar_proporcja_poziomu,
    cvar_blokada_broni;

	new perk_zmieniony,
    klasa_zmieniona;

new nazwy_perkow[MAX_ILOSC_PERKOW+1][MAX_WIELKOSC_NAZWY+1],
     opisy_perkow[MAX_ILOSC_PERKOW+1][MAX_WIELKOSC_OPISU+1],
     max_wartosci_perkow[MAX_ILOSC_PERKOW+1],
     min_wartosci_perkow[MAX_ILOSC_PERKOW+1],
     pluginy_perkow[MAX_ILOSC_PERKOW+1],
     ilosc_perkow;

	new nazwa_gracza[33][64],
	klasa_gracza[33],
    nowa_klasa_gracza[33],
    poziom_gracza[33],
    doswiadczenie_gracza[33],
    perk_gracza[33],
    wartosc_perku_gracza[33];

	new Float:maksymalne_zdrowie_gracza[33],
    Float:szybkosc_gracza[33],
    
	Float:redukcja_obrazen_gracza[33];
	new punkty_gracza[33],
    zdrowie_gracza[33],
    inteligencja_gracza[33],
    wytrzymalosc_gracza[33],
    kondycja_gracza[33];
	new bool:gracz_ma_tarcze[33],
    bool:gracz_ma_noktowizor[33];     

	new bonusowe_bronie_gracza[33],
    bonusowe_zdrowie_gracza[33],
    bonusowa_inteligencja_gracza[33],
    bonusowa_wytrzymalosc_gracza[33],
    bonusowa_kondycja_gracza[33];

	new bronie_klasy[MAX_ILOSC_KLAS+1], 
    zdrowie_klas[MAX_ILOSC_KLAS+1],
    kondycja_klas[MAX_ILOSC_KLAS+1], 
    inteligencja_klas[MAX_ILOSC_KLAS+1], 
    wytrzymalosc_klas[MAX_ILOSC_KLAS+1],
    nazwy_klas[MAX_ILOSC_KLAS+1][MAX_WIELKOSC_NAZWY+1],
    opisy_klas[MAX_ILOSC_KLAS+1][MAX_WIELKOSC_OPISU+1],
    pluginy_klas[MAX_ILOSC_KLAS+1],
    ilosc_klas;

new bronie_druzyny[] = {0, 1<<CSW_KNIFE, 1<<CSW_KNIFE},
     bronie_dozwolone = 1<<CSW_KNIFE | 1<<CSW_C4;

new bool:freezetime = true;

new w_wytrzymalosc;

new const ranga[202][]={
	"Brak",
	"Rekrut",
	"Rekrut I",
	"Rekrut II",
	"Rekrut III",
	"Rekrut IV",
	"Rekrut V",
	"Szeregowy",
	"Szeregowy I",
	"Szeregowy II",
	"Szeregowy III",
	"Szeregowy IV",
	"Szeregowy V",
	"Agent",
	"Agent I",
	"Agent II",
	"Agent III",
	"Agent IV",
	"Agent V",
	"Szturmowiec",
	"Szturmowiec I",
	"Szturmowiec II",
	"Szturmowiec III",
	"Szturmoweic IV",
	"Szturmowiec V",
	"Specjalista",
	"Specialista I",
	"Specialista II",
	"Specialista III",
	"Specjalista IV",
	"Specjalista V",
	"Kapral",
	"Kapral I",
	"Kapral II",
	"Kapral III",
	"Kapral IV",
	"Kapral V",
	"Sierzant",
	"Sierzant I",
	"Sierzant II",
	"Sierzant III",
	"Sierzant IV",
	"Sierzant V",
	"Sierzant sztabowy",
	"Sierzant sztabowy I",
	"Sierzant sztabowy II",
	"Sierzant sztabowy III",
	"Sierzant sztabowy IV",
	"Sierzant sztabowy V",
	"Sierzant pierwszej klasy",
	"Sierzant pierwszej klasy I",
	"Sierzant pierwszej klasy II",
	"Sierzant pierwszej klasy III",
	"Sierzant pierwszej klasy IV",
	"Sierzant pierwszej klasy V",
	"Mistrzowski sierzant",
	"Mistrzowski sierzant I",
	"Mistrzowski sierzant II",
	"Mistrzowski sierzant III",
	"Mistrzowski sierzant IV",
	"Mistrzowski sierzant V",
	"Pierwszy sierzant",
	"Pierwszy sierzant I",
	"Pierwszy sierzant II",
	"Pierwszy sierzant III",
	"Pierwszy sierzant IV",
	"Pierwszy sierzant V",
	"Sierzant major",
	"Sierzant major I",
	"Sierzant major II",
	"Sierzant major III",
	"Sierzant major IV",
	"Sierzant major V",
	"Sierzant major dowodca",
	"Sierzant major dowodca I",
	"Sierzant major dowodca II",
	"Sierzant major dowodca III",
	"Sierzant major dowodca IV",
	"Sierzant major dowodca V",
	"Podporucznik",
	"Podporucznik I",
	"Podporucznik II",
	"Podporucznik III",
	"Podporucznik IV",
	"Podporucznik V",
	"Porucznik",
	"Porucznik I",
	"Porucznik II",
	"Porucznik III",
	"Porucznik IV",
	"Porucznik V",
	"Kapitan",
	"Kapitan I",
	"Kapitan II",
	"Kapitan III",
	"Kapitan IV",
	"Kapitan V",
	"Major",
	"Major I",
	"Major II",
	"Major III",
	"Major IV",
	"Major V",
	"Podpulkownik",
	"Podpulkownik I",
	"Podpulkownik II",
	"Podpulkownik III",
	"Podpulkownik IV",
	"Podpulkownik V",
	"Pulkownik",
	"Pulkownik I",
	"Pulkownik II",
	"Pulkownik III",
	"Pulkownik IV",
	"Pulkownik V",
	"General brygady",
	"General brygady I",
	"General brygady II",
	"General brygady III",
	"General brygady IV",
	"General brygady V",
	"General dywizji",
	"General dywizji I",
	"General dywizji II",
	"General dywizji III",
	"General dywizji IV",
	"General dywizji V",
	"General broni",
	"General broni I",
	"General broni II",
	"General broni III",
	"General broni IV",
	"General broni V",
	"General",
	"General I",
	"General II",
	"General III",
	"General IV",
	"General V",
	"Komandor",
	"Komandor I",
	"Komandor II",
	"Komandor III",
	"Komandor IV",
	"Komandor V",
	"Brygadzista",
	"Brygadzista I",
	"Brygadzista II",
	"Brygadzista III",
	"Brygadzista IV",
	"Brygadzista V",
	"Plutonowy",
	"Plutonowy I",
	"Plutonowy II",
	"Plutonowy III",
	"Plutonowy IV",
	"Plutonowy V",
	"Oddzialowy",
	"Oddzialowy I",
	"Oddzialowy II",
	"Oddzialowy III",
	"Oddzialowy IV",
	"Oddzialowy V",
	"Weteran",
	"Weteran I",
	"Weteran II",
	"Weteran III",
	"Weteran IV",
	"Weteran V",
	"Podoficer",
	"Podoficer I",
	"Podoficer II",
	"Podoficer III",
	"Podoficer IV",
	"Podoficer V",
	"Oficer",
	"Oficer I",
	"Oficer II",
	"Oficer III",
	"Oficer IV",
	"Oficer V",
	"Chorazy",
	"Chorazy I",
	"Chorazy II",
	"Chorazy III",
	"Chorazy IV",
	"Chorazy V",
	"Starszy Chorazy",
	"Starszy Chorazy I",
	"Starszy Chorazy II",
	"Starszy Chorazy III",
	"Starszy Chorazy IV",
	"Starszy Chorazy V",
	"Marszalek",
	"Marszalek I",
	"Marszalek II",
	"Marszalek III",
	"Marszalek IV",
	"Marszalek V",
	"Vice Admiral",
	"Admiral Floty",
	"Admiral"
}

public plugin_init() 
{
	register_plugin(PLUGIN, VERSION, AUTHOR);
	
	cvar_doswiadczenie_za_zabojstwo = register_cvar("cod_killxp", "10");
	cvar_doswiadczenie_za_obrazenia = register_cvar("cod_damagexp", "1"); // ilosc doswiadczenia za 20 obrazen 
	cvar_doswiadczenie_za_wygrana = register_cvar("cod_winxp", "50");
	cvar_typ_zapisu = register_cvar("cod_savetype", "2");  // 1-Nick; 2-SID dla Steam; 3-IP
	cvar_limit_poziomu = register_cvar("cod_maxlevel", "200"); 
	cvar_proporcja_poziomu = register_cvar("cod_levelratio", "35"); 
	cvar_blokada_broni = register_cvar("cod_weaponsblocking", "1"); 
	
	register_clcmd("say /klasa", "WybierzKlase");
	register_clcmd("say /class", "WybierzKlase");
	register_clcmd("say /klasy", "OpisKlasy");
	register_clcmd("say /classinfo", "OpisKlasy");
	register_clcmd("say /item", "KomendaOpisPerku");
	register_clcmd("say /itemy", "OpisPerkow");
	register_clcmd("say /perki", "OpisPerkow");
	register_clcmd("say /przedmiot", "OpisPerku");
	register_clcmd("say /drop", "WyrzucPerk");
	register_clcmd("say /wyrzuc", "WyrzucPerk");
	register_clcmd("say /reset", "KomendaResetujPunkty");
	register_clcmd("say /statystyki", "PrzydzielPunkty");
	register_clcmd("say /staty", "PrzydzielPunkty");
	register_clcmd("say /pomoc", "Pomoc");
	register_clcmd("useperk", "UzyjPerku");
	register_clcmd("radio3", "UzyjPerku");
	register_clcmd("fullupdate", "BlokujKomende");
	
	register_menucmd(register_menuid("Klasa:"), 1023, "OpisKlasy");
	
	RegisterHam(Ham_TakeDamage, "player", "Obrazenia");
	RegisterHam(Ham_TakeDamage, "player", "ObrazeniaPost", 1);
	RegisterHam(Ham_Spawn, "player", "Odrodzenie", 1);
	RegisterHam(Ham_Killed, "player", "SmiercGraczaPost", 1);
	
	RegisterHam(Ham_Touch, "armoury_entity", "DotykBroni");
	RegisterHam(Ham_Touch, "weapon_shield", "DotykTarczy");
	RegisterHam(Ham_Touch, "weaponbox", "DotykBroni");
	
	register_forward(FM_CmdStart, "CmdStart");
	register_forward(FM_EmitSound, "EmitSound");
	
	register_logevent("PoczatekRundy", 2, "1=Round_Start"); 
	
	register_event("SendAudio", "WygranaTerro" , "a", "2&%!MRAD_terwin");
	register_event("SendAudio", "WygranaCT", "a", "2&%!MRAD_ctwin");
	register_event("CurWeapon","CurWeapon","be", "1=1");
	register_event("HLTV", "NowaRunda", "a", "1=0", "2=0");
	
	register_message(get_user_msgid("SayText"),"handleSayText");
	
	pCvarPrefixy	=	register_cvar("cod_prefix","3");
	
	vault = nvault_open("CodMod");
	
	MsgScreenfade = get_user_msgid("ScreenFade");
	
	SyncHudObj = CreateHudSyncObj();
	SyncHudObj2 = CreateHudSyncObj();
	
	perk_zmieniony = CreateMultiForward("cod_perk_changed", ET_CONTINUE, FP_CELL, FP_CELL, FP_CELL);
	klasa_zmieniona = CreateMultiForward("cod_class_changed", ET_CONTINUE, FP_CELL, FP_CELL);

	copy(nazwy_perkow[0], MAX_WIELKOSC_NAZWY, "Brak");
	copy(opisy_perkow[0], MAX_WIELKOSC_OPISU, "Zabij kogos, aby otrzymac przedmiot");
	copy(nazwy_klas[0], MAX_WIELKOSC_NAZWY, "Brak");
	
	set_task(1.0, "plugin_cfg");
	
}		

public plugin_cfg()
{
	new lokalizacja_cfg[33];
	get_configsdir(lokalizacja_cfg, charsmax(lokalizacja_cfg));
	server_cmd("exec %s/codmod.cfg", lokalizacja_cfg);
	server_exec();
}

public plugin_precache()
{	
	precache_sound("COD/newestselect.wav");
	precache_sound("COD/start.wav");
	precache_sound("COD/start2.wav");
	precache_sound("COD/levelup.wav");
}

public plugin_natives()
{
	register_native("cod_set_user_xp", "UstawDoswiadczenie", 1);
	register_native("cod_set_user_class", "UstawKlase", 1);
	register_native("cod_set_user_perk", "UstawPerk", 1);
	register_native("cod_set_user_bonus_health", "UstawBonusoweZdrowie", 1);
	register_native("cod_set_user_bonus_intelligence", "UstawBonusowaInteligencje", 1);
	register_native("cod_set_user_bonus_trim", "UstawBonusowaKondycje", 1);
	register_native("cod_set_user_bonus_stamina", "UstawBonusowaWytrzymalosc", 1);
	
	register_native("cod_points_to_health", "PrzydzielZdrowie", 1);	
	register_native("cod_points_to_intelligence", "PrzydzielInteligencje", 1);	
	register_native("cod_points_to_trim", "PrzydzielKondycje", 1);	
	register_native("cod_points_to_stamina", "PrzydzielWytrzymalosc", 1);	
	
	register_native("cod_get_user_xp", "PobierzDoswiadczenie", 1);
	register_native("cod_get_user_level", "PobierzPoziom", 1);
	register_native("cod_get_user_points", "PobierzPunkty", 1);
	register_native("cod_get_user_class", "PobierzKlase", 1);
	register_native("cod_get_user_perk", "PobierzPerk", 1);
	register_native("cod_get_user_health", "PobierzZdrowie", 1);
	register_native("cod_get_user_intelligence", "PobierzInteligencje", 1);
	register_native("cod_get_user_trim", "PobierzKondycje", 1);
	register_native("cod_get_user_stamina", "PobierzWytrzymalosc", 1);
	
	register_native("cod_get_level_xp", "PobierzDoswiadczeniePoziomu", 1);
	
	register_native("cod_get_perkid", "PobierzPerkPrzezNazwe", 1);
	register_native("cod_get_perks_num", "PobierzIloscPerkow", 1);
	register_native("cod_get_perk_name", "PobierzNazwePerku", 1);
	register_native("cod_get_perk_desc", "PobierzOpisPerku", 1);
	
	register_native("cod_get_classid", "PobierzKlasePrzezNazwe", 1);
	register_native("cod_get_classes_num", "PobierzIloscKlas", 1);
	register_native("cod_get_class_name", "PobierzNazweKlasy", 1);
	register_native("cod_get_class_desc", "PobierzOpisKlasy", 1);
	
	register_native("cod_get_class_health", "PobierzZdrowieKlasy", 1);
	register_native("cod_get_class_intelligence", "PobierzInteligencjeKlasy", 1);
	register_native("cod_get_class_trim", "PobierzKondycjeKlasy", 1);
	register_native("cod_get_class_stamina", "PobierzWytrzymaloscKlasy", 1);
	
	register_native("cod_give_weapon", "DajBron", 1);
	register_native("cod_take_weapon", "WezBron", 1);
	register_native("cod_set_user_shield", "UstawTarcze", 1);
	register_native("cod_set_user_nightvision", "UstawNoktowizor", 1);
	
	register_native("cod_inflict_damage", "ZadajObrazenia", 1);
	
	register_native("cod_register_perk", "ZarejestrujPerk");
	register_native("cod_register_class", "ZarejestrujKlase");
}

public CmdStart(id, uc_handle)
{		
	if(!is_user_alive(id))
		return FMRES_IGNORED;

	new Float: velocity[3];
	pev(id, pev_velocity, velocity);
	new Float: speed = vector_length(velocity);
	if(szybkosc_gracza[id] > speed*1.8)
		set_pev(id, pev_flTimeStepSound, 300);
	
	return FMRES_IGNORED;
}

public Odrodzenie(id)
{	
		
	if(!task_exists(id+ZADANIE_POKAZ_INFORMACJE))
		set_task(0.1, "PokazInformacje", id+ZADANIE_POKAZ_INFORMACJE, _, _, "b");
	
	if(nowa_klasa_gracza[id])
	UstawNowaKlase(id);
	
	if(!klasa_gracza[id])
	{
		WybierzKlase(id);
		return PLUGIN_CONTINUE;
	}
	
	DajBronie(id);
	ZastosujAtrybuty(id);
	
	if(punkty_gracza[id] > 0)
		PrzydzielPunkty(id);
	
	return PLUGIN_CONTINUE;

}

public UstawNowaKlase(id)
{
	new ret;
		
	new forward_handle = CreateOneForward(pluginy_klas[klasa_gracza[id]], "cod_class_disabled", FP_CELL, FP_CELL);
	ExecuteForward(forward_handle, ret, id, klasa_gracza[id]);
	DestroyForward(forward_handle);
		
	forward_handle = CreateOneForward(pluginy_klas[nowa_klasa_gracza[id]], "cod_class_enabled", FP_CELL, FP_CELL);
	ExecuteForward(forward_handle, ret, id, nowa_klasa_gracza[id]);
	DestroyForward(forward_handle);
	
	
	if(ret == 4)	
	{
		klasa_gracza[id] = 0;
		return PLUGIN_CONTINUE;
	}

	ExecuteForward(klasa_zmieniona, ret, id, klasa_gracza[id]);
	
	if(ret == 4)	
	{
		klasa_gracza[id] = 0;
		return PLUGIN_CONTINUE;
	}
	
	klasa_gracza[id] = nowa_klasa_gracza[id];
	nowa_klasa_gracza[id] = 0;
	UstawPerk(id, perk_gracza[id], wartosc_perku_gracza[id], 0);
	
	WczytajDane(id, klasa_gracza[id]);
	return PLUGIN_CONTINUE;
}

public DajBronie(id)
{
	for(new i=1; i < 32; i++)
	{
		if((1<<i) & (bronie_klasy[klasa_gracza[id]] | bonusowe_bronie_gracza[id]))
		{
			new weaponname[22];
			get_weaponname(i, weaponname, 21);
			fm_give_item(id, weaponname);
		}
	}
	
	if(gracz_ma_tarcze[id])
		fm_give_item(id, "weapon_shield");
		
	if(gracz_ma_noktowizor[id])
		cs_set_user_nvg(id, 1);
	
	new weapons[32];
	new weaponsnum;
	get_user_weapons(id, weapons, weaponsnum);
	for(new i=0; i<weaponsnum; i++)
		if(is_user_alive(id))
			if(maxAmmo[weapons[i]] > 0)
				cs_set_user_bpammo(id, weapons[i], maxAmmo[weapons[i]]);
}

public ZastosujAtrybuty(id)
{
	redukcja_obrazen_gracza[id] = 0.7*(1.0-floatpower(1.1, -0.112311341*PobierzWytrzymalosc(id, 1, 1, 1)));
	
	maksymalne_zdrowie_gracza[id] = 100.0+PobierzZdrowie(id, 1, 1, 1);
	
	szybkosc_gracza[id] = STANDARDOWA_SZYBKOSC+PobierzKondycje(id, 1, 1, 1)*1.3;
	
	set_pev(id, pev_health, maksymalne_zdrowie_gracza[id]);
}

public PoczatekRundy()	
{
	freezetime = false;
	for(new id=0;id<=32;id++)
	{
		if(!is_user_alive(id))
			continue;

		Display_Fade(id, 1<<9, 1<<9, 1<<12, 0, 255, 70, 100);
		
		set_task(0.1, "UstawSzybkosc", id+ZADANIE_USTAW_SZYBKOSC);
		
		switch(get_user_team(id))
		{
			case 1: client_cmd(id, "spk COD/start2");
			case 2: client_cmd(id, "spk COD/start");
		}
	}
}

public NowaRunda()
	freezetime = true;

public Obrazenia(this, idinflictor, idattacker, Float:damage, damagebits)
{
	if(!is_user_alive(idattacker))
		return HAM_IGNORED;

	if(get_user_team(this) == get_user_team(idattacker))
		return HAM_IGNORED;
		
	if(get_user_health(this) <= 1)
		return HAM_IGNORED;
	
	SetHamParamFloat(4, damage*(1.0-redukcja_obrazen_gracza[this]));
		
	return HAM_IGNORED;
}

public ObrazeniaPost(id, idinflictor, attacker, Float:damage, damagebits)
{
	if(!is_user_connected(attacker) || !klasa_gracza[attacker])
		return HAM_IGNORED;
		
	SprawdzPoziom(attacker);
	return HAM_IGNORED;
}

public SmiercGraczaPost(id, attacker, shouldgib)
{	
	if(!is_user_connected(attacker))
		return HAM_IGNORED;
		
	if(get_user_team(id) != get_user_team(attacker) && klasa_gracza[attacker])
	{
		new doswiadczenie_za_zabojstwo = get_pcvar_num(cvar_doswiadczenie_za_zabojstwo);
		new nowe_doswiadczenie = get_pcvar_num(cvar_doswiadczenie_za_zabojstwo);
		
		if(poziom_gracza[id] > poziom_gracza[attacker])
			nowe_doswiadczenie += (poziom_gracza[id]-poziom_gracza[attacker])*(doswiadczenie_za_zabojstwo/10);
			
		if(!perk_gracza[attacker])
			UstawPerk(attacker, -1, -1, 1);
		doswiadczenie_gracza[attacker] += nowe_doswiadczenie;
		
		ColorChat(id, RED, "[CoD UnlimiteD]^x01 Zostales zabity przez ^x03%s^x01 dostal on ^x03%i^x01 expa", nazwa_gracza[attacker], nowe_doswiadczenie);
	}
	
	SprawdzPoziom(attacker);
	
	return HAM_IGNORED;
}

public client_authorized(id)
{
	UsunUmiejetnosci(id);

	get_user_name(id, nazwa_gracza[id], 63);
	
	UsunZadania(id);
}

public client_disconnect(id)
{
	ZapiszDane(id);
	UsunUmiejetnosci(id);
	UsunZadania(id);
}

public UsunUmiejetnosci(id)
{
	nowa_klasa_gracza[id] = 0;
	UstawNowaKlase(id);
	klasa_gracza[id] = 0;
	poziom_gracza[id] = 0;
	doswiadczenie_gracza[id] = 0;
	punkty_gracza[id] = 0;
	zdrowie_gracza[id] = 0;
	inteligencja_gracza[id] = 0;
	wytrzymalosc_gracza[id] = 0;
	kondycja_gracza[id] = 0;
	bonusowe_zdrowie_gracza[id] = 0;
	bonusowa_wytrzymalosc_gracza[id] = 0;
	bonusowa_inteligencja_gracza[id] = 0;
	bonusowa_kondycja_gracza[id] = 0;
	maksymalne_zdrowie_gracza[id] = 0.0;
	szybkosc_gracza[id] = 0.0;
	UstawPerk(id, 0, 0, 0);
}

public UsunZadania(id)
{
	remove_task(id+ZADANIE_POKAZ_INFORMACJE);
	remove_task(id+ZADANIE_POKAZ_REKLAME);	
	remove_task(id+ZADANIE_USTAW_SZYBKOSC);
}
	
public WygranaTerro()
	WygranaRunda("TERRORIST");
	
public WygranaCT()
	WygranaRunda("CT");

public WygranaRunda(const Team[])
{
	new Players[32], playerCount, id;
	get_players(Players, playerCount, "aeh", Team);
	new doswiadczenie_za_wygrana = get_pcvar_num(cvar_doswiadczenie_za_wygrana);
	
	if(get_playersnum() < 2)
		return;
		
	for (new i=0; i<playerCount; i++) 
	{
		id = Players[i];
		if(!klasa_gracza[id])
		continue;
		
		doswiadczenie_gracza[id] += doswiadczenie_za_wygrana;
		
	new wytrzymalosc_itemku = cod_get_perk_durability(id);
	w_wytrzymalosc = 5;
	if(wytrzymalosc_itemku+w_wytrzymalosc)
		cod_set_perk_durability(id, wytrzymalosc_itemku+=w_wytrzymalosc);
		ColorChat(id, RED, "[CoD UnlimiteD]^x01 Zyskales ^x03%i^x01 expa oraz ^x03%i^x01 wytrzymalosci itemu za Wygranie rundy", doswiadczenie_za_wygrana, w_wytrzymalosc);
		SprawdzPoziom(id);
	}
}

public KomendaOpisPerku(id)
	OpisPerku(id, perk_gracza[id], wartosc_perku_gracza[id]);
	
public OpisPerku(id, perk, wartosc)
{
	new opis_perku[MAX_WIELKOSC_OPISU];
	new losowa_wartosc[15];
	if(wartosc > -1)
		num_to_str(wartosc, losowa_wartosc, 14);
	else
		format(losowa_wartosc, charsmax(losowa_wartosc), "%i-%i", min_wartosci_perkow[perk], max_wartosci_perkow[perk]);
		
	format(opis_perku, charsmax(opis_perku), opisy_perkow[perk]);
	replace_all(opis_perku, charsmax(opis_perku), "LW", losowa_wartosc);
	
	client_print(id, print_chat, "Item: %s.", nazwy_perkow[perk]);
	client_print(id, print_chat, "Opis: %s.", opis_perku);
}

public OpisPerkow(id)
{
	new menu = menu_create("Wybierz Item:", "OpisPerkow_Handle");
	for(new i=1; i <= ilosc_perkow; i++)
		menu_additem(menu, nazwy_perkow[i]);
	menu_setprop(menu, MPROP_EXITNAME, "Wyjdz");
	menu_setprop(menu, MPROP_BACKNAME, "Poprzednia strona");
	menu_setprop(menu, MPROP_NEXTNAME, "Nastepna strona");
	menu_display(id, menu);
	client_cmd(id, "spk QTM_CodMod/newestselect");
}

public OpisPerkow_Handle(id, menu, item)
{
	if(item++ == MENU_EXIT)
	{
		menu_destroy(menu);
		return PLUGIN_CONTINUE;
	}
	OpisPerku(id, item, -1);
	OpisPerkow(id);
	return PLUGIN_CONTINUE;
}


public OpisKlasy(id)
{
	new menu = menu_create("Wybierz klase:", "OpisKlasy_Handle");
	for(new i=1; i <= ilosc_klas; i++)
		menu_additem(menu, nazwy_klas[i]);
	menu_setprop(menu, MPROP_EXITNAME, "Wyjdz");
	menu_setprop(menu, MPROP_BACKNAME, "Poprzednia strona");
	menu_setprop(menu, MPROP_NEXTNAME, "Nastepna strona");
	menu_display(id, menu);
	
	client_cmd(id, "spk QTM_CodMod/newestselect");
}

public OpisKlasy_Handle(id, menu, item)
{
	client_cmd(id, "spk QTM_CodMod/newestselect");
	
	if(item++ == MENU_EXIT)
	{
		menu_destroy(menu);
		return PLUGIN_CONTINUE;
	}
	
	new bronie[320];
	for(new i=1, n=1; i <= 32; i++)
	{
		if((1<<i) & bronie_klasy[item])
		{
			new weaponname[22];
			get_weaponname(i, weaponname, 21);
			replace_all(weaponname, 21, "weapon_", " ");
			if(n > 1)	
				add(bronie, charsmax(bronie), ",");
			add(bronie, charsmax(bronie), weaponname);
			n++;
		}
	}
	
	new opis[416+MAX_WIELKOSC_OPISU];
	format(opis, charsmax(opis), "yKlasa: w%s^nyInteligencja: w%i^nyZdrowie: w%i^nyWytrzymalosc: w%i^nyKondycja: w%i^nyBronie:w%s^nyDodatkowy opis: w%s^n%s", nazwy_klas[item], inteligencja_klas[item], zdrowie_klas[item], wytrzymalosc_klas[item], kondycja_klas[item], bronie, opisy_klas[item], opisy_klas[item][79]);
	show_menu(id, 1023, opis);
	
	return PLUGIN_CONTINUE;
}

public bool:is_in_previous(frakcja[],from){
        for(new i = from - 1;i>=1;i--){
                if(equali(frakcja_klas[i],frakcja)){
                        return true;
                }
        }
        return false;
}

public WybierzKlase(id)
{
        new menu = menu_create("Wybierz frakcje:", "WybierzKlase_Frakcje");
        for(new i=1; i <= ilosc_klas; i++)
        {
                if(!equal(frakcja_klas[i],"") && !is_in_previous(frakcja_klas[i],i)){
                        menu_additem(menu,frakcja_klas[i],frakcja_klas[i])
                }
        }
        
        menu_setprop(menu, MPROP_EXITNAME, "Wyjdz");
        menu_setprop(menu, MPROP_BACKNAME, "Poprzednia strona");
        menu_setprop(menu, MPROP_NEXTNAME, "Nastepna strona");
        menu_display(id, menu);
}

public WybierzKlase_Frakcje(id, menu, item)
{
        if(item == MENU_EXIT){
                menu_destroy(menu);
                return PLUGIN_CONTINUE;
        }
        
        new data[65], iName[64] 
        new acces, callback 
        menu_item_getinfo(menu, item, acces, data,64, iName, 63, callback) 
        
        new menu2 = menu_create("Wybierz klase:", "WybierzKlase_Handle");
        
        new klasa[100],szTmp[5];
        for(new i=1; i <= ilosc_klas; i++)
        {
                if(equali(data,frakcja_klas[i])){
                        WczytajDane(id, i);
                        format(klasa, charsmax(klasa), "%s yPoziom: %i", nazwy_klas[i], poziom_gracza[id], ranga[poziom_gracza[id]]);
                        num_to_str(i,szTmp,charsmax(szTmp));
                        menu_additem(menu2, klasa,szTmp);
                }
        }
        
        WczytajDane(id, klasa_gracza[id]);
        
        menu_setprop(menu2, MPROP_EXITNAME, "Wyjdz");
        menu_setprop(menu2, MPROP_BACKNAME, "Poprzednia strona");
        menu_setprop(menu2, MPROP_NEXTNAME, "Nastepna strona");
        menu_display(id, menu2);
        
        client_cmd(id, "spk QTM_CodMod/select");
        
        menu_destroy(menu);
        return PLUGIN_CONTINUE;
}

public WybierzKlase_Handle(id, menu, item)
{
        client_cmd(id, "spk QTM_CodMod/select");
        
        if(item == MENU_EXIT)
        {
                menu_destroy(menu);
                return PLUGIN_CONTINUE;
        }       
        
        new data[65], iName[64] 
        new acces, callback 
        menu_item_getinfo(menu, item, acces, data,64, iName, 63, callback) 
        
        item = str_to_num(data);
        
        if(item == klasa_gracza[id] && !nowa_klasa_gracza[id])
        return PLUGIN_CONTINUE;
        
        nowa_klasa_gracza[id] = item;
        
        if(klasa_gracza[id])
        ColorChat(id, RED, "[CoD UnlimiteD]^x01 Klasa zmieni sie w nastepnej rundzie!")
        else
        {
                UstawNowaKlase(id);
                DajBronie(id);
                ZastosujAtrybuty(id);
        }
        
        return PLUGIN_CONTINUE;
}

public PrzydzielPunkty(id)
{
		new inteligencja[65];
		new zdrowie[60];
		new wytrzymalosc[60];
		new kondycja[60];
		new szybkosc[60];
		new tytul[25];
		
		format(inteligencja, charsmax(inteligencja), "Inteligencja: r%iy/r125 y[Zwieksza sile itemow i klas]", PobierzInteligencje(id, 1, 1, 1));
		format(zdrowie, charsmax(zdrowie), "Zdrowie: r%iy/r125 y[Zwieksza zdrowie]", PobierzZdrowie(id, 1, 1, 1));
		format(wytrzymalosc, charsmax(wytrzymalosc), "Wytrzymalosc: r%iy/r175 y[Jestes bardziej odporny]", PobierzWytrzymalosc(id, 1, 1, 1));
		format(kondycja, charsmax(kondycja), "Kondycja: r%iy/r175 y[Zwieksza tempo chodu]", PobierzKondycje(id, 1, 1, 1));
		format(szybkosc, charsmax(szybkosc), "Ile dodawac: r%d y[Ile pkt dodac do statow]", co_ile[szybkosc_rozdania[id]]);
		format(tytul, charsmax(tytul), "Przydziel Punkty(%i):", punkty_gracza[id]);
		new menu = menu_create(tytul, "PrzydzielPunkty_Handler");
		menu_additem(menu, inteligencja);
		menu_additem(menu, zdrowie);
		menu_additem(menu, wytrzymalosc);
		menu_additem(menu, kondycja);
		menu_addblank(menu, 0);
		menu_additem(menu, szybkosc);
		menu_setprop(menu, MPROP_EXITNAME, "Wyjdz");
		menu_display(id, menu);
}

public PrzydzielPunkty_Handler(id, menu, item) {
        client_cmd(id, "spk QTM_CodMod/newestselect");
        
        if(item == MENU_EXIT) {
                menu_destroy(menu);
                return PLUGIN_CONTINUE;
        }
        
        if(punkty_gracza[id] < 1)
                return PLUGIN_CONTINUE;
        
        new limit_poziomu = get_pcvar_num(cvar_limit_poziomu);
        new ilosc = (co_ile[szybkosc_rozdania[id]] > punkty_gracza[id]) ? punkty_gracza[id] : co_ile[szybkosc_rozdania[id]]
        
        switch(item) { 
     
		case 0: 
		{	
			if(inteligencja_gracza[id] < 125) {
				if(ilosc > 125 - inteligencja_gracza[id])
					ilosc = 125 - inteligencja_gracza[id];
				inteligencja_gracza[id]+=ilosc;
				punkty_gracza[id]-=ilosc;
			} else ColorChat(id, RED, "[CoD UnlimiteD]^x01 Maxymalny poziom Inteligencji osiagniety");
			
			
		}
		case 1: 
		{	
			if(zdrowie_gracza[id] < 125) {
				if(ilosc > 125 - zdrowie_gracza[id])
					ilosc = 125 - zdrowie_gracza[id];
				zdrowie_gracza[id]+=ilosc;
				punkty_gracza[id]-=ilosc;
			}
			else 
				ColorChat(id, RED, "[CoD UnlimiteD]^x01 Maxymalny poziom Zdrowia osiagniety");
		}
		case 2: 
		{	
			if(wytrzymalosc_gracza[id] < 175) {
				if(ilosc > 175 - wytrzymalosc_gracza[id])
					ilosc = 175 - wytrzymalosc_gracza[id];
				wytrzymalosc_gracza[id]+=ilosc;
				punkty_gracza[id]-=ilosc;
			}
			else 
				ColorChat(id, RED, "[CoD UnlimiteD]^x01 Maxymalny poziom Wytrzymalosci osiagniety");
			
		}
		case 3: 
		{	
			if(kondycja_gracza[id] < 175) {
				if(ilosc > 175 - kondycja_gracza[id])
					ilosc = 175 - kondycja_gracza[id];
				kondycja_gracza[id]+=ilosc;
				punkty_gracza[id]-=ilosc;
			}
			else 
				ColorChat(id, RED, "[CoD UnlimiteD]^x01 Maxymalny poziom Kondycji osiagniety");
			
		}
		case 4: {
                        if(szybkosc_rozdania[id] < charsmax(co_ile)) szybkosc_rozdania[id]++;
                        else szybkosc_rozdania[id] = 0;
		}
	}
	
	if(punkty_gracza[id] > 0)
		PrzydzielPunkty(id);
		
	return PLUGIN_CONTINUE;
}

public KomendaResetujPunkty(id)
{	
	ColorChat(id, RED, "[CoD UnlimiteD]^x01 Umiejetnosci zostana zresetowane");
	client_cmd(id, "spk QTM_CodMod/newestselect");
	
	ResetujPunkty(id);
}

public ResetujPunkty(id)
{
	punkty_gracza[id] = (poziom_gracza[id]-1)*3;
	inteligencja_gracza[id] = 0;
	zdrowie_gracza[id] = 0;
	kondycja_gracza[id] = 0;
	wytrzymalosc_gracza[id] = 0;
	
	if(punkty_gracza[id])
		PrzydzielPunkty(id);
}

public CurWeapon(id)
{
	if(!is_user_connected(id))
		return;
		
	new team = get_user_team(id);
	
	if(team > 2)
		return;
		
	new bron = read_data(2);
		
	new bronie = (bronie_klasy[klasa_gracza[id]] | bonusowe_bronie_gracza[id] | bronie_druzyny[team] | bronie_dozwolone);
	
	if(!(1<<bron & bronie))
	{
		new weaponname[22];
		
		get_weaponname(bron, weaponname, 21);
		ham_strip_weapon(id, weaponname);
	}
	
	if(cs_get_user_shield(id) && !gracz_ma_tarcze[id])
		engclient_cmd(id, "drop", "weapon_shield");	
		
	UstawSzybkosc(id);
}

public EmitSound(id, iChannel, szSound[], Float:fVol, Float:fAttn, iFlags, iPitch ) 
{
	if(!is_user_alive(id))
		return FMRES_IGNORED;
		
	if(equal(szSound, "common/wpn_denyselect.wav"))
	{
		new forward_handle = CreateOneForward(pluginy_klas[klasa_gracza[id]], "cod_class_skill_used", FP_CELL);
		ExecuteForward(forward_handle, id, id);
		DestroyForward(forward_handle);
		return FMRES_SUPERCEDE;
	}

	if(equal(szSound, "items/ammopickup2.wav"))
	{
		cs_set_user_armor(id, 0, CS_ARMOR_NONE);
		return FMRES_SUPERCEDE;
	}
	
	if(equal(szSound, "items/equip_nvg.wav") && !gracz_ma_noktowizor[id])
	{
		cs_set_user_nvg(id, 0);
		return FMRES_SUPERCEDE;
	}
	
	return FMRES_IGNORED;
}

public UzyjPerku(id)
{
	if(!is_user_alive(id))
		return PLUGIN_HANDLED;
		
	new forward_handle = CreateOneForward(pluginy_perkow[perk_gracza[id]], "cod_perk_used", FP_CELL);
	ExecuteForward(forward_handle, id, id);
	DestroyForward(forward_handle);
	return PLUGIN_HANDLED;
}

public ZapiszDane(id)
{
	if(!klasa_gracza[id])
		return PLUGIN_CONTINUE;
		
		new vaultkey[128],vaultdata[256], identyfikator[64];
                format(vaultdata, charsmax(vaultdata),"#%i#%i#%i#%i#%i#%i", doswiadczenie_gracza[id], poziom_gracza[id], inteligencja_gracza[id], zdrowie_gracza[id], wytrzymalosc_gracza[id], kondycja_gracza[id]);
	
	new typ_zapisu = get_pcvar_num(cvar_typ_zapisu);
	
	switch(typ_zapisu)
	{
		case 1: copy(identyfikator, charsmax(identyfikator), nazwa_gracza[id]);
		case 2: get_user_authid(id, identyfikator, charsmax(identyfikator));
		case 3: get_user_ip(id, identyfikator, charsmax(identyfikator));
	}
		
	format(vaultkey, charsmax(vaultkey),"%s-%s-%i-cod", identyfikator, nazwy_klas[klasa_gracza[id]], typ_zapisu);
	nvault_set(vault,vaultkey,vaultdata);
	
	return PLUGIN_CONTINUE;
}

public WczytajDane(id, klasa)
{
	new vaultkey[128],vaultdata[256], identyfikator[64];
	
	new typ_zapisu = get_pcvar_num(cvar_typ_zapisu);
	
	switch(typ_zapisu)
	{
		case 1: copy(identyfikator, charsmax(identyfikator), nazwa_gracza[id]);
		case 2: get_user_authid(id, identyfikator, charsmax(identyfikator));
		case 3: get_user_ip(id, identyfikator, charsmax(identyfikator));
	}
	
	format(vaultkey, charsmax(vaultkey),"%s-%s-%i-cod", identyfikator, nazwy_klas[klasa], typ_zapisu);
	

	if(!nvault_get(vault,vaultkey,vaultdata,255)) // Jezeli nie ma danych gracza sprawdza stary zapis. 
	{
		format(vaultkey, charsmax(vaultkey), "%s-%i-cod", nazwa_gracza[id], klasa);
		nvault_get(vault,vaultkey,vaultdata,255);
	}

	replace_all(vaultdata, 255, "#", " ");
	 
	new danegracza[6][32];
	
	parse(vaultdata, danegracza[0], 31, danegracza[1], 31, danegracza[2], 31, danegracza[3], 31, danegracza[4], 31, danegracza[5], 31);
	
	doswiadczenie_gracza[id] = str_to_num(danegracza[0]);
	poziom_gracza[id] = str_to_num(danegracza[1])>0?str_to_num(danegracza[1]):1;
	inteligencja_gracza[id] = str_to_num(danegracza[2]);
	zdrowie_gracza[id] = str_to_num(danegracza[3]);
	wytrzymalosc_gracza[id] = str_to_num(danegracza[4]);
	kondycja_gracza[id] = str_to_num(danegracza[5]);
	punkty_gracza[id] = (poziom_gracza[id]-1)*3-inteligencja_gracza[id]-zdrowie_gracza[id]-wytrzymalosc_gracza[id]-kondycja_gracza[id];
	
	return PLUGIN_CONTINUE;
} 


public WyrzucPerk(id)
{
	if(perk_gracza[id])
	{
		ColorChat(id, RED, "[CoD UnlimiteD]^x01 Wyrzuciles ^x03%s^x01", nazwy_perkow[perk_gracza[id]]);
		UstawPerk(id, 0, 0, 0);
	}
	else
		ColorChat(id, RED, "[CoD UnlimiteD]^x01 Nie masz zadnego itemu");
}

public SprawdzPoziom(id)
{	
	
	if(!is_user_connected(id))
		return;
		
	new limit_poziomu = get_pcvar_num(cvar_limit_poziomu);
	
	new bool:zdobyl_poziom = false, bool:stracil_poziom = false;
	
	while(doswiadczenie_gracza[id] >= PobierzDoswiadczeniePoziomu(poziom_gracza[id]) && poziom_gracza[id] < limit_poziomu)
	{
		poziom_gracza[id]++;
		punkty_gracza[id] = (poziom_gracza[id]-1)*3-inteligencja_gracza[id]-zdrowie_gracza[id]-wytrzymalosc_gracza[id]-kondycja_gracza[id];
		zdobyl_poziom = true;
	}
		
	while(doswiadczenie_gracza[id] < PobierzDoswiadczeniePoziomu(poziom_gracza[id]-1))
	{
		poziom_gracza[id]--;
		stracil_poziom = true;
	}
		
	if(poziom_gracza[id] > limit_poziomu)
	{
		poziom_gracza[id] = limit_poziomu;
		ResetujPunkty(id);
	}
	
	if(stracil_poziom)
	{
		ResetujPunkty(id);
		set_hudmessage(212, 255, 85, 0.31, 0.32, 0, 6.0, 5.0);
		ShowSyncHudMsg(id, SyncHudObj2,"Spadles do %i poziomu!", poziom_gracza[id]);
	}
	else if(zdobyl_poziom)
	{
		  punkty_gracza[id] = (poziom_gracza[id]-1)*3-inteligencja_gracza[id]-zdrowie_gracza[id]-wytrzymalosc_gracza[id]-kondycja_gracza[id];
		set_hudmessage(212, 255, 85, 0.31, 0.32, 0, 6.0, 5.0);
		ShowSyncHudMsg(id, SyncHudObj2,"Awansowales do %i poziomu!", poziom_gracza[id]);
		ColorChat(0, RED, "%s^x01 awansowal do ^x03%i^x01 lvlu klasa^x03 %s^x01 Gratulacje!", nazwa_gracza[id], poziom_gracza[id], nazwy_klas[klasa_gracza[id]]);
		client_cmd(id, "spk QTM_CodMod/levelup");
	}
		
			
	ZapiszDane(id);
}

public PokazInformacje(id)
{
	id -= ZADANIE_POKAZ_INFORMACJE;

	if(!is_user_connected(id))
	{
		remove_task(id+ZADANIE_POKAZ_INFORMACJE);
		return PLUGIN_CONTINUE;
	}

	if(!is_user_alive(id))
	{
		new target = pev(id, pev_iuser2);
		new hp = get_user_health(target);

		if(!target)
			return PLUGIN_CONTINUE;
		
		new ileMa = doswiadczenie_gracza[target],ilePotrzeba = PobierzDoswiadczeniePoziomu(poziom_gracza[target]),ilePotrzebaBylo = PobierzDoswiadczeniePoziomu(poziom_gracza[target]-1)
		new Float:fProcent = 0.0;
		fProcent = (float((ileMa - ilePotrzebaBylo)) / float((ilePotrzeba - ilePotrzebaBylo))) * 100.0;
		
		set_hudmessage(0, 255, 255, 0.02, 0.23, 0, 0.0, 0.3, 0.0, 0.0);
		ShowSyncHudMsg(id, SyncHudObj, "Ranga : %s^nStopien : %s^nPoziom : %i (%0.1f%%)^nItem : %s^nPKT Inteligencji : %i/125^nPKT Zycia : %i/125^nPKT Wytrzymalosci : %i/175^nPKT Kondycji : %i/175", nazwy_klas[klasa_gracza[target]], ranga[poziom_gracza[target]], poziom_gracza[target], fProcent, nazwy_perkow[perk_gracza[target]], inteligencja_gracza[target], zdrowie_gracza[target], wytrzymalosc_gracza[target], kondycja_gracza[target]);
		return PLUGIN_CONTINUE;
	}

	new ileMa = doswiadczenie_gracza[id],ilePotrzeba = PobierzDoswiadczeniePoziomu(poziom_gracza[id]),ilePotrzebaBylo = PobierzDoswiadczeniePoziomu(poziom_gracza[id]-1)
	new Float:fProcent = 0.0;
	fProcent = (float((ileMa - ilePotrzebaBylo)) / float((ilePotrzeba - ilePotrzebaBylo))) * 100.0;

	new hp = get_user_health(id);
	
	set_hudmessage(0, 255, 0, 0.02, 0.23, 0, 0.0, 0.3, 0.0, 0.0);
	ShowSyncHudMsg(id, SyncHudObj, "Ranga : %s^nStopien : %s^nPoziom : %i (%0.1f%%)^nItem : %s^nHP : %i", nazwy_klas[klasa_gracza[id]], ranga[poziom_gracza[id]], poziom_gracza[id], fProcent, nazwy_perkow[perk_gracza[id]], hp);

	return PLUGIN_CONTINUE;
}  

public Pomoc(id)
	show_menu(id, 1023, "y/resetw - resetuje statystyki^ny/statystykiw - wyswietla statystyki^ny/klasa lub /kw - uruchamia menu wyboru klas^ny/drop lub /dw - wyrzuca item^ny/item lub /iw - pokazuje opis twojego itemu^ny/klasyw - pokazuje opisy klas", -1, "Pomoc");

public UstawSzybkosc(id)
{
	id -= id>32? ZADANIE_USTAW_SZYBKOSC: 0;
	
	if(klasa_gracza[id] && !freezetime)
		set_pev(id, pev_maxspeed, szybkosc_gracza[id]);
}

public DotykBroni(weapon, id)
{
	if(get_pcvar_num(cvar_blokada_broni) < 1)
		return HAM_IGNORED;
	
	if(!is_user_connected(id))
		return HAM_IGNORED;
		
	new model[23];
	pev(weapon, pev_model, model, 22);
	if (pev(weapon, pev_owner) == id || containi(model, "w_backpack") != -1)
		return HAM_IGNORED;
	return HAM_SUPERCEDE;
}

public DotykTarczy(weapon, id)
{
	if(get_pcvar_num(cvar_blokada_broni) < 1)
		return HAM_IGNORED;
	
	if(!is_user_connected(id))
		return HAM_IGNORED;
		
	if(gracz_ma_tarcze[id])
		return HAM_IGNORED;
		
	return HAM_SUPERCEDE;
}
	
public UstawPerk(id, perk, wartosc, pokaz_info)
{
	if(!ilosc_perkow)
		return PLUGIN_CONTINUE;
	
	static obroty[33];
	
	if(obroty[id]++ >= 5)
	{
		UstawPerk(id, 0, 0, 0);
		obroty[id] = 0;
		return PLUGIN_CONTINUE;
	}
	
	perk = (perk == -1)? random_num(1, ilosc_perkow): perk;
	wartosc = (wartosc == -1 || min_wartosci_perkow[perk] > wartosc ||  wartosc > max_wartosci_perkow[perk])? random_num(min_wartosci_perkow[perk], max_wartosci_perkow[perk]): wartosc; 
	
	new ret;
	
	new forward_handle = CreateOneForward(pluginy_perkow[perk_gracza[id]], "cod_perk_disabled", FP_CELL, FP_CELL);
	ExecuteForward(forward_handle, ret, id, perk);
	DestroyForward(forward_handle);
	
	perk_gracza[id] = 0;
	
	forward_handle = CreateOneForward(pluginy_perkow[perk], "cod_perk_enabled", FP_CELL, FP_CELL, FP_CELL);
	ExecuteForward(forward_handle, ret, id, wartosc, perk);
	DestroyForward(forward_handle);
	
	if(ret == 4)
	{
		UstawPerk(id, -1, -1, 1);
		return PLUGIN_CONTINUE;
	}
	
	ExecuteForward(perk_zmieniony, ret, id, perk, wartosc);
	
	if(ret == 4)
	{
		UstawPerk(id, -1, -1, 1);
		return PLUGIN_CONTINUE;
	}
	
	perk_gracza[id] = perk;	
	wartosc_perku_gracza[id] = wartosc;
	
	obroty[id] = 0;
	
	if(pokaz_info && perk_gracza[id]) 
		ColorChat(id, RED, "[CoD UnlimiteD]^x01 Zdobyles ^x03%s^x01", nazwy_perkow[perk_gracza[id]]);
	
	return PLUGIN_CONTINUE;
}

public UstawDoswiadczenie(id, wartosc)
{
	doswiadczenie_gracza[id] = wartosc;
	SprawdzPoziom(id);
}

public UstawKlase(id, klasa, zmien)
{
	nowa_klasa_gracza[id] = klasa;
	if(zmien)
	{
		UstawNowaKlase(id);
		DajBronie(id);
		ZastosujAtrybuty(id);
	}
}

public UstawTarcze(id, wartosc)
{
	if((gracz_ma_tarcze[id] = (wartosc > 0)))
		fm_give_item(id, "weapon_shield");
}

public UstawNoktowizor(id, wartosc)
{
	if((gracz_ma_noktowizor[id] = (wartosc > 0)))
		cs_set_user_nvg(id, 1);
}

public DajBron(id, bron)
{
	bonusowe_bronie_gracza[id] |= (1<<bron);
	new weaponname[22];
	get_weaponname(bron, weaponname, 21);
	return fm_give_item(id, weaponname);
}

public WezBron(id, bron)
{
	bonusowe_bronie_gracza[id] &= ~(1<<bron);
	
	if((1<<bron) & (bronie_dozwolone | bronie_klasy[get_user_team(id)] | bronie_klasy[klasa_gracza[id]])) 
		return;
	
	new weaponname[22];
	get_weaponname(bron, weaponname, 21);
	if(!((1<<bron) & (1<<CSW_HEGRENADE | 1<<CSW_SMOKEGRENADE | 1<<CSW_FLASHBANG)))
		engclient_cmd(id, "drop", weaponname);
}

public UstawBonusoweZdrowie(id, wartosc)
	bonusowe_zdrowie_gracza[id] = wartosc;


public UstawBonusowaInteligencje(id, wartosc)
	bonusowa_inteligencja_gracza[id] = wartosc;

	
public UstawBonusowaKondycje(id, wartosc)
	bonusowa_kondycja_gracza[id] = wartosc;

	
public UstawBonusowaWytrzymalosc(id, wartosc)
	bonusowa_wytrzymalosc_gracza[id] = wartosc;

public PrzydzielZdrowie(id, wartosc)
{
	new max_statystyka = get_pcvar_num(cvar_limit_poziomu)/2;
	wartosc = min(min(punkty_gracza[id], wartosc), max_statystyka-zdrowie_gracza[id]);
	
	punkty_gracza[id] -= wartosc;
	zdrowie_gracza[id] += wartosc;
}

public PrzydzielInteligencje(id, wartosc)
{
	new max_statystyka = get_pcvar_num(cvar_limit_poziomu)/2;
	wartosc = min(min(punkty_gracza[id], wartosc), max_statystyka-inteligencja_gracza[id]);
	
	punkty_gracza[id] -= wartosc;
	inteligencja_gracza[id] += wartosc;
}

public PrzydzielKondycje(id, wartosc)
{
	new max_statystyka = get_pcvar_num(cvar_limit_poziomu)/2;
	wartosc = min(min(punkty_gracza[id], wartosc), max_statystyka-kondycja_gracza[id]);
	
	punkty_gracza[id] -= wartosc;
	kondycja_gracza[id] += wartosc;
}

public PrzydzielWytrzymalosc(id, wartosc)
{
	new max_statystyka = get_pcvar_num(cvar_limit_poziomu)/2;
	wartosc = min(min(punkty_gracza[id], wartosc), max_statystyka-wytrzymalosc_gracza[id]);
	
	punkty_gracza[id] -= wartosc;
	wytrzymalosc_gracza[id] += wartosc;
}

public PobierzPerk(id, &wartosc)
{
	wartosc = wartosc_perku_gracza[id];
	return perk_gracza[id];
}
	
public PobierzIloscPerkow()
	return ilosc_perkow;
	
	
public PobierzNazwePerku(perk, Return[], len)
{
	if(perk <= ilosc_perkow)
	{
		param_convert(2);
		copy(Return, len, nazwy_perkow[perk]);
	}
}
		
public PobierzOpisPerku(perk, Return[], len)
{
	if(perk <= ilosc_perkow)
	{
		param_convert(2);
		copy(Return, len, opisy_perkow[perk]);
	}
}
	
public PobierzPerkPrzezNazwe(const nazwa[])
{
	param_convert(1);
	for(new i=1; i <= ilosc_perkow; i++)
		if(equal(nazwa, nazwy_perkow[i]))
			return i;
	return 0;
}

public PobierzDoswiadczeniePoziomu(poziom)
	return power(poziom, 2)*get_pcvar_num(cvar_proporcja_poziomu);

public PobierzDoswiadczenie(id)
	return doswiadczenie_gracza[id];
	
public PobierzPunkty(id)
	return punkty_gracza[id];
	
public PobierzPoziom(id)
	return poziom_gracza[id];

public PobierzZdrowie(id, zdrowie_zdobyte, zdrowie_klasy, zdrowie_bonusowe)
{
	new zdrowie;
	
	if(zdrowie_zdobyte)
		zdrowie += zdrowie_gracza[id];
	if(zdrowie_bonusowe)
		zdrowie += bonusowe_zdrowie_gracza[id];
	if(zdrowie_klasy)
		zdrowie += zdrowie_klas[klasa_gracza[id]];
	
	return zdrowie;
}

public PobierzInteligencje(id, inteligencja_zdobyta, inteligencja_klasy, inteligencja_bonusowa)
{
	new inteligencja;
	
	if(inteligencja_zdobyta)
		inteligencja += inteligencja_gracza[id];
	if(inteligencja_bonusowa)
		inteligencja += bonusowa_inteligencja_gracza[id];
	if(inteligencja_klasy)
		inteligencja += inteligencja_klas[klasa_gracza[id]];
	
	return inteligencja;
}

public PobierzKondycje(id, kondycja_zdobyta, kondycja_klasy, kondycja_bonusowa)
{
	new kondycja;
	
	if(kondycja_zdobyta)
		kondycja += kondycja_gracza[id];
	if(kondycja_bonusowa)
		kondycja += bonusowa_kondycja_gracza[id];
	if(kondycja_klasy)
		kondycja += kondycja_klas[klasa_gracza[id]];
	
	return kondycja;
}

public PobierzWytrzymalosc(id, wytrzymalosc_zdobyta, wytrzymalosc_klasy, wytrzymalosc_bonusowa)
{
	new wytrzymalosc;
	
	if(wytrzymalosc_zdobyta)
		wytrzymalosc += wytrzymalosc_gracza[id];
	if(wytrzymalosc_bonusowa)
		wytrzymalosc += bonusowa_wytrzymalosc_gracza[id];
	if(wytrzymalosc_klasy)
		wytrzymalosc += wytrzymalosc_klas[klasa_gracza[id]];
	
	return wytrzymalosc;
}

public PobierzKlase(id)
	return klasa_gracza[id];
	
public PobierzIloscKlas()
	return ilosc_klas;
	
public PobierzNazweKlasy(klasa, Return[], len)
{
	if(klasa <= ilosc_klas)
	{
		param_convert(2);
		copy(Return, len, nazwy_klas[klasa]);
	}
}

public PobierzOpisKlasy(klasa, Return[], len)
{
	if(klasa <= ilosc_klas)
	{
		param_convert(2);
		copy(Return, len, opisy_klas[klasa]);
	}
}

public PobierzKlasePrzezNazwe(const nazwa[])
{
	param_convert(1);
	for(new i=1; i <= ilosc_klas; i++)
		if(equal(nazwa, nazwy_klas[i]))
			return i;
	return 0;
}

public PobierzZdrowieKlasy(klasa)
{
	if(klasa <= ilosc_klas)
		return zdrowie_klas[klasa];
	return -1;
}

public PobierzInteligencjeKlasy(klasa)
{
	if(klasa <= ilosc_klas)
		return inteligencja_klas[klasa];
	return -1;
}

public PobierzKondycjeKlasy(klasa)
{
	if(klasa <= ilosc_klas)
		return kondycja_klas[klasa];
	return -1;
}

public PobierzWytrzymaloscKlasy(klasa)
{
	if(klasa <= ilosc_klas)
		return wytrzymalosc_klas[klasa];
	return -1;
}

public ZadajObrazenia(atakujacy, ofiara, Float:obrazenia, Float:czynnik_inteligencji, byt_uszkadzajacy, dodatkowe_flagi)
	ExecuteHam(Ham_TakeDamage, ofiara, byt_uszkadzajacy, atakujacy, obrazenia+PobierzInteligencje(atakujacy, 1, 1, 1)*czynnik_inteligencji, (1<<31) | dodatkowe_flagi);
	
public ZarejestrujPerk(plugin, params)
{
	if(params != 4)
		return PLUGIN_CONTINUE;
		
	if(++ilosc_perkow > MAX_ILOSC_PERKOW)
		return -1;
		
	pluginy_perkow[ilosc_perkow] = plugin;
	get_string(1, nazwy_perkow[ilosc_perkow], MAX_WIELKOSC_NAZWY);
	get_string(2, opisy_perkow[ilosc_perkow], MAX_WIELKOSC_OPISU);
	min_wartosci_perkow[ilosc_perkow] = get_param(3);
	max_wartosci_perkow[ilosc_perkow] = get_param(4);
	
	return ilosc_perkow;
}

public ZarejestrujKlase(plugin, params)
{
	if(params != 7)
		return PLUGIN_CONTINUE;
		
	if(++ilosc_klas > MAX_ILOSC_KLAS)
		return -1;

	pluginy_klas[ilosc_klas] = plugin;
	
	get_string(1, nazwy_klas[ilosc_klas], MAX_WIELKOSC_NAZWY);
	get_string(2, opisy_klas[ilosc_klas], MAX_WIELKOSC_OPISU);
	
	bronie_klasy[ilosc_klas] = get_param(3);
	zdrowie_klas[ilosc_klas] = get_param(4);
	kondycja_klas[ilosc_klas] = get_param(5);
	inteligencja_klas[ilosc_klas] = get_param(6);
	wytrzymalosc_klas[ilosc_klas] = get_param(7);
	
	if(equali(nazwy_klas[ilosc_klas],"Snajper")){
                frakcja_klas[ilosc_klas] = "Najemnicy";
}
	if(equali(nazwy_klas[ilosc_klas],"Komandos")){
                frakcja_klas[ilosc_klas] = "Najemnicy";
}
	if(equali(nazwy_klas[ilosc_klas],"Zwiadowca")){
                frakcja_klas[ilosc_klas] = "Najemnicy";
}
	if(equali(nazwy_klas[ilosc_klas],"Zamachowiec")){
                frakcja_klas[ilosc_klas] = "Najemnicy";
}
	if(equali(nazwy_klas[ilosc_klas],"Talib")){
                frakcja_klas[ilosc_klas] = "Najemnicy";
}
	if(equali(nazwy_klas[ilosc_klas],"Marines")){
                frakcja_klas[ilosc_klas] = "Najemnicy";
}
	if(equali(nazwy_klas[ilosc_klas],"Arab")){
                frakcja_klas[ilosc_klas] = "Najemnicy";
}
	if(equali(nazwy_klas[ilosc_klas],"Grom")){
                frakcja_klas[ilosc_klas] = "Renegaci";
}
	if(equali(nazwy_klas[ilosc_klas],"Inzynier")){
                frakcja_klas[ilosc_klas] = "Renegaci";
}
	if(equali(nazwy_klas[ilosc_klas],"Bombardier")){
                frakcja_klas[ilosc_klas] = "Renegaci";
}
	if(equali(nazwy_klas[ilosc_klas],"Lekarz")){
                frakcja_klas[ilosc_klas] = "Renegaci";
}
	if(equali(nazwy_klas[ilosc_klas],"Wsparcie Ogniowe")){
                frakcja_klas[ilosc_klas] = "Renegaci";
}
	if(equali(nazwy_klas[ilosc_klas],"Rusher")){
                frakcja_klas[ilosc_klas] = "Renegaci";
}
	if(equali(nazwy_klas[ilosc_klas],"Amadeusz")){
                frakcja_klas[ilosc_klas] = "Renegaci";
}
	if(equali(nazwy_klas[ilosc_klas],"Longer")){
                frakcja_klas[ilosc_klas] = "Monolit";
}
	if(equali(nazwy_klas[ilosc_klas],"Partyzant")){
                frakcja_klas[ilosc_klas] = "Monolit";
}
	if(equali(nazwy_klas[ilosc_klas],"Skoczek")){
                frakcja_klas[ilosc_klas] = "Monolit";
}
	if(equali(nazwy_klas[ilosc_klas],"Demolitions")){
                frakcja_klas[ilosc_klas] = "Monolit";
}
	if(equali(nazwy_klas[ilosc_klas],"Zwinny Brygadzista")){
                frakcja_klas[ilosc_klas] = "Monolit";
}
	if(equali(nazwy_klas[ilosc_klas],"Powstaniec")){
                frakcja_klas[ilosc_klas] = "Monolit";
}
	if(equali(nazwy_klas[ilosc_klas],"Burzownik")){
                frakcja_klas[ilosc_klas] = "Monolit";
}
	if(equali(nazwy_klas[ilosc_klas],"Skrytobojca [P]")){
                frakcja_klas[ilosc_klas] = "Elita";
}
	if(equali(nazwy_klas[ilosc_klas],"Szeregowy [P]")){
                frakcja_klas[ilosc_klas] = "Elita";
}
	if(equali(nazwy_klas[ilosc_klas],"Alexander [P]")){
                frakcja_klas[ilosc_klas] = "Elita";
}
	if(equali(nazwy_klas[ilosc_klas],"Magik [P]")){
                frakcja_klas[ilosc_klas] = "Elita";
}
	if(equali(nazwy_klas[ilosc_klas],"Profesjonalny Snajper [P]")){
                frakcja_klas[ilosc_klas] = "Elita";
}
	if(equali(nazwy_klas[ilosc_klas],"Truciciel [P]")){
                frakcja_klas[ilosc_klas] = "Elita";
}
	if(equali(nazwy_klas[ilosc_klas],"Zwinny Zabojca [S|P]")){
                frakcja_klas[ilosc_klas] = "Elita";
}

	
	return ilosc_klas;
}

stock ham_strip_weapon(id, weapon[])
{
	if(!equal(weapon, "weapon_", 7) ) return 0
	new wId = get_weaponid(weapon)
	if(!wId) return 0
	new wEnt
	while( (wEnt = engfunc(EngFunc_FindEntityByString,wEnt,"classname", weapon) ) && pev(wEnt, pev_owner) != id) {}
	if(!wEnt) return 0
	
	if(get_user_weapon(id) == wId) ExecuteHamB(Ham_Weapon_RetireWeapon, wEnt)
	
	if(!ExecuteHamB(Ham_RemovePlayerItem, id, wEnt)) return 0
	ExecuteHamB(Ham_Item_Kill ,wEnt)
	
	set_pev(id, pev_weapons, pev(id, pev_weapons) & ~(1<<wId) )
	return 1
}

stock Display_Fade(id,duration,holdtime,fadetype,red,green,blue,alpha)
{
	message_begin( MSG_ONE, MsgScreenfade,{0,0,0},id );
	write_short( duration );	// Duration of fadeout
	write_short( holdtime );	// Hold time of color
	write_short( fadetype );	// Fade type
	write_byte ( red );		// Red
	write_byte ( green );		// Green
	write_byte ( blue );		// Blue
	write_byte ( alpha );	// Alpha
	message_end();
}

stock fm_give_item(index, const item[]) {
	if (!equal(item, "weapon_", 7) && !equal(item, "ammo_", 5) && !equal(item, "item_", 5) && !equal(item, "tf_weapon_", 10))
		return 0;

	new ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, item));
	if (!pev_valid(ent))
		return 0;

	new Float:origin[3];
	pev(index, pev_origin, origin);
	set_pev(ent, pev_origin, origin);
	set_pev(ent, pev_spawnflags, pev(ent, pev_spawnflags) | SF_NORESPAWN);
	dllfunc(DLLFunc_Spawn, ent);

	new save = pev(ent, pev_solid);
	dllfunc(DLLFunc_Touch, ent, index);
	if (pev(ent, pev_solid) != save)
		return ent;

	engfunc(EngFunc_RemoveEntity, ent);

	return -1;
}

public BlokujKomende()
	return PLUGIN_HANDLED;

	
	public handleSayText(msgId,msgDest,msgEnt){
	new id = get_msg_arg_int(1);
	
	if(!is_user_connected(id))      return PLUGIN_CONTINUE;
	
	new szTmp[256],szTmp2[256],szTmp3[256];
	get_msg_arg_string(2,szTmp, charsmax( szTmp ) )
	
	new szPrefix[64]
	
	switch(get_pcvar_num(pCvarPrefixy)){
		case 1:{
			cod_get_class_name(cod_get_user_class(id),szTmp3,charsmax( szTmp3 ))
			formatex(szPrefix,charsmax( szPrefix ),"^x04[%s]",szTmp3);
		}
		case 2:{
			formatex(szPrefix,charsmax( szPrefix ),"^x04[%d]",cod_get_user_level(id));
		}
		case 3:{
			cod_get_class_name(cod_get_user_class(id),szTmp3,charsmax( szTmp3 ))
			formatex(szPrefix,charsmax( szPrefix ),"^x04[%s]",ranga[poziom_gracza[id]]);
		}
	}
	
	if(!equal(szTmp,"#Cstrike_Chat_All")){
		add(szTmp2,charsmax(szTmp2),szPrefix);
		add(szTmp2,charsmax(szTmp2)," ");
		add(szTmp2,charsmax(szTmp2),szTmp);
	}
	else{
		add(szTmp2,charsmax(szTmp2),szPrefix);
		add(szTmp2,charsmax(szTmp2),"^x03 %s1^x01 :  %s2");
	}
	
	set_msg_arg_string(2,szTmp2);
	
	return PLUGIN_CONTINUE;
}