SpawnBots(amount)
{
	for (i = 1; i <= amount; i++) {
		self thread maps\mp\bots\_bot::spawn_bot("autoassign");
    }
    self iprintln("Spawned ^2" + amount + "^7 bots");
}


ToggleHostMigration()
{	

	self.host_migration = booleanOpposite(self.host_migration);
	onOrOff(self.host_migration, "Host Migration Mode");
	if(self.host_migration)
	{
		self thread host_migration_loop();
	}
	else { self notify("stop_host_migration_mode"); }
}

ToggleGodModeSelf()
{

	self.sgodmode = booleanOpposite(self.sgodmode);
	onOrOff(self.sgodmode, "GodMode");
	if (!self.sgodmode)
	{
		self disableinvulnerability();
	}
}


ToggleGodMode(player)
{
	player.godmode = booleanOpposite(player.godmode);
	onOrOff(player.godmode, player.name + "'s GodMode");
	if (player.godmode && player.status != "Host")
	{
		player enableinvulnerability();
	}
	else { player disableinvulnerability(); }
}

host_migration_loop()
{	
	self endon("stop_host_migration_mode");
	level endon("disconnect");
	for(;;)
    {
	level thread maps/mp/gametypes/_hostmigration::callback_hostmigration();
	wait RandomIntRange(1,18);
	}
}

GivePlayerKillStreaks(player)
{
player maps\mp\gametypes\_globallogic_score::_setplayermomentum(player, 32164);
self iprintln("Gave killstreaks to ^2" + player.name);
}

PlayerSuicide(player)
{
	player suicide();
}


changeMap(name)
{
	name = "mp_" + name;
	setDvar("ui_mapname", name);
	setDvar("ls_mapname", name);
	setDvar("mapname", name);
	setDvar("ui_currentMap", name);
	map(name, true);
	//fast_restart();
}

GiveUAV(player)
{
	player.has_uav = booleanOpposite(player.has_uav);
	onOrOff(player.has_uav, "UAV for " + player.name);
	if (player.has_uav){
		player setclientuivisibilityflag( "g_compassShowEnemies", 1 );
	} else { player setclientuivisibilityflag( "g_compassShowEnemies", 0); }

}

InvisibilityToggle()
{
	self.has_invis = booleanOpposite(self.has_invis);
	onOrOff(self.has_invis, "Invisibility");
	if (!self.has_invis)
	{
		self show();
	} 
}


ThirdPersonToggle()
{	
	self.inthirdperson = booleanOpposite(self.inthirdperson);
	onOrOff(self.inthirdperson, "Third Person");
	if (!self.inthirdperson)
	{
		self setclientthirdperson(0);
	}
}

GiveAmmoPlayer(player)
{
	if (player getcurrentweapon() != "none")
	{
	player giveMaxAmmo(player getCurrentWeapon());
	self iprintln("Gave ^2" + player.name + " ^7 ammo. Tell them to reload");
	}
}

ClonePlayersGun(player)
{
	if (player getcurrentweapon() != "none")
	{
	weapon = player getcurrentweapon();
	if (self getcurrentweapon() != weapon)
	{
	self giveweapon(weapon);
	self switchtoweapon(weapon);
	RefillAmmoPlayer(self);
	self iprintln("Cloned ^2" + player.name + "'s ^7weapon.");
	}
	}
}

RefillAmmoPlayer(player)
{
	if (player getcurrentweapon() != "none")
	{
	player setWeaponAmmoClip(player getCurrentWeapon(), weaponClipSize(player getCurrentWeapon()));
	GiveAmmoPlayer(player);
	}
}

RemoveAmmoPlayer(player)
{
	if (player getcurrentweapon() != "none")
	{
		player setWeaponAmmoClip(player getCurrentWeapon(), 0);
		player setweaponammostock(player getCurrentWeapon(), 0);
	}

}

RemoveWeaponsPlayer(player)
{
	player takeallweapons();
	self iprintln("^1Removed weapons from " + player.name);
}

GiveCamoIndexPlayer(player, camo)
{	


	if (player getcurrentweapon() != "none")
	{
		current_weapon = player getcurrentweapon();
		player takeweapon(current_weapon);
		player giveweapon( current_weapon, 0, camo, 0, 0, 0, 0 );
		player switchtoweapon(current_weapon);
		player setspawnweapon( player getcurrentweapon());
		self iprintln("Gave camo ^4#" + camo + "^7 to ^2" + player.name);  
	}

}



ShootPlayer(player)
{	
	if (self getcurrentweapon() != "none")
	{
		forward = anglestoforward(self getplayerangles());
		start = self geteye();
		end = vectorscale(start, 9999);
		magicbullet(self getcurrentweapon(), start, player.origin+(0,0,1), self);
	}
}

ToggleInfiniteClip()
{

	self.inf_clip = booleanOpposite(self.inf_clip);
	onOrOff(self.inf_clip, "Infinite Clip");
	if (self.inf_clip)
	{
		self thread InfiniteClip();
	}
	else
	{
		self notify("stop_inf_clip");
	}

}

InfiniteClip()
{
self endon( "disconnect" );
self endon ( "stop_inf_clip" );
level endon( "game_ended" );

for (;;)
{
	if (self getcurrentweapon() != "none")
	{
		self setWeaponAmmoClip(self getCurrentWeapon(), weaponClipSize(self getCurrentWeapon()));
	}
	wait 0.1;
}

}

ToggleInfiniteStockLegit()
{
	self.inf_stock = booleanOpposite(self.inf_stock);
	onOrOff(self.inf_stock, "Infinite Stock (^3Legit^7)");
	if (self.inf_stock)
	{	
	
		self thread InfiniteStockLegit();
	}
	else
	{
		self notify("stop_inf_stock");
	}
}

InfiniteStockLegit()
{
self endon( "disconnect" );
self endon ( "stop_inf_stock" );

for (;;)
{
	if (self getcurrentweapon() != "none")
	{
		if (self getweaponammostock(self getCurrentWeapon()) == 0)
		{
		self giveMaxAmmo(self getCurrentWeapon());
		}
	}
	wait 0.1;
}

}

ToggleInfiniteStockNeverEnding()
{

	self.inf_stock = booleanOpposite(self.inf_stock);
	onOrOff(self.inf_stock, "Infinite Stock");
	if (self.inf_stock)
	{
		self thread InfiniteStockNeverEnding();
	}
	else
	{
		self notify("stop_inf_stock");
	}

}

InfiniteStockNeverEnding()
{
self endon( "disconnect" );
self endon ( "stop_inf_stock" );
for (;;)
{
	if (self getcurrentweapon() != "none")
	{
		self giveMaxAmmo(self getCurrentWeapon());
	}
	wait 0.1;
}
	
}


ToggleInfiniteEquipment()
{

	self.inf_equipment = booleanOpposite(self.inf_equipment);
	onOrOff(self.inf_equipment, "Infinite Equipment");
	if (self.inf_equipment)
	{
		self thread InfiniteEquipment();
	}
	else
	{
		self notify("stop_inf_eq");
	}

}

InfiniteEquipment()
{

self endon( "disconnect" );
self endon ( "stop_inf_eq" );
for (;;)
{
    if(self getCurrentOffHand() != "none") {
    	self giveMaxAmmo(self getCurrentOffHand());
    }
    wait .01;

}
}


DoCrossHair()
{
	self.custom_crosshair = booleanOpposite(self.custom_crosshair);
	onOrOff(self.custom_crosshair, "Custom Crosshair");
	if (self.custom_crosshair)
	{
		self.crosshair_n = self drawText("+", "hudBig", 14, 0, 177, (0,1,0), 1, (1,1,1), 0, 255);
		self.crosshair_n.glowalpha = 0;
	}
	else
	{
		self.crosshair_n destroy();
	}
}

PauseGameTimer()
{
	self.game_timer_passed_n = booleanOpposite(self.game_timer_passed_n);
	onOrOff(self.game_timer_passed_n, "Pause Game Timer");
	if (self.game_timer_passed_n)
	{
		level thread maps/mp/gametypes/_globallogic_utils::pausetimer();
	}
	else
	{
		level thread maps/mp/gametypes/_globallogic_utils::resumetimer();
	}
}


InfiniteGame()
{

	self.infinite_game_ = booleanOpposite(self.infinite_game_);
	onOrOff(self.infinite_game_, "Infinite Game");
	if (self.infinite_game_)
	{	
		
		self.inf_game_only_headshots = GetDvar("scr_game_onlyheadshots");
		self.inf_game_sd_numlives = GetDvar("scr_sd_numlives");
		self.inf_game_war_scorelimit = GetDvar("scr_war_scorelimit");
		self.inf_game_war_timelimit = GetDvar("scr_war_timelimit");
		self.inf_game_dom_scorelimit = GetDvar("scr_dom_scorelimit");
		if (!IsDefined(self.game_timer_passed_n) || !self.game_timer_passed_n)
		{
		level thread maps/mp/gametypes/_globallogic_utils::pausetimer();
		self.game_timer_passed_n = true;
		}
		setDvar("scr_dom_scorelimit",0);
		setDvar("scr_sd_numlives",10);
		setDvar("scr_war_timelimit",0);
		setDvar("scr_game_onlyheadshots",0);
		setDvar("scr_war_scorelimit",0);
	}
	else
	{
		if (IsDefined(self.game_timer_passed_n) && self.game_timer_passed_n)
		{
		level thread maps/mp/gametypes/_globallogic_utils::resumetimer();
		self.game_timer_passed_n = false;
		}
		setDvar("scr_dom_scorelimit",self.inf_game_dom_scorelimit);
		setDvar("scr_sd_numlives",self.inf_game_sd_numlives);
		setDvar("scr_war_timelimit",self.inf_game_war_timelimi);
		setDvar("scr_game_onlyheadshots",self.inf_game_only_headshots);
		setDvar("scr_war_scorelimit",self.inf_game_war_scorelimi);
		
	}
	
}

ResetVoiceChatSettings()
{
	setmatchtalkflag( "DeadChatWithDead", level.voip.deadchatwithdead );
    setmatchtalkflag( "DeadChatWithTeam", level.voip.deadchatwithteam );
    setmatchtalkflag( "DeadHearTeamLiving", level.voip.deadhearteamliving );
    setmatchtalkflag( "DeadHearAllLiving", level.voip.deadhearallliving );
    setmatchtalkflag( "EveryoneHearsEveryone", level.voip.everyonehearseveryone );
    setmatchtalkflag( "DeadHearKiller", level.voip.deadhearkiller );
    setmatchtalkflag( "KillersHearVictim", level.voip.killershearvictim );
	self iprintln("^4Reset all voice chat options!");
}

VoiceChatSettings(matchtalkflag)
{
		setmatchtalkflag(matchtalkflag, "1" );
		self iprintln("^2" + matchtalkflag + " was or is enabled.");
}


ShowPerksToggle()
{

	self.custom_perk_hint = booleanOpposite(self.custom_perk_hint);
	onOrOff(self.custom_perk_hint, "Show Perks");
	if (self.custom_perk_hint)
	{	
		self.perkhudelem fadeovertime(99999);
		self thread ShowPerks();
	}
	else
	{
		self.perkhudelem fadeovertime(0.4);
		self maps\mp\gametypes\_hud_util::hideallperks(0.4, 0);
		self notify("stop_show_perks");
	}
}


ShowPerks()
{

	self endon("stop_show_perks");
	self endon("disconnect");
	level endon( "game_ended" );
	
	for(;;)
    {
    	if (self.health > 0 && getDvar("g_gametype") != "shrp")
    	{
    		//
    		ypos = 40;
    		if ( self issplitscreen() )
        		ypos = 5;
    		if ( !isdefined( self.perkhudelem ) )
        		self.perkhudelem = createloadouticon( self, 0, 0, 200, ypos );
    		else
        		self.perkhudelem setloadouticoncoords( self, 0, 0, 200, ypos );
    		self.perkhudelem setperks( self );
    		self.perkhudelem.x = -20;
    		self.perkhudelem.alpha = 0;
    		self.perkhudelem.alpha = 1;
    		self.perkhudelem.hidewheninmenu = 1;
    	}
    	wait 0.4;
    }
	


}

mapRestart()
{
	map_restart();
}

RageQuit()
{
    exitLevel(false);
}

GivePerksToggle()
{	
	self.give_perks = booleanOpposite(self.give_perks);
	onOrOff(self.give_perks, "Give All Perks");
	if (!self.give_perks)
	{
		self clearperks();
	}
}



QuickClassChangeToggle()
{	
	self.instant_class = booleanOpposite(self.instant_class);
	onOrOff(self.instant_class, "Instant Class Changes");
	if (self.instant_class)
	{
		self thread QuickClassChange();
	}
	else { self notify("stop_instant_cl_change"); }
}


QuickClassChange()
{

   self endon("disconnect");
   self endon("stop_instant_cl_change");

   for(;;)

   {

		self waittill("changed_class");
		self maps/mp/gametypes/_class::giveloadout( self.team, self.class );

   }

}



KickPlayer(player)
{

	kick(player getentitynumber());
	openMenu();
}





KickAll(type)
{

if (type == "bots")
{

foreach (player in level.players)
{
	if (isDefined(player.pers["isBot"]) && player.pers["isBot"])
	{
		KickPlayer(Player);
	}
}


}

if (type == "all")
{

foreach (player in level.players)
{
	if (player != self)
	{
		KickPlayer(Player);
	}
}

}

}




SuicideAll(type)
{

if (type == "bots")
{

foreach (player in level.players)
{
	if (isDefined(player.pers["isBot"]) && player.pers["isBot"])
	{
		PlayerSuicide(Player);
	}
}


}

if (type == "all")
{

foreach (player in level.players)
{
	if (player != self)
	{
		PlayerSuicide(Player);
	}
}

}

}


RemoveAmmoAll(type)
{

if (type == "bots")
{

foreach (player in level.players)
{
	if (isDefined(player.pers["isBot"]) && player.pers["isBot"])
	{
		RemoveAmmoPlayer(player);
	}
}


}

if (type == "all")
{

foreach (player in level.players)
{
	if (player != self)
	{
		RemoveAmmoPlayer(player);
	}
}

}

}


RemoveWeaponsAll(type)
{

if (type == "bots")
{

foreach (player in level.players)
{
	if (isDefined(player.pers["isBot"]) && player.pers["isBot"])
	{
		RemoveWeaponsPlayer(player);
	}
}


}

if (type == "all")
{

foreach (player in level.players)
{
	if (player != self)
	{
		RemoveWeaponsPlayer(player);
	}
}

}

}



SixthSenseToggle()
{


	self.auto_shoot = booleanOpposite(self.auto_shoot);
	onOrOff(self.auto_shoot, "Sixth Sense");
	if (self.auto_shoot)
	{
		self thread SixthSense();
	}
	else { self notify("stop_auto_shoot"); }

}


isEnemy(player)//(level.teambased && player.team == self.team)player)
{
	if (player != self && !level.teambased || player != self && player.team != self.team)
	{
	return true;
	}
	else {
	return false;
	}
}

SixthSense()
{
	self endon("stop_auto_shoot");
	self endon("disconnect");
	level endon( "game_ended" );
	
	for(;;)
    {
    
    foreach (player in level.players)
{
    if (distance(self.origin, player.origin) <= 300 && isEnemy(player) && player.health > 0 && self.health > 0)
    {	
    	
    	ShootPlayer(player);
	}
}
    
    wait 0.1;
    }
}

GiveWeaponSelf(weapon)
{	
	
	weapon_name = weaponLookup(weapon);
	weapon = weapon + "_mp";
	if (self getcurrentweapon() != "none")
	{
		self takeweapon(self getcurrentweapon());
	}
	if (self getcurrentweapon() != weapon)
	{
	self giveweapon(weapon);
	self switchtoweapon(weapon);
	self setWeaponAmmoClip(weapon, weaponClipSize(weapon));
	self giveMaxAmmo(weapon);
	self iprintlnbold("^3" + weapon_name + " is equipped.");
	}
}

AlwaysShowEnemyNames()
{

	self.long_enemy_names = booleanOpposite(self.long_enemy_names);
	onOrOff(self.long_enemy_names, "Always Show Enemy Player Names");
	if (self.long_enemy_names)
	{
		setDvar("cg_enemyNameFadeIn", "0");
		setDvar("cg_enemyNameFadeOut", "999999");
		setDvar("cg_FriedlyNameFadeOut", "999999");
	}
	else { 
		setDvar("cg_enemyNameFadeIn", "250");
		setDvar("cg_enemyNameFadeOut", "250");
		setDvar("cg_FriedlyNameFadeOut", "1500");
	}

}


BigNames()
{

	self.big_overhead_names = booleanOpposite(self.big_overhead_names);
	onOrOff(self.big_overhead_names, "Big Ass Names");
	if (self.big_overhead_names)
	{
		setDvar("cg_overheadnamessize", "3");
	}
	else { 
		setDvar("cg_overheadnamessize", "0.65");
	}

}