2507 lines
69 KiB
Text
2507 lines
69 KiB
Text
#include maps\_utility;
|
|
#include animscripts\utility;
|
|
#include common_scripts\utility;
|
|
// this script handles all major global gameskill considerations
|
|
setSkill( reset, skill_override )
|
|
{
|
|
if ( !isdefined( level.script ) )
|
|
level.script = tolower( getdvar( "mapname" ) );
|
|
|
|
|
|
if ( !isdefined( reset ) || reset == false )
|
|
{
|
|
if ( isdefined( level.gameSkill ) )
|
|
return;
|
|
|
|
if ( !isdefined( level.custom_player_attacker ) )
|
|
level.custom_player_attacker = ::return_false;
|
|
|
|
level.global_damage_func_ads = ::empty_kill_func;
|
|
level.global_damage_func = ::empty_kill_func;
|
|
level.global_kill_func = ::empty_kill_func;
|
|
if ( getdvar( "arcademode" ) == "1" )
|
|
thread maps\_arcademode::main();
|
|
|
|
// first init stuff
|
|
set_console_status();
|
|
flag_init( "player_has_red_flashing_overlay" );
|
|
flag_init( "player_is_invulnerable" );
|
|
flag_clear( "player_has_red_flashing_overlay" );
|
|
flag_clear( "player_is_invulnerable" );
|
|
level.difficultyType[ 0 ] = "easy";
|
|
level.difficultyType[ 1 ] = "normal";
|
|
level.difficultyType[ 2 ] = "hardened";
|
|
level.difficultyType[ 3 ] = "veteran";
|
|
|
|
level.difficultyString[ "easy" ] = &"GAMESKILL_EASY";
|
|
level.difficultyString[ "normal" ] = &"GAMESKILL_NORMAL";
|
|
level.difficultyString[ "hardened" ] = &"GAMESKILL_HARDENED";
|
|
level.difficultyString[ "veteran" ] = &"GAMESKILL_VETERAN";
|
|
// thread update_skill_on_change();
|
|
/#
|
|
thread playerHealthDebug();
|
|
#/
|
|
}
|
|
|
|
level.gameSkill = getdvarint( "g_gameskill" );
|
|
if ( isdefined( skill_override ) )
|
|
level.gameSkill = skill_override;
|
|
setdvar( "saved_gameskill", level.gameSkill );
|
|
|
|
|
|
// createprintchannel( "script_autodifficulty" );
|
|
|
|
if ( getdvar( "autodifficulty_playerDeathTimer" ) == "" )
|
|
setdvar( "autodifficulty_playerDeathTimer", 0 );
|
|
|
|
anim.run_accuracy = 0.5;
|
|
|
|
logString( "difficulty: " + level.gameSkill );
|
|
|
|
// if ( getdvar( "autodifficulty_frac" ) == "" )
|
|
setdvar( "autodifficulty_frac", 0 );// disabled for now
|
|
|
|
level.difficultySettings_stepFunc_percent = [];
|
|
level.difficultySettings_frac_data_points = [];
|
|
level.auto_adjust_threatbias = true;
|
|
|
|
setTakeCoverWarnings();
|
|
thread increment_take_cover_warnings_on_death();
|
|
|
|
level.mg42badplace_mintime = 8;// minimum # of seconds a badplace is created on an mg42 after its operator dies
|
|
level.mg42badplace_maxtime = 16;// maximum # of seconds a badplace is created on an mg42 after its operator dies
|
|
|
|
// anim.playerGrenadeBaseTime
|
|
add_fractional_data_point( "playerGrenadeBaseTime", 0.0, 50000 );
|
|
add_fractional_data_point( "playerGrenadeBaseTime", 0.25, 40000 ); // original easy
|
|
add_fractional_data_point( "playerGrenadeBaseTime", 0.75, 25000 ); // original normal
|
|
add_fractional_data_point( "playerGrenadeBaseTime", 1.0, 13500 );
|
|
level.difficultySettings[ "playerGrenadeBaseTime" ][ "hardened" ] = 10000;
|
|
level.difficultySettings[ "playerGrenadeBaseTime" ][ "veteran" ] = 0;
|
|
|
|
// anim.playerGrenadeRangeTime
|
|
add_fractional_data_point( "playerGrenadeRangeTime", 0.0, 22000 );
|
|
add_fractional_data_point( "playerGrenadeRangeTime", 0.25, 20000 ); // original easy
|
|
add_fractional_data_point( "playerGrenadeRangeTime", 0.75, 15000 ); // original normal
|
|
add_fractional_data_point( "playerGrenadeRangeTime", 1.0, 7500 );
|
|
level.difficultySettings[ "playerGrenadeRangeTime" ][ "hardened" ] = 5000;
|
|
level.difficultySettings[ "playerGrenadeRangeTime" ][ "veteran" ] = 1;
|
|
|
|
// time between instances where 2 grenades land near player at once( hardcoded to never happen in easy )
|
|
add_fractional_data_point( "playerDoubleGrenadeTime", 0.25, 60 * 60 * 1000 ); // original easy
|
|
add_fractional_data_point( "playerDoubleGrenadeTime", 0.75, 120 * 1000 ); // original normal
|
|
add_fractional_data_point( "playerDoubleGrenadeTime", 1.0, 20 * 1000 );
|
|
level.difficultySettings[ "playerDoubleGrenadeTime" ][ "hardened" ] = 15 * 1000;
|
|
level.difficultySettings[ "playerDoubleGrenadeTime" ][ "veteran" ] = 0;
|
|
|
|
level.difficultySettings[ "double_grenades_allowed" ][ "easy" ] = false;
|
|
level.difficultySettings[ "double_grenades_allowed" ][ "normal" ] = true;
|
|
level.difficultySettings[ "double_grenades_allowed" ][ "hardened" ] = true;
|
|
level.difficultySettings[ "double_grenades_allowed" ][ "veteran" ] = true;
|
|
level.difficultySettings_stepFunc_percent[ "double_grenades_allowed" ] = 0.75;
|
|
|
|
|
|
add_fractional_data_point( "player_deathInvulnerableTime", 0.25, 4000 ); // original easy
|
|
add_fractional_data_point( "player_deathInvulnerableTime", 0.75, 1700 ); // original normal
|
|
add_fractional_data_point( "player_deathInvulnerableTime", 1.0, 850 );
|
|
level.difficultySettings[ "player_deathInvulnerableTime" ][ "hardened" ] = 600;
|
|
level.difficultySettings[ "player_deathInvulnerableTime" ][ "veteran" ] = 100;
|
|
|
|
add_fractional_data_point( "threatbias", 0.0, 80 );
|
|
add_fractional_data_point( "threatbias", 0.25, 100 ); // original easy
|
|
add_fractional_data_point( "threatbias", 0.75, 150 ); // original normal
|
|
add_fractional_data_point( "threatbias", 1.0, 165 );
|
|
level.difficultySettings[ "threatbias" ][ "hardened" ] = 200;
|
|
level.difficultySettings[ "threatbias" ][ "veteran" ] = 400;
|
|
|
|
// level.longRegenTime
|
|
/*
|
|
redFlashingOverlay() controls how long the overlay flashes, this var controls how long it takes
|
|
before your health comes back
|
|
*/
|
|
add_fractional_data_point( "longRegenTime", 1.0, 5000 );
|
|
level.difficultySettings[ "longRegenTime" ][ "hardened" ] = 5000;
|
|
level.difficultySettings[ "longRegenTime" ][ "veteran" ] = 5000;
|
|
|
|
// level.healthOverlayCutoff
|
|
add_fractional_data_point( "healthOverlayCutoff", 0.25, 0.01 ); // original easy
|
|
add_fractional_data_point( "healthOverlayCutoff", 0.75, 0.2 ); // original normal
|
|
add_fractional_data_point( "healthOverlayCutoff", 1.0, 0.25 );
|
|
level.difficultySettings[ "healthOverlayCutoff" ][ "hardened" ] = 0.3;
|
|
level.difficultySettings[ "healthOverlayCutoff" ][ "veteran" ] = 0.5;
|
|
|
|
// level.healthOverlayCutoff
|
|
add_fractional_data_point( "base_enemy_accuracy", 0.25, 1 ); // original easy
|
|
add_fractional_data_point( "base_enemy_accuracy", 0.75, 1 ); // original normal
|
|
level.difficultySettings[ "base_enemy_accuracy" ][ "hardened" ] = 1.3;
|
|
level.difficultySettings[ "base_enemy_accuracy" ][ "veteran" ] = 1.3;
|
|
|
|
// lower numbers = higher accuracy for AI at a distance
|
|
add_fractional_data_point( "accuracyDistScale", 0.25, 1.0 ); // original easy
|
|
add_fractional_data_point( "accuracyDistScale", 0.75, 1.0 ); // original normal
|
|
level.difficultySettings[ "accuracyDistScale" ][ "hardened" ] = 1.0;
|
|
level.difficultySettings[ "accuracyDistScale" ][ "veteran" ] = 0.5;
|
|
|
|
// level.playerDifficultyHealth
|
|
add_fractional_data_point( "playerDifficultyHealth", 0.0, 550 );
|
|
add_fractional_data_point( "playerDifficultyHealth", 0.25, 475 ); // original easy
|
|
add_fractional_data_point( "playerDifficultyHealth", 0.75, 275 ); // original normal
|
|
add_fractional_data_point( "playerDifficultyHealth", 1.0, 210 );
|
|
level.difficultySettings[ "playerDifficultyHealth" ][ "hardened" ] = 165;
|
|
level.difficultySettings[ "playerDifficultyHealth" ][ "veteran" ] = 115;
|
|
|
|
// anim.min_sniper_burst_delay_time
|
|
add_fractional_data_point( "min_sniper_burst_delay_time", 0.0, 3.5 );
|
|
add_fractional_data_point( "min_sniper_burst_delay_time", 0.25, 3.0 ); // original easy
|
|
add_fractional_data_point( "min_sniper_burst_delay_time", 0.75, 2.0 ); // original normal
|
|
add_fractional_data_point( "min_sniper_burst_delay_time", 1.0, 1.80 );
|
|
level.difficultySettings[ "min_sniper_burst_delay_time" ][ "hardened" ] = 1.5;
|
|
level.difficultySettings[ "min_sniper_burst_delay_time" ][ "veteran" ] = 1.1;
|
|
|
|
// anim.max_sniper_burst_delay_time
|
|
add_fractional_data_point( "max_sniper_burst_delay_time", 0.0, 4.5 );
|
|
add_fractional_data_point( "max_sniper_burst_delay_time", 0.25, 4.0 ); // original easy
|
|
add_fractional_data_point( "max_sniper_burst_delay_time", 0.75, 3.0 ); // original normal
|
|
add_fractional_data_point( "max_sniper_burst_delay_time", 1.0, 2.5 );
|
|
level.difficultySettings[ "max_sniper_burst_delay_time" ][ "hardened" ] = 2.0;
|
|
level.difficultySettings[ "max_sniper_burst_delay_time" ][ "veteran" ] = 1.5;
|
|
|
|
|
|
add_fractional_data_point( "dog_health", 0.0, 0.2 );
|
|
add_fractional_data_point( "dog_health", 0.25, 0.25 ); // original easy
|
|
add_fractional_data_point( "dog_health", 0.75, 0.75 ); // original normal
|
|
add_fractional_data_point( "dog_health", 1.0, 0.8 );
|
|
level.difficultySettings[ "dog_health" ][ "hardened" ] = 1.0;
|
|
level.difficultySettings[ "dog_health" ][ "veteran" ] = 1.0;
|
|
|
|
|
|
add_fractional_data_point( "dog_presstime", 0.25, 415 ); // original easy
|
|
add_fractional_data_point( "dog_presstime", 0.75, 375 ); // original normal
|
|
level.difficultySettings[ "dog_presstime" ][ "hardened" ] = 250;
|
|
level.difficultySettings[ "dog_presstime" ][ "veteran" ] = 225;
|
|
|
|
level.difficultySettings[ "dog_hits_before_kill" ][ "easy" ] = 2;
|
|
level.difficultySettings[ "dog_hits_before_kill" ][ "normal" ] = 1;
|
|
level.difficultySettings[ "dog_hits_before_kill" ][ "hardened" ] = 0;
|
|
level.difficultySettings[ "dog_hits_before_kill" ][ "veteran" ] = 0;
|
|
level.difficultySettings_stepFunc_percent[ "dog_hits_before_kill" ] = 0.5;
|
|
|
|
|
|
// anim.pain_test
|
|
level.difficultySettings[ "pain_test" ][ "easy" ] = ::always_pain;
|
|
level.difficultySettings[ "pain_test" ][ "normal" ] = ::always_pain;
|
|
level.difficultySettings[ "pain_test" ][ "hardened" ] = ::pain_protection;
|
|
level.difficultySettings[ "pain_test" ][ "veteran" ] = ::pain_protection;
|
|
anim.pain_test = level.difficultySettings[ "pain_test" ][ get_skill_from_index( level.gameskill ) ];
|
|
|
|
// missTime is a number based on the distance from the AI to the player + some baseline
|
|
// it simulates bad aim as the AI starts shooting, and helps give the player a warning before they get hit.
|
|
// this is used for auto and semi auto.
|
|
// missTime = missTimeConstant + distance * missTimeDistanceFactor
|
|
|
|
level.difficultySettings[ "missTimeConstant" ][ "easy" ] = 1.0; // 0.2;// 0.3;
|
|
level.difficultySettings[ "missTimeConstant" ][ "normal" ] = 0.05;// 0.1;
|
|
level.difficultySettings[ "missTimeConstant" ][ "hardened" ] = 0;// 0.04;
|
|
level.difficultySettings[ "missTimeConstant" ][ "veteran" ] = 0;// 0.03;
|
|
// determines which misstime constant to use based on difficulty frac. Hard and Vet use their own settings.
|
|
level.difficultySettings_stepFunc_percent[ "missTimeConstant" ] = 0.5;
|
|
|
|
|
|
level.difficultySettings[ "missTimeDistanceFactor" ][ "easy" ] = 0.8 / 1000; // 0.4
|
|
level.difficultySettings[ "missTimeDistanceFactor" ][ "normal" ] = 0.1 / 1000;
|
|
level.difficultySettings[ "missTimeDistanceFactor" ][ "hardened" ] = 0.05 / 1000;
|
|
level.difficultySettings[ "missTimeDistanceFactor" ][ "veteran" ] = 0;
|
|
// determines which missTimeDistanceFactor to use based on difficulty frac. Hard and Vet use their own settings.
|
|
level.difficultySettings_stepFunc_percent[ "missTimeDistanceFactor" ] = 0.5;
|
|
|
|
add_fractional_data_point( "flashbangedInvulFactor", 0.25, 0.25 ); // original easy
|
|
add_fractional_data_point( "flashbangedInvulFactor", 0.75, 0.0 ); // original normal
|
|
level.difficultySettings[ "flashbangedInvulFactor" ][ "easy" ] = 0.25;
|
|
level.difficultySettings[ "flashbangedInvulFactor" ][ "normal" ] = 0;
|
|
level.difficultySettings[ "flashbangedInvulFactor" ][ "hardened" ] = 0;
|
|
level.difficultySettings[ "flashbangedInvulFactor" ][ "veteran" ] = 0;
|
|
|
|
// level.invulTime_preShield: time player is invulnerable when hit before their health is low enough for a red overlay( should be very short )
|
|
add_fractional_data_point( "invulTime_preShield", 0.0, 0.7 );
|
|
add_fractional_data_point( "invulTime_preShield", 0.25, 0.6 ); // original easy
|
|
add_fractional_data_point( "invulTime_preShield", 0.75, 0.35 ); // original normal
|
|
add_fractional_data_point( "invulTime_preShield", 1.0, 0.3 );
|
|
level.difficultySettings[ "invulTime_preShield" ][ "hardened" ] = 0.1;
|
|
level.difficultySettings[ "invulTime_preShield" ][ "veteran" ] = 0.0;
|
|
|
|
// level.invulTime_onShield: time player is invulnerable when hit the first time they get a red health overlay( should be reasonably long )
|
|
add_fractional_data_point( "invulTime_onShield", 0.0, 1.0 );
|
|
add_fractional_data_point( "invulTime_onShield", 0.25, 0.8 ); // original easy
|
|
add_fractional_data_point( "invulTime_onShield", 0.75, 0.5 ); // original normal
|
|
add_fractional_data_point( "invulTime_onShield", 1.0, 0.3 );
|
|
level.difficultySettings[ "invulTime_onShield" ][ "hardened" ] = 0.1;
|
|
level.difficultySettings[ "invulTime_onShield" ][ "veteran" ] = 0.05;
|
|
|
|
// level.invulTime_postShield: time player is invulnerable when hit after the red health overlay is already up( should be short )
|
|
add_fractional_data_point( "invulTime_postShield", 0.0, 0.6 );
|
|
add_fractional_data_point( "invulTime_postShield", 0.25, 0.5 ); // original easy
|
|
add_fractional_data_point( "invulTime_postShield", 0.75, 0.3 ); // original normal
|
|
add_fractional_data_point( "invulTime_postShield", 1.0, 0.2 );
|
|
level.difficultySettings[ "invulTime_postShield" ][ "hardened" ] = 0.1;
|
|
level.difficultySettings[ "invulTime_postShield" ][ "veteran" ] = 0.0;
|
|
|
|
// level.playerHealth_RegularRegenDelay
|
|
// The delay before you regen health after getting hurt
|
|
add_fractional_data_point( "playerHealth_RegularRegenDelay", 0.0, 3500 );
|
|
add_fractional_data_point( "playerHealth_RegularRegenDelay", 0.25, 3000 ); // original easy
|
|
add_fractional_data_point( "playerHealth_RegularRegenDelay", 0.75, 2000 ); // original normal
|
|
add_fractional_data_point( "playerHealth_RegularRegenDelay", 1.0, 1500 );
|
|
level.difficultySettings[ "playerHealth_RegularRegenDelay" ][ "hardened" ] = 1200;
|
|
level.difficultySettings[ "playerHealth_RegularRegenDelay" ][ "veteran" ] = 1200;
|
|
|
|
// level.worthyDamageRatio( player must recieve this much damage as a fraction of maxhealth to get invulTime. )
|
|
add_fractional_data_point( "worthyDamageRatio", 0.25, 0.0 ); // original easy
|
|
add_fractional_data_point( "worthyDamageRatio", 0.75, 0.1 ); // original normal
|
|
level.difficultySettings[ "worthyDamageRatio" ][ "hardened" ] = 0.1;
|
|
level.difficultySettings[ "worthyDamageRatio" ][ "veteran" ] = 0.1;
|
|
|
|
// level.explosiveplanttime
|
|
level.difficultySettings[ "explosivePlantTime" ][ "easy" ] = 10;
|
|
level.difficultySettings[ "explosivePlantTime" ][ "normal" ] = 10;
|
|
level.difficultySettings[ "explosivePlantTime" ][ "hardened" ] = 5;
|
|
level.difficultySettings[ "explosivePlantTime" ][ "veteran" ] = 5;
|
|
level.explosiveplanttime = level.difficultySettings[ "explosivePlantTime" ][ get_skill_from_index( level.gameskill ) ];
|
|
|
|
// anim.difficultyBasedAccuracy
|
|
level.difficultySettings[ "difficultyBasedAccuracy" ][ "easy" ] = 1;
|
|
level.difficultySettings[ "difficultyBasedAccuracy" ][ "normal" ] = 1;
|
|
level.difficultySettings[ "difficultyBasedAccuracy" ][ "hardened" ] = 1;
|
|
level.difficultySettings[ "difficultyBasedAccuracy" ][ "veteran" ] = 1.25;
|
|
anim.difficultyBasedAccuracy = getRatio( "difficultyBasedAccuracy", level.gameskill, level.gameskill );
|
|
|
|
// in case there are no enties in the map.
|
|
level.lastPlayerSighted = 0;
|
|
|
|
// only easy and normal do adjusting
|
|
difficulty_starting_frac[ "easy" ] = 0.25;
|
|
difficulty_starting_frac[ "normal" ] = 0.75;
|
|
|
|
if ( level.gameskill <= 1 )
|
|
{
|
|
// if ( aa_should_start_fresh() )
|
|
{
|
|
// started over so reset difficulty evaluation
|
|
dif_frac = difficulty_starting_frac[ get_skill_from_index( level.gameskill ) ];
|
|
dif_frac = int( dif_frac * 100 );
|
|
setdvar( "autodifficulty_frac", dif_frac );
|
|
}
|
|
|
|
set_difficulty_from_current_aa_frac();
|
|
}
|
|
else
|
|
{
|
|
set_difficulty_from_locked_settings();
|
|
}
|
|
|
|
setdvar( "autodifficulty_original_setting", level.gameskill );
|
|
setsaveddvar( "player_meleeDamageMultiplier", 100 / 250 );
|
|
}
|
|
|
|
get_skill_from_index( index )
|
|
{
|
|
return level.difficultyType[ index ];
|
|
}
|
|
|
|
aa_should_start_fresh()
|
|
{
|
|
if ( level.script == "killhouse" )
|
|
return true;
|
|
return level.gameskill == getdvarint( "autodifficulty_original_setting" );
|
|
}
|
|
|
|
apply_difficulty_frac_with_func( difficulty_func, current_frac )
|
|
{
|
|
//prof_begin( "apply_difficulty_frac_with_func" );
|
|
|
|
level.invulTime_preShield = [[ difficulty_func ]]( "invulTime_preShield", current_frac );
|
|
level.invulTime_onShield = [[ difficulty_func ]]( "invulTime_onShield", current_frac );
|
|
level.invulTime_postShield = [[ difficulty_func ]]( "invulTime_postShield", current_frac );
|
|
level.playerHealth_RegularRegenDelay = [[ difficulty_func ]]( "playerHealth_RegularRegenDelay", current_frac );
|
|
level.worthyDamageRatio = [[ difficulty_func ]]( "worthyDamageRatio", current_frac );
|
|
|
|
if ( level.auto_adjust_threatbias )
|
|
level.player.threatbias = int( [[ difficulty_func ]]( "threatbias", current_frac ) );
|
|
|
|
level.longRegenTime = [[ difficulty_func ]]( "longRegenTime", current_frac );
|
|
level.healthOverlayCutoff = [[ difficulty_func ]]( "healthOverlayCutoff", current_frac );
|
|
|
|
anim.player_attacker_accuracy = [[ difficulty_func ]]( "base_enemy_accuracy", current_frac );
|
|
level.attackeraccuracy = anim.player_attacker_accuracy;
|
|
|
|
anim.playerGrenadeBaseTime = int( [[ difficulty_func ]]( "playerGrenadeBaseTime", current_frac ) );
|
|
anim.playerGrenadeRangeTime = int( [[ difficulty_func ]]( "playerGrenadeRangeTime", current_frac ) );
|
|
anim.playerDoubleGrenadeTime = int( [[ difficulty_func ]]( "playerDoubleGrenadeTime", current_frac ) );
|
|
|
|
anim.min_sniper_burst_delay_time = [[ difficulty_func ]]( "min_sniper_burst_delay_time", current_frac );
|
|
anim.max_sniper_burst_delay_time = [[ difficulty_func ]]( "max_sniper_burst_delay_time", current_frac );
|
|
|
|
anim.dog_health = [[ difficulty_func ]]( "dog_health", current_frac );
|
|
anim.dog_presstime = [[ difficulty_func ]]( "dog_presstime", current_frac );
|
|
|
|
|
|
// we kill the player manually in script when we're ready to do so.
|
|
setsaveddvar( "player_deathInvulnerableTime", int( [[ difficulty_func ]]( "player_deathInvulnerableTime", current_frac ) ) );
|
|
setsaveddvar( "player_damageMultiplier", 100 / [[ difficulty_func ]]( "playerDifficultyHealth", current_frac ) );
|
|
setsaveddvar( "ai_accuracyDistScale", [[ difficulty_func ]]( "accuracyDistScale", current_frac ) );
|
|
|
|
//prof_end( "apply_difficulty_frac_with_func" );
|
|
}
|
|
|
|
apply_difficulty_step_with_func( difficulty_func, current_frac )
|
|
{
|
|
//prof_begin( "apply_difficulty_step_with_func" );
|
|
|
|
// sets the value of difficulty settings that can't blend between two
|
|
anim.missTimeConstant = [[ difficulty_func ]]( "missTimeConstant", current_frac );
|
|
anim.missTimeDistanceFactor = [[ difficulty_func ]]( "missTimeDistanceFactor", current_frac );
|
|
anim.dog_hits_before_kill = [[ difficulty_func ]]( "dog_hits_before_kill", current_frac );
|
|
anim.double_grenades_allowed = [[ difficulty_func ]]( "double_grenades_allowed", current_frac );
|
|
|
|
//prof_end( "apply_difficulty_step_with_func" );
|
|
}
|
|
|
|
set_difficulty_from_locked_settings()
|
|
{
|
|
apply_difficulty_frac_with_func( ::get_locked_difficulty_val, 1 );
|
|
apply_difficulty_step_with_func( ::get_locked_difficulty_step_val, 1 );
|
|
}
|
|
|
|
set_difficulty_from_current_aa_frac()
|
|
{
|
|
//prof_begin( "set_difficulty_from_current_aa_frac" );
|
|
|
|
// sets the difficulty to be a degree between two difficulty step values
|
|
level.auto_adjust_difficulty_frac = getdvarint( "autodifficulty_frac" );
|
|
current_frac = level.auto_adjust_difficulty_frac * 0.01;
|
|
assert( level.auto_adjust_difficulty_frac >= 0 );
|
|
assert( level.auto_adjust_difficulty_frac <= 100 );
|
|
|
|
apply_difficulty_frac_with_func( ::get_blended_difficulty, current_frac );
|
|
apply_difficulty_step_with_func( ::get_stepped_difficulty, current_frac );
|
|
|
|
//prof_end( "set_difficulty_from_current_aa_frac" );
|
|
}
|
|
|
|
get_stepped_difficulty( system, current_frac )
|
|
{
|
|
// returns the Normal val if the difficulty is above specified percent
|
|
if ( current_frac >= level.difficultySettings_stepFunc_percent[ system ] )
|
|
{
|
|
return level.difficultySettings[ system ][ "normal" ];
|
|
}
|
|
|
|
return level.difficultySettings[ system ][ "easy" ];
|
|
}
|
|
|
|
get_locked_difficulty_step_val( system, ignored )
|
|
{
|
|
return level.difficultySettings[ system ][ get_skill_from_index( level.gameskill ) ];
|
|
}
|
|
|
|
get_blended_difficulty( system, current_frac )
|
|
{
|
|
//prof_begin( "get_blended_difficulty" );
|
|
|
|
// get the value from the available data points
|
|
difficulty_array = level.difficultySettings_frac_data_points[ system ];
|
|
|
|
for ( i = 1; i < difficulty_array.size; i++ )
|
|
{
|
|
high_frac = difficulty_array[ i ][ "frac" ];
|
|
high_val = difficulty_array[ i ][ "val" ];
|
|
|
|
if ( current_frac <= high_frac )
|
|
{
|
|
low_frac = difficulty_array[ i - 1 ][ "frac" ];
|
|
low_val = difficulty_array[ i - 1 ][ "val" ];
|
|
|
|
frac_range = high_frac - low_frac;
|
|
val_range = high_val - low_val;
|
|
|
|
base_frac = current_frac - low_frac;
|
|
|
|
result_frac = base_frac / frac_range;
|
|
|
|
return low_val + result_frac * val_range;
|
|
|
|
/*
|
|
0.5 10 0.7
|
|
0.75 100
|
|
|
|
frac_range 0.25
|
|
base_frac 0.2
|
|
|
|
val_range 90
|
|
*/
|
|
}
|
|
}
|
|
|
|
assertex( difficulty_array.size == 1, "Shouldnt be multiple data points if we're here." );
|
|
|
|
//prof_end( "get_blended_difficulty" );
|
|
|
|
return difficulty_array[ 0 ][ "val" ];
|
|
}
|
|
|
|
is_double_grenades_allowed()
|
|
{
|
|
return level.auto_adjust_difficulty_frac > 0.75;
|
|
}
|
|
|
|
|
|
getCurrentDifficultySetting( msg )
|
|
{
|
|
return level.difficultySettings[ msg ][ get_skill_from_index( level.gameskill ) ];
|
|
}
|
|
|
|
getRatio( msg, min, max )
|
|
{
|
|
return( level.difficultySettings[ msg ][ level.difficultyType[ min ] ] * ( 100 - getdvarint( "autodifficulty_frac" ) ) + level.difficultySettings[ msg ][ level.difficultyType[ max ] ] * getdvarint( "autodifficulty_frac" ) ) * 0.01;
|
|
}
|
|
|
|
get_locked_difficulty_val( msg, ignored ) // ignored is there because this is used as a function pointer with another function that does have a second parm
|
|
{
|
|
return level.difficultySettings[ msg ][ level.difficultyType[ level.gameskill ] ];
|
|
}
|
|
|
|
always_pain()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
pain_protection()
|
|
{
|
|
if ( !pain_protection_check() )
|
|
return false;
|
|
|
|
return( randomint( 100 ) > 25 );
|
|
}
|
|
|
|
pain_protection_check()
|
|
{
|
|
if ( !isalive( self.enemy ) )
|
|
return false;
|
|
|
|
if ( self.enemy != level.player )
|
|
return false;
|
|
|
|
if ( !isalive( level.painAI ) || level.painAI.a.script != "pain" )
|
|
level.painAI = self;
|
|
|
|
// The pain AI can always take pain, so if the player focuses on one guy he'll see pain animations.
|
|
if ( self == level.painAI )
|
|
return false;
|
|
|
|
if ( self.damageWeapon != "none" && weaponIsBoltAction( self.damageWeapon ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/#
|
|
playerHealthDebug()
|
|
{
|
|
waittillframeend; // for init to finish
|
|
if ( getdvar( "scr_health_debug" ) == "" )
|
|
setdvar( "scr_health_debug", "0" );
|
|
|
|
while ( 1 )
|
|
{
|
|
while ( 1 )
|
|
{
|
|
if ( getdebugdvar( "scr_health_debug" ) != "0" )
|
|
break;
|
|
wait .5;
|
|
}
|
|
thread printHealthDebug();
|
|
while ( 1 )
|
|
{
|
|
if ( getdebugdvar( "scr_health_debug" ) == "0" )
|
|
break;
|
|
wait .5;
|
|
}
|
|
level notify( "stop_printing_grenade_timers" );
|
|
destroyHealthDebug();
|
|
}
|
|
}
|
|
|
|
printHealthDebug()
|
|
{
|
|
level notify( "stop_printing_health_bars" );
|
|
level endon( "stop_printing_health_bars" );
|
|
|
|
x = 40;
|
|
y = 40;
|
|
|
|
level.healthBarHudElems = [];
|
|
|
|
level.healthBarKeys[ 0 ] = "Health";
|
|
level.healthBarKeys[ 1 ] = "No Hit Time";
|
|
level.healthBarKeys[ 2 ] = "No Die Time";
|
|
|
|
if ( !isDefined( level.playerInvulTimeEnd ) )
|
|
level.playerInvulTimeEnd = 0;
|
|
if ( !isDefined( level.player_deathInvulnerableTimeout ) )
|
|
level.player_deathInvulnerableTimeout = 0;
|
|
|
|
for ( i = 0; i < level.healthBarKeys.size; i++ )
|
|
{
|
|
key = level.healthBarKeys[ i ];
|
|
|
|
textelem = newHudElem();
|
|
textelem.x = x;
|
|
textelem.y = y;
|
|
textelem.alignX = "left";
|
|
textelem.alignY = "top";
|
|
textelem.horzAlign = "fullscreen";
|
|
textelem.vertAlign = "fullscreen";
|
|
textelem setText( key );
|
|
|
|
bar = newHudElem();
|
|
bar.x = x + 80;
|
|
bar.y = y + 2;
|
|
bar.alignX = "left";
|
|
bar.alignY = "top";
|
|
bar.horzAlign = "fullscreen";
|
|
bar.vertAlign = "fullscreen";
|
|
bar setshader( "black", 1, 8 );
|
|
|
|
textelem.bar = bar;
|
|
textelem.key = key;
|
|
|
|
y += 10;
|
|
|
|
level.healthBarHudElems[ key ] = textelem;
|
|
}
|
|
|
|
while ( 1 )
|
|
{
|
|
wait .05;
|
|
|
|
for ( i = 0; i < level.healthBarKeys.size; i++ )
|
|
{
|
|
key = level.healthBarKeys[ i ];
|
|
|
|
width = 0;
|
|
if ( i == 0 )
|
|
width = level.player.health / level.player.maxhealth * 300;
|
|
else if ( i == 1 )
|
|
width = ( level.playerInvulTimeEnd - gettime() ) / 1000 * 40;
|
|
else if ( i == 2 )
|
|
width = ( level.player_deathInvulnerableTimeout - gettime() ) / 1000 * 40;
|
|
|
|
width = int( max( width, 1 ) );
|
|
|
|
bar = level.healthBarHudElems[ key ].bar;
|
|
bar setShader( "black", width, 8 );
|
|
}
|
|
}
|
|
}
|
|
|
|
destroyHealthDebug()
|
|
{
|
|
if ( !isdefined( level.healthBarHudElems ) )
|
|
return;
|
|
for ( i = 0; i < level.healthBarKeys.size; i++ )
|
|
{
|
|
level.healthBarHudElems[ level.healthBarKeys[ i ] ].bar destroy();
|
|
level.healthBarHudElems[ level.healthBarKeys[ i ] ] destroy();
|
|
}
|
|
}
|
|
#/
|
|
|
|
/*
|
|
// this is run on each enemy AI.
|
|
axisAccuracyControl()
|
|
{
|
|
self endon( "long_death" );
|
|
self endon( "death" );
|
|
|
|
//prof_begin( "axisAccuracyControl" );
|
|
|
|
if ( getdvar( "scr_dynamicaccuracy" ) == "" )
|
|
setdvar( "scr_dynamicaccuracy", "off" );
|
|
if ( getdvar( "scr_dynamicaccuracy" ) != "on" )
|
|
{
|
|
// self simpleAccuracyControl();
|
|
}
|
|
else
|
|
{
|
|
for ( ;; )
|
|
{
|
|
wait( 0.05 );
|
|
waittillframeend;// in case our accuracy changed this frame
|
|
|
|
//prof_begin( "axisAccuracyControl" );
|
|
|
|
if ( isDefined( self.enemy ) && isPlayer( self.enemy ) && self canSee( self.enemy ) )
|
|
{
|
|
self.a.accuracyGrowthMultiplier += 0.05 * anim.accuracyGrowthRate;
|
|
if ( self.a.accuracyGrowthMultiplier > anim.accuracyGrowthMax )
|
|
self.a.accuracyGrowthMultiplier = anim.accuracyGrowthMax;
|
|
}
|
|
else
|
|
{
|
|
self.a.accuracyGrowthMultiplier = 1;
|
|
}
|
|
|
|
self setEnemyAccuracy();
|
|
|
|
//prof_end( "axisAccuracyControl" );
|
|
}
|
|
}
|
|
|
|
//prof_end( "axisAccuracyControl" );
|
|
}
|
|
|
|
alliesAccuracyControl()
|
|
{
|
|
self endon( "long_death" );
|
|
self endon( "death" );
|
|
|
|
// self simpleAccuracyControl();
|
|
}
|
|
*/
|
|
|
|
set_accuracy_based_on_situation()
|
|
{
|
|
if ( self animscripts\combat_utility::isSniper() && isAlive( self.enemy ) )
|
|
{
|
|
self setSniperAccuracy();
|
|
return;
|
|
}
|
|
|
|
if ( isPlayer( self.enemy ) )
|
|
{
|
|
resetMissDebounceTime();
|
|
if ( self.a.missTime > gettime() )
|
|
{
|
|
self.accuracy = 0;
|
|
return;
|
|
}
|
|
|
|
if ( self.a.script == "move" )
|
|
{
|
|
self.accuracy = anim.run_accuracy * self.baseAccuracy;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( self.a.script == "move" )
|
|
{
|
|
self.accuracy = anim.run_accuracy * self.baseAccuracy;
|
|
return;
|
|
}
|
|
}
|
|
|
|
self.accuracy = self.baseAccuracy;
|
|
}
|
|
|
|
setSniperAccuracy()
|
|
{
|
|
/*
|
|
// if sniperShotCount isn't defined, a sniper is shooting from some place that's not in normal shoot behavior.
|
|
// that probably means they're doing some sort of blindfire or something that would look stupid for a sniper to do.
|
|
assert( isdefined( self.sniperShotCount ) );
|
|
*/
|
|
if ( !isdefined( self.sniperShotCount ) )
|
|
{
|
|
// snipers get this error if a dog attacks them
|
|
self.sniperShotCount = 0;
|
|
self.sniperHitCount = 0;
|
|
}
|
|
|
|
self.sniperShotCount++ ;
|
|
|
|
if ( ( !isDefined( self.lastMissedEnemy ) || self.enemy != self.lastMissedEnemy ) && distanceSquared( self.origin, self.enemy.origin ) > 500 * 500 )
|
|
{
|
|
// miss
|
|
self.accuracy = 0;
|
|
if ( level.gameSkill > 0 || self.sniperShotCount > 1 )
|
|
self.lastMissedEnemy = self.enemy;
|
|
return;
|
|
}
|
|
|
|
// guarantee a hit unless baseAccuracy is 0
|
|
self.accuracy = ( 1 + 1 * self.sniperHitCount ) * self.baseAccuracy;
|
|
|
|
self.sniperHitCount++ ;
|
|
|
|
if ( level.gameSkill < 1 && self.sniperHitCount == 1 )
|
|
self.lastMissedEnemy = undefined;// miss again
|
|
}
|
|
|
|
shotsAfterPlayerBecomesInvul()
|
|
{
|
|
return( 1 + randomfloat( 4 ) );
|
|
}
|
|
|
|
didSomethingOtherThanShooting()
|
|
{
|
|
// make sure the next time resetAccuracyAndPause() is called, we reset our misstime for sure
|
|
self.a.missTimeDebounce = 0;
|
|
}
|
|
|
|
// called when we start a volley of shots.
|
|
resetAccuracyAndPause()
|
|
{
|
|
self resetMissTime();
|
|
|
|
// self conserveAmmoWhilePlayerIsInvulnerable();
|
|
}
|
|
|
|
waitTimeIfPlayerIsHit()
|
|
{
|
|
waittime = 0;
|
|
waittillframeend;
|
|
if ( !isalive( self.enemy ) )
|
|
return waittime;
|
|
|
|
if ( self.enemy != level.player )
|
|
return waittime;
|
|
|
|
if ( flag( "player_is_invulnerable" ) && !self.a.nonstopFire )
|
|
waittime = ( 0.3 + randomfloat( 0.4 ) );
|
|
return waittime;
|
|
}
|
|
|
|
print3d_time( org, text, color, timer )
|
|
{
|
|
timer *= 20;
|
|
for ( i = 0; i < timer; i++ )
|
|
{
|
|
print3d( org, text, color );
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
|
|
|
|
resetMissTime()
|
|
{
|
|
//prof_begin( "resetMissTime" );
|
|
if ( self.team != "axis" )
|
|
return;
|
|
|
|
if ( self.weapon == "none" )
|
|
return;
|
|
|
|
if ( !self animscripts\weaponList::usingAutomaticWeapon() && !self animscripts\weaponList::usingSemiAutoWeapon() )
|
|
{
|
|
self.missTime = 0;
|
|
//prof_end( "resetMissTime" );
|
|
return;
|
|
}
|
|
|
|
self.a.nonstopFire = false;
|
|
|
|
if ( !isalive( self.enemy ) )
|
|
{
|
|
//prof_end( "resetMissTime" );
|
|
return;
|
|
}
|
|
|
|
if ( self.enemy != level.player )
|
|
{
|
|
self.accuracy = self.baseAccuracy;
|
|
//prof_end( "resetMissTime" );
|
|
return;
|
|
}
|
|
|
|
dist = distance( self.enemy.origin, self.origin );
|
|
self setMissTime( anim.missTimeConstant + dist * anim.missTimeDistanceFactor );
|
|
//prof_end( "resetMissTime" );
|
|
}
|
|
|
|
resetMissDebounceTime()
|
|
{
|
|
self.a.missTimeDebounce = gettime() + 3000;
|
|
}
|
|
|
|
setMissTime( howLong )
|
|
{
|
|
assertex( self.team == "axis", "Non axis tried to set misstime" );
|
|
|
|
// we can only start missing again if it's been a few seconds since we last shot
|
|
if ( self.a.missTimeDebounce > gettime() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( howLong > 0 )
|
|
self.accuracy = 0;
|
|
|
|
howLong *= 1000;// convert to milliseconds
|
|
|
|
self.a.missTime = gettime() + howLong;
|
|
self.a.accuracyGrowthMultiplier = 1;
|
|
// thread print3d_time( self.origin + (0,0,32 ), "Aiming..", (1,1,0), howLong * 0.001 );
|
|
//thread player_aim_debug();
|
|
}
|
|
|
|
player_aim_debug()
|
|
{
|
|
self endon( "death" );
|
|
self notify( "playeraim" );
|
|
self endon( "playeraim" );
|
|
|
|
for ( ;; )
|
|
{
|
|
color = (0,1,0);
|
|
if ( self.a.misstime > gettime() )
|
|
color = (1,0,0);
|
|
print3d( self.origin + (0,0,32), self.finalaccuracy, color );
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
|
|
playerHurtcheck()
|
|
{
|
|
self.hurtAgain = false;
|
|
for ( ;; )
|
|
{
|
|
self waittill( "damage", amount, attacker, dir, point );
|
|
self.hurtAgain = true;
|
|
self.damagePoint = point;
|
|
self.damageAttacker = attacker;
|
|
}
|
|
}
|
|
|
|
/* boltCheck()
|
|
{
|
|
// on hard, kar98s dont do quite enough damage to put you into red flashing, so we bias it a bit )
|
|
self endon( "death" );
|
|
for ( ;; )
|
|
{
|
|
self waittill( "damage", damage, attacker, direction_vec, point, cause );
|
|
if ( level.gameSkill != 2 )
|
|
continue;
|
|
if ( cause != "MOD_RIFLE_BULLET" )
|
|
continue;
|
|
|
|
ratio = self.health / self.maxHealth;
|
|
if ( ratio > level.healthOverlayCutoff )
|
|
self setnormalhealth( level.healthOverlayCutoff - 0.005 );
|
|
}
|
|
}*/
|
|
|
|
/*draw_player_health_packets()
|
|
{
|
|
packets = [];
|
|
red = ( 1, 0, 0 );
|
|
orange = ( 1, 0.5, 0 );
|
|
green = ( 0, 1, 0 );
|
|
|
|
for ( i = 0; i < 3; i++ )
|
|
{
|
|
overlay = newHudElem();
|
|
overlay.x = 5 + 20 * i;
|
|
overlay.y = 20;
|
|
overlay setshader( "white", 16, 16 );
|
|
overlay.alignX = "left";
|
|
overlay.alignY = "top";
|
|
overlay.alpha = 1;
|
|
overlay.color = ( 0, 1, 0 );
|
|
packets[ packets.size ] = overlay;
|
|
}
|
|
|
|
for ( ;; )
|
|
{
|
|
level waittill( "update_health_packets" );
|
|
if ( flag( "player_has_red_flashing_overlay" ) )
|
|
{
|
|
packetBase = 1;
|
|
for ( i = 0; i < packetBase; i++ )
|
|
{
|
|
packets[ i ] fadeOverTime( 0.5 );
|
|
packets[ i ].alpha = 1;
|
|
packets[ i ].color = red;
|
|
}
|
|
|
|
for ( i = packetBase; i < 3; i++ )
|
|
{
|
|
packets[ i ] fadeOverTime( 0.5 );
|
|
packets[ i ].alpha = 0;
|
|
packets[ i ].color = red;
|
|
}
|
|
|
|
flag_waitopen( "player_has_red_flashing_overlay" );
|
|
}
|
|
|
|
packetBase = level.player_health_packets;
|
|
if ( packetBase <= 0 )
|
|
packetBase = 0;
|
|
|
|
color = red;
|
|
if ( packetBase == 2 )
|
|
color = orange;
|
|
if ( packetBase == 3 )
|
|
color = green;
|
|
|
|
for ( i = 0; i < packetBase; i++ )
|
|
{
|
|
packets[ i ] fadeOverTime( 0.5 );
|
|
packets[ i ].alpha = 1;
|
|
packets[ i ].color = color;
|
|
}
|
|
|
|
for ( i = packetBase; i < 3; i++ )
|
|
{
|
|
packets[ i ] fadeOverTime( 0.5 );
|
|
packets[ i ].alpha = 0;
|
|
packets[ i ].color = red;
|
|
}
|
|
}
|
|
}*/
|
|
|
|
player_health_packets()
|
|
{
|
|
// thread draw_player_health_packets();
|
|
level.player_health_packets = 3;
|
|
for ( ;; )
|
|
{
|
|
flag_wait( "player_has_red_flashing_overlay" );
|
|
// change_player_health_packets( - 1 );
|
|
flag_waitopen( "player_has_red_flashing_overlay" );
|
|
}
|
|
}
|
|
|
|
playerHealthRegen()
|
|
{
|
|
// sarah - readd when SP is using code - driven low health overlay
|
|
// if ( getcvarfloat( "hud_healthOverlay_pulseStart" ) == 0 )
|
|
// setcvar( "hud_healthOverlay_pulseStart", 0.35 );
|
|
// level.healthOverlayCutoff = getcvarfloat( "hud_healthOverlay_pulseStart" );
|
|
|
|
//prof_begin( "playerHealthRegen" );
|
|
|
|
thread healthOverlay();
|
|
oldratio = 1;
|
|
player = level.player;
|
|
health_add = 0;
|
|
|
|
thread player_health_packets();
|
|
|
|
/*
|
|
if ( level.console )
|
|
regenRate = 0.01;// 0.017;
|
|
else
|
|
*/
|
|
regenRate = 0.1;// 0.017;
|
|
// regenRate = 0.01;// 0.017;
|
|
veryHurt = false;
|
|
playerJustGotRedFlashing = false;
|
|
|
|
level.hurtTime = -10000;
|
|
thread playerBreathingSound( level.player.maxHealth * 0.35 );
|
|
invulTime = 0;
|
|
hurtTime = 0;
|
|
newHealth = 0;
|
|
lastinvulratio = 1;
|
|
player thread playerHurtcheck();
|
|
|
|
player.boltHit = false;
|
|
// player thread boltCheck();
|
|
|
|
if ( getdvar( "scr_playerInvulTimeScale" ) == "" )
|
|
setdvar( "scr_playerInvulTimeScale", 1.0 );
|
|
|
|
for ( ;; )
|
|
{
|
|
wait( 0.05 );
|
|
waittillframeend;// if we're on hard, we need to wait until the bolt damage check before we decide what to do
|
|
//prof_begin( "playerHealthRegen" );
|
|
|
|
if ( player.health == level.player.maxHealth )
|
|
{
|
|
if ( flag( "player_has_red_flashing_overlay" ) )
|
|
{
|
|
flag_clear( "player_has_red_flashing_overlay" );
|
|
level notify( "take_cover_done" );
|
|
// level notify( "hit_again" ); was cutting off the overlay fadeout
|
|
}
|
|
|
|
lastinvulratio = 1;
|
|
playerJustGotRedFlashing = false;
|
|
veryHurt = false;
|
|
continue;
|
|
}
|
|
|
|
if ( player.health <= 0 )
|
|
{
|
|
/#showHitLog();#/
|
|
//prof_end( "playerHealthRegen" );
|
|
return;
|
|
}
|
|
|
|
wasVeryHurt = veryHurt;
|
|
ratio = player.health / level.player.maxHealth;
|
|
if ( ratio <= level.healthOverlayCutoff && level.player_health_packets > 1 )
|
|
{
|
|
veryHurt = true;
|
|
if ( !wasVeryHurt )
|
|
{
|
|
hurtTime = gettime();
|
|
level.hurtTime = hurtTime;
|
|
thread blurView( 3.6, 2 );
|
|
|
|
flag_set( "player_has_red_flashing_overlay" );
|
|
playerJustGotRedFlashing = true;
|
|
}
|
|
}
|
|
|
|
/*
|
|
if ( !wasVeryHurt && veryHurt )
|
|
nearAIRushesPlayer();
|
|
*/
|
|
if ( player.hurtAgain )
|
|
{
|
|
hurtTime = gettime();
|
|
player.hurtAgain = false;
|
|
}
|
|
|
|
if ( player.health / player.maxHealth >= oldratio )
|
|
{
|
|
if ( gettime() - hurttime < level.playerHealth_RegularRegenDelay )
|
|
continue;
|
|
|
|
if ( veryHurt )
|
|
{
|
|
newHealth = ratio;
|
|
if ( gettime() > hurtTime + level.longRegenTime )
|
|
newHealth += regenRate;
|
|
if ( newHealth >= 1 )
|
|
reduceTakeCoverWarnings();
|
|
}
|
|
else
|
|
{
|
|
newHealth = 1;
|
|
}
|
|
|
|
if ( newHealth > 1.0 )
|
|
newHealth = 1.0;
|
|
|
|
if ( newHealth <= 0 )
|
|
{
|
|
// Player is dead
|
|
return;
|
|
}
|
|
|
|
/#
|
|
if ( newHealth > player.health / player.maxHealth )
|
|
logRegen( newHealth );
|
|
#/
|
|
player setnormalhealth( newHealth );
|
|
oldRatio = player.health / player.maxHealth;
|
|
continue;
|
|
}
|
|
|
|
oldratio = lastinvulRatio;
|
|
invulWorthyHealthDrop = oldratio - ratio >= level.worthyDamageRatio;
|
|
|
|
if ( player.health <= 1 )
|
|
{
|
|
// if player's health is <= 1, code's player_deathInvulnerableTime has kicked in and the player won't lose health for a while.
|
|
// set the health to 2 so we can at least detect when they're getting hit.
|
|
player setnormalhealth( 2 / player.maxHealth );
|
|
invulWorthyHealthDrop = true;
|
|
/#
|
|
if ( !isDefined( level.player_deathInvulnerableTimeout ) )
|
|
level.player_deathInvulnerableTimeout = 0;
|
|
if ( level.player_deathInvulnerableTimeout < gettime() )
|
|
level.player_deathInvulnerableTimeout = gettime() + getdvarint( "player_deathInvulnerableTime" );
|
|
#/
|
|
}
|
|
|
|
oldRatio = player.health / player.maxHealth;
|
|
level notify( "hit_again" );
|
|
|
|
health_add = 0;
|
|
hurtTime = gettime();
|
|
level.hurtTime = hurtTime;
|
|
thread blurView( 3, 0.8 );
|
|
|
|
if ( !invulWorthyHealthDrop || getdvarfloat( "scr_playerInvulTimeScale" ) <= 0.0 )
|
|
{
|
|
/#logHit( player.health, 0 );#/
|
|
continue;
|
|
}
|
|
if ( flag( "player_is_invulnerable" ) )
|
|
continue;
|
|
flag_set( "player_is_invulnerable" );
|
|
level notify( "player_becoming_invulnerable" );// because "player_is_invulnerable" notify happens on both set * and * clear
|
|
|
|
|
|
if ( playerJustGotRedFlashing )
|
|
{
|
|
invulTime = level.invulTime_onShield;
|
|
playerJustGotRedFlashing = false;
|
|
}
|
|
else if ( veryHurt )
|
|
{
|
|
invulTime = level.invulTime_postShield;
|
|
}
|
|
else
|
|
{
|
|
invulTime = level.invulTime_preShield;
|
|
}
|
|
|
|
invulTime *= getdvarfloat( "scr_playerInvulTimeScale" );
|
|
|
|
/#logHit( player.health, invulTime );#/
|
|
lastinvulratio = player.health / player.maxHealth;
|
|
|
|
thread playerInvul( invulTime );
|
|
}
|
|
|
|
//prof_end( "playerHealthRegen" );
|
|
}
|
|
|
|
reduceTakeCoverWarnings()
|
|
{
|
|
//prof_begin( "reduceTakeCoverWarnings" );
|
|
|
|
if ( isAlive( level.player ) )
|
|
{
|
|
takeCoverWarnings = getdvarint( "takeCoverWarnings" );
|
|
if ( takeCoverWarnings > 0 )
|
|
{
|
|
takeCoverWarnings -- ;
|
|
setdvar( "takeCoverWarnings", takeCoverWarnings );
|
|
/#DebugTakeCoverWarnings();#/
|
|
}
|
|
}
|
|
|
|
//prof_end( "reduceTakeCoverWarnings" );
|
|
}
|
|
|
|
/#
|
|
DebugTakeCoverWarnings()
|
|
{
|
|
if ( getdvar( "scr_debugtakecover" ) == "" )
|
|
setdvar( "scr_debugtakecover", "0" );
|
|
if ( getdebugdvar( "scr_debugtakecover" ) == "1" )
|
|
{
|
|
iprintln( "Warnings remaining: ", getdebugdvarint( "takeCoverWarnings" ) - 3 );
|
|
}
|
|
}
|
|
#/
|
|
|
|
/#
|
|
logHit( newhealth, invulTime )
|
|
{
|
|
/* if ( !isdefined( level.hitlog ) )
|
|
{
|
|
level.hitlog = [];
|
|
thread showHitLog();
|
|
}
|
|
|
|
data = spawnstruct();
|
|
data.regen = false;
|
|
data.time = gettime();
|
|
data.health = newhealth / level.player.maxhealth;
|
|
data.invulTime = invulTime;
|
|
|
|
level.hitlog[ level.hitlog.size ] = data;*/
|
|
}
|
|
|
|
logRegen( newhealth )
|
|
{
|
|
/* if ( !isdefined( level.hitlog ) )
|
|
{
|
|
level.hitlog = [];
|
|
thread showHitLog();
|
|
}
|
|
|
|
data = spawnstruct();
|
|
data.regen = true;
|
|
data.time = gettime();
|
|
data.health = newhealth / level.player.maxhealth;
|
|
|
|
level.hitlog[ level.hitlog.size ] = data;*/
|
|
}
|
|
|
|
showHitLog()
|
|
{
|
|
/* level.player waittill( "death" );
|
|
|
|
println( "" );
|
|
println( "^3Hit Log:" );
|
|
|
|
prevhealth = 1;
|
|
prevtime = 0;
|
|
for ( i = 0; i < level.hitlog.size; i++ )
|
|
{
|
|
timepassed = ( level.hitlog[ i ].time - prevtime ) / 1000;
|
|
healthlost = prevhealth - level.hitlog[ i ].health;
|
|
println( "^0[ " + timepassed + " seconds passed ]" );
|
|
if ( level.hitlog[ i ].regen )
|
|
{
|
|
println( "^0Regen at time ^3" + level.hitlog[ i ].time / 1000 + "^0 for ^3" + -1 * healthlost + "^0 damage. Health is now " + level.hitlog[ i ].health );
|
|
}
|
|
else
|
|
{
|
|
damage = healthlost;
|
|
if ( damage == 0 )
|
|
damage = "unknown";
|
|
println( "^0Hit at time ^3" + level.hitlog[ i ].time / 1000 + "^0 for ^3" + damage + "^0 damage; invul for ^3" + level.hitlog[ i ].invulTime + "^0 seconds. Health is now " + level.hitlog[ i ].health );
|
|
}
|
|
|
|
prevtime = level.hitlog[ i ].time;
|
|
prevhealth = level.hitlog[ i ].health;
|
|
}
|
|
|
|
println( "" );*/
|
|
}
|
|
#/
|
|
|
|
playerInvul( timer )
|
|
{
|
|
if ( isdefined( level.player.flashendtime ) && level.player.flashendtime > gettime() )
|
|
timer = timer * getCurrentDifficultySetting( "flashbangedInvulFactor" );
|
|
|
|
if ( timer > 0 )
|
|
{
|
|
level.player.attackerAccuracy = 0;
|
|
level.player.ignoreRandomBulletDamage = true;
|
|
/#
|
|
level.playerInvulTimeEnd = gettime() + timer * 1000;
|
|
#/
|
|
|
|
wait( timer );
|
|
}
|
|
|
|
level.player.attackerAccuracy = anim.player_attacker_accuracy;
|
|
level.player.ignoreRandomBulletDamage = false;
|
|
flag_clear( "player_is_invulnerable" );
|
|
}
|
|
|
|
|
|
grenadeAwareness()
|
|
{
|
|
if ( self.team == "allies" )
|
|
{
|
|
self.grenadeawareness = 0.9;
|
|
return;
|
|
}
|
|
|
|
if ( self.team == "axis" )
|
|
{
|
|
if ( level.gameSkill >= 2 )
|
|
{
|
|
// hard and fu
|
|
if ( randomint( 100 ) < 33 )
|
|
self.grenadeawareness = 0.2;
|
|
else
|
|
self.grenadeawareness = 0.5;
|
|
}
|
|
else
|
|
{
|
|
// normal
|
|
if ( randomint( 100 ) < 33 )
|
|
self.grenadeawareness = 0;
|
|
else
|
|
self.grenadeawareness = 0.2;
|
|
}
|
|
}
|
|
}
|
|
|
|
blurView( blur, timer )
|
|
{
|
|
level notify( "blurview_stop" );
|
|
level endon( "blurview_stop" );
|
|
setblur( blur, 0 );
|
|
wait( 0.05 );
|
|
setblur( 0, timer );
|
|
}
|
|
|
|
playerBreathingSound( healthcap )
|
|
{
|
|
wait( 2 );
|
|
player = level.player;
|
|
for ( ;; )
|
|
{
|
|
wait( 0.2 );
|
|
if ( player.health <= 0 )
|
|
return;
|
|
|
|
// Player still has a lot of health so no breathing sound
|
|
ratio = player.health / level.player.maxHealth;
|
|
if ( ratio > level.healthOverlayCutoff )
|
|
continue;
|
|
|
|
level.player play_sound_on_entity( "breathing_hurt" );
|
|
wait( 0.1 + randomfloat( 0.8 ) );
|
|
}
|
|
}
|
|
|
|
healthOverlay()
|
|
{
|
|
level.player endon( "noHealthOverlay" );
|
|
//prof_begin( "healthOverlay" );
|
|
|
|
thread compassHealthOverlay();
|
|
|
|
overlay = newHudElem();
|
|
overlay.x = 0;
|
|
overlay.y = 0;
|
|
overlay setshader( "overlay_low_health", 640, 480 );
|
|
overlay.alignX = "left";
|
|
overlay.alignY = "top";
|
|
overlay.horzAlign = "fullscreen";
|
|
overlay.vertAlign = "fullscreen";
|
|
overlay.alpha = 0;
|
|
|
|
wait( 0.05 );// to give a chance for moscow to init level.strings so it doesnt clear ours
|
|
//prof_begin( "healthOverlay" );
|
|
level.strings[ "take_cover" ] = spawnstruct();
|
|
level.strings[ "take_cover" ].text = &"GAME_GET_TO_COVER";
|
|
|
|
thread healthOverlay_remove( overlay );
|
|
|
|
thread compassHealthOverlay();
|
|
|
|
pulseTime = 0.8;
|
|
for ( ;; )
|
|
{
|
|
overlay fadeOverTime( 0.5 );
|
|
overlay.alpha = 0;
|
|
flag_wait( "player_has_red_flashing_overlay" );
|
|
|
|
//prof_begin( "healthOverlay" );
|
|
redFlashingOverlay( overlay );
|
|
}
|
|
}
|
|
|
|
compassHealthOverlay()
|
|
{
|
|
level.player endon( "noHealthOverlay" );
|
|
|
|
//prof_begin( "compassHealthOverlay" );
|
|
|
|
overlay = newHudElem();
|
|
overlay.x = 0;
|
|
overlay.y = 35;
|
|
overlay setshader( "overlay_low_health_compass", 336, 168 );
|
|
overlay.alignX = "center";
|
|
overlay.alignY = "bottom";
|
|
overlay.horzAlign = "center";
|
|
overlay.vertAlign = "bottom";
|
|
overlay.alpha = 0;
|
|
|
|
for ( ;; )
|
|
{
|
|
//prof_begin( "compassHealthOverlay" );
|
|
|
|
overlay fadeOverTime( 0.2 );
|
|
overlay.alpha = 0;
|
|
|
|
if ( !isAlive( level.player ) )
|
|
break;
|
|
|
|
flag_wait( "player_has_red_flashing_overlay" );
|
|
|
|
if( getdvar( "compass" ) == "0" )
|
|
wait .5;
|
|
else
|
|
compassFlashingOverlay( overlay );
|
|
|
|
|
|
}
|
|
}
|
|
|
|
compassFlashingOverlay( overlay )
|
|
{
|
|
level endon( "hit_again" );
|
|
level.player endon( "damage" );
|
|
|
|
//prof_begin( "compassFlashingOverlay" );
|
|
|
|
fullAlphaTime = gettime() + level.longRegenTime;
|
|
zeroAlphaTime = fullAlphaTime + 500;
|
|
|
|
fadeTime = .2;
|
|
fadeFullInterval = .2;
|
|
|
|
|
|
while( isalive( level.player ) )
|
|
{
|
|
alpha = 1;
|
|
if ( gettime() > fullAlphaTime )
|
|
{
|
|
alpha = 1 - ((gettime() - fullAlphaTime) / (zeroAlphaTime - fullAlphaTime));
|
|
if ( alpha < 0 )
|
|
alpha = 0;
|
|
}
|
|
|
|
overlay fadeOverTime( fadeTime );
|
|
overlay.alpha = alpha;
|
|
wait fadeTime + fadeFullInterval;
|
|
|
|
overlay fadeOverTime( fadeTime );
|
|
overlay.alpha = alpha * .8;
|
|
wait fadeTime;
|
|
|
|
//prof_begin( "compassFlashingOverlay" );
|
|
|
|
if ( alpha <= 0 )
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
add_hudelm_position_internal( alignY )
|
|
{
|
|
//prof_begin( "add_hudelm_position_internal" );
|
|
|
|
if ( level.console )
|
|
self.fontScale = 2;
|
|
else
|
|
self.fontScale = 1.6;
|
|
|
|
self.x = 0;// 320;
|
|
self.y = -36;// 200;
|
|
self.alignX = "center";
|
|
|
|
/* if ( 0 )// if we ever get the chance to localize or find a way to dynamically find how many lines in a string
|
|
{
|
|
if ( isdefined( alignY ) )
|
|
self.alignY = alignY;
|
|
else
|
|
self.alignY = "middle";
|
|
}
|
|
else
|
|
{*/
|
|
self.alignY = "bottom";
|
|
// }
|
|
|
|
self.horzAlign = "center";
|
|
self.vertAlign = "middle";
|
|
|
|
if ( !isdefined( self.background ) )
|
|
return;
|
|
self.background.x = 0;// 320;
|
|
self.background.y = -40;// 200;
|
|
self.background.alignX = "center";
|
|
self.background.alignY = "middle";
|
|
self.background.horzAlign = "center";
|
|
self.background.vertAlign = "middle";
|
|
if ( level.console )
|
|
self.background setshader( "popmenu_bg", 650, 52 );
|
|
else
|
|
self.background setshader( "popmenu_bg", 650, 42 );
|
|
self.background.alpha = .5;
|
|
|
|
//prof_end( "add_hudelm_position_internal" );
|
|
}
|
|
|
|
create_warning_elem( ender )
|
|
{
|
|
level.hudelm_unpause_ender = ender;
|
|
level notify( "hud_elem_interupt" );
|
|
hudelem = newHudElem();
|
|
hudelem add_hudelm_position_internal();
|
|
hudelem thread destroy_warning_elem_when_hit_again();
|
|
hudelem thread destroy_warning_elem_when_mission_failed();
|
|
hudelem setText( &"GAME_GET_TO_COVER" );
|
|
hudelem.fontscale = 2;
|
|
hudelem.alpha = 1;
|
|
hudelem.color = ( 1, 0.9, 0.9 );
|
|
|
|
return hudelem;
|
|
}
|
|
|
|
waitTillPlayerIsHitAgain()
|
|
{
|
|
level endon( "hit_again" );
|
|
level.player waittill( "damage" );
|
|
}
|
|
|
|
|
|
destroy_warning_elem_when_hit_again()
|
|
{
|
|
self endon( "being_destroyed" );
|
|
|
|
waitTillPlayerIsHitAgain();
|
|
|
|
fadeout = ( !isalive( level.player ) );
|
|
self thread destroy_warning_elem( fadeout );
|
|
}
|
|
|
|
destroy_warning_elem_when_mission_failed()
|
|
{
|
|
self endon( "being_destroyed" );
|
|
|
|
flag_wait( "missionfailed" );
|
|
|
|
self thread destroy_warning_elem( true );
|
|
}
|
|
|
|
destroy_warning_elem( fadeout )
|
|
{
|
|
self notify( "being_destroyed" );
|
|
self.beingDestroyed = true;
|
|
|
|
if ( fadeout )
|
|
{
|
|
self fadeOverTime( 0.5 );
|
|
self.alpha = 0;
|
|
wait 0.5;
|
|
}
|
|
self notify( "death" );
|
|
self destroy();
|
|
}
|
|
|
|
mayChangeCoverWarningAlpha( coverWarning )
|
|
{
|
|
if ( !isdefined( coverWarning ) )
|
|
return false;
|
|
if ( isdefined( coverWarning.beingDestroyed ) )
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
fontScaler( scale, timer )
|
|
{
|
|
self endon( "death" );
|
|
scale *= 2;
|
|
dif = scale - self.fontscale;
|
|
self changeFontScaleOverTime( timer );
|
|
self.fontscale += dif;
|
|
}
|
|
|
|
fadeFunc( overlay, coverWarning, severity, mult, hud_scaleOnly )
|
|
{
|
|
pulseTime = 0.8;
|
|
scaleMin = 0.5;
|
|
|
|
fadeInTime = pulseTime * 0.1;
|
|
stayFullTime = pulseTime * ( .1 + severity * .2 );
|
|
fadeOutHalfTime = pulseTime * ( 0.1 + severity * .1 );
|
|
fadeOutFullTime = pulseTime * 0.3;
|
|
remainingTime = pulseTime - fadeInTime - stayFullTime - fadeOutHalfTime - fadeOutFullTime;
|
|
assert( remainingTime >= -.001 );
|
|
if ( remainingTime < 0 )
|
|
remainingTime = 0;
|
|
|
|
halfAlpha = 0.8 + severity * 0.1;
|
|
leastAlpha = 0.5 + severity * 0.3;
|
|
|
|
overlay fadeOverTime( fadeInTime );
|
|
overlay.alpha = mult * 1.0;
|
|
if ( mayChangeCoverWarningAlpha( coverWarning ) )
|
|
{
|
|
if ( !hud_scaleOnly )
|
|
{
|
|
coverWarning fadeOverTime( fadeInTime );
|
|
coverWarning.alpha = mult * 1.0;
|
|
}
|
|
}
|
|
if ( isDefined( coverWarning ) )
|
|
coverWarning thread fontScaler( 1.0, fadeInTime );
|
|
wait fadeInTime + stayFullTime;
|
|
|
|
overlay fadeOverTime( fadeOutHalfTime );
|
|
overlay.alpha = mult * halfAlpha;
|
|
if ( mayChangeCoverWarningAlpha( coverWarning ) )
|
|
{
|
|
if ( !hud_scaleOnly )
|
|
{
|
|
coverWarning fadeOverTime( fadeOutHalfTime );
|
|
coverWarning.alpha = mult * halfAlpha;
|
|
}
|
|
}
|
|
|
|
wait fadeOutHalfTime;
|
|
|
|
overlay fadeOverTime( fadeOutFullTime );
|
|
overlay.alpha = mult * leastAlpha;
|
|
if ( mayChangeCoverWarningAlpha( coverWarning ) )
|
|
{
|
|
if ( !hud_scaleOnly )
|
|
{
|
|
coverWarning fadeOverTime( fadeOutFullTime );
|
|
coverWarning.alpha = mult * leastAlpha;
|
|
}
|
|
}
|
|
if ( isDefined( coverWarning ) )
|
|
coverWarning thread fontScaler( 0.9, fadeOutFullTime );
|
|
wait fadeOutFullTime;
|
|
|
|
wait remainingTime;
|
|
}
|
|
|
|
shouldShowCoverWarning()
|
|
{
|
|
if ( !isAlive( level.player ) )
|
|
return false;
|
|
|
|
if ( level.gameskill > 1 )
|
|
return false;
|
|
|
|
if ( level.missionfailed )
|
|
return false;
|
|
|
|
if ( !maps\_load::map_is_early_in_the_game() )
|
|
return false;
|
|
|
|
// note: takeCoverWarnings is 3 more than the number of warnings left.
|
|
// this lets it stay away for a while unless we die 3 times in a row without taking cover successfully.
|
|
takeCoverWarnings = getdvarint( "takeCoverWarnings" );
|
|
if ( takeCoverWarnings <= 3 )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// &"GAME_GET_TO_COVER";
|
|
redFlashingOverlay( overlay )
|
|
{
|
|
level endon( "hit_again" );
|
|
level.player endon( "damage" );
|
|
|
|
//prof_begin( "redFlashingOverlay" );
|
|
|
|
coverWarning = undefined;
|
|
|
|
if ( shouldShowCoverWarning() )
|
|
{
|
|
// get to cover!
|
|
coverWarning = create_warning_elem( "take_cover_done" );
|
|
// coverWarning may be destroyed at any time if we fail the mission.
|
|
}
|
|
|
|
// if severity isn't very high, the overlay becomes very unnoticeable to the player.
|
|
// keep it high while they haven't regenerated or they'll feel like their health is nearly full and they're safe to step out.
|
|
|
|
stopFlashingBadlyTime = gettime() + level.longRegenTime;
|
|
|
|
fadeFunc( overlay, coverWarning, 1, 1, false );
|
|
while ( gettime() < stopFlashingBadlyTime && isalive( level.player ) )
|
|
fadeFunc( overlay, coverWarning, .9, 1, false );
|
|
|
|
if ( isalive( level.player ) )
|
|
fadeFunc( overlay, coverWarning, .65, 0.8, false );
|
|
|
|
if ( mayChangeCoverWarningAlpha( coverWarning ) )
|
|
{
|
|
coverWarning fadeOverTime( 1.0 );
|
|
coverWarning.alpha = 0;
|
|
}
|
|
|
|
fadeFunc( overlay, coverWarning, 0, 0.6, true );
|
|
|
|
overlay fadeOverTime( 0.5 );
|
|
overlay.alpha = 0;
|
|
|
|
flag_clear( "player_has_red_flashing_overlay" );
|
|
level.player thread play_sound_on_entity( "breathing_better" );
|
|
|
|
//prof_end( "redFlashingOverlay" );
|
|
|
|
wait( 0.5 );// for fade out
|
|
level notify( "take_cover_done" );
|
|
level notify( "hit_again" );
|
|
}
|
|
|
|
healthOverlay_remove( overlay )
|
|
{
|
|
level.player waittill( "noHealthOverlay" );
|
|
overlay destroy();
|
|
}
|
|
|
|
resetSkill()
|
|
{
|
|
setskill( true );
|
|
}
|
|
|
|
setTakeCoverWarnings()
|
|
{
|
|
// generates "Get to Cover" x number of times when you first get hurt
|
|
// dvar defaults to - 1
|
|
|
|
isPreGameplayLevel = ( level.script == "training" || level.script == "cargoship" || level.script == "coup" );
|
|
|
|
if ( getdvarint( "takeCoverWarnings" ) == -1 || isPreGameplayLevel )
|
|
{
|
|
// takeCoverWarnings is 3 more than the number of warnings we want to occur.
|
|
setdvar( "takeCoverWarnings", 3 + 6 );
|
|
}
|
|
/#DebugTakeCoverWarnings();#/
|
|
}
|
|
|
|
increment_take_cover_warnings_on_death()
|
|
{
|
|
level notify( "new_cover_on_death_thread" );
|
|
level endon( "new_cover_on_death_thread" );
|
|
level.player waittill( "death" );
|
|
|
|
// dont increment if player died to grenades, explosion, etc
|
|
if ( !flag( "player_has_red_flashing_overlay" ) )
|
|
return;
|
|
|
|
if ( level.gameSkill > 1 )
|
|
return;
|
|
|
|
warnings = getdvarint( "takeCoverWarnings" );
|
|
if ( warnings < 10 )
|
|
setdvar( "takeCoverWarnings", warnings + 1 );
|
|
/#DebugTakeCoverWarnings();#/
|
|
}
|
|
|
|
auto_adjust_difficulty_player_positioner()
|
|
{
|
|
org = level.player.origin;
|
|
// thread debug_message( ".", org, 6 );
|
|
wait( 5 );
|
|
if ( autospot_is_close_to_player( org ) )
|
|
level.autoAdjust_playerSpots[ level.autoAdjust_playerSpots.size ] = org;
|
|
}
|
|
|
|
autospot_is_close_to_player( org )
|
|
{
|
|
return distanceSquared( level.player.origin, org ) < ( 140 * 140 );
|
|
}
|
|
|
|
|
|
auto_adjust_difficulty_player_movement_check()
|
|
{
|
|
level.autoAdjust_playerSpots = [];
|
|
level.player.movedRecently = true;
|
|
wait( 1 );// for lvl start precaching of debug strings
|
|
|
|
for ( ;; )
|
|
{
|
|
thread auto_adjust_difficulty_player_positioner();
|
|
level.player.movedRecently = true;
|
|
newSpots = [];
|
|
start = level.autoAdjust_playerSpots.size - 5;
|
|
if ( start < 0 )
|
|
start = 0;
|
|
|
|
for ( i = start; i < level.autoAdjust_playerSpots.size;i++ )
|
|
{
|
|
if ( !autospot_is_close_to_player( level.autoAdjust_playerSpots[ i ] ) )
|
|
continue;
|
|
|
|
newSpots[ newSpots.size ] = level.autoAdjust_playerSpots[ i ];
|
|
level.player.movedRecently = false;
|
|
// thread debug_message( "!", newSpots[ newSpots.size - 1 ], 1 );
|
|
}
|
|
|
|
level.autoAdjust_playerSpots = newSpots;
|
|
|
|
wait( 1 );
|
|
}
|
|
}
|
|
|
|
|
|
auto_adjust_difficulty_track_player_death()
|
|
{
|
|
// reduce the difficulty timer when you die
|
|
level.player waittill( "death" );
|
|
num = getdvarint( "autodifficulty_playerDeathTimer" );
|
|
num -= 60;
|
|
setdvar( "autodifficulty_playerDeathTimer", num );
|
|
// scriptPrintln( "script_autodifficulty", "Set deathtimer to " + num );
|
|
}
|
|
|
|
|
|
auto_adjust_difficulty_track_player_shots()
|
|
{
|
|
// reduce the "time spent alive" by the time between shots fired if there has been significant time between shots
|
|
lastShotTime = gettime();
|
|
for ( ;; )
|
|
{
|
|
if ( level.player attackButtonPressed() )
|
|
lastShotTime = gettime();
|
|
|
|
level.timeBetweenShots = gettime() - lastShotTime;
|
|
wait( 0.05 );
|
|
/*
|
|
if ( lastShotTime < 10000 )
|
|
continue;
|
|
|
|
playerDeathTimer = getcvarint( "playerDeathTimer" );
|
|
playerDeathTimer = int( playerDeathTimer - lastShotTime * 0.001 );
|
|
setcvar( "playerDeathTimer", playerDeathTimer );
|
|
*/
|
|
}
|
|
}
|
|
|
|
|
|
hud_debug_add_frac( msg, num )
|
|
{
|
|
hud_debug_add_display( msg, num * 100, true );
|
|
}
|
|
|
|
hud_debug_add( msg, num )
|
|
{
|
|
hud_debug_add_display( msg, num, false );
|
|
}
|
|
|
|
hud_debug_clear()
|
|
{
|
|
level.hudNum = 0;
|
|
if ( isdefined( level.hudDebugNum ) )
|
|
{
|
|
for ( i = 0;i < level.hudDebugNum.size;i++ )
|
|
level.hudDebugNum[ i ] destroy();
|
|
}
|
|
|
|
level.hudDebugNum = [];
|
|
}
|
|
|
|
hud_debug_add_message( msg )
|
|
{
|
|
if ( !isdefined( level.hudMsgShare ) )
|
|
level.hudMsgShare = [];
|
|
if ( !isdefined( level.hudMsgShare[ msg ] ) )
|
|
{
|
|
hud = newHudElem();
|
|
hud.x = level.debugLeft;
|
|
hud.y = level.debugHeight + level.hudNum * 15;
|
|
hud.foreground = 1;
|
|
hud.sort = 100;
|
|
hud.alpha = 1.0;
|
|
hud.alignX = "left";
|
|
hud.horzAlign = "left";
|
|
hud.fontScale = 1.0;
|
|
hud setText( msg );
|
|
level.hudMsgShare[ msg ] = true;
|
|
}
|
|
}
|
|
|
|
hud_debug_add_display( msg, num, isfloat )
|
|
{
|
|
hud_debug_add_message( msg );
|
|
|
|
num = int( num );
|
|
negative = false;
|
|
if ( num < 0 )
|
|
{
|
|
negative = true;
|
|
num *= -1;
|
|
}
|
|
|
|
thousands = 0;
|
|
hundreds = 0;
|
|
tens = 0;
|
|
ones = 0;
|
|
while ( num >= 10000 )
|
|
num -= 10000;
|
|
|
|
while ( num >= 1000 )
|
|
{
|
|
num -= 1000;
|
|
thousands++ ;
|
|
}
|
|
while ( num >= 100 )
|
|
{
|
|
num -= 100;
|
|
hundreds++ ;
|
|
}
|
|
while ( num >= 10 )
|
|
{
|
|
num -= 10;
|
|
tens++ ;
|
|
}
|
|
while ( num >= 1 )
|
|
{
|
|
num -= 1;
|
|
ones++ ;
|
|
}
|
|
|
|
offset = 0;
|
|
offsetSize = 10;
|
|
if ( thousands > 0 )
|
|
{
|
|
hud_debug_add_num( thousands, offset );
|
|
offset += offsetSize;
|
|
hud_debug_add_num( hundreds, offset );
|
|
offset += offsetSize;
|
|
hud_debug_add_num( tens, offset );
|
|
offset += offsetSize;
|
|
hud_debug_add_num( ones, offset );
|
|
offset += offsetSize;
|
|
}
|
|
else
|
|
if ( hundreds > 0 || isFloat )
|
|
{
|
|
hud_debug_add_num( hundreds, offset );
|
|
offset += offsetSize;
|
|
hud_debug_add_num( tens, offset );
|
|
offset += offsetSize;
|
|
hud_debug_add_num( ones, offset );
|
|
offset += offsetSize;
|
|
}
|
|
else
|
|
if ( tens > 0 )
|
|
{
|
|
hud_debug_add_num( tens, offset );
|
|
offset += offsetSize;
|
|
hud_debug_add_num( ones, offset );
|
|
offset += offsetSize;
|
|
}
|
|
else
|
|
{
|
|
hud_debug_add_num( ones, offset );
|
|
offset += offsetSize;
|
|
}
|
|
|
|
if ( isFloat )
|
|
{
|
|
decimalHud = newHudElem();
|
|
decimalHud.x = 204.5;
|
|
decimalHud.y = level.debugHeight + level.hudNum * 15;
|
|
decimalHud.foreground = 1;
|
|
decimalHud.sort = 100;
|
|
decimalHud.alpha = 1.0;
|
|
decimalHud.alignX = "left";
|
|
decimalHud.horzAlign = "left";
|
|
decimalHud.fontScale = 1.0;
|
|
decimalHud setText( "." );
|
|
level.hudDebugNum[ level.hudDebugNum.size ] = decimalHud;
|
|
}
|
|
|
|
if ( negative )
|
|
{
|
|
negativeHud = newHudElem();
|
|
negativeHud.x = 195.5;
|
|
negativeHud.y = level.debugHeight + level.hudNum * 15;
|
|
negativeHud.foreground = 1;
|
|
negativeHud.sort = 100;
|
|
negativeHud.alpha = 1.0;
|
|
negativeHud.alignX = "left";
|
|
negativeHud.horzAlign = "left";
|
|
negativeHud.fontScale = 1.0;
|
|
negativeHud setText( " - " );
|
|
level.hudDebugNum[ level.hudNum ] = negativeHud;
|
|
}
|
|
|
|
// level.hudDebugNum[ level.hudNum ] = hud;
|
|
level.hudNum++ ;
|
|
}
|
|
|
|
hud_debug_add_string( msg, msg2 )
|
|
{
|
|
hud_debug_add_message( msg );
|
|
hud_debug_add_second_string( msg2, 0 );
|
|
level.hudNum++ ;
|
|
}
|
|
|
|
hud_debug_add_num( num, offset )
|
|
{
|
|
hud = newHudElem();
|
|
hud.x = 200 + offset * 0.65;
|
|
hud.y = level.debugHeight + level.hudNum * 15;
|
|
hud.foreground = 1;
|
|
hud.sort = 100;
|
|
hud.alpha = 1.0;
|
|
hud.alignX = "left";
|
|
hud.horzAlign = "left";
|
|
hud.fontScale = 1.0;
|
|
hud setText( num + "" );
|
|
level.hudDebugNum[ level.hudDebugNum.size ] = hud;
|
|
}
|
|
|
|
hud_debug_add_second_string( num, offset )
|
|
{
|
|
hud = newHudElem();
|
|
hud.x = 200 + offset * 0.65;
|
|
hud.y = level.debugHeight + level.hudNum * 15;
|
|
hud.foreground = 1;
|
|
hud.sort = 100;
|
|
hud.alpha = 1.0;
|
|
hud.alignX = "left";
|
|
hud.horzAlign = "left";
|
|
hud.fontScale = 1.0;
|
|
hud setText( num );
|
|
level.hudDebugNum[ level.hudDebugNum.size ] = hud;
|
|
}
|
|
|
|
aa_init_stats()
|
|
{
|
|
/#
|
|
if ( getdvar( "createfx" ) == "on" )
|
|
return;
|
|
if ( getdvar( "r_reflectionProbeGenerate" ) == "1" )
|
|
{
|
|
return;
|
|
}
|
|
#/
|
|
//prof_begin( "aa_init_stats" );
|
|
|
|
level.sp_stat_tracking_func = maps\_gameskill::auto_adjust_new_zone;
|
|
|
|
setdvar( "aa_player_kills", "0" );
|
|
setdvar( "aa_enemy_deaths", "0" );
|
|
setdvar( "aa_enemy_damage_taken", "0" );
|
|
setdvar( "aa_player_damage_taken", "0" );
|
|
setdvar( "aa_player_damage_dealt", "0" );
|
|
setdvar( "aa_ads_damage_dealt", "0" );
|
|
setdvar( "aa_time_tracking", "0" );
|
|
setdvar( "aa_deaths", "0" );
|
|
|
|
setdvar( "player_cheated", 0 );
|
|
|
|
level.auto_adjust_results = [];
|
|
thread aa_time_tracking();
|
|
thread aa_player_health_tracking();
|
|
thread aa_player_ads_tracking();
|
|
flag_set( "auto_adjust_initialized" );
|
|
|
|
flag_init( "aa_main_" + level.script );
|
|
flag_set( "aa_main_" + level.script );
|
|
|
|
//prof_end( "aa_init_stats" );
|
|
}
|
|
|
|
command_used( cmd )
|
|
{
|
|
//prof_begin( "command_used" );
|
|
|
|
binding = getKeyBinding( cmd );
|
|
if ( binding[ "count" ] <= 0 )
|
|
{
|
|
//prof_end( "command_used" );
|
|
return false;
|
|
}
|
|
|
|
for ( i = 1; i < binding[ "count" ] + 1; i++ )
|
|
{
|
|
if ( level.player buttonpressed( binding[ "key" + i ] ) )
|
|
{
|
|
//prof_end( "command_used" );
|
|
return true;
|
|
}
|
|
}
|
|
|
|
//prof_end( "command_used" );
|
|
return false;
|
|
}
|
|
|
|
aa_time_tracking()
|
|
{
|
|
/#
|
|
if ( getdvar( "createfx" ) != "" )
|
|
return;
|
|
#/
|
|
waittillframeend; // so level.start_point is defined
|
|
for ( ;; )
|
|
{
|
|
//prof_begin( "aa_time_tracking" );
|
|
|
|
aa_add_event_float( "aa_time_tracking", 0.2 );
|
|
/#
|
|
if ( IsGodMode( level.player ) || level.start_point != "default" || getdvar( "timescale" ) != "1" )
|
|
{
|
|
setdvar( "player_cheated", 1 );
|
|
}
|
|
#/
|
|
/*
|
|
level.sprint_key = getKeyBinding( "+breath_sprint" );
|
|
sprinting = false;
|
|
sprinting = command_used( "+sprint" );
|
|
if ( !sprinting )
|
|
{
|
|
sprinting = command_used( "+breath_sprint" );
|
|
}
|
|
if ( sprinting )
|
|
{
|
|
aa_add_event_float( "aa_sprint_time", 0.2 );
|
|
}
|
|
*/
|
|
wait( 0.2 );
|
|
}
|
|
}
|
|
|
|
aa_player_ads_tracking()
|
|
{
|
|
level.player endon( "death" );
|
|
level.player_ads_time = 0;
|
|
for ( ;; )
|
|
{
|
|
if ( isADS() )
|
|
{
|
|
level.player_ads_time = gettime();
|
|
while ( isADS() )
|
|
{
|
|
wait( 0.05 );
|
|
}
|
|
continue;
|
|
}
|
|
wait( 0.05 );
|
|
}
|
|
}
|
|
|
|
aa_player_health_tracking()
|
|
{
|
|
for ( ;; )
|
|
{
|
|
level.player waittill( "damage", amount );
|
|
aa_add_event( "aa_player_damage_taken", amount );
|
|
if ( !isalive( level.player ) )
|
|
{
|
|
aa_add_event( "aa_deaths", 1 );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
auto_adjust_new_zone( zone )
|
|
{
|
|
|
|
|
|
/#
|
|
if ( getdvar( "createfx" ) == "on" )
|
|
return;
|
|
#/
|
|
if ( !isdefined( level.auto_adjust_flags ) )
|
|
{
|
|
level.auto_adjust_flags = [];
|
|
}
|
|
|
|
flag_wait( "auto_adjust_initialized" );
|
|
|
|
//prof_begin( "auto_adjust_new_zone" );
|
|
|
|
level.auto_adjust_results[ zone ] = [];
|
|
level.auto_adjust_flags[ zone ] = 0;
|
|
flag_wait( zone );
|
|
|
|
//prof_begin( "auto_adjust_new_zone" );
|
|
|
|
// already processing this zone?
|
|
if ( getdvar( "aa_zone" + zone ) == "" )
|
|
{
|
|
setdvar( "aa_zone" + zone, "on" );
|
|
level.auto_adjust_flags[ zone ] = 1;
|
|
aa_update_flags();
|
|
|
|
setdvar( "start_time" + zone, getdvar( "aa_time_tracking" ) );
|
|
|
|
// measure always
|
|
setdvar( "starting_player_kills" + zone, getdvar( "aa_player_kills" ) );
|
|
setdvar( "starting_deaths" + zone, getdvar( "aa_deaths" ) );
|
|
setdvar( "starting_ads_damage_dealt" + zone, getdvar( "aa_ads_damage_dealt" ) );
|
|
setdvar( "starting_player_damage_dealt" + zone, getdvar( "aa_player_damage_dealt" ) );
|
|
setdvar( "starting_player_damage_taken" + zone, getdvar( "aa_player_damage_taken" ) );
|
|
setdvar( "starting_enemy_damage_taken" + zone, getdvar( "aa_enemy_damage_taken" ) );
|
|
setdvar( "starting_enemy_deaths" + zone, getdvar( "aa_enemy_deaths" ) );
|
|
}
|
|
else
|
|
{
|
|
if ( getdvar( "aa_zone" + zone ) == "done" )
|
|
{
|
|
//prof_end( "auto_adjust_new_zone" );
|
|
return;
|
|
}
|
|
}
|
|
|
|
//prof_end( "auto_adjust_new_zone" );
|
|
flag_waitopen( zone );
|
|
auto_adust_zone_complete( zone );
|
|
}
|
|
|
|
auto_adust_zone_complete( zone )
|
|
{
|
|
//prof_begin( "auto_adust_zone_complete" );
|
|
|
|
setdvar( "aa_zone" + zone, "done" );
|
|
|
|
start_time = getdvarfloat( "start_time" + zone );
|
|
starting_player_kills = getdvarint( "starting_player_kills" + zone );
|
|
starting_enemy_deaths = getdvarint( "aa_enemy_deaths" + zone );
|
|
starting_enemy_damage_taken = getdvarint( "aa_enemy_damage_taken" + zone );
|
|
starting_player_damage_taken = getdvarint( "aa_player_damage_taken" + zone );
|
|
starting_player_damage_dealt = getdvarint( "aa_player_damage_dealt" + zone );
|
|
starting_ads_damage_dealt = getdvarint( "aa_ads_damage_dealt" + zone );
|
|
starting_deaths = getdvarint( "aa_deaths" + zone );
|
|
level.auto_adjust_flags[ zone ] = 0;
|
|
aa_update_flags();
|
|
|
|
total_time = getdvarfloat( "aa_time_tracking" ) - start_time;
|
|
total_player_kills = getdvarint( "aa_player_kills" ) - starting_player_kills;
|
|
total_enemy_deaths = getdvarint( "aa_enemy_deaths" ) - starting_enemy_deaths;
|
|
|
|
player_kill_ratio = 0;
|
|
if ( total_enemy_deaths > 0 )
|
|
{
|
|
player_kill_ratio = total_player_kills / total_enemy_deaths;
|
|
player_kill_ratio *= 100;
|
|
player_kill_ratio = int( player_kill_ratio );
|
|
}
|
|
|
|
total_enemy_damage_taken = getdvarint( "aa_enemy_damage_taken" ) - starting_enemy_damage_taken;
|
|
total_player_damage_dealt = getdvarint( "aa_player_damage_dealt" ) - starting_player_damage_dealt;
|
|
player_damage_dealt_ratio = 0;
|
|
player_damage_dealt_per_minute = 0;
|
|
if ( total_enemy_damage_taken > 0 && total_time > 0 )
|
|
{
|
|
player_damage_dealt_ratio = total_player_damage_dealt / total_enemy_damage_taken;
|
|
player_damage_dealt_ratio *= 100;
|
|
player_damage_dealt_ratio = int( player_damage_dealt_ratio );
|
|
|
|
player_damage_dealt_per_minute = total_player_damage_dealt / total_time;
|
|
player_damage_dealt_per_minute = player_damage_dealt_per_minute * 60;
|
|
player_damage_dealt_per_minute = int( player_damage_dealt_per_minute );
|
|
}
|
|
|
|
total_ads_damage_dealt = getdvarint( "aa_ads_damage_dealt" ) - starting_ads_damage_dealt;
|
|
player_ads_damage_ratio = 0;
|
|
if ( total_player_damage_dealt > 0 )
|
|
{
|
|
player_ads_damage_ratio = total_ads_damage_dealt / total_player_damage_dealt;
|
|
player_ads_damage_ratio *= 100;
|
|
player_ads_damage_ratio = int( player_ads_damage_ratio );
|
|
}
|
|
|
|
|
|
total_player_damage_taken = getdvarint( "aa_player_damage_taken" ) - starting_player_damage_taken;
|
|
|
|
player_damage_taken_ratio = 0;
|
|
if ( total_time > 0 )
|
|
{
|
|
player_damage_taken_ratio = total_player_damage_taken / total_time;
|
|
}
|
|
|
|
player_damage_taken_per_minute = player_damage_taken_ratio * 60;
|
|
player_damage_taken_per_minute = int( player_damage_taken_per_minute );
|
|
|
|
|
|
total_deaths = getdvarint( "aa_deaths" ) - starting_deaths;
|
|
|
|
aa_array = [];
|
|
aa_array[ "player_damage_taken_per_minute" ] = player_damage_taken_per_minute;
|
|
aa_array[ "player_damage_dealt_per_minute" ] = player_damage_dealt_per_minute;
|
|
aa_array[ "minutes" ] = total_time / 60;
|
|
aa_array[ "deaths" ] = total_deaths;
|
|
aa_array[ "gameskill" ] = level.gameskill;
|
|
|
|
level.auto_adjust_results[ zone ] = aa_array;
|
|
|
|
msg = "Completed AA sequence: ";
|
|
/#
|
|
if ( getdvar( "player_cheated" ) == "1" )
|
|
{
|
|
msg = "Cheated in AA sequence: ";
|
|
}
|
|
#/
|
|
|
|
msg += level.script + " / " + zone;
|
|
keys = getarraykeys( aa_array );
|
|
// array_levelthread( keys, ::aa_print_vals, aa_array );
|
|
|
|
for ( i = 0; i < keys.size; i++ )
|
|
{
|
|
msg = msg + ", " + keys[ i ] + ": " + aa_array[ keys[ i ] ];
|
|
}
|
|
|
|
logstring( msg );
|
|
println( "^6" + msg );
|
|
|
|
//prof_end( "auto_adust_zone_complete" );
|
|
}
|
|
|
|
aa_print_vals( key, aa_array )
|
|
{
|
|
logstring( key + ": " + aa_array[ key ] );
|
|
println( "^6" + key + ": " + aa_array[ key ] );
|
|
}
|
|
|
|
/*
|
|
aa_print_vals( key, aa_array, file )
|
|
{
|
|
fprintln( file, key + ": " + aa_array[ key ] );
|
|
}
|
|
*/
|
|
|
|
aa_update_flags()
|
|
{
|
|
}
|
|
|
|
aa_add_event( event, amount )
|
|
{
|
|
old_amount = getdvarint( event );
|
|
setdvar( event, old_amount + amount );
|
|
}
|
|
|
|
aa_add_event_float( event, amount )
|
|
{
|
|
old_amount = getdvarfloat( event );
|
|
setdvar( event, old_amount + amount );
|
|
}
|
|
|
|
return_false( attacker )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
player_attacker( attacker )
|
|
{
|
|
if ( [[ level.custom_player_attacker ]]( attacker ) )
|
|
return true;
|
|
|
|
if ( attacker == level.player )
|
|
return true;
|
|
|
|
if ( !isdefined( attacker.car_damage_owner_recorder ) )
|
|
return false;
|
|
|
|
return attacker player_did_most_damage();
|
|
}
|
|
|
|
player_did_most_damage()
|
|
{
|
|
return self.player_damage * 1.75 > self.non_player_damage;
|
|
}
|
|
|
|
empty_kill_func( type, loc, point )
|
|
{
|
|
|
|
}
|
|
|
|
auto_adjust_enemy_died( amount, attacker, type, point )
|
|
{
|
|
//prof_begin( "auto_adjust_enemy_died" );
|
|
|
|
/*
|
|
Not worth effecting the speed of the game for one spot in one map in one mode
|
|
// in case the team got changed.
|
|
if ( self.team != "axis" )
|
|
return;
|
|
if ( isdefined( self.civilian ) )
|
|
return;
|
|
*/
|
|
|
|
aa_add_event( "aa_enemy_deaths", 1 );
|
|
if ( !isdefined( attacker ) )
|
|
{
|
|
//prof_end( "auto_adjust_enemy_died" );
|
|
return;
|
|
}
|
|
if ( !player_attacker( attacker ) )
|
|
{
|
|
//prof_end( "auto_adjust_enemy_died" );
|
|
return;
|
|
}
|
|
|
|
// defaults to empty_kill_func, for arcademode
|
|
[[ level.global_kill_func ]]( type, self.damagelocation, point );
|
|
|
|
aa_add_event( "aa_player_kills", 1 );
|
|
|
|
//prof_end( "auto_adjust_enemy_died" );
|
|
}
|
|
|
|
auto_adjust_enemy_death_detection()
|
|
{
|
|
for ( ;; )
|
|
{
|
|
self waittill( "damage", amount, attacker, direction_vec, point, type );
|
|
aa_add_event( "aa_enemy_damage_taken", amount );
|
|
|
|
if ( !isalive( self ) || self.delayeddeath )
|
|
{
|
|
self auto_adjust_enemy_died( amount, attacker, type, point );
|
|
return;
|
|
}
|
|
|
|
if ( !player_attacker( attacker ) )
|
|
continue;
|
|
aa_player_attacks_enemy_with_ads( amount, type, point );
|
|
}
|
|
}
|
|
|
|
aa_player_attacks_enemy_with_ads( amount, type, point )
|
|
{
|
|
aa_add_event( "aa_player_damage_dealt", amount );
|
|
assertex( getdvarint( "aa_player_damage_dealt" ) > 0 );
|
|
if ( !isADS() )
|
|
{
|
|
// defaults to empty_kill_func, for arcademode
|
|
[[ level.global_damage_func ]]( type, self.damagelocation, point );
|
|
return false;
|
|
}
|
|
|
|
if ( !bullet_attack( type ) )
|
|
{
|
|
// defaults to empty_kill_func, for arcademode
|
|
[[ level.global_damage_func ]]( type, self.damagelocation, point );
|
|
return false;
|
|
}
|
|
|
|
// defaults to empty_kill_func, for arcademode
|
|
[[ level.global_damage_func_ads ]]( type, self.damagelocation, point );
|
|
|
|
// ads only matters for bullet attacks. Otherwise you could throw a grenade then go ads and get a bunch of ads damage
|
|
aa_add_event( "aa_ads_damage_dealt", amount );
|
|
return true;
|
|
}
|
|
|
|
bullet_attack( type )
|
|
{
|
|
if ( type == "MOD_PISTOL_BULLET" )
|
|
return true;
|
|
return type == "MOD_RIFLE_BULLET";
|
|
}
|
|
|
|
/*
|
|
=============
|
|
///ScriptDocBegin
|
|
"Name: add_fractional_data_point( <name> , <frac> , <val> )"
|
|
"Summary: Adds difficulty setting data for a specific system at a specified fraction. The in game difficulty will be blended between this and the other data points."
|
|
"Module: gameskill"
|
|
"MandatoryArg: <name>: The system being adjusted."
|
|
"MandatoryArg: <frac>: Which fraction from 0 to 1 that this difficulty value exists at."
|
|
"MandatoryArg: <val>: The value that this system should be set at when the difficulty is at the specified frac."
|
|
"Example: add_fractional_data_point( "playerGrenadeRangeTime", 1.0, 7500 );"
|
|
"SPMP: singleplayer"
|
|
///ScriptDocEnd
|
|
=============
|
|
*/
|
|
add_fractional_data_point( name, frac, val )
|
|
{
|
|
//prof_begin( "add_fractional_data_point" );
|
|
|
|
if ( !isdefined( level.difficultySettings_frac_data_points[ name ] ) )
|
|
{
|
|
level.difficultySettings_frac_data_points[ name ] = [];
|
|
}
|
|
|
|
array = [];
|
|
array[ "frac" ] = frac;
|
|
array[ "val" ] = val;
|
|
assertex( frac >= 0, "Tried to set a difficulty data point less than 0." );
|
|
assertex( frac <= 1, "Tried to set a difficulty data point greater than 1." );
|
|
|
|
level.difficultySettings_frac_data_points[ name ][ level.difficultySettings_frac_data_points[ name ].size ] = array;
|
|
|
|
//prof_end( "add_fractional_data_point" );
|
|
}
|
|
|
|
update_skill_on_change()
|
|
{
|
|
waittillframeend; // for everything to be defined
|
|
for ( ;; )
|
|
{
|
|
lowest_current_skill = getdvarint( "saved_gameskill" );
|
|
gameskill = getdvarint( "g_gameskill" );
|
|
if ( gameskill < lowest_current_skill )
|
|
lowest_current_skill = gameskill;
|
|
|
|
if ( lowest_current_skill < level.gameskill )
|
|
{
|
|
setSkill( true, lowest_current_skill );
|
|
}
|
|
|
|
wait( 2 );
|
|
}
|
|
}
|