mirror of
https://github.com/Resxt/XLabs-S1X-Scripts.git
synced 2025-04-22 06:55:43 +00:00
3555 lines
102 KiB
Plaintext
3555 lines
102 KiB
Plaintext
// S1 GSC SOURCE
|
|
// Decompiled by https://github.com/xensik/gsc-tool
|
|
|
|
onforfeit( var_0 )
|
|
{
|
|
if ( isdefined( level.forfeitinprogress ) )
|
|
return;
|
|
|
|
level endon( "abort_forfeit" );
|
|
level thread forfeitwaitforabort();
|
|
level.forfeitinprogress = 1;
|
|
|
|
if ( !level.teambased && level.players.size > 1 )
|
|
wait 10;
|
|
else
|
|
wait 1.05;
|
|
|
|
level.forfeit_aborted = 0;
|
|
var_1 = 20.0;
|
|
matchforfeittimer( var_1 );
|
|
var_2 = &"";
|
|
|
|
if ( !isdefined( var_0 ) )
|
|
{
|
|
level.finalkillcam_winner = "none";
|
|
var_2 = game["end_reason"]["players_forfeited"];
|
|
var_3 = level.players[0];
|
|
}
|
|
else if ( var_0 == "axis" )
|
|
{
|
|
level.finalkillcam_winner = "axis";
|
|
var_2 = game["end_reason"]["allies_forfeited"];
|
|
|
|
if ( level.gametype == "infect" )
|
|
var_2 = game["end_reason"]["survivors_forfeited"];
|
|
|
|
var_3 = "axis";
|
|
}
|
|
else if ( var_0 == "allies" )
|
|
{
|
|
level.finalkillcam_winner = "allies";
|
|
var_2 = game["end_reason"]["axis_forfeited"];
|
|
|
|
if ( level.gametype == "infect" )
|
|
var_2 = game["end_reason"]["infected_forfeited"];
|
|
|
|
var_3 = "allies";
|
|
}
|
|
else if ( level.multiteambased && issubstr( var_0, "team_" ) )
|
|
var_3 = var_0;
|
|
else
|
|
{
|
|
level.finalkillcam_winner = "none";
|
|
var_3 = "tie";
|
|
}
|
|
|
|
level.forcedend = 1;
|
|
|
|
if ( isplayer( var_3 ) )
|
|
logstring( "forfeit, win: " + var_3 getxuid() + "(" + var_3.name + ")" );
|
|
else
|
|
logstring( "forfeit, win: " + var_3 + ", allies: " + game["teamScores"]["allies"] + ", opfor: " + game["teamScores"]["axis"] );
|
|
|
|
thread endgame( var_3, var_2 );
|
|
}
|
|
|
|
forfeitwaitforabort()
|
|
{
|
|
level endon( "game_ended" );
|
|
level waittill( "abort_forfeit" );
|
|
level.forfeit_aborted = 1;
|
|
setomnvar( "ui_match_countdown", 0 );
|
|
setomnvar( "ui_match_countdown_title", 0 );
|
|
setomnvar( "ui_match_countdown_toggle", 0 );
|
|
}
|
|
|
|
matchforfeittimer_internal( var_0 )
|
|
{
|
|
waittillframeend;
|
|
level endon( "match_forfeit_timer_beginning" );
|
|
setomnvar( "ui_match_countdown_title", 3 );
|
|
setomnvar( "ui_match_countdown_toggle", 1 );
|
|
|
|
while ( var_0 > 0 && !level.gameended && !level.forfeit_aborted && !level.ingraceperiod )
|
|
{
|
|
setomnvar( "ui_match_countdown", var_0 );
|
|
wait 1;
|
|
var_0--;
|
|
}
|
|
}
|
|
|
|
matchforfeittimer( var_0 )
|
|
{
|
|
level notify( "match_forfeit_timer_beginning" );
|
|
var_1 = int( var_0 );
|
|
matchforfeittimer_internal( var_1 );
|
|
setomnvar( "ui_match_countdown", 0 );
|
|
setomnvar( "ui_match_countdown_title", 0 );
|
|
setomnvar( "ui_match_countdown_toggle", 0 );
|
|
}
|
|
|
|
default_ondeadevent( var_0 )
|
|
{
|
|
level.finalkillcam_winner = "none";
|
|
|
|
if ( var_0 == "allies" )
|
|
{
|
|
logstring( "team eliminated, win: opfor, allies: " + game["teamScores"]["allies"] + ", opfor: " + game["teamScores"]["axis"] );
|
|
level.finalkillcam_winner = "axis";
|
|
thread endgame( "axis", game["end_reason"]["allies_eliminated"] );
|
|
}
|
|
else if ( var_0 == "axis" )
|
|
{
|
|
logstring( "team eliminated, win: allies, allies: " + game["teamScores"]["allies"] + ", opfor: " + game["teamScores"]["axis"] );
|
|
level.finalkillcam_winner = "allies";
|
|
thread endgame( "allies", game["end_reason"]["axis_eliminated"] );
|
|
}
|
|
else
|
|
{
|
|
logstring( "tie, allies: " + game["teamScores"]["allies"] + ", opfor: " + game["teamScores"]["axis"] );
|
|
level.finalkillcam_winner = "none";
|
|
|
|
if ( level.teambased )
|
|
thread endgame( "tie", game["end_reason"]["tie"] );
|
|
else
|
|
thread endgame( undefined, game["end_reason"]["tie"] );
|
|
}
|
|
}
|
|
|
|
default_ononeleftevent( var_0 )
|
|
{
|
|
if ( level.teambased )
|
|
{
|
|
var_1 = maps\mp\_utility::getlastlivingplayer( var_0 );
|
|
var_1 thread givelastonteamwarning();
|
|
}
|
|
else
|
|
{
|
|
var_1 = maps\mp\_utility::getlastlivingplayer();
|
|
logstring( "last one alive, win: " + var_1.name );
|
|
level.finalkillcam_winner = "none";
|
|
thread endgame( var_1, game["end_reason"]["enemies_eliminated"] );
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
default_ontimelimit()
|
|
{
|
|
var_0 = undefined;
|
|
level.finalkillcam_winner = "none";
|
|
|
|
if ( level.teambased )
|
|
{
|
|
if ( game["teamScores"]["allies"] == game["teamScores"]["axis"] )
|
|
var_0 = "tie";
|
|
else if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
|
|
{
|
|
level.finalkillcam_winner = "axis";
|
|
var_0 = "axis";
|
|
}
|
|
else
|
|
{
|
|
level.finalkillcam_winner = "allies";
|
|
var_0 = "allies";
|
|
}
|
|
|
|
if ( maps\mp\_utility::practiceroundgame() )
|
|
var_0 = "none";
|
|
|
|
logstring( "time limit, win: " + var_0 + ", allies: " + game["teamScores"]["allies"] + ", opfor: " + game["teamScores"]["axis"] );
|
|
}
|
|
else
|
|
{
|
|
var_0 = maps\mp\gametypes\_gamescore::gethighestscoringplayer();
|
|
|
|
if ( isdefined( var_0 ) )
|
|
logstring( "time limit, win: " + var_0.name );
|
|
else
|
|
logstring( "time limit, tie" );
|
|
}
|
|
|
|
thread endgame( var_0, game["end_reason"]["time_limit_reached"] );
|
|
}
|
|
|
|
default_onhalftime( var_0 )
|
|
{
|
|
var_1 = undefined;
|
|
level.finalkillcam_winner = "none";
|
|
thread endgame( "halftime", game["end_reason"][var_0] );
|
|
}
|
|
|
|
forceend()
|
|
{
|
|
if ( level.hostforcedend || level.forcedend )
|
|
return;
|
|
|
|
var_0 = undefined;
|
|
level.finalkillcam_winner = "none";
|
|
|
|
if ( level.teambased )
|
|
{
|
|
if ( isdefined( level.ishorde ) )
|
|
var_0 = "axis";
|
|
else if ( game["teamScores"]["allies"] == game["teamScores"]["axis"] )
|
|
var_0 = "tie";
|
|
else if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
|
|
{
|
|
level.finalkillcam_winner = "axis";
|
|
var_0 = "axis";
|
|
}
|
|
else
|
|
{
|
|
level.finalkillcam_winner = "allies";
|
|
var_0 = "allies";
|
|
}
|
|
|
|
logstring( "host ended game, win: " + var_0 + ", allies: " + game["teamScores"]["allies"] + ", opfor: " + game["teamScores"]["axis"] );
|
|
}
|
|
else
|
|
{
|
|
var_0 = maps\mp\gametypes\_gamescore::gethighestscoringplayer();
|
|
|
|
if ( isdefined( var_0 ) )
|
|
logstring( "host ended game, win: " + var_0.name );
|
|
else
|
|
logstring( "host ended game, tie" );
|
|
}
|
|
|
|
level.forcedend = 1;
|
|
level.hostforcedend = 1;
|
|
|
|
if ( level.splitscreen )
|
|
var_1 = game["end_reason"]["ended_game"];
|
|
else
|
|
var_1 = game["end_reason"]["host_ended_game"];
|
|
|
|
thread endgame( var_0, var_1 );
|
|
}
|
|
|
|
onscorelimit()
|
|
{
|
|
var_0 = game["end_reason"]["score_limit_reached"];
|
|
var_1 = undefined;
|
|
level.finalkillcam_winner = "none";
|
|
|
|
if ( level.multiteambased )
|
|
{
|
|
var_1 = maps\mp\gametypes\_gamescore::getwinningteam();
|
|
|
|
if ( var_1 == "none" )
|
|
var_1 = "tie";
|
|
}
|
|
else if ( level.teambased )
|
|
{
|
|
if ( game["teamScores"]["allies"] == game["teamScores"]["axis"] )
|
|
var_1 = "tie";
|
|
else if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
|
|
{
|
|
var_1 = "axis";
|
|
level.finalkillcam_winner = "axis";
|
|
}
|
|
else
|
|
{
|
|
var_1 = "allies";
|
|
level.finalkillcam_winner = "allies";
|
|
}
|
|
|
|
logstring( "scorelimit, win: " + var_1 + ", allies: " + game["teamScores"]["allies"] + ", opfor: " + game["teamScores"]["axis"] );
|
|
}
|
|
else
|
|
{
|
|
var_1 = maps\mp\gametypes\_gamescore::gethighestscoringplayer();
|
|
|
|
if ( isdefined( var_1 ) )
|
|
logstring( "scorelimit, win: " + var_1.name );
|
|
else
|
|
logstring( "scorelimit, tie" );
|
|
}
|
|
|
|
thread endgame( var_1, var_0 );
|
|
return 1;
|
|
}
|
|
|
|
updategameevents()
|
|
{
|
|
if ( maps\mp\_utility::matchmakinggame() && !level.ingraceperiod && !getdvarint( "force_ranking" ) && ( !isdefined( level.disableforfeit ) || !level.disableforfeit ) )
|
|
{
|
|
if ( level.multiteambased )
|
|
{
|
|
var_0 = 0;
|
|
var_1 = 0;
|
|
|
|
for ( var_2 = 0; var_2 < level.teamnamelist.size; var_2++ )
|
|
{
|
|
var_0 += level.teamcount[level.teamnamelist[var_2]];
|
|
|
|
if ( level.teamcount[level.teamnamelist[var_2]] )
|
|
var_1 += 1;
|
|
}
|
|
|
|
for ( var_2 = 0; var_2 < level.teamnamelist.size; var_2++ )
|
|
{
|
|
if ( var_0 == level.teamcount[level.teamnamelist[var_2]] && game["state"] == "playing" )
|
|
{
|
|
thread onforfeit( level.teamnamelist[var_2] );
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( var_1 > 1 )
|
|
{
|
|
level.forfeitinprogress = undefined;
|
|
level notify( "abort_forfeit" );
|
|
}
|
|
}
|
|
else if ( level.teambased )
|
|
{
|
|
if ( level.teamcount["allies"] < 1 && level.teamcount["axis"] > 0 && game["state"] == "playing" )
|
|
{
|
|
thread onforfeit( "axis" );
|
|
return;
|
|
}
|
|
|
|
if ( level.teamcount["axis"] < 1 && level.teamcount["allies"] > 0 && game["state"] == "playing" )
|
|
{
|
|
thread onforfeit( "allies" );
|
|
return;
|
|
}
|
|
|
|
if ( level.teamcount["axis"] > 0 && level.teamcount["allies"] > 0 )
|
|
{
|
|
level.forfeitinprogress = undefined;
|
|
level notify( "abort_forfeit" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( level.teamcount["allies"] + level.teamcount["axis"] == 1 && level.maxplayercount >= 1 && !getdvarint( "virtualLobbyActive", 0 ) )
|
|
{
|
|
thread onforfeit();
|
|
return;
|
|
}
|
|
|
|
if ( level.teamcount["axis"] + level.teamcount["allies"] > 1 )
|
|
{
|
|
level.forfeitinprogress = undefined;
|
|
level notify( "abort_forfeit" );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !maps\mp\_utility::getgametypenumlives() && ( !isdefined( level.disablespawning ) || !level.disablespawning ) )
|
|
return;
|
|
|
|
if ( !maps\mp\_utility::gamehasstarted() )
|
|
return;
|
|
|
|
if ( level.ingraceperiod )
|
|
return;
|
|
|
|
if ( level.multiteambased )
|
|
return;
|
|
|
|
if ( level.teambased )
|
|
{
|
|
var_3["allies"] = level.livescount["allies"];
|
|
var_3["axis"] = level.livescount["axis"];
|
|
|
|
if ( isdefined( level.disablespawning ) && level.disablespawning )
|
|
{
|
|
var_3["allies"] = 0;
|
|
var_3["axis"] = 0;
|
|
}
|
|
|
|
if ( !level.alivecount["allies"] && !level.alivecount["axis"] && !var_3["allies"] && !var_3["axis"] )
|
|
return [[ level.ondeadevent ]]( "all" );
|
|
|
|
if ( !level.alivecount["allies"] && !var_3["allies"] )
|
|
return [[ level.ondeadevent ]]( "allies" );
|
|
|
|
if ( !level.alivecount["axis"] && !var_3["axis"] )
|
|
return [[ level.ondeadevent ]]( "axis" );
|
|
|
|
var_4 = level.alivecount["allies"] == 1 && !var_3["allies"];
|
|
var_5 = level.alivecount["axis"] == 1 && !var_3["axis"];
|
|
|
|
if ( ( var_4 || var_5 ) && !isdefined( level.bot_spawn_from_devgui_in_progress ) )
|
|
{
|
|
var_6 = undefined;
|
|
|
|
if ( var_4 && !isdefined( level.onelefttime["allies"] ) )
|
|
{
|
|
level.onelefttime["allies"] = gettime();
|
|
var_7 = [[ level.ononeleftevent ]]( "allies" );
|
|
|
|
if ( isdefined( var_7 ) )
|
|
{
|
|
if ( !isdefined( var_6 ) )
|
|
var_6 = var_7;
|
|
|
|
var_6 = var_6 || var_7;
|
|
}
|
|
}
|
|
|
|
if ( var_5 && !isdefined( level.onelefttime["axis"] ) )
|
|
{
|
|
level.onelefttime["axis"] = gettime();
|
|
var_8 = [[ level.ononeleftevent ]]( "axis" );
|
|
|
|
if ( isdefined( var_8 ) )
|
|
{
|
|
if ( !isdefined( var_6 ) )
|
|
var_6 = var_8;
|
|
|
|
var_6 = var_6 || var_8;
|
|
}
|
|
}
|
|
|
|
return var_6;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( !level.alivecount["allies"] && !level.alivecount["axis"] && ( !level.livescount["allies"] && !level.livescount["axis"] ) )
|
|
return [[ level.ondeadevent ]]( "all" );
|
|
|
|
var_9 = maps\mp\_utility::getpotentiallivingplayers();
|
|
|
|
if ( var_9.size == 1 )
|
|
return [[ level.ononeleftevent ]]( "all" );
|
|
}
|
|
}
|
|
|
|
waittillfinalkillcamdone()
|
|
{
|
|
if ( !isdefined( level.finalkillcam_winner ) )
|
|
return 0;
|
|
|
|
level waittill( "final_killcam_done" );
|
|
|
|
if (GetDvarInt("mapvote_enable"))
|
|
{
|
|
[[level.mapvote_rotate_function]]();
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
timelimitclock_intermission( var_0 )
|
|
{
|
|
setgameendtime( gettime() + int( var_0 * 1000 ) );
|
|
var_1 = spawn( "script_origin", ( 0.0, 0.0, 0.0 ) );
|
|
var_1 hide();
|
|
|
|
if ( var_0 >= 10.0 )
|
|
wait(var_0 - 10.0);
|
|
|
|
for (;;)
|
|
{
|
|
var_1 playsound( "ui_mp_timer_countdown" );
|
|
wait 1.0;
|
|
}
|
|
}
|
|
|
|
waitforplayers( var_0 )
|
|
{
|
|
var_1 = gettime();
|
|
var_2 = var_1 + var_0 * 1000 - 200;
|
|
|
|
if ( var_0 > 5 )
|
|
var_3 = gettime() + getdvarint( "min_wait_for_players" ) * 1000;
|
|
else
|
|
var_3 = 0;
|
|
|
|
if ( isdefined( level.iszombiegame ) && level.iszombiegame )
|
|
var_4 = level.connectingplayers;
|
|
else
|
|
var_4 = level.connectingplayers / 3;
|
|
|
|
var_5 = 0;
|
|
|
|
for (;;)
|
|
{
|
|
if ( isdefined( game["roundsPlayed"] ) && game["roundsPlayed"] )
|
|
break;
|
|
|
|
var_6 = level.maxplayercount;
|
|
var_7 = gettime();
|
|
|
|
if ( var_6 >= var_4 && var_7 > var_3 || var_7 > var_2 )
|
|
break;
|
|
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
prematchperiod()
|
|
{
|
|
level endon( "game_ended" );
|
|
level.connectingplayers = getdvarint( "party_partyPlayerCountNum" );
|
|
|
|
if ( level.prematchperiod > 0 )
|
|
{
|
|
level.waitingforplayers = 1;
|
|
matchstarttimerwaitforplayers();
|
|
level.waitingforplayers = 0;
|
|
}
|
|
else
|
|
matchstarttimerskip();
|
|
|
|
for ( var_0 = 0; var_0 < level.players.size; var_0++ )
|
|
{
|
|
level.players[var_0] maps\mp\_utility::freezecontrolswrapper( 0 );
|
|
level.players[var_0] enableweapons();
|
|
level.players[var_0] enableammogeneration();
|
|
var_1 = maps\mp\_utility::getobjectivehinttext( level.players[var_0].pers["team"] );
|
|
|
|
if ( !isdefined( var_1 ) || !level.players[var_0].hasspawned )
|
|
continue;
|
|
|
|
level.players[var_0] thread maps\mp\gametypes\_hud_message::hintmessage( var_1 );
|
|
}
|
|
|
|
if ( game["state"] != "playing" )
|
|
return;
|
|
}
|
|
|
|
graceperiod()
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
if ( !isdefined( game["clientActive"] ) )
|
|
{
|
|
while ( getplaylistid() == 0 )
|
|
wait 0.05;
|
|
|
|
game["clientActive"] = 1;
|
|
}
|
|
|
|
while ( level.ingraceperiod > 0 )
|
|
{
|
|
wait 1.0;
|
|
level.ingraceperiod--;
|
|
}
|
|
|
|
level notify( "grace_period_ending" );
|
|
wait 0.05;
|
|
maps\mp\_utility::gameflagset( "graceperiod_done" );
|
|
level.ingraceperiod = 0;
|
|
|
|
if ( game["state"] != "playing" )
|
|
return;
|
|
|
|
level thread updategameevents();
|
|
}
|
|
|
|
sethasdonecombat( var_0, var_1 )
|
|
{
|
|
var_0.hasdonecombat = var_1;
|
|
var_0 notify( "hasDoneCombat" );
|
|
var_2 = !isdefined( var_0.hasdoneanycombat ) || !var_0.hasdoneanycombat;
|
|
|
|
if ( var_2 && var_1 )
|
|
{
|
|
var_0.hasdoneanycombat = 1;
|
|
var_0.pers["participation"] = 1;
|
|
|
|
if ( isdefined( var_0.pers["hasMatchLoss"] ) && var_0.pers["hasMatchLoss"] )
|
|
return;
|
|
|
|
updatelossstats( var_0 );
|
|
}
|
|
}
|
|
|
|
updatewinstats( var_0 )
|
|
{
|
|
if ( !var_0 maps\mp\_utility::rankingenabled() )
|
|
return;
|
|
|
|
if ( ( !isdefined( var_0.hasdoneanycombat ) || !var_0.hasdoneanycombat ) && !( level.gametype == "infect" ) )
|
|
return;
|
|
|
|
var_0 maps\mp\gametypes\_persistence::statadd( "losses", -1 );
|
|
var_0 maps\mp\gametypes\_persistence::statadd( "wins", 1 );
|
|
var_0 maps\mp\_utility::updatepersratio( "winLossRatio", "wins", "losses" );
|
|
var_0 maps\mp\gametypes\_persistence::statadd( "currentWinStreak", 1 );
|
|
var_1 = var_0 maps\mp\gametypes\_persistence::statget( "currentWinStreak" );
|
|
|
|
if ( var_1 > var_0 maps\mp\gametypes\_persistence::statget( "winStreak" ) )
|
|
var_0 maps\mp\gametypes\_persistence::statset( "winStreak", var_1 );
|
|
|
|
var_0 maps\mp\gametypes\_persistence::statsetchild( "round", "win", 1 );
|
|
var_0 maps\mp\gametypes\_persistence::statsetchild( "round", "loss", 0 );
|
|
var_0 maps\mp\gametypes\_missions::processchallenge( "ch_" + level.gametype + "_wins" );
|
|
var_0.combatrecordwin = 1;
|
|
var_0 maps\mp\gametypes\_missions::processchallengedaily( 25, undefined, undefined );
|
|
var_0 maps\mp\gametypes\_missions::processchallengedaily( 26, undefined, undefined );
|
|
var_0 maps\mp\gametypes\_missions::processchallengedaily( 27, undefined, undefined );
|
|
var_0 maps\mp\gametypes\_missions::processchallengedaily( 28, undefined, undefined );
|
|
var_0 maps\mp\gametypes\_missions::processchallengedaily( 29, undefined, undefined );
|
|
var_0 maps\mp\gametypes\_missions::processchallengedaily( 30, undefined, undefined );
|
|
var_0 maps\mp\gametypes\_missions::processchallengedaily( 36, undefined, undefined );
|
|
var_0 maps\mp\gametypes\_missions::processchallengedaily( 37, undefined, undefined );
|
|
|
|
if ( maps\mp\_utility::isgrapplinghookgamemode() )
|
|
var_0 maps\mp\gametypes\_missions::processchallenge( "ch_tier2_4_iw5_dlcgun12" );
|
|
|
|
if ( level.players.size > 5 )
|
|
{
|
|
superstarchallenge( var_0 );
|
|
|
|
switch ( level.gametype )
|
|
{
|
|
case "war":
|
|
if ( game["teamScores"][var_0.team] >= game["teamScores"][maps\mp\_utility::getotherteam( var_0.team )] + 20 )
|
|
var_0 maps\mp\gametypes\_missions::processchallenge( "ch_war_crushing" );
|
|
|
|
break;
|
|
case "hp":
|
|
if ( game["teamScores"][var_0.team] >= game["teamScores"][maps\mp\_utility::getotherteam( var_0.team )] + 70 )
|
|
var_0 maps\mp\gametypes\_missions::processchallenge( "ch_hp_crushing" );
|
|
|
|
break;
|
|
case "conf":
|
|
if ( game["teamScores"][var_0.team] >= game["teamScores"][maps\mp\_utility::getotherteam( var_0.team )] + 15 )
|
|
var_0 maps\mp\gametypes\_missions::processchallenge( "ch_conf_crushing" );
|
|
|
|
break;
|
|
case "ball":
|
|
if ( game["teamScores"][var_0.team] >= game["teamScores"][maps\mp\_utility::getotherteam( var_0.team )] + 7 )
|
|
var_0 maps\mp\gametypes\_missions::processchallenge( "ch_ball_crushing" );
|
|
|
|
break;
|
|
case "infect":
|
|
if ( var_0.team == "allies" )
|
|
{
|
|
if ( game["teamScores"][var_0.team] >= 4 )
|
|
var_0 maps\mp\gametypes\_missions::processchallenge( "ch_infect_crushing" );
|
|
|
|
if ( game["teamScores"][maps\mp\_utility::getotherteam( var_0.team )] == 1 )
|
|
var_0 maps\mp\gametypes\_missions::processchallenge( "ch_infect_cleanup" );
|
|
}
|
|
|
|
break;
|
|
case "dm":
|
|
if ( isdefined( level.placement["all"][0] ) )
|
|
{
|
|
var_2 = level.placement["all"][0];
|
|
var_3 = 9999;
|
|
|
|
if ( var_0 == var_2 )
|
|
{
|
|
foreach ( var_5 in level.players )
|
|
{
|
|
if ( var_0 == var_5 )
|
|
continue;
|
|
|
|
var_6 = var_0.score - var_5.score;
|
|
|
|
if ( var_6 < var_3 )
|
|
var_3 = var_6;
|
|
}
|
|
|
|
if ( var_3 >= 7 )
|
|
var_0 maps\mp\gametypes\_missions::processchallenge( "ch_dm_crushing" );
|
|
}
|
|
}
|
|
|
|
break;
|
|
case "gun":
|
|
foreach ( var_9 in level.players )
|
|
{
|
|
if ( var_0 == var_9 )
|
|
continue;
|
|
|
|
if ( var_0.score < var_9.score + 5 )
|
|
break;
|
|
}
|
|
|
|
var_0 maps\mp\gametypes\_missions::processchallenge( "ch_gun_crushing" );
|
|
break;
|
|
case "ctf":
|
|
case "twar":
|
|
if ( game["shut_out"][var_0.team] )
|
|
var_0 maps\mp\gametypes\_missions::processchallenge( "ch_" + level.gametype + "_crushing" );
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
superstarchallenge( var_0 )
|
|
{
|
|
var_1 = 0;
|
|
var_2 = 9999;
|
|
|
|
foreach ( var_4 in level.players )
|
|
{
|
|
if ( var_4.kills > var_1 )
|
|
var_1 = var_4.kills;
|
|
|
|
if ( var_4.deaths < var_2 )
|
|
var_2 = var_4.deaths;
|
|
}
|
|
|
|
if ( var_0.kills >= var_1 && var_0.deaths <= var_2 && var_0.kills > 0 && !isai( var_0 ) )
|
|
var_0 maps\mp\gametypes\_missions::processchallenge( "ch_" + level.gametype + "_star" );
|
|
}
|
|
|
|
checkgameendchallenges()
|
|
{
|
|
if ( level.gametype == "dom" )
|
|
{
|
|
foreach ( var_1 in level.domflags )
|
|
{
|
|
if ( !isdefined( var_1.ownedtheentireround ) || !var_1.ownedtheentireround )
|
|
continue;
|
|
|
|
var_2 = var_1 maps\mp\gametypes\_gameobjects::getownerteam();
|
|
|
|
foreach ( var_4 in level.players )
|
|
{
|
|
if ( var_4.team != var_2 )
|
|
continue;
|
|
|
|
switch ( var_1.label )
|
|
{
|
|
case "_a":
|
|
var_4 maps\mp\gametypes\_missions::processchallenge( "ch_dom_alphalock" );
|
|
continue;
|
|
case "_b":
|
|
var_4 maps\mp\gametypes\_missions::processchallenge( "ch_dom_bravolock" );
|
|
continue;
|
|
case "_c":
|
|
var_4 maps\mp\gametypes\_missions::processchallenge( "ch_dom_charlielock" );
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
updatelossstats( var_0 )
|
|
{
|
|
if ( !var_0 maps\mp\_utility::rankingenabled() )
|
|
return;
|
|
|
|
if ( !isdefined( var_0.hasdoneanycombat ) || !var_0.hasdoneanycombat )
|
|
return;
|
|
|
|
var_0.pers["hasMatchLoss"] = 1;
|
|
var_0 maps\mp\gametypes\_persistence::statadd( "losses", 1 );
|
|
var_0 maps\mp\_utility::updatepersratio( "winLossRatio", "wins", "losses" );
|
|
var_0 maps\mp\gametypes\_persistence::statsetchild( "round", "loss", 1 );
|
|
}
|
|
|
|
updatetiestats( var_0 )
|
|
{
|
|
if ( !var_0 maps\mp\_utility::rankingenabled() )
|
|
return;
|
|
|
|
if ( !isdefined( var_0.hasdoneanycombat ) || !var_0.hasdoneanycombat )
|
|
return;
|
|
|
|
var_0 maps\mp\gametypes\_persistence::statadd( "losses", -1 );
|
|
var_0 maps\mp\gametypes\_persistence::statadd( "ties", 1 );
|
|
var_0 maps\mp\_utility::updatepersratio( "winLossRatio", "wins", "losses" );
|
|
var_0 maps\mp\gametypes\_persistence::statset( "currentWinStreak", 0 );
|
|
var_0.combatrecordtie = 1;
|
|
}
|
|
|
|
updatewinlossstats( var_0 )
|
|
{
|
|
if ( maps\mp\_utility::privatematch() )
|
|
return;
|
|
|
|
if ( maps\mp\_utility::practiceroundgame() )
|
|
return;
|
|
|
|
if ( !isdefined( var_0 ) || isdefined( var_0 ) && isstring( var_0 ) && var_0 == "tie" )
|
|
{
|
|
foreach ( var_2 in level.players )
|
|
{
|
|
if ( isdefined( var_2.connectedpostgame ) )
|
|
continue;
|
|
|
|
if ( level.hostforcedend && var_2 ishost() )
|
|
{
|
|
var_2 maps\mp\gametypes\_persistence::statset( "currentWinStreak", 0 );
|
|
continue;
|
|
}
|
|
|
|
updatetiestats( var_2 );
|
|
}
|
|
}
|
|
else if ( isplayer( var_0 ) )
|
|
{
|
|
var_4[0] = var_0;
|
|
|
|
if ( level.players.size > 5 )
|
|
var_4 = maps\mp\gametypes\_gamescore::gethighestscoringplayersarray( 3 );
|
|
|
|
foreach ( var_2 in var_4 )
|
|
{
|
|
if ( isdefined( var_2.connectedpostgame ) )
|
|
continue;
|
|
|
|
if ( level.hostforcedend && var_2 ishost() )
|
|
{
|
|
var_2 maps\mp\gametypes\_persistence::statset( "currentWinStreak", 0 );
|
|
continue;
|
|
}
|
|
|
|
updatewinstats( var_2 );
|
|
}
|
|
}
|
|
else if ( isstring( var_0 ) )
|
|
{
|
|
foreach ( var_2 in level.players )
|
|
{
|
|
if ( isdefined( var_2.connectedpostgame ) )
|
|
continue;
|
|
|
|
if ( level.hostforcedend && var_2 ishost() )
|
|
{
|
|
var_2 maps\mp\gametypes\_persistence::statset( "currentWinStreak", 0 );
|
|
continue;
|
|
}
|
|
|
|
if ( var_0 == "tie" )
|
|
{
|
|
updatetiestats( var_2 );
|
|
continue;
|
|
}
|
|
|
|
if ( var_2.pers["team"] == var_0 )
|
|
{
|
|
updatewinstats( var_2 );
|
|
continue;
|
|
}
|
|
|
|
var_2 maps\mp\gametypes\_persistence::statset( "currentWinStreak", 0 );
|
|
}
|
|
}
|
|
|
|
if ( level.players.size > 5 )
|
|
{
|
|
var_4 = maps\mp\gametypes\_gamescore::gethighestscoringplayersarray( 3 );
|
|
|
|
for ( var_9 = 0; var_9 < var_4.size; var_9++ )
|
|
{
|
|
if ( var_9 == 0 )
|
|
var_4[var_9] maps\mp\gametypes\_missions::processchallenge( "ch_" + level.gametype + "_mvp" );
|
|
|
|
var_4[var_9] maps\mp\gametypes\_missions::processchallenge( "ch_" + level.gametype + "_superior" );
|
|
}
|
|
}
|
|
}
|
|
|
|
freezeplayerforroundend( var_0 )
|
|
{
|
|
self endon( "disconnect" );
|
|
maps\mp\_utility::clearlowermessages();
|
|
|
|
if ( !isdefined( var_0 ) )
|
|
var_0 = 0.05;
|
|
|
|
self closepopupmenu();
|
|
self closeingamemenu();
|
|
wait(var_0);
|
|
maps\mp\_utility::freezecontrolswrapper( 1 );
|
|
}
|
|
|
|
updatematchbonusscores( var_0 )
|
|
{
|
|
if ( !game["timePassed"] )
|
|
return;
|
|
|
|
if ( !maps\mp\_utility::matchmakinggame() )
|
|
return;
|
|
|
|
if ( maps\mp\_utility::practiceroundgame() )
|
|
return;
|
|
|
|
if ( level.teambased )
|
|
{
|
|
if ( var_0 == "allies" )
|
|
{
|
|
var_1 = "allies";
|
|
var_2 = "axis";
|
|
}
|
|
else if ( var_0 == "axis" )
|
|
{
|
|
var_1 = "axis";
|
|
var_2 = "allies";
|
|
}
|
|
else
|
|
{
|
|
var_1 = "tie";
|
|
var_2 = "tie";
|
|
}
|
|
|
|
if ( var_1 != "tie" )
|
|
clientannouncement( var_1 );
|
|
|
|
foreach ( var_4 in level.players )
|
|
{
|
|
if ( isdefined( var_4.connectedpostgame ) )
|
|
continue;
|
|
|
|
if ( !var_4 maps\mp\_utility::rankingenabled() )
|
|
continue;
|
|
|
|
if ( var_4.timeplayed["total"] < 1 || var_4.pers["participation"] < 1 )
|
|
continue;
|
|
|
|
if ( level.hostforcedend && var_4 ishost() )
|
|
continue;
|
|
|
|
var_5 = 0;
|
|
|
|
if ( var_1 == "tie" )
|
|
{
|
|
var_5 = maps\mp\gametypes\_rank::getscoreinfovalue( "tie" );
|
|
var_4.didtie = 1;
|
|
var_4.iswinner = 0;
|
|
}
|
|
else if ( isdefined( var_4.pers["team"] ) && var_4.pers["team"] == var_1 )
|
|
{
|
|
var_5 = maps\mp\gametypes\_rank::getscoreinfovalue( "win" );
|
|
var_4.iswinner = 1;
|
|
}
|
|
else if ( isdefined( var_4.pers["team"] ) && var_4.pers["team"] == var_2 )
|
|
{
|
|
var_5 = maps\mp\gametypes\_rank::getscoreinfovalue( "loss" );
|
|
var_4.iswinner = 0;
|
|
}
|
|
|
|
var_4.matchbonus = int( var_5 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach ( var_4 in level.players )
|
|
{
|
|
if ( isdefined( var_4.connectedpostgame ) )
|
|
continue;
|
|
|
|
if ( !var_4 maps\mp\_utility::rankingenabled() )
|
|
continue;
|
|
|
|
if ( var_4.timeplayed["total"] < 1 || var_4.pers["participation"] < 1 )
|
|
continue;
|
|
|
|
if ( level.hostforcedend && var_4 ishost() )
|
|
continue;
|
|
|
|
var_4.iswinner = 0;
|
|
|
|
for ( var_8 = 0; var_8 < min( level.placement["all"].size, 3 ); var_8++ )
|
|
{
|
|
if ( level.placement["all"][var_8] != var_4 )
|
|
continue;
|
|
|
|
var_4.iswinner = 1;
|
|
}
|
|
|
|
var_5 = 0;
|
|
|
|
if ( var_4.iswinner )
|
|
var_5 = maps\mp\gametypes\_rank::getscoreinfovalue( "win" );
|
|
else
|
|
var_5 = maps\mp\gametypes\_rank::getscoreinfovalue( "loss" );
|
|
|
|
var_4.matchbonus = int( var_5 );
|
|
}
|
|
}
|
|
|
|
foreach ( var_4 in level.players )
|
|
{
|
|
if ( !isdefined( var_4 ) )
|
|
continue;
|
|
|
|
if ( !isdefined( var_4.iswinner ) )
|
|
continue;
|
|
|
|
var_11 = "loss";
|
|
|
|
if ( var_4.iswinner )
|
|
var_11 = "win";
|
|
|
|
if ( isdefined( var_4.didtie ) && var_4.didtie )
|
|
var_11 = "tie";
|
|
|
|
var_4 thread givematchbonus( var_11, var_4.matchbonus );
|
|
}
|
|
}
|
|
|
|
givematchbonus( var_0, var_1 )
|
|
{
|
|
self endon( "disconnect" );
|
|
level waittill( "give_match_bonus" );
|
|
maps\mp\gametypes\_rank::giverankxp( var_0, var_1 );
|
|
maps\mp\_utility::logxpgains();
|
|
}
|
|
|
|
setxenonranks( var_0 )
|
|
{
|
|
var_1 = level.players;
|
|
|
|
for ( var_2 = 0; var_2 < var_1.size; var_2++ )
|
|
{
|
|
var_3 = var_1[var_2];
|
|
|
|
if ( !isdefined( var_3.score ) || !isdefined( var_3.pers["team"] ) )
|
|
continue;
|
|
}
|
|
|
|
for ( var_2 = 0; var_2 < var_1.size; var_2++ )
|
|
{
|
|
var_3 = var_1[var_2];
|
|
|
|
if ( !isdefined( var_3.score ) || !isdefined( var_3.pers["team"] ) )
|
|
continue;
|
|
|
|
var_4 = var_3.score;
|
|
|
|
if ( maps\mp\_utility::getminutespassed() )
|
|
var_4 = var_3.score / maps\mp\_utility::getminutespassed();
|
|
|
|
_func_173( var_3, var_3.clientid, int( var_4 ) );
|
|
}
|
|
}
|
|
|
|
checktimelimit( var_0 )
|
|
{
|
|
if ( isdefined( level.timelimitoverride ) && level.timelimitoverride )
|
|
return;
|
|
|
|
if ( game["state"] != "playing" )
|
|
{
|
|
setgameendtime( 0 );
|
|
return;
|
|
}
|
|
|
|
if ( maps\mp\_utility::gettimelimit() <= 0 )
|
|
{
|
|
if ( isdefined( level.starttime ) )
|
|
setgameendtime( level.starttime );
|
|
else
|
|
setgameendtime( 0 );
|
|
|
|
return;
|
|
}
|
|
|
|
if ( !maps\mp\_utility::gameflag( "prematch_done" ) )
|
|
{
|
|
setgameendtime( 0 );
|
|
return;
|
|
}
|
|
|
|
if ( !isdefined( level.starttime ) )
|
|
return;
|
|
|
|
if ( maps\mp\_utility::gettimepassedpercentage() > level.timepercentagecutoff )
|
|
setnojipscore( 1 );
|
|
|
|
var_1 = gettimeremaining();
|
|
|
|
if ( maps\mp\_utility::gethalftime() && game["status"] != "halftime" )
|
|
setgameendtime( gettime() + int( var_1 ) - int( maps\mp\_utility::gettimelimit() * 60 * 1000 * 0.5 ) );
|
|
else
|
|
setgameendtime( gettime() + int( var_1 ) );
|
|
|
|
if ( var_1 > 0 )
|
|
{
|
|
if ( maps\mp\_utility::gethalftime() && checkhalftime( var_0 ) )
|
|
[[ level.onhalftime ]]( "time_limit_reached" );
|
|
|
|
return;
|
|
}
|
|
|
|
[[ level.ontimelimit ]]();
|
|
}
|
|
|
|
checkhalftimescore()
|
|
{
|
|
if ( !level.halftimeonscorelimit )
|
|
return 0;
|
|
|
|
if ( !level.teambased )
|
|
return 0;
|
|
|
|
if ( game["status"] != "normal" )
|
|
return 0;
|
|
|
|
var_0 = maps\mp\_utility::getwatcheddvar( "scorelimit" );
|
|
|
|
if ( var_0 )
|
|
{
|
|
if ( game["teamScores"]["allies"] >= var_0 || game["teamScores"]["axis"] >= var_0 )
|
|
return 0;
|
|
|
|
var_1 = int( var_0 / 2 + 0.5 );
|
|
|
|
if ( game["teamScores"]["allies"] >= var_1 || game["teamScores"]["axis"] >= var_1 )
|
|
{
|
|
game["roundMillisecondsAlreadyPassed"] = maps\mp\_utility::gettimepassed();
|
|
game["round_time_to_beat"] = maps\mp\_utility::getminutespassed();
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
checkhalftime( var_0 )
|
|
{
|
|
if ( !level.teambased )
|
|
return 0;
|
|
|
|
if ( game["status"] != "normal" )
|
|
return 0;
|
|
|
|
if ( maps\mp\_utility::gettimelimit() )
|
|
{
|
|
var_1 = maps\mp\_utility::gettimelimit() * 60 * 1000 * 0.5;
|
|
|
|
if ( maps\mp\_utility::gettimepassed() >= var_1 && var_0 < var_1 && var_0 > 0 )
|
|
{
|
|
game["roundMillisecondsAlreadyPassed"] = maps\mp\_utility::gettimepassed();
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
gettimeremaining()
|
|
{
|
|
var_0 = maps\mp\_utility::gettimepassed();
|
|
var_1 = maps\mp\_utility::gettimelimit() * 60 * 1000;
|
|
|
|
if ( maps\mp\_utility::gethalftime() && game["status"] == "halftime" && isdefined( level.firsthalftimepassed ) )
|
|
{
|
|
var_2 = var_1 * 0.5;
|
|
|
|
if ( level.firsthalftimepassed < var_2 )
|
|
{
|
|
if ( level.halftimeonscorelimit )
|
|
var_0 = var_1 - level.firsthalftimepassed + var_0 - level.firsthalftimepassed;
|
|
else
|
|
var_0 += var_2 - level.firsthalftimepassed;
|
|
}
|
|
}
|
|
|
|
return var_1 - var_0;
|
|
}
|
|
|
|
checkteamscorelimitsoon( var_0 )
|
|
{
|
|
if ( maps\mp\_utility::getwatcheddvar( "scorelimit" ) <= 0 || maps\mp\_utility::isobjectivebased() )
|
|
return;
|
|
|
|
if ( isdefined( level.scorelimitoverride ) && level.scorelimitoverride )
|
|
return;
|
|
|
|
if ( level.gametype == "conf" )
|
|
return;
|
|
|
|
if ( !level.teambased )
|
|
return;
|
|
|
|
if ( maps\mp\_utility::gettimepassed() < 60000 )
|
|
return;
|
|
|
|
var_1 = estimatedtimetillscorelimit( var_0 );
|
|
|
|
if ( var_1 < 2 )
|
|
level notify( "match_ending_soon", "score" );
|
|
}
|
|
|
|
checkplayerscorelimitsoon()
|
|
{
|
|
if ( maps\mp\_utility::getwatcheddvar( "scorelimit" ) <= 0 || maps\mp\_utility::isobjectivebased() )
|
|
return;
|
|
|
|
if ( level.teambased )
|
|
return;
|
|
|
|
if ( maps\mp\_utility::gettimepassed() < 60000 )
|
|
return;
|
|
|
|
var_0 = estimatedtimetillscorelimit();
|
|
|
|
if ( var_0 < 2 )
|
|
level notify( "match_ending_soon", "score" );
|
|
}
|
|
|
|
checkscorelimit()
|
|
{
|
|
if ( maps\mp\_utility::isobjectivebased() )
|
|
return 0;
|
|
|
|
if ( isdefined( level.scorelimitoverride ) && level.scorelimitoverride )
|
|
return 0;
|
|
|
|
if ( game["state"] != "playing" )
|
|
return 0;
|
|
|
|
if ( maps\mp\_utility::getwatcheddvar( "scorelimit" ) <= 0 )
|
|
return 0;
|
|
|
|
if ( maps\mp\_utility::gethalftime() && checkhalftimescore() )
|
|
return [[ level.onhalftime ]]( "score_limit_reached" );
|
|
else if ( level.multiteambased )
|
|
{
|
|
var_0 = 0;
|
|
|
|
for ( var_1 = 0; var_1 < level.teamnamelist.size; var_1++ )
|
|
{
|
|
if ( game["teamScores"][level.teamnamelist[var_1]] >= maps\mp\_utility::getwatcheddvar( "scorelimit" ) )
|
|
var_0 = 1;
|
|
}
|
|
|
|
if ( !var_0 )
|
|
return 0;
|
|
}
|
|
else if ( level.teambased )
|
|
{
|
|
if ( game["teamScores"]["allies"] < maps\mp\_utility::getwatcheddvar( "scorelimit" ) && game["teamScores"]["axis"] < maps\mp\_utility::getwatcheddvar( "scorelimit" ) )
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
if ( !isplayer( self ) )
|
|
return 0;
|
|
|
|
if ( self.score < maps\mp\_utility::getwatcheddvar( "scorelimit" ) )
|
|
return 0;
|
|
}
|
|
|
|
return onscorelimit();
|
|
}
|
|
|
|
updategametypedvars()
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
while ( game["state"] == "playing" )
|
|
{
|
|
if ( isdefined( level.starttime ) )
|
|
{
|
|
if ( gettimeremaining() < 3000 )
|
|
{
|
|
wait 0.1;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
wait 1;
|
|
}
|
|
}
|
|
|
|
matchstarttimerwaitforplayers()
|
|
{
|
|
setomnvar( "ui_match_countdown_title", 6 );
|
|
setomnvar( "ui_match_countdown_toggle", 0 );
|
|
|
|
if ( level.currentgen )
|
|
setomnvar( "ui_cg_world_blur", 1 );
|
|
|
|
waitforplayers( level.prematchperiod );
|
|
|
|
if ( level.prematchperiodend > 0 && !isdefined( level.hostmigrationtimer ) )
|
|
matchstarttimer( level.prematchperiodend );
|
|
}
|
|
|
|
matchstarttimer_internal( var_0 )
|
|
{
|
|
waittillframeend;
|
|
level endon( "match_start_timer_beginning" );
|
|
setomnvar( "ui_match_countdown_title", 1 );
|
|
setomnvar( "ui_match_countdown_toggle", 1 );
|
|
|
|
while ( var_0 > 0 && !level.gameended )
|
|
{
|
|
setomnvar( "ui_match_countdown", var_0 );
|
|
var_0--;
|
|
|
|
if ( level.currentgen )
|
|
setomnvar( "ui_cg_world_blur", 1 );
|
|
|
|
wait 1;
|
|
}
|
|
|
|
if ( level.currentgen )
|
|
setomnvar( "ui_cg_world_blur_fade_out", 1 );
|
|
|
|
if ( level.xpscale > 1 && !( isdefined( level.ishorde ) && level.ishorde ) && !maps\mp\_utility::privatematch() && !maps\mp\_utility::practiceroundgame() && !( isdefined( level.iszombiegame ) && level.iszombiegame ) )
|
|
{
|
|
foreach ( var_2 in level.players )
|
|
var_2 thread maps\mp\gametypes\_hud_message::splashnotify( "double_xp" );
|
|
}
|
|
|
|
setomnvar( "ui_match_countdown_toggle", 0 );
|
|
setomnvar( "ui_match_countdown", 0 );
|
|
setomnvar( "ui_match_countdown_title", 2 );
|
|
level endon( "match_forfeit_timer_beginning" );
|
|
wait 1.5;
|
|
setomnvar( "ui_match_countdown_title", 0 );
|
|
}
|
|
|
|
matchstarttimer( var_0 )
|
|
{
|
|
self notify( "matchStartTimer" );
|
|
self endon( "matchStartTimer" );
|
|
level notify( "match_start_timer_beginning" );
|
|
var_1 = int( var_0 );
|
|
|
|
if ( var_1 >= 2 )
|
|
{
|
|
matchstarttimer_internal( var_1 );
|
|
visionsetnaked( "", 3.0 );
|
|
}
|
|
else
|
|
{
|
|
if ( level.currentgen )
|
|
setomnvar( "ui_cg_world_blur_fade_out", 1 );
|
|
|
|
if ( level.xpscale > 1 && !( isdefined( level.ishorde ) && level.ishorde ) && !maps\mp\_utility::privatematch() && !maps\mp\_utility::practiceroundgame() && !( isdefined( level.iszombiegame ) && level.iszombiegame ) )
|
|
{
|
|
foreach ( var_3 in level.players )
|
|
var_3 thread maps\mp\gametypes\_hud_message::splashnotify( "double_xp" );
|
|
}
|
|
|
|
visionsetnaked( "", 1.0 );
|
|
}
|
|
}
|
|
|
|
matchstarttimerskip()
|
|
{
|
|
visionsetnaked( "", 0 );
|
|
}
|
|
|
|
onroundswitch()
|
|
{
|
|
if ( !isdefined( game["switchedsides"] ) )
|
|
game["switchedsides"] = 0;
|
|
|
|
if ( game["roundsWon"]["allies"] == maps\mp\_utility::getwatcheddvar( "winlimit" ) - 1 && game["roundsWon"]["axis"] == maps\mp\_utility::getwatcheddvar( "winlimit" ) - 1 )
|
|
{
|
|
var_0 = getbetterteam();
|
|
|
|
if ( var_0 != game["defenders"] )
|
|
game["switchedsides"] = !game["switchedsides"];
|
|
|
|
level.halftimetype = "overtime";
|
|
game["dynamicEvent_Overtime"] = 1;
|
|
}
|
|
else
|
|
{
|
|
level.halftimetype = "halftime";
|
|
game["switchedsides"] = !game["switchedsides"];
|
|
}
|
|
}
|
|
|
|
checkroundswitch()
|
|
{
|
|
if ( !level.teambased )
|
|
return 0;
|
|
|
|
if ( !isdefined( level.roundswitch ) || !level.roundswitch )
|
|
return 0;
|
|
|
|
if ( game["roundsPlayed"] % level.roundswitch == 0 )
|
|
{
|
|
onroundswitch();
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
timeuntilroundend()
|
|
{
|
|
if ( level.gameended )
|
|
{
|
|
var_0 = ( gettime() - level.gameendtime ) / 1000;
|
|
var_1 = level.postroundtime - var_0;
|
|
|
|
if ( var_1 < 0 )
|
|
return 0;
|
|
|
|
return var_1;
|
|
}
|
|
|
|
if ( maps\mp\_utility::gettimelimit() <= 0 )
|
|
return undefined;
|
|
|
|
if ( !isdefined( level.starttime ) )
|
|
return undefined;
|
|
|
|
var_2 = maps\mp\_utility::gettimelimit();
|
|
var_0 = ( gettime() - level.starttime ) / 1000;
|
|
var_1 = maps\mp\_utility::gettimelimit() * 60 - var_0;
|
|
|
|
if ( isdefined( level.timepaused ) )
|
|
var_1 += level.timepaused;
|
|
|
|
return var_1 + level.postroundtime;
|
|
}
|
|
|
|
freegameplayhudelems()
|
|
{
|
|
if ( isdefined( self.perkicon ) )
|
|
{
|
|
if ( isdefined( self.perkicon[0] ) )
|
|
{
|
|
self.perkicon[0] maps\mp\gametypes\_hud_util::destroyelem();
|
|
self.perkname[0] maps\mp\gametypes\_hud_util::destroyelem();
|
|
}
|
|
|
|
if ( isdefined( self.perkicon[1] ) )
|
|
{
|
|
self.perkicon[1] maps\mp\gametypes\_hud_util::destroyelem();
|
|
self.perkname[1] maps\mp\gametypes\_hud_util::destroyelem();
|
|
}
|
|
|
|
if ( isdefined( self.perkicon[2] ) )
|
|
{
|
|
self.perkicon[2] maps\mp\gametypes\_hud_util::destroyelem();
|
|
self.perkname[2] maps\mp\gametypes\_hud_util::destroyelem();
|
|
}
|
|
}
|
|
|
|
self notify( "perks_hidden" );
|
|
self.lowermessage maps\mp\gametypes\_hud_util::destroyelem();
|
|
self.lowertimer maps\mp\gametypes\_hud_util::destroyelem();
|
|
|
|
if ( isdefined( self.proxbar ) )
|
|
self.proxbar maps\mp\gametypes\_hud_util::destroyelem();
|
|
|
|
if ( isdefined( self.proxbartext ) )
|
|
self.proxbartext maps\mp\gametypes\_hud_util::destroyelem();
|
|
}
|
|
|
|
gethostplayer()
|
|
{
|
|
var_0 = getentarray( "player", "classname" );
|
|
|
|
for ( var_1 = 0; var_1 < var_0.size; var_1++ )
|
|
{
|
|
if ( var_0[var_1] ishost() )
|
|
return var_0[var_1];
|
|
}
|
|
}
|
|
|
|
hostidledout()
|
|
{
|
|
var_0 = gethostplayer();
|
|
|
|
if ( isdefined( var_0 ) && !var_0.hasspawned && !isdefined( var_0.selectedclass ) )
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
roundendwait( var_0, var_1 )
|
|
{
|
|
foreach ( var_3 in level.players )
|
|
var_3 maps\mp\gametypes\_damage::streamfinalkillcam();
|
|
|
|
var_5 = 0;
|
|
|
|
while ( !var_5 )
|
|
{
|
|
var_6 = level.players;
|
|
var_5 = 1;
|
|
|
|
foreach ( var_3 in var_6 )
|
|
{
|
|
if ( !isdefined( var_3.doingsplash ) )
|
|
continue;
|
|
|
|
if ( !var_3 maps\mp\gametypes\_hud_message::isdoingsplash() )
|
|
continue;
|
|
|
|
var_5 = 0;
|
|
}
|
|
|
|
wait 0.5;
|
|
}
|
|
|
|
if ( !var_1 )
|
|
{
|
|
wait(var_0);
|
|
var_6 = level.players;
|
|
|
|
foreach ( var_3 in var_6 )
|
|
var_3 setclientomnvar( "ui_round_end", 0 );
|
|
|
|
level notify( "round_end_finished" );
|
|
return;
|
|
}
|
|
|
|
wait(var_0 / 2);
|
|
level notify( "give_match_bonus" );
|
|
wait(var_0 / 2);
|
|
var_5 = 0;
|
|
|
|
while ( !var_5 )
|
|
{
|
|
var_6 = level.players;
|
|
var_5 = 1;
|
|
|
|
foreach ( var_3 in var_6 )
|
|
{
|
|
if ( !isdefined( var_3.doingsplash ) )
|
|
continue;
|
|
|
|
if ( !var_3 maps\mp\gametypes\_hud_message::isdoingsplash() )
|
|
continue;
|
|
|
|
var_5 = 0;
|
|
}
|
|
|
|
wait 0.5;
|
|
}
|
|
|
|
var_6 = level.players;
|
|
|
|
foreach ( var_3 in var_6 )
|
|
var_3 setclientomnvar( "ui_round_end", 0 );
|
|
|
|
level notify( "round_end_finished" );
|
|
}
|
|
|
|
roundenddof( var_0 )
|
|
{
|
|
self setdepthoffield( 0, 128, 512, 4000, 6, 1.8 );
|
|
}
|
|
|
|
callback_startgametype()
|
|
{
|
|
maps\mp\_load::main();
|
|
maps\mp\_utility::levelflaginit( "round_over", 0 );
|
|
maps\mp\_utility::levelflaginit( "game_over", 0 );
|
|
maps\mp\_utility::levelflaginit( "block_notifies", 0 );
|
|
level.prematchperiod = 0;
|
|
level.prematchperiodend = 0;
|
|
level.postgamenotifies = 0;
|
|
level.intermission = 0;
|
|
setdvar( "bg_compassShowEnemies", getdvar( "scr_game_forceuav" ) );
|
|
|
|
if ( !isdefined( game["gamestarted"] ) )
|
|
{
|
|
game["clientid"] = 0;
|
|
var_0 = getmapcustom( "allieschar" );
|
|
|
|
if ( !isdefined( var_0 ) || var_0 == "" )
|
|
{
|
|
if ( !isdefined( game["allies"] ) )
|
|
var_0 = "sentinel";
|
|
else
|
|
var_0 = game["allies"];
|
|
}
|
|
|
|
var_1 = getmapcustom( "axischar" );
|
|
|
|
if ( !isdefined( var_1 ) || var_1 == "" )
|
|
{
|
|
if ( !isdefined( game["axis"] ) )
|
|
var_1 = "atlas";
|
|
else
|
|
var_1 = game["axis"];
|
|
}
|
|
|
|
if ( level.multiteambased )
|
|
{
|
|
var_2 = getmapcustom( "allieschar" );
|
|
|
|
if ( !isdefined( var_2 ) || var_2 == "" )
|
|
var_2 = "delta_multicam";
|
|
|
|
for ( var_3 = 0; var_3 < level.teamnamelist.size; var_3++ )
|
|
game[level.teamnamelist[var_3]] = var_2;
|
|
}
|
|
|
|
game["allies"] = var_0;
|
|
game["axis"] = var_1;
|
|
|
|
if ( !isdefined( game["attackers"] ) || !isdefined( game["defenders"] ) )
|
|
thread common_scripts\utility::error( "No attackers or defenders team defined in level .gsc." );
|
|
|
|
if ( !isdefined( game["attackers"] ) )
|
|
game["attackers"] = "allies";
|
|
|
|
if ( !isdefined( game["defenders"] ) )
|
|
game["defenders"] = "axis";
|
|
|
|
if ( !isdefined( game["state"] ) )
|
|
game["state"] = "playing";
|
|
|
|
if ( level.teambased )
|
|
{
|
|
game["strings"]["waiting_for_teams"] = &"MP_WAITING_FOR_TEAMS";
|
|
game["strings"]["opponent_forfeiting_in"] = &"MP_OPPONENT_FORFEITING_IN";
|
|
}
|
|
else
|
|
{
|
|
game["strings"]["waiting_for_teams"] = &"MP_WAITING_FOR_MORE_PLAYERS";
|
|
game["strings"]["opponent_forfeiting_in"] = &"MP_OPPONENT_FORFEITING_IN";
|
|
}
|
|
|
|
game["strings"]["press_to_spawn"] = &"PLATFORM_PRESS_TO_SPAWN";
|
|
game["strings"]["match_starting_in"] = &"MP_MATCH_STARTING_IN";
|
|
game["strings"]["match_resuming_in"] = &"MP_MATCH_RESUMING_IN";
|
|
game["strings"]["waiting_for_players"] = &"MP_WAITING_FOR_PLAYERS";
|
|
game["strings"]["spawn_tag_wait"] = &"MP_SPAWN_TAG_WAIT";
|
|
game["strings"]["spawn_next_round"] = &"MP_SPAWN_NEXT_ROUND";
|
|
game["strings"]["waiting_to_spawn"] = &"MP_WAITING_TO_SPAWN";
|
|
game["strings"]["match_starting"] = &"MP_MATCH_STARTING";
|
|
game["strings"]["change_class"] = &"MP_CHANGE_CLASS_NEXT_SPAWN";
|
|
game["strings"]["change_class_cancel"] = &"MP_CHANGE_CLASS_CANCEL";
|
|
game["strings"]["change_class_wait"] = &"MP_CHANGE_CLASS_WAIT";
|
|
game["strings"]["last_stand"] = &"MPUI_LAST_STAND";
|
|
game["strings"]["final_stand"] = &"MPUI_FINAL_STAND";
|
|
game["strings"]["cowards_way"] = &"PLATFORM_COWARDS_WAY_OUT";
|
|
game["colors"]["blue"] = ( 0.25, 0.25, 0.75 );
|
|
game["colors"]["red"] = ( 0.75, 0.25, 0.25 );
|
|
game["colors"]["white"] = ( 1.0, 1.0, 1.0 );
|
|
game["colors"]["black"] = ( 0.0, 0.0, 0.0 );
|
|
game["colors"]["grey"] = ( 0.5, 0.5, 0.5 );
|
|
game["colors"]["green"] = ( 0.25, 0.75, 0.25 );
|
|
game["colors"]["yellow"] = ( 0.65, 0.65, 0.0 );
|
|
game["colors"]["orange"] = ( 1.0, 0.45, 0.0 );
|
|
game["colors"]["cyan"] = ( 0.35, 0.7, 0.9 );
|
|
game["strings"]["allies_name"] = maps\mp\gametypes\_teams::getteamname( "allies" );
|
|
game["icons"]["allies"] = maps\mp\gametypes\_teams::getteamicon( "allies" );
|
|
game["colors"]["allies"] = maps\mp\gametypes\_teams::getteamcolor( "allies" );
|
|
game["strings"]["axis_name"] = maps\mp\gametypes\_teams::getteamname( "axis" );
|
|
game["icons"]["axis"] = maps\mp\gametypes\_teams::getteamicon( "axis" );
|
|
game["colors"]["axis"] = maps\mp\gametypes\_teams::getteamcolor( "axis" );
|
|
|
|
if ( game["colors"]["allies"] == ( 0.0, 0.0, 0.0 ) )
|
|
game["colors"]["allies"] = ( 0.5, 0.5, 0.5 );
|
|
|
|
if ( game["colors"]["axis"] == ( 0.0, 0.0, 0.0 ) )
|
|
game["colors"]["axis"] = ( 0.5, 0.5, 0.5 );
|
|
|
|
[[ level.onprecachegametype ]]();
|
|
setdvarifuninitialized( "min_wait_for_players", 5 );
|
|
|
|
if ( level.console )
|
|
{
|
|
if ( !level.splitscreen )
|
|
{
|
|
if ( _func_27A() )
|
|
level.prematchperiod = maps\mp\gametypes\_tweakables::gettweakablevalue( "game", "graceperiod_ds" );
|
|
else
|
|
level.prematchperiod = maps\mp\gametypes\_tweakables::gettweakablevalue( "game", "graceperiod" );
|
|
|
|
level.prematchperiodend = maps\mp\gametypes\_tweakables::gettweakablevalue( "game", "matchstarttime" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( _func_27A() )
|
|
level.prematchperiod = maps\mp\gametypes\_tweakables::gettweakablevalue( "game", "playerwaittime_ds" );
|
|
else
|
|
level.prematchperiod = maps\mp\gametypes\_tweakables::gettweakablevalue( "game", "playerwaittime" );
|
|
|
|
level.prematchperiodend = maps\mp\gametypes\_tweakables::gettweakablevalue( "game", "matchstarttime" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
setdvarifuninitialized( "min_wait_for_players", 5 );
|
|
|
|
if ( level.console )
|
|
{
|
|
if ( !level.splitscreen )
|
|
{
|
|
level.prematchperiod = 5;
|
|
level.prematchperiodend = maps\mp\gametypes\_tweakables::gettweakablevalue( "game", "roundstarttime" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
level.prematchperiod = 5;
|
|
level.prematchperiodend = maps\mp\gametypes\_tweakables::gettweakablevalue( "game", "roundstarttime" );
|
|
}
|
|
}
|
|
|
|
if ( !isdefined( game["status"] ) )
|
|
game["status"] = "normal";
|
|
|
|
if ( game["status"] != "overtime" && game["status"] != "halftime" && game["status"] != "overtime_halftime" )
|
|
{
|
|
game["teamScores"]["allies"] = 0;
|
|
game["teamScores"]["axis"] = 0;
|
|
|
|
if ( level.multiteambased )
|
|
{
|
|
for ( var_3 = 0; var_3 < level.teamnamelist.size; var_3++ )
|
|
game["teamScores"][level.teamnamelist[var_3]] = 0;
|
|
}
|
|
}
|
|
|
|
if ( !isdefined( game["timePassed"] ) )
|
|
game["timePassed"] = 0;
|
|
|
|
if ( !isdefined( game["roundsPlayed"] ) )
|
|
game["roundsPlayed"] = 0;
|
|
|
|
setomnvar( "ui_current_round", game["roundsPlayed"] + 1 );
|
|
|
|
if ( !isdefined( game["roundsWon"] ) )
|
|
game["roundsWon"] = [];
|
|
|
|
if ( level.teambased )
|
|
{
|
|
if ( !isdefined( game["roundsWon"]["axis"] ) )
|
|
game["roundsWon"]["axis"] = 0;
|
|
|
|
if ( !isdefined( game["roundsWon"]["allies"] ) )
|
|
game["roundsWon"]["allies"] = 0;
|
|
|
|
if ( level.multiteambased )
|
|
{
|
|
for ( var_3 = 0; var_3 < level.teamnamelist.size; var_3++ )
|
|
{
|
|
if ( !isdefined( game["roundsWon"][level.teamnamelist[var_3]] ) )
|
|
game["roundsWon"][level.teamnamelist[var_3]] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
level.gameended = 0;
|
|
level.forcedend = 0;
|
|
level.hostforcedend = 0;
|
|
level.hardcoremode = getdvarint( "g_hardcore" );
|
|
|
|
if ( level.hardcoremode )
|
|
logstring( "game mode: hardcore" );
|
|
|
|
level.diehardmode = getdvarint( "scr_diehard" );
|
|
|
|
if ( !level.teambased )
|
|
level.diehardmode = 0;
|
|
|
|
if ( level.diehardmode )
|
|
logstring( "game mode: diehard" );
|
|
|
|
level.killstreakrewards = getdvarint( "scr_game_hardpoints" );
|
|
|
|
if ( !isdefined( level.iszombiegame ) )
|
|
level.iszombiegame = 0;
|
|
|
|
level.usestartspawns = 1;
|
|
level.objectivepointsmod = 1;
|
|
level.baseplayermovescale = 1;
|
|
level.maxallowedteamkills = 2;
|
|
thread maps\mp\_teleport::main();
|
|
thread maps\mp\gametypes\_persistence::init();
|
|
thread maps\mp\gametypes\_menus::init();
|
|
thread maps\mp\gametypes\_hud::init();
|
|
thread maps\mp\gametypes\_serversettings::init();
|
|
thread maps\mp\gametypes\_teams::init();
|
|
thread maps\mp\gametypes\_weapons::init();
|
|
thread maps\mp\gametypes\_killcam::init();
|
|
thread maps\mp\gametypes\_shellshock::init();
|
|
thread maps\mp\gametypes\_deathicons::init();
|
|
thread maps\mp\gametypes\_damagefeedback::init();
|
|
thread maps\mp\gametypes\_healthoverlay::init();
|
|
thread maps\mp\gametypes\_spectating::init();
|
|
thread maps\mp\gametypes\_objpoints::init();
|
|
thread maps\mp\gametypes\_gameobjects::init();
|
|
thread maps\mp\gametypes\_spawnlogic::init();
|
|
thread maps\mp\gametypes\_battlechatter_mp::init();
|
|
thread maps\mp\gametypes\_music_and_dialog::init();
|
|
thread maps\mp\gametypes\_high_jump_mp::init();
|
|
thread maps\mp\_grappling_hook::init();
|
|
thread maps\mp\_matchdata::init();
|
|
thread maps\mp\_awards::init();
|
|
thread maps\mp\_areas::init();
|
|
|
|
if ( !maps\mp\_utility::invirtuallobby() )
|
|
thread maps\mp\killstreaks\_killstreaks_init::init();
|
|
|
|
thread maps\mp\perks\_perks::init();
|
|
thread maps\mp\_events::init();
|
|
thread maps\mp\gametypes\_damage::initfinalkillcam();
|
|
thread maps\mp\_threatdetection::init();
|
|
thread maps\mp\_exo_suit::init();
|
|
thread maps\mp\_reinforcements::init();
|
|
thread maps\mp\_snd_common_mp::init();
|
|
thread maps\mp\_utility::buildattachmentmaps();
|
|
|
|
if ( level.teambased )
|
|
thread maps\mp\gametypes\_friendicons::init();
|
|
|
|
thread maps\mp\gametypes\_hud_message::init();
|
|
thread maps\mp\gametypes\_divisions::init();
|
|
|
|
foreach ( var_5 in game["strings"] )
|
|
precachestring( var_5 );
|
|
|
|
foreach ( var_8 in game["icons"] )
|
|
precacheshader( var_8 );
|
|
|
|
game["gamestarted"] = 1;
|
|
level.maxplayercount = 0;
|
|
level.wavedelay["allies"] = 0;
|
|
level.wavedelay["axis"] = 0;
|
|
level.lastwave["allies"] = 0;
|
|
level.lastwave["axis"] = 0;
|
|
level.waveplayerspawnindex["allies"] = 0;
|
|
level.waveplayerspawnindex["axis"] = 0;
|
|
level.aliveplayers["allies"] = [];
|
|
level.aliveplayers["axis"] = [];
|
|
level.activeplayers = [];
|
|
|
|
if ( level.multiteambased )
|
|
{
|
|
for ( var_3 = 0; var_3 < level.teamnamelist.size; var_3++ )
|
|
{
|
|
level._wavedelay[level.teamnamelist[var_3]] = 0;
|
|
level._lastwave[level.teamnamelist[var_3]] = 0;
|
|
level._waveplayerspawnindex[level.teamnamelist[var_3]] = 0;
|
|
level._aliveplayers[level.teamnamelist[var_3]] = [];
|
|
}
|
|
}
|
|
|
|
setdvar( "ui_scorelimit", 0 );
|
|
setdvar( "ui_allow_teamchange", 1 );
|
|
|
|
if ( maps\mp\_utility::getgametypenumlives() )
|
|
setdvar( "g_deadChat", 0 );
|
|
else
|
|
setdvar( "g_deadChat", 1 );
|
|
|
|
var_10 = getdvarfloat( "scr_" + level.gametype + "_waverespawndelay" );
|
|
|
|
if ( var_10 > 0 )
|
|
{
|
|
level.wavedelay["allies"] = var_10;
|
|
level.wavedelay["axis"] = var_10;
|
|
level.lastwave["allies"] = 0;
|
|
level.lastwave["axis"] = 0;
|
|
|
|
if ( level.multiteambased )
|
|
{
|
|
for ( var_3 = 0; var_3 < level.teamnamelist.size; var_3++ )
|
|
{
|
|
level._wavedelay[level.teamnamelist[var_3]] = var_10;
|
|
level._lastwave[level.teamnamelist[var_3]] = 0;
|
|
}
|
|
}
|
|
|
|
level thread wavespawntimer();
|
|
}
|
|
|
|
maps\mp\_utility::gameflaginit( "prematch_done", 0 );
|
|
level.graceperiod = 15;
|
|
level.ingraceperiod = level.graceperiod;
|
|
maps\mp\_utility::gameflaginit( "graceperiod_done", 0 );
|
|
level.roundenddelay = 4;
|
|
level.halftimeroundenddelay = 4;
|
|
level.noragdollents = getentarray( "noragdoll", "targetname" );
|
|
|
|
if ( level.teambased )
|
|
{
|
|
maps\mp\gametypes\_gamescore::updateteamscore( "axis" );
|
|
maps\mp\gametypes\_gamescore::updateteamscore( "allies" );
|
|
|
|
if ( level.multiteambased )
|
|
{
|
|
for ( var_3 = 0; var_3 < level.teamnamelist.size; var_3++ )
|
|
maps\mp\gametypes\_gamescore::updateteamscore( level.teamnamelist[var_3] );
|
|
}
|
|
}
|
|
else
|
|
thread maps\mp\gametypes\_gamescore::initialdmscoreupdate();
|
|
|
|
thread updateuiscorelimit();
|
|
level notify( "update_scorelimit" );
|
|
[[ level.onstartgametype ]]();
|
|
level.scorepercentagecutoff = getdvarint( "scr_" + level.gametype + "_score_percentage_cut_off", 80 );
|
|
level.timepercentagecutoff = getdvarint( "scr_" + level.gametype + "_time_percentage_cut_off", 80 );
|
|
|
|
if ( !level.console && ( getdvar( "dedicated" ) == "dedicated LAN server" || getdvar( "dedicated" ) == "dedicated internet server" ) )
|
|
thread verifydedicatedconfiguration();
|
|
|
|
setattackingteam();
|
|
thread startgame();
|
|
level thread maps\mp\_utility::updatewatcheddvars();
|
|
level thread timelimitthread();
|
|
level thread maps\mp\gametypes\_damage::dofinalkillcam();
|
|
}
|
|
|
|
setattackingteam()
|
|
{
|
|
if ( game["attackers"] == "axis" )
|
|
var_0 = 1;
|
|
else if ( game["attackers"] == "allies" )
|
|
var_0 = 2;
|
|
else
|
|
var_0 = 0;
|
|
|
|
setomnvar( "ui_attacking_team", var_0 );
|
|
}
|
|
|
|
callback_codeendgame()
|
|
{
|
|
setplayerteamrank();
|
|
|
|
if ( !level.gameended )
|
|
level thread forceend();
|
|
}
|
|
|
|
verifydedicatedconfiguration()
|
|
{
|
|
for (;;)
|
|
{
|
|
if ( level.rankedmatch )
|
|
exitlevel( 0 );
|
|
|
|
if ( !getdvarint( "xblive_privatematch" ) )
|
|
exitlevel( 0 );
|
|
|
|
if ( getdvar( "dedicated" ) != "dedicated LAN server" && getdvar( "dedicated" ) != "dedicated internet server" )
|
|
exitlevel( 0 );
|
|
|
|
wait 5;
|
|
}
|
|
}
|
|
|
|
timelimitthread()
|
|
{
|
|
level endon( "game_ended" );
|
|
var_0 = maps\mp\_utility::gettimepassed();
|
|
|
|
while ( game["state"] == "playing" )
|
|
{
|
|
thread checktimelimit( var_0 );
|
|
var_0 = maps\mp\_utility::gettimepassed();
|
|
|
|
if ( isdefined( level.starttime ) )
|
|
{
|
|
if ( gettimeremaining() < 3000 )
|
|
{
|
|
wait 0.1;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
wait 1;
|
|
}
|
|
}
|
|
|
|
updateuiscorelimit()
|
|
{
|
|
for (;;)
|
|
{
|
|
level common_scripts\utility::waittill_either( "update_scorelimit", "update_winlimit" );
|
|
|
|
if ( !maps\mp\_utility::isroundbased() || !maps\mp\_utility::isobjectivebased() )
|
|
{
|
|
setdvar( "ui_scorelimit", maps\mp\_utility::getwatcheddvar( "scorelimit" ) );
|
|
thread checkscorelimit();
|
|
continue;
|
|
}
|
|
|
|
setdvar( "ui_scorelimit", maps\mp\_utility::getwatcheddvar( "winlimit" ) );
|
|
}
|
|
}
|
|
|
|
playtickingsound()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "stop_ticking" );
|
|
level endon( "game_ended" );
|
|
var_0 = level.bombtimer;
|
|
|
|
for (;;)
|
|
{
|
|
self playsound( "ui_mp_suitcasebomb_timer" );
|
|
|
|
if ( var_0 > 10 )
|
|
{
|
|
var_0 -= 1;
|
|
wait 1;
|
|
}
|
|
else if ( var_0 > 4 )
|
|
{
|
|
var_0 -= 0.5;
|
|
wait 0.5;
|
|
}
|
|
else if ( var_0 > 1 )
|
|
{
|
|
var_0 -= 0.4;
|
|
wait 0.4;
|
|
}
|
|
else
|
|
{
|
|
var_0 -= 0.3;
|
|
wait 0.3;
|
|
}
|
|
|
|
maps\mp\gametypes\_hostmigration::waittillhostmigrationdone();
|
|
}
|
|
}
|
|
|
|
stoptickingsound()
|
|
{
|
|
self notify( "stop_ticking" );
|
|
}
|
|
|
|
timelimitclock()
|
|
{
|
|
level endon( "game_ended" );
|
|
wait 0.05;
|
|
var_0 = spawn( "script_origin", ( 0.0, 0.0, 0.0 ) );
|
|
var_0 hide();
|
|
|
|
while ( game["state"] == "playing" )
|
|
{
|
|
if ( !level.timerstopped && maps\mp\_utility::gettimelimit() )
|
|
{
|
|
var_1 = gettimeremaining() / 1000;
|
|
var_2 = int( var_1 + 0.5 );
|
|
var_3 = int( maps\mp\_utility::gettimelimit() * 60 * 0.5 );
|
|
|
|
if ( maps\mp\_utility::gethalftime() && var_2 > var_3 )
|
|
var_2 -= var_3;
|
|
|
|
if ( var_2 >= 30 && var_2 <= 60 )
|
|
level notify( "match_ending_soon", "time" );
|
|
|
|
if ( var_2 <= 10 || var_2 <= 30 && var_2 % 2 == 0 )
|
|
{
|
|
level notify( "match_ending_very_soon" );
|
|
|
|
if ( var_2 == 0 )
|
|
break;
|
|
|
|
var_0 playsound( "ui_mp_timer_countdown" );
|
|
}
|
|
|
|
if ( var_1 - floor( var_1 ) >= 0.05 )
|
|
wait(var_1 - floor( var_1 ));
|
|
}
|
|
|
|
wait 1.0;
|
|
}
|
|
}
|
|
|
|
gametimer()
|
|
{
|
|
level endon( "game_ended" );
|
|
level waittill( "prematch_over" );
|
|
level.starttime = gettime();
|
|
level.discardtime = 0;
|
|
level.matchdurationstarttime = gettime();
|
|
|
|
if ( isdefined( game["roundMillisecondsAlreadyPassed"] ) )
|
|
{
|
|
level.starttime -= game["roundMillisecondsAlreadyPassed"];
|
|
level.firsthalftimepassed = game["roundMillisecondsAlreadyPassed"];
|
|
game["roundMillisecondsAlreadyPassed"] = undefined;
|
|
}
|
|
|
|
var_0 = gettime();
|
|
|
|
while ( game["state"] == "playing" )
|
|
{
|
|
if ( !level.timerstopped )
|
|
game["timePassed"] += gettime() - var_0;
|
|
|
|
var_0 = gettime();
|
|
wait 1.0;
|
|
}
|
|
}
|
|
|
|
updatetimerpausedness()
|
|
{
|
|
var_0 = level.timerstoppedforgamemode || isdefined( level.hostmigrationtimer );
|
|
|
|
if ( !maps\mp\_utility::gameflag( "prematch_done" ) )
|
|
var_0 = 0;
|
|
|
|
if ( !level.timerstopped && var_0 )
|
|
{
|
|
level.timerstopped = 1;
|
|
level.timerpausetime = gettime();
|
|
}
|
|
else if ( level.timerstopped && !var_0 )
|
|
{
|
|
level.timerstopped = 0;
|
|
level.discardtime += gettime() - level.timerpausetime;
|
|
}
|
|
}
|
|
|
|
pausetimer()
|
|
{
|
|
level.timerstoppedforgamemode = 1;
|
|
updatetimerpausedness();
|
|
}
|
|
|
|
resumetimer()
|
|
{
|
|
level.timerstoppedforgamemode = 0;
|
|
updatetimerpausedness();
|
|
}
|
|
|
|
startgame()
|
|
{
|
|
thread gametimer();
|
|
level.timerstopped = 0;
|
|
level.timerstoppedforgamemode = 0;
|
|
setdvar( "ui_inprematch", 1 );
|
|
prematchperiod();
|
|
maps\mp\_utility::gameflagset( "prematch_done" );
|
|
level notify( "prematch_over" );
|
|
setdvar( "ui_inprematch", 0 );
|
|
level.prematch_done_time = gettime();
|
|
updatetimerpausedness();
|
|
thread timelimitclock();
|
|
thread graceperiod();
|
|
thread maps\mp\gametypes\_missions::roundbegin();
|
|
thread maps\mp\_matchdata::matchstarted();
|
|
var_0 = isdefined( level.ishorde ) && level.ishorde;
|
|
var_1 = isdefined( level.iszombiegame ) && level.iszombiegame;
|
|
|
|
if ( var_0 || var_1 )
|
|
thread updategameduration();
|
|
|
|
_func_240();
|
|
}
|
|
|
|
wavespawntimer()
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
while ( game["state"] == "playing" )
|
|
{
|
|
var_0 = gettime();
|
|
|
|
if ( var_0 - level.lastwave["allies"] > level.wavedelay["allies"] * 1000 )
|
|
{
|
|
level notify( "wave_respawn_allies" );
|
|
level.lastwave["allies"] = var_0;
|
|
level.waveplayerspawnindex["allies"] = 0;
|
|
}
|
|
|
|
if ( var_0 - level.lastwave["axis"] > level.wavedelay["axis"] * 1000 )
|
|
{
|
|
level notify( "wave_respawn_axis" );
|
|
level.lastwave["axis"] = var_0;
|
|
level.waveplayerspawnindex["axis"] = 0;
|
|
}
|
|
|
|
if ( level.multiteambased )
|
|
{
|
|
for ( var_1 = 0; var_1 < level.teamnamelist.size; var_1++ )
|
|
{
|
|
if ( var_0 - level.lastwave[level.teamnamelist[var_1]] > level._wavedelay[level.teamnamelist[var_1]] * 1000 )
|
|
{
|
|
var_2 = "wave_rewpawn_" + level.teamnamelist[var_1];
|
|
level notify( var_2 );
|
|
level.lastwave[level.teamnamelist[var_1]] = var_0;
|
|
level.waveplayerspawnindex[level.teamnamelist[var_1]] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
getbetterteam()
|
|
{
|
|
var_0["allies"] = 0;
|
|
var_0["axis"] = 0;
|
|
var_1["allies"] = 0;
|
|
var_1["axis"] = 0;
|
|
var_2["allies"] = 0;
|
|
var_2["axis"] = 0;
|
|
|
|
foreach ( var_4 in level.players )
|
|
{
|
|
var_5 = var_4.pers["team"];
|
|
|
|
if ( isdefined( var_5 ) && ( var_5 == "allies" || var_5 == "axis" ) )
|
|
{
|
|
var_0[var_5] += var_4.score;
|
|
var_1[var_5] += var_4.kills;
|
|
var_2[var_5] += var_4.deaths;
|
|
}
|
|
}
|
|
|
|
if ( var_0["allies"] > var_0["axis"] )
|
|
return "allies";
|
|
else if ( var_0["axis"] > var_0["allies"] )
|
|
return "axis";
|
|
|
|
if ( var_1["allies"] > var_1["axis"] )
|
|
return "allies";
|
|
else if ( var_1["axis"] > var_1["allies"] )
|
|
return "axis";
|
|
|
|
if ( var_2["allies"] < var_2["axis"] )
|
|
return "allies";
|
|
else if ( var_2["axis"] < var_2["allies"] )
|
|
return "axis";
|
|
|
|
if ( randomint( 2 ) == 0 )
|
|
return "allies";
|
|
|
|
return "axis";
|
|
}
|
|
|
|
rankedmatchupdates( var_0 )
|
|
{
|
|
if ( !maps\mp\_utility::waslastround() )
|
|
return;
|
|
|
|
var_0 = getgamewinner( var_0, 0 );
|
|
|
|
if ( maps\mp\_utility::matchmakinggame() )
|
|
{
|
|
setxenonranks();
|
|
|
|
if ( hostidledout() )
|
|
{
|
|
level.hostforcedend = 1;
|
|
logstring( "host idled out" );
|
|
endlobby();
|
|
}
|
|
|
|
updatematchbonusscores( var_0 );
|
|
}
|
|
|
|
updatewinlossstats( var_0 );
|
|
}
|
|
|
|
displayroundend( var_0, var_1 )
|
|
{
|
|
if ( !maps\mp\_utility::practiceroundgame() )
|
|
{
|
|
foreach ( var_3 in level.players )
|
|
{
|
|
if ( isdefined( var_3.connectedpostgame ) || var_3.pers["team"] == "spectator" && !var_3 ismlgspectator() )
|
|
continue;
|
|
|
|
if ( level.teambased )
|
|
{
|
|
var_3 thread maps\mp\gametypes\_hud_message::teamoutcomenotify( var_0, 1, var_1 );
|
|
continue;
|
|
}
|
|
|
|
var_3 thread maps\mp\gametypes\_hud_message::outcomenotify( var_0, var_1 );
|
|
}
|
|
}
|
|
|
|
if ( !maps\mp\_utility::waslastround() )
|
|
level notify( "round_win", var_0 );
|
|
|
|
if ( maps\mp\_utility::waslastround() )
|
|
roundendwait( level.roundenddelay, 0 );
|
|
else
|
|
roundendwait( level.roundenddelay, 1 );
|
|
}
|
|
|
|
displaygameend( var_0, var_1 )
|
|
{
|
|
if ( !maps\mp\_utility::practiceroundgame() )
|
|
{
|
|
foreach ( var_3 in level.players )
|
|
{
|
|
if ( isdefined( var_3.connectedpostgame ) || var_3.pers["team"] == "spectator" && !var_3 ismlgspectator() )
|
|
continue;
|
|
|
|
if ( level.teambased )
|
|
{
|
|
var_3 thread maps\mp\gametypes\_hud_message::teamoutcomenotify( var_0, 0, var_1, 1 );
|
|
continue;
|
|
}
|
|
|
|
var_3 thread maps\mp\gametypes\_hud_message::outcomenotify( var_0, var_1 );
|
|
}
|
|
}
|
|
|
|
level notify( "game_win", var_0 );
|
|
roundendwait( level.postroundtime, 1 );
|
|
}
|
|
|
|
displayroundswitch()
|
|
{
|
|
var_0 = level.halftimetype;
|
|
|
|
if ( var_0 == "halftime" )
|
|
{
|
|
if ( maps\mp\_utility::getwatcheddvar( "roundlimit" ) )
|
|
{
|
|
if ( game["roundsPlayed"] * 2 == maps\mp\_utility::getwatcheddvar( "roundlimit" ) )
|
|
var_0 = "halftime";
|
|
else
|
|
var_0 = "intermission";
|
|
}
|
|
else if ( maps\mp\_utility::getwatcheddvar( "winlimit" ) )
|
|
{
|
|
if ( game["roundsPlayed"] == maps\mp\_utility::getwatcheddvar( "winlimit" ) - 1 )
|
|
var_0 = "halftime";
|
|
else
|
|
var_0 = "intermission";
|
|
}
|
|
else
|
|
var_0 = "intermission";
|
|
}
|
|
|
|
level notify( "round_switch", var_0 );
|
|
|
|
foreach ( var_2 in level.players )
|
|
{
|
|
if ( isdefined( var_2.connectedpostgame ) || var_2.pers["team"] == "spectator" && !var_2 ismlgspectator() )
|
|
continue;
|
|
|
|
var_2 thread maps\mp\gametypes\_hud_message::teamoutcomenotify( var_0, 1, game["end_reason"]["switching_sides"] );
|
|
}
|
|
|
|
roundendwait( level.halftimeroundenddelay, 0 );
|
|
}
|
|
|
|
freezeallplayers( var_0, var_1 )
|
|
{
|
|
if ( !isdefined( var_0 ) )
|
|
var_0 = 0;
|
|
|
|
foreach ( var_3 in level.players )
|
|
{
|
|
var_3 disableammogeneration();
|
|
var_3 thread freezeplayerforroundend( var_0 );
|
|
var_3 thread roundenddof( 4.0 );
|
|
var_3 freegameplayhudelems();
|
|
|
|
if ( isdefined( var_1 ) && var_1 )
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( isdefined( level.agentarray ) )
|
|
{
|
|
foreach ( var_6 in level.agentarray )
|
|
var_6 maps\mp\_utility::freezecontrolswrapper( 1 );
|
|
}
|
|
}
|
|
|
|
endgameovertime( var_0, var_1 )
|
|
{
|
|
setdvar( "bg_compassShowEnemies", 0 );
|
|
freezeallplayers( 1.0, 1 );
|
|
|
|
foreach ( var_3 in level.players )
|
|
{
|
|
var_3.pers["stats"] = var_3.stats;
|
|
var_3.pers["segments"] = var_3.segments;
|
|
}
|
|
|
|
level notify( "round_switch", "overtime" );
|
|
var_5 = 0;
|
|
var_6 = var_0 == "overtime";
|
|
|
|
if ( level.gametype == "ctf" )
|
|
{
|
|
var_0 = "tie";
|
|
var_5 = 1;
|
|
|
|
if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
|
|
var_0 = "axis";
|
|
|
|
if ( game["teamScores"]["allies"] > game["teamScores"]["axis"] )
|
|
var_0 = "allies";
|
|
}
|
|
|
|
foreach ( var_3 in level.players )
|
|
{
|
|
if ( isdefined( var_3.connectedpostgame ) || var_3.pers["team"] == "spectator" && !var_3 ismlgspectator() )
|
|
continue;
|
|
|
|
if ( level.teambased )
|
|
{
|
|
var_3 thread maps\mp\gametypes\_hud_message::teamoutcomenotify( var_0, var_5, var_1 );
|
|
continue;
|
|
}
|
|
|
|
var_3 thread maps\mp\gametypes\_hud_message::outcomenotify( var_0, var_1 );
|
|
}
|
|
|
|
roundendwait( level.roundenddelay, 0 );
|
|
|
|
if ( level.gametype == "ctf" )
|
|
var_0 = "overtime_halftime";
|
|
|
|
if ( isdefined( level.finalkillcam_winner ) && var_6 )
|
|
{
|
|
level.finalkillcam_timegameended[level.finalkillcam_winner] = maps\mp\_utility::getsecondspassed();
|
|
|
|
foreach ( var_3 in level.players )
|
|
var_3 notify( "reset_outcome" );
|
|
|
|
level notify( "game_cleanup" );
|
|
waittillfinalkillcamdone();
|
|
|
|
if ( level.gametype == "ctf" )
|
|
{
|
|
var_0 = "overtime";
|
|
var_1 = game["end_reason"]["tie"];
|
|
}
|
|
|
|
foreach ( var_3 in level.players )
|
|
{
|
|
if ( isdefined( var_3.connectedpostgame ) || var_3.pers["team"] == "spectator" && !var_3 ismlgspectator() )
|
|
continue;
|
|
|
|
if ( level.teambased )
|
|
{
|
|
var_3 thread maps\mp\gametypes\_hud_message::teamoutcomenotify( var_0, 0, var_1 );
|
|
continue;
|
|
}
|
|
|
|
var_3 thread maps\mp\gametypes\_hud_message::outcomenotify( var_0, var_1 );
|
|
}
|
|
|
|
roundendwait( level.halftimeroundenddelay, 0 );
|
|
}
|
|
|
|
game["status"] = var_0;
|
|
level notify( "restarting" );
|
|
game["state"] = "playing";
|
|
setdvar( "ui_game_state", game["state"] );
|
|
map_restart( 1 );
|
|
}
|
|
|
|
endgamehalftime( var_0 )
|
|
{
|
|
setdvar( "bg_compassShowEnemies", 0 );
|
|
var_1 = "halftime";
|
|
var_2 = 1;
|
|
|
|
if ( isdefined( level.halftime_switch_sides ) && !level.halftime_switch_sides )
|
|
var_2 = 0;
|
|
|
|
if ( var_2 )
|
|
{
|
|
game["switchedsides"] = !game["switchedsides"];
|
|
var_3 = game["end_reason"]["switching_sides"];
|
|
}
|
|
else
|
|
var_3 = var_0;
|
|
|
|
freezeallplayers( 1.0, 1 );
|
|
|
|
if ( level.gametype == "ctf" )
|
|
{
|
|
var_3 = var_0;
|
|
var_1 = "tie";
|
|
|
|
if ( game["teamScores"]["axis"] > game["teamScores"]["allies"] )
|
|
var_1 = "axis";
|
|
|
|
if ( game["teamScores"]["allies"] > game["teamScores"]["axis"] )
|
|
var_1 = "allies";
|
|
}
|
|
|
|
foreach ( var_5 in level.players )
|
|
{
|
|
var_5.pers["stats"] = var_5.stats;
|
|
var_5.pers["segments"] = var_5.segments;
|
|
}
|
|
|
|
level notify( "round_switch", "halftime" );
|
|
|
|
foreach ( var_5 in level.players )
|
|
{
|
|
if ( isdefined( var_5.connectedpostgame ) || var_5.pers["team"] == "spectator" && !var_5 ismlgspectator() )
|
|
continue;
|
|
|
|
var_5 thread maps\mp\gametypes\_hud_message::teamoutcomenotify( var_1, 1, var_3 );
|
|
}
|
|
|
|
roundendwait( level.roundenddelay, 0 );
|
|
|
|
if ( isdefined( level.finalkillcam_winner ) )
|
|
{
|
|
level.finalkillcam_timegameended[level.finalkillcam_winner] = maps\mp\_utility::getsecondspassed();
|
|
|
|
foreach ( var_5 in level.players )
|
|
var_5 notify( "reset_outcome" );
|
|
|
|
level notify( "game_cleanup" );
|
|
waittillfinalkillcamdone();
|
|
var_11 = game["end_reason"]["switching_sides"];
|
|
|
|
if ( !var_2 )
|
|
var_11 = var_3;
|
|
|
|
foreach ( var_5 in level.players )
|
|
{
|
|
if ( isdefined( var_5.connectedpostgame ) || var_5.pers["team"] == "spectator" && !var_5 ismlgspectator() )
|
|
continue;
|
|
|
|
var_5 thread maps\mp\gametypes\_hud_message::teamoutcomenotify( "halftime", 1, var_11 );
|
|
}
|
|
|
|
roundendwait( level.halftimeroundenddelay, 0 );
|
|
}
|
|
|
|
game["status"] = "halftime";
|
|
level notify( "restarting" );
|
|
game["state"] = "playing";
|
|
setdvar( "ui_game_state", game["state"] );
|
|
map_restart( 1 );
|
|
}
|
|
|
|
updategameduration()
|
|
{
|
|
level endon( "game_ended" );
|
|
|
|
for (;;)
|
|
{
|
|
var_0 = getgameduration();
|
|
setomnvar( "ui_game_duration", var_0 * 1000 );
|
|
wait 1.0;
|
|
}
|
|
}
|
|
|
|
getgameduration()
|
|
{
|
|
var_0 = maps\mp\_utility::getgametimepassedseconds();
|
|
|
|
if ( isdefined( level.ishorde ) && level.ishorde )
|
|
var_0 = gamedurationclamp( var_0 );
|
|
|
|
return var_0;
|
|
}
|
|
|
|
gamedurationclamp( var_0 )
|
|
{
|
|
if ( var_0 > 86399 )
|
|
return 86399;
|
|
|
|
return var_0;
|
|
}
|
|
|
|
endgame( var_0, var_1, var_2 )
|
|
{
|
|
if ( !isdefined( var_2 ) )
|
|
var_2 = 0;
|
|
|
|
if ( game["state"] == "postgame" || level.gameended )
|
|
return;
|
|
|
|
game["state"] = "postgame";
|
|
setdvar( "ui_game_state", "postgame" );
|
|
level.gameendtime = gettime();
|
|
level.gameended = 1;
|
|
level.ingraceperiod = 0;
|
|
level notify( "game_ended", var_0 );
|
|
maps\mp\_utility::levelflagset( "game_over" );
|
|
maps\mp\_utility::levelflagset( "block_notifies" );
|
|
var_3 = getgameduration();
|
|
setomnvar( "ui_game_duration", var_3 * 1000 );
|
|
waitframe();
|
|
setgameendtime( 0 );
|
|
setmatchdata( "gameLengthSeconds", var_3 );
|
|
setmatchdata( "endTimeUTC", getsystemtime() );
|
|
checkgameendchallenges();
|
|
|
|
if ( isdefined( var_0 ) && isstring( var_0 ) && maps\mp\_utility::isovertimetext( var_0 ) )
|
|
{
|
|
level.finalkillcam_winner = "none";
|
|
endgameovertime( var_0, var_1 );
|
|
return;
|
|
}
|
|
|
|
if ( isdefined( var_0 ) && isstring( var_0 ) && var_0 == "halftime" )
|
|
{
|
|
level.finalkillcam_winner = "none";
|
|
endgamehalftime( var_1 );
|
|
return;
|
|
}
|
|
|
|
if ( isdefined( level.finalkillcam_winner ) )
|
|
level.finalkillcam_timegameended[level.finalkillcam_winner] = maps\mp\_utility::getsecondspassed();
|
|
|
|
game["roundsPlayed"]++;
|
|
setomnvar( "ui_current_round", game["roundsPlayed"] );
|
|
|
|
if ( level.teambased )
|
|
{
|
|
if ( ( var_0 == "axis" || var_0 == "allies" ) && level.gametype != "ctf" )
|
|
game["roundsWon"][var_0]++;
|
|
|
|
maps\mp\gametypes\_gamescore::updateteamscore( "axis" );
|
|
maps\mp\gametypes\_gamescore::updateteamscore( "allies" );
|
|
}
|
|
else if ( isdefined( var_0 ) && isplayer( var_0 ) )
|
|
game["roundsWon"][var_0.guid]++;
|
|
|
|
maps\mp\gametypes\_gamescore::updateplacement();
|
|
rankedmatchupdates( var_0 );
|
|
|
|
foreach ( var_5 in level.players )
|
|
{
|
|
var_5 setclientdvar( "ui_opensummary", 1 );
|
|
|
|
if ( maps\mp\_utility::wasonlyround() || maps\mp\_utility::waslastround() )
|
|
var_5 maps\mp\killstreaks\_killstreaks::clearkillstreaks( 1 );
|
|
}
|
|
|
|
setdvar( "g_deadChat", 1 );
|
|
setdvar( "ui_allow_teamchange", 0 );
|
|
setdvar( "bg_compassShowEnemies", 0 );
|
|
freezeallplayers( 1.0, 1 );
|
|
|
|
if ( !maps\mp\_utility::wasonlyround() && !var_2 )
|
|
{
|
|
displayroundend( var_0, var_1 );
|
|
|
|
if ( isdefined( level.finalkillcam_winner ) )
|
|
{
|
|
foreach ( var_5 in level.players )
|
|
var_5 notify( "reset_outcome" );
|
|
|
|
level notify( "game_cleanup" );
|
|
waittillfinalkillcamdone();
|
|
}
|
|
|
|
if ( !maps\mp\_utility::waslastround() )
|
|
{
|
|
maps\mp\_utility::levelflagclear( "block_notifies" );
|
|
|
|
if ( checkroundswitch() )
|
|
displayroundswitch();
|
|
|
|
foreach ( var_5 in level.players )
|
|
{
|
|
var_5.pers["stats"] = var_5.stats;
|
|
var_5.pers["segments"] = var_5.segments;
|
|
}
|
|
|
|
level notify( "restarting" );
|
|
game["state"] = "playing";
|
|
setdvar( "ui_game_state", "playing" );
|
|
map_restart( 1 );
|
|
return;
|
|
}
|
|
|
|
if ( !level.forcedend )
|
|
var_1 = updateendreasontext( var_0 );
|
|
}
|
|
|
|
if ( !isdefined( game["clientMatchDataDef"] ) )
|
|
{
|
|
game["clientMatchDataDef"] = "mp/clientmatchdata.def";
|
|
setclientmatchdatadef( game["clientMatchDataDef"] );
|
|
}
|
|
|
|
maps\mp\gametypes\_missions::roundend( var_0 );
|
|
var_0 = getgamewinner( var_0, 1 );
|
|
|
|
if ( level.teambased )
|
|
{
|
|
setomnvar( "ui_game_victor", 0 );
|
|
|
|
if ( var_0 == "allies" )
|
|
setomnvar( "ui_game_victor", 2 );
|
|
else if ( var_0 == "axis" )
|
|
setomnvar( "ui_game_victor", 1 );
|
|
}
|
|
|
|
displaygameend( var_0, var_1 );
|
|
var_11 = gettime();
|
|
|
|
if ( isdefined( level.finalkillcam_winner ) && maps\mp\_utility::wasonlyround() )
|
|
{
|
|
foreach ( var_5 in level.players )
|
|
var_5 notify( "reset_outcome" );
|
|
|
|
level notify( "game_cleanup" );
|
|
waittillfinalkillcamdone();
|
|
}
|
|
|
|
maps\mp\_utility::levelflagclear( "block_notifies" );
|
|
level.intermission = 1;
|
|
level notify( "spawning_intermission" );
|
|
|
|
foreach ( var_5 in level.players )
|
|
{
|
|
var_5 closepopupmenu();
|
|
var_5 closeingamemenu();
|
|
var_5 notify( "reset_outcome" );
|
|
var_5 thread maps\mp\gametypes\_playerlogic::spawnintermission();
|
|
}
|
|
|
|
processlobbydata();
|
|
wait 1.0;
|
|
checkforpersonalbests();
|
|
updatecombatrecord();
|
|
|
|
if ( level.teambased )
|
|
{
|
|
if ( var_0 == "axis" || var_0 == "allies" )
|
|
setmatchdata( "victor", var_0 );
|
|
else
|
|
setmatchdata( "victor", "none" );
|
|
|
|
setmatchdata( "alliesScore", game["teamScores"]["allies"] );
|
|
setmatchdata( "axisScore", game["teamScores"]["axis"] );
|
|
_func_242( var_0 );
|
|
}
|
|
else
|
|
setmatchdata( "victor", "none" );
|
|
|
|
level maps\mp\_matchdata::endofgamesummarylogger();
|
|
|
|
foreach ( var_5 in level.players )
|
|
{
|
|
if ( var_5 maps\mp\_utility::rankingenabled() )
|
|
var_5 maps\mp\_matchdata::logfinalstats();
|
|
|
|
var_5 maps\mp\gametypes\_playerlogic::logplayerstats();
|
|
}
|
|
|
|
setmatchdata( "host", maps\mp\gametypes\_playerlogic::truncateplayername( level.hostname ) );
|
|
|
|
if ( maps\mp\_utility::matchmakinggame() )
|
|
{
|
|
setmatchdata( "playlistVersion", isdedicatedserver() );
|
|
setmatchdata( "playlistID", getplaylistversion() );
|
|
setmatchdata( "isDedicated", _func_27A() );
|
|
}
|
|
|
|
setmatchdata( "levelMaxClients", level.maxclients );
|
|
sendmatchdata();
|
|
|
|
foreach ( var_5 in level.players )
|
|
{
|
|
var_5.pers["stats"] = var_5.stats;
|
|
var_5.pers["segments"] = var_5.segments;
|
|
}
|
|
|
|
tournamentreportwinningteam();
|
|
var_20 = 0;
|
|
|
|
if ( maps\mp\_utility::practiceroundgame() )
|
|
var_20 = 5.0;
|
|
|
|
if ( isdefined( level.endgamewaitfunc ) )
|
|
[[ level.endgamewaitfunc ]]( var_2, level.postgamenotifies, var_20, var_0 );
|
|
else if ( !var_2 && !level.postgamenotifies )
|
|
{
|
|
if ( !maps\mp\_utility::wasonlyround() )
|
|
wait(6.0 + var_20);
|
|
else
|
|
wait(min( 10.0, 4.0 + var_20 + level.postgamenotifies ));
|
|
}
|
|
else
|
|
wait(min( 10.0, 4.0 + var_20 + level.postgamenotifies ));
|
|
|
|
var_21 = "_gamelogic.gsc";
|
|
var_22 = "all";
|
|
|
|
if ( level.teambased && isdefined( var_0 ) )
|
|
var_22 = var_0;
|
|
|
|
var_23 = "undefined";
|
|
|
|
if ( isdefined( var_1 ) )
|
|
{
|
|
switch ( var_1 )
|
|
{
|
|
case 1:
|
|
var_23 = "MP_SCORE_LIMIT_REACHED";
|
|
break;
|
|
case 2:
|
|
var_23 = "MP_TIME_LIMIT_REACHED";
|
|
break;
|
|
case 3:
|
|
var_23 = "MP_PLAYERS_FORFEITED";
|
|
break;
|
|
case 4:
|
|
var_23 = "MP_TARGET_DESTROYED";
|
|
break;
|
|
case 5:
|
|
var_23 = "MP_BOMB_DEFUSED";
|
|
break;
|
|
case 6:
|
|
var_23 = "MP_GHOSTS_ELIMINATED";
|
|
break;
|
|
case 7:
|
|
var_23 = "MP_FEDERATION_ELIMINATED";
|
|
break;
|
|
case 8:
|
|
var_23 = "MP_GHOSTS_FORFEITED";
|
|
break;
|
|
case 9:
|
|
var_23 = "MP_FEDERATION_FORFEITED";
|
|
break;
|
|
case 10:
|
|
var_23 = "MP_ENEMIES_ELIMINATED";
|
|
break;
|
|
case 11:
|
|
var_23 = "MP_MATCH_TIE";
|
|
break;
|
|
case 12:
|
|
var_23 = "GAME_OBJECTIVECOMPLETED";
|
|
break;
|
|
case 13:
|
|
var_23 = "GAME_OBJECTIVEFAILED";
|
|
break;
|
|
case 14:
|
|
var_23 = "MP_SWITCHING_SIDES";
|
|
break;
|
|
case 15:
|
|
var_23 = "MP_ROUND_LIMIT_REACHED";
|
|
break;
|
|
case 16:
|
|
var_23 = "MP_ENDED_GAME";
|
|
break;
|
|
case 17:
|
|
var_23 = "MP_HOST_ENDED_GAME";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !isdefined( var_11 ) )
|
|
var_11 = -1;
|
|
|
|
var_24 = 15;
|
|
var_25 = var_24;
|
|
var_26 = getmatchdata( "playerCount" );
|
|
var_27 = getmatchdata( "lifeCount" );
|
|
|
|
if ( !isdefined( level.matchdata ) )
|
|
{
|
|
var_28 = 0;
|
|
var_29 = 0;
|
|
var_30 = 0;
|
|
var_31 = 0;
|
|
var_32 = 0;
|
|
var_33 = 0;
|
|
var_34 = 0;
|
|
}
|
|
else
|
|
{
|
|
if ( isdefined( level.matchdata["botJoinCount"] ) )
|
|
var_28 = level.matchdata["botJoinCount"];
|
|
else
|
|
var_28 = 0;
|
|
|
|
if ( isdefined( level.matchdata["deathCount"] ) )
|
|
var_29 = level.matchdata["deathCount"];
|
|
else
|
|
var_29 = 0;
|
|
|
|
if ( isdefined( level.matchdata["badSpawnDiedTooFastCount"] ) )
|
|
var_30 = level.matchdata["badSpawnDiedTooFastCount"];
|
|
else
|
|
var_30 = 0;
|
|
|
|
if ( isdefined( level.matchdata["badSpawnKilledTooFastCount"] ) )
|
|
var_31 = level.matchdata["badSpawnKilledTooFastCount"];
|
|
else
|
|
var_31 = 0;
|
|
|
|
if ( isdefined( level.matchdata["badSpawnDmgDealtCount"] ) )
|
|
var_32 = level.matchdata["badSpawnDmgDealtCount"];
|
|
else
|
|
var_32 = 0;
|
|
|
|
if ( isdefined( level.matchdata["badSpawnDmgReceivedCount"] ) )
|
|
var_33 = level.matchdata["badSpawnDmgReceivedCount"];
|
|
else
|
|
var_33 = 0;
|
|
|
|
if ( isdefined( level.matchdata["badSpawnByAnyMeansCount"] ) )
|
|
var_34 = level.matchdata["badSpawnByAnyMeansCount"];
|
|
else
|
|
var_34 = 0;
|
|
}
|
|
|
|
var_35 = 0;
|
|
|
|
if ( isdefined( level.spawnsighttracesused_pres1tu ) )
|
|
var_35 += 1;
|
|
|
|
if ( isdefined( level.spawnsighttracesused_posts1tu ) )
|
|
var_35 += 2;
|
|
|
|
reconevent( "script_mp_match_end: script_file %s, gameTime %d, match_winner %s, win_reason %s, version %d, joinCount %d, botJoinCount %d, spawnCount %d, deathCount %d, badSpawnDiedTooFastCount %d, badSpawnKilledTooFastCount %d, badSpawnDmgDealtCount %d, badSpawnDmgReceivedCount %d, badSpawnByAnyMeansCount %d, sightTraceMethodsUsed %d", var_21, var_11, var_22, var_23, var_25, var_26, var_28, var_27, var_29, var_30, var_31, var_32, var_33, var_34, var_35 );
|
|
|
|
if ( isdefined( level.ishorde ) && level.ishorde )
|
|
{
|
|
if ( isdefined( level.zombiescompleted ) && level.zombiescompleted )
|
|
setdvar( "cg_drawCrosshair", 1 );
|
|
}
|
|
|
|
level notify( "exitLevel_called" );
|
|
exitlevel( 0 );
|
|
}
|
|
|
|
getgamewinner( var_0, var_1 )
|
|
{
|
|
if ( !isstring( var_0 ) )
|
|
return var_0;
|
|
|
|
var_2 = var_0;
|
|
|
|
if ( level.teambased && ( maps\mp\_utility::isroundbased() || level.gametype == "ctf" ) && level.gameended )
|
|
{
|
|
var_3 = "roundsWon";
|
|
|
|
if ( isdefined( level.winbycaptures ) && level.winbycaptures )
|
|
var_3 = "teamScores";
|
|
|
|
if ( game[var_3]["allies"] == game[var_3]["axis"] )
|
|
var_2 = "tie";
|
|
else if ( game[var_3]["axis"] > game[var_3]["allies"] )
|
|
var_2 = "axis";
|
|
else
|
|
var_2 = "allies";
|
|
}
|
|
|
|
if ( var_1 && ( var_2 == "allies" || var_2 == "axis" ) )
|
|
level.finalkillcam_winner = var_2;
|
|
|
|
return var_2;
|
|
}
|
|
|
|
updateendreasontext( var_0 )
|
|
{
|
|
if ( !level.teambased )
|
|
return 1;
|
|
|
|
if ( maps\mp\_utility::hitroundlimit() )
|
|
return game["end_reason"]["round_limit_reached"];
|
|
|
|
if ( maps\mp\_utility::hitwinlimit() )
|
|
return game["end_reason"]["score_limit_reached"];
|
|
|
|
return game["end_reason"]["objective_completed"];
|
|
}
|
|
|
|
estimatedtimetillscorelimit( var_0 )
|
|
{
|
|
var_1 = getscoreperminute( var_0 );
|
|
var_2 = getscoreremaining( var_0 );
|
|
var_3 = 999999;
|
|
|
|
if ( var_1 )
|
|
var_3 = var_2 / var_1;
|
|
|
|
return var_3;
|
|
}
|
|
|
|
getscoreperminute( var_0 )
|
|
{
|
|
var_1 = maps\mp\_utility::getwatcheddvar( "scorelimit" );
|
|
var_2 = maps\mp\_utility::gettimelimit();
|
|
var_3 = maps\mp\_utility::gettimepassed() / 60000 + 0.0001;
|
|
|
|
if ( isplayer( self ) )
|
|
var_4 = self.score / var_3;
|
|
else
|
|
var_4 = setclientnamemode( var_0 ) / var_3;
|
|
|
|
return var_4;
|
|
}
|
|
|
|
getscoreremaining( var_0 )
|
|
{
|
|
var_1 = maps\mp\_utility::getwatcheddvar( "scorelimit" );
|
|
|
|
if ( isplayer( self ) )
|
|
var_2 = var_1 - self.score;
|
|
else
|
|
var_2 = var_1 - setclientnamemode( var_0 );
|
|
|
|
return var_2;
|
|
}
|
|
|
|
givelastonteamwarning()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "disconnect" );
|
|
level endon( "game_ended" );
|
|
maps\mp\_utility::waittillrecoveredhealth( 3 );
|
|
thread maps\mp\_utility::teamplayercardsplash( "callout_lastteammemberalive", self, self.pers["team"] );
|
|
|
|
if ( level.multiteambased )
|
|
{
|
|
foreach ( var_1 in level.teamnamelist )
|
|
{
|
|
if ( self.pers["team"] != var_1 )
|
|
thread maps\mp\_utility::teamplayercardsplash( "callout_lastenemyalive", self, var_1 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var_3 = maps\mp\_utility::getotherteam( self.pers["team"] );
|
|
thread maps\mp\_utility::teamplayercardsplash( "callout_lastenemyalive", self, var_3 );
|
|
}
|
|
|
|
level notify( "last_alive", self );
|
|
}
|
|
|
|
processlobbydata()
|
|
{
|
|
var_0 = 0;
|
|
|
|
foreach ( var_2 in level.players )
|
|
{
|
|
if ( !isdefined( var_2 ) )
|
|
continue;
|
|
|
|
var_2.clientmatchdataid = var_0;
|
|
var_0++;
|
|
|
|
if ( isdefined( level.iszombiegame ) && level.iszombiegame )
|
|
var_2.clientmatchdataid = var_2 getentitynumber();
|
|
|
|
setclientmatchdata( "players", var_2.clientmatchdataid, "name", maps\mp\gametypes\_playerlogic::truncateplayername( var_2.name ) );
|
|
setclientmatchdata( "players", var_2.clientmatchdataid, "xuid", var_2.xuid );
|
|
}
|
|
|
|
maps\mp\_awards::assignawards();
|
|
maps\mp\_scoreboard::processlobbyscoreboards();
|
|
sendclientmatchdata();
|
|
_func_23E();
|
|
}
|
|
|
|
trackleaderboarddeathstats( var_0, var_1 )
|
|
{
|
|
thread threadedsetweaponstatbyname( var_0, 1, "deaths" );
|
|
}
|
|
|
|
trackattackerleaderboarddeathstats( var_0, var_1, var_2 )
|
|
{
|
|
if ( isdefined( self ) && isplayer( self ) )
|
|
{
|
|
if ( var_1 != "MOD_FALLING" )
|
|
{
|
|
if ( maps\mp\_utility::ismeleemod( var_1 ) && issubstr( var_0, "tactical" ) )
|
|
return;
|
|
|
|
if ( maps\mp\_utility::ismeleemod( var_1 ) && !issubstr( var_0, "riotshield" ) && !issubstr( var_0, "combatknife" ) )
|
|
return;
|
|
|
|
thread threadedsetweaponstatbyname( var_0, 1, "kills" );
|
|
var_3 = 0;
|
|
|
|
if ( isdefined( var_2 ) && isdefined( var_2.firedads ) )
|
|
var_3 = var_2.firedads;
|
|
else
|
|
var_3 = self playerads();
|
|
|
|
if ( var_3 < 0.2 )
|
|
thread threadedsetweaponstatbyname( var_0, 1, "hipfirekills" );
|
|
}
|
|
|
|
if ( var_1 == "MOD_HEAD_SHOT" )
|
|
thread threadedsetweaponstatbyname( var_0, 1, "headShots" );
|
|
}
|
|
}
|
|
|
|
setweaponstat( var_0, var_1, var_2 )
|
|
{
|
|
if ( !var_1 )
|
|
return;
|
|
|
|
var_3 = maps\mp\_utility::getweaponclass( var_0 );
|
|
|
|
if ( var_3 == "killstreak" || var_3 == "other" )
|
|
return;
|
|
|
|
if ( maps\mp\_utility::isenvironmentweapon( var_0 ) )
|
|
return;
|
|
|
|
if ( maps\mp\_utility::isbombsiteweapon( var_0 ) )
|
|
return;
|
|
|
|
if ( var_0 == maps\mp\_grappling_hook::get_grappling_hook_weapon() )
|
|
return;
|
|
|
|
if ( var_3 == "weapon_grenade" || var_3 == "weapon_explosive" )
|
|
{
|
|
var_4 = maps\mp\_utility::strip_suffix( var_0, "_lefthand" );
|
|
var_4 = maps\mp\_utility::strip_suffix( var_4, "_mp" );
|
|
maps\mp\gametypes\_persistence::incrementweaponstat( var_4, var_2, var_1 );
|
|
maps\mp\_matchdata::logweaponstat( var_4, var_2, var_1 );
|
|
return;
|
|
}
|
|
|
|
var_5 = maps\mp\gametypes\_weapons::isprimaryorsecondaryprojectileweapon( var_0 );
|
|
|
|
if ( var_2 != "timeInUse" && var_2 != "deaths" && !var_5 )
|
|
{
|
|
var_6 = var_0;
|
|
var_0 = self getcurrentweapon();
|
|
|
|
if ( var_0 != var_6 && maps\mp\_utility::iskillstreakweapon( var_0 ) )
|
|
return;
|
|
}
|
|
|
|
if ( !isdefined( self.trackingweaponname ) )
|
|
self.trackingweaponname = var_0;
|
|
|
|
if ( var_0 != self.trackingweaponname )
|
|
{
|
|
maps\mp\gametypes\_persistence::updateweaponbufferedstats();
|
|
self.trackingweaponname = var_0;
|
|
self.currentfirefightshots = 0;
|
|
}
|
|
|
|
switch ( var_2 )
|
|
{
|
|
case "shots":
|
|
self.trackingweaponshots++;
|
|
self.currentfirefightshots++;
|
|
break;
|
|
case "hits":
|
|
self.trackingweaponhits++;
|
|
break;
|
|
case "headShots":
|
|
self.trackingweaponheadshots++;
|
|
self.trackingweaponhits++;
|
|
break;
|
|
case "kills":
|
|
self.trackingweaponkills++;
|
|
break;
|
|
case "hipfirekills":
|
|
self.trackingweaponhipfirekills++;
|
|
break;
|
|
case "timeInUse":
|
|
self.trackingweaponusetime += var_1;
|
|
break;
|
|
}
|
|
|
|
if ( var_2 == "deaths" )
|
|
{
|
|
var_7 = maps\mp\_utility::getbaseweaponname( var_0 );
|
|
|
|
if ( !maps\mp\_utility::iscacprimaryweapon( var_7 ) && !maps\mp\_utility::iscacsecondaryweapon( var_7 ) )
|
|
return;
|
|
|
|
var_8 = maps\mp\_utility::getweaponattachmentsbasenames( var_0 );
|
|
maps\mp\gametypes\_persistence::incrementweaponstat( var_7, var_2, var_1 );
|
|
maps\mp\_matchdata::logweaponstat( var_7, "deaths", var_1 );
|
|
|
|
foreach ( var_10 in var_8 )
|
|
maps\mp\gametypes\_persistence::incrementattachmentstat( var_10, var_2, var_1 );
|
|
}
|
|
}
|
|
|
|
setinflictorstat( var_0, var_1, var_2 )
|
|
{
|
|
if ( !isdefined( var_1 ) )
|
|
return;
|
|
|
|
if ( !isdefined( var_0 ) )
|
|
{
|
|
var_1 setweaponstat( var_2, 1, "hits" );
|
|
return;
|
|
}
|
|
|
|
if ( !isdefined( var_0.playeraffectedarray ) )
|
|
var_0.playeraffectedarray = [];
|
|
|
|
var_3 = 1;
|
|
|
|
for ( var_4 = 0; var_4 < var_0.playeraffectedarray.size; var_4++ )
|
|
{
|
|
if ( var_0.playeraffectedarray[var_4] == self )
|
|
{
|
|
var_3 = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( var_3 )
|
|
{
|
|
var_0.playeraffectedarray[var_0.playeraffectedarray.size] = self;
|
|
var_1 setweaponstat( var_2, 1, "hits" );
|
|
}
|
|
}
|
|
|
|
threadedsetweaponstatbyname( var_0, var_1, var_2 )
|
|
{
|
|
self endon( "disconnect" );
|
|
waittillframeend;
|
|
setweaponstat( var_0, var_1, var_2 );
|
|
}
|
|
|
|
checkforpersonalbests()
|
|
{
|
|
foreach ( var_1 in level.players )
|
|
{
|
|
if ( !isdefined( var_1 ) )
|
|
continue;
|
|
|
|
if ( var_1 maps\mp\_utility::rankingenabled() )
|
|
{
|
|
var_2 = var_1 getcommonplayerdata( "round", "kills" );
|
|
var_3 = var_1 getcommonplayerdata( "round", "deaths" );
|
|
var_4 = var_1.pers["summary"]["xp"];
|
|
var_5 = var_1.score;
|
|
var_6 = getroundaccuracy( var_1 );
|
|
var_7 = var_1 getrankedplayerdata( "bestKills" );
|
|
var_8 = var_1 getrankedplayerdata( "mostDeaths" );
|
|
var_9 = var_1 getrankedplayerdata( "mostXp" );
|
|
var_10 = var_1 getrankedplayerdata( "bestScore" );
|
|
var_11 = var_1 getrankedplayerdata( "bestAccuracy" );
|
|
|
|
if ( var_2 > var_7 )
|
|
var_1 setrankedplayerdata( "bestKills", var_2 );
|
|
|
|
if ( var_4 > var_9 )
|
|
var_1 setrankedplayerdata( "mostXp", var_4 );
|
|
|
|
if ( var_3 > var_8 )
|
|
var_1 setrankedplayerdata( "mostDeaths", var_3 );
|
|
|
|
if ( var_5 > var_10 )
|
|
var_1 setrankedplayerdata( "bestScore", var_5 );
|
|
|
|
if ( var_6 > var_11 )
|
|
var_1 setrankedplayerdata( "bestAccuracy", var_6 );
|
|
|
|
var_1 checkforbestweapon();
|
|
var_1 maps\mp\_matchdata::logplayerxp( var_4, "totalXp" );
|
|
var_1 maps\mp\_matchdata::logplayerxp( var_1.pers["summary"]["score"], "scoreXp" );
|
|
var_1 maps\mp\_matchdata::logplayerxp( var_1.pers["summary"]["challenge"], "challengeXp" );
|
|
var_1 maps\mp\_matchdata::logplayerxp( var_1.pers["summary"]["match"], "matchXp" );
|
|
var_1 maps\mp\_matchdata::logplayerxp( var_1.pers["summary"]["misc"], "miscXp" );
|
|
}
|
|
|
|
if ( isdefined( var_1.pers["confirmed"] ) )
|
|
var_1 maps\mp\_matchdata::logkillsconfirmed();
|
|
|
|
if ( isdefined( var_1.pers["denied"] ) )
|
|
var_1 maps\mp\_matchdata::logkillsdenied();
|
|
}
|
|
}
|
|
|
|
getroundaccuracy( var_0 )
|
|
{
|
|
var_1 = float( var_0 getrankedplayerdata( "totalShots" ) - var_0.pers["previous_shots"] );
|
|
|
|
if ( var_1 == 0 )
|
|
return 0;
|
|
|
|
var_2 = float( var_0 getrankedplayerdata( "hits" ) - var_0.pers["previous_hits"] );
|
|
var_3 = clamp( var_2 / var_1, 0.0, 1.0 ) * 10000.0;
|
|
return int( var_3 );
|
|
}
|
|
|
|
checkforbestweapon()
|
|
{
|
|
var_0 = maps\mp\_matchdata::buildbaseweaponlist();
|
|
|
|
for ( var_1 = 0; var_1 < var_0.size; var_1++ )
|
|
{
|
|
var_2 = var_0[var_1];
|
|
var_2 = maps\mp\_utility::getbaseweaponname( var_2 );
|
|
var_3 = maps\mp\_utility::getweaponclass( var_2 );
|
|
|
|
if ( !maps\mp\_utility::iskillstreakweapon( var_2 ) && var_3 != "killstreak" && var_3 != "other" )
|
|
{
|
|
var_4 = self getrankedplayerdata( "bestWeapon", "kills" );
|
|
var_5 = 0;
|
|
|
|
if ( isdefined( self.pers["mpWeaponStats"][var_2] ) && isdefined( self.pers["mpWeaponStats"][var_2]["kills"] ) )
|
|
{
|
|
var_5 = self.pers["mpWeaponStats"][var_2]["kills"];
|
|
|
|
if ( var_5 > var_4 )
|
|
{
|
|
self setrankedplayerdata( "bestWeapon", "kills", var_5 );
|
|
var_6 = 0;
|
|
|
|
if ( isdefined( self.pers["mpWeaponStats"][var_2]["shots"] ) )
|
|
var_6 = self.pers["mpWeaponStats"][var_2]["shots"];
|
|
|
|
var_7 = 0;
|
|
|
|
if ( isdefined( self.pers["mpWeaponStats"][var_2]["headShots"] ) )
|
|
var_7 = self.pers["mpWeaponStats"][var_2]["headShots"];
|
|
|
|
var_8 = 0;
|
|
|
|
if ( isdefined( self.pers["mpWeaponStats"][var_2]["hits"] ) )
|
|
var_8 = self.pers["mpWeaponStats"][var_2]["hits"];
|
|
|
|
var_9 = 0;
|
|
|
|
if ( isdefined( self.pers["mpWeaponStats"][var_2]["deaths"] ) )
|
|
var_9 = self.pers["mpWeaponStats"][var_2]["deaths"];
|
|
|
|
self setrankedplayerdata( "bestWeapon", "shots", var_6 );
|
|
self setrankedplayerdata( "bestWeapon", "headShots", var_7 );
|
|
self setrankedplayerdata( "bestWeapon", "hits", var_8 );
|
|
self setrankedplayerdata( "bestWeapon", "deaths", var_9 );
|
|
var_10 = int( tablelookup( "mp/statstable.csv", 4, var_2, 0 ) );
|
|
self setrankedplayerdata( "bestWeaponIndex", var_10 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
updatecombatrecordforplayertrends()
|
|
{
|
|
var_0 = 5;
|
|
var_1 = self getrankedplayerdata( "combatRecord", "numTrends" );
|
|
var_1++;
|
|
|
|
if ( var_1 > var_0 )
|
|
{
|
|
var_1 = var_0;
|
|
|
|
if ( var_0 > 1 )
|
|
{
|
|
for ( var_2 = 0; var_2 < var_0 - 1; var_2++ )
|
|
{
|
|
var_3 = self getrankedplayerdata( "combatRecord", "trend", var_2 + 1, "timestamp" );
|
|
var_4 = self getrankedplayerdata( "combatRecord", "trend", var_2 + 1, "kills" );
|
|
var_5 = self getrankedplayerdata( "combatRecord", "trend", var_2 + 1, "deaths" );
|
|
self setrankedplayerdata( "combatRecord", "trend", var_2, "timestamp", var_3 );
|
|
self setrankedplayerdata( "combatRecord", "trend", var_2, "kills", var_4 );
|
|
self setrankedplayerdata( "combatRecord", "trend", var_2, "deaths", var_5 );
|
|
}
|
|
}
|
|
}
|
|
|
|
var_3 = maps\mp\_utility::gettimeutc_for_stat_recording();
|
|
var_4 = self.kills;
|
|
var_5 = self.deaths;
|
|
self setrankedplayerdata( "combatRecord", "trend", var_1 - 1, "timestamp", var_3 );
|
|
self setrankedplayerdata( "combatRecord", "trend", var_1 - 1, "kills", var_4 );
|
|
self setrankedplayerdata( "combatRecord", "trend", var_1 - 1, "deaths", var_5 );
|
|
self setrankedplayerdata( "combatRecord", "numTrends", var_1 );
|
|
}
|
|
|
|
updatecombatrecordcommondata()
|
|
{
|
|
var_0 = maps\mp\_utility::gettimeutc_for_stat_recording();
|
|
setcombatrecordstat( "timeStampLastGame", var_0 );
|
|
incrementcombatrecordstat( "numMatches", 1 );
|
|
incrementcombatrecordstat( "timePlayed", self.timeplayed["total"] );
|
|
incrementcombatrecordstat( "kills", self.kills );
|
|
incrementcombatrecordstat( "deaths", self.deaths );
|
|
incrementcombatrecordstat( "xpEarned", self.pers["summary"]["xp"] );
|
|
|
|
if ( isdefined( self.combatrecordwin ) )
|
|
incrementcombatrecordstat( "wins", 1 );
|
|
|
|
if ( isdefined( self.combatrecordtie ) )
|
|
incrementcombatrecordstat( "ties", 1 );
|
|
|
|
var_1 = self getrankedplayerdata( "combatRecord", level.gametype, "timeStampFirstGame" );
|
|
|
|
if ( var_1 == 0 )
|
|
setcombatrecordstat( "timeStampFirstGame", var_0 );
|
|
}
|
|
|
|
incrementcombatrecordstat( var_0, var_1 )
|
|
{
|
|
var_2 = self getrankedplayerdata( "combatRecord", level.gametype, var_0 );
|
|
var_2 += var_1;
|
|
self setrankedplayerdata( "combatRecord", level.gametype, var_0, var_2 );
|
|
}
|
|
|
|
setcombatrecordstat( var_0, var_1 )
|
|
{
|
|
self setrankedplayerdata( "combatRecord", level.gametype, var_0, var_1 );
|
|
}
|
|
|
|
setcombatrecordstatifgreater( var_0, var_1 )
|
|
{
|
|
var_2 = self getrankedplayerdata( "combatRecord", level.gametype, var_0 );
|
|
|
|
if ( var_1 > var_2 )
|
|
setcombatrecordstat( var_0, var_1 );
|
|
}
|
|
|
|
updatecombatrecordforplayergamemodes()
|
|
{
|
|
if ( level.gametype == "war" || level.gametype == "dm" )
|
|
{
|
|
updatecombatrecordcommondata();
|
|
var_0 = self.deaths;
|
|
|
|
if ( var_0 == 0 )
|
|
var_0 = 1;
|
|
|
|
var_1 = int( self.kills / var_0 ) * 1000;
|
|
setcombatrecordstatifgreater( "mostkills", self.kills );
|
|
setcombatrecordstatifgreater( "bestkdr", var_1 );
|
|
}
|
|
else if ( level.gametype == "ctf" )
|
|
{
|
|
updatecombatrecordcommondata();
|
|
var_2 = maps\mp\_utility::getpersstat( "captures" );
|
|
var_3 = maps\mp\_utility::getpersstat( "returns" );
|
|
incrementcombatrecordstat( "captures", var_2 );
|
|
incrementcombatrecordstat( "returns", var_3 );
|
|
setcombatrecordstatifgreater( "mostcaptures", var_2 );
|
|
setcombatrecordstatifgreater( "mostreturns", var_3 );
|
|
}
|
|
else if ( level.gametype == "dom" )
|
|
{
|
|
updatecombatrecordcommondata();
|
|
var_2 = maps\mp\_utility::getpersstat( "captures" );
|
|
var_4 = maps\mp\_utility::getpersstat( "defends" );
|
|
incrementcombatrecordstat( "captures", var_2 );
|
|
incrementcombatrecordstat( "defends", var_4 );
|
|
setcombatrecordstatifgreater( "mostcaptures", var_2 );
|
|
setcombatrecordstatifgreater( "mostdefends", var_4 );
|
|
}
|
|
else if ( level.gametype == "conf" )
|
|
{
|
|
updatecombatrecordcommondata();
|
|
var_5 = maps\mp\_utility::getpersstat( "confirmed" );
|
|
var_6 = maps\mp\_utility::getpersstat( "denied" );
|
|
incrementcombatrecordstat( "confirms", var_5 );
|
|
incrementcombatrecordstat( "denies", var_6 );
|
|
setcombatrecordstatifgreater( "mostconfirms", var_5 );
|
|
setcombatrecordstatifgreater( "mostdenies", var_6 );
|
|
}
|
|
else if ( level.gametype == "sd" )
|
|
{
|
|
updatecombatrecordcommondata();
|
|
var_7 = maps\mp\_utility::getpersstat( "plants" );
|
|
var_8 = maps\mp\_utility::getpersstat( "defuses" );
|
|
var_9 = maps\mp\_utility::getpersstat( "destructions" );
|
|
incrementcombatrecordstat( "plants", var_7 );
|
|
incrementcombatrecordstat( "defuses", var_8 );
|
|
incrementcombatrecordstat( "detonates", var_9 );
|
|
setcombatrecordstatifgreater( "mostplants", var_7 );
|
|
setcombatrecordstatifgreater( "mostdefuses", var_8 );
|
|
setcombatrecordstatifgreater( "mostdetonates", var_9 );
|
|
}
|
|
else if ( level.gametype == "hp" )
|
|
{
|
|
updatecombatrecordcommondata();
|
|
var_2 = maps\mp\_utility::getpersstat( "captures" );
|
|
var_4 = maps\mp\_utility::getpersstat( "defends" );
|
|
incrementcombatrecordstat( "captures", var_2 );
|
|
incrementcombatrecordstat( "defends", var_4 );
|
|
setcombatrecordstatifgreater( "mostcaptures", var_2 );
|
|
setcombatrecordstatifgreater( "mostdefends", var_4 );
|
|
}
|
|
else if ( level.gametype == "sr" )
|
|
{
|
|
updatecombatrecordcommondata();
|
|
var_7 = maps\mp\_utility::getpersstat( "plants" );
|
|
var_8 = maps\mp\_utility::getpersstat( "defuses" );
|
|
var_9 = maps\mp\_utility::getpersstat( "destructions" );
|
|
var_5 = maps\mp\_utility::getpersstat( "confirmed" );
|
|
var_6 = maps\mp\_utility::getpersstat( "denied" );
|
|
incrementcombatrecordstat( "plants", var_7 );
|
|
incrementcombatrecordstat( "defuses", var_8 );
|
|
incrementcombatrecordstat( "detonates", var_9 );
|
|
incrementcombatrecordstat( "confirms", var_5 );
|
|
incrementcombatrecordstat( "denies", var_6 );
|
|
setcombatrecordstatifgreater( "mostplants", var_7 );
|
|
setcombatrecordstatifgreater( "mostdefuses", var_8 );
|
|
setcombatrecordstatifgreater( "mostdetonates", var_9 );
|
|
setcombatrecordstatifgreater( "mostconfirms", var_5 );
|
|
setcombatrecordstatifgreater( "mostdenies", var_6 );
|
|
}
|
|
else if ( level.gametype == "infect" )
|
|
{
|
|
updatecombatrecordcommondata();
|
|
var_10 = maps\mp\_utility::getplayerstat( "contagious" );
|
|
var_11 = self.kills - var_10;
|
|
incrementcombatrecordstat( "infectedKills", var_11 );
|
|
incrementcombatrecordstat( "survivorKills", var_10 );
|
|
setcombatrecordstatifgreater( "mostInfectedKills", var_11 );
|
|
setcombatrecordstatifgreater( "mostSurvivorKills", var_10 );
|
|
}
|
|
else if ( level.gametype == "gun" )
|
|
{
|
|
updatecombatrecordcommondata();
|
|
var_12 = maps\mp\_utility::getplayerstat( "levelup" );
|
|
var_13 = maps\mp\_utility::getplayerstat( "humiliation" );
|
|
incrementcombatrecordstat( "gunPromotions", var_12 );
|
|
incrementcombatrecordstat( "stabs", var_13 );
|
|
setcombatrecordstatifgreater( "mostGunPromotions", var_12 );
|
|
setcombatrecordstatifgreater( "mostStabs", var_13 );
|
|
}
|
|
else if ( level.gametype == "ball" )
|
|
{
|
|
updatecombatrecordcommondata();
|
|
var_14 = maps\mp\_utility::getplayerstat( "fieldgoal" ) + maps\mp\_utility::getplayerstat( "touchdown" ) * 2;
|
|
var_15 = maps\mp\_utility::getplayerstat( "killedBallCarrier" );
|
|
incrementcombatrecordstat( "pointsScored", var_14 );
|
|
incrementcombatrecordstat( "killedBallCarrier", var_15 );
|
|
setcombatrecordstatifgreater( "mostPointsScored", var_14 );
|
|
setcombatrecordstatifgreater( "mostKilledBallCarrier", var_15 );
|
|
}
|
|
else if ( level.gametype == "twar" )
|
|
{
|
|
updatecombatrecordcommondata();
|
|
var_2 = maps\mp\_utility::getpersstat( "captures" );
|
|
var_16 = maps\mp\_utility::getplayerstat( "kill_while_capture" );
|
|
incrementcombatrecordstat( "captures", var_2 );
|
|
incrementcombatrecordstat( "killWhileCaptures", var_16 );
|
|
setcombatrecordstatifgreater( "mostCaptures", var_2 );
|
|
setcombatrecordstatifgreater( "mostKillWhileCaptures", var_16 );
|
|
}
|
|
}
|
|
|
|
updatecombatrecordforplayer()
|
|
{
|
|
updatecombatrecordforplayertrends();
|
|
updatecombatrecordforplayergamemodes();
|
|
}
|
|
|
|
updatecombatrecord()
|
|
{
|
|
foreach ( var_1 in level.players )
|
|
{
|
|
if ( !isdefined( var_1 ) )
|
|
continue;
|
|
|
|
if ( var_1 maps\mp\_utility::rankingenabled() )
|
|
var_1 updatecombatrecordforplayer();
|
|
|
|
level maps\mp\gametypes\_playerlogic::writesegmentdata( var_1 );
|
|
|
|
if ( maps\mp\_utility::practiceroundgame() )
|
|
level maps\mp\gametypes\_playerlogic::checkpracticeroundlockout( var_1 );
|
|
}
|
|
}
|