/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
//

#include "g_local.h"


typedef struct teamgame_s
{
	float           last_flag_capture;
	int             last_capture_team;
	flagStatus_t    redStatus;	// CTF
	flagStatus_t    blueStatus;	// CTF
	flagStatus_t    flagStatus;	// One Flag CTF
	int             redTakenTime;
	int             blueTakenTime;
	int             redObeliskAttackedTime;
	int             blueObeliskAttackedTime;
} teamgame_t;

teamgame_t      teamgame;

gentity_t      *neutralObelisk;

void            Team_SetFlagStatus(int team, flagStatus_t status);

void Team_InitGame(void)
{
	memset(&teamgame, 0, sizeof teamgame);

	switch (g_gametype.integer)
	{
		case GT_CTF:
			teamgame.redStatus = teamgame.blueStatus = -1;	// Invalid to force update
			Team_SetFlagStatus(TEAM_RED, FLAG_ATBASE);
			Team_SetFlagStatus(TEAM_BLUE, FLAG_ATBASE);
			break;
#ifdef MISSIONPACK
		case GT_1FCTF:
			teamgame.flagStatus = -1;	// Invalid to force update
			Team_SetFlagStatus(TEAM_FREE, FLAG_ATBASE);
			break;
#endif
		default:
			break;
	}
}

int OtherTeam(int team)
{
	if(team == TEAM_RED)
		return TEAM_BLUE;
	else if(team == TEAM_BLUE)
		return TEAM_RED;
	return team;
}

const char     *TeamName(int team)
{
	if(team == TEAM_RED)
		return "RED";
	else if(team == TEAM_BLUE)
		return "BLUE";
	else if(team == TEAM_SPECTATOR)
		return "SPECTATOR";
	return "FREE";
}

const char     *OtherTeamName(int team)
{
	if(team == TEAM_RED)
		return "BLUE";
	else if(team == TEAM_BLUE)
		return "RED";
	else if(team == TEAM_SPECTATOR)
		return "SPECTATOR";
	return "FREE";
}

const char     *TeamColorString(int team)
{
	if(team == TEAM_RED)
		return S_COLOR_RED;
	else if(team == TEAM_BLUE)
		return S_COLOR_BLUE;
	else if(team == TEAM_SPECTATOR)
		return S_COLOR_YELLOW;
	return S_COLOR_WHITE;
}

// NULL for everyone
void QDECL PrintMsg(gentity_t * ent, const char *fmt, ...)
{
	char            msg[1024];
	va_list         argptr;
	char           *p;

	va_start(argptr, fmt);
	if(vsprintf(msg, fmt, argptr) > sizeof(msg))
	{
		G_Error("PrintMsg overrun");
	}
	va_end(argptr);

	// double quotes are bad
	while((p = strchr(msg, '"')) != NULL)
		*p = '\'';

	trap_SendServerCommand(((ent == NULL) ? -1 : ent - g_entities), va("print \"%s\"", msg));
}

/*
==============
AddTeamScore

 used for gametype > GT_TEAM
 for gametype GT_TEAM the level.teamScores is updated in AddScore in g_combat.c
==============
*/
void AddTeamScore(vec3_t origin, int team, int score)
{
	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;
		}
	}
	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;
		}
	}
	level.teamScores[team] += score;
}

/*
==============
OnSameTeam
==============
*/
qboolean OnSameTeam(gentity_t * ent1, gentity_t * ent2)
{
	if(!ent1->client || !ent2->client)
	{
		return qfalse;
	}

	if(g_gametype.integer < GT_TEAM)
	{
		return qfalse;
	}

	if(ent1->client->sess.sessionTeam == ent2->client->sess.sessionTeam)
	{
		return qtrue;
	}

	return qfalse;
}


static char     ctfFlagStatusRemap[] = { '0', '1', '*', '*', '2' };
static char     oneFlagStatusRemap[] = { '0', '1', '2', '3', '4' };

void Team_SetFlagStatus(int team, flagStatus_t status)
{
	qboolean        modified = qfalse;

	switch (team)
	{
		case TEAM_RED:			// CTF
			if(teamgame.redStatus != status)
			{
				teamgame.redStatus = status;
				modified = qtrue;
			}
			break;

		case TEAM_BLUE:		// CTF
			if(teamgame.blueStatus != status)
			{
				teamgame.blueStatus = status;
				modified = qtrue;
			}
			break;

		case TEAM_FREE:		// One Flag CTF
			if(teamgame.flagStatus != status)
			{
				teamgame.flagStatus = status;
				modified = qtrue;
			}
			break;
	}

	if(modified)
	{
		char            st[4];

		if(g_gametype.integer == GT_CTF)
		{
			st[0] = ctfFlagStatusRemap[teamgame.redStatus];
			st[1] = ctfFlagStatusRemap[teamgame.blueStatus];
			st[2] = 0;
		}
		else
		{						// GT_1FCTF
			st[0] = oneFlagStatusRemap[teamgame.flagStatus];
			st[1] = 0;
		}

		trap_SetConfigstring(CS_FLAGSTATUS, st);
	}
}

void Team_CheckDroppedItem(gentity_t * dropped)
{
	if(dropped->item->giTag == PW_REDFLAG)
	{
		Team_SetFlagStatus(TEAM_RED, FLAG_DROPPED);
	}
	else if(dropped->item->giTag == PW_BLUEFLAG)
	{
		Team_SetFlagStatus(TEAM_BLUE, FLAG_DROPPED);
	}
	else if(dropped->item->giTag == PW_NEUTRALFLAG)
	{
		Team_SetFlagStatus(TEAM_FREE, FLAG_DROPPED);
	}
}

/*
================
Team_ForceGesture
================
*/
void Team_ForceGesture(int team)
{
	int             i;
	gentity_t      *ent;

	for(i = 0; i < MAX_CLIENTS; i++)
	{
		ent = &g_entities[i];
		if(!ent->inuse)
			continue;
		if(!ent->client)
			continue;
		if(ent->client->sess.sessionTeam != team)
			continue;
		//
		ent->flags |= FL_FORCE_GESTURE;
	}
}

/*
================
Team_FragBonuses

Calculate the bonuses for flag defense, flag carrier defense, etc.
Note that bonuses are not cumulative.  You get one, they are in importance
order.
================
*/
void Team_FragBonuses(gentity_t * targ, gentity_t * inflictor, gentity_t * attacker)
{
	int             i;
	gentity_t      *ent;
	int             flag_pw, enemy_flag_pw;
	int             otherteam;
	int             tokens;
	gentity_t      *flag, *carrier = NULL;
	char           *c;
	vec3_t          v1, v2;
	int             team;

	// no bonus for fragging yourself or team mates
	if(!targ->client || !attacker->client || targ == attacker || OnSameTeam(targ, attacker))
		return;

	team = targ->client->sess.sessionTeam;
	otherteam = OtherTeam(targ->client->sess.sessionTeam);
	if(otherteam < 0)
		return;					// whoever died isn't on a team

	// same team, if the flag at base, check to he has the enemy flag
	if(team == TEAM_RED)
	{
		flag_pw = PW_REDFLAG;
		enemy_flag_pw = PW_BLUEFLAG;
	}
	else
	{
		flag_pw = PW_BLUEFLAG;
		enemy_flag_pw = PW_REDFLAG;
	}

	if(g_gametype.integer == GT_1FCTF)
	{
		enemy_flag_pw = PW_NEUTRALFLAG;
	}

	// did the attacker frag the flag carrier?
	tokens = 0;
#ifdef MISSIONPACK
	if(g_gametype.integer == GT_HARVESTER)
	{
		tokens = targ->client->ps.generic1;
	}
#endif
	if(targ->client->ps.powerups[enemy_flag_pw])
	{
		attacker->client->pers.teamState.lastfraggedcarrier = level.time;
		AddScore(attacker, targ->r.currentOrigin, CTF_FRAG_CARRIER_BONUS);
		attacker->client->pers.teamState.fragcarrier++;
		PrintMsg(NULL, "%s" S_COLOR_WHITE " fragged %s's flag carrier!\n", attacker->client->pers.netname, TeamName(team));

		// the target had the flag, clear the hurt carrier
		// field on the other team
		for(i = 0; i < g_maxclients.integer; i++)
		{
			ent = g_entities + i;
			if(ent->inuse && ent->client->sess.sessionTeam == otherteam)
				ent->client->pers.teamState.lasthurtcarrier = 0;
		}
		return;
	}

	// did the attacker frag a head carrier? other->client->ps.generic1
	if(tokens)
	{
		attacker->client->pers.teamState.lastfraggedcarrier = level.time;
		AddScore(attacker, targ->r.currentOrigin, CTF_FRAG_CARRIER_BONUS * tokens * tokens);
		attacker->client->pers.teamState.fragcarrier++;
		PrintMsg(NULL, "%s" S_COLOR_WHITE " fragged %s's skull carrier!\n", attacker->client->pers.netname, TeamName(team));

		// the target had the flag, clear the hurt carrier
		// field on the other team
		for(i = 0; i < g_maxclients.integer; i++)
		{
			ent = g_entities + i;
			if(ent->inuse && ent->client->sess.sessionTeam == otherteam)
				ent->client->pers.teamState.lasthurtcarrier = 0;
		}
		return;
	}

	if(targ->client->pers.teamState.lasthurtcarrier &&
	   level.time - targ->client->pers.teamState.lasthurtcarrier < CTF_CARRIER_DANGER_PROTECT_TIMEOUT &&
	   !attacker->client->ps.powerups[flag_pw])
	{
		// attacker is on the same team as the flag carrier and
		// fragged a guy who hurt our flag carrier
		AddScore(attacker, targ->r.currentOrigin, CTF_CARRIER_DANGER_PROTECT_BONUS);

		attacker->client->pers.teamState.carrierdefense++;
		targ->client->pers.teamState.lasthurtcarrier = 0;

		attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
		team = attacker->client->sess.sessionTeam;
		// 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_DEFEND;
		attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;

		return;
	}

	if(targ->client->pers.teamState.lasthurtcarrier &&
	   level.time - targ->client->pers.teamState.lasthurtcarrier < CTF_CARRIER_DANGER_PROTECT_TIMEOUT)
	{
		// attacker is on the same team as the skull carrier and
		AddScore(attacker, targ->r.currentOrigin, CTF_CARRIER_DANGER_PROTECT_BONUS);

		attacker->client->pers.teamState.carrierdefense++;
		targ->client->pers.teamState.lasthurtcarrier = 0;

		attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
		team = attacker->client->sess.sessionTeam;
		// 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_DEFEND;
		attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;

		return;
	}

	// flag and flag carrier area defense bonuses

	// we have to find the flag and carrier entities

#ifdef MISSIONPACK
	if(g_gametype.integer == GT_OBELISK)
	{
		// find the team obelisk
		switch (attacker->client->sess.sessionTeam)
		{
			case TEAM_RED:
				c = "team_redobelisk";
				break;
			case TEAM_BLUE:
				c = "team_blueobelisk";
				break;
			default:
				return;
		}

	}
	else if(g_gametype.integer == GT_HARVESTER)
	{
		// find the center obelisk
		c = "team_neutralobelisk";
	}
	else
	{
#endif
		// find the flag
		switch (attacker->client->sess.sessionTeam)
		{
			case TEAM_RED:
				c = "team_CTF_redflag";
				break;
			case TEAM_BLUE:
				c = "team_CTF_blueflag";
				break;
			default:
				return;
		}
		// find attacker's team's flag carrier
		for(i = 0; i < g_maxclients.integer; i++)
		{
			carrier = g_entities + i;
			if(carrier->inuse && carrier->client->ps.powerups[flag_pw])
				break;
			carrier = NULL;
		}
#ifdef MISSIONPACK
	}
#endif
	flag = NULL;
	while((flag = G_Find(flag, FOFS(classname), c)) != NULL)
	{
		if(!(flag->flags & FL_DROPPED_ITEM))
			break;
	}

	if(!flag)
		return;					// can't find attacker's flag

	// ok we have the attackers flag and a pointer to the carrier

	// check to see if we are defending the base's flag
	VectorSubtract(targ->r.currentOrigin, flag->r.currentOrigin, v1);
	VectorSubtract(attacker->r.currentOrigin, flag->r.currentOrigin, v2);

	if(((VectorLength(v1) < CTF_TARGET_PROTECT_RADIUS &&
		 trap_InPVS(flag->r.currentOrigin, targ->r.currentOrigin)) ||
		(VectorLength(v2) < CTF_TARGET_PROTECT_RADIUS &&
		 trap_InPVS(flag->r.currentOrigin, attacker->r.currentOrigin))) &&
	   attacker->client->sess.sessionTeam != targ->client->sess.sessionTeam)
	{

		// we defended the base flag
		AddScore(attacker, targ->r.currentOrigin, CTF_FLAG_DEFENSE_BONUS);
		attacker->client->pers.teamState.basedefense++;

		attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
		// 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_DEFEND;
		attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;

		return;
	}

	if(carrier && carrier != attacker)
	{
		VectorSubtract(targ->r.currentOrigin, carrier->r.currentOrigin, v1);
		VectorSubtract(attacker->r.currentOrigin, carrier->r.currentOrigin, v1);

		if(((VectorLength(v1) < CTF_ATTACKER_PROTECT_RADIUS &&
			 trap_InPVS(carrier->r.currentOrigin, targ->r.currentOrigin)) ||
			(VectorLength(v2) < CTF_ATTACKER_PROTECT_RADIUS &&
			 trap_InPVS(carrier->r.currentOrigin, attacker->r.currentOrigin))) &&
		   attacker->client->sess.sessionTeam != targ->client->sess.sessionTeam)
		{
			AddScore(attacker, targ->r.currentOrigin, CTF_CARRIER_PROTECT_BONUS);
			attacker->client->pers.teamState.carrierdefense++;

			attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
			// 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_DEFEND;
			attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;

			return;
		}
	}
}

/*
================
Team_CheckHurtCarrier

Check to see if attacker hurt the flag carrier.  Needed when handing out bonuses for assistance to flag
carrier defense.
================
*/
void Team_CheckHurtCarrier(gentity_t * targ, gentity_t * attacker)
{
	int             flag_pw;

	if(!targ->client || !attacker->client)
		return;

	if(targ->client->sess.sessionTeam == TEAM_RED)
		flag_pw = PW_BLUEFLAG;
	else
		flag_pw = PW_REDFLAG;

	// flags
	if(targ->client->ps.powerups[flag_pw] && targ->client->sess.sessionTeam != attacker->client->sess.sessionTeam)
		attacker->client->pers.teamState.lasthurtcarrier = level.time;

	// skulls
	if(targ->client->ps.generic1 && targ->client->sess.sessionTeam != attacker->client->sess.sessionTeam)
		attacker->client->pers.teamState.lasthurtcarrier = level.time;
}


gentity_t      *Team_ResetFlag(int team)
{
	char           *c;
	gentity_t      *ent, *rent = NULL;

	switch (team)
	{
		case TEAM_RED:
			c = "team_CTF_redflag";
			break;
		case TEAM_BLUE:
			c = "team_CTF_blueflag";
			break;
		case TEAM_FREE:
			c = "team_CTF_neutralflag";
			break;
		default:
			return NULL;
	}

	ent = NULL;
	while((ent = G_Find(ent, FOFS(classname), c)) != NULL)
	{
		if(ent->flags & FL_DROPPED_ITEM)
			G_FreeEntity(ent);
		else
		{
			rent = ent;
			RespawnItem(ent);
		}
	}

	Team_SetFlagStatus(team, FLAG_ATBASE);

	return rent;
}

void Team_ResetFlags(void)
{
	if(g_gametype.integer == GT_CTF)
	{
		Team_ResetFlag(TEAM_RED);
		Team_ResetFlag(TEAM_BLUE);
	}
#ifdef MISSIONPACK
	else if(g_gametype.integer == GT_1FCTF)
	{
		Team_ResetFlag(TEAM_FREE);
	}
#endif
}

void Team_ReturnFlagSound(gentity_t * ent, int team)
{
	gentity_t      *te;

	if(ent == NULL)
	{
		G_Printf("Warning:  NULL passed to Team_ReturnFlagSound\n");
		return;
	}

	te = G_TempEntity(ent->s.pos.trBase, EV_GLOBAL_TEAM_SOUND);
	if(team == TEAM_BLUE)
	{
		te->s.eventParm = GTS_RED_RETURN;
	}
	else
	{
		te->s.eventParm = GTS_BLUE_RETURN;
	}
	te->r.svFlags |= SVF_BROADCAST;
}

void Team_TakeFlagSound(gentity_t * ent, int team)
{
	gentity_t      *te;

	if(ent == NULL)
	{
		G_Printf("Warning:  NULL passed to Team_TakeFlagSound\n");
		return;
	}

	// only play sound when the flag was at the base
	// or not picked up the last 10 seconds
	switch (team)
	{
		case TEAM_RED:
			if(teamgame.blueStatus != FLAG_ATBASE)
			{
				if(teamgame.blueTakenTime > level.time - 10000)
					return;
			}
			teamgame.blueTakenTime = level.time;
			break;

		case TEAM_BLUE:		// CTF
			if(teamgame.redStatus != FLAG_ATBASE)
			{
				if(teamgame.redTakenTime > level.time - 10000)
					return;
			}
			teamgame.redTakenTime = level.time;
			break;
	}

	te = G_TempEntity(ent->s.pos.trBase, EV_GLOBAL_TEAM_SOUND);
	if(team == TEAM_BLUE)
	{
		te->s.eventParm = GTS_RED_TAKEN;
	}
	else
	{
		te->s.eventParm = GTS_BLUE_TAKEN;
	}
	te->r.svFlags |= SVF_BROADCAST;
}

void Team_CaptureFlagSound(gentity_t * ent, int team)
{
	gentity_t      *te;

	if(ent == NULL)
	{
		G_Printf("Warning:  NULL passed to Team_CaptureFlagSound\n");
		return;
	}

	te = G_TempEntity(ent->s.pos.trBase, EV_GLOBAL_TEAM_SOUND);
	if(team == TEAM_BLUE)
	{
		te->s.eventParm = GTS_BLUE_CAPTURE;
	}
	else
	{
		te->s.eventParm = GTS_RED_CAPTURE;
	}
	te->r.svFlags |= SVF_BROADCAST;
}

void Team_ReturnFlag(int team)
{
	Team_ReturnFlagSound(Team_ResetFlag(team), team);
	if(team == TEAM_FREE)
	{
		PrintMsg(NULL, "The flag has returned!\n");
	}
	else
	{
		PrintMsg(NULL, "The %s flag has returned!\n", TeamName(team));
	}
}

void Team_FreeEntity(gentity_t * ent)
{
	if(ent->item->giTag == PW_REDFLAG)
	{
		Team_ReturnFlag(TEAM_RED);
	}
	else if(ent->item->giTag == PW_BLUEFLAG)
	{
		Team_ReturnFlag(TEAM_BLUE);
	}
	else if(ent->item->giTag == PW_NEUTRALFLAG)
	{
		Team_ReturnFlag(TEAM_FREE);
	}
}

/*
==============
Team_DroppedFlagThink

Automatically set in Launch_Item if the item is one of the flags

Flags are unique in that if they are dropped, the base flag must be respawned when they time out
==============
*/
void Team_DroppedFlagThink(gentity_t * ent)
{
	int             team = TEAM_FREE;

	if(ent->item->giTag == PW_REDFLAG)
	{
		team = TEAM_RED;
	}
	else if(ent->item->giTag == PW_BLUEFLAG)
	{
		team = TEAM_BLUE;
	}
	else if(ent->item->giTag == PW_NEUTRALFLAG)
	{
		team = TEAM_FREE;
	}

	Team_ReturnFlagSound(Team_ResetFlag(team), team);
	// Reset Flag will delete this entity
}


/*
==============
Team_DroppedFlagThink
==============
*/
int Team_TouchOurFlag(gentity_t * ent, gentity_t * other, int team)
{
	int             i;
	gentity_t      *player;
	gclient_t      *cl = other->client;
	int             enemy_flag;

#ifdef MISSIONPACK
	if(g_gametype.integer == GT_1FCTF)
	{
		enemy_flag = PW_NEUTRALFLAG;
	}
	else
	{
#endif
		if(cl->sess.sessionTeam == TEAM_RED)
		{
			enemy_flag = PW_BLUEFLAG;
		}
		else
		{
			enemy_flag = PW_REDFLAG;
		}

		if(ent->flags & FL_DROPPED_ITEM)
		{
			// hey, its not home.  return it by teleporting it back
			PrintMsg(NULL, "%s" S_COLOR_WHITE " returned the %s flag!\n", cl->pers.netname, TeamName(team));
			AddScore(other, ent->r.currentOrigin, CTF_RECOVERY_BONUS);
			other->client->pers.teamState.flagrecovery++;
			other->client->pers.teamState.lastreturnedflag = level.time;
			//ResetFlag will remove this entity!  We must return zero
			Team_ReturnFlagSound(Team_ResetFlag(team), team);
			return 0;
		}
#ifdef MISSIONPACK
	}
#endif

	// the flag is at home base.  if the player has the enemy
	// flag, he's just won!
	if(!cl->ps.powerups[enemy_flag])
		return 0;				// We don't have the flag
#ifdef MISSIONPACK
	if(g_gametype.integer == GT_1FCTF)
	{
		PrintMsg(NULL, "%s" S_COLOR_WHITE " captured the flag!\n", cl->pers.netname);
	}
	else
	{
#endif
		PrintMsg(NULL, "%s" S_COLOR_WHITE " captured the %s flag!\n", cl->pers.netname, TeamName(OtherTeam(team)));
#ifdef MISSIONPACK
	}
#endif

	cl->ps.powerups[enemy_flag] = 0;

	teamgame.last_flag_capture = level.time;
	teamgame.last_capture_team = team;

	// Increase the team's score
	AddTeamScore(ent->s.pos.trBase, other->client->sess.sessionTeam, 1);
	Team_ForceGesture(other->client->sess.sessionTeam);

	other->client->pers.teamState.captures++;
	// 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]++;

	// other gets another 10 frag bonus
	AddScore(other, ent->r.currentOrigin, CTF_CAPTURE_BONUS);

	Team_CaptureFlagSound(ent, team);

	// Ok, let's do the player loop, hand out the bonuses
	for(i = 0; i < g_maxclients.integer; i++)
	{
		player = &g_entities[i];
		if(!player->inuse)
			continue;

		if(player->client->sess.sessionTeam != cl->sess.sessionTeam)
		{
			player->client->pers.teamState.lasthurtcarrier = -5;
		}
		else if(player->client->sess.sessionTeam == cl->sess.sessionTeam)
		{
			if(player != other)
				AddScore(player, ent->r.currentOrigin, CTF_TEAM_BONUS);
			// award extra points for capture assists
			if(player->client->pers.teamState.lastreturnedflag + CTF_RETURN_FLAG_ASSIST_TIMEOUT > level.time)
			{
				AddScore(player, ent->r.currentOrigin, CTF_RETURN_FLAG_ASSIST_BONUS);
				other->client->pers.teamState.assists++;

				player->client->ps.persistant[PERS_ASSIST_COUNT]++;
				// add the sprite over the player's head
				player->client->ps.eFlags &=
					~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND |
					  EF_AWARD_CAP);
				player->client->ps.eFlags |= EF_AWARD_ASSIST;
				player->client->rewardTime = level.time + REWARD_SPRITE_TIME;

			}
			else if(player->client->pers.teamState.lastfraggedcarrier + CTF_FRAG_CARRIER_ASSIST_TIMEOUT > level.time)
			{
				AddScore(player, ent->r.currentOrigin, CTF_FRAG_CARRIER_ASSIST_BONUS);
				other->client->pers.teamState.assists++;
				player->client->ps.persistant[PERS_ASSIST_COUNT]++;
				// add the sprite over the player's head
				player->client->ps.eFlags &=
					~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND |
					  EF_AWARD_CAP);
				player->client->ps.eFlags |= EF_AWARD_ASSIST;
				player->client->rewardTime = level.time + REWARD_SPRITE_TIME;
			}
		}
	}
	Team_ResetFlags();

	CalculateRanks();

	return 0;					// Do not respawn this automatically
}

int Team_TouchEnemyFlag(gentity_t * ent, gentity_t * other, int team)
{
	gclient_t      *cl = other->client;

#ifdef MISSIONPACK
	if(g_gametype.integer == GT_1FCTF)
	{
		PrintMsg(NULL, "%s" S_COLOR_WHITE " got the flag!\n", other->client->pers.netname);

		cl->ps.powerups[PW_NEUTRALFLAG] = INT_MAX;	// flags never expire

		if(team == TEAM_RED)
		{
			Team_SetFlagStatus(TEAM_FREE, FLAG_TAKEN_RED);
		}
		else
		{
			Team_SetFlagStatus(TEAM_FREE, FLAG_TAKEN_BLUE);
		}
	}
	else
	{
#endif
		PrintMsg(NULL, "%s" S_COLOR_WHITE " got the %s flag!\n", other->client->pers.netname, TeamName(team));

		if(team == TEAM_RED)
			cl->ps.powerups[PW_REDFLAG] = INT_MAX;	// flags never expire
		else
			cl->ps.powerups[PW_BLUEFLAG] = INT_MAX;	// flags never expire

		Team_SetFlagStatus(team, FLAG_TAKEN);
#ifdef MISSIONPACK
	}
#endif

	AddScore(other, ent->r.currentOrigin, CTF_FLAG_BONUS);
	cl->pers.teamState.flagsince = level.time;
	Team_TakeFlagSound(ent, team);

	return -1;					// Do not respawn this automatically, but do delete it if it was FL_DROPPED
}

int Pickup_Team(gentity_t * ent, gentity_t * other)
{
	int             team;
	gclient_t      *cl = other->client;

#ifdef MISSIONPACK
	if(g_gametype.integer == GT_OBELISK)
	{
		// there are no team items that can be picked up in obelisk
		G_FreeEntity(ent);
		return 0;
	}

	if(g_gametype.integer == GT_HARVESTER)
	{
		// the only team items that can be picked up in harvester are the cubes
		if(ent->spawnflags != cl->sess.sessionTeam)
		{
			cl->ps.generic1 += 1;
		}
		G_FreeEntity(ent);
		return 0;
	}
#endif
	// figure out what team this flag is
	if(strcmp(ent->classname, "team_CTF_redflag") == 0)
	{
		team = TEAM_RED;
	}
	else if(strcmp(ent->classname, "team_CTF_blueflag") == 0)
	{
		team = TEAM_BLUE;
	}
#ifdef MISSIONPACK
	else if(strcmp(ent->classname, "team_CTF_neutralflag") == 0)
	{
		team = TEAM_FREE;
	}
#endif
	else
	{
		PrintMsg(other, "Don't know what team the flag is on.\n");
		return 0;
	}
#ifdef MISSIONPACK
	if(g_gametype.integer == GT_1FCTF)
	{
		if(team == TEAM_FREE)
		{
			return Team_TouchEnemyFlag(ent, other, cl->sess.sessionTeam);
		}
		if(team != cl->sess.sessionTeam)
		{
			return Team_TouchOurFlag(ent, other, cl->sess.sessionTeam);
		}
		return 0;
	}
#endif
	// GT_CTF
	if(team == cl->sess.sessionTeam)
	{
		return Team_TouchOurFlag(ent, other, team);
	}
	return Team_TouchEnemyFlag(ent, other, team);
}

/*
===========
Team_GetLocation

Report a location for the player. Uses placed nearby target_location entities
============
*/
gentity_t      *Team_GetLocation(gentity_t * ent)
{
	gentity_t      *eloc, *best;
	float           bestlen, len;
	vec3_t          origin;

	best = NULL;
	bestlen = 3 * 8192.0 * 8192.0;

	VectorCopy(ent->r.currentOrigin, origin);

	for(eloc = level.locationHead; eloc; eloc = eloc->nextTrain)
	{
		len = (origin[0] - eloc->r.currentOrigin[0]) * (origin[0] - eloc->r.currentOrigin[0])
			+ (origin[1] - eloc->r.currentOrigin[1]) * (origin[1] - eloc->r.currentOrigin[1])
			+ (origin[2] - eloc->r.currentOrigin[2]) * (origin[2] - eloc->r.currentOrigin[2]);

		if(len > bestlen)
		{
			continue;
		}

		if(!trap_InPVS(origin, eloc->r.currentOrigin))
		{
			continue;
		}

		bestlen = len;
		best = eloc;
	}

	return best;
}


/*
===========
Team_GetLocation

Report a location for the player. Uses placed nearby target_location entities
============
*/
qboolean Team_GetLocationMsg(gentity_t * ent, char *loc, int loclen)
{
	gentity_t      *best;

	best = Team_GetLocation(ent);

	if(!best)
		return qfalse;

	if(best->count)
	{
		if(best->count < 0)
			best->count = 0;
		if(best->count > 7)
			best->count = 7;
		Com_sprintf(loc, loclen, "%c%c%s" S_COLOR_WHITE, Q_COLOR_ESCAPE, best->count + '0', best->message);
	}
	else
		Com_sprintf(loc, loclen, "%s", best->message);

	return qtrue;
}


/*---------------------------------------------------------------------------*/

/*
================
SelectRandomDeathmatchSpawnPoint

go to a random point that doesn't telefrag
================
*/
#define	MAX_TEAM_SPAWN_POINTS	32
gentity_t      *SelectRandomTeamSpawnPoint(int teamstate, team_t team)
{
	gentity_t      *spot;
	int             count;
	int             selection;
	gentity_t      *spots[MAX_TEAM_SPAWN_POINTS];
	char           *classname;

	if(teamstate == TEAM_BEGIN)
	{
		if(team == TEAM_RED)
			classname = "team_CTF_redplayer";
		else if(team == TEAM_BLUE)
			classname = "team_CTF_blueplayer";
		else
			return NULL;
	}
	else
	{
		if(team == TEAM_RED)
			classname = "team_CTF_redspawn";
		else if(team == TEAM_BLUE)
			classname = "team_CTF_bluespawn";
		else
			return NULL;
	}
	count = 0;

	spot = NULL;

	while((spot = G_Find(spot, FOFS(classname), classname)) != NULL)
	{
		if(SpotWouldTelefrag(spot))
		{
			continue;
		}
		spots[count] = spot;
		if(++count == MAX_TEAM_SPAWN_POINTS)
			break;
	}

	if(!count)
	{							// no spots that won't telefrag
		return G_Find(NULL, FOFS(classname), classname);
	}

	selection = rand() % count;
	return spots[selection];
}


/*
===========
SelectCTFSpawnPoint

============
*/
gentity_t      *SelectCTFSpawnPoint(team_t team, int teamstate, vec3_t origin, vec3_t angles)
{
	gentity_t      *spot;

	spot = SelectRandomTeamSpawnPoint(teamstate, team);

	if(!spot)
	{
		return SelectSpawnPoint(vec3_origin, origin, angles);
	}

	VectorCopy(spot->s.origin, origin);
	origin[2] += 9;
	VectorCopy(spot->s.angles, angles);

	return spot;
}

/*---------------------------------------------------------------------------*/

static int QDECL SortClients(const void *a, const void *b)
{
	return *(int *)a - *(int *)b;
}


/*
==================
TeamplayLocationsMessage

Format:
	clientNum location health armor weapon powerups

==================
*/
void TeamplayInfoMessage(gentity_t * ent)
{
	char            entry[1024];
	char            string[8192];
	int             stringlength;
	int             i, j;
	gentity_t      *player;
	int             cnt;
	int             h, a;
	int             clients[TEAM_MAXOVERLAY];

	if(!ent->client->pers.teamInfo)
		return;

	// figure out what client should be on the display
	// we are limited to 8, but we want to use the top eight players
	// but in client order (so they don't keep changing position on the overlay)
	for(i = 0, cnt = 0; i < g_maxclients.integer && cnt < TEAM_MAXOVERLAY; i++)
	{
		player = g_entities + level.sortedClients[i];
		if(player->inuse && player->client->sess.sessionTeam == ent->client->sess.sessionTeam)
		{
			clients[cnt++] = level.sortedClients[i];
		}
	}

	// We have the top eight players, sort them by clientNum
	qsort(clients, cnt, sizeof(clients[0]), SortClients);

	// send the latest information on all clients
	string[0] = 0;
	stringlength = 0;

	for(i = 0, cnt = 0; i < g_maxclients.integer && cnt < TEAM_MAXOVERLAY; i++)
	{
		player = g_entities + i;
		if(player->inuse && player->client->sess.sessionTeam == ent->client->sess.sessionTeam)
		{

			h = player->client->ps.stats[STAT_HEALTH];
			a = player->client->ps.stats[STAT_ARMOR];
			if(h < 0)
				h = 0;
			if(a < 0)
				a = 0;

			Com_sprintf(entry, sizeof(entry), " %i %i %i %i %i %i",
//              level.sortedClients[i], player->client->pers.teamState.location, h, a, 
						i, player->client->pers.teamState.location, h, a, player->client->ps.weapon, player->s.powerups);
			j = strlen(entry);
			if(stringlength + j > sizeof(string))
				break;
			strcpy(string + stringlength, entry);
			stringlength += j;
			cnt++;
		}
	}

	trap_SendServerCommand(ent - g_entities, va("tinfo %i %s", cnt, string));
}

void CheckTeamStatus(void)
{
	int             i;
	gentity_t      *loc, *ent;

	if(level.time - level.lastTeamLocationTime > TEAM_LOCATION_UPDATE_TIME)
	{

		level.lastTeamLocationTime = level.time;

		for(i = 0; i < g_maxclients.integer; i++)
		{
			ent = g_entities + i;

			if(ent->client->pers.connected != CON_CONNECTED)
			{
				continue;
			}

			if(ent->inuse && (ent->client->sess.sessionTeam == TEAM_RED || ent->client->sess.sessionTeam == TEAM_BLUE))
			{
				loc = Team_GetLocation(ent);
				if(loc)
					ent->client->pers.teamState.location = loc->health;
				else
					ent->client->pers.teamState.location = 0;
			}
		}

		for(i = 0; i < g_maxclients.integer; i++)
		{
			ent = g_entities + i;

			if(ent->client->pers.connected != CON_CONNECTED)
			{
				continue;
			}

			if(ent->inuse && (ent->client->sess.sessionTeam == TEAM_RED || ent->client->sess.sessionTeam == TEAM_BLUE))
			{
				TeamplayInfoMessage(ent);
			}
		}
	}
}

/*-----------------------------------------------------------------*/

/*QUAKED team_CTF_redplayer (1 0 0) (-16 -16 -16) (16 16 32)
Only in CTF games.  Red players spawn here at game start.
*/
void SP_team_CTF_redplayer(gentity_t * ent)
{
}


/*QUAKED team_CTF_blueplayer (0 0 1) (-16 -16 -16) (16 16 32)
Only in CTF games.  Blue players spawn here at game start.
*/
void SP_team_CTF_blueplayer(gentity_t * ent)
{
}


/*QUAKED team_CTF_redspawn (1 0 0) (-16 -16 -24) (16 16 32)
potential spawning position for red team in CTF games.
Targets will be fired when someone spawns in on them.
*/
void SP_team_CTF_redspawn(gentity_t * ent)
{
}

/*QUAKED team_CTF_bluespawn (0 0 1) (-16 -16 -24) (16 16 32)
potential spawning position for blue team in CTF games.
Targets will be fired when someone spawns in on them.
*/
void SP_team_CTF_bluespawn(gentity_t * ent)
{
}


#ifdef MISSIONPACK
/*
================
Obelisks
================
*/

static void ObeliskRegen(gentity_t * self)
{
	self->nextthink = level.time + g_obeliskRegenPeriod.integer * 1000;
	if(self->health >= g_obeliskHealth.integer)
	{
		return;
	}

	G_AddEvent(self, EV_POWERUP_REGEN, 0);
	self->health += g_obeliskRegenAmount.integer;
	if(self->health > g_obeliskHealth.integer)
	{
		self->health = g_obeliskHealth.integer;
	}

	self->activator->s.modelindex2 = self->health * 0xff / g_obeliskHealth.integer;
	self->activator->s.frame = 0;
}


static void ObeliskRespawn(gentity_t * self)
{
	self->takedamage = qtrue;
	self->health = g_obeliskHealth.integer;

	self->think = ObeliskRegen;
	self->nextthink = level.time + g_obeliskRegenPeriod.integer * 1000;

	self->activator->s.frame = 0;
}


static void ObeliskDie(gentity_t * self, gentity_t * inflictor, gentity_t * attacker, int damage, int mod)
{
	int             otherTeam;

	otherTeam = OtherTeam(self->spawnflags);
	AddTeamScore(self->s.pos.trBase, 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;
}


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);
}

static void ObeliskPain(gentity_t * self, gentity_t * attacker, int damage)
{
	int             actualDamage = damage / 10;

	if(actualDamage <= 0)
	{
		actualDamage = 1;
	}
	self->activator->s.modelindex2 = self->health * 0xff / g_obeliskHealth.integer;
	if(!self->activator->s.frame)
	{
		G_AddEvent(self, EV_OBELISKPAIN, 0);
	}
	self->activator->s.frame = 1;
	AddScore(attacker, self->r.currentOrigin, actualDamage);
}

gentity_t      *SpawnObelisk(vec3_t origin, int team, int spawnflags)
{
	trace_t         tr;
	vec3_t          dest;
	gentity_t      *ent;

	ent = G_Spawn();

	VectorCopy(origin, ent->s.origin);
	VectorCopy(origin, ent->s.pos.trBase);
	VectorCopy(origin, ent->r.currentOrigin);

	VectorSet(ent->r.mins, -15, -15, 0);
	VectorSet(ent->r.maxs, 15, 15, 87);

	ent->s.eType = ET_GENERAL;
	ent->flags = FL_NO_KNOCKBACK;

	if(g_gametype.integer == GT_OBELISK)
	{
		ent->r.contents = CONTENTS_SOLID;
		ent->takedamage = qtrue;
		ent->health = g_obeliskHealth.integer;
		ent->die = ObeliskDie;
		ent->pain = ObeliskPain;
		ent->think = ObeliskRegen;
		ent->nextthink = level.time + g_obeliskRegenPeriod.integer * 1000;
	}
	if(g_gametype.integer == GT_HARVESTER)
	{
		ent->r.contents = CONTENTS_TRIGGER;
		ent->touch = ObeliskTouch;
	}

	if(spawnflags & 1)
	{
		// suspended
		G_SetOrigin(ent, ent->s.origin);
	}
	else
	{
		// mappers like to put them exactly on the floor, but being coplanar
		// will sometimes show up as starting in solid, so lif it up one pixel
		ent->s.origin[2] += 1;

		// drop to floor
		VectorSet(dest, ent->s.origin[0], ent->s.origin[1], ent->s.origin[2] - 4096);
		trap_Trace(&tr, ent->s.origin, ent->r.mins, ent->r.maxs, dest, ent->s.number, MASK_SOLID);
		if(tr.startsolid)
		{
			ent->s.origin[2] -= 1;
			G_Printf("SpawnObelisk: %s startsolid at %s\n", ent->classname, vtos(ent->s.origin));

			ent->s.groundEntityNum = ENTITYNUM_NONE;
			G_SetOrigin(ent, ent->s.origin);
		}
		else
		{
			// allow to ride movers
			ent->s.groundEntityNum = tr.entityNum;
			G_SetOrigin(ent, tr.endpos);
		}
	}

	ent->spawnflags = team;

	trap_LinkEntity(ent);

	return ent;
}

/*QUAKED team_redobelisk (1 0 0) (-16 -16 0) (16 16 8)
*/
void SP_team_redobelisk(gentity_t * ent)
{
	gentity_t      *obelisk;

	if(g_gametype.integer <= GT_TEAM)
	{
		G_FreeEntity(ent);
		return;
	}
	ent->s.eType = ET_TEAM;
	if(g_gametype.integer == GT_OBELISK)
	{
		obelisk = SpawnObelisk(ent->s.origin, TEAM_RED, ent->spawnflags);
		obelisk->activator = ent;
		// initial obelisk health value
		ent->s.modelindex2 = 0xff;
		ent->s.frame = 0;
	}
	if(g_gametype.integer == GT_HARVESTER)
	{
		obelisk = SpawnObelisk(ent->s.origin, TEAM_RED, ent->spawnflags);
		obelisk->activator = ent;
	}
	ent->s.modelindex = TEAM_RED;
	trap_LinkEntity(ent);
}

/*QUAKED team_blueobelisk (0 0 1) (-16 -16 0) (16 16 88)
*/
void SP_team_blueobelisk(gentity_t * ent)
{
	gentity_t      *obelisk;

	if(g_gametype.integer <= GT_TEAM)
	{
		G_FreeEntity(ent);
		return;
	}
	ent->s.eType = ET_TEAM;
	if(g_gametype.integer == GT_OBELISK)
	{
		obelisk = SpawnObelisk(ent->s.origin, TEAM_BLUE, ent->spawnflags);
		obelisk->activator = ent;
		// initial obelisk health value
		ent->s.modelindex2 = 0xff;
		ent->s.frame = 0;
	}
	if(g_gametype.integer == GT_HARVESTER)
	{
		obelisk = SpawnObelisk(ent->s.origin, TEAM_BLUE, ent->spawnflags);
		obelisk->activator = ent;
	}
	ent->s.modelindex = TEAM_BLUE;
	trap_LinkEntity(ent);
}

/*QUAKED team_neutralobelisk (0 0 1) (-16 -16 0) (16 16 88)
*/
void SP_team_neutralobelisk(gentity_t * ent)
{
	if(g_gametype.integer != GT_1FCTF && g_gametype.integer != GT_HARVESTER)
	{
		G_FreeEntity(ent);
		return;
	}
	ent->s.eType = ET_TEAM;
	if(g_gametype.integer == GT_HARVESTER)
	{
		neutralObelisk = SpawnObelisk(ent->s.origin, TEAM_FREE, ent->spawnflags);
		neutralObelisk->spawnflags = TEAM_FREE;
	}
	ent->s.modelindex = TEAM_FREE;
	trap_LinkEntity(ent);
}


/*
================
CheckObeliskAttack
================
*/
qboolean CheckObeliskAttack(gentity_t * obelisk, gentity_t * attacker)
{
	gentity_t      *te;

	// if this really is an obelisk
	if(obelisk->die != ObeliskDie)
	{
		return qfalse;
	}

	// if the attacker is a client
	if(!attacker->client)
	{
		return qfalse;
	}

	// if the obelisk is on the same team as the attacker then don't hurt it
	if(obelisk->spawnflags == attacker->client->sess.sessionTeam)
	{
		return qtrue;
	}

	// obelisk may be hurt

	// if not played any sounds recently
	if((obelisk->spawnflags == TEAM_RED &&
		teamgame.redObeliskAttackedTime < level.time - OVERLOAD_ATTACK_BASE_SOUND_TIME) ||
	   (obelisk->spawnflags == TEAM_BLUE && teamgame.blueObeliskAttackedTime < level.time - OVERLOAD_ATTACK_BASE_SOUND_TIME))
	{

		// tell which obelisk is under attack
		te = G_TempEntity(obelisk->s.pos.trBase, EV_GLOBAL_TEAM_SOUND);
		if(obelisk->spawnflags == TEAM_RED)
		{
			te->s.eventParm = GTS_REDOBELISK_ATTACKED;
			teamgame.redObeliskAttackedTime = level.time;
		}
		else
		{
			te->s.eventParm = GTS_BLUEOBELISK_ATTACKED;
			teamgame.blueObeliskAttackedTime = level.time;
		}
		te->r.svFlags |= SVF_BROADCAST;
	}

	return qfalse;
}
#endif