mirror of
https://github.com/InfinityLoader/IL-GSC.git
synced 2025-06-07 17:17:50 -05:00
877 lines
26 KiB
Plaintext
877 lines
26 KiB
Plaintext
#include maps\_utility;
|
||
#include common_scripts\utility;
|
||
#include maps\_music;
|
||
init()
|
||
{
|
||
level.splitscreen = isSplitScreen();
|
||
level.xenon = ( GetDvar( #"xenonGame" ) == "true" );
|
||
level.ps3 = ( GetDvar( #"ps3Game" ) == "true" );
|
||
level.wii = ( GetDvar( #"wiiGame" ) == "true" );
|
||
level.onlineGame = GetDvarInt( #"onlinegame" );
|
||
level.systemLink = GetDvarInt( #"systemlink" );
|
||
level.console = ( level.xenon || level.ps3 || level.wii );
|
||
PrecacheMenu( "briefing" );
|
||
level.rankedMatch = ( level.onlineGame
|
||
);
|
||
level.profileLoggedIn = ( GetDvar( #"xblive_loggedin" ) == "1" );
|
||
}
|
||
SetupCallbacks()
|
||
{
|
||
level.otherPlayersSpectate = false;
|
||
level.spawnPlayer = ::spawnPlayer;
|
||
level.spawnClient = ::spawnClient;
|
||
level.spawnSpectator = ::spawnSpectator;
|
||
level.spawnIntermission = ::spawnIntermission;
|
||
level.onSpawnPlayer = ::default_onSpawnPlayer;
|
||
level.onPostSpawnPlayer = ::default_onPostSpawnPlayer;
|
||
level.onSpawnSpectator = ::default_onSpawnSpectator;
|
||
level.onSpawnIntermission = ::default_onSpawnIntermission;
|
||
level.onStartGameType = ::blank;
|
||
level.onPlayerConnect = ::blank;
|
||
level.onPlayerDisconnect = ::blank;
|
||
level.onPlayerDamage = ::blank;
|
||
level.onPlayerKilled = ::blank;
|
||
level.onPlayerWeaponSwap = ::blank;
|
||
level._callbacks["on_first_player_connect"] = [];
|
||
level._callbacks["on_player_connect"] = [];
|
||
level._callbacks["on_player_disconnect"] = [];
|
||
level._callbacks["on_player_damage"] = [];
|
||
level._callbacks["on_player_last_stand"] = [];
|
||
level._callbacks["on_player_killed"] = [];
|
||
level._callbacks["on_actor_damage"] = [];
|
||
level._callbacks["on_actor_killed"] = [];
|
||
level._callbacks["on_vehicle_damage"] = [];
|
||
level._callbacks["on_save_restored"] = [];
|
||
if (!IsDefined(level.onMenuMessage))
|
||
level.onMenuMessage = ::blank;
|
||
if (!IsDefined(level.onDec20Message))
|
||
level.onDec20Message = ::blank;
|
||
}
|
||
AddCallback(event, func)
|
||
{
|
||
AssertEx(IsDefined(event), "Trying to set a callback on an undefined event.");
|
||
AssertEx(IsDefined(level._callbacks[event]), "Trying to set callback for unknown event '" + event + "'.");
|
||
level._callbacks[event] = add_to_array(level._callbacks[event], func, false);
|
||
}
|
||
RemoveCallback(event, func)
|
||
{
|
||
AssertEx(IsDefined(event), "Trying to remove a callback on an undefined event.");
|
||
AssertEx(IsDefined(level._callbacks[event]), "Trying to remove callback for unknown event '" + event + "'.");
|
||
level._callbacks[event] = array_remove( level._callbacks[event], func, true );
|
||
}
|
||
Callback(event)
|
||
{
|
||
AssertEx(IsDefined(level._callbacks[event]), "Must init callback array before trying to call it.");
|
||
for (i = 0; i < level._callbacks[event].size; i++)
|
||
{
|
||
callback = level._callbacks[event][i];
|
||
if (IsDefined(callback))
|
||
{
|
||
self thread [[callback]]();
|
||
}
|
||
}
|
||
}
|
||
blank( arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10 )
|
||
{
|
||
}
|
||
Callback_CurveNotify( string, curveId, nodeIndex )
|
||
{
|
||
level notify( string, curveId, nodeIndex );
|
||
}
|
||
Callback_StartGameType()
|
||
{
|
||
}
|
||
BriefInvulnerability()
|
||
{
|
||
self endon( "disconnect" );
|
||
self EnableInvulnerability();
|
||
wait (3);
|
||
if(IsDefined(self))
|
||
{
|
||
if(IsDefined(self.invulnerable) && (self.invulnerable == true))
|
||
{
|
||
}
|
||
else
|
||
{
|
||
self DisableInvulnerability();
|
||
}
|
||
}
|
||
}
|
||
Callback_SaveRestored()
|
||
{
|
||
players = get_players();
|
||
level.debug_player = players[0];
|
||
num = 0;
|
||
if( isdefined( level._save_pos ) )
|
||
{
|
||
num = level._save_trig_ent;
|
||
}
|
||
for( i = 0; i < 4; i++ )
|
||
{
|
||
player = players[i];
|
||
if( isDefined( player ) )
|
||
{
|
||
player thread BriefInvulnerability();
|
||
if( isdefined( player.savedVisionSet ) )
|
||
{
|
||
player VisionSetNaked( player.savedVisionSet, 0.1 );
|
||
}
|
||
if( GetDvar( #"zombiemode") != "1" )
|
||
{
|
||
dvarName = "player" + player GetEntityNumber() + "downs";
|
||
player.downs = getdvarint( dvarName );
|
||
}
|
||
}
|
||
}
|
||
level Callback("on_save_restored");
|
||
}
|
||
Player_BreadCrumb_Reset( position, angles )
|
||
{
|
||
if( !isdefined( angles ) )
|
||
{
|
||
angles = ( 0, 0, 0 );
|
||
}
|
||
level.playerPrevOrigin0 = position;
|
||
level.playerPrevOrigin1 = position;
|
||
if( !isdefined( level._player_breadcrumbs ) )
|
||
{
|
||
level._player_breadcrumbs = [];
|
||
for( i = 0; i < 4; i ++ )
|
||
{
|
||
level._player_breadcrumbs[i] = [];
|
||
for( j = 0; j < 4; j ++ )
|
||
{
|
||
level._player_breadcrumbs[i][j] = spawnstruct();
|
||
}
|
||
}
|
||
}
|
||
for( i = 0; i < 4; i ++ )
|
||
{
|
||
for( j = 0; j < 4; j ++ )
|
||
{
|
||
level._player_breadcrumbs[i][j].pos = position;
|
||
level._player_breadcrumbs[i][j].ang = angles;
|
||
}
|
||
}
|
||
}
|
||
Player_BreadCrumb_Update()
|
||
{
|
||
self endon( "disconnect" );
|
||
drop_distance = 70;
|
||
right = anglestoright( self.angles ) * drop_distance;
|
||
level.playerPrevOrigin0 = self.origin + right;
|
||
level.playerPrevOrigin1 = self.origin - right;
|
||
if( !isdefined( level._player_breadcrumbs ) )
|
||
{
|
||
Player_BreadCrumb_Reset( self.origin, self.angles );
|
||
}
|
||
num = self GetEntityNumber();
|
||
while( 1 )
|
||
{
|
||
wait 1;
|
||
dist_squared = distancesquared( self.origin, level.playerPrevOrigin0 );
|
||
if( dist_squared > 500*500 )
|
||
{
|
||
right = anglestoright( self.angles ) * drop_distance;
|
||
level.playerPrevOrigin0 = self.origin + right;
|
||
level.playerPrevOrigin1 = self.origin - right;
|
||
}
|
||
else if( dist_squared > drop_distance*drop_distance )
|
||
{
|
||
level.playerPrevOrigin1 = level.playerPrevOrigin0;
|
||
level.playerPrevOrigin0 = self.origin;
|
||
}
|
||
dist_squared = distancesquared( self.origin, level._player_breadcrumbs[num][0].pos );
|
||
dropBreadcrumbs = true;
|
||
if(IsDefined( level.flag ) && IsDefined( level.flag["drop_breadcrumbs"]))
|
||
{
|
||
if(!flag("drop_breadcrumbs"))
|
||
{
|
||
dropBreadcrumbs = false;
|
||
}
|
||
}
|
||
if( dropBreadcrumbs && (dist_squared > drop_distance * drop_distance) )
|
||
{
|
||
for( i = 2; i >= 0; i -- )
|
||
{
|
||
level._player_breadcrumbs[num][i + 1].pos = level._player_breadcrumbs[num][i].pos;
|
||
level._player_breadcrumbs[num][i + 1].ang = level._player_breadcrumbs[num][i].ang;
|
||
}
|
||
level._player_breadcrumbs[num][0].pos = PlayerPhysicsTrace(self.origin, self.origin + ( 0, 0, -1000 ));
|
||
level._player_breadcrumbs[num][0].ang = self.angles;
|
||
}
|
||
}
|
||
}
|
||
SetPlayerSpawnPos()
|
||
{
|
||
players = get_players();
|
||
player = players[0];
|
||
if( !isdefined( level._player_breadcrumbs ) )
|
||
{
|
||
spawnpoints = getentarray( "info_player_deathmatch", "classname" );
|
||
if( player.origin == ( 0, 0, 0 ) && isdefined( spawnpoints ) && spawnpoints.size > 0 )
|
||
{
|
||
Player_BreadCrumb_Reset( spawnpoints[0].origin, spawnpoints[0].angles );
|
||
}
|
||
else
|
||
{
|
||
Player_BreadCrumb_Reset( player.origin, player.angles );
|
||
}
|
||
}
|
||
too_close = 30;
|
||
spawn_pos = level._player_breadcrumbs[0][0].pos;
|
||
dist_squared = distancesquared( player.origin, spawn_pos );
|
||
if( dist_squared > 500*500 )
|
||
{
|
||
if( player.origin != ( 0, 0, 0 ) )
|
||
{
|
||
spawn_pos = player.origin +( 0, 30, 0 );
|
||
}
|
||
}
|
||
else if( dist_squared < too_close*too_close )
|
||
{
|
||
spawn_pos = level._player_breadcrumbs[0][1].pos;
|
||
}
|
||
spawn_angles = vectornormalize( player.origin - spawn_pos );
|
||
spawn_angles = vectorToAngles( spawn_angles );
|
||
if( !playerpositionvalid( spawn_pos ) )
|
||
{
|
||
spawn_pos = player.origin;
|
||
spawn_angles = player.angles;
|
||
}
|
||
}
|
||
Callback_PlayerConnect()
|
||
{
|
||
thread first_player_connect();
|
||
self waittill( "begin" );
|
||
self reset_clientdvars();
|
||
waittillframeend;
|
||
wait(0.1);
|
||
level notify( "connected", self );
|
||
self Callback("on_player_connect");
|
||
self thread maps\_load_common::player_special_death_hint();
|
||
self thread maps\_flashgrenades::monitorFlash();
|
||
if( GetDvar( #"zombiemode" ) == "0" )
|
||
{
|
||
info_player_spawn = getentarray( "info_player_deathmatch", "classname" );
|
||
if( isdefined( info_player_spawn ) && info_player_spawn.size > 0 )
|
||
{
|
||
players = get_players("all");
|
||
if( Isdefined( players ) &&( players.size != 0 ) )
|
||
{
|
||
if( players[0] == self )
|
||
{
|
||
println( "2: Setting player origin to info_player_start " + info_player_spawn[0].origin );
|
||
self setOrigin( info_player_spawn[0].origin );
|
||
self setPlayerAngles( info_player_spawn[0].angles );
|
||
self thread Player_BreadCrumb_Update();
|
||
}
|
||
else
|
||
{
|
||
println( "Callback_PlayerConnect: Setting player origin near host position " + players[0].origin );
|
||
self SetPlayerSpawnPos();
|
||
self thread Player_BreadCrumb_Update();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
println( "Callback_PlayerConnect: Setting player origin to info_player_start " + info_player_spawn[0].origin );
|
||
self setOrigin( info_player_spawn[0].origin );
|
||
self setPlayerAngles( info_player_spawn[0].angles );
|
||
self thread Player_BreadCrumb_Update();
|
||
}
|
||
}
|
||
}
|
||
if( !IsDefined( self.flag ) )
|
||
{
|
||
self.flag = [];
|
||
self.flags_lock = [];
|
||
}
|
||
if( !IsDefined( self.flag["player_has_red_flashing_overlay"] ) )
|
||
{
|
||
self player_flag_init( "player_has_red_flashing_overlay" );
|
||
self player_flag_init( "player_is_invulnerable" );
|
||
}
|
||
if( !IsDefined( self.flag["loadout_given"] ) )
|
||
{
|
||
self player_flag_init( "loadout_given" );
|
||
}
|
||
self player_flag_clear( "loadout_given" );
|
||
if( GetDvar( #"r_reflectionProbeGenerate" ) == "1" )
|
||
{
|
||
waittillframeend;
|
||
self thread spawnPlayer();
|
||
return;
|
||
}
|
||
self setClientDvar( "ui_allow_loadoutchange", "1" );
|
||
self thread[[level.spawnClient]]();
|
||
dvarName = "player" + self GetEntityNumber() + "downs";
|
||
setdvar( dvarName, self.downs );
|
||
}
|
||
reset_clientdvars()
|
||
{
|
||
if( IsDefined( level.reset_clientdvars ) )
|
||
{
|
||
self [[level.reset_clientdvars]]();
|
||
return;
|
||
}
|
||
self SetClientDvars( "compass", "1",
|
||
"hud_showStance", "1",
|
||
"cg_thirdPerson", "0",
|
||
"cg_fov", "65",
|
||
"cg_cursorHints","4",
|
||
"cg_thirdPersonAngle", "0",
|
||
"hud_showobjectives","1",
|
||
"ammoCounterHide", "0",
|
||
"miniscoreboardhide", "0",
|
||
"ui_hud_hardcore", "0",
|
||
"credits_active", "0",
|
||
"hud_missionFailed", "0",
|
||
"cg_cameraUseTagCamera", "1",
|
||
"cg_drawCrosshair", "1",
|
||
"r_heroLightScale", "1 1 1",
|
||
"r_fog_disable", "0",
|
||
"r_dof_tweak", "0",
|
||
"player_sprintUnlimited", "0",
|
||
"r_bloomTweaks", "0",
|
||
"r_exposureTweak", "0",
|
||
"cg_aggressiveCullRadius", "0",
|
||
"sm_sunSampleSizeNear", "0.25"
|
||
);
|
||
self AllowSpectateTeam( "allies", false );
|
||
self AllowSpectateTeam( "axis", false );
|
||
self AllowSpectateTeam( "freelook", false );
|
||
self AllowSpectateTeam( "none", false );
|
||
}
|
||
Callback_PlayerDisconnect()
|
||
{
|
||
self Callback("on_player_disconnect");
|
||
}
|
||
Callback_PlayerDamage( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime )
|
||
{
|
||
if( IsDefined( self.overridePlayerDamage ) )
|
||
{
|
||
iDamage = self [[self.overridePlayerDamage]]( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime );
|
||
}
|
||
else if( IsDefined( level.overridePlayerDamage ) )
|
||
{
|
||
iDamage = self [[level.overridePlayerDamage]]( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime );
|
||
}
|
||
AssertEx(IsDefined(iDamage), "You must return a value from a damage override function.");
|
||
self Callback("on_player_damage");
|
||
if (is_true(self.magic_bullet_shield))
|
||
{
|
||
maxHealth = self.maxHealth;
|
||
self.health += iDamage;
|
||
self.maxHealth = maxHealth;
|
||
}
|
||
if( isdefined( self.divetoprone ) && self.divetoprone == 1 )
|
||
{
|
||
if( sMeansOfDeath == "MOD_GRENADE_SPLASH" )
|
||
{
|
||
dist = Distance2d(vPoint, self.origin);
|
||
if( dist > 32 )
|
||
{
|
||
dot_product = vectordot( AnglesToForward( self.angles ), vDir );
|
||
if( dot_product > 0 )
|
||
{
|
||
iDamage = int( iDamage * 0.5 );
|
||
}
|
||
}
|
||
}
|
||
}
|
||
println("CB PD");
|
||
if( isdefined( eAttacker ) && ((isPlayer( eAttacker )) && (eAttacker.team == self.team))&& ( !isDefined( level.friendlyexplosivedamage ) || !level.friendlyexplosivedamage ))
|
||
{
|
||
if( !isDefined(level.is_friendly_fire_on) || ![[level.is_friendly_fire_on]]() )
|
||
{
|
||
if( self != eAttacker)
|
||
{
|
||
println("Exiting - players can't hut each other.");
|
||
return;
|
||
}
|
||
else if( sMeansOfDeath != "MOD_GRENADE_SPLASH"
|
||
&& sMeansOfDeath != "MOD_GRENADE"
|
||
&& sMeansOfDeath != "MOD_EXPLOSIVE"
|
||
&& sMeansOfDeath != "MOD_PROJECTILE"
|
||
&& sMeansOfDeath != "MOD_PROJECTILE_SPLASH"
|
||
&& sMeansOfDeath != "MOD_BURNED"
|
||
&& sMeansOfDeath != "MOD_SUICIDE" )
|
||
{
|
||
println("Exiting - damage type verbotten.");
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
if ( isdefined( level.prevent_player_damage ) )
|
||
{
|
||
if ( self [[ level.prevent_player_damage ]]( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime ) )
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
if ( isdefined(eAttacker) && eAttacker != self )
|
||
{
|
||
if ( maps\_damagefeedback::doDamageFeedback( sWeapon, eInflictor ) )
|
||
{
|
||
if ( iDamage > 0 )
|
||
{
|
||
eAttacker thread maps\_damagefeedback::updateDamageFeedback();
|
||
}
|
||
}
|
||
}
|
||
self maps\_dds::update_player_damage( eAttacker );
|
||
if (iDamage >= self.health)
|
||
{
|
||
if ((sMeansOfDeath == "MOD_CRUSH")
|
||
&& IsDefined(eAttacker) && IsDefined(eAttacker.classname)
|
||
&& (eAttacker.classname == "script_vehicle"))
|
||
{
|
||
SetDvar( "ui_deadquote", "@SCRIPT_MOVING_VEHICLE_DEATH" );
|
||
}
|
||
}
|
||
if ( is_true( level.disable_player_damage_knockback ) )
|
||
{
|
||
iDFlags = iDFlags | level.iDFLAGS_NO_KNOCKBACK;
|
||
}
|
||
PrintLn("Finishplayerdamagage wrapper.");
|
||
self finishPlayerDamageWrapper( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime );
|
||
}
|
||
finishPlayerDamageWrapper( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime )
|
||
{
|
||
self finishPlayerDamage( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime );
|
||
}
|
||
incrGrenadeKillCount()
|
||
{
|
||
if (!isPlayer(self) )
|
||
{
|
||
return;
|
||
}
|
||
if (!isDefined(self.grenadeKillCounter) )
|
||
{
|
||
self.grenadeKillCounter = 0;
|
||
}
|
||
self.grenadeKillCounter++;
|
||
if( self.grenadeKillCounter >= 5 )
|
||
{
|
||
self giveachievement_wrapper( "SP_GEN_FRAGMASTER" );
|
||
}
|
||
wait( 0.25 );
|
||
self.grenadeKillCounter--;
|
||
}
|
||
Callback_ActorDamage( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime )
|
||
{
|
||
self endon("death");
|
||
if( IsDefined( self.overrideActorDamage ) )
|
||
{
|
||
iDamage = self [[self.overrideActorDamage]]( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime );
|
||
}
|
||
else if( IsDefined( level.overrideActorDamage ) )
|
||
{
|
||
iDamage = self [[level.overrideActorDamage]]( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime );
|
||
}
|
||
AssertEx(IsDefined(iDamage), "You must return a value from a damage override function.");
|
||
self Callback("on_actor_damage");
|
||
if ( is_true(self.magic_bullet_shield ) && !is_true( self.bulletcam_death ) )
|
||
{
|
||
MIN_PAIN_INTERVAL = 500;
|
||
t = GetTime();
|
||
if ((t - self._mbs.last_pain_time > MIN_PAIN_INTERVAL)
|
||
|| (sMeansOfDeath == "MOD_EXPLOSIVE"))
|
||
{
|
||
if (self.allowPain || is_true(self._mbs.allow_pain_old))
|
||
{
|
||
enable_pain();
|
||
}
|
||
self._mbs.last_pain_time = t;
|
||
self thread ignore_me_timer( self._mbs.ignore_time, "stop_magic_bullet_shield" );
|
||
self thread turret_ignore_me_timer( self._mbs.turret_ignore_time );
|
||
}
|
||
else
|
||
{
|
||
self._mbs.allow_pain_old = self.allowPain;
|
||
disable_pain();
|
||
}
|
||
self.delayedDeath = false;
|
||
maxHealth = self.maxHealth;
|
||
self.health += iDamage;
|
||
self.maxHealth = maxHealth;
|
||
}
|
||
else if (!is_true(self.a.doingRagdollDeath))
|
||
{
|
||
iDamage = maps\_bulletcam::try_bulletcam( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime );
|
||
if( GetDvar( #"zombiemode") != "1" )
|
||
{
|
||
if (!self call_overloaded_func( "animscripts\balcony", "balconyDamage", iDamage, sHitLoc, sMeansOfDeath ))
|
||
{
|
||
self animscripts\revive::tryGoingDown( iDamage, sHitLoc );
|
||
}
|
||
}
|
||
}
|
||
if ( IsDefined(eAttacker) && eAttacker != self )
|
||
{
|
||
if ( maps\_damagefeedback::doDamageFeedback( sWeapon, eInflictor ) )
|
||
{
|
||
if ( iDamage > 0 )
|
||
{
|
||
eAttacker thread maps\_damagefeedback::updateDamageFeedback();
|
||
}
|
||
}
|
||
}
|
||
self maps\_dds::update_actor_damage( eAttacker, sMeansOfDeath );
|
||
if( self.health - iDamage <= 0 && sWeapon == "crossbow_sp" )
|
||
{
|
||
self.dofiringdeath = false;
|
||
}
|
||
if( isPlayer( eAttacker ) && ( self.health - iDamage <= 0 ) )
|
||
{
|
||
println( "player killed enemy with "+sWeapon+" via "+sMeansOfDeath );
|
||
if ( self.team == "axis" && GetDvar( #"zombiemode" ) != "1" )
|
||
{
|
||
if ( sWeapon == "explosive_bolt_sp" || sWeapon == "crossbow_explosive_alt_sp" )
|
||
{
|
||
killedSoFar = 1 + GetPersistentProfileVar( 0, 0 );
|
||
if( killedSoFar >= 30 )
|
||
{
|
||
eAttacker giveachievement_wrapper( "SP_GEN_CROSSBOW" );
|
||
}
|
||
SetPersistentProfileVar( 0, killedSoFar );
|
||
}
|
||
if( ( sMeansOfDeath == "MOD_GRENADE" || sMeansOfDeath == "MOD_GRENADE_SPLASH" ) && sWeapon == "frag_grenade_sp" )
|
||
{
|
||
eAttacker thread incrGrenadeKillCount();
|
||
}
|
||
}
|
||
}
|
||
self finishActorDamageWrapper( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime );
|
||
}
|
||
finishActorDamageWrapper( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime )
|
||
{
|
||
self finishActorDamage( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime );
|
||
}
|
||
Callback_RevivePlayer()
|
||
{
|
||
self endon( "disconnect" );
|
||
self RevivePlayer();
|
||
}
|
||
Callback_PlayerLastStand( eInflictor, eAttacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration )
|
||
{
|
||
self endon( "disconnect" );
|
||
self Callback("on_player_last_stand");
|
||
[[maps\_laststand::PlayerLastStand]]( eInflictor, eAttacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration );
|
||
}
|
||
Callback_PlayerKilled( eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration )
|
||
{
|
||
self thread[[level.onPlayerKilled]]( eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime, deathAnimDuration );
|
||
self.downs++;
|
||
dvarName = "player" + self GetEntityNumber() + "downs";
|
||
setdvar( dvarName, self.downs );
|
||
if( IsDefined( level.player_killed_shellshock ) )
|
||
{
|
||
self ShellShock( level.player_killed_shellshock, 3 );
|
||
}
|
||
else
|
||
{
|
||
self ShellShock( "death", 3 );
|
||
}
|
||
self PlayLocalSound( "evt_player_death" );
|
||
self setmovespeedscale( 1.0 );
|
||
self.ignoreme = false;
|
||
self notify( "killed_player" );
|
||
self Callback("on_player_killed");
|
||
wait( 1 );
|
||
if( IsDefined( level.overridePlayerKilled ) )
|
||
{
|
||
self [[level.overridePlayerKilled]]();
|
||
}
|
||
if( get_players().size > 1 )
|
||
{
|
||
players = get_players();
|
||
for( i = 0; i < players.size; i++ )
|
||
{
|
||
if( isDefined( players[i] ) )
|
||
{
|
||
if( !isAlive( players[i] ) )
|
||
{
|
||
println( "Player #"+i+" is dead" );
|
||
}
|
||
else
|
||
{
|
||
println( "Player #"+i+" is alive" );
|
||
}
|
||
}
|
||
}
|
||
missionfailed();
|
||
return;
|
||
}
|
||
}
|
||
Callback_ActorKilled( eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime )
|
||
{
|
||
if( IsDefined( self.overrideActorKilled ) )
|
||
{
|
||
self [[self.overrideActorKilled]]( eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime );
|
||
}
|
||
else if( IsDefined( level.overrideActorKilled ) )
|
||
{
|
||
self [[level.overrideActorKilled]]( eInflictor, attacker, iDamage, sMeansOfDeath, sWeapon, vDir, sHitLoc, psOffsetTime );
|
||
}
|
||
self Callback("on_actor_killed");
|
||
}
|
||
Callback_VehicleDamage( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, psOffsetTime, damageFromUnderneath, modelIndex, partName )
|
||
{
|
||
self endon("death");
|
||
if( IsDefined( self.overrideVehicleDamage ) )
|
||
{
|
||
iDamage = self [[self.overrideVehicleDamage]]( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, psOffsetTime, damageFromUnderneath, modelIndex, partName );
|
||
}
|
||
else if( IsDefined( level.overrideVehicleDamage ) )
|
||
{
|
||
iDamage = self [[level.overrideVehicleDamage]]( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, psOffsetTime, damageFromUnderneath, modelIndex, partName );
|
||
}
|
||
AssertEx(IsDefined(iDamage), "You must return a value from a damage override function.");
|
||
self Callback("on_vehicle_damage");
|
||
if( self IsVehicleImmuneToDamage( iDFlags, sMeansOfDeath, sWeapon ) )
|
||
{
|
||
return;
|
||
}
|
||
if( self maps\_vehicle::friendlyfire_shield_callback( eAttacker, iDamage, sMeansOfDeath ) )
|
||
{
|
||
return;
|
||
}
|
||
self finishVehicleDamage(eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, psOffsetTime, damageFromUnderneath, modelIndex, partName, false);
|
||
}
|
||
spawnClient()
|
||
{
|
||
self endon( "disconnect" );
|
||
self endon( "end_respawn" );
|
||
println( "*************************spawnClient****" );
|
||
self unlink();
|
||
if( isdefined( self.spectate_cam ) )
|
||
{
|
||
self.spectate_cam delete();
|
||
}
|
||
if( level.otherPlayersSpectate )
|
||
{
|
||
self thread [[level.spawnSpectator]]();
|
||
}
|
||
else
|
||
{
|
||
self thread [[level.spawnPlayer]]();
|
||
}
|
||
}
|
||
spawnPlayer( spawnOnHost )
|
||
{
|
||
self endon( "disconnect" );
|
||
self endon( "spawned_spectator" );
|
||
self notify( "spawned" );
|
||
self notify( "end_respawn" );
|
||
synchronize_players();
|
||
setSpawnVariables();
|
||
self.sessionstate = "playing";
|
||
self.spectatorclient = -1;
|
||
self.archivetime = 0;
|
||
self.psoffsettime = 0;
|
||
self.statusicon = "";
|
||
self.maxhealth = self.health;
|
||
self.shellshocked = false;
|
||
self.inWater = false;
|
||
self.friendlydamage = undefined;
|
||
self.hasSpawned = true;
|
||
self.spawnTime = getTime();
|
||
self.afk = false;
|
||
println( "*************************spawnPlayer****" );
|
||
self detachAll();
|
||
if( IsDefined( level.custom_spawnPlayer ) )
|
||
{
|
||
self [[level.custom_spawnPlayer]]();
|
||
return;
|
||
}
|
||
if( isdefined( level.onSpawnPlayer ) )
|
||
{
|
||
self [[level.onSpawnPlayer]]();
|
||
}
|
||
wait_for_first_player();
|
||
if( isdefined( spawnOnHost ) )
|
||
{
|
||
self Spawn( get_players()[0].origin, get_players()[0].angles );
|
||
self SetPlayerSpawnPos();
|
||
}
|
||
else
|
||
{
|
||
self Spawn( self.origin, self.angles );
|
||
}
|
||
if( isdefined( level.onPostSpawnPlayer ) )
|
||
{
|
||
self[[level.onPostSpawnPlayer]]();
|
||
}
|
||
if( isdefined( level.onPlayerWeaponSwap ) )
|
||
{
|
||
self thread[[level.onPlayerWeaponSwap]]();
|
||
}
|
||
self maps\_introscreen::introscreen_player_connect();
|
||
waittillframeend;
|
||
if( self != get_players("all")[0] )
|
||
{
|
||
wait( 0.5 );
|
||
}
|
||
self notify( "spawned_player" );
|
||
}
|
||
synchronize_players()
|
||
{
|
||
if( !IsDefined( level.flag ) || !IsDefined( level.flag["all_players_connected"] ) )
|
||
{
|
||
println( "^1**** ERROR: You must call _load::main() if you don't want bad coop things to happen! ****" );
|
||
println( "^1**** ERROR: You must call _load::main() if you don't want bad coop things to happen! ****" );
|
||
println( "^1**** ERROR: You must call _load::main() if you don't want bad coop things to happen! ****" );
|
||
return;
|
||
}
|
||
if( GetNumConnectedPlayers() == GetNumExpectedPlayers() )
|
||
{
|
||
return;
|
||
}
|
||
if( flag( "all_players_connected" ) )
|
||
{
|
||
return;
|
||
}
|
||
background = undefined;
|
||
if ( level.onlineGame || level.systemLink )
|
||
{
|
||
self OpenMenu( "briefing" );
|
||
}
|
||
else
|
||
{
|
||
background = NewHudElem();
|
||
background.x = 0;
|
||
background.y = 0;
|
||
background.horzAlign = "fullscreen";
|
||
background.vertAlign = "fullscreen";
|
||
background.foreground = true;
|
||
background SetShader( "black", 640, 480 );
|
||
}
|
||
flag_wait( "all_players_connected" );
|
||
if ( level.onlineGame || level.systemLink )
|
||
{
|
||
players = get_players("all");
|
||
for ( i = 0; i < players.size; i++ )
|
||
{
|
||
players[i] CloseMenu();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
assert( IsDefined( background ) );
|
||
background Destroy();
|
||
}
|
||
}
|
||
spawnSpectator()
|
||
{
|
||
self endon( "disconnect" );
|
||
self endon( "spawned_spectator" );
|
||
self notify( "spawned" );
|
||
self notify( "end_respawn" );
|
||
setSpawnVariables();
|
||
self.sessionstate = "spectator";
|
||
self.spectatorclient = -1;
|
||
if( isdefined( level.otherPlayersSpectateClient ) )
|
||
{
|
||
self.spectatorclient = level.otherPlayersSpectateClient getEntityNumber();
|
||
}
|
||
self setClientDvars( "cg_thirdPerson", 0 );
|
||
self setSpectatePermissions();
|
||
self.archivetime = 0;
|
||
self.psoffsettime = 0;
|
||
self.statusicon = "";
|
||
self.maxhealth = self.health;
|
||
self.shellshocked = false;
|
||
self.inWater = false;
|
||
self.friendlydamage = undefined;
|
||
self.hasSpawned = true;
|
||
self.spawnTime = getTime();
|
||
self.afk = false;
|
||
println( "*************************spawnSpectator***" );
|
||
self detachAll();
|
||
if( isdefined( level.onSpawnSpectator ) )
|
||
{
|
||
self[[level.onSpawnSpectator]]();
|
||
}
|
||
self Spawn( self.origin, self.angles );
|
||
waittillframeend;
|
||
flag_wait( "all_players_connected" );
|
||
self notify( "spawned_spectator" );
|
||
}
|
||
setSpectatePermissions()
|
||
{
|
||
self AllowSpectateTeam( "allies", true );
|
||
self AllowSpectateTeam( "axis", false );
|
||
self AllowSpectateTeam( "freelook", false );
|
||
self AllowSpectateTeam( "none", false );
|
||
}
|
||
spawnIntermission()
|
||
{
|
||
self notify( "spawned" );
|
||
self notify( "end_respawn" );
|
||
self setSpawnVariables();
|
||
self freezeControls( false );
|
||
self setClientDvar( "cg_everyoneHearsEveryone", "1" );
|
||
self.sessionstate = "intermission";
|
||
self.spectatorclient = -1;
|
||
self.killcamentity = -1;
|
||
self.archivetime = 0;
|
||
self.psoffsettime = 0;
|
||
self.friendlydamage = undefined;
|
||
[[level.onSpawnIntermission]]();
|
||
self setDepthOfField( 0, 128, 512, 4000, 6, 1.8 );
|
||
}
|
||
default_onSpawnPlayer()
|
||
{
|
||
}
|
||
default_onPostSpawnPlayer()
|
||
{
|
||
}
|
||
default_onSpawnSpectator()
|
||
{
|
||
}
|
||
default_onSpawnIntermission()
|
||
{
|
||
spawnpointname = "info_intermission";
|
||
spawnpoints = getentarray( spawnpointname, "classname" );
|
||
if(spawnpoints.size < 1)
|
||
{
|
||
println( "NO " + spawnpointname + " SPAWNPOINTS IN MAP" );
|
||
return;
|
||
}
|
||
spawnpoint = spawnpoints[RandomInt(spawnpoints.size)];
|
||
if( isDefined( spawnpoint ) )
|
||
{
|
||
self spawn( spawnpoint.origin, spawnpoint.angles );
|
||
}
|
||
}
|
||
first_player_connect()
|
||
{
|
||
waittillframeend;
|
||
if( isDefined( self ) )
|
||
{
|
||
level notify( "connecting", self );
|
||
players = get_players();
|
||
if( isdefined( players ) &&( players.size == 0 || players[0] == self ) )
|
||
{
|
||
level notify( "connecting_first_player", self );
|
||
self waittill( "spawned_player" );
|
||
waittillframeend;
|
||
level notify( "first_player_ready", self );
|
||
if( GetDvar( #"zombiemode") != "1" )
|
||
{
|
||
prefetchnext();
|
||
}
|
||
self Callback("on_first_player_connect");
|
||
}
|
||
}
|
||
}
|
||
setSpawnVariables()
|
||
{
|
||
resetTimeout();
|
||
self StopShellshock();
|
||
self StopRumble( "damage_heavy" );
|
||
}
|
||
|
||
|
||
|
||
|