#if SERVER untyped #endif globalize_all_functions global string INVALID_REF = "INVALID_REF" void function InitDefaultLoadouts() { PopulateDefaultPilotLoadouts( shGlobal.defaultPilotLoadouts ) PopulateDefaultTitanLoadouts( shGlobal.defaultTitanLoadouts ) } PilotLoadoutDef function GetDefaultPilotLoadout( int index ) { return shGlobal.defaultPilotLoadouts[ index ] } TitanLoadoutDef function GetDefaultTitanLoadout( int index ) { return shGlobal.defaultTitanLoadouts[ index ] } PilotLoadoutDef[NUM_PERSISTENT_PILOT_LOADOUTS] function GetDefaultPilotLoadouts() { return shGlobal.defaultPilotLoadouts } TitanLoadoutDef[NUM_PERSISTENT_TITAN_LOADOUTS] function GetDefaultTitanLoadouts() { return shGlobal.defaultTitanLoadouts } void function PopulateDefaultPilotLoadouts( PilotLoadoutDef[ NUM_PERSISTENT_PILOT_LOADOUTS ] loadouts ) { var dataTable = GetDataTable( $"datatable/default_pilot_loadouts.rpak" ) for ( int i = 0; i < NUM_PERSISTENT_PILOT_LOADOUTS; i++ ) { PilotLoadoutDef loadout = loadouts[i] loadout.name = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "name" ) ) loadout.suit = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "suit" ) ) loadout.race = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "race" ) ) loadout.primary = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "primary" ) ) loadout.primaryAttachment = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "primaryAttachment" ) ) loadout.primaryMod1 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "primaryMod1" ) ) loadout.primaryMod2 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "primaryMod2" ) ) loadout.primaryMod3 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "primaryMod3" ) ) loadout.secondary = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "secondary" ) ) loadout.secondaryMod1 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "secondaryMod1" ) ) loadout.secondaryMod2 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "secondaryMod2" ) ) loadout.secondaryMod3 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "secondaryMod3" ) ) loadout.weapon3 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "weapon3" ) ) loadout.weapon3Mod1 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "weapon3Mod1" ) ) loadout.weapon3Mod2 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "weapon3Mod2" ) ) loadout.weapon3Mod3 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "weapon3Mod3" ) ) loadout.ordnance = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "ordnance" ) ) loadout.passive1 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "passive1" ) ) loadout.passive2 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "passive2" ) ) //TODO: Why isn't execution initialized here? UpdateDerivedPilotLoadoutData( loadout, false ) //loadout.race //ValidateDefaultLoadoutData( "pilot", loadout.primary ) //ValidateWeaponSubitem( loadout.primary, loadout.primaryAttachment, eItemTypes.PILOT_PRIMARY_ATTACHMENT ) //ValidateWeaponSubitem( loadout.primary, loadout.primaryMod1, eItemTypes.PILOT_PRIMARY_MOD ) //ValidateWeaponSubitem( loadout.primary, loadout.primaryMod2, eItemTypes.PILOT_PRIMARY_MOD ) Assert( ( loadout.primaryMod1 == "" && loadout.primaryMod2 == "" ) || ( loadout.primaryMod1 != loadout.primaryMod2 ), "!!! Primary mod1 and mod2 in default pilot loadout: " + loadout.name + " should be different but are both set to: " + loadout.primaryMod1 ) //ValidateDefaultLoadoutData( "pilot", loadout.secondary ) //ValidateWeaponSubitem( loadout.secondary, loadout.secondaryMod1, eItemTypes.PILOT_SECONDARY_MOD ) //ValidateWeaponSubitem( loadout.secondary, loadout.secondaryMod2, eItemTypes.PILOT_SECONDARY_MOD ) Assert( ( loadout.secondaryMod1 == "" && loadout.secondaryMod2 == "" ) || ( loadout.secondaryMod1 != loadout.secondaryMod2 ), "!!! Secondary mod1 and mod2 in default pilot loadout: " + loadout.name + " should be different but are both set to: " + loadout.secondaryMod1 ) //ValidateDefaultLoadoutData( "pilot", loadout.weapon3 ) //ValidateWeaponSubitem( loadout.weapon3, loadout.weapon3Mod1, eItemTypes.PILOT_SECONDARY_MOD ) //ValidateWeaponSubitem( loadout.weapon3, loadout.weapon3Mod2, eItemTypes.PILOT_SECONDARY_MOD ) Assert( ( loadout.weapon3Mod1 == "" && loadout.weapon3Mod2 == "" ) || ( loadout.weapon3Mod1 != loadout.weapon3Mod2 ), "!!! Weapon3 mod1 and mod2 in default pilot loadout: " + loadout.name + " should be different but are both set to: " + loadout.weapon3Mod1 ) //ValidateDefaultLoadoutData( "pilot", loadout.ordnance ) //ValidateDefaultLoadoutData( "pilot", loadout.special ) //ValidateDefaultLoadoutData( "pilot", loadout.passive1 ) //ValidateDefaultLoadoutData( "pilot", loadout.passive2 ) } } void function PopulateDefaultTitanLoadouts( TitanLoadoutDef[ NUM_PERSISTENT_TITAN_LOADOUTS ] loadouts ) { var dataTable = GetDataTable( $"datatable/default_titan_loadouts.rpak" ) for ( int i = 0; i < NUM_PERSISTENT_TITAN_LOADOUTS; i++ ) { TitanLoadoutDef loadout = loadouts[i] loadout.name = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "name" ) ) loadout.titanClass = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "titanRef" ) ) loadout.setFile = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "setFile" ) ) loadout.primaryMod = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "primaryMod" ) ) loadout.special = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "special" ) ) loadout.antirodeo = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "antirodeo" ) ) loadout.passive1 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "passive1" ) ) loadout.passive2 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "passive2" ) ) loadout.passive3 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "passive3" ) ) loadout.passive4 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "passive4" ) ) loadout.passive5 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "passive5" ) ) loadout.passive6 = GetDataTableString( dataTable, i, GetDataTableColumnByName( dataTable, "passive6" ) ) loadout.titanExecution = GetLoadoutPropertyDefault( "titan", i, "titanExecution" ) OverwriteLoadoutWithDefaultsForSetFile_ExceptSpecialAndAntiRodeo( loadout ) //ValidateDefaultLoadoutData( "titan", loadout.setFile ) ////loadout.primaryMod //ValidateDefaultLoadoutData( "titan", loadout.special ) //ValidateDefaultLoadoutData( "titan", loadout.antirodeo ) //ValidateDefaultLoadoutData( "titan", loadout.passive1 ) //ValidateDefaultLoadoutData( "titan", loadout.passive2 ) } } void function ValidateDefaultLoadoutData( string loadoutType, string itemRef ) { if ( itemRef == "" ) return Assert( loadoutType == "pilot" || loadoutType == "titan" ) string tableFile = "default_" + loadoutType + "_loadouts.csv" Assert( ItemDefined( itemRef ), "Datatable \"" + tableFile + "\" contains an unknown item reference: " + itemRef ) Assert( GetUnlockLevelReq( itemRef ) <= 1, "Datatable \"" + tableFile + "\" item: " + itemRef + " must be unlocked at level 1" ) } void function ValidateWeaponSubitem( string weaponRef, string itemRef, int itemType ) { bool isPlayerLevelLocked = IsItemLockedForPlayerLevel( 1, weaponRef ) bool isWeaponLevelLocked = IsItemLockedForWeaponLevel( 1, weaponRef, itemRef ) if ( isPlayerLevelLocked || isWeaponLevelLocked ) { //array<ItemData> subitems = GetAllSubitemsOfType( weaponRef, itemType ) //foreach ( subitem in subitems ) //{ // if ( !IsItemLockedForWeaponLevel( 1, weaponRef, subitem.ref ) ) // printt( " ", subitem.ref ) //} Assert( 0, "Subitem: " + itemRef + " for item: " + weaponRef + " should either be available by default, or changed to one of the values listed above." ) CodeWarning( "Subitem: " + itemRef + " for item: " + weaponRef + " should either be available by default, or changed to one of the values listed above." ) } } PilotLoadoutDef function GetPilotLoadoutFromPersistentData( entity player, int loadoutIndex ) { PilotLoadoutDef loadout PopulatePilotLoadoutFromPersistentData( player, loadout, loadoutIndex ) return loadout } TitanLoadoutDef function GetTitanLoadoutFromPersistentData( entity player, int loadoutIndex ) { TitanLoadoutDef loadout PopulateTitanLoadoutFromPersistentData( player, loadout, loadoutIndex ) return loadout } void function PopulatePilotLoadoutFromPersistentData( entity player, PilotLoadoutDef loadout, int loadoutIndex ) { loadout.name = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "name" ) loadout.suit = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "suit" ) loadout.race = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "race" ) loadout.execution = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "execution" ) loadout.primary = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "primary" ) loadout.primaryAttachment = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "primaryAttachment" ) loadout.primaryMod1 = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "primaryMod1" ) loadout.primaryMod2 = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "primaryMod2" ) loadout.primaryMod3 = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "primaryMod3" ) loadout.secondary = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "secondary" ) loadout.secondaryMod1 = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "secondaryMod1" ) loadout.secondaryMod2 = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "secondaryMod2" ) loadout.secondaryMod3 = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "secondaryMod3" ) loadout.weapon3 = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "weapon3" ) loadout.weapon3Mod1 = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "weapon3Mod1" ) loadout.weapon3Mod2 = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "weapon3Mod2" ) loadout.weapon3Mod3 = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "weapon3Mod3" ) loadout.ordnance = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "ordnance" ) loadout.passive1 = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "passive1" ) loadout.passive2 = GetValidatedPersistentLoadoutValue( player, "pilot", loadoutIndex, "passive2" ) loadout.camoIndex = GetValidatedPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "camoIndex" ) loadout.skinIndex = GetValidatedPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "skinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes loadout.primaryCamoIndex = GetValidatedPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "primaryCamoIndex" ) loadout.primarySkinIndex = GetValidatedPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "primarySkinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes loadout.secondaryCamoIndex = GetValidatedPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "secondaryCamoIndex" ) loadout.secondarySkinIndex = GetValidatedPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "secondarySkinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes loadout.weapon3CamoIndex = GetValidatedPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "weapon3CamoIndex" ) loadout.weapon3SkinIndex = GetValidatedPersistentLoadoutValueInt( player, "pilot", loadoutIndex, "weapon3SkinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes UpdateDerivedPilotLoadoutData( loadout ) } void function PopulateTitanLoadoutFromPersistentData( entity player, TitanLoadoutDef loadout, int loadoutIndex ) { loadout.name = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "name" ) loadout.titanClass = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "titanClass" ) loadout.primaryMod = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "primaryMod" ) loadout.special = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "special" ) loadout.antirodeo = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "antirodeo" ) loadout.passive1 = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "passive1" ) loadout.passive2 = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "passive2" ) loadout.passive3 = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "passive3" ) loadout.passive4 = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "passive4" ) loadout.passive5 = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "passive5" ) loadout.passive6 = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "passive6" ) loadout.camoIndex = GetValidatedPersistentLoadoutValueInt( player, "titan", loadoutIndex, "camoIndex" ) loadout.skinIndex = GetValidatedPersistentLoadoutValueInt( player, "titan", loadoutIndex, "skinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes loadout.decalIndex = GetValidatedPersistentLoadoutValueInt( player, "titan", loadoutIndex, "decalIndex" ) loadout.primaryCamoIndex = GetValidatedPersistentLoadoutValueInt( player, "titan", loadoutIndex, "primaryCamoIndex" ) loadout.primarySkinIndex = GetValidatedPersistentLoadoutValueInt( player, "titan", loadoutIndex, "primarySkinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes loadout.titanExecution = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "titanExecution" ) loadout.showArmBadge = GetValidatedPersistentLoadoutValueInt( player, "titan", loadoutIndex, "showArmBadge" ) //Prime Titan related vars loadout.isPrime = GetValidatedPersistentLoadoutValue( player, "titan", loadoutIndex, "isPrime" ) loadout.primeCamoIndex = GetValidatedPersistentLoadoutValueInt( player, "titan", loadoutIndex, "primeCamoIndex" ) loadout.primeSkinIndex = GetValidatedPersistentLoadoutValueInt( player, "titan", loadoutIndex, "primeSkinIndex" ) //Important: Skin index needs to be gotten after camoIndex for loadout validation purposes loadout.primeDecalIndex = GetValidatedPersistentLoadoutValueInt( player, "titan", loadoutIndex, "primeDecalIndex" ) UpdateDerivedTitanLoadoutData( loadout ) OverwriteLoadoutWithDefaultsForSetFile( loadout ) } string function GetSetFileForTitanClassAndPrimeStatus( string titanClass, bool isPrimeTitan = false ) { string nonPrimeSetFile array<TitanLoadoutDef> legalLoadouts = GetAllowedTitanLoadouts() foreach ( loadout in legalLoadouts ) { if ( GetTitanCharacterNameFromSetFile( loadout.setFile ) == titanClass ) { nonPrimeSetFile = loadout.setFile break } } if ( !isPrimeTitan ) return nonPrimeSetFile string primeSetFile = GetPrimeTitanSetFileFromNonPrimeSetFile( nonPrimeSetFile ) Assert( primeSetFile != "" ) return primeSetFile } string function GetPrimeTitanRefForTitanClass( string titanClass ) { array<TitanLoadoutDef> legalLoadouts = GetAllowedTitanLoadouts() foreach ( loadout in legalLoadouts ) { if ( GetTitanCharacterNameFromSetFile( loadout.setFile ) == titanClass ) return loadout.primeTitanRef } unreachable } string function GetPersistentLoadoutValue( entity player, string loadoutType, int loadoutIndex, string loadoutProperty ) { // printt( "=======================================================================================" ) // printt( "loadoutType:", loadoutType, "loadoutIndex:", loadoutIndex, "loadoutProperty:" , loadoutProperty ) // printl( "script GetPlayerArray()[0].SetPersistentVar( \"" + loadoutType + "Loadouts[" + loadoutIndex + "]." + loadoutProperty + "\", \"" + value + "\" )" ) // printt( "=======================================================================================" ) string getString = BuildPersistentVarAccessorString( loadoutType, loadoutIndex, loadoutProperty ) var value = player.GetPersistentVar( getString ) if ( value == null ) return "" return string( value ) } int function GetPersistentLoadoutValueInt( entity player, string loadoutType, int loadoutIndex, string loadoutProperty ) { return int( GetPersistentLoadoutValue( player, loadoutType, loadoutIndex, loadoutProperty ) ) } string function GetPersistentLoadoutPropertyType( string loadoutProperty ) { switch ( loadoutProperty ) { case "skinIndex": case "camoIndex": case "decalIndex": case "primeSkinIndex": case "primeCamoIndex": case "primeDecalIndex": case "primarySkinIndex": case "primaryCamoIndex": case "secondarySkinIndex": case "secondaryCamoIndex": case "weapon3SkinIndex": case "weapon3CamoIndex": case "showArmBadge": return "int" } return "string" } #if SERVER // TODO: If we change a property that has a parent or child relationship, all related properties need updating if invalid // A parent change should validate children and set invalid to defaults // If a child change is invalid for the parent, it should be changed to a valid default based on the parent // TODO: Return type. Currently getting passed to AddClientCommandCallback() which expects a bool return, but this isn't setup to return values. function SetPersistentLoadoutValue( entity player, string loadoutType, int loadoutIndex, string loadoutProperty, string value ) { //printt( "=======================================================================================" ) //printt( "SetPersistentLoadoutValue called with loadoutType:", loadoutType, "loadoutIndex:", loadoutIndex, "loadoutProperty:" , loadoutProperty, "value:", value ) //printl( "script GetPlayerArray()[0].SetPersistentVar( \"" + loadoutType + "Loadouts[" + loadoutIndex + "]." + loadoutProperty + "\", \"" + value + "\" )" ) //printt( "=======================================================================================" ) bool loadoutIsPilot = ( loadoutType == "pilot" ) bool loadoutIsTitan = ( loadoutType == "titan" ) bool loadoutIsPilotOrTitan = ( loadoutIsPilot || loadoutIsTitan ) //Assert( loadoutIsPilotOrTitan, "Invalid loadoutType that is not pilot or titan" ) if ( !loadoutIsPilotOrTitan ) { CodeWarning( "Loadout neither pilot or titan" ) return } //Assert( ( loadoutIsPilot && IsValidPilotLoadoutIndex( loadoutIndex ) ) || ( loadoutIsTitan && !IsValidTitanLoadoutIndex( loadoutIndex ) ), "SetPersistentLoadoutValue() called with invalid loadoutIndex: " + loadoutIndex ) if ( loadoutIsPilot && !IsValidPilotLoadoutIndex( loadoutIndex ) ) { CodeWarning( "!IsValidPilotLoadoutIndex" ) return } if ( loadoutIsTitan && !IsValidTitanLoadoutIndex( loadoutIndex ) ) { CodeWarning( "!IsValidTitanLoadoutIndex" ) return } if ( value == "none" ) value = "" var loadoutPropertyEnum = null if ( loadoutIsPilot ) { bool isValid = IsValidPilotLoadoutProperty( loadoutProperty ) //Assert( IsValidPilotLoadoutProperty, "SetPersistentLoadoutValue() called with invalid pilot loadoutProperty: " + loadoutProperty ) if ( !isValid ) { CodeWarning( "!IsValidPilotLoadoutProperty" ) return } loadoutPropertyEnum = GetPilotLoadoutPropertyEnum( loadoutProperty ) } else { bool isValid = IsValidTitanLoadoutProperty( loadoutProperty ) //Assert( isValidTitanLoadoutProperty, "SetPersistentLoadoutValue() called with invalid titan loadoutProperty: " + loadoutProperty ) if ( !isValid ) { CodeWarning( "!IsValidTitanLoadoutProperty" ) return } loadoutPropertyEnum = GetTitanLoadoutPropertyEnum( loadoutProperty ) } if ( loadoutPropertyEnum != null && !PersistenceEnumValueIsValid( loadoutPropertyEnum, value ) ) { CodeWarning( loadoutType + " " + loadoutProperty + " value: " + value + " not valid in persistent data!" ) return } if ( LoadoutPropertyRequiresItemValidation( loadoutProperty ) && value != "" ) { if ( FailsLoadoutValidationCheck( player, loadoutType, loadoutIndex, loadoutProperty, value ) ) { printt( "=======================================================================================" ) printt( "SetPersistentLoadoutValue failed FailsLoadoutValidationCheck with loadoutType:", loadoutType, "loadoutIndex:", loadoutIndex, "loadoutProperty:" , loadoutProperty, "value:", value ) printt( "=======================================================================================" ) //Assert( false, "SetPersistentLoadoutValue() call " + loadoutType + " " + loadoutProperty + ", value: " + value + " failed FailsLoadoutValidationCheck() check!" ) return } } // Only checks primary mods and attachments are valid in itemData and the parent isn't locked if ( !IsLoadoutSubitemValid( player, loadoutType, loadoutIndex, loadoutProperty, value ) ) { CodeWarning( loadoutType + " " + loadoutProperty + " value: " + value + " failed IsLoadoutSubitemValid() check! It may not exist in itemData, or it's parent item is locked." ) return } SetPlayerPersistentVarWithoutValidation( player, loadoutType, loadoutIndex, loadoutProperty, value ) // Reset child properties when parent changes ResolveInvalidLoadoutChildValues( player, loadoutType, loadoutIndex, loadoutProperty, value ) ValidateSkinAndCamoIndexesAsAPair( player, loadoutType, loadoutIndex, loadoutProperty, value ) //Skin and camo properties need to be set correctly as a pair #if HAS_THREAT_SCOPE_SLOT_LOCK if ( loadoutProperty.tolower() == "primaryattachment" && value == "threat_scope" ) { SetPlayerPersistentVarWithoutValidation( player, loadoutType, loadoutIndex, "primaryMod2", "" ) } #endif // TEMP client model update method bool updateModel = ( loadoutProperty == "suit" || loadoutProperty == "race" || loadoutProperty == "setFile" || loadoutProperty == "primary" || loadoutProperty == "isPrime" ) if ( loadoutType == "pilot" ) { player.p.pilotLoadoutChanged = true if ( updateModel ) player.p.pilotModelNeedsUpdate = loadoutIndex } else { player.p.titanLoadoutChanged = true if ( updateModel ) player.p.titanModelNeedsUpdate = loadoutIndex } thread UpdateCachedLoadouts() } string function GetRefFromLoadoutTypeIndexPropertyAndValue( entity player, string loadoutType, int index, string property, var value ) { bool isPilotLoadout = ( loadoutType == "pilot" ) bool isTitanLoadout = ( loadoutType == "titan" ) if ( !isPilotLoadout && !isTitanLoadout ) return INVALID_REF switch ( property ) { case "isPrime": { if ( !isTitanLoadout ) return INVALID_REF if( PersistenceEnumValueIsValid( "titanIsPrimeTitan", value ) ) return GetTitanRefFromPersistenceLoadoutIndexAndValueForIsPrime( index, expect string( value ) ) else return INVALID_REF } case "camoIndex": //Camos work across all Titans, all pilots, and all weapons. case "primeCamoIndex": { int valueAsInt = ForceCastVarToInt( value ) if ( !IsValidCamoIndex( valueAsInt ) ) //Note that we should have already checked for the case that we're setting a Titan's camo to -1 ( valid warpaint use case ) in FailsLoadoutValidationCheck() { return INVALID_REF } else { if ( isPilotLoadout ) return CamoSkins_GetByIndex( valueAsInt ).pilotCamoRef else return CamoSkins_GetByIndex( valueAsInt ).titanCamoRef } } break case "primaryCamoIndex": case "secondaryCamoIndex": case "weapon3CamoIndex": { int valueAsInt = ForceCastVarToInt( value ) if ( !IsValidCamoIndex( valueAsInt ) ) return INVALID_REF else return CamoSkins_GetByIndex( valueAsInt ).ref } break case "primarySkinIndex": case "secondarySkinIndex": case "weapon3SkinIndex": { string parentProperty = GetParentLoadoutProperty( loadoutType, property ) string weaponRef = GetPersistentLoadoutValue( player, loadoutType, index, parentProperty ) int valueAsInt = ForceCastVarToInt( value ) return GetSkinRefFromWeaponRefAndPersistenceValue( weaponRef, valueAsInt ) } break case "decalIndex": case "primeDecalIndex": //Assume same nose arts work for both prime and non-prime titans { if ( !isTitanLoadout ) return INVALID_REF string titanClass = GetDefaultTitanLoadout( index ).titanClass int valueAsInt = ForceCastVarToInt( value ) return GetNoseArtRefFromTitanClassAndPersistenceValue( titanClass, valueAsInt ) } break case "primeSkinIndex": //Primes don't have war paints, white listed skins for titans (0 and 2) should have already been handled earlier { return INVALID_REF } break case "skinIndex": { if ( !isTitanLoadout ) //Only titans have warpaints. White listed skins for pilots should already have been handled earlier return INVALID_REF string titanClass = GetDefaultTitanLoadout( index ).titanClass int valueAsInt = ForceCastVarToInt( value ) return GetSkinRefFromTitanClassAndPersistenceValue( titanClass, valueAsInt ) } break default: return string( value ) } unreachable } bool function IsValidCamoIndex( int camoIndex ) { int numCamos = CamoSkins_GetCount() //Note that we should have already handled the case for a titan's camoIndex to be -1 (valid warpaint usecase) in FailsLoadoutValidationCheck return ((camoIndex >= 0) && (camoIndex < numCamos)) } string function GetTitanRefFromPersistenceLoadoutIndexAndValueForIsPrime( int index, string value ) { bool isPrimeRef = (value == "titan_is_prime") string titanClass = GetDefaultTitanLoadout( index ).titanClass if ( isPrimeRef ) return GetPrimeTitanRefForTitanClass( titanClass ) return titanClass } bool function LoadoutPropertyRequiresItemValidation( string loadoutProperty ) { bool shouldSkipValidation = ( GetCurrentPlaylistVarInt( "skip_loadout_validation", 0 ) == 1 ) if ( shouldSkipValidation ) { //printt( "skip_loadout_validation" ) return false } if ( loadoutProperty == "name" ) return false if ( loadoutProperty == "showArmBadge" ) return false if ( loadoutProperty == "primarySkinIndex" || loadoutProperty == "secondarySkinIndex" || loadoutProperty == "weapon3SkinIndex") return false return true } // Only checks primary mods and attachments are valid in itemData and the parent isn't locked bool function IsLoadoutSubitemValid( entity player, string loadoutType, int loadoutIndex, string property, string ref ) { string childRef = "" switch ( property ) { case "primaryAttachment": case "primaryMod1": case "primaryMod2": case "primaryMod3": case "secondaryMod1": case "secondaryMod2": case "secondaryMod3": case "weapon3Mod1": case "weapon3Mod2": case "weapon3Mod3": if ( loadoutType == "pilot" ) { string parentProperty = GetParentLoadoutProperty( loadoutType, property ) string loadoutString = BuildPersistentVarAccessorString( loadoutType, loadoutIndex, parentProperty ) if ( ref != "" ) childRef = ref ref = expect string( player.GetPersistentVar( loadoutString ) ) } break case "skinIndex": case "camoIndex": case "decalIndex": case "primarySkinIndex": case "primaryCamoIndex": case "secondarySkinIndex": case "secondaryCamoIndex": case "weapon3SkinIndex": case "weapon3CamoIndex": case "primeSkinIndex": case "primeCamoIndex": case "primeDecalIndex": return true break } // TODO: Seems bad to pass null childRef on to some of the checks below if the property wasn't one of the above // invalid attachment if ( childRef != "" && !HasSubitem( ref, childRef ) ) return false //if ( IsItemLocked( player, childRef, expect string( ref ) ) ) // return false return true } void function SetPlayerPersistentVarWithoutValidation( entity player, string loadoutType, int loadoutIndex, string propertyName, string value ) { string persistentLoadoutString = BuildPersistentVarAccessorString( loadoutType, loadoutIndex, propertyName ) if ( GetPersistentLoadoutPropertyType( propertyName ) == "int" ) player.SetPersistentVar( persistentLoadoutString, int( value ) ) else player.SetPersistentVar( persistentLoadoutString, value ) } string function ResetLoadoutPropertyToDefault( entity player, string loadoutType, int loadoutIndex, string propertyName ) { string defaultValue = GetLoadoutPropertyDefault( loadoutType, loadoutIndex, propertyName ) SetPlayerPersistentVarWithoutValidation( player, loadoutType, loadoutIndex, propertyName, defaultValue ) return defaultValue } bool function FailsLoadoutValidationCheck( entity player, string loadoutType, int loadoutIndex, string loadoutProperty, var value ) { //printt( "FailsLoadoutValidationCheck, player: " + player + ", loadoutType: " + loadoutType + ", loadoutIndex: " + loadoutIndex + ", loadoutProperty: " + loadoutProperty + ", value: " + value ) int initializedVersion = player.GetPersistentVarAsInt( "initializedVersion" ) bool previouslyInitialized = ( initializedVersion >= PERSISTENCE_INIT_VERSION ) if ( !previouslyInitialized ) //Special case: if we're intializing from defaults/updating persistent data, don't try to reset to defaults { //printt( "!previouslyInitialized" ) return false } if ( AllowCamoIndexToSkipValidation( loadoutType, loadoutProperty, value ) ) //Special case: Warpaints will set camoIndex { // printt( "AllowCamoIndexToSkipValidation" ) return false } if ( AllowSkinIndexToSkipValidation( loadoutType, loadoutProperty, value ) ) //Skins need to be handled differently because they are only valid refs for warpaints, and we set values of 0, 1 and 2 for different cases { // printt( "AllowSkinIndexToSkipValidation" ) return false } string ref = GetRefFromLoadoutTypeIndexPropertyAndValue( player, loadoutType, loadoutIndex, loadoutProperty, value ) if ( !IsRefValid( ref ) ) { printt( "!IsRefValid( " + ref + " ), generated from loadoutType: " + loadoutType + ", loadoutIndex: " + loadoutIndex + ". loadoutProperty: " + loadoutProperty + ", value: " + value ) return true } if ( IsSettingPrimeTitanWithoutSetFile( player, loadoutType, loadoutProperty, loadoutIndex, value ) ) //Hack, working around fact that we allow setting Prime Titan value since it's entitlement based unlock. { //printt( "IsSettingPrimeTitanWithoutSetFile, player: " + player + ", ref: " + ref ) return true } if ( FailsItemLockedValidationCheck( player, loadoutType, loadoutIndex, loadoutProperty, ref ) ) { printt( "FailsItemLockedValidationCheck, player: " + player + ", ref: " + ref ) return true } if ( !IsValueValidForLoadoutTypeIndexAndProperty( loadoutType, loadoutIndex, loadoutProperty, value, ref ) ) { //printt( "!IsValueValidForLoadoutTypeIndexAndProperty, loadoutType: " + loadoutType + ", loadoutIndex: " + loadoutIndex + ", loadoutProperty: " + loadoutProperty + ", value: " + value + " ref: " + ref ) return true } if ( ( loadoutProperty == "secondary" || loadoutProperty == "weapon3" ) && !IsValueValidForPropertyWithCategoryRestriction( player, loadoutIndex, loadoutProperty, string( value ) ) ) return true //printt( "End FailsLoadoutValidationCheck" ) return false } bool function IsValueValidForPropertyWithCategoryRestriction( entity player, int loadoutIndex, string targetProperty, string targetValue ) { Assert( targetProperty == "secondary" || targetProperty == "weapon3" ) string otherProperty if ( targetProperty == "secondary" ) otherProperty = "weapon3" else otherProperty = "secondary" string otherValue = GetPersistentLoadoutValue( player, "pilot", loadoutIndex, otherProperty ) if ( ItemsInSameMenuCategory( targetValue, otherValue ) ) return false return true } bool function FailsItemLockedValidationCheck( entity player, string loadoutType, int loadoutIndex, string loadoutProperty, string ref ) { bool shouldSkipValidation = ( GetCurrentPlaylistVarInt( "skip_loadout_item_locked_validation", 0 ) == 1 ) if ( shouldSkipValidation ) { //printt( "skip_loadout_item_locked_validation" ) return false } if ( LoadoutIsLocked( player, loadoutType, loadoutIndex ) ) { //printt( "loadout of type " + loadoutType + " and index " + loadoutIndex + " is locked, skip checking if items under it are locked" ) return false } if ( IsSubItemType( GetItemType( ref ) ) ) { string parentRef = GetParentRefFromLoadoutInfoAndRef( player, loadoutType, loadoutIndex, loadoutProperty, ref ) if ( parentRef == "" ) { //printt( "parentRef == blankstring" ) return true } if ( !SkipItemLockedCheck( player, ref, parentRef, loadoutProperty ) ) { if ( IsSubItemLocked( player, ref, parentRef ) ) { //printt( "IsSubItemLocked, player: " + player + ", ref: " + ref + ", parentRef: " + parentRef ) return true } } } else { if ( !SkipItemLockedCheck( player, ref, "", loadoutProperty ) ) { if ( IsItemLocked( player, ref ) ) //Somehow we are trying to get something that is locked. Might be rogue client sending bad values? { //printt( "IsItemLocked, player: " + player + ", ref: " + ref ) return true } } } return false } bool function IsSettingPrimeTitanWithoutSetFile( entity player, string loadoutType, string loadoutProperty, int loadoutIndex, var value ) //Temp function, remove once all titans have prime Titans { if ( loadoutType != "titan" ) return false if ( loadoutProperty != "isPrime" ) return false if ( value != "titan_is_prime" ) return false string titanClass = GetPersistentLoadoutValue( player, "titan", loadoutIndex, "titanClass" ) return ( !TitanClassHasPrimeTitan( titanClass ) ) } bool function SkipItemLockedCheck( entity player, string ref, string parentRef, string loadoutProperty ) //Hack: Skip entitlement related unlock checks for now. Can fail. { if ( DevEverythingUnlocked() ) return true //if ( IsItemInEntitlementUnlock( ref ) && IsLobby() ) //TODO: Look into restricting this to lobby only? But entitlement checks can fail randomly... if ( IsItemInEntitlementUnlock( ref, parentRef ) ) return true if ( loadoutProperty == "isPrime" ) //Temp check to avoid weirdness where we can set titan_is_prime but not titan_is_not_prime because prime titan refs are not child refs of non prime titan refs. Should be able to remove this once all prime titans are in game. return true return false } bool function AllowCamoIndexToSkipValidation( string loadoutType, string loadoutProperty, var value ) //HACK: working around the fact that we do SetCamo( -1 ) when applying warpaints { if ( loadoutProperty != "camoIndex" ) //Prime Titans currently don't have warpaints, so not supporting setting primeCamoIndex to be -1 return false int valueAsInt = ForceCastVarToInt( value ) if ( valueAsInt == CAMO_INDEX_BASE ) return true if ( loadoutType != "titan" ) return false if ( valueAsInt != TITAN_WARPAINT_CAMO_INDEX ) return false return true } bool function AllowSkinIndexToSkipValidation( string loadoutType, string loadoutProperty, var value ) //TODO: test weapon skin/camo combinations? { int valueAsInt = ForceCastVarToInt( value ) //TODO: Awkward, getting around the fact that you can't do int( value ) if it's already an int. switch( loadoutProperty ) { case "skinIndex": { if ( loadoutType == "pilot" ) return ( (valueAsInt == SKIN_INDEX_BASE) || (valueAsInt == PILOT_SKIN_INDEX_CAMO) ) else return ( (valueAsInt == SKIN_INDEX_BASE) || (valueAsInt == TITAN_SKIN_INDEX_CAMO) ) //War paints will have different values, hence we must validate them } break case "primeSkinIndex": //Prime Titans don't support war paints, so should only support values of 0 and 2 { return ( (valueAsInt == SKIN_INDEX_BASE) || (valueAsInt == TITAN_SKIN_INDEX_CAMO) ) } break case "primarySkinIndex": case "secondarySkinIndex": case "weapon3SkinIndex": { return ( (valueAsInt == SKIN_INDEX_BASE) || (valueAsInt == WEAPON_SKIN_INDEX_CAMO) ) } break default: return false } unreachable } bool function IsValueValidForLoadoutTypeIndexAndProperty( string loadoutType, int loadoutIndex, string loadoutProperty, var value, string ref ) { bool isTitanLoadout = (loadoutType == "titan") bool isPilotLoadout = (loadoutType == "pilot") if ( !isTitanLoadout && !isPilotLoadout ) return false //Should have run IsRefValid( ref already, so should be fine just doing GetItemType( ref ) ) int itemType = GetItemType( ref ) //printt( "itemType : " + itemType ) switch ( loadoutProperty ) { case "suit": return ( (itemType == eItemTypes.PILOT_SUIT) && isPilotLoadout ) case "race": return ( (itemType == eItemTypes.RACE) && isPilotLoadout ) case "execution": return ( (itemType == eItemTypes.PILOT_EXECUTION) && isPilotLoadout ) case "titanExecution": return ( isTitanLoadout && IsValidTitanExecution( loadoutIndex, loadoutProperty, value, ref ) ) case "primary": //Only Pilots store their primary in persistence return ( (itemType == eItemTypes.PILOT_PRIMARY) && isPilotLoadout ) case "primaryAttachment": //Only Pilots their primary in persistence return ( (itemType == eItemTypes.SUB_PILOT_WEAPON_ATTACHMENT || itemType == eItemTypes.PILOT_PRIMARY_ATTACHMENT) && isPilotLoadout ) case "primaryMod1": //Only Pilots have primary mods in persistence case "primaryMod2": case "primaryMod3": return ( (itemType == eItemTypes.SUB_PILOT_WEAPON_MOD || itemType == eItemTypes.PILOT_PRIMARY_MOD) && isPilotLoadout ) case "secondary": //Only Pilots store their secondary in persistence case "weapon3": return ( (itemType == eItemTypes.PILOT_SECONDARY) && isPilotLoadout ) case "secondaryMod1": //Only Pilots store their secondary in persistence case "secondaryMod2": //Only Pilots store their secondary in persistence case "secondaryMod3": //Only Pilots store their secondary in persistence case "weapon3Mod1": case "weapon3Mod2": case "weapon3Mod3": return ( (itemType == eItemTypes.SUB_PILOT_WEAPON_MOD || itemType == eItemTypes.PILOT_SECONDARY_MOD) && isPilotLoadout ) case "ordnance": return ( (itemType == eItemTypes.PILOT_ORDNANCE) && isPilotLoadout ) case "passive1": if ( isPilotLoadout ) { return ( itemType == eItemTypes.PILOT_PASSIVE1 ) } else { return IsValidTitanPassive( loadoutIndex, loadoutProperty, value, ref ) } case "passive2": if ( isPilotLoadout ) return ( itemType == eItemTypes.PILOT_PASSIVE2 ) else return IsValidTitanPassive( loadoutIndex, loadoutProperty, value, ref ) case "passive3": case "passive4": case "passive5": case "passive6": return ( isTitanLoadout && IsValidTitanPassive( loadoutIndex, loadoutProperty, value, ref ) ) case "isPrime": return ( isTitanLoadout && PersistenceEnumValueIsValid( "titanIsPrimeTitan", value ) ) //Technically will be covered by enumValue checks before LoadoutValidation checks, but included here for completeness //TODO: Need to get ref for these correctly! case "skinIndex": case "camoIndex": case "primarySkinIndex": case "primaryCamoIndex": case "secondarySkinIndex": case "secondaryCamoIndex": case "weapon3SkinIndex": case "weapon3CamoIndex": case "decalIndex": case "primeSkinIndex": case "primeCamoIndex": case "primeDecalIndex": return true // assume already validated case "titanClass": //Should never be able to set these things normally! case "primaryMod": case "special": case "antirodeo": string defaultValue = GetLoadoutPropertyDefault( loadoutType, loadoutIndex, loadoutProperty ) return ( value == defaultValue ) default: Assert( false, "Unknown loadoutProperty " + loadoutProperty ) return false } unreachable } bool function ValidateSkinAndCamoIndexesAsAPair( entity player, string loadoutType, int loadoutIndex, string loadoutProperty, var value ) { bool isSkinIndex = false switch( loadoutProperty ) { case "skinIndex": case "primeSkinIndex": case "primarySkinIndex": case "secondarySkinIndex": case "weapon3SkinIndex": isSkinIndex = true break } if ( !isSkinIndex ) return false int valueAsInt = ForceCastVarToInt( value ) string camoProperty = GetCorrectCamoProperty( loadoutProperty ) int camoIndexValue = GetValidatedPersistentLoadoutValueInt( player, loadoutType, loadoutIndex, camoProperty ) //printt( "ValidateSkinAndCamoIndexesAsAPair, player: " + player + " loadouType: " + loadoutType + ", loadoutIndex: " + loadoutIndex + ", skinProperty: " + loadoutProperty + ", skin Value: " + string( value ) + ", camoProperty: " + camoProperty + ", camo Value: " + camoIndexValue ) if ( valueAsInt == SKIN_INDEX_BASE ) //Just set to default of 0, 0. return SetCamoIndexToValue( player, loadoutType, loadoutIndex, camoProperty, CAMO_INDEX_BASE ) switch ( loadoutProperty ) { case "skinIndex": { if (loadoutType == "pilot" ) //1 is skin for camo, only other valid value is 0 { if ( valueAsInt == PILOT_SKIN_INDEX_CAMO && camoIndexValue <= CAMO_INDEX_BASE ) { ResetSkinAndCamoIndexesToZero( player, loadoutType, loadoutIndex, loadoutProperty, camoProperty ) return true } } else if ( loadoutType == "titan" ) //2 is skin for camos, all other skin values other than 0 are warpaints that have camo index == -1 { if ( valueAsInt == TITAN_SKIN_INDEX_CAMO ) //This is a camo skin { if ( camoIndexValue <= CAMO_INDEX_BASE ) { ResetSkinAndCamoIndexesToZero( player, loadoutType, loadoutIndex, loadoutProperty, camoProperty ) return true } } else //i.e. this is a warpaint { return SetCamoIndexToValue( player, loadoutType, loadoutIndex, camoProperty, TITAN_WARPAINT_CAMO_INDEX ) //Set to default of -1 for warpaint } } break } case "primeSkinIndex": //switching between prime and non-prime doesn't have problems where skin is unlocked on non-prime but is locked on prime, so no need to return false { if ( valueAsInt == TITAN_SKIN_INDEX_CAMO && camoIndexValue <= CAMO_INDEX_BASE ) { ResetSkinAndCamoIndexesToZero( player, loadoutType, loadoutIndex, loadoutProperty, camoProperty ) return true } break } case "primarySkinIndex": case "secondarySkinIndex": case "weapon3SkinIndex": //1 is skin for camo { if ( valueAsInt == WEAPON_SKIN_INDEX_CAMO ) { if ( camoIndexValue <= CAMO_INDEX_BASE ) { ResetSkinAndCamoIndexesToZero( player, loadoutType, loadoutIndex, loadoutProperty, camoProperty ) return false // HACK: Work around fact that when we switch weapons we don't do a corresponding call to set camo and skin indexes } } else { return SetCamoIndexToValue( player, loadoutType, loadoutIndex, camoProperty, 0 ) //Set to default of 0 for weapon skins } break } } return false } bool function SetCamoIndexToValue( entity player, string loadoutType, int loadoutIndex, string camoProperty, int setValue ) //HACK HACK: should fix dependency between skin and camo index on UI side. Remove when done. { int camoIndexValue = GetPersistentLoadoutValueInt( player, loadoutType, loadoutIndex, camoProperty ) if ( camoIndexValue == setValue ) return false //printt( "SetCamoIndexToValue, player: " + player + " loadouType: " + loadoutType + ", loadoutIndex: " + loadoutIndex + ", camoProperty: " + camoProperty + ", setValue: " + string( setValue )) SetPlayerPersistentVarWithoutValidation( player, loadoutType, loadoutIndex, camoProperty, string( setValue ) ) return true } void function ResetSkinAndCamoIndexesToZero( entity player, string loadoutType, int loadoutIndex, string skinProperty, string camoProperty ) { SetPlayerPersistentVarWithoutValidation( player, loadoutType, loadoutIndex, camoProperty, "0" ) SetPlayerPersistentVarWithoutValidation( player, loadoutType, loadoutIndex, skinProperty, "0" ) } string function GetCorrectCamoProperty( string loadoutProperty ) //HACK HACK: should fix dependency between skin and camo index on UI side. Remove when done. { string returnValue switch( loadoutProperty ) { case "skinIndex": returnValue = "camoIndex" break case "primeSkinIndex": returnValue = "primeCamoIndex" break case "primarySkinIndex": returnValue = "primaryCamoIndex" break case "secondarySkinIndex": returnValue = "secondaryCamoIndex" break case "weapon3SkinIndex": returnValue = "weapon3CamoIndex" break default: unreachable } return returnValue } bool function IsValidTitanPassive( int loadoutIndex, string loadoutProperty, var value, string ref ) //TODO: Not using all parameters in this function yet, might need them for full validation { //Should have run IsRefValid(ref already, so fine to do GetItemType( ref )) int itemType = GetItemType( ref ) //printt( "itemType: " + itemType ) switch ( loadoutProperty ) { case "passive1": return (itemType == eItemTypes.TITAN_GENERAL_PASSIVE) case "passive2": { switch( loadoutIndex ) //TODO: Hard coded, not great! { case 0: return itemType == eItemTypes.TITAN_ION_PASSIVE case 1: return itemType == eItemTypes.TITAN_SCORCH_PASSIVE case 2: return itemType == eItemTypes.TITAN_NORTHSTAR_PASSIVE case 3: return itemType == eItemTypes.TITAN_RONIN_PASSIVE case 4: return itemType == eItemTypes.TITAN_TONE_PASSIVE case 5: return itemType == eItemTypes.TITAN_LEGION_PASSIVE case 6: return itemType == eItemTypes.TITAN_VANGUARD_PASSIVE default: return false } } case "passive3": return (itemType == eItemTypes.TITAN_TITANFALL_PASSIVE) case "passive4": return (itemType == eItemTypes.TITAN_UPGRADE1_PASSIVE) case "passive5": return (itemType == eItemTypes.TITAN_UPGRADE2_PASSIVE) case "passive6": return (itemType == eItemTypes.TITAN_UPGRADE3_PASSIVE) default: unreachable } unreachable } bool function IsValidTitanExecution( int loadoutIndex, string loadoutProperty, var value, string ref ) //TODO: Not using all parameters in this function yet, might need them for full validation { //Should have run IsRefValid(ref already, so fine to do GetItemType( ref )) int itemType = GetItemType( ref ) //printt( "itemType: " + itemType ) switch ( loadoutProperty ) { case "titanExecution": { switch( loadoutIndex ) //TODO: Hard coded, not great! { case 0: return itemType == eItemTypes.TITAN_ION_EXECUTION case 1: return itemType == eItemTypes.TITAN_SCORCH_EXECUTION case 2: return itemType == eItemTypes.TITAN_NORTHSTAR_EXECUTION case 3: return itemType == eItemTypes.TITAN_RONIN_EXECUTION case 4: return itemType == eItemTypes.TITAN_TONE_EXECUTION case 5: return itemType == eItemTypes.TITAN_LEGION_EXECUTION case 6: return itemType == eItemTypes.TITAN_VANGUARD_EXECUTION default: return false } } default: unreachable } unreachable } string function GetParentRefFromLoadoutInfoAndRef( entity player, string loadoutType, int loadoutIndex, string property, string childRef ) { bool isPilotLoadout = (loadoutType == "pilot") bool isTitanLoadout = (loadoutType == "titan") if ( !isPilotLoadout && !isTitanLoadout ) return "" switch ( property ) { case "primaryAttachment": case "primaryMod1": case "primaryMod2": case "primaryMod3": case "secondaryMod1": case "secondaryMod2": case "secondaryMod3": case "weapon3Mod1": case "weapon3Mod2": case "weapon3Mod3": { string parentProperty = GetParentLoadoutProperty( loadoutType, property ) string loadoutString = BuildPersistentVarAccessorString( loadoutType, loadoutIndex, parentProperty ) string resultString = string( player.GetPersistentVar( loadoutString ) ) //titanLoadouts[5].titanClass if ( HasSubitem( resultString, childRef ) ) return resultString else return "" } case "passive1": case "passive2": case "passive3": case "passive4": case "passive5": case "passive6": { if ( isTitanLoadout && !IsValidTitanPassive( loadoutIndex, property, childRef, childRef ) ) return "" string parentProperty = GetParentLoadoutProperty( loadoutType, property ) string loadoutString = BuildPersistentVarAccessorString( loadoutType, loadoutIndex, parentProperty ) string resultString = string( player.GetPersistentVar( loadoutString ) ) //titanLoadouts[5].titanClass if ( HasSubitem( resultString, childRef ) ) return resultString else return "" } case "skinIndex": //These should all only be allowed to be changed on Titans case "decalIndex": case "primeCamoIndex": case "primeDecalIndex": case "camoIndex": //For pilots, this is not a subitem. For titans, it should be titanclass. { if ( !isTitanLoadout ) return "" //Only Titans have war paints, which allow for arbitrary skin index. All others should have been taken care of earlier in AllowSkinIndexToSkipValidation() return GetDefaultTitanLoadout( loadoutIndex ).titanClass } case "primaryCamoIndex": //For Pilots, subitem is primary. For Titans, subitem is titanclass { if ( isPilotLoadout ) { string loadoutString = BuildPersistentVarAccessorString( loadoutType, loadoutIndex, "primary" ) return string( player.GetPersistentVar( loadoutString ) ) } else { return GetDefaultTitanLoadout( loadoutIndex ).titanClass } } case "secondaryCamoIndex": { if ( !isPilotLoadout ) //Only Pilots have secondaries return "" string loadoutString = BuildPersistentVarAccessorString( loadoutType, loadoutIndex, "secondary" ) return string( player.GetPersistentVar( loadoutString ) ) } case "weapon3CamoIndex": { if ( !isPilotLoadout ) return "" string loadoutString = BuildPersistentVarAccessorString( loadoutType, loadoutIndex, "weapon3" ) return string( player.GetPersistentVar( loadoutString ) ) } case "primarySkinIndex": { string loadoutString = BuildPersistentVarAccessorString( loadoutType, loadoutIndex, "primary" ) return string( player.GetPersistentVar( loadoutString ) ) } case "secondarySkinIndex": { if ( !isPilotLoadout ) //Only Pilots have secondaries return "" string loadoutString = BuildPersistentVarAccessorString( loadoutType, loadoutIndex, "secondary" ) return string( player.GetPersistentVar( loadoutString ) ) } case "weapon3SkinIndex": { if ( !isPilotLoadout ) return "" string loadoutString = BuildPersistentVarAccessorString( loadoutType, loadoutIndex, "weapon3" ) return string( player.GetPersistentVar( loadoutString ) ) } case "primeSkinIndex": //Should be taken care of earlier in AllowSkinIndexToSkipValidation() default: return "" } unreachable } int function ForceCastVarToInt( var value ) //HACK: working around inability to cast an int to int. Reexamine when less busy! { if ( typeof( value ) == "int" ) return ( expect int( value ) ) return int( value ) } #endif //Server only string function GetLoadoutPropertyDefault( string loadoutType, int loadoutIndex, string propertyName ) //Bad things go wrong if you give the wrong default! { string resultString switch ( propertyName ) { case "skinIndex": case "camoIndex": case "decalIndex": case "primarySkinIndex": case "primaryCamoIndex": case "secondarySkinIndex": case "secondaryCamoIndex": case "weapon3SkinIndex": case "weapon3CamoIndex": case "primeSkinIndex": case "primeCamoIndex": case "primeDecalIndex": resultString = "0" break case "isPrime": resultString = "titan_is_not_prime" break case "execution": resultString = "execution_neck_snap" //HACK, not sure where this is getting set otherwise. break case "titanExecution": resultString = "execution_random_" + loadoutIndex //Loadout Index for Titans is synced to a specific Titan. break default: { bool isTitanLoadout = (loadoutType == "titan") bool isPilotLoadout = (loadoutType == "pilot") if ( isPilotLoadout ) { PilotLoadoutDef defaultPilotLoadout = GetDefaultPilotLoadout( loadoutIndex ) //HACK: note that this can give an invalid default for a child property, e.g. a sight that doesn't exist on this weapon. This is handled later in ResolveInvalidLoadoutChildValues resultString = GetPilotLoadoutValue( defaultPilotLoadout, propertyName ) } else if ( isTitanLoadout ) { TitanLoadoutDef defaultPilotLoadout = GetDefaultTitanLoadout( loadoutIndex ) //HACK: note that this can give an invalid default for a child property, e.g. a sight that doesn't exist on this weapon. This is handled later in ResolveInvalidLoadoutChildValues resultString = GetTitanLoadoutValue( defaultPilotLoadout, propertyName ) } else { unreachable } break } } //printt( "GetLoadoutPropertyDefault, loadoutType: " + loadoutType + ", loadoutIndex: " + loadoutIndex + ", propertyName: " + propertyName + ", resultString: " + resultString ) return resultString } string function GetCategoryRestrictedResetValue( entity player, int loadoutIndex, string targetProperty, string otherProperty ) { string loadoutType = "pilot" string otherPropertyValue = GetPersistentLoadoutValue( player, loadoutType, loadoutIndex, otherProperty ) string potentialDefaultValue = GetLoadoutPropertyDefault( loadoutType, loadoutIndex, targetProperty ) string resetValue = potentialDefaultValue if ( otherPropertyValue != "" ) { int otherCategory = expect int( GetItemDisplayData( otherPropertyValue ).i.menuCategory ) int potentialDefaultCategory = expect int( GetItemDisplayData( potentialDefaultValue ).i.menuCategory ) if ( potentialDefaultCategory == otherCategory ) { Assert( otherCategory == eSecondaryWeaponCategory.AT || otherCategory == eSecondaryWeaponCategory.PISTOL ) if ( otherCategory == eSecondaryWeaponCategory.AT ) resetValue = GetWeaponCategoryBasedDefault( eSecondaryWeaponCategory.PISTOL ) else resetValue = GetWeaponCategoryBasedDefault( eSecondaryWeaponCategory.AT ) } } return resetValue } string function GetWeaponCategoryBasedDefault( int category ) { string val switch ( category ) { case eSecondaryWeaponCategory.AT: val = "mp_weapon_defender" break case eSecondaryWeaponCategory.PISTOL: val = "mp_weapon_autopistol" break default: Assert( 0, "category: " + DEV_GetEnumStringFromIndex( "eSecondaryWeaponCategory", category ) + " not handled in GetWeaponCategoryBasedDefault()" ) break } return val } string function BuildPersistentVarAccessorString( string loadoutType, int loadoutIndex, string propertyName ) { return loadoutType + "Loadouts[" + loadoutIndex + "]." + propertyName } bool function LoadoutIsLocked( entity player, string loadoutType, int loadoutIndex ) { if ( loadoutType == "titan" ) { string titanClass = GetLoadoutPropertyDefault( "titan", loadoutIndex, "titanClass" ) return IsItemLocked( player, titanClass ) } else if ( loadoutType == "pilot" ) { string pilotLoadoutRef = "pilot_loadout_" + ( loadoutIndex + 1 ) return IsItemLocked( player, pilotLoadoutRef ) } unreachable } string function GetValidatedPersistentLoadoutValue( entity player, string loadoutType, int loadoutIndex, string loadoutProperty ) { #if SERVER Assert( loadoutType == "pilot" || loadoutType == "titan" ) Assert( loadoutIndex < PersistenceGetArrayCount( loadoutType + "Loadouts" ), "Invalid loadoutIndex: " + loadoutIndex ) var loadoutPropertyEnum = null if ( loadoutType == "pilot" ) { bool isValidPilotLoadoutProperty = IsValidPilotLoadoutProperty( loadoutProperty ) //Assert( isValidPilotLoadoutProperty, "Invalid pilot loadoutProperty: " + loadoutProperty ) if( !isValidPilotLoadoutProperty ) { CodeWarning( "Invalid pilot loadoutProperty: " + loadoutProperty ) return "" } loadoutPropertyEnum = GetPilotLoadoutPropertyEnum( loadoutProperty ) } else { bool isValidTitanLoadoutProperty = IsValidTitanLoadoutProperty( loadoutProperty ) //Assert( isValidTitanLoadoutProperty, "Invalid titan loadoutProperty: " + loadoutProperty ) if ( !isValidTitanLoadoutProperty ) { CodeWarning( "Invalid titan loadoutProperty: " + loadoutProperty ) return "" } loadoutPropertyEnum = GetTitanLoadoutPropertyEnum( loadoutProperty ) } string getString = BuildPersistentVarAccessorString( loadoutType, loadoutIndex, loadoutProperty ) var value = player.GetPersistentVar( getString ) if ( value == null ) value = "" if ( loadoutPropertyEnum != null ) { if ( !PersistenceEnumValueIsValid( loadoutPropertyEnum, value ) ) { printt( "Invalid Loadout Property: ", loadoutType, loadoutIndex, loadoutProperty, value ) value = ResetLoadoutPropertyToDefault( player, loadoutType, loadoutIndex, loadoutProperty ) //TODO: This will call player.SetPersistentVar() directly. Awkward to do this in a getter function ClientCommand( player, "disconnect #RESETTING_LOADOUT", 0 ) //Kick player out with a "Resetting Invalid Loadout" message. Mainly necessary so UI/Client script don't crash out later with known, bad data from persistence } } if ( LoadoutPropertyRequiresItemValidation( loadoutProperty ) && value != "" ) { if ( FailsLoadoutValidationCheck( player, loadoutType, loadoutIndex, loadoutProperty, value ) ) { printt( "Invalid Loadout Property: ", loadoutType, loadoutIndex, loadoutProperty, value ) value = ResetLoadoutPropertyToDefault( player, loadoutType, loadoutIndex, loadoutProperty ) //TODO: This will call player.SetPersistentVar() directly. Awkward to do this in a getter function ClientCommand( player, "disconnect #RESETTING_LOADOUT", 0 ) //Kick player out with a "Resetting Invalid Loadout" message. Mainly necessary so UI/Client script don't crash out later with known, bad data from persistence } ValidateSkinAndCamoIndexesAsAPair( player, loadoutType, loadoutIndex, loadoutProperty, value ) //TODO: This is awkward, has the potential to call a SetPersistentLoadoutValue() if skinIndex and camoIndex are not correct as a pair } return string( value ) #else return GetPersistentLoadoutValue( player, loadoutType, loadoutIndex, loadoutProperty ) #endif } int function GetValidatedPersistentLoadoutValueInt( entity player, string loadoutType, int loadoutIndex, string loadoutProperty ) { #if SERVER string returnValue = GetValidatedPersistentLoadoutValue( player, loadoutType, loadoutIndex, loadoutProperty ) return int( returnValue ) #else return GetPersistentLoadoutValueInt( player, loadoutType, loadoutIndex, loadoutProperty ) #endif } // SERVER: Looks at and updates persistent loadout data // CLIENT/UI: Looks at and updates cached loadout data void function ResolveInvalidLoadoutChildValues( entity player, string loadoutType, int loadoutIndex, string loadoutProperty, string parentValue ) { array<string> childProperties = GetChildLoadoutProperties( loadoutType, loadoutProperty ) //if ( childProperties.len() ) //{ // printt( "====== loadoutProperty:", loadoutProperty, "childProperties are:" ) // foreach ( childProperty in childProperties ) // printt( "====== ", childProperty ) //} if ( childProperties.len() ) { Assert( parentValue != "" ) foreach ( childProperty in childProperties ) { string childValue if ( childProperty == "primaryCamoIndex" || childProperty == "secondaryCamoIndex" || childProperty == "weapon3CamoIndex" ) // TODO: Keep skin on weapon change if possible { //printt( "====== loadoutProperty:", loadoutProperty, "childProperty:", childProperty, "will blind RESET" ) } else if ( childProperty == "primarySkinIndex" || childProperty == "secondarySkinIndex" || childProperty == "weapon3SkinIndex" ) { //printt( "====== loadoutProperty:", loadoutProperty, "childProperty:", childProperty, "will blind RESET" ) } else if ( (childProperty == "primaryMod2" || childProperty == "primaryMod3") && IsSubItemLocked( player, childProperty.tolower(), parentValue ) ) // check primarymod2 or primarymod3 feature locked { //printt( "====== loadoutProperty:", loadoutProperty, "childProperty:", childProperty, "will RESET due to feature lock" ) } else if ( (childProperty == "secondaryMod2" || childProperty == "weapon3Mod2") && IsSubItemLocked( player, "secondarymod2", parentValue ) ) // check secondarymod2 feature locked { //printt( "====== loadoutProperty:", loadoutProperty, "childProperty:", childProperty, "will RESET due to feature lock" ) } else if ( (childProperty == "secondaryMod3" || childProperty == "weapon3Mod3") && IsSubItemLocked( player, "secondarymod3", parentValue ) ) // check secondarymod3 feature locked { //printt( "====== loadoutProperty:", loadoutProperty, "childProperty:", childProperty, "will RESET due to feature lock" ) } else // check subitem locked { #if SERVER // TODO: This call will actually check and change the persistent data if it's invalid. Doesn't break anything here, but this function really shouldn't change persistent data. childValue = GetPersistentLoadoutValue( player, loadoutType, loadoutIndex, childProperty ) #else if ( loadoutType == "pilot" ) childValue = GetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], childProperty ) else if ( loadoutType == "titan" ) childValue = GetTitanLoadoutValue( shGlobal.cachedTitanLoadouts[ loadoutIndex ], childProperty ) else CodeWarning( "Unhandled loadoutType: " + loadoutType ) #endif if ( childValue == "" || ( childValue != "" && HasSubitem( parentValue, childValue ) && !IsSubItemLocked( player, childValue, parentValue ) ) ) { //printt( "====== loadoutProperty:", loadoutProperty, "childProperty:", childProperty, "will KEEP childValue: \"" + childValue + "\"" ) continue } //else //{ // printt( "====== loadoutProperty:", loadoutProperty, "childProperty:", childProperty, "will RESET childValue: \"" + childValue + "\"" ) //} } childValue = GetLoadoutChildPropertyDefault( loadoutType, childProperty, parentValue ) #if SERVER SetPlayerPersistentVarWithoutValidation( player, loadoutType, loadoutIndex, childProperty, childValue ) #else if ( loadoutType == "pilot" ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], childProperty, childValue ) else if ( loadoutType == "titan" ) SetTitanLoadoutValue( shGlobal.cachedTitanLoadouts[ loadoutIndex ], childProperty, childValue ) else CodeWarning( "Unhandled loadoutType: " + loadoutType ) #endif } } //else //{ // printt( "====== loadoutProperty:", loadoutProperty, "childProperties is empty" ) //} } #if UI || CLIENT void function SetCachedPilotLoadoutValue( entity player, int loadoutIndex, string loadoutProperty, string value ) { if ( !IsValidPilotLoadoutProperty( loadoutProperty ) ) { CodeWarning( "Tried to set pilot " + loadoutProperty + " to invalid value: " + value ) return } // Reset child properties when parent changes ResolveInvalidLoadoutChildValues( player, "pilot", loadoutIndex, loadoutProperty, value ) #if HAS_THREAT_SCOPE_SLOT_LOCK if ( loadoutProperty.tolower() == "primaryattachment" && value == "threat_scope" ) { SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "primaryMod2", "" ) } #endif SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], loadoutProperty, value ) UpdateDerivedPilotLoadoutData( shGlobal.cachedPilotLoadouts[ loadoutIndex ] ) #if UI if ( value == "" ) value = "null" ClientCommand( "SetPersistentLoadoutValue pilot " + loadoutIndex + " " + loadoutProperty + " " + value ) #endif // UI } void function SetCachedTitanLoadoutValue( entity player, int loadoutIndex, string loadoutProperty, string value ) { if ( !IsValidTitanLoadoutProperty( loadoutProperty ) ) { CodeWarning( "Tried to set titan " + loadoutProperty + " to invalid value: " + value ) return } // Reset child properties when parent changes ResolveInvalidLoadoutChildValues( player, "titan", loadoutIndex, loadoutProperty, value ) SetTitanLoadoutValue( shGlobal.cachedTitanLoadouts[ loadoutIndex ], loadoutProperty, value ) UpdateDerivedTitanLoadoutData( shGlobal.cachedTitanLoadouts[ loadoutIndex ] ) #if UI if ( value == "" ) value = "null" ClientCommand( "SetPersistentLoadoutValue titan " + loadoutIndex + " " + loadoutProperty + " " + value ) #endif // UI } // TODO: If we change a property that has a parent or child relationship, all related properties need updating if invalid // A parent change should validate children and set invalid to defaults // If a child change is invalid for the parent, it should be changed to a valid default based on the parent void function SetCachedLoadoutValue( entity player, string loadoutType, int loadoutIndex, string loadoutProperty, string value ) { // Keep CLIENT matching UI #if UI RunClientScript( "SetCachedLoadoutValue", player, loadoutType, loadoutIndex, loadoutProperty, value ) #endif // UI //printt( "=======================================================================================" ) //printt( "SetPersistentLoadoutValue called with loadoutType:", loadoutType, "loadoutIndex:", loadoutIndex, "loadoutProperty:" , loadoutProperty, "value:", value ) //printl( "script GetPlayerArray()[0].SetPersistentVar( \"" + loadoutType + "Loadouts[" + loadoutIndex + "]." + loadoutProperty + "\", \"" + value + "\" )" ) //printt( "=======================================================================================" ) if ( loadoutType == "pilot" ) SetCachedPilotLoadoutValue( player, loadoutIndex, loadoutProperty, value ) else if ( loadoutType == "titan" ) SetCachedTitanLoadoutValue( player, loadoutIndex, loadoutProperty, value ) else CodeWarning( "Unhandled loadoutType: " + loadoutType ) /* Assert( loadoutType == "pilot" || loadoutType == "titan" ) Assert( loadoutIndex < PersistenceGetArrayCount( loadoutType + "Loadouts" ), "Invalid loadoutIndex: " + loadoutIndex ) if ( value == "null" || value == "" || value == null ) { CodeWarning( "Tried to set " + loadoutType + " " + loadoutProperty + " to invalid value: " + value ) return } var loadoutPropertyEnum = null if ( loadoutType == "pilot" ) { if ( !IsValidPilotLoadoutProperty( loadoutProperty ) ) { CodeWarning( "Invalid pilot loadoutProperty: " + loadoutProperty ) return } loadoutPropertyEnum = GetPilotLoadoutPropertyEnum( loadoutProperty ) } else { if ( !IsValidTitanLoadoutProperty( loadoutProperty ) ) { CodeWarning( "Invalid titan loadoutProperty: " + loadoutProperty ) return } loadoutPropertyEnum = GetTitanLoadoutPropertyEnum( loadoutProperty ) } if ( loadoutPropertyEnum == null ) { CodeWarning( "Couldn't find loadoutPropertyEnum for " + loadoutType + " " + loadoutProperty ) return } if ( !PersistenceEnumValueIsValid( loadoutPropertyEnum, value ) ) { CodeWarning( loadoutProperty + " value: " + value + " not valid in persistent data!" ) return } // Only checks primary mods and attachments are valid in itemData and the parent isn't locked if ( !IsLoadoutSubitemValid( player, loadoutType, loadoutIndex, loadoutProperty, value ) ) { CodeWarning( loadoutProperty + " value: " + value + " failed IsLoadoutSubitemValid() check! It may not exist in itemData, or it's parent item is locked." ) return } // Reset child properties when parent changes array<string> childProperties = GetChildLoadoutProperties( loadoutType, loadoutProperty ) if ( childProperties.len() ) { foreach ( childProperty in childProperties ) { Assert( value != "" ) string childValue = GetLoadoutChildPropertyDefault( loadoutType, childProperty, value ) if ( loadoutType == "pilot" ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], childProperty, childValue ) else SetTitanLoadoutValue( shGlobal.cachedTitanLoadouts[ loadoutIndex ], childProperty, childValue ) } } if ( loadoutType == "pilot" ) { SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], loadoutProperty, value ) UpdateDerivedPilotLoadoutData( shGlobal.cachedPilotLoadouts[ loadoutIndex ] ) } else { SetTitanLoadoutValue( shGlobal.cachedTitanLoadouts[ loadoutIndex ], loadoutProperty, value ) OverwriteLoadoutWithDefaultsForSetFile_ExceptSpecialAndAntiRodeo( shGlobal.cachedTitanLoadouts[ loadoutIndex ] ) } if ( value == "" || value == "null" ) ClientCommand( "SetPersistentLoadoutValue " + loadoutType + " " + loadoutIndex + " " + loadoutProperty + " " + null ) else ClientCommand( "SetPersistentLoadoutValue " + loadoutType + " " + loadoutIndex + " " + loadoutProperty + " " + value ) */ } #endif // UI || CLIENT // SERVER version waits till end of frame to reduce remote calls which can get high when loadouts are first initialized // CLIENT and UI versions need to wait for persistent data to be ready // Ideally, UI and CLIENT would have a callback that triggered when persistent loadout data changed. void function UpdateCachedLoadouts() { #if SERVER Signal( level, "EndUpdateCachedLoadouts" ) EndSignal( level, "EndUpdateCachedLoadouts" ) WaitEndFrame() array<entity> players = GetPlayerArray() foreach ( player in players ) { if ( player.p.pilotLoadoutChanged ) { Remote_CallFunction_NonReplay( player, "UpdateAllCachedPilotLoadouts" ) player.p.pilotLoadoutChanged = false } if ( player.p.titanLoadoutChanged ) { Remote_CallFunction_NonReplay( player, "UpdateAllCachedTitanLoadouts" ) player.p.titanLoadoutChanged = false } // TEMP client model update method if ( player.p.pilotModelNeedsUpdate != -1 ) { Remote_CallFunction_NonReplay( player, "ServerCallback_UpdatePilotModel", player.p.pilotModelNeedsUpdate ) player.p.pilotModelNeedsUpdate = -1 } if ( player.p.titanModelNeedsUpdate != -1 ) { Remote_CallFunction_NonReplay( player, "ServerCallback_UpdateTitanModel", player.p.titanModelNeedsUpdate ) player.p.titanModelNeedsUpdate = -1 } } #elseif UI || CLIENT #if UI entity player = GetUIPlayer() #elseif CLIENT entity player = GetLocalClientPlayer() #endif if ( player == null ) return #if UI EndSignal( uiGlobal.signalDummy, "LevelShutdown" ) #endif // UI while ( player.GetPersistentVarAsInt( "initializedVersion" ) < PERSISTENCE_INIT_VERSION ) { WaitFrame() } UpdateAllCachedPilotLoadouts() UpdateAllCachedTitanLoadouts() #if CLIENT Signal( level, "CachedLoadoutsReady" ) #endif // CLIENT #endif } #if UI void function InitUISpawnLoadoutIndexes() { EndSignal( uiGlobal.signalDummy, "LevelShutdown" ) entity player = GetUIPlayer() if ( player == null ) return while ( player.GetPersistentVarAsInt( "initializedVersion" ) < PERSISTENCE_INIT_VERSION ) WaitFrame() uiGlobal.pilotSpawnLoadoutIndex = GetPersistentSpawnLoadoutIndex( player, "pilot" ) uiGlobal.titanSpawnLoadoutIndex = GetPersistentSpawnLoadoutIndex( player, "titan" ) } #endif // UI // There's no good way to dynamically reference a struct variable string function GetPilotLoadoutValue( PilotLoadoutDef loadout, string property ) { string value printt( "GetPilotLoadoutValue, property: " + property ) switch ( property ) { case "name": value = loadout.name break case "suit": value = loadout.suit break case "race": value = loadout.race break case "primary": value = loadout.primary break case "primaryAttachment": value = loadout.primaryAttachment break case "primaryMod1": value = loadout.primaryMod1 break case "primaryMod2": value = loadout.primaryMod2 break case "primaryMod3": value = loadout.primaryMod3 break case "secondary": value = loadout.secondary break case "secondaryMod1": value = loadout.secondaryMod1 break case "secondaryMod2": value = loadout.secondaryMod2 break case "secondaryMod3": value = loadout.secondaryMod3 break case "weapon3": value = loadout.weapon3 break case "weapon3Mod1": value = loadout.weapon3Mod1 break case "weapon3Mod2": value = loadout.weapon3Mod2 break case "weapon3Mod3": value = loadout.weapon3Mod3 break case "special": value = loadout.special break case "ordnance": value = loadout.ordnance break case "passive1": value = loadout.passive1 break case "passive2": value = loadout.passive2 break case "melee": value = loadout.melee break case "execution": value = loadout.execution break case "skinIndex": value = string( loadout.skinIndex ) break case "camoIndex": value = string( loadout.camoIndex ) break case "primarySkinIndex": value = string( loadout.primarySkinIndex ) break case "primaryCamoIndex": value = string( loadout.primaryCamoIndex ) break case "secondarySkinIndex": value = string( loadout.secondarySkinIndex ) break case "secondaryCamoIndex": value = string ( loadout.secondaryCamoIndex ) break case "weapon3SkinIndex": value = string( loadout.weapon3SkinIndex ) break case "weapon3CamoIndex": value = string ( loadout.weapon3CamoIndex ) break default: printt( "Returning blank for property: " + property ) //TODO: This should probably just be an error, but some existing calls depend on blank string being returned value = "" } return value } // There's no good way to dynamically reference a struct variable // If this starts getting called outside of SetPersistentLoadoutValue(), it needs error checking void function SetPilotLoadoutValue( PilotLoadoutDef loadout, string property, string value ) { switch ( property ) { case "name": loadout.name = value break case "suit": loadout.suit = value break case "execution": loadout.execution = value break case "race": loadout.race = value break case "primary": loadout.primary = value break case "primaryAttachment": loadout.primaryAttachment = value break case "primaryMod1": loadout.primaryMod1 = value break case "primaryMod2": loadout.primaryMod2 = value break case "primaryMod3": loadout.primaryMod3 = value break case "secondary": loadout.secondary = value break case "secondaryMod1": loadout.secondaryMod1 = value break case "secondaryMod2": loadout.secondaryMod2 = value break case "secondaryMod3": loadout.secondaryMod3 = value break case "weapon3": loadout.weapon3 = value break case "weapon3Mod1": loadout.weapon3Mod1 = value break case "weapon3Mod2": loadout.weapon3Mod2 = value break case "weapon3Mod3": loadout.weapon3Mod3 = value break case "special": loadout.special = value break case "ordnance": loadout.ordnance = value break case "passive1": loadout.passive1 = value break case "passive2": loadout.passive2 = value break case "melee": loadout.melee = value break case "skinIndex": loadout.skinIndex = int( value ) break case "camoIndex": loadout.camoIndex = int( value ) break case "primarySkinIndex": loadout.primarySkinIndex = int( value ) break case "primaryCamoIndex": loadout.primaryCamoIndex = int( value ) break case "secondarySkinIndex": loadout.secondarySkinIndex = int( value ) break case "secondaryCamoIndex": loadout.secondaryCamoIndex = int( value ) break case "weapon3SkinIndex": loadout.weapon3SkinIndex = int( value ) break case "weapon3CamoIndex": loadout.weapon3CamoIndex = int( value ) break } } // There's no good way to dynamically reference a struct variable string function GetTitanLoadoutValue( TitanLoadoutDef loadout, string property ) { string value switch ( property ) { case "name": value = loadout.name break case "titanClass": value = loadout.titanClass break case "primeTitanRef": value = loadout.primeTitanRef break case "setFile": value = loadout.setFile break case "coreAbility": value = loadout.coreAbility break case "primary": value = loadout.primary break case "primaryMod": value = loadout.primaryMod break case "special": value = loadout.special break case "antirodeo": value = loadout.antirodeo break case "ordnance": value = loadout.ordnance break case "passive1": value = loadout.passive1 break case "passive2": value = loadout.passive2 break case "passive3": value = loadout.passive3 break case "passive4": value = loadout.passive4 break case "passive5": value = loadout.passive5 break case "passive6": value = loadout.passive6 break case "skinIndex": value = string( loadout.skinIndex ) break case "camoIndex": value = string ( loadout.camoIndex ) break case "decalIndex": value = string( loadout.decalIndex ) break case "primarySkinIndex": value = string ( loadout.primarySkinIndex ) break case "primaryCamoIndex": value = string ( loadout.primaryCamoIndex ) break case "difficulty": value = string ( loadout.difficulty ) //TODO: Unused? break case "isPrime": value = loadout.isPrime break case "primeSkinIndex": value = string( loadout.primeSkinIndex ) break case "primeCamoIndex": value = string( loadout.primeCamoIndex ) break case "primeDecalIndex": value = string( loadout.primeDecalIndex ) break case "titanExecution": value = loadout.titanExecution break default: printt( "Returning blank for property: " + property ) //TODO: This should probably just be an error, but some existing calls depend on blank string being returned value = "" } return value } // There's no good way to dynamically reference a struct variable // If this starts getting called outside of SetPersistentLoadoutValue(), it needs error checking void function SetTitanLoadoutValue( TitanLoadoutDef loadout, string property, string value ) { switch ( property ) { case "name": loadout.name = value break case "setFile": loadout.setFile = value break case "primaryMod": loadout.primaryMod = value break case "special": loadout.special = value break case "antirodeo": loadout.antirodeo = value break case "passive1": loadout.passive1 = value break case "passive2": loadout.passive2 = value break case "passive3": loadout.passive3 = value break case "passive4": loadout.passive4 = value break case "passive5": loadout.passive5 = value break case "passive6": loadout.passive6 = value break case "skinIndex": loadout.skinIndex = int( value ) break case "camoIndex": loadout.camoIndex = int( value ) break case "decalIndex": loadout.decalIndex = int( value ) break case "primarySkinIndex": loadout.primarySkinIndex = int( value ) break case "primaryCamoIndex": loadout.primaryCamoIndex = int( value ) break case "isPrime": loadout.isPrime = value break case "primeSkinIndex": loadout.primeSkinIndex = int( value ) break case "primeCamoIndex": loadout.primeCamoIndex = int( value ) break case "primeDecalIndex": loadout.primeDecalIndex = int( value ) break case "titanExecution": loadout.titanExecution = value break case "showArmBadge": loadout.showArmBadge = int( value ) break } } bool function IsValidPilotLoadoutProperty( string propertyName ) { switch ( propertyName ) { case "name": case "suit": case "race": case "execution": case "primary": case "primaryAttachment": case "primaryMod1": case "primaryMod2": case "primaryMod3": case "secondary": case "secondaryMod1": case "secondaryMod2": case "secondaryMod3": case "weapon3": case "weapon3Mod1": case "weapon3Mod2": case "weapon3Mod3": case "ordnance": case "special": case "passive1": case "passive2": case "melee": case "skinIndex": case "camoIndex": case "primarySkinIndex": case "primaryCamoIndex": case "secondarySkinIndex": case "secondaryCamoIndex": case "weapon3SkinIndex": case "weapon3CamoIndex": return true } return false } bool function IsValidTitanLoadoutProperty( string propertyName ) { switch ( propertyName ) { case "name": case "titanClass": case "setFile": case "primaryMod": case "special": case "antirodeo": case "passive1": case "passive2": case "passive3": case "passive4": case "passive5": case "passive6": case "skinIndex": case "camoIndex": case "decalIndex": case "primarySkinIndex": case "primaryCamoIndex": case "isPrime": case "primeSkinIndex": case "primeCamoIndex": case "primeDecalIndex": case "titanExecution": case "showArmBadge": return true } return false } var function GetPilotLoadoutPropertyEnum( string property ) { switch ( property ) { case "suit": return "pilotSuit" case "race": return "pilotRace" case "primary": case "secondary": case "weapon3": case "special": case "ordnance": case "melee": return "loadoutWeaponsAndAbilities" case "primaryAttachment": case "primaryMod1": case "primaryMod2": case "primaryMod3": case "secondaryMod1": case "secondaryMod2": case "secondaryMod3": case "weapon3Mod1": case "weapon3Mod2": case "weapon3Mod3": return "pilotMod" case "passive1": case "passive2": return "pilotPassive" case "name": default: return null } } var function GetTitanLoadoutPropertyEnum( string property ) { switch ( property ) { case "titanClass": return "titanClasses" case "primary": case "special": case "antirodeo": case "ordnance": return "loadoutWeaponsAndAbilities" case "primaryMod": return "titanMod" case "passive1": case "passive2": case "passive3": case "passive4": case "passive5": case "passive6": return "titanPassive" case "isPrime": return "titanIsPrimeTitan" case "name": default: return null } } int function GetItemTypeFromPilotLoadoutProperty( string loadoutProperty ) { int itemType switch ( loadoutProperty ) { case "suit": itemType = eItemTypes.PILOT_SUIT break case "primary": itemType = eItemTypes.PILOT_PRIMARY break case "secondary": case "weapon3": // Most cases need to treat as secondary, so don't return eItemTypes.PILOT_WEAPON3 here itemType = eItemTypes.PILOT_SECONDARY break case "special": itemType = eItemTypes.PILOT_SPECIAL break case "ordnance": itemType = eItemTypes.PILOT_ORDNANCE break case "passive1": itemType = eItemTypes.PILOT_PASSIVE1 break case "passive2": itemType = eItemTypes.PILOT_PASSIVE2 break case "primaryAttachment": itemType = eItemTypes.PILOT_PRIMARY_ATTACHMENT break case "primaryMod1": case "primaryMod2": itemType = eItemTypes.PILOT_PRIMARY_MOD break case "secondaryMod1": case "secondaryMod2": case "weapon3Mod1": case "weapon3Mod2": itemType = eItemTypes.PILOT_SECONDARY_MOD break case "primaryMod3": case "secondaryMod3": case "weapon3Mod3": itemType = eItemTypes.PILOT_WEAPON_MOD3 break case "race": itemType = eItemTypes.RACE break case "execution": itemType = eItemTypes.PILOT_EXECUTION break default: Assert( false, "Invalid pilot loadout property!" ) } return itemType } int function GetItemTypeFromTitanLoadoutProperty( string loadoutProperty, string setFile = "" ) { int itemType switch ( loadoutProperty ) { case "setFile": itemType = eItemTypes.TITAN break case "coreAbility": itemType = eItemTypes.TITAN_CORE_ABILITY break case "primary": itemType = eItemTypes.TITAN_PRIMARY break case "special": itemType = eItemTypes.TITAN_SPECIAL break case "ordnance": itemType = eItemTypes.TITAN_ORDNANCE break case "antirodeo": itemType = eItemTypes.TITAN_ANTIRODEO break case "passive1": case "passive2": case "passive3": case "passive4": case "passive5": case "passive6": Assert( setFile != "" ) itemType = GetTitanLoadoutPropertyPassiveType( setFile, loadoutProperty ) break case "titanExecution": Assert( setFile != "" ) itemType = GetTitanLoadoutPropertyExecutionType( setFile, loadoutProperty ) break case "voice": itemType = eItemTypes.TITAN_OS break case "primaryMod": itemType = eItemTypes.TITAN_PRIMARY_MOD break default: Assert( false, "Invalid titan loadout property!" ) } return itemType } string function GetLoadoutChildPropertyDefault( string loadoutType, string propertyName, string parentValue ) { Assert( loadoutType == "pilot" || loadoutType == "titan" ) string resetValue = "" if ( loadoutType == "pilot" ) { switch ( propertyName ) { case "primaryAttachment": case "primaryMod1": case "primaryMod2": case "primaryMod3": case "secondaryMod1": case "secondaryMod2": case "secondaryMod3": case "weapon3Mod1": case "weapon3Mod2": case "weapon3Mod3": resetValue = GetWeaponBasedDefaultMod( parentValue, propertyName ) break case "primaryCamoIndex": case "primarySkinIndex": case "secondaryCamoIndex": case "secondarySkinIndex": case "weapon3CamoIndex": case "weapon3SkinIndex": resetValue = "0" break } } return resetValue } // There's no great way to know the dependency heirarchy of persistent loadout data array<string> function GetChildLoadoutProperties( string loadoutType, string propertyName ) { Assert( loadoutType == "pilot" || loadoutType == "titan" ) array<string> childProperties if ( loadoutType == "pilot" ) { switch ( propertyName ) { /*case "suit": childProperties.append( "passive1" ) childProperties.append( "passive2" ) break*/ case "primary": childProperties.append( "primaryAttachment" ) childProperties.append( "primaryMod1" ) childProperties.append( "primaryMod2" ) childProperties.append( "primaryMod3" ) childProperties.append( "primaryCamoIndex" ) childProperties.append( "primarySkinIndex" ) break case "secondary": childProperties.append( "secondaryMod1" ) childProperties.append( "secondaryMod2" ) childProperties.append( "secondaryMod3" ) childProperties.append( "secondaryCamoIndex" ) childProperties.append( "secondarySkinIndex" ) break case "weapon3": childProperties.append( "weapon3Mod1" ) childProperties.append( "weapon3Mod2" ) childProperties.append( "weapon3Mod3" ) childProperties.append( "weapon3CamoIndex" ) childProperties.append( "weapon3SkinIndex" ) break /*case "melee": childProperties.append( "meleeMods" ) // not in persistent data break case "ordnance": childProperties.append( "ordnanceMods" ) // not in persistent data break*/ } } else { switch ( propertyName ) { /*case "setFile": childProperties.append( "setFileMods" ) // not in persistent data break case "primary": //childProperties.append( "primaryAttachment" ) // not in persistent data childProperties.append( "primaryMod" ) break case "special": childProperties.append( "specialMods" ) // not in persistent data break case "ordnance": childProperties.append( "ordnanceMods" ) // not in persistent data break case "antirodeo": childProperties.append( "antirodeoMods" ) // not in persistent data break*/ } } return childProperties } // There's no great way to know the dependency heirarchy of persistent loadout data string function GetParentLoadoutProperty( string loadoutType, string propertyName ) { Assert( loadoutType == "pilot" || loadoutType == "titan" ) string parentProperty if ( loadoutType == "pilot" ) { switch ( propertyName ) { case "primaryAttachment": case "primaryMod1": case "primaryMod2": case "primaryMod3": case "primaryCamoIndex": case "primarySkinIndex": parentProperty = "primary" break case "secondaryMod1": case "secondaryMod2": case "secondaryMod3": case "secondaryCamoIndex": case "secondarySkinIndex": parentProperty = "secondary" break case "weapon3Mod1": case "weapon3Mod2": case "weapon3Mod3": case "weapon3CamoIndex": case "weapon3SkinIndex": parentProperty = "weapon3" break case "passive1": case "passive2": parentProperty = "special" break default: Assert( 0, "Unknown loadout propertyName: " + propertyName ) } } else { switch ( propertyName ) { case "passive1": case "passive2": case "passive3": case "passive4": case "passive5": case "passive6": parentProperty = "titanClass" break default: Assert( 0, "Unknown loadout propertyName: " + propertyName ) } } return parentProperty } int function GetPersistentSpawnLoadoutIndex( entity player, string loadoutType ) { int loadoutIndex = player.GetPersistentVarAsInt( loadoutType + "SpawnLoadout.index" ) if ( loadoutType == "titan" && loadoutIndex >= NUM_PERSISTENT_TITAN_LOADOUTS ) loadoutIndex = 0 return loadoutIndex } #if SERVER void function SetPersistentSpawnLoadoutIndex( entity player, string loadoutType, int loadoutIndex ) { Assert( loadoutIndex >= 0 ) player.SetPersistentVar( loadoutType + "SpawnLoadout.index", loadoutIndex ) } #endif // SERVER #if UI void function SetEditLoadout( string loadoutType, int loadoutIndex ) { uiGlobal.editingLoadoutType = loadoutType uiGlobal.editingLoadoutIndex = loadoutIndex } void function ClearEditLoadout() { uiGlobal.editingLoadoutType = "" uiGlobal.editingLoadoutIndex = -1 } PilotLoadoutDef function GetPilotEditLoadout() { return GetCachedPilotLoadout( uiGlobal.editingLoadoutIndex ) } TitanLoadoutDef function GetTitanEditLoadout() { return GetCachedTitanLoadout( uiGlobal.editingLoadoutIndex ) } int function GetLoadoutIndexForTitanClass( string titanClass ) { for ( int loadoutIndex = 0; loadoutIndex < NUM_PERSISTENT_TITAN_LOADOUTS; loadoutIndex++ ) { TitanLoadoutDef loadout = GetCachedTitanLoadout( loadoutIndex ) if ( loadout.titanClass == titanClass ) return loadoutIndex } return -1 } string function GetPilotLoadoutName( PilotLoadoutDef loadout ) { if ( IsTokenLoadoutName( loadout.name ) ) return Localize( loadout.name ) return loadout.name } string function GetTitanLoadoutName( TitanLoadoutDef loadout ) { if ( IsTokenLoadoutName( loadout.name ) ) return Localize( loadout.name ) return loadout.name } void function SetTextFromItemName( var element, string ref ) { string text = "" if ( ref != "" ) text = GetItemName( ref ) Hud_SetText( element, text ) } void function SetTextFromItemDescription( var element, string ref ) { string text = "" if ( ref != "" ) text = GetItemDescription( ref ) Hud_SetText( element, text ) } void function SetTextFromItemLongDescription( var element, string ref ) { string text = "" if ( ref != "" ) text = GetItemLongDescription( ref ) Hud_SetText( element, text ) } void function SetImageFromItemImage( var element, string ref ) { if ( ref != "" ) { Hud_SetImage( element, GetItemImage( ref ) ) Hud_Show( element ) } else { Hud_Hide( element ) } } void function SetTextFromSubItemClipSize( var element, string ref, string modRef ) { Hud_SetText( element, "" ) if ( ref != "" && modRef != "" ) { int clipDiff = GetSubItemClipSizeStat( ref, modRef ) if ( clipDiff == 0 ) return if ( clipDiff > 0 ) { Hud_SetColor( element, 141, 197, 84, 255 ) Hud_SetText( element, "#MOD_CLIP_AMMO_INCREASE", string( clipDiff ) ) } else { Hud_SetColor( element, 211, 77, 61, 255 ) Hud_SetText( element, "#MOD_CLIP_AMMO_DECREASE", string( abs( clipDiff ) ) ) } } } void function SetTextFromSubitemName( var element, string parentRef, string childRef, string defaultText = "" ) { string text = defaultText if ( parentRef != "" && childRef != "" && childRef != "none" ) text = GetSubitemName( parentRef, childRef ) Hud_SetText( element, text ) } void function SetTextFromSubitemDescription( var element, string parentRef, string childRef, string defaultText = "" ) { string text = defaultText if ( parentRef != "" && childRef != "" && childRef != "none" ) text = GetSubitemDescription( parentRef, childRef ) Hud_SetText( element, text ) } void function SetTextFromSubitemLongDescription( var element, string parentRef, string childRef, string defaultText = "" ) { string text = defaultText if ( parentRef != "" && childRef != "" && childRef != "none" ) text = GetSubitemLongDescription( parentRef, childRef ) Hud_SetText( element, text ) } void function SetImageFromSubitemImage( var element, string parentRef, string childRef, asset defaultIcon = $"" ) { if ( parentRef != "" && childRef != "" && childRef != "none" ) { Hud_SetImage( element, GetSubitemImage( parentRef, childRef ) ) Hud_Show( element ) } else { if ( defaultIcon != $"" ) { Hud_SetImage( element, defaultIcon ) Hud_Show( element ) } else { Hud_Hide( element ) } } } void function SetTextFromSubitemUnlockReq( var element, string parentRef, string childRef, string defaultText = "" ) { string text = defaultText if ( parentRef != "" && childRef != "" && childRef != "none" ) text = GetItemUnlockReqText( childRef, parentRef ) Hud_SetText( element, text ) } #endif //UI #if UI || CLIENT void function UpdateAllCachedPilotLoadouts() { int numLoadouts = shGlobal.cachedPilotLoadouts.len() for ( int i = 0; i < numLoadouts; i++ ) UpdateCachedPilotLoadout( i ) } void function UpdateAllCachedTitanLoadouts() { int numLoadouts = shGlobal.cachedTitanLoadouts.len() for ( int i = 0; i < numLoadouts; i++ ) UpdateCachedTitanLoadout( i ) } void function UpdateCachedPilotLoadout( int loadoutIndex ) { entity player #if UI player = GetUIPlayer() #elseif CLIENT player = GetLocalClientPlayer() #endif if ( player == null ) return PopulatePilotLoadoutFromPersistentData( player, shGlobal.cachedPilotLoadouts[ loadoutIndex ], loadoutIndex ) } void function UpdateCachedTitanLoadout( int loadoutIndex ) { entity player #if UI player = GetUIPlayer() #elseif CLIENT player = GetLocalClientPlayer() #endif if ( player == null ) return PopulateTitanLoadoutFromPersistentData( player, shGlobal.cachedTitanLoadouts[ loadoutIndex ], loadoutIndex ) } PilotLoadoutDef function GetCachedPilotLoadout( int loadoutIndex ) { Assert( loadoutIndex >= 0 && loadoutIndex < shGlobal.cachedPilotLoadouts.len() ) return shGlobal.cachedPilotLoadouts[ loadoutIndex ] } TitanLoadoutDef function GetCachedTitanLoadout( int loadoutIndex ) { Assert( loadoutIndex >= 0 && loadoutIndex < shGlobal.cachedTitanLoadouts.len() ) return shGlobal.cachedTitanLoadouts[ loadoutIndex ] } PilotLoadoutDef[ NUM_PERSISTENT_PILOT_LOADOUTS ] function GetAllCachedPilotLoadouts() { return shGlobal.cachedPilotLoadouts } TitanLoadoutDef[ NUM_PERSISTENT_TITAN_LOADOUTS ] function GetAllCachedTitanLoadouts() { return shGlobal.cachedTitanLoadouts } int function GetCachedTitanLoadoutCamoIndex( int loadoutIndex ) { TitanLoadoutDef cachedTitanLoadout = GetCachedTitanLoadout( loadoutIndex ) return GetTitanCamoIndexFromLoadoutAndPrimeStatus( cachedTitanLoadout ) } int function GetCachedTitanLoadoutSkinIndex( int loadoutIndex ) { TitanLoadoutDef cachedTitanLoadout = GetCachedTitanLoadout( loadoutIndex ) return GetTitanSkinIndexFromLoadoutAndPrimeStatus( cachedTitanLoadout ) } int function GetCachedTitanLoadoutDecalIndex( int loadoutIndex ) { TitanLoadoutDef cachedTitanLoadout = GetCachedTitanLoadout( loadoutIndex ) return GetTitanDecalIndexFromLoadoutAndPrimeStatus( cachedTitanLoadout ) } asset function GetCachedTitanLoadoutArmBadge( int loadoutIndex ) { TitanLoadoutDef cachedTitanLoadout = GetCachedTitanLoadout( loadoutIndex ) return GetTitanArmBadgeFromLoadoutAndPrimeStatus( cachedTitanLoadout ) } int function GetCachedTitanArmBadgeState( int loadoutIndex ) { TitanLoadoutDef cachedTitanLoadout = GetCachedTitanLoadout( loadoutIndex ) return cachedTitanLoadout.showArmBadge } #endif // UI || CLIENT #if UI bool function IsTokenLoadoutName( string name ) { if ( name.find( "#DEFAULT_PILOT_" ) != null || name.find( "#DEFAULT_TITAN_" ) != null ) return true return false } #endif // UI string function Loadouts_GetSetFileForRequestedClass( entity player ) { int loadoutIndex = GetPersistentSpawnLoadoutIndex( player, "pilot" ) PilotLoadoutDef loadout PopulatePilotLoadoutFromPersistentData( player, loadout, loadoutIndex ) return loadout.setFile } #if SERVER void function SetPersistentPilotLoadout( entity player, int loadoutIndex, PilotLoadoutDef loadout ) { SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "name", loadout.name ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "suit", loadout.suit ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "race", loadout.race ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "primary", loadout.primary ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "primaryAttachment", loadout.primaryAttachment ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "primaryMod1", loadout.primaryMod1 ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "primaryMod2", loadout.primaryMod2 ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "primaryMod3", loadout.primaryMod3 ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "secondary", loadout.secondary ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "secondaryMod1", loadout.secondaryMod1 ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "secondaryMod2", loadout.secondaryMod2 ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "secondaryMod3", loadout.secondaryMod3 ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "weapon3", loadout.weapon3 ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "weapon3Mod1", loadout.weapon3Mod1 ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "weapon3Mod2", loadout.weapon3Mod2 ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "weapon3Mod3", loadout.weapon3Mod3 ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "ordnance", loadout.ordnance ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "passive1", loadout.passive1 ) SetPersistentLoadoutValue( player, "pilot", loadoutIndex, "passive2", loadout.passive2 ) } void function SetPersistentTitanLoadout( entity player, int loadoutIndex, TitanLoadoutDef loadout ) { SetPersistentLoadoutValue( player, "titan", loadoutIndex, "name", loadout.name ) SetPersistentLoadoutValue( player, "titan", loadoutIndex, "titanClass", GetTitanCharacterNameFromSetFile( loadout.setFile ) ) //SetPersistentLoadoutValue( player, "titan", loadoutIndex, "setFile", loadout.setFile ) //SetPersistentLoadoutValue( player, "titan", loadoutIndex, "primaryMod", loadout.primaryMod ) SetPersistentLoadoutValue( player, "titan", loadoutIndex, "special", loadout.special ) SetPersistentLoadoutValue( player, "titan", loadoutIndex, "antirodeo", loadout.antirodeo ) SetPersistentLoadoutValue( player, "titan", loadoutIndex, "passive1", loadout.passive1 ) SetPersistentLoadoutValue( player, "titan", loadoutIndex, "passive2", loadout.passive2 ) SetPersistentLoadoutValue( player, "titan", loadoutIndex, "passive3", loadout.passive3 ) SetPersistentLoadoutValue( player, "titan", loadoutIndex, "passive4", loadout.passive4 ) SetPersistentLoadoutValue( player, "titan", loadoutIndex, "passive5", loadout.passive5 ) SetPersistentLoadoutValue( player, "titan", loadoutIndex, "passive6", loadout.passive6 ) SetPersistentLoadoutValue( player, "titan", loadoutIndex, "titanExecution", loadout.titanExecution ) } bool function PlayerIsInGracePeriod( entity player ) { if ( svGlobal.isInPilotGracePeriod && !player.IsTitan() ) return true if ( player.s.inGracePeriod ) return true if ( player.p.usingLoadoutCrate ) return true return false } bool function Loadouts_CanGivePilotLoadout( entity player ) { if ( !IsAlive( player ) ) return false if ( !PlayerIsInGracePeriod( player ) ) return false // hack for bug 114632, 167264. Real fix would be to make dropship spawn script not end on anim reset from model change. if ( player.GetParent() != null ) { if ( HasCinematicFlag( player, CE_FLAG_INTRO ) ) return false if ( HasCinematicFlag( player, CE_FLAG_CLASSIC_MP_SPAWNING ) ) return false if ( HasCinematicFlag( player, CE_FLAG_WAVE_SPAWNING ) ) return false } if ( player.IsTitan() ) return false return true } bool function Loadouts_CanGiveTitanLoadout( entity player ) { // if ( GetPlayerBurnCardOnDeckIndex( player ) != null ) // return false if ( HasCinematicFlag( player, CE_FLAG_INTRO ) ) return false if ( HasCinematicFlag( player, CE_FLAG_CLASSIC_MP_SPAWNING ) ) return false if ( !IsAlive( player ) ) return false if ( !PlayerIsInGracePeriod( player ) ) return false if ( player.isSpawningHotDroppingAsTitan ) return false if ( !player.IsTitan() ) return false // JFS: wargames round switch BS if ( !IsValid( player.GetTitanSoul() ) ) return false return true } string function Loadouts_GetSetFileForActiveClass( entity player ) { int loadoutIndex = GetActivePilotLoadoutIndex( player ) PilotLoadoutDef loadout PopulatePilotLoadoutFromPersistentData( player, loadout, loadoutIndex ) return loadout.setFile } string function Loadouts_GetPilotRaceForActiveClass( entity player ) { int loadoutIndex = GetActivePilotLoadoutIndex( player ) PilotLoadoutDef loadout PopulatePilotLoadoutFromPersistentData( player, loadout, loadoutIndex ) return loadout.race } bool function Loadouts_TryGivePilotLoadout( entity player ) { if ( !Loadouts_CanGivePilotLoadout( player ) ) return false PilotLoadoutDef loadout int loadoutIndex = GetPersistentSpawnLoadoutIndex( player, "pilot" ) #if DEV if ( player.IsBot() && !player.IsPlayback() && GetConVarString( "bot_pilot_settings" ) == "random" ) loadout = GetRandomPilotLoadout() else #endif loadout = GetPilotLoadoutFromPersistentData( player, loadoutIndex ) UpdateDerivedPilotLoadoutData( loadout ) if ( player.IsBot() && !player.IsPlayback() ) OverrideBotPilotLoadout( loadout ) GivePilotLoadout( player, loadout ) SetActivePilotLoadout( player ) SetActivePilotLoadoutIndex( player, loadoutIndex ) //PROTO_DisplayPilotLoadouts( player, loadout ) return true } bool function Loadouts_TryGiveTitanLoadout( entity player ) { if ( !Loadouts_CanGiveTitanLoadout( player ) ) return false Assert( IsMultiplayer(), "Spawning as a Titan is not supported in SP currently" ) entity soul = player.GetTitanSoul() TakeAllWeapons( player ) TakeAllPassives( player ) soul.passives = arrayofsize( GetNumPassives(), false ) //Clear out passives on soul TitanLoadoutDef loadout int loadoutIndex = GetPersistentSpawnLoadoutIndex( player, "titan" ) #if DEV if ( player.IsBot() && !player.IsPlayback() ) { string botTitanSettings = GetConVarString( "bot_titan_settings" ) loadout = GetRandomTitanLoadout( botTitanSettings ) array<string> legalLoadouts = GetAllowedTitanSetFiles() if ( legalLoadouts.contains( botTitanSettings ) ) loadout.setFile = botTitanSettings //Overwrite just the setfile, mods etc will be random } else #endif loadout = GetTitanLoadoutFromPersistentData( player, loadoutIndex ) OverwriteLoadoutWithDefaultsForSetFile_ExceptSpecialAndAntiRodeo( loadout ) if ( player.IsBot() && !player.IsPlayback() ) OverrideBotTitanLoadout( loadout ) ApplyTitanLoadoutModifiers( player, loadout ) player.SetPlayerSettingsFromDataTable( { playerSetFile = loadout.setFile, playerSetFileMods = loadout.setFileMods } ) GiveTitanLoadout( player, loadout ) SetActiveTitanLoadoutIndex( player, loadoutIndex ) SetActiveTitanLoadout( player ) //PROTO_DisplayTitanLoadouts( player, player, loadout ) string settings = GetSoulPlayerSettings( soul ) var titanTint = Dev_GetPlayerSettingByKeyField_Global( settings, "titan_tint" ) if ( titanTint != null ) { expect string( titanTint ) Highlight_SetEnemyHighlight( player, titanTint ) } else { Highlight_ClearEnemyHighlight( player ) } var title = GetPlayerSettingsFieldForClassName( settings, "printname" ) if ( title != null ) { player.SetTitle( expect string( title ) ) } return true } void function OverrideBotPilotLoadout( PilotLoadoutDef loadout ) { string bot_force_pilot_primary = GetConVarString( "bot_force_pilot_primary" ) string bot_force_pilot_secondary = GetConVarString( "bot_force_pilot_secondary" ) //string bot_force_pilot_weapon3 = GetConVarString( "bot_force_pilot_weapon3" ) // TODO: Convar needs to be added in code string bot_force_pilot_ordnance = GetConVarString( "bot_force_pilot_ordnance" ) string bot_force_pilot_ability = GetConVarString( "bot_force_pilot_ability" ) // Primary if ( DevFindItemByName( eItemTypes.PILOT_PRIMARY, bot_force_pilot_primary ) ) { loadout.primary = bot_force_pilot_primary loadout.primaryAttachment = "" loadout.primaryAttachments = [] loadout.primaryMod1 = "" loadout.primaryMod2 = "" loadout.primaryMod3 = "" loadout.primaryMods = [] } // Secondary if ( DevFindItemByName( eItemTypes.PILOT_SECONDARY, bot_force_pilot_secondary ) ) { loadout.secondary = bot_force_pilot_secondary loadout.secondaryMod1 = "" loadout.secondaryMod2 = "" loadout.secondaryMod3 = "" loadout.secondaryMods = [] } // Weapon3 //if ( DevFindItemByName( eItemTypes.PILOT_SECONDARY, bot_force_pilot_weapon3 ) ) //{ // loadout.weapon3 = bot_force_pilot_weapon3 // loadout.weapon3Mod1 = "" // loadout.weapon3Mod2 = "" // loadout.weapon3Mod3 = "" // loadout.weapon3Mods = [] //} // Ordnance/Offhand if ( DevFindItemByName( eItemTypes.PILOT_ORDNANCE, bot_force_pilot_ordnance ) ) { loadout.ordnance = bot_force_pilot_ordnance loadout.ordnanceMods = [] } // Ability/Special if ( DevFindItemByName( eItemTypes.PILOT_SPECIAL, bot_force_pilot_ability ) ) { loadout.special = bot_force_pilot_ability loadout.specialMods = [] } } void function OverrideBotTitanLoadout( TitanLoadoutDef loadout ) { string bot_force_titan_primary = GetConVarString( "bot_force_titan_primary" ) string bot_force_titan_ordnance = GetConVarString( "bot_force_titan_ordnance" ) string bot_force_titan_ability = GetConVarString( "bot_force_titan_ability" ) // Primary if ( DevFindItemByName( eItemTypes.TITAN_PRIMARY, bot_force_titan_primary ) ) { loadout.primary = bot_force_titan_primary loadout.primaryMod = "" loadout.primaryMods = [] } // Ordnance/Offhand if ( DevFindItemByName( eItemTypes.TITAN_ORDNANCE, bot_force_titan_ordnance ) ) { loadout.ordnance = bot_force_titan_ordnance loadout.ordnanceMods = [] } // Ability/Special if ( DevFindItemByName( eItemTypes.TITAN_SPECIAL, bot_force_titan_ability ) ) { loadout.special = bot_force_titan_ability loadout.specialMods = [] } } TitanLoadoutDef function GetTitanSpawnLoadout( entity player ) { int loadoutIndex = GetPersistentSpawnLoadoutIndex( player, "titan" ) TitanLoadoutDef loadout = GetTitanLoadoutFromPersistentData( player, loadoutIndex ) OverwriteLoadoutWithDefaultsForSetFile_ExceptSpecialAndAntiRodeo( loadout, player ) return loadout } // TODO: make loadout crate stuff not update your requested loadout void function Loadouts_OnUsedLoadoutCrate( entity player ) { int loadoutIndex = GetPersistentSpawnLoadoutIndex( player, "pilot" ) PilotLoadoutDef loadout = GetPilotLoadoutFromPersistentData( player, loadoutIndex ) GivePilotLoadout( player, loadout ) } void function SetActivePilotLoadout( entity player ) { PilotLoadoutDef loadout = GetPilotLoadoutFromPersistentData( player, GetPersistentSpawnLoadoutIndex( player, "pilot" ) ) player.SetPersistentVar( "activePilotLoadout.name", loadout.name ) player.SetPersistentVar( "activePilotLoadout.suit", loadout.suit ) player.SetPersistentVar( "activePilotLoadout.race", loadout.race ) player.SetPersistentVar( "activePilotLoadout.execution", loadout.execution ) player.SetPersistentVar( "activePilotLoadout.primary", loadout.primary ) player.SetPersistentVar( "activePilotLoadout.primaryAttachment", loadout.primaryAttachment ) player.SetPersistentVar( "activePilotLoadout.primaryMod1", loadout.primaryMod1 ) player.SetPersistentVar( "activePilotLoadout.primaryMod2", loadout.primaryMod2 ) player.SetPersistentVar( "activePilotLoadout.primaryMod3", loadout.primaryMod3 ) player.SetPersistentVar( "activePilotLoadout.secondary", loadout.secondary ) player.SetPersistentVar( "activePilotLoadout.secondaryMod1", loadout.secondaryMod1 ) player.SetPersistentVar( "activePilotLoadout.secondaryMod2", loadout.secondaryMod2 ) player.SetPersistentVar( "activePilotLoadout.secondaryMod3", loadout.secondaryMod3 ) player.SetPersistentVar( "activePilotLoadout.weapon3", loadout.weapon3 ) player.SetPersistentVar( "activePilotLoadout.weapon3Mod1", loadout.weapon3Mod1 ) player.SetPersistentVar( "activePilotLoadout.weapon3Mod2", loadout.weapon3Mod2 ) player.SetPersistentVar( "activePilotLoadout.weapon3Mod3", loadout.weapon3Mod3 ) player.SetPersistentVar( "activePilotLoadout.ordnance", loadout.ordnance ) player.SetPersistentVar( "activePilotLoadout.passive1", loadout.passive1 ) player.SetPersistentVar( "activePilotLoadout.passive2", loadout.passive2 ) player.SetPersistentVar( "activePilotLoadout.skinIndex", loadout.skinIndex ) player.SetPersistentVar( "activePilotLoadout.camoIndex", loadout.camoIndex ) player.SetPersistentVar( "activePilotLoadout.primarySkinIndex", loadout.primarySkinIndex ) player.SetPersistentVar( "activePilotLoadout.primaryCamoIndex", loadout.primaryCamoIndex ) player.SetPersistentVar( "activePilotLoadout.secondarySkinIndex", loadout.secondarySkinIndex ) player.SetPersistentVar( "activePilotLoadout.secondaryCamoIndex", loadout.secondaryCamoIndex ) player.SetPersistentVar( "activePilotLoadout.weapon3SkinIndex", loadout.weapon3SkinIndex ) player.SetPersistentVar( "activePilotLoadout.weapon3CamoIndex", loadout.weapon3CamoIndex ) } void function SetActivePilotLoadoutIndex( entity player, int loadoutIndex ) { player.p.activePilotLoadoutIndex = loadoutIndex player.SetPlayerNetInt( "activePilotLoadoutIndex", loadoutIndex ) } void function SetActiveTitanLoadout( entity player ) { Assert( player.IsPlayer(), "Titan spawn loadout makes sense for players not NPCs") TitanLoadoutDef loadout = GetTitanSpawnLoadout( player ) player.SetPersistentVar( "activeTitanLoadout.name", loadout.name ) player.SetPersistentVar( "activeTitanLoadout.titanClass", loadout.titanClass ) player.SetPersistentVar( "activeTitanLoadout.primaryMod", loadout.primaryMod ) player.SetPersistentVar( "activeTitanLoadout.special", loadout.special ) player.SetPersistentVar( "activeTitanLoadout.antirodeo", loadout.antirodeo ) player.SetPersistentVar( "activeTitanLoadout.passive1", loadout.passive1 ) player.SetPersistentVar( "activeTitanLoadout.passive2", loadout.passive2 ) player.SetPersistentVar( "activeTitanLoadout.passive3", loadout.passive3 ) player.SetPersistentVar( "activeTitanLoadout.passive4", loadout.passive4 ) player.SetPersistentVar( "activeTitanLoadout.passive5", loadout.passive5 ) player.SetPersistentVar( "activeTitanLoadout.passive6", loadout.passive6 ) player.SetPersistentVar( "activeTitanLoadout.skinIndex", loadout.skinIndex ) player.SetPersistentVar( "activeTitanLoadout.camoIndex", loadout.camoIndex ) player.SetPersistentVar( "activeTitanLoadout.decalIndex", loadout.decalIndex ) player.SetPersistentVar( "activeTitanLoadout.primarySkinIndex", loadout.primarySkinIndex ) player.SetPersistentVar( "activeTitanLoadout.primaryCamoIndex", loadout.primaryCamoIndex ) player.SetPersistentVar( "activeTitanLoadout.titanExecution", loadout.titanExecution ) player.SetPersistentVar( "activeTitanLoadout.isPrime", loadout.isPrime ) player.SetPersistentVar( "activeTitanLoadout.primeSkinIndex", loadout.primeSkinIndex ) player.SetPersistentVar( "activeTitanLoadout.primeCamoIndex", loadout.primeCamoIndex ) player.SetPersistentVar( "activeTitanLoadout.primeDecalIndex", loadout.primeDecalIndex ) player.SetPersistentVar( "activeTitanLoadout.showArmBadge", loadout.showArmBadge ) } void function SetActiveTitanLoadoutIndex( entity player, int loadoutIndex ) { //printt( ">>>>>>>>>>>>> SetActiveTitanLoadoutIndex() with index:", loadoutIndex ) player.p.activeTitanLoadoutIndex = loadoutIndex player.SetPlayerNetInt( "activeTitanLoadoutIndex", loadoutIndex ) } void function PROTO_DisplayTitanLoadouts( entity player, entity titan, TitanLoadoutDef loadout ) { entity soul = titan.GetTitanSoul() if ( soul.e.embarkCount > 0 ) return if ( loadout.primary != "" ) PROTO_PlayLoadoutNotification( loadout.primary, player ) if ( loadout.ordnance != "" ) PROTO_PlayLoadoutNotification( loadout.ordnance, player ) if ( loadout.special != "" ) PROTO_PlayLoadoutNotification( loadout.special, player ) if ( loadout.passive1 != "" ) PROTO_PlayLoadoutNotification( loadout.passive1, player ) if ( loadout.passive2 != "" ) PROTO_PlayLoadoutNotification( loadout.passive2, player ) if ( loadout.passive3 != "" ) PROTO_PlayLoadoutNotification( loadout.passive3, player ) if ( loadout.passive4 != "" ) PROTO_PlayLoadoutNotification( loadout.passive4, player ) if ( loadout.passive5 != "" ) PROTO_PlayLoadoutNotification( loadout.passive5, player ) if ( loadout.passive6 != "" ) PROTO_PlayLoadoutNotification( loadout.passive6, player ) } void function PROTO_DisplayPilotLoadouts( entity player, PilotLoadoutDef loadout ) { if ( loadout.primary != "" ) PROTO_PlayLoadoutNotification( loadout.primary, player ) if ( loadout.secondary != "" ) PROTO_PlayLoadoutNotification( loadout.secondary, player ) if ( loadout.ordnance != "" ) PROTO_PlayLoadoutNotification( loadout.ordnance, player ) if ( loadout.special != "" ) PROTO_PlayLoadoutNotification( loadout.special, player ) if ( loadout.passive1 != "" ) PROTO_PlayLoadoutNotification( loadout.passive1, player ) if ( loadout.passive2 != "" ) PROTO_PlayLoadoutNotification( loadout.passive2, player ) } #endif //SERVER #if !UI PilotLoadoutDef function GetActivePilotLoadout( entity player ) { PilotLoadoutDef loadout loadout.name = string( player.GetPersistentVar( "activePilotLoadout.name" ) ) loadout.suit = string( player.GetPersistentVar( "activePilotLoadout.suit" ) ) loadout.race = string( player.GetPersistentVar( "activePilotLoadout.race" ) ) loadout.execution = string( player.GetPersistentVar( "activePilotLoadout.execution" ) ) loadout.primary = string( player.GetPersistentVar( "activePilotLoadout.primary" ) ) loadout.primaryAttachment = string( player.GetPersistentVar( "activePilotLoadout.primaryAttachment" ) ) loadout.primaryMod1 = string( player.GetPersistentVar( "activePilotLoadout.primaryMod1" ) ) loadout.primaryMod2 = string( player.GetPersistentVar( "activePilotLoadout.primaryMod2" ) ) loadout.primaryMod3 = string( player.GetPersistentVar( "activePilotLoadout.primaryMod3" ) ) loadout.secondary = string( player.GetPersistentVar( "activePilotLoadout.secondary" ) ) loadout.secondaryMod1 = string( player.GetPersistentVar( "activePilotLoadout.secondaryMod1" ) ) loadout.secondaryMod2 = string( player.GetPersistentVar( "activePilotLoadout.secondaryMod2" ) ) loadout.secondaryMod3 = string( player.GetPersistentVar( "activePilotLoadout.secondaryMod3" ) ) loadout.weapon3 = string( player.GetPersistentVar( "activePilotLoadout.weapon3" ) ) loadout.weapon3Mod1 = string( player.GetPersistentVar( "activePilotLoadout.weapon3Mod1" ) ) loadout.weapon3Mod2 = string( player.GetPersistentVar( "activePilotLoadout.weapon3Mod2" ) ) loadout.weapon3Mod3 = string( player.GetPersistentVar( "activePilotLoadout.weapon3Mod3" ) ) loadout.ordnance = string( player.GetPersistentVar( "activePilotLoadout.ordnance" ) ) loadout.passive1 = string( player.GetPersistentVar( "activePilotLoadout.passive1" ) ) loadout.passive2 = string( player.GetPersistentVar( "activePilotLoadout.passive2" ) ) loadout.skinIndex = player.GetPersistentVarAsInt( "activePilotLoadout.skinIndex" ) loadout.camoIndex = player.GetPersistentVarAsInt( "activePilotLoadout.camoIndex" ) loadout.primarySkinIndex = player.GetPersistentVarAsInt( "activePilotLoadout.primarySkinIndex" ) loadout.primaryCamoIndex = player.GetPersistentVarAsInt( "activePilotLoadout.primaryCamoIndex" ) loadout.secondarySkinIndex = player.GetPersistentVarAsInt( "activePilotLoadout.secondarySkinIndex" ) loadout.secondaryCamoIndex = player.GetPersistentVarAsInt( "activePilotLoadout.secondaryCamoIndex" ) loadout.weapon3SkinIndex = player.GetPersistentVarAsInt( "activePilotLoadout.weapon3SkinIndex" ) loadout.weapon3CamoIndex = player.GetPersistentVarAsInt( "activePilotLoadout.weapon3CamoIndex" ) UpdateDerivedPilotLoadoutData( loadout ) return loadout } TitanLoadoutDef function GetActiveTitanLoadout( entity player ) { TitanLoadoutDef loadout loadout.name = string( player.GetPersistentVar( "activeTitanLoadout.name" ) ) loadout.titanClass = string( player.GetPersistentVar( "activeTitanLoadout.titanClass" ) ) loadout.primaryMod = string( player.GetPersistentVar( "activeTitanLoadout.primaryMod" ) ) loadout.special = string( player.GetPersistentVar( "activeTitanLoadout.special" ) ) loadout.antirodeo = string( player.GetPersistentVar( "activeTitanLoadout.antirodeo" ) ) loadout.passive1 = string( player.GetPersistentVar( "activeTitanLoadout.passive1" ) ) loadout.passive2 = string( player.GetPersistentVar( "activeTitanLoadout.passive2" ) ) loadout.passive3 = string( player.GetPersistentVar( "activeTitanLoadout.passive3" ) ) loadout.passive4 = string( player.GetPersistentVar( "activeTitanLoadout.passive4" ) ) loadout.passive5 = string( player.GetPersistentVar( "activeTitanLoadout.passive5" ) ) loadout.passive6 = string( player.GetPersistentVar( "activeTitanLoadout.passive6" ) ) loadout.titanExecution = string( player.GetPersistentVar( "activeTitanLoadout.titanExecution" ) ) loadout.skinIndex = player.GetPersistentVarAsInt( "activeTitanLoadout.skinIndex" ) loadout.camoIndex = player.GetPersistentVarAsInt( "activeTitanLoadout.camoIndex" ) loadout.decalIndex = player.GetPersistentVarAsInt( "activeTitanLoadout.decalIndex" ) loadout.primarySkinIndex = player.GetPersistentVarAsInt( "activeTitanLoadout.primarySkinIndex" ) loadout.primaryCamoIndex = player.GetPersistentVarAsInt( "activeTitanLoadout.primaryCamoIndex" ) loadout.isPrime = string( player.GetPersistentVar( "activeTitanLoadout.isPrime" ) ) loadout.primeSkinIndex = player.GetPersistentVarAsInt( "activeTitanLoadout.primeSkinIndex" ) loadout.primeCamoIndex = player.GetPersistentVarAsInt( "activeTitanLoadout.primeCamoIndex" ) loadout.primeDecalIndex = player.GetPersistentVarAsInt( "activeTitanLoadout.primeDecalIndex" ) loadout.showArmBadge = player.GetPersistentVarAsInt( "activeTitanLoadout.showArmBadge" ) UpdateDerivedTitanLoadoutData( loadout ) OverwriteLoadoutWithDefaultsForSetFile_ExceptSpecialAndAntiRodeo( loadout, player ) //int loadoutIndex = GetActiveTitanLoadoutIndex( player ) //TitanLoadoutDef loadout = GetTitanLoadoutFromPersistentData( player, loadoutIndex ) //OverwriteLoadoutWithDefaultsForSetFile_ExceptSpecialAndAntiRodeo( loadout ) return loadout } // When possible use GetActivePilotLoadout() instead int function GetActivePilotLoadoutIndex( entity player ) { #if SERVER return player.p.activePilotLoadoutIndex #else return player.GetPlayerNetInt( "activePilotLoadoutIndex" ) #endif } int function GetActiveTitanLoadoutIndex( entity player ) { //printt( "<<<<<<<<<<<<< GetActiveTitanLoadoutIndex() with index:", player.p.activeTitanLoadoutIndex ) #if SERVER return player.p.activeTitanLoadoutIndex #else return player.GetPlayerNetInt( "activeTitanLoadoutIndex" ) #endif } #endif // Added doOverrideCallback as a temporary measure to work around an issue the callback override added here is causing // This is called in PopulateDefaultPilotLoadouts() which sets the data GetDefaultPilotLoadout() returns // GetDefaultPilotLoadout() should never be returning overridden loadouts because it is used in many places to correct or reset persistent loadout data void function UpdateDerivedPilotLoadoutData( PilotLoadoutDef loadout, bool doOverrideCallback = true ) { loadout.setFile = GetSuitAndGenderBasedSetFile( loadout.suit, loadout.race ) loadout.special = GetSuitBasedTactical( loadout.suit ) loadout.primaryAttachments = [ loadout.primaryAttachment ] loadout.primaryMods = [ loadout.primaryMod1, loadout.primaryMod2, loadout.primaryMod3 ] loadout.secondaryMods = [ loadout.secondaryMod1, loadout.secondaryMod2, loadout.secondaryMod3 ] loadout.weapon3Mods = [ loadout.weapon3Mod1, loadout.weapon3Mod2, loadout.weapon3Mod3 ] loadout.setFileMods = GetSetFileModsForSettingType( "pilot", [ loadout.passive1, loadout.passive2 ] ) #if SERVER if ( doOverrideCallback ) { foreach ( callbackFunc in svGlobal.onUpdateDerivedPilotLoadoutCallbacks ) callbackFunc( loadout ) } #endif } bool function TitanClassHasPrimeTitan( string titanClass ) { string nonPrimeSetFile = GetSetFileForTitanClassAndPrimeStatus( titanClass, false ) string primeSetFile = GetPrimeTitanSetFileFromNonPrimeSetFile( nonPrimeSetFile ) return primeSetFile != "" } bool function IsTitanLoadoutPrime( TitanLoadoutDef loadout ) { return loadout.isPrime == "titan_is_prime" } bool function IsTitanClassPrime( entity player, string titanClass ) { for ( int i = 0; i < NUM_PERSISTENT_TITAN_LOADOUTS; i++ ) { TitanLoadoutDef loadout = GetTitanLoadoutFromPersistentData( player, i ) if ( loadout.titanClass == titanClass ) { if ( loadout.isPrime == "titan_is_prime" ) return true else return false } } unreachable } void function UpdateDerivedTitanLoadoutData( TitanLoadoutDef loadout ) { bool isTitanLoadoutPrime = IsTitanLoadoutPrime( loadout ) loadout.setFile = GetSetFileForTitanClassAndPrimeStatus( loadout.titanClass, IsTitanLoadoutPrime( loadout ) ) loadout.primeTitanRef = GetPrimeTitanRefForTitanClass( loadout.titanClass ) } void function PrintPilotLoadoutIndex( entity player, int index ) { PrintPilotLoadout( GetPilotLoadoutFromPersistentData( player, index ) ) } void function PrintTitanLoadoutIndex( entity player, int index ) { PrintTitanLoadout( GetTitanLoadoutFromPersistentData( player, index ) ) } void function PrintPilotLoadouts( entity player ) { for ( int i = 0; i < NUM_PERSISTENT_PILOT_LOADOUTS; i++ ) PrintPilotLoadoutIndex( player, i ) } void function PrintTitanLoadouts( entity player ) { for ( int i = 0; i < NUM_PERSISTENT_TITAN_LOADOUTS; i++ ) PrintTitanLoadoutIndex( player, i ) } void function PrintPilotLoadout( PilotLoadoutDef loadout ) { printt( "PILOT LOADOUT:" ) printt( " PERSISTENT DATA:" ) printt( " name \"" + loadout.name + "\"" ) printt( " suit \"" + loadout.suit + "\"" ) printt( " race \"" + loadout.race + "\"" ) printt( " execution \"" + loadout.execution + "\"" ) printt( " primary \"" + loadout.primary + "\"" ) printt( " primaryAttachment \"" + loadout.primaryAttachment + "\"" ) printt( " primaryMod1 \"" + loadout.primaryMod1 + "\"" ) printt( " primaryMod2 \"" + loadout.primaryMod2 + "\"" ) printt( " primaryMod3 \"" + loadout.primaryMod3 + "\"" ) printt( " primarySkinIndex " + loadout.primarySkinIndex ) printt( " primaryCamoIndex " + loadout.primaryCamoIndex ) printt( " secondary \"" + loadout.secondary + "\"" ) printt( " secondaryMod1 \"" + loadout.secondaryMod1 + "\"" ) printt( " secondaryMod2 \"" + loadout.secondaryMod2 + "\"" ) printt( " secondaryMod3 \"" + loadout.secondaryMod3 + "\"" ) printt( " secondarySkinIndex " + loadout.secondarySkinIndex ) printt( " secondaryCamoIndex " + loadout.secondaryCamoIndex ) printt( " weapon3 \"" + loadout.weapon3 + "\"" ) printt( " weapon3Mod1 \"" + loadout.weapon3Mod1 + "\"" ) printt( " weapon3Mod2 \"" + loadout.weapon3Mod2 + "\"" ) printt( " weapon3Mod3 \"" + loadout.weapon3Mod3 + "\"" ) printt( " weapon3SkinIndex " + loadout.weapon3SkinIndex ) printt( " weapon3CamoIndex " + loadout.weapon3CamoIndex ) printt( " ordnance \"" + loadout.ordnance + "\"" ) printt( " special \"" + loadout.special + "\"" ) printt( " passive1 \"" + loadout.passive1 + "\"" ) printt( " passive2 \"" + loadout.passive2 + "\"" ) printt( " skinIndex " + loadout.skinIndex ) printt( " camoIndex " + loadout.camoIndex ) printt( " DERIVED DATA:" ) printt( " setFile \"" + loadout.setFile + "\"" ) print( " setFileMods " ) PrintStringArray( loadout.setFileMods ) printt( " melee \"" + loadout.melee + "\"" ) print( " meleeMods " ) PrintStringArray( loadout.meleeMods ) print( " primaryAttachments " ) PrintStringArray( loadout.primaryAttachments ) print( " primaryMods " ) PrintStringArray( loadout.primaryMods ) print( " secondaryMods " ) PrintStringArray( loadout.secondaryMods ) print( " weapon3Mods " ) PrintStringArray( loadout.weapon3Mods ) print( " specialMods " ) PrintStringArray( loadout.specialMods ) print( " ordnanceMods " ) PrintStringArray( loadout.ordnanceMods ) } void function PrintTitanLoadout( TitanLoadoutDef loadout ) { printt( "TITAN LOADOUT:" ) printt( " PERSISTENT DATA:" ) printt( " name \"" + loadout.name + "\"" ) printt( " titanClass \"" + loadout.titanClass + "\"" ) printt( " setFile \"" + loadout.setFile + "\"" ) printt( " primeTitanRef \"" + loadout.primeTitanRef + "\"" ) printt( " primaryMod \"" + loadout.primaryMod + "\"" ) printt( " special \"" + loadout.special + "\"" ) printt( " antirodeo \"" + loadout.antirodeo + "\"" ) printt( " passive1 \"" + loadout.passive1 + "\"" ) printt( " passive2 \"" + loadout.passive2 + "\"" ) printt( " passive3 \"" + loadout.passive3 + "\"" ) printt( " passive4 \"" + loadout.passive4 + "\"" ) printt( " passive5 \"" + loadout.passive5 + "\"" ) printt( " passive6 \"" + loadout.passive6 + "\"" ) printt( " voice \"" + loadout.voice + "\"" ) printt( " skinIndex " + loadout.skinIndex ) printt( " camoIndex " + loadout.camoIndex ) printt( " decalIndex " + loadout.decalIndex ) printt( " primarySkinIndex " + loadout.primarySkinIndex ) printt( " primaryCamoIndex " + loadout.primaryCamoIndex ) printt( " isPrime \"" + loadout.isPrime + "\"" ) printt( " primeSkinIndex " + loadout.primeSkinIndex ) printt( " primeCamoIndex " + loadout.primeCamoIndex ) printt( " primeDecalIndex " + loadout.primeDecalIndex ) printt( " DERIVED DATA:" ) print( " setFileMods " ) PrintStringArray( loadout.setFileMods ) printt( " melee \"" + loadout.melee + "\"" ) printt( " coreAbility \"" + loadout.coreAbility + "\"" ) printt( " primary \"" + loadout.primary + "\"" ) printt( " primaryAttachment \"" + loadout.primaryAttachment + "\"" ) print( " primaryMods " ) PrintStringArray( loadout.primaryMods ) printt( " ordnance \"" + loadout.ordnance + "\"" ) print( " ordnanceMods " ) PrintStringArray( loadout.ordnanceMods ) print( " specialMods " ) PrintStringArray( loadout.specialMods ) print( " antirodeoMods " ) PrintStringArray( loadout.antirodeoMods ) } void function PrintStringArray( array<string> stringArray ) { if ( stringArray.len() == 0 ) { print( "[]" ) } else { for ( int i = 0; i < stringArray.len(); i++ ) { if ( i == 0 ) print( "[ " ) print( "\"" + stringArray[i] + "\"" ) if ( i+1 < stringArray.len() ) print( ", " ) else print( " ]" ) } } print( "\n" ) } string function GetSkinPropertyName( string camoPropertyName ) { string skinPropertyName switch ( camoPropertyName ) { case "camoIndex": skinPropertyName = "skinIndex" break case "primeCamoIndex": skinPropertyName = "primeSkinIndex" break case "primaryCamoIndex": skinPropertyName = "primarySkinIndex" break case "secondaryCamoIndex": skinPropertyName = "secondarySkinIndex" break case "weapon3CamoIndex": skinPropertyName = "weapon3SkinIndex" break default: Assert( false, "Unknown camoPropertyName: " + camoPropertyName ) break } return skinPropertyName } int function GetSkinIndexForCamo( string modelType, string camoPropertyName, int camoIndex ) { Assert( modelType == "pilot" || modelType == "titan" ) Assert( camoPropertyName == "camoIndex" || camoPropertyName == "primeCamoIndex" || camoPropertyName == "primaryCamoIndex" || camoPropertyName == "secondaryCamoIndex" || camoPropertyName == "weapon3CamoIndex" ) int skinIndex = SKIN_INDEX_BASE if ( camoIndex > 0 ) { if ( camoPropertyName == "camoIndex" || camoPropertyName == "primeCamoIndex" ) { if ( modelType == "pilot" ) skinIndex = PILOT_SKIN_INDEX_CAMO else skinIndex = TITAN_SKIN_INDEX_CAMO } else if ( camoPropertyName == "primaryCamoIndex" || camoPropertyName == "secondaryCamoIndex" || camoPropertyName == "weapon3CamoIndex" ) { skinIndex = WEAPON_SKIN_INDEX_CAMO } } return skinIndex } #if SERVER void function UpdateProScreen( entity player, entity weapon ) { int proScreenKills = WeaponGetProScreenKills( player, weapon.GetWeaponClassName() ) int previousProScreenKills = WeaponGetPreviousProScreenKills( player, weapon.GetWeaponClassName() ) weapon.SetProScreenIntValForIndex( PRO_SCREEN_INT_LIFETIME_KILLS, proScreenKills ) weapon.SetProScreenIntValForIndex( PRO_SCREEN_INT_MATCH_KILLS, proScreenKills - previousProScreenKills ) } #endif bool function IsValidPilotLoadoutIndex( int loadoutIndex ) { if ( loadoutIndex < 0 ) return false if( loadoutIndex >= NUM_PERSISTENT_PILOT_LOADOUTS ) return false return true } bool function IsValidTitanLoadoutIndex( int loadoutIndex ) { if ( loadoutIndex < 0 ) return false if( loadoutIndex >= NUM_PERSISTENT_TITAN_LOADOUTS ) return false return true } bool function HasPrimeToMatchExecutionType( entity player, int itemType ) { if ( DevEverythingUnlocked() ) return true switch( itemType ) { case eItemTypes.TITAN_RONIN_EXECUTION: return !IsItemLocked( player, "ronin_prime" ) case eItemTypes.TITAN_NORTHSTAR_EXECUTION: return !IsItemLocked( player, "northstar_prime" ) case eItemTypes.TITAN_ION_EXECUTION: return !IsItemLocked( player, "ion_prime" ) case eItemTypes.TITAN_TONE_EXECUTION: return !IsItemLocked( player, "tone_prime" ) case eItemTypes.TITAN_SCORCH_EXECUTION: return !IsItemLocked( player, "scorch_prime" ) case eItemTypes.TITAN_LEGION_EXECUTION: return !IsItemLocked( player, "legion_prime" ) case eItemTypes.TITAN_VANGUARD_EXECUTION: return false default: unreachable } unreachable } bool function IsTitanLoadoutAvailable( entity player, string titanClass ) { int titanClassLockState = player.GetPersistentVarAsInt( "titanClassLockState[" + titanClass + "]" ) return (titanClassLockState == TITAN_CLASS_LOCK_STATE_AVAILABLE || titanClassLockState == TITAN_CLASS_LOCK_STATE_LEVELRECOMMENDED) } int function GetTitanLoadAvailableState( entity player, string titanClass ) { return player.GetPersistentVarAsInt( "titanClassLockState[" + titanClass + "]" ) } #if UI || CLIENT void function SwapSecondaryAndWeapon3LoadoutData( entity player, int loadoutIndex ) { // Keep CLIENT matching UI #if UI RunClientScript( "SwapSecondaryAndWeapon3LoadoutData", player, loadoutIndex ) #endif // UI string loadoutType = "pilot" PilotLoadoutDef loadout loadout.secondary = shGlobal.cachedPilotLoadouts[ loadoutIndex ].secondary loadout.secondaryMod1 = shGlobal.cachedPilotLoadouts[ loadoutIndex ].secondaryMod1 loadout.secondaryMod2 = shGlobal.cachedPilotLoadouts[ loadoutIndex ].secondaryMod2 loadout.secondaryMod3 = shGlobal.cachedPilotLoadouts[ loadoutIndex ].secondaryMod3 loadout.secondarySkinIndex = shGlobal.cachedPilotLoadouts[ loadoutIndex ].secondarySkinIndex loadout.secondaryCamoIndex = shGlobal.cachedPilotLoadouts[ loadoutIndex ].secondaryCamoIndex loadout.weapon3 = shGlobal.cachedPilotLoadouts[ loadoutIndex ].weapon3 loadout.weapon3Mod1 = shGlobal.cachedPilotLoadouts[ loadoutIndex ].weapon3Mod1 loadout.weapon3Mod2 = shGlobal.cachedPilotLoadouts[ loadoutIndex ].weapon3Mod2 loadout.weapon3Mod3 = shGlobal.cachedPilotLoadouts[ loadoutIndex ].weapon3Mod3 loadout.weapon3SkinIndex = shGlobal.cachedPilotLoadouts[ loadoutIndex ].weapon3SkinIndex loadout.weapon3CamoIndex = shGlobal.cachedPilotLoadouts[ loadoutIndex ].weapon3CamoIndex SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "secondary", loadout.weapon3 ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "secondaryMod1", loadout.weapon3Mod1 ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "secondaryMod2", loadout.weapon3Mod2 ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "secondaryMod3", loadout.weapon3Mod3 ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "secondarySkinIndex", string( loadout.weapon3SkinIndex ) ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "secondaryCamoIndex", string( loadout.weapon3CamoIndex ) ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "weapon3", loadout.secondary ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "weapon3Mod1", loadout.secondaryMod1 ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "weapon3Mod2", loadout.secondaryMod2 ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "weapon3Mod3", loadout.secondaryMod3 ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "weapon3SkinIndex", string( loadout.secondarySkinIndex ) ) SetPilotLoadoutValue( shGlobal.cachedPilotLoadouts[ loadoutIndex ], "weapon3CamoIndex", string( loadout.secondaryCamoIndex ) ) #if UI ClientCommand( "SwapSecondaryAndWeapon3PersistentLoadoutData " + loadoutIndex ) #endif // UI } #endif // UI || CLIENT