Progression system (#655)

This also can't hurt right?

---------

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

17 files changed, 2244 insertions, 45 deletions

diff --git a/Northstar.CustomServers/mod/scripts/vscripts/_items.nut b/Northstar.CustomServers/mod/scripts/vscripts/_items.nut
index 539b72bc..5878da13 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/_items.nut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/_items.nut
@@ -5698,7 +5698,7 @@ bool function IsUnlockValid( string ref, string parentRef = "" )
 
 bool function IsSubItemLocked( entity player, string ref, string parentRef )
 {
-	if ( DevEverythingUnlocked() )
+	if ( DevEverythingUnlocked( player ) )
 		return false
 
 	if ( IsItemInEntitlementUnlock( ref, parentRef ) )
@@ -5817,7 +5817,7 @@ bool function IsSubItemLocked( entity player, string ref, string parentRef )
 
 bool function IsItemLocked( entity player, string ref )
 {
-	if ( DevEverythingUnlocked() )
+	if ( DevEverythingUnlocked( player ) )
 		return false
 
 	if ( IsItemInEntitlementUnlock( ref ) )
@@ -5906,7 +5906,7 @@ bool function IsItemLockedForEntitlement( entity player, string ref, string pare
 
 bool function IsSubItemOwned( entity player, string ref, string parentRef )
 {
-	if ( DevEverythingUnlocked() )
+	if ( DevEverythingUnlocked( player ) )
 		return false
 
 	Assert( IsValid( player ) )
@@ -5990,7 +5990,7 @@ bool function IsSubItemOwned( entity player, string ref, string parentRef )
 
 bool function IsItemOwned( entity player, string ref )
 {
-	if ( DevEverythingUnlocked() )
+	if ( DevEverythingUnlocked( player ) )
 		return false
 
 	Assert( IsValid( player ) )
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/_menu_callbacks.gnut b/Northstar.CustomServers/mod/scripts/vscripts/_menu_callbacks.gnut
index 1092bf2d..6499faa2 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/_menu_callbacks.gnut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/_menu_callbacks.gnut
@@ -65,6 +65,8 @@ bool function ClientCommandCallback_GenUp( entity player, array<string> args )
 		player.GenChanged()
 		player.XPChanged()
 	}
+
+	RegenPersistentLoadouts(player)
 	
 	return true
 }
\ No newline at end of file
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/_xp.gnut b/Northstar.CustomServers/mod/scripts/vscripts/_xp.gnut
index 6f044b7a..2b95d1a8 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/_xp.gnut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/_xp.gnut
@@ -1,6 +1,7 @@
 global function SvXP_Init
 global function PlayerProgressionAllowed
 global function HandleXPGainForScoreEvent
+global function AddXP
 
 void function SvXP_Init()
 {
@@ -29,46 +30,38 @@ bool function PlayerProgressionAllowed( entity player )
 void function HandleXPGainForScoreEvent( entity player, ScoreEvent event )
 {
 	// note: obviously all xp stuff can be cheated in if people want to on customs, this is mainly just here for fun for those who want it and feature completeness
-	// most score events don't have this, so we'll set this to the xp value of other categories later if needed
+
 	int xpValue = ScoreEvent_GetXPValue( event )
 	int weaponXp = ScoreEvent_GetXPValueWeapon( event )
 	int titanXp = ScoreEvent_GetXPValueTitan( event )
-
-	if ( xpValue < weaponXp )
-		xpValue = weaponXp
-	else if ( xpValue < titanXp )
-		xpValue = titanXp
+	int factionXp = ScoreEvent_GetXPValueFaction( event )
 
 	entity weapon = player.GetActiveWeapon()
-	if ( IsValid( weapon ) && ShouldTrackXPForWeapon( weapon.GetWeaponClassName() ) )
-		AddWeaponXP( player, xpValue )
+	if ( IsValid( weapon ) && ShouldTrackXPForWeapon( weapon.GetWeaponClassName() ) && weaponXp != 0 )
+		AddWeaponXP( player, weaponXp )
 
 	// if we specifically gain titan xp, then give titan xp no matter what, otherwise only give it when we're in a titan
-	if ( titanXp != 0 || player.IsTitan() )
-		AddTitanXP( player, xpValue )
-
-	// most events don't have faction xp but almost everything should give it
-	int factionXp = ScoreEvent_GetXPValueFaction( event )
-	if ( xpValue > factionXp )
-		factionXp = xpValue
-	else if ( xpValue < factionXp )
-		xpValue = factionXp
+	if ( titanXp != 0 )
+		AddTitanXP( player, titanXp )
 
 	if ( factionXp != 0 )
 		AddFactionXP( player, factionXp )
 
-	if ( xpValue == 0 )
-		return
-
 	// global xp
+	if ( xpValue != 0 )
+		AddXP( player, xpValue )
+}
+
+void function AddXP( entity player, int amount )
+{
 	int oldXp = player.GetPersistentVarAsInt( "xp" )
-	if(oldXp<0) oldXp = 0
+	if( oldXp < 0 ) oldXp = 0
 	int oldLevel = GetLevelForXP( oldXp )
-	player.SetPersistentVar( "xp", min( oldXp + xpValue, PlayerGetMaxXPPerGen() ) )
+	player.SetPersistentVar( "xp", min( oldXp + amount, PlayerGetMaxXPPerGen() ) )
 	player.XPChanged() // network xp change to client, gen can't change here
 
 	int newXp = player.GetPersistentVarAsInt( "xp" )
 	int newLevel = GetLevelForXP( newXp )
 	if ( newLevel != oldLevel )
 		Remote_CallFunction_NonReplay( player, "ServerCallback_PlayerLeveledUp", player.GetPersistentVarAsInt( "gen" ), newLevel )
-}
\ No newline at end of file
+}
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/burnmeter/_burnmeter.gnut b/Northstar.CustomServers/mod/scripts/vscripts/burnmeter/_burnmeter.gnut
index 5821d015..56750352 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/burnmeter/_burnmeter.gnut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/burnmeter/_burnmeter.gnut
@@ -265,6 +265,8 @@ void function UseBurnCardWeapon( entity weapon, entity player )
 		PlayerEarnMeter_SetRewardUsed( player )

 

 	thread PlayerInventory_PopInventoryItem( player )

+

+	UpdatePlayerStat( player, "misc_stats", "boostsActivated" )

 }

 

 void function UseBurnCardWeaponInCriticalSection( entity weapon, entity ownerPlayer )

diff --git a/Northstar.CustomServers/mod/scripts/vscripts/evac/_evac.gnut b/Northstar.CustomServers/mod/scripts/vscripts/evac/_evac.gnut
index f23c841d..af074689 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/evac/_evac.gnut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/evac/_evac.gnut
@@ -422,6 +422,40 @@ void function Evac( int evacTeam, float initialWait, float arrivalTime, float wa
 		foreach ( entity otherPlayer in GetPlayerArray() )
 			Remote_CallFunction_NonReplay( otherPlayer, "ServerCallback_EvacObit", player.GetEncodedEHandle() )
 	}
+
+	// award player score to evacing team
+	int evacCount = 0
+	array<entity> evacingPlayers = GetPlayerArrayOfTeam( dropship.GetTeam() ) // all players that are supposed to evac in the dropship
+
+	// count how many players are in the dropship
+	foreach ( entity player in evacingPlayers )
+	{
+		if ( !PlayerInDropship( player, dropship ) )
+			continue
+		
+		evacCount++
+	}
+
+	bool allEvac = evacCount == evacingPlayers.len()
+
+	foreach(entity player in evacingPlayers)
+	{
+		if ( !PlayerInDropship( player, dropship ) )
+			continue
+
+		AddPlayerScore( player, "HotZoneExtract" )
+		UpdatePlayerStat( player, "misc_stats", "evacsSurvived" )
+
+		if ( allEvac )
+			AddPlayerScore( player, "TeamBonusFullEvac" )
+	}
+
+	// sole survivor (but not the only one on the team)
+	if ( evacCount == 1 && !allEvac )
+	{
+		// we can assume there is one player in the array because otherwise evacCount wouldn't be 1
+		AddPlayerScore( evacingPlayers[0], "SoleSurvivor" )
+	}
 }
 
 void function AddPlayerToEvacDropship( entity dropship, entity player ) 
@@ -442,6 +476,8 @@ void function AddPlayerToEvacDropship( entity dropship, entity player )
 	if ( !PlayerInDropship( player, dropship ) )
 		return
 
+	UpdatePlayerStat( player, "misc_stats", "evacsAttempted" )
+
     // need to cancel if the dropship dies
     dropship.EndSignal( "OnDeath", "OnDestroy" )
 
@@ -507,6 +543,15 @@ void function CheckIfAnyPlayerLeft( int evacTeam )
 			SetTeamActiveObjective( evacTeam, "EG_DropshipExtractEvacPlayersKilled" )
 			SetTeamActiveObjective( GetOtherTeam( evacTeam ), "EG_StopExtractEvacPlayersKilled" )
 			thread EvacEpilogueCompleted( null )
+
+			// score for killing the entire evacing team
+			foreach ( entity player in GetPlayerArray() )
+			{
+				if ( player.GetTeam() == evacTeam )
+					continue
+
+				AddPlayerScore( player, "TeamBonusKilledAll")
+			}
 		}
 	)
 	while( true )
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/faction_xp.gnut b/Northstar.CustomServers/mod/scripts/vscripts/faction_xp.gnut
index 5fd7d101..6555c875 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/faction_xp.gnut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/faction_xp.gnut
@@ -3,8 +3,11 @@ global function AddFactionXP
 void function AddFactionXP( entity player, int amount )
 {
 	string faction = GetFactionChoice( player )
+	int oldLevel = FactionGetLevel( player, faction )
 	// increment xp
 	player.SetPersistentVar( "factionXP[" + faction + "]", min( FactionGetXP( player, faction ) + amount, FactionGetMaxXP( faction ) ) )
 	
 	// note: no notif for faction level up
+	if ( FactionGetLevel( player, faction ) != oldLevel )
+		AddPlayerScore( player, "FactionLevelUp" )
 }
\ No newline at end of file
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/lobby/_lobby.gnut b/Northstar.CustomServers/mod/scripts/vscripts/lobby/_lobby.gnut
index ae933b71..8b65ec93 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/lobby/_lobby.gnut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/lobby/_lobby.gnut
@@ -14,6 +14,7 @@ void function Lobby_Init()
 	{
 		// non-private lobby clientcommands
 		AddClientCommandCallback( "StartPrivateMatchSearch", ClientCommandCallback_StartPrivateMatchSearch )
+		AddClientCommandCallback( "SetAnnouncementVersionSeen", ClientCommandCallback_SetAnnouncementVersionSeen )
 	}
 }
 
@@ -37,3 +38,14 @@ bool function ClientCommandCallback_StartPrivateMatchSearch( entity player, arra
 	
 	return true
 }
+
+bool function ClientCommandCallback_SetAnnouncementVersionSeen( entity player, array<string> args )
+{
+	if ( args.len() < 1 )
+		return false
+	
+	int version = int( args[0] )
+
+	player.SetPersistentVar( "announcementVersionSeen", version )
+	return true
+}
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/mp/_base_gametype_mp.gnut b/Northstar.CustomServers/mod/scripts/vscripts/mp/_base_gametype_mp.gnut
index 3bd0cd69..bab7eaed 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/mp/_base_gametype_mp.gnut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/mp/_base_gametype_mp.gnut
@@ -134,6 +134,15 @@ void function CodeCallback_OnClientConnectionCompleted( entity player )
 		Lobby_OnClientConnectionCompleted( player )
 		return
 	}
+	else if ( !IsFDMode( GAMETYPE ) )
+	{
+		// reset this for non-fd modes
+		// for some reason the postgame scoreboard uses this to
+		// determine if it should show the FD aegis rank one
+		// FD should either set this in their own mode, or add an else
+		// to this if statement when it releases
+		player.SetPersistentVar( "lastFDTitanRef", "" )
+	}
 
 	player.hasConnected = true
 
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/mp/_changemap.nut b/Northstar.CustomServers/mod/scripts/vscripts/mp/_changemap.nut
index 16a3ce92..0ababfc7 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/mp/_changemap.nut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/mp/_changemap.nut
@@ -58,7 +58,9 @@ void function CodeCallback_MatchIsOver()
 #if MP
 void function PopulatePostgameData()
 {
-	// something's busted here because this isn't showing automatically on match end, ag
+	// show the postgame scoreboard summary
+	SetUIVar( level, "showGameSummary", true )
+
 	foreach ( entity player in GetPlayerArray() )
 	{
 		int teams = GetCurrentPlaylistVarInt( "max_teams", 2 )
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/mp/_gamestate_mp.nut b/Northstar.CustomServers/mod/scripts/vscripts/mp/_gamestate_mp.nut
index 46b39ebc..3426cec5 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/mp/_gamestate_mp.nut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/mp/_gamestate_mp.nut
@@ -800,6 +800,8 @@ void function SetWinner( int team, string winningReason = "", string losingReaso
 		}
 		else
 			SetGameState( eGameState.WinnerDetermined )
+
+		ScoreEvent_MatchComplete( team )
 	}
 }
 
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/mp/_score.nut b/Northstar.CustomServers/mod/scripts/vscripts/mp/_score.nut
index dacd43b0..0b55e9ff 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/mp/_score.nut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/mp/_score.nut
@@ -7,6 +7,7 @@ global function ScoreEvent_PlayerKilled
 global function ScoreEvent_TitanDoomed
 global function ScoreEvent_TitanKilled
 global function ScoreEvent_NPCKilled
+global function ScoreEvent_MatchComplete
 
 global function ScoreEvent_SetEarnMeterValues
 global function ScoreEvent_SetupEarnMeterValuesForMixedModes
@@ -230,7 +231,15 @@ void function ScoreEvent_NPCKilled( entity victim, entity attacker, var damageIn
 	catch ( ex ) {}
 }
 
-
+void function ScoreEvent_MatchComplete( int winningTeam )
+{
+	foreach( entity player in GetPlayerArray() )
+	{
+		AddPlayerScore( player, "MatchComplete" )
+		if ( player.GetTeam() == winningTeam )
+			AddPlayerScore( player, "MatchVictory" )
+	}
+}
 
 void function ScoreEvent_SetEarnMeterValues( string eventName, float earned, float owned, float coreScale = 1.0 )
 {
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/mp/_stats.nut b/Northstar.CustomServers/mod/scripts/vscripts/mp/_stats.nut
index 0e8b58f4..92c0f401 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/mp/_stats.nut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/mp/_stats.nut
@@ -1,3 +1,5 @@
+untyped // because entity.s
+
 global function Stats_Init
 global function AddStatCallback
 global function Stats_SaveStatDelayed
@@ -12,67 +14,1084 @@ global function PreScoreEventUpdateStats
 global function PostScoreEventUpdateStats
 global function Stats_OnPlayerDidDamage
 
+struct {
+	table< string, array<string> > refs
+	table< string, array< void functionref( entity, float, string ) > > callbacks
+
+	table< entity, table< string, int > > cachedIntStatChanges
+	table< table< string, float > > cachedFloatStatChanges
+
+	table< entity, float > playerKills
+	table< entity, float > playerKillsPvp
+	table< entity, float > playerDeaths
+	table< entity, float > playerDeathsPvp
+
+	bool isFirstStrike = true
+} file
+
 void function Stats_Init()
 {
+	AddCallback_OnPlayerKilled( OnPlayerOrNPCKilled )
+	AddCallback_OnNPCKilled( OnPlayerOrNPCKilled )
+	AddCallback_OnPlayerRespawned( OnPlayerRespawned )
+	AddCallback_OnClientConnected( OnClientConnected )
+	AddCallback_OnClientDisconnected( OnClientDisconnected )
+	AddCallback_GameStateEnter( eGameState.Epilogue, OnEpilogueStarted )
 
+	thread HandleDistanceAndTimeStats_Threaded()
+	thread SaveStatsPeriodically_Threaded()
 }
 
-void function AddStatCallback(string statCategory, string statAlias, string statSubAlias, void functionref(entity, float, string) callback, string subRef)
+void function AddStatCallback( string statCategory, string statAlias, string statSubAlias, void functionref( entity, float, string ) callback, string subRef )
 {
+	if ( !IsValidStat( statCategory, statAlias, statSubAlias ) )
+		throw format( "INVALID STAT: %s : %s : %s", statCategory, statAlias, statSubAlias )
+
+
+	string statVar = GetStatVar( statCategory, statAlias, statSubAlias )
 
+	if ( statVar in file.refs )
+	{
+		file.refs[ statVar ].append( subRef )
+		file.callbacks[ statVar ].append( callback )
+	}
+	else
+	{
+		file.refs[ statVar ] <- [ subRef ]
+		file.callbacks[ statVar ] <- [ callback ]
+	}
 }
 
-void function Stats_SaveStatDelayed(entity player, string statCategory, string statAlias, string statSubAlias)
+// a lot of this file seems to be doing caching of stats in some way
+void function Stats_SaveStatDelayed( entity player, string statCategory, string statAlias, string statSubAlias, float delay = 0.1 )
 {
+	// idk how long the delay is meant to be but whatever
+	wait delay
+
+	if ( !IsValid( player ) )
+		return
+
+	Stats_SaveStat( player, statCategory, statAlias, statSubAlias )
+}
+
+void function Stats_SaveAllStats( entity player )
+{
+	if ( player in file.cachedIntStatChanges )
+	{
+		foreach( string key, int val in file.cachedIntStatChanges[ player ] )
+		{
+			player.SetPersistentVar( key, player.GetPersistentVarAsInt( key ) + val )
+		}
+
+		delete file.cachedIntStatChanges[ player ]
+	}
+	// save cached float stat change
+	if ( player in file.cachedFloatStatChanges )
+	{
+		foreach( string key, float val in file.cachedFloatStatChanges[ player ] )
+		{
+			player.SetPersistentVar( key, expect float( player.GetPersistentVar( key ) ) + val )
+		}
 
+		delete file.cachedFloatStatChanges[ player ]
+	}
 }
 
-int function PlayerStat_GetCurrentInt(entity player, string statCategory, string statAlias, string statSubAlias)
+void function Stats_SaveStat( entity player, string statCategory, string statAlias, string statSubAlias )
 {
+	string stat = GetStatVar( statCategory, statAlias, statSubAlias )
+	// save cached int stat change
+	if ( player in file.cachedIntStatChanges && stat in file.cachedIntStatChanges[ player ] )
+	{
+		player.SetPersistentVar( stat, player.GetPersistentVarAsInt( stat ) + file.cachedIntStatChanges[ player ][ stat ] )
+		delete file.cachedIntStatChanges[ player ][ stat ]
+		return
+	}
+	// save cached float stat change
+	if ( player in file.cachedFloatStatChanges && stat in file.cachedFloatStatChanges[ player ] )
+	{
+		player.SetPersistentVar( stat, expect float( player.GetPersistentVar( stat ) ) + file.cachedFloatStatChanges[ player ][ stat ] )
+		delete file.cachedFloatStatChanges[ player ][ stat ]
+		return
+	}
+}
+
+// this gets the cached change, not the actual value
+int function PlayerStat_GetCurrentInt( entity player, string statCategory, string statAlias, string statSubAlias )
+{
+	string str = GetStatVar( statCategory, statAlias, statSubAlias )
+
+	if ( player in file.cachedIntStatChanges && str in file.cachedIntStatChanges[ player ] )
+		return file.cachedIntStatChanges[ player ][ str ]
 	return 0
 }
 
-float function PlayerStat_GetCurrentFloat(entity player, string statCategory, string statAlias, string statSubAlias)
+// this gets the cached change, not the actual value
+float function PlayerStat_GetCurrentFloat( entity player, string statCategory, string statAlias, string statSubAlias )
 {
+	string str = GetStatVar( statCategory, statAlias, statSubAlias )
+
+	if ( player in file.cachedFloatStatChanges && str in file.cachedFloatStatChanges[ player ] )
+		return file.cachedFloatStatChanges[ player ][ str ]
 	return 0
 }
 
-void function UpdatePlayerStat(entity player, string statCategory, string subStat, int count = 0)
+void function UpdatePlayerStat( entity player, string statCategory, string subStat, int count = 1 )
 {
+	if ( !IsValid( player ) )
+		return
+
+	Stats_IncrementStat( player, statCategory, subStat, "", count.tofloat() )
+}
+
+void function IncrementPlayerDidPilotExecutionWhileCloaked( entity player )
+{
+	UpdatePlayerStat( player, "kills_stats", "pilotExecutePilotWhileCloaked" )
+}
+
+void function UpdateTitanDamageStat( entity attacker, float savedDamage, var damageInfo )
+{
+	if ( !IsValid( attacker ) )
+		return
+
+	Stats_IncrementStat( attacker, "titan_stats", "titanDamage", GetTitanCharacterName( attacker ), savedDamage )
+}
+
+void function UpdateTitanWeaponDamageStat( entity attacker, float savedDamage, var damageInfo )
+{
+	if ( !IsValid( attacker ) )
+		return
+
+	string weaponName = GetPersistenceRefFromDamageInfo( damageInfo )
+	if ( weaponName == "" )
+		return
+
+	Stats_IncrementStat( attacker, "weapon_stats", "titanDamage", weaponName, savedDamage )
+}
+
+void function UpdateTitanCoreEarnedStat( entity player, entity titan, int count = 1 )
+{
+	if ( !IsValid( player ) )
+		return
+
+	if ( !IsValid( titan ) )
+		return
+
+	Stats_IncrementStat( player, "titan_stats", "coresEarned", GetTitanCharacterName( titan ), count.tofloat() )
+}
+
+void function PreScoreEventUpdateStats( entity attacker, entity ent )
+{
+	// used to track kill streaks ending i think ( that stuff gets reset during score event update )
+}
+
+void function PostScoreEventUpdateStats( entity attacker, entity ent )
+{
+	if ( !attacker.IsPlayer() )
+		return
+	// used to track kill streaks starting maybe
+	if ( attacker.s.currentKillstreak == KILLINGSPREE_KILL_REQUIREMENT )
+	{
+		// killingSpressAs_<chassis>
+		if ( attacker.IsTitan() )
+			Stats_IncrementStat( attacker, "kills_stats", "killingSpressAs_" + GetTitanCharacterName( attacker ), "", 1.0 )
+
+		entity weapon = attacker.GetActiveWeapon()
+		// I guess if you dont have a valid active weapon when you get awarded a killing spree
+		// you dont get the stat. Too bad!
+		if ( !IsValid( weapon ) )
+			return
+		Stats_IncrementStat( attacker, "weapon_kill_stats", "killingSprees", weapon.GetWeaponClassName(), 1.0 )
+	}
+}
+
+void function Stats_OnPlayerDidDamage( entity victim, var damageInfo )
+{
+	// try and get the player
+	entity attacker = DamageInfo_GetAttacker( damageInfo )
+	// get the player from their titan
+	if ( attacker.IsTitan() && IsPetTitan( attacker ) )
+		attacker = attacker.GetTitanSoul().GetBossPlayer()
+
+	if ( !attacker.IsPlayer() )
+		return
+
+	string weaponName = GetPersistenceRefFromDamageInfo( damageInfo )
+	if ( weaponName == "" )
+		return
+
+	Stats_IncrementStat( attacker, "weapon_stats", "shotsHit", weaponName, 1.0 )
+
+	if ( DamageInfo_GetCustomDamageType( damageInfo ) & DF_CRITICAL )
+		Stats_IncrementStat( attacker, "weapon_stats", "critHits", weaponName, 1.0 )
+	if ( DamageInfo_GetCustomDamageType( damageInfo ) & DF_HEADSHOT )
+		Stats_IncrementStat( attacker, "weapon_stats", "headshots", weaponName, 1.0 )
+}
+
+void function Stats_IncrementStat( entity player, string statCategory, string statAlias, string statSubAlias, float amount )
+{
+	if ( !IsValidStat( statCategory, statAlias, statSubAlias ) )
+	{
+		printt( "invalid stat: " + statCategory + " : " + statAlias + " : " + statSubAlias )
+		return
+	}
+
+	string str = GetStatVar( statCategory, statAlias, statSubAlias )
+	int type = GetStatVarType( statCategory, statAlias, statSubAlias )
+
+	// stupid exception because respawn set this up as an int in script
+	// but it is actually a float, so the game will crash if we don't fix it somewhere
+	// i dont feel like committing all of sh_stats.gnut so im doing this instead
+	if ( str == "mapStats[%mapname%].hoursPlayed[%gamemode%]" )
+		type = ePlayerStatType.FLOAT
+
+	// this is rather hacky
+	string mode = GAMETYPE
+	int difficulty = GetDifficultyLevel()
+	if ( difficulty >= 5 )
+		return
+
+	string saveVar = Stats_GetFixedSaveVar( str, GetMapName(), mode, difficulty.tostring() )
+	// check if the map and mode exist in persistence
+	try
+	{
+		PersistenceGetEnumIndexForItemName( "gamemodes", mode )
+		PersistenceGetEnumIndexForItemName( "maps", GetMapName() )
+	}
+	catch( ex )
+	{
+		// if we have an invalid mode or map for persistence, and it is used in the
+		// persistence string, we can't save the persistence so we have to just return
+		if ( str != saveVar )
+		{
+			printt( ex )
+			return
+		}
+	}
+	str = saveVar
+
+	switch ( type )
+	{
+	case ePlayerStatType.INT:
+		// populate table if needed
+		if ( !( player in file.cachedIntStatChanges ) )
+			file.cachedIntStatChanges[ player ] <- {}
+		if ( !( str in file.cachedIntStatChanges[ player ] ) )
+			file.cachedIntStatChanges[ player ][ str ] <- 0
+
+		file.cachedIntStatChanges[ player ][ str ] += amount.tointeger()
+		break
+	case ePlayerStatType.FLOAT:
+		// populate table if needed
+		if ( !( player in file.cachedFloatStatChanges ) )
+			file.cachedFloatStatChanges[ player ] <- {}
+		if ( !( str in file.cachedFloatStatChanges[ player ] ) )
+			file.cachedFloatStatChanges[ player ][ str ] <- 0.0
+
+		file.cachedFloatStatChanges[ player ][ str ] += amount
+		break
+	default:
+		throw "UNIMPLEMENTED STAT TYPE: " + type
+	}
+
+	// amount here is never used
+	Stats_RunCallbacks( str, player, amount )
+}
+
+void function Stats_RunCallbacks( string statVar, entity player, float change )
+{
+	if ( !( statVar in file.refs ) )
+		return
+
+	for( int i = 0; i < file.refs[ statVar ].len(); i++ )
+	{
+		string ref = file.refs[ statVar ][ i ]
+		void functionref( entity, float, string ) callback = file.callbacks[ statVar ][ i ]
+
+		callback( player, change, ref )
+	}
+}
+
+void function OnClientConnected( entity player )
+{
+	Stats_IncrementStat( player, "game_stats", "game_joined", "", 1.0 )
+}
+
+void function OnClientDisconnected( entity player )
+{
+	Stats_SaveAllStats( player )
+	// maybe we can save this stuff, but idk if we can access persistence in this callback
+	if ( player in file.cachedIntStatChanges )
+		delete file.cachedIntStatChanges[ player ]
+
+	if ( player in file.cachedFloatStatChanges )
+		delete file.cachedFloatStatChanges[ player ]
+}
+
+void function OnPlayerOrNPCKilled( entity victim, entity attacker, var damageInfo )
+{
+	if ( victim.IsPlayer() )
+		thread SetLastPosForDistanceStatValid_Threaded( victim, false )
+
+	HandleDeathStats( victim, attacker, damageInfo )
+	HandleKillStats( victim, attacker, damageInfo )
+	HandleWeaponKillStats( victim, attacker, damageInfo )
+	HandleTitanStats( victim, attacker, damageInfo )
+}
+
+void function HandleDeathStats( entity player, entity attacker, var damageInfo )
+{
+	if ( !IsValid( player ) || !player.IsPlayer() )
+		return
+
+	if ( player in file.playerDeaths )
+		file.playerDeaths[ player ]++
+	else
+		file.playerDeaths[ player ] <- 1.0
+	// total
+	Stats_IncrementStat( player, "deaths_stats", "total", "", 1.0 )
+
+	// these all rely on the attacker being valid
+	if ( IsValid( attacker ) )
+	{
+		// totalPVP
+		// note: I'm not sure if owned entities count towards totalPVP
+		// such as auto-titans, turrets, etc.
+		if ( attacker.IsPlayer() || attacker.GetBossPlayer() )
+		{
+			if ( player in file.playerDeathsPvp )
+				file.playerDeathsPvp[ player ]++
+			else
+				file.playerDeathsPvp[ player ] <- 1.0
+			Stats_IncrementStat( player, "deaths_stats", "totalPVP", "", 1.0 )
+		}
+
+		// byPilots
+		if ( IsPilot( attacker ) )
+			Stats_IncrementStat( player, "deaths_stats", "byPilots", "", 1.0 )
+
+		// byTitan_<chassis>
+		if ( attacker.IsTitan() && attacker.IsPlayer() )
+			Stats_IncrementStat( player, "deaths_stats", "byTitan_" + GetTitanCharacterName( attacker ), "", 1.0 )
+
+		// bySpectres
+		if ( IsSpectre( attacker ) )
+			Stats_IncrementStat( player, "deaths_stats", "bySpectres", "", 1.0 )
+
+		// byGrunts
+		if ( IsGrunt( attacker ) )
+			Stats_IncrementStat( player, "deaths_stats", "byGrunts", "", 1.0 )
+
+		// byNPCTitans_<chassis>
+		if ( attacker.IsTitan() && attacker.IsNPC() )
+			Stats_IncrementStat( player, "deaths_stats", "byNPCTitans_" + GetTitanCharacterName( attacker ), "", 1.0 )
+	}
+
+	// asPilot
+	if ( IsPilot( player ) )
+		Stats_IncrementStat( player, "deaths_stats", "asPilot", "", 1.0 )
+
+	// asTitan_<chassis>
+	if ( player.IsTitan() )
+		Stats_IncrementStat( player, "deaths_stats", "asTitan_" + GetTitanCharacterName( player ), "", 1.0 )
+
+	// suicides
+	if ( IsSuicide( attacker, player, DamageInfo_GetDamageSourceIdentifier( damageInfo ) ) )
+		Stats_IncrementStat( player, "deaths_stats", "suicides", "", 1.0 )
+
+	// whileEjecting
+	if ( player.p.pilotEjecting )
+		Stats_IncrementStat( player, "deaths_stats", "whileEjecting", "", 1.0 )
+}
+
+void function HandleWeaponKillStats( entity victim, entity attacker, var damageInfo )
+{
+	if ( !IsValid( attacker ) )
+		return
+
+	// get the player and it's pet titan
+	entity player
+	entity playerPetTitan
+	if ( attacker.IsPlayer() )
+	{
+		// the player is just the attacker
+		player = attacker
+		playerPetTitan = player.GetPetTitan()
+	}
+	else if ( attacker.IsTitan() && IsPetTitan( attacker ) )
+	{
+		// the attacker is the player's auto titan
+		player = attacker.GetTitanSoul().GetBossPlayer()
+		playerPetTitan = attacker
+	}
+	else
+	{
+		// attacker could be something like an NPC, or worldspawn
+		return
+	}
+
+	string damageSourceStr = GetPersistenceRefFromDamageInfo( damageInfo )
+	// cant do weapon stats for no weapon
+	if ( damageSourceStr == "" )
+		return
+
+	// check things once, for performance
+	int damageSource = DamageInfo_GetDamageSourceIdentifier( damageInfo )
+	bool victimIsPlayer = victim.IsPlayer()
+	bool victimIsNPC = victim.IsNPC()
+	bool victimIsPilot = IsPilot( victim )
+	bool victimIsTitan = victim.IsTitan()
+
+	// total
+	Stats_IncrementStat( player, "weapon_kill_stats", "total", damageSourceStr, 1.0 )
+
+	// pilots
+	if ( victimIsPilot )
+		Stats_IncrementStat( player, "weapon_kill_stats", "pilots", damageSourceStr, 1.0 )
+
+	// ejecting_pilots
+	if ( victimIsPilot && victim.p.pilotEjecting )
+		Stats_IncrementStat( player, "weapon_kill_stats", "ejecting_pilots", damageSourceStr, 1.0 )
+
+	// titansTotal
+	if ( victimIsTitan )
+		Stats_IncrementStat( player, "weapon_kill_stats", "titansTotal", damageSourceStr, 1.0 )
 
+	// spectres
+	if ( IsSpectre( victim ) )
+		Stats_IncrementStat( player, "weapon_kill_stats", "spectres", damageSourceStr, 1.0 )
+
+	// marvins
+	if ( IsMarvin( victim ) )
+		Stats_IncrementStat( player, "weapon_kill_stats", "marvins", damageSourceStr, 1.0 )
+
+	// grunts
+	if ( IsGrunt( victim ) )
+		Stats_IncrementStat( player, "weapon_kill_stats", "grunts", damageSourceStr, 1.0 )
+
+	// ai
+	if ( victimIsNPC )
+		Stats_IncrementStat( player, "weapon_kill_stats", "ai", damageSourceStr, 1.0 )
+
+	// titans_<chassis>
+	if ( victimIsPlayer && victimIsTitan )
+		Stats_IncrementStat( player, "weapon_kill_stats", "titans_" + GetTitanCharacterName( victim ), damageSourceStr, 1.0 )
+
+	// npcTitans_<chassis>
+	if ( victimIsNPC && victimIsTitan )
+		Stats_IncrementStat( player, "weapon_kill_stats", "npcTitans_" + GetTitanCharacterName( victim ), damageSourceStr, 1.0 )
 }
 
-void function IncrementPlayerDidPilotExecutionWhileCloaked(entity player)
+void function HandleKillStats( entity victim, entity attacker, var damageInfo )
 {
+	if ( !IsValid( attacker ) )
+		return
+	// get the player and it's pet titan
+	entity player
+	entity playerPetTitan
+	if ( attacker.IsPlayer() )
+	{
+		// the player is just the attacker
+		player = attacker
+		playerPetTitan = player.GetPetTitan()
+	}
+	else if ( attacker.IsTitan() && IsPetTitan( attacker ) )
+	{
+		// the attacker is the player's auto titan
+		player = attacker.GetTitanSoul().GetBossPlayer()
+		playerPetTitan = attacker
+	}
+	else
+	{
+		// attacker could be something like an NPC, or worldspawn
+		return
+	}
+
+	// check things once, for performance
+	int damageSource = DamageInfo_GetDamageSourceIdentifier( damageInfo )
+	bool victimIsPlayer = victim.IsPlayer()
+	bool victimIsNPC = victim.IsNPC()
+	bool victimIsPilot = IsPilot( victim )
+	bool victimIsTitan = victim.IsTitan()
+
+	if ( player in file.playerKills )
+		file.playerKills[ player ]++
+	else
+		file.playerKills[ player ] <- 1.0
+	// total
+	Stats_IncrementStat( player, "kills_stats", "total", "", 1.0 )
+
+	// totalPVP
+	if ( victimIsPlayer )
+	{
+		if ( player in file.playerKillsPvp )
+			file.playerKillsPvp[ player ]++
+		else
+			file.playerKillsPvp[ player ] <- 1.0
+		Stats_IncrementStat( player, "kills_stats", "totalPVP", "", 1.0 )
+	}
+
+	// pilots
+	if ( victimIsPilot )
+		Stats_IncrementStat( player, "kills_stats", "pilots", "", 1.0 )
+
+	// spectres
+	if ( IsSpectre( victim ) )
+		Stats_IncrementStat( player, "kills_stats", "spectres", "", 1.0 )
+
+	// marvins
+	if ( IsMarvin( victim ) )
+		Stats_IncrementStat( player, "kills_stats", "marvins", "", 1.0 )
+
+	// grunts
+	if ( IsGrunt( victim ) )
+		Stats_IncrementStat( player, "kills_stats", "grunts", "", 1.0 )
+
+	// totalTitans
+	if ( victimIsTitan )
+		Stats_IncrementStat( player, "kills_stats", "totalTitans", "", 1.0 )
+
+	// totalPilots
+	if ( victimIsPilot )
+		Stats_IncrementStat( player, "kills_stats", "totalPilots", "", 1.0 )
+
+	// totalNPC
+	if ( victimIsNPC )
+		Stats_IncrementStat( player, "kills_stats", "totalNPC", "", 1.0 )
+
+	// totalTitansWhileDoomed
+	if ( victimIsTitan && attacker.IsTitan() && GetDoomedState( attacker ) )
+		Stats_IncrementStat( player, "kills_stats", "totalTitansWhileDoomed", "", 1.0 )
+
+	// asPilot
+	if ( IsPilot( attacker ) )
+		Stats_IncrementStat( player, "kills_stats", "asPilot", "", 1.0 )
+
+	// totalAssists
+	// assistsTotal ( weapon_kill_stats )
+	// note: eww
+	table<int, bool> alreadyAssisted
+	foreach( DamageHistoryStruct attackerInfo in victim.e.recentDamageHistory )
+	{
+		if ( !IsValid( attackerInfo.attacker ) || !attackerInfo.attacker.IsPlayer() || attackerInfo.attacker == victim )
+			continue
+
+		bool exists = attackerInfo.attacker.GetEncodedEHandle() in alreadyAssisted ? true : false
+		if( attackerInfo.attacker != attacker && !exists )
+		{
+			alreadyAssisted[ attackerInfo.attacker.GetEncodedEHandle() ] <- true
+			Stats_IncrementStat( attackerInfo.attacker, "kills_stats", "totalAssists", "", 1.0 )
+
+			string source = DamageSourceIDToString( attackerInfo.damageSourceId )
+
+			if ( IsValidStatItemString( source ) )
+				Stats_IncrementStat( attacker, "weapon_kill_stats", "assistsTotal", source, 1.0 )
+		}
+	}
+
+	// asTitan_<chassis>
+	if ( player.IsTitan() )
+		Stats_IncrementStat( player, "kills_stats", "asTitan_" + GetTitanCharacterName( player ), "", 1.0 )
+
+	// firstStrikes
+	if ( file.isFirstStrike && attacker.IsPlayer() && victimIsPlayer )
+	{
+		Stats_IncrementStat( player, "kills_stats", "firstStrikes", "", 1.0 )
+		file.isFirstStrike = false
+	}
+
+	// ejectingPilots
+	if ( victimIsPilot && victim.p.pilotEjecting )
+		Stats_IncrementStat( player, "kills_stats", "ejectingPilots", "", 1.0 )
+
+	// whileEjecting
+	if ( attacker.IsPlayer() && attacker.p.pilotEjecting )
+		Stats_IncrementStat( player, "kills_stats", "whileEjecting", "", 1.0 )
+
+	// cloakedPilots
+	if ( victimIsPilot && IsCloaked( victim ) )
+		Stats_IncrementStat( player, "kills_stats", "cloakedPilots", "", 1.0 )
+
+	// whileCloaked
+	if ( attacker == player && IsCloaked( attacker ) )
+		Stats_IncrementStat( player, "kills_stats", "whileCloaked", "", 1.0 )
+
+	// wallrunningPilots
+	if ( victimIsPilot && victim.IsWallRunning() )
+		Stats_IncrementStat( player, "kills_stats", "wallrunningPilots", "", 1.0 )
+
+	// whileWallrunning
+	if ( attacker == player && attacker.IsWallRunning() )
+		Stats_IncrementStat( player, "kills_stats", "whileWallrunning", "", 1.0 )
+
+	// wallhangingPilots
+	if ( victimIsPilot && victim.IsWallHanging() )
+		Stats_IncrementStat( player, "kills_stats", "wallhangingPilots", "", 1.0 )
+
+	// whileWallhanging
+	if ( attacker == player && attacker.IsWallHanging() )
+		Stats_IncrementStat( player, "kills_stats", "whileWallhanging", "", 1.0 )
+
+	// pilotExecution
+	if ( damageSource == eDamageSourceId.human_execution )
+		Stats_IncrementStat( player, "kills_stats", "pilotExecution", "", 1.0 )
+
+	// pilotExecutePilot
+	if ( victimIsPilot && damageSource == eDamageSourceId.human_execution )
+		Stats_IncrementStat( player, "kills_stats", "pilotExecutePilot", "", 1.0 )
+
+	// pilotKillsWithHoloPilotActive
+	if ( victimIsPilot && GetDecoyActiveCountForPlayer( player ) > 0 )
+		Stats_IncrementStat( player, "kills_stats", "pilotKillsWithHoloPilotActive", "", 1.0 )
+
+	// pilotKillsWithAmpedWallActive
+	if ( victimIsPilot && GetAmpedWallsActiveCountForPlayer( player ) > 0 )
+		Stats_IncrementStat( player, "kills_stats", "pilotKillsWithAmpedWallActive", "", 1.0 )
+
+	// pilotExecutePilotUsing_<execution>
+	if ( victimIsPilot && damageSource == eDamageSourceId.human_execution )
+		Stats_IncrementStat( player, "kills_stats", "pilotExecutePilotUsing_" + player.p.lastExecutionUsed, "", 1.0 )
+
+	// pilotKickMelee
+	if ( damageSource == eDamageSourceId.human_melee )
+		Stats_IncrementStat( player, "kills_stats", "pilotKickMelee", "", 1.0 )
+
+	// pilotKickMeleePilot
+	if ( victimIsPilot && damageSource == eDamageSourceId.human_melee )
+		Stats_IncrementStat( player, "kills_stats", "pilotKickMeleePilot", "", 1.0 )
+
+	// titanMelee
+	if ( DamageIsTitanMelee( damageSource ) )
+		Stats_IncrementStat( player, "kills_stats", "titanMelee", "", 1.0 )
+
+	// titanMeleePilot
+	if ( victimIsPilot && DamageIsTitanMelee( damageSource ) )
+		Stats_IncrementStat( player, "kills_stats", "titanMeleePilot", "", 1.0 )
+
+	// titanStepCrush
+	if ( IsTitanCrushDamage( damageInfo ) )
+		Stats_IncrementStat( player, "kills_stats", "titanStepCrush", "", 1.0 )
+
+	// titanStepCrushPilot
+	if ( victimIsPilot && IsTitanCrushDamage( damageInfo ) )
+		Stats_IncrementStat( player, "kills_stats", "titanStepCrushPilot", "", 1.0 )
+
+	// titanExocution<capitalisedChassis>
+	// note: RESPAWN WHY? EXPLAIN
+	if ( damageSource == eDamageSourceId.titan_execution )
+	{
+		string titanName = GetTitanCharacterName( player )
+		titanName = titanName.slice( 0, 1 ).toupper() + titanName.slice( 1, titanName.len() )
+		Stats_IncrementStat( player, "kills_stats", "titanExocution" + titanName, "", 1.0 )
+	}
+
+	// titanFallKill
+	if ( damageSource == eDamageSourceId.damagedef_titan_fall )
+		Stats_IncrementStat( player, "kills_stats", "titanFallKill", "", 1.0 )
+
+	// petTitanKillsFollowMode
+	if ( attacker == playerPetTitan && player.GetPetTitanMode() == eNPCTitanMode.FOLLOW )
+		Stats_IncrementStat( player, "kills_stats", "petTitanKillsFollowMode", "", 1.0 )
+
+	// petTitanKillsGuardMode
+	if ( attacker == playerPetTitan && player.GetPetTitanMode() == eNPCTitanMode.STAY )
+		Stats_IncrementStat( player, "kills_stats", "petTitanKillsGuardMode", "", 1.0 )
+
+	// rodeo_total
+	if ( damageSource == eDamageSourceId.rodeo_battery_removal )
+		Stats_IncrementStat( player, "kills_stats", "rodeo_total", "", 1.0 )
+
+	// pilot_headshots_total
+	if ( victimIsPilot && DamageInfo_GetCustomDamageType( damageInfo ) & DF_HEADSHOT )
+		Stats_IncrementStat( player, "kills_stats", "pilot_headshots_total", "", 1.0 )
+
+	// evacShips
+	if ( IsEvacDropship( victim ) )
+		Stats_IncrementStat( player, "kills_stats", "evacShips", "", 1.0 )
+
+	// nuclearCore
+	if ( damageSource == eDamageSourceId.damagedef_nuclear_core )
+		Stats_IncrementStat( player, "kills_stats", "nuclearCore", "", 1.0 )
+
+	// meleeWhileCloaked
+	if ( IsCloaked( attacker ) && damageSource == eDamageSourceId.human_melee )
+		Stats_IncrementStat( player, "kills_stats", "meleeWhileCloaked", "", 1.0 )
+
+	// titanKillsAsPilot
+	if ( victimIsTitan && IsPilot( attacker ) )
+		Stats_IncrementStat( player, "kills_stats", "titanKillsAsPilot", "", 1.0 )
+
+	// pilotKillsWhileStimActive
+	if ( victimIsPilot && StatusEffect_Get( attacker, eStatusEffect.stim_visual_effect ) <= 0 )
+		Stats_IncrementStat( player, "kills_stats", "pilotKillsWhileStimActive", "", 1.0 )
+
+	// pilotKillsAsTitan
+	if ( victimIsPilot && attacker.IsTitan() )
+		Stats_IncrementStat( player, "kills_stats", "pilotKillsAsTitan", "", 1.0 )
+
+	// pilotKillsAsPilot
+	if ( victimIsPilot && IsPilot( attacker ) )
+		Stats_IncrementStat( player, "kills_stats", "pilotKillsAsPilot", "", 1.0 )
+
+	// titanKillsAsTitan
+	if ( victimIsTitan && attacker.IsTitan() )
+		Stats_IncrementStat( player, "kills_stats", "titanKillsAsTitan", "", 1.0 )
 
 }
 
-void function UpdateTitanDamageStat(entity attacker, float savedDamage, var damageInfo)
+void function HandleTitanStats( entity victim, entity attacker, var damageInfo )
 {
+	if ( !IsValid( attacker ) )
+		return
+
+	// get the player and it's pet titan
+	entity player
+	entity playerPetTitan
+	if ( attacker.IsPlayer() )
+	{
+		// the player is just the attacker
+		player = attacker
+		playerPetTitan = player.GetPetTitan()
+	}
+	else if ( attacker.IsTitan() && IsPetTitan( attacker ) )
+	{
+		// the attacker is the player's auto titan
+		player = attacker.GetTitanSoul().GetBossPlayer()
+		playerPetTitan = attacker
+	}
+	else
+	{
+		// attacker could be something like an NPC, or worldspawn
+		return
+	}
+
+	int damageSource = DamageInfo_GetDamageSourceIdentifier( damageInfo )
+	bool victimIsPlayer = victim.IsPlayer()
+	bool victimIsNPC = victim.IsNPC()
+	bool victimIsPilot = IsPilot( victim )
+	bool victimIsTitan = victim.IsTitan()
+	bool titanIsPrime = IsTitanPrimeTitan( player )
 
+	// pilots
+	if ( victimIsPilot && attacker.IsTitan() )
+		Stats_IncrementStat( player, "titan_stats", "pilots", GetTitanCharacterName( attacker ), 1.0 )
+
+	// titansTotal
+	if ( victimIsTitan && attacker.IsTitan() )
+		Stats_IncrementStat( player, "titan_stats", "titansTotal", GetTitanCharacterName( attacker ), 1.0 )
+
+	// pilotsAsPrime
+	if ( victimIsPilot && attacker.IsTitan() && titanIsPrime )
+		Stats_IncrementStat( player, "titan_stats", "pilotsAsPrime", GetTitanCharacterName( attacker ), 1.0 )
+
+	// titansAsPrime
+	if ( victimIsTitan && attacker.IsTitan() && titanIsPrime )
+		Stats_IncrementStat( player, "titan_stats", "titansAsPrime", GetTitanCharacterName( attacker ), 1.0 )
+
+	// executionsAsPrime
+	if ( damageSource == eDamageSourceId.titan_execution && attacker.IsTitan() && titanIsPrime )
+		Stats_IncrementStat( player, "titan_stats", "executionsAsPrime", GetTitanCharacterName( attacker ), 1.0 )
 }
 
-void function UpdateTitanWeaponDamageStat(entity attacker, float savedDamage, var damageInfo)
+void function OnPlayerRespawned( entity player )
 {
+	thread SetLastPosForDistanceStatValid_Threaded( player, true )
+}
+
+void function OnEpilogueStarted()
+{
+	// award players for match completed, wins, and losses
+	foreach ( entity player in GetPlayerArray() )
+	{
+		Stats_IncrementStat( player, "game_stats", "game_completed", "", 1.0 )
+
+		if ( player.GetTeam() == GetWinningTeam() )
+			Stats_IncrementStat( player, "game_stats", "game_won", "", 1.0 )
+		else
+			Stats_IncrementStat( player, "game_stats", "game_lost", "", 1.0 )
+	}
+
+	if ( IsValidGamemodeString( GAMETYPE ) )
+	{
+		// award players with matches played on the mode
+		foreach ( entity player in GetPlayerArray() )
+		{
+			Stats_IncrementStat( player, "game_stats", "mode_played", GAMETYPE, 1.0 )
+
+			if ( player.GetTeam() == GetWinningTeam() )
+				Stats_IncrementStat( player, "game_stats", "mode_won", GAMETYPE, 1.0 )
+		}
+	}
+
+	// update player's KD
+	foreach ( entity player in GetPlayerArray() )
+	{
+		// kd stats
+		// index 0 is most recent game
+		// index 9 is least recent game
+		float playerKills = ( player in file.playerKills ) ? file.playerKills[ player ] : 0.0
+		float playerDeaths = ( player in file.playerDeaths ) ? file.playerDeaths[ player ] : 0.0
+		float kdratio_match
+		if ( playerDeaths == 0.0 )
+			kdratio_match = playerKills
+		else
+			kdratio_match = playerKills / playerDeaths
+
+		float playerKillsPvp = ( player in file.playerKillsPvp ) ? file.playerKillsPvp[ player ] : 0.0
+		float playerDeathsPvp = ( player in file.playerDeathsPvp ) ? file.playerDeathsPvp[ player ] : 0.0
+		float kdratiopvp_match
+		if ( playerDeathsPvp == 0.0 )
+			kdratiopvp_match = playerKillsPvp
+		else
+			kdratiopvp_match = playerKillsPvp / playerDeathsPvp
+
+		float totalDeaths = player.GetPersistentVarAsInt( "deathStats.total" ).tofloat()
+		float totalKills = player.GetPersistentVarAsInt( "killStats.total" ).tofloat()
+		float totalDeathsPvp = player.GetPersistentVarAsInt( "deathStats.totalPVP" ).tofloat()
+		float totalKillsPvp = player.GetPersistentVarAsInt( "killStats.totalPVP" ).tofloat()
+		float kdratio_lifetime
+		if ( totalDeaths == 0.0 )
+			kdratio_lifetime = totalKills
+		else
+			kdratio_lifetime = totalKills / totalDeaths
+		float kdratio_lifetimepvp
+		if ( totalDeathsPvp == 0.0 )
+			kdratio_lifetimepvp = totalKillsPvp
+		else
+			kdratio_lifetimepvp = totalKillsPvp / totalDeathsPvp
+
+		// shift stats by 1 to make room for new game data
+		for ( int i = NUM_GAMES_TRACK_KDRATIO - 2; i >= 0; --i )
+		{
+			player.SetPersistentVar( format( "kdratio_match[%i]", ( i + 1 ) ), player.GetPersistentVar( format("kdratio_match[%i]", i ) ) )
+			player.SetPersistentVar( format( "kdratiopvp_match[%i]", ( i + 1 ) ), player.GetPersistentVar( format( "kdratiopvp_match[%i]", i ) ) )
+		}
+		// add new game data
+		player.SetPersistentVar( "kdratio_match[0]", kdratio_match )
+		player.SetPersistentVar( "kdratiopvp_match[0]", kdratiopvp_match )
+		player.SetPersistentVar( "kdratio_lifetime", kdratio_lifetime )
+		player.SetPersistentVar( "kdratio_lifetime_pvp", kdratio_lifetimepvp )
+	}
+
+	// award mvp and top 3 in each team
+	if ( !IsFFAGame() )
+	{
+		string gamemode = GameRules_GetGameMode()
+		int functionref( entity, entity ) compareFunc = GameMode_GetScoreCompareFunc( gamemode )
+
+		for( int team = 0; team < MAX_TEAMS; team++ )
+		{
+			array<entity> players = GetPlayerArrayOfTeam( team )
+			if ( compareFunc == null )
+			{
+				printt( "gamemode doesn't have a compare func to get the top 3" )
+				return
+			}
+			players.sort( compareFunc )
+			int maxAwards = int( min( players.len(), 3 ) )
+			for ( int i = 0; i < maxAwards; i++ )
+			{
+				if ( i == 0 )
+					Stats_IncrementStat( players[ i ], "game_stats", "mvp", "", 1.0 )
+				Stats_IncrementStat( players[ i ], "game_stats", "top3OnTeam", "", 1.0 )
+			}
+		}
+
+	}
+}
 
+void function SetLastPosForDistanceStatValid_Threaded( entity player, bool val )
+{
+	WaitFrame()
+	if ( !IsValid( player ) )
+		return
+	player.p.lastPosForDistanceStatValid = val
 }
 
-void function UpdateTitanCoreEarnedStat( entity player, entity titan )
+// Respawn did this through stuff found in _entitystructs.gnut (stuff like stats_wallrunTime)
+// but their implementation seems kinda bad. The advantage it has over this method is not polling
+// every 0.25 seconds, and using movement callbacks and stuff instead. However, since i can't find
+// callbacks for things like changing weapon, i would have to poll for that *anyway* and thus,
+// there is no point in doing things Respawn's way here
+void function HandleDistanceAndTimeStats_Threaded()
 {
+	// just to be safe
+	if ( IsLobby() )
+		return
+
+	while ( GetGameState() < eGameState.Playing )
+		WaitFrame()
+
+	float lastTickTime = Time()
+
+	while( true )
+	{
+		// track distance stats
+		foreach ( entity player in GetPlayerArray() )
+		{
+			if ( player.p.lastPosForDistanceStatValid )
+			{
+				// not 100% sure on using Distance2D over Distance tbh
+				float distInches = Distance2D( player.p.lastPosForDistanceStat, player.GetOrigin() )
+				float distMiles = distInches / 63360.0
+
+				// more generic distance stats
+				Stats_IncrementStat( player, "distance_stats", "total", "", distMiles )
+				if ( player.IsTitan() )
+				{
+					Stats_IncrementStat( player, "distance_stats", "asTitan_" + GetTitanCharacterName( player ), "", distMiles )
+					Stats_IncrementStat( player, "distance_stats", "asTitan", "", distMiles )
+				}
+				else
+					Stats_IncrementStat( player, "distance_stats", "asPilot", "", distMiles )
+
+
+				string state = ""
+				// specific distance stats
+				if ( player.IsWallRunning() )
+					state = "wallrunning"
+				else if ( PlayerIsRodeoingTitan( player ) )
+				{
+					if ( player.GetTitanSoulBeingRodeoed().GetTeam() == player.GetTeam() )
+						state = "onFriendlyTitan"
+					else
+						state = "onEnemyTitan"
+				}
+				else if ( player.IsZiplining() )
+					state = "ziplining"
+				else if ( !player.IsOnGround() )
+					state = "inAir"
+
+				if ( state != "" )
+					Stats_IncrementStat( player, "distance_stats", state, "", distMiles )
+			}
+
+			player.p.lastPosForDistanceStat = player.GetOrigin()
+		}
+
+		float timeSeconds = Time() - lastTickTime
+		float timeHours = timeSeconds / 3600.0
+
+		// track time stats
+		foreach ( entity player in GetPlayerArray() )
+		{
+			// first tick i dont count
+			if ( timeSeconds == 0 )
+				break
+
+			// more generic time stats
+			Stats_IncrementStat( player, "time_stats", "hours_total", "", timeHours )
+			if ( player.IsTitan() )
+			{
+				Stats_IncrementStat( player, "time_stats", "hours_as_titan_" + GetTitanCharacterName( player ), "", timeHours )
+				Stats_IncrementStat( player, "time_stats", "hours_as_titan", "", timeHours )
+			}
+			else
+				Stats_IncrementStat( player, "time_stats", "hours_as_pilot", "", timeHours )
+
+			string state = ""
+			// specific time stats
+			if ( !IsAlive( player ) )
+				state = "hours_dead"
+			else if ( player.IsWallHanging() )
+				state = "hours_wallhanging"
+			else if ( player.IsWallRunning() )
+				state = "hours_wallrunning"
+			else if ( !player.IsOnGround() )
+				state = "hours_inAir"
 
+			if ( state != "" )
+				Stats_IncrementStat( player, "time_stats", state, "", timeHours )
+
+			// weapon time stats
+			entity activeWeapon = player.GetActiveWeapon()
+			if ( IsValid( activeWeapon ) )
+			{
+				if ( IsValidStatItemString( activeWeapon.GetWeaponClassName() ) )
+					Stats_IncrementStat( player, "weapon_stats", "hoursUsed", activeWeapon.GetWeaponClassName(), timeHours )
+
+				foreach( entity weapon in player.GetMainWeapons() )
+				{
+					if ( IsValidStatItemString( weapon.GetWeaponClassName() ) )
+						Stats_IncrementStat( player, "weapon_stats", "hoursEquipped", weapon.GetWeaponClassName(), timeHours )
+				}
+			}
+
+			// map time stats
+			Stats_IncrementStat( player, "game_stats", "hoursPlayed", "", timeHours )
+		}
+
+		lastTickTime = Time()
+		// not rly worth doing this every frame, just a couple of times per second should be fine
+		wait 0.25
+	}
+}
+
+// this is kinda shit
+void function SaveStatsPeriodically_Threaded()
+{
+	while( true )
+	{
+		foreach( entity player in GetPlayerArray() )
+			Stats_SaveAllStats( player )
+		wait 5
+	}
 }
 
-void function PreScoreEventUpdateStats(entity attacker, entity ent)
+bool function IsValidGamemodeString( string mode )
 {
+	int gameModeCount = PersistenceGetEnumCount( "gameModes" )
+	for ( int modeIndex = 0; modeIndex < gameModeCount; modeIndex++ )
+	{
+		string gameModeName = PersistenceGetEnumItemNameForIndex( "gameModes", modeIndex )
+
+		if ( gameModeName == mode )
+			return true
+	}
 
+	return false
 }
 
-void function PostScoreEventUpdateStats(entity attacker, entity ent)
+bool function IsValidStatItemString( string item )
 {
+	foreach( str in shGlobalMP.statsItemsList )
+	{
+		if ( str == item )
+			return true
+	}
 
+	return false
 }
 
-void function Stats_OnPlayerDidDamage(entity player, var damageInfo)
+string function GetPersistenceRefFromDamageInfo( var damageInfo )
 {
+	string damageSourceString = DamageSourceIDToString( DamageInfo_GetDamageSourceIdentifier( damageInfo ) )
+
+	foreach( str in shGlobalMP.statsItemsList )
+	{
+		if ( str == damageSourceString )
+			return damageSourceString
+	}
 
+	return ""
+}
+
+bool function DamageIsTitanMelee( int damageSourceId )
+{
+	switch( damageSourceId )
+	{
+		case eDamageSourceId.melee_titan_punch:
+		case eDamageSourceId.melee_titan_punch_ion:
+		case eDamageSourceId.melee_titan_punch_legion:
+		case eDamageSourceId.melee_titan_punch_tone:
+		case eDamageSourceId.melee_titan_punch_scorch:
+		case eDamageSourceId.melee_titan_punch_northstar:
+		case eDamageSourceId.melee_titan_punch_fighter:
+		case eDamageSourceId.melee_titan_sword:
+		case eDamageSourceId.melee_titan_sword_aoe:
+			return true
+		default:
+			return false
+	}
+	unreachable
 }
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/sh_loadouts.nut b/Northstar.CustomServers/mod/scripts/vscripts/sh_loadouts.nut
index 85f5aa05..7a7498b8 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/sh_loadouts.nut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/sh_loadouts.nut
@@ -785,7 +785,7 @@ bool function IsSettingPrimeTitanWithoutSetFile( entity player, string loadoutTy
 

 bool function SkipItemLockedCheck( entity player, string ref, string parentRef, string loadoutProperty ) //Hack: Skip entitlement related unlock checks for now. Can fail.

 {

-	if ( DevEverythingUnlocked() )

+	if ( DevEverythingUnlocked( player ) )

 		return true

 

 	//if ( IsItemInEntitlementUnlock( ref ) && IsLobby()  ) //TODO: Look into restricting this to lobby only? But entitlement checks can fail randomly...

@@ -3993,7 +3993,7 @@ bool function IsValidTitanLoadoutIndex( int loadoutIndex )
 

 bool function HasPrimeToMatchExecutionType( entity player, int itemType )

 {

-	if ( DevEverythingUnlocked() )

+	if ( DevEverythingUnlocked( player ) )

 		return true

 

 	switch( itemType )

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
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/sh_utility_all.gnut b/Northstar.CustomServers/mod/scripts/vscripts/sh_utility_all.gnut
index 7f356a18..a2de9913 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/sh_utility_all.gnut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/sh_utility_all.gnut
@@ -386,8 +386,12 @@ float function RoundToNearestMultiplier( float value, float multiplier )
 	return value
 }
 
-function DevEverythingUnlocked()
+function DevEverythingUnlocked( entity player = null )
 {
+	// check if player has opted into progression or not
+	if ( player != null && ProgressionEnabledForPlayer( player ) )
+		return false
+
 	return EverythingUnlockedConVarEnabled()
 }
 
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/titan_xp.gnut b/Northstar.CustomServers/mod/scripts/vscripts/titan_xp.gnut
index 4bfeb4f8..0436a393 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/titan_xp.gnut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/titan_xp.gnut
@@ -10,5 +10,8 @@ void function AddTitanXP( entity player, int amount )
 	
 	// level up notif
 	if ( TitanGetLevel( player, titan ) != oldLevel )
+	{
 		Remote_CallFunction_NonReplay( player, "ServerCallback_TitanLeveledUp", shTitanXP.titanClasses.find( titan ), TitanGetGen( player, titan ), TitanGetLevel( player, titan ) )
+		AddPlayerScore( player, "TitanLevelUp" )
+	}
 }
\ No newline at end of file
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/weapon_xp.gnut b/Northstar.CustomServers/mod/scripts/vscripts/weapon_xp.gnut
index 8e100257..4e25e301 100644
--- a/Northstar.CustomServers/mod/scripts/vscripts/weapon_xp.gnut
+++ b/Northstar.CustomServers/mod/scripts/vscripts/weapon_xp.gnut
@@ -12,8 +12,11 @@ void function AddWeaponXP( entity player, int amount )
 	
 	// level up notif
 	if ( WeaponGetLevel( player, weaponClassname ) != oldLevel )
+	{
 		Remote_CallFunction_NonReplay( player, "ServerCallback_WeaponLeveledUp", shWeaponXP.weaponClassNames.find( weaponClassname ), WeaponGetGen( player, weaponClassname ), WeaponGetLevel( player, weaponClassname ) )
-	
+		AddPlayerScore( player, "WeaponLevelUp" )
+	}
+
 	// proscreen 
 	if ( player == activeWeapon.GetProScreenOwner() )
 	{