Raised This Month: $ Target: $400
 0% 

I'm trying to compile plugins of pug mod


  
 
 
Thread Tools Display Modes
Prev Previous Post   Next Post Next
Author Message
iagopuma
Junior Member
Join Date: May 2011
Old 11-06-2014 , 17:58   I'm trying to compile plugins of pug mod
Reply With Quote #1

I've tried to compile plugins from this pug mod and have some errors, you could help me?



pug_aux.sma
Code:
#include <amxmodx>
#include <amxmisc>

#pragma semicolon 1

#include <pug_const>
#include <pug_modspecific>
#include <pug_forwards>
#include <pug_stocks>

new g_iHits[33][33];
new g_iDamage[33][33];

new bool:g_bInRound = true;

new g_sMOTD[1600];
new g_sMOTD1[1600];

public plugin_init()
{
	register_plugin("Pug Mod (Aux)",AMXX_VERSION_STR,"Twilight Suzuka");
	
	register_dictionary("pug.txt");
	register_dictionary("pug_aux.txt");
	
	PugRegisterCommand("hp","PugCommandHP",ADMIN_ALL,"HP do time oposto");
	PugRegisterCommand("dmg","PugCommandDamage",ADMIN_ALL,"Dano do round");
	PugRegisterCommand("rdmg","PugCommandRecivedDamage",ADMIN_ALL,"Dano recebido");
	PugRegisterCommand("sum","PugCommandSummary",ADMIN_ALL,"Resumo do round");
	
	PugRegisterCommand("help","PugCommandClient",ADMIN_ALL,"Comandos do cliente");
	PugRegisterAdminCommand("help","PugCommandAdmin",PUG_CMD_LVL,"Comandos do Admin");
}

public plugin_cfg()
{
	PugLoadHelp(ADMIN_ALL);
	PugLoadHelp(PUG_CMD_LVL);
}

public client_putinserver(id) 
{
	arrayset(g_iHits[id],0,sizeof(g_iHits));
	arrayset(g_iDamage[id],0,sizeof(g_iDamage)); 
}

public client_disconnect(id)
{
	for(new i;i < sizeof(g_iHits);i++)
	{
		g_iHits[i][id] = 0;
		g_iDamage[i][id] = 0;
	}
}

public PugLoadHelp(iFlag)
{
	new sCommand[16],sInfo[128],iFlags,iCommands;
	
	if(iFlag == ADMIN_ALL)
	{
		formatex(g_sMOTD,charsmax(g_sMOTD),"<style type='text/css'>body{background:#000;margin:2px;color:#FFB000;font:normal 6px/6px Lucida Console;}</style><table width='100%%'>");
		
		iCommands = get_concmdsnum(iFlag);
		
		for(new i;i < iCommands;i++)
		{
			get_concmd(i,sCommand,charsmax(sCommand),iFlags,sInfo,charsmax(sInfo),iFlag,-1);
			
			if(sCommand[0] == '.')
			{
				replace_all(sInfo,sizeof(sInfo),"<","<");
				replace_all(sInfo,sizeof(sInfo),">",">");
				
				format(g_sMOTD,charsmax(g_sMOTD),"%s<tr><td>%s</td><td>%s</td></tr>",g_sMOTD,sCommand,sInfo);
			}
		}
	}
	else if(iFlag == PUG_CMD_LVL)
	{
		formatex(g_sMOTD1,charsmax(g_sMOTD1),"<style type='text/css'>body{background:#000;margin:2px;color:#FFB000;font:normal 6px/6px Lucida Console;}</style><table width='100%%'>");
		
		iCommands = get_concmdsnum(iFlag);
		
		for(new i;i < iCommands;i++)
		{
			get_concmd(i,sCommand,charsmax(sCommand),iFlags,sInfo,charsmax(sInfo),iFlag,-1);
			
			if(sCommand[0] == '!')
			{
				replace_all(sInfo,sizeof(sInfo),"<","<");
				replace_all(sInfo,sizeof(sInfo),">",">");
				
				format(g_sMOTD1,charsmax(g_sMOTD1),"%s<tr><td>%s</td><td>%s</td></tr>",g_sMOTD1,sCommand,sInfo);
			}
		}
	}
}

public PugRoundStart()
{
	g_bInRound = true;
	
	for(new i;i < sizeof(g_iHits);i++)
	{
		arrayset(g_iHits[i],0,sizeof(g_iHits));	
		arrayset(g_iDamage[i],0,sizeof(g_iDamage));	
	}
}

public PugRoundStartFailed()
{
	g_bInRound = true;
	
	for(new i;i < sizeof(g_iHits);i++)
	{
		arrayset(g_iHits[i],0,sizeof(g_iHits));	
		arrayset(g_iDamage[i],0,sizeof(g_iDamage));	
	}
}

public PugRoundEnd(iWinner)
{
	g_bInRound = false;
}

public PugRoundEndFailed()
{
	g_bInRound = false;
}

public  client_damage(iAttacker,iVictim,iDamage,iWeapon,iPlace,TA)
{
	g_iHits[iAttacker][iVictim]++;
	g_iDamage[iAttacker][iVictim] += iDamage;
}

public PugCommandHP(id)
{
	if(GET_PUG_STATUS() == PUG_STATUS_LIVE)
	{
		if(is_user_alive(id) && g_bInRound)
		{
			client_print_color(id,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_CMD_NOTALLOWED");
		}
		else
		{
			new iPlayers[32],iNum,iPlayer;
			get_players(iPlayers,iNum,"ah");
			
			if(!iNum) PugMessage(id,"PUG_AUX_HP_ALIVE");
			
			new sName[32];
			new iTeam = PugGetClientTeam(id);
			
			for(new i;i < iNum;i++)
			{
				iPlayer = iPlayers[i];
				
				if(iTeam != PugGetClientTeam(iPlayer))
				{
					get_user_name(iPlayer,sName,charsmax(sName));
				    
					client_print_color
					(
						id,
						print_team_grey,
						"^4%s^1 %L",
						g_sHead,
						LANG_SERVER,
						"PUG_AUX_HP",
						sName,
						get_user_health(iPlayer),
						get_user_armor(iPlayer)
					);
				}
			}
		}
	}
	else client_print_color(id,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_CMD_NOTALLOWED");
	
	return PLUGIN_HANDLED;
}

public PugCommandDamage(id)
{
	if(GET_PUG_STATUS() == PUG_STATUS_LIVE)
	{
		if(is_user_alive(id) && g_bInRound)
		{
			client_print_color(id,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_CMD_NOTALLOWED");
		}
		else
		{
			new iPlayers[32],iNum,iPlayer;
			get_players(iPlayers,iNum,"h");
			
			new sName[32];
			new iDmg,iHit,iCheck;
			
			for(new i;i < iNum;i++)
			{
				iPlayer = iPlayers[i];
				iHit = g_iHits[id][iPlayer];
				
				if(iHit)
				{
					++iCheck;
					iDmg = g_iDamage[id][iPlayer];
					
					if(iPlayer == id)
					{
						client_print_color
						(
							id,
							print_team_grey,
							"^4%s^1 %L",
							g_sHead,
							LANG_SERVER,
							"PUG_AUX_DMG_SELF",
							iHit,
							(iHit > 1) ? "vezes" : "vez",
							iDmg
						);
					}
					else
					{
						get_user_name(iPlayer,sName,charsmax(sName));
						
						client_print_color
						(
							id,
							print_team_grey,
							"^4%s^1 %L",
							g_sHead,
							LANG_SERVER,
							"PUG_AUX_DMG",
							sName,
							iHit,
							(iHit > 1) ? "vezes" : "vez",
							iDmg
						);
					}
				}
			}
			
			if(!iCheck)
			{	
				client_print_color
				(
					id,
					print_team_grey,
					"^4%s^1 %L",
					g_sHead,
					LANG_SERVER,
					"PUG_AUX_NODMG"
				);
			}
		}
	}
	else client_print_color(id,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_CMD_NOTALLOWED");
	
	return PLUGIN_HANDLED;
}

public PugCommandRecivedDamage(id)
{
	if(GET_PUG_STATUS() == PUG_STATUS_LIVE)
	{
		if(is_user_alive(id) && g_bInRound)
		{
			client_print_color(id,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_CMD_NOTALLOWED");
		}
		else
		{
			new iPlayers[32],iNum,iPlayer;
			get_players(iPlayers,iNum,"h");
			
			new sName[32];
			new iDmg,iHit,iCheck;
			
			for(new i;i < iNum;i++)
			{
				iPlayer = iPlayers[i];
				iHit = g_iHits[iPlayer][id];
				
				if(iHit)
				{
					++iCheck;
					iDmg = g_iDamage[iPlayer][id];
					
					if(iPlayer == id)
					{
						client_print_color
						(
							id,
							print_team_grey,
							"^4%s^1 %L",
							g_sHead,
							LANG_SERVER,
							"PUG_AUX_RDMG_SELF",
							iHit,
							(iHit > 1) ? "vezes" : "vez",
							iDmg
						);
					}
					else
					{
						get_user_name(iPlayer,sName,charsmax(sName));
						
						client_print_color
						(
							id,
							print_team_grey,
							"^4%s^1 %L",
							g_sHead,
							LANG_SERVER,
							"PUG_AUX_RDMG",
							sName,
							iHit,
							(iHit > 1) ? "vezes" : "vez",
							iDmg
						);
					}
				}
			}
			
			if(!iCheck)
			{	
				client_print_color
				(
					id,
					print_team_grey,
					"^4%s^1 %L",
					g_sHead,
					LANG_SERVER,
					"PUG_AUX_NORDMG"
				);
			}
		}
	}
	else client_print_color(id,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_CMD_NOTALLOWED");
	
	return PLUGIN_HANDLED;
}

public PugCommandSummary(id)
{
	if(GET_PUG_STATUS() == PUG_STATUS_LIVE)
	{
		if(is_user_alive(id) && g_bInRound)
		{
			client_print_color(id,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_CMD_NOTALLOWED");
		}
		else
		{
			new iPlayers[32],iNum,iPlayer;
			get_players(iPlayers,iNum,"h");
			
			new sName[32];
			
			new iDmg[2],iHit[2],iCheck;
			
			for(new i;i < iNum;i++)
			{
				iPlayer = iPlayers[i];
				
				if(id == iPlayer) continue;
				
				iHit[0] = g_iHits[id][iPlayer]; // Hits Done
				iHit[1] = g_iHits[iPlayer][id]; // Hits Recived
				
				if(iHit[0] || iHit[1])
				{
					++iCheck;
				
					iDmg[0] = g_iDamage[id][iPlayer]; // Damage Done
					iDmg[1] = g_iDamage[iPlayer][id]; // Damag Recived
					
					get_user_name(iPlayer,sName,charsmax(sName));
					
					client_print_color
					(
						id,
						print_team_grey,
						"^4%s^1 %L",
						g_sHead,
						LANG_SERVER,
						"PUG_AUX_SUM",
						iDmg[0],iHit[0],
						iDmg[1],iHit[1],
						sName,
						(is_user_alive(iPlayer) ? get_user_health(iPlayer) : 0)
					);
				}
			}
			
			if(!iCheck)
			{
				client_print_color
				(
					id,
					print_team_grey,
					"^4%s^1 %L",
					g_sHead,
					LANG_SERVER,
					"PUG_AUX_NOSUM"
				);
			}
		}
	}
	else client_print_color(id,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_CMD_NOTALLOWED");
	
	return PLUGIN_HANDLED;
}

public PugCommandClient(id)
{
	if(g_sMOTD[0])
	{
		show_motd(id,g_sMOTD,"Comandos Registrados");
	}
	
	return PLUGIN_HANDLED;
}

public PugCommandAdmin(id,iLevel)
{
	if(access(id,iLevel) && g_sMOTD1[0])
	{
		show_motd(id,g_sMOTD1,"Comandos Registrados");
	}
	
	return PLUGIN_HANDLED;
}
Error


pug_cfgvote.sma
Code:
#include <amxmodx>
#include <amxmisc>

#include <pug_menu>
#include <pug_const>
#include <pug_stocks>
#include <pug_forwards>
#include <pug_modspecific>

#pragma semicolon 1

new g_pVoteDelay;
new g_pVotePercent;

public g_iMenuConfig;

new g_iConfigVotes[3];

public plugin_init()
{
	register_plugin("Pug Mod Config Votes",AMXX_VERSION_STR,"Twilight Suzuka");
	
	register_dictionary("pug.txt");
	register_dictionary("pug_vote.txt");
	
	g_pVoteDelay = get_cvar_pointer("pug_vote_delay");
	g_pVotePercent = get_cvar_pointer("pug_vote_percent");
	
	PugRegisterAdminCommand("voteconfig","PugCommandVoteConfig",PUG_CMD_LVL,"Escolha de Config");
	
	g_iMenuConfig = menu_create("Configuracao:","PugVoteConfigHandle",1);
	
	menu_additem(g_iMenuConfig,"ESL (15 Rounds, 1:45 min, $800)","1");
	menu_additem(g_iMenuConfig,"CEVO (15 Rounds, 2:00 min, $800)","2");
	
	menu_setprop(g_iMenuConfig,MPROP_EXIT,MEXIT_NEVER);
}

CREATE_GEN_FORW_ID(Fw_PugFirstHalf);

public PugFirstHalf(GEN_FORW_ID(iForward))
{
	Fw_PugFirstHalf = iForward;

	PugVoteConfigStart();

	return PLUGIN_HANDLED;
}

public PugCommandVoteConfig(id,iLevel)
{
	if(!access(id,PUG_CMD_LVL) && (id != 0))
	{
		PugMessage(id,"PUG_CMD_NOTALLOWED");
	}
	else PugAdminCommand(id,"escolha de configuracao","PUG_FORCE_VOTE",(GET_PUG_VOTING()) ? 0 : PugVoteConfigStart());

	return PLUGIN_HANDLED;
}

public PugVoteConfigStart()
{
	if(GET_PUG_VOTING())
	{
		set_task(get_pcvar_float(g_pVoteDelay),"PugVoteConfigStart",1990 + g_iMenuConfig);
		
		return PLUGIN_CONTINUE;
	}
	
	arrayset(g_bVoted,false,sizeof(g_bVoted));

	PugDisplayMenuAll(g_iMenuConfig);
	arrayset(g_iConfigVotes,0,charsmax(g_iConfigVotes));

	client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,"PUG_VOTE_START","de configuracao");

	set_task(get_pcvar_float(g_pVoteDelay),"PugVoteConfigEnd",1990 + g_iMenuConfig);
	
	return PLUGIN_HANDLED;
}

public PugVoteConfigHandle(id,iMenu,iKey)
{
	if(iKey < 0)
	{
		return PLUGIN_HANDLED;
	}
 
	new iAccess,iCallBack,sCommand[3],sOption[36];
	menu_item_getinfo(iMenu,iKey, iAccess, sCommand,charsmax(sCommand),sOption,charsmax(sOption),iCallBack);

	g_iConfigVotes[str_to_num(sCommand)]++;

	new sName[32];
	get_user_name(id,sName,charsmax(sName));
		
	client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,"PUG_VOTED_FOR",sName,sOption);

	g_bVoted[id] = true;
	
	if(PugShoudStopVote()) PugVoteConfigEnd();
 
	return PLUGIN_HANDLED;
}

public PugVoteConfigEnd()
{
	PugCancelMenu();
	PugVoteConfigCount();

	remove_task(1990 + g_iMenuConfig);
}

stock g_sConfigs[][] = {"SERVER","ESL","CEVO"};

public PugVoteConfigCount()
{
	new iWinner,iWinnerVotes,iVotes;
	
	for(new i;i < sizeof(g_iConfigVotes);i++)
	{
		iVotes = g_iConfigVotes[i];
		
		if(iVotes >= iWinnerVotes)
		{
			iWinner = i;
			iWinnerVotes = iVotes;
		}
		else if(iVotes == iWinnerVotes)
		{
			if(random_num(0,1))
			{
				iWinner = i;
				iWinnerVotes = iVotes;
			}
		}
	}
	
	if(!g_iConfigVotes[iWinner])
	{
		return PugMessage(0,"PUG_VOTE_FAILED_NOVOTES");
	}

	new Float:fTemp = float(PugGetPlayers()) * get_pcvar_float(g_pVotePercent);
	
	if(g_iConfigVotes[iWinner] < floatround(fTemp,floatround_floor))
	{
		return PugMessage(0,"PUG_VOTE_FAILED_INSUF_VOTES");
	}
	
	PugSetConfigs(iWinner);
	
	client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,"PUG_VOTE_WON",g_sConfigs[iWinner]);	
	
	ContinueGenForward(Fw_PugFirstHalf);
	
	return PLUGIN_HANDLED;
}

stock PugSetConfigs(iConfig)
{
	switch(iConfig)
	{
		case 1:
		{
			set_cvar_string("pug_config_firsthalf","esl.rc");
			set_cvar_string("pug_config_secondhalf","esl.rc");
			set_cvar_string("pug_config_overtime","esl-overtime.rc");
		}
		case 2:
		{
			set_cvar_string("pug_config_firsthalf","cevo.rc");
			set_cvar_string("pug_config_secondhalf","cevo.rc");
			set_cvar_string("pug_config_overtime","cevo-overtime.rc");
		}
	}
}
Error


pug_core.sma
Code:
#include <amxmodx>
#include <amxmisc>

#include <pug_const>
#include <pug_ready>
#include <pug_stocks>
#include <pug_forwards>
#include <pug_modspecific>

#pragma semicolon 1

public g_iStage;
public g_iStatus;
public g_iRounds;

CREATE_GEN_FORW_ID(Fw_PugStart);
CREATE_GEN_FORW_ID(Fw_PugFirstHalf);
CREATE_GEN_FORW_ID(Fw_PugIntermission);
CREATE_GEN_FORW_ID(Fw_PugSecondHalf);
CREATE_GEN_FORW_ID(Fw_PugIntermissionOT);
CREATE_GEN_FORW_ID(Fw_PugOvertime);

public PugForwardEnd;
public PugForwardFinish;

public PugForwardRoundStart;
public PugForwardRoundStartFailed;
public PugForwardRoundEnd;
public PugForwardRoundEndFailed;

new g_iRet;
new g_iTempEndHolder;

new g_iTeams;
new g_iScore[PUG_MAX_TEAMS];
new g_sTeams[PUG_MAX_TEAMS][32];

public g_pMaxRounds;
public g_pMaxOTRounds;
public g_pIntermissionTime;

public g_pMaxPlayers;
public g_pMinPlayers;

public g_pDefaultMaxPlayers;
public g_pDefaultMinPlayers;

public g_pAllowSpec;
public g_pAllowHLTV;

new g_pSvVisibleMaxPlayers;

public plugin_init()
{
	new hPlugin = register_plugin("Pug Mod Core",AMXX_VERSION_STR,"Twilight Suzuka");
	
	register_dictionary("pug.txt");
	
	g_pMaxRounds = register_cvar("pug_rounds_max","30");
	g_pMaxOTRounds = register_cvar("pug_rounds_ot","6");
	g_pIntermissionTime = register_cvar("pug_intermission_time","10.0");
	
	g_pMaxPlayers = register_cvar("pug_players_max","10");
	g_pMinPlayers = register_cvar("pug_players_min","10");
	
	g_pDefaultMaxPlayers = register_cvar("pug_players_default_max","10");
	g_pDefaultMinPlayers = register_cvar("pug_players_default_min","10");
	
	g_pAllowSpec = register_cvar("pug_allow_spectators","1");
	g_pAllowHLTV = register_cvar("pug_allow_hltv","1");
	
	g_pSvVisibleMaxPlayers = get_cvar_pointer("sv_visiblemaxplayers");
	
	register_clcmd("say","PugHandleSay");
	register_clcmd("say_team","PugHandleSay");
	
	PugRegisterCommand("status","PugCommandStatus",ADMIN_ALL,"Mostra o status do PUG");
	PugRegisterCommand("score","PugCommandCheckScore",ADMIN_ALL,"Mostra o placar do PUG");
	PugRegisterCommand("round","PugCommandCheckRound",ADMIN_ALL,"Mostra o round atual");
	
	PugRegisterAdminCommand("pause","PugCommandPause",PUG_CMD_LVL,"Pausa o PUG");
	PugRegisterAdminCommand("unpause","PugCommandUnPause",PUG_CMD_LVL,"Despausa o PUG");
	PugRegisterAdminCommand("togglepause","PugCommandTogglePause",PUG_CMD_LVL,"Altera a Pausa no PUG");
	
	PugRegisterAdminCommand("pugstart","PugCommandStart",PUG_CMD_LVL,"Forca o inicio do PUG");
	PugRegisterAdminCommand("pugstop","PugCommandStop",PUG_CMD_LVL,"Forca o fim do PUG");
	PugRegisterAdminCommand("pugreset","PugCommandReset",PUG_CMD_LVL,"Reinicia o PUG");
	
	Fw_PugStart = CreateGenForward("PugPreStart",hPlugin,get_func_id("PugStartHandler"));
	Fw_PugFirstHalf = CreateGenForward("PugFirstHalf",hPlugin,get_func_id("PugFirstHalfHandler"));
	Fw_PugIntermission = CreateGenForward("PugIntermission",hPlugin,get_func_id("PugIntermissionHandler"));
	Fw_PugSecondHalf = CreateGenForward("PugSecondHalf",hPlugin,get_func_id("PugSecondHalfHandler"));
	Fw_PugIntermissionOT = CreateGenForward("PugIntermissionOT",hPlugin,get_func_id("PugIntermissionOTHandler"));
	Fw_PugOvertime = CreateGenForward("PugOvertime",hPlugin,get_func_id("PugOvertimeHandler"));
	
	PugForwardEnd = CreateMultiForward("PugWinner",ET_CONTINUE,FP_CELL);
	PugForwardFinish = CreateMultiForward("PugFinished",ET_CONTINUE);
	
	PugForwardRoundStart = CreateMultiForward("PugRoundStart",ET_CONTINUE);
	PugForwardRoundEnd = CreateMultiForward("PugRoundEnd",ET_CONTINUE,FP_CELL);

	PugForwardRoundStartFailed = CreateMultiForward("PugRoundStartFailed",ET_CONTINUE);
	PugForwardRoundEndFailed = CreateMultiForward("PugRoundEndFailed",ET_CONTINUE);
}

public plugin_cfg() 
{
	set_pcvar_num(g_pSvVisibleMaxPlayers,get_pcvar_num(g_pMaxPlayers));

	g_iStage = PUG_STAGE_WAITING;
	g_iStatus = PUG_STATUS_DEAD;
	g_iRounds = 0;
	
	g_iTeams = 1;
	g_iTempEndHolder = -1;
	copy(g_sTeams[0],charsmax(g_sTeams),"PugMod");
	
	set_task(5.0,"PugStart");
}

public plugin_end()
{
	if((g_iStage != PUG_STAGE_END) && (g_iStatus == PUG_STATUS_LIVE))
	{
		PugEnd(0);
	}
}

public client_authorized(id)
{
	PugCheckPlayer(id);
}

public client_disconnect(id)
{
	if(PUG_STAGE_FIRSTHALF <= g_iStage <= PUG_STAGE_OVERTIME)
	{
		if(PugGetPlayers() <= PUG_MIN_PLAYERS)
		{
			PugEnd(0);
		}
	}
}

public PugCheckPlayer(id)
{
	new iHLTV = is_user_hltv(id);
	new iSpec = get_pcvar_num(g_pAllowSpec);
	new iMaxP = get_pcvar_num(g_pMaxPlayers);
	
	if(get_playersnum() >= iMaxP)
	{
		if(!iHLTV || !iSpec)
		{
			PugDisconnect(id,"%L",LANG_SERVER,"PUG_KICK_FULL");
			
			return PLUGIN_HANDLED;
		}
	}
	
	new iAllowTV = get_pcvar_num(g_pAllowHLTV);
	
	if(PugGetPlayers() >= iMaxP)
	{
		if(iHLTV && !iAllowTV)
		{
			PugDisconnect(id,"%L",LANG_SERVER,"PUG_KICK_HLTV");
			
			return PLUGIN_HANDLED;
		}
		else if(!iSpec)
		{
			PugDisconnect(id,"%L",LANG_SERVER,"PUG_KICK_SPEC");
			
			return PLUGIN_HANDLED;
		}
	}
	
	return PLUGIN_CONTINUE;
}

PugRestoreOrder()
{
	while(PugGetPlayers() > get_pcvar_num(g_pMaxPlayers))
	{
		new iTest = 3600,iWho,iTime;

		new iPlayers[32],iNum,iPlayer;
		get_players(iPlayers,iNum,"ch");

		for(new i;i < iNum;i++)
		{
			iPlayer = iPlayers[i];

			if(is_user_connected(iPlayer))
			{
				iTime = get_user_time(iPlayer,1);

     				if(iTest >= iTime)
				{
					iTest = iTime;

					iWho = iPlayer;
				}
			}
		}
		
		PugDisconnect(iWho,"%L",LANG_SERVER,"PUG_KICK_ORDER");
	}
}

public PugHandleSay(id)
{
	new sArgs[192];
	read_args(sArgs,charsmax(sArgs));
	remove_quotes(sArgs);

	if(sArgs[0] == '.' || sArgs[0] == '!')
	{
		client_cmd(id,sArgs);
		return PLUGIN_HANDLED;
	}
	
	return PLUGIN_CONTINUE;
}

public PugStart()
{
	if(g_iStage != PUG_STAGE_WAITING)
	{
		return PLUGIN_CONTINUE;
	}
	else if(g_iStatus != PUG_STATUS_DEAD)
	{
		return SetPauseCall(get_func_id("PugStart"));
	}

	g_iStage = PUG_STAGE_START;
	g_iStatus = PUG_STATUS_WAITING;

	ExecuteGenForward(Fw_PugStart);
	
	return PLUGIN_HANDLED;
}

public PugStartHandler()
{
	if(g_iStatus != PUG_STATUS_WAITING)
	{
		return SetPauseCall(get_func_id("PugStartHandler"));
	}

	g_iStatus = PUG_STATUS_LIVE;
	g_iRounds = 1;

	PugMessage(0,"PUG_START");
	PugNativeReadyPlayers(get_func_id("PugStartFirstHalf"));

	return PLUGIN_HANDLED;
}

public PugStartFirstHalf()
{
	if(g_iStage != PUG_STAGE_START)
	{
		return PLUGIN_CONTINUE;
	}
	else if(g_iStatus != PUG_STATUS_LIVE)
	{
		return SetPauseCall(get_func_id("PugStartFirstHalf"));
	}

	g_iStage = PUG_STAGE_FIRSTHALF;
	g_iStatus = PUG_STATUS_WAITING;

	ExecuteGenForward(Fw_PugFirstHalf);
	
	return PLUGIN_HANDLED;
}

public PugFirstHalfHandler()
{
	if(g_iStatus != PUG_STATUS_WAITING)
	{
		return SetPauseCall(get_func_id("PugFirstHalfHandler"));
	}

	g_iStatus = PUG_STATUS_LIVE;
	PugMessage(0,"PUG_FIRST_HALF");

	return PLUGIN_HANDLED;
}

public PugStartIntermission()
{
	if(g_iStage != PUG_STAGE_FIRSTHALF)
	{
		return PLUGIN_CONTINUE;
	}
	else if(g_iStatus != PUG_STATUS_LIVE)
	{
		return SetPauseCall(get_func_id("PugStartIntermission"));
	}

	g_iStage = PUG_STAGE_INTERMISSION;
	g_iStatus = PUG_STATUS_WAITING;

	ExecuteGenForward(Fw_PugIntermission);
	
	return PLUGIN_HANDLED;
}

public PugIntermissionHandler()
{
	if(g_iStatus != PUG_STATUS_WAITING)
	{
		return SetPauseCall(get_func_id("PugIntermissionHandler"));
	}

	g_iStatus = PUG_STATUS_LIVE;

	PugMessage(0,"PUG_INTERMISSION");
	PugNativeReadyPlayers(get_func_id("PugStartSecondHalf"));

	return PLUGIN_CONTINUE;
}

public PugStartSecondHalf()
{
	if(g_iStage != PUG_STAGE_INTERMISSION)
	{
		return PLUGIN_CONTINUE;
	}
	else if(g_iStatus != PUG_STATUS_LIVE)
	{
		return SetPauseCall(get_func_id("PugStartSecondHalf"));
	}

	g_iStage = PUG_STAGE_SECONDHALF;
	g_iStatus = PUG_STATUS_WAITING;

	ExecuteGenForward(Fw_PugSecondHalf);
	
	return PLUGIN_HANDLED;
}

public PugSecondHalfHandler()
{
	if(g_iStatus != PUG_STATUS_WAITING)
	{
		return SetPauseCall(get_func_id("PugSecondHalfHandler"));
	}

	g_iStatus = PUG_STATUS_LIVE;
	
	PugMessage(0,"PUG_SECOND_HALF");

	return PLUGIN_HANDLED;
}

public PugStartIntermissionOT()
{
	if((g_iStage != PUG_STAGE_SECONDHALF) && (g_iStage != PUG_STAGE_OVERTIME))
	{
		return PLUGIN_CONTINUE;
	}
	else if(g_iStatus != PUG_STATUS_LIVE)
	{
		return SetPauseCall(get_func_id("PugStartIntermissionOT"));
	}

	g_iStage = PUG_STAGE_INTERMISSION;
	g_iStatus = PUG_STATUS_WAITING;

	ExecuteGenForward(Fw_PugIntermissionOT);
	
	return PLUGIN_HANDLED;
}

public PugIntermissionOTHandler()
{
	if(g_iStatus != PUG_STATUS_WAITING)
	{
		return SetPauseCall(get_func_id("PugIntermissionOTHandler"));
	}

	g_iStatus = PUG_STATUS_LIVE;

	PugMessage(0,"PUG_OT_INTERMISSION");
	
	PugNativeReadyPlayers(get_func_id("PugStartOvertime"));

	return PLUGIN_HANDLED;
}

public PugStartOvertime()
{
	if(g_iStage != PUG_STAGE_INTERMISSION)
	{
		return PLUGIN_CONTINUE;
	}
	else if(g_iStatus != PUG_STATUS_LIVE)
	{
		return SetPauseCall(get_func_id("PugStartOvertime"));
	}

	g_iStage = PUG_STAGE_OVERTIME;
	g_iStatus = PUG_STATUS_WAITING;

	ExecuteGenForward(Fw_PugOvertime);
	
	return PLUGIN_HANDLED;
}

public PugOvertimeHandler()
{
	if(g_iStatus != PUG_STATUS_WAITING)
	{
		return SetPauseCall(get_func_id("PugOvertimeHandler"));
	}

	g_iStatus = PUG_STATUS_LIVE;
	
	PugMessage(0,"PUG_OVERTIME");

	return PLUGIN_HANDLED;
}

public PugStartEnd(id,iParams)
{
	PugEnd(get_param(1));
}

public PugEnd(iWinner)
{
	if((g_iStage != PUG_STAGE_FIRSTHALF) && (g_iStage != PUG_STAGE_INTERMISSION) && (g_iStage != PUG_STAGE_SECONDHALF)&& (g_iStage != PUG_STAGE_OVERTIME))
	{
		return PLUGIN_CONTINUE;
	}
	else if(g_iStatus != PUG_STATUS_LIVE)
	{
		g_iTempEndHolder = iWinner;
		
		return SetPauseCall(get_func_id("PugEnd"));
	}

	if(g_iTempEndHolder != -1)
	{
		iWinner = g_iTempEndHolder;
	}
	
	g_iTempEndHolder = -1;

	ExecuteForward(PugForwardEnd,g_iRet,iWinner);

	DisplayScores(0,"PUG_TEAM_WONALL");

	g_iStatus = PUG_STATUS_DEAD;
	g_iStage = PUG_STAGE_END;
	g_iRounds = 0;

	ExecuteForward(PugForwardFinish,g_iRet);

	set_task(get_pcvar_float(g_pIntermissionTime),"PugReset",1990 + g_pIntermissionTime);
	
	return PLUGIN_HANDLED;
}

public PugReset()
{
	g_iStage = PUG_STAGE_WAITING;
	g_iStatus = PUG_STATUS_DEAD;
	g_iRounds = 0;
	
	arrayset(g_iScore,0,sizeof(g_iScore));

	new iDefaultPlayers = get_pcvar_num(g_pDefaultMaxPlayers);
	
	if(iDefaultPlayers)
	{
		set_pcvar_num(g_pMaxPlayers,iDefaultPlayers);
		set_pcvar_num(g_pSvVisibleMaxPlayers,iDefaultPlayers);
		
		iDefaultPlayers = get_pcvar_num(g_pDefaultMinPlayers);
		
		if(iDefaultPlayers)
		{
			set_pcvar_num(g_pMinPlayers,iDefaultPlayers);
		}
	}

	PugRestoreOrder();
	
	return PugStart();
}

public PugCallRoundStart()
{
	if((g_iStage == PUG_STAGE_READY) || ((g_iStage != PUG_STAGE_FIRSTHALF) && (g_iStage != PUG_STAGE_SECONDHALF) && (g_iStage != PUG_STAGE_OVERTIME))) 
	{
		ExecuteForward(PugForwardRoundStartFailed,g_iRet);
		
		return PLUGIN_CONTINUE;
	}

	if(g_iStatus & (PUG_STATUS_UNPAUSED))
	{
		g_iStatus &= ~(PUG_STATUS_UNPAUSED);
	}

	if(g_iStatus != PUG_STATUS_LIVE)
	{
		ExecuteForward(PugForwardRoundStartFailed,g_iRet);
		
		return PLUGIN_CONTINUE;
	}

	console_print(0,"%s %L",g_sHead,LANG_SERVER,"PUG_ROUND_START",g_iRounds);
	
	PugCommandCheckScore(0);

	ExecuteForward(PugForwardRoundStart,g_iRet);
	
	return PLUGIN_HANDLED;
}

public PugCallRoundEnd(id,iParams)
{
	PugRoundend(get_param(1));
}

public PugRoundend(iWinner)
{
	if((g_iStage != PUG_STAGE_FIRSTHALF) && (g_iStage != PUG_STAGE_SECONDHALF) && (g_iStage != PUG_STAGE_OVERTIME)) 
	{
		ExecuteForward(PugForwardRoundEndFailed,g_iRet);
		
		return PLUGIN_CONTINUE;
	}
	
	if(g_iStatus != PUG_STATUS_LIVE)
	{
		if(g_iStatus & (PUG_STATUS_UNPAUSED))
		{
			g_iStatus &= ~(PUG_STATUS_UNPAUSED);
			
			PugMessage(0,"PUG_ROUND_FAIL_PAUSE");
			
			ExecuteForward(PugForwardRoundEndFailed,g_iRet);
			
			return PLUGIN_CONTINUE;
		}
	}

	g_iScore[iWinner]++;
	
	PugHandleRound();

	if(iWinner == 0)
	{
		PugMessage(0,"PUG_ROUND_FAIL_SERVER");
	}
	else 
	{
		console_print(0,"%s %L",g_sHead,LANG_SERVER,"PUG_TEAM_WON",g_iRounds,g_sTeams[iWinner]);
		
		g_iRounds++;
	}

	ExecuteForward(PugForwardRoundEnd,g_iRet,iWinner);

	return PUG_STATUS_LIVE;
}

PugHandleRound()
{
	new iTotalRounds = get_pcvar_num(g_pMaxRounds);

	switch(g_iStage)
	{
		case PUG_STAGE_FIRSTHALF:
		{
			if(g_iRounds == (iTotalRounds / 2))
			{
				PugCommandCheckScore(0);
				
				PugStartIntermission();
			}
		}
		case PUG_STAGE_SECONDHALF:
		{
			if(CheckScore(iTotalRounds / 2) || (g_iRounds >= iTotalRounds))
			{
				new iTotalWinner = PugCalcWinner();
				
				if(iTotalWinner == 0)
				{
					PugCommandCheckScore(0);
					
					PugStartIntermissionOT();
				}
				else
				{
					PugEnd(iTotalWinner);
				}
			}
		}
		case PUG_STAGE_OVERTIME:
		{
			new iOTRounds = (g_iRounds - iTotalRounds);
			new iStoreOTRounds = (get_pcvar_num(g_pMaxOTRounds));

			iOTRounds %= iStoreOTRounds;
			new iTotalRounds = (iStoreOTRounds / 2);

			if(iOTRounds == iTotalRounds )
			{
				PugCommandCheckScore(0);
				
				PugStartIntermissionOT();
			}
			else if(CheckOvertimeScore((iStoreOTRounds / 2),(iTotalRounds / 2),iStoreOTRounds) || !iOTRounds)
			{
				new iTotalWinner = PugCalcWinner();
				
				if(iTotalWinner == 0)
				{
					PugCommandCheckScore(0);
					
					PugStartIntermissionOT();
				}
				else
				{
					PugEnd(iTotalWinner);
				}
			}
		}
	}
}

PugCalcWinner()
{
	new iScoreA,iScoreB;
	new iWinner = 1,iTied = 0;
	
	for(new i = 2;i < g_iTeams;i++)
	{
		iScoreA = g_iScore[iWinner];
		iScoreB = g_iScore[i];

		if(iScoreA == iScoreB)
		{
			iTied = 1;
		}
		else if(iScoreA < iScoreB)
		{
			iWinner = i;
			iTied = 0;
		}
	}

	if(iTied != 0)
	{
		return 0;
	}

	return iWinner;
}

public CheckScore(iValue)
{
	for(new i = 1;i < g_iTeams;i++)
	{
		if(g_iScore[i] > iValue)
		{
			return i;
		}
	}

	return 0;
}

public CheckOvertimeScore(iCheck,iSub,iModulo)
{
	new iTempScore;
	
	for(new i = 1;i < g_iTeams;i++)
	{
		iTempScore = g_iScore[i] - iSub;
		iTempScore %= iModulo;
		
		if(iTempScore > iCheck)
		{
			return i;
		}
	}

	return 0;
}

public PugPauseFuncID;
public PugPausePluginID;

public PugPause()
{
	if(g_iStatus & (PUG_STATUS_UNPAUSED))
	{
		g_iStatus &= ~(PUG_STATUS_UNPAUSED);
	}

	g_iStatus |= (PUG_STATUS_PAUSED);
	
	PugPausePluginID = INVALID_PLUGIN_ID;
	PugPausePluginID = INVALID_PLUGIN_ID;
}

public PugUnPause()
{
	if(g_iStatus ^ (PUG_STATUS_PAUSED)) return;

	g_iStatus &= ~(PUG_STATUS_PAUSED);
	g_iStatus |= (PUG_STATUS_UNPAUSED);

	if(PugPauseFuncID != INVALID_PLUGIN_ID)
	{
		if(callfunc_begin_i(PugPauseFuncID,PugPausePluginID) > 0)
		{
			callfunc_end();
		}
	}
}

public PugIsPaused()
{
	return g_iStatus & (PUG_STATUS_PAUSED);
}

stock SetPauseCall(iFunction,iPlugin = INVALID_PLUGIN_ID)
{
	PugPauseFuncID = iFunction;
	PugPausePluginID = iPlugin;
	
	return PLUGIN_CONTINUE;
}

public plugin_natives()
{
	register_native("PugPause","PugPause");
	register_native("PugUnPause","PugUnPause");
	register_native("PugSetPauseCall","PugSetPauseCall");

	register_native("PugCallRoundStart","PugCallRoundStart");
	register_native("PugCallRoundEnd","PugCallRoundEnd");

	register_native("PugCallReset","PugReset");

	register_native("PugSwapTeams","SwapTeams");
	register_native("PugRegisterTeam","RegisterTeam");
	register_native("PugNumTeams","NumTeams");

	register_native("PugGetTeamName","GetTeamName");
	register_native("PugSetTeamName","SetTeamName");
	
	register_native("PugSetTeamScore","SetTeamScore");
	register_native("PugGetTeamScore","GetTeamScore");
}

public GetTeamName(id,iParams)
{
	 set_string(2,g_sTeams[get_param(1)],charsmax(g_sTeams));
}

public SetTeamName(id,iParams)
{
	get_string(2,g_sTeams[get_param(1)],charsmax(g_sTeams));
}

public NumTeams(id,iParams)
{
	return g_iTeams - 1;
}

public SwapTeams(id,iParams)
{
	new a = get_param(1);
	new b = get_param(2);

	new sTeamA[32];
	
	formatex(sTeamA,charsmax(sTeamA),"%s",g_sTeams[a]);
	formatex(g_sTeams[a],charsmax(g_sTeams[]),"%s",g_sTeams[b]);
	formatex(g_sTeams[b],charsmax(g_sTeams[]),"%s",sTeamA);
	
	new iScoreA = g_iScore[a];
	
	g_iScore[a] = g_iScore[b];
	g_iScore[b] = iScoreA;
}

public RegisterTeam(id,iParams)
{
	get_string(1,g_sTeams[g_iTeams],charsmax(g_sTeams[]));
	++g_iTeams;

	return g_iTeams - 1;
}

public SetTeamScore(id,iParams)
{
	g_iScore[get_param(1)] = get_param(2);
}

public GetTeamScore(id,iParams)
{
	return g_iScore[get_param(1)];
}

public PugSetPauseCall(id,iParams)
{
	new iPlugin = get_param(2);
	
	return SetPauseCall(get_param(1),(iPlugin == INVALID_PLUGIN_ID) ? id : iPlugin);
}

public DisplayScores(id,sMethod[])
{
	new sCurrentScore[PUG_MAX_TEAMS],iTopTeam = 0;
	new sTeam[64],sFinishedScores[PUG_MAX_TEAMS * 5];
	
	for(new i = 1;i < g_iTeams;++i)
	{
		if(g_iScore[iTopTeam] < g_iScore[i])
		{
			iTopTeam = i;
		}
		
		sCurrentScore[i] = g_iScore[i];
	}
	
	if(PugCalcWinner() == 0)
	{
		formatex(sTeam,charsmax(sTeam),"%L",LANG_SERVER,"PUG_SCORE_TIED");
	}
	else
	{
		formatex(sTeam,charsmax(sTeam),"%L",LANG_SERVER,sMethod,g_sTeams[iTopTeam]);
	}

	SortIntegers(sCurrentScore,PUG_MAX_TEAMS,Sort_Descending);

	format(sFinishedScores,(PUG_MAX_TEAMS * 5),"%i",sCurrentScore[0]);
	
	for(new i = 2;i < g_iTeams;++i)
	{
		format(sFinishedScores,(PUG_MAX_TEAMS * 5),"%s-%i",sFinishedScores,sCurrentScore[i - 1]);
	}

	client_print_color(id,print_team_grey,"^4%s^1 %s %s",g_sHead,sTeam,sFinishedScores);
	
	if(id == 0)
	{
		server_print("%s %s %s",g_sHead,sTeam,sFinishedScores);
	}
}

public PugCommandStatus(id)
{
	client_print_color
	(
		id,
		print_team_grey,
		"^4%s^1 Players: %i (Min: %i - Max: %i) (Stage: %s)",
		g_sHead,
		PugGetPlayers(),
		get_pcvar_num(g_pMinPlayers),
		get_pcvar_num(g_pMaxPlayers),
		g_sStage[g_iStage]
	);
	
	if(g_iStatus == PUG_STATUS_LIVE)
	{
		for(new i = 1;i < g_iTeams;i++)
		{
			client_print_color
			(
				id,
				print_team_grey,
				"^4%s^1 %L",
				g_sHead,
				LANG_SERVER,
				"PUG_CHECK_SCORE",
				g_sTeams[i],
				g_iScore[i]
			);
		}
	}

	return PLUGIN_HANDLED;
}

public PugCommandCheckScore(id)
{
	if(g_iStatus == PUG_STATUS_LIVE)
	{
		DisplayScores(id,"PUG_SCORE_WINNING");
	}
	else PugMessage(id,"PUG_CMD_NOTALLOWED");

	return PLUGIN_HANDLED;
}

public PugCommandCheckRound(id)
{
	if(g_iStatus == PUG_STATUS_LIVE)
	{
		if(id)
		{
			client_print_color(id,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,"PUG_CHECK_ROUND",g_iRounds);
		}
		else server_print("%s %L",g_sHead,LANG_SERVER,"PUG_CHECK_ROUND",g_iRounds);
	}
	else PugMessage(id,"PUG_CMD_NOTALLOWED");
	
	return PLUGIN_HANDLED;
}

public PugCommandPause(id)
{
	if(!access(id,PUG_CMD_LVL) && (id != 0))
	{
		PugMessage(id,"PUG_CMD_NOACCESS");
	}
	else
	{
		PugAdminCommand(id,"Pause","PUG_FORCE_PAUSE",PugPause());
	}

	return PLUGIN_HANDLED;
}

public PugCommandUnPause(id)
{
	if(!access(id,PUG_CMD_LVL) && (id != 0))
	{
		PugMessage(id,"PUG_CMD_NOACCESS");
	}
	else PugAdminCommand(id,"Un-Pause","PUG_FORCE_UNPAUSE",PugUnPause());

	return PLUGIN_HANDLED;
}

public PugCommandTogglePause(id)
{
	if(!access(id,PUG_CMD_LVL) && (id != 0))
	{
		PugMessage(id,"PUG_CMD_NOACCESS");
	}
	else PugAdminCommand(id,"Toggle Pause","PUG_FORCE_TOGGLE_PAUSE",PugIsPaused() ? PugUnPause() : PugPause());

	return PLUGIN_HANDLED;
}

public PugCommandStart(id)
{
	if(!access(id,PUG_CMD_LVL) && (id != 0))
	{
		PugMessage(id,"PUG_CMD_NOACCESS");
	}
	else
	{
		if(g_iStage == PUG_STAGE_READY)
		{
			g_iStage = PUG_STAGE_START;
			g_iStatus = PUG_STATUS_LIVE;
		}
		
		PugAdminCommand(id,"Start PUG","PUG_FORCE_START",PugStartFirstHalf());
	}

	return PLUGIN_HANDLED;
}

public PugCommandStop(id)
{
	if(!access(id,PUG_CMD_LVL) && (id != 0))
	{
		PugMessage(id,"PUG_CMD_NOACCESS");
	}
	else
	{
		PugAdminCommand(id,"Stop PUG","PUG_FORCE_END",PugEnd(PugCalcWinner()));
	}

	return PLUGIN_HANDLED;
}

public PugCommandReset(id)
{
	if(!access(id,PUG_CMD_LVL) && (id != 0))
	{
		PugMessage(id,"PUG_CMD_NOACCESS");
	}
	else
	{
		PugAdminCommand(id,"Pug Reset","PUG_FORCE_RESTART",PugReset());
	}

	return PLUGIN_HANDLED;
}
Error


pug_cs.sma
Code:
#include <amxmodx>
#include <amxmisc>
#include <cstrike>

#include <fakemeta>
#include <hamsandwich>

#pragma semicolon 1

#include <pug_const>
#include <pug_stocks>
#include <pug_natives>
#include <pug_forwards>
#include <pug_modspecific>

new g_pForceRestart;
new g_pSwitchDelay;
new g_pAllowShield;
new g_pAllowGrenades;
new g_pAllowKill;

new g_pAllowSpec;

new g_pMpLimitTeams;
new g_pSvRestart;

public plugin_init()
{
	register_plugin("Pug Mod (CS)",AMXX_VERSION_STR,"Twilight Suzuka");
	
	register_dictionary("pug.txt");
	register_dictionary("pug_mod.txt");
	
	g_pForceRestart = register_cvar("pug_force_restart","1");
	g_pSwitchDelay = register_cvar("pug_switch_delay","5.0");
	
	g_pAllowShield = register_cvar("pug_allow_shield","0");
	g_pAllowGrenades = register_cvar("pug_allow_grenades","0");
	g_pAllowKill = register_cvar("pug_allow_kill","1");
	
	g_pAllowSpec = get_cvar_pointer("pug_allow_spectators");
	
	g_pSvRestart = get_cvar_pointer("sv_restart");
	g_pMpLimitTeams = get_cvar_pointer("mp_limitteams");

	register_event("HLTV","ev_HLTV","a","1=0","2=0");
	
	register_event("SendAudio","ev_WonTR","a","2=%!MRAD_terwin");
	register_event("SendAudio","ev_WonCT","a","2=%!MRAD_ctwin");
	register_logevent("ev_RoundEnd",2,"1=Round_End");
	
	register_clcmd("jointeam","PugJoinTeam");
	
	register_menucmd(-2,MENU_KEY_1|MENU_KEY_2|MENU_KEY_5|MENU_KEY_6,"PugTeamSelect");
	register_menucmd(register_menuid("Team_Select",1),MENU_KEY_1|MENU_KEY_2|MENU_KEY_5|MENU_KEY_6,"PugTeamSelect");
	
	register_forward(FM_ClientKill,"PugFwClientKill",false);
}

public plugin_cfg()
{
	PugRegisterTeam("Terrorists");
	PugRegisterTeam("Counter-Terrorists");
}

public plugin_natives()
{
	register_native("PugGetPlayers","CS_GetPlayers");
	register_native("PugGetPlayersTeam","CS_GetPlayersTeam");
	
	register_native("PugTeamsRandomize","CS_TeamsRandomize");
	register_native("PugTeamsBalance","CS_TeamsBalance");
	register_native("PugTeamsOptmize","CS_TeamsOptmize");
	
	register_native("PugGetClientTeam","CS_GetClientTeam");
	register_native("PugSetClientTeam","CS_SetClientTeam");

	register_native("PugRespawnClient","CS_RespawnClient");
	register_native("PugSetGodMode","CS_SetGodModeClient");
	register_native("PugSetClientMoney","CS_SetClientMoney");
	
	register_native("PugRemoveC4","CS_RemoveC4");
}

public CS_GetClientTeam()
{
	return _:cs_get_user_team(get_param(1));
}	

public CS_SetClientTeam()
{
	cs_set_user_team(get_param(1),_:get_param(2));
}

public CS_RespawnClient()
{
	ExecuteHamB(Ham_CS_RoundRespawn,get_param(1));
}

public CS_SetGodModeClient()
{
	set_pev(get_param(1),pev_takedamage,get_param(2) ? DAMAGE_NO : DAMAGE_AIM);
}

public CS_SetClientMoney()
{
	cs_set_user_money(get_param(1),get_param(2),get_param(3));
}

public CS_RemoveC4()
{
	new iRemove = get_param(1);

	new iEnt = -1;

	while((iEnt = engfunc(EngFunc_FindEntityByString,iEnt,"classname",iRemove ? "func_bomb_target" : "_func_bomb_target")) > 0)
	{
		set_pev(iEnt,pev_classname,iRemove ? "_func_bomb_target" : "func_bomb_target");
	}

	while((iEnt = engfunc(EngFunc_FindEntityByString,iEnt,"classname",iRemove ? "info_bomb_target" : "_info_bomb_target")) > 0)
	{
		set_pev(iEnt,pev_classname,iRemove ? "_info_bomb_target" : "info_bomb_target");
	}
}

public CS_TeamsRandomize()
{
	new iPlayers[32],iNum;
	get_players(iPlayers,iNum,"h");
	
	for(new i;i < iNum;i++)
	{
		if(!(CS_TEAM_T <= cs_get_user_team(iPlayers[i]) <= CS_TEAM_CT))
		{
			iPlayers[i--] = iPlayers[--iNum];
		}
	}
	
	new iPlayer,CsTeams:iTeam = random(2) ? CS_TEAM_T : CS_TEAM_CT;
	
	new iRandom;
	
	while(iNum)
	{
		iRandom = random(iNum);
		
		iPlayer = iPlayers[iRandom];
		
		cs_set_user_team(iPlayer,iTeam);
		
		iPlayers[iRandom] = iPlayers[--iNum];
		
		iTeam = CsTeams:((_:iTeam) % 2 + 1);
	}
	
	if(get_pcvar_num(g_pForceRestart)) set_pcvar_num(g_pSvRestart,1);
}

public CS_TeamsBalance()
{
	new iPlayers[32],iNum,iPlayer;
	get_players(iPlayers,iNum,"h");

	new a,b,aPlayer,bPlayer;
	
	for(new i;i < iNum;i++)
	{
		iPlayer = iPlayers[i];

		switch(cs_get_user_team(iPlayer))
		{
			case 1:
			{
				++a;
				aPlayer = iPlayer;
			}
			case 2:
			{
				++b;
				bPlayer = iPlayer;
			}
		}
	}
	
	if(a == b) 
	{
		return;
	}
	else if((a + 2) == b)
	{
		cs_set_user_team(aPlayer,_:2);
	}
	else if((b + 2) == a)
	{
		cs_set_user_team(bPlayer,_:1);
	}
	else if((a + b) < GET_CVAR_MINPLAYERS())
	{
		a = PugGetTeamScore(1);
		b = PugGetTeamScore(2);

		if(a < b)
		{
			cs_set_user_team(aPlayer,_:1);
		}
		else if(b < a)
		{
			cs_set_user_team(bPlayer,_:2);
		}
	}
}

public CS_TeamsOptmize()
{
	new iSkills[33],iSorted[33];
	
	new iPlayers[32],iNum,iPlayer;
	for(new i;i < iNum;i++)
	{
		iPlayer = iPlayers[i];
		
		iSorted[iPlayer] = iSkills[iPlayer] = (get_user_time(iPlayer,1) / get_user_frags(iPlayer));
	}
	
	SortIntegers(iSorted,sizeof(iSorted),Sort_Descending);

	new iCheck = 1,iTeams = PugNumTeams();
	
	for(new i;i < sizeof(iSorted);i++)
	{
		for(new a;a < iNum;a++)
		{
			iPlayer = iPlayers[a];
			
			if(iSkills[iPlayer] == iSorted[i])
			{
				PugSetClientTeam(iPlayer,iCheck);
				
				iCheck++;
				if(iCheck > iTeams)
				{
					iCheck = 1;
				}
			}
		}
	}
}

public CS_GetPlayers()
{
	new iPlayers[32],iNum,iCount = 0;
	get_players(iPlayers,iNum,"ch");
	
	for(new i;i < iNum;i++)
	{
		if(CS_TEAM_T <= cs_get_user_team(iPlayers[i]) <= CS_TEAM_CT)
		{
			iCount++;
		}
	}
	
	return iCount;
}

public CS_GetPlayersTeam()
{
	new iPlayers[32],iNum,iPlayer,iCount = 0;
	get_players(iPlayers,iNum,"ch");
	
	new iTeam = get_param(1);
	
	for(new i;i < iNum;i++)
	{
		iPlayer = iPlayers[i];
		
		if(is_user_connected(iPlayer) && (get_user_team(iPlayer) == iTeam))
		{
			iCount++;
		}
	}
	
	return iCount;
}

new g_iWhoWon;

public ev_HLTV()
{
	if(GET_PUG_STATUS() == PUG_STATUS_LIVE)
	{
		g_iWhoWon = 0;
		
		PugCallRoundStart();
	}
}

public ev_WonTR()
{
	g_iWhoWon = 1;
}

public ev_WonCT()
{
	g_iWhoWon = 2;
}

public ev_RoundEnd()
{
	if(GET_PUG_STATUS() == PUG_STATUS_LIVE)
	{
		PugCallRoundEnd((g_iWhoWon == -1) ? 0 : g_iWhoWon);
		
		g_iWhoWon = -1;
	}
}

public PugIntermission(GEN_FORW_ID(iForward))
{
	PugSwitchTeams();
}

public PugIntermissionOT(GEN_FORW_ID(iForward))
{
	PugSwitchTeams();
}

public PugSwitchTeams()
{
	set_task(get_pcvar_float(g_pSwitchDelay),"PugSwitchTeamsReally",1337);
}

public PugSwitchTeamsReally()
{
	new iScore = PugGetTeamScore(1);
	PugSetTeamScore(1,PugGetTeamScore(2));
	PugSetTeamScore(2,iScore);

	new iLimitTeams = get_pcvar_num(g_pMpLimitTeams);
	set_pcvar_num(g_pMpLimitTeams,0);

	new iPlayers[32],iNum,iPlayer;
	get_players(iPlayers,iNum,"h");

	for(new i;i < iNum;i++)
	{
		iPlayer = iPlayers[i];

		switch(cs_get_user_team(iPlayer))
		{
			case CS_TEAM_T: cs_set_user_team(iPlayer,CS_TEAM_CT);
			case CS_TEAM_CT: cs_set_user_team(iPlayer,CS_TEAM_T);
		}
	}

	set_pcvar_num(g_pMpLimitTeams,iLimitTeams);
	
	if(get_pcvar_num(g_pForceRestart)) set_pcvar_num(g_pSvRestart,1);
}

public PugJoinTeam(id) 
{
	new sArg[3];
	read_argv(1,sArg,charsmax(sArg));

	return PugCheckTeam(id,str_to_num(sArg));
}

public PugTeamSelect(id,iKey) return PugCheckTeam(id,iKey + 1);

public PugCheckTeam(id,iTeamNew) 
{
	new iTeam = get_user_team(id);
	
	if((GET_PUG_STATUS() == PUG_STATUS_LIVE) || (PUG_STAGE_FIRSTHALF <= GET_PUG_STAGE() <= PUG_STAGE_OVERTIME))
	{
		if((iTeam == 1) || (iTeam == 2))
		{
			client_print_color
			(
				id,
				print_team_grey,
				"^4%s^1 %L",
				g_sHead,
				LANG_SERVER,
				"PUG_SELECTTEAM_NOSWITCH"
			);
			
			return PLUGIN_HANDLED;
		}
	}
	
	if(iTeam == iTeamNew)
	{
		client_print_color
		(
			id,
			print_team_grey,
			"^4%s^1 %L",
			g_sHead,
			LANG_SERVER,
			"PUG_SELECTTEAM_SAMETEAM"
		);
		
		return PLUGIN_HANDLED;
	}
	
	switch(iTeamNew)
	{
		case 1,2:
		{
			new iMaxPlayers = (GET_CVAR_MAXPLAYERS() / 2);
			
			new iPlayers[32],iNum[CsTeams];
			get_players(iPlayers,iNum[CS_TEAM_T],"eh","TERRORIST");
			get_players(iPlayers,iNum[CS_TEAM_CT],"eh","CT");
			
			if((iNum[CS_TEAM_T] >= iMaxPlayers) && (iTeamNew == 1))
			{
				client_print_color
				(
					id,
					print_team_grey,
					"^4%s^1 %L",
					g_sHead,
					LANG_SERVER,
					"PUG_SELECTTEAM_TEAMFULL"
				);
				
				return PLUGIN_HANDLED;
			}
			else if((iNum[CS_TEAM_CT] >= iMaxPlayers) && (iTeamNew == 2))
			{
				client_print_color
				(
					id,
					print_team_grey,
					"^4%s^1 %L",
					g_sHead,
					LANG_SERVER,
					"PUG_SELECTTEAM_TEAMFULL"
				);
				
				return PLUGIN_HANDLED;
			}
		}
		case 5:
		{
			client_print_color
			(
				id,
				print_team_grey,
				"^4%s^1 %L",
				g_sHead,
				LANG_SERVER,
				"PUG_SELECTTEAM_NOAUTO"
			);
			
			return PLUGIN_HANDLED;
		}
		case 6:
		{
			if(!access(id,PUG_CMD_LVL) && !get_pcvar_num(g_pAllowSpec))
			{
				client_print_color
				(
					id,
					print_team_grey,
					"^4%s^1 %L",
					g_sHead,
					LANG_SERVER,
					"PUG_SELECTTEAM_NOSPC"
				);
				
				return PLUGIN_HANDLED;
			}
		}
	}

	return PLUGIN_CONTINUE;
}

public CS_OnBuy(id,iWeapon)
{
	switch(iWeapon)
	{
		case CSI_HEGRENADE,CSI_FLASHBANG,CSI_SMOKEGRENADE:
		{
			if(GET_PUG_STATUS() != PUG_STATUS_LIVE)
			{
				return !get_pcvar_num(g_pAllowGrenades);
			}
		}
		case CSI_SHIELDGUN:
		{
			return !get_pcvar_num(g_pAllowShield);
		}
	}
	
	return PLUGIN_CONTINUE;
}

public PugFwClientKill(id)
{
	if(is_user_alive(id) && !get_pcvar_num(g_pAllowKill))
	{
		console_print(id,"%s %L",g_sHead,LANG_PLAYER,"PUG_CMD_NOTALLOWED");
		
		return FMRES_SUPERCEDE;
	}
	
	return FMRES_IGNORED;
}
Error


pug_menu.sma
Code:
#include <amxmodx>
#include <amxmisc>

#include <pug_menu>
#include <pug_const>
#include <pug_stocks>
#include <pug_natives>
#include <pug_forwards>
#include <pug_modspecific>

#pragma semicolon 1

CREATE_GEN_FORW_ID(Fw_PugFirstHalf);

#include <pug_captains>

public bool:g_bVoting;

new g_iMenuMap;
new g_iMenuTeam;

new g_bMapNoSwitch;

new g_pVoteDelay;
new g_pVotePercent;
new g_pMapVoteEnabled;
new g_pMapVote;
new g_pShowScores;
new g_pHLDSVote;

#define PUG_MAX_MAPS 16

new g_iMapVotes[PUG_MAX_MAPS];
new g_sMapNames[PUG_MAX_MAPS][32];
new g_iMapCount;

new g_iTeamVotes[5];

new g_pMapCycleFile;

public plugin_init()
{
	register_plugin("Pug Mod Menu",AMXX_VERSION_STR,"Twilight Suzuka");
	
	register_dictionary("pug.txt");
	register_dictionary("pug_vote.txt");
	
	g_pVoteDelay = register_cvar("pug_vote_delay","15.0");
	g_pVotePercent = register_cvar("pug_vote_percent","0.3");
	g_pMapVoteEnabled = register_cvar("pug_vote_map_enabled","1");
	g_pMapVote = register_cvar("pug_vote_map","1");
	g_pShowScores = register_cvar("pug_show_scores","1");
	g_pHLDSVote = register_cvar("pug_hlds_vote","0");
	
	register_clcmd("vote","PugCommandHLDSVote");
	register_clcmd("votemap","PugCommandHLDSVote");
	
	PugRegisterAdminCommand("votemap","PugCommandVoteMap",PUG_CMD_LVL,"Vote Map");
	PugRegisterAdminCommand("voteteams","PugCommandVoteTeam",PUG_CMD_LVL,"Modo de jogo");
	
	g_pMapCycleFile = get_cvar_pointer("mapcyclefile");
	
	g_iMenuMap = menu_create("Vote Map:","PugVoteMapHandle",1);
	menu_setprop(g_iMenuMap,MPROP_EXIT,MEXIT_NEVER);
	
	g_iMenuTeam = menu_create("Modo de jogo:","PugVoteTeamHandle",1);
	
	menu_additem(g_iMenuTeam,"Sem sorteio","1");
	menu_additem(g_iMenuTeam,"Skill","2");
	menu_additem(g_iMenuTeam,"Capitaes","3");
	menu_additem(g_iMenuTeam,"Automatico","4");
	
	menu_setprop(g_iMenuTeam,MPROP_EXIT,MEXIT_NEVER);
}

public plugin_cfg()
{
	new sPatch[64];
	PugGetConfigsDir(sPatch,charsmax(sPatch));

	format(sPatch,charsmax(sPatch),"%s/maps.ini",sPatch);

	if(!PugLoadMaps(sPatch))
	{
		get_pcvar_string(g_pMapCycleFile,sPatch,charsmax(sPatch));
		
		PugLoadMaps(sPatch);
	}
}

public PugFirstHalf(GEN_FORW_ID(iForward))
{
	Fw_PugFirstHalf = iForward;

	if(get_pcvar_num(g_pMapVoteEnabled) && get_pcvar_num(g_pMapVote))
	{
		PugStartVoteMap();
	}
	else
	{
		PugStartVoteTeam();
	}

	return PLUGIN_HANDLED;
}

public PugFinished()
{
	if(!g_bMapNoSwitch) set_pcvar_num(g_pMapVoteEnabled,1);
}

public PugLoadMaps(const sPatch[])
{
	if(file_exists(sPatch))
	{
		new iFile = fopen(sPatch,"rb");
		
		new sMap[32],iNum[10];
	
		new sCurrent[32];
		get_mapname(sCurrent,charsmax(sCurrent));
		
		while(!feof(iFile) && (g_iMapCount < PUG_MAX_MAPS))
		{
			fgets(iFile,sMap,charsmax(sMap));
			trim(sMap);
			
			if(sMap[0] != ';' && is_map_valid(sMap) && !equali(sMap,sCurrent))
			{
				copy(g_sMapNames[g_iMapCount],charsmax(g_sMapNames[]),sMap);
					
				num_to_str(g_iMapCount,iNum,charsmax(iNum));
				menu_additem(g_iMenuMap,g_sMapNames[g_iMapCount],iNum);
			
				g_iMapCount++;
			}
		}
		
		fclose(iFile);
		
		return g_iMapCount;
	}
	
	return 0;
}

public PugStartVoteMap()
{
	new Float:fDelay = get_pcvar_float(g_pVoteDelay);
	
	if(g_bVoting)
	{
		set_task(fDelay,"PugStartVoteMap",1990 + g_iMenuMap);
		
		return PLUGIN_CONTINUE;
	}

	g_bVoting = true;
	arrayset(g_bVoted,false,sizeof(g_bVoted));
	arrayset(g_iMapVotes,0,sizeof(g_iMapVotes));
	
	PugDisplayMenuAll(g_iMenuMap);

	client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,"PUG_VOTE_START","do mapa");
	
	set_task(fDelay,"PugVoteMapEnd",1990 + g_iMenuMap);
	
	return PLUGIN_HANDLED;
}

public PugVoteMapHandle(id,iMenu,iKey)
{
	if(iKey < 0)
	{
		return PLUGIN_HANDLED;
	}
 
	new iAccess,iCallBack,sCommand[3],sOption[32];
	menu_item_getinfo(iMenu,iKey, iAccess, sCommand,charsmax(sCommand),sOption,charsmax(sOption),iCallBack);
	
	g_iMapVotes[str_to_num(sCommand)]++;

	new sName[32];
	get_user_name(id,sName,charsmax(sName));
		
	client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,"PUG_VOTED_FOR",sName,sOption);

	g_bVoted[id] = true;
	
	if(PugShoudStopVote()) PugVoteMapEnd();
 
	return PLUGIN_HANDLED;
}

public PugVoteMapEnd()
{
	PugCancelMenu();

	g_bVoting = false;
	remove_task(1990 + g_iMenuMap);

	if(PugVoteMapCount())
	{
		PugStartVoteTeam();
	}
}

public PugVoteMapCount()
{
	new iWinner,iWinnerVotes,iVotes;

	for(new i;i < g_iMapCount;++i)
	{
		iVotes = g_iMapVotes[i];
		
		if(iVotes > iWinnerVotes)
		{
			iWinner = i;
			iWinnerVotes = iVotes;
		}
		else if(iVotes == iWinnerVotes)
		{
			if(random_num(0,1))
			{
				iWinner = i;
				iWinnerVotes = iVotes;
			}
		}
	}

	if(!g_iMapVotes[iWinner])
	{
		return PugMessage(0,"PUG_VOTE_FAILED_NOVOTES");
	}

	new Float:fTemp = float(PugGetPlayers()) * get_pcvar_float(g_pVotePercent);
	
	if(g_iMapVotes[iWinner] < floatround(fTemp,floatround_floor))
	{
		return PugMessage(0,"PUG_VOTE_FAILED_INSUF_VOTES");
	}

	client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,"PUG_VOTE_WON",g_sMapNames[iWinner]);

	g_bVoting = false;
	g_bMapNoSwitch = true;
	
	set_pcvar_num(g_pMapVoteEnabled,0);

	if(get_pcvar_num(g_pShowScores))
	{
		message_begin(MSG_ALL,SVC_INTERMISSION);
		message_end();
	}

	set_task(5.0,"PugChangeMap",iWinner);
	
	return PLUGIN_CONTINUE;
}

public PugChangeMap(iMap)
{
	server_cmd("changelevel ^"%s^"",g_sMapNames[iMap]);
}

public PugStartVoteTeam()
{
	new Float:fDelay = get_pcvar_float(g_pVoteDelay);
	
	if(g_bVoting)
	{
		set_task(fDelay,"PugStartVoteTeam",1990 + g_iMenuTeam);
		
		return PLUGIN_CONTINUE;
	}

	g_bVoting = true;
	arrayset(g_bVoted,false,sizeof(g_bVoted));
	arrayset(g_iTeamVotes,0,sizeof(g_iTeamVotes));
	
	PugDisplayMenuAll(g_iMenuTeam);

	client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,"PUG_VOTE_START","dos times");

	set_task(fDelay,"PugVoteTeamEnd",1990 + g_iMenuTeam);
	
	return PLUGIN_HANDLED;
}

public PugVoteTeamHandle(id,iMenu,iKey)
{
	if(iKey < 0)
	{
		return PLUGIN_HANDLED;
	}

	new iAccess,iCallBack,sCommand[3],sOption[32];
	menu_item_getinfo(iMenu,iKey, iAccess, sCommand,charsmax(sCommand),sOption,charsmax(sOption),iCallBack);
	
	g_iTeamVotes[str_to_num(sCommand)]++;

	new sName[32];
	get_user_name(id,sName,charsmax(sName));
		
	client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,"PUG_VOTED_FOR",sName,sOption);

	g_bVoted[id] = true;

	if(PugShoudStopVote()) PugVoteTeamEnd();
 
	return PLUGIN_HANDLED;
}

public PugVoteTeamEnd()
{
	PugCancelMenu();
	PugVoteTeamCount();

	g_bVoting = false;
	remove_task(1990 + g_iMenuTeam);
}

public PugVoteTeamCount()
{
	new iWinner,iWinnerVotes,iVotes;
	
	for(new i;i < sizeof(g_iTeamVotes);i++)
	{
		iVotes = g_iTeamVotes[i];
		
		if(iVotes >= iWinnerVotes)
		{
			iWinner = i;
			iWinnerVotes = iVotes;
		}
		else if(iVotes == iWinnerVotes)
		{
			if(random_num(0,1))
			{
				iWinner = i;
				iWinnerVotes = iVotes;
			}
		}
	}
	
	if(!g_iTeamVotes[iWinner])
	{
		ContinueGenForward(Fw_PugFirstHalf);
		
		return PugMessage(0,"PUG_VOTE_FAILED_NOVOTES");
	}

	new Float:fTemp = float(PugGetPlayers()) * get_pcvar_float(g_pVotePercent);
	
	if(g_iTeamVotes[iWinner] < floatround(fTemp,floatround_floor))
	{
		ContinueGenForward(Fw_PugFirstHalf);
		
		return PugMessage(0,"PUG_VOTE_FAILED_INSUF_VOTES");
	}
	
	switch(iWinner)
	{
		case 1:
		{
			PugMessage(0,"PUG_VOTETEAM_UNSORT");
			
			ContinueGenForward(Fw_PugFirstHalf);
		}
		case 2:
		{
			PugMessage(0,"PUG_VOTETEAM_SKILLSORT");
			PugTeamsOptmize();
			
			ContinueGenForward(Fw_PugFirstHalf);
		}
		case 3:
		{
			#if defined _pug_captains_included
			PugMessage(0,"PUG_VOTETEAM_CAPTAINSORT");
			PugTeamsCaptains();
			#else
			PugMessage(0,"PUG_VOTETEAM_CAPTAINSORT_1");
			PugTeamsRandomize();
			
			ContinueGenForward(Fw_PugFirstHalf);
			#endif
		}
		case 4:
		{
			PugMessage(0,"PUG_VOTETEAM_RANDOM");
			PugTeamsRandomize();
			
			ContinueGenForward(Fw_PugFirstHalf);
		}
	}
	
	return PLUGIN_CONTINUE;
}

public PugCommandHLDSVote(id)
{
	new sCommand[10];
	read_argv(0,sCommand,charsmax(sCommand));
	
	new iVote = get_pcvar_num(g_pHLDSVote);
	
	if((equali("vote",sCommand) && !iVote) || (equali("votemap",sCommand) && !iVote))
	{
		console_print(id,"%s %L",g_sHead,LANG_PLAYER,"PUG_CMD_NOTALLOWED");
		
		return PLUGIN_HANDLED;
	}
	
	return PLUGIN_CONTINUE;
}

public PugCommandVoteMap(id,iLevel)
{
	if(!access(id,PUG_CMD_LVL) && (id != 0))
	{
		PugMessage(id,"PUG_CMD_NOACCESS");
	}
	else PugAdminCommand(id,"o Vote Map","PUG_FORCE_VOTE",(g_bVoting) ? 0 : PugStartVoteMap());

	return PLUGIN_HANDLED;
}

public PugCommandVoteTeam(id,iLevel)
{
	if(!access(id,PUG_CMD_LVL) && (id != 0))
	{
		PugMessage(id,"PUG_CMD_NOACCESS");
	}
	else PugAdminCommand(id,"a escolha dos times","PUG_FORCE_VOTE",(g_bVoting) ? 0 : PugStartVoteTeam());

	return PLUGIN_HANDLED;
}
Error


pug_ready.sma
Code:
#include <amxmodx>
#include <amxmisc>

#include <pug_const>
#include <pug_natives>
#include <pug_stocks>
#include <pug_forwards>

#pragma semicolon 1

new bool:g_bReady[33];

CREATE_GEN_FORW_ID(Fw_PugReady);

public plugin_init()
{
	new hPlugin = register_plugin("Pug Ready",AMXX_VERSION_STR,"Twilight Suzuka");
	
	register_dictionary("pug.txt");
	register_dictionary("pug_ready.txt");
	
	PugRegisterCommand("ready","PugIsReady", .sInfo="O Player esta pronto para o jogo");
	PugRegisterCommand("notready","PugNotReady", .sInfo="O Player nao esta pronto para o jogo");
	
	PugRegisterAdminCommand("forceready","PugForceReady",PUG_CMD_LVL,"<Player> - Forca o Player a ficar pronto");
	PugRegisterAdminCommand("forceunready","PugForceNotReady",PUG_CMD_LVL,"<Player> - Forca o Player a nao estar pronto");
	
	Fw_PugReady = CreateGenForward("PugAllReady",hPlugin,get_func_id("PugReadyHandler"));
	
	register_event("ResetHUD","PugKeepUpMenu","b");
	
	PugChangeDisPlay(get_func_id("PugReadyDisPlayReally"),INVALID_PLUGIN_ID);
}

public client_putinserver(id)
{
	PugKeepUpMenu();
}

public client_disconnect(id)
{
	if(GET_PUG_STAGE() == PUG_STAGE_READY)
	{
		if(g_bReady[id])
		{
			g_bReady[id] = false;
		}
		
		PugKeepUpMenu();
	}
}

public client_infochanged(id)
{
	set_task(0.1,"PugKeepUpMenu");
}

public plugin_natives()
{
	register_native("PugNativeReadyPlayers","PugNativeReadyPlayers");
	register_native("PugNativeRegisterReadyDisPlay","PugNativeRegisterReadyDisPlay");
}

public PugNativeReadyPlayers(id,iParams)
{
	new iPlugin = get_param(2);
	PugReadyPlayers(get_param(1),(iPlugin == INVALID_PLUGIN_ID) ? id : iPlugin);
}

public PugNativeRegisterReadyDisPlay(id,iParams)
{
	new iPlugin = get_param(2);
	
	PugChangeDisPlay(get_param(1),(iPlugin == INVALID_PLUGIN_ID) ? id : iPlugin);
}

public PugReadyFunctionID;
public PugReadyPluginID;
public PugReadyPrevStage;

PugReadyPlayers(iFunction,iPlugin = INVALID_PLUGIN_ID)
{
	if(GET_PUG_STAGE() == PUG_STAGE_READY) return;

	PugReadyFunctionID = iFunction;
	PugReadyPluginID = iPlugin;

	PugStartReadyPlayers();
}

public PugStartReadyPlayers()
{
	if(GET_PUG_STATUS() != PUG_STATUS_LIVE)
	{
		return PugSetPauseCall(get_func_id("PugStartReadyPlayers"));
	}

	PugReadyPrevStage = GET_PUG_STAGE();

	SET_PUG_STAGE(PUG_STAGE_READY);
	SET_PUG_STATUS(PUG_STATUS_WAITING);

	arrayset(g_bReady,false,sizeof(g_bReady));

	PugMessage(0,"PUG_READY_UP");
	
	PugKeepUpMenu();

	return PLUGIN_HANDLED;
}

public PugIsReady(id)
{
	if(g_bReady[id] || (GET_PUG_STATUS() != PUG_STATUS_WAITING) || (GET_PUG_STAGE() != PUG_STAGE_READY) || is_user_hltv(id))
	{
		return PugMessage(id,"PUG_CMD_NOTALLOWED");
	}

	g_bReady[id] = true;

	new sName[32];
	get_user_name(id,sName,charsmax(sName));
	
	client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,"PUG_PLAYER_READYED",sName);

	PugReadyDisPlay(9999.0);
	PugCheckReady();

	return PLUGIN_HANDLED;
}

public PugNotReady(id)
{
	if(!g_bReady[id] || (GET_PUG_STATUS() != PUG_STATUS_WAITING) || (GET_PUG_STAGE() != PUG_STAGE_READY) || is_user_hltv(id))
	{
		return PugMessage(id,"PUG_CMD_NOTALLOWED");
	}

	g_bReady[id] = false;

	new sName[32];
	get_user_name(id,sName,charsmax(sName));
	
	client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,"PUG_PLAYER_UNREADYED",sName);

	PugReadyDisPlay(9999.0);

	return PLUGIN_HANDLED;
}

public PugForceReady(id,iLevel)
{
	if(!access(id,PUG_CMD_LVL) && (id != 0))
	{
		PugMessage(id,"PUG_CMD_NOTALLOWED");
	}
	else
	{
		new sArg[32];
		read_argv(1,sArg,charsmax(sArg));
		
		if(equali(sArg,"all"))
		{
			return PugForceReadyAll(id);
		}
		
		new iPlayer = cmd_target(id,sArg,CMDTARGET_OBEY_IMMUNITY);
		
		if(!iPlayer) return PLUGIN_HANDLED;
		
		PugAdminCommandClient(id,"Forcar .ready","PUG_FORCE_READY",iPlayer,PugIsReady(iPlayer));
	}
	
	return PLUGIN_HANDLED;
}

public PugForceNotReady(id,iLevel)
{
	if(!access(id,PUG_CMD_LVL) && (id != 0))
	{
		PugMessage(id,"PUG_CMD_NOTALLOWED");
	}
	else
	{
		new sArg[32];
		read_argv(1,sArg,charsmax(sArg));
		
		if(equali(sArg,"all"))
		{
			return PugForceReadyAll(id);
		}
		
		new iPlayer = cmd_target(id,sArg,CMDTARGET_OBEY_IMMUNITY);
		
		if(!iPlayer) return PLUGIN_HANDLED;
		
		PugAdminCommandClient(id,"Forcar .notready","PUG_FORCE_UNREADY",iPlayer,PugNotReady(iPlayer));
	}
	
	return PLUGIN_HANDLED;
}

public PugForceReadyAll(id)
{
	new iPlayers[32],iNum;
	get_players(iPlayers,iNum,"ch");
	
	for(new i;i < iNum;i++)
	{
		PugIsReady(iPlayers[i]);
	}

	PugAdminCommand(id,"Forcar .ready","PUG_FORCE_ALL_READY",1);
	
	return PLUGIN_HANDLED;
}

public PugForceNotReadyAll(id)
{
	new iPlayers[32],iNum;
	get_players(iPlayers,iNum,"ch");
	
	for(new i;i < iNum;i++)
	{
		PugNotReady(iPlayers[i]);
	}

	PugAdminCommand(id,"Forcar .notready","PUG_FORCE_ALL_UNREADY",1);
	
	return PLUGIN_HANDLED;
}

public PugKeepUpMenu()
{
	if((GET_PUG_STAGE() == PUG_STAGE_READY) && (GET_PUG_STATUS() == PUG_STATUS_WAITING))
	{
		PugReadyDisPlay(9999.0);
	}
}

public PugCheckReady()
{
	new iReady = 0;
	
	for(new i;i < sizeof(g_bReady);i++)
	{
		if(g_bReady[i])
		{
			iReady++;
		}
	}
	
	if(iReady >= GET_CVAR_MINPLAYERS())
	{
		PugReady();
	}
	else PugReadyDisPlay(9999.0);
}

public PugReadyDisPlayFunctionID;
public PugReadyDisPlayPluginID;

public PugChangeDisPlay(iFunction,iPlugin)
{
	PugReadyDisPlayFunctionID = iFunction;
	PugReadyDisPlayPluginID = iPlugin;
	
	PugKeepUpMenu();
}

public PugReadyDisPlay(Float:fHold)
{
	callfunc_begin_i(PugReadyDisPlayFunctionID,PugReadyDisPlayPluginID);
	callfunc_push_float(fHold);
	callfunc_end();
}

public PugReadyDisPlayReally(Float:fHold)
{
	new sReady[512],sNotReady[512],sName[32];
	
	new iPlayers[32],iNum,iPlayer;
	get_players(iPlayers,iNum,"ch");
	
	new iReadys,iPlayerNum;
	
	for(new i;i < iNum;i++)
	{
		iPlayer = iPlayers[i];
		
		iPlayerNum++;
		get_user_name(iPlayer,sName,charsmax(sName));

		if(g_bReady[iPlayer])
		{
			iReadys++;
			
			format(sReady,charsmax(sReady),"%s%s^n",sReady,sName);
		}
		else format(sNotReady,charsmax(sNotReady),"%s%s^n",sNotReady,sName);
	}
	
	new iMinPlayers = GET_CVAR_MINPLAYERS();

	set_hudmessage(0,255,0,0.23,0.02,0,0.0,fHold,0.0,0.0,3);
	show_hudmessage(0,"Aquecendo (%i de %i):",(iPlayerNum - iReadys),iMinPlayers);

	set_hudmessage(0,255,0,0.58,0.02,0,0.0,fHold,0.0,0.0,2);
	show_hudmessage(0,"Prontos (%i de %i):",iReadys,iMinPlayers);

	set_hudmessage(255,255,225,0.58,0.05,0,0.0,fHold,0.0,0.0,1);
	show_hudmessage(0,sReady);

	set_hudmessage(255,255,225,0.23,0.05,0,0.0,fHold,0.0,0.0,4);
	show_hudmessage(0,sNotReady);
}

public PugFirstHalf()
{
	PugReadyDisPlay(0.0);
}

public PugReady()
{
	if(GET_PUG_STAGE() != PUG_STAGE_READY)
	{
		return PLUGIN_CONTINUE;
	}
	else if(GET_PUG_STATUS() != PUG_STATUS_WAITING)
	{
		return PugSetPauseCall(get_func_id("PugReady"));
	}
	
	PugReadyDisPlay(0.0);
	ExecuteGenForward(Fw_PugReady);
	
	return PLUGIN_HANDLED;
}

public PugReadyHandler()
{
	if(GET_PUG_STATUS() != PUG_STATUS_WAITING)
	{
		return PugSetPauseCall(get_func_id("PugReadyHandler"));
	}
	
	SET_PUG_STATUS(PUG_STATUS_LIVE);
	SET_PUG_STAGE(PugReadyPrevStage);

	PugMessage(0,"PUG_IS_READY");

	callfunc_begin_i(PugReadyFunctionID,PugReadyPluginID);
	callfunc_end();

	return PLUGIN_HANDLED;
}
Error






INCLUDES

pug_captains.inc
Code:
#if defined _pug_captains_included
	#endinput
#endif
#define _pug_captains_included

#define TASK_HUDLIST 6676

new g_iCaptain[2];

public PugTeamsCaptains()
{
	new iPlayers[32],iNum;
	get_players(iPlayers,iNum,"h");
	
	new iPlayer,sName[2][32],sTeam[2][32];
	
	if(iNum > 4)
	{
		arrayset(g_iCaptain,0,sizeof(g_iCaptain));
		
		for(new i;i < iNum;i++)
		{
			iPlayer = iPlayers[i];
			
			if(!g_iCaptain[0])
			{
				g_iCaptain[0] = iPlayer;
				get_user_name(iPlayer,sName[0],charsmax(sName[]));
				
				PugSetClientTeam(iPlayer,1);
				PugGetTeamName(1,sTeam[0]);
				
				continue;
			}
			
			if(!g_iCaptain[1])
			{
				g_iCaptain[1] = iPlayer;
				get_user_name(iPlayer,sName[1],charsmax(sName[]));
				
				PugSetClientTeam(iPlayer,2);
				PugGetTeamName(2,sTeam[1]);
				
				continue;
			}
			
			user_silentkill(iPlayer);
			PugSetClientTeam(iPlayer,3);
		}
		
		set_cvar_num("sv_restart",1);
		set_task(0.5,"PugCaptainHud",TASK_HUDLIST, .flags="b");
		set_task(2.0,"PugCaptainMenu",g_iCaptain[random_num(0,1)]);
		
		client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_CAPTAINS_ARE",sName[0],sTeam[0],sName[1],sTeam[1]);
	}
	else
	{
		client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_CAPTAINS_MIN");
		
		ContinueGenForward(Fw_PugFirstHalf);
	}
}

public PugCaptainMenu(id)
{
	if(!is_user_connected(id))
	{
		new iPlayers[32],iNum,iPlayer;
		get_players(iPlayers,iNum,"eh","SPECTATOR");
		
		iPlayer = iPlayers[random(iNum)];
		
		new sName[32];
		get_user_name(iPlayer,sName,charsmax(sName));
		
		new sTeam[32];
	
		if(id == g_iCaptain[0])
		{
			g_iCaptain[0] = iPlayer;
			
			PugSetClientTeam(iPlayer,1);
			PugGetTeamName(1,sTeam);
		}
		else if(id == g_iCaptain[1])
		{
			g_iCaptain[1] = iPlayer;
			
			PugSetClientTeam(iPlayer,2);
			PugGetTeamName(2,sTeam);
		}
		
		client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_CAPTAIN_NEW",sTeam,sName);
		
		set_task(2.0,"PugCaptainMenu",iPlayer);
		
		return;
	}
	
	new iPlayers[32],iNum;
	get_players(iPlayers,iNum,"eh","SPECTATOR");
	
	if(iNum)
	{
		if(is_user_bot(id)) PugCaptainAutoPick(id);
		
		else
		{
			PugCancelMenuClient(id);
			
			new iMenu = menu_create("Spectators:","PugMenuCaptainHandler",1);
			
			new iPlayer,sName[32],sNum[3];
			
			for(new i;i < iNum;i++)
			{
				iPlayer = iPlayers[i];
				
				num_to_str(iPlayer,sNum,charsmax(sNum));
				get_user_name(iPlayer,sName,charsmax(sName));
				
				menu_additem(iMenu,sName,sNum);
			}
			
			menu_setprop(iMenu,MPROP_EXIT,MEXIT_NEVER);
			
			PugDisplayMenuSingle(id,iMenu);
			
			set_task(10.0,"PugCaptainAutoPick",id);
		}
	}
	else
	{
		remove_task(TASK_HUDLIST);
		ContinueGenForward(Fw_PugFirstHalf);
	}
}

public PugMenuCaptainHandler(id,iMenu,iKey)
{
	if(iKey != MENU_EXIT)
	{
		new iAccess,sData[3],sOption[32],iBack;
		menu_item_getinfo(iMenu,iKey,iAccess,sData,charsmax(sData),sOption,charsmax(sOption),iBack);
		
		new iPlayer = str_to_num(sData);
		
		if(is_user_connected(iPlayer) && is_user_connected(id))
		{
			remove_task(id);
			
			PugSetClientTeam(iPlayer,PugGetClientTeam(id));
			PugRespawnClient(iPlayer);
			
			new sName[2][32];
			get_user_name(id,sName[0],charsmax(sName[]));
			get_user_name(iPlayer,sName[1],charsmax(sName[]));
			
			client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_VOTE_CHOOSED",sName[0],sName[1]);
		}
		
		set_task(2.0,"PugCaptainMenu",(id == g_iCaptain[0]) ? g_iCaptain[1] : g_iCaptain[0]);
	}
	
	return PLUGIN_HANDLED;
}

public PugCaptainAutoPick(id)
{
	PugCancelMenuClient(id);
	
	new iPlayers[32],iNum;
	get_players(iPlayers,iNum,"eh","SPECTATOR");
	
	if(iNum)
	{
		new iPlayer = iPlayers[random(iNum)];
		
		if(is_user_connected(iPlayer) && is_user_connected(id))
		{
			PugSetClientTeam(iPlayer,PugGetClientTeam(id));
			PugRespawnClient(iPlayer);
			
			new sName[2][32];
			get_user_name(id,sName[0],charsmax(sName[]));
			get_user_name(iPlayer,sName[1],charsmax(sName[]));
			
			client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,"PUG_VOTE_CHOOSED",sName[0],sName[1]);
		}
		
		set_task(2.0,"PugCaptainMenu",(id == g_iCaptain[0]) ? g_iCaptain[1] : g_iCaptain[0]);
	}
	else
	{
		remove_task(TASK_HUDLIST);
		ContinueGenForward(Fw_PugFirstHalf);
	}
}

#include <pug_natives>

public PugCaptainHud()
{
	new sTRs[512],sCTs[512],sName[32];
	
	new iPlayers[32],iNum,iPlayer;
	get_players(iPlayers,iNum,"h");
	
	for(new i;i < iNum;i++)
	{
		iPlayer = iPlayers[i];
		
		get_user_name(iPlayer,sName,charsmax(sName));
		
		if(g_iCaptain[0] == iPlayer || g_iCaptain[1] == iPlayer)
		{
			format(sName,charsmax(sName),"%s (C)",sName);
		}
		
		switch(PugGetClientTeam(iPlayer))
		{
			case 1:
			{
				format(sTRs,charsmax(sTRs),"%s%s^n",sTRs,sName);
			}
			case 2:
			{
				format(sCTs,charsmax(sCTs),"%s%s^n",sCTs,sName);
			}
		}
	}
	
	static sTeam[2][32];
	PugGetTeamName(1,sTeam[0]);
	PugGetTeamName(2,sTeam[1]);
	
	set_hudmessage(255,0,0,0.23,0.02,0,0.0,0.6,0.0,0.0,1);
	show_hudmessage(0,"%s:",sTeam[0]);

	set_hudmessage(255,255,255,0.23,0.05,0,0.0,0.6,0.0,0.0,2);
	show_hudmessage(0,sTRs);

	set_hudmessage(0,0,255,0.58,0.02,0,0.0,0.6,0.0,0.0,3);
	show_hudmessage(0,"%s:",sTeam[1]);

	set_hudmessage(255,255,255,0.58,0.05,0,0.0,0.6,0.0,0.0,4);
	show_hudmessage(0,sCTs);
}
pug_const.inc
Code:
#if defined _pug_const_included
	#endinput
#endif
#define _pug_const_included

#include <amxmodx>

#pragma semicolon 1

#define PUG_CMD_LVL ADMIN_LEVEL_A

#define PUG_MAX_TEAMS 32
#define PUG_MIN_PLAYERS 5

#define PUG_STATUS_LIVE 0
#define PUG_STATUS_CLEAR 0
#define PUG_STATUS_DEAD (1<<0)
#define PUG_STATUS_WAITING (1<<1)
#define PUG_STATUS_PAUSED (1<<2)
#define PUG_STATUS_UNPAUSED (1<<3)

#define get_x_var(%0) (get_xvar_num(get_xvar_id(%0)))
#define set_x_var(%0,%1) (set_xvar_num(get_xvar_id(%0),%1))

#define GET_PUG_STATUS() get_x_var("g_iStatus")
#define SET_PUG_STATUS(%0) set_x_var("g_iStatus",%0)

stock ADD_PUG_STATUS(iStatus)
{
	do
	{
		new id = get_xvar_id("g_iStatus");
		set_xvar_num(id,get_xvar_num(id) | iStatus);
	}
	while(0)
}

stock REMOVE_PUG_STATUS(iStatus)
{
	do
	{
		new id = get_xvar_id("g_iStatus");
		set_xvar_num(id,get_xvar_num(id) & ~iStatus);
	}
	while(0)
}

enum _:PugStage
{
	PUG_STAGE_WAITING = 0,
	PUG_STAGE_READY,
	PUG_STAGE_START,
	PUG_STAGE_FIRSTHALF,
	PUG_STAGE_INTERMISSION,
	PUG_STAGE_SECONDHALF,
	PUG_STAGE_OVERTIME,
	PUG_STAGE_END
};

stock const g_sStage[PugStage][] =
{
	"Waiting",
	"Readying",
	"Starting",
	"First Half",
	"Intermission",
	"Second Half",
	"Overtime",
	"Finished"
};

#define GET_PUG_STAGE() get_x_var("g_iStage")
#define SET_PUG_STAGE(%0) set_x_var("g_iStage",%0)

#define GET_PUG_ROUND() get_x_var("g_iRounds")

#define GET_CVAR_TOTAL_ROUNDS() get_pcvar_num(get_x_var("g_pMaxRounds"))
#define GET_CVAR_OT_ROUNDS() get_pcvar_num(get_x_var("g_pMaxOTRounds"))

#define GET_CVAR_MAXPLAYERS() get_pcvar_num(get_x_var("g_pMaxPlayers"))
#define SET_CVAR_MAXPLAYERS(%0) set_cvar_num("g_pMaxPlayers",%0)

#define GET_CVAR_MINPLAYERS() get_pcvar_num(get_x_var("g_pMinPlayers"))
#define SET_CVAR_MINPLAYERS(%0) set_cvar_num("g_pMinPlayers",%0)

stock PugGetConfigsDir(sName[],iLen)
{
	get_localinfo("amxx_configsdir",sName,iLen);
	
	format(sName,iLen,"%s/pug-config",sName);
}

stock g_sHead[] = "[PUG]";
pug_forwards.inc
Code:
#if defined _pug_forwards_included
	#endinput
#endif
#define _pug_forwards_included

#include <gen_forw_stocks>

forward PugPreStart(GEN_FORW_ID(iForward));
forward PugFirstHalf(GEN_FORW_ID(iForward));
forward PugIntermission(GEN_FORW_ID(iForward));
forward PugSecondHalf(GEN_FORW_ID(iForward));
forward PugIntermissionOT(GEN_FORW_ID(iForward));
forward PugOvertime(GEN_FORW_ID(iForward));

forward PugAllReady(GEN_FORW_ID(iForward));

forward PugRoundStart();
forward PugRoundStartFailed();

forward PugRoundEnd(iWinner);
forward PugRoundEndFailed();

forward PugWinner(iWinner);
forward PugFinished();
pug_menu.inc
Code:
#if defined _pug_menu_included
	#endinput
#endif
#define _pug_menu_included

stock bool:g_bVoted[33];
stock g_iMenuTemp[33];

stock GET_PUG_VOTING()
{
	if(xvar_exists("g_bVoting"))
	{
		return get_xvar_num(get_xvar_id("g_bVoting"));
	}
	
	return 0;
}

stock PugDisplayMenuAll(iMenu)
{
	new iPlayers[32],iNum,iPlayer;
	get_players(iPlayers,iNum,"ch");
	
	for(new i;i < iNum;i++) 
	{
		iPlayer = iPlayers[i];
		
		g_iMenuTemp[iPlayer] = iMenu;
		
		PugDisplayMenuClient(iPlayer);
	}
}

stock PugDisplayMenuSingle(id,iMenu)
{
	g_iMenuTemp[id] = iMenu;
	
	PugDisplayMenuClient(id);
}

public PugDisplayMenuClient(id)
{
	new iMenu,iKeys;
	new iMenuUP = player_menu_info(id,iMenu,iKeys);

	if((iMenuUP <= 0) || (iMenu < 0))
	{
		menu_display(id,g_iMenuTemp[id],0);
	}
	else set_task(1.0,"PugDisplayMenuClient",id);
}

stock PugCancelMenu()
{
	new iPlayers[32],iNum;
	get_players(iPlayers,iNum,"ch");
	
	for(new i;i < iNum;i++) 
	{
		menu_cancel(iPlayers[i]);
	}
	
	show_menu(0,0,"^n",1);
}

stock PugCancelMenuClient(id)
{
	menu_cancel(id);
	show_menu(id,0,"^n",1);
}

stock bool:PugShoudStopVote()
{
	new iPlayers[32],iNum;
	get_players(iPlayers,iNum,"ch");
	
	for(new i;i < iNum;i++) 
	{
		if(!g_bVoted[iPlayers[i]])
		{
			return false;
		}
	}

	return true;
}
pug_modspecific.inc
Code:
#if defined _pug_modspecific_included
  #endinput
#endif
#define _pug_modspecific_included

native PugGetPlayers();
native PugGetPlayersTeam(iTeam);

native PugTeamsRandomize();
native PugTeamsBalance();
native PugTeamsOptmize();

native PugGetClientTeam(id);
native PugSetClientTeam(id,iTeam);

native PugRespawnClient(id);
native PugSetGodMode(id,iGodMode);
native PugSetClientMoney(id,iMoney,iFlash);

native PugRemoveC4(iRemove);
pug_natives.inc
Code:
#if defined _pug_natives_included
	#endinput
#endif
#define _pug_natives_included

#include <amxconst>

native PugPause();
native PugUnPause();
native PugSetPauseCall(iFunctionID,iPluginID = INVALID_PLUGIN_ID);

native PugCallRoundStart();
native PugCallRoundEnd(iWinner);

native PugCallReset();

native PugSwapTeams(iTeamA,iTeamB);
native PugRegisterTeam(sTeam[]);
native PugNumTeams();

native PugGetTeamName(iTeam,sName[32]);
native PugSetTeamName(iTeam,sName[32]);

native PugSetTeamScore(iTeam,iScore);
native PugGetTeamScore(iTeam);
pug_ready.inc
Code:
#if defined _pug_ready_included
  #endinput
#endif
#define _pug_ready_included

native PugNativeReadyPlayers(iFunctionID,iPluginID = -1);
native PugNativeRegisterReadyDisPlay(iFunctionID,iPluginID = -1);
pug_stocks.inc
Code:
#if defined _pug_stocks_included
	#endinput
#endif
#define _pug_stocks_included

#include <pug_const>

#pragma semicolon 1

stock PugMessage(id,sLang[])
{
	if(!id) server_print("%s %L",g_sHead,LANG_SERVER,sLang);
	
	client_print_color
	(
		id,
		print_team_grey,
		"^4%s^1 %L",
		g_sHead,
		(id == 0) ? LANG_SERVER : LANG_PLAYER,
		sLang
	);
	
	return PLUGIN_HANDLED;
}

stock PugRegisterCommand(const sCommand[],const sFunction[],iFlags = 0,const sInfo[]="")
{
	static sBuffer[16];
	formatex(sBuffer,charsmax(sBuffer),".%s",sCommand);
	
	register_clcmd(sBuffer,sFunction,iFlags,sInfo);
}

stock PugRegisterAdminCommand(const sCommand[],const sFunction[],iFlags = 0,const sInfo[]="")
{
	static sBuffer[16];
	formatex(sBuffer,charsmax(sBuffer),"!%s",sCommand);
	
	register_concmd(sBuffer,sFunction,iFlags,sInfo);
}

stock PugAdminCommand(id,sCommand[],sLang[],iCheck)
{
	if(iCheck)
	{
		new sName[32];
		get_user_name(id,sName,charsmax(sName));

		client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,sLang,sName);
	}
	
	client_print_color(id,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,iCheck ? "PUG_CMD_SUCCESS" : "PUG_CMD_FAILURE",sCommand);
}

stock PugAdminCommandClient(id,sCommand[],sLang[],iClient,iCheck)
{
	if(iCheck)
	{
		new sName[32];
		get_user_name(iClient,sName,charsmax(sName));
		
		client_print_color(0,print_team_grey,"^4%s^1 %L",g_sHead,LANG_SERVER,sLang,sName);
	}
	
	client_print_color(id,print_team_grey,"^4%s^1 %L",g_sHead,LANG_PLAYER,iCheck ? "PUG_CMD_SUCCESS" : "PUG_CMD_FAILURE",sCommand);
}

stock PugDisconnect(const id,const sReason[] = "",any:...)
{
	if(sReason[0])
	{
		new sMessage[192];
		vformat(sMessage,charsmax(sMessage),sReason,3);

		message_begin(MSG_ONE_UNRELIABLE,SVC_DISCONNECT,{0,0,0},id);
		write_string(sMessage);
		message_end();
	}
	else server_cmd("kick #%i",get_user_userid(id));
}
iagopuma is offline
 



Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off

Forum Jump


All times are GMT -4. The time now is 17:45.


Powered by vBulletin®
Copyright ©2000 - 2024, vBulletin Solutions, Inc.
Theme made by Freecode