initial commit after moving to new repo

13 files changed, 2669 insertions, 0 deletions

diff --git a/bobthebob.testing/mod.json b/bobthebob.testing/mod.json
new file mode 100644
index 00000000..f79cb091
--- /dev/null
+++ b/bobthebob.testing/mod.json
@@ -0,0 +1,40 @@
+{
+	"ApiId" : "bobthebob.testing",
+	"Name" : "bobthebob.testing",
+	"Description" : "a place to put custom testing/debug functions and shit, shouldn't mess with game core behaviour at all",
+	"Authors" : [
+		"BobTheBob"
+	],
+	"Contacts" : [
+		"BobTheBob#1150"
+	],
+	"Version" : "0.1",
+	"CustomScripts": [
+		{
+			"Path": "sh_bobtestingfunctions_mp.gnut",
+			"RunOn": "( CLIENT || SERVER ) && MP"
+		},
+		{
+			"Path": "_bobtestingfunctions_sp.gnut",
+			"RunOn": "SERVER && SP"
+		},
+		{
+			"Path": "_bobtestingfunctions_mp.gnut",
+			"RunOn": "SERVER && MP",
+			"ServerPreCallback": "SvTestingMPInit"
+		},
+		
+		{
+			"Path": "sh_bleedout_test.gnut",
+			"RunOn": "( CLIENT || SERVER ) && MP",
+			"ServerPreCallback": "BleedoutTest_Init",
+			"ClientPreCallback": "BleedoutTest_Init",
+		},
+		
+		{
+			"Path": "sh_northstar_utils.gnut",
+			"RunOn": "CLIENT || SERVER || UI",
+		}
+		
+	]
+}
\ No newline at end of file
diff --git a/bobthebob.testing/scripts/vscripts/_bobtestingfunctions_mp.gnut b/bobthebob.testing/scripts/vscripts/_bobtestingfunctions_mp.gnut
new file mode 100644
index 00000000..b782243a
--- /dev/null
+++ b/bobthebob.testing/scripts/vscripts/_bobtestingfunctions_mp.gnut
@@ -0,0 +1,239 @@
+untyped
+globalize_all_functions
+
+void function SvTestingMPInit()
+{
+	Bleedout_Init()
+	AddCallback_EntitiesDidLoad( CreateSpawns )
+}
+
+void function CreateSpawns()
+{
+	//thread CreateSpawns_Threaded()
+}
+
+void function CreateSpawns_Threaded()
+{
+	WaitEndFrame() // wait for spawns to get cleared, game ctds if we don't do this
+	entity validSpawn = GetEntArrayByClass_Expensive( "info_spawnpoint_human" )[ 0 ]
+
+	for ( int i = 0; i < 50; i++ )
+	{
+		entity newSpawn = CreateEntity( "info_spawnpoint_human" )
+		newSpawn.SetOrigin( validSpawn.GetOrigin() )
+		DispatchSpawn( newSpawn )
+	}
+}
+
+void function TestSpawnpoints( bool titan = false )
+{
+	entity player = GetPlayerArray()[0]
+	array<entity> spawnpoints
+	if ( !titan )
+		spawnpoints = SpawnPoints_GetPilotStart( player.GetTeam() )
+	else
+		spawnpoints = SpawnPoints_GetTitanStart( player.GetTeam() )
+	
+	SpawnPoints_InitRatings( player, player.GetTeam() )
+	
+	foreach ( entity spawnpoint in spawnpoints )
+		spawnpoint.CalculateRating( titan ? TD_TITAN : TD_PILOT, player.GetTeam(), RandomFloat( 7.0 ) - 3.5, RandomFloat( 7.0 ) - 3.5 )
+		
+	if ( !titan )
+	{
+		SpawnPoints_SortPilotStart()
+		spawnpoints = SpawnPoints_GetPilotStart( player.GetTeam() )
+	}
+	else
+	{
+		SpawnPoints_SortTitanStart()
+		spawnpoints = SpawnPoints_GetTitanStart( player.GetTeam() )
+	}
+		
+	entity chosenPoint
+	foreach ( entity spawnpoint in spawnpoints )
+		if ( IsSpawnpointValid( spawnpoint, player.GetTeam() ) )
+		{
+			chosenPoint = spawnpoint
+			break
+		}
+	
+	player.SetOrigin( chosenPoint.GetOrigin() )
+	player.SetAngles( chosenPoint.GetAngles() )
+	
+	//SpawnPoints_DiscardRatings() // somehow the game seems to call this automatically so unneeded
+}
+
+bool function IsSpawnpointValid( entity spawnpoint, int team )
+{
+	if ( GameModeRemove( spawnpoint ) )
+		return false
+
+	// ultra temp
+	print( spawnpoint.GetTeam() )
+	if ( spawnpoint.GetTeam() == 0 )
+		return false
+	
+	if ( spawnpoint.GetTeam() > 0 && spawnpoint.GetTeam() != team )
+		return false
+
+	
+		
+	return true
+}
+
+void function TestScoreEvent( entity player, int id )
+{
+	ScoreEvent event = ScoreEvent_FromId( id )
+	
+	Remote_CallFunction_NonReplay( player, "ServerCallback_ScoreEvent", id, event.pointValue, event.displayType, player.GetEncodedEHandle(), event.earnMeterOwnValue, event.earnMeterEarnValue )
+}
+
+void function TestDrop( entity player )
+{
+	thread CreateTitanForPlayerAndHotdrop( player, GetTitanReplacementPoint( player, false ) )
+}
+
+void function WarpThroughSpawnpoints( string modeOverride = "" ) 
+{
+	if ( !modeOverride.len() )
+		modeOverride = GAMETYPE
+
+	entity player = GetPlayerArray()[0]
+
+	array<entity> spawnpoints = GetEntArrayByClass_Expensive( "info_hardpoint" ) //SpawnPoints_GetPilot()
+	foreach ( entity spawnpoint in spawnpoints )
+	{
+		//string gamemodeKey = "gamemode_" + modeOverride
+		//if ( spawnpoint.HasKey( gamemodeKey ) && ( spawnpoint.kv[ gamemodeKey ] == "0" || spawnpoint.kv[ gamemodeKey ] == "" ) )
+		//	continue
+		//	
+		//if ( !spawnpoint.HasKey( gamemodeKey ) )
+		//	continue
+		
+		if ( spawnpoint.HasKey( "hardpointGroup" ) )
+			print( spawnpoint.kv.hardpointGroup )
+			
+		player.SetOrigin( spawnpoint.GetOrigin() )
+		player.SetAngles( spawnpoint.GetAngles() ) 
+		
+		wait 0.5
+	}
+}
+
+void function AttemptSpawnBuddyTitan()
+{
+	PrecacheModel( $"models/titans/buddy/titan_buddy.mdl" )
+	PrecacheModel( $"models/weapons/arms/buddypov.mdl" )
+	
+	entity player = GetPlayerArray()[0]
+	entity titan = CreateNPCTitan( "titan_buddy", player.GetTeam(), player.GetOrigin(), <0, 0, 0> )
+	SetSpawnOption_AISettings( titan, "npc_titan_buddy" )
+	SetSpawnOption_Weapon( titan, "mp_titanweapon_xo16_vanguard", [ ] )
+	
+	DispatchSpawn( titan )
+	
+	player.SetPetTitan( titan )
+	titan.SetOwner( player )
+	titan.SetUsable()
+}
+
+
+void function SetPlayerCameraToHead()
+{
+	entity viewControl = CreateEntity( "point_viewcontrol" )
+	viewControl.kv.spawnflags = 56
+	DispatchSpawn( viewControl )
+	
+	viewControl.SetParent( GetPlayerArray()[0], "headshot" )
+	viewControl.SetOrigin( < 4, 0, 1 > )
+	viewControl.SetAngles( < 0, 0, 0 > )
+	GetPlayerArray()[0].SetViewEntity( viewControl, true )
+}
+
+void function CreateTestControlPanel()
+{
+	entity player = GetPlayerArray()[0]
+	
+	entity panel = CreateEntity( "prop_control_panel" )
+	panel.SetValueForModelKey( $"models/communication/terminal_usable_imc_01.mdl" )
+	panel.SetOrigin( player.GetOrigin() )
+	panel.SetAngles( player.GetAngles() )
+	panel.kv.solid = SOLID_VPHYSICS
+	SetTargetName( panel, "cpanel" )
+	DispatchSpawn( panel )
+	
+	panel.SetModel( $"models/communication/terminal_usable_imc_01.mdl" )
+	panel.s.onPlayerFinishesUsing_func = TestOnPanelHacked
+	
+}
+
+function TestOnPanelHacked( panel, player, success )
+{
+	expect entity( panel )
+	expect entity( player )
+	expect bool( success )
+	
+	if ( !success )
+		return
+	
+	print( panel + " was hacked by " + player )
+	PanelFlipsToPlayerTeamAndUsableByEnemies( panel, player )
+}
+
+void function TestFastball()
+{
+	PrecacheModel( $"models/titans/buddy/titan_buddy.mdl" )
+	RegisterSignal( "fastball_start_throw" )
+	RegisterSignal( "fastball_release" )
+	PrecacheParticleSystem( $"P_BT_eye_SM" )
+	
+	entity player = GetPlayerArray()[0]
+	
+	entity prop = CreatePropDynamic( $"models/titans/buddy/titan_buddy.mdl", player.GetOrigin(), player.GetAngles() )
+	thread PlayAnim( prop, "bt_beacon_fastball_throw_end" )
+	
+	player.ContextAction_SetFastball()
+	FirstPersonSequenceStruct throwSequence
+	throwSequence.attachment = "REF"
+	throwSequence.useAnimatedRefAttachment = true
+	throwSequence.hideProxy = true
+	throwSequence.firstPersonAnim = "ptpov_beacon_fastball_throw_end"
+	//throwSequence.thirdPersonAnim = "pt_beacon_fastball_throw_end"
+	throwSequence.firstPersonBlendOutTime = 0.0
+	
+	thread FirstPersonSequence( throwSequence, player, prop )
+	player.HolsterWeapon()
+	
+	EmitSoundOnEntityOnlyToPlayer( player, player, "Music_Beacon_14_BTThrowThruFirstCrane" )
+	
+	prop.WaitSignal( "fastball_start_throw" )
+	float duration = EmitSoundOnEntity( prop, "diag_sp_spoke1_BE117_04_01_mcor_bt" ) // trust me
+	vector eyeAngles = player.EyeAngles()
+	
+	// particle effect 
+	StartParticleEffectOnEntity( prop, GetParticleSystemIndex( $"P_BT_eye_SM" ), FX_PATTACH_POINT_FOLLOW, prop.LookupAttachment( "EYEGLOW" ) )
+	wait duration
+	
+	prop.WaitSignal( "fastball_release" )
+	player.ContextAction_ClearFastball()
+	player.ClearParent()
+	ClearPlayerAnimViewEntity( player )
+	player.SetVelocity( AnglesToForward( eyeAngles ) * 1250 )
+	player.DeployWeapon()
+	
+	wait 0.5
+	prop.Destroy()
+}
+
+void function TestPlanetExplosion() // won't look good until we can load textures from rpak for these models
+{
+	PrecacheModel( $"models/vistas/planet_ex_static.mdl" )
+	PrecacheModel( $"models/vistas/planet_explosion_animated.mdl" )
+	
+	entity cam = GetEnt( "skybox_cam_level" )
+	cam.SetOrigin( < 7000, 7000, 7000 > ) // arbitrary point
+	CreatePropDynamic( $"models/vistas/planet_ex_static.mdl", cam.GetOrigin(), cam.GetAngles() )
+	entity explosion = CreatePropDynamic( $"models/vistas/planet_explosion_animated.mdl", cam.GetOrigin(), cam.GetAngles() )
+	thread PlayAnim( explosion, "planet_ex_ending" )
+}
\ No newline at end of file
diff --git a/bobthebob.testing/scripts/vscripts/_bobtestingfunctions_sp.gnut b/bobthebob.testing/scripts/vscripts/_bobtestingfunctions_sp.gnut
new file mode 100644
index 00000000..2ad814fe
--- /dev/null
+++ b/bobthebob.testing/scripts/vscripts/_bobtestingfunctions_sp.gnut
@@ -0,0 +1,13 @@
+globalize_all_functions
+
+void function TestPlanetExplosion()
+{
+	PrecacheModel( $"models/vistas/planet_ex_static.mdl" )
+	PrecacheModel( $"models/vistas/planet_explosion_animated.mdl" )
+	
+	entity cam = GetEnt( "skybox_cam_level" )
+	cam.SetOrigin( < 7000, 7000, 7000 > ) // arbitrary point
+	CreatePropDynamic( $"models/vistas/planet_ex_static.mdl", cam.GetOrigin(), cam.GetAngles() )
+	entity explosion = CreatePropDynamic( $"models/vistas/planet_explosion_animated.mdl", cam.GetOrigin(), cam.GetAngles() )
+	thread PlayAnim( explosion, "planet_ex_ending" )
+}
\ No newline at end of file
diff --git a/bobthebob.testing/scripts/vscripts/lobby/sh_lobby.gnut b/bobthebob.testing/scripts/vscripts/lobby/sh_lobby.gnut
new file mode 100644
index 00000000..24436017
--- /dev/null
+++ b/bobthebob.testing/scripts/vscripts/lobby/sh_lobby.gnut
@@ -0,0 +1,356 @@
+globalize_all_functions
+
+const string PRIVATE_MATCH_PLAYLIST = "private_match"
+
+struct {
+	array<string> modes = [ // default modes in vanilla
+		"aitdm",
+		"tdm",
+		"cp",
+		"at",
+		"ctf",
+		"lts",
+		"ps",
+		"speedball",
+		"mfd",
+		"ttdm",
+		"fd_easy",
+		"fd_normal",
+		"fd_hard",
+		"fd_master",
+		"fd_insane"
+	]
+	
+	array<string> maps = [ // default maps in vanilla
+		"mp_forwardbase_kodai",
+		"mp_grave",
+		"mp_homestead",
+		"mp_thaw",
+		"mp_black_water_canal",
+		"mp_eden",
+		"mp_drydock",
+		"mp_crashsite3",
+		"mp_complex3",
+		"mp_angel_city",
+		"mp_colony02",
+		"mp_glitch",
+		"mp_relic02",
+		"mp_wargames",
+		"mp_rise",
+		"mp_lf_stacks",
+		"mp_lf_deck",
+		"mp_lf_meadow",
+		"mp_lf_traffic",
+		"mp_lf_township",
+		"mp_lf_uma"
+	]
+} file 
+
+void function AddPrivateMatchMode( string mode )
+{
+	if ( !file.modes.contains( mode ) )
+		file.modes.append( mode )
+	
+	#if CLIENT
+		// call this on ui too so the client and ui states are the same
+		RunUIScript( "AddPrivateMatchMode", mode ) 
+	#endif
+}
+
+void function AddPrivateMatchMap( string map )
+{
+	if ( !file.maps.contains( map ) )
+		file.maps.append( map )
+	
+	#if CLIENT 
+		// call this on ui too so the client and ui states are the same
+		RunUIScript( "AddPrivateMatchMap", map )
+	#endif
+}
+
+array<string> function GetPrivateMatchModes()
+{
+	//array<string> modesArray
+	//
+	//int numModes = GetPlaylistGamemodesCount( PRIVATE_MATCH_PLAYLIST )
+	//for ( int modeIndex = 0; modeIndex < numModes; modeIndex++ )
+	//{
+	//	modesArray.append( GetPlaylistGamemodeByIndex( PRIVATE_MATCH_PLAYLIST, modeIndex ) )
+	//}
+	
+	//return modesArray
+	
+	return file.modes
+}
+
+int function GetPrivateMatchModeIndex( string modeName )
+{
+	//int indexForName = 0
+	//
+	//int numModes = GetPlaylistGamemodesCount( PRIVATE_MATCH_PLAYLIST )
+	//for ( int modeIndex = 0; modeIndex < numModes; modeIndex++ )
+	//{
+	//	if ( GetPlaylistGamemodeByIndex( PRIVATE_MATCH_PLAYLIST, modeIndex ) != modeName )
+	//		continue
+	//
+	//	indexForName = modeIndex;
+	//	break
+	//}
+	//
+	//return indexForName
+	
+	return file.modes.find( modeName )
+}
+
+
+array<string> function GetPrivateMatchMapsForMode( string modeName )
+{
+	//array<string> mapsArray
+	//
+	//int modeIndex = GetPrivateMatchModeIndex( modeName )
+	//int numMaps = GetPlaylistGamemodeByIndexMapsCount( PRIVATE_MATCH_PLAYLIST, modeIndex )
+	//for ( int mapIndex = 0; mapIndex < numMaps; mapIndex++ )
+	//{
+	//	mapsArray.append( GetPlaylistGamemodeByIndexMapByIndex( PRIVATE_MATCH_PLAYLIST, modeIndex, mapIndex ) )
+	//}
+	//
+	//return mapsArray
+	
+	array<string> maps
+	
+	// use the private match playlist for this if the gamemode is in it already
+	int privatePlaylistModeIndex = GetPrivateMatchModeIndex( modeName )
+	if ( privatePlaylistModeIndex < GetPlaylistGamemodesCount( PRIVATE_MATCH_PLAYLIST ) )
+	{
+		for ( int i = 0; i < GetPlaylistGamemodeByIndexMapsCount( PRIVATE_MATCH_PLAYLIST, privatePlaylistModeIndex ); i++ )
+			maps.append( GetPlaylistGamemodeByIndexMapByIndex( PRIVATE_MATCH_PLAYLIST, privatePlaylistModeIndex, i ) )
+	}
+	else
+	{
+		int numMaps = GetPlaylistGamemodeByIndexMapsCount( modeName, 0 )
+		for ( int i = 0; i < numMaps; i++ )
+			maps.append( GetPlaylistGamemodeByIndexMapByIndex( modeName, 0, i ) )
+	}
+		
+	return maps
+}
+
+// never called
+/*array<string> function GetPrivateMatchModesForMap( string mapName )
+{
+	array<string> modesArray
+
+	int numModes = GetPlaylistGamemodesCount( PRIVATE_MATCH_PLAYLIST )
+	for ( int modeIndex = 0; modeIndex < numModes; modeIndex++ )
+	{
+		int numMaps = GetPlaylistGamemodeByIndexMapsCount( PRIVATE_MATCH_PLAYLIST, modeIndex )
+		for ( int mapIndex = 0; mapIndex < numMaps; mapIndex++ )
+		{
+			if ( GetPlaylistGamemodeByIndexMapByIndex( PRIVATE_MATCH_PLAYLIST, modeIndex, mapIndex ) != mapName )
+				continue
+
+			modesArray.append( GetPlaylistGamemodeByIndex( PRIVATE_MATCH_PLAYLIST, modeIndex ) )
+		}
+	}
+
+	return modesArray
+}*/
+
+
+string function GetPrivateMatchMapForIndex( int index )
+{
+	array<string> mapsArray = GetPrivateMatchMaps()
+
+	if ( index >= mapsArray.len() )
+		return ""
+
+	return mapsArray[index]
+}
+
+string function GetPrivateMatchModeForIndex( int index )
+{
+	array<string> modesArray = GetPrivateMatchModes()
+
+	if ( index >= modesArray.len() )
+		return ""
+
+	return modesArray[index]
+}
+
+int function GetPrivateMatchMapIndex( string mapName )
+{
+	array<string> mapsArray = GetPrivateMatchMaps()
+	for ( int index = 0; index < mapsArray.len(); index++ )
+	{
+		if ( mapsArray[index] == mapName )
+			return index
+	}
+
+	return 0
+}
+/*
+int function GetPrivateMatchModeIndex( string modeName )
+{
+	array<string> modesArray = GetPrivateMatchModes()
+	for ( int index = 0; index < modesArray.len(); index++ )
+	{
+		if ( modesArray[index] == modeName )
+			return index
+	}
+
+	return 0
+}
+*/
+
+array<string> function GetPrivateMatchMaps()
+{
+	//array<string> mapsArray
+	//
+	//int numModes = GetPlaylistGamemodesCount( PRIVATE_MATCH_PLAYLIST )
+	//for ( int modeIndex = 0; modeIndex < numModes; modeIndex++ )
+	//{
+	//	int numMaps = GetPlaylistGamemodeByIndexMapsCount( PRIVATE_MATCH_PLAYLIST, modeIndex )
+	//	for ( int mapIndex = 0; mapIndex < numMaps; mapIndex++ )
+	//	{
+	//		string mapName = GetPlaylistGamemodeByIndexMapByIndex( PRIVATE_MATCH_PLAYLIST, modeIndex, mapIndex )
+	//		if ( mapsArray.contains( mapName ) )
+	//			continue
+	//
+	//		mapsArray.append( mapName )
+	//	}
+	//}
+	//
+	//return mapsArray
+	
+	return file.maps
+}
+
+
+
+array<string> function GetPlaylistMaps( string playlistName )
+{
+	array<string> mapsArray
+
+	int numModes = GetPlaylistGamemodesCount( playlistName )
+	for ( int modeIndex = 0; modeIndex < numModes; modeIndex++ )
+	{
+		int numMaps = GetPlaylistGamemodeByIndexMapsCount( playlistName, modeIndex )
+		for ( int mapIndex = 0; mapIndex < numMaps; mapIndex++ )
+		{
+			string mapName = GetPlaylistGamemodeByIndexMapByIndex( playlistName, modeIndex, mapIndex )
+			if ( mapsArray.contains( mapName ) )
+				continue
+
+			mapsArray.append( mapName )
+		}
+	}
+
+	return mapsArray
+}
+
+
+bool function MapSettings_SupportsTitans( string mapName )
+{
+	if ( mapName.find( "mp_lf_") != null )
+		return false
+
+	if ( mapName.find( "coliseum" ) != null )
+		return false;
+
+	return true
+}
+
+bool function MapSettings_SupportsAI( string mapName )
+{
+	if ( mapName.find( "mp_lf_") != null )
+		return false
+
+	if ( mapName.find( "coliseum" ) != null )
+		return false;
+
+	return true
+}
+
+
+bool function ModeSettings_RequiresTitans( string modeName )
+{
+	switch ( modeName )
+	{
+		case "lts":
+			return true
+	}
+
+	return false
+}
+
+bool function ModeSettings_RequiresAI( string modeName )
+{
+	switch ( modeName )
+	{
+		case "aitdm":
+		case "at":
+			return true
+	}
+
+	return false
+}
+
+#if !CLIENT
+string function PrivateMatch_GetSelectedMap()
+{
+	var mapIndex = level.ui.privatematch_map
+	string mapName = GetPrivateMatchMapForIndex( expect int(mapIndex) )
+
+	return mapName
+}
+
+
+string function PrivateMatch_GetSelectedMode()
+{
+	var modeIndex = level.ui.privatematch_mode
+	string modeName = GetPrivateMatchModeForIndex( expect int(modeIndex) )
+
+	return modeName
+}
+#endif
+
+bool function PrivateMatch_IsValidMapModeCombo( string mapName, string modeName )
+{
+	array<string> mapsForMode = GetPrivateMatchMapsForMode( modeName )
+
+	return mapsForMode.contains( mapName )
+}
+
+// end private match stuff
+
+int function Player_GetMaxMatchmakingDelay( entity player )
+{
+	//	return GetCurrentPlaylistVarInt( "matchmaking_delay", 0 )
+	return 300
+}
+
+int function Player_GetRemainingMatchmakingDelay( entity player )
+{
+	int lastLeaveTime = player.GetPersistentVarAsInt( PERSISTENCE_LAST_LEAVE_TIME )
+
+	return Player_GetMaxMatchmakingDelay( player ) - (GetCurrentTimeForPersistence() - lastLeaveTime)
+}
+
+int function Player_NextAvailableMatchmakingTime( entity player )
+{
+	#if MP
+	int lastLeaveTime = player.GetPersistentVarAsInt( PERSISTENCE_LAST_LEAVE_TIME )
+	if ( GetCurrentTimeForPersistence() - lastLeaveTime < Player_GetMaxMatchmakingDelay( player ) )
+	{
+		return Player_GetRemainingMatchmakingDelay(	player )
+	}
+	#endif
+
+	return 0
+}
+
+int function GetCurrentTimeForPersistence()
+{
+	// Returns the unix timestap offset to the timezone we want to use
+	return GetUnixTimestamp() + DAILY_RESET_TIME_ZONE_OFFSET * SECONDS_PER_HOUR
+}
diff --git a/bobthebob.testing/scripts/vscripts/mp/levels/mp_box.nut b/bobthebob.testing/scripts/vscripts/mp/levels/mp_box.nut
new file mode 100644
index 00000000..aa94be52
--- /dev/null
+++ b/bobthebob.testing/scripts/vscripts/mp/levels/mp_box.nut
@@ -0,0 +1,24 @@
+/*global function CodeCallback_MapInit
+global function SpawnGamemodeObjects
+
+void function CodeCallback_MapInit()
+{
+	AddCallback_EntitiesDidLoad( SpawnGamemodeObjects )
+}
+
+void function SpawnGamemodeObjects()
+{	
+	thread SpawnGamemodeObjects_Threaded()
+
+}
+
+void function SpawnGamemodeObjects_Threaded()
+{
+	WaitEndFrame()
+	entity liveFireFlagSpawn = CreateEntity( "script_ref" )
+	liveFireFlagSpawn.kv.editorclass = "info_speedball_flag"
+	liveFireFlagSpawn.kv.origin = < 0.0, -382.0, 60.0 >
+	liveFireFlagSpawn.kv.angles = < 0, 0, 0 >
+	DispatchSpawn( liveFireFlagSpawn )
+	liveFireFlagSpawn.kv.editorclass = "info_speedball_flag"
+}*/
\ No newline at end of file
diff --git a/bobthebob.testing/scripts/vscripts/mp/sh_revive.gnut b/bobthebob.testing/scripts/vscripts/mp/sh_revive.gnut
new file mode 100644
index 00000000..8caa2a82
--- /dev/null
+++ b/bobthebob.testing/scripts/vscripts/mp/sh_revive.gnut
@@ -0,0 +1,19 @@
+#if SERVER
+global const REVIVE_ENABLED = true // currently not used anywhere
+global function ReviveEnabled
+
+bool function ReviveEnabled()
+{
+	return GetCurrentPlaylistVarInt( "player_revive_enabled", 0 ) == 1
+}
+#elseif true
+global const REVIVE_ENABLED = false // currently not used anywhere
+global function ReviveEnabled
+
+bool function ReviveEnabled()
+{
+	// client version of this doesn't work lol
+	return false
+	//return GetCurrentPlaylistVarInt( "player_revive_enabled", 0 ) == 1
+}
+#endif
\ No newline at end of file
diff --git a/bobthebob.testing/scripts/vscripts/sh_bleedout_test.gnut b/bobthebob.testing/scripts/vscripts/sh_bleedout_test.gnut
new file mode 100644
index 00000000..42727adc
--- /dev/null
+++ b/bobthebob.testing/scripts/vscripts/sh_bleedout_test.gnut
@@ -0,0 +1,34 @@
+global function BleedoutTest_Init
+
+void function BleedoutTest_Init()
+{
+	return // not in use rn
+
+	AddCallback_OnRegisteringCustomNetworkVars( RegisterBleedoutVars )
+	
+	BleedoutShared_Init( 30.0, 3.0, -1.0, 1.0, 0.0, false, false )
+	
+	#if SERVER
+		Bleedout_Init()
+		if ( ReviveEnabled() )
+			AddCallback_OnPlayerKilled( StartRevive )
+	#elseif CLIENT
+		BleedoutClient_Init()
+	#endif
+}
+
+#if SERVER 
+void function StartRevive( entity victim, entity attacker, var damageInfo )
+{
+	DeathPackage_PlayerRevive( victim )
+	thread PlayerRevivesOrBleedsOut( victim )
+}
+#endif
+
+void function RegisterBleedoutVars()
+{
+	Remote_RegisterFunction( "ServerCallback_BLEEDOUT_StartFirstAidProgressBar" )
+	Remote_RegisterFunction( "ServerCallback_BLEEDOUT_StopFirstAidProgressBar" )
+	Remote_RegisterFunction( "ServerCallback_BLEEDOUT_ShowWoundedMarker" )
+    Remote_RegisterFunction( "ServerCallback_BLEEDOUT_HideWoundedMarker" )
+}
\ No newline at end of file
diff --git a/bobthebob.testing/scripts/vscripts/sh_bobtestingfunctions_mp.gnut b/bobthebob.testing/scripts/vscripts/sh_bobtestingfunctions_mp.gnut
new file mode 100644
index 00000000..124c7a54
--- /dev/null
+++ b/bobthebob.testing/scripts/vscripts/sh_bobtestingfunctions_mp.gnut
@@ -0,0 +1,128 @@
+globalize_all_functions
+
+void function DumpPdefEnum( string pdefEnum )
+{
+	for ( int i = 0; i < PersistenceGetEnumCount( pdefEnum ); i++ )
+		print( PersistenceGetEnumItemNameForIndex( pdefEnum, i ) )
+}
+
+void function ListPlayers()
+{
+	foreach ( entity player in GetPlayerArray() )
+	{
+		if ( player == null )
+			continue
+	
+		print( "player " + player.GetPlayerName() + ": G" + player.GetGen() + "." + player.GetLevel() )
+	}
+}
+
+void function DumpPdefTable()
+{
+	foreach ( key0, value0 in shGlobalMP.playerStatVars )
+	{
+		foreach ( key1, value1 in value0 )
+		{
+			foreach ( key2, statData in value1 )
+			{
+				print ( statData.statVar )
+			}
+		}
+	}
+}
+
+void function DumpModels()
+{
+	for ( int i = 0; i < 2048; i++ )
+		if ( GetEntByIndex( i ) != null && GetEntByIndex( i ).GetModelName() != $"?" )
+			print( i + ": " + GetEntByIndex( i ).GetModelName() )
+}
+
+void function DumpScoreEvents()
+{
+	int i = 0;
+	while ( true ) 
+	{
+		ScoreEvent event 
+		try event = ScoreEvent_FromId( i ) catch ( exception ) break
+			
+		print( "event " + i + ":" )
+		print( "name: " + event.name )
+		print( "splashText: " + event.splashText )
+		
+		// get string representation of displaytype
+		// if squirrel has a better way to do this i don't know it
+		string displayType
+		
+		if ( event.displayType & eEventDisplayType.HIDDEN )
+			displayType += "HIDDEN, "
+		if ( event.displayType & eEventDisplayType.CENTER )
+			displayType += "CENTER, "
+		if ( event.displayType & eEventDisplayType.MEDAL )
+			displayType += "MEDAL, "
+		if ( event.displayType & eEventDisplayType.CALLINGCARD )
+			displayType += "CALLINGCARD, "
+		if ( event.displayType & eEventDisplayType.ATTRITION )
+			displayType += "ATTRITION, "
+		if ( event.displayType & eEventDisplayType.BIG )
+			displayType += "BIG, "
+		if ( event.displayType & eEventDisplayType.GAMEMODE )
+			displayType += "GAMEMODE, "
+		if ( event.displayType & eEventDisplayType.CHALLENGE )
+			displayType += "CHALLENGE, "
+		if ( event.displayType & eEventDisplayType.MEDAL_FORCED )
+			displayType += "MEDAL_FORCED, "
+		if ( event.displayType & eEventDisplayType.SHOW_SCORE )
+			displayType += "SHOW_SCORE, "
+		
+		print( "displayType: " + displayType )
+		print( " " ) // newline
+		
+		i++
+	}
+	
+	print( "got " + i + " events!" )
+}
+
+void function DumpConversations()
+{
+	foreach ( string k, v in GetConversationToIndexTable() )
+		print( k )
+}
+
+#if CLIENT 
+void function TestMarkRUI()
+{
+	var rui = CreateCockpitRui( $"ui/speedball_flag_marker.rpak", 200 )
+	RuiSetBool( rui, "isVisible", true )
+	RuiSetFloat3( rui, "pos", GetLocalViewPlayer().GetOrigin() )
+	RuiSetBool( rui, "playerIsCarrying", false )
+	RuiSetInt( rui, "teamRelation", TEAM_IMC )
+	RuiSetBool( rui, "isCarried", false )
+}
+
+void function TestObjectiveRUIHunted()
+{
+	var rui = CreateCockpitRui( $"ui/hunted_objective.rpak", 200 )
+	RuiSetGameTime( rui, "startTime", Time() )
+	RuiSetGameTime( rui, "endTime", Time() + 20.0 )
+	RuiSetString( rui, "objectiveTitleText", "#HUNTED_OBJECTIVE_TITLE" )
+	RuiSetFloat( rui, "blingDuration", 5.0 )
+	RuiSetBool( rui, "showAll", true )
+}
+
+void function TestObjectiveRUIFW()
+{
+	var rui = CreateCockpitRui( $"ui/fw_objective_text.rpak" )
+	RuiSetString( rui, "objective", "deez nuts" )
+	
+	float time = Time() + 10.0
+	while ( time > Time() )
+	{
+		RuiSetString( rui, "objective", "deez nuts " + ( time - Time() ) )
+		WaitFrame()
+	}
+	
+	RuiDestroy( rui )
+}
+#endif
\ No newline at end of file
diff --git a/bobthebob.testing/scripts/vscripts/sh_northstar_utils.gnut b/bobthebob.testing/scripts/vscripts/sh_northstar_utils.gnut
new file mode 100644
index 00000000..15eed9b2
--- /dev/null
+++ b/bobthebob.testing/scripts/vscripts/sh_northstar_utils.gnut
@@ -0,0 +1,49 @@
+globalize_all_functions
+
+enum eNorthstarLobbyType
+{
+	PrivateMatchLobby, // normal vanilla private lobby
+	IntermissionLobby, // similar to tf1's intermission lobby, chooses next map automatically
+	CompetitiveLobby // similar to vanilla privates, but with ready up system
+}
+
+// whether the server is a modded, northstar server
+bool function IsNorthstarServer()
+{
+	bool isModded = true // TEMP for testing
+	try
+	{
+		// need this in a trycatch because the var might not exist atm
+		isModded = GetConVarInt( "northstar_is_modded_server" ) == 1
+	} catch ( ex ) {}
+	
+	return isModded
+}
+
+// whether the game should return to the lobby on GameRules_EndMatch()
+bool function ShouldReturnToLobby()
+{	
+	bool shouldReturnToLobby = false 
+	try
+	{
+		// need this in a trycatch because the var might not exist atm
+		shouldReturnToLobby = GetConVarInt( "northstar_should_return_to_lobby" ) == 1
+	} catch ( ex ) {}
+	
+	return shouldReturnToLobby
+}
+
+int function GetNorthstarLobbyType()
+{
+	if ( !IsNorthstarServer() )
+		return eNorthstarLobbyType.PrivateMatchLobby
+		
+	int lobbyType = eNorthstarLobbyType.PrivateMatchLobby
+	try
+	{
+		// need this in a trycatch because the var might not exist atm
+		lobbyType = GetConVarInt( "northstar_lobby_type" )
+	} catch ( ex ) {}
+	
+	return lobbyType
+}
\ No newline at end of file
diff --git a/bobthebob.testing/scripts/vscripts/ui/menu_dev.nut b/bobthebob.testing/scripts/vscripts/ui/menu_dev.nut
new file mode 100644
index 00000000..d9b9234b
--- /dev/null
+++ b/bobthebob.testing/scripts/vscripts/ui/menu_dev.nut
@@ -0,0 +1,707 @@
+untyped
+
+global function InitDevMenu
+global function GetActionBlocks
+global function SetDevMenu_SinglePlayer
+global function SetupDevCommand // for dev
+global function SetupDevFunc // for dev
+global function SetDevMenu_SpawnNPCWithWeapon
+global function RepeatLastDevCommand
+global function SetDevMenu_ArmedNPC
+global function UpdatePrecachedSPWeapons
+
+struct DevCommand
+{
+	string label
+	string command
+	var opParm
+	void functionref( var ) func
+	bool storeAsLastCommand = true
+}
+
+
+struct
+{
+	void functionref() devMenuFunc
+	void functionref( var ) devMenuFuncWithOpParm
+	var devMenuOpParm
+	array<var> buttons
+	array actionBlocks
+	array<DevCommand> devCommands
+	DevCommand& lastDevCommand
+	bool lastDevCommandAssigned
+	bool precachedWeapons
+} file
+
+void function OnOpenDevMenu()
+{
+	file.devMenuFunc = null
+	file.devMenuFuncWithOpParm = null
+	file.devMenuOpParm = null
+	if ( IsMultiplayer() )
+		SetDevMenu_MP()
+	else
+		SetDevMenu_Default()
+}
+
+void function InitDevMenu()
+{
+	var menu = GetMenu( "DevMenu" )
+
+	AddMenuEventHandler( menu, eUIEvent.MENU_OPEN, OnOpenDevMenu )
+
+
+	AddMenuFooterOption( menu, BUTTON_A, "#A_BUTTON_SELECT" )
+	AddMenuFooterOption( menu, BUTTON_B, "#B_BUTTON_BACK", "#BACK" )
+
+	OnOpenDevMenu()
+	
+	file.buttons = GetElementsByClassname( menu, "DevButtonClass" )
+	foreach ( button in file.buttons )
+	{
+		Hud_AddEventHandler( button, UIE_CLICK, OnDevButton_Activate )
+
+		RuiSetString( Hud_GetRui( button ), "buttonText", "" )
+		Hud_SetEnabled( button, false )
+	}
+
+}
+
+function UpdateDevMenuButtons()
+{
+	file.devCommands.clear()
+	if ( developer() == 0 )
+		return
+
+	if ( file.devMenuOpParm != null )
+		file.devMenuFuncWithOpParm( file.devMenuOpParm )
+	else
+		file.devMenuFunc()
+
+	foreach ( index, button in file.buttons )
+	{
+		int buttonID = int( Hud_GetScriptID( button ) )
+
+		if ( buttonID < file.devCommands.len() )
+		{
+			RuiSetString( Hud_GetRui( button ), "buttonText", file.devCommands[buttonID].label )
+			Hud_SetEnabled( button, true )
+		}
+		else
+		{
+			RuiSetString( Hud_GetRui( button ), "buttonText", "" )
+			Hud_SetEnabled( button, false )
+		}
+	}
+}
+
+void function SetDevMenu_Default()
+{
+	file.devMenuFunc = SetupDefaultDevCommands
+	UpdateDevMenuButtons()
+}
+
+
+void function SetDevMenu_MP()
+{
+	file.devMenuFunc = SetupDefaultDevCommandsMP
+	UpdateDevMenuButtons()
+}
+
+void function ChangeToThisMenu( void functionref() menuFunc )
+{
+	file.devMenuFunc = menuFunc
+	file.devMenuFuncWithOpParm = null
+	file.devMenuOpParm = null
+	UpdateDevMenuButtons()
+}
+
+void function ChangeToThisMenu_WithOpParm( void functionref( var ) menuFuncWithOpParm, opParm = null )
+{
+	file.devMenuFunc = null
+	file.devMenuFuncWithOpParm = menuFuncWithOpParm
+	file.devMenuOpParm = opParm
+	UpdateDevMenuButtons()
+}
+
+void function SetDevMenu_SinglePlayer( var _ )
+{
+	CloseAllInGameMenus()
+	AdvanceMenu( GetMenu( "SinglePlayerDevMenu" ), true )
+}
+
+void function SetupDefaultDevCommands()
+{
+	SetupDevFunc( "Frontier Defense", SetDevMenu_FrontierDefense )
+	// SetupDevFunc( "Difficulty", SetDevMenu_Difficulty )
+	SetupDevFunc( "Single Player", SetDevMenu_SinglePlayer )
+	if ( GetStartPointsForMap( GetActiveLevel() ).len() )
+	{
+		SetupDevFunc( "Start Points", SetDevMenu_StartPoints )
+	}
+	SetupDevFunc( "Level Commands", SetDevMenu_LevelCommands )
+
+	SetupRepeatLastDevCommand()
+	SetupDevFunc( "Spawn IMC NPC", SetDevMenu_AISpawn, 2 )
+	SetupDevFunc( "Spawn IMC Boss Titan", SetDevMenu_BossTitans )
+	SetupDevFunc( "Spawn Militia NPC", SetDevMenu_AISpawn, 3 )
+	SetupDevFunc( "Spawn Team 4 NPC", SetDevMenu_AISpawn, 4 )
+
+	if ( IsSingleplayer() )
+	{
+		SetupDevCommand( "Spawn BT", "script thread DEV_SpawnBTAtCrosshair( false )" )
+		SetupDevCommand( "Hotdrop BT", "script thread DEV_SpawnBTAtCrosshair( true )" )
+	}
+
+	SetupDevFunc( "Spawn Titan Weapon", SetDevMenu_TitanWeapons )
+	SetupDevFunc( "Spawn Pilot Weapons", SetDevMenu_PilotWeapons )
+	SetupDevFunc( "Spawn Pilot Offhands", SetDevMenu_PilotOffhands )
+
+	SetupDevFunc( "AI Commands", SetDevMenu_AICommands )
+	SetupDevCommand( "Toggle Model Viewer", "script thread ToggleModelViewer()" )
+	SetupDevCommand( "AI Titan Duel", "script DEV_AITitanDuel()" )
+	SetupDevCommand( "Free Titans for everybody", "script GiveAllTitans()" )
+
+	if ( IsSingleplayer() )
+	{
+		SetupDevCommand( "Checkpoint", "script CheckPoint_Forced()" )
+		SetupDevCommand( "Test Next Checkpoint Spawnpoint", "script TestDevSpawnPoint()" )
+	}
+
+	SetupDevCommand( "Disable NPCs", "script disable_npcs()" )
+	// SetupDevCommand( "Disable New NPCs", "script disable_new_npcs()" )
+
+	if ( IsMultiplayer() )
+	{
+		SetupDevCommand( "Swap the teams", "script teamswap()" )
+		SetupDevCommand( "Force time limit", "script ForceTimeLimitDone()" )
+		SetupDevCommand( "Force My Team Win", "script_client GetLocalClientPlayer().ClientCommand(\"ForceMyTeamWin\")" )
+		SetupDevCommand( "Force My Team Lose", "script_client GetLocalClientPlayer().ClientCommand(\"ForceMyTeamLose\")" )
+		SetupDevCommand( "Force Match End", "script ForceMatchEnd()" )
+		SetupDevCommand( "Force Draw", "script ForceDraw()" )
+	}
+
+	SetupDevCommand( "Toggle Friendly Highlights", "script DEV_ToggleFriendlyHighlight()" )
+	SetupDevCommand( "Export precache script", "script_ui Dev_CommandLineAddParm( \"-autoprecache\", \"\" ); script_ui Dev_CommandLineRemoveParm( \"" + STARTPOINT_DEV_STRING + "\" ); reload" )
+	// SetupDevCommand( "Toggle Blood Spray Decals", "script_client BloodSprayDecals_Toggle()" )
+
+	//SetupDevCommand( "PlaySpyglassVDU", "script ForcePlayConversationToAll(\"SpyglassVDU\")" )
+	//SetupDevCommand( "PlayGravesVDU", "script ForcePlayConversationToAll(\"GravesVDU\")" )
+	//SetupDevCommand( "PlayBliskVDU", "script ForcePlayConversationToAll(\"BliskVDU\")" )
+	//SetupDevCommand( "PlaySarahVDU", "script ForcePlayConversationToAll(\"SarahVDU\")" )
+	//SetupDevCommand( "PlayMacVDU", "script ForcePlayConversationToAll(\"MacVDU\")" )
+	//SetupDevCommand( "PlayBishVDU", "script ForcePlayConversationToAll(\"BishVDU\")" )
+	//SetupDevCommand( "PlayMCORGruntBattleRifleVDU", "script ForcePlayConversationToAll(\"MCORGruntBattleRifleVDU\")" )
+	//SetupDevCommand( "PlayMCORGruntAntiTitanVDU", "script ForcePlayConversationToAll(\"MCORGruntAntiTitanVDU\")" )
+	//SetupDevCommand( "PlayIMCSoldierBattleRifleVDU", "script ForcePlayConversationToAll(\"IMCSoldierBattleRifleVDU\")" )
+	SetupDevCommand( "Doom my titan", "script_client GetLocalViewPlayer().ClientCommand( \"DoomTitan\" )" )
+	SetupDevCommand( "DoF debug (ads)", "script_client ToggleDofDebug()" )
+
+	SetupDevCommand( "ToggleTitanCallInEffects", "script FlagToggle( \"EnableIncomingTitanDropEffects\" )" )
+	//SetupDevCommand( "TrailerTitanDrop", "script_client GetLocalViewPlayer().ClientCommand( \"TrailerTitanDrop\" )" )
+	//SetupDevCommand( "AI Chatter: aichat_callout_pilot_dev", "script playconvtest(\"aichat_callout_pilot_dev\")" )
+	SetupDevCommand( "Spawn IMC grunt", "SpawnViewGrunt " + TEAM_IMC )
+	SetupDevCommand( "Spawn Militia grunt", "SpawnViewGrunt " + TEAM_MILITIA )
+	SetupDevCommand( "Enable titan-always-executes-titan", "script FlagSet( \"ForceSyncedMelee\" )" )
+	//SetupDevCommand( "Display Embark times", "script DebugEmbarkTimes()" )
+	SetupDevCommand( "Kill All Titans", "script killtitans()" )
+	SetupDevCommand( "Kill All Minions", "script killminions()" )
+	if ( IsSingleplayer() )
+		SetupDevCommand( "Kill All Enemies", "script KillAllBadguys()" )
+
+	SetupDevCommand( "Export leveled_weapons.def / r2_weapons.fgd", "script thread LeveledWeaponDump()" )
+
+
+	if ( IsMultiplayer() )
+	{
+		SetupDevCommand( "Summon Players to player 0", "script summonplayers()" )
+		SetupDevCommand( "Display Titanfall spots", "script thread ShowAllTitanFallSpots()" )
+		SetupDevCommand( "Toggle check inside Titanfall Blocker", "script thread DevCheckInTitanfallBlocker()" )
+		SetupDevCommand( "Simulate Game Scoring", "script thread SimulateGameScore()" )
+		SetupDevCommand( "Test Dropship Intro Spawns with Bots", "script thread DebugTestDropshipStartSpawnsForAll()" )
+		SetupDevCommand( "Preview Dropship Spawn at this location", "script SetCustomPlayerDropshipSpawn()" )
+		SetupDevCommand( "Test Dropship Spawn at this location", "script thread DebugTestCustomDropshipSpawn()" )
+		SetupDevCommand( "Max Activity (Pilots)", "script SetMaxActivityMode(1)" )
+		SetupDevCommand( "Max Activity (Titans)", "script SetMaxActivityMode(2)" )
+		SetupDevCommand( "Max Activity (Conger Mode)", "script SetMaxActivityMode(4)" )
+		SetupDevCommand( "Max Activity (Disabled)", "script SetMaxActivityMode(0)" )
+	}
+	else
+	{
+		SetupDevCommand( "Reset Collectibles Progress (level)", "script Dev_ResetCollectiblesProgress_Level()" )
+		SetupDevCommand( "Reset Collectibles Progress (all)", "script ResetCollectiblesProgress_All()" )
+
+		SetupDevCommand( "BT Loadouts - Reset", "script SetBTLoadoutsUnlockedBitfield( 1 )" )
+		SetupDevCommand( "BT Loadouts - Unlock All", "script SetBTLoadoutsUnlockedBitfield( 65535 )" )
+		SetupDevCommand( "BT Loadouts - Spawn Unlock Pickup", "script SPTitanLoadout_SpawnAtCrosshairDEV( -1 )" )
+	}
+
+	SetupDevCommand( "Toggle Skybox View", "script thread ToggleSkyboxView()" )
+	//SetupDevCommand( "Toggle Bubble Shield", "ToggleBubbleShield" )
+	//SetupDevCommand( "Toggle Grenade Indicators", "script_client ToggleGrenadeIndicators()" )
+	SetupDevCommand( "Toggle HUD", "ToggleHUD" )
+	SetupDevCommand( "Toggle Offhand Low Recharge", "ToggleOffhandLowRecharge" )
+	SetupDevCommand( "Map Metrics Toggle", "script_client GetLocalClientPlayer().ClientCommand( \"toggle map_metrics 0 1 2 3\" )" )
+	SetupDevCommand( "Toggle Pain Death sound debug", "script TogglePainDeathDebug()" )
+	SetupDevCommand( "Jump Randomly Forever", "script_client thread JumpRandomlyForever()" )
+}
+
+
+void function SetupDefaultDevCommandsMP()
+{
+	SetupRepeatLastDevCommand()
+
+	SetupDevFunc( "Frontier Defense", SetDevMenu_FrontierDefense )
+
+	SetupDevFunc( "Spawn IMC NPC", SetDevMenu_AISpawn, 2 )
+	SetupDevFunc( "Spawn IMC Boss Titan", SetDevMenu_BossTitans )
+	SetupDevFunc( "Spawn Militia NPC", SetDevMenu_AISpawn, 3 )
+	SetupDevFunc( "Spawn Team 4 NPC", SetDevMenu_AISpawn, 4 )
+
+	SetupDevFunc( "Spawn Titan Weapon", SetDevMenu_TitanWeapons )
+	SetupDevFunc( "Spawn Pilot Weapons", SetDevMenu_PilotWeapons )
+	SetupDevFunc( "Spawn Pilot Offhands", SetDevMenu_PilotOffhands )
+
+	SetupDevFunc( "AI Commands", SetDevMenu_AICommands )
+	SetupDevCommand( "Toggle Model Viewer", "script thread ToggleModelViewer()" )
+	SetupDevCommand( "AI Titan Duel", "script DEV_AITitanDuel()" )
+	SetupDevCommand( "Free Titans for everybody", "script GiveAllTitans()" )
+
+	SetupDevCommand( "Disable NPCs", "script disable_npcs()" )
+	// SetupDevCommand( "Disable New NPCs", "script disable_new_npcs()" )
+
+	SetupDevCommand( "Swap the teams", "script teamswap()" )
+	SetupDevCommand( "Force time limit", "script ForceTimeLimitDone()" )
+	SetupDevCommand( "Force My Team Win", "script_client GetLocalClientPlayer().ClientCommand(\"ForceMyTeamWin\")" )
+	SetupDevCommand( "Force My Team Lose", "script_client GetLocalClientPlayer().ClientCommand(\"ForceMyTeamLose\")" )
+	SetupDevCommand( "Force Match End", "script ForceMatchEnd()" )
+	SetupDevCommand( "Force Draw", "script ForceDraw()" )
+
+	SetupDevCommand( "Toggle Friendly Highlights", "script DEV_ToggleFriendlyHighlight()" )
+	SetupDevCommand( "Export precache script", "script_ui Dev_CommandLineAddParm( \"-autoprecache\", \"\" ); script_ui Dev_CommandLineRemoveParm( \"" + STARTPOINT_DEV_STRING + "\" ); reload" )
+
+	SetupDevCommand( "Doom my titan", "script_client GetLocalViewPlayer().ClientCommand( \"DoomTitan\" )" )
+	SetupDevCommand( "DoF debug (ads)", "script_client ToggleDofDebug()" )
+
+	SetupDevCommand( "ToggleTitanCallInEffects", "script FlagToggle( \"EnableIncomingTitanDropEffects\" )" )
+
+	SetupDevCommand( "Spawn IMC grunt", "SpawnViewGrunt " + TEAM_IMC )
+	SetupDevCommand( "Spawn Militia grunt", "SpawnViewGrunt " + TEAM_MILITIA )
+
+	SetupDevCommand( "Enable titan-always-executes-titan", "script FlagSet( \"ForceSyncedMelee\" )" )
+
+	SetupDevCommand( "Kill All Titans", "script killtitans()" )
+	SetupDevCommand( "Kill All Minions", "script killminions()" )
+
+	SetupDevCommand( "Export leveled_weapons.def / r2_weapons.fgd", "script thread LeveledWeaponDump()" )
+
+	SetupDevCommand( "Summon Players to player 0", "script summonplayers()" )
+	SetupDevCommand( "Display Titanfall spots", "script thread ShowAllTitanFallSpots()" )
+	SetupDevCommand( "Toggle check inside Titanfall Blocker", "script thread DevCheckInTitanfallBlocker()" )
+	SetupDevCommand( "Simulate Game Scoring", "script thread SimulateGameScore()" )
+	SetupDevCommand( "Test Dropship Intro Spawns with Bots", "script thread DebugTestDropshipStartSpawnsForAll()" )
+	SetupDevCommand( "Preview Dropship Spawn at this location", "script SetCustomPlayerDropshipSpawn()" )
+	SetupDevCommand( "Test Dropship Spawn at this location", "script thread DebugTestCustomDropshipSpawn()" )
+	SetupDevCommand( "Max Activity (Pilots)", "script SetMaxActivityMode(1)" )
+	SetupDevCommand( "Max Activity (Titans)", "script SetMaxActivityMode(2)" )
+	SetupDevCommand( "Max Activity (Conger Mode)", "script SetMaxActivityMode(4)" )
+	SetupDevCommand( "Max Activity (Disabled)", "script SetMaxActivityMode(0)" )
+
+	SetupDevCommand( "Toggle Skybox View", "script thread ToggleSkyboxView()" )
+	SetupDevCommand( "Toggle HUD", "ToggleHUD" )
+	SetupDevCommand( "Toggle Offhand Low Recharge", "ToggleOffhandLowRecharge" )
+	SetupDevCommand( "Map Metrics Toggle", "script_client GetLocalClientPlayer().ClientCommand( \"toggle map_metrics 0 1 2 3\" )" )
+	SetupDevCommand( "Toggle Pain Death sound debug", "script TogglePainDeathDebug()" )
+	SetupDevCommand( "Jump Randomly Forever", "script_client thread JumpRandomlyForever()" )
+}
+
+
+void function SetupRepeatLastDevCommand()
+{
+	DevCommand cmd
+	cmd.label = "Repeat Last Dev Command"
+	cmd.func = RepeatLastDevCommand
+	cmd.storeAsLastCommand = false
+
+	file.devCommands.append( cmd )
+}
+
+void function SetDevMenu_LevelCommands( var _ )
+{
+	ChangeToThisMenu( SetupLevelDevCommands )
+}
+
+void function SetupLevelDevCommands()
+{
+	string activeLevel = GetActiveLevel()
+	if ( activeLevel == "" )
+		return
+
+	switch ( activeLevel )
+	{
+		case "mp_titan_rodeo":
+			SetupDevCommand( "Atlas titans", "script thread TitanTypes( \"titan_atlas_stickybomb\")" )
+			SetupDevCommand( "Ogre titans", "script thread TitanTypes( \"titan_ogre_meteor\")" )
+			SetupDevCommand( "Stryder titans", "script thread TitanTypes( \"titan_stryder_leadwall\")" )
+			break
+
+		case "model_viewer":
+			SetupDevCommand( "Toggle Rebreather Masks", "script ToggleRebreatherMasks()" )
+			break
+
+		case "sp_grunt_arena":
+			SetupDevCommand( "Toggle health pickups", "script ToggleHealthRegen(); reload" )
+			break
+	}
+}
+
+void function SetDevMenu_SpawnNPCWithWeapon( var parms )
+{
+	ChangeToThisMenu_WithOpParm( SetupMenu_SpawnNPCWithWeapons, parms )
+}
+
+
+void function SetDevMenu_StartPoints( var _ )
+{
+	string currentMap = GetActiveLevel()
+	array<StartPointCSV> foundStartPoints = GetStartPointsForMap( currentMap )
+//	foreach ( index, startPointEnum in foundStartPoints )
+//	{
+//		table parms = { currentMap = currentMap, startPointEnum = startPointEnum }
+//		SetupDevCommand( "#" + startPointEnum, SetDevMenu_SelectStartPointDifficulty, parms )
+//		//SetupDevCommand( "#" + startPointEnum, "script PickStartPoint( \"" + currentMap + "\", \"" + startPointEnum + "\" )" )
+//	}
+
+	CloseAllInGameMenus()
+	AdvanceMenu( GetMenu( "SinglePlayerDevMenu" ), true )
+	DisplayStartPointButtons( currentMap, foundStartPoints )
+}
+
+
+void function SetDevMenu_ActionBlocks()
+{
+	ChangeToThisMenu( SetupActionBlocks )
+}
+
+function DefineActionBlocks()
+{
+	file.actionBlocks = []
+
+	/*				[Menu name]		[action block name]									[owner]		[description]														[load commands]															*/
+	AddActionBlock( "Week 1", 		"Timed Switch Panel Run", 							"Sean", 	"Test your wallrunning abilities by jumping on timed platforms",	"playlist Load a map on the command line; map sp_platform_test01" )
+	AddActionBlock( "Week 1", 		"Energon Room", 									"Mackey", 	"Combat test arena. Collect all Energon Spheres to win",			"playlist Load a map on the command line; map sp_abmac1" )
+	AddActionBlock( "Week 1", 		"Titan Buddy + Turret Columns", 					"Carlos", 	null,																"playlist Load a map on the command line; map carlos_test" )
+	AddActionBlock( "Week 1", 		"Titan Maze", 										"Soupy", 	null,																"playlist Load a map on the command line; map sp_act-block_maze" )
+	AddActionBlock( "Week 1", 		"Catch me if you Can", 								"Chin", 	"Catch up to a moving pilot and kill him to win",					"launchplaylist catchmeifyoucan" )
+	AddActionBlock( "Week 1", 		"Jumping Puzzles", 									"ChadG", 	"Various pilot jumping puzzles with moving platforms",				"playlist Load a map on the command line; mp_gamemode at; map mp_chad" )
+	AddActionBlock( "Week 1", 		"FLANKER BOOST loadout basics", 					"Brent", 	"Non-wallrunning pilot jumping basics",								"playlist Load a map on the command line; mp_gamemode at; map mp_ab_test" )
+	AddActionBlock( "Week 1", 		"Flee Titan Attack by wallrunning", 				"Roger", 	null,																"playlist Load a map on the command line; map sp_ab_flee" )
+	AddActionBlock( "Week 1", 		"Protect Grunt squad from Mortar fire", 			"Roger", 	null,																"playlist Load a map on the command line; map sp_ab_vortex" )
+	AddActionBlock( "Week 1", 		"Catch me if you Can Part 2", 						"Soupy",	null,																"playlist catchmeifyoucan;mp_gamemode ps; map mp_catchme" )
+	AddActionBlock( "Week 2", 		"Environment Puzzles",								"ChadG", 	"Get your titan to the exit by solving some puzzles",				"playlist Load a map on the command line; mp_gamemode at; map mp_chad2" )
+//	AddActionBlock( "Week 2", 		"Fun House - survive to the end",					"Mo",		null,																"playlist Load a map on the command line; map mp_ab_funhouse" )
+	AddActionBlock( "Week 2", 		"Assassin Arena - boss fight with the Assassin", 	"Mo", 		null,																"playlist Load a map on the command line; map sp_ab_assassin" )
+	AddActionBlock( "Week 2", 		"Creature Ship", 									"LumberJake", 	"Explore a crashed ship with mysterious cargo",					"playlist Load a map on the command line; mp_gamemode at; map mp_actionblockjake01" )
+	AddActionBlock( "Week 2", 		"Titan/Pilot Puzzles", 								"RyanR",	"Get your titan to the green room",									"playlist Load a map on the command line; mp_gamemode at; map mp_ryanr_actionblock_01" )
+	AddActionBlock( "Week 2", 		"Titan/Pilot Core Combat", 							"Carlos",	null,																"playlist Load a map on the command line; map sp_ammo_pickup" )
+	AddActionBlock( "Week 2", 		"Titan Overwatch", 									"Roger",	"Your sniping titan will cover you as you advance to the bunker",	"playlist Load a map on the command line; map sp_ab_titanbuddy" )
+	AddActionBlock( "Week 2", 		"Rodeo Express", 									"Chin",		"Use your titan to get you through a pilot hazard area",			"playlist lava; mp_gamemode at; map mp_chin_rodeo_express" )
+	AddActionBlock( "Week 2", 		"Wallrun Gauntlet",									"McCord",	"Wallrun through the geo and don't fall to your death",				"playlist Load a map on the command line; map sp_zipline_action_block01" )
+	AddActionBlock( "Week 2", 		"Titan Mortar Targeting Test", 						"Soupy",	null,																"playlist Load a map on the command line; map sp_mortar_targeting_test" )
+	AddActionBlock( "Week 2", 		"Tremors", 											"David",	null,																"playlist Load a map on the command line; map sp_tremors" )
+	AddActionBlock( "Week 2", 		"Titan Combat Blok", 								"Mackey",	"Combat arena. Kill all enemies.",									"playlist Load a map on the command line; map sp_abmac3" )
+	AddActionBlock( "Week 2", 		"Smart Targeted Switch Panels", 					"Sean",		"Wallrun from wall to wall while activating switches",				"playlist Load a map on the command line; map sp_platform_test02" )
+	AddActionBlock( "Week 3", 		"Combat Canyon", 									"Mo", 		"Kill enemies in the canyon and extract", 							"playlist Load a map on the command line; map sp_ab_ski" )
+	AddActionBlock( "Week 3", 		"Titan v Titan", 									"Roger", 	"Test Titan vs Titan combat against various titan AI", 				"playlist Load a map on the command line; map sp_ab_tvt" )
+	AddActionBlock( "Week 3", 		"Train Raid", 										"ChadG",	"Board a speeding train and hack the explosives on board", 			"playlist Load a map on the command line; map sp_ab_trainride01" )
+	AddActionBlock( "Week 3", 		"Super Spectre Bros", 								"David", 	"Survive 6 waves against super spectres", 							"playlist Load a map on the command line; map mp_ab_super_spectre_bros" )
+	AddActionBlock( "Week 4", 		"Nightshot", 										"David", 			"Help your titan buddy hunt in the dark.", 					"playlist Load a map on the command line; map sp_ab_nightshot" )
+	//AddActionBlock( "Week 4", 		"Space Battle", 									"Mo", 				"Pilot a ship in space. \n -Play with Always run OFF. \n -Use low sensitivity. \n -Use bug_reproNum 1 to invert flight controls.\n -Use bug_reproNum 2 for PRO flight controls. (free look) \n -Use bug_reproNum 3 for inverted PRO flight controls.", 											"playlist Load a map on the command line; map sp_ab_week4" )
+	AddActionBlock( "Week 4", 		"Buddy Fight", 										"Mackey",			"Arena fight with buddy Titan",												"playlist Load a map on the command line; map sp_buddy_fight" )
+	AddActionBlock( "Week 4", 		"Fastball Special", 								"Slayback/McCord", 	"Use a new Titan ability to hurl yourself to new heights.", 				"playlist Load a map on the command line; map sp_fastball" )
+	AddActionBlock( "Week 4", 		"Time Travel Mechanic", 							"LumberJake", 		"Travel back and forth through time to complete your mission.", 			"playlist Load a map on the command line; map sp_actionblockjake02" )
+	AddActionBlock( "Week 5", 		"Titan Ability: Death Blossom", 					"Mo", 				"Use Up on D-Pad to use Death Blossom\n\nUse your new ability to defeat the enemies", 							"playlist Load a map on the command line; bug_reproNum 0; map sp_ab_blossom" )
+	AddActionBlock( "Week 5", 		"Titan Ability: Arc Blast", 						"Mo", 				"Use Down on D-Pad to use Arc Blast\n\nUse your new ability to defeat the enemies", 							"playlist Load a map on the command line; bug_reproNum 1; map sp_ab_blossom" )
+	AddActionBlock( "Week 5", 		"Titan Abilities: Death Blossom + Arc Blast", 		"Mo", 				"D-Pad Up = Death Blossom\nD-Pad Down = Arc Blast\n\nUse your new abilities to defeat the enemies", 			"playlist Load a map on the command line; bug_reproNum 2; map sp_ab_blossom" )
+	AddActionBlock( "Week 5", 		"Time Stasis Gun", 									"LumberJake", 		"Titan freezes enemies allowing the Pilot \nto do a one-shot kill", 		"playlist Load a map on the command line; map sp_actionblockjake03" )
+	AddActionBlock( "Week 5", 		"Fastball Mortar Battle", 							"McCord/Slayback", 	"Freeform Buddy Titan arena battle. \n - Fastball Special \n - Mortar Crews \n - Buddy Hibernation \n - Harvester Defense", 	"playlist Load a map on the command line; map sp_ab_mortar_battle01" )
+	AddActionBlock( "Week 5", 		"Zipline Gun", 										"ChadG", 			"Create permanent ziplines in the map", 									"playlist Load a map on the command line; mp_gamemode tdm; bug_reproNum 1234; map mp_angel_city" )
+	AddActionBlock( "Week 6", 		"Titan Hulk", 										"David", 			"Buddy Titan hulks out and throws things.", 								"playlist Load a map on the command line; map sp_ab_titan_thrower" )
+	AddActionBlock( "Week 6", 		"Player & Titan vs Enemy Titan",					"Roger", 			"Bare bones Pilot & Auto Titan vs Enemy Titan", 							"playlist Load a map on the command line; map sp_ab_ptvt"  )
+	AddActionBlock( "Week 6", 		"Pilot Stasis Gun", 								"Soupy", 			"Pilot has a Stasis gun to help a friendly Titan out", 						"playlist Load a map on the command line; map sp_ab_synergy" )
+	AddActionBlock( "Week 6", 		"Acid Rain", 										"LumberJake", 		"- Destroy 3 harvesters in a poison rain storm\n- Avoid poison rain by staying in your Titan or indoors\n- Collect powerups to get rain immunity", 	"map sp_actionblockjake04" )
+	AddActionBlock( "Week 6", 		"Freeform Hallway Fight", 							"McCord/Slayback", 	"Move through the tight hallways with your Titan Buddy.", 					"playlist Load a map on the command line; map sp_ab_hallway_fight01" )
+	AddActionBlock( "Week 6", 		"Stealth Town",		 								"Carlos", 			"Stealth through a group of enemy titans", 									"playlist Load a map on the command line; map sp_titan_stealth" )
+	AddActionBlock( "Week 6", 		"Titan Attack Command", 							"Mo", 				"Command your buddy titan to attack a position.", 							"playlist Load a map on the command line; map sp_ab_break" )
+	AddActionBlock( "Week 7", 		"SP Shell", 										"Chad/McCord", 		"", 																		"playlist Load a map on the command line; map sp_shell1" )
+	AddActionBlock( "Week 7", 		"Smart Pistol Progression", 						"Soupy", 			"Try different smart pistol mods in different combat situations", 			"playlist Load a map on the command line; map sp_ab_smart_pistol_ramp" )
+}
+
+
+function AddActionBlock( subMenu, actionBlockName, owner, description, command )
+{
+	local subMenuIndex = null
+	foreach( i, Table in file.actionBlocks )
+	{
+		if ( Table.name == subMenu )
+			subMenuIndex = i
+	}
+	if ( subMenuIndex == null )
+	{
+		file.actionBlocks.append( { name = subMenu, actionBlocks = [] } )
+		subMenuIndex = file.actionBlocks.len() - 1
+	}
+
+	local Table = {}
+	Table.name <- actionBlockName
+	Table.owner <- owner
+	Table.description <- description
+	Table.command <- command
+
+	file.actionBlocks[ subMenuIndex ].actionBlocks.append( Table )
+}
+
+function GetActionBlocks()
+{
+	DefineActionBlocks()
+	return file.actionBlocks
+}
+
+void function SetupActionBlocks()
+{
+	DefineActionBlocks()
+
+	// For the in-game dev menu we only add the current week of action blocks
+	foreach ( week, actionBlock in file.actionBlocks )
+	{
+		SetupDevFunc( "Week " + ( week + 1 ), SetDevMenu_Week, week )
+	}
+}
+
+void function SetDevMenu_Week( var week )
+{
+	ChangeToThisMenu_WithOpParm( SetupActionBlocksByWeek, week )
+}
+
+void function SetupActionBlocksByWeek( var week )
+{
+	foreach ( actionBlock in file.actionBlocks[ week ].actionBlocks )
+	{
+		SetupDevCommand( actionBlock.name + " - " + actionBlock.owner, expect string( actionBlock.command ) )
+	}
+}
+
+void function SetDevMenu_AICommands( var _ )
+{
+	ChangeToThisMenu( SetupAIDevCommands )
+}
+
+void function SetDevMenu_AISpawn( var enemy )
+{
+#if DEV
+	InitNpcSettingsFileNamesForDevMenu()
+	ChangeToThisMenu_WithOpParm( SetupSpawnAIButtons, enemy )
+#endif
+}
+
+void function SetDevMenu_BossTitans( var _ )
+{
+#if DEV
+	InitNpcSettingsFileNamesForDevMenu()
+	ChangeToThisMenu( SetupSpawnBossTitans )
+#endif
+}
+
+void function SetDevMenu_FrontierDefense( var _ )
+{
+	#if DEV
+		thread ChangeToThisMenu( SetupFrontierDefense )
+	#endif
+}
+
+void function SetDevMenu_TitanWeapons( var _ )
+{
+#if DEV
+	thread ChangeToThisMenu_PrecacheWeapons( SetupTitanWeapon )
+#endif
+}
+
+void function SetDevMenu_ArmedNPC( var data )
+{
+#if DEV
+	thread ChangeToThisMenu_PrecacheWeapons_WithOpParm( SetupSpawnArmedNPC, data )
+#endif
+}
+
+void function SetDevMenu_PilotWeapons( var _ )
+{
+#if DEV
+	thread ChangeToThisMenu_PrecacheWeapons_WithOpParm( SetupPilotWeaponsFromFields, "not_set" )
+#endif
+}
+
+void function SetDevMenu_PilotOffhands( var _ )
+{
+#if DEV
+	thread ChangeToThisMenu_PrecacheWeapons_WithOpParm( SetupPilotWeaponsFromFields, "offhand" )
+#endif
+}
+
+void function ChangeToThisMenu_PrecacheWeapons( void functionref() menuFunc )
+{
+	waitthread PrecacheWeaponsIfNecessary()
+
+	file.devMenuFunc = menuFunc
+	file.devMenuFuncWithOpParm = null
+	file.devMenuOpParm = null
+	UpdateDevMenuButtons()
+}
+
+void function ChangeToThisMenu_PrecacheWeapons_WithOpParm( void functionref( var ) menuFuncWithOpParm, opParm = null )
+{
+	waitthread PrecacheWeaponsIfNecessary()
+
+	file.devMenuFunc = null
+	file.devMenuFuncWithOpParm = menuFuncWithOpParm
+	file.devMenuOpParm = opParm
+	UpdateDevMenuButtons()
+}
+
+void function PrecacheWeaponsIfNecessary()
+{
+	if ( file.precachedWeapons )
+		return
+
+	file.precachedWeapons = true
+	CloseAllInGameMenus()
+
+	DisablePrecacheErrors()
+	wait 0.1
+	ClientCommand( "script PrecacheSPWeapons()" )
+	wait 0.1
+	ClientCommand( "script_client PrecacheSPWeapons()" )
+	wait 0.1
+	RestorePrecacheErrors()
+
+	AdvanceMenu( GetMenu( "DevMenu" ) )
+}
+
+void function UpdatePrecachedSPWeapons()
+{
+	file.precachedWeapons = IsMultiplayer()
+}
+
+void function SetupMenu_SpawnNPCWithWeapons( parms )
+{
+	string weaponCapacity 	= expect string( parms.weaponCapacity )
+	string baseClass 		= expect string( parms.baseClass )
+	string aiSettings 		= expect string( parms.aiSettings )
+	int team				= expect int( parms.team )
+
+	array<int> itemTypes
+	switch ( weaponCapacity )
+	{
+		case "PilotMainWeapons":
+			itemTypes = [ eItemTypes.PILOT_PRIMARY, eItemTypes.PILOT_SECONDARY ]
+			break
+
+		case "TitanMainWeapons":
+			itemTypes = [ eItemTypes.TITAN_PRIMARY ]
+			break
+
+		default:
+			Assert( 0, "Unknown weapon capacity " + weaponCapacity )
+			break
+	}
+
+	array<string> itemNames
+	foreach ( itemType in itemTypes )
+	{
+		array<string> items = GetAllItemRefsOfType( itemType )
+		foreach ( item in items )
+		{
+			itemNames.append( item )
+		}
+	}
+
+	foreach ( ref in itemNames )
+	{
+		string weaponName = expect string( GetWeaponInfoFileKeyField_GlobalNotNull( ref, "printname" ) )
+
+		string cmd = "thread DEV_SpawnNPCWithWeaponAtCrosshair( \"" + baseClass + "\", \"" + aiSettings + "\", " + team + ", \"" + ref + "\" )"
+		SetupDevCommand( weaponName, "script " + cmd )
+	}
+}
+
+void function SetupAIDevCommands()
+{
+}
+
+void function SetDevMenu_titanSelection( var _ )
+{
+	ChangeToThisMenu( SetupTitanSelection )
+}
+
+void function SetupTitanSelection()
+{
+}
+
+void function SetupDevCommand( string label, string command )
+{
+	DevCommand cmd
+	cmd.label = label
+	cmd.command = command
+
+	file.devCommands.append( cmd )
+}
+
+void function SetupDevFunc( string label, void functionref( var ) func, var opParm = null )
+{
+	DevCommand cmd
+	cmd.label = label
+	cmd.func = func
+	cmd.opParm = opParm
+
+	file.devCommands.append( cmd )
+}
+
+function OnDevButton_Activate( button )
+{
+	//if ( level.ui.disableDev )
+	//{
+	//	CodeWarning( "Dev commands disabled on matchmaking servers." )
+	//	return
+	//}
+
+	int buttonID = int( Hud_GetScriptID( button ) )
+	DevCommand cmd = file.devCommands[buttonID]
+
+	RunDevCommand( cmd )
+}
+
+void function RunDevCommand( DevCommand cmd )
+{
+	if ( cmd.storeAsLastCommand )
+	{
+		file.lastDevCommand = cmd
+		file.lastDevCommandAssigned = true
+	}
+
+	if ( cmd.command != "" )
+	{
+		ClientCommand( cmd.command )
+		CloseAllInGameMenus()
+	}
+	else
+	{
+		cmd.func( cmd.opParm )
+	}
+}
+
+void function RepeatLastDevCommand( var _ )
+{
+	if ( !file.lastDevCommandAssigned )
+		return
+
+	RunDevCommand( file.lastDevCommand )
+}
\ No newline at end of file
diff --git a/bobthebob.testing/scripts/vscripts/ui/menu_map_select.nut b/bobthebob.testing/scripts/vscripts/ui/menu_map_select.nut
new file mode 100644
index 00000000..7263a9fa
--- /dev/null
+++ b/bobthebob.testing/scripts/vscripts/ui/menu_map_select.nut
@@ -0,0 +1,200 @@
+untyped
+
+
+global function MenuMapSelect_Init
+
+global function InitMapsMenu
+
+const int MAPS_PER_PAGE = 21
+
+const MAP_LIST_VISIBLE_ROWS = 21
+const MAP_LIST_SCROLL_SPEED = 0
+
+struct {
+	var menu = null
+	array<var> buttons
+	int numMapButtonsOffScreen
+	int mapListScrollState = 0
+} file
+
+// note: this does have a scrolling system in vanilla, but it's honestly really weird and jank and i don't like it
+// so for parity with menu_mode_select i'm removing it in favour of a page system
+
+function MenuMapSelect_Init()
+{
+	RegisterSignal( "OnCloseMapsMenu" )
+}
+
+void function InitMapsMenu()
+{
+	file.menu = GetMenu( "MapsMenu" )
+	var menu = file.menu
+
+	AddMenuEventHandler( menu, eUIEvent.MENU_OPEN, OnOpenMapsMenu )
+	AddMenuEventHandler( menu, eUIEvent.MENU_CLOSE, OnCloseMapsMenu )
+
+	AddEventHandlerToButtonClass( menu, "MapButtonClass", UIE_GET_FOCUS, MapButton_Focused )
+	AddEventHandlerToButtonClass( menu, "MapButtonClass", UIE_LOSE_FOCUS, MapButton_LostFocus )
+	AddEventHandlerToButtonClass( menu, "MapButtonClass", UIE_CLICK, MapButton_Activate )
+	//AddEventHandlerToButtonClass( menu, "MapListScrollUpClass", UIE_CLICK, OnMapListScrollUp_Activate )
+	//AddEventHandlerToButtonClass( menu, "MapListScrollDownClass", UIE_CLICK, OnMapListScrollDown_Activate )
+
+	AddMenuFooterOption( menu, BUTTON_A, "#A_BUTTON_SELECT" )
+	AddMenuFooterOption( menu, BUTTON_B, "#B_BUTTON_BACK", "#BACK" )
+
+	file.buttons = GetElementsByClassname( menu, "MapButtonClass" )
+	
+	AddMenuFooterOption( menu, BUTTON_SHOULDER_LEFT, "#PRIVATE_MATCH_PAGE_PREV", "#PRIVATE_MATCH_PAGE_PREV", CycleModesBack, IsNorthstarServer )
+	AddMenuFooterOption( menu, BUTTON_SHOULDER_RIGHT, "#PRIVATE_MATCH_PAGE_NEXT", "#PRIVATE_MATCH_PAGE_NEXT", CycleModesForward, IsNorthstarServer )
+}
+
+void function OnOpenMapsMenu()
+{
+	array<var> buttons = file.buttons
+	array<string> mapsArray = GetPrivateMatchMaps()
+
+	file.numMapButtonsOffScreen = int( max( mapsArray.len() - MAP_LIST_VISIBLE_ROWS, 0 ) )
+//	Assert( file.numMapButtonsOffScreen >= 0 )
+
+	foreach ( button in buttons )
+	{
+		int buttonID = int( Hud_GetScriptID( button ) )
+
+		if ( buttonID >= 0 && buttonID < mapsArray.len() )
+		{
+			string name = mapsArray[buttonID]
+			SetButtonRuiText( button, GetMapDisplayName( name ) )
+			Hud_SetEnabled( button, true )
+
+			if ( IsItemInEntitlementUnlock( name ) && IsValid( GetUIPlayer() ) )
+	 		{
+	 			if ( IsItemLocked( GetUIPlayer(), name ) && GetCurrentPlaylistVarInt( name + "_available" , 0 ) == 0 )
+	 			{
+	 				SetButtonRuiText( button, Localize( "#MAP_LOCKED", Localize( GetMapDisplayName( name ) ) ) )
+	 			}
+	 		}
+
+			bool mapSupportsMode = PrivateMatch_IsValidMapModeCombo( name, PrivateMatch_GetSelectedMode() )
+			Hud_SetLocked( button, !mapSupportsMode )
+
+			if ( !mapSupportsMode )
+				SetButtonRuiText( button, Localize( "#PRIVATE_MATCH_UNAVAILABLE", Localize( GetMapDisplayName( name ) ) ) )
+		}
+		else
+		{
+			SetButtonRuiText( button, "" )
+			Hud_SetEnabled( button, false )
+		}
+
+		if ( buttonID == level.ui.privatematch_map )
+		{
+			printt( buttonID, mapsArray[buttonID] )
+			Hud_SetFocused( button )
+		}
+	}
+
+	//RegisterButtonPressedCallback( MOUSE_WHEEL_UP, OnMapListScrollUp_Activate )
+	//RegisterButtonPressedCallback( MOUSE_WHEEL_DOWN, OnMapListScrollDown_Activate )
+}
+
+void function OnCloseMapsMenu()
+{
+	//DeregisterButtonPressedCallback( MOUSE_WHEEL_UP, OnMapListScrollUp_Activate )
+	//DeregisterButtonPressedCallback( MOUSE_WHEEL_DOWN, OnMapListScrollDown_Activate )
+
+	Signal( uiGlobal.signalDummy, "OnCloseMapsMenu" )
+}
+
+void function MapButton_Focused( var button )
+{
+	int buttonID = int( Hud_GetScriptID( button ) )
+
+	var menu = file.menu
+	var nextMapImage = Hud_GetChild( menu, "NextMapImage" )
+	var nextMapName = Hud_GetChild( menu, "NextMapName" )
+	var nextMapDesc = Hud_GetChild( menu, "NextMapDesc" )
+
+	array<string> mapsArray = GetPrivateMatchMaps()
+	string mapName = mapsArray[buttonID]
+
+	asset mapImage = GetMapImageForMapName( mapName )
+	RuiSetImage( Hud_GetRui( nextMapImage ), "basicImage", mapImage )
+	Hud_SetText( nextMapName, GetMapDisplayName( mapName ) )
+
+	string modeName = PrivateMatch_GetSelectedMode()
+	bool mapSupportsMode = PrivateMatch_IsValidMapModeCombo( mapName, modeName )
+	if ( !mapSupportsMode )
+		Hud_SetText( nextMapDesc, Localize( "#PRIVATE_MATCH_MAP_NO_MODE_SUPPORT", Localize( GetMapDisplayName( mapName ) ), Localize( GetGameModeDisplayName( modeName ) ) ) )
+	else
+		Hud_SetText( nextMapDesc, GetMapDisplayDesc( mapName ) )
+
+	// Update window scrolling if we highlight a map not in view
+	int minScrollState = int( clamp( buttonID - (MAP_LIST_VISIBLE_ROWS - 1), 0, file.numMapButtonsOffScreen ) )
+	int maxScrollState = int( clamp( buttonID, 0, file.numMapButtonsOffScreen ) )
+
+	if ( file.mapListScrollState < minScrollState )
+		file.mapListScrollState = minScrollState
+	if ( file.mapListScrollState > maxScrollState )
+		file.mapListScrollState = maxScrollState
+
+	UpdateMapListScroll()
+}
+
+void function MapButton_LostFocus( var button )
+{
+	HandleLockedCustomMenuItem( file.menu, button, [], true )
+}
+
+void function MapButton_Activate( var button )
+{
+	if ( Hud_IsLocked( button ) )
+	{
+		return
+	}
+
+	if ( !AmIPartyLeader() && GetPartySize() > 1 )
+		return
+
+	array<string> mapsArray = GetPrivateMatchMaps()
+	int mapID = int( Hud_GetScriptID( button ) )
+	string mapName = mapsArray[mapID]
+
+	printt( mapName, mapID )
+
+	ClientCommand( "SetCustomMap " + mapName )
+	CloseActiveMenu()
+}
+
+
+void function OnMapListScrollUp_Activate( var button )
+{
+	file.mapListScrollState--
+	if ( file.mapListScrollState < 0 )
+		file.mapListScrollState = 0
+
+	UpdateMapListScroll()
+}
+
+void function OnMapListScrollDown_Activate( var button )
+{
+	file.mapListScrollState++
+	if ( file.mapListScrollState > file.numMapButtonsOffScreen )
+		file.mapListScrollState = file.numMapButtonsOffScreen
+
+	UpdateMapListScroll()
+}
+
+function UpdateMapListScroll()
+{
+	array<var> buttons = file.buttons
+	local basePos = buttons[0].GetBasePos()
+	local offset = buttons[0].GetHeight() * file.mapListScrollState
+
+	buttons[0].SetPos( basePos[0], basePos[1] - offset )
+}
+
+void function CycleModesBack( var button )
+{}
+
+void function CycleModesForward( var button )
+{}
diff --git a/bobthebob.testing/scripts/vscripts/ui/menu_mode_select.nut b/bobthebob.testing/scripts/vscripts/ui/menu_mode_select.nut
new file mode 100644
index 00000000..4e0ecef5
--- /dev/null
+++ b/bobthebob.testing/scripts/vscripts/ui/menu_mode_select.nut
@@ -0,0 +1,138 @@
+global function InitModesMenu
+
+struct {
+	int currentModePage
+	
+} file
+
+const int MODES_PER_PAGE = 15
+
+void function InitModesMenu()
+{
+	var menu = GetMenu( "ModesMenu" )
+
+	AddMenuEventHandler( menu, eUIEvent.MENU_OPEN, OnOpenModesMenu )
+
+	AddEventHandlerToButtonClass( menu, "ModeButton", UIE_GET_FOCUS, ModeButton_GetFocus )
+	AddEventHandlerToButtonClass( menu, "ModeButton", UIE_CLICK, ModeButton_Click )
+
+	AddMenuFooterOption( menu, BUTTON_A, "#A_BUTTON_SELECT" )
+	AddMenuFooterOption( menu, BUTTON_B, "#B_BUTTON_BACK", "#BACK" )
+	
+	AddMenuFooterOption( menu, BUTTON_SHOULDER_LEFT, "#PRIVATE_MATCH_PAGE_PREV", "#PRIVATE_MATCH_PAGE_PREV", CycleModesBack, IsNorthstarServer )
+	AddMenuFooterOption( menu, BUTTON_SHOULDER_RIGHT, "#PRIVATE_MATCH_PAGE_NEXT", "#PRIVATE_MATCH_PAGE_NEXT", CycleModesForward, IsNorthstarServer )
+}
+
+void function OnOpenModesMenu()
+{
+	UpdateVisibleModes()
+	
+	if ( level.ui.privatematch_mode == 0 ) // set to the first mode if there's no mode focused
+		Hud_SetFocused( GetElementsByClassname( GetMenu( "ModesMenu" ), "ModeButton" )[ 0 ] )
+}
+
+void function UpdateVisibleModes()
+{	
+	// ensures that we only ever show enough buttons for the number of modes we have
+	array<var> buttons = GetElementsByClassname( GetMenu( "ModesMenu" ), "ModeButton" )
+	foreach ( var button in buttons )
+	{
+		Hud_SetEnabled( button, false )
+		Hud_SetVisible( button, false )
+	}
+		
+	array<string> modesArray = GetPrivateMatchModes()
+	for ( int i = 0; i < MODES_PER_PAGE; i++ )
+	{
+		if ( i + ( file.currentModePage * MODES_PER_PAGE ) >= modesArray.len() )
+			break
+		
+		int modeIndex = i + ( file.currentModePage * MODES_PER_PAGE )
+		SetButtonRuiText( buttons[ i ], GetGameModeDisplayName( modesArray[ modeIndex ] ) )
+		Hud_SetEnabled( buttons[ i ], true )
+		Hud_SetVisible( buttons[ i ], true )
+		Hud_SetLocked( buttons[ i ], false )
+		
+		if ( !PrivateMatch_IsValidMapModeCombo( PrivateMatch_GetSelectedMap(), modesArray[ modeIndex ] ) && !IsNorthstarServer() )
+		{
+			Hud_SetLocked( buttons[ i ], true )
+			SetButtonRuiText( buttons[ i ], Localize( "#PRIVATE_MATCH_UNAVAILABLE", Localize( GetGameModeDisplayName( modesArray[ modeIndex ] ) ) ) )
+		}		
+	}
+}
+
+void function ModeButton_GetFocus( var button )
+{
+	int modeId = int( Hud_GetScriptID( button ) ) + ( file.currentModePage * MODES_PER_PAGE )
+
+	var menu = GetMenu( "ModesMenu" )
+	var nextModeImage = Hud_GetChild( menu, "NextModeImage" )
+	var nextModeIcon = Hud_GetChild( menu, "ModeIconImage" )
+	var nextModeName = Hud_GetChild( menu, "NextModeName" )
+	var nextModeDesc = Hud_GetChild( menu, "NextModeDesc" )
+
+	array<string> modesArray = GetPrivateMatchModes()
+
+	if ( modeId > modesArray.len() )
+		return
+
+	string modeName = modesArray[modeId]
+
+	asset playlistImage = GetPlaylistImage( modeName )
+	RuiSetImage( Hud_GetRui( nextModeImage ), "basicImage", playlistImage )
+	RuiSetImage( Hud_GetRui( nextModeIcon ), "basicImage", GetPlaylistThumbnailImage( modeName ) )
+	Hud_SetText( nextModeName, GetGameModeDisplayName( modeName ) )
+
+	string mapName = PrivateMatch_GetSelectedMap()
+	bool mapSupportsMode = PrivateMatch_IsValidMapModeCombo( mapName, modeName )
+	if ( !mapSupportsMode && !IsNorthstarServer() )
+		Hud_SetText( nextModeDesc, Localize( "#PRIVATE_MATCH_MODE_NO_MAP_SUPPORT", Localize( GetGameModeDisplayName( modeName ) ), Localize( GetMapDisplayName( mapName ) ) ) )
+	else if ( IsFDMode( modeName ) ) // HACK!
+		Hud_SetText( nextModeDesc, Localize( "#FD_PLAYERS_DESC", Localize( GetGameModeDisplayHint( modeName ) ) ) )
+	else
+		Hud_SetText( nextModeDesc, GetGameModeDisplayHint( modeName ) )
+}
+
+void function ModeButton_Click( var button )
+{
+	// this never activates on custom servers, but keeping it for parity with official
+	if ( !AmIPartyLeader() && GetPartySize() > 1 )
+		return
+
+	if ( Hud_IsLocked( button ) )
+		return
+
+	int mapID = int( Hud_GetScriptID( button ) ) + ( file.currentModePage * MODES_PER_PAGE )
+
+	var menu = GetMenu( "MapsMenu" )
+
+	array<string> modesArray = GetPrivateMatchModes()
+	string modeName = modesArray[mapID]
+
+	// on modded servers set us to the first map for that mode automatically
+	// need this for coliseum mainly which is literally impossible to select without this
+	if ( IsNorthstarServer() && !PrivateMatch_IsValidMapModeCombo( PrivateMatch_GetSelectedMap(), modesArray[ mapID ] ) )
+		ClientCommand( "SetCustomMap " + GetPrivateMatchMapsForMode( modeName )[ 0 ] )
+		
+	// set it
+	ClientCommand( "PrivateMatchSetMode " + modeName )
+	CloseActiveMenu()
+}
+
+void function CycleModesBack( var button )
+{
+	if ( file.currentModePage == 0 )
+		return
+
+	file.currentModePage--
+	UpdateVisibleModes()
+}
+
+void function CycleModesForward( var button )
+{
+	if ( ( file.currentModePage + 1 ) * MODES_PER_PAGE >= GetPrivateMatchModes().len() )
+		return
+
+	file.currentModePage++
+	UpdateVisibleModes()
+}
\ No newline at end of file
diff --git a/bobthebob.testing/scripts/vscripts/ui/menu_team_titan_select.nut b/bobthebob.testing/scripts/vscripts/ui/menu_team_titan_select.nut
new file mode 100644
index 00000000..92bb849e
--- /dev/null
+++ b/bobthebob.testing/scripts/vscripts/ui/menu_team_titan_select.nut
@@ -0,0 +1,722 @@
+global function InitTeamTitanSelectMenu
+global function TeamTitanSelectMenuIsOpen
+global function ServerCallback_OpenTeamTitanMenu
+global function ServerCallback_CloseTeamTitanMenu
+global function ServerCallback_UpdateTeamTitanMenuTime
+global function ServerCallback_RegisterTeamTitanMenuButtons
+global function TTSUpdateDoubleXP
+global function TTSUpdateDoubleXPStatus
+global function TTSMenuModeFD
+global function TTSMenuModeDefault
+global function TTSMenu_UpdateGameMode
+global function EnableDoubleXP
+
+const float SELECT_DELAY = 0.2
+
+enum eTTSMenuMode
+{
+	DEFAULT,
+	FD
+}
+
+struct
+{
+	var menu
+	bool allowManualClose = false
+	bool isReady = false
+	bool menuOpened = false
+	bool allowSelection = false
+
+	array<var> titanButtons
+	array<var> titanUpgradeButtons
+	var editButton
+	var readyPanel
+	var cover
+	var doubleXPButton
+	var chatBox
+
+	bool buttonsRegistered = false
+
+	int menuMode
+
+	float nextAllowSoundTime = 0.0
+} file
+
+void function InitTeamTitanSelectMenu()
+{
+	file.menu = GetMenu( "TeamTitanSelectMenu" )
+
+	AddMenuEventHandler( file.menu, eUIEvent.MENU_NAVIGATE_BACK, OnTeamTitanSelectMenu_NavigateBack )
+	AddMenuEventHandler( file.menu, eUIEvent.MENU_OPEN, OnTeamTitanSelectMenu_Open )
+	AddMenuEventHandler( file.menu, eUIEvent.MENU_SHOW, OnTeamTitanSelectMenu_Open )
+	AddMenuEventHandler( file.menu, eUIEvent.MENU_HIDE, OnTeamTitanSelectMenu_Hide )
+	AddMenuEventHandler( file.menu, eUIEvent.MENU_CLOSE, OnTeamTitanSelectMenu_Close )
+
+	RegisterSignal( "TTSMenuClosed" )
+	RegisterSignal( "Delayed_RequestTitanLoadout" )
+
+	float margin = 10.0
+	float totalWidth = 0.0
+	for ( int i=0; i<NUM_PERSISTENT_TITAN_LOADOUTS; i++ )
+	{
+		var button = Hud_GetChild( file.menu, "TitanButton" + i )
+		file.titanButtons.append( button )
+		float xPos = totalWidth * -1
+		totalWidth += Hud_GetWidth( button ) + margin
+		Hud_SetPos( button, xPos, Hud_GetY( button ) )
+	}
+
+	var bg = Hud_GetChild( file.menu, "BG" )
+	totalWidth -= margin
+	float bgWidth = float( Hud_GetWidth( bg ) )
+	float startPos = (bgWidth*0.5 - totalWidth*0.5) * -1
+	for ( int i=0; i<NUM_PERSISTENT_TITAN_LOADOUTS; i++ )
+	{
+		var button = file.titanButtons[i]
+		Hud_SetPos( button, startPos + Hud_GetX( button ), Hud_GetY( button ) )
+
+		Hud_AddEventHandler( button, UIE_CLICK, TitanButton_OnClick )
+		Hud_AddEventHandler( button, UIE_GET_FOCUS, TitanButton_OnFocused )
+	}
+
+	for ( int i=0; i<7; i++ )
+	{
+		var button = Hud_GetChild( file.menu, "BtnSub" + i )
+
+		Hud_AddEventHandler( button, UIE_LOSE_FOCUS, TitanUpgradeButton_OnLoseFocus )
+		Hud_AddEventHandler( button, UIE_GET_FOCUS, TitanUpgradeButton_OnFocused )
+	}
+
+	SetNavLeftRight( file.titanButtons, true )
+
+	//file.editButton = Hud_GetChild( file.menu, "EditTitanButton" )
+	//Hud_AddEventHandler( file.editButton, UIE_CLICK, EditTitanButton_OnClick )
+	file.readyPanel = Hud_GetChild( file.menu, "ReadyRui" )
+	file.cover = Hud_GetChild( file.menu, "Cover" )
+
+	#if PC_PROG
+	file.chatBox = Hud_GetChild( file.menu, "LobbyChatBox" )
+	#endif // PC_PROG
+
+	file.doubleXPButton = Hud_GetChild( file.menu, "DoubleXP" )
+
+	AddMenuFooterOption( file.menu, BUTTON_A, "#A_BUTTON_SELECT", "", null, TeamTitanSelect_IsNotReady )
+	AddMenuFooterOption( file.menu, BUTTON_B, "#B_BUTTON_BACK", "#BACK" )
+	AddMenuFooterOption( file.menu, BUTTON_X, "#MENU_X_BUTTON_EDIT_TITAN", "#MENU_EDIT_TITAN", EditTitanButton_OnClick, TeamTitanSelect_IsReady )
+	AddMenuFooterOption( file.menu, BUTTON_Y, "#MENU_Y_BUTTON_EDIT_PILOT", "#MENU_EDIT_PILOT", EditPilotButton_OnClick, CoverIsOff )
+}
+
+void function TTSUpdateDoubleXP( int count, bool avialable, float status )
+{
+	var rui = Hud_GetRui( file.doubleXPButton )
+	RuiSetInt( rui, "doubleXPCount", count )
+	RuiSetBool( rui, "doubleXPAvailable", avialable )
+	RuiSetFloat( rui, "doubleXPStatus", status )
+}
+
+void function TTSUpdateDoubleXPStatus( int status )
+{
+	var rui = Hud_GetRui( file.doubleXPButton )
+	RuiSetFloat( rui, "doubleXPStatus", float( status ) )
+}
+
+void function ServerCallback_UpdateTeamTitanMenuTime( float endTime )
+{
+	Signal( uiGlobal.signalDummy, "TTSMenuClosed" )
+
+	file.allowSelection = true
+
+	if ( file.nextAllowSoundTime < Time() )
+	{
+		EmitUISound( "ui_ctf_1p_playerscore" )
+		file.nextAllowSoundTime = Time() + 5.0
+	}
+
+	Hud_SetEnabled( file.cover, false )
+	Hud_Hide( file.cover )
+	Hud_SetAlpha( file.cover, 0 )
+
+	if ( endTime > 5 )
+		file.allowSelection = true
+
+	thread UpdateSubText( Time() + endTime )
+}
+
+void function ServerCallback_OpenTeamTitanMenu( float endTime )
+{
+	if ( TeamTitanSelectMenuIsOpen() )
+		return
+
+	if ( uiGlobal.activeMenu != null )
+		CloseAllMenus()
+
+	RunClientScript( "PlayTTSMusic" )
+
+	file.allowManualClose = false
+	file.allowSelection = true
+	file.isReady = true // set to true so selection mode kicks in
+	thread MenuFadeIn()
+	BeginSelectionMode()
+	AdvanceMenu( file.menu )
+	thread UpdateSubText( Time() + endTime )
+}
+
+void function MenuFadeIn()
+{
+	Hud_SetEnabled( file.cover, true )
+	Hud_SetAlpha( file.cover, 255 )
+	Hud_Show( file.cover )
+	wait 1.0
+	Hud_FadeOverTime( file.cover, 0, 1.0 )
+	wait 1.0
+	Hud_Hide( file.cover )
+	Hud_SetEnabled( file.cover, false )
+}
+
+void function UpdateSubText( float endTime )
+{
+	EndSignal( uiGlobal.signalDummy, "TTSMenuClosed" )
+
+	var subText = Hud_GetChild( file.menu, "MenuSubTitle" )
+	var rui = Hud_GetRui( file.readyPanel )
+	RuiSetBool( rui, "isReady", true )
+
+	thread Countdown( endTime )
+	while ( Time() < endTime )
+	{
+		int countdownTime = int( ceil( endTime - Time() ) )
+		Hud_SetText( subText, Localize( "#MENU_STARTS_IN", countdownTime ) )
+		RuiSetInt( rui, "timer", countdownTime )
+		WaitFrame()
+	}
+
+	Hud_SetText( subText, Localize( "#MENU_STARTS_IN", 0 ) )
+	RuiSetInt( rui, "timer", 0 )
+}
+
+void function Countdown( float endTime )
+{
+	EndSignal( uiGlobal.signalDummy, "TTSMenuClosed" )
+
+	float countdownTime = 5.0
+	float startCountdownTime = endTime - countdownTime
+
+	if ( Time() > startCountdownTime )
+		return
+
+	wait startCountdownTime - Time()
+
+	while ( Time() < endTime )
+	{
+		EmitUISound( "UI_InGame_MarkedForDeath_CountdownToMarked" )
+		wait 1.0
+	}
+
+	file.allowSelection = false
+	BeginEditMode(null)
+
+	Hud_SetAlpha( file.cover, 0 )
+	Hud_SetEnabled( file.cover, true )
+	Hud_Show( file.cover )
+	Hud_FadeOverTime( file.cover, 255, 1.0 )
+
+	float soundTime = DoPrematchWarpSound() ? PICK_LOADOUT_SOUND_TIME : 1.5
+	wait soundTime
+
+	thread ServerCallback_CloseTeamTitanMenu()
+}
+
+void function ServerCallback_CloseTeamTitanMenu()
+{
+	if ( TeamTitanSelectMenuIsOpen() )
+	{
+		file.allowManualClose = true
+		UI_SetPresentationType( ePresentationType.INACTIVE )
+		CloseAllMenus()
+		OnTeamTitanSelectMenu_Close()
+	}
+}
+
+void function OnTeamTitanSelectMenu_NavigateBack()
+{
+	if ( file.allowManualClose )
+	{
+		CloseActiveMenu()
+		return
+	}
+
+	if ( file.isReady && file.allowSelection )
+	{
+		BeginSelectionMode()
+		return
+	}
+
+	LeaveDialog()
+	return
+}
+
+void function TTSMenu_UpdateGameMode( string modeName )
+{
+	var title = Hud_GetChild( file.menu, "MenuTitle" )
+	Hud_SetText( title, Localize( modeName ) )
+}
+
+void function ServerCallback_RegisterTeamTitanMenuButtons()
+{
+	RegisterButtonCallbacks()
+}
+
+void function RegisterButtonCallbacks()
+{
+	if ( file.buttonsRegistered )
+		return
+
+	file.buttonsRegistered = true
+	RegisterButtonPressedCallback( BUTTON_BACK, EnableDoubleXP )
+	RegisterButtonPressedCallback( KEY_RSHIFT, EnableDoubleXP )
+}
+
+void function OnTeamTitanSelectMenu_Open()
+{
+	file.menuOpened = true
+
+	var dataTable = GetDataTable( $"datatable/titan_properties.rpak" )
+	int loadoutIconCol = GetDataTableColumnByName( dataTable, "loadoutIconFD" )
+	int titanCol = GetDataTableColumnByName( dataTable, "titanRef" )
+
+	entity player = GetUIPlayer()
+
+	var nextMapImage = Hud_GetChild( file.menu, "NextMapImage" )
+	string mapName = GetActiveLevel()
+	asset mapImage = GetMapImageForMapName( mapName )
+
+	RefreshCreditsAvailable()
+
+	RuiSetImage( Hud_GetRui( nextMapImage ), "basicImage", mapImage )
+	Hud_Show( nextMapImage )
+	Hud_SetText( Hud_GetChild( file.menu, "NextMapName" ), GetMapDisplayName( mapName ) )
+	Hud_Show( Hud_GetChild( file.menu, "NextMapName" ) )
+
+	var buttonToFocus
+
+	for ( int i=0; i<NUM_PERSISTENT_TITAN_LOADOUTS; i++ )
+	{
+		var button = file.titanButtons[i]
+		TitanLoadoutDef loadout = GetCachedTitanLoadout( i )
+		int row = GetDataTableRowMatchingStringValue( dataTable, titanCol,  loadout.titanClass )
+
+		asset icon = GetDataTableAsset( dataTable, row, loadoutIconCol )
+		var rui = Hud_GetRui( button )
+
+		RuiSetImage( rui, "buttonImage", icon )
+
+		if ( !IsTitanLoadoutAvailable( player, loadout.titanClass ) )
+		{
+			Hud_SetLocked( button, true )
+			if ( !IsItemLocked( player, loadout.titanClass ) )
+				RefreshButtonCost( button, loadout.titanClass, "", 0, 0 )
+		}
+		else
+		{
+			Hud_SetLocked( button, IsItemLocked( player, loadout.titanClass ) )
+			RefreshButtonCost( button, loadout.titanClass )
+
+			if ( uiGlobal.titanSpawnLoadoutIndex == i )
+			{
+				buttonToFocus = button
+			}
+		}
+	}
+
+	if ( buttonToFocus == null )
+		buttonToFocus = FindValidTitanButton()
+	thread HACK_DelayedSetFocus_BecauseWhy( buttonToFocus )
+
+	TitanLoadoutDef loadout = GetCachedTitanLoadout( uiGlobal.titanSpawnLoadoutIndex )
+
+	for ( int i=0; i<7; i++ )
+	{
+		var button = Hud_GetChild( file.menu, "BtnSub"+i )
+		file.titanUpgradeButtons.append( button )
+
+		if ( file.menuMode == eTTSMenuMode.FD )
+		{
+			Hud_Show( button )
+		}
+		else
+		{
+			Hud_Hide( button )
+		}
+	}
+	SetNavLeftRight( file.titanUpgradeButtons, true )
+
+	SetBlurEnabled( false )
+	var title = Hud_GetChild( file.menu, "MenuTitle" )
+	string name = expect string( GetCurrentPlaylistVar( "name" ) )
+	Hud_SetText( title, Localize( name ) )
+	RunMenuClientFunction( "ShowTTSPanel" )
+
+	if ( file.isReady )
+		UI_SetPresentationType( ePresentationType.TITAN_CENTER_SELECTED )
+	else
+		UI_SetPresentationType( ePresentationType.TITAN_CENTER )
+
+
+	RunClientScript( "TTS_UpdateLocalPlayerTitan", loadout.setFile, loadout.primary, loadout.passive1, loadout.passive2 )
+}
+
+void function EnableDoubleXP( var button )
+{
+	#if PC_PROG
+	if ( Hud_IsFocused( file.chatBox ) )
+		return
+	#endif // PC_PROG
+
+	if ( CanRunClientScript() )
+	{
+		EmitUISound( "Menu_Email_Sent" )
+		RunClientScript( "UseDoubleXP" )
+	}
+}
+
+void function OnTeamTitanSelectMenu_Hide()
+{
+	RunMenuClientFunction( "HideTTSPanel" )
+
+	DeregisterButtonCallbacks()
+}
+
+void function DeregisterButtonCallbacks()
+{
+	if ( !file.buttonsRegistered )
+		return
+
+	file.buttonsRegistered = false
+
+	DeregisterButtonPressedCallback( BUTTON_BACK, EnableDoubleXP )
+	DeregisterButtonPressedCallback( KEY_RSHIFT, EnableDoubleXP )
+}
+
+void function OnTeamTitanSelectMenu_Close()
+{
+	RunMenuClientFunction( "ClearAllPilotPreview" )
+	Signal( uiGlobal.signalDummy, "TTSMenuClosed" )
+	file.menuOpened = false
+	UI_SetPresentationType( ePresentationType.INACTIVE )
+
+	DeregisterButtonCallbacks()
+}
+
+void function TitanButton_OnClick( var button )
+{
+	int scriptID = int( Hud_GetScriptID( button ) )
+	if ( Hud_IsLocked( button ) )
+	{
+		TitanLoadoutDef loadout = GetCachedTitanLoadout( scriptID )
+		if ( !IsTitanLoadoutAvailable( GetUIPlayer(), loadout.titanClass ) )
+			return
+
+		OpenBuyItemDialog( file.titanButtons, button, GetItemName( loadout.titanClass ), loadout.titanClass )
+		return
+	}
+
+	if ( file.isReady )
+	{
+		BeginSelectionMode()
+		return
+	}
+
+	uiGlobal.titanSpawnLoadoutIndex = scriptID
+	Signal( uiGlobal.signalDummy, "Delayed_RequestTitanLoadout" )
+	ClientCommand( "RequestTitanLoadout " + uiGlobal.titanSpawnLoadoutIndex )
+	BeginEditMode( button )
+}
+
+void function TitanButton_OnFocused( var button )
+{
+	int scriptID = int( Hud_GetScriptID( button ) )
+
+	var rui = Hud_GetRui( Hud_GetChild( file.menu, "TitanName" ) )
+
+	TitanLoadoutDef loadout = GetCachedTitanLoadout( scriptID )
+
+	RuiSetString( rui, "titanName", GetTitanLoadoutName( loadout ) )
+	RuiSetString( rui, "titanLevelString", "" )
+	RuiSetString( rui, "titanRole", "" )
+
+	entity player = GetUIPlayer()
+
+	var dataTable = GetDataTable( $"datatable/titan_properties.rpak" )
+	int row = GetDataTableRowMatchingStringValue( dataTable, GetDataTableColumnByName( dataTable, "titanRef" ), loadout.titanClass )
+	string role = GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "fdRole" ) )
+	int titanLevel = FD_TitanGetLevelForXP( loadout.titanClass, FD_TitanGetXP( GetUIPlayer(), loadout.titanClass ) )
+	array<ItemDisplayData> titanUpgrades = FD_GetUpgradesForTitanClass( loadout.titanClass )
+
+	if ( file.menuMode == eTTSMenuMode.FD )
+	{
+		RuiSetString( rui, "titanLevelString", Localize( "#FD_TITAN_LEVEL", titanLevel ) )
+		RuiSetString( rui, "titanRole", Localize( "#FD_ROLE", Localize(role) ) )
+
+		foreach ( index, item in titanUpgrades )
+		{
+			var button = file.titanUpgradeButtons[index]
+			var upgradeRui = Hud_GetRui( button )
+
+			bool locked = IsSubItemLocked( GetUIPlayer(), item.ref, item.parentRef )
+
+			if ( locked )
+				RuiSetImage( upgradeRui, "buttonImage", expect asset( item.i.lockedImage ) )
+			else
+				RuiSetImage( upgradeRui, "buttonImage", item.image )
+
+			Hud_SetLocked( button, locked )
+		}
+	}
+
+	if ( !Hud_IsLocked( button ) )
+	{
+		uiGlobal.titanSpawnLoadoutIndex = scriptID
+		thread Delayed_RequestTitanLoadout( uiGlobal.titanSpawnLoadoutIndex )
+		SetLabelRuiText( Hud_GetChild( file.menu, "TitanSelectTitle" ), "#MENU_TITAN_SELECT" )
+	}
+	else
+	{
+		RuiSetString( rui, "titanLevelString", GetItemUnlockReqText( loadout.titanClass ) )
+	}
+
+	SetLabelRuiText( Hud_GetChild( file.menu, "TitanSelectTitle" ), GetTitanAvailableText( player, loadout.titanClass) )
+
+	RunMenuClientFunction( "UpdateTitanModel", scriptID )
+	RunClientScript( "TTS_UpdateLocalPlayerTitan", loadout.setFile, loadout.primary, loadout.passive1, loadout.passive2 )
+}
+
+string function GetTitanAvailableText( entity player, string titanClass )
+{
+	int titanAvailableState = GetTitanLoadAvailableState( player, titanClass )
+
+	if ( titanAvailableState == TITAN_CLASS_LOCK_STATE_AVAILABLE )
+		return "#MENU_TITAN_SELECT_HINT"
+
+	if ( titanAvailableState == TITAN_CLASS_LOCK_STATE_LEVELREQUIRED || titanAvailableState == TITAN_CLASS_LOCK_STATE_LEVELRECOMMENDED )
+	{
+		int difficultyLevel = GetCurrentPlaylistVarInt( "fd_difficulty", 0 )
+		int requiredTitanLevel = 0
+		switch ( difficultyLevel )
+		{
+			case eFDDifficultyLevel.EASY:
+				if ( GetItemUnlockType( "fd_easy" ) == eUnlockType.STAT )
+					requiredTitanLevel = int( GetStatUnlockStatVal( "fd_easy" ) )
+				break
+			case eFDDifficultyLevel.NORMAL:
+				if ( GetItemUnlockType( "fd_normal" ) == eUnlockType.STAT )
+					requiredTitanLevel = int( GetStatUnlockStatVal( "fd_normal" ) )
+				break
+			case eFDDifficultyLevel.HARD:
+				if ( GetItemUnlockType( "fd_hard" ) == eUnlockType.STAT )
+					requiredTitanLevel = int( GetStatUnlockStatVal( "fd_hard" ) )
+				break
+			case eFDDifficultyLevel.MASTER:
+				if ( GetItemUnlockType( "fd_master" ) == eUnlockType.STAT )
+					requiredTitanLevel = int( GetStatUnlockStatVal( "fd_master" ) )
+				break
+			case eFDDifficultyLevel.INSANE:
+				if ( GetItemUnlockType( "fd_insane" ) == eUnlockType.STAT )
+					requiredTitanLevel = int( GetStatUnlockStatVal( "fd_insane" ) )
+				break
+		}
+
+		if ( titanAvailableState == TITAN_CLASS_LOCK_STATE_LEVELREQUIRED )
+			return Localize( "#MENU_TITAN_SELECT_LEVELREQUIRED", requiredTitanLevel )
+		else
+			return Localize( "#MENU_TITAN_SELECT_LEVELRECOMMENDED", requiredTitanLevel )
+	}
+
+	if ( titanAvailableState == TITAN_CLASS_LOCK_STATE_INUSE )
+		return "#MENU_TITAN_SELECT_INUSE"
+
+	if ( titanAvailableState == TITAN_CLASS_LOCK_STATE_LOCKED )
+		return "#MENU_TITAN_SELECT_LOCKED"
+
+	return "#MENU_TITAN_SELECT_HINT"
+}
+
+void function Delayed_RequestTitanLoadout( int index )
+{
+	Signal( uiGlobal.signalDummy, "Delayed_RequestTitanLoadout" )
+	EndSignal( uiGlobal.signalDummy, "Delayed_RequestTitanLoadout" )
+	wait 0.5
+	ClientCommand( "RequestTitanLoadout " + uiGlobal.titanSpawnLoadoutIndex )
+}
+
+void function TitanUpgradeButton_OnFocused( var button )
+{
+	if ( file.menuMode == eTTSMenuMode.DEFAULT )
+		return
+
+	int scriptID = int( Hud_GetScriptID( button ) )
+	TitanLoadoutDef loadout = GetCachedTitanLoadout( uiGlobal.titanSpawnLoadoutIndex )
+	array<ItemDisplayData> titanUpgrades = FD_GetUpgradesForTitanClass( loadout.titanClass )
+
+	ItemDisplayData item = titanUpgrades[ scriptID ]
+	var panel = Hud_GetChild( file.menu, "UpgradeName" )
+	Hud_Show( panel )
+	var rui = Hud_GetRui( panel )
+	RuiSetString( rui, "upgradeName", item.name )
+	RuiSetString( rui, "upgradeDesc", item.desc )
+	RuiSetBool( rui, "isLocked", IsSubItemLocked( GetUIPlayer(), item.ref, item.parentRef ) )
+}
+
+void function TitanUpgradeButton_OnLoseFocus( var button )
+{
+	Hud_Hide( Hud_GetChild( file.menu, "UpgradeName" ) )
+}
+
+void function BeginEditMode( var button )
+{
+	if ( file.isReady )
+		return
+
+	file.isReady = true
+
+	EmitUISound( "UI_InGame_FD_TitanSelected" )
+	SetLabelRuiText( Hud_GetChild( file.menu, "TitanSelectTitle" ), "#MENU_TITAN_SELECTED" )
+	Hud_Hide( Hud_GetChild( file.menu, "TitanSelectTitle" ) )
+	Hud_Show( file.readyPanel )
+	var rui = Hud_GetRui( file.readyPanel )
+	RuiSetBool( rui, "isReady", true )
+
+	foreach ( b in file.titanButtons )
+	{
+		Hud_Hide( b )
+	}
+
+	//Hud_Show( file.editButton )
+	//Hud_SetFocused( file.editButton )
+	Hud_SetFocused( file.titanUpgradeButtons[0] )
+
+	TitanLoadoutDef loadout = GetCachedTitanLoadout( uiGlobal.titanSpawnLoadoutIndex )
+	string primeTitanString = ""
+
+	if ( loadout.isPrime == "titan_is_prime" )
+		primeTitanString = "_prime"
+
+	string modifiedAlias = "diag_gs_titan" + loadout.titanClass + primeTitanString + "_embark"
+	EmitUISound( modifiedAlias )
+
+	if ( uiGlobal.activeMenu == file.menu )
+		UI_SetPresentationType( ePresentationType.TITAN_CENTER_SELECTED )
+
+	Signal( uiGlobal.signalDummy, "Delayed_RequestTitanLoadout" )
+	ClientCommand( "RequestTitanLoadout " + uiGlobal.titanSpawnLoadoutIndex )
+	RunMenuClientFunction( "UpdateTitanModel", uiGlobal.titanSpawnLoadoutIndex )
+
+	var subText = Hud_GetChild( file.menu, "MenuSubTitle" )
+	// Hud_Hide( subText )
+}
+
+void function BeginSelectionMode()
+{
+	if ( !file.isReady )
+		return
+
+	file.isReady = false
+	//Hud_Hide( file.editButton )
+
+	SetLabelRuiText( Hud_GetChild( file.menu, "TitanSelectTitle" ), "#MENU_TITAN_SELECT_HINT" )
+	Hud_Show( Hud_GetChild( file.menu, "TitanSelectTitle" ) )
+	Hud_Hide( file.readyPanel )
+	var rui = Hud_GetRui( file.readyPanel )
+	RuiSetBool( rui, "isReady", false )
+
+	Hud_SetFocused( FindValidTitanButton() )
+
+	for ( int i=0; i<file.titanButtons.len(); i++ )
+	{
+		var b = file.titanButtons[i]
+		Hud_Show( b )
+		if ( i == uiGlobal.titanSpawnLoadoutIndex && !Hud_IsLocked( b ) )
+		{
+			Hud_SetFocused( b )
+		}
+	}
+
+	Hud_Hide( Hud_GetChild( file.menu, "UpgradeName" ) )
+
+	UI_SetPresentationType( ePresentationType.TITAN_CENTER )
+	RunMenuClientFunction( "UpdateTitanModel", uiGlobal.titanSpawnLoadoutIndex )
+
+	var subText = Hud_GetChild( file.menu, "MenuSubTitle" )
+	// Hud_Show( subText )
+}
+
+void function EditPilotButton_OnClick( var button )
+{
+	// SetEditLoadout( "pilot", uiGlobal.pilotSpawnLoadoutIndex )
+	// RunMenuClientFunction( "SetEditingPilotLoadoutIndex", uiGlobal.pilotSpawnLoadoutIndex )
+	AdvanceMenu( GetMenu( "EditPilotLoadoutsMenu" ) )
+	RunMenuClientFunction( "HideTTSPanel" )
+}
+
+void function EditTitanButton_OnClick( var button )
+{
+	SetEditLoadout( "titan", uiGlobal.titanSpawnLoadoutIndex )
+	RunMenuClientFunction( "SetEditingTitanLoadoutIndex", uiGlobal.titanSpawnLoadoutIndex )
+	AdvanceMenu( GetMenu( "EditTitanLoadoutMenu" ) )
+	RunMenuClientFunction( "HideTTSPanel" )
+}
+
+bool function CoverIsOff()
+{
+	return !Hud_IsEnabled( file.cover )
+}
+
+bool function TeamTitanSelectMenuIsOpen()
+{
+	return file.menuOpened
+}
+
+bool function TeamTitanSelect_IsReady()
+{
+	return file.isReady
+}
+
+bool function TeamTitanSelect_IsNotReady()
+{
+	return !file.isReady
+}
+
+void function TTSMenuModeFD()
+{
+	file.menuMode = eTTSMenuMode.FD
+
+	foreach ( button in file.titanUpgradeButtons )
+	{
+		Hud_Show( button )
+	}
+}
+
+void function TTSMenuModeDefault()
+{
+	file.menuMode = eTTSMenuMode.DEFAULT
+
+	foreach ( button in file.titanUpgradeButtons )
+	{
+		Hud_Hide( button )
+	}
+
+	var panel = Hud_GetChild( file.menu, "UpgradeName" )
+	Hud_Hide( panel )
+}
+
+var function FindValidTitanButton()
+{
+	foreach ( button in file.titanButtons )
+	{
+		if ( Hud_IsLocked( button ) )
+			continue
+
+		return button
+	}
+
+	return file.titanButtons[0]
+}
\ No newline at end of file