ThePhoenix

/*
Changelog

1.1.0
- Pierwsza publiczna wersja

1.1.1
- Poprawienie bug'a z ustawianiem szybkoњci
*/



#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 

#define PLUGIN "Call of Duty: MW Mod SQL"
#define VERSION "1.1.1"
#define AUTHOR "QTM_Peyote (edit Cypis)"

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

#define STANDARDOWA_SZYBKOSC 250.0

#define ZADANIE_POKAZ_INFORMACJE 672
#define ZADANIE_USTAW_SZYBKOSC 832

#define MAX_WIELKOSC_FRAKCJA 64

//#define MA_FRAKCJE 1

#if defined MA_FRAKCJE
new frakcja_klas[MAX_ILOSC_KLAS+1][MAX_WIELKOSC_FRAKCJA+1];
new nazwa_klasy[MAX_ILOSC_KLAS+1][64];
new nazwa_frakcji[MAX_ILOSC_KLAS+1][64];
new klasid;
#endif

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 MsgScreenfade;

new SyncHudObj, SyncHudObj2;

new cvar_doswiadczenie_za_zabojstwo,
cvar_doswiadczenie_za_obrazenia,
cvar_doswiadczenie_za_wygrana,
cvar_limit_poziomu,
cvar_proporcja_poziomu;

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< bronie_dozwolone = 1<
new bool:freezetime = true;

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_limit_poziomu = register_cvar("cod_maxlevel", "200");
cvar_proporcja_poziomu = register_cvar("cod_levelratio", "35");

register_cvar("cod_sql_host", "ds3.shootline.ru");
register_cvar("cod_sql_user", "s1976_war3ft");
register_cvar("cod_sql_pass", "freshblood");
register_cvar("cod_sql_db", "s1976_war3ft");
register_cvar("cod_sql_table", "codmod_table");

register_clcmd("say /class", "WybierzKlase");
register_clcmd("say /classinfo", "OpisKlasy");
register_clcmd("say /perk", "KomendaOpisPerku");
register_clcmd("say /perks", "OpisPerkow");
register_clcmd("say /item", "Pomoc");
register_clcmd("say /przedmiot", "OpisPerku");
register_clcmd("say /drop", "WyrzucPerk");
register_clcmd("say /reset", "KomendaResetujPunkty");
register_clcmd("say /codstats", "PrzydzielPunkty");
register_clcmd("say /help", "Pomoc");
register_clcmd("useperk", "UzyjPerku");
register_clcmd("fullupdate", "BlokujKomende");

register_clcmd("cl_autobuy", "BlokujKomende");
register_clcmd("cl_rebuy", "BlokujKomende");
register_clcmd("cl_setautobuy","BlokujKomende");
register_clcmd("rebuy", "BlokujKomende");
register_clcmd("autobuy", "BlokujKomende");
register_clcmd("glock", "BlokujKomende");
register_clcmd("usp", "BlokujKomende");
register_clcmd("p228", "BlokujKomende");
register_clcmd("deagle", "BlokujKomende");
register_clcmd("elites", "BlokujKomende");
register_clcmd("fn57", "BlokujKomende");
register_clcmd("m3", "BlokujKomende");
register_clcmd("autoshotgun", "BlokujKomende");
register_clcmd("xm1024", "BlokujKomende");
register_clcmd("mac10", "BlokujKomende");
register_clcmd("tmp", "BlokujKomende");
register_clcmd("mp5", "BlokujKomende");
register_clcmd("ump45", "BlokujKomende");
register_clcmd("p90", "BlokujKomende");
register_clcmd("galil", "BlokujKomende");
register_clcmd("ak47", "BlokujKomende");
register_clcmd("scout", "BlokujKomende");
register_clcmd("sg552", "BlokujKomende");
register_clcmd("awp", "BlokujKomende");
register_clcmd("g3sg1", "BlokujKomende");
register_clcmd("famas", "BlokujKomende");
register_clcmd("m4a1", "BlokujKomende");
register_clcmd("bullpup", "BlokujKomende");
register_clcmd("sg550", "BlokujKomende");
register_clcmd("m249", "BlokujKomende");
register_clcmd("shield", "BlokujKomende");
register_clcmd("hegren", "BlokujKomende");
register_clcmd("sgren", "BlokujKomende");
register_clcmd("flash", "BlokujKomende");

/*register_concmd("cod_setlvl", "cmd_setlvl", ADMIN_RCON, "");*/

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");

new WeaponName[24];
for(new i = CSW_P228; i <= CSW_P90; i++){
if(i == 2)
continue;

get_weaponname(i, WeaponName, 23);
RegisterHam(Ham_Item_Deploy, WeaponName, "Item_Deploy_Post", 1);
}
RegisterHam(get_player_resetmaxspeed_func(), "player", "CS_Player_ResetMaxSpeed_Post", 1);

register_forward(FM_CmdStart, "CmdStart");
register_forward(FM_EmitSound, "EmitSound");

register_logevent("PoczatekRundy", 2, "1=Round_Start");

register_logevent("RestartTime", 2, "0=World triggered", "1=Game_Commencing");//rozgrzewka

register_event("Health", "MessageHealth", "be", "1!255");
register_event("SendAudio", "WygranaTerro" , "a", "2&%!MRAD_terwin");
register_event("SendAudio", "WygranaCT", "a", "2&%!MRAD_ctwin");
register_event("HLTV", "NowaRunda", "a", "1=0", "2=0");

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, "Нету");
copy(opisy_perkow[0], MAX_WIELKOSC_OPISU, "Убей противника - получи предмет");
copy(nazwy_klas[0], MAX_WIELKOSC_NAZWY, "Нету");

#if defined MA_FRAKCJE
loadfile();
#endif
}

new bool:g_rozgrzewka;
public RestartTime()
{
new ilosc = 30;
switch(get_playersnum())
{
case 0..8: return;
case 9..15: ilosc = 45;
case 16..20: ilosc = 50;
case 21..25: ilosc = 60;
case 26..33: ilosc = 70;
}
remove_task(98213);
show_time(98213, ilosc);
}

public show_time(taskid, iStart)
{
static iCount
if(iStart)
{
g_rozgrzewka = true;
iCount = iStart + 1
}

if(iCount-- > 0)
{
new szTime[12];
format_time(szTime, 11, "%M:%S", iCount);
set_dhudmessage(0, 255, 0, -1.0, 0.2, 0, 0.0, 1.0, 0.0, 0.0, false);
show_dhudmessage(0, "Разминка - %s", szTime);

set_task(1.0, "show_time", taskid);
}
else
{
server_cmd("sv_restart 1");
g_rozgrzewka = false;
}
}

new Handle:hookSql;
new Trie:ClassName;

new lvl_klasy_gracza[33][MAX_ILOSC_KLAS];
new xp_klasy_gracza[33][MAX_ILOSC_KLAS];
new int_klasy_gracza[33][MAX_ILOSC_KLAS];
new zdr_klasy_gracza[33][MAX_ILOSC_KLAS];
new wyt_klasy_gracza[33][MAX_ILOSC_KLAS];
new kon_klasy_gracza[33][MAX_ILOSC_KLAS];

new bool:wczytane_dane[33];
new gracz_zdobyl_expa[33];
new Tabela[32];

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

new DaneBazy[4][64];
get_cvar_string("cod_sql_host", DaneBazy[0], 63);
get_cvar_string("cod_sql_user", DaneBazy[1], 63);
get_cvar_string("cod_sql_pass", DaneBazy[2], 63);
get_cvar_string("cod_sql_db", DaneBazy[3], 63);

get_cvar_string("cod_sql_table", Tabela, 31);

hookSql = SQL_MakeDbTuple(DaneBazy[0], DaneBazy[1], DaneBazy[2], DaneBazy[3]);

new error, szError[128];
new Handle:hConn = SQL_Connect(hookSql, error, szError, 127);
if(error){
log_amx("Error: %s", szError);
return;
}
new szTemp[1024];
formatex(szTemp, charsmax(szTemp), "CREATE TABLE IF NOT EXISTS `%s` (name VARCHAR(35) NOT NULL, klasa VARCHAR(64) NOT NULL, xp INT UNSIGNED NOT NULL DEFAULT 1, level INT UNSIGNED NOT NULL DEFAULT 1, PRIMARY KEY(name, klasa), ", Tabela);
add(szTemp, charsmax(szTemp), "intelligence INT UNSIGNED NOT NULL DEFAULT 0, health INT UNSIGNED NOT NULL DEFAULT 0, strength INT UNSIGNED NOT NULL DEFAULT 0, stamina INT UNSIGNED NOT NULL DEFAULT 0)");

new Handle:query = SQL_PrepareQuery(hConn, szTemp);
SQL_Execute(query);
SQL_FreeHandle(query);
SQL_FreeHandle(hConn);
}

public plugin_end() {
SQL_FreeHandle(hookSql);
}

#if defined MA_FRAKCJE
public loadfile()
{
new file[256];
get_configsdir(file,charsmax(file));
formatex(file, charsmax(file), "%s/cod_frakcje.ini", file);

if(!file_exists(file))
return;

new row[128], trash, size=file_size(file,1);
for(new i=0;i {
read_file(file, i, row, charsmax(row), trash);

if((contain(row,";")!=0) && strlen(row) && klasid {
replace(row, charsmax(row), "[klasa]", "");
split(row, nazwa_klasy[klasid], charsmax(nazwa_klasy[]), nazwa_frakcji[klasid], charsmax(nazwa_frakcji[]), "[frakcja]");
klasid++;
}
}
}
#endif

public plugin_precache()
{
precache_sound("QTM_CodMod/select.wav");
precache_sound("QTM_CodMod/start.wav");
precache_sound("QTM_CodMod/start2.wav");
precache_sound("QTM_CodMod/levelup.wav");
}

public plugin_natives()
{
ClassName = TrieCreate();
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_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_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_get_user_perk", "PobierzPerk");
register_native("cod_register_perk", "ZarejestrujPerk");
register_native("cod_register_class", "ZarejestrujKlase");

#if defined MA_FRAKCJE
register_native("cod_get_frakcja_name", "PobierzNazweFrakcji", 1);
#endif
}

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(1.5, "PokazInformacje", id+ZADANIE_POKAZ_INFORMACJE, _, _, "b");

if(g_rozgrzewka)
{
strip_user_weapons(id);
give_item(id, "weapon_knife");
return PLUGIN_CONTINUE;
}

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;
}

if(klasa_gracza[id])
ZapiszDane(id, 0);

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< {
new weaponname[22];
get_weaponname(i, weaponname, 21);
give_item(id, weaponname); //fm_give_item(id, weaponname);
}
}

if(gracz_ma_tarcze[id])
give_item(id, "weapon_shield"); //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 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]);

UstawSzybkosc(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 QTM_CodMod/start2");
case 2: client_cmd(id, "spk QTM_CodMod/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;

if(get_user_team(id) != get_user_team(attacker))
{
new doswiadczenie_za_obrazenia = get_pcvar_num(cvar_doswiadczenie_za_obrazenia);
while(damage>20)
{
damage -= 20;
gracz_zdobyl_expa[attacker] += doswiadczenie_za_obrazenia;
}
}
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);
gracz_zdobyl_expa[attacker] += nowe_doswiadczenie;
client_print(attacker, print_center, "+%i", nowe_doswiadczenie);
}

SprawdzPoziom(attacker);

if(g_rozgrzewka)
set_task(0.5, "task_Wskrzes", id+5641);

return HAM_IGNORED;
}

public task_Wskrzes(id)
ExecuteHamB(Ham_CS_RoundRespawn, id-5641);

public MessageHealth(id)
{
if(read_data(1) > 255)
{
message_begin(MSG_ONE, get_user_msgid("Health"), {0,0,0}, id);
write_byte(255);
message_end();
}
}

public client_putinserver(id)
{
for(new i=0; i {
lvl_klasy_gracza[id][i] = 1;
xp_klasy_gracza[id][i] = 0;
int_klasy_gracza[id][i] = 0;
zdr_klasy_gracza[id][i] = 0;
wyt_klasy_gracza[id][i] = 0;
kon_klasy_gracza[id][i] = 0;
}
gracz_zdobyl_expa[id] = 0;
wczytane_dane[id] = false;

UsunUmiejetnosci(id);

get_user_name(id, nazwa_gracza[id], 63);
replace_all(nazwa_gracza[id], 63, "'", "\'");
replace_all(nazwa_gracza[id], 63, "`", "\`");

new data[1], szTemp[256];
data[0] = id;
formatex(szTemp, 255, "SELECT * FROM `%s` WHERE name = '%s'", Tabela, nazwa_gracza[id]);
SQL_ThreadQuery(hookSql, "handleCacheDane", szTemp, data, 1);

UsunZadania(id);

}

public handleCacheDane(failstate, Handle:query, error[], errnum, data[], size)
{
if(failstate != TQUERY_SUCCESS)
{
log_amx(" Error: %s", error);
return;
}
new id = data[0];
if(!is_user_connected(id) && !is_user_connecting(id))
return;

new szClass[32], int;
while(SQL_MoreResults(query))
{
SQL_ReadResult(query, SQL_FieldNameToNum(query, "klasa"), szClass, 31);
TrieGetCell(ClassName, szClass, int);

lvl_klasy_gracza[id][int] = SQL_ReadResult(query, SQL_FieldNameToNum(query, "level"));
xp_klasy_gracza[id][int] = SQL_ReadResult(query, SQL_FieldNameToNum(query, "xp"));
int_klasy_gracza[id][int] = SQL_ReadResult(query, SQL_FieldNameToNum(query, "intelligence"));
zdr_klasy_gracza[id][int] = SQL_ReadResult(query, SQL_FieldNameToNum(query, "health"));
wyt_klasy_gracza[id][int] = SQL_ReadResult(query, SQL_FieldNameToNum(query, "strength"));
kon_klasy_gracza[id][int] = SQL_ReadResult(query, SQL_FieldNameToNum(query, "stamina"));

SQL_NextRow(query);
}
wczytane_dane[id] = true;
if(is_user_alive(id) && !g_rozgrzewka)
WybierzKlase(id);
}

public ZapiszDane(id, level)
{
if(!klasa_gracza[id] || !wczytane_dane[id])
return;

new szTemp[1024];
formatex(szTemp, 1023, "UPDATE `%s` SET xp=(`xp` + %d), level=(`level` + %d), intelligence='%d', health='%d', strength='%d', stamina='%d' WHERE name='%s' AND klasa='%s'", Tabela,
gracz_zdobyl_expa[id], level, inteligencja_gracza[id],
zdrowie_gracza[id], wytrzymalosc_gracza[id], kondycja_gracza[id],
nazwa_gracza[id], nazwy_klas[klasa_gracza[id]]);

doswiadczenie_gracza[id] += gracz_zdobyl_expa[id];
gracz_zdobyl_expa[id] = 0;//wyzeruj expa po dodaniu do bazy zeby nie dawalo 2x tyle expa typowi

lvl_klasy_gracza[id][klasa_gracza[id]] = poziom_gracza[id];
xp_klasy_gracza[id][klasa_gracza[id]] = doswiadczenie_gracza[id];
int_klasy_gracza[id][klasa_gracza[id]] = inteligencja_gracza[id];
zdr_klasy_gracza[id][klasa_gracza[id]] = zdrowie_gracza[id];
wyt_klasy_gracza[id][klasa_gracza[id]] = wytrzymalosc_gracza[id];
kon_klasy_gracza[id][klasa_gracza[id]] = kondycja_gracza[id];

SQL_ThreadQuery(hookSql, "handleIgnore", szTemp);
}

public WczytajDane(id, klasa)
{
if(!klasa || !wczytane_dane[id])
return;

gracz_zdobyl_expa[id] = 0;
poziom_gracza[id] = max(1, lvl_klasy_gracza[id][klasa]);
doswiadczenie_gracza[id] = xp_klasy_gracza[id][klasa];
inteligencja_gracza[id] = int_klasy_gracza[id][klasa];
zdrowie_gracza[id] = zdr_klasy_gracza[id][klasa];
wytrzymalosc_gracza[id] = wyt_klasy_gracza[id][klasa];
kondycja_gracza[id] = kon_klasy_gracza[id][klasa];

punkty_gracza[id] = (poziom_gracza[id]-1)*2-inteligencja_gracza[id]-zdrowie_gracza[id]-wytrzymalosc_gracza[id]-kondycja_gracza[id];
if(poziom_gracza[id] && !doswiadczenie_gracza[id])
{
doswiadczenie_gracza[id] = 1;
xp_klasy_gracza[id][klasa] = 1;
new szTemp[512];
formatex(szTemp, 511, "INSERT INTO `%s` (`name`, `klasa`) VALUES ('%s', '%s')", Tabela, nazwa_gracza[id], nazwy_klas[klasa]);
SQL_ThreadQuery(hookSql, "handleIgnore", szTemp);
}
}

public handleIgnore(failstate, Handle:query, error[], errnum, data[], size){
if(failstate != TQUERY_SUCCESS){
log_amx(" Error: %s", error);
return;
}
}

public client_disconnect(id)
{
ZapiszDane(id, 0);
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;
gracz_zdobyl_expa[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_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() < 3)
return;

for (new i=0; i {
id = Players[i];
if(!klasa_gracza[id])
continue;

gracz_zdobyl_expa[id] += doswiadczenie_za_wygrana;
client_print(id, print_chat, "[COD:MW] Получено %i опыта за победу в раунде.", doswiadczenie_za_wygrana);
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, "Предмет: %s.", nazwy_perkow[perk]);
client_print(id, print_chat, "Описание: %s.", opis_perku);
}

public OpisPerkow(id) {
OpisPerkowPage(id, 0);
}

public OpisPerkowPage(id, page)
{
new menu = menu_create("Выберите предмет:", "OpisPerkow_Handle");
for(new i=1; i <= ilosc_perkow; i++)
menu_additem(menu, nazwy_perkow[i]);
menu_setprop(menu, MPROP_EXITNAME, "Выход");
menu_setprop(menu, MPROP_BACKNAME, "Назад");
menu_setprop(menu, MPROP_NEXTNAME, "Вперёд");
menu_display(id, menu, page);
}

public OpisPerkow_Handle(id, menu, item)
{
if(item++ == MENU_EXIT)
{
menu_destroy(menu);
return PLUGIN_CONTINUE;
}
client_cmd(id, "spk QTM_CodMod/select");

OpisPerku(id, item, -1);
OpisPerkowPage(id, (item-1)/7);
return PLUGIN_CONTINUE;
}

public OpisKlasy(id)
{
new menu = menu_create("Выберите класс:", "OpisKlasy_Handle");
for(new i=1; i <= ilosc_klas; i++)
menu_additem(menu, nazwy_klas[i]);
menu_setprop(menu, MPROP_EXITNAME, "Выход");
menu_setprop(menu, MPROP_BACKNAME, "Назад");
menu_setprop(menu, MPROP_NEXTNAME, "Вперёд");
menu_display(id, menu);
}

public OpisKlasy_Handle(id, menu, item)
{
client_cmd(id, "spk QTM_CodMod/select");

if(item++ == MENU_EXIT)
{
menu_destroy(menu);
return PLUGIN_CONTINUE;
}

new bronie[320];
for(new i=1, n=1; i <= 32; i++)
{
if((1< {
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), "\yКласс: \w%s^n\yИнтеллект: \w%i^n\yЗдоровье: \w%i^n\yСила: \w%i^n\yСкорость: \w%i^n\yБроня:\w%s^n\yДополнительно: \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 WybierzKlase(id)
{
if(g_rozgrzewka)
{
client_print(id, 3, "[Разминка] Во время разминки вы не можете выбрать классы :)");
return;
}
if(!wczytane_dane[id])
{
client_print(id, 3, "[SQL by Cypis] Загрузка классов ...");
return;
}

lvl_klasy_gracza[id][klasa_gracza[id]] = poziom_gracza[id];

#if defined MA_FRAKCJE
new menu = menu_create("Выберите класс:", "WybierzKlase_Frakcje");
for(new i=1; i <= ilosc_klas; i++)
{
if(!is_in_previous(frakcja_klas[i],i))
{
menu_additem(menu,frakcja_klas[i],frakcja_klas[i])
}
}
#else
new klasa[50], szTmp[5], menu = menu_create("Выберите класс:", "WybierzKlase_Handle");
for(new i=1; i <= ilosc_klas; i++)
{
formatex(klasa, charsmax(klasa), "%s \yУровень: %i", nazwy_klas[i], lvl_klasy_gracza[id][i]);
num_to_str(i, szTmp, charsmax(szTmp));
menu_additem(menu, klasa, szTmp);
}
#endif

menu_setprop(menu, MPROP_EXITNAME, "Выход");
menu_setprop(menu, MPROP_BACKNAME, "Назад");
menu_setprop(menu, MPROP_NEXTNAME, "Вперёд");
menu_display(id, menu);
}

#if defined MA_FRAKCJE
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("Выберите класс:", "WybierzKlase_Handle");

new klasa[50],szTmp[5];
for(new i=1; i <= ilosc_klas; i++)
{
if(equali(data,frakcja_klas[i])){
formatex(klasa, charsmax(klasa), "%s \yУровень: %i", nazwy_klas[i], lvl_klasy_gracza[id][i]);
num_to_str(i,szTmp,charsmax(szTmp));
menu_additem(menu2, klasa, szTmp);
}
}

menu_setprop(menu2, MPROP_EXITNAME, "Выход");
menu_setprop(menu2, MPROP_BACKNAME, "Назад");
menu_setprop(menu2, MPROP_NEXTNAME, "Вперёд");
menu_display(id, menu2);

client_cmd(id, "spk QTM_CodMod/select");

menu_destroy(menu);
return PLUGIN_CONTINUE;
}
#endif

public WybierzKlase_Handle(id, menu, item)
{
client_cmd(id, "spk QTM_CodMod/select");

if(item == MENU_EXIT || g_rozgrzewka)
{
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])
client_print(id, print_chat, "[COD:MW] Класс смениться в след.раунде");
else
{
UstawNowaKlase(id);
DajBronie(id);
ZastosujAtrybuty(id);
}
return PLUGIN_CONTINUE;
}

#if defined MA_FRAKCJE
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;
}
#endif

new const co_ile[] = { 1, 4, 8, 16, 24, -1 }; // Wlasnie tutaj zmieniamy co ile maja rosnac punkty.
new szybkosc_rozdania[33];

public PrzydzielPunkty(id) {
PrzydzielPunktyPage(id, 0);
}

public PrzydzielPunktyPage(id, page)
{
new szybkosc[60];
new inteligencja[65];
new zdrowie[60];
new wytrzymalosc[60];
new kondycja[60];
new tytul[25];

if(co_ile[szybkosc_rozdania[id]] == -1)
format(szybkosc, charsmax(szybkosc), "Ile dodawac: \rwszystko \y(Ile pkt dodac do statow)");
else
format(szybkosc, charsmax(szybkosc), "Ile dodawac: \r%d \y(Ile pkt dodac do statow)", co_ile[szybkosc_rozdania[id]]);

format(inteligencja, charsmax(inteligencja), "Интеллект: \r%i \y(+damage item)", PobierzInteligencje(id, 1, 1, 1));
format(zdrowie, charsmax(zdrowie), "Жизни: \r%i \y(+hp)", PobierzZdrowie(id, 1, 1, 1));
format(wytrzymalosc, charsmax(wytrzymalosc), "Сила: \r%i \y(-damage for you)", PobierzWytrzymalosc(id, 1, 1, 1));
format(kondycja, charsmax(kondycja), "Скорость: \r%i \y(+speed)", PobierzKondycje(id, 1, 1, 1));
format(tytul, charsmax(tytul), "Поинтов(%i):", punkty_gracza[id]);

new menu = menu_create(tytul, "PrzydzielPunkty_Handler");

menu_additem(menu, szybkosc);
menu_addblank(menu, 0);
menu_additem(menu, inteligencja);
menu_additem(menu, zdrowie);
menu_additem(menu, wytrzymalosc);
menu_additem(menu, kondycja);
menu_setprop(menu, MPROP_EXIT, 0);
menu_display(id, menu, page);
}

public PrzydzielPunkty_Handler(id, menu, item) {
client_cmd(id, "spk QTM_CodMod/select");

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(szybkosc_rozdania[id] < charsmax(co_ile))
szybkosc_rozdania[id]++;
else
szybkosc_rozdania[id] = 0;
}
case 1: {
if(inteligencja_gracza[id] < limit_poziomu/2) {

if(ilosc > limit_poziomu/2 - inteligencja_gracza[id])
ilosc = limit_poziomu/2 - inteligencja_gracza[id];

inteligencja_gracza[id]+=ilosc;
punkty_gracza[id]-=ilosc;

}
else
client_print(id, print_chat, "[COD:MW] Максимальный уровень интеллекта");
}
case 2: {
if(zdrowie_gracza[id] < limit_poziomu/2) {
if(ilosc > limit_poziomu/2 - zdrowie_gracza[id])
ilosc = limit_poziomu/2 - zdrowie_gracza[id];

zdrowie_gracza[id]+=ilosc;
punkty_gracza[id]-=ilosc;
}
else
client_print(id, print_chat, "[COD:MW] Максимальный уровень жизней");
}
case 3: {
if(wytrzymalosc_gracza[id] < limit_poziomu/2) {
if(ilosc > limit_poziomu/2 - wytrzymalosc_gracza[id])
ilosc = limit_poziomu/2 - wytrzymalosc_gracza[id];

wytrzymalosc_gracza[id]+=ilosc;
punkty_gracza[id]-=ilosc;
}
else
client_print(id, print_chat, "[COD:MW] Максимальный уровень силы");

}
case 4: {
if(kondycja_gracza[id] < limit_poziomu/2) {

if(ilosc > limit_poziomu/2 - kondycja_gracza[id])
ilosc = limit_poziomu/2 - kondycja_gracza[id];

kondycja_gracza[id]+=ilosc;
punkty_gracza[id]-=ilosc;
}
else
client_print(id, print_chat, "[COD:MW] Максимальный уровень скорости");
}
}

if(punkty_gracza[id] > 0)
PrzydzielPunktyPage(id, item/7);

return PLUGIN_CONTINUE;
}

public KomendaResetujPunkty(id)
{
client_print(id, print_chat, "[COD:MW] Навыки будут сброшены.");
client_cmd(id, "spk QTM_CodMod/select");

ResetujPunkty(id);
}

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

if(punkty_gracza[id])
PrzydzielPunkty(id);
}

/*public cmd_setlvl(id, level, cid)
{
if(!cmd_access(id,level,cid,3))
return PLUGIN_HANDLED;
new arg[2][33];
read_argv(1, arg[0], 32);
read_argv(2, arg[1], 32);
new player = cmd_target(id, arg[0], 8);
new value = str_to_num(arg[1]);

doswiadczenie_gracza[player] = doswiadczenie_poziomu(value);
poziom_gracza[player] = 0;
SprawdzPoziom(player);
return PLUGIN_HANDLED;
}*/

public DotykBroni(weapon, id)
{
if(!is_user_connected(id))
return HAM_IGNORED;

new model[23];
pev(weapon, pev_model, model, 22);
if(containi(model, "w_backpack") != -1)
return HAM_IGNORED;

new team = get_user_team(id);
if(team > 2)
return HAM_IGNORED;

pev(weapon, pev_classname, model, 2);
new bron = ((model[0] == 'a')? cs_get_armoury_type(weapon): cs_get_weaponbox_type(weapon));

if((1< return HAM_IGNORED;

return HAM_SUPERCEDE;
}

public DotykTarczy(weapon, id)
{
if(!is_user_connected(id))
return HAM_IGNORED;

if(gracz_ma_tarcze[id])
return HAM_IGNORED;

return HAM_SUPERCEDE;
}

public Item_Deploy_Post(ent)
{
new id = get_pdata_cbase(ent, 41, 4);
if(!is_user_alive(id))
return;

new team = get_user_team(id);
if(team > 2)
return;

new bron = cs_get_weapon_id(ent);
if(!((1< {
new weaponname[24];
get_weaponname(bron, weaponname, 23);
engclient_cmd(id, "drop", weaponname);
}
if(cs_get_user_shield(id) && !gracz_ma_tarcze[id])
engclient_cmd(id, "drop", "weapon_shield");
}

public CS_Player_ResetMaxSpeed_Post(id)
{
if(!is_user_alive(id))
return;

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 SprawdzPoziom(id)
{
if(!is_user_connected(id) || !klasa_gracza[id])
return;

new limit_poziomu = get_pcvar_num(cvar_limit_poziomu);

new zdobyl_poziom = 0;

while((gracz_zdobyl_expa[id]+doswiadczenie_gracza[id]) >= PobierzDoswiadczeniePoziomu(poziom_gracza[id]) && poziom_gracza[id] < limit_poziomu)
{
poziom_gracza[id]++;
zdobyl_poziom++;
}

if(!zdobyl_poziom)
{
while((gracz_zdobyl_expa[id]+doswiadczenie_gracza[id]) < PobierzDoswiadczeniePoziomu(poziom_gracza[id]-1))
{
poziom_gracza[id]--;
zdobyl_poziom--;
}
}

if(poziom_gracza[id] > limit_poziomu)
{
poziom_gracza[id] = limit_poziomu;
ResetujPunkty(id);
}

if(!zdobyl_poziom)
return;

if(zdobyl_poziom)
{
punkty_gracza[id] = (poziom_gracza[id]-1)*2-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,"Получен %i уровень!", poziom_gracza[id]);
client_cmd(id, "spk QTM_CodMod/levelup");
}
else
{
ResetujPunkty(id);
set_hudmessage(212, 255, 85, 0.31, 0.32, 0, 6.0, 5.0);
ShowSyncHudMsg(id, SyncHudObj2,"Снижен до %i уровня!", poziom_gracza[id]);
}
ZapiszDane(id, zdobyl_poziom);
}

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);

if(!target)
return PLUGIN_CONTINUE;

set_hudmessage(255, 255, 255, 0.6, -1.0, 0, 0.0, 1.5, 0.0, 0.0, 2);
ShowSyncHudMsg(id, SyncHudObj, "Класс : %s^nОпыт : %i / %i^nУровень : %i^nПредмет : %s", nazwy_klas[klasa_gracza[target]], doswiadczenie_gracza[target]+gracz_zdobyl_expa[target], PobierzDoswiadczeniePoziomu(poziom_gracza[target]), poziom_gracza[target], nazwy_perkow[perk_gracza[target]]);
return PLUGIN_CONTINUE;
}

set_hudmessage(0, 255, 0, 0.02, 0.23, 0, 0.0, 1.5, 0.0, 0.0);
ShowSyncHudMsg(id, SyncHudObj, "[Класс : %s]^n[Опыт : %i / %i]^n[Уровень : %i]^n[Предмет : %s]", nazwy_klas[klasa_gracza[id]], doswiadczenie_gracza[id]+gracz_zdobyl_expa[id], PobierzDoswiadczeniePoziomu(poziom_gracza[id]), poziom_gracza[id], nazwy_perkow[perk_gracza[id]]);

return PLUGIN_CONTINUE;
}

public Pomoc(id)
show_menu(id, 1023, "\y/reset\w - resetuje statystyki^n\y/statystyki\w - wyswietla statystyki^n\y/klasa\w - uruchamia menu wyboru klas^n\y/wyrzuc\w - wyrzuca perk^n\y/perk\w - pokazuje opis twojego perku^n\y/klasy\w - pokazuje opisy klas^n\y+use\w - Uzycie umiejetnosci klasy^n\yradio3\w (standardowo C) lub \yuseperk\w - Uzycie perku", -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 WyrzucPerk(id)
{
if(perk_gracza[id])
{
client_print(id, print_chat, "[COD:MW] Выкинуто: %s.", nazwy_perkow[perk_gracza[id]]);
UstawPerk(id, 0, 0, 0);
}
else
client_print(id, print_chat, "[COD:MW] У вас нет предметов.");
}

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])
client_print(id, print_chat, "[COD:MW] Получено: %s.", nazwy_perkow[perk_gracza[id]]);

return PLUGIN_CONTINUE;
}

public UstawDoswiadczenie(id, wartosc)
{
gracz_zdobyl_expa[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)))
give_item(id, "weapon_shield"); //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< new weaponname[22];
get_weaponname(bron, weaponname, 21);
return give_item(id, weaponname); //fm_give_item(id, weaponname);
}

public WezBron(id, bron)
{
bonusowe_bronie_gracza[id] &= ~(1<
if((1< return;

new weaponname[22];
get_weaponname(bron, weaponname, 21);
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 PobierzPerk(plugin, params)
{
if(!(0 < params < 3))
return 0;

new id = get_param(1);
if(!is_user_connected(id))
return 0;

if(params == 2)
set_param_byref(2, 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 gracz_zdobyl_expa[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;
}

#if defined MA_FRAKCJE
public PobierzNazweFrakcji(klasa, Return[], len)
{
if(klasa <= ilosc_klas)
{
param_convert(2);
copy(Return, len, frakcja_klas[klasa]);
}
}
#endif

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);
TrieSetCell(ClassName, nazwy_klas[ilosc_klas], ilosc_klas);

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 defined MA_FRAKCJE
for(new i=0;i {
if(equali(nazwy_klas[ilosc_klas],nazwa_klasy[i]))
{
frakcja_klas[ilosc_klas] = nazwa_frakcji[i];
break;
}
}
#endif

return ilosc_klas;
}

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;


//stock by ConnorMcLeod - http://forums.alliedmods.net/showpost.php?p=1712101#post1712101
stock const XO_CWEAPONBOX = 4;
stock const m_rgpPlayerItems_CWeaponBox[6] = { 34 , 35 , ... };

stock cs_get_weaponbox_type(iWeaponBox)
{
new iWeapon;
for(new i=1; i<=5; i++) {
iWeapon = get_pdata_cbase(iWeaponBox, m_rgpPlayerItems_CWeaponBox[i], XO_CWEAPONBOX);
if( iWeapon > 0 ) {
return cs_get_weapon_id(iWeapon);
}
}
return 0;
}

Ham:get_player_resetmaxspeed_func(){
#if defined Ham_CS_Player_ResetMaxSpeed
return IsHamValid(Ham_CS_Player_ResetMaxSpeed)?Ham_CS_Player_ResetMaxSpeed:Ham_Item_PreFrame;
#else
return Ham_Item_PreFrame;
#endif
}

//////dhud//////
stock dhud_color;
stock dhud_x;
stock dhud_y;
stock dhud_effect;
stock dhud_fxtime;
stock dhud_holdtime;
stock dhud_fadeintime;
stock dhud_fadeouttime;
stock dhud_reliable;

stock set_dhudmessage(red = 0, green = 160, blue = 0, Float:x = -1.0, Float:y = 0.65, effects = 2, Float:fxtime = 6.0, Float:holdtime = 3.0, Float:fadeintime = 0.1, Float:fadeouttime = 1.5, bool:reliable = false)
{
#define clamp_byte(%1) (clamp(%1, 0, 255))
#define pack_color(%1,%2,%3) (%3 + (%2<<8) + (%1<<16))

dhud_color = pack_color(clamp_byte(red), clamp_byte(green), clamp_byte(blue));
dhud_x = _:x;
dhud_y = _:y;
dhud_effect = effects;
dhud_fxtime = _:fxtime;
dhud_holdtime = _:holdtime;
dhud_fadeintime = _:fadeintime;
dhud_fadeouttime = _:fadeouttime;
dhud_reliable = _:reliable;
return 1;
}

stock show_dhudmessage(index, const message[], any:...)
{
new buffer[128];
new numArguments = numargs();

if(numArguments == 2)
send_dhudMessage(index, message);
else if(index || numArguments == 3)
{
vformat(buffer, charsmax(buffer), message, 3);
send_dhudMessage(index, buffer);
}
else
{
new playersList[32], numPlayers;
get_players(playersList, numPlayers, "ch");

if(!numPlayers)
return 0;

new Array:handleArrayML = ArrayCreate();

for(new i = 2, j; i < numArguments; i++)
{
if(getarg(i) == LANG_PLAYER)
{
while((buffer[j] = getarg(i + 1, j++))) {}
j = 0;

if(GetLangTransKey(buffer) != TransKey_Bad)
ArrayPushCell(handleArrayML, i++);
}
}

new size = ArraySize(handleArrayML);

if(!size)
{
vformat(buffer, charsmax(buffer), message, 3);
send_dhudMessage(index, buffer);
}
else
{
for(new i = 0, j; i < numPlayers; i++)
{
index = playersList[i];

for(j = 0; j < size; j++)
setarg(ArrayGetCell(handleArrayML, j), 0, index);

vformat(buffer, charsmax(buffer), message, 3);
send_dhudMessage(index, buffer);
}
}
ArrayDestroy(handleArrayML);
}
return 1;
}

stock send_dhudMessage(const index, const message[])
{
message_begin(dhud_reliable? (index? MSG_ONE: MSG_ALL): (index? MSG_ONE_UNRELIABLE: MSG_BROADCAST), SVC_DIRECTOR, _, index);
write_byte(strlen(message) + 31);
write_byte(DRC_CMD_MESSAGE);
write_byte(dhud_effect);
write_long(dhud_color);
write_long(dhud_x);
write_long(dhud_y);
write_long(dhud_fadeintime);
write_long(dhud_fadeouttime);
write_long(dhud_holdtime);
write_long(dhud_fxtime);
write_string(message);
message_end();
}
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1045\\ f0\\ fs16 \n\\ par }
*/

;i++)
)>);
);
)>)>)>;>