407 lines
12 KiB
Plaintext
407 lines
12 KiB
Plaintext
#include common_scripts\utility;
|
|
#include maps\mp\gametypes\_hud_util;
|
|
#include maps\mp\_utility;
|
|
#include maps\mp\alien\_utility;
|
|
#include maps\mp\alien\_challenge_function;
|
|
|
|
init_challenge()
|
|
{
|
|
//set up the challenge table automatically
|
|
map_name = getdvar("ui_mapname" );
|
|
level.alien_challenge_table = "mp/alien/" + map_name + "_challenges.csv";
|
|
|
|
if ( maps\mp\alien\_utility::is_hardcore_mode() )
|
|
{
|
|
level.alien_challenge_table = "mp/alien/" + map_name + "_hardcore_challenges.csv";
|
|
if ( !TableExists( level.alien_challenge_table ) )
|
|
level.alien_challenge_table = "mp/alien/" + map_name + "_challenges.csv";
|
|
}
|
|
|
|
init_challenge_type();
|
|
}
|
|
|
|
spawn_challenge()
|
|
{
|
|
if ( !alien_mode_has( "challenge" ) )
|
|
return;
|
|
|
|
level.current_challenge_index = undefined;
|
|
level thread spawn_challenge_internal();
|
|
}
|
|
|
|
spawn_challenge_internal()
|
|
{
|
|
challenge = get_valid_challenge();
|
|
if ( !isDefined ( challenge ) )
|
|
{
|
|
println( "***CHALLENGE_ERROR*** - no challenge found" );
|
|
return;
|
|
}
|
|
/#
|
|
if ( GetDvar( "scr_setactivechallenge" ) != "" )
|
|
{
|
|
challenge = GetDvar( "scr_setactivechallenge" );
|
|
SetDvar( "scr_setactivechallenge" ,"" );
|
|
}
|
|
#/
|
|
activate_new_challenge ( challenge );
|
|
}
|
|
|
|
update_challenge ( challenge_name, param_1, param_2, param_3, param_4, param_5, param_6, param_7, param_8, param_9 )
|
|
{
|
|
if ( !current_challenge_is ( challenge_name ) || !alien_mode_has( "challenge" ) )
|
|
return;
|
|
|
|
if ( level.pre_challenge_active )
|
|
return;
|
|
|
|
current_challenge = level.challenge_data [ level.current_challenge ];
|
|
current_challenge [[ current_challenge.updateFunc ]]( param_1, param_2, param_3, param_4, param_5, param_6, param_7, param_8, param_9 );
|
|
}
|
|
|
|
end_current_challenge()
|
|
{
|
|
if ( current_challenge_exist() && alien_mode_has( "challenge" ) )
|
|
deactivate_current_challenge();
|
|
}
|
|
|
|
remove_all_challenge_cases()
|
|
{
|
|
level notify ( "remove_all_challenge_case" );
|
|
}
|
|
|
|
get_valid_challenge()
|
|
{
|
|
valid_challenges = [];
|
|
|
|
foreach ( challenge in level.challenge_data )
|
|
{
|
|
if ( isDefined ( challenge.already_issued ) ) //don't repeat the challenges
|
|
continue;
|
|
if ( level.players.size == 1 && !is_true(challenge.allowedinsolo) ) //challenge not allowed in solo
|
|
continue;
|
|
|
|
if ( !isDefined ( challenge.allowed_cycles ) )
|
|
continue;
|
|
|
|
allowed_cycles = strTok( challenge.allowed_cycles, " " );
|
|
|
|
foreach ( cycle in allowed_cycles ) //see if this challenge is allowed
|
|
{
|
|
if ( level.cycle_count - 1 == int( cycle ) )
|
|
{
|
|
current_hive = maps\mp\alien\_spawn_director::get_current_encounter();
|
|
if ( !isDefined ( current_hive ) )
|
|
{
|
|
println("***CHALLENGE ERROR*** - no current hive found" );
|
|
continue;
|
|
}
|
|
|
|
if ( should_skip_challenge( challenge ) )
|
|
continue;
|
|
|
|
allowed_hives = StrTok( challenge.allowed_hives," " );
|
|
foreach ( hive in allowed_hives ) //see if this challenge is allowed for this hive
|
|
{
|
|
if ( hive == current_hive )
|
|
{
|
|
valid_challenges[ valid_challenges.size ] = challenge;
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( valid_challenges.size > 0 )
|
|
{
|
|
valid_challenge = valid_challenges[randomint( valid_challenges.size )];
|
|
valid_challenge.already_issued = true;
|
|
|
|
return valid_challenge.ref;
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
should_skip_challenge( challenge )
|
|
{
|
|
is_weapon_challenge = (challenge.ref == "ar_only" ||
|
|
challenge.ref == "smg_only" ||
|
|
challenge.ref == "lmgs_only" ||
|
|
challenge.ref == "shotguns_only" ||
|
|
challenge.ref == "2_weapons_only" ||
|
|
challenge.ref == "semi_autos_only" ||
|
|
challenge.ref == "new_weapon" ||
|
|
challenge.ref == "snipers_only" );
|
|
|
|
if( !is_weapon_challenge )
|
|
return false;
|
|
|
|
num_pistol_prestige_players = 0;
|
|
foreach ( player in level.players )
|
|
{
|
|
if ( player maps\mp\alien\_prestige::prestige_getPistolsOnly() == 1 )
|
|
num_pistol_prestige_players++;
|
|
}
|
|
|
|
if ( challenge.ref == "new_weapon" && num_pistol_prestige_players > 0 ) //skip this challenge if any single person has the nerf
|
|
return true;
|
|
|
|
if ( num_pistol_prestige_players >= level.players.size - 1 ) //skip this challenge if the majority of the players have the nerf
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
deactivate_current_challenge()
|
|
{
|
|
if ( !current_challenge_exist() )
|
|
return;
|
|
|
|
current_challenge = level.challenge_data [ level.current_challenge ];
|
|
|
|
unset_current_challenge();
|
|
if ( current_challenge [[ current_challenge.isSuccessFunc ]]() )
|
|
{
|
|
display_challenge_message ( "challenge_success",false );
|
|
current_challenge [[ current_challenge.rewardFunc ]]();
|
|
maps\mp\alien\_gamescore::update_players_encounter_performance( maps\mp\alien\_gamescore::get_challenge_score_component_name(), "challenge_complete" );
|
|
maps\mp\alien\_persistence::update_LB_alienSession_challenge( true );
|
|
maps\mp\alien\_alien_matchdata::update_challenges_status( current_challenge.ref, true );
|
|
level.num_challenge_completed++;
|
|
|
|
if ( !is_casual_mode() )
|
|
{
|
|
if ( level.num_challenge_completed == 10 )
|
|
{
|
|
foreach( player in level.players )
|
|
player maps\mp\alien\_persistence::give_player_tokens( 2, true );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
display_challenge_message ( "challenge_failed",false );
|
|
current_challenge [[ current_challenge.failFunc ]]();
|
|
level.all_challenge_completed = false;
|
|
maps\mp\alien\_persistence::update_LB_alienSession_challenge( false );
|
|
maps\mp\alien\_alien_matchdata::update_challenges_status( current_challenge.ref, false );
|
|
}
|
|
|
|
current_challenge [[ current_challenge.deactivateFunc ]]();
|
|
}
|
|
|
|
activate_new_challenge ( challenge_name )
|
|
{
|
|
assert( IsDefined( challenge_name ) && isDefined ( level.challenge_data [ challenge_name ] ) );
|
|
|
|
new_challenge = level.challenge_data [ challenge_name ];
|
|
|
|
if ( new_challenge [[ new_challenge.canActivateFunc ]]() )
|
|
{
|
|
|
|
scalar = get_challenge_scalar( challenge_name );
|
|
if ( isDefined ( scalar ) )
|
|
{
|
|
level.challenge_data[ challenge_name ].goal = scalar;
|
|
level.current_challenge_scalar = scalar;
|
|
}
|
|
else
|
|
level.current_challenge_scalar = -1;
|
|
|
|
display_challenge_message ( challenge_name, true, scalar ); //get_challenge_activate_string( new_challenge ) );
|
|
set_current_challenge ( challenge_name );
|
|
|
|
level.pre_challenge_active = true;
|
|
challenge_countdown();
|
|
level.pre_challenge_active = false;
|
|
|
|
foreach ( player in level.players )
|
|
{
|
|
player setClientOmnvar ( "ui_intel_prechallenge", 0 );
|
|
}
|
|
|
|
level.current_challenge_pre_challenge = 0;
|
|
new_challenge [[ new_challenge.activateFunc ]]();
|
|
}
|
|
else
|
|
{
|
|
new_challenge [[ new_challenge.failActivateFunc ]]();
|
|
}
|
|
}
|
|
|
|
challenge_countdown()
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
new_challenge_time = int ( gettime() + 5000 );
|
|
foreach ( player in level.players )
|
|
{
|
|
player SetClientOmnvar( "ui_intel_timer",new_challenge_time );
|
|
player SetClientOmnvar ( "ui_intel_title", 1 );
|
|
}
|
|
level.current_challenge_title = 1;
|
|
wait ( 5 );
|
|
|
|
foreach ( player in level.players )
|
|
{
|
|
player SetClientOmnvar( "ui_intel_timer",-1 );
|
|
player SetClientOmnvar ( "ui_intel_title", -1 );
|
|
}
|
|
level.current_challenge_title = -1;
|
|
wait ( .5 );
|
|
}
|
|
|
|
|
|
can_pick_up_challenge ( player )
|
|
{
|
|
if ( !IsPlayer(player) )
|
|
return false;
|
|
|
|
if ( isAI( player ) )
|
|
return false;
|
|
|
|
if ( !isAlive( player ) || ( isDefined( player.fauxDead ) && player.fauxDead ) ) //there is a time when you kill your self with remote that this will pass
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
display_challenge_message ( message, activate , scalar )
|
|
{
|
|
index = TableLookup(level.alien_challenge_table, 1, message, 0 );
|
|
|
|
foreach ( player in level.players )
|
|
{
|
|
|
|
if ( activate )
|
|
{
|
|
if ( isDefined ( scalar ) )
|
|
{
|
|
player SetClientOmnvar( "ui_intel_challenge_scalar", scalar );
|
|
}
|
|
else
|
|
{
|
|
player SetClientOmnvar( "ui_intel_challenge_scalar",-1 );
|
|
}
|
|
player setClientOmnvar ( "ui_intel_prechallenge", 1 );
|
|
player SetClientOmnvar( "ui_intel_active_index", int( index ) );
|
|
level.current_challenge_index = int( index );
|
|
level.current_challenge_pre_challenge = 1;
|
|
player PlayLocalSound( "mp_intel_received" );
|
|
|
|
}
|
|
else
|
|
{
|
|
player SetClientOmnvar( "ui_intel_active_index", -1 );
|
|
player SetClientOmnvar ( "ui_intel_progress_current",-1 );
|
|
player setClientOmnvar ( "ui_intel_progress_max",-1 );
|
|
player setClientOmnvar ( "ui_intel_percent",-1 );
|
|
player SetClientOmnvar ( "ui_intel_target_player" , -1 );
|
|
player setClientOmnvar ( "ui_intel_prechallenge", 0 );
|
|
player SetClientOmnvar( "ui_intel_timer",-1 );
|
|
player SetClientOmnvar( "ui_intel_challenge_scalar" ,-1);
|
|
|
|
level.current_challenge_index = -1;
|
|
level.current_challenge_progress_max = -1;
|
|
level.current_challenge_progress_current = -1;
|
|
level.current_challenge_percent = -1;
|
|
level.current_challenge_target_player = -1;
|
|
level.current_challenge_timer = -1;
|
|
level.current_challenge_scalar = -1;
|
|
level.current_challenge_pre_challenge = 0;
|
|
}
|
|
}
|
|
if ( activate )
|
|
return;
|
|
|
|
level thread show_challenge_outcome( message, index );
|
|
|
|
}
|
|
|
|
show_challenge_outcome( message, challenge_message_index )
|
|
{
|
|
level endon("game_ended");
|
|
wait ( 1 );
|
|
foreach ( player in level.players )
|
|
{
|
|
if ( message == "challenge_failed" )
|
|
{
|
|
player SetClientOmnvar("ui_intel_active_index", int( challenge_message_index ) );
|
|
player PlayLocalSound( "mp_intel_fail" );
|
|
}
|
|
else
|
|
{
|
|
player SetClientOmnvar("ui_intel_active_index", int ( challenge_message_index ) );
|
|
player PlayLocalSound( "mp_intel_success" );
|
|
}
|
|
}
|
|
wait ( 4 );
|
|
foreach ( player in level.players )
|
|
{
|
|
player SetClientOmnvar("ui_intel_active_index",-1 );
|
|
}
|
|
}
|
|
|
|
|
|
current_challenge_exist() { return isDefined ( level.current_challenge ); }
|
|
current_challenge_is ( challenge_name ) { return ( current_challenge_exist() && level.current_challenge == challenge_name ); }
|
|
unset_current_challenge() { level.current_challenge = undefined; }
|
|
set_current_challenge ( challenge_name ) { level.current_challenge = challenge_name; }
|
|
|
|
|
|
handle_challenge_hotjoin()
|
|
{
|
|
self endon( "disconnect" );
|
|
|
|
self setClientOmnvar ( "ui_intel_prechallenge", level.current_challenge_pre_challenge );
|
|
|
|
if ( current_challenge_exist() )
|
|
{
|
|
|
|
self SetClientOmnvar( "ui_intel_active_index", int( level.current_challenge_index ) );
|
|
self SetClientOmnvar ( "ui_intel_progress_current", int ( level.current_challenge_progress_current ) );
|
|
self setClientOmnvar ( "ui_intel_progress_max", int ( level.current_challenge_progress_max ) );
|
|
self setClientOmnvar ( "ui_intel_percent", int ( level.current_challenge_percent ) );
|
|
self SetClientOmnvar ( "ui_intel_target_player" , int ( level.current_challenge_target_player ) );
|
|
self setclientOmnvar ( "ui_intel_title", int ( level.current_challenge_title ) );
|
|
if ( level.current_challenge_timer > 0 )
|
|
self SetClientOmnvar( "ui_intel_timer", int ( gettime() + ( level.current_challenge_timer * 1000) ) );
|
|
|
|
self SetClientOmnvar( "ui_intel_challenge_scalar", level.current_challenge_scalar );
|
|
}
|
|
|
|
if ( level.current_challenge == "50_percent_accuracy" || level.current_challenge == "75_percent_accuracy" )// accuracy challenges
|
|
{
|
|
challenge = level.challenge_data[ level.current_challenge ];
|
|
self thread track_percent_accuracy_shots_fired_internal( challenge );
|
|
}
|
|
else if ( level.current_challenge == "no_reloads" ) //no reloads
|
|
{
|
|
self thread wait_for_reload();
|
|
}
|
|
else if ( level.current_challenge == "no_abilities" ) // use no abilities
|
|
{
|
|
self thread wait_for_ability_use();
|
|
}
|
|
|
|
if ( isDefined ( level.current_drill_health ) )
|
|
{
|
|
SetOmnvar( "ui_alien_drill_health_text", int( level.current_drill_health ) );
|
|
}
|
|
if ( isDefined ( level.current_drill_time ) )
|
|
{
|
|
SetOmnvar( "ui_alien_drill_end_milliseconds", int( level.current_drill_time ) );
|
|
}
|
|
}
|
|
|
|
get_num_challenge_completed()
|
|
{
|
|
if ( !isDefined( level.num_challenge_completed ) )
|
|
return 0;
|
|
else
|
|
return level.num_challenge_completed;
|
|
} |