Skocz do zawartości

Witamy w Nieoficjalnym polskim support'cie AMX Mod X

Witamy w Nieoficjalnym polskim support'cie AMX Mod X, jak w większości społeczności internetowych musisz się zarejestrować aby móc odpowiadać lub zakładać nowe tematy, ale nie bój się to jest prosty proces w którym wymagamy minimalnych informacji.
  • Rozpoczynaj nowe tematy i odpowiedaj na inne
  • Zapisz się do tematów i for, aby otrzymywać automatyczne uaktualnienia
  • Dodawaj wydarzenia do kalendarza społecznościowego
  • Stwórz swój własny profil i zdobywaj nowych znajomych
  • Zdobywaj nowe doświadczenia

Dołączona grafika Dołączona grafika
Guest Message by DevFuse
 

Zdjęcie
CoD Nowy

[ROZWIĄZANE] Problem z /klasa

Temat rozp. mrziala, 25.03.2013 15:36
cod nowy problem klasa cod

  • Zamknięty Temat jest zamknięty
4 odpowiedzi w tym temacie

#1 mrziala

    Początkujący

  • Użytkownik

Reputacja: 0
Nowy

  • Postów:12
  • Lokalizacja:Kalisz
Offline

Napisano 25.03.2013 15:36

Mam problem gdy wpisze /klasa to mam komunikat, poczekaj na klase a nie spamujesz. Pomożecie? nie można wcale klasy wybrać jak możecie to od razu powiedzcie w czym problem :)

Silnik wygląda tak:
#include <amxmodx>
#include <amxmisc>
#include <cstrike>
#include <fakemeta>
#include <hamsandwich>
#include <sqlx>
#include <csx>
#include <colorchat>

#define PLUGIN "Call of Duty: MW Mod"
#define VERSION "1.0-2"
#define AUTHOR "QTM_Peyote"

#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_USTAW_SZYBKOSC 832

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_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, 0, 0},
bronie_dozwolone = 1<<CSW_KNIFE | 1<<CSW_C4;

new bool:freezetime = true;

new licznik_zabiccod[33];
new weaponname[22];
new min_lvl = 0;
new Float:procent = 0.10; // liczba 0.20 oznacza 20 % max lvl'u. Dajac 0.5 damy 50 % a 1.0 - 100 % lvlu

new lvl_klasy_gracza[33][sizeof nazwy_klas];
new xp_klasy_gracza[33][sizeof nazwy_klas];
new int_klasy_gracza[33][sizeof nazwy_klas];
new zdr_klasy_gracza[33][sizeof nazwy_klas];
new wyt_klasy_gracza[33][sizeof nazwy_klas];
new kon_klasy_gracza[33][sizeof nazwy_klas];

new polaczony_raz[33], wczytane_dane[33];
new Handle:info

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_cvar("cod_host", "host");
register_cvar("cod_user", "login");
register_cvar("cod_pass", "haslo");
register_cvar("cod_db", "nazwa bazy");
register_cvar("cod_table", "codmod_table");

register_clcmd("say /klasa", "WybierzKlase");
register_clcmd("say /class", "WybierzKlase");
register_clcmd("say /klasy", "OpisKlasy");
register_clcmd("say /classinfo", "OpisKlasy");
register_clcmd("say /perk", "KomendaOpisPerku");
register_clcmd("say /perki", "OpisPerkow");
register_clcmd("say /perks", "OpisPerkow");
register_clcmd("say /item", "Pomoc");
register_clcmd("say /przedmiot", "OpisPerku");
register_clcmd("say /dropp", "WyrzucPerk");
register_clcmd("say /wyrzuc", "WyrzucPerk");
register_clcmd("say /reset", "KomendaResetujPunkty");
register_clcmd("say /statystyki", "PrzydzielPunkty");
register_clcmd("say /skille", "statystyki_klasy");
register_clcmd("say /staty", "statystyki_klasy");
register_clcmd("say /vip","ShowMotd")
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_event("DeathMsg", "SmiercGraczaKillCod", "a");

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

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 Host[64], User[64], Pass[64], DB[64], Table[32];

get_cvar_string("cod_host", Host, 63);
get_cvar_string("cod_user", User, 63);
get_cvar_string("cod_pass", Pass, 63);
get_cvar_string("cod_db", DB, 63);
get_cvar_string("cod_table", Table, 31);

info = SQL_MakeDbTuple(Host, User, Pass, DB);
if(info == Empty_Handle){
set_fail_state("Brak polaczenia z baza danych!");
return;
}

new szTemp[1028], iLen = 0
iLen += formatex(szTemp[iLen], charsmax(szTemp)-iLen, "CREATE TABLE IF NOT EXISTS `%s` (`nick` VARCHAR(64)", Table);

for(new i=1; i<= ilosc_klas; i++)
iLen += formatex(szTemp[iLen], charsmax(szTemp)-iLen, ", `%i` VARCHAR(32)", i);

iLen += copy(szTemp[iLen], charsmax(szTemp)-iLen, ")");

SQL_ThreadQuery(info, "IgnoreHandle", szTemp);
}

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()
{
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(poziom_gracza[id] < min_lvl)
{
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Wykrylem duze problemy z balansem lvli na serwerze");
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 W ramach tego dostales ^x04%i^x01 na start",min_lvl);
UstawDoswiadczenie(id,PobierzDoswiadczeniePoziomu(min_lvl)+1);
poziom_gracza[id] = min_lvl;
SprawdzPoziom(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;

WczytajDane(id, klasa_gracza[id]);
UstawPerk(id, 0, 0, 0);
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 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;

if(PobierzWytrzymalosc(this, 1, 1, 1) <= 0)
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;
doswiadczenie_gracza[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);
doswiadczenie_gracza[attacker] += nowe_doswiadczenie;
}

SprawdzPoziom(attacker);

return HAM_IGNORED;
}


public client_authorized(id)
{
UsunUmiejetnosci(id);

wczytane_dane[id] = 0;
polaczony_raz[id] = 0;

for(new i=1 ;i<sizeof nazwy_klas; i++)
{
lvl_klasy_gracza[id][i] = 0;
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;
}

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_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<playerCount; i++)
{
id = Players[i];
if(!klasa_gracza[id])
continue;

doswiadczenie_gracza[id] += doswiadczenie_za_wygrana;
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Dostales ^x04%i^x01 doswiadczenia za wygrana runde.", 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);

ColorChat(id, GREEN, "^x01Perk: ^x04%s.", nazwy_perkow[perk]);
ColorChat(id, GREEN, "^x04Opis: ^x01%s.", opis_perku);
}

public OpisPerkow(id)
{
new menu = menu_create("Wybierz Perk:", "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/select");
}

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/select");
}

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<<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^n\yInteligencja: \w%i^n\yZdrowie: \w%i^n\yWytrzymalosc: \w%i^n\yKondycja: \w%i^n\yBronie:\w%s^n\yDodatkowy 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 WybierzKlase(id)
{
if(polaczony_raz[id])
{
client_print(id, print_center, "Poczekaj na klase, a nie spamujesz!");
return PLUGIN_CONTINUE;
}
if(!wczytane_dane[id])
{
new szTemp[1024], data[1], Table[32];
new identyfikator[64], typ_zapisu = get_pcvar_num(cvar_typ_zapisu);

get_cvar_string("cod_table", Table, 31);
data[0] = id;

switch(typ_zapisu)
{
case 1:{
copy(identyfikator, charsmax(identyfikator), nazwa_gracza[id]);
replace_all(identyfikator, charsmax(identyfikator), "'", "\'");
replace_all(identyfikator, charsmax(identyfikator), "`", "\`");
}
case 2: get_user_authid(id, identyfikator, charsmax(identyfikator));
case 3: get_user_ip(id, identyfikator, charsmax(identyfikator));
}

formatex(szTemp, charsmax(szTemp), "SELECT * FROM `%s` WHERE `nick` = '%s'", Table, identyfikator)
SQL_ThreadQuery(info, "KlasaHandle", szTemp, data, sizeof data)
polaczony_raz[id] = 1;
}
else
{
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];

new klasa[50], menu = menu_create("Wybierz klase:", "WybierzKlase_Handle");
for(new i=1; i <= ilosc_klas; i++)
{
format(klasa, 49, "%s \yPoziom: %i", nazwy_klas[i], lvl_klasy_gracza[id][i]);
menu_additem(menu, klasa);
}
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/select");
}
return PLUGIN_CONTINUE;
}

public KlasaHandle(failstate, Handle:query, error[], errnum, Data[], size){
if(failstate != TQUERY_SUCCESS){
log_amx("MySQL Select error: %s",error);
return;
}
new id = Data[0]
new szTemp[2028], klasa[50], menu = menu_create("Wybierz klase:", "WybierzKlase_Handle");

if(SQL_NumRows(query))
{
new daneklasy[6][32];
for(new i=1; i <= ilosc_klas; i++)
{
formatex(szTemp, charsmax(szTemp), "%i", i);
SQL_ReadResult(query, SQL_FieldNameToNum(query, szTemp), szTemp, charsmax(szTemp))

replace_all(szTemp, charsmax(szTemp), "#", " ");

parse(szTemp, daneklasy[0], 31, daneklasy[1], 31, daneklasy[2], 31, daneklasy[3], 31, daneklasy[4], 31, daneklasy[5], 31);
lvl_klasy_gracza[id][i] = str_to_num(daneklasy[0])
xp_klasy_gracza[id][i] = str_to_num(daneklasy[1])
int_klasy_gracza[id][i] = str_to_num(daneklasy[2])
zdr_klasy_gracza[id][i] = str_to_num(daneklasy[3])
wyt_klasy_gracza[id][i] = str_to_num(daneklasy[4])
kon_klasy_gracza[id][i] = str_to_num(daneklasy[5])

formatex(klasa, 49, "%s \yPoziom: %i", nazwy_klas[i], lvl_klasy_gracza[id][i]);
menu_additem(menu, klasa);
}
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/select");
wczytane_dane[id] = 1;
}
else
{
new iLen = 0, Table[32];
new identyfikator[64], typ_zapisu = get_pcvar_num(cvar_typ_zapisu);
get_cvar_string("cod_table", Table, 31);

switch(typ_zapisu)
{
case 1:{
copy(identyfikator, charsmax(identyfikator), nazwa_gracza[id]);
replace_all(identyfikator, charsmax(identyfikator), "'", "\'");
replace_all(identyfikator, charsmax(identyfikator), "`", "\`");
}
case 2: get_user_authid(id, identyfikator, charsmax(identyfikator));
case 3: get_user_ip(id, identyfikator, charsmax(identyfikator));
}

iLen += formatex(szTemp[iLen], charsmax(szTemp)-iLen, "INSERT INTO `%s` (`nick`", Table);

for(new i=1; i <= ilosc_klas; i++)
iLen += formatex(szTemp[iLen], charsmax(szTemp)-iLen, ", `%i`", i);

iLen += copy(szTemp[iLen], charsmax(szTemp)-iLen, ") VALUES (");
iLen += formatex(szTemp[iLen], charsmax(szTemp)-iLen, "'%s'", identyfikator);

for(new i=1; i <= ilosc_klas; i++)
iLen += copy(szTemp[iLen], charsmax(szTemp)-iLen, ", '1#0#0#0#0#0'");

iLen += copy(szTemp[iLen], charsmax(szTemp)-iLen, ")");
SQL_ThreadQuery(info, "IgnoreHandle", szTemp)

for(new i=1; i <= ilosc_klas; i++)
{
formatex(klasa, 49, "%s \yPoziom: 1", nazwy_klas[i]);
menu_additem(menu, klasa);
}
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/select");
}
polaczony_raz[id] = 0;
}

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

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

if(item == klasa_gracza[id] && !nowa_klasa_gracza[id])
return PLUGIN_CONTINUE;

nowa_klasa_gracza[id] = item;

if(klasa_gracza[id])
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Klasa zostanie zmieniona 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 tytul[25];
new kondycjaa[60];
new wytrzymalosca[60];
new zdrowiea[60];
new inteligencjaa[60];
format(inteligencja, charsmax(inteligencja), "Inteligencja: \r%i \y(Zwieksza sile perkow i umiejetnosci klasy)", PobierzInteligencje(id, 1, 1, 1));
format(zdrowie, charsmax(zdrowie), "Zdrowie: \r%i \y(Zwieksza zdrowie)", PobierzZdrowie(id, 1, 1, 1));
format(wytrzymalosc, charsmax(wytrzymalosc), "Wytrzymalosc: \r%i \y(Zmniejsza obrazenia)", PobierzWytrzymalosc(id, 1, 1, 1));
format(kondycja, charsmax(kondycja), "Kondycja: \r%i \y(Zwieksza tempo chodu)", PobierzKondycje(id, 1, 1, 1));
format(tytul, charsmax(tytul), "Przydziel Punkty(%i):", punkty_gracza[id]);
format(inteligencjaa, charsmax(inteligencjaa), "Dodaj 5 punktow w inteligencje");
format(zdrowiea, charsmax(zdrowiea), "Dodaj 5 punktow w zdrowie");
format(wytrzymalosca, charsmax(wytrzymalosca), "Dodaj 5 punktow w wytrzymalosc");
format(kondycjaa, charsmax(kondycjaa), "Dodaj 5 punktow w kondycje");
new menu = menu_create(tytul, "PrzydzielPunkty_Handler");
menu_additem(menu, inteligencja);
menu_additem(menu, zdrowie);
menu_additem(menu, wytrzymalosc);
menu_additem(menu, kondycja);
menu_additem(menu, inteligencjaa);
menu_additem(menu, zdrowiea);
menu_additem(menu, wytrzymalosca);
menu_additem(menu, kondycjaa);
menu_setprop(menu, MPROP_EXIT, 0);
menu_display(id, menu);
}

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

switch(item)
{
case 0:
{
if(inteligencja_gracza[id] < limit_poziomu/2)
{
inteligencja_gracza[id]++;
punkty_gracza[id]--;
}
else
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Maxymalny poziom ^x04inteligencji^x01 osiagniety");


}
case 1:
{
if(zdrowie_gracza[id] < limit_poziomu/2)
{
zdrowie_gracza[id]++;
punkty_gracza[id]--;
}
else
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Maxymalny poziom ^x04zdrowia^x01 osiagniety");
}
case 2:
{
if(wytrzymalosc_gracza[id] < limit_poziomu/2)
{
wytrzymalosc_gracza[id]++;
punkty_gracza[id]--;
}
else
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Maxymalny poziom ^x04wytrzymalosci^x01 osiagniety");

}
case 3:
{
if(kondycja_gracza[id] < limit_poziomu/2)
{
kondycja_gracza[id]++;
punkty_gracza[id]--;
}
else
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Maxymalny poziom ^x04kondycji^x01 osiagniety");
}
case 4:
{
if(inteligencja_gracza[id] < limit_poziomu/2)
{
if(punkty_gracza[id] < 5)
{
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Masz za malo punktow do rozdania");
}
else
{
if(inteligencja_gracza[id] + 5 <= limit_poziomu/2)
{
inteligencja_gracza[id] += 5;
punkty_gracza[id] -= 5;
}
else
{
new punktydododania;
punktydododania = limit_poziomu/2 - inteligencja_gracza[id];
inteligencja_gracza[id] += punktydododania;
punkty_gracza[id] -= punktydododania;
}
}
}
else
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Maksymalny poziom ^x04inteligencji^x01 osiagniety");


}
case 5:
{
if(zdrowie_gracza[id] < limit_poziomu/2)
{
if(punkty_gracza[id] < 5)
{
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Masz za malo punktow do rozdania");
}
else
{
if(zdrowie_gracza[id] + 5 <= limit_poziomu/2)
{
zdrowie_gracza[id] += 5;
punkty_gracza[id] -= 5;
}
else
{
new punktydododania;
punktydododania = limit_poziomu/2 - zdrowie_gracza[id];
zdrowie_gracza[id] += punktydododania;
punkty_gracza[id] -= punktydododania;
}
}
}
else
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Maksymalny poziom ^x04zdrowia^x01 osiagniety");
}
case 6:
{
if(wytrzymalosc_gracza[id] < limit_poziomu/2)
{
if(punkty_gracza[id] < 5)
{
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Masz za malo punktow do rozdania");
}
else
{
if(wytrzymalosc_gracza[id] + 5 <= limit_poziomu/2)
{
wytrzymalosc_gracza[id] += 5;
punkty_gracza[id] -= 5;
}
else
{
new punktydododania;
punktydododania = limit_poziomu/2 - wytrzymalosc_gracza[id];
wytrzymalosc_gracza[id] += punktydododania;
punkty_gracza[id] -= punktydododania;
}
}
}
else
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Maksymalny poziom ^x04wytrzymalosci^x01 osiagniety");

}
case 7:
{
if(kondycja_gracza[id] < limit_poziomu/2)
{
if(punkty_gracza[id] < 5)
{
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Masz za malo punktow do rozdania");
}
else
{
if(kondycja_gracza[id] + 5 <= limit_poziomu/2)
{
kondycja_gracza[id] += 5;
punkty_gracza[id] -= 5;
}
else
{
new punktydododania;
punktydododania = limit_poziomu/2 - kondycja_gracza[id];
kondycja_gracza[id] += punktydododania;
punkty_gracza[id] -= punktydododania;
}
}
}
else
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Maksymalny poziom ^x04kondycji^x01 osiagniety");
}
}

if(punkty_gracza[id] > 0)
PrzydzielPunkty(id);

return PLUGIN_CONTINUE;
}

public KomendaResetujPunkty(id)
{
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Umiejetnosci zostana zresetowane.");
client_cmd(id, "spk QTM_CodMod/select");

ResetujPunkty(id);
}

public ResetujPunkty(id)
{
punkty_gracza[id] = poziom_gracza[id]*2-2;
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 param[2];
param[0] = id;
param[1] = bron;
set_task(0.1, "Strip", _, param, 2);
}

if(cs_get_user_shield(id) && !gracz_ma_tarcze[id])
engclient_cmd(id, "drop", "weapon_shield");

UstawSzybkosc(id);
}
public Strip(param[2])
{
if(is_user_alive(param[0]) && ( 1 <= param[1] <= 30) )
{
get_weaponname(param[1], weaponname, 21);
ham_strip_weapon(param[0], weaponname);
}
}

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 WczytajDane(id, klasa)
{
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];
return PLUGIN_CONTINUE;
}

public ZapiszDane(id)
{
if(!klasa_gracza[id])
return PLUGIN_CONTINUE;

new szTemp[512], szTemp2[512], Table[32], identyfikator[64];
get_cvar_string("cod_table", Table, 31);

new typ_zapisu = get_pcvar_num(cvar_typ_zapisu);

switch(typ_zapisu)
{
case 1:{
copy(identyfikator, charsmax(identyfikator), nazwa_gracza[id]);
replace_all(identyfikator, 63, "'", "\'");
replace_all(identyfikator, 63, "`", "\`");
}
case 2: get_user_authid(id, identyfikator, charsmax(identyfikator));
case 3: get_user_ip(id, identyfikator, charsmax(identyfikator));
}

formatex(szTemp2, charsmax(szTemp2),"%i#%i#%i#%i#%i#%i", poziom_gracza[id], doswiadczenie_gracza[id], inteligencja_gracza[id], zdrowie_gracza[id], wytrzymalosc_gracza[id], kondycja_gracza[id]);
formatex(szTemp, charsmax(szTemp), "UPDATE `%s` SET `%i` = '%s' WHERE `nick` = '%s'", Table, klasa_gracza[id], szTemp2, identyfikator);

SQL_ThreadQuery(info, "IgnoreHandle",szTemp)
return PLUGIN_CONTINUE;
}

public IgnoreHandle(FailState,Handle:query,Error[],Errcode,Data[],DataSize)
{
if(FailState != TQUERY_SUCCESS){
log_amx("MySQL save error: %s", Error);
return;
}
}

public plugin_end()
SQL_FreeHandle(info)

public WyrzucPerk(id)
{
if(perk_gracza[id])
{
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Wyrzuciles ^x04%s.", nazwy_perkow[perk_gracza[id]]);
UstawPerk(id, 0, 0, 0);
}
else
ColorChat(id, GREEN, "[Cs-Maniek.pl] ^x01 Nie masz zadnego perku.");
}

public SprawdzPoziom(id)
{
new limit_poziomu = get_pcvar_num(cvar_limit_poziomu);

new bool:zdobyl_poziom, bool:stracil_poziom;

while(doswiadczenie_gracza[id] >= PobierzDoswiadczeniePoziomu(poziom_gracza[id]) && poziom_gracza[id] < limit_poziomu)
{
poziom_gracza[id]++;
punkty_gracza[id] = (poziom_gracza[id]-1)*2-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);
ZapiszDane(id);
}

if(stracil_poziom)
{
ResetujPunkty(id);
set_hudmessage(255, 255, 0, 0.31, 0.32, 0, 6.0, 5.0);
ShowSyncHudMsg(id, SyncHudObj2,"Spadles do %i poziomu!", poziom_gracza[id]);
ZapiszDane(id);
}
else if(zdobyl_poziom)
{
set_hudmessage(255, 255, 0, 0.31, 0.32, 0, 6.0, 5.0);
ShowSyncHudMsg(id, SyncHudObj2,"Awansowales do %i poziomu!", poziom_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;
}

new name[32];

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

if(!target)
return PLUGIN_CONTINUE;

get_user_name(target, name, 31);
new hp = get_user_health(target);
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;
static stats[8], body[8]
get_user_stats(target, stats, body)
set_hudmessage(255, 255, 0, 0.02, 0.14, 0, 1.0, 1.0, 0.1, 0.1);
ShowSyncHudMsg(id, SyncHudObj, " INFO:^n|Gracz: %s^n|Klasa : %s^n|Exp : %i | %0.1f%%^n|Poziom : %i^n|Perk : %s^n|KillStreak : x%d^n|HP : %d^n^n^n STATY:^n|Inteligencja : %i^n|Zycie : %i^n|Wytrzymalosc : %i^n|Kondycja : %i^n|Fragi : %d^n^n||VIP : %s||"
, name, nazwy_klas[klasa_gracza[target]], doswiadczenie_gracza[target], fProcent, poziom_gracza[target], nazwy_perkow[perk_gracza[target]], licznik_zabiccod[target], hp, inteligencja_gracza[target], zdrowie_gracza[target], wytrzymalosc_gracza[target], kondycja_gracza[target], stats[0], get_user_flags(target) & ADMIN_LEVEL_H ? "Tak" : "Nie");
return PLUGIN_CONTINUE;
}

new Time[9]
new ileMa = doswiadczenie_gracza[id],ilePotrzeba = PobierzDoswiadczeniePoziomu(poziom_gracza[id]),ilePotrzebaBylo = poziom_gracza[id]-1 >= 0 ?PobierzDoswiadczeniePoziomu(poziom_gracza[id]-1) : 0
new Float:fProcent = 0.0;
fProcent = (float((ileMa - ilePotrzebaBylo)) / float((ilePotrzeba - ilePotrzebaBylo))) * 100.0;
new hp = get_user_health(id);
static stats[8], body[8]
get_user_stats(id, stats, body)
get_time("%H:%M:%S",Time,8)
set_hudmessage(255, 255, 0, -1.0, 0.01, 0, 1.0, 1.0, 0.1, 0.1);
ShowSyncHudMsg(id, SyncHudObj, "[Klasa : %s]|[Exp: %i | %0.1f%%]|[LvL : %i]^n[CoD 301]|[Nocny Exp]|[Eventy]|[Cs-Maniek.pl]^n[Perk : [%s]|[HP : %d]^n[KillStreak : x%d]|[Fragi : %d]|[Godzina : %s]"
, nazwy_klas[klasa_gracza[id]], doswiadczenie_gracza[id], fProcent, poziom_gracza[id], nazwy_perkow[perk_gracza[id]], hp, licznik_zabiccod[id], stats[0], Time);
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\y[c]\w - Uzycie umiejetnosci klasy", -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, GREEN, "[Cs-Maniek.pl] ^x01 Zdobyles ^x04%s.", 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);
ham_strip_weapon(id, 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);

return ilosc_klas;
}

public SmiercGraczaKillCod(id)
{
new zabojcacod = read_data(1)
new ofiaracod = read_data(2)

licznik_zabiccod[zabojcacod]++;

if(!is_user_alive(id))
{
licznik_zabiccod[ofiaracod] = 0;
}
}

public statystyki_klasy(id)
{
if(!is_user_alive(id) || !is_user_connected(id))
{
ColorChat(id, GREEN, "[Cs-Maniek.pl]^x01 Statystyki mozesz podgladac tylko gdy zyjesz!")
return PLUGIN_CONTINUE;
}
else
{
new name[64];
get_user_name(id, name, 63);
new hp_klasy = PobierzZdrowie(id, 1, 1, 1);
new hp = hp_klasy+100

const SIZE = 1024;
new staty[SIZE+1],len = 0;
len += formatex(staty[len], SIZE - len, "<html><body style=^"background-color:black;color:white;font-size:14;text-align:center;^"<br>");
len += formatex(staty[len], SIZE - len, "Witaj <font color=#00c000>%s</font> w statystykach twojej klasy.<br><br>", name);
len += formatex(staty[len], SIZE - len, "Klasa: <font color=#00c000><b>%s</b></font><br><br>", nazwy_klas[klasa_gracza[id]]);
len += formatex(staty[len], SIZE - len, "Masz <font color=#00c000><b>%d</b></font> Hp wiecej.<br>", zdrowie_gracza[id]);
len += formatex(staty[len], SIZE - len, "Masz <font color=#00c000><b>%0.1f%%</b></font> redukcji obrazen.<br>", redukcja_obrazen_gracza[id]*100);
len += formatex(staty[len], SIZE - len, "Jestes szybszy o <font color=#00c000><b>%d</b></font>.<br>", floatround(kondycja_gracza[id]*1.3));
len += formatex(staty[len], SIZE - len, "Masz o <font color=#00c000><b>%d</b></font> obrazen wiecej z rakiet/min/itp.<br>", inteligencja_gracza[id]);
len += formatex(staty[len], SIZE - len, "Laczna ilosc zycia wynosi <font color=#00c000><b>%d</b></font><br><br>", hp);
len += formatex(staty[len], SIZE - len, "Twoj Perk to: <font color=#00c000><b>%s</b></font><br>", nazwy_perkow[perk_gracza[id]]);
len += formatex(staty[len], SIZE - len, "Opis Perku: <font color=#00c000><b>%s</b></font><br><br>", opisy_perkow[perk_gracza[id]]);
len += formatex(staty[len], SIZE - len, "Forum: <b><font color=#00c000>Cs-Maniek.pl</b></font><br>");
len += formatex(staty[len], SIZE - len, "</body></html>");

show_motd(id, staty, "Statystyki Klasy");
}
return PLUGIN_CONTINUE;
}

public FindMaxLvl()
{
min_lvl = 0;
new max_lvl=0;
for(new id=1;id<=32;id++)
{
if(poziom_gracza[id] > max_lvl)
max_lvl = poziom_gracza[id];
}
min_lvl = floatround(max_lvl*procent);
}

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 ShowMotd(id)
{
show_motd(id, "vip.txt")
}

public BlokujKomende()
return PLUGIN_HANDLED;

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
}

  • +
  • -
  • 0

#2 Amstaff

    Życzliwy

  • Zbanowany

Reputacja: 0
Nowy

  • Postów:27
  • Lokalizacja:Słopnice
Offline

Napisano 25.03.2013 18:26

Mam ten sam problem .

#3 Vasto_Lorde

    Wszechmogący

  • Power User

Reputacja: 256
Wszechwidzący

  • Postów:633
  • GG:
  • Steam:steam
  • Imię:Maćko
  • Lokalizacja:Poznań
Offline

Napisano 25.03.2013 21:50

Tutaj: 
public client_authorized(id)
{
UsunUmiejetnosci(id);

wczytane_dane[id] = 0;
polaczony_raz[id] = 0;

for(new i=1 ;i<sizeof nazwy_klas; i++)
{
lvl_klasy_gracza[id][i] = 0;
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;
}

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

UsunZadania(id);
}
Zamień na: 
public client_authorized(id)
{
UsunUmiejetnosci(id);

for(new i=1 ;i<sizeof nazwy_klas; i++)
{
lvl_klasy_gracza[id][i] = 0;
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;
}

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

UsunZadania(id);
}
A w public UsunUmiejetnosci (kilka linijek niżej) dodaj 
wczytane_dane[id] = 0;

polaczony_raz[id] = 0;

  • +
  • -
  • 1

GO-Code.pl

#4 mrziala

    Początkujący

  • Autor tematu
  • Użytkownik

Reputacja: 0
Nowy

  • Postów:12
  • Lokalizacja:Kalisz
Offline

Napisano 26.03.2013 14:27

Thanks do zamknięcia :)
  • +
  • -
  • 0

#5 dasiek

    Nie wiem, nie znam się, nie orientuję się, zarobiony jestem.

  • Junior Admin

Reputacja: 2 077
Godlike

  • Postów:5 706
  • Imię:Adaś
  • Lokalizacja:No teraz trochę dalej od WWy
Offline

Napisano 26.03.2013 14:39

Wiadomość wygenerowana automatycznie


Ten temat został zamknięty przez moderatora.

Powód: Pomoc udzielona

Jeśli się z tym nie zgadzasz, Dołączona grafika raportuj ten post, a moderator lub administrator rozpatrzy go ponownie.


Z pozdrowieniami,
Zespół AMXX.PL
  • +
  • -
  • 0
Wróć do Problemy



Również z jednym lub większą ilością słów kluczowych: cod nowy, problem, klasa, cod

Użytkownicy przeglądający ten temat: 0

0 użytkowników, 0 gości, 0 anonimowych

Coinsy CSGOPolygon Za SMS, PSC , Przelew - CoinSell.pro
Skiny do CS:GO za SMS, PSC, Przelew - CSGOPaka.com
Automatyczny Bot Levelowania Steam - LVLUPSteam.com
CSGO Gambling Sites and Free Betting Codes - DreamCodes.gg
  1. AMXX.pl: Support AMX Mod X i SourceMod
  2. → Mody
  3. → Call of Duty Mod
  4. → Problemy
  5. Regulamin