mirror of
https://github.com/reaaLx/nx1-gsc-dump.git
synced 2025-04-22 09:05:45 +00:00
692 lines
17 KiB
Plaintext
692 lines
17 KiB
Plaintext
//****************************************************************************
|
|
// **
|
|
// Confidential - (C) Activision Publishing, Inc. 2011 **
|
|
// **
|
|
//****************************************************************************
|
|
// **
|
|
// Module: Nx Utility Scripts **
|
|
// **
|
|
// Created: 3/10/2011 - John Webb **
|
|
// **
|
|
//****************************************************************************
|
|
|
|
#include maps\_utility;
|
|
#include common_scripts\utility;
|
|
#include maps\_hud_util;
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: move_player_to_start_point( sTargetname )"
|
|
"Summary: Move player to start points"
|
|
"Module: Utility"
|
|
"CallOn: a player "
|
|
"MandatoryArg: <sTargetname>: targetname of entity to teleport the player to"
|
|
"Example: move_player_to_start_point( "intersection_start" );
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
// Player start code (orients player based on
|
|
move_player_to_start_point( sTargetname )
|
|
{
|
|
assert( isdefined( sTargetname ) );
|
|
start = getent( sTargetname, "targetname" );
|
|
self SetOrigin( start.origin );
|
|
|
|
lookat = undefined;
|
|
if ( isdefined( start.target ) )
|
|
{
|
|
lookat = getent( start.target, "targetname" );
|
|
assert( isdefined( lookat ) );
|
|
}
|
|
|
|
if ( isdefined( lookat ) )
|
|
{
|
|
self setPlayerAngles( vectorToAngles( lookat.origin - start.origin ) );
|
|
}
|
|
else
|
|
{
|
|
self setPlayerAngles( start.angles );
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: delete_ai_in_volume_not_bullet_shielded( targetname, team )"
|
|
"Summary: Deletes all non bullet shielded actors of the specified team in the volumes with the KVP targetname <targetname>"
|
|
"Module: Utility"
|
|
"CallOn: "
|
|
"MandatoryArg: <targetname>: Targetname of volume(s) to delete AI from"
|
|
"OptionalArg: <team>: 'axis' or 'allies'. Left blank the function will try to delete all ai"
|
|
"Example: delete_ai_in_volume_not_bullet_shielded( "intersection", "axis" );
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
delete_ai_in_volume_not_bullet_shielded( targetname, team )
|
|
{
|
|
if ( !isdefined( team ) )
|
|
{
|
|
team = "all";
|
|
}
|
|
|
|
areas = getentarray( targetname, "targetname" );
|
|
assert( areas.size > 0 );
|
|
|
|
foreach( area in areas )
|
|
{
|
|
array_thread( area get_ai_touching_volume( team ), ::delete_ai_not_bullet_shielded );
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: delete_ai_not_bullet_shielded()"
|
|
"Summary: Deletes Ai if not bullet shielded"
|
|
"Module: Utility"
|
|
"CallOn: An actor"
|
|
"Example: actor delete_ai_not_bullet_shielded();
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
delete_ai_not_bullet_shielded()
|
|
{
|
|
if ( isdefined( self.magic_bullet_shield ) )
|
|
return;
|
|
self delete();
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: spawn_targetname_and_return_array( targetname )"
|
|
"Summary: Attempts to spawn ai from each spawner with the KVP targetname <targetname>, and returns an array of those spawned"
|
|
"Module: Utility"
|
|
"CallOn: "
|
|
"MandatoryArg: <targetname>: Targetname of spawners to spawn from"
|
|
"OptionalArg: <spawn_limit>: Total number of Ai to be spawned from the list of spawners."
|
|
"Example: spawn_targetname_and_return_array( "street_spawners" );
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
spawn_targetname_and_return_array( targetname, spawn_limit )
|
|
{
|
|
spawners = GetEntArray( targetname, "targetname" );
|
|
guys = [];
|
|
|
|
if( IsDefined( spawn_limit ) && spawn_limit < spawners.size )
|
|
{
|
|
spawn_count = spawn_limit;
|
|
}
|
|
else
|
|
{
|
|
spawn_count = spawners.size;
|
|
}
|
|
|
|
for( i = 0; i < spawn_count; i++ )
|
|
{
|
|
spawners[i].count = 1;
|
|
guy = spawners[i] spawn_ai();
|
|
if ( IsDefined( guy ) && IsAlive( guy ) )
|
|
{
|
|
guys[ guys.size ] = guy;
|
|
}
|
|
}
|
|
return guys;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: set_springy_cam_pitch_offset( angle, reset_time )"
|
|
"Summary: Sets springy cam pitch offset angle from center (0 degrees)"
|
|
"Module: Utility"
|
|
"CallOn: "
|
|
"MandatoryArg: <angle>"
|
|
"OptionalArg: <reset_time>"
|
|
"Example: thread set_springy_cam_pitch_offset( 20, 3.0 );
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
set_springy_cam_pitch_offset( angle, reset_time )
|
|
{
|
|
if ( level._player IsSpringyCamEnabled() )
|
|
{
|
|
level._player SetSpringyCamPitchOffset( angle );
|
|
|
|
if ( IsDefined( reset_time ) )
|
|
{
|
|
wait reset_time;
|
|
|
|
if ( level._player IsSpringyCamEnabled() )
|
|
{
|
|
level._player SetSpringyCamPitchOffset( 0 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: boundry_trigger_planes_init()"
|
|
"Summary: Small system to handle players going into area's they aren't supposed to. Like old school minefields"
|
|
"Module: Utility"
|
|
"CallOn: "
|
|
"Example: boundry_trigger_planes_init();"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
boundry_trigger_planes_init()
|
|
{
|
|
// setup our flags
|
|
flag_init( "player_out_of_bounds" );
|
|
|
|
|
|
// setup our handlers for players out of bounds
|
|
patrol = GetEntArray( "border_patrol", "targetname" );
|
|
foreach( vehicle in patrol )
|
|
{
|
|
vehicle thread vehicle_handle_player_out_of_bounds();
|
|
}
|
|
// tagMJS<NOTE> other potential out bounds handlers can go here, say a mine field for example
|
|
|
|
|
|
// setup our triggers to handle a player out of bounds
|
|
array_thread( GetEntArray( "boundary_trigger", "targetname" ), ::out_of_bounds_update );;
|
|
}
|
|
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: vehicle_handle_player_out_of_bounds()"
|
|
"Summary: vehicle handler for player being out of bounds. Currently written for UGVs."
|
|
"Module: Utility"
|
|
"CallOn: "
|
|
"Example: vehicle thread vehicle_handle_player_out_of_bounds();"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
vehicle_handle_player_out_of_bounds()
|
|
{
|
|
self endon( "death" );
|
|
|
|
|
|
// we need to make sure our vehicles aren't shooting at all first
|
|
if ( IsDefined( self.mgturret ) )
|
|
{
|
|
foreach( turret in self.mgturret )
|
|
{
|
|
turret SetMode( "manual" );
|
|
}
|
|
}
|
|
|
|
|
|
while ( 1 )
|
|
{
|
|
if ( flag( "player_out_of_bounds" ) )
|
|
{
|
|
if ( IsDefined( self.mgturret ) && 0 < self.mgturret.size )
|
|
{
|
|
self.mgturret[0] SetMode( "auto_nonai" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( IsDefined( self.mgturret ) && 0 < self.mgturret.size )
|
|
{
|
|
self.mgturret[0] SetMode( "manual" );
|
|
}
|
|
}
|
|
wait 1;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: out_of_bounds_update()"
|
|
"Summary: loop called on our trigger plane to update our out of bounds flag that handlers are checking."
|
|
"Module: Utility"
|
|
"CallOn: "
|
|
"Example: out_of_bounds_update();"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
out_of_bounds_update()
|
|
{
|
|
while ( 1 )
|
|
{
|
|
if ( level._player IsTouching( self ) )
|
|
{
|
|
flag_set( "player_out_of_bounds" );
|
|
}
|
|
else
|
|
{
|
|
flag_clear( "player_out_of_bounds" );
|
|
}
|
|
wait 1;
|
|
}
|
|
}
|
|
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: scriptmodel_last_frame( targetname )"
|
|
"Summary: Locks scriptmodels to their animation's last frame"
|
|
"Module: Utility"
|
|
"CallOn: "
|
|
"MandatoryArg: <targetname>: Targetname of script_models. Script_models must have script_animation and a model defined"
|
|
"Example: scriptmodel_last_frame( "dead_crew" );
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
#using_animtree( "generic_human" );
|
|
scriptmodel_last_frame( targetname )
|
|
{
|
|
scriptmodels = GetEntArray( targetname, "targetname" );
|
|
assert( scriptmodels.size > 0 );
|
|
|
|
foreach ( scriptmodel in scriptmodels )
|
|
{
|
|
scriptmodel UseAnimTree( #animtree );
|
|
scriptmodel thread maps\_anim::anim_generic( scriptmodel, scriptmodel.script_animation );
|
|
scriptmodel SetAnimTime( getanim_generic( scriptmodel.script_animation ), 1 );
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: vehicle_get_gunner()"
|
|
"Summary: Returns actor manning the first turret on the vehicle, if any"
|
|
"Module: Utility"
|
|
"CallOn: a vehicle"
|
|
"Example: vehicle vehicle_get_gunner();
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
vehicle_get_gunner()
|
|
{
|
|
// Find a turret, if any
|
|
assert( isdefined( level._vehicle_aianims ) );
|
|
//turret_anim_pos = undefined;
|
|
|
|
for ( pos = 0; pos < level._vehicle_aianims[ self.vehicletype ].size; pos++ )
|
|
{
|
|
if ( isdefined( level._vehicle_aianims[ self.vehicletype ].mgturret ) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( ( pos == level._vehicle_aianims[ self.vehicletype ].size ) || !isdefined( self.riders ) || self.riders.size == 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
foreach ( rider in self.riders )
|
|
{
|
|
if ( rider.vehicle_position == pos )
|
|
{
|
|
if ( isalive( rider ) )
|
|
{
|
|
return rider;
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: set_battlechatter_id()"
|
|
"Summary: Sets the battlechatter id of the actor"
|
|
"Module: Utility"
|
|
"CallOn: AI"
|
|
"MandatoryArg: <bcs_id>: The string battlechatter id"
|
|
"Example: set_battlechatter_id( "eag" );"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
set_battlechatter_id( bcs_id )
|
|
{
|
|
self.npcid = bcs_id;
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: pos_dialogue()"
|
|
"Summary: Plays positional audio for dialogue and animates actor's mouth"
|
|
"Module: Utility"
|
|
"CallOn: AI"
|
|
"MandatoryArg: <scene>: The scene name (usually set in _anim.gsc)"
|
|
"MandatoryArg: <animname>: The animname to set to actor (usually set in _anim.gsc)"
|
|
"Example: set_battlechatter_id( "duke", "hithard_duke_snipe_comms" );"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
pos_dialogue( scene, animname )
|
|
{
|
|
self.animname = animname;
|
|
self dialogue_queue( scene );
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: mantle_text_on()"
|
|
"Summary: Displays the mantle hint"
|
|
"Module: Utility"
|
|
"CallOn: nothing"
|
|
"MandatoryArg:"
|
|
"Example: mantle_text_on();"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
mantle_text_on()
|
|
{
|
|
level._hud_mantle[ "text" ].alpha = 1.0;
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: mantle_text_off()"
|
|
"Summary: Turns off the mantle hint"
|
|
"Module: Utility"
|
|
"CallOn: nothing"
|
|
"MandatoryArg:"
|
|
"Example: mantle_text_off();"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
mantle_text_off()
|
|
{
|
|
level._hud_mantle[ "text" ].alpha = 0.0;
|
|
}
|
|
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: waittill_all"
|
|
"Summary: waits for multiple notifies on a single entity before continuing"
|
|
"Module: Utility"
|
|
"CallOn: nothing"
|
|
"MandatoryArg:"
|
|
"Example: waittill_all( array_of_messages );"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
waittill_all( array_of_messages )
|
|
{
|
|
flags = [];
|
|
|
|
Assert( IsDefined( array_of_messages ));
|
|
Assert( IsArray( array_of_messages ));
|
|
|
|
foreach( msg in array_of_messages )
|
|
{
|
|
flagname = "_waittill_flag_" + msg;
|
|
flag_init( flagname );
|
|
flags = add_to_array( flags, flagname );
|
|
self thread waittill_all_solo( msg, flagname );
|
|
}
|
|
|
|
foreach( flag in flags )
|
|
{
|
|
flag_wait( flag );
|
|
}
|
|
}
|
|
|
|
waittill_all_solo( msg, flag )
|
|
{
|
|
Assert( IsDefined( msg ));
|
|
Assert( IsDefined( flag ));
|
|
|
|
self waittill( msg );
|
|
flag_set( flag );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: wait_random"
|
|
"Summary: Wait a random amount of time"
|
|
"Module: Utility"
|
|
"CallOn: nothing"
|
|
"MandatoryArg: time_low - Lowest possible time (in seconds)"
|
|
"MandatoryArg: time_high - Highest possible time (in seconds)"
|
|
"Example: wait_random( time_low, time_high );"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
wait_random( time_low, time_high )
|
|
{
|
|
Assert( IsDefined( time_low ));
|
|
Assert( IsDefined( time_high ));
|
|
|
|
wait RandomFloatRange( time_low, time_high );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: assert_isdefined"
|
|
"Summary: Assert that something is defined"
|
|
"Module: Utility"
|
|
"CallOn: nothing"
|
|
"MandatoryArg:"
|
|
"Example: assert_isdefined( ent );"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
assert_isdefined( ent )
|
|
{
|
|
Assert( IsDefined( ent ));
|
|
}
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: enable_trigger_with_targetname( <name> )"
|
|
"Summary: calls trigger_on() on a trigger with targetname of <name>"
|
|
"Module: Trigger"
|
|
"MandatoryArg: <name>: string get the entity that has a targetname of <name>"
|
|
"Example: enable_trigger_with_targetname( "red_team1" );"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
enable_trigger_with_targetname( msg )
|
|
{
|
|
trigger = GetEnt( msg, "targetname" );
|
|
trigger trigger_on();
|
|
}
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: enable_trigger_with_noteworthy( <name> )"
|
|
"Summary: calls trigger_on() on a trigger with script_noteworthy of <name>"
|
|
"Module: Trigger"
|
|
"MandatoryArg: <name>: string get the entity that has a script_noteworthy of <name>"
|
|
"Example: enable_trigger_with_noteworthy( "red_team1" );"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
enable_trigger_with_noteworthy( msg )
|
|
{
|
|
trigger = GetEnt( msg, "script_noteworthy" );
|
|
trigger trigger_on();
|
|
}
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: SetGoalVolumeAuto_targetname( <name> )"
|
|
"Summary: calls trigger_on() on a trigger with script_noteworthy of <name>"
|
|
"Module: AI"
|
|
"CallOn: AI"
|
|
"MandatoryArg: <name>: volume with targetname of <name>"
|
|
"Example: SetGoalVolumeAuto_targetname( "red_team1" );"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
SetGoalVolumeAuto_targetname( targetname )
|
|
{
|
|
Assert( IsDefined( targetname ));
|
|
|
|
vol = GetEnt( targetname, "targetname" );
|
|
Assert( IsDefined( vol ));
|
|
|
|
self SetGoalVolumeAuto( vol );
|
|
self._goal_volume = vol;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: IsAlive_array( <guys> )"
|
|
"Summary: Runs IsAlive() on an array and returns true if someone is living"
|
|
"Module: Utility"
|
|
"CallOn: nothing"
|
|
"MandatoryArg: <guys>: array of enemy AI"
|
|
"Example: IsAlive_Array( enemies );"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
|
|
IsAlive_array( entities )
|
|
{
|
|
Assert( IsDefined( entities ));
|
|
Assert( IsArray( entities ));
|
|
|
|
something_lives = 0;
|
|
|
|
foreach( thing in entities )
|
|
{
|
|
if( isalive( thing ))
|
|
{
|
|
something_lives++;
|
|
}
|
|
}
|
|
|
|
return something_lives;
|
|
}
|
|
|
|
|