Change to Thunderstore template

For easier publishing to both platforms

mods/ToneAPI.pulse/mod/scripts/vscripts/ui/menu_stats_maps.nut

@@ -0,0 +1,318 @@
+global function InitViewStatsMapsMenu
+global function setit
+
+struct
+{
+	var menu
+	GridMenuData gridData
+	bool isGridInitialized = false
+	array<string> allMaps
+} file
+
+void function InitViewStatsMapsMenu()
+{
+	var menu = GetMenu( "ViewStats_Maps_Menu" )
+	file.menu = menu
+
+	Hud_SetText( Hud_GetChild( file.menu, "MenuTitle" ), "#STATS_MAPS" )
+
+	file.gridData.rows = 5
+	file.gridData.columns = 1
+	//file.gridData.numElements // Set in OnViewStatsWeapons_Open after itemdata exists
+	file.gridData.pageType = eGridPageType.VERTICAL
+	file.gridData.tileWidth = 224
+	file.gridData.tileHeight = 112
+	file.gridData.paddingVert = 6
+	file.gridData.paddingHorz = 6
+
+	Grid_AutoAspectSettings( menu, file.gridData )
+
+	file.gridData.initCallback = MapButton_Init
+	file.gridData.getFocusCallback = MapButton_GetFocus
+	file.gridData.clickCallback = MapButton_Activate
+
+	AddMenuEventHandler( file.menu, eUIEvent.MENU_OPEN, OnViewStatsWeapons_Open )
+
+	AddMenuFooterOption( file.menu, BUTTON_B, "#B_BUTTON_BACK", "#BACK" )
+}
+
+void function OnViewStatsWeapons_Open()
+{
+	UI_SetPresentationType( ePresentationType.NO_MODELS )
+
+	file.allMaps = GetPrivateMatchMaps()
+
+	file.gridData.numElements = file.allMaps.len()
+
+	if ( !file.isGridInitialized )
+	{
+		GridMenuInit( file.menu, file.gridData )
+		file.isGridInitialized = true
+	}
+
+	file.gridData.currentPage = 0
+
+	Grid_InitPage( file.menu, file.gridData )
+	Hud_SetFocused( Grid_GetButtonForElementNumber( file.menu, 0 ) )
+}
+
+bool function MapButton_Init( var button, int elemNum )
+{
+	string mapName = file.allMaps[ elemNum ]
+	UpdateStatsForMap( mapName )
+	asset mapImage = GetMapImageForMapName( mapName )
+
+	var rui = Hud_GetRui( button )
+	RuiSetImage( rui, "buttonImage", mapImage )
+
+	Hud_SetEnabled( button, true )
+	Hud_SetVisible( button, true )
+
+	return true
+}
+
+void function MapButton_GetFocus( var button, int elemNum )
+{
+	if ( IsControllerModeActive() )
+		UpdateStatsForMap( file.allMaps[ elemNum ] )
+}
+
+void function MapButton_Activate( var button, int elemNum )
+{
+	if ( !IsControllerModeActive() )
+		UpdateStatsForMap( file.allMaps[ elemNum ] )
+}
+
+int function GetGameStatForMapInt( string gameStat, string mapName )
+{
+	array<string> privateMatchModes = GetPrivateMatchModes()
+
+	int totalStat = 0
+	int enumCount = PersistenceGetEnumCount( "gameModes" )
+	for ( int modeId = 0; modeId < enumCount; modeId++ )
+	{
+		string modeName = PersistenceGetEnumItemNameForIndex( "gameModes", modeId )
+
+		totalStat += GetGameStatForMapAndModeInt( gameStat, mapName, modeName )
+	}
+
+	return totalStat
+}
+
+int function GetGameStatForMapAndModeInt( string gameStat, string mapName, string modeName, string difficulty = "1" )
+{
+	string statString = GetStatVar( "game_stats", gameStat, "" )
+	string persistentVar = Stats_GetFixedSaveVar( statString, mapName, modeName, difficulty )
+
+	return GetUIPlayer().GetPersistentVarAsInt( persistentVar )
+}
+
+float function GetGameStatForMapFloat( string gameStat, string mapName )
+{
+	array<string> privateMatchModes = GetPrivateMatchModes()
+
+	float totalStat = 0
+	int enumCount = PersistenceGetEnumCount( "gameModes" )
+	for ( int modeId = 0; modeId < enumCount; modeId++ )
+	{
+		string modeName = PersistenceGetEnumItemNameForIndex( "gameModes", modeId )
+
+		totalStat += GetGameStatForMapAndModeFloat( gameStat, mapName, modeName )
+	}
+
+	return totalStat
+}
+
+float function GetGameStatForMapAndModeFloat( string gameStat, string mapName, string modeName )
+{
+	string statString = GetStatVar( "game_stats", gameStat, "" )
+	string persistentVar = Stats_GetFixedSaveVar( statString, mapName, modeName, "1" )
+
+	return expect float( GetUIPlayer().GetPersistentVar( persistentVar ) )
+}
+
+
+void function UpdateStatsForMap( string mapName )
+{
+	entity player = GetUIPlayer()
+	if ( player == null )
+		return
+
+	Hud_SetText( Hud_GetChild( file.menu, "WeaponName" ), GetMapDisplayName( mapName ) )
+
+	// Image
+	var imageElem = Hud_GetRui( Hud_GetChild( file.menu, "WeaponImageLarge" ) )
+	RuiSetImage( imageElem, "basicImage", GetMapImageForMapName( mapName ) )
+
+	string timePlayed = "null"
+	string gamesPlayed = "null"
+
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat0" ), Localize( "#STATS_HEADER_TIME_PLAYED" ), 		timePlayed )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat1" ), Localize( "#STATS_GAMES_PLAYED" ), 				gamesPlayed )
+	//SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat2" ), Localize( "#STATS_GAMES_PLAYED" ), 				gamesPlayed )
+	//SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat3" ), Localize( "#STATS_GAMES_PLAYED" ), 				gamesPlayed )
+
+	SetStatsLabelValue( file.menu, "KillsLabel0", 				"KILLS ON MAP" )
+	SetStatsLabelValue( file.menu, "KillsValue0", 				pulseParse(mapName, "maps", "kills") )
+
+	SetStatsLabelValue( file.menu, "KillsLabel1", 				"DEATHS ON MAP" )
+	SetStatsLabelValue( file.menu, "KillsValue1", 				pulseParse(mapName, "maps", "deaths") )
+
+	SetStatsLabelValue( file.menu, "KillsLabel2", 				"TOTAL SHOT DISTANCE" )
+	SetStatsLabelValue( file.menu, "KillsValue2", 				string(int((1.905 * float(pulseParse(mapName, "maps", "total_distance") ) ) )/100) + "m" )
+
+	SetStatsLabelValue( file.menu, "KillsLabel3", 				"MAXIMUM SHOT DISTANCE" )
+	SetStatsLabelValue( file.menu, "KillsValue3", 				string(int((1.905 * float(pulseParse(mapName, "maps", "max_distance") ) ) )/100) + "m" )
+
+	SetStatsLabelValue( file.menu, "KillsLabel4", 				"--" )
+	SetStatsLabelValue( file.menu, "KillsValue4", 				"--" )
+
+	//var anchorElem = Hud_GetChild( file.menu, "WeaponStatsBackground" )
+	//printt( Hud_GetX( anchorElem ) )
+	//printt( Hud_GetX( anchorElem ) )
+	//printt( Hud_GetX( anchorElem ) )
+	//printt( Hud_GetX( anchorElem ) )
+	//Hud_SetX( anchorElem, 0 )
+	//
+	array<string> gameModesArray = GetPersistenceEnumAsArray( "gameModes" )
+
+	array<PieChartEntry> modes
+	int enumCount = PersistenceGetEnumCount( "gameModes" )
+	table< string, array<int> > customGamemodeList = {
+		sns = [255, 178, 102, 255],
+		fw = [147, 204, 57, 255],
+		gg = [14, 87, 132, 255]
+	}
+	table< string, string > customGamemodeNames = {
+		sns = "Sticks and Stones"
+		fw = "Frontier War"
+		gg = "Gun Game"
+	}
+	for ( int modeId = 0; modeId < enumCount; modeId++ )
+	{
+		string modeName = PersistenceGetEnumItemNameForIndex( "gameModes", modeId )
+		if (mapName in pulseData["gamemodesSeparated"])
+		{
+			float modePlayedTime = 0
+			modePlayedTime = float(pulseParse(mapName, "gamemodesSeparated", modeName, "kills"))
+			if ( modePlayedTime > 0 ) {
+				AddPieChartEntry( modes, GameMode_GetName( modeName ), modePlayedTime, GetGameModeDisplayColor( modeName ) )
+			}
+		}
+	}
+	foreach (string key, array<int> value in customGamemodeList)
+	{
+		if (mapName in pulseData["gamemodesSeparated"])
+		{
+			float modePlayedTime = 0
+			modePlayedTime = float(pulseParse(mapName, "gamemodesSeparated", key, "kills"))
+			if ( modePlayedTime > 0 ) {
+				AddPieChartEntry( modes, customGamemodeNames[key], modePlayedTime, value)
+			}
+		}
+	}
+	const MAX_MODE_ROWS = 8
+
+	if ( modes.len() > 0 )
+	{
+		modes.sort( ComparePieChartEntryValues )
+
+		if ( modes.len() > MAX_MODE_ROWS )
+		{
+			float otherValue
+			for ( int i = MAX_MODE_ROWS-1; i < modes.len() ; i++ )
+				otherValue += modes[i].numValue
+
+			modes.resize( MAX_MODE_ROWS-1 )
+			AddPieChartEntry( modes, "#GAMEMODE_OTHER", otherValue, [127, 127, 127, 255] )
+		}
+	}
+
+	PieChartData modesPlayedData
+	modesPlayedData.entries = modes
+	modesPlayedData.labelColor = [ 255, 255, 255, 255 ]
+	SetPieChartData( file.menu, "ModesPieChart", "KILLS BY GAMEMODE", modesPlayedData )
+
+	array<string> fdMaps = GetPlaylistMaps( "fd" )
+
+	if ( 0 == 1 )  // maybe work later on some FD servers
+	{
+		array<var> pveElems = GetElementsByClassname( file.menu, "PvEGroup" )
+		foreach ( elem in pveElems )
+		{
+			Hud_Show( elem )
+		}
+
+		vector perfectColor = TEAM_COLOR_FRIENDLY / 219.0
+
+		var iconLegendRui = Hud_GetRui( Hud_GetChild( file.menu, "PvEIconLegend" ) )
+		RuiSetImage( iconLegendRui, "basicImage", $"rui/menu/gametype_select/playlist_fd_normal" )
+		RuiSetFloat3( iconLegendRui, "basicImageColor", perfectColor )
+
+		var icon0Rui = Hud_GetRui( Hud_GetChild( file.menu, "PvEIcon0" ) )
+		RuiSetImage( icon0Rui, "basicImage", $"rui/menu/gametype_select/playlist_fd_easy" )
+		int easyWins = GetGameStatForMapAndModeInt( "games_completed_fd", mapName, "fd", "0" )
+		SetStatsLabelValue( file.menu, "PvELabel0", 				"#FD_DIFFICULTY_EASY" )
+		SetStatsLabelValue( file.menu, "PvEValueA0", 				easyWins )
+		if ( GetGameStatForMapAndModeInt( "perfectMatches", mapName, "fd", "0" ) )
+			RuiSetFloat3( icon0Rui, "basicImageColor", perfectColor )
+		else
+			RuiSetFloat3( icon0Rui, "basicImageColor", easyWins > 0 ? <1, 1, 1> : <0.15, 0.15, 0.15> )
+
+		var icon1Rui = Hud_GetRui( Hud_GetChild( file.menu, "PvEIcon1" ) )
+		RuiSetImage( icon1Rui, "basicImage", $"rui/menu/gametype_select/playlist_fd_normal" )
+		int normalWins = GetGameStatForMapAndModeInt( "games_completed_fd", mapName, "fd", "1" )
+		SetStatsLabelValue( file.menu, "PvELabel1", 				"#FD_DIFFICULTY_NORMAL" )
+		SetStatsLabelValue( file.menu, "PvEValueA1", 				normalWins )
+		if ( GetGameStatForMapAndModeInt( "perfectMatches", mapName, "fd", "1" ) )
+			RuiSetFloat3( icon1Rui, "basicImageColor", perfectColor )
+		else
+			RuiSetFloat3( icon1Rui, "basicImageColor", normalWins > 0 ? <1, 1, 1> : <0.15, 0.15, 0.15> )
+
+		var icon2Rui = Hud_GetRui( Hud_GetChild( file.menu, "PvEIcon2" ) )
+		RuiSetImage( icon2Rui, "basicImage", $"rui/menu/gametype_select/playlist_fd_hard" )
+		int hardWins = GetGameStatForMapAndModeInt( "games_completed_fd", mapName, "fd", "2" )
+		SetStatsLabelValue( file.menu, "PvELabel2", 				"#FD_DIFFICULTY_HARD" )
+		SetStatsLabelValue( file.menu, "PvEValueA2", 				hardWins )
+		if ( GetGameStatForMapAndModeInt( "perfectMatches", mapName, "fd", "2" ) )
+			RuiSetFloat3( icon2Rui, "basicImageColor", perfectColor )
+		else
+			RuiSetFloat3( icon2Rui, "basicImageColor", hardWins > 0 ? <1, 1, 1> : <0.15, 0.15, 0.15> )
+
+		var icon3Rui = Hud_GetRui( Hud_GetChild( file.menu, "PvEIcon3" ) )
+		RuiSetImage( icon3Rui, "basicImage", $"rui/menu/gametype_select/playlist_fd_master" )
+		int masterWins = GetGameStatForMapAndModeInt( "games_completed_fd", mapName, "fd", "3" )
+		SetStatsLabelValue( file.menu, "PvELabel3", 				"#FD_DIFFICULTY_MASTER" )
+		SetStatsLabelValue( file.menu, "PvEValueA3", 				masterWins )
+		if ( GetGameStatForMapAndModeInt( "perfectMatches", mapName, "fd", "3" ) )
+			RuiSetFloat3( icon3Rui, "basicImageColor", perfectColor )
+		else
+			RuiSetFloat3( icon3Rui, "basicImageColor", masterWins > 0 ? <1, 1, 1> : <0.15, 0.15, 0.15> )
+
+		var icon4Rui = Hud_GetRui( Hud_GetChild( file.menu, "PvEIcon4" ) )
+		RuiSetImage( icon4Rui, "basicImage", $"rui/menu/gametype_select/playlist_fd_insane" )
+		int insaneWins = GetGameStatForMapAndModeInt( "games_completed_fd", mapName, "fd", "4" )
+		SetStatsLabelValue( file.menu, "PvELabel4", 				"#FD_DIFFICULTY_INSANE" )
+		SetStatsLabelValue( file.menu, "PvEValueA4", 				insaneWins )
+		if ( GetGameStatForMapAndModeInt( "perfectMatches", mapName, "fd", "4" ) )
+			RuiSetFloat3( icon4Rui, "basicImageColor", perfectColor )
+		else
+			RuiSetFloat3( icon4Rui, "basicImageColor", insaneWins > 0 ? <1, 1, 1> : <0.15, 0.15, 0.15> )
+	}
+	else
+	{
+		array<var> pveElems = GetElementsByClassname( file.menu, "PvEGroup" )
+		foreach ( elem in pveElems )
+		{
+			Hud_Hide( elem )
+		}
+	}
+}
+
+
+var function setit( vector color )
+{
+	var iconLegendRui = Hud_GetRui( Hud_GetChild( file.menu, "PvEIconLegend" ) )
+	RuiSetImage( iconLegendRui, "basicImage", $"rui/menu/gametype_select/playlist_fd_normal" )
+	RuiSetFloat3( iconLegendRui, "basicImageColor", color )
+}

mods/ToneAPI.pulse/mod/scripts/vscripts/ui/menu_stats_overview.nut

@@ -0,0 +1,547 @@
+untyped
+
+global function InitViewStatsOverviewMenu
+
+struct
+{
+	var menu
+	array<ItemDisplayData> allTitans
+	array<ItemDisplayData> allPilotWeapons
+	table<string, array<string> > titanStatLoadout
+} file
+
+const MAX_DOTS_ON_GRAPH = 10
+table <string, int> titanKillData = {}
+table <string, int> pilotKillData = {}
+
+const IMAGE_TITAN_STRYDER = $"ui/menu/personal_stats/ps_titan_icon_stryder"
+const IMAGE_TITAN_ATLAS = $"ui/menu/personal_stats/ps_titan_icon_atlas"
+const IMAGE_TITAN_OGRE = $"ui/menu/personal_stats/ps_titan_icon_ogre"
+
+void function InitViewStatsOverviewMenu()
+{
+	PrecacheHUDMaterial( IMAGE_TITAN_STRYDER )
+	PrecacheHUDMaterial( IMAGE_TITAN_ATLAS )
+	PrecacheHUDMaterial( IMAGE_TITAN_OGRE )
+
+	var menu = GetMenu( "ViewStats_Overview_Menu" )
+	file.menu = menu
+
+	AddMenuEventHandler( menu, eUIEvent.MENU_OPEN, OnStatsOverview_Open )
+
+	AddMenuFooterOption( menu, BUTTON_B, "#B_BUTTON_BACK", "#BACK" )
+}
+
+void function GetTitanKills( string titanName )
+{
+	file.allTitans = GetVisibleItemsOfType( eItemTypes.TITAN )
+	var dataTable = GetDataTable( $"datatable/titan_properties.rpak" )
+
+	foreach ( titan in file.allTitans )
+	{
+		file.titanStatLoadout[ titan.ref ] <- []
+
+		int row = GetDataTableRowMatchingStringValue( dataTable, GetDataTableColumnByName( dataTable, "titanRef" ), titan.ref )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "primary" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "ordnance" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "special" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "antirodeo" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "coreAbility" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "melee" ) ) )
+	}
+
+	foreach ( weaponRef in file.titanStatLoadout[ titanName ])
+	{
+		titanKillData[weaponRef] <- pulseParse(weaponRef, "weaponsLocal", "kills")
+	}
+}
+
+void function GetAllPilotWeapons()
+{
+	file.allPilotWeapons = GetVisibleItemsOfType( eItemTypes.PILOT_PRIMARY)
+	file.allPilotWeapons.extend(GetVisibleItemsOfType( eItemTypes.PILOT_SECONDARY) )
+	file.allPilotWeapons.extend(GetVisibleItemsOfType( eItemTypes.PILOT_ORDNANCE) )
+	file.allPilotWeapons.extend( GetVisibleItemsOfType( eItemTypes.PILOT_SPECIAL ) )
+}
+
+
+void function OnStatsOverview_Open()
+{
+	UI_SetPresentationType( ePresentationType.NO_MODELS )
+
+	GetTitanKills("ion")
+	GetTitanKills("scorch")
+	GetTitanKills("northstar")
+	GetTitanKills("ronin")
+	GetTitanKills("tone")
+	GetTitanKills("legion")
+	GetTitanKills("vanguard")
+
+	UpdateViewStatsOverviewMenu()
+}
+
+function UpdateViewStatsOverviewMenu()
+{
+	entity player = GetUIPlayer()
+	if ( player == null )
+		return
+
+	//#########################
+	// 		  Games
+	//#########################
+
+	string timePlayed = StatToTimeString( "time_stats", "hours_total" )
+	int gamesPlayed = GetPlayerStat_AllCompetitiveModesAndMapsInt( player, "game_stats", "game_completed" )
+	int gamesWon = GetPlayerStat_AllCompetitiveModesAndMapsInt( player, "game_stats", "game_won" )
+	string winPercent = GetPercent( float( gamesWon ), float( gamesPlayed ), 0 )
+	int timesMVP = GetPlayerStatInt( player, "game_stats", "mvp_total" )
+	int timesTop3 = GetPlayerStat_AllCompetitiveModesAndMapsInt( player, "game_stats", "top3OnTeam" )
+
+	//SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat0" ), Localize( "#STATS_HEADER_TIME_PLAYED" ), timePlayed )
+	//SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat1" ), Localize( "#STATS_GAMES_PLAYED" ), 		string( gamesPlayed ) )
+	//SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat2" ), Localize( "#STATS_GAMES_WON" ), 			string( gamesWon ) )
+	//SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat3" ), Localize( "#STATS_GAMES_WIN_PERCENT" ), 	Localize( "#STATS_PERCENTAGE", winPercent ) )
+	//SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat4" ), Localize( "#STATS_GAMES_MVP" ), 			string( timesMVP ) )
+	//SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat5" ), Localize( "#STATS_GAMES_TOP3" ), 		string( timesTop3 ) )
+
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat0" ), Localize( "#STATS_HEADER_TIME_PLAYED" ), string( 0 ))
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat1" ), Localize( "#STATS_GAMES_PLAYED" ), 		string( 0 ) )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat2" ), Localize( "#STATS_GAMES_WON" ), 			string( 0 ) )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat3" ), Localize( "#STATS_GAMES_WIN_PERCENT" ), 	string( 0 ) )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat4" ), Localize( "#STATS_GAMES_MVP" ), 			string( 0 ) )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat5" ), Localize( "#STATS_GAMES_TOP3" ), 		string( 0 ) )
+
+	//#########################
+	// 		   Modes
+	//#########################
+
+	/*local gameModePlayedVar = GetStatVar( "game_stats", "mode_played" )
+	local basicModes = [ "tdm", "cp", "at", "lts", "ctf" ]
+
+	local timesPlayedArray = []
+	local gameModeNamesArray = []
+	local otherGameModesPlayed = 0
+	array<string> gameModesArray = GetPersistenceEnumAsArray( "gameModes" )
+
+	foreach ( modeName in gameModesArray )
+	{
+		local gameModePlaysVar = StringReplace( expect string( gameModePlayedVar ), "%gamemode%", modeName )
+		local timesPlayed = player.GetPersistentVar( gameModePlaysVar )
+
+		if ( basicModes.contains( modeName ) )  //Don't really like doing ArrayContains, but Chad prefers not storing a separate enum in persistence that contains the "other" gamemodes
+		{
+			timesPlayedArray.append( timesPlayed )
+			gameModeNamesArray.append( GAMETYPE_TEXT[ modeName] )
+		}
+		else
+		{
+			otherGameModesPlayed += timesPlayed
+		}
+	}
+
+	//Add Other game modes' data to the end of the arrays
+	gameModeNamesArray.append( "#GAMEMODE_OTHER"  )
+	timesPlayedArray.append( otherGameModesPlayed )
+
+	local data = {}
+	data.names <- gameModeNamesArray
+	data.values <- timesPlayedArray
+
+	SetPieChartData( menu, "ModesPieChart", "#GAME_MODES_PLAYED", data )*/
+
+	//#########################
+	// 		Completion
+	//#########################
+
+	// Challenges complete
+	//local challengeData = GetChallengeCompleteData()
+	//SetStatsBarValues( menu, "CompletionBar0", "#STATS_COMPLETION_CHALLENGES", 		0, challengeData.total, challengeData.complete )
+
+	// Item unlocks
+	//local itemUnlockData = GetItemUnlockCountData()
+	//SetStatsBarValues( menu, "CompletionBar1", "#STATS_COMPLETION_WEAPONS", 	0, itemUnlockData["weapons"].total, 	itemUnlockData["weapons"].unlocked )
+	//SetStatsBarValues( menu, "CompletionBar2", "#STATS_COMPLETION_ATTACHMENTS", 0, itemUnlockData["attachments"].total, itemUnlockData["attachments"].unlocked )
+	//SetStatsBarValues( menu, "CompletionBar3", "#STATS_COMPLETION_MODS", 		0, itemUnlockData["mods"].total, 		itemUnlockData["mods"].unlocked )
+	//SetStatsBarValues( menu, "CompletionBar4", "#STATS_COMPLETION_ABILITIES", 	0, itemUnlockData["abilities"].total, 	itemUnlockData["abilities"].unlocked )
+	//SetStatsBarValues( menu, "CompletionBar5", "#STATS_COMPLETION_GEAR", 		0, itemUnlockData["gear"].total, 		itemUnlockData["gear"].unlocked )
+
+	//#########################
+	// 		  Weapons
+	//#########################
+
+	table<string, table> weaponData = GetOverviewWeaponData()
+	table mostKillsData = weaponData[ "most_kills" ]
+	table nemesisWeapon = weaponData[ "nemesis_weapon" ]
+	table highestKPMData = weaponData[ "highest_kpm" ]
+
+	var weaponImageElem
+	var weaponRui
+	var weaponNameElem
+	var weaponDescElem
+	var noDataElem
+
+	// Weapon with most kills
+	weaponImageElem = Hud_GetChild( file.menu, "WeaponImage0" )
+	weaponRui = Hud_GetRui( weaponImageElem )
+	weaponNameElem = Hud_GetChild( file.menu, "WeaponName0" )
+	weaponDescElem = Hud_GetChild( file.menu, "WeaponDesc0" )
+	noDataElem = Hud_GetChild( file.menu, "WeaponImageTextOverlay0" )
+	if ( mostKillsData.ref != "" )
+	{
+		SetItemImageWidth( weaponImageElem, expect string( mostKillsData.ref ) )
+		RuiSetImage( weaponRui, "buttonImage", GetItemImage( expect string( mostKillsData.ref ) ) )
+		Hud_Show( weaponImageElem )
+		Hud_SetText( weaponNameElem, mostKillsData.printName )
+		Hud_Show( weaponNameElem )
+		Hud_SetText( weaponDescElem, "#STATS_MOST_KILLS_VALUE", mostKillsData.val )
+		Hud_Show( weaponDescElem )
+		Hud_Hide( noDataElem )
+	}
+	else
+	{
+		Hud_Hide( weaponImageElem )
+		Hud_Hide( weaponNameElem )
+		Hud_Hide( weaponDescElem )
+		Hud_Show( noDataElem )
+	}
+
+	// Most Used Weapon
+	weaponImageElem = Hud_GetChild( file.menu, "WeaponImage1" )
+	weaponRui = Hud_GetRui( weaponImageElem )
+	weaponNameElem = Hud_GetChild( file.menu, "WeaponName1" )
+	weaponDescElem = Hud_GetChild( file.menu, "WeaponDesc1" )
+	noDataElem = Hud_GetChild( file.menu, "WeaponImageTextOverlay1" )
+	if ( nemesisWeapon.ref != "" )
+	{
+		SetItemImageWidth( weaponImageElem, expect string( nemesisWeapon.ref ) )
+		RuiSetImage( weaponRui, "buttonImage", GetItemImage( expect string( nemesisWeapon.ref ) ) )
+		Hud_Show( weaponImageElem )
+		Hud_SetText( weaponNameElem, nemesisWeapon.printName )
+		Hud_Show( weaponNameElem )
+		Hud_SetText( weaponDescElem, nemesisWeapon.val + " DEATHS BY WEAPON" )
+		Hud_Show( weaponDescElem )
+		Hud_Hide( noDataElem )
+	}
+	else
+	{
+		Hud_Hide( weaponImageElem )
+		Hud_Hide( weaponNameElem )
+		Hud_Hide( weaponDescElem )
+		Hud_Show( noDataElem )
+	}
+
+	// Weapon with highest KPM
+	weaponImageElem = Hud_GetChild( file.menu, "WeaponImage2" )
+	weaponRui = Hud_GetRui( weaponImageElem )
+	weaponNameElem = Hud_GetChild( file.menu, "WeaponName2" )
+	weaponDescElem = Hud_GetChild( file.menu, "WeaponDesc2" )
+	noDataElem = Hud_GetChild( file.menu, "WeaponImageTextOverlay2" )
+	if ( highestKPMData.ref != "" )
+	{
+		SetItemImageWidth( weaponImageElem, expect string( highestKPMData.ref ) )
+		RuiSetImage( weaponRui, "buttonImage", GetItemImage( expect string( highestKPMData.ref ) ) )
+		Hud_Show( weaponImageElem )
+		Hud_SetText( weaponNameElem, highestKPMData.printName )
+		Hud_Show( weaponNameElem )
+		Hud_SetText( weaponDescElem, highestKPMData.val + " K/D")
+		Hud_Show( weaponDescElem )
+		Hud_Hide( noDataElem )
+	}
+	else
+	{
+		Hud_Hide( weaponImageElem )
+		Hud_Hide( weaponNameElem )
+		Hud_Hide( weaponDescElem )
+		Hud_Show( noDataElem )
+	}
+
+	//#########################
+	// 		Titan Unlocks
+	//#########################
+
+	Assert( player == GetUIPlayer() )
+	Assert( player != null )
+
+	int unlockedCount = 0
+
+	//var imageLabel = GetElem( menu, "TitanUnlockImage0" )
+	//if ( !IsItemLocked( player, "titan_stryder" ) )
+	//{
+	//	imageLabel.SetImage( IMAGE_TITAN_STRYDER )
+	//	unlockedCount++
+	//}
+	//else
+	//	imageLabel.SetImage( $"ui/menu/personal_stats/ps_titan_icon_locked" )
+	//
+	//imageLabel = GetElem( menu, "TitanUnlockImage1" )
+	//if ( !IsItemLocked( player, "titan_atlas" ) )
+	//{
+	//	imageLabel.SetImage( IMAGE_TITAN_ATLAS )
+	//	unlockedCount++
+	//}
+	//else
+	//	imageLabel.SetImage( $"ui/menu/personal_stats/ps_titan_icon_locked" )
+	//
+	//imageLabel = GetElem( menu, "TitanUnlockImage2" )
+	//if ( !IsItemLocked( player, "titan_ogre" ) )
+	//{
+	//	imageLabel.SetImage( IMAGE_TITAN_OGRE )
+	//	unlockedCount++
+	//}
+	//else
+	//	imageLabel.SetImage( $"ui/menu/personal_stats/ps_titan_icon_locked" )
+	//
+	//var unlockCountLabel = GetElem( menu, "TitanUnlocksCount" )
+	//Hud_SetText( unlockCountLabel, "#STATS_CHASSIS_UNLOCK_COUNT", string( unlockedCount ) )
+
+	//#########################
+	// 	   K/D Ratios
+	//#########################
+
+	// Lifetime
+	table playerweaponData = expect table(pulseData["weaponsLocal"])
+	table globalweaponData = expect table(pulseData["weaponsGlobal"])
+	var totalPilotKills = 0
+
+	foreach (var key, var value in playerweaponData) {
+		table values = expect table(value)
+		totalPilotKills += values["kills"]
+	}
+
+	var totalGlobalKills = 0
+	foreach (var key, var value in globalweaponData) {
+		table values = expect table(value)
+		totalGlobalKills += values["kills"]
+	}
+
+	var totalPilotDeaths = 0
+	foreach (var key, var value in playerweaponData) {
+		table values = expect table(value)
+		totalPilotDeaths += values["deaths"]
+	}
+
+	var totalGlobalDeaths = 0
+	foreach (var key, var value in globalweaponData) {
+		table values = expect table(value)
+		totalGlobalDeaths += values["deaths"]
+	}
+
+
+	var killsAsPilot = 0
+	foreach (var key, var value in playerweaponData) {
+		if (key in titanKillData) {
+			continue
+		} else {
+			killsAsPilot += pulseParse(string(key), "weaponsLocal", "kills")
+		}
+	}
+
+	var killsAsTitan = 0
+	foreach (var key, var value in playerweaponData) {
+		if (key in titanKillData) {
+			killsAsTitan += titanKillData[string(key)]
+		}
+	}
+
+	float kval = float(totalPilotKills)
+	float dval = float(totalPilotDeaths)
+	float kdval = float(int((kval / dval)*100))/100
+
+	float gkval = float(totalGlobalKills)
+	float gdval = float(totalGlobalDeaths)
+	float gkdval = float(int((gkval / gdval)*100))/100
+
+	SetStatsLabelValue( file.menu, "LifetimeAverageValue", [ "#STATS_KD_VALUE", kdval ] )
+
+	SetStatsLabelValue( file.menu, "LifetimePVPAverageValue", [ "#STATS_KD_VALUE", gkdval ] )
+
+	bool last10GamesStatsVisible = gamesPlayed >= NUM_GAMES_TRACK_KDRATIO ? true : false
+	SetLast10GamesStatVisibility( file.menu, last10GamesStatsVisible )
+
+	// Last 10 Matches
+	local kdratio_match = []
+	local kdratiopvp_match = []
+	for ( int i = NUM_GAMES_TRACK_KDRATIO - 1 ; i >= 0 ; i-- )
+	{
+		kdratio_match.append( player.GetPersistentVar( "kdratio_match[" + i + "]" ) )
+		kdratiopvp_match.append( player.GetPersistentVar( "kdratiopvp_match[" + i + "]" ) )
+	}
+
+	// Last 10
+	local kdratio_match_sum = 0
+	local count = 0
+	foreach( value in kdratio_match )
+	{
+		if ( value == 0 )
+			continue
+		kdratio_match_sum += value
+		count++
+	}
+	local kdratio_match_average = count > 0 ? kdratio_match_sum / count : kdratio_match_sum
+	if ( kdratio_match_average % 1 == 0 )
+		kdratio_match_average = format( "%.0f", kdratio_match_average )
+	else
+		kdratio_match_average = format( "%.1f", kdratio_match_average )
+	SetStatsLabelValue( file.menu, "Last10GamesValue", [ "#STATS_KD_VALUE", kdratio_match_average ] )
+	PlotKDPointsOnGraph( file.menu, 0, kdratio_match, kdval )
+
+	// Last 10 (PVP)
+	local kdratiopvp_match_sum = 0
+	count = 0
+	foreach( value in kdratiopvp_match )
+	{
+		if ( value == 0 )
+			continue
+		kdratiopvp_match_sum += value
+		count++
+	}
+	local kdratiopvp_match_average = count > 0 ? kdratiopvp_match_sum / count : kdratiopvp_match_sum
+	if ( kdratiopvp_match_average % 1 == 0 )
+		kdratiopvp_match_average = format( "%.0f", kdratiopvp_match_average )
+	else
+		kdratiopvp_match_average = format( "%.1f", kdratiopvp_match_average )
+	SetStatsLabelValue( file.menu, "Last10GamesPVPValue", [ "#STATS_KD_VALUE", kdratiopvp_match_average ] )
+	PlotKDPointsOnGraph( file.menu, 1, kdratiopvp_match, gkdval )
+
+	/////////////////////////
+	Hud_SetText( GetElem( file.menu, "KillsAsPilotValue0" ), string( killsAsPilot ) )
+	Hud_SetText( GetElem( file.menu, "KillsAsPilotValue1" ), string( GetPlayerStatInt( player, "kills_stats", "titanKillsAsPilot" ) ) )
+	Hud_SetText( GetElem( file.menu, "KillsAsPilotValue2" ), string( GetPlayerStatInt( player, "kills_stats", "totalNPC" ) ) )
+	Hud_SetText( GetElem( file.menu, "KillsAsPilotValue3" ), string( pulseParse("pilot_emptyhanded", "weaponsLocal", "kills") ) )
+	Hud_SetText( GetElem( file.menu, "KillsAsPilotValue4" ), string( pulseParse("human_execution", "weaponsLocal", "kills") ) )
+//	Hud_SetText( GetElem( file.menu, "KillsAsPilotValue5" ), string( GetPlayerStatInt( player, "kills_stats", "titanFallKill" ) ) )
+
+	var titanMeleeKills = 0
+	titanMeleeKills += pulseParse("titan_punch_ion", "weaponsLocal", "kills")
+	titanMeleeKills += pulseParse("titan_punch_scorch", "weaponsLocal", "kills")
+	titanMeleeKills += pulseParse("titan_punch_northstar", "weaponsLocal", "kills")
+	titanMeleeKills += pulseParse("titan_sword", "weaponsLocal", "kills")
+	titanMeleeKills += pulseParse("titan_punch_tone", "weaponsLocal", "kills")
+	titanMeleeKills += pulseParse("titan_punch_legion", "weaponsLocal", "kills")
+	titanMeleeKills += pulseParse("titan_punch_vanguard", "weaponsLocal", "kills")
+	titanMeleeKills += pulseParse("auto_titan_melee", "weaponsLocal", "kills")
+
+	var titanExecutions = pulseParse("titan_execution", "weaponsLocal", "kills")
+
+	Hud_SetText( GetElem( file.menu, "KillsAsTitanValue0" ), string( killsAsTitan ) )
+	Hud_SetText( GetElem( file.menu, "KillsAsTitanValue1" ), string( GetPlayerStatInt( player, "kills_stats", "titanKillsAsTitan" ) ) )
+	Hud_SetText( GetElem( file.menu, "KillsAsTitanValue2" ), string( titanExecutions ) )
+	Hud_SetText( GetElem( file.menu, "KillsAsTitanValue3" ), string( titanMeleeKills ) )
+	Hud_SetText( GetElem( file.menu, "KillsAsTitanValue4" ), string( pulseParse("damagedef_titan_step", "weaponsLocal", "kills") ) )
+}
+
+function PlotKDPointsOnGraph( menu, graphIndex, values, dottedAverage )
+{
+	//printt( "values:" )
+	//PrintTable( values )
+
+	var background = GetElem( menu, "KDRatioLast10Graph" + graphIndex )
+	local graphHeight = Hud_GetBaseHeight( background )
+	local graphOrigin = Hud_GetAbsPos( background )
+	graphOrigin[1] += graphHeight
+	local dotSpacing = Hud_GetBaseWidth( background ) / 9.0
+	local dotPositions = []
+
+	// Calculate min/max for the graph
+	local graphMin = 0.0
+	local graphMax = max( dottedAverage, 1.0 )
+	foreach( value in values )
+	{
+		if ( value > graphMax )
+			graphMax = value
+	}
+	graphMax += graphMax * 0.1
+
+	var maxLabel = GetElem( menu, "Graph" + graphIndex + "ValueMax" )
+	local maxValueString = format( "%.1f", graphMax )
+	Hud_SetText( maxLabel, maxValueString )
+
+	// Plot the dots
+	for ( int i = 0; i < MAX_DOTS_ON_GRAPH; i++ )
+	{
+		var dot = GetElem( menu, "Graph" + graphIndex + "Dot" + i )
+
+		if ( i >= values.len() )
+		{
+			Hud_Hide( dot )
+			continue
+		}
+
+		float dotOffset = GraphCapped( values[i], graphMin, graphMax, 0, graphHeight )
+
+		local posX = graphOrigin[0] - ( Hud_GetBaseWidth( dot ) * 0.5 ) + ( dotSpacing * i )
+		local posY = graphOrigin[1] - ( Hud_GetBaseHeight( dot ) * 0.5 ) - dotOffset
+		Hud_SetPos( dot, posX, posY )
+		Hud_Show( dot )
+
+		dotPositions.append( [ posX + ( Hud_GetBaseWidth( dot ) * 0.5 ), posY + ( Hud_GetBaseHeight( dot ) * 0.5 ) ] )
+	}
+
+	{
+		// Place the dotted lifetime average line
+		var dottedLine = GetElem( menu, "KDRatioLast10Graph" + graphIndex + "DottedLine0" )
+		float dottedLineOffset = GraphCapped( dottedAverage, graphMin, graphMax, 0, graphHeight )
+		local posX = graphOrigin[0]
+		local posY = graphOrigin[1] - ( Hud_GetBaseHeight( dottedLine ) * 0.5 ) - dottedLineOffset
+		Hud_SetPos( dottedLine, posX, posY )
+		Hud_Show( dottedLine )
+	}
+
+	{
+		// Place the dotted zero line
+		var dottedLine = GetElem( menu, "KDRatioLast10Graph" + graphIndex + "DottedLine1" )
+		float dottedLineOffset = GraphCapped( 0.0, graphMin, graphMax, 0, graphHeight )
+		local posX = graphOrigin[0]
+		local posY = graphOrigin[1] - ( Hud_GetBaseHeight( dottedLine ) * 0.5 ) - dottedLineOffset
+		Hud_SetPos( dottedLine, posX, posY )
+		Hud_Show( dottedLine )
+	}
+
+	// Connect the dots with lines
+	for ( int i = 1; i < MAX_DOTS_ON_GRAPH; i++ )
+	{
+		var line = GetElem( menu, "Graph" + graphIndex + "Line" + i )
+
+		if ( i >= values.len() )
+		{
+			Hud_Hide( line )
+			continue
+		}
+
+		// Get angle from previous dot to this dot
+		local startPos = dotPositions[i-1]
+		local endPos = dotPositions[i]
+		local offsetX = endPos[0] - startPos[0]
+		local offsetY = endPos[1] - startPos[1]
+		local angle = ( atan( offsetX / offsetY ) * ( 180 / PI ) )
+
+		// Get line length
+		local length = sqrt( offsetX * offsetX + offsetY * offsetY )
+
+		// Calculate where the line should be positioned
+		local posX = endPos[0] - ( offsetX / 2.0 ) - ( length / 2.0 )
+		local posY = endPos[1] - ( offsetY / 2.0 ) - ( Hud_GetBaseHeight( line ) / 2.0 )
+
+		//line.SetHeight( 2.0 )
+		Hud_SetWidth( line, length )
+		Hud_SetRotation( line, angle + 90.0 )
+		Hud_SetPos( line, posX, posY )
+		Hud_Show( line )
+	}
+}
+
+void function SetLast10GamesStatVisibility( var menu, bool visible )
+{
+	Hud_SetVisible( Hud_GetChild( menu, "Last10GamesLabel" ), visible )
+	Hud_SetVisible( Hud_GetChild( menu, "Last10GamesValue" ), visible )
+	Hud_SetVisible( Hud_GetChild( menu, "Last10GamesPVPLabel" ), visible )
+	Hud_SetVisible( Hud_GetChild( menu, "Last10GamesPVPValue" ), visible )
+}
+
+void function SetItemImageWidth( var imageElem, string ref )
+{
+	vector vec = GetItemImageAspect( ref )
+	float aspectRatio = vec.x / vec.y
+	int imageWidth = int( Hud_GetHeight( imageElem ) * aspectRatio )
+	Hud_SetWidth( imageElem, imageWidth )
+}

mods/ToneAPI.pulse/mod/scripts/vscripts/ui/menu_stats_time.nut

@@ -0,0 +1,206 @@
+
+global function InitViewStatsTimeMenu
+global function AddPieChartEntry
+
+const MAX_MODE_ROWS = 8
+
+struct
+{
+	var menu
+	array<ItemDisplayData> allTitans
+	table<string, array<string> > titanStatLoadout
+} file
+
+void function InitViewStatsTimeMenu()
+{
+	var menu = GetMenu( "ViewStats_Time_Menu" )
+	file.menu = menu
+
+	AddMenuEventHandler( menu, eUIEvent.MENU_OPEN, OnStatsTime_Open )
+
+	AddMenuFooterOption( menu, BUTTON_B, "#B_BUTTON_BACK", "#BACK" )
+}
+
+void function OnStatsTime_Open()
+{
+	UI_SetPresentationType( ePresentationType.NO_MODELS )
+
+	file.allTitans = GetVisibleItemsOfType( eItemTypes.TITAN )
+	var dataTable = GetDataTable( $"datatable/titan_properties.rpak" )
+
+	foreach ( titan in file.allTitans )
+	{
+		file.titanStatLoadout[ titan.ref ] <- []
+
+		int row = GetDataTableRowMatchingStringValue( dataTable, GetDataTableColumnByName( dataTable, "titanRef" ), titan.ref )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "primary" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "ordnance" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "special" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "antirodeo" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "coreAbility" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "melee" ) ) )
+	}
+
+	UpdateViewStatsTimeMenu()
+}
+
+float function GetTitanKills( string titanName)
+{
+	float weaponKills = 0
+	foreach ( weaponRef in file.titanStatLoadout[ titanName ])
+	{
+		weaponKills += float(pulseParse(weaponRef, "weaponsLocal", "kills"))
+	}
+	return weaponKills
+}
+
+void function UpdateViewStatsTimeMenu()
+{
+	entity player = GetUIPlayer()
+	if ( player == null )
+		return
+
+	//#########################################
+	float killsAsTitan = 0
+	float killsAsIon = GetTitanKills( "ion" )
+	killsAsTitan += killsAsIon
+	float killsAsScorch = GetTitanKills( "scorch" )
+	killsAsTitan += killsAsScorch
+	float killsAsNorthstar = GetTitanKills( "northstar" )
+	killsAsTitan += killsAsNorthstar
+	float killsAsRonin = GetTitanKills( "ronin" )
+	killsAsTitan += killsAsRonin
+	float killsAsTone = GetTitanKills( "tone" )
+	killsAsTitan += killsAsTone
+	float killsAsLegion = GetTitanKills( "legion" )
+	killsAsTitan += killsAsLegion
+	float killsAsMonarch = GetTitanKills( "vanguard" )
+	killsAsTitan += killsAsMonarch
+	//#########################################
+	// 		  Time By Class Pie Chart
+	//#########################################
+
+	var totalPilotKills = 0
+	table playerweaponData = expect table(pulseData["weaponsLocal"])
+
+	foreach (var key, var value in playerweaponData) {
+		table values = expect table(value)
+		totalPilotKills += values["kills"]
+	}
+	float hoursAsPilot = float(totalPilotKills)
+	float hoursAsTitan = killsAsTitan
+
+	array<PieChartEntry> classes
+
+	if ( hoursAsPilot > 0 )
+		AddPieChartEntry( classes, "#STATS_HEADER_PILOT", hoursAsPilot, [61, 117, 193, 255] )
+
+	if ( hoursAsTitan > 0 )
+		AddPieChartEntry( classes, "#STATS_HEADER_TITAN", hoursAsTitan, [223, 94, 0, 255] )
+
+	classes.sort( ComparePieChartEntryValues )
+
+	PieChartData classTimeData
+	classTimeData.entries = classes
+	classTimeData.labelColor = [ 255, 255, 255, 255 ]
+	SetPieChartData( file.menu, "ClassPieChart", "KILLS BY CLASS", classTimeData )
+
+	//#########################################
+	// 		 Time By Chassis Pie Chart
+	//#########################################
+
+	array<PieChartEntry> titans
+
+	if ( killsAsIon > 0 )
+		AddPieChartEntry( titans, "#TITAN_ION", killsAsIon, [200, 40, 40, 255] )
+
+	if ( killsAsScorch > 0 )
+		AddPieChartEntry( titans, "#TITAN_SCORCH", killsAsScorch, [223, 94, 0, 255] )
+
+	if ( killsAsNorthstar > 0 )
+		AddPieChartEntry( titans, "#TITAN_NORTHSTAR", killsAsNorthstar, [61, 117, 193, 255] )
+
+	if ( killsAsRonin > 0 )
+		AddPieChartEntry( titans, "#TITAN_RONIN", killsAsRonin, [207, 191, 59, 255] )
+
+	if ( killsAsTone > 0 )
+		AddPieChartEntry( titans, "#TITAN_TONE", killsAsTone, [88, 172, 67, 255] )
+
+	if ( killsAsLegion > 0 )
+		AddPieChartEntry( titans, "#TITAN_LEGION", killsAsLegion, [46, 188, 180, 255] )
+
+	if ( killsAsMonarch > 0 )
+		AddPieChartEntry( titans, "#TITAN_VANGUARD", killsAsMonarch, [151, 71, 175, 255] )
+
+	titans.sort( ComparePieChartEntryValues )
+
+	PieChartData chassisTimeData
+	chassisTimeData.entries = titans
+	chassisTimeData.labelColor = [ 255, 255, 255, 255 ]
+	SetPieChartData( file.menu, "ChassisPieChart", "KILLS BY TITAN", chassisTimeData )
+
+	//#########################################
+	// 		  Time By Mode Pie Chart
+	//#########################################
+
+	array<string> gameModesArray = GetPersistenceEnumAsArray( "gameModes" )
+
+	array<PieChartEntry> modes
+	int enumCount = PersistenceGetEnumCount( "gameModes" )
+	table< string, array<int> > customGamemodeList = {
+		sns = [255, 178, 102, 255],
+		fw = [147, 204, 57, 255],
+		gg = [14, 87, 132, 255]
+	}
+	table< string, string > customGamemodeNames = {
+		sns = "Sticks and Stones"
+		fw = "Frontier War"
+		gg = "Gun Game"
+	}
+	for ( int modeId = 0; modeId < enumCount; modeId++ )
+	{
+		string modeName = PersistenceGetEnumItemNameForIndex( "gameModes", modeId )
+		if ( pulseParse(modeName, "gamemodesAll", "kills") != 0 )
+		{
+			float modePlayedTime = 0
+			modePlayedTime = float(pulseParse(modeName, "gamemodesAll", "kills"))
+			if ( modePlayedTime > 0 ) {
+				AddPieChartEntry( modes, GameMode_GetName( modeName ), modePlayedTime, GetGameModeDisplayColor( modeName ) )
+			}
+		}
+	}
+	foreach (string key, array<int> value in customGamemodeList)
+	{
+		if ( pulseParse(key, "gamemodesAll", "kills") != 0 )
+		{
+			float modePlayedTime = 0
+			modePlayedTime = float(pulseParse(key, "gamemodesAll", "kills"))
+			if ( modePlayedTime > 0 ) {
+				AddPieChartEntry( modes, customGamemodeNames[key], modePlayedTime, value)
+			}
+		}
+	}
+
+	PieChartData modesPlayedData
+	modesPlayedData.entries = modes
+	modesPlayedData.labelColor = [ 255, 255, 255, 255 ]
+	SetPieChartData( file.menu, "ModesPieChart", "KILLS BY GAMEMODE", modesPlayedData )
+
+	//#########################################
+	// 				Time Stats
+	//#########################################
+
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat0" ), Localize( "#STATS_HEADER_TIME_PLAYED" ), 		StatToTimeString( "time_stats", "hours_total" ) )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat1" ), Localize( "#STATS_HEADER_TIME_IN_AIR" ), 		StatToTimeString( "time_stats", "hours_inAir" ) )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat2" ), Localize( "#STATS_HEADER_TIME_WALLRUNNING" ), 	StatToTimeString( "time_stats", "hours_wallrunning" ) )
+}
+
+void function AddPieChartEntry( array<PieChartEntry> entries, string displayName, float numValue, array<int> color )
+{
+	PieChartEntry newEntry
+	newEntry.displayName = displayName
+	newEntry.numValue = numValue
+	newEntry.color = color
+
+	entries.append( newEntry )
+}

mods/ToneAPI.pulse/mod/scripts/vscripts/ui/menu_stats_titans.nut

@@ -0,0 +1,227 @@
+//TODO: Kills Per Minute stat
+
+global function InitViewStatsTitansMenu
+
+struct
+{
+	var menu
+	var[NUM_PERSISTENT_TITAN_LOADOUTS] buttons
+	array<ItemDisplayData> allTitans
+	table<string, array<string> > titanStatLoadout
+} file
+
+void function InitViewStatsTitansMenu()
+{
+	var menu = GetMenu( "ViewStats_Titans_Menu" )
+	file.menu = menu
+
+	Hud_SetText( Hud_GetChild( file.menu, "MenuTitle" ), "#STATS_TITANS" )
+
+	AddMenuEventHandler( file.menu, eUIEvent.MENU_OPEN, OnViewStatsTitans_Open )
+
+	for ( int i = 0; i < NUM_PERSISTENT_TITAN_LOADOUTS; i++ )
+	{
+		var button = Hud_GetChild( menu, "Button" + i )
+		//button.s.rowIndex <- i
+		//Hud_AddEventHandler( button, UIE_CLICK, OnButton_Activate )
+		Hud_AddEventHandler( button, UIE_GET_FOCUS, OnButton_Focused )
+		file.buttons[i] = button
+	}
+
+	AddMenuFooterOption( file.menu, BUTTON_B, "#B_BUTTON_BACK", "#BACK" )
+}
+
+void function OnViewStatsTitans_Open()
+{
+	UI_SetPresentationType( ePresentationType.STORE_PRIME_TITANS )
+	RunMenuClientFunction( "UpdateTitanModel", 0 )
+
+	// Get Titan list
+	file.allTitans = GetVisibleItemsOfType( eItemTypes.TITAN )
+	var dataTable = GetDataTable( $"datatable/titan_properties.rpak" )
+
+	foreach ( titan in file.allTitans )
+	{
+		file.titanStatLoadout[ titan.ref ] <- []
+
+		int row = GetDataTableRowMatchingStringValue( dataTable, GetDataTableColumnByName( dataTable, "titanRef" ), titan.ref )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "primary" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "ordnance" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "special" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "antirodeo" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "coreAbility" ) ) )
+		file.titanStatLoadout[ titan.ref ].append( GetDataTableString( dataTable, row, GetDataTableColumnByName( dataTable, "melee" ) ) )
+	}
+
+	UpdateButtons( 0, file.buttons )
+	UpdateStatsForTitan( file.allTitans[ 0 ].ref, 0 )
+}
+
+void function UpdateButtons( int selectedIndex, var[NUM_PERSISTENT_TITAN_LOADOUTS] buttons )
+{
+	foreach ( index, button in buttons )
+	{
+		TitanLoadoutDef loadout = GetCachedTitanLoadout( index )
+		RHud_SetText( button, GetTitanLoadoutName( loadout ) )
+
+		Hud_SetEnabled( button, true )
+		Hud_SetVisible( button, true )
+	}
+}
+
+//void function OnButton_Activate( var button )
+//{
+//	int id = int( Hud_GetScriptID( button ) )
+//	if ( !IsControllerModeActive() )
+//		UpdateStatsForTitan( file.allTitans[ id ].ref, id )
+//}
+
+void function OnButton_Focused( var button )
+{
+	int id = int( Hud_GetScriptID( button ) )
+	//if ( IsControllerModeActive() )
+		UpdateStatsForTitan( file.allTitans[ id ].ref, id )
+}
+
+void function UpdateStatsForTitan( string titanRef, int loadoutIndex )
+{
+	entity player = GetUIPlayer()
+	if ( player == null )
+		return
+
+	RunMenuClientFunction( "UpdateTitanModel", loadoutIndex )
+	RunMenuClientFunction( "UpdateStorePrimeBg", loadoutIndex )
+
+	// Name
+	Hud_SetText( Hud_GetChild( file.menu, "TitanName" ), GetItemName( titanRef ) )
+
+	// Locked info
+	var lockLabel = GetElementsByClassname( file.menu, "LblTitanLocked" )[0]
+
+	if ( IsItemLocked( player, titanRef ) )
+	{
+		Hud_SetText( lockLabel, "#LOUADOUT_UNLOCK_REQUIREMENT_LEVEL", GetUnlockLevelReq( titanRef ) )
+		Hud_Show( lockLabel )
+	}
+	else
+	{
+		Hud_Hide( lockLabel )
+	}
+
+	string timeUsed = StatToTimeString( "time_stats", "hours_as_titan_" + titanRef )
+	int shotsHit
+	foreach ( weaponRef in file.titanStatLoadout[ titanRef ] )
+		shotsHit += GetPlayerStatInt( player, "weapon_stats", "shotsHit", weaponRef )
+	int coresEarned = GetPlayerStatInt( player, "titan_stats", "coresEarned", titanRef )
+
+	int crits
+	bool critsApplicable = false
+	foreach ( weaponRef in file.titanStatLoadout[ titanRef ] )
+	{
+		if ( GetWeaponInfoFileKeyField_Global( weaponRef, "critical_hit" ) == true )
+		{
+			critsApplicable = true
+			crits += GetPlayerStatInt( player, "weapon_stats", "critHits", weaponRef )
+		}
+	}
+
+	string critHitsValue = Localize( "#STATS_NOT_APPLICABLE" )
+	if ( critsApplicable )
+		critHitsValue = string( crits )
+
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat0" ), Localize( "#STATS_HEADER_TIME_USED" ), 		timeUsed )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat1" ), Localize( "#STATS_HEADER_SHOTS_HIT" ), 		string( shotsHit ) )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat2" ), Localize( "#STATS_HEADER_CORES_EARNED" ), 	string( coresEarned ) )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat3" ), Localize( "#STATS_HEADER_CRITICAL_HITS" ), 	critHitsValue )
+
+	string nextUnlockRef = GetNextUnlockForTitanLevel( player, titanRef, TitanGetRawLevel( player, titanRef ) + 1 )
+	if ( nextUnlockRef != "" )
+	{
+		var rui = Hud_GetRui( Hud_GetChild( file.menu, "NextUnlock" ) )
+
+		if ( nextUnlockRef == "random" )
+		{
+			RuiSetString( rui, "unlockName", "" )
+			RuiSetImage( rui, "unlockImage", $"rui/menu/common/unlock_random" )
+		}
+		else
+		{
+			ItemDisplayData displayData
+			if ( IsSubItemType( GetItemType( nextUnlockRef ) ) )
+				displayData = GetItemDisplayData( nextUnlockRef, titanRef )
+			else
+				displayData = GetItemDisplayData( nextUnlockRef )
+			RuiSetString( rui, "unlockName", displayData.name )
+			RuiSetImage( rui, "unlockImage", displayData.image )
+
+			vector aspect = GetItemImageAspect( nextUnlockRef )
+
+			float mult = 1.0
+			if ( aspect.x > aspect.y )
+				mult = 120.0 / aspect.x
+			else
+				mult = 120.0 / aspect.y
+
+			aspect.x *= mult
+			aspect.y *= mult
+
+			RuiSetFloat2( rui, "unlockImageSize", aspect )
+		}
+	}
+
+	int totalKills
+	int pilotKills
+	int titanKills
+	int aiKills
+	foreach ( weaponRef in file.titanStatLoadout[ titanRef ] )
+	{
+		totalKills += pulseParse(weaponRef, "weaponsLocal", "kills")
+		pilotKills += GetPlayerStatInt( player, "weapon_kill_stats", "pilots", weaponRef )
+		titanKills += GetPlayerStatInt( player, "weapon_kill_stats", "titansTotal", weaponRef )
+		aiKills += GetPlayerStatInt( player, "weapon_kill_stats", "ai", weaponRef )
+	}
+
+	// Total Kills Stats
+	SetStatsLabelValue( file.menu, "KillsValue0", totalKills )
+	SetStatsLabelValue( file.menu, "KillsValue1", pilotKills )
+	SetStatsLabelValue( file.menu, "KillsValue2", titanKills )
+	SetStatsLabelValue( file.menu, "KillsValue3", aiKills )
+}
+
+asset function GetTitanStatImage( string titanRef )
+{
+	asset image
+
+	switch ( titanRef )
+	{
+		case "ion":
+			image = $"r2_ui/menus/loadout_icons/titans/ion_icon"
+			break
+
+		case "scorch":
+			image = $"r2_ui/menus/loadout_icons/titans/scorch_icon"
+			break
+
+		case "northstar":
+			image = $"r2_ui/menus/loadout_icons/titans/northstar_icon"
+			break
+
+		case "ronin":
+			image = $"r2_ui/menus/loadout_icons/titans/ronin_icon"
+			break
+
+		case "tone":
+			image = $"r2_ui/menus/loadout_icons/titans/tone_icon"
+			break
+
+		case "legion":
+			image = $"r2_ui/menus/loadout_icons/titans/legion_icon"
+			break
+
+		case "vanguard":
+			image = $"r2_ui/menus/loadout_icons/titans/vanguard_icon"
+			break
+	}
+
+	return image
+}

mods/ToneAPI.pulse/mod/scripts/vscripts/ui/menu_stats_utility.nut

@@ -0,0 +1,558 @@
+untyped
+
+
+global function SetPieChartData
+global function SetStatsBarValues
+global function SetStatsValueInfo
+global function SetStatsLabelValue
+global function GetPercent
+//global function GetChallengeCompleteData
+global function GetItemUnlockCountData
+global function GetOverviewWeaponData
+global function StatToTimeString
+global function HoursToTimeString
+global function StatToDistanceString
+global function ComparePieChartEntryValues
+global function SetStatBoxDisplay
+global function SetMedalStatBoxDisplay
+
+void function SetPieChartData( var menu, string panelName, string titleString, PieChartData data )
+{
+	Assert( data.entries.len() <= 8 )
+
+	// Get nested panel
+	var piePanel = GetElem( menu, panelName )
+
+	// Create background
+	var background = Hud_GetChild( piePanel, "BarBG" )
+	Hud_SetBarProgress( background, 1.0 )
+	Hud_SetColor( background, [190, 190, 190, 255] )
+
+	// Calculate total of all values combined
+	foreach ( entry in data.entries )
+		data.sum += entry.numValue
+
+	// Calculate bar fraction for each value
+	foreach ( entry in data.entries )
+	{
+		if ( data.sum > 0 )
+			entry.fracValue = entry.numValue / data.sum
+		else
+			entry.fracValue = 0.0
+	}
+
+	// Set slice sizes and text data
+	var titleLabel = Hud_GetChild( piePanel, "Title" )
+	Hud_SetText( titleLabel, titleString )
+	Hud_SetColor( titleLabel, data.labelColor )
+
+	var noDataLabel = Hud_GetChild( piePanel, "NoData" )
+
+	for ( int index = 0; index < 8; index++ )
+	{
+		var barColorGuide = Hud_GetChild( piePanel, "BarColorGuide" + index )
+		//			Hud_SetColor( barColorGuide, entry.color )
+		Hud_Hide( barColorGuide )
+
+		var barColorGuideFrame = Hud_GetChild( piePanel, "BarColorGuideFrame" + index )
+		Hud_Hide( barColorGuideFrame )
+
+		var barName = Hud_GetChild( piePanel, "BarName" + index )
+		Hud_SetColor( barName, data.labelColor )
+		Hud_SetText( barName, "" )
+
+		var bar = Hud_GetChild( piePanel, "Bar" + index )
+		//Hud_SetBarProgress( bar, combinedFrac )
+		//Hud_SetColor( bar, entry.color )
+		Hud_Hide( bar )
+	}
+
+	if ( data.entries.len() > 0 )
+	{
+		Hud_Hide( noDataLabel )
+
+		float combinedFrac = 0.0
+		int largestTextWidth = 0
+
+		foreach ( index, entry in data.entries )
+		{
+			var barColorGuide = Hud_GetChild( piePanel, "BarColorGuide" + index )
+			Hud_SetColor( barColorGuide, entry.color )
+			Hud_Show( barColorGuide )
+
+			var barColorGuideFrame = Hud_GetChild( piePanel, "BarColorGuideFrame" + index )
+			Hud_Show( barColorGuideFrame )
+
+			string percent = GetPercent( entry.fracValue, 1.0, 0, true )
+			var barName = Hud_GetChild( piePanel, "BarName" + index )
+			Hud_SetColor( barName, data.labelColor )
+
+			if ( data.timeBased )
+				Hud_SetText( barName, PieChartHoursToTimeString( entry.numValue, entry.displayName, percent ) )
+			else
+				Hud_SetText( barName, "#STATS_TEXT_AND_PERCENTAGE", entry.displayName, percent )
+
+			int currentTextWidth = Hud_GetTextWidth( barName )
+			if ( currentTextWidth > largestTextWidth )
+				largestTextWidth = currentTextWidth
+
+			Hud_Show( barName )
+
+			combinedFrac += entry.fracValue
+			var bar = Hud_GetChild( piePanel, "Bar" + index )
+			Hud_SetBarProgress( bar, combinedFrac )
+			Hud_SetColor( bar, entry.color )
+			Hud_Show( bar )
+		}
+
+		// Position the list
+		int xOffset = int( ( largestTextWidth / -2 ) + ContentScaledX( 18 ) )
+		Hud_SetX( Hud_GetChild( piePanel, "BarName0" ), xOffset )
+	}
+	else
+	{
+		Hud_Show( noDataLabel )
+		for ( int index = 0; index < 8; index++ )
+		{
+			var barColorGuide = Hud_GetChild( piePanel, "BarColorGuide" + index )
+//			Hud_SetColor( barColorGuide, entry.color )
+			Hud_Hide( barColorGuide )
+
+			var barColorGuideFrame = Hud_GetChild( piePanel, "BarColorGuideFrame" + index )
+			Hud_Hide( barColorGuideFrame )
+
+			var barName = Hud_GetChild( piePanel, "BarName" + index )
+			Hud_SetColor( barName, data.labelColor )
+			Hud_SetText( barName, "" )
+
+			var bar = Hud_GetChild( piePanel, "Bar" + index )
+			//Hud_SetBarProgress( bar, combinedFrac )
+			//Hud_SetColor( bar, entry.color )
+			Hud_Hide( bar )
+		}
+	}
+}
+
+function SetStatsBarValues( menu, panelName, titleString, startValue, endValue, currentValue )
+{
+	Assert( endValue > startValue )
+	Assert( currentValue >= startValue && currentValue <= endValue )
+
+	// Get nested panel
+	var panel = GetElem( menu, panelName )
+
+	// Update titel
+	var title = Hud_GetChild( panel, "Title" )
+	Hud_SetText( title, titleString )
+
+	// Update progress text
+	var progressText = Hud_GetChild( panel, "ProgressText" )
+	Hud_SetText( progressText, "#STATS_PROGRESS_BAR_VALUE", currentValue, endValue )
+
+	// Update bar progress
+	float frac = GraphCapped( currentValue, startValue, endValue, 0.0, 1.0 )
+
+	var barFill = Hud_GetChild( panel, "BarFill" )
+	Hud_SetScaleX( barFill, frac )
+
+	var barFillShadow = Hud_GetChild( panel, "BarFillShadow" )
+	Hud_SetScaleX( barFillShadow, frac )
+}
+
+void function SetStatsValueInfo( var menu, valueID, labelText, textString )
+{
+	var elem = GetElem( menu, "Column0Label" + valueID )
+	Assert( elem != null )
+	Hud_SetText( elem, labelText )
+
+	elem = GetElem( menu, "Column0Value" + valueID )
+	Assert( elem != null )
+	SetStatsLabelValueOnLabel( elem, textString )
+}
+
+void function SetStatsLabelValue( var menu, labelName, textString )
+{
+	var elem = GetElem( menu, labelName )
+	Assert( elem != null)
+	SetStatsLabelValueOnLabel( elem, textString )
+}
+
+void function SetStatsLabelValueOnLabel( elem, textString )
+{
+	if ( type( textString ) == "array" )
+	{
+		if ( textString.len() == 6 )
+			Hud_SetText( elem, string( textString[0] ), textString[1], textString[2], textString[3], textString[4], textString[5] )
+		if ( textString.len() == 5 )
+			Hud_SetText( elem, string( textString[0] ), textString[1], textString[2], textString[3], textString[4] )
+		if ( textString.len() == 4 )
+			Hud_SetText( elem, string( textString[0] ), textString[1], textString[2], textString[3] )
+		if ( textString.len() == 3 )
+			Hud_SetText( elem, string( textString[0] ), textString[1], textString[2] )
+		if ( textString.len() == 2 )
+			Hud_SetText( elem, string( textString[0] ), textString[1] )
+		if ( textString.len() == 1 )
+			Hud_SetText( elem, string( textString[0] ) )
+	}
+	else
+	{
+		Hud_SetText( elem, string( textString ) )
+	}
+}
+
+string function GetPercent( float val, float total, float defaultPercent, bool doClamp = true )
+{
+	float percent = defaultPercent
+	if ( total > 0 )
+	{
+		percent = val / total
+		percent *= 100
+	}
+
+	if ( doClamp )
+		percent = clamp( percent, 0, 100 )
+
+	string formattedPercent
+	if ( int( percent * 10 ) % 10 == 0 )
+		formattedPercent = format( "%.0f", percent )
+	else
+		formattedPercent = format( "%.1f", percent )
+
+	return formattedPercent
+}
+
+//function GetChallengeCompleteData()
+//{
+//	local Table = {}
+//	Table.total <- 0
+//	Table.complete <- 0
+//
+//	UI_GetAllChallengesProgress()
+//	var allChallenges = GetLocalChallengeTable()
+//
+//	foreach( challengeRef, val in allChallenges )
+//	{
+//		if ( IsDailyChallenge( challengeRef ) )
+//			continue
+//		local tierCount = GetChallengeTierCount( challengeRef )
+//		Table.total += tierCount
+//		for ( int i = 0; i < tierCount; i++ )
+//		{
+//			if ( IsChallengeTierComplete( challengeRef, i ) )
+//				Table.complete++
+//		}
+//	}
+//
+//	return Table
+//}
+
+function GetItemUnlockCountData()
+{
+	entity player = GetUIPlayer()
+	if ( player == null )
+		return {}
+
+	local Table = {}
+	Table[ "weapons" ] <- {}
+	Table[ "weapons" ].total <- 0
+	Table[ "weapons" ].unlocked <- 0
+	Table[ "attachments" ] <- {}
+	Table[ "attachments" ].total <- 0
+	Table[ "attachments" ].unlocked <- 0
+	Table[ "mods" ] <- {}
+	Table[ "mods" ].total <- 0
+	Table[ "mods" ].unlocked <- 0
+	Table[ "abilities" ] <- {}
+	Table[ "abilities" ].total <- 0
+	Table[ "abilities" ].unlocked <- 0
+	Table[ "gear" ] <- {}
+	Table[ "gear" ].total <- 0
+	Table[ "gear" ].unlocked <- 0
+/*
+	local tableMapping = {}
+
+	tableMapping[ eItemTypes.PILOT_PRIMARY ] 			<- "weapons"
+	tableMapping[ eItemTypes.PILOT_SECONDARY ] 			<- "weapons"
+	tableMapping[ eItemTypes.PILOT_ORDNANCE ] 			<- "weapons"
+	tableMapping[ eItemTypes.TITAN_PRIMARY ] 			<- "weapons"
+	tableMapping[ eItemTypes.TITAN_ORDNANCE ] 			<- "weapons"
+	tableMapping[ eItemTypes.PILOT_PRIMARY_ATTACHMENT ] <- "attachments"
+	tableMapping[ eItemTypes.PILOT_PRIMARY_MOD ] 		<- "mods"
+	tableMapping[ eItemTypes.PILOT_SECONDARY_MOD ] 		<- "mods"
+	tableMapping[ eItemTypes.TITAN_PRIMARY_MOD ] 		<- "mods"
+	tableMapping[ eItemTypes.PILOT_SPECIAL_MOD ] 		<- "mods"
+	tableMapping[ eItemTypes.TITAN_SPECIAL_MOD ] 		<- "mods"
+	tableMapping[ eItemTypes.PILOT_SPECIAL ] 			<- "abilities"
+	tableMapping[ eItemTypes.TITAN_SPECIAL ] 			<- "abilities"
+
+	local itemRefs = GetAllItemRefs()
+	foreach ( data in itemRefs )
+	{
+		if ( !( data.Type in tableMapping ) )
+			continue
+		Table[ tableMapping[ data.Type ] ].total++
+
+		if ( !IsItemLocked( player, expect string( data.childRef ), expect string( data.ref ) ) )
+			Table[ tableMapping[ data.Type ] ].unlocked++
+	}
+*/
+	return Table
+}
+
+table<string, table> function GetOverviewWeaponData()
+{
+	table<string, table> Table = {}
+	Table[ "most_kills" ] <- {}
+	Table[ "most_kills" ].ref <- ""
+	Table[ "most_kills" ].printName <- ""
+	Table[ "most_kills" ].val <- 0
+	Table[ "nemesis_weapon" ] <- {}
+	Table[ "nemesis_weapon" ].ref <- ""
+	Table[ "nemesis_weapon" ].printName <- ""
+	Table[ "nemesis_weapon" ].val <- 0
+	Table[ "highest_kpm" ] <- {}
+	Table[ "highest_kpm" ].ref <- ""
+	Table[ "highest_kpm" ].printName <- ""
+	Table[ "highest_kpm" ].val <- 0
+
+	entity player = GetUIPlayer()
+	if ( player == null )
+		return Table
+
+	array<ItemDisplayData> allWeapons = []
+
+	allWeapons.extend( GetVisibleItemsOfType( eItemTypes.PILOT_PRIMARY ) )
+	allWeapons.extend( GetVisibleItemsOfType( eItemTypes.PILOT_SECONDARY ) )
+	//allWeapons.extend( GetVisibleItemsOfType( eItemTypes.PILOT_ORDNANCE ) ) // art looks bad
+	allWeapons.extend( GetVisibleItemsOfType( eItemTypes.TITAN_PRIMARY ) )
+	allWeapons.extend( GetVisibleItemsOfType( eItemTypes.TITAN_ORDNANCE ) )
+	allWeapons.extend( GetVisibleItemsOfType( eItemTypes.TITAN_ANTIRODEO ) )
+	allWeapons.extend( GetVisibleItemsOfType( eItemTypes.TITAN_SPECIAL ) )
+	//allWeapons.extend( GetVisibleItemsOfType( eItemTypes.BURN_METER_REWARD ) ) // script errors
+
+	foreach ( weapon in allWeapons )
+	{
+		string weaponName = weapon.ref
+		string weaponDisplayName = expect string( GetWeaponInfoFileKeyField_Global( weaponName, "printname" ) )
+
+		if ( !PersistenceEnumValueIsValid( "loadoutWeaponsAndAbilities", weaponName ) )
+			continue
+
+		int val = pulseParse(weaponName, "weaponsLocal", "kills")
+		if ( val > Table[ "most_kills" ].val )
+		{
+			Table[ "most_kills" ].ref = weaponName
+			Table[ "most_kills" ].printName = weaponDisplayName
+			Table[ "most_kills" ].val = val
+		}
+
+		int nval = pulseParse(weaponName, "weaponsLocal", "deaths")
+		if ( nval > Table[ "nemesis_weapon" ].val )
+		{
+			Table[ "nemesis_weapon" ].ref = weaponName
+			Table[ "nemesis_weapon" ].printName = weaponDisplayName
+			Table[ "nemesis_weapon" ].val = nval
+		}
+
+		float kdval = 0
+		float kval = 0
+		float dval = 0
+		if( pulseParse(weaponName, "weaponsLocal", "kills") != 0 && pulseParse(weaponName, "weaponsLocal", "deaths_while_equipped") != 0){
+			kval = float(pulseParse(weaponName, "weaponsLocal", "kills"))
+			dval = float(pulseParse(weaponName, "weaponsLocal", "deaths_while_equipped"))
+			if (kval / dval > kdval){
+			kdval = kval / dval
+			}
+		}
+		int rnd= int(kdval*100)
+		kdval = float(rnd)/100
+		if ( kdval > Table[ "highest_kpm" ].val.tofloat() )
+		{
+			Table[ "highest_kpm" ].ref = weaponName
+			Table[ "highest_kpm" ].printName = weaponDisplayName
+			Table[ "highest_kpm" ].val = kdval
+		}
+	}
+
+	return Table
+}
+
+string function StatToTimeString( string category, string alias, string weapon = "" )
+{
+	entity player = GetUIPlayer()
+	if ( player == null )
+		return "0"
+
+	string statString = GetStatVar( category, alias, weapon )
+	float savedHours = expect float( player.GetPersistentVar( statString ) )
+
+	return HoursToTimeString( savedHours )
+}
+
+string function HoursToTimeString( float savedHours )
+{
+	string timeString
+	local minutes = floor( savedHours * 60.0 )
+
+	if ( minutes < 0 )
+		minutes = 0
+
+	int days = 0
+	int hours = 0
+
+	while ( minutes >= 1440 )
+	{
+		minutes -= 1440
+		days++
+	}
+
+	while ( minutes >= 60 )
+	{
+		minutes -= 60
+		hours++
+	}
+
+	if ( days > 0 && hours > 0 && minutes > 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_D_H_M", days, hours, minutes )
+	}
+	else if ( days > 0 && hours == 0 && minutes == 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_D", days )
+	}
+	else if ( days == 0 && hours > 0 && minutes == 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_H", hours )
+	}
+	else if ( days == 0 && hours == 0 && minutes >= 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_M", minutes )
+	}
+	else if ( days > 0 && hours > 0 && minutes == 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_D_H", days, hours )
+	}
+	else if ( days == 0 && hours > 0 && minutes > 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_H_M", hours, minutes )
+	}
+	else if ( days > 0 && hours == 0 && minutes > 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_D_M", days, minutes )
+	}
+	else
+	{
+		Assert( 0, "Unhandled time string creation case" )
+	}
+
+	return timeString
+}
+
+string function PieChartHoursToTimeString( float savedHours, string pieChartHeader, string pieChartPercent )
+{
+	string timeString
+	local minutes = floor( savedHours * 60.0 )
+
+	if ( minutes < 0 )
+		minutes = 0
+
+	int days = 0
+	int hours = 0
+
+	while ( minutes >= 1440 )
+	{
+		minutes -= 1440
+		days++
+	}
+
+	while ( minutes >= 60 )
+	{
+		minutes -= 60
+		hours++
+	}
+
+	if ( days > 0 && hours > 0 && minutes > 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_D_H_M_PIECHART", days, hours, minutes, Localize( pieChartHeader ), pieChartPercent )
+	}
+	else if ( days > 0 && hours == 0 && minutes == 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_D_PIECHART", days, Localize( pieChartHeader ), pieChartPercent )
+	}
+	else if ( days == 0 && hours > 0 && minutes == 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_H_PIECHART", hours, Localize( pieChartHeader ), pieChartPercent )
+	}
+	else if ( days == 0 && hours == 0 && minutes >= 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_M_PIECHART", minutes, Localize( pieChartHeader ), pieChartPercent )
+	}
+	else if ( days > 0 && hours > 0 && minutes == 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_D_H_PIECHART", days, hours, Localize( pieChartHeader ), pieChartPercent )
+	}
+	else if ( days == 0 && hours > 0 && minutes > 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_H_M_PIECHART", hours, minutes, Localize( pieChartHeader ), pieChartPercent )
+	}
+	else if ( days > 0 && hours == 0 && minutes > 0 )
+	{
+		timeString = Localize( "#STATS_TIME_STRING_D_M_PIECHART", days, minutes, Localize( pieChartHeader ), pieChartPercent )
+	}
+	else
+	{
+		Assert( 0, "Unhandled time string creation case" )
+	}
+
+	return timeString
+}
+
+string function StatToDistanceString( string category, string alias, string weapon = "" )
+{
+	entity player = GetUIPlayer()
+	if ( player == null )
+		return ""
+
+	string statString = GetStatVar( category, alias, weapon )
+	float kilometers = expect float( player.GetPersistentVar( statString ) )
+
+	string formattedNum
+	if ( kilometers % 1 == 0 )
+		formattedNum = format( "%.0f", kilometers )
+	else
+		formattedNum = format( "%.2f", kilometers )
+
+	string distString = Localize( "#STATS_KILOMETERS_ABBREVIATION", formattedNum )
+
+	return distString
+}
+
+int function ComparePieChartEntryValues( PieChartEntry a, PieChartEntry b )
+{
+	float aVal = a.numValue
+	float bVal = b.numValue
+
+	if ( aVal < bVal )
+		return 1
+	else if ( aVal > bVal )
+		return -1
+
+	return 0
+}
+
+void function SetStatBoxDisplay( var vguiElem, string text, string value )
+{
+	var rui = Hud_GetRui( vguiElem )
+
+	RuiSetString( rui, "statText", text )
+	RuiSetString( rui, "statValue", value )
+}
+
+void function SetMedalStatBoxDisplay( var vguiElem, string text, asset image, int value )
+{
+	var rui = Hud_GetRui( vguiElem )
+
+	RuiSetString( rui, "statText", text )
+	RuiSetString( rui, "statValue", string( value ) )
+	RuiSetImage( rui, "statImage", image )
+}

mods/ToneAPI.pulse/mod/scripts/vscripts/ui/menu_stats_weapons.nut

@@ -0,0 +1,187 @@
+//TODO: Kills Per Minute stat
+
+global function InitViewStatsWeaponsMenu
+
+struct
+{
+	var menu
+	GridMenuData gridData
+	bool isGridInitialized = false
+	array<ItemDisplayData> allPilotWeapons
+} file
+
+void function InitViewStatsWeaponsMenu()
+{
+	var menu = GetMenu( "ViewStats_Weapons_Menu" )
+	file.menu = menu
+
+	Hud_SetText( Hud_GetChild( file.menu, "MenuTitle" ), "#STATS_PILOT_WEAPONS" )
+
+	file.gridData.rows = 5
+	file.gridData.columns = 1
+	//file.gridData.numElements // Set in OnViewStatsWeapons_Open after itemdata exists
+	file.gridData.pageType = eGridPageType.VERTICAL
+	file.gridData.tileWidth = 224
+	file.gridData.tileHeight = 112
+	file.gridData.paddingVert = 6
+	file.gridData.paddingHorz = 6
+
+	Grid_AutoAspectSettings( menu, file.gridData )
+
+	file.gridData.initCallback = WeaponButton_Init
+	file.gridData.getFocusCallback = WeaponButton_GetFocus
+	//file.gridData.clickCallback = WeaponButton_Activate
+
+	AddMenuEventHandler( file.menu, eUIEvent.MENU_OPEN, OnViewStatsWeapons_Open )
+
+	AddMenuFooterOption( file.menu, BUTTON_B, "#B_BUTTON_BACK", "#BACK" )
+}
+
+void function OnViewStatsWeapons_Open()
+{
+	//UI_SetPresentationType( ePresentationType.NO_MODELS )
+	UI_SetPresentationType( ePresentationType.STORE_WEAPON_SKINS )
+
+	// Get Pilot weapon list
+	file.allPilotWeapons = GetVisibleItemsOfType( eItemTypes.PILOT_PRIMARY )
+	file.allPilotWeapons.extend( GetVisibleItemsOfType( eItemTypes.PILOT_SECONDARY ) )
+	file.allPilotWeapons.sort( SortItemsAlphabetically )
+	//file.allPilotWeapons.extend( GetVisibleItemsOfType( eItemTypes.PILOT_ORDNANCE ) )
+	//file.allPilotWeapons.extend( GetVisibleItemsOfType( eItemTypes.PILOT_SPECIAL ) )
+
+	file.gridData.numElements = file.allPilotWeapons.len()
+
+	if ( !file.isGridInitialized )
+	{
+		GridMenuInit( file.menu, file.gridData )
+		file.isGridInitialized = true
+	}
+
+	file.gridData.currentPage = 0
+
+	Grid_InitPage( file.menu, file.gridData )
+	Hud_SetFocused( Grid_GetButtonForElementNumber( file.menu, 0 ) )
+	UpdateStatsForWeapon( file.allPilotWeapons[ 0 ].ref )
+}
+
+bool function WeaponButton_Init( var button, int elemNum )
+{
+	string ref = file.allPilotWeapons[ elemNum ].ref
+	int itemType = GetItemType( ref )
+
+	var rui = Hud_GetRui( button )
+	asset image = GetImage( itemType, ref )
+	RuiSetImage( rui, "buttonImage", image )
+
+	Hud_SetEnabled( button, true )
+	Hud_SetVisible( button, true )
+
+	return true
+}
+
+void function WeaponButton_GetFocus( var button, int elemNum )
+{
+	//if ( IsControllerModeActive() )
+		UpdateStatsForWeapon( file.allPilotWeapons[ elemNum ].ref )
+}
+
+//void function WeaponButton_Activate( var button, int elemNum )
+//{
+//	if ( !IsControllerModeActive() )
+//		UpdateStatsForWeapon( file.allPilotWeapons[ elemNum ].ref )
+//}
+
+void function UpdateStatsForWeapon( string weaponRef )
+{
+	//Sliced names are to be removed afterwards
+	string slicedName = ""
+	if(weaponRef.find("mp_weapon")){
+		slicedName = weaponRef.slice(10)
+	}
+	entity player = GetUIPlayer()
+	if ( player == null )
+		return
+
+	RunMenuClientFunction( "UpdateStoreWeaponModelSkin", weaponRef, 0 )
+
+	// Name
+	Hud_SetText( Hud_GetChild( file.menu, "WeaponName" ), GetItemName( weaponRef ) )
+
+	// Locked info
+	var lockLabel = GetElementsByClassname( file.menu, "LblWeaponLocked" )[0]
+
+	if ( IsItemLocked( player, weaponRef ) )
+	{
+		Hud_SetText( lockLabel, "#LOUADOUT_UNLOCK_REQUIREMENT_LEVEL", GetUnlockLevelReq( weaponRef ) )
+		Hud_Show( lockLabel )
+	}
+	else
+	{
+		Hud_Hide( lockLabel )
+	}
+
+	// Get required data needed for some calculations
+	//float hoursUsed = GetPlayerStatFloat( player, "weapon_stats", "hoursUsed", weaponRef )
+	string timeUsed = StatToTimeString( "weapon_stats", "hoursUsed", weaponRef )
+	int shotsHit = GetPlayerStatInt( player, "weapon_stats", "shotsHit", weaponRef )
+	int headshots = GetPlayerStatInt( player, "weapon_stats", "headshots", weaponRef )
+	int crits = GetPlayerStatInt( player, "weapon_stats", "critHits", weaponRef )
+
+	string headShotsValue = Localize( "#STATS_NOT_APPLICABLE" )
+	bool headshotWeapon = GetWeaponInfoFileKeyField_Global( weaponRef, "allow_headshots" ) == true
+	if ( headshotWeapon )
+		headShotsValue = string( headshots )
+
+	string critHitsValue = Localize( "#STATS_NOT_APPLICABLE" )
+	bool critHitWeapon = GetWeaponInfoFileKeyField_Global( weaponRef, "critical_hit" ) == true
+	if ( critHitWeapon )
+		critHitsValue = string( crits )
+
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat0" ), Localize( "#STATS_HEADER_TIME_USED" ), 		timeUsed )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat1" ), Localize( "#STATS_HEADER_SHOTS_HIT" ), 		string( shotsHit ) )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat2" ), Localize( "#STATS_HEADER_HEADSHOTS" ), 		headShotsValue )
+	SetStatBoxDisplay( Hud_GetChild( file.menu, "Stat3" ), Localize( "#STATS_HEADER_CRITICAL_HITS" ), 	critHitsValue )
+
+	string nextUnlockRef = GetNextUnlockForWeaponLevel( player, weaponRef, WeaponGetRawLevel( player, weaponRef ) + 1 )
+	if ( nextUnlockRef != "" )
+	{
+		var rui = Hud_GetRui( Hud_GetChild( file.menu, "NextUnlock" ) )
+
+		if ( nextUnlockRef == "random" )
+		{
+			RuiSetString( rui, "unlockName", "" )
+			RuiSetImage( rui, "unlockImage", $"rui/menu/common/unlock_random" )
+		}
+		else
+		{
+			ItemDisplayData displayData
+			if ( IsSubItemType( GetItemType( nextUnlockRef ) ) )
+				displayData = GetItemDisplayData( nextUnlockRef, weaponRef )
+			else
+				displayData = GetItemDisplayData( nextUnlockRef )
+
+			RuiSetString( rui, "unlockName", displayData.name )
+			RuiSetImage( rui, "unlockImage", displayData.image )
+
+			vector aspect = GetItemImageAspect( nextUnlockRef )
+
+			float mult = 1.0
+			if ( aspect.x > aspect.y )
+				mult = 120.0 / aspect.x
+			else
+				mult = 120.0 / aspect.y
+
+			aspect.x *= mult
+			aspect.y *= mult
+
+			RuiSetFloat2( rui, "unlockImageSize", aspect )
+		}
+		//printt( displayData.image )
+	}
+
+	// Total Kills Stats
+	SetStatsLabelValue( file.menu, "KillsValue0", 				pulseParse(weaponRef, "weaponsLocal", "kills") ) //Total kills
+	SetStatsLabelValue( file.menu, "KillsValue1", 				pulseParse(weaponRef, "weaponsLocal", "kills") ) //Pilots
+	SetStatsLabelValue( file.menu, "KillsValue2", 				GetPlayerStatInt( player, "weapon_kill_stats", "titansTotal", weaponRef ) ) //Titans
+	SetStatsLabelValue( file.menu, "KillsValue3", 				pulseParse(weaponRef, "weaponsLocal", "deaths_while_equipped")) // Deaths with weapon
+}