16 odpowiedzi w tym temacie

[Heineken]

Mam silnik i che do niego wrzucic jakiśplugin da rade

jak to zrobić.

[Łokiec]

Podaj jaki plugin i silnik to ci to zrobie

[Heineken]

Nie che gotowca che to zrobić sam

[Twistu]

No to paczaj bo to proste , na początku dodjesz biblioteki które są w pluginie to co się zaczyna #include i przekopiowujesz do silnika ( tych których nie ma , te które są pomiń) , potem przekopiowujesz z pluginu wszystko co jest pod public plugin_init do następnego "public" i wklejasz to pod public plugin_init w silniku . Na końcu przekopiowujesz reszte z tego pluginu na samym dole kodu silnika

[Heineken]

Dodałem tak jak napisałeś i coś nie wyszło.
Ja to dodałem tak:
Silnik:

Spoiler

#include <amxmodx>
#include <amxmisc>
#include <cstrike>
#include <fakemeta>
#include <hamsandwich>
#include <nvault>
#define PLUGIN "Call of Duty: MW Mod"
#define VERSION "1.0-3"
#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_POKAZ_REKLAME 768
#define ZADANIE_USTAW_SZYBKOSC 832
#define VAULT_EXPIREDAYS 30
new const maxAmmo[31] = {0, 52, 0, 90, 1, 31, 1, 100, 90, 1, 120, 100, 100, 90, 90, 90, 100, 120, 30, 120, 200, 31, 90, 120,
90, 2, 35, 90, 90,0, 100};
new const co_ile[] = { 1, 4, 8, 16, 24, 50 ,100, 200, 500, 1000 } // Wlasnie tutaj zmieniamy co ile maja rosnac punkty.
new szybkosc_rozdania[33];
new MsgScreenfade;
new vault;
new SyncHudObj, SyncHudObj2;

new cvar_doswiadczenie_za_zabojstwo,
	 cvar_doswiadczenie_za_obrazenia,
	 cvar_doswiadczenie_za_wygrana,
	 cvar_typ_zapisu,
	 cvar_limit_poziomu,
	 cvar_proporcja_poziomu,
	 cvar_blokada_broni;
    
new perk_zmieniony,
	 klasa_zmieniona;
	
new nazwy_perkow[MAX_ILOSC_PERKOW+1][MAX_WIELKOSC_NAZWY+1],
	 opisy_perkow[MAX_ILOSC_PERKOW+1][MAX_WIELKOSC_OPISU+1],
	 max_wartosci_perkow[MAX_ILOSC_PERKOW+1],
	 min_wartosci_perkow[MAX_ILOSC_PERKOW+1],
	 pluginy_perkow[MAX_ILOSC_PERKOW+1],
	 ilosc_perkow;
	
new nazwa_gracza[33][64],
	 klasa_gracza[33],
	 nowa_klasa_gracza[33],
	 poziom_gracza[33],
	 doswiadczenie_gracza[33],
	 perk_gracza[33],
	 wartosc_perku_gracza[33];
new Float:maksymalne_zdrowie_gracza[33],
	 Float:szybkosc_gracza[33],
	 Float:redukcja_obrazen_gracza[33];
	
new punkty_gracza[33],
	 zdrowie_gracza[33],
	 inteligencja_gracza[33],
	 wytrzymalosc_gracza[33],
	 kondycja_gracza[33];
new bool:gracz_ma_tarcze[33],
	 bool:gracz_ma_noktowizor[33];	
new bonusowe_bronie_gracza[33],
	 bonusowe_zdrowie_gracza[33],
	 bonusowa_inteligencja_gracza[33],
	 bonusowa_wytrzymalosc_gracza[33],
	 bonusowa_kondycja_gracza[33];
new bronie_klasy[MAX_ILOSC_KLAS+1],
	 zdrowie_klas[MAX_ILOSC_KLAS+1],
	 kondycja_klas[MAX_ILOSC_KLAS+1],
	 inteligencja_klas[MAX_ILOSC_KLAS+1],
	 wytrzymalosc_klas[MAX_ILOSC_KLAS+1],
	 nazwy_klas[MAX_ILOSC_KLAS+1][MAX_WIELKOSC_NAZWY+1],
	 opisy_klas[MAX_ILOSC_KLAS+1][MAX_WIELKOSC_OPISU+1],
	 pluginy_klas[MAX_ILOSC_KLAS+1],
	 ilosc_klas;
new bronie_druzyny[] = {0, 1<<CSW_GLOCK18, 1<<CSW_USP},
	 bronie_dozwolone = 1<<CSW_KNIFE | 1<<CSW_C4;
new bool:freezetime = true;
#define MAX_WIELKOSC_FRAKCJA 64
new frakcja_klas[MAX_ILOSC_KLAS+1][MAX_WIELKOSC_FRAKCJA+1]
public plugin_init()
{
register_plugin(PLUGIN, VERSION, AUTHOR);

cvar_doswiadczenie_za_zabojstwo = register_cvar("cod_killxp", "10");
cvar_doswiadczenie_za_obrazenia = register_cvar("cod_damagexp", "1"); // ilosc doswiadczenia za 20 obrazen
cvar_doswiadczenie_za_wygrana = register_cvar("cod_winxp", "50");
cvar_typ_zapisu = register_cvar("cod_savetype", "2");  // 1-Nick; 2-SID dla Steam; 3-IP
cvar_limit_poziomu = register_cvar("cod_maxlevel", "200");
cvar_proporcja_poziomu = register_cvar("cod_levelratio", "35");
cvar_blokada_broni = register_cvar("cod_weaponsblocking", "1");

register_clcmd("say /klasa", "WybierzKlase");
register_clcmd("say /class", "WybierzKlase");
register_clcmd("say /klasy", "OpisKlasy");
register_clcmd("say /classinfo", "OpisKlasy");
register_clcmd("say /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 /drop", "WyrzucPerk");
register_clcmd("say /wyrzuc", "WyrzucPerk");
register_clcmd("say /reset", "KomendaResetujPunkty");
register_clcmd("say /statystyki", "PrzydzielPunkty");
register_clcmd("say /staty", "PrzydzielPunkty");
register_clcmd("say /pomoc", "Pomoc");
register_clcmd("useperk", "UzyjPerku");
register_clcmd("radio3", "UzyjPerku");
register_clcmd("fullupdate", "BlokujKomende");

register_menucmd(register_menuid("Klasa:"), 1023, "OpisKlasy");

RegisterHam(Ham_TakeDamage, "player", "Obrazenia");
RegisterHam(Ham_TakeDamage, "player", "ObrazeniaPost", 1);
RegisterHam(Ham_Spawn, "player", "Odrodzenie", 1);
RegisterHam(Ham_Killed, "player", "SmiercGraczaPost", 1);

RegisterHam(Ham_Touch, "armoury_entity", "DotykBroni");
RegisterHam(Ham_Touch, "weapon_shield", "DotykTarczy");
RegisterHam(Ham_Touch, "weaponbox", "DotykBroni");

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

register_message(get_user_msgid("Health"),"MessageHealth");

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

vault = nvault_open("CodMod");

MsgScreenfade = get_user_msgid("ScreenFade");

SyncHudObj = CreateHudSyncObj();
SyncHudObj2 = CreateHudSyncObj();

perk_zmieniony = CreateMultiForward("cod_perk_changed", ET_CONTINUE, FP_CELL, FP_CELL, FP_CELL);
klasa_zmieniona = CreateMultiForward("cod_class_changed", ET_CONTINUE, FP_CELL, FP_CELL);
copy(nazwy_perkow[0], MAX_WIELKOSC_NAZWY, "Brak");
copy(opisy_perkow[0], MAX_WIELKOSC_OPISU, "Zabij kogos, aby otrzymac przedmiot");
copy(nazwy_klas[0], MAX_WIELKOSC_NAZWY, "Brak");

set_task(1.0, "plugin_cfg");
{
register_plugin(PLUGIN, VERSION, AUTHOR);

register_event("DeathMsg", "DeathMsg", "a");
register_event("ResetHUD", "ResetHUD", "abe");
register_logevent("HostageRescued", 3, "1=triggered", "2=Rescued_A_Hostage");
register_logevent("HostageKilled", 3, "1=triggered", "2=Killed_A_Hostage");

SyncHudObj = CreateHudSyncObj();

cvar_coins_ff	 =  register_cvar("cod_coins_friendlyfire", "0");

cvar_coins_kill	 =  register_cvar("cod_coins_kill", "1");
cvar_coins_kill_vip	=  register_cvar("cod_coins_kill_vip", "2");
cvar_coins_kill_hs	 =  register_cvar("cod_coins_kill_hs", "3");
cvar_coins_kill_hs_vip	=  register_cvar("cod_coins_kill_hs_vip", "6");

cvar_coins_planted	=  register_cvar("cod_coins_planted", "1");
cvar_coins_planted_vip   =  register_cvar("cod_coins_planted_vip", "2");
cvar_coins_defused	 =  register_cvar("cod_coins_defused", "1");
cvar_coins_defused_vip	=  register_cvar("cod_coins_defused_vip", "2");

cvar_coins_rescue_hostage  =  register_cvar("cod_coins_rescue_hostage", "1");
cvar_coins_rescue_hostage_vip =  register_cvar("cod_coins_rescue_hostage_vip", "2");
cvar_coins_kill_hostage   =  register_cvar("cod_coins_kill_hostage", "2");
cvar_coins_kill_hostage_vip  =  register_cvar("cod_coins_kill_hostage_vip", "1");

cvar_typ_zapisu	 =  get_cvar_pointer("cod_savetype");

vault=nvault_open("monety");
if(vault == INVALID_HANDLE)
  set_fail_state("Nie mozna otworzyc pliku");
}
	
}
public plugin_cfg()
{
new lokalizacja_cfg[33];
get_configsdir(lokalizacja_cfg, charsmax(lokalizacja_cfg));
server_cmd("exec %s/codmod.cfg", lokalizacja_cfg);
server_exec();
if(vault != INVALID_HANDLE)
  nvault_prune(vault, 0, get_systime()-(86400*VAULT_EXPIREDAYS));
}
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(!is_user_alive(id))
  return HAM_IGNORED;
if(!task_exists(id+ZADANIE_POKAZ_INFORMACJE))
  set_task(1.0, "PokazInformacje", id+ZADANIE_POKAZ_INFORMACJE, _, _, "b");

if(nowa_klasa_gracza[id])
  UstawNowaKlase(id);

if(!klasa_gracza[id])
{
  WybierzKlase(id);
  return HAM_IGNORED;
}

DajBronie(id);
ZastosujAtrybuty(id);

if(punkty_gracza[id] > 0)
  PrzydzielPunkty(id);
return HAM_IGNORED;
}
public UstawNowaKlase(id)
{
new ret;

new forward_handle = CreateOneForward(pluginy_klas[klasa_gracza[id]], "cod_class_disabled", FP_CELL, FP_CELL);
ExecuteForward(forward_handle, ret, id, klasa_gracza[id]);
DestroyForward(forward_handle);

forward_handle = CreateOneForward(pluginy_klas[nowa_klasa_gracza[id]], "cod_class_enabled", FP_CELL, FP_CELL);
ExecuteForward(forward_handle, ret, id, nowa_klasa_gracza[id]);
DestroyForward(forward_handle);


if(ret == 4)
{
  klasa_gracza[id] = 0;
  return PLUGIN_CONTINUE;
}
ExecuteForward(klasa_zmieniona, ret, id, klasa_gracza[id]);

if(ret == 4)
{
  klasa_gracza[id] = 0;
  return PLUGIN_CONTINUE;
}

klasa_gracza[id] = nowa_klasa_gracza[id];
nowa_klasa_gracza[id] = 0;
UstawPerk(id, perk_gracza[id], wartosc_perku_gracza[id], 0);

WczytajDane(id, klasa_gracza[id]);
return PLUGIN_CONTINUE;
}
public DajBronie(id)
{
for(new i=1; i < 32; i++)
{
  if((1<<i) & (bronie_klasy[klasa_gracza[id]] | bonusowe_bronie_gracza[id]))
  {
   new weaponname[22];
   get_weaponname(i, weaponname, 21);
   fm_give_item(id, weaponname);
  }
}

if(gracz_ma_tarcze[id])
  fm_give_item(id, "weapon_shield");

if(gracz_ma_noktowizor[id])
  cs_set_user_nvg(id, 1);

new weapons[32];
new weaponsnum;
get_user_weapons(id, weapons, weaponsnum);
for(new i=0; i<weaponsnum; i++)
  if(is_user_alive(id))
   if(maxAmmo[weapons[i]] > 0)
	cs_set_user_bpammo(id, weapons[i], maxAmmo[weapons[i]]);
}
public ZastosujAtrybuty(id)
{
redukcja_obrazen_gracza[id] = 0.7*(1.0-floatpower(1.1, -0.112311341*PobierzWytrzymalosc(id, 1, 1, 1)));

maksymalne_zdrowie_gracza[id] = 100.0+PobierzZdrowie(id, 1, 1, 1);

szybkosc_gracza[id] = STANDARDOWA_SZYBKOSC+PobierzKondycje(id, 1, 1, 1)*1.3;

set_pev(id, pev_health, maksymalne_zdrowie_gracza[id]);
}
public PoczatekRundy()
{
freezetime = false;
for(new id=0;id<=32;id++)
{
  if(!is_user_alive(id))
   continue;
  Display_Fade(id, 1<<9, 1<<9, 1<<12, 0, 255, 70, 100);

  set_task(0.1, "UstawSzybkosc", id+ZADANIE_USTAW_SZYBKOSC);

  switch(get_user_team(id))
  {
   case 1: client_cmd(id, "spk 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;
   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 MessageHealth(msg_id, msg_dest, msg_entity)
{
static health;
health = get_msg_arg_int(1);

if (health < 256) return;

if (!(health % 256))
  set_pev(msg_entity, pev_health, pev(msg_entity, pev_health)-1);

set_msg_arg_int(1, get_msg_argtype(1), 255);
}
public client_authorized(id)
{
UsunUmiejetnosci(id);
get_user_name(id, nazwa_gracza[id], 63);

UsunZadania(id);

set_task(10.0, "PokazReklame", id+ZADANIE_POKAZ_REKLAME);
}
public client_disconnect(id)
{
ZapiszDane(id);
UsunUmiejetnosci(id);
UsunZadania(id);
}
public UsunUmiejetnosci(id)
{
nowa_klasa_gracza[id] = 0;
UstawNowaKlase(id);
klasa_gracza[id] = 0;
poziom_gracza[id] = 0;
doswiadczenie_gracza[id] = 0;
punkty_gracza[id] = 0;
zdrowie_gracza[id] = 0;
inteligencja_gracza[id] = 0;
wytrzymalosc_gracza[id] = 0;
kondycja_gracza[id] = 0;
bonusowe_zdrowie_gracza[id] = 0;
bonusowa_wytrzymalosc_gracza[id] = 0;
bonusowa_inteligencja_gracza[id] = 0;
bonusowa_kondycja_gracza[id] = 0;
maksymalne_zdrowie_gracza[id] = 0.0;
szybkosc_gracza[id] = 0.0;
UstawPerk(id, 0, 0, 0);
}
public UsunZadania(id)
{
remove_task(id+ZADANIE_POKAZ_INFORMACJE);
remove_task(id+ZADANIE_POKAZ_REKLAME);
remove_task(id+ZADANIE_USTAW_SZYBKOSC);
}

public WygranaTerro()
WygranaRunda("TERRORIST");

public WygranaCT()
WygranaRunda("CT");
public WygranaRunda(const Team[])
{
new Players[32], playerCount, id;
get_players(Players, playerCount, "aeh", Team);
new doswiadczenie_za_wygrana = get_pcvar_num(cvar_doswiadczenie_za_wygrana);

if(get_playersnum() < 3)
  return;

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

  doswiadczenie_gracza[id] += doswiadczenie_za_wygrana;
  client_print(id, print_chat, "[COD:MW] Dostales %i 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);
	  
		new opis2[416+MAX_WIELKOSC_OPISU];
		format(opis2, charsmax(opis2), "\r[Call of Duty MoD \yby \rTaRoNe]^n\r[Forum\y: \rCs-FastKill.xaa.pl]^n^n^n\r[\dPerk\y: \r%s]^n\r[\dOpis\y: \r%s]", nazwy_perkow[perk], opis_perku);
		show_menu(id, 1023, opis2);
}
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 bool:is_in_previous(frakcja[],from){
		for(new i = from - 1;i>=1;i--){
				if(equali(frakcja_klas[i],frakcja)){
						return true;
				}
		}
		return false;
}
public WybierzKlase(id)
{
		new menu = menu_create("Wybierz klase:", "WybierzKlase_Frakcje");
		for(new i=1; i <= ilosc_klas; i++)
		{
				if(!equal(frakcja_klas[i],"") && !is_in_previous(frakcja_klas[i],i)){
						menu_additem(menu,frakcja_klas[i],frakcja_klas[i])
				}
		}
	  
		menu_setprop(menu, MPROP_EXITNAME, "Wyjdz");
		menu_setprop(menu, MPROP_BACKNAME, "Poprzednia strona");
		menu_setprop(menu, MPROP_NEXTNAME, "Nastepna strona");
		menu_display(id, menu);
}
public WybierzKlase_Frakcje(id, menu, item)
{
		if(item == MENU_EXIT){
				menu_destroy(menu);
				return PLUGIN_CONTINUE;
		}
	  
		new data[65], iName[64]
		new acces, callback
		menu_item_getinfo(menu, item, acces, data,64, iName, 63, callback)
	  
		new menu2 = menu_create("Wybierz klase:", "WybierzKlase_Handle");
	  
		new klasa[50],szTmp[5];
		for(new i=1; i <= ilosc_klas; i++)
		{
				if(equali(data,frakcja_klas[i])){
						WczytajDane(id, i);
						format(klasa, charsmax(klasa), "%s \yPoziom: %i", nazwy_klas[i], poziom_gracza[id]);
						num_to_str(i,szTmp,charsmax(szTmp));
						menu_additem(menu2, klasa,szTmp);
				}
		}
	  
		WczytajDane(id, klasa_gracza[id]);
	  
		menu_setprop(menu2, MPROP_EXITNAME, "Wyjdz");
		menu_setprop(menu2, MPROP_BACKNAME, "Poprzednia strona");
		menu_setprop(menu2, MPROP_NEXTNAME, "Nastepna strona");
		menu_display(id, menu2);
	  
		client_cmd(id, "spk QTM_CodMod/select");
	  
		menu_destroy(menu);
		return PLUGIN_CONTINUE;
}
public WybierzKlase_Handle(id, menu, item)
{
		client_cmd(id, "spk QTM_CodMod/select");
	  
		if(item == MENU_EXIT)
		{
				menu_destroy(menu);
				return PLUGIN_CONTINUE;
		}	  
	  
		new data[65], iName[64]
		new acces, callback
		menu_item_getinfo(menu, item, acces, data,64, iName, 63, callback)
	  
		item = str_to_num(data);
	  
		if(item == klasa_gracza[id] && !nowa_klasa_gracza[id])
		return PLUGIN_CONTINUE;
	  
		nowa_klasa_gracza[id] = item;
	  
		if(klasa_gracza[id])
		client_print(id, print_chat, "[COD:MW] Klasa zostanie zmieniona w nastepnej rundzie.");
		else
		{
				UstawNowaKlase(id);
				DajBronie(id);
				ZastosujAtrybuty(id);
		}
	  
		return PLUGIN_CONTINUE;
}
public PrzydzielPunkty(id)
{
		new szybkosc[60];
		new inteligencja[65];
		new zdrowie[60];
		new wytrzymalosc[60];
		new kondycja[60];
		new tytul[25];
	  
		format(szybkosc, charsmax(szybkosc), "Ile dodawac: \r%d \y(Ile pkt dodac do statow)", co_ile[szybkosc_rozdania[id]]);
		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]);
		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);
}
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] Maxymalny poziom inteligencji osiagniety");										
				}
				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] Maxymalny poziom sily osiagniety");
				}
				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] Maxymalny poziom zrecznosci osiagniety");
				}
				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] Maxymalny poziom kondycji osiagniety");
				}
		}
	  
		if(punkty_gracza[id] > 0)
				PrzydzielPunkty(id);
	  
		return PLUGIN_CONTINUE;
}
public KomendaResetujPunkty(id)
{
client_print(id, print_chat, "[COD:MW] Umiejetnosci zostana zresetowane.");
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 CurWeapon(id)
{
if(!is_user_connected(id))
  return;

new team = get_user_team(id);

if(team > 2)
  return;

new bron = read_data(2);

new bronie = (bronie_klasy[klasa_gracza[id]] | bonusowe_bronie_gracza[id] | bronie_druzyny[team] | bronie_dozwolone);

if(!(1<<bron & bronie))
{
  new weaponname[22];

  get_weaponname(bron, weaponname, 21);
  ham_strip_weapon(id, weaponname);
}

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

UstawSzybkosc(id);
}
public EmitSound(id, iChannel, szSound[], Float:fVol, Float:fAttn, iFlags, iPitch )
{
if(!is_user_alive(id))
  return FMRES_IGNORED;

if(equal(szSound, "common/wpn_denyselect.wav"))
{
  new forward_handle = CreateOneForward(pluginy_klas[klasa_gracza[id]], "cod_class_skill_used", FP_CELL);
  ExecuteForward(forward_handle, id, id);
  DestroyForward(forward_handle);
  return FMRES_SUPERCEDE;
}
if(equal(szSound, "items/ammopickup2.wav"))
{
  cs_set_user_armor(id, 0, CS_ARMOR_NONE);
  return FMRES_SUPERCEDE;
}

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

return FMRES_IGNORED;
}
public UzyjPerku(id)
{
if(!is_user_alive(id))
  return PLUGIN_HANDLED;

new forward_handle = CreateOneForward(pluginy_perkow[perk_gracza[id]], "cod_perk_used", FP_CELL);
ExecuteForward(forward_handle, id, id);
DestroyForward(forward_handle);
return PLUGIN_HANDLED;
}
public ZapiszDane(id)
{
if(!klasa_gracza[id] || doswiadczenie_gracza[id] < 1 || vault == INVALID_HANDLE)
  return PLUGIN_CONTINUE;

new vaultkey[128],vaultdata[256], identyfikator[64];
format(vaultdata, charsmax(vaultdata),"%i %i %i %i %i %i", doswiadczenie_gracza[id], poziom_gracza[id], inteligencja_gracza[id], zdrowie_gracza[id], wytrzymalosc_gracza[id], kondycja_gracza[id]);

new typ_zapisu = get_pcvar_num(cvar_typ_zapisu);

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

format(vaultkey, charsmax(vaultkey),"%s-%s-%i-cod", identyfikator, nazwy_klas[klasa_gracza[id]], typ_zapisu);
nvault_set(vault,vaultkey,vaultdata);

return PLUGIN_CONTINUE;
}
public WczytajDane(id, klasa)
{
if(vault == INVALID_HANDLE)
  return PLUGIN_CONTINUE;
new vaultkey[128],vaultdata[256], identyfikator[64];

new typ_zapisu = get_pcvar_num(cvar_typ_zapisu);

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

format(vaultkey, charsmax(vaultkey),"%s-%s-%i-cod", identyfikator, nazwy_klas[klasa], typ_zapisu);
new wczytaj/*, wersjaz*/;
if(!(wczytaj = nvault_get(vault,vaultkey,vaultdata,255))) // Jezeli nie ma danych gracza sprawdza stary zapis.
{
  format(vaultkey, charsmax(vaultkey), "%s-%i-cod", nazwa_gracza[id], klasa);
  wczytaj = nvault_get(vault,vaultkey,vaultdata,255);
  //wersjaz = 1;
}
if(wczytaj) {
  new danegracza[6][16];
  parse(vaultdata, danegracza[0], 15, danegracza[1], 15, danegracza[2], 15, danegracza[3], 15, danegracza[4], 15, danegracza[5], 15);

  doswiadczenie_gracza[id] = str_to_num(danegracza[0]);
  poziom_gracza[id] = str_to_num(danegracza[1]);
  inteligencja_gracza[id] = str_to_num(danegracza[2]);
  zdrowie_gracza[id] = str_to_num(danegracza[3]);
  wytrzymalosc_gracza[id] = str_to_num(danegracza[4]);
  kondycja_gracza[id] = str_to_num(danegracza[5]);
  punkty_gracza[id] = (poziom_gracza[id]-1)*2-inteligencja_gracza[id]-zdrowie_gracza[id]-wytrzymalosc_gracza[id]-kondycja_gracza[id];
  nvault_touch(vault, vaultkey);
  /*for(new i=1; i<=ilosc_klas; ++i) {
   if(i != klasa) {
	if(wersjaz == 1)
	 format(vaultkey, charsmax(vaultkey), "%s-%i-cod", nazwa_gracza[id], i);
	else
	 format(vaultkey, charsmax(vaultkey),"%s-%s-%i-cod", identyfikator, nazwy_klas[i], typ_zapisu);
	if(nvault_get(vault,vaultkey,vaultdata,2))
	 nvault_touch(vault, vaultkey);
   }
  }*/
}
else {
  doswiadczenie_gracza[id] = 0;
  poziom_gracza[id] = 1;
  inteligencja_gracza[id] = 0;
  zdrowie_gracza[id] = 0;
  wytrzymalosc_gracza[id] = 0;
  kondycja_gracza[id] = 0;
  punkty_gracza[id] = 0
}

return PLUGIN_CONTINUE;
}

public WyrzucPerk(id)
{
if(perk_gracza[id])
{
  client_print(id, print_chat, "[COD:MW] Wyrzuciles %s.", nazwy_perkow[perk_gracza[id]]);
  UstawPerk(id, 0, 0, 0);
}
else
  client_print(id, print_chat, "[COD:MW] Nie masz zadnego perku.");
}
public SprawdzPoziom(id)
{
if(!is_user_connected(id))
  return;

new limit_poziomu = get_pcvar_num(cvar_limit_poziomu);

new bool:zdobyl_poziom = false, bool:stracil_poziom = false;

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

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

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

  if(!target)
   return PLUGIN_CONTINUE;

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

  set_hudmessage(255, 255, 0, 0.02, 0.14, 0, 1.0, 1.0, 0.1, 0.1);
  ShowSyncHudMsg(id, SyncHudObj, "|Klasa : %s^n|Exp : %0.1f%%^n|Poziom : %i^n|Perk : %s^n^n^n|STATY:^n|Inteligencja : %i^n|Zycie : %i^n|Wytrzymalosc : %i^n|Kondycja : %i^n", nazwy_klas[klasa_gracza[target]], fProcent, poziom_gracza[target], nazwy_perkow[perk_gracza[target]], inteligencja_gracza[target], zdrowie_gracza[target], wytrzymalosc_gracza[target], kondycja_gracza[target]);
  return PLUGIN_CONTINUE;
}
new ileMa = doswiadczenie_gracza[id],ilePotrzeba = PobierzDoswiadczeniePoziomu(poziom_gracza[id]),ilePotrzebaBylo = PobierzDoswiadczeniePoziomu(poziom_gracza[id]-1)
new Float:fProcent = 0.0;
fProcent = (float((ileMa - ilePotrzebaBylo)) / float((ilePotrzeba - ilePotrzebaBylo))) * 100.0;

	  new hp = get_user_health(id);
set_hudmessage(255, 255, 0, -1.0, 0.01, 0, 1.0, 1.0, 0.1, 0.1);
ShowSyncHudMsg(id, SyncHudObj, "[Klasa : %s] | [Exp : %0.1f%%] | [LvL : %i]^n[Cod : 301] | [Night Exp] | [Eventy] | [Cs-FastKill.xaa.pl]^n[Perk : %s] | [Zdrowie : %d] | ", nazwy_klas[klasa_gracza[id]], fProcent, poziom_gracza[id], nazwy_perkow[perk_gracza[id]], hp);

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 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])
  client_print(id, print_chat, "[COD:MW] Zdobyles %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);
if(!((1<<bron) & (1<<CSW_HEGRENADE | 1<<CSW_SMOKEGRENADE | 1<<CSW_FLASHBANG)))
  engclient_cmd(id, "drop", weaponname);
}
public UstawBonusoweZdrowie(id, wartosc)
bonusowe_zdrowie_gracza[id] = wartosc;

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

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

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

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

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

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

punkty_gracza[id] -= wartosc;
wytrzymalosc_gracza[id] += wartosc;
}
public PobierzPerk(id, &wartosc)
{
wartosc = wartosc_perku_gracza[id];
return perk_gracza[id];
}

public PobierzIloscPerkow()
return ilosc_perkow;


public PobierzNazwePerku(perk, Return[], len)
{
if(perk <= ilosc_perkow)
{
  param_convert(2);
  copy(Return, len, nazwy_perkow[perk]);
}
}

public PobierzOpisPerku(perk, Return[], len)
{
if(perk <= ilosc_perkow)
{
  param_convert(2);
  copy(Return, len, opisy_perkow[perk]);
}
}

public PobierzPerkPrzezNazwe(const nazwa[])
{
param_convert(1);
for(new i=1; i <= ilosc_perkow; i++)
  if(equal(nazwa, nazwy_perkow[i]))
   return i;
return 0;
}
public PobierzDoswiadczeniePoziomu(poziom)
return power(poziom, 2)*get_pcvar_num(cvar_proporcja_poziomu);
public PobierzDoswiadczenie(id)
return doswiadczenie_gracza[id];

public PobierzPunkty(id)
return punkty_gracza[id];

public PobierzPoziom(id)
return poziom_gracza[id];
public PobierzZdrowie(id, zdrowie_zdobyte, zdrowie_klasy, zdrowie_bonusowe)
{
new zdrowie;

if(zdrowie_zdobyte)
  zdrowie += zdrowie_gracza[id];
if(zdrowie_bonusowe)
  zdrowie += bonusowe_zdrowie_gracza[id];
if(zdrowie_klasy)
  zdrowie += zdrowie_klas[klasa_gracza[id]];

return zdrowie;
}
public PobierzInteligencje(id, inteligencja_zdobyta, inteligencja_klasy, inteligencja_bonusowa)
{
new inteligencja;

if(inteligencja_zdobyta)
  inteligencja += inteligencja_gracza[id];
if(inteligencja_bonusowa)
  inteligencja += bonusowa_inteligencja_gracza[id];
if(inteligencja_klasy)
  inteligencja += inteligencja_klas[klasa_gracza[id]];

return inteligencja;
}
public PobierzKondycje(id, kondycja_zdobyta, kondycja_klasy, kondycja_bonusowa)
{
new kondycja;

if(kondycja_zdobyta)
  kondycja += kondycja_gracza[id];
if(kondycja_bonusowa)
  kondycja += bonusowa_kondycja_gracza[id];
if(kondycja_klasy)
  kondycja += kondycja_klas[klasa_gracza[id]];

return kondycja;
}
public PobierzWytrzymalosc(id, wytrzymalosc_zdobyta, wytrzymalosc_klasy, wytrzymalosc_bonusowa)
{
new wytrzymalosc;

if(wytrzymalosc_zdobyta)
  wytrzymalosc += wytrzymalosc_gracza[id];
if(wytrzymalosc_bonusowa)
  wytrzymalosc += bonusowa_wytrzymalosc_gracza[id];
if(wytrzymalosc_klasy)
  wytrzymalosc += wytrzymalosc_klas[klasa_gracza[id]];

return wytrzymalosc;
}
public PobierzKlase(id)
return klasa_gracza[id];

public PobierzIloscKlas()
return ilosc_klas;

public PobierzNazweKlasy(klasa, Return[], len)
{
if(klasa <= ilosc_klas)
{
  param_convert(2);
  copy(Return, len, nazwy_klas[klasa]);
}
}
public PobierzOpisKlasy(klasa, Return[], len)
{
if(klasa <= ilosc_klas)
{
  param_convert(2);
  copy(Return, len, opisy_klas[klasa]);
}
}
public PobierzKlasePrzezNazwe(const nazwa[])
{
param_convert(1);
for(new i=1; i <= ilosc_klas; i++)
  if(equal(nazwa, nazwy_klas[i]))
   return i;
return 0;
}
public PobierzZdrowieKlasy(klasa)
{
if(klasa <= ilosc_klas)
  return zdrowie_klas[klasa];
return -1;
}
public PobierzInteligencjeKlasy(klasa)
{
if(klasa <= ilosc_klas)
  return inteligencja_klas[klasa];
return -1;
}
public PobierzKondycjeKlasy(klasa)
{
if(klasa <= ilosc_klas)
  return kondycja_klas[klasa];
return -1;
}
public PobierzWytrzymaloscKlasy(klasa)
{
if(klasa <= ilosc_klas)
  return wytrzymalosc_klas[klasa];
return -1;
}
public ZadajObrazenia(atakujacy, ofiara, Float:obrazenia, Float:czynnik_inteligencji, byt_uszkadzajacy, dodatkowe_flagi)
ExecuteHam(Ham_TakeDamage, ofiara, byt_uszkadzajacy, atakujacy, obrazenia+PobierzInteligencje(atakujacy, 1, 1, 1)*czynnik_inteligencji, (1<<31) | dodatkowe_flagi);

public ZarejestrujPerk(plugin, params)
{
if(params != 4)
  return PLUGIN_CONTINUE;

if(++ilosc_perkow > MAX_ILOSC_PERKOW)
  return -1;

pluginy_perkow[ilosc_perkow] = plugin;
get_string(1, nazwy_perkow[ilosc_perkow], MAX_WIELKOSC_NAZWY);
get_string(2, opisy_perkow[ilosc_perkow], MAX_WIELKOSC_OPISU);
min_wartosci_perkow[ilosc_perkow] = get_param(3);
max_wartosci_perkow[ilosc_perkow] = get_param(4);

return ilosc_perkow;
}
public ZarejestrujKlase(plugin, params)
{
		if(params != 8)
		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);
		get_string(8, frakcja_klas[ilosc_klas], MAX_WIELKOSC_FRAKCJA);
	  
		return ilosc_klas;
}
stock ham_strip_weapon(id, weapon[])
{
if(!equal(weapon, "weapon_", 7) ) return 0
new wId = get_weaponid(weapon)
if(!wId) return 0
new wEnt
while( (wEnt = engfunc(EngFunc_FindEntityByString,wEnt,"classname", weapon) ) && pev(wEnt, pev_owner) != id) {}
if(!wEnt) return 0

if(get_user_weapon(id) == wId) ExecuteHamB(Ham_Weapon_RetireWeapon, wEnt)

if(!ExecuteHamB(Ham_RemovePlayerItem, id, wEnt)) return 0
ExecuteHamB(Ham_Item_Kill ,wEnt)

set_pev(id, pev_weapons, pev(id, pev_weapons) & ~(1<<wId) )
return 1
}
stock Display_Fade(id,duration,holdtime,fadetype,red,green,blue,alpha)
{
message_begin( MSG_ONE, MsgScreenfade,{0,0,0},id );
write_short( duration ); // Duration of fadeout
write_short( holdtime ); // Hold time of color
write_short( fadetype ); // Fade type
write_byte ( red );  // Red
write_byte ( green );  // Green
write_byte ( blue );  // Blue
write_byte ( alpha ); // Alpha
message_end();
}
stock fm_give_item(index, const item[]) {
if (!equal(item, "weapon_", 7) && !equal(item, "ammo_", 5) && !equal(item, "item_", 5) && !equal(item, "tf_weapon_", 10))
  return 0;
new ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, item));
if (!pev_valid(ent))
  return 0;
new Float:origin[3];
pev(index, pev_origin, origin);
set_pev(ent, pev_origin, origin);
set_pev(ent, pev_spawnflags, pev(ent, pev_spawnflags) | SF_NORESPAWN);
dllfunc(DLLFunc_Spawn, ent);
new save = pev(ent, pev_solid);
dllfunc(DLLFunc_Touch, ent, index);
if (pev(ent, pev_solid) != save)
  return ent;
engfunc(EngFunc_RemoveEntity, ent);
return -1;
}
public BlokujKomende()
return PLUGIN_HANDLED;

#include <amxmodx>
#include <amxmisc>
#include <nvault>
#define PLUGIN "System Monet"
#define AUTHOR "kisiel96"
#define VERSION "1.0.8"
#define ZADANIE_POKAZ_MONETY 666
#define VIP ADMIN_LEVEL_G
new nazwa_gracza[32][64],
identyfikator[32][64];
new monety[32];
new SyncHudObj;
new cvar_coins_kill,
cvar_coins_kill_hs,
cvar_coins_kill_vip,
cvar_coins_kill_hs_vip,
cvar_coins_defused,
cvar_coins_defused_vip,
cvar_coins_planted,
cvar_coins_planted_vip,
cvar_coins_rescue_hostage,
cvar_coins_rescue_hostage_vip,
cvar_coins_kill_hostage,
cvar_coins_kill_hostage_vip,
cvar_coins_ff,
cvar_typ_zapisu;
new coins_kill,
coins_kill_hs,
coins_kill_vip,
coins_kill_hs_vip,
coins_defused,
coins_defused_vip,
coins_planted,
coins_planted_vip,
coins_rescue_hostage,
coins_rescue_hostage_vip,
coins_kill_hostage,
coins_kill_hostage_vip,
coins_ff,
typ_zapisu;
new vault;
public plugin_natives()
{
register_native("cod_get_user_coins", "PobierzMonety", 1);
register_native("cod_set_user_coins", "UstawMonety", 1);
}
public client_authorized(id)
{
UsunMonety(id);

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

typ_zapisu = get_pcvar_num(cvar_typ_zapisu);

switch(typ_zapisu)
{
  case 1: copy(identyfikator[id], 63, nazwa_gracza[id]);
  case 2: get_user_authid(id, identyfikator[id], 63);
  case 3: get_user_ip(id, identyfikator[id], 63);
}

Wczytaj(id);
}
public client_connect(id)
Wczytaj(id);
public client_disconnect(id)
{
Zapisz(id);
UsunMonety(id)
}
public plugin_end()
nvault_close(vault);
/////RESET MONET/////
public UsunMonety(id)
monety[id] = 0;
/////ZLICZNIE MONET/////
public DeathMsg()
{
new kid = read_data(1);
new vid = read_data(2);
new hs = read_data(3);

if(kid == vid)
  return;

coins_ff = get_pcvar_num(cvar_coins_ff)

if(coins_ff == 0 && get_user_team(kid) == get_user_team(vid))
  return;

coins_kill = get_pcvar_num(cvar_coins_kill);
coins_kill_vip  = get_pcvar_num(cvar_coins_kill_vip);
coins_kill_hs = get_pcvar_num(cvar_coins_kill_hs);
coins_kill_hs_vip = get_pcvar_num(cvar_coins_kill_hs_vip);

if(get_user_flags(kid) & VIP)
{
  if(hs == 1)
   monety[kid] += coins_kill_hs_vip;
  else
   monety[kid] += coins_kill_vip;
}
else
{
  if(hs == 1)
   monety[kid] += coins_kill_hs;
  else
   monety[kid] += coins_kill;
}
}
public bomb_planted(planter)
{
coins_planted = get_pcvar_num(cvar_coins_planted);
coins_planted_vip = get_pcvar_num(cvar_coins_planted_vip);

if(get_user_flags(planter) & VIP)
  monety[planter] += coins_planted_vip;
else
  monety[planter] += coins_planted;
}
public bomb_defused(defuser)
{
coins_defused = get_pcvar_num(cvar_coins_defused);
coins_defused_vip = get_pcvar_num(cvar_coins_defused_vip);

if(get_user_flags(defuser) & VIP)
  monety[defuser] += coins_defused_vip;
else
  monety[defuser] += coins_defused;
}
public HostageRescued(id)
{
new loguser[80], name[32];
read_logargv(0, loguser, 79);
parse_loguser(loguser, name, 31);

new id = get_user_index(name);

coins_rescue_hostage = get_pcvar_num(cvar_coins_rescue_hostage);
coins_rescue_hostage_vip = get_pcvar_num(cvar_coins_rescue_hostage_vip);

if(get_user_flags(id) & VIP)
  monety[id] += coins_rescue_hostage_vip;
else
  monety[id] += coins_rescue_hostage;

return PLUGIN_CONTINUE
}
public HostageKilled(id)
{
new loguser[80], name[32];
read_logargv(0, loguser, 79);
parse_loguser(loguser, name, 31);

new id = get_user_index(name);

coins_kill_hostage = get_pcvar_num(cvar_coins_kill_hostage);
coins_kill_hostage_vip = get_pcvar_num(cvar_coins_kill_hostage_vip);

if(get_user_flags(id) & VIP)
  monety[id] -= coins_kill_hostage_vip;
else
  monety[id] -= coins_kill_hostage;
}
/////HUD/////
public PokazMonety(id)
{
id -= ZADANIE_POKAZ_MONETY;

if(!is_user_alive(id))
{
  remove_task(id+ZADANIE_POKAZ_MONETY);
  return;
}

set_hudmessage(0, 255, 0, 0.75, 0.00, 0, 0.0, 0.3, 0.0, 2);
ShowSyncHudMsg(id, SyncHudObj, "^n^n^n^n^n[Monety: %i]", monety[id]);
}
public ResetHUD(id)
{
if(!task_exists(id+ZADANIE_POKAZ_MONETY))
  set_task(0.1, "PokazMonety", id+ZADANIE_POKAZ_MONETY, _, _, "b");
}
/////NATYWY/////
public UstawMonety(id, wartosc)
{
monety[id] = wartosc
}
public PobierzMonety(id)
return monety[id];
/////NVAULT/////
public Zapisz(id)
{
new vaultkey[64], vaultdata[256];
format(vaultkey, 63, "%s-monety", identyfikator[id]);
format(vaultdata, 255, "%d#", monety[id]);
nvault_set(vault, vaultkey, vaultdata);

return PLUGIN_CONTINUE
}
public Wczytaj(id)
{
new vaultkey[64], vaultdata[256];
format(vaultkey, 63, "%s-monety", identyfikator[id]);
format(vaultdata, 255, "%d#", monety[id]);
nvault_get(vault, vaultkey, vaultdata,255);

replace_all(vaultdata, 255, "#", " ");

new monetytemp[33];
parse(vaultdata, monetytemp, 32);

monety[id] = str_to_num(monetytemp);

return PLUGIN_CONTINUE
}
////////////////////////////////

A to ten plugin system monet

Spoiler

/* Script generated by Pawn Studio */
/*CHANGELOG:
* 1.0.0 - pierwsza dzialajaca wersja
* 1.0.1 - usuniecie bugu: kopiowanie monet z jednego nicku na drugi
* 1.0.2 - dodanie: natywow
* 1.0.3 - dodanie: typu zapisu
* 1.0.4 - usuniecie bugu: dostawanie monet za wpisanie kill (Podziekowania dla Szybcioor za wykrycie i dla Goliath za zalatanie <img src='https://amxx.pl/public/style_emoticons/<#EMO_DIR#>/cwaniak.gif' class='bbc_emoticon' alt=':]' />)
* 1.0.5 - dodanie: nowe eventy za ktore zdobywa sie monety
* 1.0.6 - dodanie: cvaru - wlacznie/wylaczenie monet za TeamKill
* 1.0.7 - usuniecie bugu: brak monet za zabicie
* 1.0.8 - usuniecie bugu: brak monet za uratowanie/zabicie hosta*/
#include <amxmodx>
#include <amxmisc>
#include <nvault>
#define PLUGIN "System Monet"
#define AUTHOR "kisiel96"
#define VERSION "1.0.8"
#define ZADANIE_POKAZ_MONETY 666
#define VIP ADMIN_LEVEL_G
new nazwa_gracza[32][64],
identyfikator[32][64];
new monety[32];
new SyncHudObj;
new cvar_coins_kill,
cvar_coins_kill_hs,
cvar_coins_kill_vip,
cvar_coins_kill_hs_vip,
cvar_coins_defused,
cvar_coins_defused_vip,
cvar_coins_planted,
cvar_coins_planted_vip,
cvar_coins_rescue_hostage,
cvar_coins_rescue_hostage_vip,
cvar_coins_kill_hostage,
cvar_coins_kill_hostage_vip,
cvar_coins_ff,
cvar_typ_zapisu;
new coins_kill,
coins_kill_hs,
coins_kill_vip,
coins_kill_hs_vip,
coins_defused,
coins_defused_vip,
coins_planted,
coins_planted_vip,
coins_rescue_hostage,
coins_rescue_hostage_vip,
coins_kill_hostage,
coins_kill_hostage_vip,
coins_ff,
typ_zapisu;
new vault;
public plugin_init()
{
register_plugin(PLUGIN, VERSION, AUTHOR);

register_event("DeathMsg", "DeathMsg", "a");
register_event("ResetHUD", "ResetHUD", "abe");
register_logevent("HostageRescued", 3, "1=triggered", "2=Rescued_A_Hostage");
register_logevent("HostageKilled", 3, "1=triggered", "2=Killed_A_Hostage");

SyncHudObj = CreateHudSyncObj();

cvar_coins_ff	 =  register_cvar("cod_coins_friendlyfire", "0");

cvar_coins_kill	 =  register_cvar("cod_coins_kill", "1");
cvar_coins_kill_vip	=  register_cvar("cod_coins_kill_vip", "2");
cvar_coins_kill_hs	 =  register_cvar("cod_coins_kill_hs", "3");
cvar_coins_kill_hs_vip	=  register_cvar("cod_coins_kill_hs_vip", "6");

cvar_coins_planted	=  register_cvar("cod_coins_planted", "1");
cvar_coins_planted_vip   =  register_cvar("cod_coins_planted_vip", "2");
cvar_coins_defused	 =  register_cvar("cod_coins_defused", "1");
cvar_coins_defused_vip	=  register_cvar("cod_coins_defused_vip", "2");

cvar_coins_rescue_hostage  =  register_cvar("cod_coins_rescue_hostage", "1");
cvar_coins_rescue_hostage_vip =  register_cvar("cod_coins_rescue_hostage_vip", "2");
cvar_coins_kill_hostage   =  register_cvar("cod_coins_kill_hostage", "2");
cvar_coins_kill_hostage_vip  =  register_cvar("cod_coins_kill_hostage_vip", "1");

cvar_typ_zapisu	 =  get_cvar_pointer("cod_savetype");

vault=nvault_open("monety");
if(vault == INVALID_HANDLE)
  set_fail_state("Nie mozna otworzyc pliku");
}
public plugin_natives()
{
register_native("cod_get_user_coins", "PobierzMonety", 1);
register_native("cod_set_user_coins", "UstawMonety", 1);
}
public client_authorized(id)
{
UsunMonety(id);

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

typ_zapisu = get_pcvar_num(cvar_typ_zapisu);

switch(typ_zapisu)
{
  case 1: copy(identyfikator[id], 63, nazwa_gracza[id]);
  case 2: get_user_authid(id, identyfikator[id], 63);
  case 3: get_user_ip(id, identyfikator[id], 63);
}

Wczytaj(id);
}
public client_connect(id)
Wczytaj(id);
public client_disconnect(id)
{
Zapisz(id);
UsunMonety(id)
}
public plugin_end()
nvault_close(vault);
/////RESET MONET/////
public UsunMonety(id)
monety[id] = 0;
/////ZLICZNIE MONET/////
public DeathMsg()
{
new kid = read_data(1);
new vid = read_data(2);
new hs = read_data(3);

if(kid == vid)
  return;

coins_ff = get_pcvar_num(cvar_coins_ff)

if(coins_ff == 0 && get_user_team(kid) == get_user_team(vid))
  return;

coins_kill = get_pcvar_num(cvar_coins_kill);
coins_kill_vip  = get_pcvar_num(cvar_coins_kill_vip);
coins_kill_hs = get_pcvar_num(cvar_coins_kill_hs);
coins_kill_hs_vip = get_pcvar_num(cvar_coins_kill_hs_vip);

if(get_user_flags(kid) & VIP)
{
  if(hs == 1)
   monety[kid] += coins_kill_hs_vip;
  else
   monety[kid] += coins_kill_vip;
}
else
{
  if(hs == 1)
   monety[kid] += coins_kill_hs;
  else
   monety[kid] += coins_kill;
}
}
public bomb_planted(planter)
{
coins_planted = get_pcvar_num(cvar_coins_planted);
coins_planted_vip = get_pcvar_num(cvar_coins_planted_vip);

if(get_user_flags(planter) & VIP)
  monety[planter] += coins_planted_vip;
else
  monety[planter] += coins_planted;
}
public bomb_defused(defuser)
{
coins_defused = get_pcvar_num(cvar_coins_defused);
coins_defused_vip = get_pcvar_num(cvar_coins_defused_vip);

if(get_user_flags(defuser) & VIP)
  monety[defuser] += coins_defused_vip;
else
  monety[defuser] += coins_defused;
}
public HostageRescued(id)
{
new loguser[80], name[32];
read_logargv(0, loguser, 79);
parse_loguser(loguser, name, 31);

new id = get_user_index(name);

coins_rescue_hostage = get_pcvar_num(cvar_coins_rescue_hostage);
coins_rescue_hostage_vip = get_pcvar_num(cvar_coins_rescue_hostage_vip);

if(get_user_flags(id) & VIP)
  monety[id] += coins_rescue_hostage_vip;
else
  monety[id] += coins_rescue_hostage;

return PLUGIN_CONTINUE
}
public HostageKilled(id)
{
new loguser[80], name[32];
read_logargv(0, loguser, 79);
parse_loguser(loguser, name, 31);

new id = get_user_index(name);

coins_kill_hostage = get_pcvar_num(cvar_coins_kill_hostage);
coins_kill_hostage_vip = get_pcvar_num(cvar_coins_kill_hostage_vip);

if(get_user_flags(id) & VIP)
  monety[id] -= coins_kill_hostage_vip;
else
  monety[id] -= coins_kill_hostage;
}
/////HUD/////
public PokazMonety(id)
{
id -= ZADANIE_POKAZ_MONETY;

if(!is_user_alive(id))
{
  remove_task(id+ZADANIE_POKAZ_MONETY);
  return;
}

set_hudmessage(0, 255, 0, 0.75, 0.00, 0, 0.0, 0.3, 0.0, 2);
ShowSyncHudMsg(id, SyncHudObj, "^n^n^n^n^n[Monety: %i]", monety[id]);
}
public ResetHUD(id)
{
if(!task_exists(id+ZADANIE_POKAZ_MONETY))
  set_task(0.1, "PokazMonety", id+ZADANIE_POKAZ_MONETY, _, _, "b");
}
/////NATYWY/////
public UstawMonety(id, wartosc)
{
monety[id] = wartosc
}
public PobierzMonety(id)
return monety[id];
/////NVAULT/////
public Zapisz(id)
{
new vaultkey[64], vaultdata[256];
format(vaultkey, 63, "%s-monety", identyfikator[id]);
format(vaultdata, 255, "%d#", monety[id]);
nvault_set(vault, vaultkey, vaultdata);

return PLUGIN_CONTINUE
}
public Wczytaj(id)
{
new vaultkey[64], vaultdata[256];
format(vaultkey, 63, "%s-monety", identyfikator[id]);
format(vaultdata, 255, "%d#", monety[id]);
nvault_get(vault, vaultkey, vaultdata,255);

replace_all(vaultdata, 255, "#", " ");

new monetytemp[33];
parse(vaultdata, monetytemp, 32);

monety[id] = str_to_num(monetytemp);

return PLUGIN_CONTINUE
}
////////////////////////////////

Co zrobiłem źle?

Załączone pliki

•  qtm_codmod.sma   44,88 KB  38 Ilość pobrań
    qtm_codmod.amxx
•  systemmonet.sma   7,07 KB  36 Ilość pobrań
    systemmonet.amxx

Użytkownik Heineken edytował ten post 21.02.2013 19:33

[Heineken]

pomoze ktos?

[Heineken]

Ogarnie ktoś?

[Nemek]

Tak w ogóle po jakiego groma "scalasz" te 2 pluginy jeśli efekt będzie ten sam?

[Heineken]

Pomocy.

[Heineken]

Refffff

[Heineken]

Reffffffff

[Klakier]

Trzymaj, nawet od razu dodałem ci ilość monet w hud.

Załączone pliki

•  qtm_codmod.sma   47,99 KB  37 Ilość pobrań
    qtm_codmod.amxx

[TSUBA]

Klakierku a mógłbyś opisać kroczek po kroczku jak dodałeś? bo mi też by się to przydało ale niestety silnik zabardzo modyfikowany by go tutaj udostępniać

[Heineken]

Klakierku a mógłbyś opisać kroczek po kroczku jak dodałeś? bo mi też by się to przydało ale niestety silnik zabardzo modyfikowany by go tutaj udostępniać

Ha. Pewnie sam mógłbym zrobić co ty tam dodałeś

Też by mi się przydała mało podpowiedź jak to scaliłeś ;D

[A może sma?]

Odpowiedź na Wasze pytania to WinMergre.

[Heineken]

Coś tam w necie znalazłem ale totalnie nie wiem o co w nim chodzi
Może byłby ktoś zainteresowany zrobieniem jakiegoś poradnika na temat programu WinMergre

[TSUBA]

Ha. Pewnie sam mógłbym zrobić co ty tam dodałeś

I właśnie takiego czegoś nie nawidzę na tym forum... Człowieczku guzik mnie to interesuje czy byś to zrobił i swoje HA wsadź sobie nie powiem gdzie a jak już mamy być wścibscy to równie dobrze twój temat też mógłbym wybrechtać ale tego nie zrobię ponieważ jestem osobą tolerancyjną i dobrze wychowaną więc sobie odpuść...