Escapers Zone

Code: Select all

/*
	I create plugin nemesis round to fun 
	to work nemesis you need add plugin ze_leap (ze_leap.amxx)
*/

/* -- Included -- */  
#include <zombie_escape>
#include <cstrike>
#include <fun>

/* -- Definded -- */
#define PLAYERMODEL_MAX_LENGTH 32
#define MODEL_MAX_LENGTH 64

/* -- Variable Cvars -- */ 
new Cvar_Nemesis_Chance
new Cvar_Nemesis_Health
new Cvar_Nemesis_Gravity
new Cvar_Nemesis_Speed
new Cvar_Nemesis_Glow
new Cvar_Nemesis_Leap
new Cvar_Nemesis_Sound
new Cvar_Nemesis_HudInfo
new Cvar_Nemesis_Damage

/* -- Global Variable -- */ 
new g_MaxPlayers

/* -- Bool Variable -- */
new g_IsNemesis


/* -- Natives -- */
native ze_get_longjump(id)
native ze_remove_longjump(id)

/* -- Custom Model -- */
// Settings file
new const ZE_SETTING_FILE[] = "zombie_escape.ini"

/*-- Default models --*/
new const models_nemesis_player[][] = { "ze_nemesis_host" }
new const models_nemesis_claw[][] = { "models/zombie_escape/v_knife_nemesis.mdl" }

/* -- Array -- */
new Array:g_models_nemesis_player
new Array:g_models_nemesis_claw

/* -- Sound Nemesis -- */
new const Snd_Nemesis[] = "sound/zombie_escape/ze_nemesis.wav"

/* ------------------ */
public plugin_init() 
{
	register_plugin("[ZE] Nemesis Class", "1.0.0", AUTHORS)

	// Other Cvar
	register_clcmd("ze_nemesis_round", "ze_round_nemesis", _, "Round Nemesis", ADMIN_KICK) 
	
	// Ham Take Damage 
	RegisterHam( Ham_TakeDamage, "player", "TakeDamage" );
	
	// Max Players 
	g_MaxPlayers = get_maxplayers()
	
	// Cvars 
	Cvar_Nemesis_Chance = register_cvar("ze_nemesis_chance", "1")
	Cvar_Nemesis_Health = register_cvar("ze_nemsis_health", "50000")
	Cvar_Nemesis_Gravity = register_cvar("ze_nemesis_gravity", "650.0")
	Cvar_Nemesis_Speed = register_cvar("ze_nemesis_speed", "1.6")
	Cvar_Nemesis_Glow = register_cvar("ze_nemesis_glow", "1")
	Cvar_Nemesis_Leap = register_cvar("ze_nemesis_leap", "1")
	Cvar_Nemesis_Sound = register_cvar("ze_nemesis_sound", "1")
	Cvar_Nemesis_HudInfo = register_cvar("ze_nemesis_hudinfo", "1")
	Cvar_Nemesis_Damage = register_cvar("ze_nemesis_damage", "25.0")
	
	// Precache Lang Text
	register_dictionary("zombie_escape.txt")
}

/* -- Precache Files -- */
public plugin_precache()
{
	// Initialize arrays
	g_models_nemesis_player = ArrayCreate(PLAYERMODEL_MAX_LENGTH, 1)
	g_models_nemesis_claw = ArrayCreate(MODEL_MAX_LENGTH, 1)
	
	// Load from external file
	amx_load_setting_string_arr(ZE_SETTING_FILE, "Player Models", "NEMESIS", g_models_nemesis_player)
	amx_load_setting_string_arr(ZE_SETTING_FILE, "Weapon Models", "V_KNIFE NEMESIS", g_models_nemesis_claw)
	
	// If we couldn't load from file, use and save default ones
	new index
	if (ArraySize(g_models_nemesis_player) == 0)
	{
		for (index = 0; index < sizeof models_nemesis_player; index++)
			ArrayPushString(g_models_nemesis_player, models_nemesis_player[index])
		
		// Save to external file
		amx_save_setting_string_arr(ZE_SETTING_FILE, "Player Models", "NEMESIS", g_models_nemesis_player)
	}
	if (ArraySize(g_models_nemesis_claw) == 0)
	{
		for (index = 0; index < sizeof models_nemesis_claw; index++)
			ArrayPushString(g_models_nemesis_claw, models_nemesis_claw[index])
		
		// Save to external file
		amx_save_setting_string_arr(ZE_SETTING_FILE, "Weapon Models", "V_KNIFE NEMESIS", g_models_nemesis_claw)
	}
	
	// Precache models
	new player_model[PLAYERMODEL_MAX_LENGTH], model[MODEL_MAX_LENGTH], model_path[128]
	for (index = 0; index < ArraySize(g_models_nemesis_player); index++)
	{
		ArrayGetString(g_models_nemesis_player, index, player_model, charsmax(player_model))
		formatex(model_path, charsmax(model_path), "models/player/%s/%s.mdl", player_model, player_model)
		precache_model(model_path)
		// Support modelT.mdl files
		formatex(model_path, charsmax(model_path), "models/player/%s/%sT.mdl", player_model, player_model)
		if (file_exists(model_path)) precache_model(model_path)
	}
	for (index = 0; index < ArraySize(g_models_nemesis_claw); index++)
	{
		ArrayGetString(g_models_nemesis_claw, index, model, charsmax(model))
		precache_model(model)
	}
}

/* -- Register Natives -- */
public plugin_natives()
{
	register_native("ze_is_user_nemesis", "_native_is_nemesis")
}

public _native_is_nemesis(id)
{
	return g_IsNemesis
}

/* -- Player Disconnected Server -- */
public client_disconnected(id)
{
	g_IsNemesis = false
}

/* -- Start Round Nemesis -- */
public ze_round_nemesis(id)
{
	g_IsNemesis = false
	return 1;
}

/* -- New Round -- */
public ze_newround(id)
{
	if(random_num(1, (Cvar_Nemesis_Chance)) != 1)
	{
		g_IsNemesis = true
	}
}

/* -- Zombie Choosed -- */
public ze_zombie_appear()
{
	if(g_IsNemesis)
	{
		for(new id = 0;id < g_MaxPlayers;id++)
		{
			// start feature nemesis
			nemesis_feature(id)
	
			// start hud + sound nemesis
			nemesis_message(id)		
		}
	}
	
	return 1;
}

/* -- Nemesis Features -- */
public nemesis_feature(id)
{	
	if(is_user_alive(id) && g_IsNemesis)
	{
		// Message notice log jump is active 
		if(get_pcvar_num(Cvar_Nemesis_Leap) == 1)
		{
			ze_colored_print(0, "You Have ^4Long Jump^1, ^3Crouch + Jump")
		}
		
		// Feature Nemesis [HP + Gravity + Speed ] 
		set_user_health(id, get_pcvar_num(Cvar_Nemesis_Health)) // Health
		set_user_gravity(id, get_pcvar_float(Cvar_Nemesis_Gravity)) // Gravity
		set_user_maxspeed(id, get_pcvar_float(Cvar_Nemesis_Speed)) // Speed
			
		// Glow 
		if(get_pcvar_num(Cvar_Nemesis_Glow) == 1)
		{
			Set_Rendering(id, kRenderFxNone, 255, 0, 0, kRenderNormal, 15)
		}
				
		if(get_pcvar_num(Cvar_Nemesis_Leap) == 1)
		{
			ze_get_longjump(id)
		}
	}
	
	set_model(id) // Set Model Nemesis
	
	return 1;

}

/* -- Make Nemesis Killer -- */ 
public TakeDamage(iVictim, iInfector, iAttacker, Float:iDamage, iDamageBits )
{
    if(iInfector == iAttacker && is_user_alive(iAttacker) && get_user_weapon(iAttacker) == CSW_KNIFE && !g_IsNemesis == true)
    {
        SetHamParamFloat(4, iDamage * get_pcvar_float(Cvar_Nemesis_Damage))
        return HAM_HANDLED;
    }
    return HAM_IGNORED;
} 
		

/* -- Message Nemesis -- */
public nemesis_message(id)
{
	if(get_pcvar_num(Cvar_Nemesis_Sound))
	{
		// Notice Sound
		client_cmd(id, "spk %s", Snd_Nemesis)
	}
	
	if(get_pcvar_num(Cvar_Nemesis_HudInfo))
	{	
		// Hud Message Nemesis
		static NNemesis[64]
		formatex(NNemesis, charsmax(NNemesis), "%L", LANG_PLAYER, "NOTICE_NEMESIS")
		set_hudmessage(255, 0, 0, -1.0, -1.0, 0, 0.0, 5.0, 0.1, 1.5, false)
		show_hudmessage(id, NNemesis)
		
		// Chat Message Nemesis
		static NNemesisChat[64]
		formatex(NNemesisChat, charsmax(NNemesisChat), "%L", LANG_PLAYER, "NOTICE_NEMESIS_CHAT")
		ze_colored_print(id, NNemesisChat)
	}
	
	return 1;
} 	

/* -- Set Nemesis Model -- */
public set_model(id)
{
	if(g_IsNemesis)
	{
		// Apply nemesis player model
		new player_model[PLAYERMODEL_MAX_LENGTH]
		ArrayGetString(g_models_nemesis_player, random_num(0, ArraySize(g_models_nemesis_player) - 1), player_model, charsmax(player_model))
		cs_set_user_model(id, player_model)
				
		// Apply nemesis claw model
		new model[MODEL_MAX_LENGTH]
		ArrayGetString(g_models_nemesis_claw, random_num(0, ArraySize(g_models_nemesis_claw) - 1), model, charsmax(model))
		cs_set_player_view_model(id, CSW_KNIFE, model)
	}
}

/* -- Round Ended -- */
public ze_roundend(id)
{
	Set_Rendering(id)
	g_IsNemesis = false
	ze_remove_longjump(id)
}

Code: Select all

#include <zombie_escape>

#define PLUGIN "[ZE] Extra Item:Leap"
#define VERSION "1.5.7"
#define AUTHOR "Fry!"

/*================================================================================
 [Plugin Customization]
=================================================================================*/

new bool:g_hasLongJump[33],g_SayText
new Float:g_last_LongJump_time[33]
new g_LongJump_force, g_LongJump_height, g_LongJump_cooldown
public plugin_init() 
{
	register_plugin(PLUGIN, VERSION, AUTHOR)
	
	register_cvar("ze_leap",VERSION,FCVAR_SERVER|FCVAR_EXTDLL|FCVAR_UNLOGGED|FCVAR_SPONLY)
	
	g_LongJump_force = register_cvar("ze_longjump_force", "580")
	g_LongJump_height = register_cvar("ze_longjump_height", "320")
	g_LongJump_cooldown = register_cvar("ze_longjump_cooldown", "5.0")
	
	register_forward(FM_PlayerPreThink, "fw_PlayerPreThink")
	
	register_event("DeathMsg", "death", "a")
	register_event("HLTV", "event_round_start", "a", "1=0", "2=0")
	g_SayText = get_user_msgid("SayText")
}
public plugin_natives()
{
	register_native("ze_get_longjump","native_give_longjump",1)
	register_native("ze_remove_longjump","native_remove_longjump",1)
}
public native_give_longjump(id)
{
	if(ze_is_user_zombie(id))
	{
		g_hasLongJump[id] = true
	}
	else
	{
		g_hasLongJump[id] = false
	}
}

public native_remove_longjump(id)
{
	g_hasLongJump[id] = false
}

stock Color(const id, const input[], any:...)
{
	static msg[191]
	vformat(msg, 190, input, 3)
	
	replace_all(msg, 190, "!g", "^4")
	replace_all(msg, 190, "!y", "^1")
	replace_all(msg, 190, "!t", "^3")
	
	message_begin(MSG_ONE_UNRELIABLE, g_SayText, _, id)
	write_byte(id)
	write_string(msg)
	message_end()
}
// Reset on disconnection
public client_disconnected(id)
{
	g_hasLongJump[id] = false
}

// Reset on death
public death()
{
	g_hasLongJump[read_data(2)] = false
}

// Reset if turned into human
public ze_user_humanized(id)
{
	g_hasLongJump[id] = false
}

// Reset at round start (for everyone)
public event_round_start()
{
	for (new i = 1; i <= 32; i++)
		g_hasLongJump[i] = false
}	
public fw_PlayerPreThink(id)
{
	if (!is_user_alive(id))
		return FMRES_IGNORED
	
	if (allow_LongJump(id))
	{
		static Float:velocity[3]
		velocity_by_aim(id, get_pcvar_num(g_LongJump_force), velocity)
		
		velocity[2] = get_pcvar_float(g_LongJump_height)
		
		set_pev(id, pev_velocity, velocity)
		
		g_last_LongJump_time[id] = get_gametime()
	}
	
	return FMRES_IGNORED
}

// Check if the player can longjump
allow_LongJump(id)
{
	if (!g_hasLongJump[id])
		return false
	
	if (!(pev(id, pev_flags) & FL_ONGROUND) || fm_get_speed(id) < 80)
		return false
	
	static buttons
	buttons = pev(id, pev_button)
	
	if (!is_user_bot(id) && (!(buttons & IN_JUMP) || !(buttons & IN_DUCK)))
		return false
	
	if (get_gametime() - g_last_LongJump_time[id] < get_pcvar_float(g_LongJump_cooldown))
		return false
		
	if(g_last_LongJump_time[id] == get_pcvar_float(g_LongJump_cooldown))
	{
		client_print(id,print_chat,"[ZE] You can use the Leap Jump now.")
		return true
	}
	
	return true
}

// Get entity's speed (from fakemeta_util)
stock fm_get_speed(entity)
{
	static Float:velocity[3]
	pev(entity, pev_velocity, velocity)
	
	return floatround(vector_length(velocity))
}

Code: Select all

AMX Mod X Compiler 1.9.0.5249
Copyright (c) 1997-2006 ITB CompuPhase
Copyright (c) 2004-2013 AMX Mod X Team

Error: Number of arguments does not match definition on line 217

1 Error.
Could not locate output file C:\Users\loulou\Desktop\ze_class_nemesis.amx (compile failed).

Code: Select all

#include <zombie_escape>
 
// Uncomment to use custom model for nemesis
// Note: This includes player model & claws
//#define USE_NEMESIS_MODEL
 
// Uncomment to use leap for nemesis
// Leap code: https://escapers-zone.net/viewtopic.php?p=10582#p10582
//#define USE_NEMESIS_LEAP
 
#define TASK_MAKE_HEROINE 4949849
 
// Access to start nemesis round
#define STARTNEMESIS_ACCESS ADMIN_LEVEL_H
 
#if defined USE_NEMESIS_MODEL
// Settings file
new const ZE_SETTING_FILE[] = "zombie_escape.ini"
 
// Default models
new const g_szModels_Nemesis_Player[][] = { "ze_nemesis_host" }
new const g_szModels_Nemesis_Claws[][] = { "models/zombie_escape/v_knife_nemesis.mdl" }
 
new Array:g_aModels_Nemesis_Player,
    Array:g_aModels_Nemesis_Claws
#endif
 
#if defined USE_NEMESIS_LEAP
native ze_get_longjump(id)
native ze_remove_longjump(id)
#endif
 
enum _:Colors
{
    Red = 0,
    Green,
    Blue
}
 
new bool:g_bIsNemesis[33],
    bool:g_bIsNextRoundNemesis = false,
    g_iNemesisNum = 0
 
new g_pCvarNemesisHP,
    g_pCvarNemesisGravity,
    g_pCvarNemesisSpeed,
    g_pCvarNemesisGlow,
    g_pCvarNemesisGlowColor[Colors],
    g_pCvarNemesisKB,
    g_pCvarNemesisFreeze,
    g_pCvarNemesisFire,
    g_pCvarFreezetime
 
public plugin_natives()
{
    register_native("ze_is_user_nemesis", "native_ze_is_user_nemesis", 1)
    register_native("ze_set_user_nemesis", "native_ze_set_user_nemesis", 1)
    register_native("ze_get_nemesis_number", "native_ze_get_nemesis_number", 1)
}
 
#if defined USE_NEMESIS_MODEL
public plugin_precache()
{
    // Initialize arrays
    g_aModels_Nemesis_Player = ArrayCreate(32, 1)
    g_aModels_Nemesis_Claws = ArrayCreate(64, 1)
   
    // Load from external file
    amx_load_setting_string_arr(ZE_SETTING_FILE, "Player Models", "NEMESIS MODEL", g_aModels_Nemesis_Player)
    amx_load_setting_string_arr(ZE_SETTING_FILE, "Weapon Models", "V_KNIFE NEMESIS", g_aModels_Nemesis_Claws)
   
    // If we couldn't load from file, use and save default ones
    new index
 
    if (ArraySize(g_aModels_Nemesis_Player) == 0)
    {
        for (index = 0; index < sizeof g_szModels_Nemesis_Player; index++)
            ArrayPushString(g_aModels_Nemesis_Player, g_szModels_Nemesis_Player[index])
       
        // Save to external file
        amx_save_setting_string_arr(ZE_SETTING_FILE, "Player Models", "NEMESIS", g_aModels_Nemesis_Player)
    }
 
    if (ArraySize(g_aModels_Nemesis_Claws) == 0)
    {
        for (index = 0; index < sizeof g_szModels_Nemesis_Claws; index++)
            ArrayPushString(g_aModels_Nemesis_Claws, g_szModels_Nemesis_Claws[index])
       
        // Save to external file
        amx_save_setting_string_arr(ZE_SETTING_FILE, "Weapon Models", "V_KNIFE NEMESIS", g_aModels_Nemesis_Claws)
    }
   
    // Precache models
    new player_model[32], model[64], model_path[128]
 
    for (index = 0; index < ArraySize(g_aModels_Nemesis_Player); index++)
    {
        ArrayGetString(g_aModels_Nemesis_Player, index, player_model, charsmax(player_model))
        formatex(model_path, charsmax(model_path), "models/player/%s/%s.mdl", player_model, player_model)
        precache_model(model_path)
        // Support modelT.mdl files
        formatex(model_path, charsmax(model_path), "models/player/%s/%sT.mdl", player_model, player_model)
        if (file_exists(model_path)) precache_model(model_path)
    }
 
    for (index = 0; index < ArraySize(g_aModels_Nemesis_Claws); index++)
    {
        ArrayGetString(g_aModels_Nemesis_Claws, index, model, charsmax(model))
        precache_model(model)
    }
}
#endif
 
public plugin_init()
{
    register_plugin("[ZE] Addons: Nemesis", "1.0", "Jack")
 
    register_clcmd("ze_start_nemesis_next", "cmd_nemesis", STARTNEMESIS_ACCESS)
 
    g_pCvarNemesisHP = register_cvar("ze_nemesis_hp", "20000")  // Nemesis health - Set 0 to use zombie HP
    g_pCvarNemesisGravity = register_cvar("ze_nemesis_gravity", "600")  // Nemesis gravity - Set 0 to use zombie gravity
    g_pCvarNemesisSpeed = register_cvar("ze_nemesis_speed", "300")  // Nemesis speed - Set 0 to use zombie speed
    g_pCvarNemesisGlow = register_cvar("ze_nemesis_glow", "1")  // Nemesis glow - 1 = enable | 0 = disable
    g_pCvarNemesisGlowColor[Red] = register_cvar("ze_nemesis_glow_r", "255")    // Nemesis glow color RED
    g_pCvarNemesisGlowColor[Green] = register_cvar("ze_nemesis_glow_g", "255")  // Nemesis glow color GREEN
    g_pCvarNemesisGlowColor[Blue] = register_cvar("ze_nemesis_glow_b", "255")   // Nemesis glow color BLUE
    g_pCvarNemesisKB = register_cvar("ze_nemesis_kb", "200.0")  // Nemesis knockback - Set 0 to use zombie knockback
    g_pCvarNemesisFreeze = register_cvar("ze_nemesis_freeze", "0")  // Nemesis get frozen? - 1 = doesn't get frozen | 0 = gets frozen
    g_pCvarNemesisFire = register_cvar("ze_nemesis_fire", "1")  // Nemesis set on fire? - 1 = doesn't set on fire | 0 = set on fire
}
 
public plugin_cfg()
{
    g_pCvarFreezetime = get_cvar_pointer("ze_freeze_time")
}
 
public client_disconnected(id)
{
    UnSet_Nemesis(id)
}
 
public client_putinserver(id)
{
    UnSet_Nemesis(id)
}
 
public ze_user_infected_pre(iVictim, iAttacker)
{
    if (g_bIsNemesis[iAttacker] && !ze_is_user_zombie(iVictim))
    {
        ExecuteHamB(Ham_Killed, iVictim, iAttacker, 0)
        return 1
    }
 
    return 0
}
 
public ze_fire_pre(id)
{
    if (g_bIsNemesis[id] && get_pcvar_num(g_pCvarNemesisFire))
        return PLUGIN_HANDLED
    return PLUGIN_CONTINUE
}
 
public ze_frost_pre(id)
{
    if (g_bIsNemesis[id] && get_pcvar_num(g_pCvarNemesisFreeze))
        return PLUGIN_HANDLED
    return PLUGIN_CONTINUE
}
 
public ze_user_humanized(id)
{
    UnSet_Nemesis(id)
}
 
public ze_roundend()
{
    for (new id = 0; id <= get_member_game(m_nMaxPlayers); id++)
    {
        if (is_user_alive(id) && g_bIsNemesis[id])
            UnSet_Nemesis(id)
    }
    g_iNemesisNum = 0
}
 
public ze_game_started_pre()
{
    while (g_bIsNextRoundNemesis)
    {
        g_bIsNextRoundNemesis = false
        ze_colored_print(0, "!tThis is nemesis round.")
        set_task(get_pcvar_float(g_pCvarFreezetime), "ChooseNemesis", TASK_MAKE_HEROINE)
        return PLUGIN_HANDLED
    }
 
    return PLUGIN_CONTINUE
}
 
public ChooseNemesis(taskid)
{
    new iNemesis, id
    
    while (iNemesis < RequiredNemesis())
    {
        id = GetRandomAlive(random_num(1, GetAllAlivePlayersNum()))
        
        if (!is_user_alive(id) || g_bIsNemesis[id])
            continue

        Set_Nemesis(id)
        iNemesis++
    }

    g_iNemesisNum = iNemesis
    remove_task(taskid)
    return
}
 
public cmd_nemesis(id, level, cid)
{
    if (!cmd_access(id, STARTNEMESIS_ACCESS, cid, 0))
    {
        client_print(id, print_console, "You have not access.")
        return PLUGIN_HANDLED
    }
   
    g_bIsNextRoundNemesis = true
    client_print(id, print_console, "Nemesis round will start next round.")
 
    new szName[32]
    get_user_name(id, szName, charsmax(szName))
    ze_colored_print(0, "!g%s !thas activated a nemesis round. Next round is nemesis.", szName)
    return PLUGIN_HANDLED
}
 
public Set_Nemesis(id)
{
    if (g_bIsNemesis[id] || !is_user_alive(id))
        return
 
    g_bIsNemesis[id] = true
 
    if (!ze_is_user_zombie(id))
        ze_set_user_zombie(id)
 
    #if defined USE_NEMESIS_LEAP
        ze_get_longjump(id)
    #endif
 
    #if defined USE_NEMESIS_MODEL
        new szPlayerModel[32], szModel[64]
        ArrayGetString(g_aModels_Nemesis_Player, random_num(0, ArraySize(g_aModels_Nemesis_Player) - 1), szPlayerModel, charsmax(szPlayerModel))
        cs_set_user_model(id, szPlayerModel)
 
        ArrayGetString(g_aModels_Nemesis_Claws, random_num(0, ArraySize(g_aModels_Nemesis_Claws) - 1), szModel, charsmax(szModel))
        cs_set_player_view_model(id, CSW_KNIFE, szModel)
    #endif
   
    if (get_pcvar_float(g_pCvarNemesisHP))
    {
        set_entvar(id, var_health, get_pcvar_float(g_pCvarNemesisHP))
    }
 
    if (get_pcvar_num(g_pCvarNemesisSpeed))
    {
        ze_set_zombie_speed(id, get_pcvar_num(g_pCvarNemesisSpeed))
    }
 
    if (get_pcvar_num(g_pCvarNemesisGravity))
    {
        ze_set_user_gravity(id, get_pcvar_num(g_pCvarNemesisGravity))
    }
 
    if (get_pcvar_num(g_pCvarNemesisKB))
    {
        ze_set_user_knockback(id, get_pcvar_float(g_pCvarNemesisKB))
    }
 
    if (get_pcvar_num(g_pCvarNemesisGlow))
    {
        Set_Rendering(id, kRenderFxNone, 255, 0, 0, kRenderNormal, 15)
    }
 
    new szName[32]
    get_user_name(id, szName, charsmax(szName))
    set_hudmessage(255, 0, 0, -1.0, -1.0, 0, 0.0, 5.0, 0.1, 1.5)
    show_hudmessage(id, "%s became Nemesis", szName)
    ze_colored_print(0, "!g%s !tbecame !gNemesis!n.", szName)
    ze_colored_print(id, "!gYou !tbecame !gNemesis!n.")
}
 
public UnSet_Nemesis(id)
{
    if (!g_bIsNemesis[id] || !is_user_alive(id))
        return
 
    g_bIsNemesis[id] = false
 
    #if defined USE_NEMESIS_LEAP
        ze_remove_longjump(id)
    #endif
 
    if (get_pcvar_num(g_pCvarNemesisSpeed))
    {
        ze_reset_zombie_speed(id)
    }
 
    if (get_pcvar_num(g_pCvarNemesisGravity))
    {
        ze_reset_user_gravity(id)
    }
 
    if (get_pcvar_num(g_pCvarNemesisKB))
    {
        ze_reset_user_knockback(id)
    }
 
    if (get_pcvar_num(g_pCvarNemesisGlow))
    {
        Set_Rendering(id)
    }
}
 
public GetRandomNemesis()
{
    new iPlayers[32], iSelected[33], iCount = 0, iTotalPlayers, iRandomIndex
    get_players(iPlayers, iTotalPlayers)
 
    if (iTotalPlayers > 0)
    {
        for (new i = 0; i < iTotalPlayers; i++)
        {
            iRandomIndex = iPlayers[i]
 
            if (is_user_alive(iRandomIndex))
            {
                iSelected[iCount++] = iRandomIndex
            }
        }
 
        return iSelected[random(--iCount)]
    }
 
    return 0
}
 
public native_ze_is_user_nemesis(id)
{
    if (!is_user_connected(id))
    {
        log_error(AMX_ERR_NATIVE, "[ZE] Invalid Player id (%d)", id)
        return -1
    }
 
    return g_bIsNemesis[id]
}
 
public native_ze_set_user_nemesis(id, bool:set)
{
    if (!is_user_connected(id))
    {
        log_error(AMX_ERR_NATIVE, "[ZE] Invalid Player id (%d)", id)
        return false
    }
 
    if (set)
    {
        if (!g_bIsNemesis[id])
            Set_Nemesis(id)
    }
    else
    {
        if (g_bIsNemesis[id])
            UnSet_Nemesis(id)
    }
 
    return true
}

stock RequiredNemesis()
{
    switch(GetAllAlivePlayersNum())
    {
        case 2..5: return 1
        case 6..15: return 2
        case 16..25: return 3
        case 26..32: return 4
    }
    return 0
}

public native_ze_get_nemesis_number()
{
    return g_iNemesisNum
}