Solved errors in core

Report bugs to be fixed
Post Reply
czirimbolo
Veteran Member
Veteran Member
Poland
Posts: 598
Joined: 7 years ago
Contact:

errors in core

#1

Post by czirimbolo » 5 years ago

hey,

I had some errors:

L 08/11/2018 - 13:31:23: [ReAPI] rg_set_user_team: player 1 is not connected
L 08/11/2018 - 13:31:23: [AMXX] Displaying debug trace (plugin "ze_core.amxx", version "1.3")
L 08/11/2018 - 13:31:23: [AMXX] Run time error 10: native error (native "rg_set_user_team")
L 08/11/2018 - 13:31:23: [AMXX] [0] ze_core.sma::Fw_PlayerSpawn_Post (line 234)
Image

User avatar
th3_king
VIP
VIP
Egypt
Posts: 35
Joined: 6 years ago
Location: Egypt
Contact:

#2

Post by th3_king » 5 years ago

Go type in console FIX IT and it will be FIXED instantly.

czirimbolo
Veteran Member
Veteran Member
Poland
Posts: 598
Joined: 7 years ago
Contact:

#3

Post by czirimbolo » 5 years ago

L 08/14/2018 - 23:15:25: Start of error session.
L 08/14/2018 - 23:15:25: Info (map "ze_campescape_b1") (file "addons/amxmodx/logs/error_20180814.log")
L 08/14/2018 - 23:15:25: [ReAPI] rg_set_user_team: player 3 is not connected
L 08/14/2018 - 23:15:25: [AMXX] Displaying debug trace (plugin "ze_core.amxx", version "1.3")
L 08/14/2018 - 23:15:25: [AMXX] Run time error 10: native error (native "rg_set_user_team")
L 08/14/2018 - 23:15:25: [AMXX] [0] ze_core.sma::Fw_PlayerSpawn_Post (line 234)
Image

User avatar
Raheem
Mod Developer
Mod Developer
Posts: 2214
Joined: 7 years ago
Contact:

#4

Post by Raheem » 5 years ago

th3_king wrote: 5 years ago Go type in console FIX IT and it will be FIXED instantly.

:joy: :joy:

Try this:
  • Code: Select all

    #include <zombie_escape>
    
    // Fowards
    enum _:TOTAL_FORWARDS
    {
    	FORWARD_NONE = 0,
    	FORWARD_ROUNDEND,
    	FORWARD_HUMANIZED,
    	FORWARD_PRE_INFECTED,
    	FORWARD_INFECTED,
    	FORWARD_ZOMBIE_APPEAR,
    	FORWARD_ZOMBIE_RELEASE,
    	FORWARD_GAME_STARTED
    }
    
    new g_iForwards[TOTAL_FORWARDS], g_iFwReturn, g_iTeam
    
    // Tasks IDs
    enum
    {
    	TASK_COUNTDOWN = 1100,
    	TASK_COUNTDOWN2,
    	TASK_SCORE_MESSAGE,
    	FREEZE_ZOMBIES,
    	ROUND_TIME_LEFT
    }
    
    // Colors (g_pCvarColors[] array indexes)
    enum
    {
    	Red = 0,
    	Green,
    	Blue
    }
    
    // Variables
    new g_iAliveHumansNum, 
    	g_iAliveZombiesNum, 
    	g_iRoundTime, 
    	g_iCountDown, 
    	g_iReleaseNotice, 
    	g_iMaxClients, 
    	g_iHumansScore, 
    	g_iZombiesScore, 
    	g_iRoundNum,
    	g_iHSpeedFactor[33],
    	g_iZSpeedSet[33],
    	bool:g_bGameStarted, 
    	bool:g_bIsZombie[33], 
    	bool:g_bIsZombieFrozen[33], 
    	bool:g_bZombieFreezeTime, 
    	bool:g_bIsRoundEnding,
    	bool:g_bHSpeedUsed[33], 
    	bool:g_bZSpeedUsed[33],
    	bool:g_bEndCalled,
    	Float:g_flReferenceTime
    
    // Cvars
    new	g_pCvarHumanSpeedFactor, 
    	g_pCvarHumanGravity, 
    	g_pCvarHumanHealth, 
    	g_pCvarZombieSpeed, 
    	g_pCvarZombieGravity,
    	g_pCvarZombieReleaseTime, 
    	g_pCvarFreezeTime, 
    	g_pCvarRoundTime, 
    	g_pCvarReqPlayers, 
    	g_pCvarZombieHealth, 
    	g_pCvarFirstZombiesHealth,
    	g_pCvarZombieKnockback, 
    	g_pCvarScoreMessageType, 
    	g_pCvarColors[3],
    	g_pCvarRoundEndDelay
    
    public plugin_natives()
    {
    	register_native("ze_is_user_zombie", "native_ze_is_user_zombie", 1)
    	register_native("ze_is_game_started", "native_ze_is_game_started", 1)
    	register_native("ze_is_zombie_frozen", "native_ze_is_zombie_frozen", 1)
    	
    	register_native("ze_get_round_number", "native_ze_get_round_number", 1)
    	register_native("ze_get_humans_number", "native_ze_get_humans_number", 1)
    	register_native("ze_get_zombies_number", "native_ze_get_zombies_number", 1)
    	
    	register_native("ze_set_user_zombie", "native_ze_set_user_zombie", 1)
    	register_native("ze_set_user_human", "native_ze_set_user_human", 1)
    	register_native("ze_set_human_speed_factor", "native_ze_set_human_speed_factor", 1)
    	register_native("ze_set_zombie_speed", "native_ze_set_zombie_speed", 1)
    	
    	register_native("ze_reset_human_speed", "native_ze_reset_human_speed", 1)
    	register_native("ze_reset_zombie_speed", "native_ze_reset_zombie_speed", 1)
    }
    
    public plugin_init()
    {
    	register_plugin("[ZE] Core/Engine", ZE_VERSION, AUTHORS)
    	
    	// Hook Chains
    	RegisterHookChain(RG_CBasePlayer_TraceAttack, "Fw_TraceAttack_Pre", 0)
    	RegisterHookChain(RG_CBasePlayer_TakeDamage, "Fw_TakeDamage_Post", 1)
    	RegisterHookChain(RG_CBasePlayer_Spawn, "Fw_PlayerSpawn_Post", 1)
    	RegisterHookChain(RG_CSGameRules_CheckWinConditions, "Fw_CheckMapConditions_Post", 1)
    	RegisterHookChain(RG_CBasePlayer_Killed, "Fw_PlayerKilled_Post", 1)
    	RegisterHookChain(RG_RoundEnd, "Event_RoundEnd_Pre", 0)
    	
    	// Events
    	register_event("HLTV", "New_Round", "a", "1=0", "2=0")
    	register_event("TextMsg", "Map_Restart", "a", "2=#Game_Commencing", "2=#Game_will_restart_in", "2=#Round_Draw")
    	register_logevent("Round_Start", 2, "1=Round_Start")
    	register_logevent("Round_End", 2, "1=Round_End")
    	
    	// Hams
    	RegisterHam(Ham_Item_PreFrame, "player", "Fw_RestMaxSpeed_Post", 1)
    	
    	// Create Forwards (All Return Values Ignored)
    	g_iForwards[FORWARD_ROUNDEND] = CreateMultiForward("ze_roundend", ET_IGNORE, FP_CELL)
    	g_iForwards[FORWARD_HUMANIZED] = CreateMultiForward("ze_user_humanized", ET_IGNORE, FP_CELL)
    	g_iForwards[FORWARD_PRE_INFECTED] = CreateMultiForward("ze_user_infected_pre", ET_CONTINUE, FP_CELL, FP_CELL, FP_CELL)
    	g_iForwards[FORWARD_INFECTED] = CreateMultiForward("ze_user_infected", ET_IGNORE, FP_CELL, FP_CELL)
    	g_iForwards[FORWARD_ZOMBIE_APPEAR] = CreateMultiForward("ze_zombie_appear", ET_IGNORE)
    	g_iForwards[FORWARD_ZOMBIE_RELEASE] = CreateMultiForward("ze_zombie_release", ET_IGNORE)
    	g_iForwards[FORWARD_GAME_STARTED] = CreateMultiForward("ze_game_started", ET_IGNORE)
    	
    	// Hud Messages
    	g_iReleaseNotice = CreateHudSyncObj()
    	
    	// Sequential files (.txt)
    	register_dictionary("zombie_escape.txt")
    	
    	// Humans Cvars
    	g_pCvarHumanSpeedFactor = register_cvar("ze_human_speed_factor", "20.0")
    	g_pCvarHumanGravity = register_cvar("ze_human_gravity", "800")
    	g_pCvarHumanHealth = register_cvar("ze_human_health", "1000")
    	
    	// Zombie Cvars
    	g_pCvarZombieSpeed = register_cvar("ze_zombie_speed", "350.0")
    	g_pCvarZombieGravity = register_cvar("ze_zombie_gravity", "640")
    	g_pCvarZombieHealth = register_cvar("ze_zombie_health", "10000")
    	g_pCvarFirstZombiesHealth = register_cvar("ze_first_zombies_health", "20000")
    	g_pCvarZombieKnockback = register_cvar("ze_zombie_knockback", "300.0")
    	
    	// General Cvars
    	g_pCvarZombieReleaseTime = register_cvar("ze_release_time", "15")
    	g_pCvarFreezeTime = register_cvar("ze_freeze_time", "20")
    	g_pCvarRoundTime = register_cvar("ze_round_time", "9.0")
    	g_pCvarReqPlayers = register_cvar("ze_required_players", "2")
    	g_pCvarScoreMessageType = register_cvar("ze_score_message_type", "1")
    	g_pCvarColors[Red] = register_cvar("ze_score_message_red", "200")
    	g_pCvarColors[Green] = register_cvar("ze_score_message_green", "100")
    	g_pCvarColors[Blue] = register_cvar("ze_score_message_blue", "0")
    	g_pCvarRoundEndDelay = register_cvar("ze_round_end_delay", "5")
    	
    	// Default Values
    	g_bGameStarted = false
    	
    	// Static Values
    	g_iMaxClients = get_member_game(m_nMaxPlayers)
    	
    	// Check Round Time to Terminate it
    	set_task(1.0, "Check_RoundTimeleft", ROUND_TIME_LEFT, _, _, "b")
    }
    
    public plugin_cfg()
    {
    	// Get our configiration file and Execute it
    	new szCfgDir[64]
    	get_localinfo("amxx_configsdir", szCfgDir, charsmax(szCfgDir))
    	server_cmd("exec %s/zombie_escape.cfg", szCfgDir)
    	
    	// Set Game Name
    	new szGameName[64]
    	formatex(szGameName, sizeof(szGameName), "Zombie Escape v%s", ZE_VERSION)
    	set_member_game(m_GameDesc, szGameName)
    	
    	// Set Version
    	register_cvar("ze_version", ZE_VERSION, FCVAR_SERVER|FCVAR_SPONLY)
    	set_cvar_string("ze_version", ZE_VERSION)
    }
    
    public Fw_CheckMapConditions_Post()
    {
    	// Block Game Commencing
    	set_member_game(m_bGameStarted, true)
    	
    	// Set Freeze Time
    	set_member_game(m_iIntroRoundTime, get_pcvar_num(g_pCvarFreezeTime))
    	
    	// Set Round Time
    	set_member_game(m_iRoundTime, floatround(get_pcvar_float(g_pCvarRoundTime) * 60.0))
    }
    
    public Fw_PlayerKilled_Post(id)
    {
    	g_iAliveHumansNum = GetAlivePlayersNum(CsTeams:TEAM_CT)
    	g_iAliveZombiesNum = GetAlivePlayersNum(CsTeams:TEAM_TERRORIST)
    	
    	if (g_iAliveHumansNum == 0 && g_iAliveZombiesNum == 0)
    	{
    		// No Winner, All Players in one team killed Or Both teams Killed
    		client_print(0, print_center, "%L", LANG_PLAYER, "NO_WINNER")
    	}
    }
    
    public Fw_RestMaxSpeed_Post(id)
    {
    	if (!g_bIsZombie[id])
    	{
    		static Float:flMaxSpeed
    		get_entvar(id, var_maxspeed, flMaxSpeed)
    		
    		if (flMaxSpeed != 1.0 && is_user_alive(id))
    		{
    			if (g_bHSpeedUsed[id])
    			{
    				// Set New Human Speed Factor
    				set_entvar(id, var_maxspeed, flMaxSpeed + float(g_iHSpeedFactor[id]))
    				return HAM_IGNORED
    			}
    				
    			// Set Human Speed Factor, native not used
    			set_entvar(id, var_maxspeed, flMaxSpeed + get_pcvar_float(g_pCvarHumanSpeedFactor))
    			return HAM_IGNORED
    		}
    	}
    	
    	return HAM_SUPERCEDE
    }
    
    public Fw_PlayerSpawn_Post(id)
    {
    	if (!is_user_connected(id))
    		return;
    	
    	if (!g_bGameStarted)
    	{
    		// Force All player to be Humans if Game not started yet
    		rg_set_user_team(id, TEAM_CT, MODEL_UNASSIGNED)
    	}
    	else
    	{
    		if (get_member_game(m_bFreezePeriod))
    		{
    			// Respawn Him As human if we are in freeze time (Zombie Not Chosen yet)
    			Set_User_Human(id)
    			g_bIsZombieFrozen[id] = false
    		}
    		else
    		{
    			if (g_bZombieFreezeTime)
    			{
    				// Zombie Chosen and zombies Frozen, Spawn him as zombie and Freeze Him
    				Set_User_Zombie(id)
    				g_bIsZombieFrozen[id] = true
    				set_entvar(id, var_maxspeed, 1.0)
    			}
    			else
    			{
    				// Respawn him as normal zombie
    				Set_User_Zombie(id)
    				g_bIsZombieFrozen[id] = false
    			}
    		}
    	}
    }
    
    public New_Round()
    {
    	// Remove All tasks in the New Round
    	remove_task(TASK_COUNTDOWN)
    	remove_task(TASK_COUNTDOWN2)
    	remove_task(TASK_SCORE_MESSAGE)
    	remove_task(FREEZE_ZOMBIES)
    	
    	// Score Message Task
    	set_task(10.0, "Score_Message", TASK_SCORE_MESSAGE, _, _, "b")
    	
    	// 2 is Hardcoded Value, It's Fix for the countdown to work correctly
    	g_iCountDown = get_member_game(m_iIntroRoundTime) - 2
    	
    	if (!g_bGameStarted)
    	{
    		// No Enough Players
    		ze_colored_print(0, "%L", LANG_PLAYER, "NO_ENOUGH_PLAYERS", get_pcvar_num(g_pCvarReqPlayers))
    		return // Block the execution of the blew code 
    	}
    	
    	// Game Already started, Countdown now started
    	set_task(1.0, "Countdown_Start", TASK_COUNTDOWN, _, _, "b")
    	ze_colored_print(0, "%L", LANG_PLAYER, "READY_TO_RUN")
    	ExecuteForward(g_iForwards[FORWARD_GAME_STARTED], g_iFwReturn)
    	
    	g_iRoundNum++
    	
    	// Round Starting
    	g_bIsRoundEnding = false
    	g_bEndCalled = false
    }
    
    // Score Message Task
    public Score_Message(TaskID)
    {
    	switch(get_pcvar_num(g_pCvarScoreMessageType))
    	{
    		case 0: // Disabled
    		{
    			return
    		}
    		case 1: // DHUD
    		{
    			set_dhudmessage(get_pcvar_num(g_pCvarColors[Red]), get_pcvar_num(g_pCvarColors[Green]), get_pcvar_num(g_pCvarColors[Blue]), -1.0, 0.01, 0, 0.0, 9.0)
    			show_dhudmessage(0, "%L", LANG_PLAYER, "SCORE_MESSAGE", g_iZombiesScore, g_iHumansScore)
    		}
    		case 2: // HUD
    		{
    			set_hudmessage(get_pcvar_num(g_pCvarColors[Red]), get_pcvar_num(g_pCvarColors[Green]), get_pcvar_num(g_pCvarColors[Blue]), -1.0, 0.01, 0, 0.0, 9.0)
    			show_hudmessage(0, "%L", LANG_PLAYER, "SCORE_MESSAGE", g_iZombiesScore, g_iHumansScore)
    		}
    	}
    }
    
    public Countdown_Start(TaskID)
    {
    	// Check if the players Disconnected and there is only one player then remove all messages, and stop tasks
    	if (!g_bGameStarted)
    		return
    	
    	if (!g_iCountDown)
    	{
    		Choose_Zombies()
    		remove_task(TASK_COUNTDOWN) // Remove the task
    		return // Block the execution of the blew code
    	}
    	
    	set_hudmessage(random(256), random(256), random(256), -1.0, 0.21, 0, 0.8, 0.8)
    	show_hudmessage(0, "%L", LANG_PLAYER, "RUN_NOTICE", g_iCountDown)
    
    	g_iCountDown--
    }
    
    public Choose_Zombies()
    {
    	new iZombies, id, iAliveCount
    	new iReqZombies
    	
    	// Get total alive players and required players
    	iAliveCount  = GetAllAlivePlayersNum()
    	iReqZombies = RequiredZombies()
    	
    	// Loop till we find req players
    	while(iZombies < iReqZombies)
    	{
    		id = GetRandomAlive(random_num(1, iAliveCount))
    		
    		if (!is_user_alive(id) || g_bIsZombie[id])
    			continue
    
    		Set_User_Zombie(id)
    		set_entvar(id, var_health, get_pcvar_float(g_pCvarFirstZombiesHealth))
    		g_bIsZombieFrozen[id] = true
    		g_bZombieFreezeTime = true
    		set_entvar(id, var_maxspeed, 1.0)
    		set_task(0.1, "Freeze_Zombies", FREEZE_ZOMBIES, _, _, "b") // Better than PreThink
    		ExecuteForward(g_iForwards[FORWARD_ZOMBIE_APPEAR], g_iFwReturn)
    		iZombies++
    	}
    	
    	// 2 is Hardcoded Value, It's Fix for the countdown to work correctly
    	g_iCountDown = get_pcvar_num(g_pCvarZombieReleaseTime) - 2
    	
    	set_task(1.0, "ReleaseZombie_CountDown", TASK_COUNTDOWN2, _, _, "b")
    }
    
    public ReleaseZombie_CountDown(TaskID)
    {
    	if (!g_iCountDown)
    	{
    		ReleaseZombie()
    		remove_task(TASK_COUNTDOWN2)
    		return
    	}
    	
    	// Release Hud Message
    	set_hudmessage(255, 255, 0, -1.0, 0.21, 1, 2.0, 2.0)
    	ShowSyncHudMsg(0, g_iReleaseNotice, "%L", LANG_PLAYER, "ZOMBIE_RELEASE", g_iCountDown)
    	
    	g_iCountDown --
    }
    
    public ReleaseZombie()
    {
    	ExecuteForward(g_iForwards[FORWARD_ZOMBIE_RELEASE], g_iFwReturn)
    	
    	for(new id = 1; id <= g_iMaxClients; id++)
    	{
    		if (is_user_alive(id) && g_bIsZombie[id])
    		{
    			g_bIsZombieFrozen[id] = false
    			g_bZombieFreezeTime = false
    		}
    	}
    }
    
    public Freeze_Zombies(TaskID)
    {
    	for(new id = 1; id <= g_iMaxClients; id++)
    	{
    		if(!is_user_alive(id) || !g_bIsZombie[id])
    			continue
    		
    		if (g_bIsZombieFrozen[id])
    		{
    			// Zombie & Frozen, then Freeze him
    			set_entvar(id, var_maxspeed, 1.0)
    		}
    		else
    		{
    			if (g_bZSpeedUsed[id])
    			{
    				// Zombie but Not Frozen the set his speed form .cfg
    				set_entvar(id, var_maxspeed, float(g_iZSpeedSet[id]))
    				continue;
    			}
    				
    			// Zombie but Not Frozen the set his speed form .cfg
    			set_entvar(id, var_maxspeed, get_pcvar_float(g_pCvarZombieSpeed))
    		}
    	}
    }
    
    public Fw_TraceAttack_Pre(iVictim, iAttacker, Float:flDamage, Float:flDirection[3], iTracehandle, bitsDamageType)
    {
    	if (iVictim == iAttacker || !is_user_connected(iVictim) || !is_user_connected(iAttacker))
    		return HC_CONTINUE
    	
    	// Attacker and Victim is in same teams? Skip code blew
    	if (get_member(iAttacker, m_iTeam) == get_member(iVictim, m_iTeam))
    		return HC_CONTINUE
    	
    	// In freeze time? Skip all other plugins (Skip the real trace attack event)
    	if (g_bIsZombieFrozen[iVictim] || g_bIsZombieFrozen[iAttacker])
    		return HC_SUPERCEDE
    	
    	// Execute pre-infection forward
    	ExecuteForward(g_iForwards[FORWARD_PRE_INFECTED], g_iFwReturn, iVictim, iAttacker, floatround(flDamage))
    	
    	if (g_iFwReturn > 0)
    	{
    		return HC_SUPERCEDE
    	}
    	
    	g_iAliveHumansNum = GetAlivePlayersNum(CsTeams:TEAM_CT)
    	
    	if (g_bIsZombie[iAttacker])
    	{
    		// Death Message with Infection style [Added here because of delay in Forward use]
    		SendDeathMsg(iAttacker, iVictim)
    		
    		Set_User_Zombie(iVictim)
    		
    		ExecuteForward(g_iForwards[FORWARD_INFECTED], g_iFwReturn, iVictim, iAttacker)
    		
    		if (g_iAliveHumansNum == 1) // Check if this is Last Human, Because of Delay i can't check if it's 0 instead of 1
    		{
    			// End round event called one time
    			g_bEndCalled = true
    			
    			// Round is Ending
    			g_bIsRoundEnding = true
    			
    			// Zombie Win, Leave text blank so we use ours from ML
    			rg_round_end(get_pcvar_float(g_pCvarRoundEndDelay), WINSTATUS_TERRORISTS, ROUND_TERRORISTS_WIN, "")
    			
    			// Show Our Message
    			client_print(0, print_center, "%L", LANG_PLAYER, "ESCAPE_FAIL")
    			
    			// This needed so forward work also to add +1 for Zombies
    			g_iTeam = 1 // ZE_TEAM_ZOMBIE
    			ExecuteForward(g_iForwards[FORWARD_ROUNDEND], g_iFwReturn, g_iTeam)
    		}
    	}
    	
    	return HC_CONTINUE
    }
    
    public Fw_TakeDamage_Post(iVictim, iInflictor, iAttacker, Float:fDamage, bitsDamageType)
    {
    	// Not Vaild Victim or Attacker so skip the event (Important to block out bounds errors)
    	if (!is_user_connected(iVictim) || !is_user_connected(iAttacker))
    		return HC_CONTINUE
    	
    	// Set Knockback here, So if we blocked damage in TraceAttack event player won't get knockback (Fix For Madness)
    	if (g_bIsZombie[iVictim] && !g_bIsZombie[iAttacker])
    	{
    		// Remove Shock Pain
    		set_member(iVictim, m_flVelocityModifier, 1.0)
    		
    		// Set Knockback
    		static Float:flOrigin[3]
    		get_entvar(iAttacker, var_origin, flOrigin)
    		Set_Knockback(iVictim, flOrigin, get_pcvar_float(g_pCvarZombieKnockback), 2)
    	}
    	
    	return HC_CONTINUE
    }
    
    public Round_End()
    {
    	g_iAliveZombiesNum = GetAlivePlayersNum(CsTeams:TEAM_TERRORIST)
    	
    	if (g_iAliveZombiesNum == 0 && g_bGameStarted) 
    	{
    		g_iTeam = 2 // ZE_TEAM_HUMAN
    		ExecuteForward(g_iForwards[FORWARD_ROUNDEND], g_iFwReturn, g_iTeam)
    		client_print(0, print_center, "%L", LANG_PLAYER, "ESCAPE_SUCCESS")
    		g_iHumansScore++
    		g_bIsRoundEnding = true
    		return // To block Execute the code blew
    	}
    	
    	g_iTeam = 1 // ZE_TEAM_ZOMBIE
    	g_iZombiesScore++
    	g_bIsRoundEnding = true
    	
    	// If it's already called one time, don't call it again
    	if (!g_bEndCalled)
    	{
    		ExecuteForward(g_iForwards[FORWARD_ROUNDEND], g_iFwReturn, g_iTeam)
    	}
    	
    	client_print(0, print_center, "%L", LANG_PLAYER, "ESCAPE_FAIL")
    }
    
    public Event_RoundEnd_Pre(WinStatus:status, ScenarioEventEndRound:event, Float:tmDelay)
    {
    	// The two unhandeld cases by rg_round_end() native in our Mod
    	if (event == ROUND_CTS_WIN || event == ROUND_TERRORISTS_WIN)
    	{
    		SetHookChainArg(3, ATYPE_FLOAT, get_pcvar_float(g_pCvarRoundEndDelay))
    	}
    }
    
    public Round_Start()
    {
        g_flReferenceTime = get_gametime()
        g_iRoundTime = get_member_game(m_iRoundTime)
    }
    
    public Check_RoundTimeleft()
    {
    	new Float:flRoundTimeLeft = (g_flReferenceTime + float(g_iRoundTime)) - get_gametime()
    	
    	if (floatround(flRoundTimeLeft) == 0)
    	{
    		// Round is Ending
    		g_bIsRoundEnding = true
    		
    		// If Time is Out then Terminate the Round
    		rg_round_end(get_pcvar_float(g_pCvarRoundEndDelay), WINSTATUS_TERRORISTS, ROUND_TERRORISTS_WIN, "")
    		
    		// Show our Message
    		client_print(0, print_center, "%L", LANG_PLAYER, "ESCAPE_FAIL")
    	}
    }
    
    public client_disconnected(id)
    {
    	// Delay Then Check Players to Terminate The round (Delay needed)
    	set_task(0.1, "Check_AlivePlayers")
    	
    	// Reset speed for this dropped id
    	g_bHSpeedUsed[id] = false
    	g_bZSpeedUsed[id] = false
    }
    
    // This check done when player disconnect
    public Check_AlivePlayers()
    {
    	g_iAliveZombiesNum = GetAlivePlayersNum(CsTeams:TEAM_TERRORIST)
    	g_iAliveHumansNum = GetAlivePlayersNum(CsTeams:TEAM_CT)
    	
    	// Game Started? (There is at least 2 players Alive?)
    	if (g_bGameStarted)
    	{
    		// We are in freeze time?
    		if (get_member_game(m_bFreezePeriod))
    		{
    			// Humans alive number = 1 and no zombies?
    			if (g_iAliveHumansNum < get_pcvar_num(g_pCvarReqPlayers))
    			{
    				// Game started false again
    				g_bGameStarted = false
    			}
    		}
    		else // Not freeze time?
    		{
    			// Variables
    			new iAllZombiesNum = GetTeamPlayersNum(CsTeams:TEAM_TERRORIST),
    			iAllHumansNum = GetTeamPlayersNum(CsTeams:TEAM_CT),
    			iDeadZombiesNum = GetDeadPlayersNum(CsTeams:TEAM_TERRORIST),
    			iDeadHumansNum = GetDeadPlayersNum(CsTeams:TEAM_CT)
    	
    			// Alive humans number = 1 and no zombies at all, And no dead humans?
    			if (g_iAliveHumansNum < get_pcvar_num(g_pCvarReqPlayers) && iDeadHumansNum == 0 && iAllZombiesNum == 0)
    			{
    				// Game started is false and humans wins (Escape Success)
    				g_bGameStarted = false
    				rg_round_end(get_pcvar_float(g_pCvarRoundEndDelay), WINSTATUS_CTS, ROUND_CTS_WIN, "")
    				client_print(0, print_center, "%L", LANG_PLAYER, "ESCAPE_SUCCESS")
    			}
    			
    			// Alive zombies number = 1 and no humans at all, And no dead zombies?
    			if (g_iAliveZombiesNum < get_pcvar_num(g_pCvarReqPlayers) && iDeadZombiesNum == 0 && iAllHumansNum == 0)
    			{
    				// Game started is false and zombies wins (Escape Fail)
    				g_bGameStarted = false
    				rg_round_end(get_pcvar_float(g_pCvarRoundEndDelay), WINSTATUS_TERRORISTS, ROUND_TERRORISTS_WIN, "")
    				client_print(0, print_center, "%L", LANG_PLAYER, "ESCAPE_FAIL")
    			}
    			
    			// Humans number more than 1 and no zombies?
    			if (g_iAliveHumansNum >= get_pcvar_num(g_pCvarReqPlayers) && g_iAliveZombiesNum == 0 && !g_bIsRoundEnding)
    			{
    				// Then Escape success as there is no Zombies
    				rg_round_end(get_pcvar_float(g_pCvarRoundEndDelay), WINSTATUS_CTS, ROUND_CTS_WIN, "")
    				client_print(0, print_center, "%L", LANG_PLAYER, "ESCAPE_SUCCESS")
    			}
    			
    			// Zombies number more than 1 and no humans?
    			if (g_iAliveZombiesNum >= get_pcvar_num(g_pCvarReqPlayers) && g_iAliveHumansNum == 0 && !g_bIsRoundEnding)
    			{
    				// Then Escape Fail as there is no humans
    				rg_round_end(get_pcvar_float(g_pCvarRoundEndDelay), WINSTATUS_TERRORISTS, ROUND_TERRORISTS_WIN, "")
    				client_print(0, print_center, "%L", LANG_PLAYER, "ESCAPE_FAIL")
    			}
    		}
    	}
    }
    
    public client_putinserver(id)
    {
    	// Add Delay and Check Conditions To start the Game (Delay needed)
    	set_task(1.0, "Check_AllPlayersNumber", _, _, _, "b")
    }
    
    public Check_AllPlayersNumber(TaskID)
    {
    	if (g_bGameStarted)
    	{
    		// If game started remove the task and block the blew Checks
    		remove_task(TaskID)
    		return
    	}
    	
    	if (GetAllAlivePlayersNum() >= get_pcvar_num(g_pCvarReqPlayers))
    	{
    		// Players In server == The Required so game started is true
    		g_bGameStarted = true
    		
    		// Restart the game
    		server_cmd("sv_restart 2")
    		
    		// Print Fake game Commencing Message
    		client_print(0, print_center, "%L", LANG_PLAYER, "START_GAME")
    		
    		// Remove the task
    		remove_task(TaskID)
    	}
    }
    
    public Set_User_Human(id)
    {
    	if (!is_user_alive(id))
    		return
    	
    	g_bIsZombie[id] = false
    	set_entvar(id, var_health, get_pcvar_float(g_pCvarHumanHealth))
    	set_entvar(id, var_gravity, get_pcvar_float(g_pCvarHumanGravity)/800.0)
    	ExecuteForward(g_iForwards[FORWARD_HUMANIZED], g_iFwReturn, id)
    	
    	if (get_member(id, m_iTeam) != TEAM_CT)
    		rg_set_user_team(id, TEAM_CT, MODEL_UNASSIGNED)
    }
    
    public Set_User_Zombie(id)
    {
    	if (!is_user_alive(id))
    		return
    	
    	g_bIsZombie[id] = true
    	set_entvar(id, var_health, get_pcvar_float(g_pCvarZombieHealth))
    	set_entvar(id, var_gravity, get_pcvar_float(g_pCvarZombieGravity)/800.0)
    	rg_remove_all_items(id)
    	rg_give_item(id, "weapon_knife", GT_APPEND)
    	ExecuteForward(g_iForwards[FORWARD_INFECTED], g_iFwReturn, id, 0)
    	
    	if (get_member(id, m_iTeam) != TEAM_TERRORIST)
    		rg_set_user_team(id, TEAM_TERRORIST, MODEL_UNASSIGNED)
    }
    
    public Map_Restart()
    {
    	// Add Delay To help Rest Scores if player kill himself, and there no one else him so round draw (Delay needed)
    	set_task(0.1, "Reset_Score_Message")
    }
    
    public Reset_Score_Message()
    {
    	g_iHumansScore = 0
    	g_iZombiesScore = 0
    	g_iRoundNum = 0
    }
    
    // Natives
    public native_ze_is_user_zombie(id)
    {
    	if (!is_user_connected(id))
    	{
    		return -1;
    	}
    	
    	return g_bIsZombie[id]
    }
    
    public native_ze_set_user_zombie(id)
    {
    	if (!is_user_connected(id))
    	{
    		log_error(AMX_ERR_NATIVE, "[ZE] Invalid Player id (%d)", id)
    		return false;
    	}
    	
    	Set_User_Zombie(id)
    	return true;
    }
    
    public native_ze_set_user_human(id)
    {
    	if (!is_user_connected(id))
    	{
    		log_error(AMX_ERR_NATIVE, "[ZE] Invalid Player id (%d)", id)
    		return false;
    	}
    	
    	Set_User_Human(id)
    	return true;
    }
    
    public native_ze_is_game_started()
    {
    	return g_bGameStarted
    }
    
    public native_ze_is_zombie_frozen(id)
    {
    	if (!is_user_connected(id) || !g_bIsZombie[id])
    	{
    		return -1;
    	}
    	
    	return g_bIsZombieFrozen[id]
    }
    
    public native_ze_get_round_number()
    {
    	if (!g_bGameStarted)
    	{
    		return -1;
    	}
    	
    	return g_iRoundNum
    }
    
    public native_ze_get_humans_number()
    {
    	return GetAlivePlayersNum(CsTeams:TEAM_CT)
    }
    
    public native_ze_get_zombies_number()
    {
    	return GetAlivePlayersNum(CsTeams:TEAM_TERRORIST)
    }
    
    public native_ze_set_human_speed_factor(id, iFactor)
    {
    	if (!is_user_connected(id))
    	{
    		log_error(AMX_ERR_NATIVE, "[ZE] Invalid Player id (%d)", id)
    		return false;
    	}
    	
    	g_bHSpeedUsed[id] = true
    	g_iHSpeedFactor[id] = iFactor
    	ExecuteHamB(Ham_Item_PreFrame, id)
    	return true;
    }
    
    public native_ze_reset_human_speed(id)
    {
    	if (!is_user_connected(id))
    	{
    		log_error(AMX_ERR_NATIVE, "[ZE] Invalid Player id (%d)", id)
    		return false;
    	}
    	
    	g_bHSpeedUsed[id] = false
    	ExecuteHamB(Ham_Item_PreFrame, id)
    	return true;
    }
    
    public native_ze_set_zombie_speed(id, iSpeed)
    {
    	if (!is_user_connected(id))
    	{
    		log_error(AMX_ERR_NATIVE, "[ZE] Invalid Player id (%d)", id)
    		return false;
    	}
    	
    	g_bZSpeedUsed[id] = true
    	g_iZSpeedSet[id] = iSpeed
    	return true;
    }
    
    public native_ze_reset_zombie_speed(id)
    {
    	if (!is_user_connected(id))
    	{
    		log_error(AMX_ERR_NATIVE, "[ZE] Invalid Player id (%d)", id)
    		return false;
    	}
    	
    	g_bZSpeedUsed[id] = false
    	return true;
    }
Will add this officially if more members reports it.
He who fails to plan is planning to fail

Post Reply

Create an account or sign in to join the discussion

You need to be a member in order to post a reply

Create an account

Not a member? register to join our community
Members can start their own topics & subscribe to topics
It’s free and only takes a minute

Register

Sign in

Who is online

Users browsing this forum: No registered users and 4 guests