Progression system (#655)

This also can't hurt right?

---------

Co-authored-by: uniboi <64006268+uniboi@users.noreply.github.com>

1 files changed, 1091 insertions, 0 deletions

diff --git a/Northstar.CustomServers/mod/scripts/vscripts/sh_progression.nut b/Northstar.CustomServers/mod/scripts/vscripts/sh_progression.nut
new file mode 100644
index 00000000..00bdff60
--- /dev/null
+++ b/Northstar.CustomServers/mod/scripts/vscripts/sh_progression.nut
@@ -0,0 +1,1091 @@
+global function Progression_Init
+global function ProgressionEnabledForPlayer
+#if CLIENT || UI
+global function Progression_SetPreference
+global function Progression_GetPreference
+global function UpdateCachedLoadouts_Delayed
+#endif
+
+// SO FOR SOME GOD DAMN REASON, PUTTING THESE INTO ONE STRUCT
+// AND PUTTING THE #if STUFF AROUND THE VARS CAUSES A COMPILE
+// ERROR, SO I HAVE TO DO THIS AWFULNESS
+
+#if SERVER
+struct {
+	table<entity, bool> progressionEnabled
+} file
+#else // UI || CLIENT
+struct {
+	bool isUpdatingCachedLoadouts = false
+} file
+#endif
+
+
+void function Progression_Init()
+{
+	#if SERVER
+	AddCallback_OnClientDisconnected( OnClientDisconnected )
+	AddClientCommandCallback( "ns_progression", ClientCommand_SetProgression )
+	AddCallback_GameStateEnter( eGameState.Playing, OnPlaying )
+	#elseif CLIENT
+	AddCallback_OnClientScriptInit( OnClientScriptInit )
+	#endif
+}
+
+bool function ProgressionEnabledForPlayer( entity player )
+{
+	#if SERVER
+	if ( player in file.progressionEnabled )
+		return file.progressionEnabled[player]
+	
+	return false
+	#else // CLIENT || UI
+	return GetConVarBool( "ns_progression_enabled" )
+	#endif
+}
+
+#if SERVER
+void function OnPlaying()
+{
+	SetUIVar( level, "penalizeDisconnect", false ) // dont show the "you will lose merits thing"
+}
+
+void function OnClientDisconnected( entity player )
+{
+	// cleanup table when player leaves
+	if ( player in file.progressionEnabled )
+		delete file.progressionEnabled[player]
+}
+
+bool function ClientCommand_SetProgression( entity player, array<string> args )
+{
+	if ( args.len() != 1 )
+		return false
+	if ( args[0] != "0" && args[0] != "1" )
+		return false
+	
+	file.progressionEnabled[player] <- args[0] == "1"
+
+	// loadout validation when progression is turned on
+	if ( file.progressionEnabled[player] )
+		ValidateEquippedItems( player )
+
+	return true
+}
+#endif
+
+#if CLIENT
+void function OnClientScriptInit( entity player )
+{
+	// unsure if this is needed, just being safe
+	if ( player != GetLocalClientPlayer() )
+		return
+
+	Progression_SetPreference( GetConVarBool( "ns_progression_enabled" ) )
+	UpdateCachedLoadouts_Delayed()
+}
+#endif
+
+#if CLIENT || UI
+void function Progression_SetPreference( bool enabled )
+{
+	SetConVarBool( "ns_progression_enabled", enabled )
+
+	#if CLIENT
+	GetLocalClientPlayer().ClientCommand( "ns_progression " + enabled.tointeger() )
+	#else // UI
+	ClientCommand( "ns_progression " + enabled.tointeger() )
+	#endif
+}
+
+bool function Progression_GetPreference()
+{
+	return GetConVarBool( "ns_progression_enabled" )
+}
+
+void function UpdateCachedLoadouts_Delayed()
+{
+	if ( file.isUpdatingCachedLoadouts )
+		return
+
+	file.isUpdatingCachedLoadouts = true
+
+	#if UI
+	RunClientScript( "UpdateCachedLoadouts_Delayed" ) // keep client and UI synced
+	#else // CLIENT
+	RunUIScript( "UpdateCachedLoadouts_Delayed" ) // keep client and UI synced
+	#endif
+
+	thread UpdateCachedLoadouts_Threaded()
+}
+
+void function UpdateCachedLoadouts_Threaded()
+{
+	wait 1.0 // give the server time to network our new persistence
+
+	UpdateCachedLoadouts()
+
+	// below here is just making all the menu models update properly and such
+
+	#if UI
+	uiGlobal.pilotSpawnLoadoutIndex = GetPersistentSpawnLoadoutIndex( GetUIPlayer(), "pilot" )
+	uiGlobal.titanSpawnLoadoutIndex = GetPersistentSpawnLoadoutIndex( GetUIPlayer(), "titan" )
+	#endif
+
+	#if CLIENT
+	entity player = GetLocalClientPlayer()
+	ClearAllTitanPreview( player )
+	ClearAllPilotPreview( player )
+	UpdateTitanModel( player, GetPersistentSpawnLoadoutIndex( player, "titan" ) )
+	UpdatePilotModel( player, GetPersistentSpawnLoadoutIndex( player, "pilot" ) )
+	#endif
+
+	file.isUpdatingCachedLoadouts = false
+}
+#endif
+
+#if SERVER
+void function ValidateEquippedItems( entity player )
+{
+	printt( "VALIDATING EQUIPPED ITEMS FOR PLAYER: " + player.GetPlayerName() )
+
+	// banner
+	CallingCard card = PlayerCallingCard_GetActive( player )
+	if ( IsItemLocked( player, card.ref ) )
+	{
+		printt( "- BANNER CARD IS LOCKED, RESETTING" )
+		PlayerCallingCard_SetActiveByRef( player, "callsign_16_col" ) // copied from _persistentdata.gnut
+	}
+
+	// patch
+	CallsignIcon icon = PlayerCallsignIcon_GetActive( player )
+	if ( IsItemLocked( player, icon.ref ) )
+	{
+		printt( "- BANNER PATCH IS LOCKED, RESETTING" )
+		PlayerCallsignIcon_SetActiveByRef( player, "gc_icon_titanfall" ) // copied from _persistentdata.gnut
+	}
+
+	// faction
+	int factionIndex = player.GetPersistentVarAsInt( "factionChoice" )
+	string factionRef = PersistenceGetEnumItemNameForIndex( "faction", factionIndex )
+	if ( IsItemLocked( player, factionRef ) )
+	{
+		printt( "- FACTION IS LOCKED, RESETTING" )
+		player.SetPersistentVar( "factionChoice", "faction_marauder" ) // im so sorry that i am setting you to use sarah, you don't deserve this
+	}
+	
+	// boost
+	BurnReward reward = BurnReward_GetById( player.GetPersistentVarAsInt( "burnmeterSlot" ) )
+	if ( IsItemLocked( player, reward.ref ) )
+	{
+		printt( "- BOOST IS LOCKED, RESETTING" )
+		player.SetPersistentVar( "burnmeterSlot", BurnReward_GetByRef( "burnmeter_amped_weapons" ).id )
+	}
+
+	// titan loadouts
+	for ( int titanLoadoutIndex = 0; titanLoadoutIndex < NUM_PERSISTENT_TITAN_LOADOUTS; titanLoadoutIndex++ )
+	{
+		printt( "- VALIDATING TITAN LOADOUT: " + titanLoadoutIndex )
+
+		bool isSelected = titanLoadoutIndex == player.GetPersistentVarAsInt( "titanSpawnLoadout.index" )
+		TitanLoadoutDef loadout = GetTitanLoadout( player, titanLoadoutIndex )
+		TitanLoadoutDef defaultLoadout = shGlobal.defaultTitanLoadouts[titanLoadoutIndex]
+
+		printt( "  - CHASSIS: " + loadout.titanClass )
+
+		// passive1 - "Titan Kit" (things like overcore)
+		if ( loadout.passive1 != defaultLoadout.passive1 && IsSubItemLocked( player, loadout.passive1, loadout.titanClass ) )
+		{
+			printt( "  - TITAN KIT EQUIPPED WHEN LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].passive1", defaultLoadout.passive1 )
+		}
+
+		// passive2 - "<chassis> Kit" (things like zero point tripwire)
+		if ( loadout.passive2 != defaultLoadout.passive2 && IsSubItemLocked( player, loadout.passive2, loadout.titanClass ) )
+		{
+			printt( "  - CHASSIS KIT EQUIPPED WHEN LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].passive2", defaultLoadout.passive2 )
+		}
+
+		// passive3 - "Titanfall Kit" (warpfall/dome shield)
+		if ( loadout.passive3 != defaultLoadout.passive3 && IsSubItemLocked( player, loadout.passive3, loadout.titanClass ) )
+		{
+			printt( "  - TITANFALL KIT EQUIPPED WHEN LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].passive3", defaultLoadout.passive3 )
+		}
+
+		// passive4 - monarch core 1
+		if ( loadout.passive4 != defaultLoadout.passive4 && IsSubItemLocked( player, loadout.passive4, loadout.titanClass ) )
+		{
+			printt( "  - MONARCH CORE 1 KIT EQUIPPED WHEN LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].passive4", defaultLoadout.passive4 )
+		}
+
+		// passive5 - monarch core 2
+		if ( loadout.passive5 != defaultLoadout.passive5 && IsSubItemLocked( player, loadout.passive5, loadout.titanClass ) )
+		{
+			printt( "  - MONARCH CORE 2 KIT EQUIPPED WHEN LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].passive5", defaultLoadout.passive5 )
+		}
+
+		// passive6 - monarch core 3
+		if ( loadout.passive6 != defaultLoadout.passive6 && IsSubItemLocked( player, loadout.passive6, loadout.titanClass ) )
+		{
+			printt( "  - MONARCH CORE 3 KIT EQUIPPED WHEN LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].passive6", defaultLoadout.passive6 )
+		}
+
+		// titanExecution
+		if ( !IsRefValid( loadout.titanExecution ) || !IsValidTitanExecution( titanLoadoutIndex, "titanExecution", "", loadout.titanExecution ) )
+		{
+			printt( "  - TITAN EXECUTION IS INVALID FOR CHASSIS, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].titanExecution", defaultLoadout.titanExecution )
+		}
+		else if ( IsItemLocked( player, loadout.titanExecution ) )
+		{
+			printt( "  - TITAN EXECUTION EQUIPPED WHEN LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].titanExecution", defaultLoadout.titanExecution )
+		}
+		else if ( GetItemData( loadout.titanExecution ).reqPrime && IsItemLocked( player, loadout.primeTitanRef ) )
+		{
+			printt( "  - PRIME TITAN EXECUTION EQUIPPED WHEN PRIME TITAN IS LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].titanExecution", defaultLoadout.titanExecution )
+		}
+
+		// skinIndex
+		// camoIndex
+		if ( loadout.skinIndex == TITAN_SKIN_INDEX_CAMO )
+		{
+			array<ItemData> camoSkins = GetAllItemsOfType( eItemTypes.CAMO_SKIN )
+			if ( loadout.camoIndex >= camoSkins.len() || loadout.camoIndex < 0 )
+			{
+				printt( "  - INVALID TITAN CAMO/SKIN, RESETTING" )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].skinIndex", defaultLoadout.skinIndex )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].camoIndex", defaultLoadout.camoIndex )
+			}
+			else
+			{
+				ItemData camoSkin = camoSkins[loadout.camoIndex]
+				if ( IsSubItemLocked( player, camoSkin.ref, loadout.titanClass ) )
+				{
+					printt( "  - TITAN CAMO/SKIN EQUIPPED WHEN LOCKED, RESETTING" )
+					player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].skinIndex", defaultLoadout.skinIndex )
+					player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].camoIndex", defaultLoadout.camoIndex )
+				}
+			}
+		}
+		else if ( loadout.skinIndex == 0 )
+		{
+			if ( loadout.camoIndex != 0 )
+			{
+				printt( "  - INVALID TITAN CAMO/SKIN, RESETTING" )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].skinIndex", defaultLoadout.skinIndex )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].camoIndex", defaultLoadout.camoIndex )
+			}
+		}
+		else
+		{
+			string ref = GetSkinRefFromTitanClassAndPersistenceValue( loadout.titanClass, loadout.skinIndex )
+			if ( ref == INVALID_REF )
+			{
+				printt( "  - INVALID TITAN WARPAINT, RESETTING" )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].skinIndex", defaultLoadout.skinIndex )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].camoIndex", defaultLoadout.camoIndex )
+			}
+			else if ( IsSubItemLocked( player, ref, loadout.titanClass ) )
+			{
+				printt( "  - TITAN WARPAINT EQUIPPED WHEN LOCKED, RESETTING" )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].skinIndex", defaultLoadout.skinIndex )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].camoIndex", defaultLoadout.camoIndex )
+			}
+		}
+
+		// decalIndex
+		string noseArtRef = GetNoseArtRefFromTitanClassAndPersistenceValue( loadout.titanClass, loadout.decalIndex )
+		if ( loadout.decalIndex != defaultLoadout.decalIndex && IsSubItemLocked( player, noseArtRef, loadout.titanClass ) )
+		{
+			printt( "  - NOSE ART EQUIPPED WHEN LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].decalIndex", defaultLoadout.decalIndex )
+		}
+
+		// primarySkinIndex
+		// primaryCamoIndex
+		if ( loadout.primarySkinIndex == WEAPON_SKIN_INDEX_CAMO )
+		{
+			array<ItemData> camoSkins = GetAllItemsOfType( eItemTypes.CAMO_SKIN )
+			if ( loadout.primaryCamoIndex >= camoSkins.len() || loadout.primaryCamoIndex < 0 )
+			{
+				printt( "  - INVALID WEAPON CAMO/SKIN, RESETTING" )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primarySkinIndex", defaultLoadout.primarySkinIndex )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primaryCamoIndex", defaultLoadout.primaryCamoIndex )
+			}
+			else
+			{
+				ItemData camoSkin = camoSkins[loadout.primaryCamoIndex]
+				if ( IsSubItemLocked( player, camoSkin.ref, loadout.titanClass ) )
+				{
+					printt( "  - WEAPON CAMO/SKIN EQUIPPED WHEN LOCKED, RESETTING" )
+					player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primarySkinIndex", defaultLoadout.primarySkinIndex )
+					player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primaryCamoIndex", defaultLoadout.primaryCamoIndex )
+				}
+			}
+		}
+		else if ( loadout.primarySkinIndex == 0 && loadout.primaryCamoIndex != 0 )
+		{
+			// titan weapons do not have skins, if we ever do add them lots of stuff will 
+			//need a refactor outside of here so with that being said, i cannot be bothered
+			printt( "  - INVALID WEAPON CAMO/SKIN, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primarySkinIndex", defaultLoadout.primarySkinIndex )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primaryCamoIndex", defaultLoadout.primaryCamoIndex )
+		}
+		
+
+		// isPrime
+		if ( loadout.isPrime == "titan_is_prime" && IsItemLocked( player, loadout.primeTitanRef ) )
+		{
+			printt( "  - PRIME TITAN EQUIPPED WHEN LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].isPrime", defaultLoadout.isPrime )
+		}
+
+		// primeSkinIndex
+		// primeCamoIndex
+		if ( loadout.primeSkinIndex == TITAN_SKIN_INDEX_CAMO )
+		{
+			array<ItemData> camoSkins = GetAllItemsOfType( eItemTypes.CAMO_SKIN )
+			if ( loadout.primeCamoIndex >= camoSkins.len() || loadout.primeCamoIndex < 0 )
+			{
+				printt( "  - INVALID TITAN CAMO/SKIN, RESETTING" )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primeSkinIndex", defaultLoadout.primeSkinIndex )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primeCamoIndex", defaultLoadout.primeCamoIndex )
+			}
+			else
+			{
+				ItemData camoSkin = camoSkins[loadout.primeCamoIndex]
+				if ( IsSubItemLocked( player, camoSkin.ref, loadout.titanClass ) )
+				{
+					printt( "  - TITAN CAMO/SKIN EQUIPPED WHEN LOCKED, RESETTING" )
+					player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primeSkinIndex", defaultLoadout.primeSkinIndex )
+					player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primeCamoIndex", defaultLoadout.primeCamoIndex )
+				}
+			}
+		}
+		else if ( loadout.primeSkinIndex == 0 )
+		{
+			if ( loadout.primeCamoIndex != 0 )
+			{
+				printt( "  - INVALID TITAN CAMO/SKIN, RESETTING" )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primeSkinIndex", defaultLoadout.primeSkinIndex )
+				player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primeCamoIndex", defaultLoadout.primeCamoIndex )
+			}
+		}
+		else
+		{
+			printt( "  - INVALID PRIME TITAN SKIN, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primeSkinIndex", defaultLoadout.primeSkinIndex )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primeCamoIndex", defaultLoadout.primeCamoIndex )
+		}
+
+		// primeDecalIndex
+		string primeNoseArtRef = GetNoseArtRefFromTitanClassAndPersistenceValue( loadout.titanClass, loadout.primeDecalIndex )
+		if ( loadout.primeDecalIndex != defaultLoadout.primeDecalIndex && IsSubItemLocked( player, primeNoseArtRef, loadout.titanClass ) )
+		{
+			printt( "  - PRIME NOSE ART EQUIPPED WHEN LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].primeDecalIndex", defaultLoadout.primeDecalIndex )
+		}
+
+		// showArmBadge - equipped and shouldnt be able to
+		if ( loadout.showArmBadge && !CanEquipArmBadge( player, loadout.titanClass ) )
+		{
+			printt( "  - ARM BADGE EQUIPPED WHEN LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanLoadouts[" + titanLoadoutIndex + "].showArmBadge", defaultLoadout.showArmBadge )
+		}
+
+		// equipped titan loadout - equipped titan class is locked
+		if ( isSelected && IsItemLocked( player, loadout.titanClass ) )
+		{
+			printt( "  - SELECTED TITAN CLASS IS LOCKED, RESETTING" )
+			player.SetPersistentVar( "titanSpawnLoadout.index", 0 )
+			Remote_CallFunction_NonReplay( player, "ServerCallback_UpdateTitanModel", 0 )
+		}
+	}
+
+	Remote_CallFunction_NonReplay( player, "ServerCallback_UpdateTitanModel", player.GetPersistentVarAsInt( "titanSpawnLoadout.index" ) )
+
+	// pilot loadouts
+	for ( int pilotLoadoutIndex = 0; pilotLoadoutIndex < NUM_PERSISTENT_PILOT_LOADOUTS; pilotLoadoutIndex++ )
+	{
+		printt( "- VALIDATING PILOT LOADOUT: " + pilotLoadoutIndex )
+
+		bool isSelected = pilotLoadoutIndex == player.GetPersistentVarAsInt( "pilotSpawnLoadout.index" )
+		PilotLoadoutDef loadout = GetPilotLoadout( player, pilotLoadoutIndex )
+		PilotLoadoutDef defaultLoadout = shGlobal.defaultPilotLoadouts[pilotLoadoutIndex]
+
+		// note: for readability, I have added {} around the different items,
+		// so that you can collapse them in visual studio code (and other good IDEs)
+
+		// tactical
+		{
+			if ( !IsRefValid( loadout.suit ) )
+			{
+				printt( "  - TACTICAL IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].suit", defaultLoadout.suit )
+			}
+			else if ( IsItemLocked( player, loadout.suit ) )
+			{
+				printt( "  - TACTICAL IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].suit", defaultLoadout.suit )
+			}
+		}
+		
+		// ordnance
+		{
+			if ( !IsRefValid( loadout.ordnance ) )
+			{
+				printt( "  - ORDNANCE IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].ordnance", defaultLoadout.ordnance )
+			}
+			else if ( IsItemLocked( player, loadout.ordnance ) )
+			{
+				printt( "  - ORDNANCE IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].ordnance", defaultLoadout.ordnance )
+			}
+		}
+
+		// race ( gender )
+		{
+			if ( !IsRefValid( loadout.race ) )
+			{
+				printt( "  - GENDER IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].race", defaultLoadout.race )
+			}
+			else if ( IsItemLocked( player, loadout.race ) )
+			{
+				printt( "  - GENDER IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].race", defaultLoadout.race )
+			}
+		}
+
+		// camoIndex
+		// skinIndex
+		{
+			if ( loadout.skinIndex == PILOT_SKIN_INDEX_CAMO )
+			{
+				array<ItemData> camoSkins = GetAllItemsOfType( eItemTypes.CAMO_SKIN_PILOT )
+				if ( loadout.camoIndex >= camoSkins.len() || loadout.camoIndex < 0 )
+				{
+					printt( "  - INVALID PILOT CAMO/SKIN, RESETTING" )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].skinIndex", defaultLoadout.skinIndex )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].camoIndex", defaultLoadout.camoIndex )
+				}
+				else
+				{
+					ItemData camoSkin = camoSkins[loadout.camoIndex]
+					if ( IsItemLocked( player, camoSkin.ref ) )
+					{
+						printt( "  - PILOT CAMO/SKIN EQUIPPED WHEN LOCKED, RESETTING" )
+						player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].skinIndex", defaultLoadout.skinIndex )
+						player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].camoIndex", defaultLoadout.camoIndex )
+					}
+				}
+			}
+			else if ( loadout.skinIndex == 0 )
+			{
+				if ( loadout.camoIndex != 0 )
+				{
+					printt( "  - INVALID PILOT CAMO/SKIN, RESETTING" )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].skinIndex", defaultLoadout.skinIndex )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].camoIndex", defaultLoadout.camoIndex )
+				}
+			}
+			else
+			{
+				// pilots can't have skins other than 0 and 1 right?
+				printt( "  - INVALID PILOT SKIN, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].skinIndex", defaultLoadout.skinIndex )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].camoIndex", defaultLoadout.camoIndex )
+			}
+		}
+
+		// primary weapon
+		{
+			if ( !IsRefValid( loadout.primary ) || GetItemType( loadout.primary ) != eItemTypes.PILOT_PRIMARY )
+			{
+				printt( "  - PRIMARY WEAPON IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primary", defaultLoadout.primary )
+			}
+			else if ( IsItemLocked( player, loadout.primary ) )
+			{
+				printt( "  - PRIMARY WEAPON IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primary", defaultLoadout.primary )
+			}
+		}
+
+		// primary weapon mods
+		{
+			// mod1
+			if ( loadout.primaryMod1 == "" )
+			{
+				// do nothing
+			}
+			else if ( !HasSubitem( loadout.primary, loadout.primaryMod1 ) )
+			{
+				printt( "  - PRIMARY WEAPON MOD 1 IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryMod1", defaultLoadout.primaryMod1 )
+			}
+			else if ( IsSubItemLocked( player, loadout.primaryMod1, loadout.primary ) )
+			{
+				printt( "  - PRIMARY WEAPON MOD 1 IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryMod1", defaultLoadout.primaryMod1 )
+			}
+			// mod2
+			if ( loadout.primaryMod2 == "" )
+			{
+				// do nothing
+			}
+			else if ( IsSubItemLocked( player, "primarymod2", loadout.primary ) )
+			{
+				printt( "  - PRIMARY WEAPON MOD 2 SLOT IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryMod2", defaultLoadout.primaryMod2 )
+			}
+			else if ( !HasSubitem( loadout.primary, loadout.primaryMod2 ) )
+			{
+				printt( "  - PRIMARY WEAPON MOD 2 IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryMod2", defaultLoadout.primaryMod2 )
+			}
+			else if ( IsSubItemLocked( player, loadout.primaryMod2, loadout.primary ) )
+			{
+				printt( "  - PRIMARY WEAPON MOD 2 IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryMod2", defaultLoadout.primaryMod2 )
+			}
+			else if ( loadout.primaryMod2 == loadout.primaryMod1 && loadout.primaryMod2 != "" )
+			{
+				printt( "  - PRIMARY WEAPON MOD 2 IS DUPLICATE, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryMod2", defaultLoadout.primaryMod2 )
+			}
+			else if ( loadout.primaryAttachment == "threat_scope" )
+			{
+				printt( "  - PRIMARY WEAPON MOD 2 IS SET WITH THREAT SCOPE, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryMod2", defaultLoadout.primaryMod2 )
+			}
+			// attachment
+			if ( loadout.primaryAttachment == "" )
+			{
+				// do nothing
+			}
+			else if ( !HasSubitem( loadout.primary, loadout.primaryAttachment ) )
+			{
+				printt( "  - PRIMARY WEAPON ATTACHMENT IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryAttachment", defaultLoadout.primaryAttachment )
+			}
+			else if ( IsSubItemLocked( player, loadout.primaryAttachment, loadout.primary ) )
+			{
+				printt( "  - PRIMARY WEAPON ATTACHMENT IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryAttachment", defaultLoadout.primaryAttachment )
+			}
+			// mod3 (pro screen)
+			if ( loadout.primaryMod3 == "" )
+			{
+				// do nothing
+			}
+			else if ( loadout.primaryMod3 == "pro_screen" )
+			{
+				// fuck you and your three mod slot stuff
+				printt( "  - PRIMARY WEAPON PRO SCREEN IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryMod3", defaultLoadout.primaryMod3 )
+			}
+			else if ( IsSubItemLocked( player, loadout.primaryMod3, loadout.primary ) )
+			{
+				printt( "  - PRIMARY WEAPON PRO SCREEN IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryMod3", defaultLoadout.primaryMod3 )
+			}
+		}
+
+		// primary weapon camoIndex
+		// primary weapon skinIndex
+		{
+			if ( loadout.primarySkinIndex == WEAPON_SKIN_INDEX_CAMO )
+			{
+				array<ItemData> camoSkins = GetAllItemsOfType( eItemTypes.CAMO_SKIN )
+				if ( loadout.primaryCamoIndex >= camoSkins.len() || loadout.primaryCamoIndex < 0 )
+				{
+					printt( "  - INVALID PRIMARY WEAPON CAMO/SKIN, RESETTING" )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primarySkinIndex", defaultLoadout.primarySkinIndex )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryCamoIndex", defaultLoadout.primaryCamoIndex )
+				}
+				else
+				{
+					ItemData camoSkin = camoSkins[loadout.primaryCamoIndex]
+					if ( IsSubItemLocked( player, camoSkin.ref, loadout.primary ) )
+					{
+						printt( "  - PRIMARY WEAPON CAMO/SKIN EQUIPPED WHEN LOCKED, RESETTING" )
+						player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primarySkinIndex", defaultLoadout.primarySkinIndex )
+						player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryCamoIndex", defaultLoadout.primaryCamoIndex )
+					}
+				}
+			}
+			else if ( loadout.primarySkinIndex == 0 )
+			{
+				if ( loadout.primaryCamoIndex != 0 )
+				{
+					printt( "  - INVALID PRIMARY WEAPON CAMO/SKIN, RESETTING" )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primarySkinIndex", defaultLoadout.primarySkinIndex )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryCamoIndex", defaultLoadout.primaryCamoIndex )
+				}
+			}
+			else if ( IsSubItemLocked( player, GetWeaponWarpaintRefByIndex( loadout.primarySkinIndex, loadout.primary ), loadout.primary ) )
+			{
+				printt( "  - PRIMARY WEAPON SKIN LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primarySkinIndex", defaultLoadout.primarySkinIndex )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].primaryCamoIndex", defaultLoadout.primaryCamoIndex )
+			}
+		}
+
+		// secondary weapon
+		{
+			if ( !IsRefValid( loadout.secondary ) || GetItemType( loadout.secondary ) != eItemTypes.PILOT_SECONDARY )
+			{
+				printt( "  - SECONDARY WEAPON IS LOCKED, RESETTING" )
+				string ref = defaultLoadout.secondary
+				if ( loadout.secondary == ref ) // item dupes swap
+				{
+					ref = defaultLoadout.weapon3
+				}
+				else if ( ItemsInSameMenuCategory( loadout.secondary, ref ) ) // category dupes assign value to other slot and swap
+				{
+					ref = defaultLoadout.weapon3
+				}
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondary", ref )
+			}
+			else if ( IsItemLocked( player, loadout.secondary ) )
+			{
+				printt( "  - SECONDARY WEAPON IS LOCKED, RESETTING" )
+				string ref = defaultLoadout.secondary
+				if ( loadout.weapon3 == ref ) // item dupes swap
+				{
+					ref = defaultLoadout.weapon3
+				}
+				else if ( ItemsInSameMenuCategory( loadout.weapon3, ref ) ) // category dupes assign value to other slot and swap
+				{
+					ref = defaultLoadout.weapon3
+				}
+
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondary", ref )
+			}
+		}
+
+		// secondary weapon mods
+		{
+			// mod1
+			if ( loadout.secondaryMod1 == "" )
+			{
+				// do nothing
+			}
+			else if ( !HasSubitem( loadout.secondary, loadout.secondaryMod1 ) )
+			{
+				printt( "  - SECONDARY WEAPON MOD 1 IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondaryMod1", defaultLoadout.secondaryMod1 )
+			}
+			else if ( IsSubItemLocked( player, loadout.secondaryMod1, loadout.secondary ) )
+			{
+				printt( "  - SECONDARY WEAPON MOD 1 IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondaryMod1", defaultLoadout.secondaryMod1 )
+			}
+			// mod2
+			if ( loadout.secondaryMod2 == "" )
+			{
+				// do nothing
+			}
+			else if ( IsSubItemLocked( player, "secondarymod2", loadout.secondary ) )
+			{
+				printt( "  - SECONDARY WEAPON MOD 2 SLOT IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondaryMod2", defaultLoadout.secondaryMod2 )
+			}
+			else if ( !HasSubitem( loadout.secondary, loadout.secondaryMod2 ) )
+			{
+				printt( "  - SECONDARY WEAPON MOD 2 IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondaryMod2", defaultLoadout.secondaryMod2 )
+			}
+			else if ( IsSubItemLocked( player, loadout.secondaryMod2, loadout.secondary ) )
+			{
+				printt( "  - SECONDARY WEAPON MOD 2 IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondaryMod2", defaultLoadout.secondaryMod2 )
+			}
+			else if ( loadout.secondaryMod2 == loadout.secondaryMod1 && loadout.secondaryMod2 != "" )
+			{
+				printt( "  - SECONDARY WEAPON MOD 2 IS DUPLICATE, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondaryMod2", defaultLoadout.secondaryMod2 )
+			}
+			// mod3 (pro screen)
+			if ( loadout.secondaryMod3 == "" )
+			{
+				// do nothing
+			}
+			else if ( loadout.secondaryMod3 == "pro_screen" )
+			{
+				// fuck you and your three mod slot stuff
+				printt( "  - SECONDARY WEAPON PRO SCREEN IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondaryMod3", defaultLoadout.secondaryMod3 )
+			}
+			else if ( IsSubItemLocked( player, "secondarymod3", loadout.secondary ) )
+			{
+				printt( "  - SECONDARY WEAPON PRO SCREEN IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondaryMod3", defaultLoadout.secondaryMod3 )
+			}
+		}
+
+		// secondary weapon camoIndex
+		// secondary weapon skinIndex
+		{
+			if ( loadout.secondarySkinIndex == WEAPON_SKIN_INDEX_CAMO )
+			{
+				array<ItemData> camoSkins = GetAllItemsOfType( eItemTypes.CAMO_SKIN )
+				if ( loadout.secondaryCamoIndex >= camoSkins.len() || loadout.secondaryCamoIndex < 0 )
+				{
+					printt( "  - INVALID SECONDARY WEAPON CAMO/SKIN, RESETTING" )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondarySkinIndex", defaultLoadout.secondarySkinIndex )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondaryCamoIndex", defaultLoadout.secondaryCamoIndex )
+				}
+				else
+				{
+					ItemData camoSkin = camoSkins[loadout.secondaryCamoIndex]
+					if ( IsSubItemLocked( player, camoSkin.ref, loadout.secondary ) )
+					{
+						printt( "  - SECONDARY WEAPON CAMO/SKIN EQUIPPED WHEN LOCKED, RESETTING" )
+						player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondarySkinIndex", defaultLoadout.secondarySkinIndex )
+						player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondaryCamoIndex", defaultLoadout.secondaryCamoIndex )
+					}
+				}
+			}
+			else if ( loadout.secondarySkinIndex == 0 )
+			{
+				if ( loadout.secondaryCamoIndex != 0 )
+				{
+					printt( "  - INVALID SECONDARY WEAPON CAMO/SKIN, RESETTING" )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondarySkinIndex", defaultLoadout.secondarySkinIndex )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondaryCamoIndex", defaultLoadout.secondaryCamoIndex )
+				}
+			}
+			else if ( IsSubItemLocked( player, GetWeaponWarpaintRefByIndex( loadout.secondarySkinIndex, loadout.secondary ), loadout.secondary ) )
+			{
+				printt( "  - SECONDARY WEAPON SKIN LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondarySkinIndex", defaultLoadout.secondarySkinIndex )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].secondaryCamoIndex", defaultLoadout.secondaryCamoIndex )
+			}
+		}
+
+		// weapon3
+		// note: these are always eItemTypes.PILOT_SECONDARY
+		{
+			if ( !IsRefValid( loadout.weapon3 ) || GetItemType( loadout.weapon3 ) != eItemTypes.PILOT_SECONDARY )
+			{
+				printt( "  - WEAPON3 WEAPON IS LOCKED, RESETTING" )
+				string ref = defaultLoadout.weapon3
+				if ( loadout.weapon3 == ref ) // item dupes swap
+				{
+					ref = defaultLoadout.secondary
+				}
+				else if ( ItemsInSameMenuCategory( loadout.weapon3, ref ) ) // category dupes assign value to other slot and swap
+				{
+					ref = defaultLoadout.secondary
+				}
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3", ref )
+			}
+			else if ( IsItemLocked( player, loadout.weapon3 ) )
+			{
+				printt( "  - TERTIARY WEAPON IS LOCKED, RESETTING" )
+				string ref = defaultLoadout.weapon3
+				if ( loadout.secondary == ref ) // item dupes swap
+				{
+					ref = defaultLoadout.secondary
+				}
+				else if ( ItemsInSameMenuCategory( loadout.secondary, ref ) ) // category dupes assign value to other slot and swap
+				{
+					ref = defaultLoadout.secondary
+				}
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3", ref )
+			}
+		}
+
+		// weapon3 mods
+		{
+			// mod1
+			if ( loadout.weapon3Mod1 == "" )
+			{
+				// do nothing
+			}
+			else if ( !HasSubitem( loadout.weapon3, loadout.weapon3Mod1 ) )
+			{
+				printt( "  - WEAPON3 MOD 1 IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3Mod1", defaultLoadout.weapon3Mod1 )
+			}
+			else if ( IsSubItemLocked( player, loadout.weapon3Mod1, loadout.weapon3 ) )
+			{
+				printt( "  - WEAPON3 MOD 1 IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3Mod1", defaultLoadout.weapon3Mod1 )
+			}
+			// mod2
+			if ( loadout.weapon3Mod2 == "" )
+			{
+				// do nothing
+			}
+			else if ( IsSubItemLocked( player, "secondarymod2", loadout.weapon3 ) )
+			{
+				printt( "  - WEAPON3 MOD 2 SLOT IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3Mod2", defaultLoadout.weapon3Mod2 )
+			}
+			else if ( !HasSubitem( loadout.weapon3, loadout.weapon3Mod2 ) )
+			{
+				printt( "  - WEAPON3 MOD 2 IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3Mod2", defaultLoadout.weapon3Mod2 )
+			}
+			else if ( IsSubItemLocked( player, loadout.weapon3Mod2, loadout.weapon3 ) )
+			{
+				printt( "  - WEAPON3 MOD 2 IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3Mod2", defaultLoadout.weapon3Mod2 )
+			}
+			else if ( loadout.weapon3Mod2 == loadout.weapon3Mod1 && loadout.weapon3Mod2 != "" )
+			{
+				printt( "  - WEAPON3 MOD 2 IS DUPLICATE, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3Mod2", defaultLoadout.weapon3Mod2 )
+			}
+			// mod3 (pro screen)
+			if ( loadout.weapon3Mod3 == "" )
+			{
+				// do nothing
+			}
+			else if ( loadout.weapon3Mod3 != "pro_screen" )
+			{
+				// fuck you and your three mod slot stuff
+				printt( "  - WEAPON3 PRO SCREEN IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3Mod3", defaultLoadout.weapon3Mod3 )
+			}
+			else if ( IsSubItemLocked( player, "secondarymod3", loadout.weapon3 ) )
+			{
+				printt( "  - WEAPON3 PRO SCREEN IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3Mod3", defaultLoadout.weapon3Mod3 )
+			}
+		}
+
+		// weapon3 camoIndex
+		// weapon3 skinIndex
+		{
+			if ( loadout.weapon3SkinIndex == WEAPON_SKIN_INDEX_CAMO )
+			{
+				array<ItemData> camoSkins = GetAllItemsOfType( eItemTypes.CAMO_SKIN )
+				if ( loadout.weapon3CamoIndex >= camoSkins.len() || loadout.weapon3CamoIndex < 0 )
+				{
+					printt( "  - INVALID TERTIARY WEAPON CAMO/SKIN, RESETTING" )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3SkinIndex", defaultLoadout.weapon3SkinIndex )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3CamoIndex", defaultLoadout.weapon3CamoIndex )
+				}
+				else
+				{
+					ItemData camoSkin = camoSkins[loadout.weapon3CamoIndex]
+					if ( IsSubItemLocked( player, camoSkin.ref, loadout.weapon3 ) )
+					{
+						printt( "  - TERTIARY WEAPON CAMO/SKIN EQUIPPED WHEN LOCKED, RESETTING" )
+						player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3SkinIndex", defaultLoadout.weapon3SkinIndex )
+						player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3CamoIndex", defaultLoadout.weapon3CamoIndex )
+					}
+				}
+			}
+			else if ( loadout.weapon3SkinIndex == 0 )
+			{
+				if ( loadout.weapon3CamoIndex != 0 )
+				{
+					printt( "  - INVALID TERTIARY WEAPON CAMO/SKIN, RESETTING" )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3SkinIndex", defaultLoadout.weapon3SkinIndex )
+					player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3CamoIndex", defaultLoadout.weapon3CamoIndex )
+				}
+			}
+			else if ( IsSubItemLocked( player, GetWeaponWarpaintRefByIndex( loadout.weapon3SkinIndex, loadout.weapon3 ), loadout.weapon3 ) )
+			{
+				printt( "  - TERTIARY WEAPON SKIN LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3SkinIndex", defaultLoadout.weapon3SkinIndex )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].weapon3CamoIndex", defaultLoadout.weapon3CamoIndex )
+			}
+		}
+
+		// kit 1
+		{
+			if ( !IsRefValid( loadout.passive1 ) || GetItemType( loadout.passive1 ) != eItemTypes.PILOT_PASSIVE1 )
+			{
+				printt( "  - KIT 1 IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].passive1", defaultLoadout.passive1 )
+			}
+			else if ( IsItemLocked( player, loadout.passive1 ) )
+			{
+				printt( "  - KIT 1 IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].passive1", defaultLoadout.passive1 )
+			}
+		}
+
+		// kit 2
+		{
+			if ( !IsRefValid( loadout.passive2 ) || GetItemType( loadout.passive2 ) != eItemTypes.PILOT_PASSIVE2 )
+			{
+				printt( "  - KIT 2 IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].passive2", defaultLoadout.passive2 )
+			}
+			else if ( IsItemLocked( player, loadout.passive2 ) )
+			{
+				printt( "  - KIT 2 IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].passive2", defaultLoadout.passive2 )
+			}
+		}
+
+		// execution
+		// note: not sure why defaultLoadout has this set to "", but neck snap should be default
+		{
+			if ( !IsRefValid( loadout.execution ) || GetItemType( loadout.execution ) != eItemTypes.PILOT_EXECUTION )
+			{
+				printt( "  - EXECUTION IS INVALID, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].execution", "execution_neck_snap" )
+			}
+			else if ( IsItemLocked( player, loadout.execution ) )
+			{
+				printt( "  - EXECUTION IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotLoadouts[" + pilotLoadoutIndex + "].execution", "execution_neck_snap" )
+			}
+		}
+		
+		// equipped pilot loadout
+		{
+			if ( isSelected && IsItemLocked( player, "pilot_loadout_" + ( pilotLoadoutIndex + 1 ) ) )
+			{
+				printt( "  - SELECTED PILOT LOADOUT IS LOCKED, RESETTING" )
+				player.SetPersistentVar( "pilotSpawnLoadout.index", 0 )
+				Remote_CallFunction_NonReplay( player, "ServerCallback_UpdatePilotModel", 0 )
+			}
+		}
+	}
+
+	Remote_CallFunction_NonReplay( player, "ServerCallback_UpdatePilotModel", player.GetPersistentVarAsInt( "pilotSpawnLoadout.index" ) )
+
+	printt( "ITEM VALIDATION COMPLETE FOR PLAYER: " + player.GetPlayerName() )
+}
+
+// basically just PopulateTitanLoadoutFromPersistentData but without validation, we are doing the validation in a better way
+// that doesnt just kick the player and reset the entire loadout, since we want to only reset parts of the loadout that we need
+TitanLoadoutDef function GetTitanLoadout( entity player, int loadoutIndex )
+{
+	TitanLoadoutDef loadout
+
+	loadout.name 				= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "name" )
+	loadout.titanClass			= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "titanClass" )
+	loadout.primaryMod			= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "primaryMod" )
+	loadout.special 			= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "special" )
+	loadout.antirodeo 			= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "antirodeo" )
+	loadout.passive1 			= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "passive1" )
+	loadout.passive2 			= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "passive2" )
+	loadout.passive3 			= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "passive3" )
+	loadout.passive4 			= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "passive4" )
+	loadout.passive5 			= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "passive5" )
+	loadout.passive6 			= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "passive6" )
+	loadout.camoIndex			= GetPersistentLoadoutValueInt( player, "titan", loadoutIndex, "camoIndex" )
+	loadout.skinIndex			= GetPersistentLoadoutValueInt( player, "titan", loadoutIndex, "skinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes
+	loadout.decalIndex			= GetPersistentLoadoutValueInt( player, "titan", loadoutIndex, "decalIndex" )
+	loadout.primaryCamoIndex	= GetPersistentLoadoutValueInt( player, "titan", loadoutIndex, "primaryCamoIndex" )
+	loadout.primarySkinIndex	= GetPersistentLoadoutValueInt( player, "titan", loadoutIndex, "primarySkinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes
+	loadout.titanExecution 		= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "titanExecution" )
+	loadout.showArmBadge		= GetPersistentLoadoutValueInt( player, "titan", loadoutIndex, "showArmBadge" )
+
+	//Prime Titan related vars
+	loadout.isPrime			= GetPersistentLoadoutValue( player, "titan", loadoutIndex, "isPrime" )
+	loadout.primeCamoIndex	= GetPersistentLoadoutValueInt( player, "titan", loadoutIndex, "primeCamoIndex" )
+	loadout.primeSkinIndex	= GetPersistentLoadoutValueInt( player, "titan", loadoutIndex, "primeSkinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes
+	loadout.primeDecalIndex	= GetPersistentLoadoutValueInt( player, "titan", loadoutIndex, "primeDecalIndex" )
+
+	UpdateDerivedTitanLoadoutData( loadout )
+	OverwriteLoadoutWithDefaultsForSetFile( loadout )
+
+	return loadout
+}
+
+// basically just PopulatePilotLoadoutFromPersistentData but without validation, we are doing the validation in a better way
+// that doesnt just kick the player and reset the entire loadout, since we want to only reset parts of the loadout that we need
+PilotLoadoutDef function GetPilotLoadout( entity player, int loadoutIndex )
+{
+	PilotLoadoutDef loadout
+
+	loadout.name 				= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "name" )
+	loadout.suit 				= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "suit" )
+	loadout.race 				= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "race" )
+	loadout.execution 			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "execution" )
+	loadout.primary 			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "primary" )
+	loadout.primaryAttachment	= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "primaryAttachment" )
+	loadout.primaryMod1			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "primaryMod1" )
+	loadout.primaryMod2			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "primaryMod2" )
+	loadout.primaryMod3			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "primaryMod3" )
+	loadout.secondary 			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "secondary" )
+	loadout.secondaryMod1		= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "secondaryMod1" )
+	loadout.secondaryMod2		= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "secondaryMod2" )
+	loadout.secondaryMod3		= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "secondaryMod3" )
+	loadout.weapon3 			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "weapon3" )
+	loadout.weapon3Mod1			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "weapon3Mod1" )
+	loadout.weapon3Mod2			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "weapon3Mod2" )
+	loadout.weapon3Mod3			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "weapon3Mod3" )
+	loadout.ordnance 			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "ordnance" )
+	loadout.passive1 			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "passive1" )
+	loadout.passive2 			= GetPersistentLoadoutValue( player, "pilot", loadoutIndex, "passive2" )
+	loadout.camoIndex			= GetPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "camoIndex" )
+	loadout.skinIndex			= GetPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "skinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes
+	loadout.primaryCamoIndex	= GetPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "primaryCamoIndex" )
+	loadout.primarySkinIndex	= GetPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "primarySkinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes
+	loadout.secondaryCamoIndex	= GetPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "secondaryCamoIndex" )
+	loadout.secondarySkinIndex	= GetPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "secondarySkinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes
+	loadout.weapon3CamoIndex	= GetPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "weapon3CamoIndex" )
+	loadout.weapon3SkinIndex	= GetPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "weapon3SkinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes
+
+	UpdateDerivedPilotLoadoutData( loadout )
+
+	return loadout
+}
+
+bool function CanEquipArmBadge( entity player, string titanClass )
+{
+	string skinRef
+	switch ( titanClass )
+	{
+		case "ion":
+			skinRef = "ion_skin_fd"
+			break
+		case "scorch":
+			skinRef = "scorch_skin_fd"
+			break
+		case "northstar":
+			skinRef = "northstar_skin_fd"
+			break
+		case "ronin":
+			skinRef = "ronin_skin_fd"
+			break
+		case "tone":
+			skinRef = "tone_skin_fd"
+			break
+		case "legion":
+			skinRef = "legion_skin_fd"
+			break
+		case "vanguard":
+			skinRef = "monarch_skin_fd"
+			break
+	}
+
+	return !IsSubItemLocked( player, skinRef, titanClass )
+}
+
+string function GetWeaponWarpaintRefByIndex( int skinIndex, string parentRef )
+{
+	ItemData parentItem = GetItemData( parentRef )
+	foreach ( subItem in parentItem.subitems )
+	{
+		if ( GetSubitemType( parentRef, subItem.ref ) != eItemTypes.WEAPON_SKIN )
+			continue
+		if ( subItem.i.skinIndex != skinIndex )
+			continue
+
+		return subItem.ref
+	}
+
+	return INVALID_REF
+}
+#endif
\ No newline at end of file