void respawn (edict_t *self)
{
if (deathmatch->value || coop->value)
{
// spectator's don't leave bodies
if (self->movetype != MOVETYPE_NOCLIP)
CopyToBodyQue (self);
self->svflags &= ~SVF_NOCLIENT;
PutClientInServer (self);
// add a teleportation effect
self->s.event = EV_PLAYER_TELEPORT;
// hold in place briefly
self->client->ps.pmove.pm_flags = PMF_TIME_TELEPORT;
self->client->ps.pmove.pm_time = 14;
self->client->respawn_time = level.time;
return;
}
// restart the entire server
gi.AddCommandString ("menu_loadgame\n");
}
void respawn (edict_t *self)
{
if (deathmatch->value || coop->value)
{
#ifdef WITH_ACEBOT
// ACEBOT_ADD special respawning code
if (self->is_bot)
{
ACESP_Respawn (self);
return;
}
// ACEBOT_END
#endif
CopyToBodyQue (self);
PutClientInServer (self);
// add a teleportation effect
self->s.event = EV_PLAYER_TELEPORT;
// hold in place briefly
self->client->ps.pmove.pm_flags = PMF_TIME_TELEPORT;
self->client->ps.pmove.pm_time = 14;
self->client->respawn_time = level.time;
return;
}
// restart the entire server
gi.AddCommandString ("menu_loadgame\n");
}
/*
================
respawn
================
*/
void respawn( gentity_t *ent ) {
gentity_t *tent;
CopyToBodyQue (ent);
ClientSpawn(ent);
// add a teleportation effect
tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_IN );
tent->s.clientNum = ent->s.clientNum;
}
/*
================
respawn
================
*/
void respawn( gentity_t *ent ) {
gentity_t *tent;
//kick fragged bots from game
if (IsBot(ent->client->ps.clientNum) ) {
trap_DropClient( ent->client->ps.clientNum, "" );
G_EndWave(); //check if the wave was won and handle it
return;
}
CopyToBodyQue (ent);
ClientSpawn(ent);
// add a teleportation effect
tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_IN );
tent->s.clientNum = ent->s.clientNum;
}
// called by ClientKill and DeadThink
void respawn(entvars_t* pev, BOOL fCopyCorpse)
{
if (gpGlobals->coop || gpGlobals->deathmatch)
{
if ( fCopyCorpse )
{
// make a copy of the dead body for appearances sake
CopyToBodyQue(pev);
}
// respawn player
GetClassPtr( (CBasePlayer *)pev)->Spawn( );
}
else
{ // restart the entire server
SERVER_COMMAND("reload\n");
}
}
///////////////////////////////////////////////////////////////////////
// Respawn the bot
///////////////////////////////////////////////////////////////////////
void BOT_Respawn (edict_t *self)
{
CopyToBodyQue (self);
PutClientInServer (self);
// add a teleportation effect
self->s.event = EV_PLAYER_TELEPORT;
// hold in place briefly
self->client->ps.pmove.pm_flags = PMF_TIME_TELEPORT;
self->client->ps.pmove.pm_time = 14;
self->client->respawn_time = level.time;
AI_ResetWeights(self);
AI_ResetNavigation(self);
}
///////////////////////////////////////////////////////////////////////
// Respawn the bot
///////////////////////////////////////////////////////////////////////
void ACESP_Respawn(edict_t *self)
{
CopyToBodyQue (self);
if (ctf->value)
ACESP_PutClientInServer (self,true, self->client->resp.ctf_team);
else
ACESP_PutClientInServer (self,true,0);
// add a teleportation effect
self->s.event = EV_PLAYER_TELEPORT;
// hold in place briefly
self->client->ps.pmove.pm_flags = PMF_TIME_TELEPORT;
self->client->ps.pmove.pm_time = 14;
self->client->respawn_time = level.time;
}
void respawn (edict_t *self)
{
if (deathmatch->value || coop->value)
{
CopyToBodyQue (self);
PutClientInServer (self);
// add a teleportation effect
self->s.event = EV_PLAYER_TELEPORT;
// hold in place briefly
self->client->ps.pmove.pm_flags = PMF_TIME_TELEPORT;
self->client->ps.pmove.pm_time = 14;
self->client->respawn_time = level.time;
return;
}
// restart the entire server
gi.AddCommandString ("menu_loadgame\n");
}
/*
* player_die
*/
void player_die( edict_t *ent, edict_t *inflictor, edict_t *attacker, int damage, const vec3_t point )
{
snap_edict_t snap_backup = ent->snap;
client_snapreset_t resp_snap_backup = ent->r.client->resp.snap;
VectorClear( ent->avelocity );
ent->s.angles[0] = 0;
ent->s.angles[2] = 0;
ent->s.sound = 0;
ent->r.solid = SOLID_NOT;
ent->r.client->teamstate.last_killer = attacker;
// player death
ent->s.angles[YAW] = ent->r.client->ps.viewangles[YAW] = LookAtKillerYAW( ent, inflictor, attacker );
ClientObituary( ent, inflictor, attacker );
// create a body
CopyToBodyQue( ent, attacker, damage );
ent->enemy = NULL;
// clear his combo stats
G_AwardResetPlayerComboStats( ent );
// go ghost (also resets snap)
G_GhostClient( ent );
ent->deathTimeStamp = level.time;
VectorClear( ent->velocity );
VectorClear( ent->avelocity );
ent->snap = snap_backup;
ent->r.client->resp.snap = resp_snap_backup;
ent->r.client->resp.snap.buttons = 0;
GClip_LinkEntity( ent );
}
/*
================
ClientRespawn
================
*/
void ClientRespawn( gentity_t *ent ) {
CopyToBodyQue (ent);
ClientSpawn(ent);
}
/*
=================
SetTeam
=================
*/
void SetTeam( gentity_t *ent, char *s ) {
int team, oldTeam;
gclient_t *client;
int clientNum;
spectatorState_t specState;
int specClient;
int teamLeader;
//
// see what change is requested
//
client = ent->client;
clientNum = client - level.clients;
specClient = 0;
specState = SPECTATOR_NOT;
if ( !Q_stricmp( s, "scoreboard" ) || !Q_stricmp( s, "score" ) ) {
team = TEAM_SPECTATOR;
specState = SPECTATOR_SCOREBOARD;
} else if ( !Q_stricmp( s, "follow1" ) ) {
team = TEAM_SPECTATOR;
specState = SPECTATOR_FOLLOW;
specClient = -1;
} else if ( !Q_stricmp( s, "follow2" ) ) {
team = TEAM_SPECTATOR;
specState = SPECTATOR_FOLLOW;
specClient = -2;
} else if ( !Q_stricmp( s, "spectator" ) || !Q_stricmp( s, "s" ) ) {
team = TEAM_SPECTATOR;
specState = SPECTATOR_FREE;
} else if ( g_gametype.integer >= GT_TEAM ) {
// if running a team game, assign player to one of the teams
specState = SPECTATOR_NOT;
if ( !Q_stricmp( s, "red" ) || !Q_stricmp( s, "r" ) ) {
team = TEAM_RED;
} else if ( !Q_stricmp( s, "blue" ) || !Q_stricmp( s, "b" ) ) {
team = TEAM_BLUE;
} else {
// pick the team with the least number of players
team = PickTeam( clientNum );
}
if ( g_teamForceBalance.integer ) {
int counts[TEAM_NUM_TEAMS];
counts[TEAM_BLUE] = TeamCount( clientNum, TEAM_BLUE );
counts[TEAM_RED] = TeamCount( clientNum, TEAM_RED );
// We allow a spread of two
if ( team == TEAM_RED && counts[TEAM_RED] - counts[TEAM_BLUE] > 1 ) {
trap_SendServerCommand( clientNum,
"cp \"Red team has too many players.\n\"" );
return; // ignore the request
}
if ( team == TEAM_BLUE && counts[TEAM_BLUE] - counts[TEAM_RED] > 1 ) {
trap_SendServerCommand( clientNum,
"cp \"Blue team has too many players.\n\"" );
return; // ignore the request
}
// It's ok, the team we are switching to has less or same number of players
}
} else {
// force them to spectators if there aren't any spots free
team = TEAM_FREE;
}
// override decision if limiting the players
if ( (g_gametype.integer == GT_TOURNAMENT)
&& level.numNonSpectatorClients >= 2 ) {
team = TEAM_SPECTATOR;
} else if ( g_maxGameClients.integer > 0 &&
level.numNonSpectatorClients >= g_maxGameClients.integer ) {
team = TEAM_SPECTATOR;
}
//
// decide if we will allow the change
//
oldTeam = client->sess.sessionTeam;
if ( team == oldTeam && team != TEAM_SPECTATOR ) {
return;
}
//
// execute the team change
//
// if the player was dead leave the body
if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
CopyToBodyQue(ent);
}
// he starts at 'base'
client->pers.teamState.state = TEAM_BEGIN;
if ( oldTeam != TEAM_SPECTATOR ) {
// Kill him (makes sure he loses flags, etc)
ent->flags &= ~FL_GODMODE;
ent->client->ps.stats[STAT_HEALTH] = ent->health = 0;
player_die (ent, ent, ent, 100000, MOD_SUICIDE);
}
// they go to the end of the line for tournements
if(team == TEAM_SPECTATOR && oldTeam != team)
AddTournamentQueue(client);
client->sess.sessionTeam = team;
client->sess.spectatorState = specState;
client->sess.spectatorClient = specClient;
client->sess.teamLeader = qfalse;
if ( team == TEAM_RED || team == TEAM_BLUE ) {
teamLeader = TeamLeader( team );
// if there is no team leader or the team leader is a bot and this client is not a bot
if ( teamLeader == -1 || ( !(g_entities[clientNum].r.svFlags & SVF_BOT) && (g_entities[teamLeader].r.svFlags & SVF_BOT) ) ) {
SetLeader( team, clientNum );
}
}
// make sure there is a team leader on the team the player came from
if ( oldTeam == TEAM_RED || oldTeam == TEAM_BLUE ) {
CheckTeamLeader( oldTeam );
}
BroadcastTeamChange( client, oldTeam );
// get and distribute relevent paramters
ClientUserinfoChanged( clientNum );
ClientBegin( clientNum );
}
/*
================
PlayerRespawn
================
*/
void PlayerRespawn( gentity_t *ent ) {
CopyToBodyQue (ent);
PlayerSpawn(ent);
}
void SetTeam( gentity_t *ent, char *s ) {
int clientNum, specClient=0;
team_t team, oldTeam;
gclient_t *client = ent->client;
spectatorState_t specState = SPECTATOR_NOT;
// see what change is requested
clientNum = ARRAY_INDEX( level.clients, client );
if ( !Q_stricmp( s, "scoreboard" ) || !Q_stricmp( s, "score" ) ) {
team = TEAM_SPECTATOR;
specState = SPECTATOR_SCOREBOARD;
}
else if ( !Q_stricmp( s, "follow1" ) ) {
team = TEAM_SPECTATOR;
specState = SPECTATOR_FOLLOW;
specClient = -1;
}
else if ( !Q_stricmp( s, "follow2" ) ) {
team = TEAM_SPECTATOR;
specState = SPECTATOR_FOLLOW;
specClient = -2;
}
else if ( !Q_stricmp( s, "spectator" ) || !Q_stricmp( s, "s" ) ) {
team = TEAM_SPECTATOR;
specState = SPECTATOR_FREE;
}
// if running a team game, assign player to one of the teams
else if ( level.gametype >= GT_TEAMBLOOD ) {
specState = SPECTATOR_NOT;
if ( !Q_stricmp( s, "red" ) || !Q_stricmp( s, "r" ) )
team = TEAM_RED;
else if ( !Q_stricmp( s, "blue" ) || !Q_stricmp( s, "b" ) )
team = TEAM_BLUE;
else
team = PickTeam( clientNum ); // pick the team with the least number of players
if ( g_teamForceBalance->integer ) {
int counts[TEAM_NUM_TEAMS];
counts[TEAM_BLUE] = TeamCount( clientNum, TEAM_BLUE );
counts[TEAM_RED] = TeamCount( clientNum, TEAM_RED );
// We allow a spread of two
if ( team == TEAM_RED && counts[TEAM_RED] - counts[TEAM_BLUE] > 1 ) {
trap->SV_GameSendServerCommand( clientNum, "cp \"Red team has too many players.\n\"" );
return; // ignore the request
}
if ( team == TEAM_BLUE && counts[TEAM_BLUE] - counts[TEAM_RED] > 1 ) {
trap->SV_GameSendServerCommand( clientNum, "cp \"Blue team has too many players.\n\"" );
return; // ignore the request
}
// It's ok, the team we are switching to has less or same number of players
}
}
else
team = TEAM_FREE; // force them to spectators if there aren't any spots free
// override decision if limiting the players
if ( (level.gametype == GT_DUEL) && level.numNonSpectatorClients >= 2 )
team = TEAM_SPECTATOR;
else if ( g_maxGameClients->integer > 0 && level.numNonSpectatorClients >= g_maxGameClients->integer )
team = TEAM_SPECTATOR;
// decide if we will allow the change
oldTeam = client->sess.sessionTeam;
if ( team == oldTeam && team != TEAM_SPECTATOR )
return;
// if the player was dead leave the body
if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
CopyToBodyQue( ent );
}
// he starts at 'base'
client->pers.teamState.state = TEAM_BEGIN;
if ( oldTeam != TEAM_SPECTATOR ) {
// Kill him (makes sure he loses flags, etc)
ent->flags &= ~FL_GODMODE;
ent->client->ps.stats[STAT_HEALTH] = ent->health = 0;
player_die( ent, ent, ent, 100000, MOD_SUICIDE );
}
// they go to the end of the line for tournaments
if ( team == TEAM_SPECTATOR && oldTeam != team )
AddTournamentQueue( client );
// exploit fix: with 3 (any odd amount?) players connected, one could /callvote map x followed by /team s to force the vote
G_ClearVote( ent );
client->sess.sessionTeam = team;
client->sess.spectatorState = specState;
client->sess.spectatorClient = specClient;
BroadcastTeamChange( client, oldTeam );
ClientUserinfoChanged( clientNum );
ClientBegin( clientNum );
}
/* LQ3A: Added bBroadcast parameter to allow the calling function to suppress the change. */
void SetTeam( gentity_t *ent, char *s, qboolean bBroadcast) {
/* LQ3A */
team_t team, oldTeam;
gclient_t *client;
int clientNum;
spectatorState_t specState;
int specClient;
int teamLeader;
//
// see what change is requested
//
client = ent->client;
clientNum = client - level.clients;
specClient = 0;
specState = SPECTATOR_NOT;
if ( !Q_stricmp( s, "scoreboard" ) || !Q_stricmp( s, "score" ) ) {
team = TEAM_SPECTATOR;
specState = SPECTATOR_SCOREBOARD;
} else if ( !Q_stricmp( s, "follow1" ) ) {
team = TEAM_SPECTATOR;
specState = SPECTATOR_FOLLOW;
specClient = -1;
} else if ( !Q_stricmp( s, "follow2" ) ) {
team = TEAM_SPECTATOR;
specState = SPECTATOR_FOLLOW;
specClient = -2;
} else if ( !Q_stricmp( s, "spectator" ) || !Q_stricmp( s, "s" ) ) {
team = TEAM_SPECTATOR;
specState = SPECTATOR_FREE;
} else if ( g_gametype.integer >= GT_TEAM ) {
// if running a team game, assign player to one of the teams
specState = SPECTATOR_NOT;
if ( !Q_stricmp( s, "red" ) || !Q_stricmp( s, "r" ) ) {
team = TEAM_RED;
} else if ( !Q_stricmp( s, "blue" ) || !Q_stricmp( s, "b" ) ) {
team = TEAM_BLUE;
} else {
// pick the team with the least number of players
team = PickTeam( clientNum );
}
if ( g_teamForceBalance.integer ) {
int counts[TEAM_NUM_TEAMS];
counts[TEAM_BLUE] = TeamCount( ent->client->ps.clientNum, TEAM_BLUE );
counts[TEAM_RED] = TeamCount( ent->client->ps.clientNum, TEAM_RED );
// We allow a spread of two
if ( team == TEAM_RED && counts[TEAM_RED] - counts[TEAM_BLUE] > 1 ) {
trap_SendServerCommand( ent->client->ps.clientNum,
"cp \"Red team has too many players.\n\"" );
return; // ignore the request
}
if ( team == TEAM_BLUE && counts[TEAM_BLUE] - counts[TEAM_RED] > 1 ) {
trap_SendServerCommand( ent->client->ps.clientNum,
"cp \"Blue team has too many players.\n\"" );
return; // ignore the request
}
// It's ok, the team we are switching to has less or same number of players
}
} else {
// force them to spectators if there aren't any spots free
/* LQ3A */
team = ((client->sess.sessionTeam == TEAM_FREE) ||
((client->sess.sessionTeam != TEAM_FREE) && LQ3A_GetVacantPlayerSlots())) ? TEAM_FREE : TEAM_SPECTATOR;
}
// override decision if limiting the players
if ( (g_gametype.integer == GT_TOURNAMENT)
&& level.numNonSpectatorClients >= 2 ) {
team = TEAM_SPECTATOR;
} else if ( g_maxGameClients.integer > 0 &&
level.numNonSpectatorClients > g_maxGameClients.integer ) {
team = TEAM_SPECTATOR;
}
//
// decide if we will allow the change
//
oldTeam = client->sess.sessionTeam;
/* LQ3A */
if ( team == oldTeam /*&& team != TEAM_SPECTATOR*/ ) {
return;
}
/* LQ3A: Ensure we're allowed to spectate. */
if ((team == TEAM_SPECTATOR) && !LQ3A_CanClientSpectate(ent))
{
return;
}
//
// execute the team change
//
// if the player was dead leave the body
if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
CopyToBodyQue(ent);
}
// he starts at 'base'
client->pers.teamState.state = TEAM_BEGIN;
/* LQ3A*/
if (oldTeam == TEAM_SPECTATOR)
{
ent->r.svFlags &= ~SVF_NOCLIENT;
client->pers.enterTime += (level.time - client->sess.spectatorTime);
/* Restore the players score. */
client->ps.persistant[PERS_SCORE] = client->pers.iScore;
}
else if (ent->client->ps.stats[STAT_HEALTH] > 0)
{
// Kill him (makes sure he loses flags, etc)
ent->flags &= ~FL_GODMODE;
/* LQ3A: Kill the player if they have too little health. */
if ((g_spectatorFreePass.integer > 0) && (ent->client->ps.stats[STAT_HEALTH] < g_spectatorFreePass.integer))
{
ent->client->ps.stats[STAT_HEALTH] = ent->health = 0;
player_die (ent, ent, ent, 100000, MOD_SUICIDE);
}
else
{
/* LQ3A: Drop items and return flags when we're allowed
to become a spectator without commiting suicide. */
// if client is in a nodrop area, don't drop anything (but return CTF flags!)
if (!(trap_PointContents(ent->r.currentOrigin, -1) & CONTENTS_NODROP))
{
TossClientItems(ent);
}
else
{
if (ent->client->ps.powerups[PW_NEUTRALFLAG])
{
Team_ReturnFlag(TEAM_FREE);
}
else if (ent->client->ps.powerups[PW_REDFLAG])
{
Team_ReturnFlag(TEAM_RED);
}
else if (ent->client->ps.powerups[PW_BLUEFLAG])
{
Team_ReturnFlag(TEAM_BLUE);
}
}
#ifdef MISSIONPACK
TossClientPersistantPowerups(ent);
if(g_gametype.integer == GT_HARVESTER)
{
TossClientCubes(ent);
}
#endif
}
}
// they go to the end of the line for tournements
if ( team == TEAM_SPECTATOR ) {
/* LQ3A */
LQ3A_CompleteClientMoveToSpectatorTeam(ent);
}
client->sess.sessionTeam = team;
client->sess.spectatorState = specState;
client->sess.spectatorClient = specClient;
client->sess.teamLeader = qfalse;
if ( team == TEAM_RED || team == TEAM_BLUE ) {
teamLeader = TeamLeader( team );
// if there is no team leader or the team leader is a bot and this client is not a bot
if ( teamLeader == -1 || ( !(g_entities[clientNum].r.svFlags & SVF_BOT) && (g_entities[teamLeader].r.svFlags & SVF_BOT) ) ) {
SetLeader( team, clientNum );
}
}
// make sure there is a team leader on the team the player came from
if ( oldTeam == TEAM_RED || oldTeam == TEAM_BLUE ) {
CheckTeamLeader( oldTeam );
}
/* LQ3A: Broadcast the change when instructed to do so. */
if (bBroadcast)
{
BroadcastTeamChange(client, oldTeam);
}
// get and distribute relevent paramters
ClientUserinfoChanged( clientNum );
/* LQ3A */
if (team != TEAM_SPECTATOR)
{
/* Spawn the client into the game. */
ClientBegin(clientNum);
}
else
{
/* Update the cached scores. */
CalculateRanks();
}
}
