diff options
Diffstat (limited to 'Northstar.CustomServers/mod')
| -rw-r--r-- | Northstar.CustomServers/mod/scripts/vscripts/sh_utility_all.gnut | 1585 |
1 files changed, 1585 insertions, 0 deletions
diff --git a/Northstar.CustomServers/mod/scripts/vscripts/sh_utility_all.gnut b/Northstar.CustomServers/mod/scripts/vscripts/sh_utility_all.gnut new file mode 100644 index 00000000..9eb673a1 --- /dev/null +++ b/Northstar.CustomServers/mod/scripts/vscripts/sh_utility_all.gnut @@ -0,0 +1,1585 @@ +untyped + +globalize_all_functions + +global const DEG_TO_RAD = 0.01745329251994 // PI / 180.0 +global const RAD_TO_DEG = 57.29577951308232 // 180.0 / PI + +global array<string> LEGAL_PLAYER_TITAN_SETTINGS + +global struct AllModesAndMapsCompleteData +{ + int required + int progress +} + +struct +{ + int lastHostThreadMode + int lastScriptPrecacheErrors + int lastReportFatal + bool devUnlockedSPMissions +} file + +void function ShUtilityAll_Init() +{ + #document( "DistanceAlongVector", "" ) + #document( "GetClosestPointOnLineSegment", "Get the nearest point on a line segment" ) + #document( "GetDistanceFromLineSegment", "" ) + #document( "GetDistanceSqrFromLineSegment", "" ) + + LEGAL_PLAYER_TITAN_SETTINGS = GetAllowedPlayerTitanSettings() //Function reads from the data table, no point doing it over and over when it shouldn't change mid-match/game +} + +bool function IsMultiplayer() +{ + #if UI + return GetConVarString( "mp_gamemode" ) != "solo" + #else + return GAMETYPE != GAMEMODE_SP + #endif +} + +bool function IsSingleplayer() +{ + #if UI + return GetConVarString( "mp_gamemode" ) == "solo" + #else + return GAMETYPE == GAMEMODE_SP + #endif +} + +function PrintObject( obj, indent, depth, maxDepth ) +{ + if ( IsTable( obj ) ) + { + if ( depth >= maxDepth ) + { + printl( "{...}" ) + return + } + + printl( "{" ) + foreach ( k, v in obj ) + { + print( TableIndent( indent + 2 ) + k + " = " ) + PrintObject( v, indent + 2, depth + 1, maxDepth ) + } + printl( TableIndent( indent ) + "}" ) + } + else if ( IsArray( obj ) ) + { + if ( depth >= maxDepth ) + { + printl( "[...]" ) + return + } + + printl( "[" ) + foreach ( v in obj ) + { + print( TableIndent( indent + 2 ) ) + PrintObject( v, indent + 2, depth + 1, maxDepth ) + } + printl( TableIndent( indent ) + "]" ) + } + else if ( obj != null ) + { + printl( "" + obj ) + } + else + { + printl( "<null>" ) + } +} + +string function FunctionToString( func ) +{ + Assert( func, "No function passed" ) + Assert( type( func ) == "function", "Type " + type( func ) + " is not a function" ) + + return expect string( func.getinfos().name ) +} + +// dump the stack trace to the console +function DumpStack( int offset = 1 ) +{ + for ( int i = offset; i < 20; i++ ) + { + if ( !( "src" in getstackinfos(i) ) ) + break + printl( i + " File : " + getstackinfos(i)["src"] + " [" + getstackinfos(i)["line"] + "]\n Function : " + getstackinfos(i)["func"] + "() " ) + } +} + +function DumpPreviousFunction() +{ + int i = 3 + if ( !( "src" in getstackinfos(i) ) ) + return + printl( "Called from: " + getstackinfos(i)["src"] + " [" + getstackinfos(i)["line"] + "] : " + getstackinfos(i)["func"] + "() " ) +} + +function GetPreviousFunction() +{ + int i = 3 + if ( !( "src" in getstackinfos(i) ) ) + return "" + return "Called from: " + getstackinfos(i)["src"] + " [" + getstackinfos(i)["line"] + "] : " + getstackinfos(i)["func"] + "() " +} + +bool function IsNewThread() +{ + //return threads.GetCurrentThread().co == getthread() + int i + for ( i = 0; i < 20; i++ ) + { + if ( !( "src" in getstackinfos(i) ) ) + break + } + + return i == 3 +} + +function AssertParameters( func, paramCount, paramDesc ) +{ + local funcInfos = func.getinfos() + local funcName = funcInfos.name + // subtract one from the param count for the hidden "this" object + Assert( funcInfos.parameters.len() == (paramCount + 1), "Function \"" + funcName +"\" must have exactly " + paramCount + " parameters (" + paramDesc + ")." ) +} + +function PrintTable( tbl, indent = 0, maxDepth = 4 ) +{ + print( TableIndent( indent ) ) + PrintObject( tbl, indent, 0, maxDepth ) +} + +string function TableIndent( indent ) +{ + return (" ").slice( 0, indent ) +} + +function GetHattID( id ) +{ + local result = getconsttable()[ id ] + //printt( "This is hattID: " + result ) + return getconsttable()[ id ] +} + +function GetCurrentPlaylistVar( val, opVal = null ) +{ + #if UI + return Code_GetCurrentPlaylistVar( val ) + #else + if ( opVal == null ) + return Code_GetCurrentPlaylistVar( val ) + + return GetCurrentPlaylistVarOrUseValue( val, opVal ) + #endif +} + +function GetCurrentPlaylistVarOrUseValue( val, opVal ) +{ + if ( typeof opVal != "string" ) + opVal = string( opVal ) + + #if !SERVER + if ( !IsConnected() ) + return opVal + #endif + + return Code_GetCurrentPlaylistVarOrUseValue( val, opVal ) // HACK +} + +int function GetCurrentPlaylistVarInt( string val, int useVal ) +{ + local result = GetCurrentPlaylistVarOrUseValue( val, useVal ) + if ( result == null ) + return 0 + + return int( result ) +} + +// Return a random entry from a table +function RandomTable( Table ) +{ + Assert( type( Table ) == "table", "Not a table" ) + if ( Table.len() == 0 ) + return null + + int index = RandomInt( Table.len() ) + int i = 0 + foreach ( entry in Table ) + { + if ( i != index ) + { + i++ + continue + } + return entry + } +} + +bool function IsMultiplayerPlaylist() +{ + return GetCurrentPlaylistVarInt( "classic_mp", 0 ) ? true : false +} + +function SortLowest( a, b ) +{ + if ( a > b ) + return 1 + + if ( a < b ) + return -1 + + return 0 +} + +function SortHighest( a, b ) +{ + if ( a < b ) + return 1 + + if ( a > b ) + return -1 + + return 0 +} + +float function DegToRad( float degrees ) +{ + return degrees * DEG_TO_RAD +} + +float function RadToDeg( float radians ) +{ + return radians * RAD_TO_DEG +} + +vector function RotateAroundOrigin2D( vector originToRotate, vector origin, float angRadians ) +{ + vector rotated = Vector( 0.0, 0.0, originToRotate.z ) + float sinOffsetAng = sin( angRadians ) + float cosOffsetAng = cos( angRadians ) + vector offset = originToRotate - origin + + rotated.x = origin.x + ( offset.x * cosOffsetAng ) - ( offset.y * sinOffsetAng ) + rotated.y = origin.y + ( offset.x * sinOffsetAng ) + ( offset.y * cosOffsetAng ) + + return rotated +} + +bool function IsLobbyMapName( string levelname ) +{ + if ( levelname == "mp_lobby" ) + return true + + return false +} + +bool function IsLobby() +{ + string mapName + + #if UI + mapName = GetActiveLevel() + #else + mapName = GetMapName() + #endif + + return IsLobbyMapName( mapName ) +} + +bool function IsFFAGame() +{ + return ( MAX_TEAMS > 2 ) +} + +int function GetEnemyTeam( int team ) +{ + if ( IsFFAGame() ) + return TEAM_UNASSIGNED + + Assert( team == TEAM_IMC || team == TEAM_MILITIA ) + + return (TEAM_IMC + TEAM_MILITIA) - team +} + +string function GetTeamName( int team ) +{ + #if UI + Assert( team == TEAM_IMC || team == TEAM_MILITIA ) + #endif + + if ( team == TEAM_IMC ) + return "#FACTION_APEX" + + if ( team == TEAM_MILITIA ) + return "#FACTION_64" + + return "" +} + +string function GetTeamShortName( int team ) +{ + if ( team == TEAM_IMC ) + return "APEX" + + if ( team == TEAM_MILITIA ) + return "6-4" + + return "" +} + +string function GetMapDisplayNameAllCaps( string mapname ) +{ + return "#" + mapname + "_ALLCAPS" +} + +string function GetMapDisplayName( string mapname ) +{ + return "#" + mapname +} + +string function GetMapDisplayDesc( string mapname ) +{ + return "#" + mapname + "_CLASSIC_DESC" +} + +string function StringReplace( string baseString, string searchString, string replaceString ) +{ + var findResult = baseString.find( searchString ) + + if ( findResult != null ) + { + string part1 = baseString.slice( 0, findResult ) + string part2 = baseString.slice( findResult + searchString.len(), baseString.len() ) + + baseString = part1 + replaceString + part2 + } + + return baseString +} + +// Returns float +function RoundToNearestInt( value ) +{ + return floor( value + 0.5 ) +} + +float function RoundToNearestMultiplier( float value, float multiplier ) +{ + float remainder = value % multiplier + + value -= remainder + + if ( remainder >= ( multiplier / 2 ) ) + value += multiplier + + return value +} + +function DevEverythingUnlocked() +{ + return EverythingUnlockedConVarEnabled() +} + + +table<string, string> function GetByTitanTypes() +{ + return { + byTitan_ion = "ion" + byTitan_scorch = "scorch" + byTitan_northstar = "northstar" + byTitan_ronin = "ronin" + byTitan_tone = "tone" + byTitan_legion = "legion" + byTitan_vanguard = "vanguard" + } +} + +table<string, string> function GetAsTitanTypes() +{ + return { + asTitan_ion = "ion" + asTitan_scorch = "scorch" + asTitan_northstar = "northstar" + asTitan_ronin = "ronin" + asTitan_tone = "tone" + asTitan_legion = "legion" + asTitan_vanguard = "vanguard" + } +} + +table<string, string> function GetAsNPCTitanTypes() +{ + return { + byNPCTitans_ion = "ion" + byNPCTitans_scorch = "scorch" + byNPCTitans_northstar = "northstar" + byNPCTitans_ronin = "ronin" + byNPCTitans_tone = "tone" + byNPCTitans_legion = "legion" + byNPCTitans_vanguard = "vanguard" + } +} + +table<string, string> function GetPluralTitanTypes() +{ + return { + titans_ion = "ion" + titans_scorch = "scorch" + titans_northstar = "northstar" + titans_ronin = "ronin" + titans_tone = "tone" + titans_legion = "legion" + titans_vanguard = "vanguard" + } +} + +table<string, string> function GetCapitalizedTitanTypes() +{ + return { + Ion = "ion" + Scorch = "scorch" + Northstar = "northstar" + Ronin = "ronin" + Tone = "tone" + Legion = "legion" + Vanguard = "vanguard" + } +} + +bool function ValidateTitanType( titanSubClass ) +{ + switch ( titanSubClass ) + { + case "ion": + case "scorch": + case "northstar": + case "ronin": + case "tone": + case "legion": + case "vanguard": + return true + } + + return false +} + +function GetWeaponInfoFileKeyField_GlobalNotNull( ref, variable ) +{ + local val = GetWeaponInfoFileKeyField_Global( ref, variable ) + Assert( val != null, "Tried to get ref " + ref + " var " + variable + " but it was null" ) + return val +} + +bool function IsWeaponKeyFieldDefined( string ref, string variable ) +{ + var val = GetWeaponInfoFileKeyField_Global( ref, variable ) + + if ( val != null ) + return true + + return false +} + +string function GetWeaponInfoFileKeyField_GlobalString( string ref, string variable ) +{ + var val = GetWeaponInfoFileKeyField_Global( ref, variable ) + Assert( val != null, "Weapon key \"" + variable + "\" does not exist in weapon \"" + ref + "\" !" ) + return expect string( val ) +} + +int function GetWeaponInfoFileKeyField_GlobalInt( string ref, string variable ) +{ + var val = GetWeaponInfoFileKeyField_Global( ref, variable ) + Assert( val != null, "Weapon key \"" + variable + "\" does not exist in weapon \"" + ref + "\" !" ) + return expect int( val ) +} + +float function GetWeaponInfoFileKeyField_GlobalFloat( string ref, string variable ) +{ + var val = GetWeaponInfoFileKeyField_Global( ref, variable ) + Assert( val != null, "Weapon key \"" + variable + "\" does not exist in weapon \"" + ref + "\" !" ) + return expect float( val ) +} + +function PrintTimeParts( Table ) +{ + printt( " ", Table["month"] + "/" + Table["day"] + "/" + Table["year"], "-", Table["hour"] + ":" + Table["minute"] + ":" + Table["second"] ) +} + +function WaitFrame() +{ + //Don't use wait 0 since it doesn't actually wait a game frame. For example, if you have a client loop that does wait 0 even if the game is paused the loop will still run + wait 0.0001 +} + +function TableRemoveInvalidKeys( table Table ) +{ + array deleteKey = [] + + foreach ( key, value in Table ) + { + if ( !IsValid( key ) ) + deleteKey.append( key ) + } + + foreach ( key in deleteKey ) + { + // in this search, two things could end up on the same key + if ( key in Table ) + delete Table[ key ] + } +} + +string function VectorToString( vector vec ) +{ + return "Vector( " + vec.x + ", " + vec.y + ", " + vec.z + " )" +} + +bool function PROTO_RTS_HealthDisplay() +{ + return SharedPlaylistVarInt( "rts_style_health_bars", 0 ) > 0 +} + +int function SharedPlaylistVarInt( string name, int defaultVal ) +{ + #if UI + if ( !IsConnected() ) + return defaultVal + #endif + + return GetCurrentPlaylistVarInt( name, defaultVal ) +} + +function DeepClone( data ) +{ + if ( type( data ) == "table" ) + { + table newTable = {} + foreach( key, value in data ) + { + newTable[ key ] <- DeepClone( value ) + } + return newTable + } + else if ( type( data ) == "array" ) + { + array newArray = [] + for ( int i = 0; i < data.len(); i++ ) + { + newArray.append( DeepClone( data[ i ] ) ) + } + return newArray + } + else + { + return data + } +} + +vector function GetClosestPointOnPlane( vector a, vector b, vector c, vector p, bool clampInside = false ) +{ + vector n = CrossProduct( b - a, c - a ) + float eqTop = DotProduct( p - a, n ) + float eqBot = DotProduct( n, n ) + + //can't devide by 0 -> this is a degenerate triangle + if ( fabs( eqBot ) < 0.001 ) + return GetClosestPointOnLineSegment( a, b, p ) + + float magnitude = eqTop / eqBot + + vector endPoint = p - ( n * magnitude ) + + if ( clampInside ) + { + float testAB = DotProduct( CrossProduct( b - a, n ), p - a ) + float testBC = DotProduct( CrossProduct( c - b, n ), p - b ) + float testCA = DotProduct( CrossProduct( a - c, n ), p - c ) + + //if the results are negative - we're outside the triangle + if ( testAB * testBC < 0 || testBC * testCA < 0 ) + { + vector lineAB = GetClosestPointOnLineSegment( a, b, p ) + vector lineBC = GetClosestPointOnLineSegment( b, c, p ) + vector lineCA = GetClosestPointOnLineSegment( c, a, p ) + + vector closestVector = lineAB + float closestDist = DistanceSqr( p, lineAB ) + float dist = DistanceSqr( p, lineBC ) + if ( dist < closestDist ) + { + closestDist = dist + closestVector = lineBC + } + dist = DistanceSqr( p, lineCA ) + if ( dist < closestDist ) + { + closestDist = dist + closestVector = lineCA + } + return closestVector + } + //if we got this far - there are no outliers + } + + return endPoint +} + +float function DistanceAlongVector( vector origin, vector lineStart, vector lineForward ) +{ + vector originDif = origin - lineStart + return DotProduct( originDif, lineForward ) +} + +// NearestPointOnLine +vector function GetClosestPointOnLineSegment( vector a, vector b, vector p ) +{ + float distanceSqr = LengthSqr( a - b ) + + if ( distanceSqr == 0.0 ) + return a + + float t = DotProduct( p - a, b - a ) / distanceSqr + if ( t < 0.0 ) + return a + else if ( t > 1.0 ) + return b + + return a + t * (b - a) +} + +float function GetDistanceFromLineSegment( vector a, vector b, vector p ) +{ + vector closestPoint = GetClosestPointOnLineSegment( a, b, p ) + return Distance( p, closestPoint ) +} + +float function GetDistanceSqrFromLineSegment( vector a, vector b, vector p ) +{ + vector closestPoint = GetClosestPointOnLineSegment( a, b, p ) + return DistanceSqr( p, closestPoint ) +} + +float function GetProgressAlongLineSegment( vector P, vector A, vector B ) +{ + vector AP = P - A + vector AB = B - A + + float ab2 = DotProduct( AB, AB ) // AB.x*AB.x + AB.y*AB.y + float ap_ab = DotProduct( AP, AB ) // AP.x*AB.x + AP.y*AB.y + float t = ap_ab / ab2 + return t +} + +array<string> function UntypedArrayToStringArray( array arr ) +{ + // work around for old arrays in code functions + array<string> newArray + + for ( int i = 0; i < arr.len(); i++ ) + { + newArray.append( expect string( arr[i] ) ) + } + + return newArray +} + +string function PadString( string str, int len ) +{ + for ( int i = str.len(); i < len; i++ ) + str += " " + + return str +} + +bool function IsSpawner( entity ent ) +{ + return ( IsValid( ent ) && ent.GetClassName() == "spawner" ) +} + + + + +string function Dev_GetEnumString( table enumTable, int enumValue ) +{ + foreach ( string k, int v in enumTable ) + { + if ( v == enumValue ) + return k + } + + unreachable +} + +string function GetAllowedTitanAISettingsSearchString() +{ + if ( IsSingleplayer() ) + return "titanLoadoutInSP" + + return "mp_npcUseAllowed" +} + +string function GetAISettingsStringForMode() +{ + if ( IsSingleplayer() ) + return "sp_aiSettingsFile" + return "aiSettingsFile" +} + +array<string> function GetAllowedPlayerTitanSettings() //Based off AllowedTItanAISettings, which is based off the titan_properties table +{ + string searchString + + if ( IsSingleplayer() ) + searchString = "titanLoadoutInSP" + else + searchString = "mp_npcUseAllowed" + + array<string> list = [] + var dataTable = GetDataTable( $"datatable/titan_properties.rpak" ) + int numRows = GetDatatableRowCount( dataTable ) + + for ( int r=0; r<numRows; r++ ) + { + bool allowed = GetDataTableBool( dataTable, r, GetDataTableColumnByName( dataTable, searchString ) ) + if ( allowed ) + { + string titanRef = GetDataTableString( dataTable, r, GetDataTableColumnByName( dataTable, "titanRef" ) ) + + #if MP + if ( IsDisabledRef( titanRef ) ) + continue + #endif + + list.append( GetDataTableString( dataTable, r, GetDataTableColumnByName( dataTable, "setFile" ) ) ) + } + } + + return list +} + +array<string> function GetAllowedTitanAISettings( string settings = "" ) +{ + if ( settings == "" ) + { + settings = GetAISettingsStringForMode() + } + + string searchString = GetAllowedTitanAISettingsSearchString() + array<string> list = [] + var dataTable = GetDataTable( $"datatable/titan_properties.rpak" ) + int numRows = GetDatatableRowCount( dataTable ) + + for ( int r=0; r<numRows; r++ ) + { + bool allowed = GetDataTableBool( dataTable, r, GetDataTableColumnByName( dataTable, searchString ) ) + if ( allowed ) + { + list.append( GetDataTableString( dataTable, r, GetDataTableColumnByName( dataTable, "setFile" ) ) ) + } + } + + for ( int i=0; i<list.len(); i++ ) + { + string aiSettings = expect string( Dev_GetPlayerSettingByKeyField_Global( list[i], settings ) ) + list[i] = aiSettings + } + + return list +} + +array<string> function GetAllNPCSettings() +{ + // should be replaced with a getter that gets the content of classes.txt + array<string> aiSettings + + // these npcs appear in the dev menu. Dev menu presence should be changed to a key in the settings file + aiSettings.append( "npc_drone" ) + aiSettings.append( "npc_drone_beam" ) + aiSettings.append( "npc_drone_plasma" ) + aiSettings.append( "npc_drone_worker" ) + aiSettings.append( "npc_dropship" ) + aiSettings.append( "npc_frag_drone" ) + aiSettings.append( "npc_frag_drone_throwable" ) + aiSettings.append( "npc_marvin" ) + aiSettings.append( "npc_prowler" ) + aiSettings.append( "npc_soldier" ) + aiSettings.append( "npc_soldier_hero_bear" ) + aiSettings.append( "npc_soldier_hero_sarah" ) + aiSettings.append( "npc_soldier_shield_captain" ) + aiSettings.append( "npc_soldier_sidearm" ) + aiSettings.append( "npc_soldier_specialist" ) + aiSettings.append( "npc_soldier_specialist_militia" ) + aiSettings.append( "npc_spectre" ) + aiSettings.append( "npc_stalker" ) + aiSettings.append( "npc_stalker_zombie" ) + aiSettings.append( "npc_stalker_zombie_mossy" ) + aiSettings.append( "npc_super_spectre" ) + aiSettings.append( "npc_titan_sarah" ) + aiSettings.append( "npc_titan_vanguard" ) + + // insert titans here! + aiSettings.extend( GetAllowedTitanAISettings() ) + + aiSettings.extend( [ + "npc_turret_mega" + "npc_turret_sentry" + "npc_turret_sentry_plasma" + "npc_turret_sentry_tday" + ] ) + + return aiSettings +} + +array<string> function GetAllDeprecatedNPCSettings() +{ + // this is all the npc settings, then the legal settings are subtracted from it. + // also commented out settings that we don't want to have appear in the dev menu + table<string,bool> allNpcSettings = + { + //base_vehicle = true + //npc_bullseye = true + npc_drone = true + npc_drone_beam = true + npc_drone_cloaked = true + npc_drone_plasma = true + npc_drone_rocket = true + npc_drone_shield = true + npc_drone_worker = true + //npc_drone_plasma_fast = true + //npc_drone_rocket_fast = true + //npc_drone_worker_fast = true + npc_dropship = true + npc_dropship_dogfighter = true + npc_dropship_hero = true + npc_frag_drone = true + npc_frag_drone_throwable = true + npc_gunship = true + npc_gunship_scripted = true + npc_marvin = true + //npc_pilot_elite = true + npc_pilot_elite_assassin = true + npc_pilot_elite_assassin_cqb = true + npc_pilot_elite_assassin_sniper = true + //npc_pilot_elite_s2s = true + npc_prowler = true + npc_soldier = true + npc_soldier_bish = true + npc_soldier_blisk = true + npc_soldier_drone_summoner = true + npc_soldier_hero_bear = true + npc_soldier_hero_sarah = true + npc_soldier_shield_captain = true + npc_soldier_sidearm = true + npc_soldier_specialist = true + npc_soldier_specialist_militia = true + npc_soldier_spyglass = true + npc_soldier_training_sentry = true + npc_soldier_pve_sandbox = true + npc_soldier_pve_specialist = true + npc_soldier_pve_eliteguard = true + npc_spectre = true + npc_stalker = true + //npc_stalker_crawling = true + npc_stalker_zombie = true + npc_stalker_zombie_mossy = true + npc_super_spectre = true + npc_super_spectre_burnmeter = true + npc_super_spectre_calmer = true + npc_titan = true + npc_titan_arc = true + npc_titan_atlas = true + npc_titan_atlas_stickybomb = true + npc_titan_atlas_tracker = true + npc_titan_atlas_vanguard = true + npc_titan_auto = true + npc_titan_auto_atlas = true + npc_titan_auto_atlas_rocketeer = true + npc_titan_auto_atlas_stickybomb = true + npc_titan_auto_atlas_tracker = true + npc_titan_auto_atlas_vanguard = true + npc_titan_auto_ogre = true + npc_titan_auto_ogre_fighter = true + npc_titan_auto_ogre_meteor = true + npc_titan_auto_ogre_minigun = true + npc_titan_auto_stryder = true + npc_titan_auto_stryder_arc = true + npc_titan_auto_stryder_leadwall = true + npc_titan_auto_stryder_sniper = true + npc_titan_buddy = true + npc_titan_buddy_s2s = true + npc_titan_mortar = true + npc_titan_nuke = true + npc_titan_ogre = true + npc_titan_ogre_fighter = true + npc_titan_ogre_fighter_berserker_core = true + npc_titan_ogre_meteor = true + npc_titan_ogre_minigun = true + npc_titan_proto_stasisgun = true + npc_titan_sarah = true + npc_titan_vanguard = true + npc_titan_sniper = true + npc_titan_stryder = true + npc_titan_stryder_arc = true + npc_titan_stryder_leadwall = true + npc_titan_stryder_leadwall_shift_core = true + npc_titan_stryder_rocketeer = true + npc_titan_stryder_rocketeer_dash_core = true + npc_titan_stryder_sniper = true + npc_turret_mega = true + npc_turret_mega_nowindup = true + //npc_turret_mega_old = true + npc_turret_mega_windup = true + npc_turret_mega_attrition = true + npc_turret_mega_fortwar = true + npc_turret_sentry = true + npc_turret_sentry_plasma = true + npc_turret_sentry_burn_card_at = true + npc_turret_sentry_burn_card_ap = true + npc_turret_sentry_tactical_ability = true + npc_turret_sentry_tday = true + npc_turret_sentry_windup = true + npc_titan_atlas_stickybomb_bounty = true + npc_titan_atlas_tracker_bounty = true + npc_titan_atlas_vanguard_bounty = true + npc_titan_stryder_leadwall_bounty = true + npc_titan_stryder_sniper_bounty = true + npc_titan_ogre_meteor_bounty = true + npc_titan_ogre_minigun_bounty = true + } + + foreach ( aiSettings in GetAllNPCSettings() ) + { + delete allNpcSettings[ aiSettings ] + } + + array<string> settings + foreach ( aiSettings, _ in allNpcSettings ) + { + settings.append( aiSettings ) + } + settings.sort( SortStringAlphabetize ) + + return settings +} + +/////// +// These are Brent's utility functions that match RUI functions of the same name; use these to accurately compute RUI values from script +float function EaseIn( float val ) +{ + return AttackDecay( 0, 2, val ) +} + +float function EaseOut( float val ) +{ + return AttackDecay( 2, 0, val ) +} + +float function AttackDecay( float attack, float decay, float time ) +{ + float sum = attack + decay + float a = sum - 2.0 + float b = (3.0 - attack) - sum + float c = attack + float t = max( min( time, 1.0 ), 0.0 ) + + return t * (c + t * (b + t * a)) +} + +float function Clamp( float value, float minValue, float maxValue ) +{ + return max( min( value, maxValue ), minValue ) +} +/////// + +string function GetCurrentPlaylistVarString( string varName, string defaultValue ) +{ + var value = GetCurrentPlaylistVar( varName ) + if ( value != null ) + return expect string( value ) + + return defaultValue +} + +bool function IsPlayerFemale( entity player ) +{ + return player.Dev_GetPlayerSettingByKeyField( "raceOrSex" ) == "race_human_female" +} + +bool function IsPlayerPrimeTitan( entity player ) +{ + if ( !player.IsTitan() ) + return false + + return player.Dev_GetPlayerSettingByKeyField( "isPrime" ) == 1 +} + +int function GetCollectibleLevelIndex( string mapName ) +{ + foreach( int i, table data in LEVEL_UNLOCKS_COUNT ) + { + if ( data.level == mapName ) + return i + } + return -1 +} + +int function GetFoundLionsInLevel( string mapName ) +{ + int saveIndex = GetCollectibleLevelIndex( mapName ) + Assert( saveIndex >= 0 ) + + return 0 +} + +int function GetMaxLionsInLevel( string mapName ) +{ + int saveIndex = GetCollectibleLevelIndex( mapName ) + Assert( saveIndex >= 0 ) + return expect int( LEVEL_UNLOCKS_COUNT[ saveIndex ].count ) +} + +int function GetCombinedLionsInLevel( string mapName ) +{ + int saveIndex = GetCollectibleLevelIndex( mapName ) + Assert( saveIndex >= 0 ) + + array<string> bsps = GetBSPsForLevel( mapName ) + int count = 0 + foreach( string bsp in bsps ) + count += GetMaxLionsInLevel( bsp ) + + return count +} + +int function GetTotalLionsCollected() +{ + array<string> bsps = GetAllR2SPBSPs() + int total + + foreach ( mapName in bsps ) + { + total += GetCollectiblesFoundForLevel( mapName ) + } + + return total +} + +int function GetTotalLionsInGame() +{ + array<string> bsps = GetAllR2SPBSPs() + int total + + foreach ( mapName in bsps ) + { + total += GetMaxLionsInLevel( mapName ) + } + + return total +} + + + +int function GetCollectiblesFoundForLevel( string mapName ) +{ + int saveIndex = GetCollectibleLevelIndex( mapName ) + if ( saveIndex < 0 ) + return 0 + + int numCollectiblesFound = 0 + int numCollectiblesInLevel = GetMaxLionsInLevel( mapName ) + string unlockVar = "sp_unlocks_level_" + saveIndex + int bitMask = GetConVarInt( unlockVar ) + + for ( int i = 0 ; i < numCollectiblesInLevel ; i++ ) + { + int _id = 1 << i + if ( bitMask & _id ) + numCollectiblesFound++ + } + return numCollectiblesFound +} + +int function GetCombinedCollectiblesFoundForLevel( string mapName ) +{ +#if UI || CLIENT + if ( Script_IsRunningTrialVersion() ) + return 0 +#endif + + array<string> bsps = GetBSPsForLevel( mapName ) + int count = 0 + foreach( string bsp in bsps ) + count += GetCollectiblesFoundForLevel( bsp ) + + return count +} + +void function ResetCollectiblesProgress_All() +{ + #if DEV + printt( "RESETTING COLLECTIBLE PROGRESS (ALL)" ) + #endif + + for ( int i = 0 ; i < 15 ; i++ ) + { + #if DEV + printt( " sp_unlocks_level_" + i, 0 ) + #endif + + SetConVarInt( "sp_unlocks_level_" + i, 0 ) + } +} + +void function RemoveDupesFromSorted_String( array<string> data ) +{ + for ( int i = 0; i < data.len() - 1; i++ ) + { + if ( data[i] == data[i+1] ) + { + data.remove( i ) + i-- + } + } +} + + +function SortAlphabetize( a, b ) +{ + if ( a > b ) + return 1 + + if ( a < b ) + return -1 + + return 0 +} + +int function SortStringAlphabetize( string a, string b ) +{ + if ( a > b ) + return 1 + + if ( a < b ) + return -1 + + return 0 +} + +int function SortAssetAlphabetize( asset a, asset b ) +{ + if ( a > b ) + return 1 + + if ( a < b ) + return -1 + + return 0 +} + + +void function RemoveDupesFromSorted_Asset( array<asset> data ) +{ + for ( int i = 0; i < data.len() - 1; i++ ) + { + if ( data[i] == data[i+1] ) + { + data.remove( i ) + i-- + } + } +} + + +array<string> function GetBSPsForLevel( string mapName ) +{ + array<string> bsps + switch( mapName ) + { + // Levels aren't split, just return the bsp name of the level + case "sp_training": + case "sp_crashsite": + case "sp_sewers1": + case "sp_tday": + case "sp_s2s": + case "sp_skyway_v1": + case "sp_chadbox": + bsps.append( mapName ) + break + + // Have to return all bsps that are part of the level + case "sp_boomtown_start": + case "sp_boomtown": + case "sp_boomtown_end": + bsps.append( "sp_boomtown_start" ) + bsps.append( "sp_boomtown" ) + bsps.append( "sp_boomtown_end" ) + break + + case "sp_hub_timeshift": + case "sp_timeshift_spoke02": + bsps.append( "sp_hub_timeshift" ) + bsps.append( "sp_timeshift_spoke02" ) + break + + case "sp_beacon": + case "sp_beacon_spoke0": + bsps.append( "sp_beacon" ) + bsps.append( "sp_beacon_spoke0" ) + break + + default: + Assert( 0, "Unhandled collectible level " + mapName + " in GetBSPsForLevel" ) + break + } + + return bsps +} + +array<string> function GetAllR2SPBSPs() +{ + return [ + "sp_training" + "sp_crashsite" + "sp_sewers1" + "sp_tday" + "sp_s2s" + "sp_skyway_v1" + "sp_boomtown_start" + "sp_boomtown" + "sp_boomtown_end" + "sp_hub_timeshift" + "sp_timeshift_spoke02" + "sp_beacon" + "sp_beacon_spoke0" ] +} + +//sp_unlocks_level + +asset function GetWeaponModel( string weaponName ) +{ + asset modelName = GetWeaponInfoFileKeyFieldAsset_Global( weaponName, "playermodel" ) + + return modelName +} + +asset function GetWeaponViewmodel( string weaponName ) +{ + asset modelName = GetWeaponInfoFileKeyFieldAsset_Global( weaponName, "viewmodel" ) + + // TODO: In the future all weapon models should be made in a way that doesn't require this kind of HACK. + switch ( modelName ) + { + case $"models/weapons/shoulder_rocket_SRAM/ptpov_law.mdl": + modelName = $"models/weapons/shoulder_rocket_SRAM/ptpov_law_menu.mdl" + break + + case $"models/weapons/lstar/ptpov_lstar.mdl": + modelName = $"models/weapons/lstar/ptpov_lstar_menu.mdl" + break + + case $"models/weapons/softball_at/ptpov_softball_at.mdl": + modelName = $"models/weapons/softball_at/ptpov_softball_at_menu.mdl" + break + + case $"models/weapons/mastiff_stgn/ptpov_mastiff.mdl": + modelName = $"models/weapons/mastiff_stgn/ptpov_mastiff_menu.mdl" + break + } + + return modelName +} + +string function GetTitanClassFromSetFile( string setFile ) //JFS: As of right now titanClass is really just the same thing as "titanCharacterName". Should change this for next game if needed. +{ + var result = Dev_GetPlayerSettingByKeyField_Global( setFile, "titanCharacterName" ) + expect string( result ) + return result +} + + +string function GetTitanCharacterNameFromSetFile( string setFile ) +{ + var result = Dev_GetPlayerSettingByKeyField_Global( setFile, "titanCharacterName" ) + if ( result == null ) + { + CodeWarning( "Warning, no field titanCharacterName found for set file: " + setFile + ", returning default of ion" ) + return "ion" + } + + expect string( result ) + return result +} + + +string function GetTitanReadyMessageFromSetFile( string setFile ) +{ + var result = Dev_GetPlayerSettingByKeyField_Global( setFile, "readymessage" ) + if ( result == null ) + { + CodeWarning( "Warning, no field readymessage found for set file: " + setFile ) + return "ion" + } + + expect string( result ) + return result +} + + + + +#if CLIENT || UI +void function DisablePrecacheErrors() +{ + file.lastHostThreadMode = GetConVarInt( "host_thread_mode" ) + file.lastScriptPrecacheErrors = GetConVarInt( "script_precache_errors" ) + file.lastReportFatal = GetConVarInt( "fs_report_sync_opens_fatal" ) + + #if CLIENT + entity player = GetLocalClientPlayer() + player.ClientCommand( "host_thread_mode 0" ) + player.ClientCommand( "script_precache_errors 0" ) + player.ClientCommand( "fs_report_sync_opens_fatal 0" ) + #endif + + #if UI + ClientCommand( "host_thread_mode 0" ) + ClientCommand( "script_precache_errors 0" ) + ClientCommand( "fs_report_sync_opens_fatal 0" ) + #endif +} + +void function RestorePrecacheErrors() +{ + #if CLIENT + entity player = GetLocalClientPlayer() + player.ClientCommand( "host_thread_mode " + file.lastHostThreadMode ) + player.ClientCommand( "script_precache_errors " + file.lastScriptPrecacheErrors ) + player.ClientCommand( "fs_report_sync_opens_fatal " + file.lastReportFatal ) + #endif + + #if UI + ClientCommand( "host_thread_mode " + file.lastHostThreadMode ) + ClientCommand( "script_precache_errors " + file.lastScriptPrecacheErrors ) + ClientCommand( "fs_report_sync_opens_fatal " + file.lastReportFatal ) + #endif +} +#endif + +#if SERVER +void function DisablePrecacheErrors() +{ + foreach ( player in GetPlayerArray() ) + { + Remote_CallFunction_UI( player, "DisablePrecacheErrors" ) + } +} + +void function RestorePrecacheErrors() +{ + foreach ( player in GetPlayerArray() ) + { + Remote_CallFunction_UI( player, "RestorePrecacheErrors" ) + } +} + +#endif + +string function GetTitanReadyHintFromSetFile( string setFile ) +{ + var result = Dev_GetPlayerSettingByKeyField_Global( setFile, "readyhint" ) + if ( result == null ) + { + CodeWarning( "Warning, no field readyhint found for set file: " + setFile ) + return "" + } + + expect string( result ) + return result +} + + +void function HideHudElem( var hudelem ) +{ + hudelem.Hide() // sp does not run as much logic, so these elems don't get hidden on player death/spawn. +} + +void function ShowHudElem( var hudelem ) +{ + hudelem.Show() +} + +int function GetBestCompletedDifficultyForLevelId( string uniqueIdentifier ) +{ + int bspNum = GetBSPNum( uniqueIdentifier ) + + if ( GetCompletedDifficultyForBSPNum( bspNum, "sp_missionMasterCompletion" ) ) + return DIFFICULTY_MASTER + if ( GetCompletedDifficultyForBSPNum( bspNum, "sp_missionHardCompletion" ) ) + return DIFFICULTY_HARD + if ( GetCompletedDifficultyForBSPNum( bspNum, "sp_missionNormalCompletion" ) ) + return DIFFICULTY_NORMAL + if ( GetCompletedDifficultyForBSPNum( bspNum, "sp_missionEasyCompletion" ) ) + return DIFFICULTY_EASY + + return -1 // not completed +} + +bool function GetCompletedDifficultyForLevelId( string uniqueIdentifier, string pvar ) +{ + int bspNum = GetBSPNum( uniqueIdentifier ) + + Assert ( bspNum >= 0 ) + + return GetCompletedDifficultyForBSPNum( bspNum, pvar ) +} + +bool function DevStartPoints() +{ + #if DEV + return true + #endif + + return Dev_CommandLineHasParm( "-startpoints" ) +} + +int function GetBSPNum( string uniqueIdentifier ) +{ + var dataTable = GetDataTable( $"datatable/sp_levels.rpak" ) + int numRows = GetDatatableRowCount( dataTable ) + int bspCol = GetDataTableColumnByName( dataTable, "levelId" ) + + for ( int i = 0; i <numRows; i++ ) + { + string levelBsp = GetDataTableString( dataTable, i, bspCol ) + + if ( levelBsp == uniqueIdentifier ) + return i + } + + return -1 +} + +bool function GetCompletedDifficultyForBSPNum( int bspNum, string pvar ) +{ +#if UI || CLIENT + if ( Script_IsRunningTrialVersion() ) + return false +#endif + + int bitfield = GetConVarInt( pvar ) + + return (( bitfield & (1 << bspNum) ) >= 1 ) +} + +int function GetLastLevelUnlocked() +{ + if ( file.devUnlockedSPMissions ) + { + return 9 + } + return GetConVarInt( "sp_unlockedMission" ) +} + +void function UnlockSPLocally() +{ + file.devUnlockedSPMissions = true +} + +bool function CoinFlip() +{ + return RandomInt( 2 ) != 0 +} + +bool function EmotesEnabled() +{ + return false +} + + +array<string> function GetAvailableTitanRefs( entity player ) +{ + array<string> availableTitanRefs + + int enumCount = PersistenceGetEnumCount( "titanClasses" ) + for ( int i = 0; i < enumCount; i++ ) + { + string enumName = PersistenceGetEnumItemNameForIndex( "titanClasses", i ) + if ( enumName == "" ) + continue + + if ( player.GetPersistentVarAsInt( "titanClassLockState[" + enumName + "]" ) > TITAN_CLASS_LOCK_STATE_AVAILABLE ) + continue + + availableTitanRefs.append( enumName ) + } + + return availableTitanRefs +} + +#if MP +string function GetTitanRefForLoadoutIndex( entity player, int loadoutIndex ) +{ + TitanLoadoutDef loadout = GetTitanLoadoutFromPersistentData( player, loadoutIndex ) + return loadout.titanClass +} +#endif + +bool function DoPrematchWarpSound() +{ + return GetCurrentPlaylistVarInt( "pick_loadout_warp_sound", 1 ) == 1 +} + + +int function GetIntFromString( string inString ) +{ + if ( inString.len() > 0 ) + { + string firstChar = inString.slice( 0, 1 ) + if ( ( firstChar >= "0" && firstChar <= "9" ) || firstChar == "." ) + return int( inString ) + else + return expect int( getconsttable()[ inString ] ) + } + + return 0 +} + +//Function returns whether the given mode name is a Frontier Defense mode. +bool function IsFDMode( string modeName ) +{ + bool isFD = false + switch ( modeName ) + { + case "fd_easy": + case "fd_normal": + case "fd_hard": + case "fd_master": + case "fd_insane": + isFD = true + } + + return isFD +} + +// Join an array of strings with a seperator +string function JoinStringArray( array<string> strings, string separator ) +{ + string output; + + foreach( int i, string stringoStarr in strings ) + { + if (i == 0) + output = stringoStarr + else + output = output + separator + stringoStarr + } + + return output; +}
\ No newline at end of file |