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

void G_PlayerAward( edict_t *ent, const char *awardMsg ){	edict_t *other;	char cmd[MAX_STRING_CHARS];	gameaward_t *ga;	int i, size;	score_stats_t *stats;	if( !awardMsg || !awardMsg[0] || !ent->r.client )		return;	Q_snprintfz( cmd, sizeof( cmd ), "aw /"%s/"", awardMsg );	trap_GameCmd( ent, cmd );	if( dedicated->integer )		G_Printf( "%s", COM_RemoveColorTokens( va( "%s receives a '%s' award./n", ent->r.client->netname, awardMsg ) ) );	ent->r.client->level.stats.awards++;	teamlist[ent->s.team].stats.awards++;	G_Gametype_ScoreEvent( ent->r.client, "award", awardMsg );	stats = &ent->r.client->level.stats;	if( !stats->awardAllocator )		stats->awardAllocator = LinearAllocator( sizeof( gameaward_t ), 0, _G_LevelMalloc, _G_LevelFree );	// ch : this doesnt work for race right?	if( GS_MatchState() == MATCH_STATE_PLAYTIME || GS_MatchState() == MATCH_STATE_POSTMATCH )	{		// ch : we store this locally to send to MM		// first check if we already have this one on the clients list		size = LA_Size( stats->awardAllocator );		ga = NULL;		for( i = 0; i < size; i++ )		{			ga = ( gameaward_t * )LA_Pointer( stats->awardAllocator, i );			if( !strncmp( ga->name, awardMsg, sizeof(ga->name)-1 ) )				break;		}		if( i >= size )		{			ga = ( gameaward_t * )LA_Alloc( stats->awardAllocator );			memset( ga, 0, sizeof(*ga) );			ga->name = G_RegisterLevelString( awardMsg );		}		if( ga )			ga->count++;	}	// add it to every player who's chasing this player	for( other = game.edicts + 1; PLAYERNUM( other ) < gs.maxclients; other++ )	{		if( !other->r.client || !other->r.inuse || !other->r.client->resp.chase.active )			continue;		if( other->r.client->resp.chase.target == ENTNUM( ent ) )			trap_GameCmd( other, cmd );	}}

/** G_Match_NotReady*/void G_Match_NotReady( edict_t *ent ){	if( ent->s.team == TEAM_SPECTATOR )	{		G_PrintMsg( ent, "Join the game first/n" );		return;	}	if( GS_MatchState() != MATCH_STATE_WARMUP && GS_MatchState() != MATCH_STATE_COUNTDOWN )	{		G_PrintMsg( ent, "A match is not being setup./n" );		return;	}	if( !level.ready[PLAYERNUM( ent )] )	{		G_PrintMsg( ent, "You weren't ready./n" );		return;	}	level.ready[PLAYERNUM( ent )] = false;	G_PrintMsg( NULL, "%s%s is no longer ready./n", ent->r.client->netname, S_COLOR_WHITE );	G_UpdatePlayerMatchMsg( ent );	G_Match_CheckReadys();}

static void G_Gametype_GENERIC_ThinkRules( void ){	if( G_Match_ScorelimitHit() || G_Match_TimelimitHit() || G_Match_SuddenDeathFinished() )		G_Match_LaunchState( GS_MatchState() + 1 );	if( GS_MatchState() >= MATCH_STATE_POSTMATCH )		return;}

/** G_Teams_ExecuteChallengersQueue*/void G_Teams_ExecuteChallengersQueue( void ){	edict_t *ent;	edict_t **challengers;	bool restartmatch = false;	// Medar fixme: this is only really makes sense, if playerlimit per team is one	if( GS_MatchState() == MATCH_STATE_PLAYTIME )		return;	if( !GS_HasChallengers() )		return;	if( game.realtime < level.spawnedTimeStamp + G_CHALLENGERS_MIN_JOINTEAM_MAPTIME )	{		static int time, lasttime;		time = (int)( ( G_CHALLENGERS_MIN_JOINTEAM_MAPTIME - ( game.realtime - level.spawnedTimeStamp ) )*0.001 );		if( lasttime && time == lasttime )			return;		lasttime = time;		if( lasttime )			G_CenterPrintFormatMsg( NULL, "Waiting... %s", va( "%i", lasttime ), NULL );		else			G_CenterPrintMsg( NULL, "" );		return;	}	// pick players in join order and try to put them in the	// game until we get the first refused one.	challengers = G_Teams_ChallengersQueue();	if( challengers )	{		int i;		for( i = 0; challengers[i]; i++ )		{			ent = challengers[i];			if( !G_Teams_JoinAnyTeam( ent, true ) )				break;			// if we successfully execute the challengers queue during the countdown, revert to warmup			if( GS_MatchState() == MATCH_STATE_COUNTDOWN )			{				restartmatch = true;			}		}	}	if( restartmatch == true )	{		G_Match_Autorecord_Cancel();		G_Match_LaunchState( MATCH_STATE_WARMUP );	}}

static bool G_Gametype_GENERIC_MatchStateFinished( int incomingMatchState ){	if( GS_MatchState() <= MATCH_STATE_WARMUP && incomingMatchState > MATCH_STATE_WARMUP		&& incomingMatchState < MATCH_STATE_POSTMATCH )		G_Match_Autorecord_Start();	if( GS_MatchState() == MATCH_STATE_POSTMATCH )		G_Match_Autorecord_Stop();	return true;}

static void G_Gametype_GENERIC_ThinkRules( void ){	if( G_Match_ScorelimitHit() || G_Match_TimelimitHit() || G_Match_SuddenDeathFinished() ){	G_CenterPrintMsg( NULL, "ENDOOOOOOOOOOOOOOOOO saaaaan!!!!!!!!!!/n" );		G_Match_LaunchState( GS_MatchState() + 1 );}	if( GS_MatchState() >= MATCH_STATE_POSTMATCH )		return;}

/** ClientDisconnect* Called when a player drops from the server.* Will not be called between levels.*/void ClientDisconnect( edict_t *ent, const char *reason ){	int team;	if( !ent->r.client || !ent->r.inuse )		return;	// always report in RACE mode	if( GS_RaceGametype() 		|| ( ent->r.client->team != TEAM_SPECTATOR && ( GS_MatchState() == MATCH_STATE_PLAYTIME || GS_MatchState() == MATCH_STATE_POSTMATCH ) ) )		G_AddPlayerReport( ent, GS_MatchState() == MATCH_STATE_POSTMATCH );	for( team = TEAM_PLAYERS; team < GS_MAX_TEAMS; team++ )		G_Teams_UnInvitePlayer( team, ent );	if( !level.gametype.disableObituaries || !(ent->r.svflags & SVF_FAKECLIENT ) )	{		if( !reason )			G_PrintMsg( NULL, "%s" S_COLOR_WHITE " disconnected/n", ent->r.client->netname );		else			G_PrintMsg( NULL, "%s" S_COLOR_WHITE " disconnected (%s" S_COLOR_WHITE ")/n", ent->r.client->netname, reason );	}	// send effect	if( ent->s.team > TEAM_SPECTATOR )		G_TeleportEffect( ent, false );	ent->r.client->team = TEAM_SPECTATOR;	G_ClientRespawn( ent, true ); // respawn as ghost	ent->movetype = MOVETYPE_NOCLIP; // allow freefly	// let the gametype scripts know this client just disconnected	G_Gametype_ScoreEvent( ent->r.client, "disconnect", NULL );	G_FreeAI( ent );	AI_EnemyRemoved( ent );	ent->r.inuse = false;	ent->r.svflags = SVF_NOCLIENT;	memset( ent->r.client, 0, sizeof( *ent->r.client ) );	ent->r.client->ps.playerNum = PLAYERNUM( ent );	trap_ConfigString( CS_PLAYERINFOS+PLAYERNUM( ent ), "" );	GClip_UnlinkEntity( ent );	G_Match_CheckReadys();}

/** Cmd_Say_f*/void Cmd_Say_f( edict_t *ent, bool arg0, bool checkflood ){	char *p;	char text[2048];	size_t arg0len = 0;#ifdef AUTHED_SAY	if( sv_mm_enable->integer && ent->r.client && ent->r.client->mm_session <= 0 )	{		// unauthed players are only allowed to chat to public at non play-time		if( GS_MatchState() == MATCH_STATE_PLAYTIME )		{			G_PrintMsg( ent, "%s", S_COLOR_YELLOW "You must authenticate to be able to communicate to other players during the match./n");			return;		}	}#endif	if( checkflood )	{		if( CheckFlood( ent, false ) )			return;	}	if( ent->r.client && ( ent->r.client->muted & 1 ) )		return;	if( trap_Cmd_Argc() < 2 && !arg0 )		return;	text[0] = 0;	if( arg0 )	{		Q_strncatz( text, trap_Cmd_Argv( 0 ), sizeof( text ) );		Q_strncatz( text, " ", sizeof( text ) );		arg0len = strlen( text );		Q_strncatz( text, trap_Cmd_Args(), sizeof( text ) );	}	else	{		p = trap_Cmd_Args();		if( *p == '"' )		{			if( p[strlen( p )-1] == '"' )				p[strlen( p )-1] = 0;			p++;		}		Q_strncatz( text, p, sizeof( text ) );	}	// don't let text be too long for malicious reasons	text[arg0len + (MAX_CHAT_BYTES - 1)] = 0;	if( !Q_stricmp( text, "gg" ) || !Q_stricmp( text, "good game" ) )		G_AwardFairPlay( ent );	G_ChatMsg( NULL, ent, false, "%s", text );}

void SetRespawn( edict_t *ent, int delay ){	if( !ent->item )		return;	if( delay < 0 )	{		G_FreeEdict( ent );		return;	}	ent->r.solid = SOLID_NOT;	ent->nextThink = level.time + delay;	ent->think = DoRespawn;	if( GS_MatchState() == MATCH_STATE_WARMUP ) {		ent->s.effects |= EF_GHOST;	}	else {		ent->r.svflags |= SVF_NOCLIENT;	}	// megahealth is different	if( ( ent->spawnflags & ITEM_TIMED ) && ent->r.owner )	{		if( ent->item->type == IT_HEALTH )		{			ent->think = MegaHealth_think;			ent->nextThink = level.time + 1;		}	}	GClip_LinkEntity( ent );}

void G_AwardFairPlay( edict_t *ent ){	// only award during postmatch	if( GS_MatchState() != MATCH_STATE_POSTMATCH ) {		return;	}	if( level.finalMatchDuration <= SIGNIFICANT_MATCH_DURATION ) {		return;	}	gclient_t *client = ent->r.client;	// don't try to give the award to the server console	if( !client ) {		return;	}	// already awarded	if( client->resp.awardInfo.fairplay_award ) {		return;	}	// the player must not be muted during the match	if( client->level.stats.muted_count > 0 ) {		return;	}	// has he actually played?	if( !client->level.stats.had_playtime ) {		return;	}	client->level.stats.fairplay_count++;	client->resp.awardInfo.fairplay_award = true;	G_PlayerAward( ent, S_COLOR_CYAN "Fair Play!" );}

/** G_Teams_SetTeam - sets clients team without any checking*/void G_Teams_SetTeam( edict_t *ent, int team ){	assert( ent && ent->r.inuse && ent->r.client );	assert( team >= TEAM_SPECTATOR && team < GS_MAX_TEAMS );	// if player was on a team, send partial report to matchmaker	if( ent->r.client->team != TEAM_SPECTATOR && ent->r.client->team != team && GS_MatchState() == MATCH_STATE_PLAYTIME )	{		G_Printf("Sending teamchange to MM, team %d to team %d/n", ent->r.client->team, team );		G_AddPlayerReport( ent, false );		// trap_MR_SendPartialReport();	}	// clear scores at changing team	memset( &ent->r.client->level.stats, 0, sizeof( ent->r.client->level.stats ) );	memset( &ent->r.client->teamstate, 0, sizeof( ent->r.client->teamstate ) );	ent->r.client->team = team;	ent->r.client->teamstate.timeStamp = level.time;	G_Teams_UnInvitePlayer( team, ent );	G_ClientRespawn( ent, true ); // make ghost using G_ClientRespawn so team is updated at ghosting	G_SpawnQueue_AddClient( ent );	level.ready[PLAYERNUM( ent )] = false;	G_Match_CheckReadys();	G_UpdatePlayerMatchMsg( ent );}

/** G_Match_ScorelimitHit*/bool G_Match_ScorelimitHit( void ){	edict_t	*e;	if( GS_MatchState() != MATCH_STATE_PLAYTIME )		return false;	if( g_scorelimit->integer )	{		if( !GS_TeamBasedGametype() )		{			for( e = game.edicts+1; PLAYERNUM( e ) < gs.maxclients; e++ )			{				if( !e->r.inuse )					continue;				if( e->r.client->level.stats.score >= g_scorelimit->integer )					return true;			}		}		else		{			int team;			for( team = TEAM_ALPHA; team < GS_MAX_TEAMS; team++ )			{				if( teamlist[team].stats.score >= g_scorelimit->integer )					return true;			}		}	}	return false;}

/** G_Match_Ready*/void G_Match_Ready( edict_t *ent ){	if( ent->r.svflags & SVF_FAKECLIENT && level.ready[PLAYERNUM( ent )] == true )		return;	if( ent->s.team == TEAM_SPECTATOR )	{		G_PrintMsg( ent, "Join the game first/n" );		return;	}	if( GS_MatchState() != MATCH_STATE_WARMUP )	{		if( !( ent->r.svflags & SVF_FAKECLIENT ) )			G_PrintMsg( ent, "We're not in warmup./n" );		return;	}	if( level.ready[PLAYERNUM( ent )] )	{		G_PrintMsg( ent, "You are already ready./n" );		return;	}	level.ready[PLAYERNUM( ent )] = true;	G_PrintMsg( NULL, "%s%s is ready!/n", ent->r.client->netname, S_COLOR_WHITE );	G_UpdatePlayerMatchMsg( ent );	G_Match_CheckReadys();}

/** G_Match_TimelimitHit*/bool G_Match_TimelimitHit( void ){	// check for timelimit hit	if( !GS_MatchDuration() || game.serverTime < GS_MatchEndTime() )		return false;	if( GS_MatchState() == MATCH_STATE_WARMUP )		level.forceStart = true; // force match starting when timelimit is up, even if someone goes unready	if( GS_MatchState() == MATCH_STATE_WAITEXIT )	{		level.exitNow = true;		return false; // don't advance into next state. The match will be restarted	}	return true;}

/** G_ClientEndSnapFrame* * Called for each player at the end of the server frame* and right after spawning*/void G_ClientEndSnapFrame( edict_t *ent ){	gclient_t *client;	int i;	if( trap_GetClientState( PLAYERNUM( ent ) ) < CS_SPAWNED )		return;	client = ent->r.client;	// set fov	if( !client->ps.pmove.stats[PM_STAT_ZOOMTIME] )		client->ps.fov = ent->r.client->fov;	else	{		float frac = (float)client->ps.pmove.stats[PM_STAT_ZOOMTIME] / (float)ZOOMTIME;		client->ps.fov = client->fov - ( (float)( client->fov - client->zoomfov ) * frac );	}	// If the end of unit layout is displayed, don't give	// the player any normal movement attributes	if( GS_MatchState() >= MATCH_STATE_POSTMATCH )	{		G_SetClientStats( ent );	}	else	{		if( G_IsDead( ent ) && !level.gametype.customDeadBodyCam )		{			G_Client_DeadView( ent );		}		G_PlayerWorldEffects( ent ); // burn from lava, etc		G_ClientDamageFeedback( ent ); // show damage taken along the snap		G_SetClientStats( ent );		G_SetClientEffects( ent );		G_SetClientSound( ent );		G_SetClientFrame( ent );		client->ps.plrkeys = client->resp.snap.plrkeys;	}	G_ReleaseClientPSEvent( client );	// set the delta angle	for( i = 0; i < 3; i++ )		client->ps.pmove.delta_angles[i] = ANGLE2SHORT( client->ps.viewangles[i] ) - client->ucmd.angles[i];	// this is pretty hackish. We exploit the fact that servers *do not* transmit	// origin2/old_origin for ET_PLAYER/ET_CORPSE entities, and we use it for sending the player velocity	if( !G_ISGHOSTING( ent ) )	{		ent->r.svflags |= SVF_TRANSMITORIGIN2;		VectorCopy( ent->velocity, ent->s.origin2 );	}	else		ent->r.svflags &= ~SVF_TRANSMITORIGIN2;}

void G_Gametype_GENERIC_ClientRespawn( edict_t *self, int old_team, int new_team ){	int i;	gclient_t *client = self->r.client;	gs_weapon_definition_t *weapondef;	if( G_ISGHOSTING( self ) )		return;	//give default items	if( self->s.team != TEAM_SPECTATOR )	{		if( GS_Instagib() )		{			client->ps.inventory[WEAP_INSTAGUN] = 1;			client->ps.inventory[AMMO_INSTAS] = 1;			client->ps.inventory[AMMO_WEAK_INSTAS] = 1;		}		else		{			if( GS_MatchState() <= MATCH_STATE_WARMUP )			{				for( i = WEAP_GUNBLADE; i < WEAP_TOTAL; i++ )				{					if( i == WEAP_INSTAGUN )  // dont add instagun...						continue;					weapondef = GS_GetWeaponDef( i );					client->ps.inventory[i] = 1;					if( weapondef->firedef_weak.ammo_id )						client->ps.inventory[weapondef->firedef_weak.ammo_id] = weapondef->firedef_weak.ammo_max;					if( weapondef->firedef.ammo_id )						client->ps.inventory[weapondef->firedef.ammo_id] = weapondef->firedef.ammo_max;				}				client->resp.armor = GS_Armor_MaxCountForTag( ARMOR_YA );			}			else			{				weapondef = GS_GetWeaponDef( WEAP_GUNBLADE );				client->ps.inventory[WEAP_GUNBLADE] = 1;				client->ps.inventory[AMMO_GUNBLADE] = weapondef->firedef.ammo_max;;				client->ps.inventory[AMMO_WEAK_GUNBLADE] = 0;			}		}	}	// select rocket launcher if available	if( GS_CheckAmmoInWeapon( &client->ps, WEAP_ROCKETLAUNCHER ) )		client->ps.stats[STAT_PENDING_WEAPON] = WEAP_ROCKETLAUNCHER;	else		client->ps.stats[STAT_PENDING_WEAPON] = GS_SelectBestWeapon( &client->ps );	// add a teleportation effect	if( self->r.solid != SOLID_NOT )		G_RespawnEffect( self );}

/** G_GameTypes_DenyJoinTeam*/static int G_GameTypes_DenyJoinTeam( edict_t *ent, int team ){	if( team < 0 || team >= GS_MAX_TEAMS )	{		G_Printf( "WARNING: 'G_GameTypes_CanJoinTeam' parsing a unrecognized team value/n" );		return ER_TEAM_INVALID;	}	if( team == TEAM_SPECTATOR )		return ER_TEAM_OK;	if( GS_MatchState() > MATCH_STATE_PLAYTIME )		return ER_TEAM_MATCHSTATE;	// waiting for chanllengers queue to be executed	if( GS_HasChallengers() &&		game.realtime < level.spawnedTimeStamp + (unsigned)( G_CHALLENGERS_MIN_JOINTEAM_MAPTIME + game.snapFrameTime ) )		return ER_TEAM_CHALLENGERS;	// force eveyone to go through queue so things work on map change	if( GS_HasChallengers() && !ent->r.client->queueTimeStamp )		return ER_TEAM_CHALLENGERS;	//see if team is locked	if( G_Teams_TeamIsLocked( team ) && !G_Teams_PlayerIsInvited( team, ent ) )		return ER_TEAM_LOCKED;	if( GS_TeamBasedGametype() )	{		if( team >= TEAM_ALPHA && team < GS_MAX_TEAMS )		{			// see if team is full			int count = teamlist[team].numplayers;			if( ( count + 1 > level.gametype.maxPlayersPerTeam &&				level.gametype.maxPlayersPerTeam > 0 ) ||				( count + 1 > g_teams_maxplayers->integer &&				g_teams_maxplayers->integer > 0 ) )				return ER_TEAM_FULL;			if( !g_teams_allow_uneven->integer && !G_Teams_CanKeepEvenTeam( ent->s.team, team ) )				return ER_TEAM_UNEVEN;			return ER_TEAM_OK;		}		else		{			return ER_TEAM_INVALID;		}	}	else if( team == TEAM_PLAYERS )	{		return ER_TEAM_OK;	}	return ER_TEAM_INVALID;}

/** SelectSpawnPoint* * Chooses a player start, deathmatch start, etc*/void SelectSpawnPoint( edict_t *ent, edict_t **spawnpoint, vec3_t origin, vec3_t angles ){	edict_t	*spot = NULL;	if( GS_MatchState() >= MATCH_STATE_POSTMATCH )	{		spot = G_SelectIntermissionSpawnPoint();	}	else 	{		if( game.asEngine != NULL )			spot = GT_asCallSelectSpawnPoint( ent );		if( !spot )			spot = SelectDeathmatchSpawnPoint( ent );	}	// find a single player start spot	if( !spot )	{		spot = G_Find( spot, FOFS( classname ), "info_player_start" );		if( !spot )		{			spot = G_Find( spot, FOFS( classname ), "team_CTF_alphaspawn" );			if( !spot )				spot = G_Find( spot, FOFS( classname ), "team_CTF_betaspawn" );			if( !spot )				spot = world;		}	}	*spawnpoint = spot;	VectorCopy( spot->s.origin, origin );	VectorCopy( spot->s.angles, angles );	if( !Q_stricmp( spot->classname, "info_player_intermission" ) )	{		// if it has a target, look towards it		if( spot->target )		{			vec3_t dir;			edict_t *target;			target = G_PickTarget( spot->target );			if( target )			{				VectorSubtract( target->s.origin, origin, dir );				VecToAngles( dir, angles );			}		}	}	// SPAWN TELEFRAGGING PROTECTION.	if( ent->r.solid == SOLID_YES && ( level.gametype.spawnpointRadius > ( playerbox_stand_maxs[0] - playerbox_stand_mins[0] ) ) )		G_OffsetSpawnPoint( origin, playerbox_stand_mins, playerbox_stand_maxs, level.gametype.spawnpointRadius, 			!( spot->spawnflags & 1 ) ? true : false );}

void Bot::ActiveFrame(){    //get ready if in the game    if(GS_MatchState() <= MATCH_STATE_WARMUP && !IsReady() && self->r.client->teamstate.timeStamp + 4000 < level.time)        G_Match_Ready(self);    ApplyPendingTurnToLookAtPoint();    const CombatTask &combatTask = botBrain.combatTask;    bool inhibitShooting, inhibitCombatMove;    SetCombatInhibitionFlags(&inhibitShooting, &inhibitCombatMove);    // ucmd modification in FireWeapon() will be overwritten by MoveFrame()    bool fireButtonPressed = false;    if (!inhibitShooting)    {        SetCloakEnabled(false);        // If bot fired builtin or script weapon, save builtin fire button status        FireWeapon(&fireButtonPressed);    }    else    {        if (!combatTask.Empty())        {            SetCloakEnabled(true);        }        else if (botBrain.HasGoal())        {            if (botBrain.IsCloseToAnyGoal(768.0f, true))                SetCloakEnabled(true);            else if (botBrain.IsCloseToAnyGoal(384.0f, false))                SetCloakEnabled(true);            else                SetCloakEnabled(false);        }        else        {            SetCloakEnabled(false);        }    }    bool beSilent = ShouldBeSilent(inhibitShooting);    // Do not modify pmove features by beSilent value, features may be changed dynamically by script.    usercmd_t ucmd;    memset(&ucmd, 0, sizeof(ucmd));    MoveFrame(&ucmd, inhibitCombatMove, beSilent);    if (fireButtonPressed)        ucmd.buttons |= BUTTON_ATTACK;    CallActiveClientThink(&ucmd);    SayVoiceMessages();}

/** G_Match_SuddenDeathFinished*/bool G_Match_SuddenDeathFinished( void ){	if( GS_MatchState() != MATCH_STATE_PLAYTIME )		return false;	if( !GS_MatchExtended() || GS_MatchDuration() )		return false;	return G_Match_Tied() ? false : true;}

/** G_PlayerCanTeleport** Checks if the player can be teleported.*/bool G_PlayerCanTeleport( edict_t *player ){	if ( !player->r.client )		return false;	if ( player->r.client->ps.pmove.pm_type > PM_SPECTATOR )		return false;	if ( GS_MatchState( ) == MATCH_STATE_COUNTDOWN ) // match countdown		return false;	return true;}

/** * Checks if the scoreboard column of the specific type needs to be skipped. * * @param type the column type * @return whether the column needs to be skipped */static bool SCR_SkipColumn( char type ){	switch( type )	{	case 'r':		return GS_MatchState() != MATCH_STATE_WARMUP;	}	return false;}

/** G_Killed*/void G_Killed( edict_t *targ, edict_t *inflictor, edict_t *attacker, int damage, const vec3_t point, int mod ){	if( targ->health < -999 )		targ->health = -999;	if( targ->deadflag == DEAD_DEAD )		return;	targ->deadflag = DEAD_DEAD;	targ->enemy = attacker;	if( targ->r.client )	{		if( attacker && targ != attacker )		{			if( GS_IsTeamDamage( &targ->s, &attacker->s ) )				attacker->snap.teamkill = qtrue;			else				attacker->snap.kill = qtrue;		}		// count stats		if( GS_MatchState() == MATCH_STATE_PLAYTIME )		{			targ->r.client->level.stats.deaths++;			teamlist[targ->s.team].stats.deaths++;			if( !attacker || !attacker->r.client || attacker == targ || attacker == world )			{				targ->r.client->level.stats.suicides++;				teamlist[targ->s.team].stats.suicides++;			}			else			{				if( GS_IsTeamDamage( &targ->s, &attacker->s ) )				{					attacker->r.client->level.stats.teamfrags++;					teamlist[attacker->s.team].stats.teamfrags++;				}				else				{					attacker->r.client->level.stats.frags++;					teamlist[attacker->s.team].stats.frags++;					G_AwardPlayerKilled( targ, inflictor, attacker, mod );				}			}		}	}	G_Gametype_ScoreEvent( attacker ? attacker->r.client : NULL, "kill", va( "%i %i %i", targ->s.number, ( inflictor == world ) ? -1 : ENTNUM( inflictor ), ENTNUM( attacker ) ) );	G_CallDie( targ, inflictor, attacker, damage, point );}

/** CG_IsScoreboardShown*/bool CG_IsScoreboardShown( void ){	if( !cgs.configStrings[CS_SCB_PLAYERTAB_LAYOUT][0] ) // no layout defined		return false;	if( scoreboardString[0] != '&' ) // nothing to draw		return false;	if( cgs.demoPlaying || cg.frame.multipov || cgs.tv )		return cg.showScoreboard || ( GS_MatchState() > MATCH_STATE_PLAYTIME );	return ( cg.predictedPlayerState.stats[STAT_LAYOUTS] & STAT_LAYOUT_SCOREBOARD ) ? true : false;}

char *G_Gametype_GENERIC_ScoreboardMessage( void ){	char entry[MAX_TOKEN_CHARS];	size_t len;	int i;	edict_t	*e;	int carrierIcon;	*scoreboardString = 0;	len = 0;	Q_snprintfz( entry, sizeof(entry), "&t %i 0 0 ", TEAM_PLAYERS );	if( SCOREBOARD_MSG_MAXSIZE - len > strlen( entry ) )	{		Q_strncatz( scoreboardString, entry, sizeof( scoreboardString ) );		len = strlen( scoreboardString );	}	// players	for( i = 0; i < teamlist[TEAM_PLAYERS].numplayers; i++ )	{		e = game.edicts + teamlist[TEAM_PLAYERS].playerIndices[i];		if( e->s.effects & EF_CARRIER )			carrierIcon = trap_ImageIndex( ( e->s.team == TEAM_BETA ) ? PATH_ALPHAFLAG_ICON : PATH_BETAFLAG_ICON );		else if( e->s.effects & EF_QUAD )			carrierIcon = trap_ImageIndex( PATH_QUAD_ICON );		else if( e->s.effects & EF_SHELL )			carrierIcon = trap_ImageIndex( PATH_SHELL_ICON );		else if( e->s.effects & EF_REGEN )			carrierIcon = trap_ImageIndex( PATH_REGEN_ICON );		else			carrierIcon = 0;		Q_snprintfz( entry, sizeof( entry ), "&p %i %i %i %i %i ",			PLAYERNUM( e ),			e->r.client->level.stats.score,			e->r.client->r.ping > 999 ? 999 : e->r.client->r.ping,			carrierIcon,			( level.ready[PLAYERNUM( e )] || GS_MatchState() >= MATCH_STATE_PLAYTIME ) ? trap_ImageIndex( PATH_VSAY_YES_ICON ) : 0			);		if( SCOREBOARD_MSG_MAXSIZE - len > strlen( entry ) )		{			Q_strncatz( scoreboardString, entry, sizeof( scoreboardString ) );			len = strlen( scoreboardString );		}	}	return scoreboardString;}

/** G_SetClientEffects*/static void G_SetClientEffects( edict_t *ent ){	gclient_t *client = ent->r.client;	if( G_IsDead( ent ) || GS_MatchState() >= MATCH_STATE_POSTMATCH )		return;	if( client->ps.inventory[POWERUP_QUAD] > 0 )	{		ent->s.effects |= EF_QUAD;		if( client->ps.inventory[POWERUP_QUAD] < 6 )			ent->s.effects |= EF_EXPIRING_QUAD;	}	if( client->ps.inventory[POWERUP_SHELL] > 0 )	{		ent->s.effects |= EF_SHELL;		if( client->ps.inventory[POWERUP_SHELL] < 6 )			ent->s.effects |= EF_EXPIRING_SHELL;				}	if( client->ps.inventory[POWERUP_REGEN] > 0 )	{		ent->s.effects |= EF_REGEN;		if( client->ps.inventory[POWERUP_REGEN] < 6 )			ent->s.effects |= EF_EXPIRING_REGEN;				}	if( ent->s.weapon )	{		firedef_t *firedef = GS_FiredefForPlayerState( &client->ps, ent->s.weapon );		if( firedef && firedef->fire_mode == FIRE_MODE_STRONG )			ent->s.effects |= EF_STRONG_WEAPON;	}	if( client->ps.pmove.stats[PM_STAT_STUN] )		ent->s.effects |= EF_PLAYER_STUNNED;	else		ent->s.effects &= ~EF_PLAYER_STUNNED;	// show cheaters!!!	if( ent->flags & FL_GODMODE )		ent->s.effects |= EF_GODMODE;	// add chatting icon effect	if( ent->r.client->resp.snap.buttons & BUTTON_BUSYICON )		ent->s.effects |= EF_BUSYICON;}

/** G_Client_InactivityRemove*/void G_Client_InactivityRemove( gclient_t *client ){	if( !client )		return;	// racesow	if( !level.gametype.autoInactivityRemove )		return;	// !racesow	if( client->ps.pmove.pm_type != PM_NORMAL )		return;	if( g_inactivity_maxtime->modified )	{		if( g_inactivity_maxtime->value <= 0.0f )			trap_Cvar_ForceSet( "g_inactivity_maxtime", "0.0" );		else if( g_inactivity_maxtime->value < 15.0f )			trap_Cvar_ForceSet( "g_inactivity_maxtime", "15.0" );		g_inactivity_maxtime->modified = false;	}	if( g_inactivity_maxtime->value == 0.0f )		return;	if( ( GS_MatchState() != MATCH_STATE_PLAYTIME ) || !level.gametype.removeInactivePlayers )		return;	// inactive for too long	if( client->level.last_activity && client->level.last_activity + ( g_inactivity_maxtime->value * 1000 ) < level.time )	{		if( client->team >= TEAM_PLAYERS && client->team < GS_MAX_TEAMS )		{			edict_t *ent = &game.edicts[ client - game.clients + 1 ];			// move to spectators and reset the queue time, effectively removing from the challengers queue			G_Teams_SetTeam( ent, TEAM_SPECTATOR );			G_SpawnQueue_RemoveClient( ent ); // racesow - set player in free-view			client->queueTimeStamp = 0;			G_PrintMsg( NULL, "%s" S_COLOR_YELLOW " has been moved to spectator after %.1f seconds of inactivity/n", client->netname, g_inactivity_maxtime->value );		}	}}

void G_PlayerMetaAward( edict_t *ent, const char *awardMsg ){    int i, size;    gameaward_t *ga;    score_stats_t *stats;    /*    * ch : meta-award is an award that isn't announced but    * it is sent to MM    */    if( !awardMsg || !awardMsg[0] || !ent->r.client )        return;    stats = &ent->r.client->level.stats;    if( !stats->awardAllocator )        stats->awardAllocator = LinearAllocator( sizeof( gameaward_t ), 0, _G_LevelMalloc, _G_LevelFree );    // ch : this doesnt work for race right?    if( GS_MatchState() == MATCH_STATE_PLAYTIME )    {        // ch : we store this locally to send to MM        // first check if we already have this one on the clients list        size = LA_Size( stats->awardAllocator );        ga = NULL;        for( i = 0; i < size; i++ )        {            ga = LA_Pointer( stats->awardAllocator, i );            if( !strncmp( ga->name, awardMsg, sizeof(ga->name)-1 ) )                break;        }        if( i >= size )        {            ga = LA_Alloc( stats->awardAllocator );            memset( ga, 0, sizeof(*ga) );            ga->name = G_RegisterLevelString( awardMsg );        }        if( ga )            ga->count++;    }}

void G_Teams_Coach( edict_t *ent ){	if( GS_TeamBasedGametype() && !GS_InvidualGameType() && ent->s.team != TEAM_SPECTATOR )	{		if( !teamlist[ent->s.team].has_coach )		{			if( GS_MatchState() > MATCH_STATE_WARMUP && !GS_MatchPaused() )			{				G_PrintMsg( ent, "Can't set coach mode with the match in progress/n" );			}			else			{				// move to coach mode				ent->r.client->teamstate.is_coach = true;				G_GhostClient( ent );				ent->health = ent->max_health;				ent->deadflag = DEAD_NO;				G_ChasePlayer( ent, NULL, true, 0 );				//clear up his scores				G_Match_Ready( ent ); // set ready and check readys				memset( &ent->r.client->level.stats, 0, sizeof( ent->r.client->level.stats ) );				teamlist[ent->s.team].has_coach = true;				G_PrintMsg( NULL, "%s%s is now team %s coach /n", ent->r.client->netname,					S_COLOR_WHITE, GS_TeamName( ent->s.team ) );			}		}		else if( ent->r.client->teamstate.is_coach )		{                            // if you are this team coach, resign			ent->r.client->teamstate.is_coach = false;			G_PrintMsg( NULL, "%s%s is no longer team %s coach /n", ent->r.client->netname,				S_COLOR_WHITE, GS_TeamName( ent->s.team ) );			G_Teams_SetTeam( ent, ent->s.team );		}		else			G_PrintMsg( ent, "Your team already has a coach./n" );	}	else		G_PrintMsg( ent, "Coaching only valid while on a team in Team based Gametypes./n" );}

static void G_Gametype_GENERIC_MatchStateStarted( void ){	switch( GS_MatchState() )	{//	case MATCH_STATE_WAITING:	case MATCH_STATE_WARMUP:		G_Gametype_GENERIC_SetUpWarmup();		break;	case MATCH_STATE_COUNTDOWN:		G_Gametype_GENERIC_SetUpCountdown();		break;	case MATCH_STATE_PLAYTIME:		G_Gametype_GENERIC_SetUpMatch();		break;	case MATCH_STATE_POSTMATCH:		G_Gametype_GENERIC_SetUpEndMatch();		break;	default:		break;	}}