1120 lines
33 KiB
Plaintext
1120 lines
33 KiB
Plaintext
#include maps\_anim;
|
|
#include maps\_utility;
|
|
#include common_scripts\utility;
|
|
#include maps\pel2_util;
|
|
#include maps\_vehicle_utility;
|
|
#include maps\_music;
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: see2_playSound
|
|
// CALLED ON: level
|
|
// PURPOSE: if a sound exists, add it to the line queue of lines to be played
|
|
// ADDITIONS NEEDED: None
|
|
/////////////////////////////////
|
|
see2_playSound( anime, animname )
|
|
{
|
|
if( isDefined( level.scr_sound[anime][animname] ) )
|
|
{
|
|
level.line_queue = array_add( level.line_queue, level.scr_sound[anime][animname] );
|
|
println("see2_playSound " + level.scr_sound[anime][animname]);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: see2_playAudio
|
|
// CALLED ON: level
|
|
// PURPOSE: This plays a passed soundAlias and resets the time since last line was played
|
|
// ADDITIONS NEEDED: None
|
|
/////////////////////////////////
|
|
see2_playAudio( soundAlias )
|
|
{
|
|
new_string = "";
|
|
name = "";
|
|
if( IsSubStr( soundAlias, "print:" ) )
|
|
{
|
|
// Take out the print:
|
|
for( i = 6; i < soundAlias.size; i++ )
|
|
{
|
|
new_string = new_string + soundAlias[i];
|
|
}
|
|
|
|
iprintln( name + new_string );
|
|
println( "^3TEMP DIALOGUE - " + new_string );
|
|
wait( 2 );
|
|
}
|
|
else
|
|
{
|
|
get_players()[0] playSound( soundAlias, soundAlias+" done" );
|
|
println("see2_PlayAudio : " + soundAlias);
|
|
level.dialogue_timer = 0;
|
|
get_players()[0] waittill( soundAlias+" done" );
|
|
println("see2_PlayAudio : " + soundAlias + " done.");
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: see2_handleLineQueue
|
|
// CALLED ON: level
|
|
// PURPOSE: This is a thread that continuously pops lines from the line queue and causes them
|
|
// to be played
|
|
// ADDITIONS NEEDED: Maybe add a stale line array that times out to prevent too much repetition
|
|
/////////////////////////////////
|
|
see2_handleLineQueue()
|
|
{
|
|
level endon( "kill the audio queue" );
|
|
|
|
new_array = [];
|
|
while( 1 )
|
|
{
|
|
if( level.line_queue.size == 0 )
|
|
{
|
|
wait( 0.05 );
|
|
continue;
|
|
}
|
|
|
|
see2_playAudio( level.line_queue[0] );
|
|
println("see2_handleLineQueue : Play audio " + level.line_queue[0]);
|
|
new_array = [];
|
|
for( i = 1; i < level.line_queue.size; i++ )
|
|
{
|
|
new_array = array_add( new_array, level.line_queue[i] );
|
|
}
|
|
level.line_queue = new_array;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: see2_makeRadioBreaks
|
|
// CALLED ON: level
|
|
// PURPOSE: This checks for a flag after a line is played, if it is already sets, it immediately
|
|
// plays the next line. If not, it plays a radio stop, then plays a radio start when the
|
|
// flag is set.
|
|
// ADDITIONS NEEDED: None
|
|
/////////////////////////////////
|
|
see2_makeRadioBreaks( flag )
|
|
{
|
|
if( !flag( flag ) )
|
|
{
|
|
see2_playRadioStop();
|
|
flag_wait( flag );
|
|
see2_playRadioStart();
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: see2_playRadioStart
|
|
// CALLED ON: level
|
|
// PURPOSE: This plays the sound of a radio pop to start a radio line
|
|
// ADDITIONS NEEDED: None, unless radio static is needed for coop players, then this must be
|
|
// changed to work with the queue system
|
|
/////////////////////////////////
|
|
see2_playRadioStart()
|
|
{
|
|
// playSound( level.scr_sound["generic"]["radio_static_start"];
|
|
// wait( 0.05 );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: see2_playRadioStop
|
|
// CALLED ON: level
|
|
// PURPOSE: This plays the sound of a radio pop to stop a radio line
|
|
// ADDITIONS NEEDED: None, unless radio static is needed for coop players, then this must be
|
|
// changed to work with the queue system
|
|
/////////////////////////////////
|
|
see2_playRadioStop()
|
|
{
|
|
// playSound( level.scr_sound["generic"]["radio_static_stop"];
|
|
// wait( 0.05 );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: level_intro_announcements
|
|
// CALLED ON: level
|
|
// PURPOSE: plays the three intro lines.
|
|
// ADDITIONS NEEDED: None
|
|
/////////////////////////////////
|
|
level_intro_announcements( endon_signal, complete_signal, arg1, arg2, arg3, arg4, arg5, arg6, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
|
|
see2_playRadioStart();
|
|
see2_playSound( "commissar", "intro1" );
|
|
|
|
see2_playSound( "commissar", "intro2" );
|
|
|
|
see2_playSound( "commissar", "intro3" );
|
|
|
|
see2_playRadioStop();
|
|
|
|
level notify( complete_signal );
|
|
|
|
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: first_88_obj
|
|
// CALLED ON: level
|
|
// PURPOSE: calls out the first 88 position
|
|
// ADDITIONS NEEDED: None
|
|
/////////////////////////////////
|
|
first_88_obj( endon_signal, complete_signal, destroyed_first_88, arg2, arg3, arg4, arg5, arg6, arg7 )
|
|
{
|
|
//tuey sets music state to FIRST_FIGHT
|
|
setmusicstate("FIRST_FIGHT");
|
|
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
|
|
if( flag( destroyed_first_88 ) )
|
|
{
|
|
return;
|
|
}
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "first_88" );
|
|
see2_playRadioStop();
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: second_88_obj
|
|
// CALLED ON: level
|
|
// PURPOSE: Calls out the second 88 and encourages the player to fire when it is in their sights
|
|
// ADDITIONS NEEDED:
|
|
/////////////////////////////////
|
|
second_88_obj( endon_signal, complete_signal, second_88_in_sights, destroyed_second_88, arg3, arg4, arg5, arg6, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
if( flag( destroyed_second_88 ) )
|
|
{
|
|
return;
|
|
}
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "second_88" );
|
|
|
|
see2_makeRadioBreaks( second_88_in_sights );
|
|
|
|
if( !flag( destroyed_second_88 ) )
|
|
{
|
|
see2_playSound( "reznov", "second_88_fire" );
|
|
see2_playRadioStop();
|
|
}
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: flamethrower_tutorial
|
|
// CALLED ON: level
|
|
// PURPOSE: Tells the player to fire the flamethrower, waits for them to do so, tells the player to
|
|
// ADS, waits for them to do so, tells the player to flame the infantry when he is close
|
|
// enough.
|
|
// ADDITIONS NEEDED: Tutorial HUD elems don't always clean up properly, needs to be investigated
|
|
// and fixed.
|
|
//
|
|
// GLockes: this now threads a tutorial for each player
|
|
//
|
|
/////////////////////////////////
|
|
flamethrower_tutorial( endon_signal, complete_signal, flame_on_success, ads_success, flamethrower_prox, arg4, arg5, arg6, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
|
|
//level thread do_hud_for_ft_tut( endon_signal, complete_signal );
|
|
//-- thread this for each player
|
|
players = get_players();
|
|
for( i = 0; i < players.size; i++ )
|
|
{
|
|
players[i] thread do_hud_for_ft_tut_by_client( endon_signal, complete_signal );
|
|
}
|
|
|
|
level thread cleanup_ft_tut_hud( endon_signal, complete_signal );
|
|
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "flame_tip" );
|
|
|
|
see2_makeRadioBreaks( flame_on_success );
|
|
|
|
see2_playSound( "reznov", "flame_success" );
|
|
|
|
see2_makeRadioBreaks( ads_success );
|
|
|
|
see2_playSound( "reznov", "ads_success" );
|
|
|
|
see2_makeRadioBreaks( flamethrower_prox );
|
|
|
|
see2_playSound( "reznov", "flame_prompt" );
|
|
|
|
see2_playRadioStop();
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: cleanup_ft_tut_hud
|
|
// CALLED ON: level
|
|
// PURPOSE: When the event is completed or interrupted, cleans up tutorial hud
|
|
// ADDITIONS NEEDED: None
|
|
/////////////////////////////////
|
|
cleanup_ft_tut_hud( endon_signal, complete_signal )
|
|
{
|
|
level waittill_either( endon_signal, complete_signal );
|
|
|
|
if( !isDefined( level.hint_huds ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
for( i = 0; i < get_players().size; i++ )
|
|
{
|
|
level.hint_huds[i].alpha = 0;
|
|
level.hint_huds[i] setText( "" );
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: do_hud_for_ft_tut
|
|
// CALLED ON: level
|
|
// PURPOSE: Shows the prompts telling the player to press the flamethrower and ads buttons.
|
|
// ADDITIONS NEEDED: None
|
|
/////////////////////////////////
|
|
|
|
do_hud_for_ft_tut( endon_signal, complete_signal )
|
|
{
|
|
level endon( endon_signal );
|
|
level endon( complete_signal );
|
|
|
|
players = get_players();
|
|
|
|
level.hint_huds = [];
|
|
for( i = 0; i < players.size; i++ )
|
|
{
|
|
level.hint_huds[i] = newClientHudElem( players[i] );
|
|
level.hint_huds[i].x = 220;
|
|
level.hint_huds[i].y = 200;
|
|
level.hint_huds[i].fontScale = 1.5;
|
|
level.hint_huds[i] setText( &"SEE2_FLAMETHROWER_HINT" );
|
|
}
|
|
|
|
flag_wait( "flamethrower_fired_once" );
|
|
|
|
for( i = 0; i < players.size; i++ )
|
|
{
|
|
level.hint_huds[i] setText( &"SEE2_ADS_HINT" );
|
|
}
|
|
|
|
flag_wait( "ads_once" );
|
|
|
|
for( i = 0; i < players.size; i++ )
|
|
{
|
|
level.hint_huds[i].alpha = 0;
|
|
level.hint_huds[i] setText( "" );
|
|
}
|
|
}
|
|
|
|
|
|
do_hud_for_ft_tut_by_client( endon_signal, complete_signal )
|
|
{
|
|
level endon( endon_signal );
|
|
level endon( complete_signal );
|
|
|
|
//-- Check and see if the player is the host (he is the only one with the flamethrower)
|
|
has_flamethrower = false;
|
|
if( self == get_players()[0] )
|
|
{
|
|
has_flamethrower = true;
|
|
}
|
|
|
|
//-- find the players index (because I don't know if level.hint_huds is used for anything ); GLocke
|
|
i = 0;
|
|
players = get_players();
|
|
for(j = 0; j < players.size; j++)
|
|
{
|
|
if( players[j] == self )
|
|
{
|
|
i = j;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!IsDefined(level.hint_huds))
|
|
{
|
|
level.hint_huds = [];
|
|
}
|
|
|
|
level.hint_huds[i] = newClientHudElem( self );
|
|
level.hint_huds[i].x = 220;
|
|
level.hint_huds[i].y = 200;
|
|
level.hint_huds[i].fontScale = 1.5;
|
|
|
|
if( has_flamethrower )
|
|
{
|
|
level.hint_huds[i] setText( &"SEE2_FLAMETHROWER_HINT" );
|
|
}
|
|
else
|
|
{
|
|
level.hint_huds[i] setText( &"SEE2_MG_COOP_HINT" );
|
|
}
|
|
|
|
//flag_wait( "flamethrower_fired_once" );
|
|
|
|
if( self != get_players()[0] )
|
|
{
|
|
flame_allowed_time = 0;
|
|
while( !(self FragButtonPressed()) && flame_allowed_time > 120 ) //-- or wait 6 seconds
|
|
{
|
|
wait( 0.05 );
|
|
flame_allowed_time++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self waittill( "go_past_ft_tut" );
|
|
}
|
|
|
|
wait(0.5);
|
|
|
|
//-- this wait is just for looks
|
|
level.hint_huds[i] setText( "" );
|
|
wait(0.2);
|
|
|
|
level.hint_huds[i] setText( &"SEE2_ADS_HINT" );
|
|
|
|
//flag_wait( "ads_once" );
|
|
|
|
if( self != get_players()[0] )
|
|
{
|
|
ads_time_allowed = 0;
|
|
while( !(self AdsButtonPressed()) && ads_time_allowed > 120 ) //-- or wait 6 seconds
|
|
{
|
|
wait( 0.05 );
|
|
ads_time_allowed++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(!flag( "ads_once" ))
|
|
{
|
|
self waittill( "go_past_ads_tut" );
|
|
}
|
|
else
|
|
{
|
|
ads_time_allowed = 0;
|
|
while( !(self AdsButtonPressed()) && ads_time_allowed > 120 ) //-- or wait 6 seconds
|
|
{
|
|
wait( 0.05 );
|
|
ads_time_allowed++;
|
|
}
|
|
}
|
|
}
|
|
|
|
wait(0.5);
|
|
level.hint_huds[i].alpha = 0;
|
|
level.hint_huds[i] setText( "" );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: tank_reload_movement_tutorial
|
|
// CALLED ON: level
|
|
// PURPOSE: Tells the player to keeping moving the first time they are hit by enemy fire, and then
|
|
// warns them that they are vulnerable when reloading after they have fired their first shot
|
|
// ADDITIONS NEEDED: None, currently unused
|
|
/////////////////////////////////
|
|
tank_reload_movement_tutorial( endon_signal, complete_signal, first_fired_on_event, first_shot, arg3, arg4, arg5, arg6, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
flag_wait( first_fired_on_event );
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "motion_is_life" );
|
|
|
|
see2_playRadioStart();
|
|
|
|
|
|
flag_wait( first_shot );
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "reloading" );
|
|
|
|
see2_playRadioStart();
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: First panther prompt
|
|
// CALLED ON: level
|
|
// PURPOSE: Warns the player about panther tanks and introduces the new enemy when it first appears
|
|
// ADDITIONS NEEDED: None, currently unused
|
|
/////////////////////////////////
|
|
first_panther_prompt( endon_signal, complete_signal, panther_activated, panther_in_sights, panther_first_shot, panther_second_shot, panther_third_shot, panther_dead, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
flag_wait( panther_activated );
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "first_panther1" );
|
|
|
|
see2_playRadioStop();
|
|
flag_wait( panther_in_sights );
|
|
if( !flag( panther_dead ) )
|
|
{
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "first_panther2" );
|
|
|
|
see2_playRadioStop();
|
|
flag_wait( panther_first_shot );
|
|
|
|
if( !flag( panther_dead ) )
|
|
{
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "first_panther3" );
|
|
|
|
see2_playRadioStop();
|
|
flag_wait( panther_second_shot );
|
|
|
|
}
|
|
if( !flag( panther_dead ) )
|
|
{
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "first_panther4" );
|
|
|
|
see2_playRadioStop();
|
|
flag_wait( panther_third_shot );
|
|
|
|
}
|
|
}
|
|
flag_wait( panther_dead );
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "first_panther_dead" );
|
|
|
|
see2_playRadioStop();
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: choose_path
|
|
// CALLED ON: level
|
|
// PURPOSE: Tells the player to choose a path to proceed through the first area
|
|
// ADDITIONS NEEDED: None, coop only (since there are no artillery to the NW in SP, untested
|
|
/////////////////////////////////
|
|
choose_path( endon_signal, complete_signal, arg1, arg2, arg3, arg4, arg5, arg6, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
|
|
if( !flag( "coop" ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "route" );
|
|
see2_playRadioStop();
|
|
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "route2" );
|
|
see2_playRadioStop();
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: choose_right_path
|
|
// CALLED ON: level
|
|
// PURPOSE: Calls out the artillery on the right path
|
|
// ADDITIONS NEEDED: None, coop only (since there are no artillery to the NW in SP, untested
|
|
/////////////////////////////////
|
|
choose_right_path( endon_signal, complete_signal, destroyed_both_88s, destroyed_second_last_88, destroyed_last_88, arg4, arg5, arg6, arg7 )
|
|
{
|
|
flag_waitopen( "playback happening" );
|
|
|
|
if( !flag( "coop" ) || flag( destroyed_both_88s ) || flag( destroyed_second_last_88 ) || flag( destroyed_last_88 ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "field_88s" );
|
|
see2_playRadioStop();
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: choose_left_path
|
|
// CALLED ON: level
|
|
// PURPOSE: Calls out the artillery on the left path
|
|
// ADDITIONS NEEDED: None, coop only (since there are no artillery to the NW in SP, untested
|
|
/////////////////////////////////
|
|
choose_left_path( endon_signal, complete_signal, destroyed_both_88s, destroyed_second_last_88, destroyed_last_88, arg4, arg5, arg6, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
|
|
if( flag( destroyed_both_88s ) || flag( destroyed_second_last_88 ) || flag( destroyed_last_88 ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "road_88s" );
|
|
see2_playRadioStop();
|
|
|
|
flag_set( "left_path" );
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: dead_88
|
|
// CALLED ON: level
|
|
// PURPOSE: Gives Reznov's cheers and feedback as you kill objective artillery
|
|
// ADDITIONS NEEDED: None, coop only lines have not been tested
|
|
/////////////////////////////////
|
|
dead_88( endon_signal, complete_signal, destroyed_first_88, destroyed_second_88, destroyed_both_88s, destroyed_second_last_88, destroyed_last_88, arg6, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
|
|
flag_wait( destroyed_first_88 );
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "first_88_destroy" );
|
|
see2_makeRadioBreaks( destroyed_second_88 );
|
|
see2_playSound( "reznov", "second_88_destroy" );
|
|
if( flag( "coop" ) )
|
|
{
|
|
see2_makeRadioBreaks( destroyed_both_88s );
|
|
if( !flag( "left_path" ) )
|
|
{
|
|
see2_playSound( "reznov", "road_88s_destroy" );
|
|
}
|
|
else
|
|
{
|
|
see2_playSound( "reznov", "field_88s_destroy" );
|
|
}
|
|
}
|
|
|
|
see2_makeRadioBreaks( destroyed_second_last_88 );
|
|
see2_playSound( "reznov", "second_last_88" );
|
|
see2_makeRadioBreaks( destroyed_last_88 );
|
|
see2_playSound( "reznov", "last_88_destroy" );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: player_exposed
|
|
// CALLED ON: level
|
|
// PURPOSE: Tells the player that they are exposed and being targeted by everyone and their mom
|
|
// ADDITIONS NEEDED: None, currently not used
|
|
/////////////////////////////////
|
|
player_exposed( endon_signal, complete_signal, first_warning_given, second_warning_given, arg3, arg4, arg5, arg6, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
|
|
if( !flag( first_warning_given ) )
|
|
{
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "center_map1" );
|
|
|
|
see2_playRadioStop();
|
|
flag_set( first_warning_given );
|
|
|
|
}
|
|
|
|
if( !flag( second_warning_given ) )
|
|
{
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "center_map2" );
|
|
|
|
see2_playRadioStop();
|
|
flag_set( second_warning_given );
|
|
}
|
|
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "center_map3" );
|
|
|
|
see2_playRadioStop();
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: radio_tower_dialog
|
|
// CALLED ON: level
|
|
// PURPOSE: Gives the radio tower objective, calls it out when it is visible, encourages its
|
|
// destruction when close and gives feedback when it is destroyed
|
|
// ADDITIONS NEEDED:
|
|
/////////////////////////////////
|
|
radio_tower_dialog( endon_signal, complete_signal, radio_tower_visible, radio_tower_close, radio_tower_destroyed, arg4, arg5, arg6, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
|
|
see2_playRadioStart();
|
|
see2_playSound( "commissar", "radio_tower_obj" );
|
|
|
|
see2_playRadioStop();
|
|
|
|
see2_playRadioStart();
|
|
see2_playSound( "reznov", "onward" );
|
|
|
|
if( !flag( radio_tower_visible ) )
|
|
{
|
|
see2_playSound( "reznov", "next_area" );
|
|
|
|
see2_makeRadioBreaks( radio_tower_visible );
|
|
}
|
|
see2_playSound( "reznov", "radio_tower_prompt" );
|
|
|
|
see2_playRadioStop();
|
|
|
|
flag_wait( radio_tower_close );
|
|
|
|
see2_playRadioStart();
|
|
if( !flag( radio_tower_destroyed ) )
|
|
{
|
|
see2_playSound( "reznov", "radio_tower2" );
|
|
|
|
see2_makeRadioBreaks( radio_tower_destroyed );
|
|
}
|
|
see2_playSound( "reznov", "radio_tower_destroy" );
|
|
|
|
see2_playSound( "reznov", "train3" );
|
|
|
|
see2_playRadioStop();
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: fuel_depot_dialog
|
|
// CALLED ON: level
|
|
// PURPOSE: Introduces the fuel depot area as the rallying point before the train station
|
|
// ADDITIONS NEEDED: None
|
|
/////////////////////////////////
|
|
fuel_depot_dialog( endon_signal, complete_signal, arg1, arg2, arg3, arg4, arg5, arg6, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
|
|
see2_playSound( "reznov", "train2" );
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: final_battle_dialog
|
|
// CALLED ON: level
|
|
// PURPOSE: Commissar encourages the players to push on to the train station
|
|
// ADDITIONS NEEDED: Additional dialogue calling out the airstrike, still needs to be recorded
|
|
/////////////////////////////////
|
|
final_battle_dialog( endon_signal, complete_signal, arg1, arg2, arg3, arg4, arg5, arg6, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
|
|
see2_playSound( "commissar", "almost_there1" );
|
|
see2_playSound( "commissar", "almost_there2" );
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: victory_dialog
|
|
// CALLED ON: level
|
|
// PURPOSE: plays the victory dialogue from the commissar when the victory trigger is breached
|
|
// ADDITIONS NEEDED: None
|
|
/////////////////////////////////
|
|
victory_dialog( endon_signal, complete_signal, arg1, arg2, arg3, arg4, arg5, arg6, arg7 )
|
|
{
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
|
|
see2_playSound( "commissar", "victory1");
|
|
see2_playSound( "commissar", "victory2");
|
|
see2_playSound( "commissar", "victory3");
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: do_battlechatter
|
|
// CALLED ON: level
|
|
// PURPOSE: Plays battlechatter if there hasn't been any other dialogue in a fixed period of time.
|
|
// It first checks the following priorities:
|
|
// 1. Infantry close enough to flame
|
|
// 2. Enemy is in the player's sights
|
|
// 3. An opel has just begun its retreat or the player has overrun a bunker position
|
|
// 4. The player has recently taken damage
|
|
// 5. The player is currently suffering from heavy damage
|
|
// 6. The player has destroyed a tank or fortification recently
|
|
// If none of those is true, it finds the most important entity around the player then
|
|
// tells the player about it.
|
|
// ADDITIONS NEEDED: This is all predicated off of the host. This may need to be switched over to
|
|
// a per client model. The see2::update_target_flag would have to be threaded
|
|
// per client for this to work.
|
|
/////////////////////////////////
|
|
do_battlechatter( endon_signal, complete_signal, do_firing, heavy_damage, damage, infantry_close, retreaters, destruction, idle )
|
|
{
|
|
level endon( "kill the audio queue" );
|
|
level endon( endon_signal );
|
|
flag_waitopen( "playback happening" );
|
|
current_idle_line = 1;
|
|
|
|
while( 1 )
|
|
{
|
|
if( !flag( "battlechatter allowed" ) )
|
|
{
|
|
wait( 0.05 );
|
|
continue;
|
|
}
|
|
|
|
if( level.dialogue_timer > level.time_between_dialogue )
|
|
{
|
|
if( flag( idle ) )
|
|
{
|
|
if( current_idle_line <= level.num_idle_lines )
|
|
{
|
|
clear_battlechatter_flags( do_firing, heavy_damage, damage, infantry_close, retreaters, destruction, idle );
|
|
see2_playSound( "reznov", "idle"+current_idle_line );
|
|
current_idle_line++;
|
|
}
|
|
}
|
|
if( flag( infantry_close ) )
|
|
{
|
|
clear_battlechatter_flags( do_firing, heavy_damage, damage, infantry_close, retreaters, destruction, idle );
|
|
see2_playSound( "reznov", "infantry_close"+randomintrange( 1, 7 ) );
|
|
}
|
|
else if( flag( do_firing ) )
|
|
{
|
|
clear_battlechatter_flags( do_firing, heavy_damage, damage, infantry_close, retreaters, destruction, idle );
|
|
see2_playSound( "reznov", "shoot"+randomintrange( 1, 7 ) );
|
|
}
|
|
else if( flag( retreaters ) )
|
|
{
|
|
clear_battlechatter_flags( do_firing, heavy_damage, damage, infantry_close, retreaters, destruction, idle );
|
|
see2_playSound( "reznov", "retreaters"+randomintrange(1, 4) );
|
|
}
|
|
else if( flag( damage ) )
|
|
{
|
|
clear_battlechatter_flags( do_firing, heavy_damage, damage, infantry_close, retreaters, destruction, idle );
|
|
see2_playSound( "reznov", "hit"+randomintrange( 1, 7 ) );
|
|
}
|
|
else if( flag( heavy_damage ) )
|
|
{
|
|
clear_battlechatter_flags( do_firing, heavy_damage, damage, infantry_close, retreaters, destruction, idle );
|
|
if( ( get_players()[0].myTank.armor/get_players()[0].myTank.maxarmor ) < 0.1 )
|
|
{
|
|
see2_playSound( "reznov", "almost_dead" );
|
|
}
|
|
else
|
|
{
|
|
see2_playSound( "reznov", "half_damage" );
|
|
}
|
|
}
|
|
else if( flag( destruction ) )
|
|
{
|
|
id = randomintrange( 1, 12 );
|
|
clear_battlechatter_flags( do_firing, heavy_damage, damage, infantry_close, retreaters, destruction, idle );
|
|
if( id < 10 )
|
|
{
|
|
see2_playSound( "reznov", "generic_destroy"+id );
|
|
}
|
|
else
|
|
{
|
|
see2_playSound( "commissar", "generic_destroy"+id );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
object = get_players()[0] get_most_threatening_object();
|
|
if( isDefined( object ) )
|
|
{
|
|
level.identified_entities = array_add( level.identified_entities, object );
|
|
direction = get_players()[0].myTank get_heading_of_object( object );
|
|
designation = get_designation( object );
|
|
if( isDefined( direction ) && isDefined( designation ) )
|
|
{
|
|
see2_playSound( "reznov", designation );
|
|
see2_playSound( "reznov", direction );
|
|
}
|
|
}
|
|
wait( 1 );
|
|
}
|
|
}
|
|
wait( 1 );
|
|
}
|
|
|
|
level notify( complete_signal );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: clear_battlechatter_flags
|
|
// CALLED ON: level
|
|
// PURPOSE: Clears out the flags to prevent stacking of multiple battlechatter lines if we hit a
|
|
// dead zone
|
|
// ADDITIONS NEEDED: None
|
|
/////////////////////////////////
|
|
clear_battlechatter_flags( almost_dead, half_damage, damage, infantry_close, retreaters, destruction, idle )
|
|
{
|
|
flag_clear( infantry_close );
|
|
flag_clear( retreaters );
|
|
flag_clear( damage );
|
|
flag_clear( half_damage );
|
|
flag_clear( almost_dead );
|
|
flag_clear( destruction );
|
|
flag_clear( idle );
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: get_most_threatening_object
|
|
// CALLED ON: an entity
|
|
// PURPOSE: This finds the entity considered most threatening or important to the player then
|
|
// returns it.
|
|
// ADDITIONS NEEDED: Prioritization will need to be tweaked. Infantry is not currently identified.
|
|
// Infantry should be reenabled when we have more infantry callout lines. Each
|
|
// for loop should add best_ent to level.identified_entities when it sets it as
|
|
// best_ent. A better tracing function should be used for callouts since they
|
|
// callout non-visible enemies sometimes, seeming like bugs
|
|
/////////////////////////////////
|
|
get_most_threatening_object()
|
|
{
|
|
best_dist = 10000000000;
|
|
best_ent = undefined;
|
|
// First favor any armor that has us as their target which we cannot see
|
|
for( i = 0; i < level.enemy_armor.size; i++ )
|
|
{
|
|
if( isDefined( level.enemy_armor[i] ) && level.enemy_armor[i].health > 0 && level.enemy_armor[i].classname != "script_vehicle_corpse" )
|
|
{
|
|
dist = distanceSquared( level.enemy_armor[i].origin, self.origin );
|
|
if( isDefined( level.enemy_armor[i].current_target ) && level.enemy_armor[i].current_target == self && dist < best_dist && array_check_for_dupes( level.identified_entities, level.enemy_armor[i] ) && level.enemy_armor[i].model != "artillery_ger_flak88" )
|
|
{
|
|
object_origin = ( level.enemy_armor[i].origin[0], level.enemy_armor[i].origin[1], 0 );
|
|
player_origin = ( self.origin[0], self.origin[1], 0 );
|
|
player_vec = anglesToForward( self.angles );
|
|
player_vec = ( player_vec[0], player_vec[1], 0 );
|
|
player_vec = VectorNormalize( player_vec );
|
|
target_vec = VectorNormalize( object_origin - player_origin );
|
|
dot = VectorDot( target_vec, player_vec );
|
|
if( acos( dot ) < 32.5 )
|
|
{
|
|
best_ent = level.enemy_armor[i];
|
|
best_dist = dist;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
wait(0.05);
|
|
|
|
//Barring that, check for other tanks within 3000 units of us but out of our view arc
|
|
for( z = 0; z < level.enemy_armor.size; z++ )
|
|
{
|
|
if( isDefined( level.enemy_armor[z] ) && level.enemy_armor[z].health > 0 && level.enemy_armor[z].classname != "script_vehicle_corpse" && array_check_for_dupes( level.identified_entities, level.enemy_armor[z] ) && level.enemy_armor[z].model != "artillery_ger_flak88")
|
|
{
|
|
dist = distanceSquared( level.enemy_armor[z].origin, self.origin );
|
|
if( dist < best_dist)
|
|
{
|
|
object_origin = ( level.enemy_armor[z].origin[0], level.enemy_armor[z].origin[1], 0 );
|
|
player_origin = ( self.origin[0], self.origin[1], 0 );
|
|
player_vec = anglesToForward( self.angles );
|
|
player_vec = ( player_vec[0], player_vec[1], 0 );
|
|
player_vec = VectorNormalize( player_vec );
|
|
target_vec = VectorNormalize( object_origin - player_origin );
|
|
dot = VectorDot( target_vec, player_vec );
|
|
//trace = bullettrace( player_origin+(0, 0, 120), object_origin+(0, 0, 120), false, get_players()[0].myTank );
|
|
if( acos( dot ) > 10 )
|
|
{
|
|
trace = bullettrace( player_origin+(0, 0, 120), object_origin+(0, 0, 120), false, get_players()[0].myTank );
|
|
if( trace["fraction"] > 0.95 )
|
|
{
|
|
best_ent = level.enemy_armor[z];
|
|
best_dist = dist;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
wait(0.05);
|
|
|
|
// Next check for guard towers that are still active but not in the view arc
|
|
guard_tower_array = GetEntArray( "guard tower damage trigger", "script_noteworthy" );
|
|
for( j = 0; j < guard_tower_array.size; j++ )
|
|
{
|
|
if( isDefined( guard_tower_array[j] ) && !isDefined( guard_tower_array[j].destroyed ) && array_check_for_dupes( level.identified_entities, guard_tower_array[j] ) )
|
|
{
|
|
dist = distanceSquared( guard_tower_array[j].origin, self.origin );
|
|
if( dist < best_dist)
|
|
{
|
|
object_origin = ( guard_tower_array[j].origin[0], guard_tower_array[j].origin[1], 0 );
|
|
player_origin = ( self.origin[0], self.origin[1], 0 );
|
|
player_vec = anglesToForward( self.angles );
|
|
player_vec = ( player_vec[0], player_vec[1], 0 );
|
|
player_vec = VectorNormalize( player_vec );
|
|
target_vec = VectorNormalize( object_origin - player_origin );
|
|
dot = VectorDot( target_vec, player_vec );
|
|
if( acos( dot ) > 10 )
|
|
{
|
|
trace = bullettrace( player_origin+(0, 0, 120), object_origin+(0, 0, 120), false, get_players()[0].myTank );
|
|
if( trace["fraction"] > 0.95 )
|
|
{
|
|
best_ent = guard_tower_array[j];
|
|
best_dist = dist;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
wait(0.05);
|
|
|
|
/*
|
|
// Next check for enemy panzerschrecks who are not retreating
|
|
for( k = 0; k < level.enemy_infantry.size; k++ )
|
|
{
|
|
if( isDefined( level.enemy_infantry[k] ) && level.enemy_infantry[k].health > 0 && array_check_for_dupes( level.identified_entities, level.enemy_infantry[k] ))
|
|
{
|
|
dist = distanceSquared( level.enemy_infantry[k].origin, self.origin );
|
|
if( dist < best_dist)
|
|
{
|
|
object_origin = ( level.enemy_infantry[k].origin[0], level.enemy_infantry[k].origin[1], 0 );
|
|
player_origin = ( self.origin[0], self.origin[1], 0 );
|
|
player_vec = anglesToForward( self.angles );
|
|
player_vec = ( player_vec[0], player_vec[1], 0 );
|
|
player_vec = VectorNormalize( player_vec );
|
|
target_vec = VectorNormalize( object_origin - player_origin );
|
|
dot = VectorDot( target_vec, player_vec );
|
|
best_ent = level.enemy_infantry[k];
|
|
best_dist = dist;
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
// Finally check for retreating troop transports in the player view arc
|
|
retreat_truck_array = getEntArray( "retreat truck", "targetname" );
|
|
for( m = 0; m < retreat_truck_array.size; m++ )
|
|
{
|
|
if( isDefined( retreat_truck_array[m] ) && retreat_truck_array[m].health > 0 && retreat_truck_array[m].classname != "script_vehicle_corpse" )
|
|
{
|
|
dist = distanceSquared( retreat_truck_array[m].origin, self.origin );
|
|
if( dist < best_dist)
|
|
{
|
|
object_origin = ( retreat_truck_array[m].origin[0], retreat_truck_array[m].origin[1], 0 );
|
|
player_origin = ( self.origin[0], self.origin[1], 0 );
|
|
player_vec = anglesToForward( self.angles );
|
|
player_vec = ( player_vec[0], player_vec[1], 0 );
|
|
player_vec = VectorNormalize( player_vec );
|
|
target_vec = VectorNormalize( object_origin - player_origin );
|
|
dot = VectorDot( target_vec, player_vec );
|
|
if( acos( dot ) > 32.5 )
|
|
{
|
|
trace = bullettrace( player_origin+(0, 0, 120), object_origin+(0, 0, 120), false, get_players()[0].myTank );
|
|
if( trace["fraction"] > 0.95 )
|
|
{
|
|
best_ent = retreat_truck_array[m];
|
|
best_dist = dist;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return best_ent;
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: get_designation
|
|
// CALLED ON: level
|
|
// PURPOSE: Returns the designation of the object used to index into level.designation and
|
|
// determine what callout lines to play
|
|
// ADDITIONS NEEDED: Add bunkers as a designation, entries already exist in level.designation
|
|
// located in see2_anim
|
|
/////////////////////////////////
|
|
get_designation( object )
|
|
{
|
|
designation = undefined;
|
|
if( object.classname == "script_vehicle" && object.model != "artillery_ger_flak88" )
|
|
{
|
|
size = level.designation[object.model].size;
|
|
index = 0;
|
|
if( size > 1 )
|
|
{
|
|
index = randomint( size );
|
|
}
|
|
designation = level.designation[object.model][index];
|
|
}
|
|
else if( object.script_noteworthy == "guard tower damage trigger" )
|
|
{
|
|
size = level.designation["guard_tower"].size;
|
|
index = 0;
|
|
if( size > 1 )
|
|
{
|
|
index = randomint( size );
|
|
}
|
|
designation = level.designation["guard_tower"][index];
|
|
}
|
|
else
|
|
{
|
|
size = level.designation[object.classname].size;
|
|
index = 0;
|
|
if( size > 1 )
|
|
{
|
|
index = randomint( size );
|
|
}
|
|
designation = level.designation[object.classname][index];
|
|
}
|
|
return designation;
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// FUNCTION: get_heading_of_object
|
|
// CALLED ON: entity
|
|
// PURPOSE: Finds the heading (right, left, ahead, behind) for an object relative to the entity
|
|
// ADDITIONS NEEDED: None
|
|
/////////////////////////////////
|
|
get_heading_of_object( object )
|
|
{
|
|
if( isDefined( object ) )
|
|
{
|
|
// Give behind/in front precedence since they are more descriptive to players
|
|
theirPos = ( object.origin[0], object.origin[1], 0 );
|
|
myPos = ( self.origin[0], self.origin[1], 0 );
|
|
|
|
diff = object.origin - self.origin;
|
|
angles = vectorToAngles( diff );
|
|
|
|
diff = abs( self.angles[1] - angles[1] );
|
|
|
|
if( diff > 315 || diff <= 45 )
|
|
{
|
|
return "ahead"+randomintrange(1,3);
|
|
}
|
|
if( diff <= 135 && diff > 45 )
|
|
{
|
|
max = 4;
|
|
if( diff >100 )
|
|
{
|
|
max = 5;
|
|
}
|
|
return "right"+randomintrange(1,max);
|
|
}
|
|
if( diff > 135 && diff <= 225 )
|
|
{
|
|
return "behind"+randomintrange(1,3);
|
|
}
|
|
if( diff > 225 && diff <= 315 )
|
|
{
|
|
max = 4;
|
|
if( diff < 260 )
|
|
{
|
|
max = 5;
|
|
}
|
|
return "left"+randomintrange(1,max);
|
|
}
|
|
}
|
|
} |