void G_namelog_restore( gclient_t *client )
{
namelog_t *n = client->pers.namelog;
G_ChangeTeam( g_entities + n->slot, n->team );
client->ps.persistant[ PERS_SCORE ] = n->score;
client->ps.persistant[ PERS_CREDIT ] = 0;
G_AddCreditToClient( client, n->credits, qfalse );
}
void game_funds_act( gentity_t *self, gentity_t*, gentity_t *activator )
{
if( !activator )
{
return;
}
G_AddCreditToClient( activator->client, self->amount, true );
}
/*
==================
player_die
==================
*/
void player_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int meansOfDeath )
{
gentity_t *ent;
int anim;
int killer;
int i;
const char *killerName, *obit;
if ( self->client->ps.pm_type == PM_DEAD )
{
return;
}
if ( level.intermissiontime )
{
return;
}
self->client->ps.pm_type = PM_DEAD;
self->suicideTime = 0;
if ( attacker )
{
killer = attacker->s.number;
if ( attacker->client )
{
killerName = attacker->client->pers.netname;
}
else
{
killerName = "<world>";
}
}
else
{
killer = ENTITYNUM_WORLD;
killerName = "<world>";
}
if ( meansOfDeath < 0 || meansOfDeath >= ARRAY_LEN( modNames ) )
{
// fall back on the number
obit = va( "%d", meansOfDeath );
}
else
{
obit = modNames[ meansOfDeath ];
}
G_LogPrintf( "Die: %d %d %s: %s" S_COLOR_WHITE " killed %s\n",
killer,
( int )( self - g_entities ),
obit,
killerName,
self->client->pers.netname );
// deactivate all upgrades
for ( i = UP_NONE + 1; i < UP_NUM_UPGRADES; i++ )
{
BG_DeactivateUpgrade( i, self->client->ps.stats );
}
// broadcast the death event to everyone
ent = G_NewTempEntity( self->r.currentOrigin, EV_OBITUARY );
ent->s.eventParm = meansOfDeath;
ent->s.otherEntityNum = self->s.number;
ent->s.otherEntityNum2 = killer;
ent->r.svFlags = SVF_BROADCAST; // send to everyone
if ( attacker && attacker->client )
{
if ( ( attacker == self || OnSameTeam( self, attacker ) ) )
{
//punish team kills and suicides
if ( attacker->client->ps.stats[ STAT_TEAM ] == TEAM_ALIENS )
{
G_AddCreditToClient( attacker->client, -ALIEN_TK_SUICIDE_PENALTY, qtrue );
G_AddCreditsToScore( attacker, -ALIEN_TK_SUICIDE_PENALTY );
}
else if ( attacker->client->ps.stats[ STAT_TEAM ] == TEAM_HUMANS )
{
G_AddCreditToClient( attacker->client, -HUMAN_TK_SUICIDE_PENALTY, qtrue );
G_AddCreditsToScore( attacker, -HUMAN_TK_SUICIDE_PENALTY );
}
}
else if ( g_showKillerHP.integer )
{
trap_SendServerCommand( self - g_entities, va( "print_tr %s %s %3i", QQ( N_("Your killer, $1$^7, had $2$ HP.\n") ),
Quote( killerName ),
attacker->health ) );
}
}
else if ( attacker->s.eType != ET_BUILDABLE )
{
if ( self->client->ps.stats[ STAT_TEAM ] == TEAM_ALIENS )
{
G_AddCreditsToScore( self, -ALIEN_TK_SUICIDE_PENALTY );
}
else if ( self->client->ps.stats[ STAT_TEAM ] == TEAM_HUMANS )
{
G_AddCreditsToScore( self, -HUMAN_TK_SUICIDE_PENALTY );
}
}
// give credits for killing this player
G_RewardAttackers( self );
ScoreboardMessage( self ); // show scores
// send updated scores to any clients that are following this one,
// or they would get stale scoreboards
for ( i = 0; i < level.maxclients; i++ )
{
gclient_t *client;
client = &level.clients[ i ];
if ( client->pers.connected != CON_CONNECTED )
{
continue;
}
if ( client->sess.spectatorState == SPECTATOR_NOT )
{
continue;
}
if ( client->sess.spectatorClient == self->s.number )
{
ScoreboardMessage( g_entities + i );
}
}
VectorCopy( self->s.origin, self->client->pers.lastDeathLocation );
self->takedamage = qfalse; // can still be gibbed
self->s.weapon = WP_NONE;
if ( self->client->noclip )
{
self->client->cliprcontents = CONTENTS_CORPSE;
}
else
{
self->r.contents = CONTENTS_CORPSE;
}
self->s.angles[ PITCH ] = 0;
self->s.angles[ ROLL ] = 0;
self->s.angles[ YAW ] = self->s.apos.trBase[ YAW ];
LookAtKiller( self, inflictor, attacker );
VectorCopy( self->s.angles, self->client->ps.viewangles );
self->s.loopSound = 0;
self->r.maxs[ 2 ] = -8;
// don't allow respawn until the death anim is done
// g_forcerespawn may force spawning at some later time
self->client->respawnTime = level.time + 1700;
// clear misc
memset( self->client->ps.misc, 0, sizeof( self->client->ps.misc ) );
{
static int i;
if ( !( self->client->ps.persistant[ PERS_STATE ] & PS_NONSEGMODEL ) )
{
switch ( i )
{
case 0:
anim = BOTH_DEATH1;
break;
case 1:
anim = BOTH_DEATH2;
break;
case 2:
default:
anim = BOTH_DEATH3;
break;
}
}
else
{
switch ( i )
{
case 0:
anim = NSPA_DEATH1;
break;
case 1:
anim = NSPA_DEATH2;
break;
case 2:
default:
anim = NSPA_DEATH3;
break;
}
}
self->client->ps.legsAnim =
( ( self->client->ps.legsAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;
if ( !( self->client->ps.persistant[ PERS_STATE ] & PS_NONSEGMODEL ) )
{
self->client->ps.torsoAnim =
( ( self->client->ps.torsoAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;
}
// use own entityid if killed by non-client to prevent uint8_t overflow
G_AddEvent( self, EV_DEATH1 + i,
( killer < MAX_CLIENTS ) ? killer : self - g_entities );
// globally cycle through the different death animations
i = ( i + 1 ) % 3;
}
trap_LinkEntity( self );
self->client->pers.infoChangeTime = level.time;
}
/*
==================
G_RewardAttackers
Function to distribute rewards to entities that killed this one.
==================
*/
void G_RewardAttackers( gentity_t *self )
{
float value, reward;
int playerNum, enemyDamage, maxHealth, damageShare;
gentity_t *player;
team_t ownTeam, playerTeam;
confidence_reason_t reason;
confidence_qualifier_t qualifier;
// Only reward killing players and buildables
if ( self->client )
{
ownTeam = self->client->pers.teamSelection;
maxHealth = self->client->ps.stats[ STAT_MAX_HEALTH ];
value = ( float )BG_GetValueOfPlayer( &self->client->ps );
}
else if ( self->s.eType == ET_BUILDABLE )
{
ownTeam = self->buildableTeam;
maxHealth = BG_Buildable( self->s.modelindex )->health;
value = ( float )BG_Buildable( self->s.modelindex )->value;
// Give partial credits for buildables in construction
if ( !self->spawned )
{
value *= ( float )( level.time - self->creationTime ) / BG_Buildable( self->s.modelindex )->buildTime;
}
}
else
{
return;
}
enemyDamage = 0;
// Sum up damage dealt by enemies
for ( playerNum = 0; playerNum < level.maxclients; playerNum++ )
{
player = &g_entities[ playerNum ];
playerTeam = player->client->pers.teamSelection;
// Player must be on the other team
if ( playerTeam == ownTeam || playerTeam <= TEAM_NONE || playerTeam >= NUM_TEAMS )
{
continue;
}
enemyDamage += self->credits[ playerNum ];
}
if ( enemyDamage <= 0 )
{
return;
}
// Give individual rewards
for ( playerNum = 0; playerNum < level.maxclients; playerNum++ )
{
player = &g_entities[ playerNum ];
playerTeam = player->client->pers.teamSelection;
damageShare = self->credits[ playerNum ];
// Clear reward array
self->credits[ playerNum ] = 0;
// Player must be on the other team
if ( playerTeam == ownTeam || playerTeam <= TEAM_NONE || playerTeam >= NUM_TEAMS )
{
continue;
}
// Player must have dealt damage
if ( damageShare <= 0 )
{
continue;
}
reward = value * ( damageShare / ( float )maxHealth );
if ( reward <= 0.0f )
{
continue;
}
if ( self->s.eType == ET_BUILDABLE )
{
G_AddConfidenceToScore( player, reward );
switch ( self->s.modelindex )
{
case BA_A_OVERMIND:
case BA_H_REACTOR:
reason = CONF_REAS_DESTR_CRUCIAL;
break;
case BA_A_ACIDTUBE:
case BA_A_TRAPPER:
case BA_A_HIVE:
case BA_H_MGTURRET:
case BA_H_TESLAGEN:
reason = CONF_REAS_DESTR_AGGRESSIVE;
break;
default:
reason = CONF_REAS_DESTR_SUPPORT;
}
qualifier = CONF_QUAL_NONE;
G_AddConfidence( playerTeam, CONFIDENCE_DESTRUCTION, reason, qualifier, reward, player );
}
else
{
G_AddCreditsToScore( player, ( int )reward );
G_AddCreditToClient( player->client, ( short )reward, qtrue );
// Give confidence for killing non-naked players outside the friendly base
switch ( self->client->ps.stats[ STAT_CLASS ] )
{
case PCL_ALIEN_LEVEL0:
case PCL_ALIEN_BUILDER0:
case PCL_ALIEN_BUILDER0_UPG:
break;
case PCL_HUMAN:
// Treat a human just wearing light armor as naked
if ( ( int )value <= BG_Class( PCL_HUMAN )->value +
( BG_Upgrade( UP_LIGHTARMOUR )->price / 2 ) )
{
break;
}
default:
if ( G_InsideBase( player, qtrue ) || G_InsideBase( self, qfalse ) )
{
break;
}
qualifier = CONF_QUAL_OUTSIDE_OWN_BASE;
G_AddConfidence( playerTeam, CONFIDENCE_KILLING, CONF_REAS_KILLING,
qualifier, reward * CONFIDENCE_PER_CREDIT, player );
}
}
}
}
void G_BotThink( gentity_t *self )
{
char buf[MAX_STRING_CHARS];
usercmd_t *botCmdBuffer;
vec3_t nudge;
botRouteTarget_t routeTarget;
self->botMind->cmdBuffer = self->client->pers.cmd;
botCmdBuffer = &self->botMind->cmdBuffer;
//reset command buffer
usercmdClearButtons( botCmdBuffer->buttons );
// for nudges, e.g. spawn blocking
nudge[0] = botCmdBuffer->doubleTap != dtType_t::DT_NONE ? botCmdBuffer->forwardmove : 0;
nudge[1] = botCmdBuffer->doubleTap != dtType_t::DT_NONE ? botCmdBuffer->rightmove : 0;
nudge[2] = botCmdBuffer->doubleTap != dtType_t::DT_NONE ? botCmdBuffer->upmove : 0;
botCmdBuffer->forwardmove = 0;
botCmdBuffer->rightmove = 0;
botCmdBuffer->upmove = 0;
botCmdBuffer->doubleTap = dtType_t::DT_NONE;
//acknowledge recieved server commands
//MUST be done
while ( trap_BotGetServerCommand( self->client->ps.clientNum, buf, sizeof( buf ) ) );
BotSearchForEnemy( self );
BotFindClosestBuildings( self );
BotFindDamagedFriendlyStructure( self );
BotCalculateStuckTime( self );
//use medkit when hp is low
if ( self->entity->Get<HealthComponent>()->Health() < BOT_USEMEDKIT_HP &&
BG_InventoryContainsUpgrade( UP_MEDKIT, self->client->ps.stats ) )
{
BG_ActivateUpgrade( UP_MEDKIT, self->client->ps.stats );
}
//infinite funds cvar
if ( g_bot_infinite_funds.integer )
{
G_AddCreditToClient( self->client, HUMAN_MAX_CREDITS, true );
}
//hacky ping fix
self->client->ps.ping = rand() % 50 + 50;
if ( !self->botMind->behaviorTree )
{
Log::Warn( "NULL behavior tree" );
return;
}
// always update the path corridor
if ( self->botMind->goal.inuse )
{
BotTargetToRouteTarget( self, self->botMind->goal, &routeTarget );
trap_BotUpdatePath( self->s.number, &routeTarget, &self->botMind->nav );
//BotClampPos( self );
}
self->botMind->behaviorTree->run( self, ( AIGenericNode_t * ) self->botMind->behaviorTree );
// if we were nudged...
VectorAdd( self->client->ps.velocity, nudge, self->client->ps.velocity );
self->client->pers.cmd = self->botMind->cmdBuffer;
}
/**
* @brief Function to distribute rewards to entities that killed this one.
* @param self
*/
void G_RewardAttackers( gentity_t *self )
{
float value, share, reward, enemyDamage, damageShare;
int playerNum, maxHealth;
gentity_t *player;
team_t ownTeam, playerTeam;
// Only reward killing players and buildables
if ( self->client )
{
ownTeam = (team_t) self->client->pers.team;
maxHealth = self->client->ps.stats[ STAT_MAX_HEALTH ];
value = BG_GetValueOfPlayer( &self->client->ps );
}
else if ( self->s.eType == ET_BUILDABLE )
{
ownTeam = (team_t) self->buildableTeam;
maxHealth = BG_Buildable( self->s.modelindex )->health;
value = BG_Buildable( self->s.modelindex )->value;
// Give partial credits for buildables in construction
if ( !self->spawned )
{
value *= ( level.time - self->creationTime ) /
( float )BG_Buildable( self->s.modelindex )->buildTime;
}
}
else
{
return;
}
// Sum up damage dealt by enemies
enemyDamage = 0.0f;
for ( playerNum = 0; playerNum < level.maxclients; playerNum++ )
{
player = &g_entities[ playerNum ];
playerTeam = (team_t) player->client->pers.team;
// Player must be on the other team
if ( playerTeam == ownTeam || playerTeam <= TEAM_NONE || playerTeam >= NUM_TEAMS )
{
continue;
}
enemyDamage += self->credits[ playerNum ];
}
if ( enemyDamage <= 0 )
{
return;
}
// Give individual rewards
for ( playerNum = 0; playerNum < level.maxclients; playerNum++ )
{
player = &g_entities[ playerNum ];
playerTeam = (team_t) player->client->pers.team;
damageShare = self->credits[ playerNum ];
// Clear reward array
self->credits[ playerNum ] = 0.0f;
// Player must be on the other team
if ( playerTeam == ownTeam || playerTeam <= TEAM_NONE || playerTeam >= NUM_TEAMS )
{
continue;
}
// Player must have dealt damage
if ( damageShare <= 0.0f )
{
continue;
}
share = damageShare / ( float )maxHealth;
reward = value * share;
if ( self->s.eType == ET_BUILDABLE )
{
// Add score
G_AddMomentumToScore( player, reward );
// Add momentum
G_AddMomentumForDestroyingStep( self, player, share );
}
else
{
// Add score
G_AddCreditsToScore( player, ( int )reward );
// Add credits
G_AddCreditToClient( player->client, ( short )reward, qtrue );
// Add momentum
G_AddMomentumForKillingStep( self, player, share );
}
}
// Complete momentum modification
G_AddMomentumEnd();
}
/*
==================
player_die
==================
*/
void player_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath )
{
gentity_t *ent;
int anim;
int killer;
int i, j;
char *killerName, *obit;
float totalDamage = 0.0f;
float percentDamage = 0.0f;
gentity_t *player;
qboolean tk = qfalse;
if( self->client->ps.pm_type == PM_DEAD )
return;
if( level.intermissiontime )
return;
self->client->ps.pm_type = PM_DEAD;
self->suicideTime = 0;
if( attacker )
{
killer = attacker->s.number;
if( attacker->client )
{
killerName = attacker->client->pers.netname;
// ROTAX
/*
tk = ( attacker != self && attacker->client->ps.stats[ STAT_PTEAM ]
== self->client->ps.stats[ STAT_PTEAM ] );
if( attacker != self && attacker->client->ps.stats[ STAT_PTEAM ] == self->client->ps.stats[ STAT_PTEAM ] )
{
attacker->client->pers.statscounters.teamkills++;
if( attacker->client->pers.teamSelection == PTE_ALIENS )
{
level.alienStatsCounters.teamkills++;
}
else if( attacker->client->pers.teamSelection == PTE_HUMANS )
{
level.humanStatsCounters.teamkills++;
}
}
*/
tk = ( attacker != self && attacker->client->pers.statscounters.tremball_team == self->client->pers.statscounters.tremball_team );
}
else
killerName = "<non-client>";
}
else
{
killer = ENTITYNUM_WORLD;
killerName = "<world>";
}
if( killer < 0 || killer >= MAX_CLIENTS )
{
killer = ENTITYNUM_WORLD;
killerName = "<world>";
}
if( meansOfDeath < 0 || meansOfDeath >= sizeof( modNames ) / sizeof( modNames[0] ) )
obit = "<bad obituary>";
else
obit = modNames[ meansOfDeath ];
G_LogPrintf("Kill: %i %i %i: %s^7 killed %s^7 by %s\n",
killer, self->s.number, meansOfDeath, killerName,
self->client->pers.netname, obit );
//TA: close any menus the client has open
G_CloseMenus( self->client->ps.clientNum );
//TA: deactivate all upgrades
for( i = UP_NONE + 1; i < UP_NUM_UPGRADES; i++ )
BG_DeactivateUpgrade( i, self->client->ps.stats );
// broadcast the death event to everyone
if( !tk )
{
ent = G_TempEntity( self->r.currentOrigin, EV_OBITUARY );
ent->s.eventParm = meansOfDeath;
ent->s.otherEntityNum = self->s.number;
ent->s.otherEntityNum2 = killer;
ent->r.svFlags = SVF_BROADCAST; // send to everyone
}
else if( attacker && attacker->client )
{
// tjw: obviously this is a hack and belongs in the client, but
// this works as a temporary fix.
trap_SendServerCommand( -1,
va( "print \"%s^7 was killed by ^1TEAMMATE^7 %s^7 (Did %d damage to %d max)\n\"",
self->client->pers.netname, attacker->client->pers.netname, self->client->tkcredits[ attacker->s.number ], self->client->ps.stats[ STAT_MAX_HEALTH ] ) );
trap_SendServerCommand( attacker - g_entities,
va( "cp \"You killed ^1TEAMMATE^7 %s\"", self->client->pers.netname ) );
G_LogOnlyPrintf("%s^7 was killed by ^1TEAMMATE^7 %s^7 (Did %d damage to %d max)\n",
self->client->pers.netname, attacker->client->pers.netname, self->client->tkcredits[ attacker->s.number ], self->client->ps.stats[ STAT_MAX_HEALTH ] );
}
self->enemy = attacker;
self->client->ps.persistant[ PERS_KILLED ]++;
self->client->pers.statscounters.deaths++;
if( self->client->pers.teamSelection == PTE_ALIENS )
{
level.alienStatsCounters.deaths++;
}
else if( self->client->pers.teamSelection == PTE_HUMANS )
{
level.humanStatsCounters.deaths++;
}
if( attacker && attacker->client )
{
attacker->client->lastkilled_client = self->s.number;
if( g_devmapKillerHP.integer && g_cheats.integer )
{
trap_SendServerCommand( self-g_entities, va( "print \"Your killer, %s, had %3i HP.\n\"", killerName, attacker->health ) );
}
if( attacker == self || attacker->client->pers.statscounters.tremball_team == self->client->pers.statscounters.tremball_team ) // ROTAX
{
AddScore( attacker, -1 );
// Retribution: transfer value of player from attacker to victim
if( g_retribution.integer) {
if(attacker!=self){
int max = ALIEN_MAX_KILLS, tk_value = 0;
char *type = "evos";
if( attacker->client->ps.stats[ STAT_PTEAM ] == PTE_ALIENS )
{
tk_value = BG_ClassCanEvolveFromTo( PCL_ALIEN_LEVEL0,
self->client->ps.stats[ STAT_PCLASS ], ALIEN_MAX_KILLS, 0 );
} else
{
tk_value = BG_GetValueOfEquipment( &self->client->ps );
max = HUMAN_MAX_CREDITS;
type = "credits";
}
if( attacker->client->ps.persistant[ PERS_CREDIT ] < tk_value )
tk_value = attacker->client->ps.persistant[ PERS_CREDIT ];
if( self->client->ps.persistant[ PERS_CREDIT ]+tk_value > max )
tk_value = max-self->client->ps.persistant[ PERS_CREDIT ];
if( tk_value > 0 ) {
// adjust using the retribution cvar (in percent)
tk_value = tk_value*g_retribution.integer/100;
G_AddCreditToClient( self->client, tk_value, qtrue );
G_AddCreditToClient( attacker->client, -tk_value, qtrue );
trap_SendServerCommand( self->client->ps.clientNum,
va( "print \"Received ^3%d %s ^7from %s ^7in retribution.\n\"",
tk_value, type, attacker->client->pers.netname ) );
trap_SendServerCommand( attacker->client->ps.clientNum,
va( "print \"Transfered ^3%d %s ^7to %s ^7in retribution.\n\"",
tk_value, type, self->client->pers.netname ) );
}
}
}
// Normal teamkill penalty
else {
if( attacker->client->ps.stats[ STAT_PTEAM ] == PTE_ALIENS )
G_AddCreditToClient( attacker->client, -FREEKILL_ALIEN, qtrue );
else if( attacker->client->ps.stats[ STAT_PTEAM ] == PTE_HUMANS )
G_AddCreditToClient( attacker->client, -FREEKILL_HUMAN, qtrue );
}
}
else
{
AddScore( attacker, 1 );
attacker->client->lastKillTime = level.time;
attacker->client->pers.statscounters.kills++;
if( attacker->client->pers.teamSelection == PTE_ALIENS )
{
level.alienStatsCounters.kills++;
}
else if( attacker->client->pers.teamSelection == PTE_HUMANS )
{
level.humanStatsCounters.kills++;
}
}
if( attacker == self )
{
attacker->client->pers.statscounters.suicides++;
if( attacker->client->pers.teamSelection == PTE_ALIENS )
{
level.alienStatsCounters.suicides++;
}
else if( attacker->client->pers.teamSelection == PTE_HUMANS )
{
level.humanStatsCounters.suicides++;
}
}
}
else if( attacker->s.eType != ET_BUILDABLE )
AddScore( self, -1 );
//total up all the damage done by every client
for( i = 0; i < MAX_CLIENTS; i++ )
totalDamage += (float)self->credits[ i ];
// if players did more than DAMAGE_FRACTION_FOR_KILL increment the stage counters
if( !OnSameTeam( self, attacker ) && totalDamage >= ( self->client->ps.stats[ STAT_MAX_HEALTH ] * DAMAGE_FRACTION_FOR_KILL ) )
{
if( self->client->ps.stats[ STAT_PTEAM ] == PTE_HUMANS )
{
trap_Cvar_Set( "g_alienKills", va( "%d", g_alienKills.integer + 1 ) );
if( g_alienStage.integer < 2 )
{
self->client->pers.statscounters.feeds++;
level.humanStatsCounters.feeds++;
}
}
else if( self->client->ps.stats[ STAT_PTEAM ] == PTE_ALIENS )
{
trap_Cvar_Set( "g_humanKills", va( "%d", g_humanKills.integer + 1 ) );
if( g_humanStage.integer < 2 )
{
self->client->pers.statscounters.feeds++;
level.alienStatsCounters.feeds++;
}
}
}
if( totalDamage > 0.0f )
{
if( self->client->ps.stats[ STAT_PTEAM ] == PTE_ALIENS )
{
//nice simple happy bouncy human land
float classValue = BG_FindValueOfClass( self->client->ps.stats[ STAT_PCLASS ] );
for( i = 0; i < MAX_CLIENTS; i++ )
{
player = g_entities + i;
if( !player->client )
continue;
if( player->client->ps.stats[ STAT_PTEAM ] != PTE_HUMANS )
continue;
if( !self->credits[ i ] )
continue;
percentDamage = (float)self->credits[ i ] / totalDamage;
if( percentDamage > 0 && percentDamage < 1)
{
player->client->pers.statscounters.assists++;
level.humanStatsCounters.assists++;
}
//add credit
G_AddCreditToClient( player->client,
(int)( classValue * percentDamage ), qtrue );
}
}
else if( self->client->ps.stats[ STAT_PTEAM ] == PTE_HUMANS )
{
//horribly complex nasty alien land
float humanValue = BG_GetValueOfHuman( &self->client->ps );
int frags;
int unclaimedFrags = (int)humanValue;
for( i = 0; i < MAX_CLIENTS; i++ )
{
player = g_entities + i;
if( !player->client )
continue;
if( player->client->ps.stats[ STAT_PTEAM ] != PTE_ALIENS )
continue;
//this client did no damage
if( !self->credits[ i ] )
continue;
//nothing left to claim
if( !unclaimedFrags )
break;
percentDamage = (float)self->credits[ i ] / totalDamage;
if( percentDamage > 0 && percentDamage < 1)
{
player->client->pers.statscounters.assists++;
level.alienStatsCounters.assists++;
}
frags = (int)floor( humanValue * percentDamage);
if( frags > 0 )
{
//add kills
G_AddCreditToClient( player->client, frags, qtrue );
//can't revist this account later
self->credits[ i ] = 0;
//reduce frags left to be claimed
unclaimedFrags -= frags;
}
}
//there are frags still to be claimed
if( unclaimedFrags )
{
//the clients remaining at this point do not
//have enough credit to claim even one frag
//so simply give the top <unclaimedFrags> clients
//a frag each
for( i = 0; i < unclaimedFrags; i++ )
{
int maximum = 0;
int topClient = 0;
for( j = 0; j < MAX_CLIENTS; j++ )
{
//this client did no damage
if( !self->credits[ j ] )
continue;
if( self->credits[ j ] > maximum )
{
maximum = self->credits[ j ];
topClient = j;
}
}
if( maximum > 0 )
{
player = g_entities + topClient;
//add kills
G_AddCreditToClient( player->client, 1, qtrue );
//can't revist this account again
self->credits[ topClient ] = 0;
}
}
}
}
}
ScoreboardMessage( self ); // show scores
// send updated scores to any clients that are following this one,
// or they would get stale scoreboards
for( i = 0 ; i < level.maxclients ; i++ )
{
gclient_t *client;
client = &level.clients[ i ];
if( client->pers.connected != CON_CONNECTED )
continue;
if( client->sess.sessionTeam != TEAM_SPECTATOR )
continue;
if( client->sess.spectatorClient == self->s.number )
ScoreboardMessage( g_entities + i );
}
VectorCopy( self->s.origin, self->client->pers.lastDeathLocation );
self->takedamage = qfalse; // can still be gibbed
self->s.weapon = WP_NONE;
self->r.contents = CONTENTS_CORPSE;
self->s.angles[ PITCH ] = 0;
self->s.angles[ ROLL ] = 0;
self->s.angles[ YAW ] = self->s.apos.trBase[ YAW ];
LookAtKiller( self, inflictor, attacker );
VectorCopy( self->s.angles, self->client->ps.viewangles );
self->s.loopSound = 0;
self->r.maxs[ 2 ] = -8;
// don't allow respawn until the death anim is done
// g_forcerespawn may force spawning at some later time
self->client->respawnTime = level.time + 1700;
// remove powerups
memset( self->client->ps.powerups, 0, sizeof( self->client->ps.powerups ) );
{
// normal death
static int i;
if( !( self->client->ps.persistant[ PERS_STATE ] & PS_NONSEGMODEL ) )
{
switch( i )
{
case 0:
anim = BOTH_DEATH1;
break;
case 1:
anim = BOTH_DEATH2;
break;
case 2:
default:
anim = BOTH_DEATH3;
break;
}
}
else
{
switch( i )
{
case 0:
anim = NSPA_DEATH1;
break;
case 1:
anim = NSPA_DEATH2;
break;
case 2:
default:
anim = NSPA_DEATH3;
break;
}
}
self->client->ps.legsAnim =
( ( self->client->ps.legsAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;
if( !( self->client->ps.persistant[ PERS_STATE ] & PS_NONSEGMODEL ) )
{
self->client->ps.torsoAnim =
( ( self->client->ps.torsoAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;
}
// use own entityid if killed by non-client to prevent uint8_t overflow
G_AddEvent( self, EV_DEATH1 + i,
( killer < MAX_CLIENTS ) ? killer : self - g_entities );
// globally cycle through the different death animations
i = ( i + 1 ) % 3;
}
trap_LinkEntity( self );
}
/*
==============
ClientThink
This will be called once for each client frame, which will
usually be a couple times for each server frame on fast clients.
If "g_synchronousClients 1" is set, this will be called exactly
once for each server frame, which makes for smooth demo recording.
==============
*/
void ClientThink_real( gentity_t *ent )
{
gclient_t *client;
pmove_t pm;
int oldEventSequence;
int msec;
usercmd_t *ucmd;
client = ent->client;
// don't think if the client is not yet connected (and thus not yet spawned in)
if( client->pers.connected != CON_CONNECTED )
return;
// mark the time, so the connection sprite can be removed
ucmd = &ent->client->pers.cmd;
// sanity check the command time to prevent speedup cheating
if( ucmd->serverTime > level.time + 200 )
{
ucmd->serverTime = level.time + 200;
// G_Printf("serverTime <<<<<\n" );
}
if( ucmd->serverTime < level.time - 1000 )
{
ucmd->serverTime = level.time - 1000;
// G_Printf("serverTime >>>>>\n" );
}
msec = ucmd->serverTime - client->ps.commandTime;
// following others may result in bad times, but we still want
// to check for follow toggles
if( msec < 1 && client->sess.spectatorState != SPECTATOR_FOLLOW )
return;
if( msec > 200 )
msec = 200;
if( pmove_msec.integer < 8 )
trap_Cvar_Set( "pmove_msec", "8" );
else if( pmove_msec.integer > 33 )
trap_Cvar_Set( "pmove_msec", "33" );
if( pmove_fixed.integer || client->pers.pmoveFixed )
{
ucmd->serverTime = ( ( ucmd->serverTime + pmove_msec.integer - 1 ) / pmove_msec.integer ) * pmove_msec.integer;
//if (ucmd->serverTime - client->ps.commandTime <= 0)
// return;
}
//
// check for exiting intermission
//
if( level.intermissiontime )
{
ClientIntermissionThink( client );
return;
}
// spectators don't do much
if( client->sess.sessionTeam == TEAM_SPECTATOR )
{
if( client->sess.spectatorState == SPECTATOR_SCOREBOARD )
return;
SpectatorThink( ent, ucmd );
return;
}
G_UpdatePTRConnection( client );
// check for inactivity timer, but never drop the local client of a non-dedicated server
if( !ClientInactivityTimer( client ) )
return;
if( client->noclip )
client->ps.pm_type = PM_NOCLIP;
else if( client->ps.stats[ STAT_HEALTH ] <= 0 )
client->ps.pm_type = PM_DEAD;
else if( client->ps.stats[ STAT_STATE ] & SS_INFESTING ||
client->ps.stats[ STAT_STATE ] & SS_HOVELING )
client->ps.pm_type = PM_FREEZE;
else if( client->ps.stats[ STAT_STATE ] & SS_BLOBLOCKED ||
client->ps.stats[ STAT_STATE ] & SS_GRABBED )
client->ps.pm_type = PM_GRABBED;
else if( BG_InventoryContainsUpgrade( UP_JETPACK, client->ps.stats ) && BG_UpgradeIsActive( UP_JETPACK, client->ps.stats ) )
client->ps.pm_type = PM_JETPACK;
else
client->ps.pm_type = PM_NORMAL;
if( client->ps.stats[ STAT_STATE ] & SS_GRABBED &&
client->grabExpiryTime < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_GRABBED;
if( client->ps.stats[ STAT_STATE ] & SS_BLOBLOCKED &&
client->lastLockTime + 5000 < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_BLOBLOCKED;
if( client->ps.stats[ STAT_STATE ] & SS_SLOWLOCKED &&
client->lastLockTime + ABUILDER_BLOB_TIME < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_SLOWLOCKED;
client->ps.stats[ STAT_BOOSTTIME ] = level.time - client->lastBoostedTime;
if( client->ps.stats[ STAT_STATE ] & SS_BOOSTED &&
client->lastBoostedTime + BOOST_TIME < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_BOOSTED;
if( client->ps.stats[ STAT_STATE ] & SS_POISONCLOUDED &&
client->lastPoisonCloudedTime + LEVEL1_PCLOUD_TIME < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_POISONCLOUDED;
if( client->ps.stats[ STAT_STATE ] & SS_POISONED &&
client->lastPoisonTime + ALIEN_POISON_TIME < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_POISONED;
client->ps.gravity = g_gravity.value;
if( BG_InventoryContainsUpgrade( UP_MEDKIT, client->ps.stats ) &&
BG_UpgradeIsActive( UP_MEDKIT, client->ps.stats ) )
{
//if currently using a medkit or have no need for a medkit now
if( client->ps.stats[ STAT_STATE ] & SS_MEDKIT_ACTIVE ||
( client->ps.stats[ STAT_HEALTH ] == client->ps.stats[ STAT_MAX_HEALTH ] &&
!( client->ps.stats[ STAT_STATE ] & SS_POISONED ) ) )
{
BG_DeactivateUpgrade( UP_MEDKIT, client->ps.stats );
}
else if( client->ps.stats[ STAT_HEALTH ] > 0 )
{
//remove anti toxin
BG_DeactivateUpgrade( UP_MEDKIT, client->ps.stats );
BG_RemoveUpgradeFromInventory( UP_MEDKIT, client->ps.stats );
client->ps.stats[ STAT_STATE ] &= ~SS_POISONED;
client->poisonImmunityTime = level.time + MEDKIT_POISON_IMMUNITY_TIME;
client->ps.stats[ STAT_STATE ] |= SS_MEDKIT_ACTIVE;
client->lastMedKitTime = level.time;
client->medKitHealthToRestore =
client->ps.stats[ STAT_MAX_HEALTH ] - client->ps.stats[ STAT_HEALTH ];
client->medKitIncrementTime = level.time +
( MEDKIT_STARTUP_TIME / MEDKIT_STARTUP_SPEED );
G_AddEvent( ent, EV_MEDKIT_USED, 0 );
}
}
if( BG_InventoryContainsUpgrade( UP_GRENADE, client->ps.stats ) &&
BG_UpgradeIsActive( UP_GRENADE, client->ps.stats ) )
{
int lastWeapon = ent->s.weapon;
//remove grenade
BG_DeactivateUpgrade( UP_GRENADE, client->ps.stats );
BG_RemoveUpgradeFromInventory( UP_GRENADE, client->ps.stats );
//M-M-M-M-MONSTER HACK
ent->s.weapon = WP_GRENADE;
FireWeapon( ent );
ent->s.weapon = lastWeapon;
}
// set speed
client->ps.speed = g_speed.value * BG_FindSpeedForClass( client->ps.stats[ STAT_PCLASS ] );
if( client->lastCreepSlowTime + CREEP_TIMEOUT < level.time )
client->ps.stats[ STAT_STATE ] &= ~SS_CREEPSLOWED;
//randomly disable the jet pack if damaged
if( BG_InventoryContainsUpgrade( UP_JETPACK, client->ps.stats ) &&
BG_UpgradeIsActive( UP_JETPACK, client->ps.stats ) )
{
if( ent->lastDamageTime + JETPACK_DISABLE_TIME > level.time )
{
if( random( ) > JETPACK_DISABLE_CHANCE )
client->ps.pm_type = PM_NORMAL;
}
//switch jetpack off if no reactor
if( !level.reactorPresent )
BG_DeactivateUpgrade( UP_JETPACK, client->ps.stats );
}
// set up for pmove
oldEventSequence = client->ps.eventSequence;
memset( &pm, 0, sizeof( pm ) );
if( !( ucmd->buttons & BUTTON_TALK ) ) //&& client->ps.weaponTime <= 0 ) //TA: erk more server load
{
switch( client->ps.weapon )
{
case WP_ALEVEL0:
if( client->ps.weaponTime <= 0 )
pm.autoWeaponHit[ client->ps.weapon ] = CheckVenomAttack( ent );
break;
case WP_ALEVEL1:
case WP_ALEVEL1_UPG:
CheckGrabAttack( ent );
break;
case WP_ALEVEL3:
case WP_ALEVEL3_UPG:
if( client->ps.weaponTime <= 0 )
pm.autoWeaponHit[ client->ps.weapon ] = CheckPounceAttack( ent );
break;
default:
break;
}
}
if( ent->flags & FL_FORCE_GESTURE )
{
ent->flags &= ~FL_FORCE_GESTURE;
ent->client->pers.cmd.buttons |= BUTTON_GESTURE;
}
pm.ps = &client->ps;
pm.cmd = *ucmd;
if( pm.ps->pm_type == PM_DEAD )
pm.tracemask = MASK_PLAYERSOLID; // & ~CONTENTS_BODY;
if( pm.ps->stats[ STAT_STATE ] & SS_INFESTING ||
pm.ps->stats[ STAT_STATE ] & SS_HOVELING )
pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
else
pm.tracemask = MASK_PLAYERSOLID;
pm.trace = trap_Trace;
pm.pointcontents = trap_PointContents;
pm.debugLevel = g_debugMove.integer;
pm.noFootsteps = (qboolean)0;
pm.pmove_fixed = pmove_fixed.integer | client->pers.pmoveFixed;
pm.pmove_msec = pmove_msec.integer;
VectorCopy( client->ps.origin, client->oldOrigin );
// moved from after Pmove -- potentially the cause of
// future triggering bugs
if( !ent->client->noclip )
G_TouchTriggers( ent );
Pmove( &pm );
// save results of pmove
if( ent->client->ps.eventSequence != oldEventSequence )
ent->eventTime = level.time;
if( g_smoothClients.integer )
BG_PlayerStateToEntityStateExtraPolate( &ent->client->ps, &ent->s, ent->client->ps.commandTime, qtrue );
else
BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, qtrue );
SendPendingPredictableEvents( &ent->client->ps );
if( !( ent->client->ps.eFlags & EF_FIRING ) )
client->fireHeld = qfalse; // for grapple
if( !( ent->client->ps.eFlags & EF_FIRING2 ) )
client->fire2Held = qfalse;
// use the snapped origin for linking so it matches client predicted versions
VectorCopy( ent->s.pos.trBase, ent->r.currentOrigin );
VectorCopy( pm.mins, ent->r.mins );
VectorCopy( pm.maxs, ent->r.maxs );
ent->waterlevel = pm.waterlevel;
ent->watertype = pm.watertype;
// execute client events
ClientEvents( ent, oldEventSequence );
// link entity now, after any personal teleporters have been used
trap_LinkEntity( ent );
// NOTE: now copy the exact origin over otherwise clients can be snapped into solid
VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
VectorCopy( ent->client->ps.origin, ent->s.origin );
// touch other objects
ClientImpacts( ent, &pm );
// save results of triggers and client events
if( ent->client->ps.eventSequence != oldEventSequence )
ent->eventTime = level.time;
// swap and latch button actions
client->oldbuttons = client->buttons;
client->buttons = ucmd->buttons;
client->latched_buttons |= client->buttons & ~client->oldbuttons;
if( ( client->buttons & BUTTON_GETFLAG ) && !( client->oldbuttons & BUTTON_GETFLAG ) &&
client->ps.stats[ STAT_HEALTH ] > 0 )
{
trace_t trace;
vec3_t view, point;
gentity_t *traceEnt;
if( client->ps.stats[ STAT_STATE ] & SS_HOVELING )
{
gentity_t *hovel = client->hovel;
//only let the player out if there is room
if( !AHovel_Blocked( hovel, ent, qtrue ) )
{
//prevent lerping
client->ps.eFlags ^= EF_TELEPORT_BIT;
client->ps.eFlags &= ~EF_NODRAW;
//client leaves hovel
client->ps.stats[ STAT_STATE ] &= ~SS_HOVELING;
//hovel is empty
G_setBuildableAnim( hovel, BANIM_ATTACK2, qfalse );
hovel->active = qfalse;
}
else
{
//exit is blocked
G_TriggerMenu( ent->client->ps.clientNum, MN_A_HOVEL_BLOCKED );
}
}
else
{
#define USE_OBJECT_RANGE 64
int entityList[ MAX_GENTITIES ];
vec3_t range = { USE_OBJECT_RANGE, USE_OBJECT_RANGE, USE_OBJECT_RANGE };
vec3_t mins, maxs;
int i, num;
//TA: look for object infront of player
AngleVectors( client->ps.viewangles, view, NULL, NULL );
VectorMA( client->ps.origin, USE_OBJECT_RANGE, view, point );
trap_Trace( &trace, client->ps.origin, NULL, NULL, point, ent->s.number, MASK_SHOT );
traceEnt = &g_entities[ trace.entityNum ];
if( traceEnt && traceEnt->biteam == client->ps.stats[ STAT_PTEAM ] && traceEnt->use )
traceEnt->use( traceEnt, ent, ent ); //other and activator are the same in this context
else
{
//no entity in front of player - do a small area search
VectorAdd( client->ps.origin, range, maxs );
VectorSubtract( client->ps.origin, range, mins );
num = trap_EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
for( i = 0; i < num; i++ )
{
traceEnt = &g_entities[ entityList[ i ] ];
if( traceEnt && traceEnt->biteam == client->ps.stats[ STAT_PTEAM ] && traceEnt->use )
{
traceEnt->use( traceEnt, ent, ent ); //other and activator are the same in this context
break;
}
}
if( i == num && client->ps.stats[ STAT_PTEAM ] == PTE_ALIENS )
{
if( BG_UpgradeClassAvailable( &client->ps ) )
{
//no nearby objects and alien - show class menu
G_TriggerMenu( ent->client->ps.clientNum, MN_A_INFEST );
}
else
{
//flash frags
G_AddEvent( ent, EV_ALIEN_EVOLVE_FAILED, 0 );
}
}
}
}
}
// check for respawning
if( client->ps.stats[ STAT_HEALTH ] <= 0 )
{
// wait for the attack button to be pressed
if( level.time > client->respawnTime )
{
// forcerespawn is to prevent users from waiting out powerups
if( g_forcerespawn.integer > 0 &&
( level.time - client->respawnTime ) > 0 )
{
respawn( ent );
return;
}
// pressing attack or use is the normal respawn method
if( ucmd->buttons & ( BUTTON_ATTACK | BUTTON_USE_HOLDABLE ) )
{
respawn( ent );
}
}
return;
}
if( level.framenum > client->retriggerArmouryMenu && client->retriggerArmouryMenu )
{
G_TriggerMenu( client->ps.clientNum, MN_H_ARMOURY );
client->retriggerArmouryMenu = 0;
}
// Give clients some credit periodically
if( ent->client->lastKillTime + FREEKILL_PERIOD < level.time )
{
if( g_suddenDeathTime.integer &&
( level.time - level.startTime >= g_suddenDeathTime.integer * 60000 ) )
{
//gotta love logic like this eh?
}
else if( ent->client->ps.stats[ STAT_PTEAM ] == PTE_ALIENS )
G_AddCreditToClient( ent->client, FREEKILL_ALIEN, qtrue );
else if( ent->client->ps.stats[ STAT_PTEAM ] == PTE_HUMANS )
G_AddCreditToClient( ent->client, FREEKILL_HUMAN, qtrue );
ent->client->lastKillTime = level.time;
}
// perform once-a-second actions
ClientTimerActions( ent, msec );
if( ent->suicideTime > 0 && ent->suicideTime < level.time )
{
ent->flags &= ~FL_GODMODE;
ent->client->ps.stats[ STAT_HEALTH ] = ent->health = 0;
player_die( ent, ent, ent, 100000, MOD_SUICIDE );
ent->suicideTime = 0;
}
}
/*
==================
G_RewardAttackers
Function to distribute rewards to entities that killed this one.
Returns the total damage dealt.
==================
*/
float G_RewardAttackers( gentity_t *self )
{
float value, totalDamage = 0;
int team, i, maxHealth = 0;
int alienCredits = 0, humanCredits = 0;
gentity_t *player;
// Total up all the damage done by non-teammates
for( i = 0; i < level.maxclients; i++ )
{
player = g_entities + i;
if( !OnSameTeam( self, player ) ||
self->buildableTeam != player->client->ps.stats[ STAT_TEAM ] )
totalDamage += (float)self->credits[ i ];
}
if( totalDamage <= 0.0f )
return 0.0f;
// Only give credits for killing players and buildables
if( self->client )
{
value = BG_GetValueOfPlayer( &self->client->ps );
team = self->client->pers.teamSelection;
maxHealth = self->client->ps.stats[ STAT_MAX_HEALTH ];
}
else if( self->s.eType == ET_BUILDABLE )
{
value = BG_Buildable( self->s.modelindex )->value;
// only give partial credits for a buildable not yet completed
if( !self->spawned )
{
value *= (float)( level.time - self->buildTime ) /
BG_Buildable( self->s.modelindex )->buildTime;
}
team = self->buildableTeam;
maxHealth = BG_Buildable( self->s.modelindex )->health;
}
else
return totalDamage;
// Give credits and empty the array
for( i = 0; i < level.maxclients; i++ )
{
int stageValue = value * self->credits[ i ] / totalDamage;
player = g_entities + i;
if( player->client->pers.teamSelection != team )
{
if( totalDamage < maxHealth )
stageValue *= totalDamage / maxHealth;
if( !self->credits[ i ] || player->client->ps.stats[ STAT_TEAM ] == team )
continue;
AddScore( player, stageValue );
// killing buildables earns score, but not credits
if( self->s.eType != ET_BUILDABLE )
{
G_AddCreditToClient( player->client, stageValue, qtrue );
// add to stage counters
if( player->client->ps.stats[ STAT_TEAM ] == TEAM_ALIENS )
alienCredits += stageValue;
else if( player->client->ps.stats[ STAT_TEAM ] == TEAM_HUMANS )
humanCredits += stageValue;
}
}
self->credits[ i ] = 0;
}
if( alienCredits )
{
trap_Cvar_Set( "g_alienCredits",
va( "%d", g_alienCredits.integer + alienCredits ) );
trap_Cvar_Update( &g_alienCredits );
}
if( humanCredits )
{
trap_Cvar_Set( "g_humanCredits",
va( "%d", g_humanCredits.integer + humanCredits ) );
trap_Cvar_Update( &g_humanCredits );
}
return totalDamage;
}
/*
==================
player_die
==================
*/
void player_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath )
{
gentity_t *ent, *ent2;
int anim;
int killer;
int i;
char *killerName, *obit;
vec3_t dir;
if( self->client->ps.pm_type == PM_DEAD )
return;
if( level.intermissiontime )
return;
self->client->ps.pm_type = PM_DEAD;
self->suicideTime = 0;
if( attacker )
{
killer = attacker->s.number;
if( attacker->client )
killerName = attacker->client->pers.netname;
else
killerName = "<world>";
}
else
{
killer = ENTITYNUM_WORLD;
killerName = "<world>";
}
if( meansOfDeath < 0 || meansOfDeath >= sizeof( modNames ) / sizeof( modNames[0] ) )
// fall back on the number
obit = va( "%d", meansOfDeath );
else
obit = modNames[ meansOfDeath ];
G_LogPrintf( "Die: %d %d %s: %s" S_COLOR_WHITE " killed %s\n",
killer,
self - g_entities,
obit,
killerName,
self->client->pers.netname );
// deactivate all upgrades
for( i = UP_NONE + 1; i < UP_NUM_UPGRADES; i++ )
BG_DeactivateUpgrade( i, self->client->ps.stats );
// kill all player's buildables if they havent spawned yet
// this should eliminate build timer hacks for ever
dir[0] = dir[1] = 0.0f;
dir[2] = 1.0f;
for( i = MAX_CLIENTS, ent = g_entities + i; i < level.num_entities; i++, ent++ )
{
if( ent->s.eType != ET_BUILDABLE )
continue;
if( ent == self )
continue;
if( ent->spawned )
continue;
if( ent->builtBy != self->client->ps.clientNum )
continue;
G_Damage( ent, self, attacker, dir, dir, ent->health, 0, MOD_DECONSTRUCT );
}
// broadcast the death event to everyone
ent = G_TempEntity( self->r.currentOrigin, EV_OBITUARY );
ent->s.eventParm = meansOfDeath;
ent->s.otherEntityNum = self->s.number;
ent->s.otherEntityNum2 = killer;
ent->r.svFlags = SVF_BROADCAST; // send to everyone
self->enemy = attacker;
self->client->ps.persistant[ PERS_KILLED ]++;
if( attacker && attacker->client )
{
attacker->client->lastkilled_client = self->s.number;
if( ( attacker == self || OnSameTeam( self, attacker ) ) && meansOfDeath != MOD_HSPAWN )
{
//punish team kills and suicides
if( attacker->client->ps.stats[ STAT_TEAM ] == TEAM_ALIENS )
{
G_AddCreditToClient( attacker->client, -ALIEN_TK_SUICIDE_PENALTY, qtrue );
AddScore( attacker, -ALIEN_TK_SUICIDE_PENALTY );
}
else if( attacker->client->ps.stats[ STAT_TEAM ] == TEAM_HUMANS )
{
G_AddCreditToClient( attacker->client, -HUMAN_TK_SUICIDE_PENALTY, qtrue );
AddScore( attacker, -HUMAN_TK_SUICIDE_PENALTY );
}
}
}
else if( attacker->s.eType != ET_BUILDABLE )
{
if( self->client->ps.stats[ STAT_TEAM ] == TEAM_ALIENS )
AddScore( self, -ALIEN_TK_SUICIDE_PENALTY );
else if( self->client->ps.stats[ STAT_TEAM ] == TEAM_HUMANS )
AddScore( self, -HUMAN_TK_SUICIDE_PENALTY );
}
// give credits for killing this player
G_RewardAttackers( self );
ScoreboardMessage( self ); // show scores
// send updated scores to any clients that are following this one,
// or they would get stale scoreboards
for( i = 0 ; i < level.maxclients ; i++ )
{
gclient_t *client;
client = &level.clients[ i ];
if( client->pers.connected != CON_CONNECTED )
continue;
if( client->sess.spectatorState == SPECTATOR_NOT )
continue;
if( client->sess.spectatorClient == self->s.number )
ScoreboardMessage( g_entities + i );
}
VectorCopy( self->s.origin, self->client->pers.lastDeathLocation );
self->takedamage = qfalse; // can still be gibbed
self->s.weapon = WP_NONE;
self->r.contents = CONTENTS_CORPSE;
self->s.angles[ PITCH ] = 0;
self->s.angles[ ROLL ] = 0;
self->s.angles[ YAW ] = self->s.apos.trBase[ YAW ];
if( meansOfDeath != MOD_ALIEN_HATCH ) //don't look at the alien that jumped out of your chest, it screws up the camera
LookAtKiller( self, inflictor, attacker );
VectorCopy( self->s.angles, self->client->ps.viewangles );
self->s.loopSound = 0;
self->r.maxs[ 2 ] = -8;
// don't allow respawn until the death anim is done
// g_forcerespawn may force spawning at some later time
self->client->respawnTime = level.time + 1700;
// clear misc
memset( self->client->ps.misc, 0, sizeof( self->client->ps.misc ) );
{
// normal death
static int i;
if( !( self->client->ps.persistant[ PERS_STATE ] & PS_NONSEGMODEL ) )
{
switch( i )
{
case 0:
anim = BOTH_DEATH1;
break;
case 1:
anim = BOTH_DEATH2;
break;
case 2:
default:
anim = BOTH_DEATH3;
break;
}
}
else
{
switch( i )
{
case 0:
anim = NSPA_DEATH1;
break;
case 1:
anim = NSPA_DEATH2;
break;
case 2:
default:
anim = NSPA_DEATH3;
break;
}
}
self->client->ps.legsAnim =
( ( self->client->ps.legsAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;
if( !( self->client->ps.persistant[ PERS_STATE ] & PS_NONSEGMODEL ) )
{
self->client->ps.torsoAnim =
( ( self->client->ps.torsoAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;
}
// use own entityid if killed by non-client to prevent uint8_t overflow
G_AddEvent( self, EV_DEATH1 + i,
( killer < MAX_CLIENTS ) ? killer : self - g_entities );
// globally cycle through the different death animations
i = ( i + 1 ) % 3;
}
trap_LinkEntity( self );
}
/*
===========
ClientSpawn
Called every time a client is placed fresh in the world:
after the first ClientBegin, and after each respawn
Initializes all non-persistant parts of playerState
============
*/
void ClientSpawn( gentity_t *ent, gentity_t *spawn, vec3_t origin, vec3_t angles )
{
int index;
vec3_t spawn_origin, spawn_angles;
gclient_t *client;
int i;
clientPersistant_t saved;
clientSession_t savedSess;
int persistant[ MAX_PERSISTANT ];
gentity_t *spawnPoint = NULL, *event;
int flags;
int savedPing;
int teamLocal;
int eventSequence;
char userinfo[ MAX_INFO_STRING ];
vec3_t up = { 0.0f, 0.0f, 1.0f }, implant_dir, implant_angles, spawnPoint_velocity;
int maxAmmo, maxClips;
weapon_t weapon;
qboolean fromImplant = qfalse, hatchingFailed = qfalse;
index = ent - g_entities;
client = ent->client;
teamLocal = client->pers.teamSelection;
//if client is dead and following teammate, stop following before spawning
if( client->sess.spectatorClient != -1 )
{
client->sess.spectatorClient = -1;
client->sess.spectatorState = SPECTATOR_FREE;
}
// only start client if chosen a class and joined a team
if( client->pers.classSelection == PCL_NONE && teamLocal == TEAM_NONE )
client->sess.spectatorState = SPECTATOR_FREE;
else if( client->pers.classSelection == PCL_NONE )
client->sess.spectatorState = SPECTATOR_LOCKED;
// if client is dead and following teammate, stop following before spawning
if( ent->client->sess.spectatorState == SPECTATOR_FOLLOW )
G_StopFollowing( ent );
if( origin != NULL )
VectorCopy( origin, spawn_origin );
if( angles != NULL )
VectorCopy( angles, spawn_angles );
// find a spawn point
// do it before setting health back up, so farthest
// ranging doesn't count this client
if( client->sess.spectatorState != SPECTATOR_NOT )
{
if( teamLocal == TEAM_NONE )
spawnPoint = G_SelectSpectatorSpawnPoint( spawn_origin, spawn_angles );
else if( teamLocal == TEAM_ALIENS )
spawnPoint = G_SelectAlienLockSpawnPoint( spawn_origin, spawn_angles );
else if( teamLocal == TEAM_HUMANS )
spawnPoint = G_SelectHumanLockSpawnPoint( spawn_origin, spawn_angles );
}
else
{
if( spawn == NULL )
{
G_Error( "ClientSpawn: spawn is NULL\n" );
return;
}
spawnPoint = spawn;
if( ent != spawn )
{
if( !spawnPoint->client ) //might be a human
{
//start spawn animation on spawnPoint
G_SetBuildableAnim( spawnPoint, BANIM_SPAWN1, qtrue );
if( spawnPoint->buildableTeam == TEAM_ALIENS )
spawnPoint->clientSpawnTime = ALIEN_SPAWN_REPEAT_TIME;
else if( spawnPoint->buildableTeam == TEAM_HUMANS )
spawnPoint->clientSpawnTime = HUMAN_SPAWN_REPEAT_TIME;
}
else
{
qboolean crouch;
int i;
float zoffs = 0.0f;
trace_t tr;
vec3_t neworigin, mins, maxs;
fromImplant = qtrue; //spawning from a human
// move the origin a bit on the Z axis so the aliens jumps out of the chest, not knees
// also prevents grangers from getting stuck in ceilings and floors
crouch = spawnPoint->client->ps.pm_flags & PMF_DUCKED;
switch( client->pers.classSelection )
{
case PCL_ALIEN_BUILDER0:
if( !crouch )
zoffs = 19.0f;
else
zoffs = -4.0f;
break;
case PCL_ALIEN_BUILDER0_UPG:
if( !crouch )
zoffs = 16.5f;
else
zoffs = -4.0f;
break;
case PCL_ALIEN_LEVEL0:
if( !crouch )
zoffs = 15.0f;
else
zoffs = -9.1f;
break;
}
spawn_origin[ 2 ] += zoffs;
// check if the spot would block
BG_ClassBoundingBox( client->pers.classSelection, mins, maxs, NULL, NULL, NULL );
trap_Trace( &tr, spawn_origin, mins, maxs, spawn_origin, spawnPoint->s.number, MASK_PLAYERSOLID );
// try to unblock the player
if( tr.startsolid )
{
Com_Printf("DEBUG: player is stuck!\n");
for( i = 0; i < 16*2; i++ )
{
float a, r;
VectorCopy( spawn_origin, neworigin );
a = (float)i / 16.0f * 2.0f * M_PI;
#define fmod(a,n) ((a)-(n)*floor((a)/(n)))
r = ( i < 16 ? 5.5f : 11.0f ) * 1.0f / cos( fmod( a+0.25f*M_PI, 0.5f*M_PI ) - 0.25f*M_PI );
neworigin[ 0 ] += cos( a ) * r;
neworigin[ 1 ] += sin( a ) * r;
trap_Trace( &tr, neworigin, mins, maxs, neworigin, spawnPoint->s.number, MASK_PLAYERSOLID );
if( !tr.startsolid )
{
Com_Printf("DEBUG: player position fixed at iteration %i\n",i);
VectorCopy( neworigin, spawn_origin );
break;
}
}
}
//reward the player that implanted this one
if( spawnPoint->client->impregnatedBy >= 0 )
{
gentity_t *granger;
granger = &g_entities[ spawnPoint->client->impregnatedBy ];
G_AddCreditToClient( granger->client, ALIEN_IMPREGNATION_REWARD, qtrue );
AddScore( granger, ALIEN_IMPREGNATION_REWARD_SCORE );
}
// kill the human, set up angles and velocity for the new alien
if( !BG_InventoryContainsUpgrade( UP_BATTLESUIT, spawnPoint->client->ps.stats ) //humans without battlesuits always die
|| spawnPoint->client->ps.stats[ STAT_HEALTH ] < ALIEN_HATCHING_MAX_BATTLESUIT_HEALTH ) //battlesuits survive if high hp
{
//save viewangles and spawn velocity for velocity calculation
VectorCopy( spawnPoint->client->ps.viewangles, implant_angles );
AngleVectors( implant_angles, implant_dir, NULL, NULL );
VectorCopy( spawnPoint->client->ps.velocity, spawnPoint_velocity );
//fire a nice chest exploding effect
event = G_TempEntity( spawnPoint->s.pos.trBase, EV_ALIEN_HATCH );
VectorCopy( implant_dir, event->s.angles );
//kill the player
G_Damage( spawnPoint, NULL, ent, NULL, NULL, spawnPoint->client->ps.stats[ STAT_HEALTH ], DAMAGE_NO_ARMOR, MOD_ALIEN_HATCH );
}
else //human survives
{
//clear impregnation so the human won't explode again
spawnPoint->client->isImpregnated = qfalse;
spawnPoint->client->isImplantMature = qfalse;
//make a sound
event = G_TempEntity( spawnPoint->s.pos.trBase, EV_ALIEN_HATCH_FAILURE );
//damage the human
G_Damage( spawnPoint, NULL, ent, NULL, NULL, ALIEN_FAILED_HATCH_DAMAGE, DAMAGE_NO_ARMOR, MOD_ALIEN_HATCH );
//kill the newly spawned alien
VectorCopy( spawnPoint->client->ps.viewangles, implant_angles );
implant_dir[0] = 0.0f;
implant_dir[1] = 0.0f;
implant_dir[2] = 0.0f;
hatchingFailed = qtrue;
}
}
}
}
// toggle the teleport bit so the client knows to not lerp
flags = ( ent->client->ps.eFlags & EF_TELEPORT_BIT ) ^ EF_TELEPORT_BIT;
G_UnlaggedClear( ent );
// clear everything but the persistant data
saved = client->pers;
savedSess = client->sess;
savedPing = client->ps.ping;
for( i = 0; i < MAX_PERSISTANT; i++ )
persistant[ i ] = client->ps.persistant[ i ];
eventSequence = client->ps.eventSequence;
memset( client, 0, sizeof( *client ) );
client->pers = saved;
client->sess = savedSess;
client->ps.ping = savedPing;
client->lastkilled_client = -1;
for( i = 0; i < MAX_PERSISTANT; i++ )
client->ps.persistant[ i ] = persistant[ i ];
client->ps.eventSequence = eventSequence;
// increment the spawncount so the client will detect the respawn
client->ps.persistant[ PERS_SPAWN_COUNT ]++;
client->ps.persistant[ PERS_SPECSTATE ] = client->sess.spectatorState;
client->airOutTime = level.time + 12000;
trap_GetUserinfo( index, userinfo, sizeof( userinfo ) );
client->ps.eFlags = flags;
//Com_Printf( "ent->client->pers->pclass = %i\n", ent->client->pers.classSelection );
ent->s.groundEntityNum = ENTITYNUM_NONE;
ent->client = &level.clients[ index ];
ent->takedamage = qtrue;
ent->inuse = qtrue;
ent->classname = "player";
ent->r.contents = CONTENTS_BODY;
ent->clipmask = MASK_PLAYERSOLID;
ent->die = player_die;
ent->waterlevel = 0;
ent->watertype = 0;
ent->flags = 0;
// calculate each client's acceleration
ent->evaluateAcceleration = qtrue;
client->ps.stats[ STAT_MISC ] = 0;
client->buildTimer = 0;
client->ps.eFlags = flags;
client->ps.clientNum = index;
BG_ClassBoundingBox( ent->client->pers.classSelection, ent->r.mins, ent->r.maxs, NULL, NULL, NULL );
if( client->sess.spectatorState == SPECTATOR_NOT )
client->ps.stats[ STAT_MAX_HEALTH ] =
BG_Class( ent->client->pers.classSelection )->health;
else
client->ps.stats[ STAT_MAX_HEALTH ] = 100;
// clear entity values
if( ent->client->pers.classSelection == PCL_HUMAN )
{
BG_AddUpgradeToInventory( UP_MEDKIT, client->ps.stats );
weapon = client->pers.humanItemSelection;
}
else if( client->sess.spectatorState == SPECTATOR_NOT )
weapon = BG_Class( ent->client->pers.classSelection )->startWeapon;
else
weapon = WP_NONE;
maxAmmo = BG_Weapon( weapon )->maxAmmo;
maxClips = BG_Weapon( weapon )->maxClips;
client->ps.stats[ STAT_WEAPON ] = weapon;
client->ps.ammo = maxAmmo;
client->ps.clips = maxClips;
// We just spawned, not changing weapons
client->ps.persistant[ PERS_NEWWEAPON ] = 0;
ent->client->ps.stats[ STAT_CLASS ] = ent->client->pers.classSelection;
ent->client->ps.stats[ STAT_TEAM ] = ent->client->pers.teamSelection;
ent->client->ps.stats[ STAT_BUILDABLE ] = BA_NONE;
ent->client->ps.stats[ STAT_STATE ] = 0;
VectorSet( ent->client->ps.grapplePoint, 0.0f, 0.0f, 1.0f );
// health will count down towards max_health
ent->health = client->ps.stats[ STAT_HEALTH ] = client->ps.stats[ STAT_MAX_HEALTH ]; //* 1.25;
//if evolving scale health
if( ent == spawn )
{
ent->health *= ent->client->pers.evolveHealthFraction;
client->ps.stats[ STAT_HEALTH ] *= ent->client->pers.evolveHealthFraction;
}
//clear the credits array
for( i = 0; i < MAX_CLIENTS; i++ )
ent->credits[ i ] = 0;
client->ps.stats[ STAT_STAMINA ] = STAMINA_MAX;
//never impregnated after respawning
client->isImpregnated = qfalse;
client->isImplantMature = qfalse;
G_SetOrigin( ent, spawn_origin );
VectorCopy( spawn_origin, client->ps.origin );
#define UP_VEL 150.0f
#define F_VEL 50.0f
//give aliens some spawn velocity
if( client->sess.spectatorState == SPECTATOR_NOT &&
client->ps.stats[ STAT_TEAM ] == TEAM_ALIENS )
{
if( ent == spawn )
{
//evolution particle system
G_AddPredictableEvent( ent, EV_ALIEN_EVOLVE, DirToByte( up ) );
}
else if( !fromImplant ) //regular egg
{
spawn_angles[ YAW ] += 180.0f;
AngleNormalize360( spawn_angles[ YAW ] );
if( spawnPoint->s.origin2[ 2 ] > 0.0f )
{
vec3_t forward, dir;
AngleVectors( spawn_angles, forward, NULL, NULL );
VectorScale( forward, F_VEL, forward );
VectorAdd( spawnPoint->s.origin2, forward, dir );
VectorNormalize( dir );
VectorScale( dir, UP_VEL, client->ps.velocity );
}
G_AddPredictableEvent( ent, EV_PLAYER_RESPAWN, 0 );
}
else //implanted egg
{
VectorCopy( implant_angles, spawn_angles );
VectorScale( implant_dir, ALIEN_HATCHING_VELOCITY, client->ps.velocity );
VectorAdd( client->ps.velocity, spawnPoint_velocity, client->ps.velocity );
}
}
else if( client->sess.spectatorState == SPECTATOR_NOT &&
client->ps.stats[ STAT_TEAM ] == TEAM_HUMANS )
{
spawn_angles[ YAW ] += 180.0f;
AngleNormalize360( spawn_angles[ YAW ] );
}
// the respawned flag will be cleared after the attack and jump keys come up
client->ps.pm_flags |= PMF_RESPAWNED;
trap_GetUsercmd( client - level.clients, &ent->client->pers.cmd );
G_SetClientViewAngle( ent, spawn_angles );
if( client->sess.spectatorState == SPECTATOR_NOT )
{
trap_LinkEntity( ent );
// force the base weapon up
if( client->pers.teamSelection == TEAM_HUMANS )
G_ForceWeaponChange( ent, weapon );
client->ps.weaponstate = WEAPON_READY;
}
// don't allow full run speed for a bit
client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
client->ps.pm_time = 100;
client->respawnTime = level.time;
ent->nextRegenTime = level.time;
client->inactivityTime = level.time + g_inactivity.integer * 1000;
client->latched_buttons = 0;
// set default animations
client->ps.torsoAnim = TORSO_STAND;
client->ps.legsAnim = LEGS_IDLE;
if( level.intermissiontime )
MoveClientToIntermission( ent );
else
{
// fire the targets of the spawn point
if( !spawn )
G_UseTargets( spawnPoint, ent );
// select the highest weapon number available, after any
// spawn given items have fired
client->ps.weapon = 1;
for( i = WP_NUM_WEAPONS - 1; i > 0 ; i-- )
{
if( BG_InventoryContainsWeapon( i, client->ps.stats ) )
{
client->ps.weapon = i;
break;
}
}
}
client->lastRantBombTime = level.time;
// run a client frame to drop exactly to the floor,
// initialize animations and other things
client->ps.commandTime = level.time - 100;
ent->client->pers.cmd.serverTime = level.time;
ClientThink( ent-g_entities );
// positively link the client, even if the command times are weird
if( client->sess.spectatorState == SPECTATOR_NOT )
{
BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
trap_LinkEntity( ent );
}
// must do this here so the number of active clients is calculated
CalculateRanks( );
// run the presend to set anything else
ClientEndFrame( ent );
// clear entity state values
BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
// kill him instantly after respawning if hatching failed
if( fromImplant && hatchingFailed )
{
VectorCopy( spawnPoint->client->ps.velocity, client->ps.velocity );
client->ps.stats[ STAT_HEALTH ] = ent->health = 0;
player_die( ent, NULL, spawnPoint, 0, MOD_ALIEN_HATCH_FAILED );
}
}
/**
* Execute a command related to bots
* @param master [gentity_t] player who executed the command
* @param clientNum [int] bot client id
* @param command [string] :
* - regular , idle , standground, followattack, etc. (change bot mode)
* - kill (kill the bot)
* - give (fund a bot)
* @param value [int] give value (for aliens 500 is about 1 evo)
*
* //TODO: bot modes will be removed
*/
void G_BotCmd( int clientNum, char *command, int value, int value2 ) {
gentity_t *ent;
ent = &g_entities[clientNum];
if( !( ent->r.svFlags & SVF_BOT ) ) {
return;
}
if( !Q_stricmp( command, "give" ) ) { //LEPE: give money/evos to ent
G_AddCreditToClient( ent->client, (short)value, qfalse );
} else if( !Q_stricmp( command, "kill" ) ) { //LEPE: kill ent
ent->client->ps.stats[ STAT_HEALTH ] = ent->health = 0;
player_die( ent, ent, ent, 10000, MOD_SUICIDE );
} else if( !Q_stricmp( command, "state" ) ) { //LEPE: change bot state. Requires g_bot_manual = 1
if(g_bot_manual.integer) {
ent->bot->think.state[ THINK_LEVEL_MAX ] = value;
}
} else if( !Q_stricmp( command, "nav" ) ) { //LEPE: change bot state. Requires g_bot_manual_nav = 1
if(g_bot_manual_nav.integer) {
ent->bot->path.state = value;
}
} else if( !Q_stricmp( command, "move" ) ) { //LEPE: move bot manually. Requires g_bot_manual = 1
if(g_bot_manual.integer) {
if(value > BOT_EMPTY_MOVE && value <= BOT_STOP) {
BotAddMove( ent, (botMove)value, value2 );
BotStartMove( ent, BOT_EMPTY_MOVE );
} else {
switch(value) {
case 50: BotControl( ent , BOT_LOOK_UP); break;
case 51: BotControl( ent , BOT_LOOK_DOWN); break;
case 52: BotControl( ent , BOT_LOOK_LEFT); break;
case 53: BotControl( ent , BOT_LOOK_RIGHT); break;
case 54: BotControl( ent , BOT_LOOK_RANDOM); break;
case 60: Bot_Strafe( ent ); break;
case 61: Bot_Pounce( ent, value2 ); break;
case 62: Bot_FullLuci( ent ); break;
default:
ADMP("unknown move value\n");
break;
}
}
}
} else if( !Q_stricmp( command, "moveto" ) ) {
if(g_bot_manual.integer) {
BotMoveToPoint( ent , level.paths[value].coord );
G_Printf("MoveTo %d\n",value);
ADMP(va("Moving to node %d\n", value));
}
} else {
ADMP("unknown bot command\n");
}
return;
}
