diff options
Diffstat (limited to 'Northstar.CustomServers/scripts/vscripts/_utility_shared.nut')
| -rw-r--r-- | Northstar.CustomServers/scripts/vscripts/_utility_shared.nut | 4069 |
1 files changed, 4069 insertions, 0 deletions
diff --git a/Northstar.CustomServers/scripts/vscripts/_utility_shared.nut b/Northstar.CustomServers/scripts/vscripts/_utility_shared.nut new file mode 100644 index 000000000..e3cb0dbfb --- /dev/null +++ b/Northstar.CustomServers/scripts/vscripts/_utility_shared.nut @@ -0,0 +1,4069 @@ +untyped + +globalize_all_functions + +const DEV_DRAWALLTRIGGERS = 0 + +global const CHARGE_TOOL = "sp_weapon_arc_tool" + +global const TRIG_FLAG_NONE = 0 +global const TRIG_FLAG_PLAYERONLY = 0x0001 +global const TRIG_FLAG_NPCONLY = 0x0002 +global const TRIG_FLAG_NOCONTEXTBUSY = 0x0004 +global const TRIG_FLAG_ONCE = 0x0008 +global const TRIG_FLAG_EXCLUSIVE = 0x0010 // can only be triggered by entities passed in at creation +global const TRIG_FLAG_DEVDRAW = 0x0020 +global const TRIG_FLAG_START_DISABLED = 0x0040 +global const TRIG_FLAG_NO_PHASE_SHIFT = 0x0080 +global const float MAP_EXTENTS = 128*128 +/* +const TRIG_FLAG_ = 0x0080 +const TRIG_FLAG_ = 0x0100*/ + +global const TRIGGER_INTERNAL_SIGNAL = "OnTrigger" + +global const CALCULATE_SEQUENCE_BLEND_TIME = -1.0 + +global struct ArrayDistanceEntry +{ + float distanceSqr + entity ent + vector origin +} + +global struct GravityLandData +{ + array<vector> points + TraceResults& traceResults + float elapsedTime +} + +global struct FirstPersonSequenceStruct +{ + string firstPersonAnim = "" + string thirdPersonAnim = "" + string firstPersonAnimIdle = "" + string thirdPersonAnimIdle = "" + string relativeAnim = "" + string attachment = "" + bool teleport = false + bool noParent = false + float blendTime = CALCULATE_SEQUENCE_BLEND_TIME + float firstPersonBlendOutTime = -1.0 + bool noViewLerp = false + bool hideProxy = false + void functionref( entity ) viewConeFunction = null + vector ornull origin = null + vector ornull angles = null + bool enablePlanting = false + float setInitialTime = 0.0 //set the starting point of the animation in seconds + bool useAnimatedRefAttachment = false //Position entity using ref every frame instead of using root motion + bool renderWithViewModels = false + bool gravity = false // force gravity command on sequence + bool playerPushable = false + array< string > thirdPersonCameraAttachments = [] + bool thirdPersonCameraVisibilityChecks = false + entity thirdPersonCameraEntity = null + bool snapPlayerFeetToEyes = true +} + +global struct FrontRightDotProductsStruct +{ + float forwardDot = 0.0 + float rightDot = 0.0 +} + +global struct RaySphereIntersectStruct +{ + bool result + float enterFrac + float leaveFrac +} + +void function Utility_Shared_Init() +{ + RegisterSignal( TRIGGER_INTERNAL_SIGNAL ) + RegisterSignal( "devForcedWin" ) + + #document( "IsAlive", "Returns true if the given ent is not null, and is alive." ) + #document( "ArrayWithin", "Remove ents from array that are out of range" ) +} + +#if DEV +// short cut for the console +// script gp()[0].Die( gp()[1] ) +array<entity> function gp() +{ + return GetPlayerArray() +} +#endif + +void function InitWeaponScripts() +{ + SmartAmmo_Init() + + // WEAPON SCRIPTS + ArcCannon_Init() + Grenade_FileInit() + Vortex_Init() + +// #if SERVER +// PrecacheProjectileEntity( "grenade_frag" ) +// PrecacheProjectileEntity( "crossbow_bolt" ) +// #endif + + MpWeaponDroneBeam_Init() + MpWeaponDroneRocket_Init() + MpWeaponDronePlasma_Init() + MpWeaponTurretPlasma_Init() + MpWeaponTurretLaser_Init() + MpWeaponSuperSpectre_Init() + MpWeaponGunshipLauncher_Init() + MpWeaponFragDrone_Init() + MpAbilityShifter_Init() + MpTitanabilityBubbleShield_Init() + MpTitanabilityAmpedWall_Init() + MpTitanabilityFusionCore_Init() + MpTitanweapon40mm_Init() + MpTitanWeaponpredatorcannon_Init() + MpTitanweaponRocketeetRocketStream_Init() + MpTitanweaponMeteor_Init() + MpTitanWeapon_SniperInit() + MpTitanweaponVortexShield_Init() + MpTitanweaponXo16_Init() + MpWeaponDefender_Init() + MpWeaponDmr_Init() + MpWeaponProximityMine_Init() + MpWeaponRocketLauncher_Init() + MpWeaponNPCRocketLauncher_Init() + MpWeaponSatchel_Init() + MpWeaponSmartPistol_Init() + MpWeaponSniper_Init() + MpWeaponLSTAR_Init() + MpTitanWeaponParticleAccelerator_Init() + MpWeaponMegaTurret_Init() + MpWeaponZipline_Init() + SpWeaponHoldBeam_Init() + MpTitanweaponArcBall_Init() + MpWeaponDeployableCover_Init() + MpTitanAbilityBasicBlock_Init() + MpTitanAbilityLaserTrip_Init() + MpTitanWeaponArcWave_Init() + MpTitanWeaponFlameWave_Init() + MpWeaponAlternatorSMG_Init() + MpWeaponGreandeElectricSmoke_Init() + MpWeaponGrenadeGravity_Init() + MpWeaponDeployableCloakfield_Init() + MpWeaponTether_Init() + MpWeaponTripWire_Init() + MpTitanAbilitySmartCore_Init() + MpTitanAbilitySlowTrap_Init() + MpTitanAbilityPowerShot_Init() + MpTitanAbilityAmmoSwap_Init() + MpTitanAbilityRocketeerAmmoSwap_Init() + MpTitanAbilityHeatShield_Init() + SonarGrenade_Init() + MpTitanAbilityGunShield_Init() + MpTitanWeaponLaserLite_Init() + MpTitanWeaponSword_Init() + MpTitanAbilityHover_Init() + MpTitanWeaponTrackerRockets_Init() + MpTitanWeaponStunLaser_Init() + MpTitanWeaponShoulderRockets_Init() + MpTitanAbilitySmoke_Init() + #if MP + MpWeaponArcTrap_Init() + #endif + + #if SERVER + BallLightning_Init() + #endif +} + +float function GetCurrentPlaylistVarFloat( string val, float useVal ) +{ + var result = GetCurrentPlaylistVarOrUseValue( val, useVal + "" ) + if ( result == null || result == "" ) + return 0.0 + + return float( result ) +} + +void function SetSkinForTeam( entity ent, int team ) +{ + if ( team == TEAM_IMC ) + ent.SetSkin( 0 ) + else if ( team == TEAM_MILITIA ) + ent.SetSkin( 1 ) +} + +void function TableDump( table Table, int depth = 0 ) +{ + if ( depth > 4 ) + return + + foreach ( k, v in Table ) + { + printl( "Key: " + k + " Value: " + v ) + if ( type( v ) == "table" && depth ) + TableDump( expect table( v ), depth + 1 ) + } +} + +/*entity function GetVortexWeapon( entity player ) +{ + for ( int weaponIndex = 0; weaponIndex < 2; weaponIndex++ ) + { + entity weapon = player.GetOffhandWeapon( weaponIndex ) + if ( !IsValid( weapon ) ) + continue + if ( weapon.GetWeaponClassName() != "mp_titanweapon_vortex_shield" ) + continue + return weapon + } + + Assert( false, "Vortex weapon not found!" ) + unreachable +}*/ + +entity function GetClosest( array<entity> entArray, vector origin, float maxdist = -1.0 ) +{ + Assert( entArray.len() > 0 ) + + entity bestEnt = entArray[ 0 ] + float bestDistSqr = DistanceSqr( bestEnt.GetOrigin(), origin ) + + for ( int i = 1; i < entArray.len(); i++ ) + { + entity newEnt = entArray[ i ] + float newDistSqr = LengthSqr( newEnt.GetOrigin() - origin ) + + if ( newDistSqr < bestDistSqr ) + { + bestEnt = newEnt + bestDistSqr = newDistSqr + } + } + + if ( maxdist >= 0.0 ) + { + if ( bestDistSqr > maxdist * maxdist ) + return null + } + + return bestEnt +} + +entity function GetClosest2D( array<entity> entArray, vector origin, float maxdist = -1.0 ) +{ + Assert( entArray.len() > 0, "Empty array!" ) + + entity bestEnt = entArray[ 0 ] + float bestDistSqr = DistanceSqr( bestEnt.GetOrigin(), origin ) + + for ( int i = 1; i < entArray.len(); i++ ) + { + entity newEnt = entArray[ i ] + float newDistSqr = Length2DSqr( newEnt.GetOrigin() - origin ) + + if ( newDistSqr < bestDistSqr ) + { + bestEnt = newEnt + bestDistSqr = newDistSqr + } + } + + if ( maxdist >= 0.0 ) + { + if ( bestDistSqr > maxdist * maxdist ) + return null + } + + return bestEnt +} + +bool function GameModeHasCapturePoints() +{ + #if CLIENT + return clGlobal.hardpointStringIDs.len() > 0 + #elseif SERVER + return svGlobal.hardpointStringIDs.len() > 0 + #endif +} + +entity function GetFarthest( array<entity> entArray, vector origin ) +{ + Assert( entArray.len() > 0, "Empty array!" ) + + entity bestEnt = entArray[0] + float bestDistSqr = DistanceSqr( bestEnt.GetOrigin(), origin ) + + for ( int i = 1; i < entArray.len(); i++ ) + { + entity newEnt = entArray[ i ] + float newDistSqr = DistanceSqr( newEnt.GetOrigin(), origin ) + + if ( newDistSqr > bestDistSqr ) + { + bestEnt = newEnt + bestDistSqr = newDistSqr + } + } + + return bestEnt +} + +int function GetClosestIndex( array<entity> Array, vector origin ) +{ + Assert( Array.len() > 0 ) + + int index = 0 + float distSqr = LengthSqr( Array[ index ].GetOrigin() - origin ) + + entity newEnt + float newDistSqr + for ( int i = 1; i < Array.len(); i++ ) + { + newEnt = Array[ i ] + newDistSqr = LengthSqr( newEnt.GetOrigin() - origin ) + + if ( newDistSqr < distSqr ) + { + index = i + distSqr = newDistSqr + } + } + + return index +} + +// nothing in the game uses the format "Table.r/g/b/a"... wtf is the point of this function +table function StringToColors( string colorString, string delimiter = " " ) +{ + PerfStart( PerfIndexShared.StringToColors + SharedPerfIndexStart ) + array<string> tokens = split( colorString, delimiter ) + + Assert( tokens.len() >= 3 ) + + table Table = {} + Table.r <- int( tokens[0] ) + Table.g <- int( tokens[1] ) + Table.b <- int( tokens[2] ) + + if ( tokens.len() == 4 ) + Table.a <- int( tokens[3] ) + else + Table.a <- 255 + + PerfEnd( PerfIndexShared.StringToColors + SharedPerfIndexStart ) + return Table +} + +// TODO: Set return type to array<int> when SetColor() accepts this type +function ColorStringToArray( string colorString ) +{ + array<string> tokens = split( colorString, " " ) + + Assert( tokens.len() >= 3 && tokens.len() <= 4 ) + + array colorArray + foreach ( token in tokens ) + colorArray.append( int( token ) ) + + return colorArray +} + +// Evaluate a generic order ( coefficientArray.len() - 1 ) polynomial +// e.g. to evaluate (Ax + B), call EvaluatePolynomial(x, A, B) +// Note that EvaluatePolynomial(x) returns 0 and +// EvaluatePolynomial(x, A) returns A, which are technically correct +// but perhaps not what you expect +float function EvaluatePolynomial( float x, array<float> coefficientArray ) +{ + float sum = 0.0 + + for ( int i = 0; i < coefficientArray.len() - 1; ++i ) + sum += coefficientArray[ i ] * pow( x, coefficientArray.len() -1 - i ) + + if ( coefficientArray.len() >= 1 ) + sum += coefficientArray[ coefficientArray.len() - 1 ] + + return sum +} + +void function WaitForever() +{ + #if SERVER + svGlobal.levelEnt.WaitSignal( "forever" ) + #elseif CLIENT + clGlobal.levelEnt.WaitSignal( "forever" ) + #endif +} + +#if SERVER + +bool function ShouldDoReplay( entity player, entity attacker, float replayTime, int methodOfDeath ) +{ + if ( ShouldDoReplayIsForcedByCode() ) + { + print( "ShouldDoReplay(): Doing a replay because code forced it." ); + return true + } + + if ( GetCurrentPlaylistVarInt( "replay_disabled", 0 ) == 1 ) + { + print( "ShouldDoReplay(): Not doing a replay because 'replay_disabled' is enabled in the current playlist.\n" ); + return false + } + + switch( methodOfDeath ) + { + case eDamageSourceId.human_execution: + case eDamageSourceId.titan_execution: + { + print( "ShouldDoReplay(): Not doing a replay because the player died from an execution.\n" ); + return false + } + } + + if ( level.nv.replayDisabled ) + { + print( "ShouldDoReplay(): Not doing a replay because replays are disabled for the level.\n" ); + return false + } + + if ( Time() - player.p.connectTime <= replayTime ) //Bad things happen if we try to do a kill replay that lasts longer than the player entity existing on the server + { + print( "ShouldDoReplay(): Not doing a replay because the player is not old enough.\n" ); + return false + } + + if ( player == attacker ) + { + print( "ShouldDoReplay(): Not doing a replay because the attacker is the player.\n" ); + return false + } + + if ( player.IsBot() == true ) + { + print( "ShouldDoReplay(): Not doing a replay because the player is a bot.\n" ); + return false + } + + return AttackerShouldTriggerReplay( attacker ) +} + +// Don't let things like killbrushes show replays +bool function AttackerShouldTriggerReplay( entity attacker ) +{ + if ( !IsValid( attacker ) ) + { + print( "AttackerShouldTriggerReplay(): Not doing a replay because the attacker is not valid.\n" ) + return false + } + + if ( attacker.IsPlayer() ) + { + print( "AttackerShouldTriggerReplay(): Doing a replay because the attacker is a player.\n" ) + return true + } + + if ( attacker.IsNPC() ) + { + print( "AttackerShouldTriggerReplay(): Doing a replay because the attacker is an NPC.\n" ) + return true + } + + print( "AttackerShouldTriggerReplay(): Not doing a replay by default.\n" ) + return false +} +#endif // #if SERVER + +vector function RandomVec( float range ) +{ + // could rewrite so it doesnt make a box of random. + vector vec = Vector( 0, 0, 0 ) + vec.x = RandomFloatRange( -range, range ) + vec.y = RandomFloatRange( -range, range ) + vec.z = RandomFloatRange( -range, range ) + + return vec +} + +function ArrayValuesToTableKeys( arr ) +{ + Assert( type( arr ) == "array", "Not an array" ) + + local resultTable = {} + for ( int i = 0; i < arr.len(); ++ i) + { + resultTable[ arr[ i ] ] <- 1 + } + + return resultTable +} + +function TableKeysToArray( tab ) +{ + Assert( type( tab ) == "table", "Not a table" ) + + local resultArray = [] + resultArray.resize( tab.len() ) + int currentArrayIndex = 0 + foreach ( key, val in tab ) + { + resultArray[ currentArrayIndex ] = key + ++currentArrayIndex + } + + return resultArray +} + +function TableRandom( Table ) +{ + Assert( type( Table ) == "table", "Not a table" ) + + local Array = [] + + foreach ( entry, contents in Table ) + { + Array.append( contents ) + } + + return Array.getrandom() +} + +int function RandomWeightedIndex( array Array ) +{ + int count = Array.len() + Assert( count != 0, "Array is empty" ) + + int sum = int( ( count * ( count + 1 ) ) / 2.0 ) // ( n * ( n + 1 ) ) / 2 + int randInt = RandomInt( sum ) + for ( int i = 0 ; i < count ; i++ ) + { + int rangeForThisIndex = count - i + if ( randInt < rangeForThisIndex ) + return i + + randInt -= rangeForThisIndex + } + + Assert( 0 ) + unreachable +} + +bool function IsValid_ThisFrame( entity ent ) +{ + if ( ent == null ) + return false + + return expect bool( ent.IsValidInternal() ) +} + +bool function IsAlive( entity ent ) +{ + if ( ent == null ) + return false + if ( !ent.IsValidInternal() ) + return false + + return ent.IsEntAlive() +} + +#if DEV && SERVER +void function vduon() +{ + PlayConversationToAll( "TitanReplacement" ) +} + +void function playconvtest( string conv ) +{ + entity player = GetPlayerArray()[0] + array<entity> guys = GetAllSoldiers() + if ( !guys.len() ) + { + printt( "No AI!!" ) + return + } + entity guy = GetClosest( guys, player.GetOrigin() ) + if ( conv in player.s.lastAIConversationTime ) + delete player.s.lastAIConversationTime[ conv ] + + printt( "Play ai conversation " + conv ) + PlaySquadConversationToAll( conv, guy ) +} +#endif //DEV + +void function FighterExplodes( entity ship ) +{ + vector origin = ship.GetOrigin() + vector angles = ship.GetAngles() + EmitSoundAtPosition( TEAM_UNASSIGNED, origin, "AngelCity_Scr_RedeyeWeaponExplos" ) + #if SERVER + PlayFX( FX_HORNET_DEATH, origin ) + #else + int fxid = GetParticleSystemIndex( FX_HORNET_DEATH ) + StartParticleEffectInWorld( fxid, origin, angles ) + #endif +} + +vector function PositionOffsetFromEnt( entity ent, float offsetX, float offsetY, float offsetZ ) +{ + vector angles = ent.GetAngles() + vector origin = ent.GetOrigin() + origin += AnglesToForward( angles ) * offsetX + origin += AnglesToRight( angles ) * offsetY + origin += AnglesToUp( angles ) * offsetZ + return origin +} + +vector function PositionOffsetFromOriginAngles( vector origin, vector angles, float offsetX, float offsetY, float offsetZ ) +{ + origin += AnglesToForward( angles ) * offsetX + origin += AnglesToRight( angles ) * offsetY + origin += AnglesToUp( angles ) * offsetZ + return origin +} + + +bool function IsMenuLevel() +{ + return IsLobby() +} + +function Dump( package, depth = 0 ) +{ + if ( depth > 6 ) + return + + foreach ( k, v in package ) + { + for ( int i = 0; i < depth; i++ ) + print( " ") + + if ( IsTable( package ) ) + printl( "Key: " + k + " Value: " + v ) + if ( IsArray( package ) ) + printl( "Index: " + k + " Value: " + v ) + + if ( IsTable( v ) || IsArray( v ) ) + Dump( v, depth + 1 ) + } +} + +bool function UseShortNPCTitles() +{ + return GetCurrentPlaylistVarInt( "npc_short_titles", 0 ) ? true : false +} + +string function GetShortNPCTitle( int team ) +{ + return GetTeamName( team ) +} + +bool function IsIMCOrMilitiaTeam( int team ) +{ + return team == TEAM_MILITIA || team == TEAM_IMC +} + +int function GetOtherTeam( int team ) +{ + if ( team == TEAM_IMC ) + return TEAM_MILITIA + + if ( team == TEAM_MILITIA ) + return TEAM_IMC + + Assert( false, "Trying to GetOtherTeam() for team: " + team + " that is neither Militia nor IMC" ) + unreachable +} + +float function VectorDot_PlayerToOrigin( entity player, vector targetOrigin ) +{ + vector playerEyePosition = player.EyePosition() + vector vecToEnt = ( targetOrigin - playerEyePosition ) + vecToEnt.Norm() + + // GetViewVector() only works on the player + float dotVal = vecToEnt.Dot( player.GetViewVector() ) + return dotVal +} + +float function VectorDot_DirectionToOrigin( entity player, vector direction, vector targetOrigin ) +{ + vector playerEyePosition = player.EyePosition() + vector vecToEnt = ( targetOrigin - playerEyePosition ) + vecToEnt.Norm() + + // GetViewVector() only works on the player + float dotVal = DotProduct( vecToEnt, direction ) + return dotVal +} + +void function WaitUntilWithinDistance( entity player, entity titan, float dist ) +{ + float distSqr = dist * dist + for ( ;; ) + { + if ( !IsAlive( titan ) ) + return + + if ( IsAlive( player ) ) + { + if ( DistanceSqr( player.GetOrigin(), titan.GetOrigin() ) <= distSqr ) + return + } + wait 0.1 + } +} + +void function WaitUntilBeyondDistance( entity player, entity titan, float dist ) +{ + float distSqr = dist * dist + for ( ;; ) + { + if ( !IsAlive( titan ) ) + return + + if ( IsAlive( player ) ) + { + if ( DistanceSqr( player.GetOrigin(), titan.GetOrigin() ) > distSqr ) + return + } + wait 0.1 + } +} + +bool function IsModelViewer() +{ + return GetMapName() == "mp_model_viewer" +} + + +//----------------------------------// +// Tweening functions // +// Pass in a fraction 0.0 - 1.0 // +// Get a fraction back 0.0 - 1.0 // +//----------------------------------// + +// simple linear tweening - no easing, no acceleration +float function Tween_Linear( float frac ) +{ + Assert( frac >= 0.0 && frac <= 1.0 ) + return frac +} + +// quadratic easing out - decelerating to zero velocity +float function Tween_QuadEaseOut( float frac ) +{ + Assert( frac >= 0.0 && frac <= 1.0 ) + return -1.0 * frac*(frac-2) +} + +// exponential easing out - decelerating to zero velocity +float function Tween_ExpoEaseOut( float frac ) +{ + Assert( frac >= 0.0 && frac <= 1.0 ) + return -pow( 2.0, -10.0 * frac ) + 1.0 +} + +float function Tween_ExpoEaseIn( float frac ) +{ + Assert( frac >= 0.0 && frac <= 1.0 ) + return pow( 2, 10 * ( frac - 1 ) ); +} + +bool function LegalOrigin( vector origin ) +{ + if ( fabs( origin.x ) > MAX_WORLD_COORD ) + return false + + if ( fabs( origin.y ) > MAX_WORLD_COORD ) + return false + + if ( fabs( origin.z ) > MAX_WORLD_COORD ) + return false + + return true +} + +vector function AnglesOnSurface( surfaceNormal, playerVelocity ) +{ + playerVelocity.Norm() + vector right = CrossProduct( playerVelocity, surfaceNormal ) + vector forward = CrossProduct( surfaceNormal, right ) + vector angles = VectorToAngles( forward ) + angles.z = atan2( right.z, surfaceNormal.z ) * RAD_TO_DEG + + return angles +} + +vector function ClampToWorldspace( vector origin ) +{ + // temp solution for start positions that are outside the world bounds + origin.x = clamp( origin.x, -MAX_WORLD_COORD, MAX_WORLD_COORD ) + origin.y = clamp( origin.y, -MAX_WORLD_COORD, MAX_WORLD_COORD ) + origin.z = clamp( origin.z, -MAX_WORLD_COORD, MAX_WORLD_COORD ) + + return origin +} + +function UseReturnTrue( user, usee ) +{ + return true +} + +function ControlPanel_CanUseFunction( playerUser, controlPanel ) +{ + expect entity( playerUser ) + expect entity( controlPanel ) + + // Does a simple cone FOV check from the screen to the player's eyes + int maxAngleToAxisAllowedDegrees = 60 + + vector playerEyePos = playerUser.EyePosition() + int attachmentIndex = controlPanel.LookupAttachment( "PANEL_SCREEN_MIDDLE" ) + + Assert( attachmentIndex != 0 ) + vector controlPanelScreenPosition = controlPanel.GetAttachmentOrigin( attachmentIndex ) + vector controlPanelScreenAngles = controlPanel.GetAttachmentAngles( attachmentIndex ) + vector controlPanelScreenForward = AnglesToForward( controlPanelScreenAngles ) + + vector screenToPlayerEyes = Normalize( playerEyePos - controlPanelScreenPosition ) + + return DotProduct( screenToPlayerEyes, controlPanelScreenForward ) > deg_cos( maxAngleToAxisAllowedDegrees ) +} + +function SentryTurret_CanUseFunction( playerUser, sentryTurret ) +{ + expect entity( playerUser ) + expect entity( sentryTurret ) + + // Does a simple cone FOV check from the screen to the player's eyes + int maxAngleToAxisAllowedDegrees = 90 + + vector playerEyePos = playerUser.EyePosition() + int attachmentIndex = sentryTurret.LookupAttachment( "turret_player_use" ) + + Assert( attachmentIndex != 0 ) + vector sentryTurretUsePosition = sentryTurret.GetAttachmentOrigin( attachmentIndex ) + vector sentryTurretUseAngles = sentryTurret.GetAttachmentAngles( attachmentIndex ) + vector sentryTurretUseForward = AnglesToForward( sentryTurretUseAngles ) + + vector useToPlayerEyes = Normalize( playerEyePos - sentryTurretUsePosition ) + + return DotProduct( useToPlayerEyes, sentryTurretUseForward ) > deg_cos( maxAngleToAxisAllowedDegrees ) +} + +void function ArrayRemoveInvalid( array<entity> ents ) +{ + for ( int i = ents.len() - 1; i >= 0; i-- ) + { + if ( !IsValid( ents[ i ] ) ) + ents.remove( i ) + } +} + +bool function HasDamageStates( entity ent ) +{ + if ( !IsValid( ent ) ) + return false + return ( "damageStateInfo" in ent.s ) +} + +bool function HasHitData( entity ent ) +{ + return ( "hasHitData" in ent.s && expect bool( ent.s.hasHitData ) ) +} + +FrontRightDotProductsStruct function GetFrontRightDots( entity baseEnt, entity relativeEnt, string optionalTag = "" ) +{ + if ( optionalTag != "" ) + { + int attachIndex = baseEnt.LookupAttachment( optionalTag ) + vector origin = baseEnt.GetAttachmentOrigin( attachIndex ) + vector angles = baseEnt.GetAttachmentAngles( attachIndex ) + angles.x = 0 + angles.z = 0 + vector forward = AnglesToForward( angles ) + vector right = AnglesToRight( angles ) + + vector targetOrg = relativeEnt.GetOrigin() + vector vecToEnt = ( targetOrg - origin ) +// printt( "vecToEnt ", vecToEnt ) + vecToEnt.z = 0 + + vecToEnt.Norm() + + + FrontRightDotProductsStruct result + result.forwardDot = DotProduct( vecToEnt, forward ) + result.rightDot = DotProduct( vecToEnt, right ) + + // red: forward for incoming ent + //DebugDrawLine( origin, origin + vecToEnt * 150, 255, 0, 0, true, 5 ) + + // green: tag forward + //DebugDrawLine( origin, origin + forward * 150, 0, 255, 0, true, 5 ) + + // blue: tag right + //DebugDrawLine( origin, origin + right * 150, 0, 0, 255, true, 5 ) + return result + } + + vector targetOrg = relativeEnt.GetOrigin() + vector origin = baseEnt.GetOrigin() + vector vecToEnt = ( targetOrg - origin ) + vecToEnt.Norm() + + FrontRightDotProductsStruct result + result.forwardDot = vecToEnt.Dot( baseEnt.GetForwardVector() ) + result.rightDot = vecToEnt.Dot( baseEnt.GetRightVector() ) + return result +} + + + +array<vector> function GetAllPointsOnBezier( array<vector> points, int numSegments, float debugDrawTime = 0.0 ) +{ + Assert( points.len() >= 2 ) + Assert( numSegments > 0 ) + array<vector> curvePoints = [] + + // Debug draw the points used for the curve + if ( debugDrawTime ) + { + for ( int i = 0; i < points.len() - 1; i++ ) + DebugDrawLine( points[i], points[i + 1], 150, 150, 150, true, debugDrawTime ) + } + + for ( int i = 0; i < numSegments; i++ ) + { + float t = ( i.tofloat() / ( numSegments.tofloat() - 1.0 ) ).tofloat() + curvePoints.append( GetSinglePointOnBezier( points, t ) ) + } + + return curvePoints +} + +vector function GetSinglePointOnBezier( array<vector> points, float t ) +{ + // evaluate a point on a bezier-curve. t goes from 0 to 1.0 + + array<vector> lastPoints = clone points + for(;;) + { + array<vector> newPoints = [] + for ( int i = 0; i < lastPoints.len() - 1; i++ ) + newPoints.append( lastPoints[i] + ( lastPoints[i+1] - lastPoints[i] ) * t ) + + if ( newPoints.len() == 1 ) + return newPoints[0] + + lastPoints = newPoints + } + + unreachable +} + +bool function GetDoomedState( entity ent ) +{ + entity soul = ent.GetTitanSoul() + if ( !IsValid( soul ) ) + return false + + return soul.IsDoomed() +} + +bool function TitanCoreInUse( entity player ) +{ + Assert( player.IsTitan() ) + + if ( !IsAlive( player ) ) + return false + + return Time() < SoulTitanCore_GetExpireTime( player.GetTitanSoul() ) +} + + +// Return float or null +function GetTitanCoreTimeRemaining( entity player ) +{ + if ( !player.IsTitan() ) + return null + + entity soul = player.GetTitanSoul() + + if ( !soul ) + return null + + return SoulTitanCore_GetExpireTime( soul ) - Time() +} + +bool function CoreAvailableDuringDoomState() +{ + return true +} + +bool function HasAntiTitanWeapon( entity guy ) +{ + foreach ( weapon in guy.GetMainWeapons() ) + { + if ( weapon.GetWeaponType() == WT_ANTITITAN ) + return true + } + return false +} + +float function GetTitanCoreActiveTime( entity player ) +{ + entity weapon = player.GetOffhandWeapon( OFFHAND_EQUIPMENT ) + + if ( !IsValid( weapon ) ) + { + printt( "WARNING: tried to get core active time, but core weapon was invalid." ) + printt( "titan is alive? " + IsAlive( player ) ) + return 5.0 // default + } + + return GetTitanCoreDurationFromWeapon( weapon ) +} + +float function GetTitanCoreChargeTime( entity player ) +{ + entity weapon = player.GetOffhandWeapon( OFFHAND_EQUIPMENT ) + + if ( !IsValid( weapon ) ) + { + printt( "WARNING: tried to get core charge time, but core weapon was invalid." ) + printt( "titan is alive? " + IsAlive( player ) ) + return 1.0 // default + } + + return GetTitanCoreChargeTimeFromWeapon( weapon ) +} + +float function GetTitanCoreChargeTimeFromWeapon( entity weapon ) +{ + return expect float( weapon.GetWeaponInfoFileKeyField( "chargeup_time" ) ) +} + +float function GetTitanCoreBuildTimeFromWeapon( entity weapon ) +{ + return expect float( weapon.GetWeaponInfoFileKeyField( "core_build_time" ).tofloat() ) +} + +float function GetTitanCoreDurationFromWeapon( entity weapon ) +{ + float coreDuration = weapon.GetCoreDuration() + + entity player = weapon.GetWeaponOwner() + if ( IsValid( player ) && player.IsPlayer() ) + { + if ( PlayerHasPassive( player, ePassives.PAS_MARATHON_CORE ) ) + coreDuration *= TITAN_CORE_MARATHON_CORE_MULTIPLIER + } + + return coreDuration +} + +float function GetCoreBuildTime( entity titan ) +{ + if ( titan.IsPlayer() ) + titan = GetTitanFromPlayer( titan ) + + Assert( titan != null ) + + entity coreWeapon = titan.GetOffhandWeapon( OFFHAND_EQUIPMENT ) + + if ( !IsValid( coreWeapon ) ) + { + //printt( "WARNING: tried to set build timer, but core weapon was invalid." ) + //printt( "titan is alive? " + IsAlive( titan ) ) + return 200.0 // default + } + + + return GetTitanCoreBuildTimeFromWeapon( coreWeapon ) +} + +string function GetCoreShortName( entity titan ) +{ + entity coreWeapon = titan.GetOffhandWeapon( OFFHAND_EQUIPMENT ) + + if ( !IsValid( coreWeapon ) ) + { + printt( "WARNING: tried to get core name, but core weapon was invalid." ) + printt( "titan is alive? " + IsAlive( titan ) ) + return "#HUD_READY" + } + + string name = expect string( coreWeapon.GetWeaponInfoFileKeyField( "shortprintname" ) ) + return name +} + +string ornull function GetCoreOSConversationName( entity titan, string event ) +{ + entity coreWeapon = titan.GetOffhandWeapon( OFFHAND_EQUIPMENT ) + + if ( !IsValid( coreWeapon ) ) + { + printt( "WARNING: tried to get core sound for " + event + ", but core weapon was invalid." ) + printt( "titan is alive? " + IsAlive( titan ) ) + return null + } + + var alias = coreWeapon.GetWeaponInfoFileKeyField( "dialog_" + event ) + + if ( alias == null ) + return null + + expect string( alias ) + + return alias +} + +entity function GetTitanFromPlayer( entity player ) +{ + Assert( player.IsPlayer() ) + if ( player.IsTitan() ) + return player + + return player.GetPetTitan() +} + +int function GetNuclearPayload( entity player ) +{ + if ( !GetDoomedState( player ) ) + return 0 + + int payload = 0 + if ( PlayerHasPassive( player, ePassives.PAS_NUCLEAR_CORE ) ) + payload += 2 + + if ( PlayerHasPassive( player, ePassives.PAS_BUILD_UP_NUCLEAR_CORE ) ) + payload += 1 + + return payload +} + +entity function GetCloak( entity ent ) +{ + return GetOffhand( ent, "mp_ability_cloak" ) +} + +entity function GetOffhand( entity ent, string classname ) +{ + entity offhand = ent.GetOffhandWeapon( OFFHAND_LEFT ) + if ( IsValid( offhand ) && offhand.GetWeaponClassName() == classname ) + return offhand + + offhand = ent.GetOffhandWeapon( OFFHAND_RIGHT ) + if ( IsValid( offhand ) && offhand.GetWeaponClassName() == classname ) + return offhand + + return null +} + +bool function IsCloaked( entity ent ) +{ + return ent.IsCloaked( true ) //pass true to ignore flicker time - +} + +float function TimeSpentInCurrentState() +{ + return Time() - expect float( level.nv.gameStateChangeTime ) +} + +float function DotToAngle( float dot ) +{ + return acos( dot ) * RAD_TO_DEG +} + +float function AngleToDot( float angle ) +{ + return cos( angle * DEG_TO_RAD ) +} + +int function GetGameState() +{ + return expect int( GetServerVar( "gameState" ) ) +} + +bool function GamePlaying() +{ + return GetGameState() == eGameState.Playing +} + +bool function GamePlayingOrSuddenDeath() +{ + int gameState = GetGameState() + return gameState == eGameState.Playing || gameState == eGameState.SuddenDeath +} + +bool function IsOdd( int num ) +{ + return ( num % 2 ) == 1 +} + +bool function IsEven( int num ) +{ + return !IsOdd( num ) +} + +vector function VectorReflectionAcrossNormal( vector vec, vector normal ) +{ + return ( vec - normal * ( 2 * DotProduct( vec, normal ) ) ) +} + +// Return an array of entities ordered from farthest to closest to the specified origin +array<entity> function ArrayFarthest( array<entity> entArray, vector origin ) +{ + array<ArrayDistanceEntry> allResults = ArrayDistanceResults( entArray, origin ) + + allResults.sort( DistanceCompareFarthest ) + + array<entity> returnEntities + + foreach ( result in allResults ) + returnEntities.append( result.ent ) + + // the actual distances aren't returned + return returnEntities +} + +// Return an array of vectors ordered from closest to furthest from the specified origin +array<vector> function ArrayFarthestVector( array<vector> vecArray, vector origin ) +{ + array<ArrayDistanceEntry> allResults = ArrayDistanceResultsVector( vecArray, origin ) + + allResults.sort( DistanceCompareFarthest ) + + array<vector> returnVecs + + foreach ( result in allResults ) + returnVecs.append( result.origin ) + + return returnVecs +} + +// Return an array of entities ordered from closest to furthest from the specified origin +array<entity> function ArrayClosest( array<entity> entArray, vector origin ) +{ + array<ArrayDistanceEntry> allResults = ArrayDistanceResults( entArray, origin ) + + allResults.sort( DistanceCompareClosest ) + + array<entity> returnEntities + + foreach ( result in allResults ) + returnEntities.append( result.ent ) + + return returnEntities +} + +// Return an array of vectors ordered from closest to furthest from the specified origin +array<vector> function ArrayClosestVector( array<vector> vecArray, vector origin ) +{ + array<ArrayDistanceEntry> allResults = ArrayDistanceResultsVector( vecArray, origin ) + + allResults.sort( DistanceCompareClosest ) + + array<vector> returnVecs + + foreach ( result in allResults ) + returnVecs.append( result.origin ) + + return returnVecs +} + +array<entity> function ArrayClosestWithinDistance( array<entity> entArray, vector origin, float maxDistance ) +{ + array<ArrayDistanceEntry> allResults = ArrayDistanceResults( entArray, origin ) + float maxDistSq = maxDistance * maxDistance + + allResults.sort( DistanceCompareClosest ) + + array<entity> returnEntities + + foreach ( result in allResults ) + { + if ( result.distanceSqr > maxDistSq ) + break + + returnEntities.append( result.ent ) + } + + return returnEntities +} + +array<vector> function ArrayClosestVectorWithinDistance( array<vector> vecArray, vector origin, float maxDistance ) +{ + array<ArrayDistanceEntry> allResults = ArrayDistanceResultsVector( vecArray, origin ) + float maxDistSq = maxDistance * maxDistance + + allResults.sort( DistanceCompareClosest ) + + array<vector> returnVecs + + foreach ( result in allResults ) + { + if ( result.distanceSqr > maxDistSq ) + break + + returnVecs.append( result.origin ) + } + + return returnVecs +} + +// Return an array of entities ordered from closest to furthest from the specified origin, ignoring z +array<entity> function ArrayClosest2D( array<entity> entArray, vector origin ) +{ + array<ArrayDistanceEntry> allResults = ArrayDistance2DResults( entArray, origin ) + + allResults.sort( DistanceCompareClosest ) + + array<entity> returnEntities + + foreach ( result in allResults ) + returnEntities.append( result.ent ) + + return returnEntities +} + +// Return an array of entities ordered from closest to furthest from the specified origin, ignoring z +array<vector> function ArrayClosest2DVector( array<vector> entArray, vector origin ) +{ + array<ArrayDistanceEntry> allResults = ArrayDistance2DResultsVector( entArray, origin ) + + allResults.sort( DistanceCompareClosest ) + + array<vector> returnVecs + + foreach ( result in allResults ) + returnVecs.append( result.origin ) + + return returnVecs +} + +array<entity> function ArrayClosest2DWithinDistance( array<entity> entArray, vector origin, float maxDistance ) +{ + array<ArrayDistanceEntry> allResults = ArrayDistance2DResults( entArray, origin ) + float maxDistSq = maxDistance * maxDistance + + allResults.sort( DistanceCompareClosest ) + + array<entity> returnEntities + + foreach ( result in allResults ) + { + if ( result.distanceSqr > maxDistSq ) + break + + returnEntities.append( result.ent ) + } + + return returnEntities +} + +// Return an array of entities ordered from closest to furthest from the specified origin, ignoring z +array<vector> function ArrayClosest2DVectorWithinDistance( array<vector> entArray, vector origin, float maxDistance ) +{ + array<ArrayDistanceEntry> allResults = ArrayDistance2DResultsVector( entArray, origin ) + float maxDistSq = maxDistance * maxDistance + + allResults.sort( DistanceCompareClosest ) + + array<vector> returnVecs + + foreach ( result in allResults ) + { + if ( result.distanceSqr > maxDistSq ) + break + + returnVecs.append( result.origin ) + } + + return returnVecs +} + +bool function ArrayEntityWithinDistance( array<entity> entArray, vector origin, float distance ) +{ + float distSq = distance * distance + foreach( entity ent in entArray ) + { + if ( DistanceSqr( ent.GetOrigin(), origin ) <= distSq ) + return true + } + return false +} + +function TableRemove( Table, entry ) +{ + Assert( typeof Table == "table" ) + + foreach ( index, tableEntry in Table ) + { + if ( tableEntry == entry ) + { + Table[ index ] = null + } + } +} + +function TableInvert( Table ) +{ + table invertedTable = {} + foreach ( key, value in Table ) + invertedTable[ value ] <- key + + return invertedTable +} + +int function DistanceCompareClosest( ArrayDistanceEntry a, ArrayDistanceEntry b ) +{ + if ( a.distanceSqr > b.distanceSqr ) + return 1 + else if ( a.distanceSqr < b.distanceSqr ) + return -1 + + return 0; +} + +int function DistanceCompareFarthest( ArrayDistanceEntry a, ArrayDistanceEntry b ) +{ + if ( a.distanceSqr < b.distanceSqr ) + return 1 + else if ( a.distanceSqr > b.distanceSqr ) + return -1 + + return 0; +} + +array<ArrayDistanceEntry> function ArrayDistanceResults( array<entity> entArray, vector origin ) +{ + array<ArrayDistanceEntry> allResults + + foreach ( ent in entArray ) + { + ArrayDistanceEntry entry + + vector entOrigin = ent.GetOrigin() + if ( IsSpawner( ent ) ) + { + var spawnKVs = ent.GetSpawnEntityKeyValues() + entOrigin = StringToVector( string( spawnKVs.origin ) ) + } + entry.distanceSqr = DistanceSqr( entOrigin, origin ) + entry.ent = ent + entry.origin = entOrigin + + allResults.append( entry ) + } + + return allResults +} + +array<ArrayDistanceEntry> function ArrayDistanceResultsVector( array<vector> vecArray, vector origin ) +{ + array<ArrayDistanceEntry> allResults + + foreach ( vec in vecArray ) + { + ArrayDistanceEntry entry + + entry.distanceSqr = DistanceSqr( vec, origin ) + entry.ent = null + entry.origin = vec + + allResults.append( entry ) + } + + return allResults +} + +array<ArrayDistanceEntry> function ArrayDistance2DResults( array<entity> entArray, vector origin ) +{ + array<ArrayDistanceEntry> allResults + + foreach ( ent in entArray ) + { + ArrayDistanceEntry entry + + vector entOrigin = ent.GetOrigin() + + entry.distanceSqr = Distance2DSqr( entOrigin, origin ) + entry.ent = ent + entry.origin = entOrigin + + allResults.append( entry ) + } + + return allResults +} + +array<ArrayDistanceEntry> function ArrayDistance2DResultsVector( array<vector> vecArray, vector origin ) +{ + array<ArrayDistanceEntry> allResults + + foreach ( vec in vecArray ) + { + ArrayDistanceEntry entry + + entry.distanceSqr = Distance2DSqr( vec, origin ) + entry.ent = null + entry.origin = vec + + allResults.append( entry ) + } + + return allResults +} + +GravityLandData function GetGravityLandData( vector startPos, vector parentVelocity, vector objectVelocity, float timeLimit, bool bDrawPath = false, float bDrawPathDuration = 0.0, array pathColor = [ 255, 255, 0 ] ) +{ + GravityLandData returnData + + Assert( timeLimit > 0 ) + + float MAX_TIME_ELAPSE = 6.0 + float timeElapsePerTrace = 0.1 + + float sv_gravity = 750.0 + float ent_gravity = 1.0 + float gravityScale = 1.0 + + vector traceStart = startPos + vector traceEnd = traceStart + float traceFrac + int traceCount = 0 + + objectVelocity += parentVelocity + + while( returnData.elapsedTime <= timeLimit ) + { + objectVelocity.z -= ( ent_gravity * sv_gravity * timeElapsePerTrace * gravityScale ) + + traceEnd += objectVelocity * timeElapsePerTrace + returnData.points.append( traceEnd ) + if ( bDrawPath ) + DebugDrawLine( traceStart, traceEnd, pathColor[0], pathColor[1], pathColor[2], false, bDrawPathDuration ) + + traceFrac = TraceLineSimple( traceStart, traceEnd, null ) + traceCount++ + if ( traceFrac < 1.0 ) + { + returnData.traceResults = TraceLine( traceStart, traceEnd, null, TRACE_MASK_SHOT, TRACE_COLLISION_GROUP_NONE ) + return returnData + } + traceStart = traceEnd + returnData.elapsedTime += timeElapsePerTrace + } + + return returnData +} + +float function GetPulseFrac( rate = 1, startTime = 0 ) +{ + return (1 - cos( ( Time() - startTime ) * (rate * (2*PI)) )) / 2 +} + +bool function IsPetTitan( titan ) +{ + Assert( titan.IsTitan() ) + + return titan.GetTitanSoul().GetBossPlayer() != null +} + +vector function StringToVector( string vecString, string delimiter = " " ) +{ + array<string> tokens = split( vecString, delimiter ) + + Assert( tokens.len() >= 3 ) + + return Vector( float( tokens[0] ), float( tokens[1] ), float( tokens[2] ) ) +} + +float function GetShieldHealthFrac( entity ent ) +{ + if ( !IsAlive( ent ) ) + return 0.0 + + if ( HasSoul( ent ) ) + { + entity soul = ent.GetTitanSoul() + if ( IsValid( soul ) ) + ent = soul + } + + int shieldHealth = ent.GetShieldHealth() + int shieldMaxHealth = ent.GetShieldHealthMax() + + if ( shieldMaxHealth == 0 ) + return 0.0 + + return float( shieldHealth ) / float( shieldMaxHealth ) +} + +vector function HackGetDeltaToRef( vector origin, vector angles, entity ent, string anim ) +{ + AnimRefPoint animStartPos = ent.Anim_GetStartForRefPoint( anim, origin, angles ) + + vector delta = origin - animStartPos.origin + return origin + delta +} + +vector function HackGetDeltaToRefOnPlane( vector origin, vector angles, entity ent, string anim, vector up ) +{ + AnimRefPoint animStartPos = ent.Anim_GetStartForRefPoint( anim, origin, angles ) + + vector delta = origin - animStartPos.origin + vector nDelta = Normalize( delta ) + vector xProd = CrossProduct( nDelta, up ) + vector G = CrossProduct( up, xProd ) + vector planarDelta = G * DotProduct( delta, G ) + vector P = origin + planarDelta + +// DebugDrawLine( origin + delta, origin, 255, 0, 0, true, 1.0 ) +// DebugDrawLine( P, origin, 0,255, 100, true, 1.0 ) + + return P +} + +TraceResults function GetViewTrace( entity ent ) +{ + vector traceStart = ent.EyePosition() + vector traceEnd = traceStart + (ent.GetPlayerOrNPCViewVector() * 56756) // longest possible trace given our map size limits + array<entity> ignoreEnts = [ ent ] + + return TraceLine( traceStart, traceEnd, ignoreEnts, TRACE_MASK_SHOT, TRACE_COLLISION_GROUP_NONE ) +} + +function GetModSourceID( modString ) +{ + foreach ( name, id in getconsttable().eModSourceId ) + { + if ( string( name ) == modString ) + return id + } + + return null +} + +void function ArrayRemoveDead( array<entity> entArray ) +{ + for ( int i = entArray.len() - 1; i >= 0; i-- ) + { + if ( !IsAlive( entArray[ i ] ) ) + entArray.remove( i ) + } +} + +array<entity> function GetSortedPlayers( IntFromEntityCompare compareFunc, int team ) +{ + array<entity> players + + if ( team ) + players = GetPlayerArrayOfTeam( team ) + else + players = GetPlayerArray() + + players.sort( compareFunc ) + + return players +} + + +// Sorts by kills and resolves ties in this order: fewest deaths, most titan kills, most assists +int function CompareKills( entity a, entity b ) +{ + int aVal = a.GetPlayerGameStat( PGS_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + aVal = a.GetPlayerGameStat( PGS_DEATHS ) + bVal = b.GetPlayerGameStat( PGS_DEATHS ) + + if ( aVal > bVal ) + return 1 + else if ( aVal < bVal ) + return -1 + + aVal = a.GetPlayerGameStat( PGS_TITAN_KILLS ) + bVal = b.GetPlayerGameStat( PGS_TITAN_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + aVal = a.GetPlayerGameStat( PGS_ASSISTS ) + bVal = b.GetPlayerGameStat( PGS_ASSISTS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + return 0 +} + +// Sorts by kills and resolves ties in this order: fewest deaths, most titan kills, most assists +int function CompareAssaultScore( entity a, entity b ) +{ + int aVal = a.GetPlayerGameStat( PGS_ASSAULT_SCORE ) + int bVal = b.GetPlayerGameStat( PGS_ASSAULT_SCORE ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + return 0 +} + +int function CompareScore( entity a, entity b ) +{ + int aVal = a.GetPlayerGameStat( PGS_SCORE ) + int bVal = b.GetPlayerGameStat( PGS_SCORE ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + return 0 +} + +int function CompareAssault( entity a, entity b ) +{ + int aVal = a.GetPlayerGameStat( PGS_ASSAULT_SCORE ) + int bVal = b.GetPlayerGameStat( PGS_ASSAULT_SCORE ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + return 0 +} + +int function CompareDefense( entity a, entity b ) +{ + int aVal = a.GetPlayerGameStat( PGS_DEFENSE_SCORE ) + int bVal = b.GetPlayerGameStat( PGS_DEFENSE_SCORE ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + return 0 +} + +int function CompareLTS( entity a, entity b ) +{ + int result = CompareTitanKills( a, b ) + if ( result != 0 ) + return result + + int aVal = a.GetPlayerGameStat( PGS_ASSAULT_SCORE ) + int bVal = b.GetPlayerGameStat( PGS_ASSAULT_SCORE ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + return 0 +} + +int function CompareCP( entity a, entity b ) +{ + // Capture Point sorting. Sort priority = assault + defense > pilot kills > titan kills > death + + { + int aVal = a.GetPlayerGameStat( PGS_ASSAULT_SCORE ) + int bVal = b.GetPlayerGameStat( PGS_ASSAULT_SCORE ) + + aVal += a.GetPlayerGameStat( PGS_DEFENSE_SCORE ) + bVal += b.GetPlayerGameStat( PGS_DEFENSE_SCORE ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + } + + // 3) Pilot Kills + { + int aVal = a.GetPlayerGameStat( PGS_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + } + + // 3) Titan Kills + { + int aVal = a.GetPlayerGameStat( PGS_TITAN_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_TITAN_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + } + + // 4) Deaths + { + int aVal = a.GetPlayerGameStat( PGS_DEATHS ) + int bVal = b.GetPlayerGameStat( PGS_DEATHS ) + + if ( aVal < bVal ) + return -1 + else if ( aVal > bVal ) + return 1 + } + + return 0 +} + + +int function CompareCTF( entity a, entity b ) +{ + // Capture the flag sorting. Sort priority = flag captures > flag returns > pilot kills > titan kills > death + + // 1) Flag Captures + int result = CompareAssault( a, b ) + if ( result != 0 ) + return result + + // 2) Flag Returns + result = CompareDefense( a, b ) + if ( result != 0 ) + return result + + // 3) Pilot Kills + int aVal = a.GetPlayerGameStat( PGS_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + // 3) Titan Kills + aVal = a.GetPlayerGameStat( PGS_TITAN_KILLS ) + bVal = b.GetPlayerGameStat( PGS_TITAN_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + // 4) Deaths + aVal = a.GetPlayerGameStat( PGS_DEATHS ) + bVal = b.GetPlayerGameStat( PGS_DEATHS ) + + if ( aVal < bVal ) + return -1 + else if ( aVal > bVal ) + return 1 + + return 0 +} + +int function CompareSpeedball( entity a, entity b ) +{ + // Capture the flag sorting. Sort priority = pilot kills > flag captures > death + + // 1) Pilot Kills + int aVal = a.GetPlayerGameStat( PGS_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + // 2) Flag Captures + int result = CompareAssault( a, b ) + if ( result != 0 ) + return result + + // 3) Deaths + aVal = a.GetPlayerGameStat( PGS_DEATHS ) + bVal = b.GetPlayerGameStat( PGS_DEATHS ) + + if ( aVal < bVal ) + return -1 + else if ( aVal > bVal ) + return 1 + + return 0 +} + +int function CompareMFD( entity a, entity b ) +{ + // 1) Marks Killed + int result = CompareAssault( a, b ) + if ( result != 0 ) + return result + + // 2) Marks Outlasted + result = CompareDefense( a, b ) + if ( result != 0 ) + return result + + // 3) Pilot Kills + int aVal = a.GetPlayerGameStat( PGS_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + // 4) Titan Kills + aVal = a.GetPlayerGameStat( PGS_TITAN_KILLS ) + bVal = b.GetPlayerGameStat( PGS_TITAN_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + // 5) Deaths + aVal = a.GetPlayerGameStat( PGS_DEATHS ) + bVal = b.GetPlayerGameStat( PGS_DEATHS ) + + if ( aVal < bVal ) + return -1 + else if ( aVal > bVal ) + return 1 + + return 0 +} + +int function CompareScavenger( entity a, entity b ) +{ + // 1) Ore Captured + int result = CompareAssault( a, b ) + if ( result != 0 ) + return result + + // 2) Pilot Kills + int aVal = a.GetPlayerGameStat( PGS_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + // 3) Titan Kills + aVal = a.GetPlayerGameStat( PGS_TITAN_KILLS ) + bVal = b.GetPlayerGameStat( PGS_TITAN_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + // 4) Deaths + aVal = a.GetPlayerGameStat( PGS_DEATHS ) + bVal = b.GetPlayerGameStat( PGS_DEATHS ) + + if ( aVal < bVal ) + return -1 + else if ( aVal > bVal ) + return 1 + + return 0 +} + +int function CompareFW( entity a, entity b ) +{ + // Capture Point sorting. Sort priority = assault + defense > pilot kills > titan kills > death + + { + int aVal = a.GetPlayerGameStat( PGS_ASSAULT_SCORE ) + int bVal = b.GetPlayerGameStat( PGS_ASSAULT_SCORE ) + + aVal += a.GetPlayerGameStat( PGS_DEFENSE_SCORE ) + bVal += b.GetPlayerGameStat( PGS_DEFENSE_SCORE ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + } + + // 3) Pilot Kills + { + int aVal = a.GetPlayerGameStat( PGS_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + } + + // 3) Titan Kills + { + int aVal = a.GetPlayerGameStat( PGS_TITAN_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_TITAN_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + } + + // 4) Deaths + { + int aVal = a.GetPlayerGameStat( PGS_DEATHS ) + int bVal = b.GetPlayerGameStat( PGS_DEATHS ) + + if ( aVal < bVal ) + return -1 + else if ( aVal > bVal ) + return 1 + } + + return 0 +} + +int function CompareHunter( entity a, entity b ) +{ + // Capture Point sorting. Sort priority = assault + defense > pilot kills > titan kills > death + + { + int aVal = a.GetPlayerGameStat( PGS_ASSAULT_SCORE ) + int bVal = b.GetPlayerGameStat( PGS_ASSAULT_SCORE ) + + aVal += a.GetPlayerGameStat( PGS_DEFENSE_SCORE ) + bVal += b.GetPlayerGameStat( PGS_DEFENSE_SCORE ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + } + + // 3) Pilot Kills + { + int aVal = a.GetPlayerGameStat( PGS_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + } + + // 3) Titan Kills + { + int aVal = a.GetPlayerGameStat( PGS_TITAN_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_TITAN_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + } + + // 4) Deaths + { + int aVal = a.GetPlayerGameStat( PGS_DEATHS ) + int bVal = b.GetPlayerGameStat( PGS_DEATHS ) + + if ( aVal < bVal ) + return -1 + else if ( aVal > bVal ) + return 1 + } + + return 0 +} + +// Sorts by kills, deaths and then cash +int function CompareATCOOP( entity a, entity b ) +{ + int aVal = a.GetPlayerGameStat( PGS_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + aVal = a.GetPlayerGameStat( PGS_DEATHS ) + bVal = b.GetPlayerGameStat( PGS_DEATHS ) + + if ( aVal > bVal ) + return 1 + else if ( aVal < bVal ) + return -1 + + aVal = a.GetPlayerGameStat( PGS_SCORE ) + bVal = b.GetPlayerGameStat( PGS_SCORE ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + return 0 +} + +int function CompareFD( entity a, entity b ) +{ + int aVal = a.GetPlayerGameStat( PGS_DETONATION_SCORE ) + int bVal = b.GetPlayerGameStat( PGS_DETONATION_SCORE ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + return 0 +} + +int function CompareTitanKills( entity a, entity b ) +{ + int aVal = a.GetPlayerGameStat( PGS_TITAN_KILLS ) + int bVal = b.GetPlayerGameStat( PGS_TITAN_KILLS ) + + if ( aVal < bVal ) + return 1 + else if ( aVal > bVal ) + return -1 + + return 0 +} + +bool function TitanEjectIsDisabled() +{ + return GetGlobalNetBool( "titanEjectEnabled" ) == false +} + +bool function IsHitEffectiveVsTitan( entity victim, int damageType ) +{ + Assert( victim.IsTitan() ) + + if ( victim.IsPlayer() ) + { + if ( PlayerHasPassive( victim, ePassives.PAS_BERSERKER ) ) + return false + } + + if ( !( damageType & DF_CRITICAL ) && ( damageType & DF_BULLET || damageType & DF_MAX_RANGE ) ) + return false + + return true +} + +bool function IsHitEffectiveVsNonTitan( entity victim, int damageType ) +{ + if ( damageType & DF_BULLET || damageType & DF_MAX_RANGE ) + return false; + + return true +} + +bool function IsPilot( entity ent ) +{ + if ( !IsValid( ent ) ) + return false + + if ( !ent.IsPlayer() ) + return false + + if ( ent.IsTitan() ) + return false + + return true +} + +bool function IsPilotDecoy( entity ent ) +{ + if ( !IsValid( ent ) ) + return false + + if ( ent.GetClassName() != "player_decoy" ) + return false + + return true +} + +string function HardpointIDToString( int id ) +{ + array<string> hardpointIDString = [ "a", "b", "c" ] + + Assert( id >= 0 && id < hardpointIDString.len() ) + + return hardpointIDString[ id ] +} + +string function Dev_TeamIDToString( id ) +{ + if ( id == TEAM_IMC ) + return "IMC" + if ( id == TEAM_MILITIA ) + return "MIL" + + return "UNASSIGNED/UNKNOWN TEAM NAME" +} + +array<entity> function ArrayWithin( array<entity> Array, vector origin, float maxDist ) +{ + float maxDistSqr = maxDist * maxDist + + array<entity> resultArray = [] + foreach ( ent in Array ) + { + float distSqr = DistanceSqr( origin, ent.GetOrigin() ) + if ( distSqr <= maxDistSqr ) + resultArray.append( ent ) + } + return resultArray +} + +function GetTitanChassis( entity titan ) +{ + if ( !("titanChassis" in titan.s ) ) + { + if ( HasSoul( titan ) ) + { + entity soul = titan.GetTitanSoul() + titan.s.titanChassis <- GetSoulTitanSubClass( soul ) + } + else + { + return "Invalid Chassis" + } + } + + return titan.s.titanChassis +} + +vector function ClampVectorToCube( vector vecStart, vector vec, vector cubeOrigin, float cubeSize ) +{ + float halfCubeSize = cubeSize * 0.5 + vector cubeMins = < -halfCubeSize, -halfCubeSize, -halfCubeSize > + vector cubeMaxs = < halfCubeSize, halfCubeSize, halfCubeSize > + + return ClampVectorToBox( vecStart, vec, cubeOrigin, cubeMins, cubeMaxs ) +} + +vector function ClampVectorToBox( vector vecStart, vector vec, vector cubeOrigin, vector cubeMins, vector cubeMaxs ) +{ + float smallestClampScale = 1.0 + vector vecEnd = vecStart + vec + + smallestClampScale = ClampVectorComponentToCubeMax( cubeOrigin.x, cubeMaxs.x, vecStart.x, vecEnd.x, vec.x, smallestClampScale ) + smallestClampScale = ClampVectorComponentToCubeMax( cubeOrigin.y, cubeMaxs.y, vecStart.y, vecEnd.y, vec.y, smallestClampScale ) + smallestClampScale = ClampVectorComponentToCubeMax( cubeOrigin.z, cubeMaxs.z, vecStart.z, vecEnd.z, vec.z, smallestClampScale ) + smallestClampScale = ClampVectorComponentToCubeMin( cubeOrigin.x, cubeMins.x, vecStart.x, vecEnd.x, vec.x, smallestClampScale ) + smallestClampScale = ClampVectorComponentToCubeMin( cubeOrigin.y, cubeMins.y, vecStart.y, vecEnd.y, vec.y, smallestClampScale ) + smallestClampScale = ClampVectorComponentToCubeMin( cubeOrigin.z, cubeMins.z, vecStart.z, vecEnd.z, vec.z, smallestClampScale ) + + return vec * smallestClampScale +} + +float function ClampVectorComponentToCubeMax( float cubeOrigin, float cubeSize, float vecStart, float vecEnd, float vec, float smallestClampScale ) +{ + float max = cubeOrigin + cubeSize + float clearance = fabs( vecStart - max ) + if ( vecEnd > max ) + { + float scale = fabs( clearance / ( ( vecStart + vec ) - vecStart ) ) + if ( scale > 0 && scale < smallestClampScale ) + return scale + } + + return smallestClampScale +} + +float function ClampVectorComponentToCubeMin( float cubeOrigin, float cubeSize, float vecStart, float vecEnd, float vec, float smallestClampScale ) +{ + float min = cubeOrigin - cubeSize + float clearance = fabs( min - vecStart ) + if ( vecEnd < min ) + { + float scale = fabs( clearance / ( ( vecStart + vec ) - vecStart ) ) + if ( scale > 0 && scale < smallestClampScale ) + return scale + } + + return smallestClampScale +} + +bool function PointInCapsule( vector vecBottom, vector vecTop, float radius, vector point ) +{ + return GetDistanceFromLineSegment( vecBottom, vecTop, point ) <= radius +} + +bool function PointInCylinder( vector vecBottom, vector vecTop, float radius, vector point ) +{ + if ( GetDistanceFromLineSegment( vecBottom, vecTop, point ) > radius ) + return false + + vector bottomVec = Normalize( vecTop - vecBottom ) + vector pointToBottom = Normalize( point - vecBottom ) + + vector topVec = Normalize( vecBottom - vecTop ) + vector pointToTop = Normalize( point - vecTop ) + + if ( DotProduct( bottomVec, pointToBottom ) < 0 ) + return false + + if ( DotProduct( topVec, pointToTop ) < 0.0 ) + return false + + return true +} + +float function AngleDiff( float ang, float targetAng ) +{ + float delta = ( targetAng - ang ) % 360.0 + if ( targetAng > ang ) + { + if ( delta >= 180.0 ) + delta -= 360.0; + } + else + { + if ( delta <= -180.0 ) + delta += 360.0; + } + return delta +} + + +float function ClampAngle( float ang ) +{ + while( ang > 360 ) + ang -= 360 + while( ang < 0 ) + ang += 360 + return ang +} + +float function ClampAngle180( float ang ) +{ + while( ang > 180 ) + ang -= 180 + while( ang < -180 ) + ang += 180 + return ang +} + +vector function ShortestRotation( vector ang, vector targetAng ) +{ + return Vector( AngleDiff( ang.x, targetAng.x ), AngleDiff( ang.y, targetAng.y ), AngleDiff( ang.z, targetAng.z ) ) +} + +int function GetWinningTeam() +{ + if ( level.nv.winningTeam != null ) + return expect int( level.nv.winningTeam ) + + if ( IsFFAGame() ) + return GetWinningTeam_FFA() + + if ( IsRoundBased() ) + { + if ( GameRules_GetTeamScore2( TEAM_IMC ) > GameRules_GetTeamScore2( TEAM_MILITIA ) ) + return TEAM_IMC + + if ( GameRules_GetTeamScore2( TEAM_MILITIA ) > GameRules_GetTeamScore2( TEAM_IMC ) ) + return TEAM_MILITIA + } + else + { + if ( GameRules_GetTeamScore( TEAM_IMC ) > GameRules_GetTeamScore( TEAM_MILITIA ) ) + return TEAM_IMC + + if ( GameRules_GetTeamScore( TEAM_MILITIA ) > GameRules_GetTeamScore( TEAM_IMC ) ) + return TEAM_MILITIA + } + + return TEAM_UNASSIGNED +} + +int function GetWinningTeam_FFA() +{ + if ( level.nv.winningTeam != null ) + return expect int( level.nv.winningTeam ) + + int maxScore = 0 + int playerTeam + int currentScore + int winningTeam = TEAM_UNASSIGNED + + foreach( player in GetPlayerArray() ) + { + playerTeam = player.GetTeam() + if ( IsRoundBased() ) + currentScore = GameRules_GetTeamScore2( playerTeam ) + else + currentScore = GameRules_GetTeamScore( playerTeam ) + + if ( currentScore == maxScore) //Treat multiple teams as having the same score as no team winning + winningTeam = TEAM_UNASSIGNED + + if ( currentScore > maxScore ) + { + maxScore = currentScore + winningTeam = playerTeam + } + } + + return winningTeam + +} + +void function EmitSkyboxSoundAtPosition( vector positionInSkybox, string sound, float skyboxScale = 0.001, bool clamp = false ) +{ + if ( IsServer() ) + clamp = true // sounds cannot play outside 16k limit on server + vector position = SkyboxToWorldPosition( positionInSkybox, skyboxScale, clamp ) + EmitSoundAtPosition( TEAM_UNASSIGNED, position, sound ) +} + +vector function SkyboxToWorldPosition( vector positionInSkybox, float skyboxScale = 0.001, bool clamp = true ) +{ + Assert( skyboxScale > 0 ) + Assert( "skyboxCamOrigin" in level ) + + vector position = Vector( 0.0, 0.0, 0.0 ) + vector skyOrigin = expect vector( level.skyboxCamOrigin ) + + #if CLIENT + position = ( positionInSkybox - skyOrigin ) * ( 1.0 / skyboxScale ) + + if ( clamp ) + { + entity localViewPlayer = GetLocalViewPlayer() + Assert( localViewPlayer ) + vector localViewPlayerOrg = localViewPlayer.GetOrigin() + + position = localViewPlayerOrg + ClampVectorToCube( localViewPlayerOrg, position - localViewPlayerOrg, Vector( 0.0, 0.0, 0.0 ), 32000.0 ) + } + #else + position = ( positionInSkybox - skyOrigin ) * ( 1.0 / skyboxScale ) + + if ( clamp ) + position = ClampVectorToCube( Vector( 0.0, 0.0, 0.0 ), position, Vector( 0.0, 0.0, 0.0 ), 32000.0 ) + #endif // CLIENT + + return position +} + +void function FadeOutSoundOnEntityAfterDelay( entity ent, string soundAlias, float delay, float fadeTime ) +{ + if ( !IsValid( ent ) ) + return + + ent.EndSignal( "OnDestroy" ) + wait delay + FadeOutSoundOnEntity( ent, soundAlias, fadeTime ) +} + +function GetRandomKeyFromWeightedTable( Table ) +{ + local weightTotal = 0.0 + foreach ( key, value in Table ) + { + weightTotal += value + } + + local randomValue = RandomFloat( weightTotal ) + + foreach ( key, value in Table ) + { + if ( randomValue <= weightTotal && randomValue >= weightTotal - value) + return key + weightTotal -= value + } +} + +bool function IsMatchOver() +{ + if ( IsRoundBased() && level.nv.gameEndTime ) + return true + else if ( !IsRoundBased() && level.nv.gameEndTime && Time() > level.nv.gameEndTime ) + return true + + return false +} + +bool function IsScoringNonStandard() +{ + return expect bool( level.nv.nonStandardScoring ) +} + +bool function IsRoundBased() +{ + return expect bool( level.nv.roundBased ) +} + +int function GetRoundsPlayed() +{ + return expect int( level.nv.roundsPlayed ) +} + +bool function IsEliminationBased() +{ + return Riff_EliminationMode() != eEliminationMode.Default +} + +bool function IsPilotEliminationBased() +{ + return ( Riff_EliminationMode() == eEliminationMode.Pilots || Riff_EliminationMode() == eEliminationMode.PilotsTitans ) +} + +bool function IsTitanEliminationBased() +{ + return ( Riff_EliminationMode() == eEliminationMode.Titans || Riff_EliminationMode() == eEliminationMode.PilotsTitans ) +} + +bool function IsSingleTeamMode() +{ + return ( 1 == GetCurrentPlaylistVarInt( "max_teams", 2 ) ) +} + +void function __WarpInEffectShared( vector origin, vector angles, string sfx, float preWaitOverride = -1.0 ) +{ + float preWait = 2.0 + float sfxWait = 0.1 + float totalTime = WARPINFXTIME + + if ( sfx == "" ) + sfx = "dropship_warpin" + + if ( preWaitOverride >= 0.0 ) + wait preWaitOverride + else + wait preWait //this needs to go and the const for warpin fx time needs to change - but not this game - the intro system is too dependent on it + + #if CLIENT + int fxIndex = GetParticleSystemIndex( FX_GUNSHIP_CRASH_EXPLOSION_ENTRANCE ) + StartParticleEffectInWorld( fxIndex, origin, angles ) + #else + entity fx = PlayFX( FX_GUNSHIP_CRASH_EXPLOSION_ENTRANCE, origin, angles ) + fx.FXEnableRenderAlways() + fx.DisableHibernation() + #endif // CLIENT + + wait sfxWait + EmitSoundAtPosition( TEAM_UNASSIGNED, origin, sfx ) + + wait totalTime - preWait - sfxWait +} + +void function __WarpOutEffectShared( entity dropship ) +{ + int attach = dropship.LookupAttachment( "origin" ) + vector origin = dropship.GetAttachmentOrigin( attach ) + vector angles = dropship.GetAttachmentAngles( attach ) + + #if CLIENT + int fxIndex = GetParticleSystemIndex( FX_GUNSHIP_CRASH_EXPLOSION_EXIT ) + StartParticleEffectInWorld( fxIndex, origin, angles ) + #else + entity fx = PlayFX( FX_GUNSHIP_CRASH_EXPLOSION_EXIT, origin, angles ) + fx.FXEnableRenderAlways() + fx.DisableHibernation() + #endif // CLIENT + + EmitSoundAtPosition( TEAM_UNASSIGNED, origin, "dropship_warpout" ) +} + +bool function IsSwitchSidesBased() +{ + return (level.nv.switchedSides != null) +} + +int function HasSwitchedSides() //This returns an int instead of a bool! Should rewrite +{ + return expect int( level.nv.switchedSides ) +} + +bool function IsFirstRoundAfterSwitchingSides() +{ + if ( !IsSwitchSidesBased() ) + return false + + if ( IsRoundBased() ) + return level.nv.switchedSides > 0 && GetRoundsPlayed() == level.nv.switchedSides + else + return level.nv.switchedSides > 0 + + unreachable +} + +void function CamBlendFov( entity cam, float oldFov, float newFov, float transTime, float transAccel, float transDecel ) +{ + if ( !IsValid( cam ) ) + return + + cam.EndSignal( "OnDestroy" ) + + float currentTime = Time() + float startTime = currentTime + float endTime = startTime + transTime + + while ( endTime > currentTime ) + { + float interp = Interpolate( startTime, endTime - startTime, transAccel, transDecel ) + cam.SetFOV( GraphCapped( interp, 0.0, 1.0, oldFov, newFov ) ) + wait( 0.0 ) + currentTime = Time() + } +} + +void function CamFollowEnt( entity cam, entity ent, float duration, vector offset = <0.0, 0.0, 0.0>, string attachment = "", bool isInSkybox = false ) +{ + if ( !IsValid( cam ) ) + return + + cam.EndSignal( "OnDestroy" ) + + vector camOrg = Vector( 0.0, 0.0, 0.0 ) + + vector targetPos = Vector( 0.0, 0.0, 0.0 ) + float currentTime = Time() + float startTime = currentTime + float endTime = startTime + duration + vector diff = Vector( 0.0, 0.0, 0.0 ) + int attachID = ent.LookupAttachment( attachment ) + + while ( endTime > currentTime ) + { + camOrg = cam.GetOrigin() + + if ( attachID <= 0 ) + targetPos = ent.GetOrigin() + else + targetPos = ent.GetAttachmentOrigin( attachID ) + + if ( isInSkybox ) + targetPos = SkyboxToWorldPosition( targetPos ) + diff = ( targetPos + offset ) - camOrg + + cam.SetAngles( VectorToAngles( diff ) ) + + wait( 0.0 ) + + currentTime = Time() + } +} + +void function CamFacePos( entity cam, vector pos, float duration ) +{ + if ( !IsValid( cam ) ) + return + + cam.EndSignal( "OnDestroy" ) + + float currentTime = Time() + float startTime = currentTime + float endTime = startTime + duration + vector diff = Vector( 0.0, 0.0, 0.0 ) + + while ( endTime > currentTime ) + { + diff = pos - cam.GetOrigin() + + cam.SetAngles( VectorToAngles( diff ) ) + + wait( 0.0 ) + + currentTime = Time() + } +} + +void function CamBlendFromFollowToAng( entity cam, entity ent, vector endAng, float transTime, float transAccel, float transDecel ) +{ + if ( !IsValid( cam ) ) + return + + cam.EndSignal( "OnDestroy" ) + + vector camOrg = cam.GetOrigin() + + float currentTime = Time() + float startTime = currentTime + float endTime = startTime + transTime + + while ( endTime > currentTime ) + { + vector diff = ent.GetOrigin() - camOrg + vector anglesToEnt = VectorToAngles( diff ) + + float frac = Interpolate( startTime, endTime - startTime, transAccel, transDecel ) + + vector newAngs = anglesToEnt + ShortestRotation( anglesToEnt, endAng ) * frac + + cam.SetAngles( newAngs ) + + wait( 0.0 ) + + currentTime = Time() + } +} + +void function CamBlendFromPosToPos( entity cam, vector startPos, vector endPos, float transTime, float transAccel, float transDecel ) +{ + if ( !IsValid( cam ) ) + return + + cam.EndSignal( "OnDestroy" ) + + float currentTime = Time() + float startTime = currentTime + float endTime = startTime + transTime + vector diff = endPos - startPos + + while ( endTime > currentTime ) + { + float frac = Interpolate( startTime, endTime - startTime, transAccel, transDecel ) + + vector newAngs = startPos + diff * frac + + cam.SetOrigin( newAngs ) + + wait( 0.0 ) + + currentTime = Time() + } +} + +void function CamBlendFromAngToAng( entity cam, vector startAng, vector endAng, float transTime, float transAccel, float transDecel ) +{ + if ( !IsValid( cam ) ) + return + + cam.EndSignal( "OnDestroy" ) + + float currentTime = Time() + float startTime = currentTime + float endTime = startTime + transTime + + while ( endTime > currentTime ) + { + float frac = Interpolate( startTime, endTime - startTime, transAccel, transDecel ) + + vector newAngs = startAng + ShortestRotation( startAng, endAng ) * frac + + cam.SetAngles( newAngs ) + + wait( 0.0 ) + + currentTime = Time() + } +} + +int function AddBitMask( int bitsExisting, int bitsToAdd ) +{ + return bitsExisting | bitsToAdd +} + +int function RemoveBitMask( int bitsExisting, int bitsToRemove ) +{ + return bitsExisting & ( ~bitsToRemove ) +} + +bool function HasBitMask( int bitsExisting, int bitsToCheck ) +{ + int bitsCommon = bitsExisting & bitsToCheck + return bitsCommon == bitsToCheck +} + +float function GetDeathCamLength( entity player ) +{ + if ( !GamePlayingOrSuddenDeath() ) + return DEATHCAM_TIME_SHORT + else + return DEATHCAM_TIME + + unreachable +} + +float function GetRespawnButtonCamTime( player ) +{ + if ( !GamePlayingOrSuddenDeath() ) + return DEATHCAM_TIME_SHORT + RESPAWN_BUTTON_BUFFER + else + return DEATHCAM_TIME + RESPAWN_BUTTON_BUFFER + + unreachable +} + +float function GetKillReplayAfterTime( player ) +{ + if ( IsSingleplayer() ) + return 4.0 + + if ( !GamePlayingOrSuddenDeath() ) + return KILL_REPLAY_AFTER_KILL_TIME_SHORT + + return KILL_REPLAY_AFTER_KILL_TIME +} + +function IntroPreviewOn() +{ + local bugnum = GetBugReproNum() + switch( bugnum ) + { + case 1337: + case 13371: + case 13372: + case 13373: + case 1338: + case 13381: + case 13382: + case 13383: + return bugnum + + default: + return null + } +} + +bool function EntHasModelSet( entity ent ) +{ + asset modelName = ent.GetModelName() + + if ( modelName == $"" || modelName == $"?" ) + return false + + return true +} + +string function GenerateTitanOSAlias( entity player, string aliasSuffix ) +{ + //HACK: Temp fix for blocker bug. Fixing correctly next. + if ( IsSingleplayer() ) + { + return "diag_gs_titanBt_" + aliasSuffix + } + else + { + entity titan + if ( player.IsTitan() ) + titan = player + else + titan = player.GetPetTitan() + + Assert( IsValid( titan ) ) + string titanCharacterName = GetTitanCharacterName( titan ) + string primeTitanString = "" + + if ( IsTitanPrimeTitan( titan ) ) + primeTitanString = "_prime" + + string modifiedAlias = "diag_gs_titan" + titanCharacterName + primeTitanString + "_" + aliasSuffix + return modifiedAlias + } + unreachable +} + +void function AddCallback_OnUseEntity( entity ent, callbackFunc ) +{ + AssertParameters( callbackFunc, 2, "ent, player" ) + + if ( !( "onUseEntityCallbacks" in ent.s ) ) + ent.s.onUseEntityCallbacks <- [] + + Assert( !ent.s.onUseEntityCallbacks.contains( callbackFunc ), "Already added " + FunctionToString( callbackFunc ) + " with AddCalback_OnUseEntity" ) + ent.s.onUseEntityCallbacks.append( callbackFunc ) +} + +void function SetWaveSpawnType( int spawnType ) +{ + shGlobal.waveSpawnType = spawnType +} + +int function GetWaveSpawnType() +{ + return shGlobal.waveSpawnType +} + +void function SetWaveSpawnInterval( float interval ) +{ + shGlobal.waveSpawnInterval = interval +} + +float function GetWaveSpawnInterval() +{ + return shGlobal.waveSpawnInterval +} + +bool function IsArcTitan( entity npc ) +{ + return npc.GetAISettingsName() == "npc_titan_arc" +} + +bool function IsNukeTitan( entity npc ) +{ + return npc.GetAISettingsName() == "npc_titan_nuke" +} + +bool function IsMortarTitan( entity npc ) +{ + return npc.GetAISettingsName() == "npc_titan_mortar" +} + +bool function IsFragDrone( entity npc ) +{ + #if SERVER + return npc.GetClassName() == "npc_frag_drone" + #endif + + #if CLIENT + return npc.GetSignifierName() == "npc_frag_drone" + #endif +} + +bool function IsSniperSpectre( entity npc ) +{ + return false +} + +bool function IsVortexSphere( entity ent ) +{ + return ( ent.GetClassName() == "vortex_sphere" ) +} + +bool function PointIsWithinBounds( vector point, vector mins, vector maxs ) +{ + Assert( mins.x < maxs.x ) + Assert( mins.y < maxs.y ) + Assert( mins.z < maxs.z ) + + return ( ( point.z >= mins.z && point.z <= maxs.z ) && + ( point.x >= mins.x && point.x <= maxs.x ) && + ( point.y >= mins.y && point.y <= maxs.y ) ) +} + +int function GetSpStartIndex() +{ + //HACK -> this should use some other code driven thing, not GetBugReproNum + int index = GetBugReproNum() + + if ( index < 0 ) + return 0 + + return index +} + +// return all living soldiers +array<entity> function GetAllSoldiers() +{ + return GetNPCArrayByClass( "npc_soldier" ) +} + +int function GameTeams_GetNumLivingPlayers( int teamIndex = TEAM_ANY ) +{ + int noOfLivingPlayers = 0 + + array<entity> players + if ( teamIndex == TEAM_ANY ) + players = GetPlayerArray() + else + players = GetPlayerArrayOfTeam( teamIndex ) + + foreach ( player in players ) + { + if ( !IsAlive( player ) ) + continue + + ++noOfLivingPlayers + } + + return noOfLivingPlayers +} + +bool function GameTeams_TeamHasDeadPlayers( int team ) +{ + array<entity> teamPlayers = GetPlayerArrayOfTeam( team ) + foreach ( entity teamPlayer in teamPlayers ) + { + if ( !IsAlive( teamPlayer ) ) + return true + } + return false +} + +typedef EntitiesDidLoadCallbackType void functionref() +array<EntitiesDidLoadCallbackType> _EntitiesDidLoadTypedCallbacks + +void function RunCallbacks_EntitiesDidLoad() +{ + // reloading the level so don't do callbacks + if ( "forcedReloading" in level ) + return + + foreach ( callback in _EntitiesDidLoadTypedCallbacks ) + { + thread callback() + } +} + +void function AddCallback_EntitiesDidLoad( EntitiesDidLoadCallbackType callback ) +{ + _EntitiesDidLoadTypedCallbacks.append( callback ) +} + +bool function IsTitanNPC( entity ent ) +{ + return ent.IsTitan() && ent.IsNPC() +} + +entity function InflictorOwner( entity inflictor ) +{ + if ( IsValid( inflictor ) ) + { + entity inflictorOwner = inflictor.GetOwner() + if ( IsValid( inflictorOwner ) ) + inflictor = inflictorOwner + } + + return inflictor +} + +bool function IsPlayerControlledSpectre( entity ent ) +{ + return ent.GetClassName() == "npc_spectre" && ent.GetBossPlayer() != null +} + +bool function IsPlayerControlledTurret( entity ent ) +{ + return IsTurret( ent ) && ent.GetBossPlayer() != null +} + +bool function TitanShieldDecayEnabled() +{ + return ( GetCurrentPlaylistVarInt( "titan_shield_decay", 0 ) == 1 ) +} + +bool function TitanShieldRegenEnabled() +{ + return ( GetCurrentPlaylistVarInt( "titan_shield_regen", 0 ) == 1 ) +} + +bool function DoomStateDisabled() +{ + return ( GetCurrentPlaylistVarString( "titan_doomstate_variation", "default" ) == "disabled" || GetCurrentPlaylistVarString( "titan_doomstate_variation", "default" ) == "lastsegment" ) +} + +bool function NoWeaponDoomState() +{ + return ( GetCurrentPlaylistVarString( "titan_doomstate_variation", "default" ) == "noweapon" ) +} + +entity function GetPetTitanOwner( entity titan ) +{ + array<entity> players = GetPlayerArray() + entity foundPlayer + foreach ( player in players ) + { + if ( player.GetPetTitan() == titan ) + { + Assert( foundPlayer == null, player + " and " + foundPlayer + " both own " + titan ) + foundPlayer = player + } + } + + return foundPlayer +} + +entity function GetSoulFromPlayer( entity player ) +{ + Assert( player.IsPlayer(), "argument should be a player" ) + + if ( player.IsTitan() ) + return player.GetTitanSoul() + else if ( IsValid( player.GetPetTitan() ) ) + return player.GetPetTitan().GetTitanSoul() + + return null +} + +string function GetPlayerBodyType( player ) +{ + return expect string( player.GetPlayerSettingsField( "weaponClass" ) ) +} + + +void function SetTeam( entity ent, int team ) +{ + #if CLIENT + ent.Code_SetTeam( team ) + #else + if ( ent.IsPlayer() ) + { + ent.Code_SetTeam( team ) + } + else if ( ent.IsNPC() ) + { + int currentTeam = ent.GetTeam() + bool alreadyAssignedValidTeam = ( currentTeam == TEAM_IMC || currentTeam == TEAM_MILITIA ) + + ent.Code_SetTeam( team ) + + if ( ent.GetModelName() == $"" ) + return + + FixupTitle( ent ) + + if ( IsGrunt( ent ) || IsSpectre( ent ) ) + { + if ( IsMultiplayer() ) + { + int eHandle = ent.GetEncodedEHandle() + + array<entity> players = GetPlayerArray() + foreach ( player in players ) + { + Remote_CallFunction_Replay( player, "ServerCallback_UpdateOverheadIconForNPC", eHandle ) + } + } + } + else if ( IsShieldDrone( ent ) ) + { + if ( team == 0 ) + { + // anybody can use neutral shield drone + ent.SetUsable() + } + else + { + // only friendlies use a team shield drone + ent.SetUsableByGroup( "friendlies pilot" ) + } + } + + table modelTable = ent.CreateTableFromModelKeyValues() + + if ( !( "teamSkin" in modelTable ) ) + return + + if ( alreadyAssignedValidTeam && ( !( "swapTeamOnLeech" in modelTable.teamSkin ) ) ) + return + + SetSkinForTeam( ent, team ) + } + else + { + ent.Code_SetTeam( team ) + } + #endif +} + +void function PrintTraceResults( TraceResults results ) +{ + printt( "TraceResults: " ) + printt( "=========================" ) + printt( "hitEnt: " + results.hitEnt ) + printt( "endPos: " + results.endPos ) + printt( "surfaceNormal: " + results.surfaceNormal ) + printt( "surfaceName: " + results.surfaceName ) + printt( "fraction: " + results.fraction ) + printt( "fractionLeftSolid: " + results.fractionLeftSolid ) + printt( "hitGroup: " + results.hitGroup ) + printt( "startSolid: " + results.startSolid ) + printt( "allSolid: " + results.allSolid ) + printt( "hitSky: " + results.hitSky ) + printt( "contents: " + results.contents ) + printt( "=========================" ) +} + +bool function PROTO_AlternateDoomedState() +{ + return ( GetCurrentPlaylistVarInt( "infinite_doomed_state", 1 ) == 1 ) +} + +bool function PROTO_VariableRegenDelay() +{ + return ( GetCurrentPlaylistVarInt( "variable_regen_delay", 1 ) == 1 ) +} + +bool function PROTO_AutoTitansDisabled() +{ + return ( GetCurrentPlaylistVarInt( "always_enable_autotitans", 1 ) == 0 ) +} + +bool function TitanDamageRewardsTitanCoreTime() +{ + if ( GetCurrentPlaylistVarInt( "titan_core_from_titan_damage", 0 ) != 0 ) + return true + return false +} + +vector function ClampToMap( vector pos ) +{ + return IterateAxis( pos, LimitAxisToMapExtents ) +} + +vector function IterateAxis( vector pos, float functionref( float ) func ) +{ + pos.x = func( pos.x ) + pos.y = func( pos.y ) + pos.z = func( pos.z ) + return pos +} + +float function LimitAxisToMapExtents( float axisVal ) +{ + if ( axisVal >= MAP_EXTENTS ) + axisVal = MAP_EXTENTS - 1 + else if ( axisVal <= -MAP_EXTENTS ) + axisVal = -( MAP_EXTENTS - 1 ) + return axisVal +} + +bool function PilotSpawnOntoTitanIsEnabledInPlaylist( entity player ) +{ + if ( GetCurrentPlaylistVarInt( "titan_spawn_deploy_enabled", 0 ) != 0 ) + return true + return false +} + +bool function PlayerCanSpawnIntoTitan( entity player ) +{ + if ( !PilotSpawnOntoTitanIsEnabledInPlaylist( player ) ) + return false + + entity titan = player.GetPetTitan() + + if ( !IsAlive( titan ) ) + return false + + if ( GetDoomedState( titan ) ) + return false + + if ( titan.ContextAction_IsActive() ) + return false + + return false // turned off until todd figures out how to enable +} + +array< vector > function EntitiesToOrigins( array< entity > ents ) +{ + array<vector> origins + + foreach ( ent in ents ) + { + origins.append( ent.GetOrigin() ) + } + + return origins +} + +vector function GetMedianOriginOfEntities( array<entity> ents ) +{ + array<vector> origins = EntitiesToOrigins( ents ) + return GetMedianOrigin( origins ) +} + +vector function GetMedianOrigin( array<vector> origins ) +{ + if ( origins.len() == 1 ) + return origins[0] + + vector median + + int middleIndex1 + int middleIndex2 + + if ( IsEven( origins.len() ) ) + { + middleIndex1 = origins.len() / 2 + middleIndex2 = middleIndex1 + } + else + { + middleIndex1 = int( floor( origins.len() / 2.0 ) ) + middleIndex2 = middleIndex1 + 1 + } + + origins.sort( CompareVecX ) + median.x = ( origins[ middleIndex1 ].x + origins[ middleIndex2 ].x ) / 2.0 + + origins.sort( CompareVecY ) + median.y = ( origins[ middleIndex1 ].y + origins[ middleIndex2 ].y ) / 2.0 + + origins.sort( CompareVecZ ) + median.z = ( origins[ middleIndex1 ].z + origins[ middleIndex2 ].z ) / 2.0 + + return median +} + +int function CompareVecX( vector a, vector b ) +{ + if ( a.x > b.x ) + return 1 + + return -1 +} + +int function CompareVecY( vector a, vector b ) +{ + if ( a.y > b.y ) + return 1 + + return -1 +} + +int function CompareVecZ( vector a, vector b ) +{ + if ( a.z > b.z ) + return 1 + + return -1 +} + +float function GetFractionAlongPath( array<entity> nodes, vector p ) +{ + float totalDistance = GetPathDistance( nodes ) + + // See which segment we are currently on (closest to) + int closestSegment = -1 + float closestDist = 9999 + for( int i = 0 ; i < nodes.len() - 1; i++ ) + { + float dist = GetDistanceSqrFromLineSegment( nodes[i].GetOrigin(), nodes[i + 1].GetOrigin(), p ) + if ( closestSegment < 0 || dist < closestDist ) + { + closestSegment = i + closestDist = dist + } + } + Assert( closestSegment >= 0 ) + Assert( closestSegment < nodes.len() - 1 ) + + // Get the distance along the path already traveled + float distTraveled = 0.0 + for( int i = 0 ; i < closestSegment; i++ ) + { + //DebugDrawLine( nodes[i].GetOrigin(), nodes[i + 1].GetOrigin(), 255, 255, 0, true, 0.1 ) + distTraveled += Distance( nodes[i].GetOrigin(), nodes[i+1].GetOrigin() ) + } + + // Add the distance traveled on current segment + vector closestPointOnSegment = GetClosestPointOnLineSegment( nodes[closestSegment].GetOrigin(), nodes[closestSegment + 1].GetOrigin(), p ) + //DebugDrawLine( nodes[closestSegment].GetOrigin(), closestPointOnSegment, 255, 255, 0, true, 0.1 ) + distTraveled += Distance( nodes[closestSegment].GetOrigin(), closestPointOnSegment ) + + return clamp( distTraveled / totalDistance, 0.0, 1.0 ) +} + +float function GetPathDistance( array<entity> nodes ) +{ + float totalDist = 0.0 + for( int i = 0 ; i < nodes.len() - 1; i++ ) + { + //DebugDrawSphere( nodes[i].GetOrigin(), 16.0, 255, 0, 0, true, 0.1 ) + totalDist += Distance( nodes[i].GetOrigin(), nodes[i+1].GetOrigin() ) + } + //DebugDrawSphere( nodes[nodes.len() -1].GetOrigin(), 16.0, 255, 0, 0, true, 0.1 ) + + return totalDist +} + +void function WaittillAnimDone( entity animatingEnt ) +{ + waitthread WaittillAnimDone_Thread( animatingEnt ) +} + +void function WaittillAnimDone_Thread( entity animatingEnt ) +{ + if ( animatingEnt.IsPlayer() ) + animatingEnt.EndSignal( "OnDestroy" ) + + animatingEnt.EndSignal( "OnAnimationInterrupted" ) + animatingEnt.WaitSignal( "OnAnimationDone" ) +} + +array<entity> function GetEntityLinkChain( entity startNode ) +{ + Assert( IsValid( startNode ) ) + array<entity> nodes + nodes.append( startNode ) + while(true) + { + entity nextNode = nodes[nodes.len() - 1].GetLinkEnt() + if ( !IsValid( nextNode ) ) + break + nodes.append( nextNode ) + } + return nodes +} + +float function HealthRatio( entity ent ) +{ + int health = ent.GetHealth() + int maxHealth = ent.GetMaxHealth() + return float( health ) / maxHealth +} + +vector function GetPointOnPathForFraction( array<entity> nodes, float frac ) +{ + Assert( frac >= 0 ) + + float totalPathDist = GetPathDistance( nodes ) + float distRemaining = totalPathDist * frac + vector point = nodes[0].GetOrigin() + + for( int i = 0 ; i < nodes.len() - 1; i++ ) + { + float segmentDist = Distance( nodes[i].GetOrigin(), nodes[i+1].GetOrigin() ) + if ( segmentDist <= distRemaining ) + { + // Add the whole segment + distRemaining -= segmentDist + point = nodes[i+1].GetOrigin() + } + else + { + // Fraction ends somewhere in this segment + vector dirVec = Normalize( nodes[i+1].GetOrigin() - nodes[i].GetOrigin() ) + point = nodes[i].GetOrigin() + ( dirVec * distRemaining ) + distRemaining = 0 + } + if ( distRemaining <= 0 ) + break + } + + if ( frac > 1.0 && distRemaining > 0 ) + { + vector dirVec = Normalize( nodes[nodes.len() - 1].GetOrigin() - nodes[nodes.len() - 2].GetOrigin() ) + point = nodes[nodes.len() - 1].GetOrigin() + ( dirVec * distRemaining ) + } + + return point +} + +bool function PlayerBlockedByTeamEMP( entity player ) +{ + return ( player.nv.empEndTime > Time() ) +} + +#if SERVER +void function Embark_Allow( entity player ) +{ + player.SetTitanEmbarkEnabled( true ) +} + +void function Embark_Disallow( entity player ) +{ + player.SetTitanEmbarkEnabled( false ) +} + +void function Disembark_Allow( entity player ) +{ + player.SetTitanDisembarkEnabled( true ) +} + +void function Disembark_Disallow( entity player ) +{ + player.SetTitanDisembarkEnabled( false ) +} +#endif + +bool function CanEmbark( entity player ) +{ + return player.GetTitanEmbarkEnabled() +} + +bool function CanDisembark( entity player ) +{ + return player.GetTitanDisembarkEnabled() +} + +string function GetDroneType( entity npc ) +{ + return expect string( npc.Dev_GetAISettingByKeyField( "drone_type" ) ) +} + +vector function FlattenVector( vector vec ) +{ + return Vector( vec.x, vec.y, 0 ) +} + +vector function FlattenAngles( vector angles ) +{ + return Vector( 0, angles.y, 0 ) +} + +bool function IsHumanSized( entity ent ) +{ + if ( ent.IsPlayer() ) + return ent.IsHuman() + + if ( ent.IsNPC() ) + { + + if ( ent.GetAIClass() == AIC_SMALL_TURRET ) + return true + + string bodyType = ent.GetBodyType() + return bodyType == "human" || bodyType == "marvin" + } + + return false +} + +bool function IsDropship( entity ent ) +{ +#if SERVER + return ent.GetClassName() == "npc_dropship" +#elseif CLIENT + if ( !ent.IsNPC() ) + return false + //Probably should not use GetClassName, but npc_dropship isn't a class so can't use instanceof? + return ( ent.GetClassName() == "npc_dropship" || ent.GetSignifierName() == "npc_dropship" ) +#endif +} + +bool function IsSpecialist( entity ent ) +{ + return IsGrunt( ent ) && ent.IsMechanical() +} + +bool function IsGrunt( entity ent ) +{ +#if SERVER + return ent.IsNPC() && ent.GetClassName() == "npc_soldier" +#elseif CLIENT + return ent.IsNPC() && ent.GetSignifierName() == "npc_soldier" +#endif +} + +bool function IsMarvin( entity ent ) +{ + return ent.IsNPC() && ent.GetAIClass() == AIC_MARVIN +} + +bool function IsSpectre( entity ent ) +{ + return ent.IsNPC() && ent.GetAIClass() == AIC_SPECTRE +} + +bool function IsWorldSpawn( entity ent ) +{ + #if SERVER + return ent.GetClassName() == "worldspawn" + #elseif CLIENT + return ent.GetSignifierName() == "worldspawn" + #endif +} + +bool function IsEnvironment( entity ent ) +{ + #if SERVER + return ent.GetClassName() == "trigger_hurt" + #elseif CLIENT + return ent.GetSignifierName() == "trigger_hurt" + #endif +} + +bool function IsSuperSpectre( entity ent ) +{ +#if SERVER + return ent.GetClassName() == "npc_super_spectre" +#elseif CLIENT + return ent.GetSignifierName() == "npc_super_spectre" +#endif +} + +bool function IsAndroidNPC( entity ent ) +{ + return ( IsSpectre( ent ) || IsStalker( ent ) || IsMarvin( ent ) ) +} + +bool function IsStalker( entity ent ) +{ + return ent.IsNPC() && ( ent.GetAIClass() == AIC_STALKER || ent.GetAIClass() == AIC_STALKER_CRAWLING ) +} + +bool function IsProwler( entity ent ) +{ +#if SERVER + return ent.GetClassName() == "npc_prowler" +#elseif CLIENT + return ent.GetSignifierName() == "npc_prowler" +#endif +} + +bool function IsAirDrone( entity ent ) +{ +#if SERVER + return ent.GetClassName() == "npc_drone" +#elseif CLIENT + return ent.GetSignifierName() == "npc_drone" +#endif +} + +bool function IsPilotElite( entity ent ) +{ +#if SERVER + return ent.GetClassName() == "npc_pilot_elite" +#elseif CLIENT + return ent.GetSignifierName() == "npc_pilot_elite" +#endif +} + +bool function IsAttackDrone( entity ent ) +{ + return ( ent.IsNPC() && !ent.IsNonCombatAI() && IsAirDrone( ent ) ) +} + +bool function IsGunship( entity ent ) +{ +#if SERVER + return ent.GetClassName() == "npc_gunship" +#elseif CLIENT + return ent.GetSignifierName() == "npc_gunship" +#endif +} + +bool function IsMinion( entity ent ) +{ + if ( IsGrunt( ent ) ) + return true + + if ( IsSpectre( ent ) ) + return true + + return false +} + +bool function IsShieldDrone( entity ent ) +{ +#if SERVER + if ( ent.GetClassName() != "npc_drone" ) + return false +#elseif CLIENT + if ( ent.GetSignifierName() != "npc_drone" ) + return false +#endif + + return GetDroneType( ent ) == "drone_type_shield" +} + +#if SERVER +bool function IsTick( entity ent ) +{ + return (ent.IsNPC() && (ent.GetAIClass() == AIC_FRAG_DRONE)) +} + +bool function IsNPCTitan( entity ent ) +{ + return ent.IsNPC() && ent.IsTitan() +} +#endif + +bool function NPC_GruntChatterSPEnabled( entity npc ) +{ + if ( !IsSingleplayer() ) + return false + + if ( !npc.IsNPC() ) + return false + + if ( npc.GetClassName() != "npc_soldier" ) + return false + + return true +} + +RaySphereIntersectStruct function IntersectRayWithSphere( vector rayStart, vector rayEnd, vector sphereOrigin, float sphereRadius ) +{ + RaySphereIntersectStruct intersection + + vector vecSphereToRay = rayStart - sphereOrigin + + vector vecRayDelta = rayEnd - rayStart + float a = DotProduct( vecRayDelta, vecRayDelta ) + + if ( a == 0.0 ) + { + intersection.result = LengthSqr( vecSphereToRay ) <= sphereRadius * sphereRadius + intersection.enterFrac = 0.0 + intersection.leaveFrac = 0.0 + return intersection + } + + float b = 2 * DotProduct( vecSphereToRay, vecRayDelta ) + float c = DotProduct( vecSphereToRay, vecSphereToRay ) - sphereRadius * sphereRadius + float discrim = b * b - 4 * a * c + if ( discrim < 0.0 ) + { + intersection.result = false + return intersection + } + + discrim = sqrt( discrim ) + float oo2a = 0.5 / a + intersection.enterFrac = ( - b - discrim ) * oo2a + intersection.leaveFrac = ( - b + discrim ) * oo2a + + if ( ( intersection.enterFrac > 1.0 ) || ( intersection.leaveFrac < 0.0 ) ) + { + intersection.result = false + return intersection + } + + if ( intersection.enterFrac < 0.0 ) + intersection.enterFrac = 0.0 + if ( intersection.leaveFrac > 1.0 ) + intersection.leaveFrac = 1.0 + + intersection.result = true + return intersection +} + +table function GetTableFromString( string inString ) +{ + if ( inString.len() > 0 ) + return expect table( getconsttable()[ inString ] ) + + return {} +} + +int function GetWeaponDamageNear( entity weapon, entity victim ) +{ + entity weaponOwner = weapon.GetWeaponOwner() + if ( weaponOwner.IsNPC() ) + { + if ( victim.GetArmorType() == ARMOR_TYPE_HEAVY ) + return weapon.GetWeaponSettingInt( eWeaponVar.npc_damage_near_value_titanarmor ) + else + return weapon.GetWeaponSettingInt( eWeaponVar.npc_damage_near_value ) + } + else + { + if ( victim.GetArmorType() == ARMOR_TYPE_HEAVY ) + return weapon.GetWeaponSettingInt( eWeaponVar.damage_near_value_titanarmor ) + else + return weapon.GetWeaponSettingInt( eWeaponVar.damage_near_value ) + } + + unreachable +} + +void function PrintFirstPersonSequenceStruct( FirstPersonSequenceStruct fpsStruct ) +{ + printt( "Printing FirstPersonSequenceStruct:" ) + + printt( "firstPersonAnim: " + fpsStruct.firstPersonAnim ) + printt( "thirdPersonAnim: " + fpsStruct.thirdPersonAnim ) + printt( "firstPersonAnimIdle: " + fpsStruct.firstPersonAnimIdle ) + printt( "thirdPersonAnimIdle: " + fpsStruct.thirdPersonAnimIdle ) + printt( "relativeAnim: " + fpsStruct.relativeAnim ) + printt( "attachment: " + fpsStruct.attachment ) + printt( "teleport: " + fpsStruct.teleport ) + printt( "noParent: " + fpsStruct.noParent ) + printt( "blendTime: " + fpsStruct.blendTime ) + printt( "noViewLerp: " + fpsStruct.noViewLerp ) + printt( "hideProxy: " + fpsStruct.hideProxy ) + printt( "viewConeFunction: " + string( fpsStruct.viewConeFunction ) ) + printt( "origin: " + string( fpsStruct.origin ) ) + printt( "angles: " + string ( fpsStruct.angles ) ) + printt( "enablePlanting: " + fpsStruct.enablePlanting ) + printt( "setInitialTime: " + fpsStruct.setInitialTime ) + printt( "useAnimatedRefAttachment: " + fpsStruct.useAnimatedRefAttachment ) + printt( "renderWithViewModels: " + fpsStruct.renderWithViewModels ) + printt( "gravity: " + fpsStruct.gravity ) + +} + +void function WaitSignalOrTimeout( entity ent, float timeout, string signal1, string signal2 = "", string signal3 = "" ) +{ + Assert( IsValid( ent ) ) + + ent.EndSignal( signal1 ) + + if ( signal2 != "" ) + ent.EndSignal( signal2 ) + + if ( signal3 != "" ) + ent.EndSignal( signal3 ) + + wait( timeout ) +} + +array<vector> function GetShortestLineSegmentConnectingLineSegments( vector line1Point1, vector line1Point2, vector line2Point1, vector line2Point2 ) +{ + // From Paul Bourke's algorithm "The shortest line between two lines in 3D" at http://paulbourke.net/geometry/pointlineplane/ + + vector p1 = line1Point1 + vector p2 = line1Point2 + vector p3 = line2Point1 + vector p4 = line2Point2 + vector p13 = p1 - p3 + vector p21 = p2 - p1 + vector p43 = p4 - p3 + + if ( Length( p43 ) < 1.0 ) + { + array<vector> resultVectors + resultVectors.append( p4 ) + resultVectors.append( p3 ) + return resultVectors + } + + if ( Length( p21 ) < 1.0 ) + { + array<vector> resultVectors + resultVectors.append( p2 ) + resultVectors.append( p1 ) + return resultVectors + } + + float d1343 = p13.x * p43.x + p13.y * p43.y + p13.z * p43.z + float d4321 = p43.x * p21.x + p43.y * p21.y + p43.z * p21.z + float d1321 = p13.x * p21.x + p13.y * p21.y + p13.z * p21.z + float d4343 = p43.x * p43.x + p43.y * p43.y + p43.z * p43.z + float d2121 = p21.x * p21.x + p21.y * p21.y + p21.z * p21.z + + + float denom = d2121 * d4343 - d4321 * d4321 + Assert( fabs( denom ) > 0.01 ) + float numer = d1343 * d4321 - d1321 * d4343 + + float mua = numer / denom + float mub = (d1343 + d4321 * (mua)) / d4343 + + vector resultVec1 + vector resultVec2 + resultVec1.x = p1.x + mua * p21.x + resultVec1.y = p1.y + mua * p21.y + resultVec1.z = p1.z + mua * p21.z + resultVec2.x = p3.x + mub * p43.x + resultVec2.y = p3.y + mub * p43.y + resultVec2.z = p3.z + mub * p43.z + + array<vector> resultVectors + resultVectors.append( resultVec1 ) + resultVectors.append( resultVec2 ) + return resultVectors +} + +vector function GetClosestPointToLineSegments( vector line1Point1, vector line1Point2, vector line2Point1, vector line2Point2 ) +{ + array<vector> results = GetShortestLineSegmentConnectingLineSegments( line1Point1, line1Point2, line2Point1, line2Point2 ) + Assert( results.len() == 2 ) + return ( results[0] + results[1] ) / 2.0 +} + + +bool function PlayerCanSee( entity player, entity ent, bool doTrace, float degrees ) +{ + float minDot = deg_cos( degrees ) + + // On screen? + float dot = DotProduct( Normalize( ent.GetWorldSpaceCenter() - player.EyePosition() ), player.GetViewVector() ) + if ( dot < minDot ) + return false + + // Can trace to it? + if ( doTrace ) + { + TraceResults trace = TraceLine( player.EyePosition(), ent.GetWorldSpaceCenter(), null, TRACE_MASK_BLOCKLOS, TRACE_COLLISION_GROUP_NONE ) + if ( trace.hitEnt == ent || trace.fraction >= 0.99 ) + return true + else + return false + } + else + return true + + Assert( 0, "shouldn't ever get here") + unreachable +} + +bool function PlayerCanSeePos( entity player, vector pos, bool doTrace, float degrees ) +{ + float minDot = deg_cos( degrees ) + float dot = DotProduct( Normalize( pos - player.EyePosition() ), player.GetViewVector() ) + if ( dot < minDot ) + return false + + if ( doTrace ) + { + TraceResults trace = TraceLine( player.EyePosition(), pos, null, TRACE_MASK_BLOCKLOS, TRACE_COLLISION_GROUP_NONE ) + if ( trace.fraction < 0.99 ) + return false + } + + return true +} + +bool function VectorsFacingSameDirection( vector v1, vector v2, float degreesThreshold ) +{ + float minDot = deg_cos( degreesThreshold ) + float dot = DotProduct( Normalize( v1 ), Normalize( v2 ) ) + return ( dot >= minDot ) +} + +vector function GetRelativeDelta( vector origin, entity ref, string attachment = "" ) +{ + vector pos + vector right + vector forward + vector up + + if ( attachment != "" ) + { + int attachID = ref.LookupAttachment( attachment ) + pos = ref.GetAttachmentOrigin( attachID ) + vector angles = ref.GetAttachmentAngles( attachID ) + right = AnglesToRight( angles ) + forward = AnglesToForward( angles ) + up = AnglesToUp( angles ) + } + else + { + pos = ref.GetOrigin() + right = ref.GetRightVector() + forward = ref.GetForwardVector() + up = ref.GetUpVector() + } + + vector x = GetClosestPointOnLineSegment( pos + right * -16384, pos + right * 16384, origin ) + vector y = GetClosestPointOnLineSegment( pos + forward * -16384, pos + forward * 16384, origin ) + vector z = GetClosestPointOnLineSegment( pos + up * -16384, pos + up * 16384, origin ) + + float distx = Distance(pos, x) + float disty = Distance(pos, y) + float distz = Distance(pos, z) + + if ( DotProduct( x - pos, right ) < 0 ) + distx *= -1 + if ( DotProduct( y - pos, forward ) < 0 ) + disty *= -1 + if ( DotProduct( z - pos, up ) < 0 ) + distz *= -1 + + return Vector( distx, disty, distz ) +} + +#if SERVER +float function GetRoundTimeLimit_ForGameMode() +{ + #if DEV + if ( level.devForcedTimeLimit ) + { + //Make it needed to be called multiple times for RoundBasedGameModes + level.devForcedTimeLimit = 0 + return 0.1 + } + #endif + + #if MP + if ( GameState_GetTimeLimitOverride() >= 0 ) + return GameState_GetTimeLimitOverride() + #endif + + if ( !GameMode_IsDefined( GAMETYPE ) ) + return GetCurrentPlaylistVarFloat( "roundtimelimit", 10 ) + else + return GameMode_GetRoundTimeLimit( GAMETYPE ) + + unreachable +} +#endif + +bool function HasIronRules() +{ + bool result = (GetCurrentPlaylistVarInt( "iron_rules", 0 ) != 0) + return result +} + +vector function GetWorldOriginFromRelativeDelta( vector delta, entity ref ) +{ + vector right = ref.GetRightVector() * delta.x + vector forward = ref.GetForwardVector() * delta.y + vector up = ref.GetUpVector() * delta.z + + return ref.GetOrigin() + right + forward + up +} + +bool function IsHardcoreGameMode() +{ + return GetCurrentPlaylistVarInt( "gm_hardcore_settings", 0 ) == 1 +} + +bool function PlayerHasWeapon( entity player, string weaponName ) +{ + array<entity> weapons = player.GetMainWeapons() + weapons.extend( player.GetOffhandWeapons() ) + + foreach ( weapon in weapons ) + { + if ( weapon.GetWeaponClassName() == weaponName ) + return true + } + + return false +} + +bool function PlayerCanUseWeapon( entity player, string weaponClass ) +{ + return ( ( player.IsTitan() && weaponClass == "titan" ) || ( !player.IsTitan() && weaponClass == "human" ) ) +} + +string function GetTitanCharacterName( entity titan ) +{ + Assert( titan.IsTitan() ) + + string setFile + + if ( titan.IsPlayer() ) + { + setFile = titan.GetPlayerSettings() + } + else + { + string aiSettingsFile = titan.GetAISettingsName() + setFile = expect string( Dev_GetAISettingByKeyField_Global( aiSettingsFile, "npc_titan_player_settings" ) ) + } + + return GetTitanCharacterNameFromSetFile( setFile ) +} + +bool function IsTitanPrimeTitan( entity titan ) +{ + Assert( titan.IsTitan() ) + string setFile + + if ( titan.IsPlayer() ) + { + setFile = titan.GetPlayerSettings() + } + else + { + string aiSettingsFile = titan.GetAISettingsName() + setFile = expect string( Dev_GetAISettingByKeyField_Global( aiSettingsFile, "npc_titan_player_settings" ) ) + } + + return Dev_GetPlayerSettingByKeyField_Global( setFile, "isPrime" ) == 1 + +}
\ No newline at end of file |