Resolved errors in core

Report bugs to be fixed
Post Reply
czirimbolo
Veteran Member
Veteran Member
Poland
Posts: 477
Joined: 2 Years Ago
Has thanked: 18 times
Been thanked: 1 time
Contact:

errors in core

#1

Post by czirimbolo » 11 Months 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: 2 Years Ago
Location: Egypt
Has thanked: 10 times
Been thanked: 2 times
Age: 17
Contact:

#2

Post by th3_king » 11 Months Ago

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

czirimbolo
Veteran Member
Veteran Member
Poland
Posts: 477
Joined: 2 Years Ago
Has thanked: 18 times
Been thanked: 1 time
Contact:

#3

Post by czirimbolo » 11 Months 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
Egypt
Posts: 1866
Joined: 2 Years Ago
Location: Egypt
Has thanked: 31 times
Been thanked: 98 times
Age: 21
Contact:

#4

Post by Raheem » 11 Months Ago

th3_king wrote:
11 Months 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.
You don't know? Learn and you will know.

Post Reply

Who is online

Users browsing this forum: No registered users and 2 guests