Level with classes for both zombies and humans

Level with classes for both zombies and humans Apr 1, 2020 9:14:13 GMT

Quote

Post by denisu3492 on Apr 1, 2020 9:14:13 GMT

Hi guys , i need a plugin like this :

Receive exp for killing / infecting / making damage

For each level you unlock a new class of human and one of zombie

Can you help me ?

EDIT :

i have this plugin but i want it with xp like i said , not with ammo packs

SPOILER: Click to show

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

// Uncomment to have an item added to zp's extra menu
#define TRIGGER_ZP_ITEM

// Uncomment to use say commands like "xp", "levels", "class", etc
#define TRIGGER_SAYMENU

// Uncomment if you have redomin8's [ZP] Bank - With Autosave installed (fixes spending spree bug)
//#define ZP_BANK_AUTOSAVE

// Uncomment to allow experimental menu alignment
//#define ZP_ALIGN_TEXT

//Uncomment to give levels to people
#define ZP_GAMERUINER

//Uncomment to automatically bind a letter to show our menu
#define ZP_BINDMENU "j"

new sound_level_up[] = { "misc/zp_level_up_zpa.wav"}
new sound_health[] = { "items/medshot4_zpa.wav" }

/*================================================================================
End Editable Section
================================================================================*/

#if defined TRIGGER_ZP_ITEM
new g_TriggerItem
#endif
#if defined ZP_BANK_AUTOSAVE
//compatibility with zp_banks spending spree mode
native zp_bank_get_packs(id)
native zp_bank_set_packs(id, value)
#endif

// Plugin info
static const PLUGIN_NAME[] = "ZP XP FREAKZ"
static const PLUGIN_VERSION[] = "1.8"

// Forwards for our zombie plugins
new g_fwRoundStart, g_fwDummyResult

// nVault parameters
new gvault;
#define VAULT_HCLASS 1
#define VAULT_ZCLASS 2

// Internal variables
enum pcvar
{
enable = 0,
packslevelup //(current level) * packslevelup = price to level up
}

new pcvars[pcvar];
new userLevel[33], userAuthID[33][32], userNeededPacks[33] , userName[33][32]
new g_modname[32] // for formating the mod name
new g_maxplayers // max players counter
new g_logfile[64] 

/*================================================================================
Required Code from zombie_plague (modified to suite the plugin)
================================================================================*/

const MAX_CLASSSES = 40

// Note: keep g_zclass_name and g_hclass_name the same array size!
// Zombie Classes vars
new g_zclass_name[MAX_CLASSSES][32] // name
new g_zclass_info[MAX_CLASSSES][32] // description
new g_zclass_model[MAX_CLASSSES][32] // player model
new g_zclass_clawmodel[MAX_CLASSSES][32] // claw model
new g_zclass_hp[MAX_CLASSSES] // health
new g_zclass_spd[MAX_CLASSSES] // speed
new g_zclass_lvl[MAX_CLASSSES] // level
new Float:g_zclass_grav[MAX_CLASSSES] // gravity
new Float:g_zclass_kb[MAX_CLASSSES] // knockback
new g_zclass_load[MAX_CLASSSES][40] // loading identifier
new g_zclass_i // loaded zombie classes counter

// Human Classes vars
new g_hclass_name[MAX_CLASSSES][32] // name
new g_hclass_info[MAX_CLASSSES][32] // description
new g_hclass_model[MAX_CLASSSES][32] // player model
new g_hclass_weapons[MAX_CLASSSES][32] // claw model
new g_hclass_hp[MAX_CLASSSES] // health
new g_hclass_spd[MAX_CLASSSES] // speed
new g_hclass_lvl[MAX_CLASSSES] // level
new Float:g_hclass_grav[MAX_CLASSSES] // gravity
new g_hclass_load[MAX_CLASSSES][40] // loading identifier
new g_hclass_i // loaded zombie classes counter

// For menu handlers
#define ZCLASSES_STARTID g_menu_data[id][0]
#define ZCLASSES_SELECTION (g_menu_data[id][0]+key)
#define HCLASSES_STARTID g_menu_data[id][1]
#define HCLASSES_SELECTION (g_menu_data[id][1]+key)
new g_menu_data[33][8] // data for various menus
const MENU_KEY_BACK = 7
const MENU_KEY_NEXT = 8
const MENU_KEY_EXIT = 9
const KEYSMENU = (1<<0)|(1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5)|(1<<6)|(1<<7)|(1<<8)|(1<<9)

// Cvars
new cvar_welcomemsg, cvar_removeweapons, cvar_removexp, cvar_removezombie;

// Vars
new g_zombieclassnext[33] // zombie class for next infection
new g_humanclassnext[33] // zombie class for next infection
new g_zombieclass[33] // zombie class
new g_humanclass[33] // zombie class
new g_resetparams[33] // reset params?
new bool:g_hclass_showmenu[33]
new bool:g_zclass_showmenu[33]

const OFFSET_CSTEAMS = 114
const OFFSET_LINUX = 5 // offsets 5 higher in Linux builds
enum
{
CS_TEAM_UNASSIGNED = 0,
CS_TEAM_T,
CS_TEAM_CT,
CS_TEAM_SPECTATOR
}
new g_freezetime; // whether it's freeze time
new bool:g_human[33]; // is zombie
new bool:loadedZombies //bugfix for cvar_removezombies being enabled after it was disabled first (and no zombies loaded)
/* --- FOR OUR HUD --- */
// Tasks for events
enum (+= 100)
{
TASK_SHOWHUD
}

// IDs inside tasks
#define ID_SHOWHUD (taskid - TASK_SHOWHUD)

// Message sync object
//new g_MsgSync2

// Message IDs vars
new g_msgSayText

// Constants
const PEV_SPEC_TARGET = pev_iuser2
new const textHeader[] = "[ZPXP]"
new const textHeaderOrig[] = "[ZP]" //imitate Zombie Plague alerts

// HUD messages
const Float:HUD_EVENT_X = -1.0
const Float:HUD_EVENT_Y = 0.17
const Float:HUD_INFECT_X = 0.05
const Float:HUD_INFECT_Y = 0.45
const Float:HUD_SPECT_X = 0.6
const Float:HUD_SPECT_Y = 0.85
const Float:HUD_STATS_X = 1.005 //changed to right align
const Float:HUD_STATS_Y = 0.9

/*================================================================================
Constants JUST for giving guns
================================================================================*/

// CS Offsets
#if cellbits == 32
const OFFSET_CSTEAMS = 114
const OFFSET_CSMONEY = 115
const OFFSET_NVGOGGLES = 129
const OFFSET_ZOOMTYPE = 363
const OFFSET_CSDEATHS = 444
const OFFSET_AWM_AMMO = 377
const OFFSET_SCOUT_AMMO = 378
const OFFSET_PARA_AMMO = 379
const OFFSET_FAMAS_AMMO = 380
const OFFSET_M3_AMMO = 381
const OFFSET_USP_AMMO = 382
const OFFSET_FIVESEVEN_AMMO = 383
const OFFSET_DEAGLE_AMMO = 384
const OFFSET_P228_AMMO = 385
const OFFSET_GLOCK_AMMO = 386
const OFFSET_FLASH_AMMO = 387
const OFFSET_HE_AMMO = 388
const OFFSET_SMOKE_AMMO = 389
const OFFSET_C4_AMMO = 390
const OFFSET_CLIPAMMO = 51
#else
const OFFSET_CSTEAMS = 139
const OFFSET_CSMONEY = 140
const OFFSET_NVGOGGLES = 155
const OFFSET_ZOOMTYPE = 402
const OFFSET_CSDEATHS = 493
const OFFSET_AWM_AMMO = 426
const OFFSET_SCOUT_AMMO = 427
const OFFSET_PARA_AMMO = 428
const OFFSET_FAMAS_AMMO = 429
const OFFSET_M3_AMMO = 430
const OFFSET_USP_AMMO = 431
const OFFSET_FIVESEVEN_AMMO = 432
const OFFSET_DEAGLE_AMMO = 433
const OFFSET_P228_AMMO = 434
const OFFSET_GLOCK_AMMO = 435
const OFFSET_FLASH_AMMO = 46
const OFFSET_HE_AMMO = 437
const OFFSET_SMOKE_AMMO = 438
const OFFSET_C4_AMMO = 439
const OFFSET_CLIPAMMO = 65
#endif

// Buy Menu: Primary and Secondary Weapons
new const g_primary_items[][] = { "weapon_galil", "weapon_famas", "weapon_m4a1", "weapon_ak47", "weapon_sg552", "weapon_aug", "weapon_scout",
"weapon_m3", "weapon_xm1014", "weapon_tmp", "weapon_mac10", "weapon_ump45", "weapon_mp5navy", "weapon_p90" }
new const g_secondary_items[][] = { "weapon_glock18", "weapon_usp", "weapon_p228", "weapon_deagle", "weapon_fiveseven", "weapon_elite" }


// Max BP ammo for weapons
new const MAXBPAMMO[] = { -1, 52, -1, 90, 1, 32, 32, 100, 90, 1, 120, 100, 100, 90, 90, 90, 100, 120,
30, 120, 200, 32, 90, 120, 90, 2, 35, 90, 90, -1, 100 }

// Additional Items to give after buying all weapons (e.g. grenades)
new const g_additional_items[][] = { "weapon_hegrenade", "weapon_flashbang", "weapon_smokegrenade" }

// Weapon bitsums
const PRIMARY_WEAPONS_BIT_SUM = (1<<CSW_SCOUT)|(1<<CSW_XM1014)|(1<<CSW_MAC10)|(1<<CSW_AUG)|(1<<CSW_UMP45)|(1<<CSW_SG550)|(1<<CSW_GALIL)|(1<<CSW_FAMAS)|(1<<CSW_AWP)|(1<<CSW_MP5NAVY)|(1<<CSW_M249)|(1<<CSW_M3)|(1<<CSW_M4A1)|(1<<CSW_TMP)|(1<<CSW_G3SG1)|(1<<CSW_SG552)|(1<<CSW_AK47)|(1<<CSW_P90)
const SECONDARY_WEAPONS_BIT_SUM = (1<<CSW_P228)|(1<<CSW_ELITE)|(1<<CSW_FIVESEVEN)|(1<<CSW_USP)|(1<<CSW_GLOCK18)|(1<<CSW_DEAGLE)

const PEV_ADDITIONAL_AMMO = pev_iuser1

/*================================================================================
The code starts here
================================================================================*/

public plugin_precache()
{
// Register all our cvars
cvar_welcomemsg = register_cvar("zp_xp_bunvenit", "1");
cvar_removeweapons = register_cvar("zp_xp_scoaterearme", "1");
cvar_removexp = register_cvar("zp_xp_scoarerelevel", "0");
cvar_removezombie = register_cvar("zp_xp_scoaterezomii", "0");
precache_sound( sound_level_up )
precache_sound( sound_health )
}

public plugin_init()
{
// Register the plugin
register_plugin(PLUGIN_NAME, PLUGIN_VERSION, "Huh?")

// Language files
register_dictionary("zombie_xp.txt")

// Register the menus
register_menu("Game Menu", KEYSMENU, "menu_game")
register_menu("Zombie Class Menu", KEYSMENU, "menu_zclass")
register_menu("Human Class Menu", KEYSMENU, "menu_hclass")

// For setting human's skills
register_forward(FM_PlayerPreThink, "fw_PlayerPreThink")

// For setting the user human on connecting
RegisterHam(Ham_Spawn, "player", "fw_PlayerSpawn_Post", 1)

// For setting humans speed also
register_logevent("logevent_round_start",2, "1=Round_Start")

// Register event round start for humans
register_event("HLTV", "event_round_start", "a", "1=0", "2=0");

// Register forward for our plugins
g_fwRoundStart = CreateMultiForward("zp_round_started_human", ET_IGNORE, FP_CELL)

// Set our vars to disable zombie plague functions
set_task(1.0, "set_cvars")

// Register variables
pcvars[enable] = register_cvar("zp_xp_enablemihai", "1")
pcvars[packslevelup] = 100

// Register client commands
register_clcmd("zp_xp_costzp", "SetPacksLevelUp", ADMIN_MENU, "")
register_clcmd("zp2_setlevelzp", "SetLevel", ADMIN_MENU, "<NUME> <NIVEL>")
register_clcmd("zp_xp_stergxp", "RemoveXP", ADMIN_MENU, "<NUME> <NIVEL>")
register_clcmd("zp_xp_stergzombie", "RemoveZombies", ADMIN_MENU, "")
register_clcmd("zp_xp_stergarme", "RemoveWeapons", ADMIN_MENU, "")

//trigger for handling the menu
#if defined TRIGGER_ZP_ITEM
g_TriggerItem = zp_register_extra_item("Zombie XP Menu", 0, 0)
#endif
#if defined TRIGGER_SAYMENU
register_clcmd("say xp", "handle_say_xp")
register_clcmd("say level", "handle_say_level")
register_clcmd("say class", "handle_say_class")
register_clcmd("say xpmenu", "handle_say_xpmenu")
#endif

//Settings variables
g_msgSayText = get_user_msgid("SayText")

// Format mod name
formatex(g_modname, sizeof g_modname - 1, "ZP FREAKZ || ZOMBIE XP %s", PLUGIN_VERSION)

get_time ( "addons/amxmodx/logs/credite_nivel/nivel_%Y%m%d.log", g_logfile, charsmax ( g_logfile ) )

// Get Max Players
g_maxplayers = get_maxplayers()

//nVault
gvault = nvault_open(PLUGIN_NAME);

//for our HUD (shows level on screen)
//g_MsgSync2 = CreateHudSyncObj()
}

public set_cvars()
{
// Disable zombie_plague's zombie auto menu
if( get_pcvar_num(cvar_removezombie) == 0) set_cvar_num("zp_zombie_classes", 0);
if( get_pcvar_num(cvar_removeweapons) == 0) set_cvar_num("zp_buy_custom", 0);
}

public plugin_natives()
{
//natives
register_native("zpxp_register_extra_item", "native_register_extra_item", 1)
register_native("zpxp_register_human_class", "native_register_human_class", 1)
register_native("zpxp_register_zombie_class", "native_register_zombie_class", 1)
register_native("zp_get_user_human_class", "native_get_user_human_class", 1)
register_native("zp_set_level","native_level",1)
register_native("zp_get_level","native_get_lvl",1)
}
public native_level(id,amount)
{
userLevel[id] = amount;
}
public native_get_lvl(id)
{
return userLevel[id];
}
public plugin_end()
{
if( get_pcvar_num(cvar_removexp) == 0)
{
// Save everyone's data first
server_print("%s Saving your clients XP.", textHeader);

for( new o = 1; o < 33; o++)
{
//if ( !is_user_connected(o) || is_user_bot(o) ) continue;
if ( !is_user_connected(o) ) continue;
if ( is_user_bot(o) ) continue;

save_data(o);
}
}

nvault_close(gvault)

//Bugfix:
if( (loadedZombies == false) && ( get_pcvar_num(cvar_removezombie) == 0 ))
{
set_pcvar_num(cvar_removezombie, 0);
set_cvar_num("zp_zombie_classes", 0)
}
}

#if defined TRIGGER_SAYMENU
public handle_say_xp(id)
{

#if defined ZP_BINDMENU
new strLetter[2];
copy(strLetter, sizeof strLetter - 1, ZP_BINDMENU);
strtoupper(strLetter);
strtoupper(ZP_BINDMENU);

zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "SAY_INFO_KEY", strLetter)
#else
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "SAY_INFO")
#endif
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "SAY_XP", pcvars[packslevelup] * userLevel[id], userLevel[id])
return PLUGIN_HANDLED
}
public handle_say_level(id)
{
//return level
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "SAY_LEVEL", userLevel[id])
return PLUGIN_HANDLED
}
public handle_say_class(id)
{
//return class
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "SAY_CLASS", g_hclass_name[g_humanclass[id]], g_zclass_name[g_zombieclass[id]])
return PLUGIN_HANDLED
}
public handle_say_xpmenu(id)
{
show_menu_game(id);
return PLUGIN_HANDLED
}
#endif

#if defined TRIGGER_ZP_ITEM
public zp_extra_item_selected(player, itemid)
{
if(itemid == g_TriggerItem)
{
//show the menu
show_menu_game(player);
}
}
#endif

#if defined ZP_BANK_AUTOSAVE
public getAmmoPacks(id)
{
return zp_bank_get_packs(id);
}
public setAmmoPacks(id, value)
{
return zp_bank_set_packs(id, value);
}
#else
public getAmmoPacks(id)
{
return zp_get_user_ammo_packs(id);
}
public setAmmoPacks(id, value)
{
return zp_set_user_ammo_packs(id, value);
}
#endif


public SetLevel(id, level, cid) { 

if (!cmd_access(id, level, cid, 2)) 
return PLUGIN_HANDLED; 

new arg[32] 
read_argv(1, arg, 31) 

new player = cmd_target(id, arg, CMDTARGET_ALLOW_SELF) 
    
if (!player) 
return PLUGIN_HANDLED 

new spower[32], name2[32], name[32] 

get_user_name(id, name, 31) 
get_user_name(player, name2, 31) 

read_argv(2, spower, 31) 
    
new arg2 = str_to_num(spower) 
    
if(arg2 <= 0) 
{ 
client_print(id, print_console, "[zp.freakz.ro] Nu poti sa setezi mai putin de Nivelul 1."); 
ColorChat(id, RED, "^4[zp.freakz.ro] ^3Nu poti sa setezi mai putin de^4 Nivelul 1^3.") 
return PLUGIN_HANDLED; 
} 
if(arg2 > g_hclass_i) 
{ 
client_print(id, print_console, "[zp.freakz.ro] Nu poti sa setezi un Nivel mai mare de %d.", g_hclass_i); 
ColorChat(id, RED, "^4[zp.freakz.ro] ^3Nu poti sa setezi un^4 Nivel^3 mai mare de^4 %d^3.", g_hclass_i) 
return PLUGIN_HANDLED; 
} 
if(id == player) 
{ 
userLevel[id] = arg2; 

client_print(id, print_console,"[zp.freakz.ro] Ti-ai setat Nivelul actual pe %d.", arg2); 
ColorChat(id, RED, "^4[zp.freakz.ro] ^3Ti-ai setat ^4Nivelul actual ^3pe ^4%d^3.", arg2); 

g_humanclassnext[id] = userLevel[id]-1; 
g_humanclass[id] = g_humanclassnext[id]; 
g_zombieclassnext[id] = userLevel[id]-1; 

setHumanParameters(id) 

save_data(id) 
} 
else 
{ 
userLevel[player] = arg2; 

client_print(id, print_console,"[zp.freakz.ro] I-ai schimbat cu succes Nivelul lui %s.", name2); 
ColorChat(id, RED, "^4[zp.freakz.ro] ^3I-ai setat ^4Nivelul %d ^3lui ^4%s^3.", arg2, name2); 
ColorChat(player, RED, "^4[zp.freakz.ro] ^3Adminul ^4%s ^3ti-a setat ^4Nivelul %d^3.", name, arg2); 

g_humanclassnext[player] = userLevel[player]-1; 
g_humanclass[player] = g_humanclassnext[player]; 
g_zombieclassnext[player] = userLevel[player]-1; 

setHumanParameters(id) 

save_data(player) 
} 
return PLUGIN_HANDLED; 
}

public getNeededPacks(id)
{
switch(userLevel[id])
{
//case 1 : return 50
case 2 : return 100
case 3 : return 200
case 4 : return 450
case 5 : return 1000
case 6 : return 1800
case 7 : return 3600
case 8 : return 6800
case 9 : return 12000
case 10: return 25000
case 11: return 45000
case 12: return 69000
case 13: return 99500
case 14: return 126800
case 15: return 197800
case 16: return 298800
case 17: return 358800
case 18: return 459800
case 19: return 698800
case 20: return 996900
case 21: return 1897900
case 22: return 2160000 
case 23: return 2500000
case 24: return 2700000 // Nivel Maxim
}
return pcvars[packslevelup] * userLevel[id]
}

public SetPacksLevelUp(id, value)
{
//this allows the user to change the multiplier for ammo cost
new arg[10], arg2
read_argv(1, arg, sizeof arg - 1)

arg2 = str_to_num(arg)
if(arg2 > 0)
{
client_print(id, print_console, "%s %L", textHeader, id, "ADMIN_CONFIRM")
pcvars[packslevelup] = arg2;

//go through each player and change the amount required to level up
for( new o = 1; o < 33; o++)
{
if ( !is_user_connected(o) ) continue;
userNeededPacks[id] = getNeededPacks(id)
}
} else {
//must be a positive number - PRINTS TO CONSOLE, LEAVE ALONE!
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ERR_NEGATIVE");
client_print(id, print_console, "%s %L", textHeader, id, "ERR_NEGATIVE")
}

return PLUGIN_HANDLED;
}


//-----------------------CVAR Handlers--------------------------

public RemoveXP(id)
{
//this allows the user to enable or disable XP
new arg[10], arg2
read_argv(1, arg, sizeof arg - 1)

arg2 = str_to_num(arg)
if(arg2 >= 0)
{
if(arg2 == 1) {
// Disable the XP
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ADMIN_CONFIRM");
client_print(id, print_console, "%s %L", textHeader, id, "ADMIN_CONFIRM")
set_pcvar_num(cvar_removexp, arg2);

} else if (arg2 == 0) {
// Enable the XP
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ADMIN_CONFIRM");
client_print(id, print_console, "%s %L", textHeader, id, "ADMIN_CONFIRM")
set_pcvar_num(cvar_removexp, arg2);

} else {
// They typed something wrong
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ERR_INVALIDENTRY");
client_print(id, print_console, "%s %L", textHeader, id, "ERR_INVALIDENTRY");
return PLUGIN_HANDLED;
}
} else {
//must be a positive number - PRINTS TO CONSOLE, LEAVE ALONE!
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ERR_NEGATIVE");
client_print(id, print_console, "%s %L", textHeader, id, "ERR_NEGATIVE")
}

return PLUGIN_HANDLED;

}

public RemoveZombies(id)
{
//this allows the user to enable or disable zombie classes
new arg[10], arg2
read_argv(1, arg, sizeof arg - 1)

arg2 = str_to_num(arg)
if(arg2 >= 0)
{
if (arg2 == 0) {
// Enable the zombie classes

if( loadedZombies == true )
{
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ADMIN_CONFIRM");
client_print(id, print_console, "%s %L", textHeader, id, "ADMIN_CONFIRM")
set_pcvar_num(cvar_removezombie, 0);
set_cvar_num("zp_zombie_classes", 0)
} else {
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ADMIN_CONFIRM_NEXTROUND");
client_print(id, print_console, "%s %L", textHeader, id, "ADMIN_CONFIRM_NEXTROUND")
//set_pcvar_num(cvar_removezombie, 0);
//set_cvar_num("zp_zombie_classes", 0)
}
} else if (arg2 == 1) {
// Disable the zombie classes
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ADMIN_CONFIRM");
client_print(id, print_console, "%s %L", textHeader, id, "ADMIN_CONFIRM")
set_pcvar_num(cvar_removezombie, 1);
set_cvar_num("zp_zombie_classes", 1)

} else if (arg2 == 2) {
// Disable, and dont add zombies to zombie plague
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ADMIN_CONFIRM_NEXTROUND");
client_print(id, print_console, "%s %L", textHeader, id, "ADMIN_CONFIRM_NEXTROUND")
set_pcvar_num(cvar_removezombie, 1);
set_cvar_num("zp_zombie_classes", 2)

} else {
// They typed something wrong
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ERR_INVALIDENTRY");
client_print(id, print_console, "%s %L", textHeader, id, "ERR_INVALIDENTRY");
return PLUGIN_HANDLED;

}
} else {
//must be a positive number - PRINTS TO CONSOLE, LEAVE ALONE!
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ERR_NEGATIVE");
client_print(id, print_console, "%s %L", textHeader, id, "ERR_NEGATIVE")
}

return PLUGIN_HANDLED;

}

public RemoveWeapons(id)
{
//this allows the user to enable or disable zombie classes
new arg[10], arg2
read_argv(1, arg, sizeof arg - 1)

arg2 = str_to_num(arg)
if(arg2 >= 0)
{
if(arg2 == 1) {
// Disable the custom human weapons
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ADMIN_CONFIRM");
client_print(id, print_console, "%s %L", textHeader, id, "ADMIN_CONFIRM")
set_pcvar_num(cvar_removeweapons, 1);
set_cvar_num("zp_buy_custom", 1);

} else if (arg2 == 0) {
// Enable the custom human weapons
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ADMIN_CONFIRM");
client_print(id, print_console, "%s %L", textHeader, id, "ADMIN_CONFIRM")
set_pcvar_num(cvar_removeweapons, 0);
set_cvar_num("zp_buy_custom", 0);

} else {
// They typed something wrong
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ERR_INVALIDENTRY");
client_print(id, print_console, "%s %L", textHeader, id, "ERR_INVALIDENTRY");
return PLUGIN_HANDLED;
}
} else {
//must be a positive number - PRINTS TO CONSOLE, LEAVE ALONE!
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ERR_NEGATIVE");
client_print(id, print_console, "%s %L", textHeader, id, "ERR_NEGATIVE")
}

return PLUGIN_HANDLED;

}

public show_menu_game(id)
{
// Show our menu
static menu[250], len, index;
len = 0
index = 1;

// Title
len += formatex(menu[len], sizeof menu - 1 - len, "\y%s^n^n", g_modname)

if( get_pcvar_num(cvar_removexp) == 0 )
{
// 1. Buy a level up
if(getAmmoPacks(id) >= getNeededPacks(id))
{
len += formatex(menu[len], sizeof menu - 1 - len, "\r%d.\w %L", index, id, "MENU_BUY_XP")
len += formatex(menu[len], sizeof menu - 1 - len, " \y%d %L^n", getNeededPacks(id), id, "AMMO_PACKS_XP")
} else {
len += formatex(menu[len], sizeof menu - 1 - len, "\d%d. %L", index, id, "MENU_BUY_XP")
len += formatex(menu[len], sizeof menu - 1 - len, " \d%d %L^n", getNeededPacks(id), id, "AMMO_PACKS_XP")
}

index++;
}

//Human class
len += formatex(menu[len], sizeof menu - 1 - len, "\r%d.\w %L^n", index, id,"MENU_HCLASS")

if (get_pcvar_num(cvar_removezombie) == 0)
{
//Zombie class
index++;
len += formatex(menu[len], sizeof menu - 1 - len, "\r%d.\w %L^n", index, id,"MENU_ZCLASS")
}

// 0. Exit
len += formatex(menu[len], sizeof menu - 1 - len, "^n^n\r0.\w %L", id, "MENU_EXIT")

show_menu(id, KEYSMENU, menu, -1, "Game Menu")
}

public log_in_player(id)
{
new szSteam[ 36 ], szText[ 164 ];	
get_user_name( id, szSteam, charsmax( szSteam ) );
formatex( szText, charsmax( szText ),"[IN] %s (%i) a intrat avand %i credite si level %i", szSteam, id, zp_get_user_ammo_packs(id), userLevel[id] );
log_to_file( g_logfile, szText );
}

public save_data(id)
{
new vaultkey[40],vaultData[256];

new g_selected_zclass[sizeof g_zclass_load[]] , g_selected_hclass[sizeof g_hclass_load[]] //bug fix for not showing menu if the user hasnt picked a zombie
if( g_hclass_showmenu[id] == true) { g_selected_hclass = "-1"; } else { formatex(g_selected_hclass, sizeof g_selected_hclass - 1, g_hclass_load[g_humanclassnext[id]]); }
if( g_zclass_showmenu[id] == true) { g_selected_zclass = "-1"; } else { formatex(g_selected_zclass, sizeof g_selected_zclass -1, g_zclass_load[g_zombieclassnext[id]]); }

formatex( vaultkey, sizeof vaultkey - 1, "%s_stats", userAuthID[id]);
formatex( vaultData, sizeof vaultData - 1, ";1=%s;2=%s;", g_selected_hclass, g_selected_zclass);

nvault_set(gvault, vaultkey, vaultData);

new szSteam[ 36 ], szText[ 164 ];	
get_user_name( id, szSteam, charsmax( szSteam ) );
formatex( szText, charsmax( szText ),"[OUT] %s (%i) a iesit avand %i credite si lvl %i", szSteam, id, zp_get_user_ammo_packs(id), userLevel[id] );
log_to_file( g_logfile, szText );
}

public load_data(id)
{
if( get_pcvar_num(cvar_removexp) != 0)
{
// Do not load or save data
g_hclass_showmenu[id] = true;
g_zclass_showmenu[id] = true;
return;
}

new vaultkey[40], vaultReturn[256];
new vaultData[4][40], vaultResults[3][40];

// Get the Level
format(vaultkey, sizeof vaultkey - 1, "%s_stats", userAuthID[id]);
nvault_get(gvault, vaultkey, vaultReturn, sizeof vaultReturn - 1);

new Count = ExplodeString(vaultData, sizeof vaultData - 1, sizeof vaultData[] - 1, vaultReturn, ';')

if(Count == sizeof vaultResults - 1)
{
new i_hclass_id = -1, i_zclass_id = -1;

for( new i = 0; i < sizeof vaultData - 1; i++)
{
ExplodeString(vaultResults, sizeof vaultResults - 1, sizeof vaultResults[] - 1, vaultData[i], '=');

// We now have our items
switch (str_to_num(vaultResults[0]))
{

case VAULT_HCLASS:
{
// Look for our human class
if( !equali(vaultResults[1], "-1") )
{
for (new i2 = 0; i2 < g_hclass_i; i2++)
{
if( equali(vaultResults[1], g_hclass_load[i2]) )
{
i_hclass_id = i2;
break;
}
}
}

if ( i_hclass_id == -1)
{
// Couldnt find them
g_hclass_showmenu[id] = true;
} else {
// We found their zombie class
g_humanclassnext[id] = i_hclass_id;
g_hclass_showmenu[id] = false;
}
}

case VAULT_ZCLASS:
{
if( !equali(vaultResults[1], "-1") )
{
for (new i2 = 0; i2 < g_zclass_i; i2++)
{
if( equali(vaultResults[1], g_zclass_load[i2]) )
{
i_zclass_id = i2;
break;
}
}
}

if ( i_zclass_id == -1)
{
g_zclass_showmenu[id] = true;
} else {
g_zombieclassnext[id] = i_zclass_id;
g_zclass_showmenu[id] = false;
zp_set_user_zombie_class(id, i_zclass_id);
}
}
}
}
} else {
g_hclass_showmenu[id] = true;
g_zclass_showmenu[id] = true;

}

new szSteam[ 36 ], szText[ 164 ];	
get_user_name( id, szSteam, charsmax( szSteam ) );
formatex( szText, charsmax( szText ),"[INGAME] %s (%i) a salvat in timpul jocului %i credite si level %i", szSteam, id, zp_get_user_ammo_packs(id), userLevel[id] );
log_to_file( g_logfile, szText );

}

public client_connect(id)
{
// Do we bind a key
#if defined ZP_BINDMENU
client_cmd(id,"bind %s ^"say xpmenu^"", ZP_BINDMENU);
#endif
}
public client_putinserver(id)
{
// Reset vars
resetvars(id)

// Make sure zombieplague doesnt load the last plugin as the default zombie
zp_set_user_zombie_class(id, 0)

// Load their data
load_data(id);

// Set amount of levels to level up (called after load_data)
userNeededPacks[id] = getNeededPacks(id)
get_user_name(id, userName[id], 31)

// Set the custom HUD display task
set_task(1.0, "ShowHUD", id+TASK_SHOWHUD, _, _, "b")
set_task(5.0, "log_in_player", id)
}

public client_disconnect(id)
{
// Save the data
save_data(id);

// Remove tasks
remove_task(id+TASK_SHOWHUD)
}

public fw_PlayerSpawn_Post(id)
{
// Both humans and zombies spawn and call this
// Zombies can respawn if deathmatch is enabled

//TODO: Check if this works
if (zp_get_user_zombie(id))
return FMRES_IGNORED;

if (!is_user_alive(id)) // you could also use is_user_connected()
return FMRES_IGNORED;

// Set selected human and zombie class
g_humanclass[id] = g_humanclassnext[id]
g_zombieclass[id] = g_zombieclassnext[id]

// Change the default human variables
humanme(id)

// We know for sure they are a human, only give guns+speed+grav if they've picked a class
//if (( g_hclass_showmenu[id] == false ) /*(get_pcvar_num(cvar_removeweapons) == 0)*/)
//{
setHumanParameters(id)
//giveWeapons(id) //give weapons
//}

return FMRES_IGNORED;
}

public event_round_start()
{
static team;

// Set our humans hp, speed, etc
for( new o = 1; o < 33; o++)
{
// Not connected
if ( !is_user_connected(o) ) continue;

// Not playing
team = fm_get_user_team(o)
if (team == CS_TEAM_SPECTATOR || team == CS_TEAM_UNASSIGNED) continue;

// Set our human vars
//humanme(o)

// Our next vars are now current
//g_humanclass[o] = g_humanclassnext[o]
//g_zombieclass[o] = g_zombieclassnext[o]

// The round has started
ExecuteForward(g_fwRoundStart, g_fwDummyResult, o);
}

// Set our vars
g_freezetime = true

// Do we show a welcome message?
if( get_pcvar_num(cvar_welcomemsg) )
set_task(2.0, "welcome_msg")
}

public zp_user_infected_pre(id, infector)
{
// Make sure he is not a human
g_human[id] = false

// Strip his guns (so they dont fall on the floor)
strip_weapons(id);
}

public zp_user_infected_post(id, infector)
{
// Do we show the menu?
if ((g_zclass_showmenu[id] == true) && get_pcvar_num(cvar_removezombie) ==0) show_menu_zclass(id);

}

public zp_user_humanized_pre(id)
{
// Set selected human class, incase he buys antidote
g_humanclass[id] = g_humanclassnext[id];
g_zombieclass[id] = g_zombieclassnext[id];
}

public zp_user_humanized_post(id)
{
// Hes become human again, set our vars
if( !zp_get_user_survivor(id) )
{
humanme(id)
setHumanParameters(id)
if( get_pcvar_num(cvar_removeweapons) == 0) giveWeapons(id) //give weapons
} else {
// He has become a survivor
g_human[id] = false
}

ShowHUD(id)
}




enum
{
WEAPON_GALIL = 0,
WEAPON_FAMAS,
WEAPON_M4A1,
}

public humanme(id)
{
// Set our human's height, jump, etc

if( g_hclass_showmenu[id] == true)
{
// They just entered, and no data was loaded for them
// Show the menu (despite the fact that they are automatically lvl. 1)
if (get_pcvar_num(cvar_removezombie) == 0)
{ set_task(0.1, "show_menu_hclass", id); } else { set_task(0.5, "show_menu_hclass", id); }
}

// They are human
g_human[id] = true;
}

public giveWeapons(id)
{
// Strip weapons first
strip_weapons(id);

// Give all weapons (everything is in g_hclass_weapons)
static i, weaponid;
for (i = 0; i < sizeof g_hclass_weapons; i++)
{
weaponid = g_hclass_weapons[g_humanclass[id]][i];

if (weaponid >= 1 && weaponid <= 14) {
// Give main weapon
give_primary_weapon(id, weaponid - 1);

} else if ( weaponid >= 15 && weaponid <= 20) {
// Give secondary gun
give_secondary_weapon(id, weaponid - 15);

} else if ( weaponid >= 21 && weaponid <=23) {
// Give grenades
fm_give_item(id, g_additional_items[weaponid - 21]);

} else {
// We have given them all their item, or they dont have any
return;
}
}
}

public setHumanParameters(id)
{
set_pev(id, pev_gravity, g_hclass_grav[g_humanclass[id]])
fm_set_user_health(id, g_hclass_hp[g_humanclass[id]])
}

public resetvars(id)
{
// This should only be called whenever a person connects!
// Otherwise it erases a persons choices
// Reset our human's variables
g_zombieclassnext[id] = 0;
g_humanclassnext[id] = 0;
g_zombieclass[id] = 0;
g_humanclass[id] = 0;

g_hclass_showmenu[id] = false;
g_zclass_showmenu[id] = false;

userLevel[id] = 1;

get_user_name(id, userAuthID[id], 31)
g_resetparams[id] = false
}

/*================================================================================
Begin Functions from the internet
================================================================================*/

//http://forums.alliedmods.net/showthread.php?p=67207#post67207
stock ExplodeString( Output[][], Max, Size, Input[], Delimiter )
{
new Idx, l = strlen(Input), Len;
do Len += (1 + copyc( Output[Idx], Size, Input[Len], Delimiter ));
while( (Len < l) && (++Idx < Max) )
return Idx;
}


/*================================================================================
Begin Code from zombie_plague (modified to suit the plugin)
================================================================================*/

// Set player's health (from fakemeta_util)
stock fm_set_user_health(id, health)
{
(health > 0) ? set_pev(id, pev_health, float(health)) : dllfunc(DLLFunc_ClientKill, id);
}


// Forward Player PreThink
public fw_PlayerPreThink(id)
{
// Not alive
if (!is_user_alive(id)) return;

// Not human, survivor will count as not a human
if(!g_human[id]) return;

// Set Player MaxSpeed
if (!g_freezetime)
{
if (g_human[id])
{
set_pev(id, pev_maxspeed, float(g_hclass_spd[g_humanclass[id]]))
return
}
}
}

public show_menu_zclass(id)
{
// Player disconnected
if (!is_user_connected(id))
return;

// Bots pick default classes
if (is_user_bot(id))
{
g_zombieclassnext[id] = 0 //basic zombie
return;
}

static menu[800], len, class, removexp;
new curClassIcon[2];

len = 0
removexp = get_pcvar_num(cvar_removexp);

// Title
len += formatex(menu[len], sizeof menu - 1 - len, "\y%L \r [%d-%d]^n^n", id, "MENU_ZCLASS_TITLE", ZCLASSES_STARTID+1, min(ZCLASSES_STARTID+7, g_zclass_i))

#if defined ZP_ALIGN_TEXT
// Align text
new spacers[400], g_zclass_spacers1, g_zclass_spacers2
new maxSpace1, maxSpace2, curSpace1[32], curSpace2[32]

// Get max width first
for (class = ZCLASSES_STARTID; class < min(ZCLASSES_STARTID+7, g_zclass_i); class++)
{
formatex(spacers, sizeof spacers - 1, "%d. %s", class-ZCLASSES_STARTID+1, g_zclass_name[class])

g_zclass_spacers1 = strlen(spacers)
g_zclass_spacers2 = strlen(g_zclass_info[class])

if(g_zclass_spacers1 > maxSpace1) maxSpace1 = g_zclass_spacers1
if(g_zclass_spacers2 > maxSpace2) maxSpace2 = g_zclass_spacers2
}

// 1-7. Class List
for (class = ZCLASSES_STARTID; class < min(ZCLASSES_STARTID+7, g_zclass_i); class++)
{
formatex(spacers, sizeof spacers - 1, "%d. %s", class-ZCLASSES_STARTID+1, g_zclass_name[class])

g_zclass_spacers1 = maxSpace1 - strlen(spacers)
g_zclass_spacers2 = maxSpace2 - strlen(g_zclass_info[class])

arrayset(curSpace1, '^0', sizeof curSpace1 - 1)
arrayset(curSpace2, '^0', sizeof curSpace2 - 1)

if(g_zclass_spacers1 != 0) arrayset(curSpace1, '^t', g_zclass_spacers1)
if(g_zclass_spacers2 != 0) arrayset(curSpace2, '^t', g_zclass_spacers2)

if (((class == g_zombieclassnext[id] && g_zclass_showmenu[id] == false) || (userLevel[id] < g_zclass_lvl[class])) && (removexp == 0))
{
if (class == g_zombieclassnext[id]) { curClassIcon = "*"; } else { curClassIcon = ""; }

len += formatex(menu[len], sizeof menu - 1 - len, "\d%s%d. %s %s %s %s %L %d^n", curClassIcon, class-ZCLASSES_STARTID+1, g_zclass_name[class], curSpace1, g_zclass_info[class], curSpace2, id, "BOTH_ATTRIB_LEVEL", g_zclass_lvl[class])
} else if (removexp == 1) {
len += formatex(menu[len], sizeof menu - 1 - len, "\r%d.\w %s\y %s %s^n", class-ZCLASSES_STARTID+1, g_zclass_name[class], curSpace1, g_zclass_info[class])
} else {
len += formatex(menu[len], sizeof menu - 1 - len, "\r%d.\w %s\y %s %s\w %s %L %d^n", class-ZCLASSES_STARTID+1, g_zclass_name[class], curSpace1, g_zclass_info[class], curSpace2, id, "BOTH_ATTRIB_LEVEL", g_zclass_lvl[class])
}
}
#else
for (class = ZCLASSES_STARTID; class < min(ZCLASSES_STARTID+7, g_zclass_i); class++)
{
if (((class == g_zombieclassnext[id] && g_zclass_showmenu[id] == false) || (userLevel[id] < g_zclass_lvl[class])) && (removexp == 0))
{
if (class == g_zombieclassnext[id]) { curClassIcon = "*"; } else { curClassIcon = ""; }

len += formatex(menu[len], sizeof menu - 1 - len, "\d%s%d. %s - %s - %L %d^n", curClassIcon, class-ZCLASSES_STARTID+1, g_zclass_name[class], g_zclass_info[class], id, "BOTH_ATTRIB_LEVEL", g_zclass_lvl[class])
} else if (removexp == 1) {
len += formatex(menu[len], sizeof menu - 1 - len, "\r%d.\w %s -\y %s^n", class-ZCLASSES_STARTID+1, g_zclass_name[class], g_zclass_info[class]);
} else {
len += formatex(menu[len], sizeof menu - 1 - len, "\r%d.\w %s -\y %s\w - %L %d^n", class-ZCLASSES_STARTID+1, g_zclass_name[class], g_zclass_info[class], id, "BOTH_ATTRIB_LEVEL", g_zclass_lvl[class]);
}
}
#endif

// 8. Back - 9. Next - 0. Exit
len += formatex(menu[len], sizeof menu - 1 - len, "^n\r8.\w %L^n\r9.\w %L^n^n\r0.\w %L", id, "MENU_BACK", id, "MENU_NEXT", id, "MENU_EXIT")

show_menu(id, KEYSMENU, menu, -1, "Zombie Class Menu")
}


public show_menu_hclass(id)
{
// Player disconnected
if (!is_user_connected(id))
return;

// Bots pick default classes
if (is_user_bot(id))
{
g_humanclassnext[id] = 0
return;
}

static menu[800], len, class, removexp
new curClassIcon[2]
len = 0
removexp = get_pcvar_num(cvar_removexp);

// Title
len += formatex(menu[len], sizeof menu - 1 - len, "\y%L \r[%d-%d]^n^n", id, "MENU_HCLASS_TITLE", HCLASSES_STARTID+1, min(HCLASSES_STARTID+7, g_hclass_i))

#if defined ZP_ALIGN_TEXT
// Align text
new spacers[400], g_hclass_spacers1, g_hclass_spacers2
new maxSpace1, maxSpace2, curSpace1[32], curSpace2[32]

// Get max width first
for (class = HCLASSES_STARTID; class < min(HCLASSES_STARTID+7, g_hclass_i); class++)
{
formatex(spacers, sizeof spacers - 1, "%d. %s", class-HCLASSES_STARTID+1, g_hclass_name[class])

g_hclass_spacers1 = strlen(spacers)
g_hclass_spacers2 = strlen(g_hclass_info[class])

if(g_hclass_spacers1 > maxSpace1) maxSpace1 = g_hclass_spacers1
if(g_hclass_spacers2 > maxSpace2) maxSpace2 = g_hclass_spacers2
}

// 1-7. Class List
for (class = HCLASSES_STARTID; class < min(HCLASSES_STARTID+7, g_hclass_i); class++)
{
formatex(spacers, sizeof spacers - 1, "%d. %s", class-HCLASSES_STARTID+1, g_hclass_name[class])

g_hclass_spacers1 = maxSpace1 - strlen(spacers)
g_hclass_spacers2 = maxSpace2 - strlen(g_hclass_info[class])

arrayset(curSpace1, '^0', sizeof curSpace1 - 1)
arrayset(curSpace2, '^0', sizeof curSpace2 - 1)

if(g_hclass_spacers1 != 0) arrayset(curSpace1, '^t', g_hclass_spacers1)
if(g_hclass_spacers2 != 0) arrayset(curSpace2, '^t', g_hclass_spacers2)

if (((class == g_humanclassnext[id] && g_hclass_showmenu[id] == false) || (userLevel[id] < g_hclass_lvl[class])) && (removexp == 0))
{
if (class == g_humanclassnext[id]) { curClassIcon = "*"; } else { curClassIcon = ""; }

len += formatex(menu[len], sizeof menu - 1 - len, "\d%s%d. %s %s %s %s %L %d^n", curClassIcon, class-HCLASSES_STARTID+1, g_hclass_name[class], curSpace1, g_hclass_info[class], curSpace2, id, "BOTH_ATTRIB_LEVEL", g_hclass_lvl[class])
} else if (removexp == 1) {
len += formatex(menu[len], sizeof menu - 1 - len, "\r%d.\w %s\y %s %s^n", class-HCLASSES_STARTID+1, g_hclass_name[class], curSpace1, g_hclass_info[class])
} else {
len += formatex(menu[len], sizeof menu - 1 - len, "\r%d.\w %s\y %s %s\w %s %L %d^n", class-HCLASSES_STARTID+1, g_hclass_name[class], curSpace1, g_hclass_info[class], curSpace2, id, "BOTH_ATTRIB_LEVEL", g_hclass_lvl[class])
}
}

#else
for (class = HCLASSES_STARTID; class < min(HCLASSES_STARTID+7, g_hclass_i); class++)
{
if (((class == g_humanclassnext[id] && g_hclass_showmenu[id] == false) || (userLevel[id] < g_hclass_lvl[class])) && (removexp == 0))
{
if (class == g_humanclassnext[id]) { curClassIcon = "*"; } else { curClassIcon = ""; }

len += formatex(menu[len], sizeof menu - 1 - len, "\d%s%d. %s - %s - %L %d^n", curClassIcon, class-HCLASSES_STARTID+1, g_hclass_name[class], g_hclass_info[class], id, "BOTH_ATTRIB_LEVEL", g_hclass_lvl[class])
} else if (removexp == 1) {
len += formatex(menu[len], sizeof menu - 1 - len, "\r%d.\w %s -\y %s^n", class-HCLASSES_STARTID+1, g_hclass_name[class], g_hclass_info[class]);
} else {
len += formatex(menu[len], sizeof menu - 1 - len, "\r%d.\w %s -\y %s\w - %L %d^n", class-HCLASSES_STARTID+1, g_hclass_name[class], g_hclass_info[class], id, "BOTH_ATTRIB_LEVEL", g_hclass_lvl[class])
}
}
#endif

// 8. Back - 9. Next - 0. Exit
len += formatex(menu[len], sizeof menu - 1 - len, "^n\r8.\w %L^n\r9.\w %L^n^n\r0.\w %L", id, "MENU_BACK", id, "MENU_NEXT", id, "MENU_EXIT")

show_menu(id, KEYSMENU, menu, -1, "Human Class Menu")
}

/* ----------------------- Menu Handlers -------------------------*/

// Game Menu
public menu_game(id, key)
{
if(get_pcvar_num(cvar_removexp) == 1) key++;

switch (key)
{
case 0: // Buy a level up
{
if(getAmmoPacks(id) >= getNeededPacks(id))
{
if(userLevel[id]<24)
{
setAmmoPacks(id, getAmmoPacks(id) - getNeededPacks(id))
userLevel[id] += 1
save_data(id)
new szSteam[ 36 ], szText[ 164 ];
get_user_name( id, szSteam, charsmax( szSteam ) );
formatex( szText, charsmax( szText ),"[NIVEL] %s a urcat la Nivel %i", szSteam, userLevel[id] );
log_to_file( g_logfile, szText );

// Inform the user they leveled up
zp_colored_print(id, "^x04%s^x01 %L %d", textHeader, id ,"MENU_BUY_LEVEL", userLevel[id])
ShowHUD(id)
zp_colored_print(0, "^x01[zp.freakz.ro] ^x04%s^x01 a Facut Nivel: Noul Lui Nivel Este: ^x04%d^x01.", userName[id], userLevel[id]);
emit_sound(id, CHAN_STREAM, sound_level_up, 1.0, ATTN_NORM, 0, PITCH_HIGH );
}
else zp_colored_print(id, "^x04%s^x01 Nivel Maxim a Fost Atins!", textHeader);
} else {
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id ,"ERR_NOTENOUGHPACKS")
}

// Return to the main xp menu
show_menu_game(id);

}

case 1: // Human Classes
{
// Restrict it here if we wanted to
show_menu_hclass(id)
}

case 2: // Zombie Classes
{
if (get_pcvar_num(cvar_removezombie) == 0)
{
// Restrict it here if we wanted to
show_menu_zclass(id)
}
}
}

return PLUGIN_HANDLED;
}

// Zombie Class Menu
public menu_zclass(id, key)
{
// Special keys / items list exceeded
if (key >= MENU_KEY_BACK || ZCLASSES_SELECTION >= g_zclass_i)
{
switch (key)
{
case MENU_KEY_BACK: // back
{
if (ZCLASSES_STARTID-7 >= 0) ZCLASSES_STARTID -= 7
}
case MENU_KEY_NEXT: // next
{
if (ZCLASSES_STARTID+7 < g_zclass_i) ZCLASSES_STARTID += 7
}
case MENU_KEY_EXIT: // exit
{
return PLUGIN_HANDLED;
}
}

// Show extra items menu again
show_menu_zclass(id)
return PLUGIN_HANDLED;
}

// They selected their own class
if (ZCLASSES_SELECTION == g_zombieclassnext[id])
{
//Plugin continues if this is false (sets class info on connect)
if( g_zclass_showmenu[id] == false) //when a client first connects, the menu shows all zombies as a choice even the one the client defaults to (index of 0)
{
// Alert them they already have chosen a zombie
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ERR_ALREADYSELECTED")
show_menu_zclass(id)

// They had already chosen this zombie, dont rerun the command
return PLUGIN_HANDLED;
}
}

if (get_pcvar_num(cvar_removexp) == 0)
{
if (g_zclass_lvl[ZCLASSES_SELECTION] > userLevel[id])
{
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ERR_NOTLEVEL")
show_menu_zclass(id)
return PLUGIN_HANDLED;
}
}

// Store selection for the next infection
g_zombieclassnext[id] = ZCLASSES_SELECTION;

// Disable showing menu since theyve chosen
g_zclass_showmenu[id] = false;

// Show selected zombie class info and stats
zp_colored_print(id, "^x04%s^x01 %L: %s", textHeader, id, "ZOMBIE_SELECT_XP", g_zclass_name[g_zombieclassnext[id]])
zp_colored_print(id, "^x04%s^x01 %L: %d %L: %d %L: %d %L: %d%%", textHeader, id, "ZOMBIE_ATTRIB1_XP", g_zclass_hp[g_zombieclassnext[id]], id, "ZOMBIE_ATTRIB2_XP", g_zclass_spd[g_zombieclassnext[id]],
id, "ZOMBIE_ATTRIB3_XP", floatround(g_zclass_grav[g_zombieclassnext[id]]*800), id, "ZOMBIE_ATTRIB4_XP", floatround(g_zclass_kb[g_zombieclassnext[id]]*100))

// Set the class for zombie plague
zp_set_user_zombie_class(id, g_zombieclassnext[id])

return PLUGIN_HANDLED;
}

// Human Class Menu
public menu_hclass(id, key)
{
// Special keys / items list exceeded
if (key >= MENU_KEY_BACK || HCLASSES_SELECTION >= g_hclass_i)
{
switch (key)
{
case MENU_KEY_BACK: // back
{
if (HCLASSES_STARTID-7 >= 0) HCLASSES_STARTID -= 7
}
case MENU_KEY_NEXT: // next
{
if (HCLASSES_STARTID+7 < g_hclass_i) HCLASSES_STARTID += 7
}
case MENU_KEY_EXIT: // exit
{
return PLUGIN_HANDLED;
}
}

// Show human list again
show_menu_hclass(id)
return PLUGIN_HANDLED;
}

if (HCLASSES_SELECTION == g_humanclassnext[id])
{
// When a client first connects, the menu shows all zombies as a choice even the one the client defaults to (index of 0)
if( g_hclass_showmenu[id] == false)
{
// Alert them they alaerdy have chosen a zombie
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ERR_ALREADYSELECTED")
show_menu_hclass(id)
return PLUGIN_HANDLED; //they had already chosen this zombie, dont rerun the command
}
}

if (get_pcvar_num(cvar_removexp) == 0)
{
if (g_hclass_lvl[HCLASSES_SELECTION] > userLevel[id])
{
zp_colored_print(id, "^x04%s^x01 %L", textHeader, id, "ERR_NOTLEVEL")
show_menu_hclass(id)
return PLUGIN_HANDLED;
}
}

// Store selection for the next infection
g_humanclassnext[id] = HCLASSES_SELECTION;

// Disable showing menu since theyve chosen
g_hclass_showmenu[id] = false;

// Show selected human class info and stats
zp_colored_print(id, "^x04%s^x01 %L: %s", textHeader, id, "HUMAN_SELECT_XP", g_hclass_name[g_humanclassnext[id]])
zp_colored_print(id, "^x04%s^x01 %L: %d %L: %d %L: %d", textHeader, id, "HUMAN_ATTRIB1_XP", g_hclass_hp[g_humanclassnext[id]], id, "HUMAN_ATTRIB2_XP", g_hclass_spd[g_humanclassnext[id]],
id, "HUMAN_ATTRIB3_XP", floatround(g_hclass_grav[g_humanclassnext[id]]*800), id)

return PLUGIN_HANDLED;
}

public ShowHUD(taskid)
{
//if (get_pcvar_num(cvar_removexp) == 1 ) return;

static id;

// Our ID
id = ID_SHOWHUD;

// Player died?
if (!is_user_alive(id))
{
// Get spectating target
id = pev(id, PEV_SPEC_TARGET) //other persons ID

// Target not alive
if (!is_user_alive(id)) return;
}

// Format the classname
static g_name[sizeof g_hclass_name]; // Hopefully g_zclass_name and g_zclass_name will be left the same array size

if ( g_human[id] == false ) // zombies
{
//red = 200
//green = 250
//blue = 0

formatex(g_name, sizeof g_name - 1, "%L", id, "HUD_ZOMBIE");
}
else // humans
{
//red = 0
//green = 0
//blue = 255

copy(g_name, sizeof g_name - 1, g_hclass_name[g_humanclass[id]]);
}

if (id != ID_SHOWHUD)
{
if (get_pcvar_num(cvar_removexp) == 0 )
{
// Set our HUD in position for spectating
//set_hudmessage(255, 255, 255, HUD_SPECT_X, HUD_SPECT_Y, 0, 6.0, 1.1, 0.0, 0.0, -1);
//ShowSyncHudMsg(ID_SHOWHUD, g_MsgSync2, "%L: %s - %L: %d", ID_SHOWHUD, "HUD_CLASS", g_name, ID_SHOWHUD, "HUD_LEVEL", userLevel[id]);
} else {
// Just show the class information
//set_hudmessage(255, 255, 255, HUD_SPECT_X, HUD_SPECT_Y, 0, 6.0, 1.1, 0.0, 0.0, -1);
//ShowSyncHudMsg(ID_SHOWHUD, g_MsgSync2, "%L: %s", ID_SHOWHUD, "HUD_CLASS", g_name);
}
} else {
if (get_pcvar_num(cvar_removexp) == 0 )
{
// Set our HUD in position for the player
//set_hudmessage(red, green, blue, HUD_STATS_X, HUD_STATS_Y, 0, 6.0, 1.1, 0.0, 0.0, -1);
//ShowSyncHudMsg(id, g_MsgSync2, "%L: %s - %L: %d^t^t^t", id, "HUD_CLASS", g_name, id, "HUD_LEVEL", userLevel[id]);
} else {
// Just show the class information
//set_hudmessage(red, green, blue, HUD_STATS_X, HUD_STATS_Y, 0, 6.0, 1.1, 0.0, 0.0, -1);
//ShowSyncHudMsg(id, g_MsgSync2, "%L: %s^t^t^t", id, "HUD_CLASS", g_name);
}
}
}

// Native: native_get_user_human_class
public native_get_user_human_class(id)
{
return g_humanclass[id];
}

// Native: zpxp_register_human_class
public native_register_human_class(const name[], const info[], const model[], const weapons[], hp, speed, Float:gravity, level)
{
// Reached human classes limit
if (g_hclass_i >= sizeof g_hclass_name)
return -1;

// Strings passed byref
param_convert(1)
param_convert(2)
param_convert(3)
param_convert(4)

// Add the class
copy(g_hclass_name[g_hclass_i], sizeof g_hclass_name[] - 1, name)
copy(g_hclass_info[g_hclass_i], sizeof g_hclass_info[] - 1, info)
copy(g_hclass_model[g_hclass_i], sizeof g_hclass_model[] - 1, model)
copy(g_hclass_weapons[g_hclass_i], sizeof g_hclass_weapons[] - 1, weapons)
g_hclass_hp[g_hclass_i] = hp
g_hclass_spd[g_hclass_i] = speed
g_hclass_grav[g_hclass_i] = gravity
g_hclass_lvl[g_hclass_i] = level


// For the load_data and save_data
new tSave[40]
formatex(tSave, sizeof tSave - 1, "%s%s", name, info);
replace_all(tSave, sizeof tSave - 1, ";", "")
replace_all(tSave, sizeof tSave - 1, " ", "")
g_hclass_load[g_hclass_i] = tSave;

// Increase registered classes counter
g_hclass_i++

// Return id under which we registered the class
return g_hclass_i-1;
}

// Native: zpxp_register_zombie_class
public native_register_zombie_class(const name[], const info[], const model[], const clawmodel[], hp, speed, Float:gravity, Float:knockback, level)
{
// Dont return -1, we wil get lots of server window print errors from the plugins
if( get_pcvar_num(cvar_removezombie) == 2) return 0;

//Bugfix for loading zombies
loadedZombies = true;

// Strings passed byref
param_convert(1)
param_convert(2)
param_convert(3)
param_convert(4)

// Save the name, level required, and classid
copy(g_zclass_name[g_zclass_i], sizeof g_zclass_name[] - 1, name)
copy(g_zclass_info[g_zclass_i], sizeof g_zclass_info[] - 1, info)
copy(g_zclass_model[g_zclass_i], sizeof g_zclass_model[] - 1, model)
copy(g_zclass_clawmodel[g_zclass_i], sizeof g_zclass_clawmodel[] - 1, clawmodel)

g_zclass_hp[g_zclass_i] = hp
g_zclass_spd[g_zclass_i] = speed
g_zclass_grav[g_zclass_i] = gravity
g_zclass_kb[g_zclass_i] = knockback
g_zclass_lvl[g_zclass_i] = level

// For the load_data and save_data
new tSave[40]
formatex(tSave, sizeof tSave - 1, "%s%s", name, info);
replace_all(tSave, sizeof tSave - 1, ";", "")
replace_all(tSave, sizeof tSave - 1, " ", "")
g_zclass_load[g_zclass_i] = tSave;

// Get the classid from zombie plague
new g_returnclass_id;
g_returnclass_id = zp_register_zombie_class(g_zclass_name[g_zclass_i], g_zclass_info[g_zclass_i], g_zclass_model[g_zclass_i], g_zclass_clawmodel[g_zclass_i], g_zclass_hp[g_zclass_i] / 2, g_zclass_spd[g_zclass_i], g_zclass_grav[g_zclass_i], g_zclass_kb[g_zclass_i]);

// Make sure there was no error
if( g_returnclass_id == -1 )
{
server_print("%s %L", textHeader, LANG_PLAYER, "ERR_BADRETURN");
return -1
}

// Increase registered classes counter
g_zclass_i++

// Return id under which we registered the class
return g_zclass_i-1;
}

public native_register_extra_item(const name[], cost, team)
{
//TO DO

}

/*================================================================================
--The following are copied directly from zombie_plague, no reinventing wheels...
[Shared Functions]
=================================================================================*/

// Welcome Message Task
public welcome_msg()
{
// Show mod info
zp_colored_print(0, "^x04%s^x01 %L", textHeaderOrig, LANG_PLAYER, "NOTICE_INFO_XP")
}

// Log Event Round Start
public logevent_round_start()
{
// Freezetime ends
g_freezetime = false
}

// Get User Team
stock fm_get_user_team(id)
{
return get_pdata_int(id, OFFSET_CSTEAMS, OFFSET_LINUX);
}

zp_colored_print(target, const message[], any:...)
{
static buffer[512], i, argscount
argscount = numargs()

// Send to everyone
if (!target)
{
static player
for (player = 1; player <= g_maxplayers; player++)
{
// Not connected
if (!is_user_connected(player))
continue;

// Remember changed arguments
static changed[5], changedcount // [5] = max LANG_PLAYER occurencies
changedcount = 0

// Replace LANG_PLAYER with player id
for (i = 2; i < argscount; i++)
{
if (getarg(i) == LANG_PLAYER)
{
setarg(i, 0, player)
changed[changedcount] = i
changedcount++
}
}

// Format message for player
vformat(buffer, sizeof buffer - 1, message, 3)

// Send it
message_begin(MSG_ONE, g_msgSayText, _, player)
write_byte(player)
write_string(buffer)
message_end()

// Replace back player id's with LANG_PLAYER
for (i = 0; i < changedcount; i++)
setarg(changed[i], 0, LANG_PLAYER)
}
}

// Send to specific target
else
{
// Replace LANG_PLAYER with player id
for (i = 2; i < argscount; i++)
{
if (getarg(i) == LANG_PLAYER)
setarg(i, 0, target)
}

// Format message for player
vformat(buffer, sizeof buffer - 1, message, 3)

// Send it
message_begin(MSG_ONE, g_msgSayText, _, target)
write_byte(target)
write_string(buffer)
message_end()
}
}

/*================================================================================
Code JUST for giving guns
================================================================================*/

// Drop primary/secondary weapons
stock drop_weapons(id, dropwhat)
{
// Get user weapons
static weapons[32], num, i, weaponid
num = 0 // reset passed weapons count (bugfix)
get_user_weapons(id, weapons, num)

// Loop through them and drop primaries or secondaries
for (i = 0; i < num; i++)
{
// Prevent re-indexing the array
weaponid = weapons[i]

if ((dropwhat == 1 && ((1<<weaponid) & PRIMARY_WEAPONS_BIT_SUM)) || (dropwhat == 2 && ((1<<weaponid) & SECONDARY_WEAPONS_BIT_SUM)))
{
// Get the weapon entity
static wname[32], weapon_ent
get_weaponname(weaponid, wname, sizeof wname - 1)
weapon_ent = fm_find_ent_by_owner(-1, wname, id);

// Hack: store weapon bpammo on PEV_ADDITIONAL_AMMO
set_pev(weapon_ent, PEV_ADDITIONAL_AMMO, fm_get_user_bpammo(id, weaponid))

// Player drops the weapon and looses his bpammo
engclient_cmd(id, "drop", wname)
fm_set_user_bpammo(id, weaponid, 0)
}
}
}

// Set User BP Ammo
stock fm_set_user_bpammo(id, weapon, amount)
{
static offset

switch(weapon)
{
case CSW_AWP: offset = OFFSET_AWM_AMMO;
case CSW_SCOUT,CSW_AK47,CSW_G3SG1: offset = OFFSET_SCOUT_AMMO;
case CSW_M249: offset = OFFSET_PARA_AMMO;
case CSW_M4A1,CSW_FAMAS,CSW_AUG,CSW_SG550,CSW_GALI,CSW_SG552: offset = OFFSET_FAMAS_AMMO;
case CSW_M3,CSW_XM1014: offset = OFFSET_M3_AMMO;
case CSW_USP,CSW_UMP45,CSW_MAC10: offset = OFFSET_USP_AMMO;
case CSW_FIVESEVEN,CSW_P90: offset = OFFSET_FIVESEVEN_AMMO;
case CSW_DEAGLE: offset = OFFSET_DEAGLE_AMMO;
case CSW_P228: offset = OFFSET_P228_AMMO;
case CSW_GLOCK18,CSW_MP5NAVY,CSW_TMP,CSW_ELITE: offset = OFFSET_GLOCK_AMMO;
case CSW_FLASHBANG: offset = OFFSET_FLASH_AMMO;
case CSW_HEGRENADE: offset = OFFSET_HE_AMMO;
case CSW_SMOKEGRENADE: offset = OFFSET_SMOKE_AMMO;
case CSW_C4: offset = OFFSET_C4_AMMO;
default: return;
}

set_pdata_int(id, offset, amount, OFFSET_LINUX)
}

// Get User BP Ammo
stock fm_get_user_bpammo(id, weapon)
{
static offset

switch(weapon)
{
case CSW_AWP: offset = OFFSET_AWM_AMMO;
case CSW_SCOUT,CSW_AK47,CSW_G3SG1: offset = OFFSET_SCOUT_AMMO;
case CSW_M249: offset = OFFSET_PARA_AMMO;
case CSW_M4A1,CSW_FAMAS,CSW_AUG,CSW_SG550,CSW_GALI,CSW_SG552: offset = OFFSET_FAMAS_AMMO;
case CSW_M3,CSW_XM1014: offset = OFFSET_M3_AMMO;
case CSW_USP,CSW_UMP45,CSW_MAC10: offset = OFFSET_USP_AMMO;
case CSW_FIVESEVEN,CSW_P90: offset = OFFSET_FIVESEVEN_AMMO;
case CSW_DEAGLE: offset = OFFSET_DEAGLE_AMMO;
case CSW_P228: offset = OFFSET_P228_AMMO;
case CSW_GLOCK18,CSW_MP5NAVY,CSW_TMP,CSW_ELITE: offset = OFFSET_GLOCK_AMMO;
case CSW_FLASHBANG: offset = OFFSET_FLASH_AMMO;
case CSW_HEGRENADE: offset = OFFSET_HE_AMMO;
case CSW_SMOKEGRENADE: offset = OFFSET_SMOKE_AMMO;
case CSW_C4: offset = OFFSET_C4_AMMO;
default: return -1;
}

return get_pdata_int(id, offset, OFFSET_LINUX);
}

// Give an item to a player (from fakemeta_util)
stock fm_give_item(id, const item[])
{
static ent
ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, item))
if (!pev_valid(ent)) return;

static Float:originF[3]
pev(id, pev_origin, originF)
set_pev(ent, pev_origin, originF)
set_pev(ent, pev_spawnflags, pev(ent, pev_spawnflags) | SF_NORESPAWN)
dllfunc(DLLFunc_Spawn, ent)

static save
save = pev(ent, pev_solid)
dllfunc(DLLFunc_Touch, ent, id)
if (pev(ent, pev_solid) != save)
return;

engfunc(EngFunc_RemoveEntity, ent)
}

// Strip user weapons (from fakemeta_util)
stock fm_strip_user_weapons(id)
{
static ent
ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "player_weaponstrip"))
if (!pev_valid(ent)) return;

dllfunc(DLLFunc_Spawn, ent)
dllfunc(DLLFunc_Use, ent, id)
engfunc(EngFunc_RemoveEntity, ent)
}


// Find entity by its owner (from fakemeta_util)
stock fm_find_ent_by_owner(entity, const classname[], owner)
{
while ((entity = engfunc(EngFunc_FindEntityByString, entity, "classname", classname)) && pev(entity, pev_owner) != owner) {}

return entity;
}

strip_weapons (id)
{
if( !get_pcvar_num(cvar_removeweapons) )
{
// Drop previous weapons
drop_weapons(id, 1)
drop_weapons(id, 2)
}

// Strip off from weapons
fm_strip_user_weapons(id)
fm_give_item(id, "weapon_knife")
}

// Buy Primary Weapon
give_primary_weapon(id, key)
{
// Get weapon index
static weaponid
weaponid = get_weaponid(g_primary_items[key])

// Give the new weapon
fm_give_item(id, g_primary_items[key])
fm_set_user_bpammo(id, weaponid, MAXBPAMMO[key])

/*
// Give additional items
static i
for (i = 0; i < sizeof g_additional_items; i++)
fm_give_item(id, g_additional_items[i])
*/
}

give_secondary_weapon(id, key)
{
// Get weapon index
static weaponid
weaponid = get_weaponid(g_secondary_items[key])

// Give the new weapon with full ammo
fm_give_item(id, g_secondary_items[key])
fm_set_user_bpammo(id, weaponid, MAXBPAMMO[weaponid])
}

also i have this one but this have only zombie classes (it has xp per kill)

SPOILER: Click to show

 /*===============================================================================
**Zombie XP system By K1llerZM**

=* Info *=
*- Add xp system (getting xp when killing zombie - infecting human )
*- Add the Abilty to register Items That will be unlocked with level ( non registred yet )
*- By dafult there 75 LEVELS
*- ITEM TEAM SUPPORT (human and zombie only)

=* Natives *=
*- zx_get_user_xp(id) 
*- zx_get_user_level(id)
*- zx_set_user_xp(id , amount)
*- zx_set_user_level(id , amount)
*- zx_get_next_class(id)
*- zx_get_current_class(id)
*- zx_get_registered_classes_count()
*- zx_set_next_class(id , const classid[])
*-  zx_register_zombie_class(const name[] , const description[] , const model[] ,const claw_model[] , health , Float:speed , Float:gravity , level)
*- zx_register_extra_item(const name[] , item_level , team)

=* Forward *=
*- zx_extra_item_selected_post(id , itemid)
*- zx_zombie_class_selected_post(id , classid)
*- zx_extra_item_selected_pre(id , itemid)

=* Commands *= 
*- say /xpmenu // show main menu

=* Updates  *=
*- v1.0 - first release , test . . .
*- v1,0a - some bugs fixed
*- v1,1 - fixed Native errors
*- v1.2 - fixed Somethings Thanks Donii
		- added cvar Creator
		- added other cvars
*- v1.3 - Fixed Native Params
		- Added support team chat
*- v1.4 - Add Zombie Classes System
*- v1.5 - Fixed Bugs According Zombie Classes System
*- v1.7 - Add Credtis
*- v1.8 - 

=*= Creditis =*=
*- DoNii - Some Fixes 	
*- Dias 'Pednragon' Leon - Some help in models
*- ZinoZack - level up sound
*- Tenebere - Test and FeedBack
*- Arion - for say commands duplicates

*- Author Notes
*- You Aren't allowed to copy/paste any code without credits

================================================================================*/
/*=============================================================================== 
START OF PLUGIN
================================================================================*/
#include <amxmodx>
#include <amxmisc>
#include <fun>
#include <nvault>
#include <hamsandwich>
#include <fakemeta>
#include <cstrike>
#include <zombieplague>
#include <cs_maxspeed_api>
#include <cs_weap_restrict_api>
#include "zx_const.cfg"
#include "zx_zombie_vars.cfg"
#include "zx_allowed_weapon.cfg"

#define PLUGIN "Zombie XP system"
#define VERSION "1.8"
#define AUTHOR "K1llerZM"

#define TEAM_ZOM (1<<0)
#define TEAM_HUM (1<<1)
#define is_user_valid(%1) (1 <= %1 <= g_MaxPlayers)
#define TASK_HUD_REMOVE 100

native cs_set_player_view_model(id, weaponid, const view_model[])
native cs_reset_player_view_model(id, weaponid)
native cs_set_player_weap_model(id, weaponid, const weapon_model[])
native cs_reset_player_weap_model(id, weaponid)
native cs_set_player_model(id, const model[])

// cvar Vars
new cvar_kill_xp , cvar_hs_xp , cvar_infect_xp , cvar_save_type , cvar_max , cvar_allow_show , cvar_show_type , cvar_extra_item_enabled , cvar_hud_r , cvar_hud_b , cvar_hud_g , cvar_allow_classes
// XP Vars
new playerxp[33] , playerlvl[33] , lvl_vault , xp_vault 
// Messages Vars
new g_saytxt 
new fade	
// Extra Item Varsx
new Array:i_name
new Array:i_lvl
new Array:i_team
new zx_items_count
new zx_item_selected_post , zx_fw_return 
new zx_item_selected_pre , pre_select_return
// Other Stuff
new g_MaxPlayers 
new zx_hud
new red , green , blue
new xp_change[3][33] , xp
new selected[33]
new sound[64] = "misc/zp_level_up.wav"

public plugin_init() {
	register_plugin(PLUGIN, VERSION, AUTHOR)
	
	// Events
	register_event("DeathMsg","event_death","a")
	
	// Cvars
	register_cvar("zombie_xp_version" , VERSION , FCVAR_SERVER)
	
	cvar_kill_xp = register_cvar("zx_kill_xp" , "25")        // xp for every kill
	
	cvar_hs_xp = register_cvar("zx_headshot_xp" , "50")        // xp for every kill with headshot
	
	cvar_infect_xp = register_cvar("zx_infect_xp" , "35")      // xp for infect
	
	cvar_max = register_cvar("zx_max_level" , "75")        // max level whenever you increase here increase limit in zx_const.cfg 
	
	cvar_save_type = register_cvar("zx_save_in" , "1")      // save type : 1 = name , 2 = ip , 3 = staemid
	
	cvar_allow_show = register_cvar("zx_allow_show_xp" , "1")  // allow show xp hud when killing (+ XP)
	
	cvar_show_type = register_cvar("zx_show_type" , "1")     //  1 = hud wtih colors  - 0 = hud with normal color 
	
	cvar_extra_item_enabled = register_cvar("zx_allow_extra_items" , "1") // allow extra items
	
	cvar_hud_b  = register_cvar("zx_hud_blue" , "0")        // 
	
	cvar_hud_g = register_cvar("zx_hud_green" , "255")
	
	cvar_hud_r = register_cvar("zx_hud_red" , "0")	
	
	cvar_allow_classes = register_cvar("zx_allow_zombie_classes", "1")
	
	// Ham
	RegisterHam(Ham_TakeDamage , "player" , "func_damage") // when user take damage , used for damage bonus
	RegisterHam(Ham_Spawn , "player" , "func_spawn") // when user spawn not round start
	
	// Vaults
	lvl_vault = nvault_open("lvl_bank")
	xp_vault = nvault_open("xp_bank")
	
	// Commands - last 2 not say commands used in console only
	register_clcmd("say" , "func_say") // used for prefix 
	
	register_clcmd("say_team" , "func_say_team") // team perfix
	
	register_clcmd("say /xpmenu" , "funcs") // show main menu
	
	register_clcmd("say xpmenu" , "funcs") // showing main menu
	
	register_clcmd("info" , "func_info") // option 2 in main menu
	
	register_clcmd("xpitems" , "func_menu") // items menu - option 1 
	
	register_clcmd("zcnemu" , "zclasses_menu")
	
	// Forwards
	zx_item_selected_post = CreateMultiForward("zx_extra_item_selected_post" , ET_CONTINUE , FP_CELL , FP_CELL)
	zx_item_selected_pre = CreateMultiForward("zx_extra_item_selected_pre" , ET_CONTINUE , FP_CELL , FP_CELL)
	zx_class_fw = CreateMultiForward("zx_zombie_class_selected_post" , ET_CONTINUE , FP_CELL , FP_CELL)
	
	// Messages
	fade = get_user_msgid("ScreenFade")
	g_saytxt = get_user_msgid ("SayText")
	register_message (g_saytxt, "avoid_duplicated") // Thanks Arion LOL
	
	// Other Stuff
	g_MaxPlayers = get_maxplayers()
	zx_hud = CreateHudSyncObj()
	register_dictionary("zombie_xp.txt")
}

public plugin_precache()
{
	// Arrays
	i_lvl = ArrayCreate(1 ,1)
	i_name = ArrayCreate(32 , 1)
	i_team = ArrayCreate(1,1)
	Zc_Name = ArrayCreate(64 ,1)
	Zc_Desc = ArrayCreate(64 ,1)
	Zc_Model = ArrayCreate(64 ,1)
	Zc_Claw = ArrayCreate(64 ,1)
	Zc_Gravity = ArrayCreate(1 ,1)
	Zc_speed = ArrayCreate(1,1)
	Zc_health = ArrayCreate(1,1)
	Zc_level = ArrayCreate(1,1)
	precache_sound(sound)
}


public plugin_cfg()
{
	new file[64]
	get_configsdir(file , 63)
	format(file , 63 , "%s/zombie_xp.cfg" ,file)
	
	if(!file_exists(file))
		create_cvars_file()
}

public avoid_duplicated (msgId, msgDest, receiver)
{
	return PLUGIN_HANDLED
}

// user spawn
public func_spawn(id)
{
	
	if (playerlvl[id] == 0)
		playerlvl[id] = 1
	
	if(is_user_alive(id))
		set_task(0.1 , "zx_hud_show" , id+TASK_HUD_REMOVE , _, _, "b") // show_hud
	//give_spawn_bonus(id)
	set_task(1.0 , "give_spawn_bonus", id)
	
	
}
// Show Hud
public zx_hud_show(id)
{
	id -= TASK_HUD_REMOVE
	
	if(is_user_valid(id))
	{
		red = get_pcvar_num(cvar_hud_r)
		green = get_pcvar_num(cvar_hud_g)
		blue = get_pcvar_num(cvar_hud_b)
		set_hudmessage(red, green, blue, 0.0, 0.31, 0, 6.0, 1.1, 0.0, 0.0, -1)
		if (playerlvl[id] >= get_pcvar_num(cvar_max))
			ShowSyncHudMsg(id ,zx_hud , "[Zombie XP system]^n[XP : %i | MAXED]^n[LEVEL : %i]" , playerxp[id] , playerlvl[id])
		else
			ShowSyncHudMsg(id ,zx_hud , "[Zombie XP system]^n[XP : %i | %i]^n[LEVEL : %i]" , playerxp[id] , level[playerlvl[id]] , playerlvl[id])
	}
}

// Give Damage Bonus
public func_damage(victim, idinflictor, attacker, Float:damage, damagebits)
{
	if(is_user_valid(attacker))
	{
		if (playerlvl[attacker] >= 5 && zp_get_user_human(attacker))
			SetHamParamFloat(4 ,damage * 1.0)
		
		if (playerlvl[attacker] >= 15 && zp_get_user_human(attacker))
			SetHamParamFloat(4 , damage * 1.1)
		
		if (playerlvl[attacker] >= 20 && zp_get_user_human(attacker))
			SetHamParamFloat(4 , damage * 1.3)
		
		if (playerlvl[attacker] >= 30 && zp_get_user_human(attacker))
			SetHamParamFloat(4 , damage * 1.5 )
		
		if (playerlvl[attacker] >= 5 && zp_get_user_zombie(attacker))
			SetHamParamFloat(4 , damage + 5.0)	
		
		if (playerlvl[attacker] >= 10 && zp_get_user_zombie(attacker))
			SetHamParamFloat(4 , damage + 20.0)
		
		if (playerlvl[attacker] >= 20 && zp_get_user_zombie(attacker))
			SetHamParamFloat(4 , damage + 40.0)
		
		if (playerlvl[attacker] >= 30 && zp_get_user_zombie(attacker))
			SetHamParamFloat(4 , damage + 50.0)
	}
}

// Give Some Bonus
public give_spawn_bonus(id)
{
	if(is_user_alive(id) && is_user_valid(id))
	{
		if (playerlvl[id] >= 5)
		{
			set_bonus(id , 150 , 30)
		}
		if (playerlvl[id] >= 10)
		{
			set_bonus(id , 200 , 50)
		}
		if (playerlvl[id] >= 15)
		{
			set_bonus(id , 250 , 80)
		}
		if (playerlvl[id] >= 20)
		{
			set_bonus(id , 300 , 100)
		}
	}
}

// Natives
public plugin_natives()
{
	register_native("zx_get_user_xp" , "native_zx_get_user_xp" , 1)
	register_native("zx_get_user_level" , "native_zx_get_user_level" , 1)
	register_native("zx_set_user_xp" , "native_zx_set_user_xp" , 1)
	register_native("zx_set_user_level" , "native_zx_set_user_level" , 1)
	register_native("zx_register_extra_item" , "zx_register_extra_item" , 1)
	register_native("zx_register_zombie_class" , "native_register_class" ,1) 
	register_native("zx_get_next_class" , "native_get_next_class" ,1) 
	register_native("zx_get_current_class" , "native_get_current_class" ,1) 
	register_native("zx_get_registered_classes_count" , "native_registered_count" ,1) 
	register_native("zx_set_next_class" , "native_set_next" ,1)
}

// After Infected
public zp_user_infected_post(id , infector)
{
	playerxp[infector] += get_pcvar_num(cvar_infect_xp)
	if(selected[id])
		set_task(1.0 , 	"attr_set" , id)
}

public attr_set(id)
{
	if(zclasses_count == 0)
	{
		return PLUGIN_HANDLED
	}
	
	if(zp_is_nemesis_round()) 
		return PLUGIN_HANDLED;

	PlayerCurClass[id] = PlayerNextClass[id]
	ExecuteForward(zx_class_fw , zx_class_fw_return , id , PlayerCurClass[id])
	new modelx[64]
	ArrayGetString(Zc_Model , PlayerCurClass[id] , modelx , 63)
	cs_set_player_model(id  ,modelx)
	
	//cs_set_user_model(id ,modelx)
	set_user_gravity(id ,Float:ArrayGetCell(Zc_Gravity ,PlayerCurClass[id]))
	cs_set_player_maxspeed_auto(id ,Float:ArrayGetCell(Zc_speed , PlayerCurClass[id]))
	set_user_health(id , ArrayGetCell(Zc_health , PlayerCurClass[id]))
	new Clawx[64]
	ArrayGetString(Zc_Claw ,PlayerCurClass[id]  , Clawx  ,63)
	cs_set_player_view_model(id , CSW_KNIFE  ,Clawx)
	cs_set_player_weap_restrict(id ,true , ALLOWED_WEAPONS , CSW_KNIFE)
	cs_set_player_weap_model(id, CSW_KNIFE, "")
	return PLUGIN_HANDLED
}

public zp_user_humanized_post(id)
{
	cs_reset_player_view_model(id, CSW_KNIFE)
	cs_reset_player_weap_model(id, CSW_KNIFE)
	
	cs_set_player_weap_restrict(id , false)
}

// Players connect
public client_putinserver(id)
{
	load_xp(id) // load_xp
	
	if(get_pcvar_num(cvar_allow_show))
		set_task(3.0 , "func_xp" , id)	
}

// Thanks to someone i don't remeber
public func_xp(id)
{
	xp = playerxp[id]
	xp_change[0][id] = xp
	xp_change[1][id] = xp
	xp_change[2][id] = xp
	set_task(1.0,"xp_changed" , id , _,_,"b")
}

public xp_changed(id)
{
	xp_change[1][id] = playerxp[id]
	new hold[33]
	
	if(xp_change[1][id] !=xp_change[2][id])
	{
		if(xp_change[1][id] > xp_change[2][id])
		{
			xp = xp_change[1][id] - xp_change[2][id]
			format(hold , charsmax(hold) ,"+ %i XP", xp)
		}
		xp_change[2][id] = xp_change[1][id]
		if(get_pcvar_num(cvar_show_type))
		{
			set_hudmessage(0, 255, 0, 0.29, 0.46, 0, 0.1, 3.0, 0.1, 0.1)
			show_hudmessage(id, hold)
		}
		else	
			client_print(id ,print_center , hold)
	}
}

// player disconnect 
public client_disconnect(id)
{
	save_xp(id) // save exp when disconnect  not including crash
	if (!is_user_alive(id))
		remove_task(id+TASK_HUD_REMOVE)
}

/*=========================================================================
STORE - VAULTS SECTION START HERE !
=========================================================================*/

public save_xp(id)
{
	// Nvault Vars
	new Xkey[65] , Lkey[65] , Xdate[256] , Ldate[256] 
	
	// Save type
	switch(get_pcvar_num(cvar_save_type))
	{
		case 0:
		{
			new name[33]
			get_user_name(id , name , 32)
			
			format(Xkey , 64 , "%s-" , name)
			format(Lkey , 64 , "%s-" , name)
		}
		case 1:
		{
			new ip[36]
			get_user_ip(id , ip , 35)
			
			format(Xkey , 64 , "%s-" , ip)
			format(Lkey , 64 , "%s-" , ip)
		}
		case 2:
		{
			new steamid[35] 
			get_user_authid(id , steamid , 34)
			format(Xkey , 64 , "%s-" , steamid)
			format(Lkey , 64 , "%s-" , steamid)
		}
	}
	format(Xdate , charsmax(Xdate) , "%i#" , playerxp[id])
	format(Ldate , charsmax(Ldate) , "%i#" , playerlvl[id])
	
	nvault_set(lvl_vault , Lkey , Ldate)
	nvault_set(xp_vault , Xkey , Xdate)
	return PLUGIN_CONTINUE
}

public load_xp(id)
{
	new Xkey[65] , Lkey[65] , Xdate[256] , Ldate[256] 
	
	switch(get_pcvar_num(cvar_save_type))
	{
		case 0:
		{
			new name[33]
			get_user_name(id , name , 32)
			
			format(Xkey , 64 , "%s-" , name)
			format(Lkey , 64 , "%s-" , name)
		}
		case 1:
		{
			new ip[36]
			get_user_ip(id , ip , 35)
			
			format(Xkey , 64 , "%s-" , ip)
			format(Lkey , 64 , "%s-" , ip)
		}
		case 2:
		{
			new steamid[35] 
			get_user_authid(id , steamid , 34)
			format(Xkey , 64 , "%s-" , steamid)
			format(Lkey , 64 , "%s-" , steamid)
		}
	}
	format(Xdate , charsmax(Xdate) , "%i#" , playerxp[id])
	format(Ldate , charsmax(Ldate) , "%i#" , playerlvl[id])
	
	nvault_get(lvl_vault , Lkey , Ldate , 255)
	nvault_get(xp_vault , Xkey , Xdate , 255)
	replace_all(Ldate , 255 ,"#" ,"")
	replace_all(Xdate , 255 ,"#" ,"") 
	
	new xp[32] , lvl[32] 
	parse(Ldate , lvl , 31)
	parse(Xdate , xp , 31)
	
	playerlvl[id] = str_to_num(lvl)
	playerxp[id] = str_to_num(xp)
	return PLUGIN_CONTINUE
}
/*=========================================================================
END OF STORE - VAULTS SECTION , START OF MENU
=========================================================================*/

// Main Menu
public funcs(id)
{
	new menu_id2 , menu[250]
	formatex(menu , charsmax(menu) , "\r%L" , id , "ZX_MAIN_TITLE")
	menu_id2 = menu_create(menu , "main_handler")
	
	if (get_pcvar_num(cvar_extra_item_enabled))
		formatex(menu , charsmax(menu) , "\w%L" ,id , "ZX_EXTRA_NAME")
	else
		formatex(menu , charsmax(menu) , "\d%L" ,id , "ZX_EXTRA_NAME_DES")
		
	menu_additem(menu_id2 , menu , "" , 0)
	
	formatex(menu , charsmax(menu) , "%s%L" , !get_pcvar_num(cvar_allow_classes) ? "\d":"\w",id , "ZX_INFO_NAME")
	menu_additem(menu_id2 , menu ,"",0)
	
	
	formatex(menu , charsmax(menu) , "\w%L" , id , "ZX_ZOMBIE_MENU_NAME")	
	menu_additem(menu_id2 , menu , "" , 0)
	
	formatex(menu, charsmax(menu), "%L", id, "ZX_MENU_BACK")
	menu_setprop(menu_id2, MPROP_BACKNAME, menu)
	formatex(menu, charsmax(menu), "%L", id, "ZX_MENU_NEXT")
	menu_setprop(menu_id2, MPROP_NEXTNAME, menu)
	formatex(menu, charsmax(menu), "%L", id, "ZX_MENU_EXIT")
	menu_setprop(menu_id2, MPROP_EXITNAME, menu)
	menu_display(id , menu_id2 , 0)
}

public main_handler(id , menu_id2 , item)
{
	if (item == MENU_EXIT)
	{
		menu_destroy(menu_id2)
		return PLUGIN_HANDLED
	}
	switch(item)
	{
		case 0: 
		{
			if (get_pcvar_num(cvar_extra_item_enabled))
				func_menu(id)
			else
				client_printcolor(id , "%L" , id , "ZX_ITEMS_DISABLED")
		}
		case 1: 
		{
			func_info(id)
		}
		case 2:
		{
			if (get_pcvar_num(cvar_allow_classes))
				zclasses_menu(id)
			else
				client_printcolor(id , "%L" , id , "ZX_CLASSES_DISABLED")
		}				
	}
	return PLUGIN_HANDLED
}

public zclasses_menu(id)
{
	if(zclasses_count == 0)
	{
		client_printcolor(id ,"%L" , id ,"ZX_NO_CLASS")
		return PLUGIN_HANDLED
	}
	
	static menu , menu_a[300]
	new item
	formatex(menu_a , charsmax(menu_a) , "\r%L" , id ,"ZX_CLASSES_TITLE")
	menu = menu_create(menu_a ,  "class_op")
	
	for(item=0; item < zclasses_count ; item++)
	{
		new name[50] , desc[50] , cost 
		ArrayGetString(Zc_Name , item , name , charsmax(name))
		ArrayGetString(Zc_Desc , item , desc , charsmax(desc))
		cost  = ArrayGetCell(Zc_level , item)
		
		if(playerlvl[id] < ArrayGetCell(Zc_level , item))
		{
			formatex(menu_a , 299 , "\d%s [%s][%d]" , name , desc , cost)
		}
		else if(item == PlayerNextClass[id])
		{
			formatex(menu_a , 299 , "\d%s [%s][%d][Selected]" , name , desc , cost)
		}
		else 
			formatex(menu_a , 299 , "%s [\r%s][%d]" , name , desc  ,cost)
		
		
		name[0] = item
		name[1] = 0
		menu_additem(menu , menu_a , name)
	}
	
	formatex(menu_a, charsmax(menu), "%L", id, "ZX_MENU_BACK")
	menu_setprop(menu, MPROP_BACKNAME, menu_a)
	formatex(menu_a, charsmax(menu), "%L", id, "ZX_MENU_NEXT")
	menu_setprop(menu, MPROP_NEXTNAME, menu_a)
	formatex(menu_a, charsmax(menu), "%L", id, "ZX_MENU_EXIT")
	menu_setprop(menu, MPROP_EXITNAME, menu_a)
	menu_display(id ,menu, 0)
	return PLUGIN_HANDLED
}

public class_op(id , menu , item)
{
	if(item == MENU_EXIT)
	{
		menu_destroy(menu)
		return PLUGIN_HANDLED
	}
	if (!is_user_alive(id)) {
		client_printcolor(id , "%L" , id , "ZX_DEAD_MSG")
		menu_destroy(menu)
	}
	new itemdata[2], dummy, classid
	menu_item_getinfo(menu, item, dummy, itemdata, charsmax(itemdata), _, _, dummy)
	classid = itemdata[0]
	
	if(playerlvl[id] < ArrayGetCell(Zc_level, classid)) {
		zclasses_menu(id)
		client_printcolor(id , "%L" , id , "ZX_NOT_AT_LVL")
		return PLUGIN_HANDLED
	}	
	
	PlayerNextClass[id] = classid
	selected[id] = true
	
	menu_destroy(menu)
	return PLUGIN_HANDLED 
}

// Player Info
public func_info(id)
{
	new menu[250] ,menu_id_info
	formatex(menu , charsmax(menu) , "\r%L" , id ,"ZX_INFO_TITLE")
	menu_id_info = menu_create(menu ,"p_handler")
	
	new players[32] , snum , pl_id , holder[500]
	
	new name[32]//, ///user_id[32]
	
	get_players(players ,snum , "")
	
	for (new i ; i<snum;i++)
	{
		pl_id = players[i]
		get_user_name(pl_id , name , charsmax(name))
		//format(user_id ,charsmax(user_id) , "%d" ,get_user_userid(pl_id))
		format(holder , charsmax(holder) , "%s \r[\yLVL : \r%i][\yXP : \r%d]" , name , playerlvl[pl_id] , playerxp[pl_id])
		menu_additem(menu_id_info ,holder)
	}
	
	formatex(menu, charsmax(menu), "%L", id, "ZX_MENU_BACK")
	menu_setprop(menu_id_info, MPROP_BACKNAME, menu)
	formatex(menu, charsmax(menu), "%L", id, "ZX_MENU_NEXT")
	menu_setprop(menu_id_info, MPROP_NEXTNAME, menu)
	formatex(menu, charsmax(menu), "%L", id, "ZX_MENU_EXIT")
	menu_setprop(menu_id_info, MPROP_EXITNAME, menu)
	menu_display(id , menu_id_info , 0)
}

public p_handler(id ,menu_id_info , item)
{
	if (item == MENU_EXIT)
	{
		menu_destroy(menu_id_info)
		return PLUGIN_HANDLED
	}
	new szData[6], szName[64];
	new _access, item_callback;
	menu_item_getinfo(menu_id_info , item, _access, szData,charsmax( szData ), szName,charsmax( szName ), item_callback );
	
	new userid = str_to_num( szData );
	
	new player = find_player( "k", userid )
	
	if (player )
	{
		func_info(id)
	}
	
	menu_destroy(menu_id_info  );
	return PLUGIN_HANDLED;
}

// Extra Items menu
public func_menu(id)
{
	// Don't Open The menu If there no items
	if (zx_items_count == 0) {
		client_printcolor(id ,"%L" , id , "NO_ITEMS")
		return PLUGIN_HANDLED
	}
	
	static menu[250] , menu_id , item 
	new holder[32] ,  check_team
	formatex(menu , charsmax(menu) , "\r%L" , id , "ZX_EXTRA_TITLE" , playerlvl[id])
	menu_id = menu_create(menu , "zx_hanlder")	
	
	for(item =0 ; item < zx_items_count ; item++)
	{
		check_team = ArrayGetCell( i_team , item)
		if(zp_get_user_zombie(id) && !(check_team & TEAM_ZOM) || (zp_get_user_human(id) && !(check_team & TEAM_HUM))) // check user team
			continue 
		
		ArrayGetString(i_name, item , holder , charsmax(holder))		// Get item name
		if (playerlvl[id] < ArrayGetCell(i_lvl , item))
			format(menu , charsmax(menu) , "\d%s \r[\yLVL:\r%d]" , holder , ArrayGetCell(i_lvl , item)) // if user not at resusted level show grey color (disabled)
		else
			format(menu , charsmax(menu) , "%s \r[\yLVL:\r%d]" , holder , ArrayGetCell(i_lvl , item))
		holder[0] = item
		holder[1] = 0
		// Add hte item
		menu_additem(menu_id , menu , holder)
	}
	formatex(menu, charsmax(menu), "%L", id, "ZX_MENU_BACK")
	menu_setprop(menu_id, MPROP_BACKNAME, menu)
	formatex(menu, charsmax(menu), "%L", id, "ZX_MENU_NEXT")
	menu_setprop(menu_id, MPROP_NEXTNAME, menu)
	formatex(menu, charsmax(menu), "%L", id, "ZX_MENU_EXIT")
	menu_setprop(menu_id, MPROP_EXITNAME, menu)
	menu_display(id , menu_id , 0)
	return PLUGIN_HANDLED
}

public zx_hanlder(id , menu_id , item)
{
	if (item == MENU_EXIT)
	{
		menu_destroy(menu_id)
		return PLUGIN_HANDLED
	}
	if (!is_user_alive(id)) {
		client_printcolor(id , "%L" , id , "ZX_DEAD_MSG")
		menu_destroy(menu_id)
	}
	if (zp_get_user_survivor(id))
		menu_destroy(menu_id)
		
	if (zp_get_user_nemesis(id))
		menu_destroy(menu_id)
	
	new itemdata[2], dummy, itemid
	menu_item_getinfo(menu_id, item, dummy, itemdata, charsmax(itemdata), _, _, dummy)
	itemid = itemdata[0]
	
	// Check user level if not as we want disable the item send message say Not at wanted level
	if (playerlvl[id] < ArrayGetCell(i_lvl , itemid))
	{
		func_menu(id)
		client_printcolor(id , "%L" , id , "ZX_NOT_AT_LVL")
		return ITEM_DISABLED
	}
	
	ExecuteForward(zx_item_selected_pre , pre_select_return , id , itemid)
	// Item has Been bought
	zx_item_bought(id , itemid)
	menu_destroy(menu_id)
	return PLUGIN_HANDLED
}

public zx_item_bought(id, itemid)
{
	static check_team
	check_team = ArrayGetCell(i_team , itemid)
	
	if(zp_get_user_zombie(id) && !(check_team & TEAM_ZOM) || (zp_get_user_human(id) && !(check_team & TEAM_HUM)))
	{
		client_printcolor(id , "%L" , id , "ZX_NO_ITEMS_FOR_YOUR_TEAM")
	}
	
	new name[32]
	ArrayGetString(i_name , itemid , name , charsmax(name))
	client_printcolor(id , "%L" , id , "ZX_ITEM_PURCHASED" ,name )
	
	// Forward (zx_extra_item_selected
	ExecuteForward(zx_item_selected_post , zx_fw_return , id , itemid)
}

/*=============================================================================
END OF MENU SECTION - KILLS GIVING XP - LEVELS START HERE
=============================================================================*/

// When user is killed
public event_death()
{
	new attacker = read_data(1)
	//new victim = read_data(2)
	new headshot = read_data(3)
	
	if (is_user_valid(attacker))
	{
		if (headshot)
		{
			playerxp[attacker] += get_pcvar_num(cvar_hs_xp)
		}
		else 
			playerxp[attacker] += get_pcvar_num(cvar_kill_xp)
		
		do_check(attacker)
		
	}
}

public do_check(id)
{
	if(playerlvl[id] < get_pcvar_num(cvar_max))	
	{
		while(playerxp[id] >= level[playerlvl[id]])
		{
			playerlvl[id] += 1
			message_begin(MSG_ONE_UNRELIABLE, fade, _, id)
			write_short(1<<12) // duration
			write_short(1) // hold time
			write_short(0x0000) // fade type
			write_byte(1) // red
			write_byte(195) // green
			write_byte(4) // blue
			write_byte(205) // alpha
			message_end()
			client_printcolor(id , "%L" ,id,"ZX_LEVEL_UP" ,playerlvl[id])
			set_user_health(id, get_user_health(id) + 50)
			set_user_armor(id , get_user_armor(id) +50)
			emit_sound(id,CHAN_VOICE , sound, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
		}	
	}
}

public func_say(id)
{
	new msg[191] , name[32] 
	read_args(msg , 191)
	remove_quotes(msg)
	get_user_name(id , name , 31)
	
	if (equali(msg , "") || equali(msg , "") || !is_valid_mesg(msg))
		return PLUGIN_HANDLED_MAIN
	
	if(is_user_alive(id))
		format(msg , 191 , "^4[LVL : ^3%d] ^3%s : ^1%s" , playerlvl[id] ,name , msg)
	else
		format(msg , 191 , "^1*DEAD*^4[LVL : ^3%d] ^3%s : ^1%s" , playerlvl[id] ,name , msg)
	
	for (new i = 1 ; i < g_MaxPlayers;i++)
	{
		send_message_lol(i , msg)
		
	}
	
	return PLUGIN_CONTINUE
}

public func_say_team(id)
{
	new msg[191] , name[32] 
	read_args(msg , 191)
	remove_quotes(msg)
	get_user_name(id , name , 31)
	
	if (equali(msg , "") || equali(msg , "") || !is_valid_mesg(msg))
		return PLUGIN_HANDLED_MAIN
	
	new CsTeams:team[33]
	team[id] = cs_get_user_team(id)	
	
	if(is_user_alive(id))
		format(msg , 191 , "^1(%s)^4[LVL : ^3%d] ^3%s : ^1%s" ,team[id], playerlvl[id] ,name , msg)
	else
		format(msg , 191 , "^1(%s)^1*DEAD*^4[LVL : ^3%d] ^3%s : ^1%s" ,team[id], playerlvl[id] ,name , msg)
	
	for (new i = 1 ; i < g_MaxPlayers;i++)
	{
		send_message_lol(i , msg)
		
	}
	
	return PLUGIN_CONTINUE
}

/*========================================================================
END OF KILLS - LEVEL SECTION , START OF NATIVES
=========================================================================*/

// zx_get_user_xp         get_user_xp when used in other plugins
public native_zx_get_user_xp(plugin_id, num_params)
{
	new id = get_param(1)
	if(!is_user_valid(id))
	{
		log_error(AMX_ERR_NATIVE , "[ZX] Invaild Player (%d)" , id)
		return -1
	}
	return playerxp[id]
}

// zx_get_user_levle       get_user_level when used in other plugins
public native_zx_get_user_level(plugin_id, num_params)
{
	new id = get_param(1)
	
	if(!is_user_valid(id))
	{
		log_error(AMX_ERR_NATIVE , "[ZX] Invaild Player (%d)" , id)
		return -1
	}
	return playerlvl[id] 
}

// zx_set_user_xp         set user xp when used in other plugins
public native_zx_set_user_xp(plugin_id, num_params)
{
	new id = get_param(1)
	new amount = get_param(2)
	
	if(!is_user_valid(id))
	{
		log_error(AMX_ERR_NATIVE , "[ZX] Invaild Player (%d)" , id)
		return false
	}
	
	playerxp[id] = amount
	return true
}

// zx_set_user_level         set_user_level when used in other plugins
public native_zx_set_user_level(plugin_id, num_params)
{
	new id = get_param(1)
	new amount = get_param(2)
	
	if(!is_user_valid(id))
	{
		log_error(AMX_ERR_NATIVE , "[ZX] Invaild Player (%d)" , id) // number of id 
		return false
	}
	
	playerlvl[id] = amount
	return true
}

// The native That register the item
public zx_register_extra_item(const name[] , item_level , team)
{
	param_convert(1)
	ArrayPushString(i_name , name)
	ArrayPushCell(i_lvl , item_level)
	ArrayPushCell(i_team , team)
	zx_items_count++ // increase the item count
	
	return zx_items_count-1 // to work proberly
}

public native_register_class(const name[] , const description[] , const player_model[] ,const claw_model[] , health , Float:speed , Float:gravity , level)
{
	param_convert(1)
	param_convert(2)
	param_convert(3)
	param_convert(4)
	
	ArrayPushString(Zc_Name , name)
	ArrayPushString(Zc_Desc , description)
	ArrayPushString(Zc_Model , player_model)
	ArrayPushString(Zc_Claw , claw_model)
	ArrayPushCell(Zc_health , health)
	ArrayPushCell(Zc_speed , speed)
	ArrayPushCell(Zc_Gravity , gravity)	
	ArrayPushCell(Zc_level , level)
	
	new model_path[128]
	formatex(model_path, charsmax(model_path), "models/player/%s/%s.mdl", player_model, player_model)	
	if(file_exists(model_path)) //precache_model(model_path)
		engfunc(EngFunc_PrecacheModel ,model_path)
	
	engfunc(EngFunc_PrecacheModel ,claw_model)	
	
	zclasses_count++
	
	return zclasses_count-1
}

public native_get_next_class(plugin_id, num_params)
{
	new id = get_param(1)
	if(!is_user_valid(id))
	{
		log_error(AMX_ERR_NATIVE , "[ZX] Invaild Player (%d)" , id) // number of id 
		return false
	}
	return PlayerNextClass[id]
}

public native_registered_count(plugin_id, num_params)
{
	return zclasses_count
}

public native_set_next(plugin_id, num_params)
{
	new id = get_param(1)
	new classid = get_param(2)
	if(!is_user_valid(id))
	{
		log_error(AMX_ERR_NATIVE , "[ZX] Invaild Player (%d)" , id) // number of id 
		return false
	}
	PlayerNextClass[id] = classid
	return true
}

public native_get_current_class(plugin_id, num_params)
{
	new id = get_param(1)
	if(!is_user_valid(id))
	{
		log_error(AMX_ERR_NATIVE , "[ZX] Invaild Player (%d)" , id) // number of id 
		return false
	}
	return PlayerCurClass[id]
}
/*==============================================================================
END OF NATIVES -  START OF STOCKES
==============================================================================*/

// Some Stocks
stock set_bonus(id , health , armor)
{
	if(is_user_valid(id))
	{
		set_user_health(id , health)
		set_user_armor(id , armor)
	}
}

stock bool:zp_get_user_human(id)
{
	if(!zp_get_user_nemesis(id) && !zp_get_user_zombie(id) && !zp_get_user_survivor(id) && is_user_valid(id))
		return true
	else
		return false
	
	return true	
}

public send_message_lol(id ,  msg[])
{
	message_begin (MSG_ONE, g_saytxt, {0, 0, 0}, id)
	write_byte(id)
	write_string(msg)
	message_end()
}

bool:is_valid_mesg(const message[])
{
	if(message[0] == '@' || message[0] == '/' || message[0] == '!' || !strlen(message))
		return false
	else		
		return true
	
	return true
	
}

stock client_printcolor(const id, const input[], any:...) 
{ 
	new count = 1, players[32]; 
	static msg[191]; 
	vformat(msg, 190, input, 3); 
	replace_all(msg, 190, "!g", "^4"); // Green Color 
	replace_all(msg, 190, "!y", "^1"); // Default Color
	replace_all(msg, 190, "!t", "^3"); // Team Color 
	if (id) players[0] = id; else get_players(players, count, "ch"); 
	for ( new i = 0; i < count; i++ ) 
	{ 
		if ( is_user_connected(players[i]) ) 
		{ 
			message_begin(MSG_ONE_UNRELIABLE, g_saytxt , _, players[i]); 
			write_byte(players[i]); 
			write_string(msg); 
			message_end(); 
		} 
	} 
} 

create_cvars_file()
{
	new file[64] , f , fmt[1000]
	get_configsdir(file, charsmax(file))
	format(file , charsmax(file) , "%s/zombie_xp",file)
	add(file , charsmax(file) ,".cfg")
	
	f = fopen(file , "wt")
	
	if (file_exists(file)) {
		server_cmd("exec %s" ,file)
	}
	
	new pug	, file_n[300] , plug_name[200] , plug_ver[300] , plug_auther[300]
	pug = get_plugin(-1 ,file_n, charsmax(file_n) , plug_name , charsmax(plug_name) , plug_ver , charsmax(plug_ver) , plug_auther , charsmax(plug_auther))	
	
	format(fmt , charsmax(fmt) ,"; %s configuration file By %s ^n" , plug_name , plug_auther)
	fprintf(f , fmt)
	
	new cvars = get_plugins_cvarsnum()
	new cvarsd , cvar_name[300] , cvar_value[30] ,id_pl
	fprintf(f , "^nCvars :^n")
	
	for(new i ; i < cvars  ;i++)
	{
		get_plugins_cvar(i ,cvar_name , charsmax(cvar_name) ,_, id_pl , cvarsd)
		if (id_pl == pug)
		{
			get_pcvar_string(cvarsd , cvar_value ,charsmax(cvar_value))
			fprintf(f , "^n%s %s^n" , cvar_name , cvar_value)
		}
	}
	fclose(f)
}

/*=====================================================================
END OF PLUGIN - HAVE FUN 
=====================================================================*/
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ fbidis\\ ansi\\ ansicpg1252\\ deff0{\\ fonttbl{\\ f0\\ fnil\\ fcharset0 Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ ltrpar\\ lang1025\\ f0\\ fs16 \n\\ par }
*/