JKA: MP Source

00142                                                       {
00143         gentity_t       *te;
00144 
00145         te = G_TempEntity(origin, EV_GLOBAL_TEAM_SOUND );
00146         te->r.svFlags |= SVF_BROADCAST;
00147 
00148         if ( team == TEAM_RED ) {
00149                 if ( level.teamScores[ TEAM_RED ] + score == level.teamScores[ TEAM_BLUE ] ) {
00150                         //teams are tied sound
00151                         te->s.eventParm = GTS_TEAMS_ARE_TIED;
00152                 }
00153                 else if ( level.teamScores[ TEAM_RED ] <= level.teamScores[ TEAM_BLUE ] &&
00154                                         level.teamScores[ TEAM_RED ] + score > level.teamScores[ TEAM_BLUE ]) {
00155                         // red took the lead sound
00156                         te->s.eventParm = GTS_REDTEAM_TOOK_LEAD;
00157                 }
00158                 else {
00159                         // red scored sound
00160                         te->s.eventParm = GTS_REDTEAM_SCORED;
00161                 }
00162         }
00163         else {
00164                 if ( level.teamScores[ TEAM_BLUE ] + score == level.teamScores[ TEAM_RED ] ) {
00165                         //teams are tied sound
00166                         te->s.eventParm = GTS_TEAMS_ARE_TIED;
00167                 }
00168                 else if ( level.teamScores[ TEAM_BLUE ] <= level.teamScores[ TEAM_RED ] &&
00169                                         level.teamScores[ TEAM_BLUE ] + score > level.teamScores[ TEAM_RED ]) {
00170                         // blue took the lead sound
00171                         te->s.eventParm = GTS_BLUETEAM_TOOK_LEAD;
00172                 }
00173                 else {
00174                         // blue scored sound
00175                         te->s.eventParm = GTS_BLUETEAM_SCORED;
00176                 }
00177         }
00178         level.teamScores[ team ] += score;
00179 }

01152                            {
01153         int i;
01154         gentity_t *loc, *ent;
01155 
01156         if (level.time - level.lastTeamLocationTime > TEAM_LOCATION_UPDATE_TIME) {
01157 
01158                 level.lastTeamLocationTime = level.time;
01159 
01160                 for (i = 0; i < g_maxclients.integer; i++) {
01161                         ent = g_entities + i;
01162 
01163                         if ( !ent->client )
01164                         {
01165                                 continue;
01166                         }
01167 
01168                         if ( ent->client->pers.connected != CON_CONNECTED ) {
01169                                 continue;
01170                         }
01171 
01172                         if (ent->inuse && (ent->client->sess.sessionTeam == TEAM_RED || ent->client->sess.sessionTeam == TEAM_BLUE)) {
01173                                 loc = Team_GetLocation( ent );
01174                                 if (loc)
01175                                         ent->client->pers.teamState.location = loc->health;
01176                                 else
01177                                         ent->client->pers.teamState.location = 0;
01178                         }
01179                 }
01180 
01181                 for (i = 0; i < g_maxclients.integer; i++) {
01182                         ent = g_entities + i;
01183 
01184                         if ( ent->client->pers.connected != CON_CONNECTED ) {
01185                                 continue;
01186                         }
01187 
01188                         if (ent->inuse && (ent->client->sess.sessionTeam == TEAM_RED || ent->client->sess.sessionTeam == TEAM_BLUE)) {
01189                                 TeamplayInfoMessage( ent );
01190                         }
01191                 }
01192         }
01193 }

00037                         {
00038         if (team==TEAM_RED)
00039                 return TEAM_BLUE;
00040         else if (team==TEAM_BLUE)
00041                 return TEAM_RED;
00042         return team;
00043 }

00055                                     {
00056         if (team==TEAM_RED)
00057                 return "BLUE";
00058         else if (team==TEAM_BLUE)
00059                 return "RED";
00060         else if (team==TEAM_SPECTATOR)
00061                 return "SPECTATOR";
00062         return "FREE";
00063 }

00839                                                     {
00840         int team;
00841         gclient_t *cl = other->client;
00842 
00843         // figure out what team this flag is
00844         if( strcmp(ent->classname, "team_CTF_redflag") == 0 ) {
00845                 team = TEAM_RED;
00846         }
00847         else if( strcmp(ent->classname, "team_CTF_blueflag") == 0 ) {
00848                 team = TEAM_BLUE;
00849         }
00850         else if( strcmp(ent->classname, "team_CTF_neutralflag") == 0  ) {
00851                 team = TEAM_FREE;
00852         }
00853         else {
00854 //              PrintMsg ( other, "Don't know what team the flag is on.\n");
00855                 return 0;
00856         }
00857         // GT_CTF
00858         if( team == cl->sess.sessionTeam) {
00859                 return Team_TouchOurFlag( ent, other, team );
00860         }
00861         return Team_TouchEnemyFlag( ent, other, team );
00862 }

01040                                                                                             {
01041         gentity_t       *spot;
01042 
01043         spot = SelectRandomTeamSpawnPoint ( teamstate, team, -1 );
01044 
01045         if (!spot) {
01046                 return SelectSpawnPoint( vec3_origin, origin, angles, team );
01047         }
01048 
01049         VectorCopy (spot->s.origin, origin);
01050         origin[2] += 9;
01051         VectorCopy (spot->s.angles, angles);
01052 
01053         return spot;
01054 }

01062                                                                                                               {
01063         gentity_t       *spot;
01064 
01065         spot = SelectRandomTeamSpawnPoint ( teamstate, team, siegeClass );
01066 
01067         if (!spot) {
01068                 return SelectSpawnPoint( vec3_origin, origin, angles, team );
01069         }
01070 
01071         VectorCopy (spot->s.origin, origin);
01072         origin[2] += 9;
01073         VectorCopy (spot->s.angles, angles);
01074 
01075         return spot;
01076 }

00536 {
00537         int flag_pw;
00538 
00539         if (!targ->client || !attacker->client)
00540                 return;
00541 
00542         if (targ->client->sess.sessionTeam == TEAM_RED)
00543                 flag_pw = PW_BLUEFLAG;
00544         else
00545                 flag_pw = PW_REDFLAG;
00546 
00547         // flags
00548         if (targ->client->ps.powerups[flag_pw] &&
00549                 targ->client->sess.sessionTeam != attacker->client->sess.sessionTeam)
00550                 attacker->client->pers.teamState.lasthurtcarrier = level.time;
00551 
00552         // skulls
00553         if (targ->client->ps.generic1 &&
00554                 targ->client->sess.sessionTeam != attacker->client->sess.sessionTeam)
00555                 attacker->client->pers.teamState.lasthurtcarrier = level.time;
00556 }

00705                                            {
00706         int             team = TEAM_FREE;
00707 
00708         if( ent->item->giTag == PW_REDFLAG ) {
00709                 team = TEAM_RED;
00710         }
00711         else if( ent->item->giTag == PW_BLUEFLAG ) {
00712                 team = TEAM_BLUE;
00713         }
00714         else if( ent->item->giTag == PW_NEUTRALFLAG ) {
00715                 team = TEAM_FREE;
00716         }
00717 
00718         Team_ReturnFlagSound( Team_ResetFlag( team ), team );
00719         // Reset Flag will delete this entity
00720 }

00355 {
00356         int i;
00357         gentity_t *ent;
00358         int flag_pw, enemy_flag_pw;
00359         int otherteam;
00360         int tokens;
00361         gentity_t *flag, *carrier = NULL;
00362         char *c;
00363         vec3_t v1, v2;
00364         int team;
00365 
00366         // no bonus for fragging yourself or team mates
00367         if (!targ->client || !attacker->client || targ == attacker || OnSameTeam(targ, attacker))
00368                 return;
00369 
00370         team = targ->client->sess.sessionTeam;
00371         otherteam = OtherTeam(targ->client->sess.sessionTeam);
00372         if (otherteam < 0)
00373                 return; // whoever died isn't on a team
00374 
00375         // same team, if the flag at base, check to he has the enemy flag
00376         if (team == TEAM_RED) {
00377                 flag_pw = PW_REDFLAG;
00378                 enemy_flag_pw = PW_BLUEFLAG;
00379         } else {
00380                 flag_pw = PW_BLUEFLAG;
00381                 enemy_flag_pw = PW_REDFLAG;
00382         }
00383 
00384         // did the attacker frag the flag carrier?
00385         tokens = 0;
00386         if (targ->client->ps.powerups[enemy_flag_pw]) {
00387                 attacker->client->pers.teamState.lastfraggedcarrier = level.time;
00388                 AddScore(attacker, targ->r.currentOrigin, CTF_FRAG_CARRIER_BONUS);
00389                 attacker->client->pers.teamState.fragcarrier++;
00390                 //PrintMsg(NULL, "%s" S_COLOR_WHITE " fragged %s's flag carrier!\n",
00391                 //      attacker->client->pers.netname, TeamName(team));
00392                 PrintCTFMessage(attacker->s.number, team, CTFMESSAGE_FRAGGED_FLAG_CARRIER);
00393 
00394                 // the target had the flag, clear the hurt carrier
00395                 // field on the other team
00396                 for (i = 0; i < g_maxclients.integer; i++) {
00397                         ent = g_entities + i;
00398                         if (ent->inuse && ent->client->sess.sessionTeam == otherteam)
00399                                 ent->client->pers.teamState.lasthurtcarrier = 0;
00400                 }
00401                 return;
00402         }
00403 
00404         // did the attacker frag a head carrier? other->client->ps.generic1
00405         if (tokens) {
00406                 attacker->client->pers.teamState.lastfraggedcarrier = level.time;
00407                 AddScore(attacker, targ->r.currentOrigin, CTF_FRAG_CARRIER_BONUS * tokens * tokens);
00408                 attacker->client->pers.teamState.fragcarrier++;
00409                 //PrintMsg(NULL, "%s" S_COLOR_WHITE " fragged %s's skull carrier!\n",
00410                 //      attacker->client->pers.netname, TeamName(team));
00411 
00412                 // the target had the flag, clear the hurt carrier
00413                 // field on the other team
00414                 for (i = 0; i < g_maxclients.integer; i++) {
00415                         ent = g_entities + i;
00416                         if (ent->inuse && ent->client->sess.sessionTeam == otherteam)
00417                                 ent->client->pers.teamState.lasthurtcarrier = 0;
00418                 }
00419                 return;
00420         }
00421 
00422         if (targ->client->pers.teamState.lasthurtcarrier &&
00423                 level.time - targ->client->pers.teamState.lasthurtcarrier < CTF_CARRIER_DANGER_PROTECT_TIMEOUT &&
00424                 !attacker->client->ps.powerups[flag_pw]) {
00425                 // attacker is on the same team as the flag carrier and
00426                 // fragged a guy who hurt our flag carrier
00427                 AddScore(attacker, targ->r.currentOrigin, CTF_CARRIER_DANGER_PROTECT_BONUS);
00428 
00429                 attacker->client->pers.teamState.carrierdefense++;
00430                 targ->client->pers.teamState.lasthurtcarrier = 0;
00431 
00432                 attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
00433                 team = attacker->client->sess.sessionTeam;
00434                 attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;
00435 
00436                 return;
00437         }
00438 
00439         if (targ->client->pers.teamState.lasthurtcarrier &&
00440                 level.time - targ->client->pers.teamState.lasthurtcarrier < CTF_CARRIER_DANGER_PROTECT_TIMEOUT) {
00441                 // attacker is on the same team as the skull carrier and
00442                 AddScore(attacker, targ->r.currentOrigin, CTF_CARRIER_DANGER_PROTECT_BONUS);
00443 
00444                 attacker->client->pers.teamState.carrierdefense++;
00445                 targ->client->pers.teamState.lasthurtcarrier = 0;
00446 
00447                 attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
00448                 team = attacker->client->sess.sessionTeam;
00449                 attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;
00450 
00451                 return;
00452         }
00453 
00454         // flag and flag carrier area defense bonuses
00455 
00456         // we have to find the flag and carrier entities
00457 
00458         // find the flag
00459         switch (attacker->client->sess.sessionTeam) {
00460         case TEAM_RED:
00461                 c = "team_CTF_redflag";
00462                 break;
00463         case TEAM_BLUE:
00464                 c = "team_CTF_blueflag";
00465                 break;          
00466         default:
00467                 return;
00468         }
00469         // find attacker's team's flag carrier
00470         for (i = 0; i < g_maxclients.integer; i++) {
00471                 carrier = g_entities + i;
00472                 if (carrier->inuse && carrier->client->ps.powerups[flag_pw])
00473                         break;
00474                 carrier = NULL;
00475         }
00476         flag = NULL;
00477         while ((flag = G_Find (flag, FOFS(classname), c)) != NULL) {
00478                 if (!(flag->flags & FL_DROPPED_ITEM))
00479                         break;
00480         }
00481 
00482         if (!flag)
00483                 return; // can't find attacker's flag
00484 
00485         // ok we have the attackers flag and a pointer to the carrier
00486 
00487         // check to see if we are defending the base's flag
00488         VectorSubtract(targ->r.currentOrigin, flag->r.currentOrigin, v1);
00489         VectorSubtract(attacker->r.currentOrigin, flag->r.currentOrigin, v2);
00490 
00491         if ( ( ( VectorLength(v1) < CTF_TARGET_PROTECT_RADIUS &&
00492                 trap_InPVS(flag->r.currentOrigin, targ->r.currentOrigin ) ) ||
00493                 ( VectorLength(v2) < CTF_TARGET_PROTECT_RADIUS &&
00494                 trap_InPVS(flag->r.currentOrigin, attacker->r.currentOrigin ) ) ) &&
00495                 attacker->client->sess.sessionTeam != targ->client->sess.sessionTeam) {
00496 
00497                 // we defended the base flag
00498                 AddScore(attacker, targ->r.currentOrigin, CTF_FLAG_DEFENSE_BONUS);
00499                 attacker->client->pers.teamState.basedefense++;
00500 
00501                 attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
00502                 attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;
00503 
00504                 return;
00505         }
00506 
00507         if (carrier && carrier != attacker) {
00508                 VectorSubtract(targ->r.currentOrigin, carrier->r.currentOrigin, v1);
00509                 VectorSubtract(attacker->r.currentOrigin, carrier->r.currentOrigin, v1);
00510 
00511                 if ( ( ( VectorLength(v1) < CTF_ATTACKER_PROTECT_RADIUS &&
00512                         trap_InPVS(carrier->r.currentOrigin, targ->r.currentOrigin ) ) ||
00513                         ( VectorLength(v2) < CTF_ATTACKER_PROTECT_RADIUS &&
00514                                 trap_InPVS(carrier->r.currentOrigin, attacker->r.currentOrigin ) ) ) &&
00515                         attacker->client->sess.sessionTeam != targ->client->sess.sessionTeam) {
00516                         AddScore(attacker, targ->r.currentOrigin, CTF_CARRIER_PROTECT_BONUS);
00517                         attacker->client->pers.teamState.carrierdefense++;
00518 
00519                         attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
00520                         attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;
00521 
00522                         return;
00523                 }
00524         }
00525 }

00684                                        {
00685         if( ent->item->giTag == PW_REDFLAG ) {
00686                 Team_ReturnFlag( TEAM_RED );
00687         }
00688         else if( ent->item->giTag == PW_BLUEFLAG ) {
00689                 Team_ReturnFlag( TEAM_BLUE );
00690         }
00691         else if( ent->item->giTag == PW_NEUTRALFLAG ) {
00692                 Team_ReturnFlag( TEAM_FREE );
00693         }
00694 }

00872 {
00873         gentity_t               *eloc, *best;
00874         float                   bestlen, len;
00875         vec3_t                  origin;
00876 
00877         best = NULL;
00878         bestlen = 3*8192.0*8192.0;
00879 
00880         VectorCopy( ent->r.currentOrigin, origin );
00881 
00882         for (eloc = level.locationHead; eloc; eloc = eloc->nextTrain) {
00883                 len = ( origin[0] - eloc->r.currentOrigin[0] ) * ( origin[0] - eloc->r.currentOrigin[0] )
00884                         + ( origin[1] - eloc->r.currentOrigin[1] ) * ( origin[1] - eloc->r.currentOrigin[1] )
00885                         + ( origin[2] - eloc->r.currentOrigin[2] ) * ( origin[2] - eloc->r.currentOrigin[2] );
00886 
00887                 if ( len > bestlen ) {
00888                         continue;
00889                 }
00890 
00891                 if ( !trap_InPVS( origin, eloc->r.currentOrigin ) ) {
00892                         continue;
00893                 }
00894 
00895                 bestlen = len;
00896                 best = eloc;
00897         }
00898 
00899         return best;
00900 }

00911 {
00912         gentity_t *best;
00913 
00914         best = Team_GetLocation( ent );
00915         
00916         if (!best)
00917                 return qfalse;
00918 
00919         if (best->count) {
00920                 if (best->count < 0)
00921                         best->count = 0;
00922                 if (best->count > 7)
00923                         best->count = 7;
00924                 Com_sprintf(loc, loclen, "%c%c%s" S_COLOR_WHITE, Q_COLOR_ESCAPE, best->count + '0', best->message );
00925         } else
00926                 Com_sprintf(loc, loclen, "%s", best->message);
00927 
00928         return qtrue;
00929 }

00022                            {
00023         memset(&teamgame, 0, sizeof teamgame);
00024 
00025         switch( g_gametype.integer ) {
00026         case GT_CTF:
00027         case GT_CTY:
00028                 teamgame.redStatus = teamgame.blueStatus = -1; // Invalid to force update
00029                 Team_SetFlagStatus( TEAM_RED, FLAG_ATBASE );
00030                 Team_SetFlagStatus( TEAM_BLUE, FLAG_ATBASE );
00031                 break;
00032         default:
00033                 break;
00034         }
00035 }

00673                                  {
00674         Team_ReturnFlagSound(Team_ResetFlag(team), team);
00675         if( team == TEAM_FREE ) {
00676                 //PrintMsg(NULL, "The flag has returned!\n" );
00677         }
00678         else { //flag should always have team in normal CTF
00679                 //PrintMsg(NULL, "The %s flag has returned!\n", TeamName(team));
00680                 PrintCTFMessage(-1, team, CTFMESSAGE_FLAG_RETURNED);
00681         }
00682 }

00065                                       {
00066         if (team==TEAM_RED)
00067                 return S_COLOR_RED;
00068         else if (team==TEAM_BLUE)
00069                 return S_COLOR_BLUE;
00070         else if (team==TEAM_SPECTATOR)
00071                 return S_COLOR_YELLOW;
00072         return S_COLOR_WHITE;
00073 }

00045                                 {
00046         if (team==TEAM_RED)
00047                 return "RED";
00048         else if (team==TEAM_BLUE)
00049                 return "BLUE";
00050         else if (team==TEAM_SPECTATOR)
00051                 return "SPECTATOR";
00052         return "FREE";
00053 }

01094                                            {
01095         char            entry[1024];
01096         char            string[8192];
01097         int                     stringlength;
01098         int                     i, j;
01099         gentity_t       *player;
01100         int                     cnt;
01101         int                     h, a;
01102         int                     clients[TEAM_MAXOVERLAY];
01103 
01104         if ( ! ent->client->pers.teamInfo )
01105                 return;
01106 
01107         // figure out what client should be on the display
01108         // we are limited to 8, but we want to use the top eight players
01109         // but in client order (so they don't keep changing position on the overlay)
01110         for (i = 0, cnt = 0; i < g_maxclients.integer && cnt < TEAM_MAXOVERLAY; i++) {
01111                 player = g_entities + level.sortedClients[i];
01112                 if (player->inuse && player->client->sess.sessionTeam == 
01113                         ent->client->sess.sessionTeam ) {
01114                         clients[cnt++] = level.sortedClients[i];
01115                 }
01116         }
01117 
01118         // We have the top eight players, sort them by clientNum
01119         qsort( clients, cnt, sizeof( clients[0] ), SortClients );
01120 
01121         // send the latest information on all clients
01122         string[0] = 0;
01123         stringlength = 0;
01124 
01125         for (i = 0, cnt = 0; i < g_maxclients.integer && cnt < TEAM_MAXOVERLAY; i++) {
01126                 player = g_entities + i;
01127                 if (player->inuse && player->client->sess.sessionTeam == 
01128                         ent->client->sess.sessionTeam ) {
01129 
01130                         h = player->client->ps.stats[STAT_HEALTH];
01131                         a = player->client->ps.stats[STAT_ARMOR];
01132                         if (h < 0) h = 0;
01133                         if (a < 0) a = 0;
01134 
01135                         Com_sprintf (entry, sizeof(entry),
01136                                 " %i %i %i %i %i %i", 
01137 //                              level.sortedClients[i], player->client->pers.teamState.location, h, a, 
01138                                 i, player->client->pers.teamState.location, h, a, 
01139                                 player->client->ps.weapon, player->s.powerups);
01140                         j = strlen(entry);
01141                         if (stringlength + j > sizeof(string))
01142                                 break;
01143                         strcpy (string + stringlength, entry);
01144                         stringlength += j;
01145                         cnt++;
01146                 }
01147         }
01148 
01149         trap_SendServerCommand( ent-g_entities, va("tinfo %i %s", cnt, string) );
01150 }


Defines
#define	CTF_CAPTURE_BONUS 100
#define	CTF_TEAM_BONUS 25
#define	CTF_RECOVERY_BONUS 10
#define	CTF_FLAG_BONUS 10
#define	CTF_FRAG_CARRIER_BONUS 20
#define	CTF_FLAG_RETURN_TIME 40000
#define	CTF_CARRIER_DANGER_PROTECT_BONUS 5
#define	CTF_CARRIER_PROTECT_BONUS 2
#define	CTF_FLAG_DEFENSE_BONUS 10
#define	CTF_RETURN_FLAG_ASSIST_BONUS 10
#define	CTF_FRAG_CARRIER_ASSIST_BONUS 10
#define	CTF_TARGET_PROTECT_RADIUS 1000
#define	CTF_ATTACKER_PROTECT_RADIUS 1000
#define	CTF_CARRIER_DANGER_PROTECT_TIMEOUT 8000
#define	CTF_FRAG_CARRIER_ASSIST_TIMEOUT 10000
#define	CTF_RETURN_FLAG_ASSIST_TIMEOUT 10000
#define	CTF_GRAPPLE_SPEED 750
#define	CTF_GRAPPLE_PULL_SPEED 750
#define	OVERLOAD_ATTACK_BASE_SOUND_TIME 20000
Functions
int	OtherTeam (int team)
const char *	TeamName (int team)
const char *	OtherTeamName (int team)
const char *	TeamColorString (int team)
void	AddTeamScore (vec3_t origin, int team, int score)
void	Team_DroppedFlagThink (gentity_t *ent)
void	Team_FragBonuses (gentity_t targ, gentity_t inflictor, gentity_t *attacker)
void	Team_CheckHurtCarrier (gentity_t targ, gentity_t attacker)
void	Team_InitGame (void)
void	Team_ReturnFlag (int team)
void	Team_FreeEntity (gentity_t *ent)
gentity_t *	SelectCTFSpawnPoint (team_t team, int teamstate, vec3_t origin, vec3_t angles)
gentity_t *	SelectSiegeSpawnPoint (int siegeClass, team_t team, int teamstate, vec3_t origin, vec3_t angles)
gentity_t *	Team_GetLocation (gentity_t *ent)
qboolean	Team_GetLocationMsg (gentity_t ent, char loc, int loclen)
void	TeamplayInfoMessage (gentity_t *ent)
void	CheckTeamStatus (void)
int	Pickup_Team (gentity_t ent, gentity_t other)

codemp/game/g_team.h File Reference

Defines

Functions

Define Documentation

Function Documentation