Addons Zombie Plague XP [Freakz Edition]

[Metin2Algeria]

Imi cer scuze ca fac dublu post fix acum, dar am rezolvat, folosesc acel "update addons zm xp" si folosesc compilarea lui cu addonsu tau <3 MERSI ORICUM DIN SUFLET

Interzis <3 best <3

[CosminZ]

Forta addons
am fct sv cu addonsu asta

[eMeKa.eXe]

Forta addonsu
am fct sv cu addonsu asta

ai uitat sa bagi hartile de ZM

[Rainq]

am modificat putin plugin de salvare lvl
levelxp.cfg

Code: Select all

echo Executing ZP XP config

// EN:	1 - Enable
//		2 - Enable mode "auto"
//		0 - Disable bank

zp_bank	"2"

// EN: block change nickname, default: 1

zp_bank_block_name_change "1"

// EN: Allow to set a password for nickname in the bank, 0 - disable, default: 1

zp_bank_allow_passwd "0"

// EN: Allow transfer level, 0 - disable, default: 1

zp_bank_allow_donate "0"

// EN: Maximum number of packs that can be stored in a bank, 0 - disable, default: 1000

zp_bank_save_limit "10000000000000000"

// EN: Announce the players every N seconds that the server is uses bank, 0 - disable, default: 360.0

zp_bank_annonce "360.0"

// EN: Through how many days to remove the ammo-packs if the player does not enter to the server, 0 - disable, default: 9200

zp_bank_save_days "9200"

// EN: How to save
//		1 - steamid,
//		2 - nick
//		3 - ip

zp_bank_save_type "2"

// EN: database settings

zp_bank_host "93.114.82.248"
zp_bank_user "hokagero_zmextreamcs"
zp_bank_pass "yBZbiURHzJip3jD"
zp_bank_db "hokagero_rainq"

// mysql or sqlite

zp_bank_type "mysql"
zp_bank_table "ZOMBIEZP"
zp_bank_pw_str "_bpw"

zp_bank_save_levelXP.sma

Code: Select all

#include <amxmodx> 
#include <amxmisc> 
#include <sqlx> 
#include <zombie_plague_special>

native zp_get_level(id); 
native zp_set_level(id,amount); 

#define DB_NONE 0 
#define DB_CONNECTING 1 
#define DB_READY 2 
#define TASK_BANK 78956 

new Handle:Conexiune = Empty_Handle 
new Handle:SqlConnection 
new g_Error[512], g_db_status 
new Host[64], User[64], Pass[64], Db[64] 
new authid[33][32] 

 public plugin_init()
{
	register_plugin("[ZP] Save XP", "1.2", "EDUTz, edited by Rainq")
	new configsDi[64], configfile[128]
	get_configsdir(configsDi, 63)	
	format(configfile, 127, "%s/levelxp.cfg", configsDi)
	if(file_exists(configfile))
	{
		server_cmd("exec %s", configfile)
	}
	else log_amx("[AMXX] levelxp.cfg not found in the config folder.")
	register_cvar("yaab", "EDUTz", (FCVAR_SERVER|FCVAR_SPONLY));
	g_db_status = DB_NONE
	set_task(0.1, "MySql_Init")
}

public client_putinserver(id) 
{ 
get_user_authid(id, authid[id], 31); 
Load_MySql(id) 
set_task(60.0, "SaveAmmobank", id+TASK_BANK, _, _, "b") 
} 

public MySql_Init()
{
	if(g_db_status == DB_CONNECTING)
		return
	g_db_status = DB_CONNECTING
	new ErrorCode
	
	get_cvar_string("amx_sql_host", Host, 63)
	get_cvar_string("amx_sql_user", User, 63)
	get_cvar_string("amx_sql_pass", Pass, 63)
	get_cvar_string("amx_sql_db", Db, 63)
	
	Conexiune = SQL_MakeDbTuple(Host,User,Pass,Db)
	SqlConnection = SQL_Connect(Conexiune,ErrorCode,g_Error,charsmax(g_Error))
	if(SqlConnection == Empty_Handle)
		set_fail_state(g_Error)
	new Handle:Queries
	Queries = SQL_PrepareQuery(SqlConnection,"CREATE TABLE IF NOT EXISTS zombie_level_bank (user varchar(32),ammo INT(11))")
	if(!SQL_Execute(Queries))
	{
		SQL_QueryError(Queries,g_Error,charsmax(g_Error))
		set_fail_state(g_Error)
		g_db_status = DB_NONE
	}
	else g_db_status = DB_READY
	SQL_FreeHandle(Queries)
	SQL_FreeHandle(SqlConnection)   
}


public plugin_end()
{
	if(g_db_status == DB_READY)
	SQL_FreeHandle(Conexiune)
}

public client_disconnect(id)
{
	if(Conexiune != Empty_Handle)
		Save_MySql(id);
	remove_task(id+TASK_BANK)
}

public Load_MySql(id)
{
	if(g_db_status != DB_READY)
	return
	
	new Data[1], szTemp[512]
	Data[0] = id
	#if defined USINGAUTHID
	format(szTemp,charsmax(szTemp),"SELECT * FROM zombie_level_bank WHERE zombie_level_bank.user = ^"%s^";", authid[id])
	#else
	new szName[32]
	get_user_name(id, szName, charsmax(szName))
	format(szTemp,charsmax(szTemp),"SELECT * FROM zombie_level_bank WHERE zombie_level_bank.user = ^"%s^";", szName)
	#endif
	SQL_ThreadQuery(Conexiune,"register_client",szTemp,Data,1)
}

public register_client(FailState,Handle:Query,Error[],Errcode,Data[],DataSize)
{
	if(FailState == TQUERY_CONNECT_FAILED)
	{
		log_amx("Load - Could not connect to SQL database.  [%d] %s", Errcode, Error)
	}
	else if(FailState == TQUERY_QUERY_FAILED)
	{
		log_amx("Load Query failed. [%d] %s", Errcode, Error)
	}
	new id, szTemp[512]
	id = Data[0]
    
	if(SQL_NumResults(Query) < 1) 
	{
		#if defined USINGAUTHID
		format(szTemp,charsmax(szTemp),"INSERT INTO zombie_level_bank ( user , ammo )VALUES (^"%s^", 1);", authid[id]) 
		#else
		new szName[32]
		get_user_name(id, szName, charsmax(szName))
		format(szTemp,charsmax(szTemp),"INSERT INTO zombie_level_bank ( user , ammo )VALUES (^"%s^", 1);", szName) 
		#endif
		SQL_ThreadQuery(Conexiune,"IgnoreHandle",szTemp)	
	} 
	else 
	{
		zp_set_level(id, SQL_ReadResult(Query, 1))
	}
	return PLUGIN_HANDLED
}

public SaveAmmobank(id)
{
	id -= TASK_BANK
	if(!is_user_connected(id))
	return
	if(g_db_status != DB_READY)
	return
	new packs = zp_get_level(id) 
	new szTemp[512]
	if ( packs > 1) 
	{
		#if defined USINGAUTHID
		format(szTemp,charsmax(szTemp),"UPDATE zombie_level_bank SET ammo = %i WHERE zombie_level_bank.user = ^"%s^";", packs, authid[id])
		#else
		new szName[32]
		get_user_name(id, szName, charsmax(szName))
		format(szTemp,charsmax(szTemp),"UPDATE zombie_level_bank SET ammo = %i WHERE zombie_level_bank.user = ^"%s^";", packs, szName)
		#endif
		SQL_ThreadQuery(Conexiune,"IgnoreHandle",szTemp)
	}
}

public IgnoreHandle(FailState,Handle:Query,Error[],Errcode,Data[],DataSize)
{
	SQL_FreeHandle(Query)
	return PLUGIN_HANDLED
}

public Save_MySql(id)
{
	if(!is_user_connected(id))
	return
	if(g_db_status != DB_READY)
	return
	new packs = zp_get_level(id) 
	new szTemp[512]
	if ( packs > 1 ) 
	{
		#if defined USINGAUTHID
		format(szTemp,charsmax(szTemp),"UPDATE zombie_level_bank SET ammo = %i WHERE zombie_level_bank.user = ^"%s^";",packs, authid[id])
		#else
		new szNume[32]
		get_user_name(id, szNume, charsmax(szNume))
		format(szTemp,charsmax(szTemp),"UPDATE zombie_level_bank SET ammo = %i WHERE zombie_level_bank.user = ^"%s^";",packs, szNume)
		#endif
		SQL_ThreadQuery(Conexiune,"IgnoreHandle",szTemp)
	}
}

[CosminZ]

era un bug cand cumparai lvl si dadeai retry primeai creditele inapoi
sau cand omori zm nu iti da points sau cand se schimba mapa nu iti selecteaza automat clasa care esti

[Rainq]

era un bug cand cumparai lvl si dadeai retry primeai creditele inapoi
sau cand omori zm nu iti da points sau cand se schimba mapa nu iti selecteaza automat clasa care esti

downloadeaza versiunea 4

[CosminZ]

era un bug cand cumparai lvl si dadeai retry primeai creditele inapoi
sau cand omori zm nu iti da points sau cand se schimba mapa nu iti selecteaza automat clasa care esti

downloadeaza versiunea 4

v4 am avut pe sv

[Rainq]

era un bug cand cumparai lvl si dadeai retry primeai creditele inapoi
sau cand omori zm nu iti da points sau cand se schimba mapa nu iti selecteaza automat clasa care esti

downloadeaza versiunea 4

v4 am avut pe sv

zombie_xp.sma , testeaza

Code: Select all

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

#define TRIGGER_ZP_ITEM
#define TRIGGER_SAYMENU
#define ZP_GAMERUINER
#define ZP_BINDMENU "j" // Daca il dezactivezi nu o sa mai mearga xpmenu

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 // Daca il dezactivezi nu o sa mai poti lua xp cu ammo

native zp_bank_get_packs(id)
native zp_bank_set_packs(id, value)
#endif

static const PLUGIN_NAME[] = "ZMX.THEXFORCE.RO"
static const PLUGIN_VERSION[] = "1.8"

new g_fwRoundStart, g_fwDummyResult

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

// 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

public plugin_precache()
{
// Register all our cvars
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_mod", "1")
pcvars[packslevelup] = 10


//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, ".:: Zombie XP ::.", PLUGIN_VERSION)

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

// Get Max Players
g_maxplayers = get_maxplayers()

//nVault
gvault = nvault_open(PLUGIN_NAME);

}

public set_cvars()
{
// Disable zombie_plague's zombie auto menu
if( get_pcvar_num(cvar_removezombie) == 0) set_cvar_num("zp_zombie_classes", 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) 
{
return PLUGIN_HANDLED; 
} 
if(arg2 > g_hclass_i) 
{
return PLUGIN_HANDLED; 
} 
if(id == player) 
{ 
userLevel[id] = 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; 

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 20
case 2 : return 30
case 3 : return 40
case 4 : return 50
case 5 : return 70
case 6 : return 90
case 7 : return 120
case 8 : return 150
case 9 : return 170
case 10: return 190
case 11: return 210
case 12: return 450
case 13: return 1200
case 14: return 2400
case 15: return 3200
case 16: return 6400
case 17: return 7532
case 18: return 8600
case 19: return 9000
case 20: return 12000 // 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)
{
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");
}

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");
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");
set_pcvar_num(cvar_removexp, arg2);

} else {
// They typed something wrong
zp_colored_print(id, "^x04%s^x01 %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");
}

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");
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");
}
} else if (arg2 == 1) {
// Disable the zombie classes
zp_colored_print(id, "^x04%s^x01 %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");
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");
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");
}

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 ammo 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 ammo 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 ammo 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,"", 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)

}

public fw_PlayerSpawn_Post(id)
{

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)

setHumanParameters(id)


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; 

ExecuteForward(g_fwRoundStart, g_fwDummyResult, o);
}

// Set our vars
g_freezetime = true
}

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

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

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 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)
{
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
================================================================================*/

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]<20)
{
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])
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;
}

// 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()
}
}

legat de level.

foloseste asta

Code: Select all

#include <amxmodx>
#include <cstrike>
#include <fvault>
#include <hamsandwich>

#define TASK_MINUTES 39292
#define ID_MINUTES (taskid - TASK_MINUTES)

native zp_get_user_ammo_packs(id);
native zp_set_user_ammo_packs(id, amount);

new const fvault_packs[] = "FvaultZombie_Packs";
new const fvault_minutes[] = "player_minutes";

new bool:g_isloaded[33], g_minutes[33], g_awardedbonus[33], g_msg_saytext;

public plugin_init()
{
	register_plugin("Auto Saver & Rewards", "1.0", "cyby");
	
	RegisterHam(Ham_Spawn, "player", "player_spawn_post", 1);
	
	register_clcmd("say /get", "get_rewards");
	g_msg_saytext = get_user_msgid("SayText");
}

public client_putinserver(id)
{
	if(!is_user_bot(id))
	{
		g_isloaded[id] = false;
		zp_set_user_ammo_packs(id, 0);
		g_minutes[id] = 0;
		g_awardedbonus[id] = 0;
	}
}

public client_authorized(id)
{
	if(!is_user_bot(id))
	{
		g_isloaded[id] = false;
		zp_set_user_ammo_packs(id, 0);
		g_minutes[id] = 0;
		g_awardedbonus[id] = 0;
	}
}

public client_disconnect(id)
{
	if(g_isloaded[id])
	{
		new stupidstats[22], name[32];
		get_user_name(id, name, charsmax(name));
		num_to_str(zp_get_user_ammo_packs(id), stupidstats, charsmax(stupidstats));
		fvault_set_data(fvault_packs, name, stupidstats);
		formatex(stupidstats, charsmax(stupidstats), "^"%d^" ^"%d^"", g_minutes[id], g_awardedbonus[id]);
		fvault_set_data(fvault_minutes, name, stupidstats);
	}
	remove_task(id+TASK_MINUTES);
}

public player_spawn_post(id)
{
	if(!is_user_alive(id) || is_user_bot(id))
		return;
		
	if(g_isloaded[id])
		return;
		
	new data_taked[22], playername[32], bool:newplayer = false;
	get_user_name(id, playername, charsmax(playername));

	if(fvault_get_data(fvault_packs, playername, data_taked, charsmax(data_taked)))
		zp_set_user_ammo_packs(id, str_to_num(data_taked)), color(id, "^4[ZP]^1 and ^3 %s^1 packs in your bank!", data_taked);
	else
		zp_set_user_ammo_packs(id, 253);
		
	if(fvault_get_data(fvault_minutes, playername, data_taked, charsmax(data_taked)))
	{
		new strmin[11], strawarded[11];
		parse(data_taked, strmin, charsmax(strmin), strawarded, charsmax(strawarded));
		g_minutes[id] = str_to_num(strmin);
		g_awardedbonus[id] = str_to_num(strawarded);
	}
	else
		newplayer = true;

	if(newplayer)
	{
		color(id, "^4[ZP]^1 Seems like you are new on this server!");
		color(id, "^4[ZP]^1 Your bonus is ready now, use the command^3 /get^1 in the chat to get^3 100,000^1 packs!");
	}
	g_isloaded[id] = true;
	set_task(60.0, "give_minutes", id+TASK_MINUTES, _, _, "b");
}

public get_rewards(id)
{
	if(!g_isloaded[id] || !is_user_connected(id))
		return PLUGIN_CONTINUE;
	
	new Float:isvalid = 0.0;
	isvalid = g_minutes[id] / 60.0;
	if(floatround(isvalid, floatround_tozero) > g_awardedbonus[id])
	{
		color(id, "^4[ZP]^1 You got^3 100,000 Packs^1 for playing on this server!");
		color(id, "^4[ZP]^1 Continue to play and you will get every hour^3 100,000 Packs^1!");
		zp_set_user_ammo_packs(id, zp_get_user_ammo_packs(id) + 100000 );
		g_awardedbonus[id]++;
		return PLUGIN_HANDLED;
	}
	
	//color(id, "^4[ZP]^1 Sorry, you need to wait a little bit more until you will get your next bonus!");
	return PLUGIN_HANDLED;
}

public give_minutes(taskid)
{
	if(!is_user_connected(ID_MINUTES) || cs_get_user_team(ID_MINUTES) == CS_TEAM_SPECTATOR || !cs_get_user_team(ID_MINUTES) || !g_isloaded[ID_MINUTES])
		return;
		
	g_minutes[ID_MINUTES]++;
	new Float:isvalid = 0.0;
	isvalid = g_minutes[ID_MINUTES] / 60.0;
	if(floatround(isvalid, floatround_tozero) > g_awardedbonus[ID_MINUTES])
		color(ID_MINUTES, "^4[ZP]^1 Take your^3 100000 Packs^1 bonus now typing^3 /get^1 in chat.");
}
	
stock color(const id, const input[], any:...)
{
	new count = 1, players[32], msg[191];
	vformat(msg, charsmax(msg), input, 3);
	
	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_msg_saytext, _, players[i]);
				write_byte(players[i]);
				write_string(msg);
				message_end();
			}
		}
	}
}

legat de credite.