1632 lines
37 KiB
Plaintext
1632 lines
37 KiB
Plaintext
#include common_scripts\utility;
|
|
#include maps\mp\_utility;
|
|
#include maps\mp\gametypes\_hud_util;
|
|
#include maps\mp\alien\_utility;
|
|
|
|
init()
|
|
{
|
|
|
|
// TEMP: Remove references to "team"
|
|
while ( !isDefined( game[ "allies" ] ) )
|
|
{
|
|
wait 0.05;
|
|
}
|
|
|
|
|
|
game["music"]["spawn_allies"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "allies" ) + "spawn_music";
|
|
game["music"]["defeat_allies"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "allies" ) + "defeat_music";
|
|
game["music"]["victory_allies"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "allies" ) + "victory_music";
|
|
game["music"]["winning_allies"] = "null";
|
|
game["music"]["losing_allies"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "allies" ) + "losing_music";
|
|
game["voice"]["allies"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "allies" ) + "1mc_";
|
|
|
|
game["music"]["spawn_axis"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "axis" ) + "spawn_music";
|
|
game["music"]["defeat_axis"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "axis" ) + "defeat_music";
|
|
game["music"]["victory_axis"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "axis" ) + "victory_music";
|
|
game["music"]["winning_axis"] = "null";
|
|
game["music"]["losing_axis"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "axis" ) + "losing_music";
|
|
game["voice"]["axis"] = maps\mp\gametypes\_teams::getTeamVoicePrefix( "axis" ) + "1mc_";
|
|
|
|
|
|
game["music"]["losing_time"] = "mp_time_running_out_losing";
|
|
|
|
game["music"]["suspense"] = [];
|
|
game["music"]["suspense"][game["music"]["suspense"].size] = "mp_suspense_01";
|
|
game["music"]["suspense"][game["music"]["suspense"].size] = "mp_suspense_02";
|
|
game["music"]["suspense"][game["music"]["suspense"].size] = "mp_suspense_03";
|
|
game["music"]["suspense"][game["music"]["suspense"].size] = "mp_suspense_04";
|
|
game["music"]["suspense"][game["music"]["suspense"].size] = "mp_suspense_05";
|
|
game["music"]["suspense"][game["music"]["suspense"].size] = "mp_suspense_06";
|
|
|
|
game["dialog"]["push_forward"] = "pushforward";
|
|
|
|
game["music"]["nuke_music"] = "nuke_music";
|
|
|
|
flag_init( "alien_music_playing" );
|
|
flag_init( "exfil_music_playing" );
|
|
|
|
level thread onPlayerConnect();
|
|
level thread musicController();
|
|
level thread onGameEnded();
|
|
level initAlienVOSystem();
|
|
level thread scriptable_vo_handler(); //for playing VO when scriptable items are activated
|
|
}
|
|
|
|
initAlienVOSystem()
|
|
{
|
|
level.alien_VO_priority_level = [ "high", "medium", "low" ];
|
|
}
|
|
|
|
onPlayerConnect()
|
|
{
|
|
for(;;)
|
|
{
|
|
level waittill ( "connected", player );
|
|
|
|
player thread onPlayerSpawned();
|
|
player thread initAndStartVOSystem();
|
|
}
|
|
}
|
|
|
|
|
|
onPlayerSpawned()
|
|
{
|
|
self endon ( "disconnect" );
|
|
|
|
self waittill( "spawned_player" );
|
|
|
|
if (level.script != "mp_alien_last" && (!level.splitscreen || level.splitscreen && !isDefined( level.playedStartingMusic )) )
|
|
{
|
|
//only play one spawn music
|
|
if( !self isSplitscreenPlayer() || self isSplitscreenPlayerPrimary() )
|
|
self playLocalSound( game["music"]["spawn_" + self.team] );
|
|
|
|
if ( level.splitscreen )
|
|
level.playedStartingMusic = true;
|
|
}
|
|
}
|
|
|
|
|
|
onGameEnded()
|
|
{
|
|
level waittill ( "game_win", winner );
|
|
|
|
if ( level.teamBased )
|
|
{
|
|
if ( level.splitscreen )
|
|
{
|
|
if ( winner == "allies" )
|
|
wait .01;
|
|
//playSoundOnPlayers( game["music"]["victory_allies"], "allies" );
|
|
else if ( winner == "axis" )
|
|
{
|
|
|
|
foreach ( player in level.players )
|
|
{
|
|
if ( flag( "alien_music_playing" ) )
|
|
{
|
|
player StopLocalSound( "mp_suspense_01" );
|
|
player StopLocalSound( "mp_suspense_02" );
|
|
player StopLocalSound( "mp_suspense_03" );
|
|
player StopLocalSound( "mp_suspense_04" );
|
|
player StopLocalSound( "mp_suspense_05" );
|
|
player StopLocalSound( "mp_suspense_06" );
|
|
player StopLocalSound( "mus_alien_newwave" );
|
|
flag_clear( "alien_music_playing" );
|
|
}
|
|
}
|
|
flag_set( "alien_music_playing" );
|
|
playSoundOnPlayers( game["music"]["defeat_allies"], "axis" );
|
|
}
|
|
else
|
|
playSoundOnPlayers( game["music"]["nuke_music"] );
|
|
}
|
|
else
|
|
{
|
|
if ( winner == "allies" )
|
|
{
|
|
wait .01;
|
|
//playSoundOnPlayers( game["music"]["victory_allies"], "allies" );
|
|
//playSoundOnPlayers( game["music"]["defeat_axis"], "axis" );
|
|
}
|
|
else if ( winner == "axis" )
|
|
{
|
|
foreach ( player in level.players )
|
|
{
|
|
if ( flag( "alien_music_playing" ) )
|
|
{
|
|
player StopLocalSound( "mp_suspense_01" );
|
|
player StopLocalSound( "mp_suspense_02" );
|
|
player StopLocalSound( "mp_suspense_03" );
|
|
player StopLocalSound( "mp_suspense_04" );
|
|
player StopLocalSound( "mp_suspense_05" );
|
|
player StopLocalSound( "mp_suspense_06" );
|
|
player StopLocalSound( "mus_alien_newwave" );
|
|
flag_clear( "alien_music_playing" );
|
|
}
|
|
}
|
|
flag_set( "alien_music_playing" );
|
|
playSoundOnPlayers( game["music"]["victory_axis"], "axis" );
|
|
playSoundOnPlayers( game["music"]["defeat_allies"], "allies" );
|
|
}
|
|
else
|
|
{
|
|
playSoundOnPlayers( game["music"]["nuke_music"] );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach ( player in level.players )
|
|
{
|
|
if( player isSplitscreenPlayer() && !player isSplitscreenPlayerPrimary() )
|
|
continue;
|
|
|
|
if ( player.pers["team"] != "allies" && player.pers["team"] != "axis" )
|
|
player playLocalSound( game["music"]["nuke_music"] );
|
|
else if ( isDefined( winner ) && isPlayer( winner ) && player == winner )
|
|
player playLocalSound( game["music"]["victory_" + player.pers["team"] ] );
|
|
else if ( !level.splitScreen )
|
|
player playLocalSound( game["music"]["defeat_" + player.pers["team"] ] );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
musicController()
|
|
{
|
|
level endon ( "game_ended" );
|
|
|
|
thread suspenseMusic();
|
|
|
|
level waittill ( "match_ending_soon", reason );
|
|
assert( isDefined( reason ) );
|
|
|
|
if ( getWatchedDvar( "roundlimit" ) == 1 || game["roundsPlayed"] == (getWatchedDvar( "roundlimit" ) - 1) )
|
|
{
|
|
if ( !level.splitScreen )
|
|
{
|
|
if ( reason == "time" )
|
|
{
|
|
if ( level.teamBased )
|
|
{
|
|
if ( game["teamScores"]["allies"] > game["teamScores"]["axis"] )
|
|
{
|
|
playSoundOnPlayers( game["music"]["losing_axis"], "axis" );
|
|
}
|
|
else if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
|
|
{
|
|
playSoundOnPlayers( game["music"]["losing_allies"], "allies" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
playSoundOnPlayers( game["music"]["losing_time"] );
|
|
}
|
|
}
|
|
else if ( reason == "score" )
|
|
{
|
|
if ( level.teamBased )
|
|
{
|
|
if ( game["teamScores"]["allies"] > game["teamScores"]["axis"] )
|
|
{
|
|
playSoundOnPlayers( game["music"]["losing_axis"], "axis" );
|
|
}
|
|
else if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
|
|
{
|
|
playSoundOnPlayers( game["music"]["losing_allies"], "allies" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
winningPlayer = maps\mp\gametypes\_gamescore::getHighestScoringPlayer();
|
|
losingPlayers = maps\mp\gametypes\_gamescore::getLosingPlayers();
|
|
excludeList[0] = winningPlayer;
|
|
|
|
winningPlayer playLocalSound( game["music"]["winning_" + winningPlayer.pers["team"] ] );
|
|
|
|
foreach ( otherPlayer in level.players )
|
|
{
|
|
if ( otherPlayer == winningPlayer )
|
|
continue;
|
|
|
|
otherPlayer playLocalSound( game["music"]["losing_" + otherPlayer.pers["team"] ] );
|
|
}
|
|
}
|
|
}
|
|
|
|
level waittill ( "match_ending_very_soon" );
|
|
//leaderDialog( "timesup" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( !level.hardcoreMode )
|
|
playSoundOnPlayers( game["music"]["losing_allies"] );
|
|
|
|
//leaderDialog( "timesup" );
|
|
}
|
|
}
|
|
|
|
|
|
suspenseMusic()
|
|
{
|
|
level endon ( "game_ended" );
|
|
level endon ( "match_ending_soon" );
|
|
level endon ( "nuke_went_off" );
|
|
|
|
if ( IsDefined( level.noSuspenseMusic ) && level.noSuspenseMusic )
|
|
return;
|
|
|
|
numTracks = game["music"]["suspense"].size;
|
|
wait ( 120 );
|
|
|
|
for ( ;; )
|
|
{
|
|
wait ( randomFloatRange( 60, 90 ) );
|
|
if ( !flag( "alien_music_playing" ) )
|
|
playSoundOnPlayers( game["music"]["suspense"][randomInt(numTracks)] );
|
|
}
|
|
}
|
|
|
|
|
|
//===========================================
|
|
// alienPlayerPainBreathingSound()
|
|
//===========================================
|
|
alienPlayerPainBreathingSound()
|
|
{
|
|
level endon ( "game_ended" );
|
|
self endon ( "death" );
|
|
self endon ( "disconnect" );
|
|
self endon ( "joined_team" );
|
|
self endon ( "joined_spectators" );
|
|
|
|
wait ( 2 );
|
|
|
|
while ( true )
|
|
{
|
|
wait ( 0.2 );
|
|
|
|
if ( shouldPlayPainBreathingSound() )
|
|
{
|
|
if ( self hasFemaleCustomizationModel() )
|
|
self playLocalSound ( "Fem_breathing_hurt" );
|
|
else
|
|
self playLocalSound( "breathing_hurt_alien" );
|
|
wait ( .784 );
|
|
wait ( 0.1 + randomfloat (0.8) );
|
|
}
|
|
}
|
|
}
|
|
|
|
//===========================================
|
|
// shouldPlayPainBreathingSound()
|
|
//===========================================
|
|
VERY_HURT_HEALTH = 0.55; //If player's health ratio is below this value, he is considered very hurt
|
|
shouldPlayPainBreathingSound()
|
|
{
|
|
if ( maps\mp\gametypes\aliens::isHealthRegenDisabled() ||
|
|
self isUsingRemote() ||
|
|
( isDefined( self.breathingStopTime ) && gettime() < self.breathingStopTime ) || //Still playing previous pain sound
|
|
self.health > self.maxhealth * self.healthRegenMaxPercent * VERY_HURT_HEALTH //Have enough health, not hurting
|
|
)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
playMusicBeforeReachLayer( time_to_reach_layer )
|
|
{
|
|
NEW_WAVE_MUSIC_ALIAS = "mus_alien_newwave";
|
|
|
|
wave_music_length = 8.5;
|
|
|
|
if ( time_to_reach_layer <= wave_music_length ) // Not enough time to play this music
|
|
return;
|
|
|
|
wait ( time_to_reach_layer - wave_music_length );
|
|
|
|
if ( !flag( "alien_music_playing" ) )
|
|
level thread play_alien_music( NEW_WAVE_MUSIC_ALIAS );
|
|
}
|
|
|
|
//============================================
|
|
// Downed VO
|
|
//============================================
|
|
playVOForDowned( player )
|
|
{
|
|
if ( maps\mp\alien\_utility::IsPlayingSolo() ) //no downed VO in solo mode
|
|
return;
|
|
|
|
line = player.vo_prefix + "downed";
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
playVOForRevived( player )
|
|
{
|
|
line = player.vo_prefix + "reviving";
|
|
player thread play_vo_on_player ( line );
|
|
|
|
}
|
|
|
|
playVOForWaveStart()
|
|
{
|
|
wait ( 3 );
|
|
players = get_array_of_valid_players();
|
|
|
|
if ( players.size < 1 )
|
|
return;
|
|
|
|
player = random ( players );
|
|
line = player.vo_prefix + "trouble";
|
|
player play_vo_on_player ( line );
|
|
|
|
}
|
|
|
|
|
|
playVOForBombDetonate( hive )
|
|
{
|
|
level endon( "drill_planted" );
|
|
level endon( "stop_post_hive_vo" );
|
|
|
|
if ( isDefined ( level.next_hive_vo_cycle ) && level.cycle_count < level.next_hive_vo_cycle )
|
|
return;
|
|
|
|
if ( !isDefined ( level.next_hive_vo_cycle ) ) //only play this VO once every 5-7 cycles
|
|
{
|
|
level.next_hive_vo_cycle = level.cycle_count + randomintrange( 5,8 );
|
|
}
|
|
|
|
if ( isDefined ( level.should_play_next_hive_vo_func ) )
|
|
{
|
|
if ( ![[level.should_play_next_hive_vo_func]]() )
|
|
return;
|
|
}
|
|
|
|
counter = 0;
|
|
while ( maps\mp\agents\_agent_utility::getActiveAgentsOfType( "alien" ).size > 0 )
|
|
{
|
|
wait ( 1 );
|
|
counter++;
|
|
if ( counter > 30 )
|
|
return;
|
|
}
|
|
|
|
if(hive is_door() || hive is_door_hive())
|
|
{
|
|
level notify("dlc_vo_notify","open_door_move", hive);
|
|
wait(5);
|
|
}
|
|
else
|
|
{
|
|
play_vo_when_aliens_dead();
|
|
|
|
wait ( 3 );
|
|
|
|
if ( randomint ( 100 ) > 40 )
|
|
{
|
|
play_vo_for_get_to_crater();
|
|
wait ( 5 );
|
|
}
|
|
|
|
if ( level.cycle_count > 1 )
|
|
{
|
|
playPosthiveVo(); //how much more can I take/need an upgrade
|
|
wait ( 5 );
|
|
}
|
|
}
|
|
play_vo_for_grab_drill();
|
|
|
|
wait ( 60 ); //wait 60 seconds and tell them to hit the next hive if they haven't already planted the drill by then
|
|
|
|
play_vo_for_next_hive( hive );
|
|
|
|
}
|
|
|
|
play_vo_for_next_hive( hive )
|
|
{
|
|
players = get_array_of_valid_players();
|
|
|
|
if ( players.size < 1 )
|
|
return;
|
|
|
|
player = random( players );
|
|
|
|
line = player.vo_prefix + "attack_hive_next";
|
|
|
|
player play_vo_on_player ( line, undefined, 10 );//hive destroyed VO
|
|
}
|
|
|
|
play_vo_for_get_to_crater()
|
|
{
|
|
players = get_array_of_valid_players();
|
|
|
|
if ( players.size < 1 )
|
|
return;
|
|
|
|
player = random( players );
|
|
|
|
if ( isDefined( player ) && isAlive ( player ) )
|
|
{
|
|
line = player.vo_prefix + "stayready";
|
|
player play_vo_on_player ( line ); // gotta get to the crater
|
|
}
|
|
}
|
|
|
|
play_vo_for_grab_drill()
|
|
{
|
|
players = get_array_of_valid_players();
|
|
|
|
if ( players.size < 1 )
|
|
return;
|
|
|
|
foreach ( player in players )
|
|
{
|
|
if ( isDefined ( level.drill_carrier ) && level.drill_carrier == player )
|
|
return;
|
|
}
|
|
|
|
player = random ( players );
|
|
|
|
line = player.vo_prefix + "get_drill";
|
|
if(!SoundExists(line))
|
|
line = player.vo_prefix + "order_grab_drill";
|
|
player play_vo_on_player ( line, undefined, 10 ); //grab the drill
|
|
}
|
|
|
|
|
|
PlayVOForIntro()
|
|
{
|
|
players = get_array_of_valid_players();
|
|
|
|
if ( players.size < 1 )
|
|
return;
|
|
|
|
player = random ( players );
|
|
|
|
if ( level.players.size == 1 )
|
|
{
|
|
line = player.vo_prefix + "intro";
|
|
player thread play_solo_vo ( line );
|
|
return;
|
|
}
|
|
|
|
foreach ( player in players )
|
|
{
|
|
if ( isDefined ( level.drill_carrier ) && level.drill_carrier == player )
|
|
return;
|
|
}
|
|
|
|
line = player.vo_prefix + "intro";
|
|
player play_vo_on_player ( line ); //grab the drill
|
|
}
|
|
|
|
|
|
play_vo_when_aliens_dead() //wait for aliens to be killed after the hive is destroyed...play some VO during the 'lull' , if there is a lull
|
|
{
|
|
level endon( "drill_planted" );
|
|
wait ( 1 );
|
|
players = get_array_of_valid_players();
|
|
|
|
if ( players.size < 1 )
|
|
return;
|
|
|
|
player = random ( players );
|
|
variants = ["destroyed","area_clear", "destroyed_hive_area"];
|
|
player play_vo_on_player ( player.vo_prefix + random( variants ) ); //"Area Clear"
|
|
|
|
}
|
|
|
|
playPostHiveVo()
|
|
{
|
|
players = get_array_of_valid_players();
|
|
|
|
if ( players.size < 1 )
|
|
return;
|
|
|
|
player = random( players );
|
|
|
|
//badly named alias, has nothing to do with destroying a hive
|
|
player play_vo_on_player ( player.vo_prefix + "destroyed_hive" ); //"could use an upgrade/don't know how much more I can take"
|
|
|
|
}
|
|
|
|
playVoForBlockerHiveReward()
|
|
{
|
|
lines = ["so_alien_plt_hivereward", "so_alien_plt_hivereward2"];
|
|
self play_pilot_vo( random( lines ) );
|
|
|
|
}
|
|
|
|
playVOforBlockerHive()
|
|
{
|
|
players = get_array_of_valid_players();
|
|
if ( players.size > 0 )
|
|
{
|
|
player = random ( players );
|
|
player play_vo_on_player ( player.vo_prefix + "explode_lung" );
|
|
}
|
|
|
|
counter = 0;
|
|
while ( maps\mp\agents\_agent_utility::getActiveAgentsOfType( "alien" ).size > 0 )
|
|
{
|
|
wait ( 1 );
|
|
counter++;
|
|
if ( counter > 30 ) //give up after 30 seconds
|
|
return;
|
|
}
|
|
|
|
hasdrill = false;
|
|
players = get_array_of_valid_players();
|
|
|
|
if ( players.size < 1 ) //don't play any VO if there are no valid players
|
|
return;
|
|
|
|
player = random ( players );
|
|
foreach ( player in players )
|
|
{
|
|
if ( player hasweapon( "alienbomb_mp" ) )
|
|
hasdrill = true;
|
|
}
|
|
if ( !hasdrill )
|
|
{
|
|
line = player.vo_prefix + "get_drill";
|
|
player play_vo_on_player ( line );
|
|
}
|
|
wait ( 1 );
|
|
if ( isDefined( player ) && isAlive ( player ) )
|
|
{
|
|
line = player.vo_prefix + "stayready";
|
|
player play_vo_on_player ( line );
|
|
}
|
|
|
|
}
|
|
|
|
playVOForBombPlant( player )
|
|
{
|
|
if ( isPlayingSolo() )
|
|
return;
|
|
|
|
if ( !isDefined ( player ) || !isAlive ( player ) || player is_in_laststand() )
|
|
return;
|
|
|
|
line = player.vo_prefix + "place_drill";
|
|
player play_vo_on_player ( line );
|
|
}
|
|
|
|
playVOForSpitterSpawn( alien )
|
|
{
|
|
wait ( 3 ); //wait a few seconds for the alien to start moving towards the players before calling out the VO
|
|
|
|
if ( !isDefined( alien ) )
|
|
return;
|
|
|
|
players = get_array_of_valid_players( true, alien.origin );
|
|
|
|
if ( players.size < 1 )
|
|
return;
|
|
|
|
player = players[0];
|
|
lines = [ player.vo_prefix + "near_spitter", player.vo_prefix + "inbound_spitters"];
|
|
player play_vo_on_player ( random( lines ) );
|
|
}
|
|
|
|
playVOForQueenSpawn( alien )
|
|
{
|
|
wait ( 3 ); //wait a few seconds for the alien to start moving towards the players before calling out the VO
|
|
|
|
if ( !isDefined( alien ) )
|
|
return;
|
|
|
|
players = get_array_of_valid_players( true, alien.origin );
|
|
|
|
if ( players.size < 1 )
|
|
return;
|
|
|
|
player = players[0];
|
|
|
|
lines = [ player.vo_prefix + "near_queen", player.vo_prefix + "inbound_queen"];
|
|
player play_vo_on_player ( random( lines ) );
|
|
}
|
|
|
|
playVOForIncomingChopperBlockerHive()
|
|
{
|
|
chopper_incoming_vo_lines = ["so_alien_plt_morefirepower","so_alien_blockerhive" ];
|
|
self play_pilot_vo( random( chopper_incoming_vo_lines ) );
|
|
}
|
|
|
|
playVOForProvidingCoverAtBlockerHive()
|
|
{
|
|
chopper_provide_covering_fire_vo = ["so_alien_plt_providecover", "so_alien_plt_incomming2" ];
|
|
self play_pilot_vo( random( chopper_provide_covering_fire_vo ) );
|
|
}
|
|
|
|
playVOForChopperTakingDamage()
|
|
{
|
|
variants = ["so_alien_plt_providecover2","so_alien_plt_scorpiondamage"];
|
|
self play_pilot_vo( random( variants) );
|
|
}
|
|
|
|
playVOForChopperTakingTooMuchDamage()
|
|
{
|
|
self play_pilot_vo( "so_alien_plt_toomuchheat" );
|
|
}
|
|
|
|
handleFirstEliteArrival( elite )
|
|
{
|
|
if ( level.script != "mp_alien_town" || is_chaos_mode() )
|
|
return;
|
|
|
|
foreach ( player in level.players )
|
|
{
|
|
if ( flag( "alien_music_playing" ) )
|
|
{
|
|
player StopLocalSound( "mp_suspense_01" );
|
|
player StopLocalSound( "mp_suspense_02" );
|
|
player StopLocalSound( "mp_suspense_03" );
|
|
player StopLocalSound( "mp_suspense_04" );
|
|
player StopLocalSound( "mp_suspense_05" );
|
|
player StopLocalSound( "mp_suspense_06" );
|
|
player StopLocalSound( "mus_alien_newwave" );
|
|
flag_clear( "alien_music_playing" );
|
|
}
|
|
if ( !flag( "exfil_music_playing" ) )
|
|
level thread play_alien_music( "mus_alien_queen" );
|
|
}
|
|
}
|
|
|
|
handleLastEliteDeath( elite )
|
|
{
|
|
}
|
|
|
|
Play_Nuke_Set_Music()
|
|
{
|
|
foreach ( player in level.players )
|
|
{
|
|
if ( flag( "alien_music_playing" ) )
|
|
{
|
|
player StopLocalSound( "mp_suspense_01" );
|
|
player StopLocalSound( "mp_suspense_02" );
|
|
player StopLocalSound( "mp_suspense_03" );
|
|
player StopLocalSound( "mp_suspense_04" );
|
|
player StopLocalSound( "mp_suspense_05" );
|
|
player StopLocalSound( "mp_suspense_06" );
|
|
player StopLocalSound( "mus_alien_newwave" );
|
|
player StopLocalSound( "mus_alien_queen" );
|
|
flag_clear( "alien_music_playing" );
|
|
}
|
|
level thread play_alien_music( "mus_alien_nukeset" );
|
|
flag_set( "exfil_music_playing" );
|
|
}
|
|
}
|
|
|
|
Play_Exfil_Music()
|
|
{
|
|
//level endon( "game_ended" );
|
|
|
|
foreach ( player in level.players )
|
|
{
|
|
if ( flag( "alien_music_playing" ) )
|
|
{
|
|
player StopLocalSound( "mus_alien_nukeset" );
|
|
flag_clear( "alien_music_playing" );
|
|
}
|
|
|
|
player playLocalSound( "mus_alien_exfil" );
|
|
flag_set( "exfil_music_playing" );
|
|
}
|
|
}
|
|
|
|
play2DSpawnSound()
|
|
{
|
|
|
|
}
|
|
|
|
playVOForDrillDamaged()
|
|
{
|
|
if(level.script == "mp_alien_last")
|
|
{
|
|
level notify("dlc_vo_notify", "conduit_attack");
|
|
return;
|
|
}
|
|
BOMB_DAMAGE_COOL_DOWN_TIME = 15000; //in ms
|
|
current_time = getTime();
|
|
|
|
if ( !isDefined( level.next_bomb_damage_VO_time ) || level.next_bomb_damage_VO_time < current_time )
|
|
{
|
|
level.next_bomb_damage_VO_time = current_time + randomintrange ( BOMB_DAMAGE_COOL_DOWN_TIME,BOMB_DAMAGE_COOL_DOWN_TIME + 5000 ) ;
|
|
|
|
players = get_array_of_valid_players();
|
|
player = random ( players );
|
|
|
|
if ( !isDefined ( player ) )
|
|
return;
|
|
|
|
if ( isPlayingSolo() )
|
|
{
|
|
line = player.vo_prefix + "drill_attacked";
|
|
//dlc doesn't use _solo for solo lines
|
|
solo_line = line + "_solo";
|
|
if(SoundExists(solo_line))
|
|
{
|
|
player thread play_solo_vo( line, undefined, 10 );
|
|
return;
|
|
}
|
|
}
|
|
|
|
line = player.vo_prefix + "drill_attacked";
|
|
player play_vo_on_player ( line, "high", 10 );
|
|
}
|
|
}
|
|
|
|
playVOForDrillHalfway()
|
|
{
|
|
if(level.script == "mp_alien_last")
|
|
{
|
|
level notify("dlc_vo_notify", "last_vo", "conduit_halfway");
|
|
return;
|
|
}
|
|
|
|
players = get_array_of_valid_players();
|
|
|
|
if ( players.size < 1 )
|
|
return;
|
|
|
|
player = random( players );
|
|
|
|
line = player.vo_prefix + "drill_halfway";
|
|
player play_vo_on_player ( line, undefined, 10 );
|
|
}
|
|
|
|
playVOForDrillOffline ()
|
|
{
|
|
return;
|
|
}
|
|
|
|
PlayVOForSentry( player, sentry_type )
|
|
{
|
|
if ( isPlayingSolo() )
|
|
return;
|
|
|
|
type = "turret_generic";
|
|
switch ( sentry_type )
|
|
{
|
|
case "grenade":
|
|
type = "turret_grenade";
|
|
break;
|
|
|
|
case "minigun":
|
|
type = "turret_minigun";
|
|
break;
|
|
|
|
case "sentry":
|
|
type = "sentry";
|
|
}
|
|
|
|
line = player.vo_prefix + "online_" + type;
|
|
player thread play_vo_on_player ( line );
|
|
|
|
}
|
|
playVOForIMS( player )
|
|
{
|
|
if ( isPlayingSolo() )
|
|
return;
|
|
|
|
line = player.vo_prefix + "online_ims";
|
|
player play_vo_on_player ( line );
|
|
}
|
|
|
|
playVOForDrone( player )
|
|
{
|
|
if ( isPlayingSolo() )
|
|
return;
|
|
line = player.vo_prefix + "online_drone";
|
|
player play_vo_on_player ( line );
|
|
}
|
|
|
|
playVOForMortarStrike( player )
|
|
{
|
|
if ( isPlayingSolo() )
|
|
return;
|
|
line = player.vo_prefix + "inbound_mortar";
|
|
player play_vo_on_player ( line );
|
|
}
|
|
|
|
playVOForPredator( player )
|
|
{
|
|
if ( isPlayingSolo() )
|
|
return;
|
|
|
|
line = player.vo_prefix + "inbound_missile";
|
|
player play_vo_on_player ( line );
|
|
}
|
|
|
|
PlayVOForTeamAmmo( player )
|
|
{
|
|
line = player.vo_prefix + "drop_ammo";
|
|
|
|
if ( isPlayingSolo() )
|
|
{
|
|
if ( randomint( 100 ) > 50 )
|
|
return;
|
|
|
|
line = player.vo_prefix + "equip_ammo_solo";
|
|
}
|
|
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
PlayVOForSpecialAmmo( player )
|
|
{
|
|
|
|
line = player.vo_prefix + "ready_specialammo";
|
|
|
|
if ( isPlayingSolo() )
|
|
{
|
|
if ( randomint( 100 ) > 50 )
|
|
return;
|
|
|
|
line = player.vo_prefix + "equip_ammo_solo";
|
|
}
|
|
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
PlayVOForTeamBoost( player )
|
|
{
|
|
line = player.vo_prefix + "deployed_boosters";
|
|
|
|
if ( isPlayingSolo() )
|
|
{
|
|
if ( randomint( 100 ) > 50 )
|
|
return;
|
|
|
|
line = player.vo_prefix + "equip_ammo_solo";
|
|
}
|
|
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
PlayVOForSupportItems( player )
|
|
{
|
|
line = player.vo_prefix + "inform_supportitems";
|
|
|
|
if ( isPlayingSolo() )
|
|
{
|
|
if ( randomint( 100 ) > 50 )
|
|
return;
|
|
|
|
line = player.vo_prefix + "equip_ammo_solo";
|
|
}
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
PlayVOForRandombox( player )
|
|
{
|
|
line = player.vo_prefix + "inform_supplies";
|
|
|
|
if ( isPlayingSolo() )
|
|
{
|
|
if ( randomint( 100 ) > 50 )
|
|
return;
|
|
|
|
line = player.vo_prefix + "equip_ammo_solo";
|
|
}
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
|
|
PlayVOForTeamArmor( player )
|
|
{
|
|
line = player.vo_prefix + "drop_armor";
|
|
|
|
if ( randomint ( 100 ) > 50 )
|
|
line = player.vo_prefix + "inform_armor";
|
|
|
|
if ( isPlayingSolo() )
|
|
{
|
|
if ( randomint( 100 ) > 50 )
|
|
return;
|
|
|
|
line = player.vo_prefix + "equip_ammo_solo";
|
|
}
|
|
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
playVOForDeathMachine( player )
|
|
{
|
|
line = player.vo_prefix + "online_machine_death";
|
|
player play_vo_on_player ( line );
|
|
}
|
|
|
|
playVOForWarMachine( player )
|
|
{
|
|
line = player.vo_prefix + "online_machine_war";
|
|
player play_vo_on_player ( line );
|
|
}
|
|
|
|
PlayVOForMeteor()
|
|
{
|
|
METEOR_VO_COOL_DOWN_TIME = 30000; //in ms
|
|
current_time = getTime();
|
|
|
|
if ( !isDefined( level.next_meteor_vo_time ) || level.next_meteor_vo_time < current_time )
|
|
{
|
|
level.next_meteor_vo_time = current_time + randomintrange ( METEOR_VO_COOL_DOWN_TIME, METEOR_VO_COOL_DOWN_TIME + 5000 ) ;
|
|
|
|
players = get_array_of_valid_players();
|
|
player = random( players );
|
|
if ( !isDefined ( player ) )
|
|
return;
|
|
line = player.vo_prefix + "inbound_meteor";
|
|
player play_vo_on_player ( line );
|
|
}
|
|
}
|
|
|
|
PlayVOForMinions()
|
|
{
|
|
MINION_VO_COOL_DOWN_TIME = 30000; //in ms
|
|
current_time = getTime();
|
|
|
|
if ( !isDefined( level.next_minion_vo_time ) || level.next_minion_vo_time < current_time )
|
|
{
|
|
level.next_minion_vo_time = current_time + randomintrange ( MINION_VO_COOL_DOWN_TIME, MINION_VO_COOL_DOWN_TIME + 5000 ) ;
|
|
|
|
players = get_array_of_valid_players();
|
|
|
|
if ( players.size < 1 )
|
|
return;
|
|
|
|
player = random( players );
|
|
|
|
line = player.vo_prefix + "inbound_minions";
|
|
player play_vo_on_player ( line );
|
|
}
|
|
}
|
|
|
|
playVOForTrapActivation( player, trap_type )
|
|
{
|
|
line = player.vo_prefix + "activated_trap_generic";
|
|
switch ( trap_type )
|
|
{
|
|
case "traps_fire":
|
|
line = player.vo_prefix + "activated_trap_fire";
|
|
break;
|
|
case "traps_fence":
|
|
line = player.vo_prefix + "online_electricfence";
|
|
}
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
playVOForPillage( player )
|
|
{
|
|
alias = player.vo_prefix + "good_loot";
|
|
|
|
if ( alias_2d_version_exists( player, alias ) )
|
|
player playlocalsound( get_alias_2d_version( player, alias ) );
|
|
else if(SoundExists(alias))
|
|
{
|
|
player playlocalsound( alias );
|
|
}
|
|
}
|
|
|
|
playVOforDrillHot()
|
|
{
|
|
if(level.script == "mp_alien_last")
|
|
{
|
|
level notify("dlc_vo_notify", "last_vo", "conduit_damaged");
|
|
return;
|
|
}
|
|
|
|
players = get_array_of_valid_players( true,level.drill.origin );
|
|
if ( players.size < 1 )
|
|
return;
|
|
player = players[0];
|
|
line = player.vo_prefix + "drill_hot";
|
|
player thread play_vo_on_player ( line , undefined, 10 );
|
|
}
|
|
|
|
playVOforNukeArmed( player )
|
|
{
|
|
players = get_array_of_valid_players( true,level.drill.origin );
|
|
if ( players.size < 1 )
|
|
return;
|
|
player = players[0];
|
|
line = player.vo_prefix + "nuke_armed";
|
|
player thread play_vo_on_player ( line );
|
|
|
|
//play a response line
|
|
level thread playVOForNukeCountdown();
|
|
}
|
|
|
|
playVOForNukeCountdown()
|
|
{
|
|
wait ( 10 );
|
|
players = get_array_of_valid_players( true,level.drill.origin );
|
|
if ( players.size < 1 )
|
|
return;
|
|
player = players[0];
|
|
line = player.vo_prefix + "nuke_countdown";
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
playVoFor30Seconds()
|
|
{
|
|
players = get_array_of_valid_players( true,level.drill.origin );
|
|
if ( players.size < 1 )
|
|
return;
|
|
player = players[0];
|
|
line = player.vo_prefix + "30_seconds";
|
|
player thread play_vo_on_player ( line );
|
|
wait ( 5 );
|
|
level thread playVOforGetToLz();
|
|
}
|
|
|
|
playVoFor10Seconds()
|
|
{
|
|
players = get_array_of_valid_players( true,level.drill.origin );
|
|
if ( players.size < 1 )
|
|
return;
|
|
player = players[0];
|
|
line = player.vo_prefix + "10_seconds";
|
|
player thread play_vo_on_player ( line );
|
|
|
|
}
|
|
|
|
playVOforGetToLz()
|
|
{
|
|
players = get_array_of_valid_players( true,level.drill.origin );
|
|
if ( players.size < 1 )
|
|
return;
|
|
player = random( players );
|
|
line = player.vo_prefix + "gettolz";
|
|
player thread play_vo_on_player ( line );
|
|
|
|
}
|
|
|
|
playVOforAttackChopper( player )
|
|
{
|
|
line = player.vo_prefix + "inbound_chopper";
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
playVOforAttackChopperIncoming()
|
|
{
|
|
self play_pilot_vo ("so_alien_plt_teamcallin");
|
|
}
|
|
|
|
PlayVOForAttackChopperLeaving()
|
|
{
|
|
self play_pilot_vo ("so_alien_plt_hivesuccess");
|
|
}
|
|
|
|
// maps\mp\alien\_music_and_dialog\playMedicClassSkillVO();
|
|
PlayMedicClassSkillVO( player )
|
|
{
|
|
line = player.vo_prefix + "medic_skill";
|
|
|
|
// if ( isPlayingSolo() )
|
|
// {
|
|
// if ( randomint( 100 ) > 50 )
|
|
// return;
|
|
// }
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
PlayEngineerClassSkillVO( player )
|
|
{
|
|
line = player.vo_prefix + "engr_skill";
|
|
|
|
// if ( isPlayingSolo() )
|
|
// {
|
|
// if ( randomint( 100 ) > 50 )
|
|
// return;
|
|
// }
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
PlayWeaponClassSkillVO( player )
|
|
{
|
|
line = player.vo_prefix + "weap_skill";
|
|
|
|
// if ( isPlayingSolo() )
|
|
// {
|
|
// if ( randomint( 100 ) > 50 )
|
|
// return;
|
|
// }
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
PlayTankClassSkillVO( player )
|
|
{
|
|
line = player.vo_prefix + "tank_skill";
|
|
|
|
// if ( isPlayingSolo() )
|
|
// {
|
|
// if ( randomint( 100 ) > 50 )
|
|
// return;
|
|
// }
|
|
player thread play_vo_on_player ( line );
|
|
}
|
|
|
|
playRandomVOline( vo_list, priority, timeout, interrupt )
|
|
{
|
|
random_index = RandomInt( vo_list.size );
|
|
vo_alias = vo_list[ random_index ];
|
|
playVOToAllPlayers ( vo_alias, priority, timeout, interrupt );
|
|
}
|
|
|
|
play_vo_on_player( alias, priority, timeout, interrupt, pause_time, only_local)
|
|
{
|
|
// iPrintLn ( "^1***** VO SOUND ALIAS*****: ^7" + alias );
|
|
self add_to_VO_system( alias, priority, timeout, interrupt, pause_time, only_local );
|
|
}
|
|
|
|
playVOToAllPlayers( alias, priority, timeout, interrupt, pause_time )
|
|
{
|
|
foreach ( player in level.players )
|
|
player add_to_VO_system( alias, priority, timeout, interrupt, pause_time );
|
|
}
|
|
|
|
add_to_VO_system( alias, priority, timeout, interrupt, pause_time, only_local )
|
|
{
|
|
self thread add_to_VO_system_internal( alias, priority, timeout, interrupt, pause_time, only_local );
|
|
}
|
|
|
|
add_to_VO_system_internal( alias, priority, timeout, interrupt, pause_time, only_local )
|
|
{
|
|
priority = get_validated_priority( priority );
|
|
|
|
VO_data = create_VO_data( alias, timeout, pause_time, only_local );
|
|
|
|
if ( should_interrupt_VO_system ( interrupt ) )
|
|
{
|
|
add_to_interrupt_VO( VO_data );
|
|
|
|
if ( is_VO_system_playing() )
|
|
interrupt_current_VO();
|
|
}
|
|
else
|
|
{
|
|
add_to_queue_at_priority( VO_data, priority );
|
|
}
|
|
|
|
if ( !is_VO_system_playing() )
|
|
play_VO_system();
|
|
}
|
|
|
|
get_validated_priority( priority )
|
|
{
|
|
if ( !isDefined( priority ) )
|
|
return level.alien_VO_priority_level[ level.alien_VO_priority_level.size - 1 ];
|
|
|
|
AssertEx( array_contains( level.alien_VO_priority_level, priority ), "'" + priority + "' is not a valid priority level." );
|
|
return priority;
|
|
}
|
|
|
|
play_VO_system()
|
|
{
|
|
self notify( "play_VO_system" );
|
|
}
|
|
|
|
interrupt_current_VO()
|
|
{
|
|
self stopLocalSound( get_current_VO_alias() );
|
|
self notify( "interrupt_current_VO" );
|
|
}
|
|
|
|
start_VO_system()
|
|
{
|
|
self endon( "disconnect" );
|
|
level endon( "game_ended" );
|
|
|
|
while ( true )
|
|
{
|
|
VO_to_play = get_VO_to_play();
|
|
|
|
if ( !isDefined ( VO_to_play ) )
|
|
{
|
|
set_VO_system_playing( false );
|
|
|
|
self waittill( "play_VO_system" );
|
|
|
|
if ( is_VO_system_paused() )
|
|
self waittill( "unpause_VO_system" );
|
|
|
|
continue;
|
|
}
|
|
|
|
set_VO_system_playing( true );
|
|
|
|
set_VO_currently_playing( VO_to_play );
|
|
|
|
play_VO( VO_to_play );
|
|
|
|
pause_between_VO( VO_to_play );
|
|
|
|
unset_VO_currently_playing();
|
|
}
|
|
}
|
|
|
|
playVOForScriptable( scriptable_name )
|
|
{
|
|
|
|
SCRIPTABLE_VO_COOL_DOWN_TIME = 45000; //in ms
|
|
current_time = getTime();
|
|
|
|
if ( !isDefined( level.next_scriptable_vo_time ) || level.next_scriptable_vo_time < current_time )
|
|
{
|
|
if ( isDefined( level.next_scriptable_vo_time ) ) //only give a random chance after the first time
|
|
{
|
|
if ( randomint( 100) < 60 )
|
|
return;
|
|
}
|
|
|
|
level.next_scriptable_vo_time = current_time + randomintrange ( SCRIPTABLE_VO_COOL_DOWN_TIME, SCRIPTABLE_VO_COOL_DOWN_TIME + 5000 ) ;
|
|
|
|
players = get_array_of_valid_players();
|
|
player = random( players );
|
|
if ( !isDefined ( player ) )
|
|
return;
|
|
|
|
switch ( scriptable_name )
|
|
{
|
|
case "scriptable_alien_tatra_t815_jump":
|
|
case "scriptable_alien_lynx_jump":
|
|
|
|
line = player.vo_prefix + "alien_approach_truck";
|
|
player play_vo_on_player ( line );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
play_VO( VO_to_play )
|
|
{
|
|
self endon( "interrupt_current_VO" );
|
|
|
|
if(self.sessionstate != "playing")
|
|
return;
|
|
|
|
alias = VO_to_play.alias;
|
|
if ( !SoundExists( alias ) )
|
|
{
|
|
PrintLn ( "^1*****SOUND ALIAS MISSING*****: ^7" + alias );
|
|
wait( .1 );
|
|
return;
|
|
}
|
|
|
|
if(self is_in_laststand() && !(IsSubStr(alias, "downed") || IsSubStr(alias, "last_stand")))
|
|
return;
|
|
self.vo_system_playing_vo = true;
|
|
foreach( player in level.players )
|
|
{
|
|
if ( player isSplitScreenPlayer() && !player isSplitScreenPlayerPrimary() )
|
|
continue; // In SplitScreen, don't play any VO to the secondary player to avoid doubling VO on the same kit
|
|
|
|
if ( player == self )
|
|
{
|
|
if ( alias_2d_version_exists( player, alias ) )
|
|
player playlocalsound( get_alias_2d_version( player, alias ) );
|
|
else
|
|
player playlocalsound( alias );
|
|
}
|
|
else
|
|
{
|
|
if(!is_true(VO_to_play.only_local))
|
|
self playSoundToPlayer( alias, player );
|
|
}
|
|
}
|
|
|
|
wait( get_sound_length( alias ) );
|
|
self.vo_system_playing_vo = false;
|
|
}
|
|
|
|
create_VO_data( alias, timeout, pause_time, only_local )
|
|
{
|
|
DEFAULT_TIMEOUT = 999;
|
|
MIN_BETWEEN_VO_WAIT = 1.5;
|
|
MAX_BETWEEN_VO_WAIT = 3;
|
|
|
|
VO_data = spawnStruct();
|
|
VO_data.alias = alias;
|
|
|
|
if ( !isDefined( timeout ) )
|
|
timeout = DEFAULT_TIMEOUT;
|
|
|
|
VO_data.expire_time = getTime() + timeout * 1000;
|
|
|
|
if ( !isDefined( pause_time ) )
|
|
pause_time = randomFloatRange( MIN_BETWEEN_VO_WAIT, MAX_BETWEEN_VO_WAIT );
|
|
|
|
VO_data.pause_time = pause_time;
|
|
|
|
if(is_true(only_local))
|
|
VO_data.only_local = true;
|
|
else
|
|
VO_data.only_local = false;
|
|
|
|
return VO_data;
|
|
}
|
|
|
|
get_VO_to_play()
|
|
{
|
|
VO_to_play = retrieve_interrupt_VO();
|
|
if ( isDefined ( VO_to_play ) )
|
|
return VO_to_play;
|
|
|
|
foreach ( array_index, priority_level in level.alien_VO_priority_level )
|
|
{
|
|
VO_to_play = retrieve_VO_from_queue( priority_level );
|
|
if ( isDefined ( VO_to_play ) )
|
|
return VO_to_play;
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
retrieve_interrupt_VO()
|
|
{
|
|
interrupt_VO = self.VO_system.interrupt_VO;
|
|
reset_interrupt_VO();
|
|
return interrupt_VO;
|
|
}
|
|
|
|
retrieve_VO_from_queue( priority )
|
|
{
|
|
remove_expired_VO_from_queue( priority );
|
|
return pop_first_VO_out_of_queue( priority );
|
|
}
|
|
|
|
pop_first_VO_out_of_queue( priority )
|
|
{
|
|
first_VO = self.VO_system.VO_queue[priority][0];
|
|
if ( !isDefined( first_VO ) )
|
|
return first_VO;
|
|
|
|
new_array = [];
|
|
for ( array_index = 1; array_index < self.VO_system.VO_queue[priority].size; array_index++ )
|
|
{
|
|
if ( !isDefined( self.VO_system.VO_queue[priority][array_index] ) )
|
|
break;
|
|
|
|
new_array[array_index-1] = self.VO_system.VO_queue[priority][array_index];
|
|
}
|
|
self.VO_system.VO_queue[priority] = new_array;
|
|
return first_VO;
|
|
}
|
|
|
|
remove_expired_VO_from_queue( priority )
|
|
{
|
|
current_time = getTime();
|
|
new_array = [];
|
|
foreach ( array_index, VO_data in self.VO_system.VO_queue[priority] )
|
|
{
|
|
if ( !VO_expired( VO_data, current_time ) )
|
|
new_array[new_array.size] = self.VO_system.VO_queue[priority][array_index];
|
|
}
|
|
self.VO_system.VO_queue[priority] = new_array;
|
|
}
|
|
|
|
initAndStartVOSystem()
|
|
{
|
|
self init_VO_system();
|
|
|
|
self thread start_VO_system();
|
|
}
|
|
|
|
init_VO_system()
|
|
{
|
|
VO_system = spawnStruct();
|
|
VO_system.VO_currently_playing = undefined;
|
|
VO_system.interrupt_VO = undefined;
|
|
VO_system.is_playing = false;
|
|
|
|
VO_queue = [];
|
|
foreach ( array_index, priority_level in level.alien_VO_priority_level )
|
|
{
|
|
VO_queue[priority_level] = [];
|
|
}
|
|
VO_system.VO_queue = VO_queue;
|
|
|
|
self.VO_system = VO_system;
|
|
}
|
|
|
|
pause_between_VO( VO_to_play )
|
|
{
|
|
if ( is_VO_system_paused() )
|
|
self waittill( "unpause_VO_system" );
|
|
|
|
if( VO_to_play.pause_time > 0 )
|
|
wait VO_to_play.pause_time;
|
|
}
|
|
|
|
is_VO_system_paused()
|
|
{
|
|
return is_true( self.pause_VO_system );
|
|
}
|
|
|
|
pause_VO_system( player_list )
|
|
{
|
|
foreach( player in player_list )
|
|
player.pause_VO_system = true;
|
|
}
|
|
|
|
unpause_VO_system( player_list )
|
|
{
|
|
foreach( player in player_list )
|
|
{
|
|
player.pause_VO_system = false;
|
|
}
|
|
foreach( player in player_list )
|
|
{
|
|
player notify( "unpause_VO_system" );
|
|
}
|
|
}
|
|
|
|
VO_expired( VO_data, current_time )
|
|
{
|
|
return ( current_time > VO_data.expire_time );
|
|
}
|
|
|
|
add_to_queue_at_priority( VO_data, priority )
|
|
{
|
|
self.VO_system.VO_queue[priority][self.VO_system.VO_queue[priority].size] = VO_data;
|
|
}
|
|
|
|
is_VO_system_playing()
|
|
{
|
|
return self.VO_system.is_playing;
|
|
}
|
|
|
|
set_VO_system_playing( bool )
|
|
{
|
|
self.VO_system.is_playing = bool;
|
|
}
|
|
|
|
set_VO_currently_playing( VO_to_play )
|
|
{
|
|
self.VO_system.VO_currently_playing = VO_to_play;
|
|
}
|
|
|
|
unset_VO_currently_playing()
|
|
{
|
|
self.VO_system.VO_currently_playing = undefined;
|
|
}
|
|
|
|
should_interrupt_VO_system ( interrupt )
|
|
{
|
|
return ( isDefined ( interrupt ) && interrupt );
|
|
}
|
|
|
|
add_to_interrupt_VO( VO_data )
|
|
{
|
|
self.VO_system.interrupt_VO = VO_data;
|
|
}
|
|
|
|
get_current_VO_alias()
|
|
{
|
|
return self.VO_system.VO_currently_playing.alias;
|
|
}
|
|
|
|
reset_interrupt_VO()
|
|
{
|
|
self.VO_system.interrupt_VO = undefined;
|
|
}
|
|
|
|
scriptable_vo_handler()
|
|
{
|
|
level endon( "game_ended" );
|
|
level.scriptable_vo_played = [];
|
|
while ( 1 )
|
|
{
|
|
level waittill( "scriptable",scriptable_name );
|
|
level thread playVOForScriptable( scriptable_name );
|
|
}
|
|
}
|
|
|
|
player_pain_vo()
|
|
{
|
|
PAIN_VO_COOL_DOWN_TIME = 1500; //in ms
|
|
current_time = getTime();
|
|
|
|
if ( !isDefined( self.next_pain_vo_time ) )
|
|
{
|
|
self.next_pain_vo_time = current_time + randomintrange ( PAIN_VO_COOL_DOWN_TIME, PAIN_VO_COOL_DOWN_TIME + 2000 ) ;
|
|
}
|
|
else if ( current_time < self.next_pain_vo_time )
|
|
{
|
|
return;
|
|
}
|
|
if ( self.vo_prefix == "p1_")
|
|
self PlayLocalSound( "female_death_american_1_plr" );
|
|
if ( self.vo_prefix == "p2_")
|
|
self PlayLocalSound( "generic_death_american_1_plr" );
|
|
if ( self.vo_prefix == "p3_")
|
|
self PlayLocalSound( "generic_death_american_2_plr" );
|
|
if ( self.vo_prefix == "p4_")
|
|
self PlayLocalSound( "generic_death_american_3_plr" );
|
|
|
|
self.next_pain_vo_time = current_time + randomintrange ( PAIN_VO_COOL_DOWN_TIME, PAIN_VO_COOL_DOWN_TIME + 1500 ) ;
|
|
|
|
}
|
|
|
|
play_pilot_vo ( alias )
|
|
{
|
|
sound_length = get_sound_length( alias );
|
|
self playsound( alias );
|
|
wait( sound_length );
|
|
}
|
|
|
|
play_alien_music( alias )
|
|
{
|
|
if ( flag( "alien_music_playing" ) ) // some music is playing
|
|
return;
|
|
|
|
sound_length = get_sound_length( alias );
|
|
|
|
flag_set( "alien_music_playing" );
|
|
|
|
foreach ( player in level.players )
|
|
{
|
|
if ( isReallyAlive( player ) )
|
|
player playLocalSound( alias );
|
|
}
|
|
|
|
wait( sound_length );
|
|
|
|
flag_clear( "alien_music_playing" );
|
|
}
|
|
|
|
get_sound_length( alias )
|
|
{
|
|
return ( LookupSoundLength( alias ) / 1000 );
|
|
}
|
|
|
|
ext_last_stand_sfx()
|
|
{
|
|
self playlocalsound( "mantle_cloth_plr_24_up" );
|
|
wait 0.65;
|
|
if ( self hasFemaleCustomizationModel() )
|
|
{
|
|
self playLocalSound("Fem_breathing_better");
|
|
}
|
|
else
|
|
{
|
|
self playLocalSound("breathing_better");
|
|
}
|
|
|
|
}
|
|
|
|
play_solo_vo( line , priority, timeout, interrupt, pause_time, only_local)
|
|
{
|
|
solo_line = line + "_solo";
|
|
if ( SoundExists ( solo_line ) )
|
|
self play_vo_on_player ( solo_line );
|
|
}
|
|
|
|
alias_2d_version_exists( player, alias )
|
|
{
|
|
alias_2d_version = get_alias_2d_version( player, alias );
|
|
return SoundExists( alias_2d_version );
|
|
}
|
|
|
|
get_alias_2d_version( player, alias )
|
|
{
|
|
end_of_alias = GetSubStr( alias, player.vo_prefix.size );
|
|
return( player.vo_prefix + "plr_" + end_of_alias );
|
|
}
|
|
|
|
remove_VO_data(alias_substring, priority)
|
|
{
|
|
new_array = [];
|
|
foreach ( array_index, VO_data in self.VO_system.VO_queue[priority] )
|
|
{
|
|
if (!((VO_data.alias == (self.vo_prefix + alias_substring)) || (VO_data.alias == (self.vo_prefix + "plr_" + alias_substring))))
|
|
new_array[new_array.size] = self.VO_system.VO_queue[priority][array_index];
|
|
}
|
|
self.VO_system.VO_queue[priority] = new_array;
|
|
}
|