1968 lines
61 KiB
Plaintext
1968 lines
61 KiB
Plaintext
#using scripts\shared\ai_shared;
|
|
#using scripts\shared\array_shared;
|
|
#using scripts\shared\clientfield_shared;
|
|
#using scripts\shared\exploder_shared;
|
|
#using scripts\shared\flag_shared;
|
|
#using scripts\shared\flagsys_shared;
|
|
#using scripts\shared\gameobjects_shared;
|
|
#using scripts\shared\load_shared;
|
|
#using scripts\shared\lui_shared;
|
|
#using scripts\shared\math_shared;
|
|
#using scripts\shared\sound_shared;
|
|
#using scripts\shared\spawner_shared;
|
|
#using scripts\shared\string_shared;
|
|
#using scripts\shared\util_shared;
|
|
|
|
|
|
|
|
|
|
|
|
#using scripts\cp\_oed;
|
|
#using scripts\cp\_skipto;
|
|
#using scripts\cp\cybercom\_cybercom_util;
|
|
#using scripts\cp\gametypes\coop;
|
|
|
|
|
|
|
|
#namespace util;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#precache( "lui_menu", "CPHintText" );
|
|
#precache( "lui_menu_data", "hint_text_line" );
|
|
|
|
#precache( "string", "blinking");
|
|
#precache( "string", "display_noblink");
|
|
#precache( "string", "fadeout");
|
|
|
|
/@
|
|
"Name: add_gametype()"
|
|
"Summary: dummy - Rex looks for these to populate the gametype pulldown"
|
|
"SPMP: COOP"
|
|
@/
|
|
function add_gametype( gt )
|
|
{
|
|
}
|
|
|
|
|
|
/#
|
|
function error(msg)
|
|
{
|
|
println("^c*ERROR* ", msg);
|
|
wait .05; // waitframe
|
|
|
|
if (GetDvarString( "debug") != "1")
|
|
assertmsg("This is a forced error - attach the log file");
|
|
}
|
|
#/
|
|
|
|
function warning( msg )
|
|
{
|
|
/# println( "^1WARNING: " + msg ); #/
|
|
}
|
|
|
|
|
|
|
|
/@
|
|
"Name: within_fov( <start_origin> , <start_angles> , <end_origin> , <fov> )"
|
|
"Summary: Returns true if < end_origin > is within the players field of view, otherwise returns false."
|
|
"Module: Vector"
|
|
"CallOn: "
|
|
"MandatoryArg: <start_origin> : starting origin for FOV check( usually the players origin )"
|
|
"MandatoryArg: <start_angles> : angles to specify facing direction( usually the players angles )"
|
|
"MandatoryArg: <end_origin> : origin to check if it's in the FOV"
|
|
"MandatoryArg: <fov> : cosine of the FOV angle to use"
|
|
"Example: qBool = within_fov( level.player.origin, level.player.angles, target1.origin, cos( 45 ) );"
|
|
"SPMP: multiplayer"
|
|
@/
|
|
function within_fov( start_origin, start_angles, end_origin, fov )
|
|
{
|
|
normal = VectorNormalize( end_origin - start_origin );
|
|
forward = AnglesToForward( start_angles );
|
|
dot = VectorDot( forward, normal );
|
|
|
|
return dot >= fov;
|
|
}
|
|
|
|
function get_player_height()
|
|
{
|
|
return 70.0; // inches, see bg_pmove.cpp::playerMins/playerMaxs
|
|
}
|
|
|
|
|
|
function IsBulletImpactMOD( sMeansOfDeath )
|
|
{
|
|
return IsSubStr( sMeansOfDeath, "BULLET" ) || sMeansOfDeath == "MOD_HEAD_SHOT";
|
|
}
|
|
|
|
function waitRespawnButton()
|
|
{
|
|
self endon("disconnect");
|
|
self endon("end_respawn");
|
|
|
|
while(self useButtonPressed() != true)
|
|
wait .05;
|
|
}
|
|
|
|
function setLowerMessage( text, time, combineMessageAndTimer )
|
|
{
|
|
if ( !isdefined( self.lowerMessage ) )
|
|
return;
|
|
|
|
if ( isdefined( self.lowerMessageOverride ) && text != &"" )
|
|
{
|
|
text = self.lowerMessageOverride;
|
|
time = undefined;
|
|
}
|
|
|
|
self notify("lower_message_set");
|
|
|
|
self.lowerMessage setText( text );
|
|
|
|
if ( isdefined( time ) && time > 0 )
|
|
{
|
|
if ( !isdefined( combineMessageAndTimer ) || !combineMessageAndTimer )
|
|
self.lowerTimer.label = &"";
|
|
else
|
|
{
|
|
self.lowerMessage setText( "" );
|
|
self.lowerTimer.label = text;
|
|
}
|
|
self.lowerTimer setTimer( time );
|
|
}
|
|
else
|
|
{
|
|
self.lowerTimer setText( "" );
|
|
self.lowerTimer.label = &"";
|
|
}
|
|
if( self IsSplitscreen() )
|
|
self.lowerMessage.fontscale = 1.4;
|
|
|
|
self.lowerMessage fadeOverTime( 0.05 );
|
|
self.lowerMessage.alpha = 1;
|
|
self.lowerTimer fadeOverTime( 0.05 );
|
|
self.lowerTimer.alpha = 1;
|
|
}
|
|
|
|
function setLowerMessageValue( text, value, combineMessage )
|
|
{
|
|
if ( !isdefined( self.lowerMessage ) )
|
|
return;
|
|
|
|
if ( isdefined( self.lowerMessageOverride ) && text != &"" )
|
|
{
|
|
text = self.lowerMessageOverride;
|
|
time = undefined;
|
|
}
|
|
|
|
self notify("lower_message_set");
|
|
if ( !isdefined( combineMessage ) || !combineMessage )
|
|
self.lowerMessage setText( text );
|
|
else
|
|
self.lowerMessage setText( "" );
|
|
|
|
if ( isdefined( value ) && value > 0 )
|
|
{
|
|
if ( !isdefined( combineMessage ) || !combineMessage )
|
|
self.lowerTimer.label = &"";
|
|
else
|
|
self.lowerTimer.label = text;
|
|
self.lowerTimer setValue( value );
|
|
}
|
|
else
|
|
{
|
|
self.lowerTimer setText( "" );
|
|
self.lowerTimer.label = &"";
|
|
}
|
|
|
|
if( self IsSplitscreen() )
|
|
self.lowerMessage.fontscale = 1.4;
|
|
|
|
self.lowerMessage fadeOverTime( 0.05 );
|
|
self.lowerMessage.alpha = 1;
|
|
self.lowerTimer fadeOverTime( 0.05 );
|
|
self.lowerTimer.alpha = 1;
|
|
}
|
|
|
|
function clearLowerMessage( fadetime )
|
|
{
|
|
if ( !isdefined( self.lowerMessage ) )
|
|
return;
|
|
|
|
self notify("lower_message_set");
|
|
|
|
if ( !isdefined( fadetime) || fadetime == 0 )
|
|
{
|
|
setLowerMessage( &"" );
|
|
}
|
|
else
|
|
{
|
|
self endon("disconnect");
|
|
self endon("lower_message_set");
|
|
|
|
self.lowerMessage fadeOverTime( fadetime );
|
|
self.lowerMessage.alpha = 0;
|
|
self.lowerTimer fadeOverTime( fadetime );
|
|
self.lowerTimer.alpha = 0;
|
|
|
|
wait fadetime;
|
|
|
|
self setLowerMessage("");
|
|
}
|
|
}
|
|
|
|
function printOnTeam(text, team)
|
|
{
|
|
assert( isdefined( level.players ) );
|
|
for ( i = 0; i < level.players.size; i++ )
|
|
{
|
|
player = level.players[i];
|
|
if ( ( isdefined(player.pers["team"]) ) && (player.pers["team"] == team) )
|
|
player iprintln(text);
|
|
}
|
|
}
|
|
|
|
|
|
function printBoldOnTeam(text, team)
|
|
{
|
|
assert( isdefined( level.players ) );
|
|
for ( i = 0; i < level.players.size; i++ )
|
|
{
|
|
player = level.players[i];
|
|
if ( ( isdefined(player.pers["team"]) ) && (player.pers["team"] == team) )
|
|
player iprintlnbold(text);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
function printBoldOnTeamArg(text, team, arg)
|
|
{
|
|
assert( isdefined( level.players ) );
|
|
for ( i = 0; i < level.players.size; i++ )
|
|
{
|
|
player = level.players[i];
|
|
if ( ( isdefined(player.pers["team"]) ) && (player.pers["team"] == team) )
|
|
player iprintlnbold(text, arg);
|
|
}
|
|
}
|
|
|
|
|
|
function printOnTeamArg(text, team, arg)
|
|
{
|
|
//assert( isdefined( level.players ) );
|
|
//for ( i = 0; i < level.players.size; i++ )
|
|
//{
|
|
// player = level.players[i];
|
|
// if ( ( isdefined(player.pers["team"]) ) && (player.pers["team"] == team) )
|
|
// {
|
|
// player iprintln(text, arg);
|
|
// }
|
|
//}
|
|
}
|
|
|
|
|
|
function printOnPlayers( text, team )
|
|
{
|
|
players = level.players;
|
|
for(i = 0; i < players.size; i++)
|
|
{
|
|
if ( isdefined( team ) )
|
|
{
|
|
if((isdefined(players[i].pers["team"])) && (players[i].pers["team"] == team))
|
|
players[i] iprintln(text);
|
|
}
|
|
else
|
|
{
|
|
players[i] iprintln(text);
|
|
}
|
|
}
|
|
}
|
|
|
|
function printAndSoundOnEveryone( team, enemyteam, printFriendly, printEnemy, soundFriendly, soundEnemy, printarg )
|
|
{
|
|
shouldDoSounds = isdefined( soundFriendly );
|
|
|
|
shouldDoEnemySounds = false;
|
|
if ( isdefined( soundEnemy ) )
|
|
{
|
|
assert( shouldDoSounds ); // can't have an enemy sound without a friendly sound
|
|
shouldDoEnemySounds = true;
|
|
}
|
|
|
|
if ( !isdefined( printarg ) )
|
|
{
|
|
printarg = "";
|
|
}
|
|
|
|
if ( level.splitscreen || !shouldDoSounds )
|
|
{
|
|
for ( i = 0; i < level.players.size; i++ )
|
|
{
|
|
player = level.players[i];
|
|
playerteam = player.pers["team"];
|
|
if ( isdefined( playerteam ) )
|
|
{
|
|
if ( playerteam == team && isdefined( printFriendly ) && printFriendly != &"" )
|
|
player iprintln( printFriendly, printarg );
|
|
else if ( isdefined( printEnemy ) && printEnemy != &"" )
|
|
{
|
|
if ( isdefined(enemyteam) && playerteam == enemyteam )
|
|
player iprintln( printEnemy, printarg );
|
|
else if ( !isdefined(enemyteam) && playerteam != team )
|
|
player iprintln( printEnemy, printarg );
|
|
}
|
|
}
|
|
}
|
|
if ( shouldDoSounds )
|
|
{
|
|
assert( level.splitscreen );
|
|
level.players[0] playLocalSound( soundFriendly );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
assert( shouldDoSounds );
|
|
if ( shouldDoEnemySounds )
|
|
{
|
|
for ( i = 0; i < level.players.size; i++ )
|
|
{
|
|
player = level.players[i];
|
|
playerteam = player.pers["team"];
|
|
if ( isdefined( playerteam ) )
|
|
{
|
|
if ( playerteam == team )
|
|
{
|
|
if( isdefined( printFriendly ) && printFriendly != &"" )
|
|
player iprintln( printFriendly, printarg );
|
|
player playLocalSound( soundFriendly );
|
|
}
|
|
else if ( (isdefined(enemyteam) && playerteam == enemyteam) || ( !isdefined( enemyteam ) && playerteam != team ) )
|
|
{
|
|
if( isdefined( printEnemy ) && printEnemy != &"" )
|
|
player iprintln( printEnemy, printarg );
|
|
player playLocalSound( soundEnemy );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( i = 0; i < level.players.size; i++ )
|
|
{
|
|
player = level.players[i];
|
|
playerteam = player.pers["team"];
|
|
if ( isdefined( playerteam ) )
|
|
{
|
|
if ( playerteam == team )
|
|
{
|
|
if( isdefined( printFriendly ) && printFriendly != &"" )
|
|
player iprintln( printFriendly, printarg );
|
|
player playLocalSound( soundFriendly );
|
|
}
|
|
else if ( isdefined( printEnemy ) && printEnemy != &"" )
|
|
{
|
|
if ( isdefined(enemyteam) && playerteam == enemyteam )
|
|
{
|
|
player iprintln( printEnemy, printarg );
|
|
}
|
|
else if ( !isdefined(enemyteam) && playerteam != team )
|
|
{
|
|
player iprintln( printEnemy, printarg );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
function _playLocalSound( soundAlias )
|
|
{
|
|
if ( level.splitscreen && !self IsHost() )
|
|
return;
|
|
|
|
self playLocalSound( soundAlias );
|
|
}
|
|
|
|
// this function is depricated
|
|
function getOtherTeam( team )
|
|
{
|
|
// TODO MTEAM - Need to fix this.
|
|
if ( team == "allies" )
|
|
return "axis";
|
|
else if ( team == "axis" )
|
|
return "allies";
|
|
else // all other teams
|
|
return "allies";
|
|
|
|
assertMsg( "getOtherTeam: invalid team " + team );
|
|
}
|
|
|
|
function getTeamMask( team )
|
|
{
|
|
// this can be undefined on connect
|
|
if ( !level.teambased || !isdefined(team) || !isdefined(level.spawnsystem.iSPAWN_TEAMMASK[team]) )
|
|
return level.spawnsystem.iSPAWN_TEAMMASK_FREE;
|
|
|
|
return level.spawnsystem.iSPAWN_TEAMMASK[team];
|
|
}
|
|
|
|
function getOtherTeamsMask( skip_team )
|
|
{
|
|
mask = 0;
|
|
foreach( team in level.teams )
|
|
{
|
|
if ( team == skip_team )
|
|
continue;
|
|
|
|
mask = mask | getTeamMask( team );
|
|
}
|
|
|
|
return mask;
|
|
}
|
|
|
|
function plot_points( plotpoints, r=1, g=1, b=1, server_frames=1 )
|
|
{
|
|
/#
|
|
lastpoint = plotpoints[ 0 ];
|
|
server_frames = int( server_frames );//Make sure this is an int
|
|
|
|
for( i = 1;i < plotpoints.size;i ++ )
|
|
{
|
|
// AE 10-26-09: line function must have changed to Line( <start>, <end>, <color>, <depthTest>, <duration> )
|
|
line( lastpoint, plotpoints[ i ], ( r, g, b ), 1, server_frames );
|
|
lastpoint = plotpoints[ i ];
|
|
}
|
|
#/
|
|
}
|
|
|
|
function getfx( fx )
|
|
{
|
|
assert( isdefined( level._effect[ fx ] ), "Fx " + fx + " is not defined in level._effect." );
|
|
return level._effect[ fx ];
|
|
}
|
|
|
|
function set_dvar_if_unset(
|
|
dvar,
|
|
value,
|
|
reset)
|
|
{
|
|
if (!isdefined(reset))
|
|
reset = false;
|
|
|
|
if (reset || GetDvarString(dvar)=="")
|
|
{
|
|
SetDvar(dvar, value);
|
|
return value;
|
|
}
|
|
|
|
return GetDvarString(dvar);
|
|
}
|
|
|
|
function set_dvar_float_if_unset(
|
|
dvar,
|
|
value,
|
|
reset)
|
|
{
|
|
if (!isdefined(reset))
|
|
reset = false;
|
|
|
|
if (reset || GetDvarString(dvar)=="")
|
|
{
|
|
SetDvar(dvar, value);
|
|
}
|
|
|
|
return GetDvarFloat(dvar);
|
|
}
|
|
|
|
function set_dvar_int_if_unset(
|
|
dvar,
|
|
value,
|
|
reset)
|
|
{
|
|
if (!isdefined(reset))
|
|
reset = false;
|
|
|
|
if (reset || GetDvarString(dvar)=="")
|
|
{
|
|
SetDvar(dvar, value);
|
|
return int(value);
|
|
}
|
|
|
|
return GetDvarInt(dvar);
|
|
}
|
|
|
|
function add_trigger_to_ent(ent) // Self == The trigger volume
|
|
{
|
|
if(!isdefined(ent._triggers))
|
|
{
|
|
ent._triggers = [];
|
|
}
|
|
|
|
ent._triggers[self GetEntityNumber()] = 1;
|
|
}
|
|
|
|
function remove_trigger_from_ent(ent) // Self == The trigger volume.
|
|
{
|
|
if(!isdefined(ent))
|
|
return;
|
|
|
|
if(!isdefined(ent._triggers))
|
|
return;
|
|
|
|
if(!isdefined(ent._triggers[self GetEntityNumber()]))
|
|
return;
|
|
|
|
ent._triggers[self GetEntityNumber()] = 0;
|
|
}
|
|
|
|
function ent_already_in_trigger(trig) // Self == The entity in the trigger volume.
|
|
{
|
|
if(!isdefined(self._triggers))
|
|
return false;
|
|
|
|
if(!isdefined(self._triggers[trig GetEntityNumber()]))
|
|
return false;
|
|
|
|
if(!self._triggers[trig GetEntityNumber()])
|
|
return false;
|
|
|
|
return true; // We're already in this trigger volume.
|
|
}
|
|
|
|
function trigger_thread_death_monitor(ent, ender)
|
|
{
|
|
ent waittill("death");
|
|
self endon(ender);
|
|
self remove_trigger_from_ent(ent);
|
|
}
|
|
|
|
function trigger_thread(ent, on_enter_payload, on_exit_payload) // Self == The trigger.
|
|
{
|
|
ent endon("entityshutdown");
|
|
ent endon("death");
|
|
|
|
if(ent ent_already_in_trigger(self))
|
|
return;
|
|
|
|
self add_trigger_to_ent(ent);
|
|
|
|
ender = "end_trig_death_monitor" + self GetEntityNumber() + " " + ent GetEntityNumber();
|
|
self thread trigger_thread_death_monitor(ent, ender); // If ent dies in trigger, clear trigger off of ent.
|
|
|
|
// iprintlnbold("Trigger " + self.targetname + " hit by ent " + ent getentitynumber());
|
|
|
|
endon_condition = "leave_trigger_" + self GetEntityNumber();
|
|
|
|
if(isdefined(on_enter_payload))
|
|
{
|
|
self thread [[on_enter_payload]](ent, endon_condition);
|
|
}
|
|
|
|
while(isdefined(ent) && ent IsTouching(self))
|
|
{
|
|
wait(0.01);
|
|
}
|
|
|
|
ent notify(endon_condition);
|
|
|
|
// iprintlnbold(ent getentitynumber() + " leaves trigger " + self.targetname + ".");
|
|
|
|
if(isdefined(ent) && isdefined(on_exit_payload))
|
|
{
|
|
self thread [[on_exit_payload]](ent);
|
|
}
|
|
|
|
if(isdefined(ent))
|
|
{
|
|
self remove_trigger_from_ent(ent);
|
|
}
|
|
|
|
self notify(ender); // Get rid of the death monitor thread.
|
|
}
|
|
|
|
function isStrStart( string1, subStr )
|
|
{
|
|
return ( getSubStr( string1, 0, subStr.size ) == subStr );
|
|
}
|
|
|
|
function isKillStreaksEnabled()
|
|
{
|
|
return isdefined( level.killstreaksenabled ) && level.killstreaksenabled;
|
|
}
|
|
|
|
function setUsingRemote( remoteName )
|
|
{
|
|
if ( isdefined( self.carryIcon) )
|
|
self.carryIcon.alpha = 0;
|
|
|
|
assert( !self isUsingRemote() );
|
|
self.usingRemote = remoteName;
|
|
|
|
self disableOffhandWeapons();
|
|
self notify( "using_remote" );
|
|
}
|
|
|
|
function getRemoteName()
|
|
{
|
|
assert( self isUsingRemote() );
|
|
|
|
return self.usingRemote;
|
|
}
|
|
|
|
function setObjectiveText( team, text )
|
|
{
|
|
game["strings"]["objective_"+team] = text;
|
|
}
|
|
|
|
function setObjectiveScoreText( team, text )
|
|
{
|
|
game["strings"]["objective_score_"+team] = text;
|
|
}
|
|
|
|
function setObjectiveHintText( team, text )
|
|
{
|
|
game["strings"]["objective_hint_"+team] = text;
|
|
}
|
|
|
|
function getObjectiveText( team )
|
|
{
|
|
return game["strings"]["objective_"+team];
|
|
}
|
|
|
|
function getObjectiveScoreText( team )
|
|
{
|
|
return game["strings"]["objective_score_"+team];
|
|
}
|
|
|
|
function getObjectiveHintText( team )
|
|
{
|
|
return game["strings"]["objective_hint_"+team];
|
|
}
|
|
|
|
function registerRoundSwitch( minValue, maxValue )
|
|
{
|
|
level.roundSwitch = math::clamp( GetGametypeSetting( "roundSwitch" ), minValue, maxValue );
|
|
level.roundSwitchMin = minValue;
|
|
level.roundSwitchMax = maxValue;
|
|
}
|
|
|
|
function registerRoundLimit( minValue, maxValue )
|
|
{
|
|
level.roundLimit = math::clamp( GetGametypeSetting( "roundLimit" ), minValue, maxValue );
|
|
level.roundLimitMin = minValue;
|
|
level.roundLimitMax = maxValue;
|
|
}
|
|
|
|
|
|
function registerRoundWinLimit( minValue, maxValue )
|
|
{
|
|
level.roundWinLimit = math::clamp( GetGametypeSetting( "roundWinLimit" ), minValue, maxValue );
|
|
level.roundWinLimitMin = minValue;
|
|
level.roundWinLimitMax = maxValue;
|
|
}
|
|
|
|
|
|
function registerScoreLimit( minValue, maxValue )
|
|
{
|
|
level.scoreLimit = math::clamp( GetGametypeSetting( "scoreLimit" ), minValue, maxValue );
|
|
level.scoreLimitMin = minValue;
|
|
level.scoreLimitMax = maxValue;
|
|
SetDvar( "ui_scorelimit", level.scoreLimit );
|
|
}
|
|
|
|
|
|
function registerTimeLimit( minValue, maxValue )
|
|
{
|
|
level.timeLimit = math::clamp( GetGametypeSetting( "timeLimit" ), minValue, maxValue );
|
|
level.timeLimitMin = minValue;
|
|
level.timeLimitMax = maxValue;
|
|
SetDvar( "ui_timelimit", level.timeLimit );
|
|
}
|
|
|
|
|
|
function registerNumLives( minValue, maxValue )
|
|
{
|
|
level.numLives = math::clamp( GetGametypeSetting( "playerNumLives" ), minValue, maxValue );
|
|
level.numLivesMin = minValue;
|
|
level.numLivesMax = maxValue;
|
|
}
|
|
|
|
function getPlayerFromClientNum( clientNum )
|
|
{
|
|
if ( clientNum < 0 )
|
|
return undefined;
|
|
|
|
for ( i = 0; i < level.players.size; i++ )
|
|
{
|
|
if ( level.players[i] getEntityNumber() == clientNum )
|
|
return level.players[i];
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
function isPressBuild()
|
|
{
|
|
buildType = GetDvarString( "buildType" );
|
|
|
|
if ( isdefined( buildType ) && buildtype == "press" )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function isFlashbanged()
|
|
{
|
|
return isdefined( self.flashEndTime ) && gettime() < self.flashEndTime;
|
|
}
|
|
|
|
|
|
/@
|
|
"Name: self isEntStunned()"
|
|
"Summary: Returns true if the entity is stunned"
|
|
"Module: Entity"
|
|
"CallOn: An entity"
|
|
"Example: if (self isEntStunned())"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function isEntStunned()
|
|
{
|
|
time = gettime();
|
|
|
|
if (isDefined(self.stunned) && self.stunned)
|
|
return true;
|
|
|
|
if (self isFlashbanged())
|
|
return true;
|
|
|
|
if (isDefined(self.stun_fx))
|
|
return true;
|
|
|
|
if (isDefined(self.lastStunnedTime) && (self.lastStunnedTime + 5000) > time)
|
|
return true;
|
|
|
|
if (isDefined( self.concussionEndTime ) && self.concussionEndTime > time)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
function DoMaxDamage( origin, attacker, inflictor, headshot, mod ) // self == entity to damage
|
|
{
|
|
if ( isdefined( self.damagedToDeath ) && self.damagedToDeath )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( isdefined( self.maxHealth ) )
|
|
{
|
|
damage = self.maxHealth + 1;
|
|
}
|
|
else
|
|
{
|
|
damage = self.health + 1;
|
|
}
|
|
|
|
self.damagedToDeath = true;
|
|
|
|
self DoDamage( damage, origin, attacker, inflictor, headshot, mod );
|
|
}
|
|
|
|
|
|
/@
|
|
"Name: self_delete()"
|
|
"Summary: Just calls the delete() script command on self. Reason for this is so that we can use array::thread_all to delete entities"
|
|
"Module: Entity"
|
|
"CallOn: An entity"
|
|
"Example: ai[ 0 ] thread self_delete();"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function self_delete()
|
|
{
|
|
if ( isdefined( self ) )
|
|
{
|
|
self delete();
|
|
}
|
|
}
|
|
|
|
|
|
/@
|
|
"Name: screen_message_create(<string_message>)"
|
|
"Summary: Creates a HUD element at the correct position with the string or string reference passed in. Shows on all players screens in a co-op game."
|
|
"Module: Utility"
|
|
"CallOn: N/A"
|
|
"MandatoryArg: <string_message_1> : A string or string reference to place on the screen."
|
|
"OptionalArg: <string_message_2> : A second string to display below the first."
|
|
"OptionalArg: <string_message_3> : A third string to display below the second."
|
|
"OptionalArg: <n_offset_y>: Optional offset in y direction that should only be used in very specific circumstances."
|
|
"OptionalArg: <n_time> : Length of time to display the message."
|
|
"Example: screen_message_create( &"LEVEL_STRING" );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function screen_message_create( string_message_1, string_message_2, string_message_3, n_offset_y, n_time )
|
|
{
|
|
level notify( "screen_message_create" );
|
|
level endon( "screen_message_create" );
|
|
|
|
// if the mission is failing then do no create this instruction
|
|
// because it can potentially overlap the death/hint string
|
|
if( isdefined( level.missionfailed ) && level.missionfailed )
|
|
return;
|
|
|
|
// if player is killed then this dvar will be set.
|
|
// SUMEET_TODO - make it efficient next game instead of checking dvar here
|
|
if( GetDvarInt( "hud_missionFailed" ) == 1 )
|
|
return;
|
|
|
|
if ( !isdefined( n_offset_y ) )
|
|
{
|
|
n_offset_y = 0;
|
|
}
|
|
|
|
//handle displaying the first string
|
|
if( !isdefined(level._screen_message_1) )
|
|
{
|
|
//text element that displays the name of the event
|
|
level._screen_message_1 = NewHudElem();
|
|
level._screen_message_1.elemType = "font";
|
|
level._screen_message_1.font = "objective";
|
|
level._screen_message_1.fontscale = 1.8;
|
|
level._screen_message_1.horzAlign = "center";
|
|
level._screen_message_1.vertAlign = "middle";
|
|
level._screen_message_1.alignX = "center";
|
|
level._screen_message_1.alignY = "middle";
|
|
level._screen_message_1.y = -60 + n_offset_y;
|
|
level._screen_message_1.sort = 2;
|
|
|
|
level._screen_message_1.color = ( 1, 1, 1 );
|
|
level._screen_message_1.alpha = 1;
|
|
|
|
level._screen_message_1.hidewheninmenu = true;
|
|
}
|
|
|
|
//set the text of the element to the string passed in
|
|
level._screen_message_1 SetText( string_message_1 );
|
|
|
|
if( isdefined(string_message_2) )
|
|
{
|
|
//handle displaying the first string
|
|
if( !isdefined(level._screen_message_2) )
|
|
{
|
|
//text element that displays the name of the event
|
|
level._screen_message_2 = NewHudElem();
|
|
level._screen_message_2.elemType = "font";
|
|
level._screen_message_2.font = "objective";
|
|
level._screen_message_2.fontscale = 1.8;
|
|
level._screen_message_2.horzAlign = "center";
|
|
level._screen_message_2.vertAlign = "middle";
|
|
level._screen_message_2.alignX = "center";
|
|
level._screen_message_2.alignY = "middle";
|
|
level._screen_message_2.y = -33 + n_offset_y;
|
|
level._screen_message_2.sort = 2;
|
|
|
|
level._screen_message_2.color = ( 1, 1, 1 );
|
|
level._screen_message_2.alpha = 1;
|
|
|
|
level._screen_message_2.hidewheninmenu = true;
|
|
}
|
|
|
|
//set the text of the element to the string passed in
|
|
level._screen_message_2 SetText( string_message_2 );
|
|
}
|
|
else if( isdefined(level._screen_message_2) )
|
|
{
|
|
level._screen_message_2 Destroy();
|
|
}
|
|
|
|
if( isdefined(string_message_3) )
|
|
{
|
|
//handle displaying the first string
|
|
if( !isdefined(level._screen_message_3) )
|
|
{
|
|
//text element that displays the name of the event
|
|
level._screen_message_3 = NewHudElem();
|
|
level._screen_message_3.elemType = "font";
|
|
level._screen_message_3.font = "objective";
|
|
level._screen_message_3.fontscale = 1.8;
|
|
level._screen_message_3.horzAlign = "center";
|
|
level._screen_message_3.vertAlign = "middle";
|
|
level._screen_message_3.alignX = "center";
|
|
level._screen_message_3.alignY = "middle";
|
|
level._screen_message_3.y = -6 + n_offset_y;
|
|
level._screen_message_3.sort = 2;
|
|
|
|
level._screen_message_3.color = ( 1, 1, 1 );
|
|
level._screen_message_3.alpha = 1;
|
|
|
|
level._screen_message_3.hidewheninmenu = true;
|
|
}
|
|
|
|
//set the text of the element to the string passed in
|
|
level._screen_message_3 SetText( string_message_3 );
|
|
}
|
|
else if( isdefined(level._screen_message_3) )
|
|
{
|
|
level._screen_message_3 Destroy();
|
|
}
|
|
|
|
if ( isdefined( n_time ) && n_time > 0 )
|
|
{
|
|
wait( n_time );
|
|
|
|
screen_message_delete();
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: screen_message_delete()"
|
|
"Summary: Deletes the current message being displayed on the screen made using screen_message_create."
|
|
"Module: Utility"
|
|
"CallOn: N/A"
|
|
"Example: screen_message_delete();"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function screen_message_delete( delay )
|
|
{
|
|
if( isdefined( delay ) )
|
|
{
|
|
wait( delay );
|
|
}
|
|
|
|
if( isdefined(level._screen_message_1) )
|
|
{
|
|
level._screen_message_1 Destroy();
|
|
}
|
|
if( isdefined(level._screen_message_2) )
|
|
{
|
|
level._screen_message_2 Destroy();
|
|
}
|
|
if( isdefined(level._screen_message_3) )
|
|
{
|
|
level._screen_message_3 Destroy();
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: screen_message_create_client(<string_message>)"
|
|
"Summary: Creates a HUD element at the correct position with the string or string reference passed in, for a specific client."
|
|
"Module: Utility"
|
|
"CallOn: Player, specific client to recieve the screen message"
|
|
"MandatoryArg: <string_message_1> : A string or string reference to place on the screen."
|
|
"OptionalArg: <string_message_2> : A second string to display below the first."
|
|
"OptionalArg: <string_message_3> : A third string to display below the second."
|
|
"OptionalArg: <n_offset_y>: Optional offset in y direction that should only be used in very specific circumstances."
|
|
"OptionalArg: <n_time> : Length of time to display the message."
|
|
"Example: level.players[0] screen_message_create( &"LEVEL_STRING" );"
|
|
"SPMP: co-op"
|
|
@/
|
|
function screen_message_create_client( string_message_1, string_message_2, string_message_3, n_offset_y, n_time ) // self = player
|
|
{
|
|
self notify( "screen_message_create" );
|
|
self endon( "screen_message_create" );
|
|
self endon( "death" );
|
|
|
|
// if the mission is failing then do no create this instruction
|
|
// because it can potentially overlap the death/hint string
|
|
if( isdefined( level.missionfailed ) && level.missionfailed )
|
|
return;
|
|
|
|
// if player is killed then this dvar will be set.
|
|
// SUMEET_TODO - make it efficient next game instead of checking dvar here
|
|
if( GetDvarInt( "hud_missionFailed" ) == 1 )
|
|
return;
|
|
|
|
if ( !isdefined( n_offset_y ) )
|
|
{
|
|
n_offset_y = 0;
|
|
}
|
|
|
|
//handle displaying the first string
|
|
if( !isdefined(self._screen_message_1) )
|
|
{
|
|
//text element that displays the name of the event
|
|
self._screen_message_1 = NewClientHudElem( self );
|
|
self._screen_message_1.elemType = "font";
|
|
self._screen_message_1.font = "objective";
|
|
self._screen_message_1.fontscale = 1.8;
|
|
self._screen_message_1.horzAlign = "center";
|
|
self._screen_message_1.vertAlign = "middle";
|
|
self._screen_message_1.alignX = "center";
|
|
self._screen_message_1.alignY = "middle";
|
|
self._screen_message_1.y = -60 + n_offset_y;
|
|
self._screen_message_1.sort = 2;
|
|
|
|
self._screen_message_1.color = ( 1, 1, 1 );
|
|
self._screen_message_1.alpha = 1;
|
|
|
|
self._screen_message_1.hidewheninmenu = true;
|
|
}
|
|
|
|
//set the text of the element to the string passed in
|
|
self._screen_message_1 SetText( string_message_1 );
|
|
|
|
if( isdefined(string_message_2) )
|
|
{
|
|
//handle displaying the first string
|
|
if( !isdefined(self._screen_message_2) )
|
|
{
|
|
//text element that displays the name of the event
|
|
self._screen_message_2 = NewClientHudElem( self );
|
|
self._screen_message_2.elemType = "font";
|
|
self._screen_message_2.font = "objective";
|
|
self._screen_message_2.fontscale = 1.8;
|
|
self._screen_message_2.horzAlign = "center";
|
|
self._screen_message_2.vertAlign = "middle";
|
|
self._screen_message_2.alignX = "center";
|
|
self._screen_message_2.alignY = "middle";
|
|
self._screen_message_2.y = -33 + n_offset_y;
|
|
self._screen_message_2.sort = 2;
|
|
|
|
self._screen_message_2.color = ( 1, 1, 1 );
|
|
self._screen_message_2.alpha = 1;
|
|
|
|
self._screen_message_2.hidewheninmenu = true;
|
|
}
|
|
|
|
//set the text of the element to the string passed in
|
|
self._screen_message_2 SetText( string_message_2 );
|
|
}
|
|
else if( isdefined(self._screen_message_2) )
|
|
{
|
|
self._screen_message_2 Destroy();
|
|
}
|
|
|
|
if( isdefined(string_message_3) )
|
|
{
|
|
//handle displaying the first string
|
|
if( !isdefined(self._screen_message_3) )
|
|
{
|
|
//text element that displays the name of the event
|
|
self._screen_message_3 = NewClientHudElem( self );
|
|
self._screen_message_3.elemType = "font";
|
|
self._screen_message_3.font = "objective";
|
|
self._screen_message_3.fontscale = 1.8;
|
|
self._screen_message_3.horzAlign = "center";
|
|
self._screen_message_3.vertAlign = "middle";
|
|
self._screen_message_3.alignX = "center";
|
|
self._screen_message_3.alignY = "middle";
|
|
self._screen_message_3.y = -6 + n_offset_y;
|
|
self._screen_message_3.sort = 2;
|
|
|
|
self._screen_message_3.color = ( 1, 1, 1 );
|
|
self._screen_message_3.alpha = 1;
|
|
|
|
self._screen_message_3.hidewheninmenu = true;
|
|
}
|
|
|
|
//set the text of the element to the string passed in
|
|
self._screen_message_3 SetText( string_message_3 );
|
|
}
|
|
else if( isdefined(self._screen_message_3) )
|
|
{
|
|
self._screen_message_3 Destroy();
|
|
}
|
|
|
|
if ( isdefined( n_time ) && n_time > 0 )
|
|
{
|
|
wait( n_time );
|
|
|
|
self screen_message_delete_client();
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: screen_message_delete_client()"
|
|
"Summary: Deletes the current message being displayed on the client's screen made using screen_message_create_client."
|
|
"Module: Utility"
|
|
"CallOn: N/A"
|
|
"Example: level.players[0] screen_message_delete_client();"
|
|
"SPMP: co-op"
|
|
@/
|
|
function screen_message_delete_client( delay )
|
|
{
|
|
self endon( "death" );
|
|
|
|
if( isdefined( delay ) )
|
|
{
|
|
wait( delay );
|
|
}
|
|
|
|
if( isdefined(self._screen_message_1) )
|
|
{
|
|
self._screen_message_1 Destroy();
|
|
}
|
|
if( isdefined(self._screen_message_2) )
|
|
{
|
|
self._screen_message_2 Destroy();
|
|
}
|
|
if( isdefined(self._screen_message_3) )
|
|
{
|
|
self._screen_message_3 Destroy();
|
|
}
|
|
}
|
|
|
|
|
|
/@
|
|
"Name: screen_fade_out( [n_time], [str_shader] )"
|
|
"Summary: Fades the screen out. Uses any shader. Defaults to black."
|
|
"Module: Utility"
|
|
"CallOn: NA"
|
|
"OptionalArg: n_time: The time to fade. Defaults to 2 seconds. Can be 0."
|
|
"OptionalArg: str_shader: The shader to use for the hud element. Defaults to black."
|
|
"OptionalArg: str_menu_id: Unique menu ID that will create a new menu seperate from the default one."
|
|
"Example: screen_fade_out( 3 );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function screen_fade_out( n_time, str_shader, str_menu_id )
|
|
{
|
|
level lui::screen_fade_out( n_time, str_shader, str_menu_id );
|
|
}
|
|
|
|
/@
|
|
"Name: screen_fade_in( [n_time], [str_shader] )"
|
|
"Summary: Fades the screen in. Uses any shader. Defaults to black."
|
|
"Module: Utility"
|
|
"CallOn: NA"
|
|
"OptionalArg: n_time: The time to fade. Defaults to 2 seconds. Can be 0."
|
|
"OptionalArg: str_shader: The shader to use for the hud element. Defaults to black."
|
|
"OptionalArg: str_menu_id: Unique menu ID that will create a new menu seperate from the default one."
|
|
"Example: screen_fade_in( 3, "white", "special_white" );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function screen_fade_in( n_time, str_shader, str_menu_id )
|
|
{
|
|
level lui::screen_fade_in( n_time, str_shader, str_menu_id );
|
|
}
|
|
|
|
/@
|
|
"Name: screen_fade_to_alpha_with_blur( n_alpha, [n_time], [n_blur], [str_shader] )"
|
|
"Summary: Fades the screen in to a specified alpha and blur value. Uses any shader. Defaults to black."
|
|
"Module: Utility"
|
|
"CallOn: NA"
|
|
"MandatoryArg: n_alpha: The alpha value to fade the hud to."
|
|
"MandatoryArg: n_fade_time: The time to fade."
|
|
"OptionalArg: n_blur: The blur value."
|
|
"OptionalArg: str_shader: The shader to use for the hud element. Defaults to black."
|
|
"Example: screen_fade_to_alpha_with_blur( .3, 4, 1 );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function screen_fade_to_alpha_with_blur( n_alpha, n_fade_time, n_blur, str_shader )
|
|
{
|
|
Assert( isdefined( n_alpha ), "Must specify an alpha value for screen_fade_to_alpha_with_blur." );
|
|
Assert( IsPlayer( self ), "screen_fade_to_alpha_with_blur can only be called on players!" );
|
|
|
|
level notify( "_screen_fade" );
|
|
level endon( "_screen_fade" );
|
|
|
|
hud_fade = get_fade_hud( str_shader );
|
|
hud_fade FadeOverTime( n_fade_time );
|
|
hud_fade.alpha = n_alpha;
|
|
|
|
if ( isdefined( n_blur ) && ( n_blur >= 0 ) )
|
|
{
|
|
self SetBlur( n_blur, n_fade_time );
|
|
}
|
|
|
|
wait n_fade_time;
|
|
}
|
|
|
|
/@
|
|
"Name: screen_fade_to_alpha( n_alpha, [n_time], [str_shader] )"
|
|
"Summary: Fades the screen in to a specified alpha value. Uses any shader. Defaults to black."
|
|
"Module: Utility"
|
|
"CallOn: NA"
|
|
"MandatoryArg: n_alpha: The alpha value to fade the hud to."
|
|
"MandatoryArg: n_fade_time: The time to fade."
|
|
"OptionalArg: str_shader: The shader to use for the hud element. Defaults to black."
|
|
"Example: screen_fade_to_alpha( .3 );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function screen_fade_to_alpha( n_alpha, n_fade_time, str_shader )
|
|
{
|
|
screen_fade_to_alpha_with_blur( n_alpha, n_fade_time, 0, str_shader );
|
|
}
|
|
|
|
function get_fade_hud( str_shader )
|
|
{
|
|
if ( !isdefined( str_shader ) )
|
|
{
|
|
str_shader = "black";
|
|
}
|
|
|
|
if ( !isdefined( level.fade_hud ) )
|
|
{
|
|
level.fade_hud = NewHudElem();
|
|
level.fade_hud.x = 0;
|
|
level.fade_hud.y = 0;
|
|
level.fade_hud.horzAlign = "fullscreen";
|
|
level.fade_hud.vertAlign = "fullscreen";
|
|
//level.fade_hud.foreground = false; //Arcade Mode compatible
|
|
level.fade_hud.sort = 0;
|
|
level.fade_hud.alpha = 0;
|
|
}
|
|
|
|
level.fade_hud SetShader( str_shader, 640, 480 );
|
|
return level.fade_hud;
|
|
}
|
|
|
|
/@
|
|
"Name: missionFailedWrapper( fail_hint, shader, iWidth, iHeight, fDelay, x, y, b_count_as_death = true )"
|
|
"Summary: Call when you want the player to fail the mission."
|
|
"Module: Utility"
|
|
"CallOn: player or level entity"
|
|
"MandatoryArg:"
|
|
"OptionalArg: [fail_reason] : Localized string for the reason the player failed the mission."
|
|
"OptionalArg: [fail_hint] : Localized hint for how they can not fail the mission next time."
|
|
"OptionalArg: [shader] : Special fail icon Shader/Icon."
|
|
"OptionalArg: [iWidth] : Shader/Icon width."
|
|
"OptionalArg: [iHeight] : Shader/Icon height."
|
|
"OptionalArg: [fDelay] : Delay to show the Shader/Icon."
|
|
"OptionalArg: [b_count_as_death] : Count again player stats for deaths."
|
|
"Example: _utility::missionFailedWrapper();"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function missionfailedwrapper( fail_reason, fail_hint, shader, iWidth, iHeight, fDelay, x, y, b_count_as_death = true )
|
|
{
|
|
if( level.missionfailed )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( isdefined( level.nextmission ) )
|
|
{
|
|
return; // don't fail the mission while the game is on it's way to the next mission.
|
|
}
|
|
|
|
if ( GetDvarString( "failure_disabled" ) == "1" )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// delete any existing in-game instructions created by screen_message_create() functionality
|
|
screen_message_delete();
|
|
|
|
if( isdefined( fail_hint ) )
|
|
{
|
|
SetDvar( "ui_deadquote", fail_hint );
|
|
}
|
|
|
|
if( isdefined( shader ) )
|
|
{
|
|
GetPlayers()[0] thread load::special_death_indicator_hudelement( shader, iWidth, iHeight, fDelay, x, y );
|
|
}
|
|
|
|
level.missionfailed = true;
|
|
// TODO: Why did this stop working?
|
|
// level flag::set( "missionfailed" );
|
|
|
|
if ( b_count_as_death )
|
|
{
|
|
// GetPlayers()[0] inc_general_stat( "deaths" );
|
|
}
|
|
|
|
level thread coop::fadeOutAndLoadCheckpoint( fail_reason, fail_hint );
|
|
}
|
|
|
|
/@
|
|
"Name: missionfailedwrapper_nodeath( fail_hint, shader, iWidth, iHeight, fDelay, x, y )"
|
|
"Summary: Call when you want the player to fail the mission but not count towards player death stats."
|
|
"Module: Utility"
|
|
"CallOn: player or level entity"
|
|
"MandatoryArg:"
|
|
"OptionalArg: [fail_reason] : Localized string for the reason the player failed the mission."
|
|
"OptionalArg: [fail_hint] : Localized hint for how they can not fail the mission next time."
|
|
"OptionalArg: [shader] : Special fail icon Shader/Icon."
|
|
"OptionalArg: [iWidth] : Shader/Icon width."
|
|
"OptionalArg: [iHeight] : Shader/Icon height."
|
|
"OptionalArg: [fDelay] : Delay to show the Shader/Icon."
|
|
"Example: _utility::missionfailedwrapper_nodeath();"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function missionfailedwrapper_nodeath( fail_reason, fail_hint, shader, iWidth, iHeight, fDelay, x, y )
|
|
{
|
|
missionfailedwrapper( fail_reason, fail_hint, shader, iWidth, iHeight, fDelay, x, y, false );
|
|
}
|
|
|
|
function helper_message( message, delay, str_abort_flag )
|
|
{
|
|
level notify( "kill_helper_message" );
|
|
level endon( "kill_helper_message" );
|
|
|
|
helper_message_delete();
|
|
|
|
level.helper_message = message;
|
|
|
|
util::screen_message_create( message );
|
|
|
|
if( !isdefined(delay) )
|
|
{
|
|
delay = 5;
|
|
}
|
|
|
|
start_time = GetTime();
|
|
while( 1 )
|
|
{
|
|
time = GetTime();
|
|
dt = ( time - start_time ) / 1000;
|
|
if( dt >= delay )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if( isdefined(str_abort_flag) && (level flag::get(str_abort_flag) == true) )
|
|
{
|
|
break;
|
|
}
|
|
|
|
wait( 0.01 );
|
|
}
|
|
|
|
|
|
if( isdefined(level.helper_message) )
|
|
{
|
|
util::screen_message_delete();
|
|
}
|
|
|
|
level.helper_message = undefined;
|
|
}
|
|
|
|
function helper_message_delete()
|
|
{
|
|
if( isdefined(level.helper_message) )
|
|
{
|
|
util::screen_message_delete();
|
|
}
|
|
level.helper_message = undefined;
|
|
}
|
|
|
|
/@
|
|
"Name: show_hit_marker()"
|
|
"Summary: Displays hit marker on player HUD. Use this when custom scripting script models or brushes that need damage feedback."
|
|
"Module: HUD"
|
|
"CallOn: Player"
|
|
"Example: player show_hit_marker();"
|
|
@/
|
|
function show_hit_marker() // self = player
|
|
{
|
|
if ( IsDefined( self ) && IsDefined( self.hud_damagefeedback ) ) // hud_damagefeedback declared in _damagefeedback.gsc
|
|
{
|
|
self.hud_damagefeedback SetShader( "damage_feedback", 24, 48 );
|
|
self.hud_damagefeedback.alpha = 1;
|
|
self.hud_damagefeedback FadeOverTime(1);
|
|
self.hud_damagefeedback.alpha = 0;
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: init_hero(name, func_init, arg1, arg2, arg3, arg4, arg5 )"
|
|
"Summary: a function that can spawn or grab an entity and turn it into a hero character."
|
|
"Module: Level"
|
|
"CallOn: N/A"
|
|
"OptionalArg: func_init, arg1, arg2, arg3, arg4, arg5"
|
|
"Example: init_hero(woods, ::equip_wooods, primary_gun, secondary_gun);
|
|
"SPMP: singleplayer"
|
|
@/
|
|
|
|
function init_hero( name, func_init, arg1, arg2, arg3, arg4, arg5, b_show_in_ev = true )
|
|
{
|
|
if ( !isdefined( level.heroes ) )
|
|
{
|
|
level.heroes = [];
|
|
}
|
|
|
|
name = ToLower( name );
|
|
|
|
ai_hero = GetEnt( name + "_ai", "targetname", true );
|
|
if ( !IsAlive( ai_hero ) )
|
|
{
|
|
ai_hero = GetEnt( name, "targetname", true );
|
|
|
|
if ( !IsAlive( ai_hero ) )
|
|
{
|
|
spawner = GetEnt( name, "targetname" );
|
|
if ( !( isdefined( spawner.spawning ) && spawner.spawning ) )
|
|
{
|
|
spawner.count++;
|
|
ai_hero = spawner::simple_spawn_single( spawner );
|
|
|
|
Assert( isdefined( ai_hero ), "Failed to spawn hero '" + name + "'." );
|
|
|
|
spawner notify( "hero_spawned", ai_hero );
|
|
}
|
|
else
|
|
{
|
|
// Another thread is already spawning this hero, just wait for that one
|
|
spawner waittill( "hero_spawned", ai_hero );
|
|
}
|
|
}
|
|
}
|
|
|
|
level.heroes[ name ] = ai_hero;
|
|
ai_hero.animname = name;
|
|
ai_hero.is_hero = true;
|
|
ai_hero.enableTerrainIk = 1; //enable IK on Heros
|
|
|
|
ai_hero SetTmodeProvider( true );
|
|
ai_hero util::magic_bullet_shield();
|
|
|
|
ai_hero thread _hero_death( name );
|
|
|
|
if ( IsDefined( func_init ) )
|
|
{
|
|
util::single_thread( ai_hero, func_init, arg1, arg2, arg3, arg4, arg5 );
|
|
}
|
|
|
|
if ( isdefined( level.customHeroSpawn ) )
|
|
{
|
|
ai_hero [[level.customHeroSpawn]]();
|
|
}
|
|
|
|
if( b_show_in_ev )
|
|
{
|
|
ai_hero thread oed::enable_thermal();
|
|
}
|
|
|
|
return ai_hero;
|
|
}
|
|
|
|
/@
|
|
"Name: init_heroes(a_hero_names, func_init, arg1, arg2, arg3, arg4, arg5 )"
|
|
"Summary: a function that takes an array of targetname string and set them up as hero characters"
|
|
"Module: Level"
|
|
"CallOn: N/A"
|
|
"OptionalArg: func_init, arg1, arg2, arg3, arg4, arg5"
|
|
"Example: init_hero( a_pow_heroes, ::equip_pow_heroes, primary_gun, secondary_gun);
|
|
"SPMP: singleplayer"
|
|
@/
|
|
|
|
function init_heroes( a_hero_names, func, arg1, arg2, arg3, arg4, arg5 )
|
|
{
|
|
a_heroes = [];
|
|
foreach ( str_hero in a_hero_names )
|
|
{
|
|
if ( !isdefined( a_heroes ) ) a_heroes = []; else if ( !IsArray( a_heroes ) ) a_heroes = array( a_heroes ); a_heroes[a_heroes.size]=init_hero( str_hero, func, arg1, arg2, arg3, arg4, arg5 );;
|
|
}
|
|
|
|
return a_heroes;
|
|
}
|
|
|
|
|
|
function _hero_death( str_name )
|
|
{
|
|
self endon( "unmake_hero" );
|
|
self waittill( "death" );
|
|
|
|
if ( isdefined( self ) )
|
|
{
|
|
AssertMsg( "Hero '" + str_name + "' died." );
|
|
}
|
|
|
|
unmake_hero( str_name );
|
|
}
|
|
|
|
/@
|
|
"Name: unmake_hero()"
|
|
"Summary: Removes the AI from the hero list and stops hero behaviors running on the AI such as magic_bullet_shield."
|
|
"Module: AI"
|
|
"CallOn: Friendly AI"
|
|
"Example: unmake_hero( "hendricks" );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function unmake_hero( str_name )
|
|
{
|
|
ai_hero = level.heroes[ str_name ];
|
|
|
|
level.heroes = array::remove_index( level.heroes, str_name, true );
|
|
|
|
// Do this last, as the _hero_death thread will be killed by it.
|
|
if ( IsAlive( ai_hero ) )
|
|
{
|
|
ai_hero SetTmodeProvider( false );
|
|
ai_hero util::stop_magic_bullet_shield();
|
|
ai_hero notify( "unmake_hero" );
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: get_heroes()"
|
|
"Summary: Returns an array of all heroes currently in the level."
|
|
"Module: AI"
|
|
"Example: heroes = get_heroes();"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function get_heroes()
|
|
{
|
|
return level.heroes;
|
|
}
|
|
|
|
|
|
/@
|
|
"Name: get_hero( str_name )"
|
|
"Summary: Returns a hero, or tries to spawn one if he doesn't exist"
|
|
"Module: Level"
|
|
"Example: level.ai_hendricks = get_hero( "hendricks" );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function get_hero( str_name )
|
|
{
|
|
if ( !isdefined( level.heroes ) )
|
|
{
|
|
level.heroes = [];
|
|
}
|
|
|
|
if ( isdefined( level.heroes[ str_name ] ) )
|
|
{
|
|
return level.heroes[ str_name ];
|
|
}
|
|
else
|
|
{
|
|
return init_hero( str_name );
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: is_hero()"
|
|
"Summary: Returns true if the AI is a hero, false if he is not."
|
|
"Module: AI"
|
|
"CallOn: Friendly AI"
|
|
"Example: ai_friendly is_hero();"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function is_hero()
|
|
{
|
|
return ( isdefined( self.is_hero ) && self.is_hero );
|
|
}
|
|
|
|
function init_streamer_hints( number_of_zones )
|
|
{
|
|
clientfield::register( "world", "force_streamer", 1, GetMinBitCountForNum( number_of_zones ), "int" );
|
|
}
|
|
|
|
/@
|
|
"Name: clear_streamer_hint()"
|
|
"Summary: Clear all streamer hints."
|
|
"CallOn: NA"
|
|
"Example: util::clear_streamer_hint()"
|
|
@/
|
|
function clear_streamer_hint()
|
|
{
|
|
level flag::wait_till( "all_players_connected" );
|
|
level clientfield::set( "force_streamer", 0 );
|
|
}
|
|
|
|
/@
|
|
"Name: set_streamer_hint( <n_zone>, [b_clear_previous = true] )"
|
|
"Summary: Force the streamer to load a particular zone that you've set up in client script."
|
|
"CallOn: NA"
|
|
"MandatoryArg: <n_zone> : Integer of the zone you've defined"
|
|
"OptionalArg: [b_clear_previous] : Clears all previous streamer hints that script has asked for"
|
|
"Example: util::set_streamer_hint( STREAMER_LEVEL_START )"
|
|
@/
|
|
function set_streamer_hint( n_zone, b_clear_previous = true )
|
|
{
|
|
level thread _set_streamer_hint( n_zone, b_clear_previous );
|
|
}
|
|
|
|
function _set_streamer_hint( n_zone, b_clear_previous = true )
|
|
{
|
|
level notify( "set_streamer_hint" );
|
|
level endon( "set_streamer_hint" );
|
|
|
|
Assert( n_zone > 0, "Streamer hint zone values must be > 0." );
|
|
|
|
level flagsys::set( "streamer_loading" );
|
|
|
|
level flag::wait_till( "all_players_connected" );
|
|
|
|
if ( b_clear_previous )
|
|
{
|
|
level clientfield::set( "force_streamer", 0 );
|
|
util::wait_network_frame();
|
|
}
|
|
|
|
level clientfield::set( "force_streamer", n_zone );
|
|
|
|
if( !isdefined( level.b_wait_for_streamer_default ) )
|
|
{
|
|
level.b_wait_for_streamer_default = 1;
|
|
// Don't wait in dev builds
|
|
/#
|
|
level.b_wait_for_streamer_default = 0;
|
|
#/
|
|
}
|
|
|
|
foreach ( player in level.players )
|
|
{
|
|
player thread _streamer_hint_wait( n_zone );
|
|
}
|
|
|
|
/#
|
|
|
|
n_timeout = GetTime() + ( 15 * 1000 );
|
|
|
|
#/
|
|
|
|
array::wait_till( level.players, "streamer" + n_zone, 15 );
|
|
level flagsys::clear( "streamer_loading" );
|
|
|
|
level util::streamer_wait();
|
|
|
|
/#
|
|
|
|
if ( GetTime() >= n_timeout )
|
|
{
|
|
PrintTopRightln( "FORCE STREAMER TIMEOUT - " + string::rfill( GetTime(), 6, "0" ), ( 1, 0, 0 ) );
|
|
}
|
|
else
|
|
{
|
|
PrintTopRightln( "FORCE STREAMER DONE - " + string::rfill( GetTime(), 6, "0" ), ( 1, 1, 1 ) );
|
|
}
|
|
|
|
#/
|
|
}
|
|
|
|
function _streamer_hint_wait( n_zone )
|
|
{
|
|
self endon( "disconnect" );
|
|
level endon( "set_streamer_hint" );
|
|
self waittillmatch( "streamer", n_zone );
|
|
self notify( "streamer" + n_zone );
|
|
}
|
|
|
|
/@
|
|
"Name: teleport_players_igc( <str_spots>, [coop_sort] )"
|
|
"Summary: Teleport players after a shared IGC. Functions similarly to skipto::teleport."
|
|
"CallOn: NA"
|
|
"MandatoryArg: <str_spots> : The name of the spawn point. Follows same ules as skipto system (using script_objective KVP)."
|
|
"OptionalArg: [coop_sort] : Specific which player gets which spot with the script_int KVP"
|
|
"Example: util::teleport_players_igc( "after_intro_igc" )"
|
|
@/
|
|
function teleport_players_igc( str_spots, coop_sort )
|
|
{
|
|
// Don't teleport the players if it's a solo game
|
|
if( level.players.size <= 1 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Grab the skipto points. if this skipto is the entrypoint into the level or needs each player in a particular spot, sort them for coop placement
|
|
a_spots = skipto::get_spots( str_spots, coop_sort );
|
|
|
|
// make sure there are enough points skipto spots for the players
|
|
assert( a_spots.size >= ( level.players.size - 1 ), "Need more teleport positions for players!" );
|
|
|
|
// set up each player
|
|
// ***SKIPS level.players[ 0 ]***
|
|
// This allows scene animation to place Player 0 where he needs to be without a pop
|
|
for ( i = 0; i < level.players.size - 1; i++ )
|
|
{
|
|
// Set the players' origin to each skipto point
|
|
level.players[i+1] SetOrigin( a_spots[i].origin );
|
|
|
|
if ( isdefined( a_spots[i].angles ) )
|
|
{
|
|
level.players[i+1] util::delay_network_frames( 2, "disconnect", &SetPlayerAngles, a_spots[ i ].angles );
|
|
}
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: set_low_ready( b_lowready )"
|
|
"Summary: Sets the player to low ready, hides the hud and everything else that should happen when in low ready mode
|
|
"CallOn: Player"
|
|
"MandatoryArg: <b_lowready> : True will set the player to low ready. False will turn off low ready"
|
|
"Example: e_player util::set_low_ready( true )"
|
|
@/
|
|
function set_low_ready( b_lowready )
|
|
{
|
|
self SetLowReady( b_lowready );
|
|
|
|
self SetClientUIVisibilityFlag( "weapon_hud_visible", !b_lowready );
|
|
|
|
self AllowJump( !b_lowready );
|
|
self AllowSprint( !b_lowready );
|
|
self AllowDoubleJump( !b_lowready );
|
|
|
|
if ( b_lowready )
|
|
{
|
|
self DisableOffhandWeapons();
|
|
}
|
|
else
|
|
{
|
|
self EnableOffhandWeapons();
|
|
}
|
|
|
|
oed::enable_ev( !b_lowready );
|
|
oed::enable_tac_mode( !b_lowready );
|
|
}
|
|
|
|
/@
|
|
"Name: CleanupActorCorpses()"
|
|
"Summary: Delete corpses of actors in the level
|
|
"Example: CleanupActorCorpses()"
|
|
@/
|
|
function CleanupActorCorpses()
|
|
{
|
|
foreach (corpse in GetCorpseArray())
|
|
{
|
|
if (isActorCorpse(corpse))
|
|
{
|
|
corpse Delete();
|
|
}
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: set_level_start_flag( <str_flag> )"
|
|
"Summary: Tells the level to hold a black screen until this flag is set."
|
|
"CallOn: NA"
|
|
"MandatoryArg: <str_flag> : flag to wait for"
|
|
"Example: util::set_level_start_flag( "start_level" )"
|
|
@/
|
|
function set_level_start_flag( str_flag )
|
|
{
|
|
level.str_level_start_flag = str_flag;
|
|
|
|
if ( !flag::exists( str_flag ) )
|
|
{
|
|
level flag::init( level.str_level_start_flag );
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: set_player_start_flag( <str_flag> )"
|
|
"Summary: Tells the player to hold a black screen when connecting until this flag is set."
|
|
"CallOn: NA"
|
|
"MandatoryArg: <str_flag> : flag to wait for"
|
|
"Example: util::set_level_start_flag( "start_player" )"
|
|
@/
|
|
function set_player_start_flag( str_flag )
|
|
{
|
|
level.str_player_start_flag = str_flag;
|
|
}
|
|
|
|
/@
|
|
"Name: set_rogue_controlled( b_state )"
|
|
"Summary: Sets the enemy AI to be controlled by an enemy Cyber Soldier. Used in special cases, it disables the use of certain cyber core abilities."
|
|
"Module: AI"
|
|
"CallOn: Enemy AI"
|
|
"OptionalArg: <b_state> : boolean value that toggles the rogue controlled state, defaults to true"
|
|
"Example: set_rogue_controlled( true );"
|
|
"SPMP: singleplayer"
|
|
@/
|
|
function set_rogue_controlled( b_state = true )
|
|
{
|
|
if( b_state )
|
|
{
|
|
self cybercom::cybercom_AIOptOut( "cybercom_hijack" );
|
|
self cybercom::cybercom_AIOptOut( "cybercom_iffoverride" );
|
|
self.rogue_controlled = true;
|
|
}
|
|
else
|
|
{
|
|
self cybercom::cybercom_AIClearOptOut( "cybercom_hijack" );
|
|
self cybercom::cybercom_AIClearOptOut( "cybercom_iffoverride" );
|
|
self.rogue_controlled = undefined;
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: init_breath_fx()"
|
|
"Summary: will need to init fx in the main level init to use so clienfields get registered."
|
|
"CallOn: Level"
|
|
"Example: util::init_breath_fx();"
|
|
@/
|
|
function init_breath_fx()
|
|
{
|
|
clientfield::register( "toplayer", "player_cold_breath", 1, 1, "int" );
|
|
clientfield::register( "actor", "ai_cold_breath", 1, 1, "counter" );
|
|
}
|
|
|
|
/@
|
|
"Name: player_frost_breath( b_true )"
|
|
"Summary: Plays a breath effect on player camera"
|
|
"CallOn: Player"
|
|
"Example: array::thread_all( level.activeplayers, &util::player_frost_breath, true );"
|
|
@/
|
|
function player_frost_breath( b_true ) //self = player
|
|
{
|
|
self clientfield::set_to_player( "player_cold_breath", b_true );
|
|
}
|
|
|
|
/@
|
|
"Name: ai_frost_breath( b_true )"
|
|
"Summary: Plays a breath effect on actor tag j_jaw"
|
|
"CallOn: Actors"
|
|
"Example: spawner::add_global_spawn_function( "allies", &util::ai_frost_breath );"
|
|
@/
|
|
function ai_frost_breath() // self = ai spawned
|
|
{
|
|
self endon( "death" );
|
|
|
|
if( ( self.archetype === "human" ) )
|
|
{
|
|
wait( RandomFloatRange( 1, 3 ) ); //wait for ai to be spawned for client and dont breath right away.
|
|
|
|
self clientfield::increment( "ai_cold_breath" );
|
|
}
|
|
}
|
|
|
|
|
|
/@
|
|
"Name: show_hint_text"
|
|
"Summary: Displays hint text for an amount of time. Can be turned off by sending a notify, or by calling hide_hint_text()."
|
|
"MandatoryArg: <str_text_to_show> : The text to display."
|
|
"OptionalArg: <b_should_blink> : Should this menu flash on and off?"
|
|
"OptionalArg: <str_turn_off_notify> : The use this notify to turn off the hint text."
|
|
"OptionalArg: <n_display_time> : Override how many seconds the text is displayed for."
|
|
"Example: show_hint_text( "Your help text here!", "notify_hide_help_text" );"
|
|
@/
|
|
function show_hint_text(str_text_to_show, b_should_blink=false, str_turn_off_notify="notify_turn_off_hint_text", n_display_time=4.0)
|
|
{
|
|
self endon ("notify_turn_off_hint_text");
|
|
self endon( "hint_text_removed" );
|
|
|
|
// Hide any help text which might already be up.
|
|
if ( isdefined(self.hint_menu_handle) )
|
|
{
|
|
hide_hint_text(false);
|
|
}
|
|
|
|
// Show the help text as a LUI menu.
|
|
self.hint_menu_handle = self OpenLUIMenu( "CPHintText" );
|
|
self SetLUIMenuData( self.hint_menu_handle, "hint_text_line", str_text_to_show );
|
|
|
|
// Play the blink anim inside the LUImenu if it's meant to flash
|
|
if (b_should_blink)
|
|
{
|
|
lui::play_animation(self.hint_menu_handle, "blinking");
|
|
}
|
|
else
|
|
{
|
|
lui::play_animation(self.hint_menu_handle, "display_noblink");
|
|
}
|
|
|
|
if( n_display_time != -1 )
|
|
{
|
|
// Listen for hide or death notify. This interrupts the normal wait timer.
|
|
// This thread will also ensure the LUImenu is closed when the text has been displayed for the intended amount of time.
|
|
self thread hide_hint_text_listener(n_display_time);
|
|
|
|
// Fade the hint text out after specified time if not interrupted.
|
|
// Note: the above thread will close the LUImenu when the desired time has elapsed.
|
|
self thread fade_hint_text_after_time(n_display_time, str_turn_off_notify);
|
|
}
|
|
}
|
|
|
|
/@
|
|
"Name: hide_hint_text"
|
|
"Summary: Hides any help text which may be on screen."
|
|
@/
|
|
function hide_hint_text(b_fade_before_hiding=true)
|
|
{
|
|
self endon( "hint_text_removed" );
|
|
|
|
if ( isdefined(self.hint_menu_handle) )
|
|
{
|
|
if (b_fade_before_hiding)
|
|
{
|
|
lui::play_animation(self.hint_menu_handle, "fadeout");
|
|
util::waittill_any_timeout(0.75, "kill_hint_text", "death");
|
|
}
|
|
|
|
self CloseLUIMenu(self.hint_menu_handle);
|
|
self.hint_menu_handle = undefined;
|
|
}
|
|
|
|
// Terminate hint text threads listening for remove help text notify.
|
|
self notify("hint_text_removed");
|
|
}
|
|
|
|
// Fade out hint text before its luimenu is destroyed.
|
|
// If a notify to hide hint text is passed, this will fade out the hint text as well.
|
|
function fade_hint_text_after_time(n_display_time, str_turn_off_notify)
|
|
{
|
|
self endon( "hint_text_removed" );
|
|
self endon( "death" );
|
|
self endon( "kill_hint_text" );
|
|
|
|
util::waittill_any_timeout(n_display_time - 0.75, str_turn_off_notify);
|
|
|
|
hide_hint_text(true);
|
|
}
|
|
|
|
// Listens for a notify to turn off the help text.
|
|
function hide_hint_text_listener(n_time)
|
|
{
|
|
// Stop listening for turn off on death or when the hint text has been removed:
|
|
self endon( "hint_text_removed" );
|
|
self endon( "disconnect" );
|
|
|
|
util::waittill_any_timeout(n_time, "kill_hint_text", "death");
|
|
|
|
hide_hint_text(false);
|
|
}
|
|
|
|
// Displays an event message.
|
|
function show_event_message(player_handle, str_message)
|
|
{
|
|
player_handle LUINotifyEvent( &"comms_event_message", 1, str_message );
|
|
// Event messsage sound effect should go here
|
|
}
|
|
|
|
/@
|
|
"Name: init_interactive_gameobject( trigger, str_objective, str_hint_text , func_on_use , a_keyline_objects )"
|
|
"Summary: Returns a gameobject with all necessary parameters for CP."
|
|
"Module: Utility"
|
|
"MandatoryArg: <trigger> : The trigger for the gameobject. Must be some type of use trigger"
|
|
"MandatoryArg: <str_objective> : The objective for the gameobject. This determines what icon and text appears on the object. 'Waypoint Type' of the objective should be '3D Prompt'. "
|
|
"MandatoryArg: <str_hint_text> : A string for the trigger's use prompt."
|
|
"OptionalArg: <func_on_use> : Function to run when the gameobject is used. Passes in the player who triggered the gameobject as the first parameter. Gameobject becomes 'self' in the specified function"
|
|
"OptionalArg: <a_keyline_objects> : An entity or array of entities to be keylined"
|
|
@/
|
|
function init_interactive_gameobject( trigger, str_objective, str_hint_text , func_on_use , a_keyline_objects )
|
|
{
|
|
trigger SetHintString( str_hint_text );
|
|
trigger SetCursorHint( "HINT_INTERACTIVE_PROMPT" );
|
|
|
|
if( !isdefined( a_keyline_objects ) )
|
|
{
|
|
a_keyline_objects = [];
|
|
}
|
|
else
|
|
{
|
|
if ( !isdefined( a_keyline_objects ) ) a_keyline_objects = []; else if ( !IsArray( a_keyline_objects ) ) a_keyline_objects = array( a_keyline_objects );;
|
|
|
|
foreach( mdl in a_keyline_objects )
|
|
{
|
|
mdl oed::enable_keyline( true );
|
|
}
|
|
}
|
|
|
|
game_object = gameobjects::create_use_object( "any", trigger, a_keyline_objects, ( 0, 0, 0 ), str_objective );
|
|
game_object gameobjects::allow_use( "any" );
|
|
game_object gameobjects::set_use_time( 0.35 );
|
|
game_object gameobjects::set_owner_team( "allies" );
|
|
game_object gameobjects::set_visible_team( "any" );
|
|
game_object.single_use = false;
|
|
|
|
// Set origin/angles so it can be used as an objective target.
|
|
game_object.origin = game_object.origin;
|
|
game_object.angles = game_object.angles;
|
|
|
|
if ( isdefined( func_on_use ) )
|
|
{
|
|
game_object.onUse = func_on_use;
|
|
}
|
|
|
|
return game_object;
|
|
}
|
|
|