自学教程：C++ CalculateRanks函数代码示例

static qboolean wopSP_calcWon(void) {    int			i;    gentity_t		*player;    int			playerClientNum;    // find the real player    player = NULL;    for (i = 0; i < level.maxclients; i++ ) {        player = &g_entities[i];        if ( !player->inuse ) {            continue;        }        if ( !( player->r.svFlags & SVF_BOT ) ) {            break;        }    }    if ( !player || i == level.maxclients ) {        return qfalse;    }    playerClientNum = i;    if ( g_gametype.integer >= GT_TEAM ) {        if((player->client->sess.sessionTeam == TEAM_RED && level.teamScores[TEAM_RED] > level.teamScores[TEAM_BLUE])                || (player->client->sess.sessionTeam == TEAM_BLUE && level.teamScores[TEAM_RED] < level.teamScores[TEAM_BLUE]))            return qtrue;        else            return qfalse;    }    else {        CalculateRanks();        return (player->client->ps.persistant[PERS_RANK] == 0);    }}

/*=======================================================================================================================================ObeliskDie=======================================================================================================================================*/static void ObeliskDie(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod) {	int otherTeam;	otherTeam = OtherTeam(self->spawnflags);	self->takedamage = qfalse;	self->think = ObeliskRespawn;	self->nextthink = level.time + g_obeliskRespawnDelay.integer * 1000;	self->activator->s.modelindex2 = 0xff;	self->activator->s.frame = 2;	G_AddEvent(self->activator, EV_OBELISKEXPLODE, 0);	if (self->spawnflags == attacker->client->sess.sessionTeam) {		AddScore(attacker, self->r.currentOrigin, -CTF_CAPTURE_BONUS);	} else {		AddScore(attacker, self->r.currentOrigin, CTF_CAPTURE_BONUS);		attacker->client->rewardTime = level.time + REWARD_TIME;		attacker->client->ps.persistant[PERS_CAPTURES]++;	}	AddTeamScore(self->s.pos.trBase, otherTeam, 1);	CalculateRanks();	Team_CaptureFlagSound(self, self->spawnflags);	Team_ForceGesture(otherTeam);	teamgame.redObeliskAttackedTime = 0;	teamgame.blueObeliskAttackedTime = 0;	trap_SendServerCommand(-1, va("cp /"%s" S_COLOR_WHITE "/ndestroyed the %s obelisk!/n/"", attacker->client->pers.netname, TeamName(self->spawnflags)));}

static void ObeliskTouch( gentity_t *self, gentity_t *other, trace_t *trace ) {	int			tokens;	if ( !other->client ) {		return;	}	if ( OtherTeam(other->client->sess.sessionTeam) != self->spawnflags ) {		return;	}	tokens = other->client->ps.generic1;	if( tokens <= 0 ) {		return;	}	PrintMsg(NULL, "%s" S_COLOR_WHITE " brought in %i skull%s./n",					other->client->pers.netname, tokens, tokens ? "s" : "" );	AddTeamScore(self->s.pos.trBase, other->client->sess.sessionTeam, tokens);	Team_ForceGesture(other->client->sess.sessionTeam);	AddScore(other, self->r.currentOrigin, CTF_CAPTURE_BONUS*tokens);	// add the sprite over the player's head	other->client->ps.eFlags &= ~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND | EF_AWARD_CAP );	other->client->ps.eFlags |= EF_AWARD_CAP;	other->client->rewardTime = level.time + REWARD_SPRITE_TIME;	other->client->ps.persistant[PERS_CAPTURES] += tokens;		other->client->ps.generic1 = 0;	CalculateRanks();	Team_CaptureFlagSound( self, self->spawnflags );}

/*============AddScoreAdds score to both the client and his team============*/void AddScore(gentity_t * ent, vec3_t origin, int score){	if(!ent->client)	{		return;	}	// no scoring during pre-match warmup	if(level.warmupTime)	{		return;	}	// Tr3B: don't draw zero skills scores	if(score == 0)	{		return;	}	// show score plum	ScorePlum(ent, origin, score);	//	ent->client->ps.persistant[PERS_SCORE] += score;	if(g_gametype.integer == GT_TEAM)		level.teamScores[ent->client->ps.persistant[PERS_TEAM]] += score;	CalculateRanks();}

/*=======================================================================================================================================ObeliskTouch=======================================================================================================================================*/static void ObeliskTouch(gentity_t *self, gentity_t *other, trace_t *trace) {	int tokens;	team_t otherTeam;	if (!other->client) {		return;	}	otherTeam = OtherTeam(other->client->sess.sessionTeam);	if (otherTeam != self->spawnflags) {		return;	}	tokens = other->client->ps.tokens;	if (tokens <= 0) {		return;	}	trap_SendServerCommand(-1, va("cp /"%s" S_COLOR_WHITE "/nbrought in %i %s %s!/n/"", other->client->pers.netname, tokens, TeamName(otherTeam), (tokens == 1) ? "skull" : "skulls"));	other->client->rewardTime = level.time + REWARD_TIME;	other->client->ps.persistant[PERS_CAPTURES] += tokens;	other->client->ps.tokens = 0;	AddScore(other, self->r.currentOrigin, CTF_CAPTURE_BONUS * tokens);	AddTeamScore(self->s.pos.trBase, other->client->sess.sessionTeam, tokens);	CalculateRanks();	Team_CaptureFlagSound(self, self->spawnflags);	Team_ForceGesture(other->client->sess.sessionTeam);}

static voidObeliskDie(Gentity *self, Gentity *inflictor, Gentity *attacker,	   int damage,	   int mod){	int otherTeam;	otherTeam = OtherTeam(self->spawnflags);	AddTeamScore(self->s.pos.base, otherTeam, 1);	Team_ForceGesture(otherTeam);	CalculateRanks();	self->takedamage = qfalse;	self->think = ObeliskRespawn;	self->nextthink = level.time + g_obeliskRespawnDelay.integer * 1000;	self->activator->s.modelindex2 = 0xff;	self->activator->s.frame = 2;	G_AddEvent(self->activator, EV_OBELISKEXPLODE, 0);	AddScore(attacker, self->r.currentOrigin, CTF_CAPTURE_BONUS);	/* add the sprite over the player's head */	attacker->client->ps.eFlags &=		~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET |		  EF_AWARD_ASSIST | EF_AWARD_DEFEND | EF_AWARD_CAP);	attacker->client->ps.eFlags |= EF_AWARD_CAP;	attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;	attacker->client->ps.persistant[PERS_CAPTURES]++;	teamgame.redObeliskAttackedTime = 0;	teamgame.blueObeliskAttackedTime = 0;}

/*===========ClientBegincalled when a client has finished connecting, and is readyto be placed into the level.  This will happen every level load,and on transition between teams, but doesn't happen on respawns============*/void ClientBegin( int clientNum ){  gentity_t *ent;  gclient_t *client;  int       flags;  ent = g_entities + clientNum;  client = level.clients + clientNum;  if( ent->r.linked )    trap_UnlinkEntity( ent );  G_InitGentity( ent );  ent->touch = 0;  ent->pain = 0;  ent->client = client;  client->pers.connected = CON_CONNECTED;  client->pers.enterTime = level.time;  client->pers.teamState.state = TEAM_BEGIN;  client->pers.classSelection = PCL_NONE;  // save eflags around this, because changing teams will  // cause this to happen with a valid entity, and we  // want to make sure the teleport bit is set right  // so the viewpoint doesn't interpolate through the  // world to the new position  flags = client->ps.eFlags;  memset( &client->ps, 0, sizeof( client->ps ) );  memset( &client->pmext, 0, sizeof( client->pmext ) );  client->ps.eFlags = flags;  // locate ent at a spawn point  ClientSpawn( ent, NULL, NULL, NULL );  trap_SendServerCommand( -1, va( "print /"%s" S_COLOR_WHITE " entered the game/n/"", client->pers.netname ) );  // name can change between ClientConnect() and ClientBegin()  G_admin_namelog_update( client, qfalse );  // request the clients PTR code  trap_SendServerCommand( ent - g_entities, "ptrcrequest" );  G_LogPrintf( "ClientBegin: %i/n", clientNum );  if( g_clientUpgradeNotice.integer )  {    if( !Q_stricmp( ent->client->pers.guid, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" ) )    {      trap_SendServerCommand( client->ps.clientNum, va( "print /"^1Your client is out of date. Updating your client will allow you to "        "become an admin on servers and download maps much more quickly. Please replace your client executable with the one "        "at ^2http://trem.tjw.org/backport/^1 and reconnect. /n/"" ) );    }  }  // count current clients and rank for scoreboard  CalculateRanks( );}

/*===========PlayerBegincalled when a player has finished connecting, and is readyto be placed into the level.  This will happen every level load,and on transition between teams, but doesn't happen on respawns============*/void PlayerBegin( int playerNum ) {	gentity_t	*ent;	gplayer_t	*player;	int			flags;	int			i;	ent = g_entities + playerNum;	player = level.players + playerNum;	if ( ent->r.linked ) {		trap_UnlinkEntity( ent );	}	G_InitGentity( ent );	ent->touch = 0;	ent->pain = 0;	ent->player = player;	player->pers.connected = CON_CONNECTED;	player->pers.enterTime = level.time;	player->pers.teamState.state = TEAM_BEGIN;	// save eflags around this, because changing teams will	// cause this to happen with a valid entity, and we	// want to make sure the teleport bit is set right	// so the viewpoint doesn't interpolate through the	// world to the new position	flags = player->ps.eFlags;	memset( &player->ps, 0, sizeof( player->ps ) );	player->ps.eFlags = flags;	// locate ent at a spawn point	PlayerSpawn( ent );	if ( player->pers.initialSpawn && g_gametype.integer != GT_TOURNAMENT ) {		// This is only sent to bots because for humans the "joining the battle" etc		// make it clear that the player is now finished connecting. Bots on the other		// hand have "entered the game" hard coded in botfiles/match.c so continue to		// send it to them.		for ( i = 0; i < level.maxplayers; i++ ) {			if ( level.players[i].pers.connected == CON_DISCONNECTED ) {				continue;			}			if ( !(g_entities[i].r.svFlags & SVF_BOT) ) {				continue;			}			trap_SendServerCommand( i, va("print /"%s" S_COLOR_WHITE " entered the game/n/"", player->pers.netname) );		}		if ( !g_singlePlayer.integer ) {			BroadcastTeamChange( player, -1 );		}	}	player->pers.initialSpawn = qfalse;	G_LogPrintf( "PlayerBegin: %i/n", playerNum );	// count current players and rank for scoreboard	CalculateRanks();}

/*============AddScoreAdds score to both the client and his team============*/void AddScore( gentity_t *ent, int score ){  if( !ent->client )    return;  ent->client->ps.persistant[ PERS_SCORE ] += score;  CalculateRanks( );}

/*===========ClientDisconnectCalled when a player drops from the server.Will not be called between levels.This should NOT be called directly by any game logic,call trap_DropClient(), which will call this and doserver system housekeeping.============*/void ClientDisconnect( int clientNum ) {	gentity_t	*ent;	gentity_t	*tent;	int			i;	// cleanup if we are kicking a bot that	// hasn't spawned yet	G_RemoveQueuedBotBegin( clientNum );	ent = g_entities + clientNum;	if ( !ent->client ) {		return;	}	// stop any following clients	for ( i = 0 ; i < level.maxclients ; i++ ) {		if ( level.clients[i].sess.sessionTeam == TEAM_SPECTATOR			&& level.clients[i].sess.spectatorState == SPECTATOR_FOLLOW			&& level.clients[i].sess.spectatorClient == clientNum ) {			StopFollowing( &g_entities[i] );		}	}	// send effect if they were completely connected	if ( ent->client->pers.connected == CON_CONNECTED 		&& ent->client->sess.sessionTeam != TEAM_SPECTATOR ) {		// They don't get to take powerups with them!		// Especially important for stuff like CTF flags		TossClientItems( ent );#ifdef MISSIONPACK		TossClientPersistantPowerups( ent );		if( g_gametype.integer == GT_HARVESTER ) {			TossClientCubes( ent );		}#endif	}	G_LogPrintf( "ClientDisconnect: %i/n", clientNum );	trap_UnlinkEntity (ent);	ent->s.modelindex = 0;	ent->inuse = qfalse;	ent->classname = "disconnected";	ent->client->pers.connected = CON_DISCONNECTED;	ent->client->ps.stats[STAT_TEAM] = TEAM_FREE;	ent->client->sess.sessionTeam = TEAM_FREE;	trap_SetConfigstring( CS_PLAYERS + clientNum, "");	CalculateRanks();	if ( ent->r.svFlags & SVF_BOT ) {		BotAIShutdownClient( clientNum, qfalse );	}}

/*==================UpdateTournamentInfo==================*/void UpdateTournamentInfo( void ){    int             n, accuracy, perfect;    char            buf[32], msg[MAX_STRING_CHARS];    unsigned int    playerClientNum, i, buflen, msglen;    gentity_t       *player;    // find the real player    player = NULL;    for (i = 0; i < level.maxclients; i++ )    {        player = &g_entities[i];        if ( !player->inuse )            continue;        if ( !( player->r.svFlags & SVF_BOT ) )            break;    }    // this should never happen!    if ( !player || i == level.maxclients )        return;    playerClientNum = i;    CalculateRanks();    if ( level.clients[playerClientNum].sess.sessionTeam == TEAM_SPECTATOR )    {        Com_sprintf( msg, sizeof(msg), "postgame %i %i 0 0 0 0 0 0", level.numNonSpectatorClients, playerClientNum );    }    else    {        if( player->client->accuracy_shots )            accuracy = player->client->accuracy_hits * 100 / player->client->accuracy_shots;        else            accuracy = 0;        perfect = ( level.clients[playerClientNum].ps.persistant[PERS_RANK] == 0 && player->client->ps.persistant[PERS_KILLED] == 0 ) ? 1 : 0;        Com_sprintf( msg, sizeof(msg), "postgame %i %i %i %i %i %i %i %i", level.numNonSpectatorClients, playerClientNum, accuracy,                     player->client->ps.persistant[PERS_IMPRESSIVE_COUNT], player->client->ps.persistant[PERS_EXCELLENT_COUNT],                     player->client->ps.persistant[PERS_GAUNTLET_FRAG_COUNT], player->client->ps.persistant[PERS_SCORE],                     perfect );    }    msglen = strlen( msg );    for( i = 0; i < level.numNonSpectatorClients; i++ )    {        n = level.sortedClients[i];        Com_sprintf( buf, sizeof(buf), " %i %i %i", n, level.clients[n].ps.persistant[PERS_RANK], level.clients[n].ps.persistant[PERS_SCORE] );        buflen = strlen( buf );        if( msglen + buflen + 1 >= sizeof(msg) )        {            break;        }        strcat( msg, buf );    }    Cbuf_ExecuteText(EXEC_APPEND, msg );}

/*===========ClientDisconnectCalled when a player drops from the server.Will not be called between levels.This should NOT be called directly by any game logic,call trap_DropClient(), which will call this and doserver system housekeeping.============*/void ClientDisconnect( int clientNum ){  gentity_t *ent;  gentity_t *tent;  int       i;  buildHistory_t *ptr;  ent = g_entities + clientNum;  if( !ent->client )    return;  // look through the bhist and readjust it if the referenced ent has left  for( ptr = level.buildHistory; ptr; ptr = ptr->next )  {    if( ptr->ent == ent )    {      ptr->ent = NULL;      Q_strncpyz( ptr->name, ent->client->pers.netname, MAX_NETNAME );    }  }  G_admin_namelog_update( ent->client, qtrue );  G_LeaveTeam( ent );  // stop any following clients  for( i = 0; i < level.maxclients; i++ )  {    // remove any /ignore settings for this clientNum    BG_ClientListRemove( &level.clients[ i ].sess.ignoreList, clientNum );  }  // send effect if they were completely connected  if( ent->client->pers.connected == CON_CONNECTED &&      ent->client->sess.sessionTeam != TEAM_SPECTATOR )  {    tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_OUT );    tent->s.clientNum = ent->s.clientNum;  }  if( ent->client->pers.connection )    ent->client->pers.connection->clientNum = -1;  G_LogPrintf( "ClientDisconnect: %i [%s] (%s) /"%s/"/n", clientNum,   ent->client->pers.ip, ent->client->pers.guid, ent->client->pers.netname );  trap_UnlinkEntity( ent );  ent->s.modelindex = 0;  ent->inuse = qfalse;  ent->classname = "disconnected";  ent->client->pers.connected = CON_DISCONNECTED;  ent->client->ps.persistant[ PERS_TEAM ] = TEAM_FREE;  ent->client->sess.sessionTeam = TEAM_FREE;  trap_SetConfigstring( CS_PLAYERS + clientNum, "");  CalculateRanks( );}

/*===========ClientBegincalled when a client has finished connecting, and is readyto be placed into the level.  This will happen every level load,and on transition between teams, but doesn't happen on respawns============*/void ClientBegin(int clientNum){  gentity_t      *ent;  gclient_t      *client;  gentity_t      *tent;  int             flags;  ent = g_entities + clientNum;  client = level.clients + clientNum;  if(ent->r.linked)  {    trap_UnlinkEntity(ent);  }  G_InitGentity(ent);  ent->touch = 0;  ent->pain = 0;  ent->client = client;  client->pers.connected = CON_CONNECTED;  client->pers.enterTime = level.time;  client->pers.teamState.state = TEAM_BEGIN;  // save eflags around this, because changing teams will  // cause this to happen with a valid entity, and we  // want to make sure the teleport bit is set right  // so the viewpoint doesn't interpolate through the  // world to the new position  flags = client->ps.eFlags;  memset(&client->ps, 0, sizeof(client->ps));  client->ps.eFlags = flags;  // locate ent at a spawn point  ClientSpawn(ent);  if(client->sess.sessionTeam != TEAM_SPECTATOR)  {    // send event    tent = G_TempEntity(ent->client->ps.origin, EV_PLAYER_TELEPORT_IN);    tent->s.clientNum = ent->s.clientNum;    if(g_gametype.integer != GT_TOURNAMENT)    {      trap_SendServerCommand(-1, va("print /"%s" S_COLOR_WHITE " entered the game/n/"", client->pers.netname));    }  }  G_LogPrintf("ClientBegin: %i/n", clientNum);  // count current clients and rank for scoreboard  CalculateRanks();#ifdef G_LUA  // Lua API callbacks  G_LuaHook_ClientBegin(clientNum);#endif}

// TODO: Draw a ScorePlum() as well? Needs cgame fixes to draw plum regardless of "owner"void AddTeamScore( vec3_t origin, int team, int score, char *reason ) {	gentity_t	*te;	te = G_TempEntity(origin, EV_GLOBAL_TEAM_SOUND );	te->r.svFlags |= SVF_BROADCAST;	if ( team == TEAM_RED ) {		if ( level.teamScores[ TEAM_RED ] + score == level.teamScores[ TEAM_BLUE ] ) {			//teams are tied sound			te->s.eventParm = GTS_TEAMS_ARE_TIED;		}		else if ( level.teamScores[ TEAM_RED ] <= level.teamScores[ TEAM_BLUE ] &&					level.teamScores[ TEAM_RED ] + score > level.teamScores[ TEAM_BLUE ]) {			// red took the lead sound			te->s.eventParm = GTS_REDTEAM_TOOK_LEAD;		}		else {			// red scored sound			te->s.eventParm = GTS_REDTEAM_SCORED;			// Hackity! In BB teams score continously, which makes for annoying			// sound spam. Thus disable sound.			// Better solution would be to either only do this sound on captures/destroys			// or continously at fixed time offsets.			// Also note that there already is a "blue/red balloon" sound in cgame CG_UpdateBalloonStates			if ( g_gametype.integer == GT_BALLOON ) {				G_FreeEntity( te );			}		}	}	else {		if ( level.teamScores[ TEAM_BLUE ] + score == level.teamScores[ TEAM_RED ] ) {			//teams are tied sound			te->s.eventParm = GTS_TEAMS_ARE_TIED;		}		else if ( level.teamScores[ TEAM_BLUE ] <= level.teamScores[ TEAM_RED ] &&					level.teamScores[ TEAM_BLUE ] + score > level.teamScores[ TEAM_RED ]) {			// blue took the lead sound			te->s.eventParm = GTS_BLUETEAM_TOOK_LEAD;		}		else {			// blue scored sound			te->s.eventParm = GTS_BLUETEAM_SCORED;			// See note above			if ( g_gametype.integer == GT_BALLOON ) {				G_FreeEntity( te );			}		}	}	level.teamScores[ team ] += score;	CalculateRanks();	G_LogPrintf( "AddTeamScore: %s %i %s/n", TeamName( team ), score, reason );}

/*===========ClientBegincalled when a client has finished connecting, and is readyto be placed into the level.  This will happen every level load,and on transition between teams, but doesn't happen on respawns============*/void ClientBegin( int clientNum ){  gentity_t *ent;  gclient_t *client;  int       flags;  ent = g_entities + clientNum;  client = level.clients + clientNum;  // ignore if client already entered the game  if( client->pers.connected != CON_CONNECTING )    return;  if( ent->r.linked )    trap_UnlinkEntity( ent );  G_InitGentity( ent );  ent->touch = 0;  ent->pain = 0;  ent->client = client;  client->pers.connected = CON_CONNECTED;  client->pers.enterTime = level.time;  // save eflags around this, because changing teams will  // cause this to happen with a valid entity, and we  // want to make sure the teleport bit is set right  // so the viewpoint doesn't interpolate through the  // world to the new position  flags = client->ps.eFlags;  memset( &client->ps, 0, sizeof( client->ps ) );  memset( &client->pmext, 0, sizeof( client->pmext ) );  client->ps.eFlags = flags;  // locate ent at a spawn point  ClientSpawn( ent, NULL, NULL, NULL );  trap_SendServerCommand( -1, va( "print /"%s" S_COLOR_WHITE " entered the game/n/"", client->pers.netname ) );  G_namelog_restore( client );  G_LogPrintf( "ClientBegin: %i/n", clientNum );  // count current clients and rank for scoreboard  CalculateRanks( );  // send the client a list of commands that can be used  G_ListCommands( ent );    // reset cuboidSelection  client->cuboidSelection[ 0 ] =  client->cuboidSelection[ 1 ] =  client->cuboidSelection[ 2 ] = 32;}

/*============AddScoreHelperHelper function for G_AddCreditsToScore and G_AddConfidenceToScore.============*/static void AddScoreHelper( gentity_t *self, float score ){	if ( !self->client || self->client->pers.connected != CON_CONNECTED )	{		return;	}	self->client->ps.persistant[ PERS_SCORE ] += ( int )( score + 0.5f );	CalculateRanks();}

/** * @brief G_AddKillSkillPointsForDestruction * @param[in] attacker * @param[in] mod * @param[in] constructibleStats */void G_AddKillSkillPointsForDestruction(gentity_t *attacker, meansOfDeath_t mod, g_constructible_stats_t *constructibleStats){	if (GetMODTableData(mod)->skillType < SK_NUM_SKILLS)	{		G_AddSkillPoints(attacker, GetMODTableData(mod)->skillType, constructibleStats->destructxpbonus);		G_DebugAddSkillPoints(attacker, GetMODTableData(mod)->skillType, constructibleStats->destructxpbonus, "destroying a constructible/explosive");	}	// prepare scoreboard	CalculateRanks();}

/*===========ClientDisconnectCalled when a player drops from the server.Will not be called between levels.This should NOT be called directly by any game logic,call trap_DropClient(), which will call this and doserver system housekeeping.============*/void ClientDisconnect( int clientNum ){  gclient_t *client;  gentity_t *ent;  gentity_t *tent;  int       i;  ent = g_entities + clientNum;  if( !ent->client || ent->client->pers.connected == CON_DISCONNECTED )    return;  G_LeaveTeam( ent );  G_namelog_disconnect( ent->client );  G_Vote( ent, TEAM_NONE, qfalse );  // stop any following clients  for( i = 0; i < level.maxclients; i++ )  {    client = &level.clients[ i ];        // remove any /ignore settings for this clientNum    Com_ClientListRemove( &client->sess.ignoreList, clientNum );        // clear impregnatedBy for everyone impregnated by this player    if( client->isImpregnated && client->impregnatedBy == clientNum )      client->impregnatedBy = -2;     }  // send effect if they were completely connected  if( ent->client->pers.connected == CON_CONNECTED &&      ent->client->sess.spectatorState == SPECTATOR_NOT )  {    tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_OUT );    tent->s.clientNum = ent->s.clientNum;  }  G_LogPrintf( "ClientDisconnect: %i [%s] (%s) /"%s^7/"/n", clientNum,   ent->client->pers.ip.str, ent->client->pers.guid, ent->client->pers.netname );  trap_UnlinkEntity( ent );  ent->s.modelindex = 0;  ent->inuse = qfalse;  ent->classname = "disconnected";  ent->client->pers.connected = CON_DISCONNECTED;  ent->client->sess.spectatorState =      ent->client->ps.persistant[ PERS_SPECSTATE ] = SPECTATOR_NOT;  trap_SetConfigstring( CS_PLAYERS + clientNum, "");  CalculateRanks( );}

/** * @brief G_AddKillSkillPoints * @param[in] attacker * @param[in] mod * @param[in] hr * @param[in] splash */void G_AddKillSkillPoints(gentity_t *attacker, meansOfDeath_t mod, hitRegion_t hr, qboolean splash){	float       points;	skillType_t skillType;	const char  *reason;	if (!attacker->client)	{		return;	}	if (GetMODTableData(mod)->hasHitRegion)	{		points = GetMODTableData(mod)->hitRegionKillPoints[hr];		switch (hr)		{		case HR_HEAD: reason = va("%s headshot kill", GetMODTableData(mod)->debugReasonMsg); break;		case HR_ARMS: reason = va("%s armshot kill", GetMODTableData(mod)->debugReasonMsg); break;		case HR_BODY: reason = va("%s bodyshot kill", GetMODTableData(mod)->debugReasonMsg); break;		case HR_LEGS: reason = va("%s legshot kill", GetMODTableData(mod)->debugReasonMsg); break;		default:      reason = va("%s kill", GetMODTableData(mod)->debugReasonMsg); break; // for weapons that don't have localized damage, should not happen		}	}	else if (splash)	{		points = GetMODTableData(mod)->splashKillPoints;		reason = va("%s splash damage kill", GetMODTableData(mod)->debugReasonMsg);	}	else	{		points = GetMODTableData(mod)->defaultKillPoints;		if (GetMODTableData(mod)->isExplosive)		{			reason = va("%s direct damage kill", GetMODTableData(mod)->debugReasonMsg);		}		else		{			reason = va("%s kill", GetMODTableData(mod)->debugReasonMsg);		}	}	skillType = GetMODTableData(mod)->skillType;	G_AddSkillPoints(attacker, skillType, points);	G_DebugAddSkillPoints(attacker, skillType, points, reason);	// prepare scoreboard	CalculateRanks();}

/*============AddKillScoreAdds score to both the client and his team, only used for playerkills, for lms============*/void AddKillScore( gentity_t *ent, int score ) {	if ( !ent || !ent->client ) {		return;	}	// someone already won	if( level.lmsWinningTeam )		return;	ent->client->sess.game_points += score;	CalculateRanks();}

/*===========ClientDisconnectCalled when a player drops from the server.Will not be called between levels.This should NOT be called directly by any game logic,call trap_DropClient(), which will call this and doserver system housekeeping.============*/void ClientDisconnect( int clientNum ){	gentity_t *ent;	gentity_t *tent;	int       i;	ent = g_entities + clientNum;	if ( !ent->client || ent->client->pers.connected == CON_DISCONNECTED )	{		return;	}	G_LeaveTeam( ent );	G_namelog_disconnect( ent->client );	G_Vote( ent, TEAM_NONE, false );	// stop any following clients	for ( i = 0; i < level.maxclients; i++ )	{		// remove any /ignore settings for this clientNum		Com_ClientListRemove( &level.clients[ i ].sess.ignoreList, clientNum );	}	// send effect if they were completely connected	if ( ent->client->pers.connected == CON_CONNECTED &&	     ent->client->sess.spectatorState == SPECTATOR_NOT )	{		tent = G_NewTempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_OUT );		tent->s.clientNum = ent->s.clientNum;	}	G_LogPrintf( "ClientDisconnect: %i [%s] (%s) /"%s^7/"", clientNum,	             ent->client->pers.ip.str, ent->client->pers.guid, ent->client->pers.netname );	ent->client->pers.connected = CON_DISCONNECTED;	ent->client->sess.spectatorState = SPECTATOR_NOT;	ent->client->ps.persistant[ PERS_SPECSTATE ] = SPECTATOR_NOT;	G_FreeEntity(ent);	ent->classname = "disconnected";	ent->client = level.clients + clientNum;	trap_SetConfigstring( CS_PLAYERS + clientNum, "" );	CalculateRanks();	Beacon::PropagateAll();}

/** * @brief Loose skill for evil tkers :E * @param[in] tker * @param[in] mod * @param hr - unused * @param splash - unused */void G_LoseKillSkillPoints(gentity_t *tker, meansOfDeath_t mod, hitRegion_t hr, qboolean splash){	if (!tker->client)	{		return;	}	if (GetMODTableData(mod)->skillType < SK_NUM_SKILLS)	{		G_LoseSkillPoints(tker, GetMODTableData(mod)->skillType, GetMODTableData(mod)->defaultKillPoints);	}	// prepare scoreboard	CalculateRanks();}

/*===========ClientDisconnectCalled when a player drops from the server.Will not be called between levels.This should NOT be called directly by any game logic,call trap_DropClient(), which will call this and doserver system housekeeping.============*/void ClientDisconnect( int clientNum ){  gentity_t *ent;  gentity_t *tent;  int       i;  ent = g_entities + clientNum;  if( !ent->client )    return;  G_admin_namelog_update( ent->client, qtrue );  G_LeaveTeam( ent );  G_Vote( ent, qfalse );  // stop any following clients  for( i = 0; i < level.maxclients; i++ )  {    // remove any /ignore settings for this clientNum    BG_ClientListRemove( &level.clients[ i ].sess.ignoreList, clientNum );  }  // send effect if they were completely connected  if( ent->client->pers.connected == CON_CONNECTED &&      ent->client->sess.spectatorState == SPECTATOR_NOT )  {    tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_OUT );    tent->s.clientNum = ent->s.clientNum;  }  if( ent->client->pers.connection )    ent->client->pers.connection->clientNum = -1;  G_LogPrintf( "ClientDisconnect: %i [%s] (%s) /"%s/"/n", clientNum,   ent->client->pers.ip, ent->client->pers.guid, ent->client->pers.netname );  trap_UnlinkEntity( ent );  ent->s.modelindex = 0;  ent->inuse = qfalse;  ent->classname = "disconnected";  ent->client->pers.connected = CON_DISCONNECTED;  ent->client->sess.spectatorState =      ent->client->ps.persistant[ PERS_SPECSTATE ] = SPECTATOR_NOT;  trap_SetConfigstring( CS_PLAYERS + clientNum, "");  CalculateRanks( );}

/*===========ClientBegincalled when a client has finished connecting, and is readyto be placed into the level.  This will happen every level load,and on transition between teams, but doesn't happen on respawns============*/void ClientBegin( int clientNum ){  gentity_t *ent;  gclient_t *client;  int       flags;  ent = g_entities + clientNum;  client = level.clients + clientNum;  if( ent->r.linked )    trap_UnlinkEntity( ent );  G_InitGentity( ent );  ent->touch = 0;  ent->pain = 0;  ent->client = client;  client->pers.connected = CON_CONNECTED;  client->pers.enterTime = level.time;  // save eflags around this, because changing teams will  // cause this to happen with a valid entity, and we  // want to make sure the teleport bit is set right  // so the viewpoint doesn't interpolate through the  // world to the new position  flags = client->ps.eFlags;  memset( &client->ps, 0, sizeof( client->ps ) );  memset( &client->pmext, 0, sizeof( client->pmext ) );  client->ps.eFlags = flags;  // locate ent at a spawn point  ClientSpawn( ent, NULL, NULL, NULL );  trap_SendServerCommand( -1, va( "print /"%s" S_COLOR_WHITE " entered the game/n/"", client->pers.netname ) );  // name can change between ClientConnect() and ClientBegin()  G_admin_namelog_update( client, qfalse );  // request the clients PTR code  trap_SendServerCommand( ent - g_entities, "ptrcrequest" );  G_LogPrintf( "ClientBegin: %i/n", clientNum );  // count current clients and rank for scoreboard  CalculateRanks( );}

/*============AddScoreAdds score to the client============*/void AddScore( gentity_t *ent, int score ){  if( !ent->client )    return;  // make alien and human scores equivalent   if ( ent->client->pers.teamSelection == TEAM_ALIENS )  {    score = rint( ((float)score) / 2.0f );  }  // scale values down to fit the scoreboard better  score = rint( ((float)score) / 50.0f );  ent->client->ps.persistant[ PERS_SCORE ] += score;  CalculateRanks( );}

/*============AddScoreAdds score to both the player and his team============*/void AddScore( gentity_t *ent, vec3_t origin, int score ) {	if ( !ent->player ) {		return;	}	// no scoring during pre-match warmup	if ( level.warmupTime ) {		return;	}	// show score plum	ScorePlum(ent, origin, score);	//	ent->player->ps.persistant[PERS_SCORE] += score;	if ( g_gametype.integer == GT_TEAM ) {		AddTeamScore( origin, ent->player->ps.persistant[PERS_TEAM], score );	}	CalculateRanks();}

/** * @brief G_LoseSkillPoints * @param[in,out] ent * @param[in] skill * @param[in] points */void G_LoseSkillPoints(gentity_t *ent, skillType_t skill, float points){	int   oldskill;	float oldskillpoints;	if (!ent->client)	{		return;	}	// no skill loss during warmup	if (g_gamestate.integer != GS_PLAYING)	{		return;	}	if (ent->client->sess.sessionTeam != TEAM_AXIS && ent->client->sess.sessionTeam != TEAM_ALLIES)	{		return;	}	if (g_gametype.integer == GT_WOLF_LMS)	{		return; // no xp in LMS	}	oldskillpoints                        = ent->client->sess.skillpoints[skill];	ent->client->sess.skillpoints[skill] -= points;	// see if player increased in skill	oldskill = ent->client->sess.skill[skill];	G_SetPlayerSkill(ent->client, skill);	if (oldskill != ent->client->sess.skill[skill])	{		ent->client->sess.skill[skill]       = oldskill;		ent->client->sess.skillpoints[skill] = GetSkillTableData(skill)->skillLevels[oldskill];	}	G_Printf("%s ^7just lost %.0f skill points for skill %s/n", ent->client->pers.netname, (double)(oldskillpoints - ent->client->sess.skillpoints[skill]), GetSkillTableData(skill)->skillNames);	level.teamScores[ent->client->ps.persistant[PERS_TEAM]]        -= oldskillpoints - ent->client->sess.skillpoints[skill];	level.teamXP[skill][ent->client->sess.sessionTeam - TEAM_AXIS] -= oldskillpoints - ent->client->sess.skillpoints[skill];	// prepare scoreboard	CalculateRanks();}

/*============AddScoreAdds score to both the client and his team============*/void AddScore( gentity_t *ent, vec3_t origin, int score ) {        int i;	if ( !ent->client ) {		return;	}	// no scoring during pre-match warmup	if ( level.warmupTime ) {		return;	}        //No scoring during intermission        if ( level.intermissiontime ) {            return;        }	// show score plum        if( level.numNonSpectatorClients<3 && score < 0 && (g_gametype.integer<GT_TEAM || g_ffa_gt==1)) {            for ( i = 0 ; i < level.maxclients ; i++ ) {                if ( level.clients[ i ].pers.connected != CON_CONNECTED )                    continue; //Client was not connected                if (level.clients[i].sess.sessionTeam == TEAM_SPECTATOR)                    continue; //Don't give anything to spectators                if (g_entities+i == ent)                    continue; //Don't award dead one                level.clients[i].ps.persistant[PERS_SCORE] -= score;                ScorePlum(ent, origin, -score);            }        }        else {            ScorePlum(ent, origin, score);            //            ent->client->ps.persistant[PERS_SCORE] += score;            if ( g_gametype.integer == GT_TEAM ) {                int team = ent->client->ps.persistant[PERS_TEAM];                    level.teamScores[ team ] += score;                    G_LogPrintf("TeamScore: %i %i: Team %d now has %d points/n",                        team, level.teamScores[ team ], team, level.teamScores[ team ] );            }        }        G_LogPrintf("PlayerScore: %i %i: %s now has %d points/n",		ent->s.number, ent->client->ps.persistant[PERS_SCORE], ent->client->pers.netname, ent->client->ps.persistant[PERS_SCORE] );	CalculateRanks();}

/** * @brief G_AddSkillPoints * @param[in,out] ent * @param[in] skill * @param[in] points */void G_AddSkillPoints(gentity_t *ent, skillType_t skill, float points){	int oldskill;	if (!ent->client)	{		return;	}	// no skill gaining during warmup	if (g_gamestate.integer != GS_PLAYING)	{		return;	}	if (ent->client->sess.sessionTeam != TEAM_AXIS && ent->client->sess.sessionTeam != TEAM_ALLIES)	{		return;	}	if (g_gametype.integer == GT_WOLF_LMS)	{		return; // no xp in LMS	}	level.teamXP[skill][ent->client->sess.sessionTeam - TEAM_AXIS] += points;	ent->client->sess.skillpoints[skill] += points;	level.teamScores[ent->client->ps.persistant[PERS_TEAM]] += points;	//G_Printf( "%s just got %.0f skill points for skill %s/n", ent->client->pers.netname, points, skillNames[skill] );	// see if player increased in skill	oldskill = ent->client->sess.skill[skill];	G_SetPlayerSkill(ent->client, skill);	if (oldskill != ent->client->sess.skill[skill])	{		// call the new func that encapsulates the skill giving behavior		G_UpgradeSkill(ent, skill);	}	// prepare scoreboard	CalculateRanks();}

/*===========PlayerBegincalled when a player has finished connecting, and is readyto be placed into the level.  This will happen every level load,and on transition between teams, but doesn't happen on respawns============*/void PlayerBegin( int playerNum ) {	gentity_t	*ent;	gplayer_t	*player;	int			flags;	ent = g_entities + playerNum;	player = level.players + playerNum;	if ( ent->r.linked ) {		trap_UnlinkEntity( ent );	}	G_InitGentity( ent );	ent->touch = 0;	ent->pain = 0;	ent->player = player;	player->pers.connected = CON_CONNECTED;	player->pers.enterTime = level.time;	player->pers.teamState.state = TEAM_BEGIN;	// save eflags around this, because changing teams will	// cause this to happen with a valid entity, and we	// want to make sure the teleport bit is set right	// so the viewpoint doesn't interpolate through the	// world to the new position	flags = player->ps.eFlags;	memset( &player->ps, 0, sizeof( player->ps ) );	player->ps.eFlags = flags;	// locate ent at a spawn point	PlayerSpawn( ent );	if ( player->pers.initialSpawn && !g_singlePlayer.integer ) {		if ( g_gametype.integer != GT_TOURNAMENT ) {			BroadcastTeamChange( player, -1 );		}	}	player->pers.initialSpawn = qfalse;	G_LogPrintf( "PlayerBegin: %i/n", playerNum );	// count current players and rank for scoreboard	CalculateRanks();}