Return to g_ctf.c CVS log

Up to [Quake II] / quake2 / ctf

Annotation of quake2/ctf/g_ctf.c, revision 1.1

1.1     ! root        1: #include "g_local.h"
        !             2: #include "m_player.h"
        !             3: 
        !             4: typedef enum match_s {
        !             5:        MATCH_NONE,
        !             6:        MATCH_SETUP,
        !             7:        MATCH_PREGAME,
        !             8:        MATCH_GAME,
        !             9:        MATCH_POST
        !            10: } match_t;
        !            11: 
        !            12: typedef enum {
        !            13:        ELECT_NONE,
        !            14:        ELECT_MATCH,
        !            15:        ELECT_ADMIN,
        !            16:        ELECT_MAP
        !            17: } elect_t;
        !            18: 
        !            19: typedef struct ctfgame_s
        !            20: {
        !            21:        int team1, team2;
        !            22:        int total1, total2; // these are only set when going into intermission!
        !            23:        float last_flag_capture;
        !            24:        int last_capture_team;
        !            25: 
        !            26:        match_t match;          // match state
        !            27:        float matchtime;        // time for match start/end (depends on state)
        !            28:        int lasttime;           // last time update
        !            29: 
        !            30:        elect_t election;       // election type
        !            31:        edict_t *etarget;       // for admin election, who's being elected
        !            32:        char elevel[32];        // for map election, target level
        !            33:        int evotes;                     // votes so far
        !            34:        int needvotes;          // votes needed
        !            35:        float electtime;        // remaining time until election times out
        !            36:        char emsg[256];         // election name
        !            37: 
        !            38: 
        !            39:        ghost_t ghosts[MAX_CLIENTS]; // ghost codes
        !            40: } ctfgame_t;
        !            41: 
        !            42: ctfgame_t ctfgame;
        !            43: 
        !            44: cvar_t *ctf;
        !            45: cvar_t *ctf_forcejoin;
        !            46: 
        !            47: cvar_t *competition;
        !            48: cvar_t *matchlock;
        !            49: cvar_t *electpercentage;
        !            50: cvar_t *matchtime;
        !            51: cvar_t *matchsetuptime;
        !            52: cvar_t *matchstarttime;
        !            53: cvar_t *admin_password;
        !            54: cvar_t *warp_list;
        !            55: 
        !            56: char *ctf_statusbar =
        !            57: "yb    -24 "
        !            58: 
        !            59: // health
        !            60: "xv    0 "
        !            61: "hnum "
        !            62: "xv    50 "
        !            63: "pic 0 "
        !            64: 
        !            65: // ammo
        !            66: "if 2 "
        !            67: "      xv      100 "
        !            68: "      anum "
        !            69: "      xv      150 "
        !            70: "      pic 2 "
        !            71: "endif "
        !            72: 
        !            73: // armor
        !            74: "if 4 "
        !            75: "      xv      200 "
        !            76: "      rnum "
        !            77: "      xv      250 "
        !            78: "      pic 4 "
        !            79: "endif "
        !            80: 
        !            81: // selected item
        !            82: "if 6 "
        !            83: "      xv      296 "
        !            84: "      pic 6 "
        !            85: "endif "
        !            86: 
        !            87: "yb    -50 "
        !            88: 
        !            89: // picked up item
        !            90: "if 7 "
        !            91: "      xv      0 "
        !            92: "      pic 7 "
        !            93: "      xv      26 "
        !            94: "      yb      -42 "
        !            95: "      stat_string 8 "
        !            96: "      yb      -50 "
        !            97: "endif "
        !            98: 
        !            99: // timer
        !           100: "if 9 "
        !           101:   "xv 246 "
        !           102:   "num 2 10 "
        !           103:   "xv 296 "
        !           104:   "pic 9 "
        !           105: "endif "
        !           106: 
        !           107: //  help / weapon icon 
        !           108: "if 11 "
        !           109:   "xv 148 "
        !           110:   "pic 11 "
        !           111: "endif "
        !           112: 
        !           113: //  frags
        !           114: "xr    -50 "
        !           115: "yt 2 "
        !           116: "num 3 14 "
        !           117: 
        !           118: //tech
        !           119: "yb -129 "
        !           120: "if 26 "
        !           121:   "xr -26 "
        !           122:   "pic 26 "
        !           123: "endif "
        !           124: 
        !           125: // red team
        !           126: "yb -102 "
        !           127: "if 17 "
        !           128:   "xr -26 "
        !           129:   "pic 17 "
        !           130: "endif "
        !           131: "xr -62 "
        !           132: "num 2 18 "
        !           133: //joined overlay
        !           134: "if 22 "
        !           135:   "yb -104 "
        !           136:   "xr -28 "
        !           137:   "pic 22 "
        !           138: "endif "
        !           139: 
        !           140: // blue team
        !           141: "yb -75 "
        !           142: "if 19 "
        !           143:   "xr -26 "
        !           144:   "pic 19 "
        !           145: "endif "
        !           146: "xr -62 "
        !           147: "num 2 20 "
        !           148: "if 23 "
        !           149:   "yb -77 "
        !           150:   "xr -28 "
        !           151:   "pic 23 "
        !           152: "endif "
        !           153: 
        !           154: // have flag graph
        !           155: "if 21 "
        !           156:   "yt 26 "
        !           157:   "xr -24 "
        !           158:   "pic 21 "
        !           159: "endif "
        !           160: 
        !           161: // id view state
        !           162: "if 27 "
        !           163:   "xv 0 "
        !           164:   "yb -58 "
        !           165:   "string \"Viewing\" "
        !           166:   "xv 64 "
        !           167:   "stat_string 27 "
        !           168: "endif "
        !           169: 
        !           170: "if 28 "
        !           171:   "xl 0 "
        !           172:   "yb -78 "
        !           173:   "stat_string 28 "
        !           174: "endif "
        !           175: ;
        !           176: 
        !           177: static char *tnames[] = {
        !           178:        "item_tech1", "item_tech2", "item_tech3", "item_tech4",
        !           179:        NULL
        !           180: };
        !           181: 
        !           182: void stuffcmd(edict_t *ent, char *s)   
        !           183: {
        !           184:        gi.WriteByte (11);              
        !           185:        gi.WriteString (s);
        !           186:     gi.unicast (ent, true);    
        !           187: }
        !           188: 
        !           189: /*--------------------------------------------------------------------------*/
        !           190: 
        !           191: /*
        !           192: =================
        !           193: findradius
        !           194: 
        !           195: Returns entities that have origins within a spherical area
        !           196: 
        !           197: findradius (origin, radius)
        !           198: =================
        !           199: */
        !           200: static edict_t *loc_findradius (edict_t *from, vec3_t org, float rad)
        !           201: {
        !           202:        vec3_t  eorg;
        !           203:        int             j;
        !           204: 
        !           205:        if (!from)
        !           206:                from = g_edicts;
        !           207:        else
        !           208:                from++;
        !           209:        for ( ; from < &g_edicts[globals.num_edicts]; from++)
        !           210:        {
        !           211:                if (!from->inuse)
        !           212:                        continue;
        !           213: #if 0
        !           214:                if (from->solid == SOLID_NOT)
        !           215:                        continue;
        !           216: #endif
        !           217:                for (j=0 ; j<3 ; j++)
        !           218:                        eorg[j] = org[j] - (from->s.origin[j] + (from->mins[j] + from->maxs[j])*0.5);
        !           219:                if (VectorLength(eorg) > rad)
        !           220:                        continue;
        !           221:                return from;
        !           222:        }
        !           223: 
        !           224:        return NULL;
        !           225: }
        !           226: 
        !           227: static void loc_buildboxpoints(vec3_t p[8], vec3_t org, vec3_t mins, vec3_t maxs)
        !           228: {
        !           229:        VectorAdd(org, mins, p[0]);
        !           230:        VectorCopy(p[0], p[1]);
        !           231:        p[1][0] -= mins[0];
        !           232:        VectorCopy(p[0], p[2]);
        !           233:        p[2][1] -= mins[1];
        !           234:        VectorCopy(p[0], p[3]);
        !           235:        p[3][0] -= mins[0];
        !           236:        p[3][1] -= mins[1];
        !           237:        VectorAdd(org, maxs, p[4]);
        !           238:        VectorCopy(p[4], p[5]);
        !           239:        p[5][0] -= maxs[0];
        !           240:        VectorCopy(p[0], p[6]);
        !           241:        p[6][1] -= maxs[1];
        !           242:        VectorCopy(p[0], p[7]);
        !           243:        p[7][0] -= maxs[0];
        !           244:        p[7][1] -= maxs[1];
        !           245: }
        !           246: 
        !           247: static qboolean loc_CanSee (edict_t *targ, edict_t *inflictor)
        !           248: {
        !           249:        trace_t trace;
        !           250:        vec3_t  targpoints[8];
        !           251:        int i;
        !           252:        vec3_t viewpoint;
        !           253: 
        !           254: // bmodels need special checking because their origin is 0,0,0
        !           255:        if (targ->movetype == MOVETYPE_PUSH)
        !           256:                return false; // bmodels not supported
        !           257: 
        !           258:        loc_buildboxpoints(targpoints, targ->s.origin, targ->mins, targ->maxs);
        !           259:        
        !           260:        VectorCopy(inflictor->s.origin, viewpoint);
        !           261:        viewpoint[2] += inflictor->viewheight;
        !           262: 
        !           263:        for (i = 0; i < 8; i++) {
        !           264:                trace = gi.trace (viewpoint, vec3_origin, vec3_origin, targpoints[i], inflictor, MASK_SOLID);
        !           265:                if (trace.fraction == 1.0)
        !           266:                        return true;
        !           267:        }
        !           268: 
        !           269:        return false;
        !           270: }
        !           271: 
        !           272: /*--------------------------------------------------------------------------*/
        !           273: 
        !           274: static gitem_t *flag1_item;
        !           275: static gitem_t *flag2_item;
        !           276: 
        !           277: void CTFSpawn(void)
        !           278: {
        !           279:        if (!flag1_item)
        !           280:                flag1_item = FindItemByClassname("item_flag_team1");
        !           281:        if (!flag2_item)
        !           282:                flag2_item = FindItemByClassname("item_flag_team2");
        !           283:        memset(&ctfgame, 0, sizeof(ctfgame));
        !           284:        CTFSetupTechSpawn();
        !           285: 
        !           286:        if (competition->value > 1) {
        !           287:                ctfgame.match = MATCH_SETUP;
        !           288:                ctfgame.matchtime = level.time + matchsetuptime->value * 60;
        !           289:        }
        !           290: }
        !           291: 
        !           292: void CTFInit(void)
        !           293: {
        !           294:        ctf = gi.cvar("ctf", "1", CVAR_SERVERINFO);
        !           295:        ctf_forcejoin = gi.cvar("ctf_forcejoin", "", 0);
        !           296:        competition = gi.cvar("competition", "0", CVAR_SERVERINFO);
        !           297:        matchlock = gi.cvar("matchlock", "1", CVAR_SERVERINFO);
        !           298:        electpercentage = gi.cvar("electpercentage", "66", 0);
        !           299:        matchtime = gi.cvar("matchtime", "20", CVAR_SERVERINFO);
        !           300:        matchsetuptime = gi.cvar("matchsetuptime", "10", 0);
        !           301:        matchstarttime = gi.cvar("matchstarttime", "20", 0);
        !           302:        admin_password = gi.cvar("admin_password", "", 0);
        !           303:        warp_list = gi.cvar("warp_list", "q2ctf1 q2ctf2 q2ctf3 q2ctf4 q2ctf5", 0);
        !           304: }
        !           305: 
        !           306: /*--------------------------------------------------------------------------*/
        !           307: 
        !           308: char *CTFTeamName(int team)
        !           309: {
        !           310:        switch (team) {
        !           311:        case CTF_TEAM1:
        !           312:                return "RED";
        !           313:        case CTF_TEAM2:
        !           314:                return "BLUE";
        !           315:        }
        !           316:        return "UKNOWN";
        !           317: }
        !           318: 
        !           319: char *CTFOtherTeamName(int team)
        !           320: {
        !           321:        switch (team) {
        !           322:        case CTF_TEAM1:
        !           323:                return "BLUE";
        !           324:        case CTF_TEAM2:
        !           325:                return "RED";
        !           326:        }
        !           327:        return "UKNOWN";
        !           328: }
        !           329: 
        !           330: int CTFOtherTeam(int team)
        !           331: {
        !           332:        switch (team) {
        !           333:        case CTF_TEAM1:
        !           334:                return CTF_TEAM2;
        !           335:        case CTF_TEAM2:
        !           336:                return CTF_TEAM1;
        !           337:        }
        !           338:        return -1; // invalid value
        !           339: }
        !           340: 
        !           341: /*--------------------------------------------------------------------------*/
        !           342: 
        !           343: edict_t *SelectRandomDeathmatchSpawnPoint (void);
        !           344: edict_t *SelectFarthestDeathmatchSpawnPoint (void);
        !           345: float  PlayersRangeFromSpot (edict_t *spot);
        !           346: 
        !           347: void CTFAssignSkin(edict_t *ent, char *s)
        !           348: {
        !           349:        int playernum = ent-g_edicts-1;
        !           350:        char *p;
        !           351:        char t[64];
        !           352: 
        !           353:        Com_sprintf(t, sizeof(t), "%s", s);
        !           354: 
        !           355:        if ((p = strrchr(t, '/')) != NULL)
        !           356:                p[1] = 0;
        !           357:        else
        !           358:                strcpy(t, "male/");
        !           359: 
        !           360:        switch (ent->client->resp.ctf_team) {
        !           361:        case CTF_TEAM1:
        !           362:                gi.configstring (CS_PLAYERSKINS+playernum, va("%s\\%s%s", 
        !           363:                        ent->client->pers.netname, t, CTF_TEAM1_SKIN) );
        !           364:                break;
        !           365:        case CTF_TEAM2:
        !           366:                gi.configstring (CS_PLAYERSKINS+playernum,
        !           367:                        va("%s\\%s%s", ent->client->pers.netname, t, CTF_TEAM2_SKIN) );
        !           368:                break;
        !           369:        default:
        !           370:                gi.configstring (CS_PLAYERSKINS+playernum, 
        !           371:                        va("%s\\%s", ent->client->pers.netname, s) );
        !           372:                break;
        !           373:        }
        !           374: //     gi.cprintf(ent, PRINT_HIGH, "You have been assigned to %s team.\n", ent->client->pers.netname);
        !           375: }
        !           376: 
        !           377: void CTFAssignTeam(gclient_t *who)
        !           378: {
        !           379:        edict_t         *player;
        !           380:        int i;
        !           381:        int team1count = 0, team2count = 0;
        !           382: 
        !           383:        who->resp.ctf_state = 0;
        !           384: 
        !           385:        if (!((int)dmflags->value & DF_CTF_FORCEJOIN)) {
        !           386:                who->resp.ctf_team = CTF_NOTEAM;
        !           387:                return;
        !           388:        }
        !           389: 
        !           390:        for (i = 1; i <= maxclients->value; i++) {
        !           391:                player = &g_edicts[i];
        !           392: 
        !           393:                if (!player->inuse || player->client == who)
        !           394:                        continue;
        !           395: 
        !           396:                switch (player->client->resp.ctf_team) {
        !           397:                case CTF_TEAM1:
        !           398:                        team1count++;
        !           399:                        break;
        !           400:                case CTF_TEAM2:
        !           401:                        team2count++;
        !           402:                }
        !           403:        }
        !           404:        if (team1count < team2count)
        !           405:                who->resp.ctf_team = CTF_TEAM1;
        !           406:        else if (team2count < team1count)
        !           407:                who->resp.ctf_team = CTF_TEAM2;
        !           408:        else if (rand() & 1)
        !           409:                who->resp.ctf_team = CTF_TEAM1;
        !           410:        else
        !           411:                who->resp.ctf_team = CTF_TEAM2;
        !           412: }
        !           413: 
        !           414: /*
        !           415: ================
        !           416: SelectCTFSpawnPoint
        !           417: 
        !           418: go to a ctf point, but NOT the two points closest
        !           419: to other players
        !           420: ================
        !           421: */
        !           422: edict_t *SelectCTFSpawnPoint (edict_t *ent)
        !           423: {
        !           424:        edict_t *spot, *spot1, *spot2;
        !           425:        int             count = 0;
        !           426:        int             selection;
        !           427:        float   range, range1, range2;
        !           428:        char    *cname;
        !           429: 
        !           430:        if (ent->client->resp.ctf_state)
        !           431:                if ( (int)(dmflags->value) & DF_SPAWN_FARTHEST)
        !           432:                        return SelectFarthestDeathmatchSpawnPoint ();
        !           433:                else
        !           434:                        return SelectRandomDeathmatchSpawnPoint ();
        !           435: 
        !           436:        ent->client->resp.ctf_state++;
        !           437: 
        !           438:        switch (ent->client->resp.ctf_team) {
        !           439:        case CTF_TEAM1:
        !           440:                cname = "info_player_team1";
        !           441:                break;
        !           442:        case CTF_TEAM2:
        !           443:                cname = "info_player_team2";
        !           444:                break;
        !           445:        default:
        !           446:                return SelectRandomDeathmatchSpawnPoint();
        !           447:        }
        !           448: 
        !           449:        spot = NULL;
        !           450:        range1 = range2 = 99999;
        !           451:        spot1 = spot2 = NULL;
        !           452: 
        !           453:        while ((spot = G_Find (spot, FOFS(classname), cname)) != NULL)
        !           454:        {
        !           455:                count++;
        !           456:                range = PlayersRangeFromSpot(spot);
        !           457:                if (range < range1)
        !           458:                {
        !           459:                        range1 = range;
        !           460:                        spot1 = spot;
        !           461:                }
        !           462:                else if (range < range2)
        !           463:                {
        !           464:                        range2 = range;
        !           465:                        spot2 = spot;
        !           466:                }
        !           467:        }
        !           468: 
        !           469:        if (!count)
        !           470:                return SelectRandomDeathmatchSpawnPoint();
        !           471: 
        !           472:        if (count <= 2)
        !           473:        {
        !           474:                spot1 = spot2 = NULL;
        !           475:        }
        !           476:        else
        !           477:                count -= 2;
        !           478: 
        !           479:        selection = rand() % count;
        !           480: 
        !           481:        spot = NULL;
        !           482:        do
        !           483:        {
        !           484:                spot = G_Find (spot, FOFS(classname), cname);
        !           485:                if (spot == spot1 || spot == spot2)
        !           486:                        selection++;
        !           487:        } while(selection--);
        !           488: 
        !           489:        return spot;
        !           490: }
        !           491: 
        !           492: /*------------------------------------------------------------------------*/
        !           493: /*
        !           494: CTFFragBonuses
        !           495: 
        !           496: Calculate the bonuses for flag defense, flag carrier defense, etc.
        !           497: Note that bonuses are not cumaltive.  You get one, they are in importance
        !           498: order.
        !           499: */
        !           500: void CTFFragBonuses(edict_t *targ, edict_t *inflictor, edict_t *attacker)
        !           501: {
        !           502:        int i;
        !           503:        edict_t *ent;
        !           504:        gitem_t *flag_item, *enemy_flag_item;
        !           505:        int otherteam;
        !           506:        edict_t *flag, *carrier;
        !           507:        char *c;
        !           508:        vec3_t v1, v2;
        !           509: 
        !           510:        if (targ->client && attacker->client) {
        !           511:                if (attacker->client->resp.ghost)
        !           512:                        if (attacker != targ)
        !           513:                                attacker->client->resp.ghost->kills++;
        !           514:                if (targ->client->resp.ghost)
        !           515:                        targ->client->resp.ghost->deaths++;
        !           516:        }
        !           517: 
        !           518:        // no bonus for fragging yourself
        !           519:        if (!targ->client || !attacker->client || targ == attacker)
        !           520:                return;
        !           521: 
        !           522:        otherteam = CTFOtherTeam(targ->client->resp.ctf_team);
        !           523:        if (otherteam < 0)
        !           524:                return; // whoever died isn't on a team
        !           525: 
        !           526:        // same team, if the flag at base, check to he has the enemy flag
        !           527:        if (targ->client->resp.ctf_team == CTF_TEAM1) {
        !           528:                flag_item = flag1_item;
        !           529:                enemy_flag_item = flag2_item;
        !           530:        } else {
        !           531:                flag_item = flag2_item;
        !           532:                enemy_flag_item = flag1_item;
        !           533:        }
        !           534: 
        !           535:        // did the attacker frag the flag carrier?
        !           536:        if (targ->client->pers.inventory[ITEM_INDEX(enemy_flag_item)]) {
        !           537:                attacker->client->resp.ctf_lastfraggedcarrier = level.time;
        !           538:                attacker->client->resp.score += CTF_FRAG_CARRIER_BONUS;
        !           539:                gi.cprintf(attacker, PRINT_MEDIUM, "BONUS: %d points for fragging enemy flag carrier.\n",
        !           540:                        CTF_FRAG_CARRIER_BONUS);
        !           541: 
        !           542:                // the target had the flag, clear the hurt carrier
        !           543:                // field on the other team
        !           544:                for (i = 1; i <= maxclients->value; i++) {
        !           545:                        ent = g_edicts + i;
        !           546:                        if (ent->inuse && ent->client->resp.ctf_team == otherteam)
        !           547:                                ent->client->resp.ctf_lasthurtcarrier = 0;
        !           548:                }
        !           549:                return;
        !           550:        }
        !           551: 
        !           552:        if (targ->client->resp.ctf_lasthurtcarrier &&
        !           553:                level.time - targ->client->resp.ctf_lasthurtcarrier < CTF_CARRIER_DANGER_PROTECT_TIMEOUT &&
        !           554:                !attacker->client->pers.inventory[ITEM_INDEX(flag_item)]) {
        !           555:                // attacker is on the same team as the flag carrier and
        !           556:                // fragged a guy who hurt our flag carrier
        !           557:                attacker->client->resp.score += CTF_CARRIER_DANGER_PROTECT_BONUS;
        !           558:                gi.bprintf(PRINT_MEDIUM, "%s defends %s's flag carrier against an agressive enemy\n",
        !           559:                        attacker->client->pers.netname, 
        !           560:                        CTFTeamName(attacker->client->resp.ctf_team));
        !           561:                if (attacker->client->resp.ghost)
        !           562:                        attacker->client->resp.ghost->carrierdef++;
        !           563:                return;
        !           564:        }
        !           565: 
        !           566:        // flag and flag carrier area defense bonuses
        !           567: 
        !           568:        // we have to find the flag and carrier entities
        !           569: 
        !           570:        // find the flag
        !           571:        switch (attacker->client->resp.ctf_team) {
        !           572:        case CTF_TEAM1:
        !           573:                c = "item_flag_team1";
        !           574:                break;
        !           575:        case CTF_TEAM2:
        !           576:                c = "item_flag_team2";
        !           577:                break;
        !           578:        default:
        !           579:                return;
        !           580:        }
        !           581: 
        !           582:        flag = NULL;
        !           583:        while ((flag = G_Find (flag, FOFS(classname), c)) != NULL) {
        !           584:                if (!(flag->spawnflags & DROPPED_ITEM))
        !           585:                        break;
        !           586:        }
        !           587: 
        !           588:        if (!flag)
        !           589:                return; // can't find attacker's flag
        !           590: 
        !           591:        // find attacker's team's flag carrier
        !           592:        for (i = 1; i <= maxclients->value; i++) {
        !           593:                carrier = g_edicts + i;
        !           594:                if (carrier->inuse && 
        !           595:                        carrier->client->pers.inventory[ITEM_INDEX(flag_item)])
        !           596:                        break;
        !           597:                carrier = NULL;
        !           598:        }
        !           599: 
        !           600:        // ok we have the attackers flag and a pointer to the carrier
        !           601: 
        !           602:        // check to see if we are defending the base's flag
        !           603:        VectorSubtract(targ->s.origin, flag->s.origin, v1);
        !           604:        VectorSubtract(attacker->s.origin, flag->s.origin, v2);
        !           605: 
        !           606:        if ((VectorLength(v1) < CTF_TARGET_PROTECT_RADIUS ||
        !           607:                VectorLength(v2) < CTF_TARGET_PROTECT_RADIUS ||
        !           608:                loc_CanSee(flag, targ) || loc_CanSee(flag, attacker)) &&
        !           609:                attacker->client->resp.ctf_team != targ->client->resp.ctf_team) {
        !           610:                // we defended the base flag
        !           611:                attacker->client->resp.score += CTF_FLAG_DEFENSE_BONUS;
        !           612:                if (flag->solid == SOLID_NOT)
        !           613:                        gi.bprintf(PRINT_MEDIUM, "%s defends the %s base.\n",
        !           614:                                attacker->client->pers.netname, 
        !           615:                                CTFTeamName(attacker->client->resp.ctf_team));
        !           616:                else
        !           617:                        gi.bprintf(PRINT_MEDIUM, "%s defends the %s flag.\n",
        !           618:                                attacker->client->pers.netname, 
        !           619:                                CTFTeamName(attacker->client->resp.ctf_team));
        !           620:                if (attacker->client->resp.ghost)
        !           621:                        attacker->client->resp.ghost->basedef++;
        !           622:                return;
        !           623:        }
        !           624: 
        !           625:        if (carrier && carrier != attacker) {
        !           626:                VectorSubtract(targ->s.origin, carrier->s.origin, v1);
        !           627:                VectorSubtract(attacker->s.origin, carrier->s.origin, v1);
        !           628: 
        !           629:                if (VectorLength(v1) < CTF_ATTACKER_PROTECT_RADIUS ||
        !           630:                        VectorLength(v2) < CTF_ATTACKER_PROTECT_RADIUS ||
        !           631:                        loc_CanSee(carrier, targ) || loc_CanSee(carrier, attacker)) {
        !           632:                        attacker->client->resp.score += CTF_CARRIER_PROTECT_BONUS;
        !           633:                        gi.bprintf(PRINT_MEDIUM, "%s defends the %s's flag carrier.\n",
        !           634:                                attacker->client->pers.netname, 
        !           635:                                CTFTeamName(attacker->client->resp.ctf_team));
        !           636:                        if (attacker->client->resp.ghost)
        !           637:                                attacker->client->resp.ghost->carrierdef++;
        !           638:                        return;
        !           639:                }
        !           640:        }
        !           641: }
        !           642: 
        !           643: void CTFCheckHurtCarrier(edict_t *targ, edict_t *attacker)
        !           644: {
        !           645:        gitem_t *flag_item;
        !           646: 
        !           647:        if (!targ->client || !attacker->client)
        !           648:                return;
        !           649: 
        !           650:        if (targ->client->resp.ctf_team == CTF_TEAM1)
        !           651:                flag_item = flag2_item;
        !           652:        else
        !           653:                flag_item = flag1_item;
        !           654: 
        !           655:        if (targ->client->pers.inventory[ITEM_INDEX(flag_item)] &&
        !           656:                targ->client->resp.ctf_team != attacker->client->resp.ctf_team)
        !           657:                attacker->client->resp.ctf_lasthurtcarrier = level.time;
        !           658: }
        !           659: 
        !           660: 
        !           661: /*------------------------------------------------------------------------*/
        !           662: 
        !           663: void CTFResetFlag(int ctf_team)
        !           664: {
        !           665:        char *c;
        !           666:        edict_t *ent;
        !           667: 
        !           668:        switch (ctf_team) {
        !           669:        case CTF_TEAM1:
        !           670:                c = "item_flag_team1";
        !           671:                break;
        !           672:        case CTF_TEAM2:
        !           673:                c = "item_flag_team2";
        !           674:                break;
        !           675:        default:
        !           676:                return;
        !           677:        }
        !           678: 
        !           679:        ent = NULL;
        !           680:        while ((ent = G_Find (ent, FOFS(classname), c)) != NULL) {
        !           681:                if (ent->spawnflags & DROPPED_ITEM)
        !           682:                        G_FreeEdict(ent);
        !           683:                else {
        !           684:                        ent->svflags &= ~SVF_NOCLIENT;
        !           685:                        ent->solid = SOLID_TRIGGER;
        !           686:                        gi.linkentity(ent);
        !           687:                        ent->s.event = EV_ITEM_RESPAWN;
        !           688:                }
        !           689:        }
        !           690: }
        !           691: 
        !           692: void CTFResetFlags(void)
        !           693: {
        !           694:        CTFResetFlag(CTF_TEAM1);
        !           695:        CTFResetFlag(CTF_TEAM2);
        !           696: }
        !           697: 
        !           698: qboolean CTFPickup_Flag(edict_t *ent, edict_t *other)
        !           699: {
        !           700:        int ctf_team;
        !           701:        int i;
        !           702:        edict_t *player;
        !           703:        gitem_t *flag_item, *enemy_flag_item;
        !           704: 
        !           705:        // figure out what team this flag is
        !           706:        if (strcmp(ent->classname, "item_flag_team1") == 0)
        !           707:                ctf_team = CTF_TEAM1;
        !           708:        else if (strcmp(ent->classname, "item_flag_team2") == 0)
        !           709:                ctf_team = CTF_TEAM2;
        !           710:        else {
        !           711:                gi.cprintf(ent, PRINT_HIGH, "Don't know what team the flag is on.\n");
        !           712:                return false;
        !           713:        }
        !           714: 
        !           715:        // same team, if the flag at base, check to he has the enemy flag
        !           716:        if (ctf_team == CTF_TEAM1) {
        !           717:                flag_item = flag1_item;
        !           718:                enemy_flag_item = flag2_item;
        !           719:        } else {
        !           720:                flag_item = flag2_item;
        !           721:                enemy_flag_item = flag1_item;
        !           722:        }
        !           723: 
        !           724:        if (ctf_team == other->client->resp.ctf_team) {
        !           725: 
        !           726:                if (!(ent->spawnflags & DROPPED_ITEM)) {
        !           727:                        // the flag is at home base.  if the player has the enemy
        !           728:                        // flag, he's just won!
        !           729:                
        !           730:                        if (other->client->pers.inventory[ITEM_INDEX(enemy_flag_item)]) {
        !           731:                                gi.bprintf(PRINT_HIGH, "%s captured the %s flag!\n",
        !           732:                                                other->client->pers.netname, CTFOtherTeamName(ctf_team));
        !           733:                                other->client->pers.inventory[ITEM_INDEX(enemy_flag_item)] = 0;
        !           734: 
        !           735:                                ctfgame.last_flag_capture = level.time;
        !           736:                                ctfgame.last_capture_team = ctf_team;
        !           737:                                if (ctf_team == CTF_TEAM1)
        !           738:                                        ctfgame.team1++;
        !           739:                                else
        !           740:                                        ctfgame.team2++;
        !           741: 
        !           742:                                gi.sound (ent, CHAN_RELIABLE+CHAN_NO_PHS_ADD+CHAN_VOICE, gi.soundindex("ctf/flagcap.wav"), 1, ATTN_NONE, 0);
        !           743: 
        !           744:                                // other gets another 10 frag bonus
        !           745:                                other->client->resp.score += CTF_CAPTURE_BONUS;
        !           746:                                if (other->client->resp.ghost)
        !           747:                                        other->client->resp.ghost->caps++;
        !           748: 
        !           749:                                // Ok, let's do the player loop, hand out the bonuses
        !           750:                                for (i = 1; i <= maxclients->value; i++) {
        !           751:                                        player = &g_edicts[i];
        !           752:                                        if (!player->inuse)
        !           753:                                                continue;
        !           754: 
        !           755:                                        if (player->client->resp.ctf_team != other->client->resp.ctf_team)
        !           756:                                                player->client->resp.ctf_lasthurtcarrier = -5;
        !           757:                                        else if (player->client->resp.ctf_team == other->client->resp.ctf_team) {
        !           758:                                                if (player != other)
        !           759:                                                        player->client->resp.score += CTF_TEAM_BONUS;
        !           760:                                                // award extra points for capture assists
        !           761:                                                if (player->client->resp.ctf_lastreturnedflag + CTF_RETURN_FLAG_ASSIST_TIMEOUT > level.time) {
        !           762:                                                        gi.bprintf(PRINT_HIGH, "%s gets an assist for returning the flag!\n", player->client->pers.netname);
        !           763:                                                        player->client->resp.score += CTF_RETURN_FLAG_ASSIST_BONUS;
        !           764:                                                }
        !           765:                                                if (player->client->resp.ctf_lastfraggedcarrier + CTF_FRAG_CARRIER_ASSIST_TIMEOUT > level.time) {
        !           766:                                                        gi.bprintf(PRINT_HIGH, "%s gets an assist for fragging the flag carrier!\n", player->client->pers.netname);
        !           767:                                                        player->client->resp.score += CTF_FRAG_CARRIER_ASSIST_BONUS;
        !           768:                                                }
        !           769:                                        }
        !           770:                                }
        !           771: 
        !           772:                                CTFResetFlags();
        !           773:                                return false;
        !           774:                        }
        !           775:                        return false; // its at home base already
        !           776:                }       
        !           777:                // hey, its not home.  return it by teleporting it back
        !           778:                gi.bprintf(PRINT_HIGH, "%s returned the %s flag!\n", 
        !           779:                        other->client->pers.netname, CTFTeamName(ctf_team));
        !           780:                other->client->resp.score += CTF_RECOVERY_BONUS;
        !           781:                other->client->resp.ctf_lastreturnedflag = level.time;
        !           782:                gi.sound (ent, CHAN_RELIABLE+CHAN_NO_PHS_ADD+CHAN_VOICE, gi.soundindex("ctf/flagret.wav"), 1, ATTN_NONE, 0);
        !           783:                //CTFResetFlag will remove this entity!  We must return false
        !           784:                CTFResetFlag(ctf_team);
        !           785:                return false;
        !           786:        }
        !           787: 
        !           788:        // hey, its not our flag, pick it up
        !           789:        gi.bprintf(PRINT_HIGH, "%s got the %s flag!\n",
        !           790:                other->client->pers.netname, CTFTeamName(ctf_team));
        !           791:        other->client->resp.score += CTF_FLAG_BONUS;
        !           792: 
        !           793:        other->client->pers.inventory[ITEM_INDEX(flag_item)] = 1;
        !           794:        other->client->resp.ctf_flagsince = level.time;
        !           795: 
        !           796:        // pick up the flag
        !           797:        // if it's not a dropped flag, we just make is disappear
        !           798:        // if it's dropped, it will be removed by the pickup caller
        !           799:        if (!(ent->spawnflags & DROPPED_ITEM)) {
        !           800:                ent->flags |= FL_RESPAWN;
        !           801:                ent->svflags |= SVF_NOCLIENT;
        !           802:                ent->solid = SOLID_NOT;
        !           803:        }
        !           804:        return true;
        !           805: }
        !           806: 
        !           807: static void CTFDropFlagTouch(edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
        !           808: {
        !           809:        //owner (who dropped us) can't touch for two secs
        !           810:        if (other == ent->owner && 
        !           811:                ent->nextthink - level.time > CTF_AUTO_FLAG_RETURN_TIMEOUT-2)
        !           812:                return;
        !           813: 
        !           814:        Touch_Item (ent, other, plane, surf);
        !           815: }
        !           816: 
        !           817: static void CTFDropFlagThink(edict_t *ent)
        !           818: {
        !           819:        // auto return the flag
        !           820:        // reset flag will remove ourselves
        !           821:        if (strcmp(ent->classname, "item_flag_team1") == 0) {
        !           822:                CTFResetFlag(CTF_TEAM1);
        !           823:                gi.bprintf(PRINT_HIGH, "The %s flag has returned!\n",
        !           824:                        CTFTeamName(CTF_TEAM1));
        !           825:        } else if (strcmp(ent->classname, "item_flag_team2") == 0) {
        !           826:                CTFResetFlag(CTF_TEAM2);
        !           827:                gi.bprintf(PRINT_HIGH, "The %s flag has returned!\n",
        !           828:                        CTFTeamName(CTF_TEAM2));
        !           829:        }
        !           830: }
        !           831: 
        !           832: // Called from PlayerDie, to drop the flag from a dying player
        !           833: void CTFDeadDropFlag(edict_t *self)
        !           834: {
        !           835:        edict_t *dropped = NULL;
        !           836: 
        !           837:        if (self->client->pers.inventory[ITEM_INDEX(flag1_item)]) {
        !           838:                dropped = Drop_Item(self, flag1_item);
        !           839:                self->client->pers.inventory[ITEM_INDEX(flag1_item)] = 0;
        !           840:                gi.bprintf(PRINT_HIGH, "%s lost the %s flag!\n",
        !           841:                        self->client->pers.netname, CTFTeamName(CTF_TEAM1));
        !           842:        } else if (self->client->pers.inventory[ITEM_INDEX(flag2_item)]) {
        !           843:                dropped = Drop_Item(self, flag2_item);
        !           844:                self->client->pers.inventory[ITEM_INDEX(flag2_item)] = 0;
        !           845:                gi.bprintf(PRINT_HIGH, "%s lost the %s flag!\n",
        !           846:                        self->client->pers.netname, CTFTeamName(CTF_TEAM2));
        !           847:        }
        !           848: 
        !           849:        if (dropped) {
        !           850:                dropped->think = CTFDropFlagThink;
        !           851:                dropped->nextthink = level.time + CTF_AUTO_FLAG_RETURN_TIMEOUT;
        !           852:                dropped->touch = CTFDropFlagTouch;
        !           853:        }
        !           854: }
        !           855: 
        !           856: qboolean CTFDrop_Flag(edict_t *ent, gitem_t *item)
        !           857: {
        !           858:        if (rand() & 1) 
        !           859:                gi.cprintf(ent, PRINT_HIGH, "Only lusers drop flags.\n");
        !           860:        else
        !           861:                gi.cprintf(ent, PRINT_HIGH, "Winners don't drop flags.\n");
        !           862:        return false;
        !           863: }
        !           864: 
        !           865: static void CTFFlagThink(edict_t *ent)
        !           866: {
        !           867:        if (ent->solid != SOLID_NOT)
        !           868:                ent->s.frame = 173 + (((ent->s.frame - 173) + 1) % 16);
        !           869:        ent->nextthink = level.time + FRAMETIME;
        !           870: }
        !           871: 
        !           872: 
        !           873: void CTFFlagSetup (edict_t *ent)
        !           874: {
        !           875:        trace_t         tr;
        !           876:        vec3_t          dest;
        !           877:        float           *v;
        !           878: 
        !           879:        v = tv(-15,-15,-15);
        !           880:        VectorCopy (v, ent->mins);
        !           881:        v = tv(15,15,15);
        !           882:        VectorCopy (v, ent->maxs);
        !           883: 
        !           884:        if (ent->model)
        !           885:                gi.setmodel (ent, ent->model);
        !           886:        else
        !           887:                gi.setmodel (ent, ent->item->world_model);
        !           888:        ent->solid = SOLID_TRIGGER;
        !           889:        ent->movetype = MOVETYPE_TOSS;  
        !           890:        ent->touch = Touch_Item;
        !           891: 
        !           892:        v = tv(0,0,-128);
        !           893:        VectorAdd (ent->s.origin, v, dest);
        !           894: 
        !           895:        tr = gi.trace (ent->s.origin, ent->mins, ent->maxs, dest, ent, MASK_SOLID);
        !           896:        if (tr.startsolid)
        !           897:        {
        !           898:                gi.dprintf ("CTFFlagSetup: %s startsolid at %s\n", ent->classname, vtos(ent->s.origin));
        !           899:                G_FreeEdict (ent);
        !           900:                return;
        !           901:        }
        !           902: 
        !           903:        VectorCopy (tr.endpos, ent->s.origin);
        !           904: 
        !           905:        gi.linkentity (ent);
        !           906: 
        !           907:        ent->nextthink = level.time + FRAMETIME;
        !           908:        ent->think = CTFFlagThink;
        !           909: }
        !           910: 
        !           911: void CTFEffects(edict_t *player)
        !           912: {
        !           913:        player->s.effects &= ~(EF_FLAG1 | EF_FLAG2);
        !           914:        if (player->health > 0) {
        !           915:                if (player->client->pers.inventory[ITEM_INDEX(flag1_item)]) {
        !           916:                        player->s.effects |= EF_FLAG1;
        !           917:                }
        !           918:                if (player->client->pers.inventory[ITEM_INDEX(flag2_item)]) {
        !           919:                        player->s.effects |= EF_FLAG2;
        !           920:                }
        !           921:        }
        !           922: 
        !           923:        if (player->client->pers.inventory[ITEM_INDEX(flag1_item)])
        !           924:                player->s.modelindex3 = gi.modelindex("players/male/flag1.md2");
        !           925:        else if (player->client->pers.inventory[ITEM_INDEX(flag2_item)])
        !           926:                player->s.modelindex3 = gi.modelindex("players/male/flag2.md2");
        !           927:        else
        !           928:                player->s.modelindex3 = 0;
        !           929: }
        !           930: 
        !           931: // called when we enter the intermission
        !           932: void CTFCalcScores(void)
        !           933: {
        !           934:        int i;
        !           935: 
        !           936:        ctfgame.total1 = ctfgame.total2 = 0;
        !           937:        for (i = 0; i < maxclients->value; i++) {
        !           938:                if (!g_edicts[i+1].inuse)
        !           939:                        continue;
        !           940:                if (game.clients[i].resp.ctf_team == CTF_TEAM1)
        !           941:                        ctfgame.total1 += game.clients[i].resp.score;
        !           942:                else if (game.clients[i].resp.ctf_team == CTF_TEAM2)
        !           943:                        ctfgame.total2 += game.clients[i].resp.score;
        !           944:        }
        !           945: }
        !           946: 
        !           947: void CTFID_f (edict_t *ent)
        !           948: {
        !           949:        if (ent->client->resp.id_state) {
        !           950:                gi.cprintf(ent, PRINT_HIGH, "Disabling player identication display.\n");
        !           951:                ent->client->resp.id_state = false;
        !           952:        } else {
        !           953:                gi.cprintf(ent, PRINT_HIGH, "Activating player identication display.\n");
        !           954:                ent->client->resp.id_state = true;
        !           955:        }
        !           956: }
        !           957: 
        !           958: static void CTFSetIDView(edict_t *ent)
        !           959: {
        !           960:        vec3_t  forward, dir;
        !           961:        trace_t tr;
        !           962:        edict_t *who, *best;
        !           963:        float   bd = 0, d;
        !           964:        int i;
        !           965: 
        !           966:        ent->client->ps.stats[STAT_CTF_ID_VIEW] = 0;
        !           967: 
        !           968:        AngleVectors(ent->client->v_angle, forward, NULL, NULL);
        !           969:        VectorScale(forward, 1024, forward);
        !           970:        VectorAdd(ent->s.origin, forward, forward);
        !           971:        tr = gi.trace(ent->s.origin, NULL, NULL, forward, ent, MASK_SOLID);
        !           972:        if (tr.fraction < 1 && tr.ent && tr.ent->client) {
        !           973:                ent->client->ps.stats[STAT_CTF_ID_VIEW] = 
        !           974:                        CS_PLAYERSKINS + (ent - g_edicts - 1);
        !           975:                return;
        !           976:        }
        !           977: 
        !           978:        AngleVectors(ent->client->v_angle, forward, NULL, NULL);
        !           979:        best = NULL;
        !           980:        for (i = 1; i <= maxclients->value; i++) {
        !           981:                who = g_edicts + i;
        !           982:                if (!who->inuse || who->solid == SOLID_NOT)
        !           983:                        continue;
        !           984:                VectorSubtract(who->s.origin, ent->s.origin, dir);
        !           985:                VectorNormalize(dir);
        !           986:                d = DotProduct(forward, dir);
        !           987:                if (d > bd && loc_CanSee(ent, who)) {
        !           988:                        bd = d;
        !           989:                        best = who;
        !           990:                }
        !           991:        }
        !           992:        if (bd > 0.90)
        !           993:                ent->client->ps.stats[STAT_CTF_ID_VIEW] = 
        !           994:                        CS_PLAYERSKINS + (best - g_edicts - 1);
        !           995: }
        !           996: 
        !           997: void SetCTFStats(edict_t *ent)
        !           998: {
        !           999:        gitem_t *tech;
        !          1000:        int i;
        !          1001:        int p1, p2;
        !          1002:        edict_t *e;
        !          1003: 
        !          1004:        if (ctfgame.match > MATCH_NONE)
        !          1005:                ent->client->ps.stats[STAT_CTF_MATCH] = CONFIG_CTF_MATCH;
        !          1006:        else
        !          1007:                ent->client->ps.stats[STAT_CTF_MATCH] = 0;
        !          1008: 
        !          1009:        //ghosting
        !          1010:        if (ent->client->resp.ghost) {
        !          1011:                ent->client->resp.ghost->score = ent->client->resp.score;
        !          1012:                strcpy(ent->client->resp.ghost->netname, ent->client->pers.netname);
        !          1013:                ent->client->resp.ghost->number = ent->s.number;
        !          1014:        }
        !          1015: 
        !          1016:        // logo headers for the frag display
        !          1017:        ent->client->ps.stats[STAT_CTF_TEAM1_HEADER] = gi.imageindex ("ctfsb1");
        !          1018:        ent->client->ps.stats[STAT_CTF_TEAM2_HEADER] = gi.imageindex ("ctfsb2");
        !          1019: 
        !          1020:        // if during intermission, we must blink the team header of the winning team
        !          1021:        if (level.intermissiontime && (level.framenum & 8)) { // blink 1/8th second
        !          1022:                // note that ctfgame.total[12] is set when we go to intermission
        !          1023:                if (ctfgame.team1 > ctfgame.team2)
        !          1024:                        ent->client->ps.stats[STAT_CTF_TEAM1_HEADER] = 0;
        !          1025:                else if (ctfgame.team2 > ctfgame.team1)
        !          1026:                        ent->client->ps.stats[STAT_CTF_TEAM2_HEADER] = 0;
        !          1027:                else if (ctfgame.total1 > ctfgame.total2) // frag tie breaker
        !          1028:                        ent->client->ps.stats[STAT_CTF_TEAM1_HEADER] = 0;
        !          1029:                else if (ctfgame.total2 > ctfgame.total1) 
        !          1030:                        ent->client->ps.stats[STAT_CTF_TEAM2_HEADER] = 0;
        !          1031:                else { // tie game!
        !          1032:                        ent->client->ps.stats[STAT_CTF_TEAM1_HEADER] = 0;
        !          1033:                        ent->client->ps.stats[STAT_CTF_TEAM2_HEADER] = 0;
        !          1034:                }
        !          1035:        }
        !          1036: 
        !          1037:        // tech icon
        !          1038:        i = 0;
        !          1039:        ent->client->ps.stats[STAT_CTF_TECH] = 0;
        !          1040:        while (tnames[i]) {
        !          1041:                if ((tech = FindItemByClassname(tnames[i])) != NULL &&
        !          1042:                        ent->client->pers.inventory[ITEM_INDEX(tech)]) {
        !          1043:                        ent->client->ps.stats[STAT_CTF_TECH] = gi.imageindex(tech->icon);
        !          1044:                        break;
        !          1045:                }
        !          1046:                i++;
        !          1047:        }
        !          1048: 
        !          1049:        // figure out what icon to display for team logos
        !          1050:        // three states:
        !          1051:        //   flag at base
        !          1052:        //   flag taken
        !          1053:        //   flag dropped
        !          1054:        p1 = gi.imageindex ("i_ctf1");
        !          1055:        e = G_Find(NULL, FOFS(classname), "item_flag_team1");
        !          1056:        if (e != NULL) {
        !          1057:                if (e->solid == SOLID_NOT) {
        !          1058:                        int i;
        !          1059: 
        !          1060:                        // not at base
        !          1061:                        // check if on player
        !          1062:                        p1 = gi.imageindex ("i_ctf1d"); // default to dropped
        !          1063:                        for (i = 1; i <= maxclients->value; i++)
        !          1064:                                if (g_edicts[i].inuse &&
        !          1065:                                        g_edicts[i].client->pers.inventory[ITEM_INDEX(flag1_item)]) {
        !          1066:                                        // enemy has it
        !          1067:                                        p1 = gi.imageindex ("i_ctf1t");
        !          1068:                                        break;
        !          1069:                                }
        !          1070:                } else if (e->spawnflags & DROPPED_ITEM)
        !          1071:                        p1 = gi.imageindex ("i_ctf1d"); // must be dropped
        !          1072:        }
        !          1073:        p2 = gi.imageindex ("i_ctf2");
        !          1074:        e = G_Find(NULL, FOFS(classname), "item_flag_team2");
        !          1075:        if (e != NULL) {
        !          1076:                if (e->solid == SOLID_NOT) {
        !          1077:                        int i;
        !          1078: 
        !          1079:                        // not at base
        !          1080:                        // check if on player
        !          1081:                        p2 = gi.imageindex ("i_ctf2d"); // default to dropped
        !          1082:                        for (i = 1; i <= maxclients->value; i++)
        !          1083:                                if (g_edicts[i].inuse &&
        !          1084:                                        g_edicts[i].client->pers.inventory[ITEM_INDEX(flag2_item)]) {
        !          1085:                                        // enemy has it
        !          1086:                                        p2 = gi.imageindex ("i_ctf2t");
        !          1087:                                        break;
        !          1088:                                }
        !          1089:                } else if (e->spawnflags & DROPPED_ITEM)
        !          1090:                        p2 = gi.imageindex ("i_ctf2d"); // must be dropped
        !          1091:        }
        !          1092: 
        !          1093: 
        !          1094:        ent->client->ps.stats[STAT_CTF_TEAM1_PIC] = p1;
        !          1095:        ent->client->ps.stats[STAT_CTF_TEAM2_PIC] = p2;
        !          1096: 
        !          1097:        if (ctfgame.last_flag_capture && level.time - ctfgame.last_flag_capture < 5) {
        !          1098:                if (ctfgame.last_capture_team == CTF_TEAM1)
        !          1099:                        if (level.framenum & 8)
        !          1100:                                ent->client->ps.stats[STAT_CTF_TEAM1_PIC] = p1;
        !          1101:                        else
        !          1102:                                ent->client->ps.stats[STAT_CTF_TEAM1_PIC] = 0;
        !          1103:                else
        !          1104:                        if (level.framenum & 8)
        !          1105:                                ent->client->ps.stats[STAT_CTF_TEAM2_PIC] = p2;
        !          1106:                        else
        !          1107:                                ent->client->ps.stats[STAT_CTF_TEAM2_PIC] = 0;
        !          1108:        }
        !          1109: 
        !          1110:        ent->client->ps.stats[STAT_CTF_TEAM1_CAPS] = ctfgame.team1;
        !          1111:        ent->client->ps.stats[STAT_CTF_TEAM2_CAPS] = ctfgame.team2;
        !          1112: 
        !          1113:        ent->client->ps.stats[STAT_CTF_FLAG_PIC] = 0;
        !          1114:        if (ent->client->resp.ctf_team == CTF_TEAM1 &&
        !          1115:                ent->client->pers.inventory[ITEM_INDEX(flag2_item)] &&
        !          1116:                (level.framenum & 8))
        !          1117:                ent->client->ps.stats[STAT_CTF_FLAG_PIC] = gi.imageindex ("i_ctf2");
        !          1118: 
        !          1119:        else if (ent->client->resp.ctf_team == CTF_TEAM2 &&
        !          1120:                ent->client->pers.inventory[ITEM_INDEX(flag1_item)] &&
        !          1121:                (level.framenum & 8))
        !          1122:                ent->client->ps.stats[STAT_CTF_FLAG_PIC] = gi.imageindex ("i_ctf1");
        !          1123: 
        !          1124:        ent->client->ps.stats[STAT_CTF_JOINED_TEAM1_PIC] = 0;
        !          1125:        ent->client->ps.stats[STAT_CTF_JOINED_TEAM2_PIC] = 0;
        !          1126:        if (ent->client->resp.ctf_team == CTF_TEAM1)
        !          1127:                ent->client->ps.stats[STAT_CTF_JOINED_TEAM1_PIC] = gi.imageindex ("i_ctfj");
        !          1128:        else if (ent->client->resp.ctf_team == CTF_TEAM2)
        !          1129:                ent->client->ps.stats[STAT_CTF_JOINED_TEAM2_PIC] = gi.imageindex ("i_ctfj");
        !          1130: 
        !          1131:        ent->client->ps.stats[STAT_CTF_ID_VIEW] = 0;
        !          1132:        if (ent->client->resp.id_state)
        !          1133:                CTFSetIDView(ent);
        !          1134: }
        !          1135: 
        !          1136: /*------------------------------------------------------------------------*/
        !          1137: 
        !          1138: /*QUAKED info_player_team1 (1 0 0) (-16 -16 -24) (16 16 32)
        !          1139: potential team1 spawning position for ctf games
        !          1140: */
        !          1141: void SP_info_player_team1(edict_t *self)
        !          1142: {
        !          1143: }
        !          1144: 
        !          1145: /*QUAKED info_player_team2 (0 0 1) (-16 -16 -24) (16 16 32)
        !          1146: potential team2 spawning position for ctf games
        !          1147: */
        !          1148: void SP_info_player_team2(edict_t *self)
        !          1149: {
        !          1150: }
        !          1151: 
        !          1152: 
        !          1153: /*------------------------------------------------------------------------*/
        !          1154: /* GRAPPLE                                                                                                                               */
        !          1155: /*------------------------------------------------------------------------*/
        !          1156: 
        !          1157: // ent is player
        !          1158: void CTFPlayerResetGrapple(edict_t *ent)
        !          1159: {
        !          1160:        if (ent->client && ent->client->ctf_grapple)
        !          1161:                CTFResetGrapple(ent->client->ctf_grapple);
        !          1162: }
        !          1163: 
        !          1164: // self is grapple, not player
        !          1165: void CTFResetGrapple(edict_t *self)
        !          1166: {
        !          1167:        if (self->owner->client->ctf_grapple) {
        !          1168:                float volume = 1.0;
        !          1169:                gclient_t *cl;
        !          1170: 
        !          1171:                if (self->owner->client->silencer_shots)
        !          1172:                        volume = 0.2;
        !          1173: 
        !          1174:                gi.sound (self->owner, CHAN_RELIABLE+CHAN_WEAPON, gi.soundindex("weapons/grapple/grreset.wav"), volume, ATTN_NORM, 0);
        !          1175:                cl = self->owner->client;
        !          1176:                cl->ctf_grapple = NULL;
        !          1177:                cl->ctf_grapplereleasetime = level.time;
        !          1178:                cl->ctf_grapplestate = CTF_GRAPPLE_STATE_FLY; // we're firing, not on hook
        !          1179:                cl->ps.pmove.pm_flags &= ~PMF_NO_PREDICTION;
        !          1180:                G_FreeEdict(self);
        !          1181:        }
        !          1182: }
        !          1183: 
        !          1184: void CTFGrappleTouch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
        !          1185: {
        !          1186:        float volume = 1.0;
        !          1187: 
        !          1188:        if (other == self->owner)
        !          1189:                return;
        !          1190: 
        !          1191:        if (self->owner->client->ctf_grapplestate != CTF_GRAPPLE_STATE_FLY)
        !          1192:                return;
        !          1193: 
        !          1194:        if (surf && (surf->flags & SURF_SKY))
        !          1195:        {
        !          1196:                CTFResetGrapple(self);
        !          1197:                return;
        !          1198:        }
        !          1199: 
        !          1200:        VectorCopy(vec3_origin, self->velocity);
        !          1201: 
        !          1202:        PlayerNoise(self->owner, self->s.origin, PNOISE_IMPACT);
        !          1203: 
        !          1204:        if (other->takedamage) {
        !          1205:                T_Damage (other, self, self->owner, self->velocity, self->s.origin, plane->normal, self->dmg, 1, 0, MOD_GRAPPLE);
        !          1206:                CTFResetGrapple(self);
        !          1207:                return;
        !          1208:        }
        !          1209: 
        !          1210:        self->owner->client->ctf_grapplestate = CTF_GRAPPLE_STATE_PULL; // we're on hook
        !          1211:        self->enemy = other;
        !          1212: 
        !          1213:        self->solid = SOLID_NOT;
        !          1214: 
        !          1215:        if (self->owner->client->silencer_shots)
        !          1216:                volume = 0.2;
        !          1217: 
        !          1218:        gi.sound (self->owner, CHAN_RELIABLE+CHAN_WEAPON, gi.soundindex("weapons/grapple/grpull.wav"), volume, ATTN_NORM, 0);
        !          1219:        gi.sound (self, CHAN_WEAPON, gi.soundindex("weapons/grapple/grhit.wav"), volume, ATTN_NORM, 0);
        !          1220: 
        !          1221:        gi.WriteByte (svc_temp_entity);
        !          1222:        gi.WriteByte (TE_SPARKS);
        !          1223:        gi.WritePosition (self->s.origin);
        !          1224:        if (!plane)
        !          1225:                gi.WriteDir (vec3_origin);
        !          1226:        else
        !          1227:                gi.WriteDir (plane->normal);
        !          1228:        gi.multicast (self->s.origin, MULTICAST_PVS);
        !          1229: }
        !          1230: 
        !          1231: // draw beam between grapple and self
        !          1232: void CTFGrappleDrawCable(edict_t *self)
        !          1233: {
        !          1234:        vec3_t  offset, start, end, f, r;
        !          1235:        vec3_t  dir;
        !          1236:        float   distance;
        !          1237: 
        !          1238:        AngleVectors (self->owner->client->v_angle, f, r, NULL);
        !          1239:        VectorSet(offset, 16, 16, self->owner->viewheight-8);
        !          1240:        P_ProjectSource (self->owner->client, self->owner->s.origin, offset, f, r, start);
        !          1241: 
        !          1242:        VectorSubtract(start, self->owner->s.origin, offset);
        !          1243: 
        !          1244:        VectorSubtract (start, self->s.origin, dir);
        !          1245:        distance = VectorLength(dir);
        !          1246:        // don't draw cable if close
        !          1247:        if (distance < 64)
        !          1248:                return;
        !          1249: 
        !          1250: #if 0
        !          1251:        if (distance > 256)
        !          1252:                return;
        !          1253: 
        !          1254:        // check for min/max pitch
        !          1255:        vectoangles (dir, angles);
        !          1256:        if (angles[0] < -180)
        !          1257:                angles[0] += 360;
        !          1258:        if (fabs(angles[0]) > 45)
        !          1259:                return;
        !          1260: 
        !          1261:        trace_t tr; //!!
        !          1262: 
        !          1263:        tr = gi.trace (start, NULL, NULL, self->s.origin, self, MASK_SHOT);
        !          1264:        if (tr.ent != self) {
        !          1265:                CTFResetGrapple(self);
        !          1266:                return;
        !          1267:        }
        !          1268: #endif
        !          1269: 
        !          1270:        // adjust start for beam origin being in middle of a segment
        !          1271: //     VectorMA (start, 8, f, start);
        !          1272: 
        !          1273:        VectorCopy (self->s.origin, end);
        !          1274:        // adjust end z for end spot since the monster is currently dead
        !          1275: //     end[2] = self->absmin[2] + self->size[2] / 2;
        !          1276: 
        !          1277:        gi.WriteByte (svc_temp_entity);
        !          1278: #if 1 //def USE_GRAPPLE_CABLE
        !          1279:        gi.WriteByte (TE_GRAPPLE_CABLE);
        !          1280:        gi.WriteShort (self->owner - g_edicts);
        !          1281:        gi.WritePosition (self->owner->s.origin);
        !          1282:        gi.WritePosition (end);
        !          1283:        gi.WritePosition (offset);
        !          1284: #else
        !          1285:        gi.WriteByte (TE_MEDIC_CABLE_ATTACK);
        !          1286:        gi.WriteShort (self - g_edicts);
        !          1287:        gi.WritePosition (end);
        !          1288:        gi.WritePosition (start);
        !          1289: #endif
        !          1290:        gi.multicast (self->s.origin, MULTICAST_PVS);
        !          1291: }
        !          1292: 
        !          1293: void SV_AddGravity (edict_t *ent);
        !          1294: 
        !          1295: // pull the player toward the grapple
        !          1296: void CTFGrapplePull(edict_t *self)
        !          1297: {
        !          1298:        vec3_t hookdir, v;
        !          1299:        float vlen;
        !          1300: 
        !          1301:        if (strcmp(self->owner->client->pers.weapon->classname, "weapon_grapple") == 0 &&
        !          1302:                !self->owner->client->newweapon &&
        !          1303:                self->owner->client->weaponstate != WEAPON_FIRING &&
        !          1304:                self->owner->client->weaponstate != WEAPON_ACTIVATING) {
        !          1305:                CTFResetGrapple(self);
        !          1306:                return;
        !          1307:        }
        !          1308: 
        !          1309:        if (self->enemy) {
        !          1310:                if (self->enemy->solid == SOLID_NOT) {
        !          1311:                        CTFResetGrapple(self);
        !          1312:                        return;
        !          1313:                }
        !          1314:                if (self->enemy->solid == SOLID_BBOX) {
        !          1315:                        VectorScale(self->enemy->size, 0.5, v);
        !          1316:                        VectorAdd(v, self->enemy->s.origin, v);
        !          1317:                        VectorAdd(v, self->enemy->mins, self->s.origin);
        !          1318:                        gi.linkentity (self);
        !          1319:                } else
        !          1320:                        VectorCopy(self->enemy->velocity, self->velocity);
        !          1321:                if (self->enemy->takedamage &&
        !          1322:                        !CheckTeamDamage (self->enemy, self->owner)) {
        !          1323:                        float volume = 1.0;
        !          1324: 
        !          1325:                        if (self->owner->client->silencer_shots)
        !          1326:                                volume = 0.2;
        !          1327: 
        !          1328:                        T_Damage (self->enemy, self, self->owner, self->velocity, self->s.origin, vec3_origin, 1, 1, 0, MOD_GRAPPLE);
        !          1329:                        gi.sound (self, CHAN_WEAPON, gi.soundindex("weapons/grapple/grhurt.wav"), volume, ATTN_NORM, 0);
        !          1330:                }
        !          1331:                if (self->enemy->deadflag) { // he died
        !          1332:                        CTFResetGrapple(self);
        !          1333:                        return;
        !          1334:                }
        !          1335:        }
        !          1336: 
        !          1337:        CTFGrappleDrawCable(self);
        !          1338: 
        !          1339:        if (self->owner->client->ctf_grapplestate > CTF_GRAPPLE_STATE_FLY) {
        !          1340:                // pull player toward grapple
        !          1341:                // this causes icky stuff with prediction, we need to extend
        !          1342:                // the prediction layer to include two new fields in the player
        !          1343:                // move stuff: a point and a velocity.  The client should add
        !          1344:                // that velociy in the direction of the point
        !          1345:                vec3_t forward, up;
        !          1346: 
        !          1347:                AngleVectors (self->owner->client->v_angle, forward, NULL, up);
        !          1348:                VectorCopy(self->owner->s.origin, v);
        !          1349:                v[2] += self->owner->viewheight;
        !          1350:                VectorSubtract (self->s.origin, v, hookdir);
        !          1351: 
        !          1352:                vlen = VectorLength(hookdir);
        !          1353: 
        !          1354:                if (self->owner->client->ctf_grapplestate == CTF_GRAPPLE_STATE_PULL &&
        !          1355:                        vlen < 64) {
        !          1356:                        float volume = 1.0;
        !          1357: 
        !          1358:                        if (self->owner->client->silencer_shots)
        !          1359:                                volume = 0.2;
        !          1360: 
        !          1361:                        self->owner->client->ps.pmove.pm_flags |= PMF_NO_PREDICTION;
        !          1362:                        gi.sound (self->owner, CHAN_RELIABLE+CHAN_WEAPON, gi.soundindex("weapons/grapple/grhang.wav"), volume, ATTN_NORM, 0);
        !          1363:                        self->owner->client->ctf_grapplestate = CTF_GRAPPLE_STATE_HANG;
        !          1364:                }
        !          1365: 
        !          1366:                VectorNormalize (hookdir);
        !          1367:                VectorScale(hookdir, CTF_GRAPPLE_PULL_SPEED, hookdir);
        !          1368:                VectorCopy(hookdir, self->owner->velocity);
        !          1369:                SV_AddGravity(self->owner);
        !          1370:        }
        !          1371: }
        !          1372: 
        !          1373: void CTFFireGrapple (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int effect)
        !          1374: {
        !          1375:        edict_t *grapple;
        !          1376:        trace_t tr;
        !          1377: 
        !          1378:        VectorNormalize (dir);
        !          1379: 
        !          1380:        grapple = G_Spawn();
        !          1381:        VectorCopy (start, grapple->s.origin);
        !          1382:        VectorCopy (start, grapple->s.old_origin);
        !          1383:        vectoangles (dir, grapple->s.angles);
        !          1384:        VectorScale (dir, speed, grapple->velocity);
        !          1385:        grapple->movetype = MOVETYPE_FLYMISSILE;
        !          1386:        grapple->clipmask = MASK_SHOT;
        !          1387:        grapple->solid = SOLID_BBOX;
        !          1388:        grapple->s.effects |= effect;
        !          1389:        VectorClear (grapple->mins);
        !          1390:        VectorClear (grapple->maxs);
        !          1391:        grapple->s.modelindex = gi.modelindex ("models/weapons/grapple/hook/tris.md2");
        !          1392: //     grapple->s.sound = gi.soundindex ("misc/lasfly.wav");
        !          1393:        grapple->owner = self;
        !          1394:        grapple->touch = CTFGrappleTouch;
        !          1395: //     grapple->nextthink = level.time + FRAMETIME;
        !          1396: //     grapple->think = CTFGrappleThink;
        !          1397:        grapple->dmg = damage;
        !          1398:        self->client->ctf_grapple = grapple;
        !          1399:        self->client->ctf_grapplestate = CTF_GRAPPLE_STATE_FLY; // we're firing, not on hook
        !          1400:        gi.linkentity (grapple);
        !          1401: 
        !          1402:        tr = gi.trace (self->s.origin, NULL, NULL, grapple->s.origin, grapple, MASK_SHOT);
        !          1403:        if (tr.fraction < 1.0)
        !          1404:        {
        !          1405:                VectorMA (grapple->s.origin, -10, dir, grapple->s.origin);
        !          1406:                grapple->touch (grapple, tr.ent, NULL, NULL);
        !          1407:        }
        !          1408: }      
        !          1409: 
        !          1410: void CTFGrappleFire (edict_t *ent, vec3_t g_offset, int damage, int effect)
        !          1411: {
        !          1412:        vec3_t  forward, right;
        !          1413:        vec3_t  start;
        !          1414:        vec3_t  offset;
        !          1415:        float volume = 1.0;
        !          1416: 
        !          1417:        if (ent->client->ctf_grapplestate > CTF_GRAPPLE_STATE_FLY)
        !          1418:                return; // it's already out
        !          1419: 
        !          1420:        AngleVectors (ent->client->v_angle, forward, right, NULL);
        !          1421: //     VectorSet(offset, 24, 16, ent->viewheight-8+2);
        !          1422:        VectorSet(offset, 24, 8, ent->viewheight-8+2);
        !          1423:        VectorAdd (offset, g_offset, offset);
        !          1424:        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
        !          1425: 
        !          1426:        VectorScale (forward, -2, ent->client->kick_origin);
        !          1427:        ent->client->kick_angles[0] = -1;
        !          1428: 
        !          1429:        if (ent->client->silencer_shots)
        !          1430:                volume = 0.2;
        !          1431: 
        !          1432:        gi.sound (ent, CHAN_RELIABLE+CHAN_WEAPON, gi.soundindex("weapons/grapple/grfire.wav"), volume, ATTN_NORM, 0);
        !          1433:        CTFFireGrapple (ent, start, forward, damage, CTF_GRAPPLE_SPEED, effect);
        !          1434: 
        !          1435: #if 0
        !          1436:        // send muzzle flash
        !          1437:        gi.WriteByte (svc_muzzleflash);
        !          1438:        gi.WriteShort (ent-g_edicts);
        !          1439:        gi.WriteByte (MZ_BLASTER);
        !          1440:        gi.multicast (ent->s.origin, MULTICAST_PVS);
        !          1441: #endif
        !          1442: 
        !          1443:        PlayerNoise(ent, start, PNOISE_WEAPON);
        !          1444: }
        !          1445: 
        !          1446: 
        !          1447: void CTFWeapon_Grapple_Fire (edict_t *ent)
        !          1448: {
        !          1449:        int             damage;
        !          1450: 
        !          1451:        damage = 10;
        !          1452:        CTFGrappleFire (ent, vec3_origin, damage, 0);
        !          1453:        ent->client->ps.gunframe++;
        !          1454: }
        !          1455: 
        !          1456: void CTFWeapon_Grapple (edict_t *ent)
        !          1457: {
        !          1458:        static int      pause_frames[]  = {10, 18, 27, 0};
        !          1459:        static int      fire_frames[]   = {6, 0};
        !          1460:        int prevstate;
        !          1461: 
        !          1462:        // if the the attack button is still down, stay in the firing frame
        !          1463:        if ((ent->client->buttons & BUTTON_ATTACK) && 
        !          1464:                ent->client->weaponstate == WEAPON_FIRING &&
        !          1465:                ent->client->ctf_grapple)
        !          1466:                ent->client->ps.gunframe = 9;
        !          1467: 
        !          1468:        if (!(ent->client->buttons & BUTTON_ATTACK) && 
        !          1469:                ent->client->ctf_grapple) {
        !          1470:                CTFResetGrapple(ent->client->ctf_grapple);
        !          1471:                if (ent->client->weaponstate == WEAPON_FIRING)
        !          1472:                        ent->client->weaponstate = WEAPON_READY;
        !          1473:        }
        !          1474: 
        !          1475: 
        !          1476:        if (ent->client->newweapon && 
        !          1477:                ent->client->ctf_grapplestate > CTF_GRAPPLE_STATE_FLY &&
        !          1478:                ent->client->weaponstate == WEAPON_FIRING) {
        !          1479:                // he wants to change weapons while grappled
        !          1480:                ent->client->weaponstate = WEAPON_DROPPING;
        !          1481:                ent->client->ps.gunframe = 32;
        !          1482:        }
        !          1483: 
        !          1484:        prevstate = ent->client->weaponstate;
        !          1485:        Weapon_Generic (ent, 5, 9, 31, 36, pause_frames, fire_frames, 
        !          1486:                CTFWeapon_Grapple_Fire);
        !          1487: 
        !          1488:        // if we just switched back to grapple, immediately go to fire frame
        !          1489:        if (prevstate == WEAPON_ACTIVATING &&
        !          1490:                ent->client->weaponstate == WEAPON_READY &&
        !          1491:                ent->client->ctf_grapplestate > CTF_GRAPPLE_STATE_FLY) {
        !          1492:                if (!(ent->client->buttons & BUTTON_ATTACK))
        !          1493:                        ent->client->ps.gunframe = 9;
        !          1494:                else
        !          1495:                        ent->client->ps.gunframe = 5;
        !          1496:                ent->client->weaponstate = WEAPON_FIRING;
        !          1497:        }
        !          1498: }
        !          1499: 
        !          1500: void CTFTeam_f (edict_t *ent)
        !          1501: {
        !          1502:        char *t, *s;
        !          1503:        int desired_team;
        !          1504: 
        !          1505:        t = gi.args();
        !          1506:        if (!*t) {
        !          1507:                gi.cprintf(ent, PRINT_HIGH, "You are on the %s team.\n",
        !          1508:                        CTFTeamName(ent->client->resp.ctf_team));
        !          1509:                return;
        !          1510:        }
        !          1511: 
        !          1512:        if (ctfgame.match > MATCH_SETUP) {
        !          1513:                gi.cprintf(ent, PRINT_HIGH, "Can't change teams in a match.\n");
        !          1514:                return;
        !          1515:        }
        !          1516: 
        !          1517:        if (Q_stricmp(t, "red") == 0)
        !          1518:                desired_team = CTF_TEAM1;
        !          1519:        else if (Q_stricmp(t, "blue") == 0)
        !          1520:                desired_team = CTF_TEAM2;
        !          1521:        else {
        !          1522:                gi.cprintf(ent, PRINT_HIGH, "Unknown team %s.\n", t);
        !          1523:                return;
        !          1524:        }
        !          1525: 
        !          1526:        if (ent->client->resp.ctf_team == desired_team) {
        !          1527:                gi.cprintf(ent, PRINT_HIGH, "You are already on the %s team.\n",
        !          1528:                        CTFTeamName(ent->client->resp.ctf_team));
        !          1529:                return;
        !          1530:        }
        !          1531: 
        !          1532: ////
        !          1533:        ent->svflags = 0;
        !          1534:        ent->flags &= ~FL_GODMODE;
        !          1535:        ent->client->resp.ctf_team = desired_team;
        !          1536:        ent->client->resp.ctf_state = 0;
        !          1537:        s = Info_ValueForKey (ent->client->pers.userinfo, "skin");
        !          1538:        CTFAssignSkin(ent, s);
        !          1539: 
        !          1540:        if (ent->solid == SOLID_NOT) { // spectator
        !          1541:                PutClientInServer (ent);
        !          1542:                // add a teleportation effect
        !          1543:                ent->s.event = EV_PLAYER_TELEPORT;
        !          1544:                // hold in place briefly
        !          1545:                ent->client->ps.pmove.pm_flags = PMF_TIME_TELEPORT;
        !          1546:                ent->client->ps.pmove.pm_time = 14;
        !          1547:                gi.bprintf(PRINT_HIGH, "%s joined the %s team.\n",
        !          1548:                        ent->client->pers.netname, CTFTeamName(desired_team));
        !          1549:                return;
        !          1550:        }
        !          1551: 
        !          1552:        ent->health = 0;
        !          1553:        player_die (ent, ent, ent, 100000, vec3_origin);
        !          1554:        // don't even bother waiting for death frames
        !          1555:        ent->deadflag = DEAD_DEAD;
        !          1556:        respawn (ent);
        !          1557: 
        !          1558:        ent->client->resp.score = 0;
        !          1559: 
        !          1560:        gi.bprintf(PRINT_HIGH, "%s changed to the %s team.\n",
        !          1561:                ent->client->pers.netname, CTFTeamName(desired_team));
        !          1562: }
        !          1563: 
        !          1564: /*
        !          1565: ==================
        !          1566: CTFScoreboardMessage
        !          1567: ==================
        !          1568: */
        !          1569: void CTFScoreboardMessage (edict_t *ent, edict_t *killer)
        !          1570: {
        !          1571:        char    entry[1024];
        !          1572:        char    string[1400];
        !          1573:        int             len;
        !          1574:        int             i, j, k, n;
        !          1575:        int             sorted[2][MAX_CLIENTS];
        !          1576:        int             sortedscores[2][MAX_CLIENTS];
        !          1577:        int             score, total[2], totalscore[2];
        !          1578:        int             last[2];
        !          1579:        gclient_t       *cl;
        !          1580:        edict_t         *cl_ent;
        !          1581:        int team;
        !          1582:        int maxsize = 1000;
        !          1583: 
        !          1584:        // sort the clients by team and score
        !          1585:        total[0] = total[1] = 0;
        !          1586:        last[0] = last[1] = 0;
        !          1587:        totalscore[0] = totalscore[1] = 0;
        !          1588:        for (i=0 ; i<game.maxclients ; i++)
        !          1589:        {
        !          1590:                cl_ent = g_edicts + 1 + i;
        !          1591:                if (!cl_ent->inuse)
        !          1592:                        continue;
        !          1593:                if (game.clients[i].resp.ctf_team == CTF_TEAM1)
        !          1594:                        team = 0;
        !          1595:                else if (game.clients[i].resp.ctf_team == CTF_TEAM2)
        !          1596:                        team = 1;
        !          1597:                else
        !          1598:                        continue; // unknown team?
        !          1599: 
        !          1600:                score = game.clients[i].resp.score;
        !          1601:                for (j=0 ; j<total[team] ; j++)
        !          1602:                {
        !          1603:                        if (score > sortedscores[team][j])
        !          1604:                                break;
        !          1605:                }
        !          1606:                for (k=total[team] ; k>j ; k--)
        !          1607:                {
        !          1608:                        sorted[team][k] = sorted[team][k-1];
        !          1609:                        sortedscores[team][k] = sortedscores[team][k-1];
        !          1610:                }
        !          1611:                sorted[team][j] = i;
        !          1612:                sortedscores[team][j] = score;
        !          1613:                totalscore[team] += score;
        !          1614:                total[team]++;
        !          1615:        }
        !          1616: 
        !          1617:        // print level name and exit rules
        !          1618:        // add the clients in sorted order
        !          1619:        *string = 0;
        !          1620:        len = 0;
        !          1621: 
        !          1622:        // team one
        !          1623:        sprintf(string, "if 24 xv 8 yv 8 pic 24 endif "
        !          1624:                "xv 40 yv 28 string \"%4d/%-3d\" "
        !          1625:                "xv 98 yv 12 num 2 18 "
        !          1626:                "if 25 xv 168 yv 8 pic 25 endif "
        !          1627:                "xv 200 yv 28 string \"%4d/%-3d\" "
        !          1628:                "xv 256 yv 12 num 2 20 ",
        !          1629:                totalscore[0], total[0],
        !          1630:                totalscore[1], total[1]);
        !          1631:        len = strlen(string);
        !          1632: 
        !          1633:        for (i=0 ; i<16 ; i++)
        !          1634:        {
        !          1635:                if (i >= total[0] && i >= total[1])
        !          1636:                        break; // we're done
        !          1637: 
        !          1638: #if 0 //ndef NEW_SCORE
        !          1639:                // set up y
        !          1640:                sprintf(entry, "yv %d ", 42 + i * 8);
        !          1641:                if (maxsize - len > strlen(entry)) {
        !          1642:                        strcat(string, entry);
        !          1643:                        len = strlen(string);
        !          1644:                }
        !          1645: #else
        !          1646:                *entry = 0;
        !          1647: #endif
        !          1648: 
        !          1649:                // left side
        !          1650:                if (i < total[0]) {
        !          1651:                        cl = &game.clients[sorted[0][i]];
        !          1652:                        cl_ent = g_edicts + 1 + sorted[0][i];
        !          1653: 
        !          1654: #if 0 //ndef NEW_SCORE
        !          1655:                        sprintf(entry+strlen(entry),
        !          1656:                        "xv 0 %s \"%3d %3d %-12.12s\" ",
        !          1657:                        (cl_ent == ent) ? "string2" : "string",
        !          1658:                        cl->resp.score, 
        !          1659:                        (cl->ping > 999) ? 999 : cl->ping, 
        !          1660:                        cl->pers.netname);
        !          1661: 
        !          1662:                        if (cl_ent->client->pers.inventory[ITEM_INDEX(flag2_item)])
        !          1663:                                strcat(entry, "xv 56 picn sbfctf2 ");
        !          1664: #else
        !          1665:                        sprintf(entry+strlen(entry),
        !          1666:                                "ctf 0 %d %d %d %d ",
        !          1667:                                42 + i * 8,
        !          1668:                                sorted[0][i],
        !          1669:                                cl->resp.score,
        !          1670:                                cl->ping > 999 ? 999 : cl->ping);
        !          1671: 
        !          1672:                        if (cl_ent->client->pers.inventory[ITEM_INDEX(flag2_item)])
        !          1673:                                sprintf(entry + strlen(entry), "xv 56 yv %d picn sbfctf2 ",
        !          1674:                                        42 + i * 8);
        !          1675: #endif
        !          1676: 
        !          1677:                        if (maxsize - len > strlen(entry)) {
        !          1678:                                strcat(string, entry);
        !          1679:                                len = strlen(string);
        !          1680:                                last[0] = i;
        !          1681:                        }
        !          1682:                }
        !          1683: 
        !          1684:                // right side
        !          1685:                if (i < total[1]) {
        !          1686:                        cl = &game.clients[sorted[1][i]];
        !          1687:                        cl_ent = g_edicts + 1 + sorted[1][i];
        !          1688: 
        !          1689: #if 0 //ndef NEW_SCORE
        !          1690:                        sprintf(entry+strlen(entry),
        !          1691:                        "xv 160 %s \"%3d %3d %-12.12s\" ",
        !          1692:                        (cl_ent == ent) ? "string2" : "string",
        !          1693:                        cl->resp.score, 
        !          1694:                        (cl->ping > 999) ? 999 : cl->ping, 
        !          1695:                        cl->pers.netname);
        !          1696: 
        !          1697:                        if (cl_ent->client->pers.inventory[ITEM_INDEX(flag1_item)])
        !          1698:                                strcat(entry, "xv 216 picn sbfctf1 ");
        !          1699: 
        !          1700: #else
        !          1701: 
        !          1702:                        sprintf(entry+strlen(entry),
        !          1703:                                "ctf 160 %d %d %d %d ",
        !          1704:                                42 + i * 8,
        !          1705:                                sorted[1][i],
        !          1706:                                cl->resp.score,
        !          1707:                                cl->ping > 999 ? 999 : cl->ping);
        !          1708: 
        !          1709:                        if (cl_ent->client->pers.inventory[ITEM_INDEX(flag1_item)])
        !          1710:                                sprintf(entry + strlen(entry), "xv 216 yv %d picn sbfctf1 ",
        !          1711:                                        42 + i * 8);
        !          1712: #endif
        !          1713:                        if (maxsize - len > strlen(entry)) {
        !          1714:                                strcat(string, entry);
        !          1715:                                len = strlen(string);
        !          1716:                                last[1] = i;
        !          1717:                        }
        !          1718:                }
        !          1719:        }
        !          1720: 
        !          1721:        // put in spectators if we have enough room
        !          1722:        if (last[0] > last[1])
        !          1723:                j = last[0];
        !          1724:        else
        !          1725:                j = last[1];
        !          1726:        j = (j + 2) * 8 + 42;
        !          1727: 
        !          1728:        k = n = 0;
        !          1729:        if (maxsize - len > 50) {
        !          1730:                for (i = 0; i < maxclients->value; i++) {
        !          1731:                        cl_ent = g_edicts + 1 + i;
        !          1732:                        cl = &game.clients[i];
        !          1733:                        if (!cl_ent->inuse ||
        !          1734:                                cl_ent->solid != SOLID_NOT ||
        !          1735:                                cl_ent->client->resp.ctf_team != CTF_NOTEAM)
        !          1736:                                continue;
        !          1737: 
        !          1738:                        if (!k) {
        !          1739:                                k = 1;
        !          1740:                                sprintf(entry, "xv 0 yv %d string2 \"Spectators\" ", j);
        !          1741:                                strcat(string, entry);
        !          1742:                                len = strlen(string);
        !          1743:                                j += 8;
        !          1744:                        }
        !          1745: 
        !          1746:                        sprintf(entry+strlen(entry),
        !          1747:                                "ctf %d %d %d %d %d ",
        !          1748:                                (n & 1) ? 160 : 0, // x
        !          1749:                                j, // y
        !          1750:                                i, // playernum
        !          1751:                                cl->resp.score,
        !          1752:                                cl->ping > 999 ? 999 : cl->ping);
        !          1753:                        if (maxsize - len > strlen(entry)) {
        !          1754:                                strcat(string, entry);
        !          1755:                                len = strlen(string);
        !          1756:                        }
        !          1757:                        
        !          1758:                        if (n & 1)
        !          1759:                                j += 8;
        !          1760:                        n++;
        !          1761:                }
        !          1762:        }
        !          1763: 
        !          1764:        if (total[0] - last[0] > 1) // couldn't fit everyone
        !          1765:                sprintf(string + strlen(string), "xv 8 yv %d string \"..and %d more\" ",
        !          1766:                        42 + (last[0]+1)*8, total[0] - last[0] - 1);
        !          1767:        if (total[1] - last[1] > 1) // couldn't fit everyone
        !          1768:                sprintf(string + strlen(string), "xv 168 yv %d string \"..and %d more\" ",
        !          1769:                        42 + (last[1]+1)*8, total[1] - last[1] - 1);
        !          1770: 
        !          1771:        gi.WriteByte (svc_layout);
        !          1772:        gi.WriteString (string);
        !          1773: }
        !          1774: 
        !          1775: /*------------------------------------------------------------------------*/
        !          1776: /* TECH                                                                                                                                          */
        !          1777: /*------------------------------------------------------------------------*/
        !          1778: 
        !          1779: void CTFHasTech(edict_t *who)
        !          1780: {
        !          1781:        if (level.time - who->client->ctf_lasttechmsg > 2) {
        !          1782:                gi.centerprintf(who, "You already have a TECH powerup.");
        !          1783:                who->client->ctf_lasttechmsg = level.time;
        !          1784:        }
        !          1785: }
        !          1786: 
        !          1787: gitem_t *CTFWhat_Tech(edict_t *ent)
        !          1788: {
        !          1789:        gitem_t *tech;
        !          1790:        int i;
        !          1791: 
        !          1792:        i = 0;
        !          1793:        while (tnames[i]) {
        !          1794:                if ((tech = FindItemByClassname(tnames[i])) != NULL &&
        !          1795:                        ent->client->pers.inventory[ITEM_INDEX(tech)]) {
        !          1796:                        return tech;
        !          1797:                }
        !          1798:                i++;
        !          1799:        }
        !          1800:        return NULL;
        !          1801: }
        !          1802: 
        !          1803: qboolean CTFPickup_Tech (edict_t *ent, edict_t *other)
        !          1804: {
        !          1805:        gitem_t *tech;
        !          1806:        int i;
        !          1807: 
        !          1808:        i = 0;
        !          1809:        while (tnames[i]) {
        !          1810:                if ((tech = FindItemByClassname(tnames[i])) != NULL &&
        !          1811:                        other->client->pers.inventory[ITEM_INDEX(tech)]) {
        !          1812:                        CTFHasTech(other);
        !          1813:                        return false; // has this one
        !          1814:                }
        !          1815:                i++;
        !          1816:        }
        !          1817:        
        !          1818:        // client only gets one tech
        !          1819:        other->client->pers.inventory[ITEM_INDEX(ent->item)]++;
        !          1820:        other->client->ctf_regentime = level.time;
        !          1821:        return true;
        !          1822: }
        !          1823: 
        !          1824: static void SpawnTech(gitem_t *item, edict_t *spot);
        !          1825: 
        !          1826: static edict_t *FindTechSpawn(void)
        !          1827: {
        !          1828:        edict_t *spot = NULL;
        !          1829:        int i = rand() % 16;
        !          1830: 
        !          1831:        while (i--)
        !          1832:                spot = G_Find (spot, FOFS(classname), "info_player_deathmatch");
        !          1833:        if (!spot)
        !          1834:                spot = G_Find (spot, FOFS(classname), "info_player_deathmatch");
        !          1835:        return spot;
        !          1836: }
        !          1837: 
        !          1838: static void TechThink(edict_t *tech)
        !          1839: {
        !          1840:        edict_t *spot;
        !          1841: 
        !          1842:        if ((spot = FindTechSpawn()) != NULL) {
        !          1843:                SpawnTech(tech->item, spot);
        !          1844:                G_FreeEdict(tech);
        !          1845:        } else {
        !          1846:                tech->nextthink = level.time + CTF_TECH_TIMEOUT;
        !          1847:                tech->think = TechThink;
        !          1848:        }
        !          1849: }
        !          1850: 
        !          1851: void CTFDrop_Tech(edict_t *ent, gitem_t *item)
        !          1852: {
        !          1853:        edict_t *tech;
        !          1854: 
        !          1855:        tech = Drop_Item(ent, item);
        !          1856:        tech->nextthink = level.time + CTF_TECH_TIMEOUT;
        !          1857:        tech->think = TechThink;
        !          1858:        ent->client->pers.inventory[ITEM_INDEX(item)] = 0;
        !          1859: }
        !          1860: 
        !          1861: void CTFDeadDropTech(edict_t *ent)
        !          1862: {
        !          1863:        gitem_t *tech;
        !          1864:        edict_t *dropped;
        !          1865:        int i;
        !          1866: 
        !          1867:        i = 0;
        !          1868:        while (tnames[i]) {
        !          1869:                if ((tech = FindItemByClassname(tnames[i])) != NULL &&
        !          1870:                        ent->client->pers.inventory[ITEM_INDEX(tech)]) {
        !          1871:                        dropped = Drop_Item(ent, tech);
        !          1872:                        // hack the velocity to make it bounce random
        !          1873:                        dropped->velocity[0] = (rand() % 600) - 300;
        !          1874:                        dropped->velocity[1] = (rand() % 600) - 300;
        !          1875:                        dropped->nextthink = level.time + CTF_TECH_TIMEOUT;
        !          1876:                        dropped->think = TechThink;
        !          1877:                        dropped->owner = NULL;
        !          1878:                        ent->client->pers.inventory[ITEM_INDEX(tech)] = 0;
        !          1879:                }
        !          1880:                i++;
        !          1881:        }
        !          1882: }
        !          1883: 
        !          1884: static void SpawnTech(gitem_t *item, edict_t *spot)
        !          1885: {
        !          1886:        edict_t *ent;
        !          1887:        vec3_t  forward, right;
        !          1888:        vec3_t  angles;
        !          1889: 
        !          1890:        ent = G_Spawn();
        !          1891: 
        !          1892:        ent->classname = item->classname;
        !          1893:        ent->item = item;
        !          1894:        ent->spawnflags = DROPPED_ITEM;
        !          1895:        ent->s.effects = item->world_model_flags;
        !          1896:        ent->s.renderfx = RF_GLOW;
        !          1897:        VectorSet (ent->mins, -15, -15, -15);
        !          1898:        VectorSet (ent->maxs, 15, 15, 15);
        !          1899:        gi.setmodel (ent, ent->item->world_model);
        !          1900:        ent->solid = SOLID_TRIGGER;
        !          1901:        ent->movetype = MOVETYPE_TOSS;  
        !          1902:        ent->touch = Touch_Item;
        !          1903:        ent->owner = ent;
        !          1904: 
        !          1905:        angles[0] = 0;
        !          1906:        angles[1] = rand() % 360;
        !          1907:        angles[2] = 0;
        !          1908: 
        !          1909:        AngleVectors (angles, forward, right, NULL);
        !          1910:        VectorCopy (spot->s.origin, ent->s.origin);
        !          1911:        ent->s.origin[2] += 16;
        !          1912:        VectorScale (forward, 100, ent->velocity);
        !          1913:        ent->velocity[2] = 300;
        !          1914: 
        !          1915:        ent->nextthink = level.time + CTF_TECH_TIMEOUT;
        !          1916:        ent->think = TechThink;
        !          1917: 
        !          1918:        gi.linkentity (ent);
        !          1919: }
        !          1920: 
        !          1921: static void SpawnTechs(edict_t *ent)
        !          1922: {
        !          1923:        gitem_t *tech;
        !          1924:        edict_t *spot;
        !          1925:        int i;
        !          1926: 
        !          1927:        i = 0;
        !          1928:        while (tnames[i]) {
        !          1929:                if ((tech = FindItemByClassname(tnames[i])) != NULL &&
        !          1930:                        (spot = FindTechSpawn()) != NULL)
        !          1931:                        SpawnTech(tech, spot);
        !          1932:                i++;
        !          1933:        }
        !          1934:        if (ent)
        !          1935:                G_FreeEdict(ent);
        !          1936: }
        !          1937: 
        !          1938: // frees the passed edict!
        !          1939: void CTFRespawnTech(edict_t *ent)
        !          1940: {
        !          1941:        edict_t *spot;
        !          1942: 
        !          1943:        if ((spot = FindTechSpawn()) != NULL)
        !          1944:                SpawnTech(ent->item, spot);
        !          1945:        G_FreeEdict(ent);
        !          1946: }
        !          1947: 
        !          1948: void CTFSetupTechSpawn(void)
        !          1949: {
        !          1950:        edict_t *ent;
        !          1951: 
        !          1952:        if (((int)dmflags->value & DF_CTF_NO_TECH))
        !          1953:                return;
        !          1954: 
        !          1955:        ent = G_Spawn();
        !          1956:        ent->nextthink = level.time + 2;
        !          1957:        ent->think = SpawnTechs;
        !          1958: }
        !          1959: 
        !          1960: void CTFResetTech(void)
        !          1961: {
        !          1962:        edict_t *ent;
        !          1963:        int i;
        !          1964: 
        !          1965:        for (ent = g_edicts + 1, i = 1; i < globals.num_edicts; i++, ent++) {
        !          1966:                if (ent->inuse)
        !          1967:                        if (ent->item && (ent->item->flags & IT_TECH))
        !          1968:                                G_FreeEdict(ent);
        !          1969:        }
        !          1970:        SpawnTechs(NULL);
        !          1971: }
        !          1972: 
        !          1973: int CTFApplyResistance(edict_t *ent, int dmg)
        !          1974: {
        !          1975:        static gitem_t *tech = NULL;
        !          1976:        float volume = 1.0;
        !          1977: 
        !          1978:        if (ent->client && ent->client->silencer_shots)
        !          1979:                volume = 0.2;
        !          1980: 
        !          1981:        if (!tech)
        !          1982:                tech = FindItemByClassname("item_tech1");
        !          1983:        if (dmg && tech && ent->client && ent->client->pers.inventory[ITEM_INDEX(tech)]) {
        !          1984:                // make noise
        !          1985:                gi.sound(ent, CHAN_VOICE, gi.soundindex("ctf/tech1.wav"), volume, ATTN_NORM, 0);
        !          1986:                return dmg / 2;
        !          1987:        }
        !          1988:        return dmg;
        !          1989: }
        !          1990: 
        !          1991: int CTFApplyStrength(edict_t *ent, int dmg)
        !          1992: {
        !          1993:        static gitem_t *tech = NULL;
        !          1994: 
        !          1995:        if (!tech)
        !          1996:                tech = FindItemByClassname("item_tech2");
        !          1997:        if (dmg && tech && ent->client && ent->client->pers.inventory[ITEM_INDEX(tech)]) {
        !          1998:                return dmg * 2;
        !          1999:        }
        !          2000:        return dmg;
        !          2001: }
        !          2002: 
        !          2003: qboolean CTFApplyStrengthSound(edict_t *ent)
        !          2004: {
        !          2005:        static gitem_t *tech = NULL;
        !          2006:        float volume = 1.0;
        !          2007: 
        !          2008:        if (ent->client && ent->client->silencer_shots)
        !          2009:                volume = 0.2;
        !          2010: 
        !          2011:        if (!tech)
        !          2012:                tech = FindItemByClassname("item_tech2");
        !          2013:        if (tech && ent->client &&
        !          2014:                ent->client->pers.inventory[ITEM_INDEX(tech)]) {
        !          2015:                if (ent->client->ctf_techsndtime < level.time) {
        !          2016:                        ent->client->ctf_techsndtime = level.time + 1;
        !          2017:                        if (ent->client->quad_framenum > level.framenum)
        !          2018:                                gi.sound(ent, CHAN_VOICE, gi.soundindex("ctf/tech2x.wav"), volume, ATTN_NORM, 0);
        !          2019:                        else
        !          2020:                                gi.sound(ent, CHAN_VOICE, gi.soundindex("ctf/tech2.wav"), volume, ATTN_NORM, 0);
        !          2021:                }
        !          2022:                return true;
        !          2023:        }
        !          2024:        return false;
        !          2025: }
        !          2026: 
        !          2027: 
        !          2028: qboolean CTFApplyHaste(edict_t *ent)
        !          2029: {
        !          2030:        static gitem_t *tech = NULL;
        !          2031: 
        !          2032:        if (!tech)
        !          2033:                tech = FindItemByClassname("item_tech3");
        !          2034:        if (tech && ent->client &&
        !          2035:                ent->client->pers.inventory[ITEM_INDEX(tech)])
        !          2036:                return true;
        !          2037:        return false;
        !          2038: }
        !          2039: 
        !          2040: void CTFApplyHasteSound(edict_t *ent)
        !          2041: {
        !          2042:        static gitem_t *tech = NULL;
        !          2043:        float volume = 1.0;
        !          2044: 
        !          2045:        if (ent->client && ent->client->silencer_shots)
        !          2046:                volume = 0.2;
        !          2047: 
        !          2048:        if (!tech)
        !          2049:                tech = FindItemByClassname("item_tech3");
        !          2050:        if (tech && ent->client &&
        !          2051:                ent->client->pers.inventory[ITEM_INDEX(tech)] &&
        !          2052:                ent->client->ctf_techsndtime < level.time) {
        !          2053:                ent->client->ctf_techsndtime = level.time + 1;
        !          2054:                gi.sound(ent, CHAN_VOICE, gi.soundindex("ctf/tech3.wav"), volume, ATTN_NORM, 0);
        !          2055:        }
        !          2056: }
        !          2057: 
        !          2058: void CTFApplyRegeneration(edict_t *ent)
        !          2059: {
        !          2060:        static gitem_t *tech = NULL;
        !          2061:        qboolean noise = false;
        !          2062:        gclient_t *client;
        !          2063:        int index;
        !          2064:        float volume = 1.0;
        !          2065: 
        !          2066:        client = ent->client;
        !          2067:        if (!client)
        !          2068:                return;
        !          2069: 
        !          2070:        if (ent->client->silencer_shots)
        !          2071:                volume = 0.2;
        !          2072: 
        !          2073:        if (!tech)
        !          2074:                tech = FindItemByClassname("item_tech4");
        !          2075:        if (tech && client->pers.inventory[ITEM_INDEX(tech)]) {
        !          2076:                if (client->ctf_regentime < level.time) {
        !          2077:                        client->ctf_regentime = level.time;
        !          2078:                        if (ent->health < 150) {
        !          2079:                                ent->health += 5;
        !          2080:                                if (ent->health > 150)
        !          2081:                                        ent->health = 150;
        !          2082:                                client->ctf_regentime += 0.5;
        !          2083:                                noise = true;
        !          2084:                        }
        !          2085:                        index = ArmorIndex (ent);
        !          2086:                        if (index && client->pers.inventory[index] < 150) {
        !          2087:                                client->pers.inventory[index] += 5;
        !          2088:                                if (client->pers.inventory[index] > 150)
        !          2089:                                        client->pers.inventory[index] = 150;
        !          2090:                                client->ctf_regentime += 0.5;
        !          2091:                                noise = true;
        !          2092:                        }
        !          2093:                }
        !          2094:                if (noise && ent->client->ctf_techsndtime < level.time) {
        !          2095:                        ent->client->ctf_techsndtime = level.time + 1;
        !          2096:                        gi.sound(ent, CHAN_VOICE, gi.soundindex("ctf/tech4.wav"), volume, ATTN_NORM, 0);
        !          2097:                }
        !          2098:        }
        !          2099: }
        !          2100: 
        !          2101: qboolean CTFHasRegeneration(edict_t *ent)
        !          2102: {
        !          2103:        static gitem_t *tech = NULL;
        !          2104: 
        !          2105:        if (!tech)
        !          2106:                tech = FindItemByClassname("item_tech4");
        !          2107:        if (tech && ent->client &&
        !          2108:                ent->client->pers.inventory[ITEM_INDEX(tech)])
        !          2109:                return true;
        !          2110:        return false;
        !          2111: }
        !          2112: 
        !          2113: /*
        !          2114: ======================================================================
        !          2115: 
        !          2116: SAY_TEAM
        !          2117: 
        !          2118: ======================================================================
        !          2119: */
        !          2120: 
        !          2121: // This array is in 'importance order', it indicates what items are
        !          2122: // more important when reporting their names.
        !          2123: struct {
        !          2124:        char *classname;
        !          2125:        int priority;
        !          2126: } loc_names[] = 
        !          2127: {
        !          2128:        {       "item_flag_team1",                      1 },
        !          2129:        {       "item_flag_team2",                      1 },
        !          2130:        {       "item_quad",                            2 }, 
        !          2131:        {       "item_invulnerability",         2 },
        !          2132:        {       "weapon_bfg",                           3 },
        !          2133:        {       "weapon_railgun",                       4 },
        !          2134:        {       "weapon_rocketlauncher",        4 },
        !          2135:        {       "weapon_hyperblaster",          4 },
        !          2136:        {       "weapon_chaingun",                      4 },
        !          2137:        {       "weapon_grenadelauncher",       4 },
        !          2138:        {       "weapon_machinegun",            4 },
        !          2139:        {       "weapon_supershotgun",          4 },
        !          2140:        {       "weapon_shotgun",                       4 },
        !          2141:        {       "item_power_screen",            5 },
        !          2142:        {       "item_power_shield",            5 },
        !          2143:        {       "item_armor_body",                      6 },
        !          2144:        {       "item_armor_combat",            6 },
        !          2145:        {       "item_armor_jacket",            6 },
        !          2146:        {       "item_silencer",                        7 },
        !          2147:        {       "item_breather",                        7 },
        !          2148:        {       "item_enviro",                          7 },
        !          2149:        {       "item_adrenaline",                      7 },
        !          2150:        {       "item_bandolier",                       8 },
        !          2151:        {       "item_pack",                            8 },
        !          2152:        { NULL, 0 }
        !          2153: };
        !          2154: 
        !          2155: 
        !          2156: static void CTFSay_Team_Location(edict_t *who, char *buf)
        !          2157: {
        !          2158:        edict_t *what = NULL;
        !          2159:        edict_t *hot = NULL;
        !          2160:        float hotdist = 999999, newdist;
        !          2161:        vec3_t v;
        !          2162:        int hotindex = 999;
        !          2163:        int i;
        !          2164:        gitem_t *item;
        !          2165:        int nearteam = -1;
        !          2166:        edict_t *flag1, *flag2;
        !          2167:        qboolean hotsee = false;
        !          2168:        qboolean cansee;
        !          2169: 
        !          2170:        while ((what = loc_findradius(what, who->s.origin, 1024)) != NULL) {
        !          2171:                // find what in loc_classnames
        !          2172:                for (i = 0; loc_names[i].classname; i++)
        !          2173:                        if (strcmp(what->classname, loc_names[i].classname) == 0)
        !          2174:                                break;
        !          2175:                if (!loc_names[i].classname)
        !          2176:                        continue;
        !          2177:                // something we can see get priority over something we can't
        !          2178:                cansee = loc_CanSee(what, who);
        !          2179:                if (cansee && !hotsee) {
        !          2180:                        hotsee = true;
        !          2181:                        hotindex = loc_names[i].priority;
        !          2182:                        hot = what;
        !          2183:                        VectorSubtract(what->s.origin, who->s.origin, v);
        !          2184:                        hotdist = VectorLength(v);
        !          2185:                        continue;
        !          2186:                }
        !          2187:                // if we can't see this, but we have something we can see, skip it
        !          2188:                if (hotsee && !cansee)
        !          2189:                        continue;
        !          2190:                if (hotsee && hotindex < loc_names[i].priority)
        !          2191:                        continue;
        !          2192:                VectorSubtract(what->s.origin, who->s.origin, v);
        !          2193:                newdist = VectorLength(v);
        !          2194:                if (newdist < hotdist || 
        !          2195:                        (cansee && loc_names[i].priority < hotindex)) {
        !          2196:                        hot = what;
        !          2197:                        hotdist = newdist;
        !          2198:                        hotindex = i;
        !          2199:                        hotsee = loc_CanSee(hot, who);
        !          2200:                }
        !          2201:        }
        !          2202: 
        !          2203:        if (!hot) {
        !          2204:                strcpy(buf, "nowhere");
        !          2205:                return;
        !          2206:        }
        !          2207: 
        !          2208:        // we now have the closest item
        !          2209:        // see if there's more than one in the map, if so
        !          2210:        // we need to determine what team is closest
        !          2211:        what = NULL;
        !          2212:        while ((what = G_Find(what, FOFS(classname), hot->classname)) != NULL) {
        !          2213:                if (what == hot)
        !          2214:                        continue;
        !          2215:                // if we are here, there is more than one, find out if hot
        !          2216:                // is closer to red flag or blue flag
        !          2217:                if ((flag1 = G_Find(NULL, FOFS(classname), "item_flag_team1")) != NULL &&
        !          2218:                        (flag2 = G_Find(NULL, FOFS(classname), "item_flag_team2")) != NULL) {
        !          2219:                        VectorSubtract(hot->s.origin, flag1->s.origin, v);
        !          2220:                        hotdist = VectorLength(v);
        !          2221:                        VectorSubtract(hot->s.origin, flag2->s.origin, v);
        !          2222:                        newdist = VectorLength(v);
        !          2223:                        if (hotdist < newdist)
        !          2224:                                nearteam = CTF_TEAM1;
        !          2225:                        else if (hotdist > newdist)
        !          2226:                                nearteam = CTF_TEAM2;
        !          2227:                }
        !          2228:                break;
        !          2229:        }
        !          2230: 
        !          2231:        if ((item = FindItemByClassname(hot->classname)) == NULL) {
        !          2232:                strcpy(buf, "nowhere");
        !          2233:                return;
        !          2234:        }
        !          2235: 
        !          2236:        // in water?
        !          2237:        if (who->waterlevel)
        !          2238:                strcpy(buf, "in the water ");
        !          2239:        else
        !          2240:                *buf = 0;
        !          2241: 
        !          2242:        // near or above
        !          2243:        VectorSubtract(who->s.origin, hot->s.origin, v);
        !          2244:        if (fabs(v[2]) > fabs(v[0]) && fabs(v[2]) > fabs(v[1]))
        !          2245:                if (v[2] > 0)
        !          2246:                        strcat(buf, "above ");
        !          2247:                else
        !          2248:                        strcat(buf, "below ");
        !          2249:        else
        !          2250:                strcat(buf, "near ");
        !          2251: 
        !          2252:        if (nearteam == CTF_TEAM1)
        !          2253:                strcat(buf, "the red ");
        !          2254:        else if (nearteam == CTF_TEAM2)
        !          2255:                strcat(buf, "the blue ");
        !          2256:        else
        !          2257:                strcat(buf, "the ");
        !          2258: 
        !          2259:        strcat(buf, item->pickup_name);
        !          2260: }
        !          2261: 
        !          2262: static void CTFSay_Team_Armor(edict_t *who, char *buf)
        !          2263: {
        !          2264:        gitem_t         *item;
        !          2265:        int                     index, cells;
        !          2266:        int                     power_armor_type;
        !          2267: 
        !          2268:        *buf = 0;
        !          2269: 
        !          2270:        power_armor_type = PowerArmorType (who);
        !          2271:        if (power_armor_type)
        !          2272:        {
        !          2273:                cells = who->client->pers.inventory[ITEM_INDEX(FindItem ("cells"))];
        !          2274:                if (cells)
        !          2275:                        sprintf(buf+strlen(buf), "%s with %i cells ",
        !          2276:                                (power_armor_type == POWER_ARMOR_SCREEN) ?
        !          2277:                                "Power Screen" : "Power Shield", cells);
        !          2278:        }
        !          2279: 
        !          2280:        index = ArmorIndex (who);
        !          2281:        if (index)
        !          2282:        {
        !          2283:                item = GetItemByIndex (index);
        !          2284:                if (item) {
        !          2285:                        if (*buf)
        !          2286:                                strcat(buf, "and ");
        !          2287:                        sprintf(buf+strlen(buf), "%i units of %s",
        !          2288:                                who->client->pers.inventory[index], item->pickup_name);
        !          2289:                }
        !          2290:        }
        !          2291: 
        !          2292:        if (!*buf)
        !          2293:                strcpy(buf, "no armor");
        !          2294: }
        !          2295: 
        !          2296: static void CTFSay_Team_Health(edict_t *who, char *buf)
        !          2297: {
        !          2298:        if (who->health <= 0)
        !          2299:                strcpy(buf, "dead");
        !          2300:        else
        !          2301:                sprintf(buf, "%i health", who->health);
        !          2302: }
        !          2303: 
        !          2304: static void CTFSay_Team_Tech(edict_t *who, char *buf)
        !          2305: {
        !          2306:        gitem_t *tech;
        !          2307:        int i;
        !          2308: 
        !          2309:        // see if the player has a tech powerup
        !          2310:        i = 0;
        !          2311:        while (tnames[i]) {
        !          2312:                if ((tech = FindItemByClassname(tnames[i])) != NULL &&
        !          2313:                        who->client->pers.inventory[ITEM_INDEX(tech)]) {
        !          2314:                        sprintf(buf, "the %s", tech->pickup_name);
        !          2315:                        return;
        !          2316:                }
        !          2317:                i++;
        !          2318:        }
        !          2319:        strcpy(buf, "no powerup");
        !          2320: }
        !          2321: 
        !          2322: static void CTFSay_Team_Weapon(edict_t *who, char *buf)
        !          2323: {
        !          2324:        if (who->client->pers.weapon)
        !          2325:                strcpy(buf, who->client->pers.weapon->pickup_name);
        !          2326:        else
        !          2327:                strcpy(buf, "none");
        !          2328: }
        !          2329: 
        !          2330: static void CTFSay_Team_Sight(edict_t *who, char *buf)
        !          2331: {
        !          2332:        int i;
        !          2333:        edict_t *targ;
        !          2334:        int n = 0;
        !          2335:        char s[1024];
        !          2336:        char s2[1024];
        !          2337: 
        !          2338:        *s = *s2 = 0;
        !          2339:        for (i = 1; i <= maxclients->value; i++) {
        !          2340:                targ = g_edicts + i;
        !          2341:                if (!targ->inuse || 
        !          2342:                        targ == who ||
        !          2343:                        !loc_CanSee(targ, who))
        !          2344:                        continue;
        !          2345:                if (*s2) {
        !          2346:                        if (strlen(s) + strlen(s2) + 3 < sizeof(s)) {
        !          2347:                                if (n)
        !          2348:                                        strcat(s, ", ");
        !          2349:                                strcat(s, s2);
        !          2350:                                *s2 = 0;
        !          2351:                        }
        !          2352:                        n++;
        !          2353:                }
        !          2354:                strcpy(s2, targ->client->pers.netname);
        !          2355:        }
        !          2356:        if (*s2) {
        !          2357:                if (strlen(s) + strlen(s2) + 6 < sizeof(s)) {
        !          2358:                        if (n)
        !          2359:                                strcat(s, " and ");
        !          2360:                        strcat(s, s2);
        !          2361:                }
        !          2362:                strcpy(buf, s);
        !          2363:        } else
        !          2364:                strcpy(buf, "no one");
        !          2365: }
        !          2366: 
        !          2367: void CTFSay_Team(edict_t *who, char *msg)
        !          2368: {
        !          2369:        char outmsg[1024];
        !          2370:        char buf[1024];
        !          2371:        int i;
        !          2372:        char *p;
        !          2373:        edict_t *cl_ent;
        !          2374: 
        !          2375:        if (CheckFlood(who))
        !          2376:                return;
        !          2377: 
        !          2378:        outmsg[0] = 0;
        !          2379: 
        !          2380:        if (*msg == '\"') {
        !          2381:                msg[strlen(msg) - 1] = 0;
        !          2382:                msg++;
        !          2383:        }
        !          2384: 
        !          2385:        for (p = outmsg; *msg && (p - outmsg) < sizeof(outmsg) - 1; msg++) {
        !          2386:                if (*msg == '%') {
        !          2387:                        switch (*++msg) {
        !          2388:                                case 'l' :
        !          2389:                                case 'L' :
        !          2390:                                        CTFSay_Team_Location(who, buf);
        !          2391:                                        strcpy(p, buf);
        !          2392:                                        p += strlen(buf);
        !          2393:                                        break;
        !          2394:                                case 'a' :
        !          2395:                                case 'A' :
        !          2396:                                        CTFSay_Team_Armor(who, buf);
        !          2397:                                        strcpy(p, buf);
        !          2398:                                        p += strlen(buf);
        !          2399:                                        break;
        !          2400:                                case 'h' :
        !          2401:                                case 'H' :
        !          2402:                                        CTFSay_Team_Health(who, buf);
        !          2403:                                        strcpy(p, buf);
        !          2404:                                        p += strlen(buf);
        !          2405:                                        break;
        !          2406:                                case 't' :
        !          2407:                                case 'T' :
        !          2408:                                        CTFSay_Team_Tech(who, buf);
        !          2409:                                        strcpy(p, buf);
        !          2410:                                        p += strlen(buf);
        !          2411:                                        break;
        !          2412:                                case 'w' :
        !          2413:                                case 'W' :
        !          2414:                                        CTFSay_Team_Weapon(who, buf);
        !          2415:                                        strcpy(p, buf);
        !          2416:                                        p += strlen(buf);
        !          2417:                                        break;
        !          2418: 
        !          2419:                                case 'n' :
        !          2420:                                case 'N' :
        !          2421:                                        CTFSay_Team_Sight(who, buf);
        !          2422:                                        strcpy(p, buf);
        !          2423:                                        p += strlen(buf);
        !          2424:                                        break;
        !          2425: 
        !          2426:                                default :
        !          2427:                                        *p++ = *msg;
        !          2428:                        }
        !          2429:                } else
        !          2430:                        *p++ = *msg;
        !          2431:        }
        !          2432:        *p = 0;
        !          2433: 
        !          2434:        for (i = 0; i < maxclients->value; i++) {
        !          2435:                cl_ent = g_edicts + 1 + i;
        !          2436:                if (!cl_ent->inuse)
        !          2437:                        continue;
        !          2438:                if (cl_ent->client->resp.ctf_team == who->client->resp.ctf_team)
        !          2439:                        gi.cprintf(cl_ent, PRINT_CHAT, "(%s): %s\n", 
        !          2440:                                who->client->pers.netname, outmsg);
        !          2441:        }
        !          2442: }
        !          2443: 
        !          2444: /*-----------------------------------------------------------------------*/
        !          2445: /*QUAKED misc_ctf_banner (1 .5 0) (-4 -64 0) (4 64 248) TEAM2
        !          2446: The origin is the bottom of the banner.
        !          2447: The banner is 248 tall.
        !          2448: */
        !          2449: static void misc_ctf_banner_think (edict_t *ent)
        !          2450: {
        !          2451:        ent->s.frame = (ent->s.frame + 1) % 16;
        !          2452:        ent->nextthink = level.time + FRAMETIME;
        !          2453: }
        !          2454: 
        !          2455: void SP_misc_ctf_banner (edict_t *ent)
        !          2456: {
        !          2457:        ent->movetype = MOVETYPE_NONE;
        !          2458:        ent->solid = SOLID_NOT;
        !          2459:        ent->s.modelindex = gi.modelindex ("models/ctf/banner/tris.md2");
        !          2460:        if (ent->spawnflags & 1) // team2
        !          2461:                ent->s.skinnum = 1;
        !          2462: 
        !          2463:        ent->s.frame = rand() % 16;
        !          2464:        gi.linkentity (ent);
        !          2465: 
        !          2466:        ent->think = misc_ctf_banner_think;
        !          2467:        ent->nextthink = level.time + FRAMETIME;
        !          2468: }
        !          2469: 
        !          2470: /*QUAKED misc_ctf_small_banner (1 .5 0) (-4 -32 0) (4 32 124) TEAM2
        !          2471: The origin is the bottom of the banner.
        !          2472: The banner is 124 tall.
        !          2473: */
        !          2474: void SP_misc_ctf_small_banner (edict_t *ent)
        !          2475: {
        !          2476:        ent->movetype = MOVETYPE_NONE;
        !          2477:        ent->solid = SOLID_NOT;
        !          2478:        ent->s.modelindex = gi.modelindex ("models/ctf/banner/small.md2");
        !          2479:        if (ent->spawnflags & 1) // team2
        !          2480:                ent->s.skinnum = 1;
        !          2481: 
        !          2482:        ent->s.frame = rand() % 16;
        !          2483:        gi.linkentity (ent);
        !          2484: 
        !          2485:        ent->think = misc_ctf_banner_think;
        !          2486:        ent->nextthink = level.time + FRAMETIME;
        !          2487: }
        !          2488: 
        !          2489: /*-----------------------------------------------------------------------*/
        !          2490: 
        !          2491: static void SetLevelName(pmenu_t *p)
        !          2492: {
        !          2493:        static char levelname[33];
        !          2494: 
        !          2495:        levelname[0] = '*';
        !          2496:        if (g_edicts[0].message)
        !          2497:                strncpy(levelname+1, g_edicts[0].message, sizeof(levelname) - 2);
        !          2498:        else
        !          2499:                strncpy(levelname+1, level.mapname, sizeof(levelname) - 2);
        !          2500:        levelname[sizeof(levelname) - 1] = 0;
        !          2501:        p->text = levelname;
        !          2502: }
        !          2503: 
        !          2504: 
        !          2505: /*-----------------------------------------------------------------------*/
        !          2506: 
        !          2507: 
        !          2508: /* ELECTIONS */
        !          2509: 
        !          2510: qboolean CTFBeginElection(edict_t *ent, elect_t type, char *msg)
        !          2511: {
        !          2512:        int i;
        !          2513:        int count;
        !          2514:        edict_t *e;
        !          2515: 
        !          2516:        if (electpercentage->value == 0) {
        !          2517:                gi.cprintf(ent, PRINT_HIGH, "Elections are disabled, only an admin can process this action.\n");
        !          2518:                return false;
        !          2519:        }
        !          2520: 
        !          2521: 
        !          2522:        if (ctfgame.election != ELECT_NONE) {
        !          2523:                gi.cprintf(ent, PRINT_HIGH, "Election already in progress.\n");
        !          2524:                return false;
        !          2525:        }
        !          2526: 
        !          2527:        // clear votes
        !          2528:        count = 0;
        !          2529:        for (i = 1; i <= maxclients->value; i++) {
        !          2530:                e = g_edicts + i;
        !          2531:                e->client->resp.voted = false;
        !          2532:                if (e->inuse)
        !          2533:                        count++;
        !          2534:        }
        !          2535: 
        !          2536:        if (count < 2) {
        !          2537:                gi.cprintf(ent, PRINT_HIGH, "Not enough players for election.\n");
        !          2538:                return false;
        !          2539:        }
        !          2540: 
        !          2541:        ctfgame.etarget = ent;
        !          2542:        ctfgame.election = type;
        !          2543:        ctfgame.evotes = 0;
        !          2544:        ctfgame.needvotes = (count * electpercentage->value) / 100;
        !          2545:        ctfgame.electtime = level.time + 20; // twenty seconds for election
        !          2546:        strncpy(ctfgame.emsg, msg, sizeof(ctfgame.emsg) - 1);
        !          2547: 
        !          2548:        // tell everyone
        !          2549:        gi.bprintf(PRINT_CHAT, "%s\n", ctfgame.emsg);
        !          2550:        gi.bprintf(PRINT_HIGH, "Type YES or NO to vote on this request.\n");
        !          2551:        gi.bprintf(PRINT_HIGH, "Votes: %d  Needed: %d  Time left: %ds\n", ctfgame.evotes, ctfgame.needvotes,
        !          2552:                (int)(ctfgame.electtime - level.time));
        !          2553: 
        !          2554:        return true;
        !          2555: }
        !          2556: 
        !          2557: void DoRespawn (edict_t *ent);
        !          2558: 
        !          2559: void CTFResetAllPlayers(void)
        !          2560: {
        !          2561:        int i;
        !          2562:        edict_t *ent;
        !          2563: 
        !          2564:        for (i = 1; i <= maxclients->value; i++) {
        !          2565:                ent = g_edicts + i;
        !          2566:                if (!ent->inuse)
        !          2567:                        continue;
        !          2568: 
        !          2569:                if (ent->client->menu)
        !          2570:                        PMenu_Close(ent);
        !          2571: 
        !          2572:                CTFPlayerResetGrapple(ent);
        !          2573:                CTFDeadDropFlag(ent);
        !          2574:                CTFDeadDropTech(ent);
        !          2575: 
        !          2576:                ent->client->resp.ctf_team = CTF_NOTEAM;
        !          2577:                ent->client->resp.ready = false;
        !          2578: 
        !          2579:                ent->svflags = 0;
        !          2580:                ent->flags &= ~FL_GODMODE;
        !          2581:                PutClientInServer(ent);
        !          2582:        }
        !          2583: 
        !          2584:        // reset the level
        !          2585:        CTFResetTech();
        !          2586:        CTFResetFlags();
        !          2587: 
        !          2588:        for (ent = g_edicts + 1, i = 1; i < globals.num_edicts; i++, ent++) {
        !          2589:                if (ent->inuse && !ent->client) {
        !          2590:                        if (ent->solid == SOLID_NOT && ent->think == DoRespawn &&
        !          2591:                                ent->nextthink >= level.time) {
        !          2592:                                ent->nextthink = 0;
        !          2593:                                DoRespawn(ent);
        !          2594:                        }
        !          2595:                }
        !          2596:        }
        !          2597:        if (ctfgame.match == MATCH_SETUP)
        !          2598:                ctfgame.matchtime = level.time + matchsetuptime->value * 60;
        !          2599: }
        !          2600: 
        !          2601: void CTFAssignGhost(edict_t *ent)
        !          2602: {
        !          2603:        int ghost, i;
        !          2604: 
        !          2605:        for (ghost = 0; ghost < MAX_CLIENTS; ghost++)
        !          2606:                if (!ctfgame.ghosts[ghost].code)
        !          2607:                        break;
        !          2608:        if (ghost == MAX_CLIENTS)
        !          2609:                return;
        !          2610:        ctfgame.ghosts[ghost].team = ent->client->resp.ctf_team;
        !          2611:        ctfgame.ghosts[ghost].score = 0;
        !          2612:        for (;;) {
        !          2613:                ctfgame.ghosts[ghost].code = 10000 + (rand() % 90000);
        !          2614:                for (i = 0; i < MAX_CLIENTS; i++)
        !          2615:                        if (i != ghost && ctfgame.ghosts[i].code == ctfgame.ghosts[ghost].code)
        !          2616:                                break;
        !          2617:                if (i == MAX_CLIENTS)
        !          2618:                        break;
        !          2619:        }
        !          2620:        ctfgame.ghosts[ghost].ent = ent;
        !          2621:        strcpy(ctfgame.ghosts[ghost].netname, ent->client->pers.netname);
        !          2622:        ent->client->resp.ghost = ctfgame.ghosts + ghost;
        !          2623:        gi.cprintf(ent, PRINT_CHAT, "Your ghost code is **** %d ****\n", ctfgame.ghosts[ghost].code);
        !          2624:        gi.cprintf(ent, PRINT_HIGH, "If you lose connection, you can rejoin with your score "
        !          2625:                "intact by typing \"ghost %d\".\n", ctfgame.ghosts[ghost].code);
        !          2626: }
        !          2627: 
        !          2628: // start a match
        !          2629: void CTFStartMatch(void)
        !          2630: {
        !          2631:        int i;
        !          2632:        edict_t *ent;
        !          2633:        int ghost = 0;
        !          2634: 
        !          2635:        ctfgame.match = MATCH_GAME;
        !          2636:        ctfgame.matchtime = level.time + matchtime->value * 60;
        !          2637: 
        !          2638:        ctfgame.team1 = ctfgame.team2 = 0;
        !          2639: 
        !          2640:        memset(ctfgame.ghosts, 0, sizeof(ctfgame.ghosts));
        !          2641: 
        !          2642:        for (i = 1; i <= maxclients->value; i++) {
        !          2643:                ent = g_edicts + i;
        !          2644:                if (!ent->inuse)
        !          2645:                        continue;
        !          2646: 
        !          2647:                ent->client->resp.score = 0;
        !          2648:                ent->client->resp.ctf_state = 0;
        !          2649:                ent->client->resp.ghost = NULL;
        !          2650: 
        !          2651:                gi.centerprintf(ent, "******************\n\nMATCH HAS STARTED!\n\n******************");
        !          2652: 
        !          2653:                if (ent->client->resp.ctf_team != CTF_NOTEAM) {
        !          2654:                        // make up a ghost code
        !          2655:                        CTFAssignGhost(ent);
        !          2656:                        CTFPlayerResetGrapple(ent);
        !          2657:                        ent->svflags = SVF_NOCLIENT;
        !          2658:                        ent->flags &= ~FL_GODMODE;
        !          2659: 
        !          2660:                        ent->client->respawn_time = level.time + 1.0 + ((rand()%30)/10.0);
        !          2661:                        ent->client->ps.pmove.pm_type = PM_DEAD;
        !          2662:                        ent->client->anim_priority = ANIM_DEATH;
        !          2663:                        ent->s.frame = FRAME_death308-1;
        !          2664:                        ent->client->anim_end = FRAME_death308;
        !          2665:                        ent->deadflag = DEAD_DEAD;
        !          2666:                        ent->movetype = MOVETYPE_NOCLIP;
        !          2667:                        ent->client->ps.gunindex = 0;
        !          2668:                        gi.linkentity (ent);
        !          2669:                }
        !          2670:        }
        !          2671: }
        !          2672: 
        !          2673: void CTFEndMatch(void)
        !          2674: {
        !          2675:        ctfgame.match = MATCH_POST;
        !          2676:        gi.bprintf(PRINT_CHAT, "MATCH COMPLETED!\n");
        !          2677: 
        !          2678:        CTFCalcScores();
        !          2679: 
        !          2680:        gi.bprintf(PRINT_HIGH, "RED TEAM:  %d captures, %d points\n",
        !          2681:                ctfgame.team1, ctfgame.total1);
        !          2682:        gi.bprintf(PRINT_HIGH, "BLUE TEAM:  %d captures, %d points\n",
        !          2683:                ctfgame.team2, ctfgame.total2);
        !          2684: 
        !          2685:        if (ctfgame.team1 > ctfgame.team2)
        !          2686:                gi.bprintf(PRINT_CHAT, "RED team won over the BLUE team by %d CAPTURES!\n",
        !          2687:                        ctfgame.team1 - ctfgame.team2);
        !          2688:        else if (ctfgame.team2 > ctfgame.team1)
        !          2689:                gi.bprintf(PRINT_CHAT, "BLUE team won over the RED team by %d CAPTURES!\n",
        !          2690:                        ctfgame.team2 - ctfgame.team1);
        !          2691:        else if (ctfgame.total1 > ctfgame.total2) // frag tie breaker
        !          2692:                gi.bprintf(PRINT_CHAT, "RED team won over the BLUE team by %d POINTS!\n",
        !          2693:                        ctfgame.total1 - ctfgame.total2);
        !          2694:        else if (ctfgame.total2 > ctfgame.total1) 
        !          2695:                gi.bprintf(PRINT_CHAT, "BLUE team won over the RED team by %d POINTS!\n",
        !          2696:                        ctfgame.total2 - ctfgame.total1);
        !          2697:        else
        !          2698:                gi.bprintf(PRINT_CHAT, "TIE GAME!\n");
        !          2699: 
        !          2700:        EndDMLevel();
        !          2701: }
        !          2702: 
        !          2703: qboolean CTFNextMap(void)
        !          2704: {
        !          2705:        if (ctfgame.match == MATCH_POST) {
        !          2706:                ctfgame.match = MATCH_SETUP;
        !          2707:                CTFResetAllPlayers();
        !          2708:                return true;
        !          2709:        }
        !          2710:        return false;
        !          2711: }
        !          2712: 
        !          2713: void CTFWinElection(void)
        !          2714: {
        !          2715:        switch (ctfgame.election) {
        !          2716:        case ELECT_MATCH :
        !          2717:                // reset into match mode
        !          2718:                if (competition->value < 3)
        !          2719:                        gi.cvar_set("competition", "2");
        !          2720:                ctfgame.match = MATCH_SETUP;
        !          2721:                CTFResetAllPlayers();
        !          2722:                break;
        !          2723: 
        !          2724:        case ELECT_ADMIN :
        !          2725:                ctfgame.etarget->client->resp.admin = true;
        !          2726:                gi.bprintf(PRINT_HIGH, "%s has become an admin.\n", ctfgame.etarget->client->pers.netname);
        !          2727:                gi.cprintf(ctfgame.etarget, PRINT_HIGH, "Type 'admin' to access the adminstration menu.\n");
        !          2728:                break;
        !          2729: 
        !          2730:        case ELECT_MAP :
        !          2731:                gi.bprintf(PRINT_HIGH, "%s is warping to level %s.\n", 
        !          2732:                        ctfgame.etarget->client->pers.netname, ctfgame.elevel);
        !          2733:                strncpy(level.forcemap, ctfgame.elevel, sizeof(level.forcemap) - 1);
        !          2734:                EndDMLevel();
        !          2735:                break;
        !          2736:        }
        !          2737:        ctfgame.election = ELECT_NONE;
        !          2738: }
        !          2739: 
        !          2740: void CTFVoteYes(edict_t *ent)
        !          2741: {
        !          2742:        if (ctfgame.election == ELECT_NONE) {
        !          2743:                gi.cprintf(ent, PRINT_HIGH, "No election is in progress.\n");
        !          2744:                return;
        !          2745:        }
        !          2746:        if (ent->client->resp.voted) {
        !          2747:                gi.cprintf(ent, PRINT_HIGH, "You already voted.\n");
        !          2748:                return;
        !          2749:        }
        !          2750:        if (ctfgame.etarget == ent) {
        !          2751:                gi.cprintf(ent, PRINT_HIGH, "You can't vote for yourself.\n");
        !          2752:                return;
        !          2753:        }
        !          2754: 
        !          2755:        ent->client->resp.voted = true;
        !          2756: 
        !          2757:        ctfgame.evotes++;
        !          2758:        if (ctfgame.evotes == ctfgame.needvotes) {
        !          2759:                // the election has been won
        !          2760:                CTFWinElection();
        !          2761:                return;
        !          2762:        }
        !          2763:        gi.bprintf(PRINT_HIGH, "%s\n", ctfgame.emsg);
        !          2764:        gi.bprintf(PRINT_CHAT, "Votes: %d  Needed: %d  Time left: %ds\n", ctfgame.evotes, ctfgame.needvotes,
        !          2765:                (int)(ctfgame.electtime - level.time));
        !          2766: }
        !          2767: 
        !          2768: void CTFVoteNo(edict_t *ent)
        !          2769: {
        !          2770:        if (ctfgame.election == ELECT_NONE) {
        !          2771:                gi.cprintf(ent, PRINT_HIGH, "No election is in progress.\n");
        !          2772:                return;
        !          2773:        }
        !          2774:        if (ent->client->resp.voted) {
        !          2775:                gi.cprintf(ent, PRINT_HIGH, "You already voted.\n");
        !          2776:                return;
        !          2777:        }
        !          2778:        if (ctfgame.etarget == ent) {
        !          2779:                gi.cprintf(ent, PRINT_HIGH, "You can't vote for yourself.\n");
        !          2780:                return;
        !          2781:        }
        !          2782: 
        !          2783:        ent->client->resp.voted = true;
        !          2784: 
        !          2785:        gi.bprintf(PRINT_HIGH, "%s\n", ctfgame.emsg);
        !          2786:        gi.bprintf(PRINT_CHAT, "Votes: %d  Needed: %d  Time left: %ds\n", ctfgame.evotes, ctfgame.needvotes,
        !          2787:                (int)(ctfgame.electtime - level.time));
        !          2788: }
        !          2789: 
        !          2790: void CTFReady(edict_t *ent)
        !          2791: {
        !          2792:        int i, j;
        !          2793:        edict_t *e;
        !          2794:        int t1, t2;
        !          2795: 
        !          2796:        if (ent->client->resp.ctf_team == CTF_NOTEAM) {
        !          2797:                gi.cprintf(ent, PRINT_HIGH, "Pick a team first (hit <TAB> for menu)\n");
        !          2798:                return;
        !          2799:        }
        !          2800: 
        !          2801:        if (ctfgame.match != MATCH_SETUP) {
        !          2802:                gi.cprintf(ent, PRINT_HIGH, "A match is not being setup.\n");
        !          2803:                return;
        !          2804:        }
        !          2805: 
        !          2806:        if (ent->client->resp.ready) {
        !          2807:                gi.cprintf(ent, PRINT_HIGH, "You have already commited.\n");
        !          2808:                return;
        !          2809:        }
        !          2810: 
        !          2811:        ent->client->resp.ready = true;
        !          2812:        gi.bprintf(PRINT_HIGH, "%s is ready.\n", ent->client->pers.netname);
        !          2813: 
        !          2814:        t1 = t2 = 0;
        !          2815:        for (j = 0, i = 1; i <= maxclients->value; i++) {
        !          2816:                e = g_edicts + i;
        !          2817:                if (!e->inuse)
        !          2818:                        continue;
        !          2819:                if (e->client->resp.ctf_team != CTF_NOTEAM && !e->client->resp.ready)
        !          2820:                        j++;
        !          2821:                if (e->client->resp.ctf_team == CTF_TEAM1)
        !          2822:                        t1++;
        !          2823:                else if (e->client->resp.ctf_team == CTF_TEAM2)
        !          2824:                        t2++;
        !          2825:        }
        !          2826:        if (!j && t1 && t2) {
        !          2827:                // everyone has commited
        !          2828:                gi.bprintf(PRINT_CHAT, "All players have commited.  Match starting\n");
        !          2829:                ctfgame.match = MATCH_PREGAME;
        !          2830:                ctfgame.matchtime = level.time + matchstarttime->value;
        !          2831:        }
        !          2832: }
        !          2833: 
        !          2834: void CTFNotReady(edict_t *ent)
        !          2835: {
        !          2836:        if (ent->client->resp.ctf_team == CTF_NOTEAM) {
        !          2837:                gi.cprintf(ent, PRINT_HIGH, "Pick a team first (hit <TAB> for menu)\n");
        !          2838:                return;
        !          2839:        }
        !          2840: 
        !          2841:        if (ctfgame.match != MATCH_SETUP && ctfgame.match != MATCH_PREGAME) {
        !          2842:                gi.cprintf(ent, PRINT_HIGH, "A match is not being setup.\n");
        !          2843:                return;
        !          2844:        }
        !          2845: 
        !          2846:        if (!ent->client->resp.ready) {
        !          2847:                gi.cprintf(ent, PRINT_HIGH, "You haven't commited.\n");
        !          2848:                return;
        !          2849:        }
        !          2850: 
        !          2851:        ent->client->resp.ready = false;
        !          2852:        gi.bprintf(PRINT_HIGH, "%s is no longer ready.\n", ent->client->pers.netname);
        !          2853: 
        !          2854:        if (ctfgame.match == MATCH_PREGAME) {
        !          2855:                gi.bprintf(PRINT_CHAT, "Match halted.\n");
        !          2856:                ctfgame.match = MATCH_SETUP;
        !          2857:                ctfgame.matchtime = level.time + matchsetuptime->value * 60;
        !          2858:        }
        !          2859: }
        !          2860: 
        !          2861: void CTFGhost(edict_t *ent)
        !          2862: {
        !          2863:        int i;
        !          2864:        int n;
        !          2865: 
        !          2866:        if (gi.argc() < 2) {
        !          2867:                gi.cprintf(ent, PRINT_HIGH, "Usage:  ghost <code>\n");
        !          2868:                return;
        !          2869:        }
        !          2870: 
        !          2871:        if (ent->client->resp.ctf_team != CTF_NOTEAM) {
        !          2872:                gi.cprintf(ent, PRINT_HIGH, "You are already in the game.\n");
        !          2873:                return;
        !          2874:        }
        !          2875:        if (ctfgame.match != MATCH_GAME) {
        !          2876:                gi.cprintf(ent, PRINT_HIGH, "No match is in progress.\n");
        !          2877:                return;
        !          2878:        }
        !          2879: 
        !          2880:        n = atoi(gi.argv(1));
        !          2881: 
        !          2882:        for (i = 0; i < MAX_CLIENTS; i++) {
        !          2883:                if (ctfgame.ghosts[i].code && ctfgame.ghosts[i].code == n) {
        !          2884:                        gi.cprintf(ent, PRINT_HIGH, "Ghost code accepted, your position has been reinstated.\n");
        !          2885:                        ctfgame.ghosts[i].ent->client->resp.ghost = NULL;
        !          2886:                        ent->client->resp.ctf_team = ctfgame.ghosts[i].team;
        !          2887:                        ent->client->resp.ghost = ctfgame.ghosts + i;
        !          2888:                        ent->client->resp.score = ctfgame.ghosts[i].score;
        !          2889:                        ent->client->resp.ctf_state = 0;
        !          2890:                        ctfgame.ghosts[i].ent = ent;
        !          2891:                        ent->svflags = 0;
        !          2892:                        ent->flags &= ~FL_GODMODE;
        !          2893:                        PutClientInServer(ent);
        !          2894:                        gi.bprintf(PRINT_HIGH, "%s has been reinstated to %s team.\n",
        !          2895:                                ent->client->pers.netname, CTFTeamName(ent->client->resp.ctf_team));
        !          2896:                        return;
        !          2897:                }
        !          2898:        }
        !          2899:        gi.cprintf(ent, PRINT_HIGH, "Invalid ghost code.\n");
        !          2900: }
        !          2901: 
        !          2902: qboolean CTFMatchSetup(void)
        !          2903: {
        !          2904:        if (ctfgame.match == MATCH_SETUP || ctfgame.match == MATCH_PREGAME)
        !          2905:                return true;
        !          2906:        return false;
        !          2907: }
        !          2908: 
        !          2909: qboolean CTFMatchOn(void)
        !          2910: {
        !          2911:        if (ctfgame.match == MATCH_GAME)
        !          2912:                return true;
        !          2913:        return false;
        !          2914: }
        !          2915: 
        !          2916: 
        !          2917: /*-----------------------------------------------------------------------*/
        !          2918: 
        !          2919: void CTFJoinTeam1(edict_t *ent, pmenuhnd_t *p);
        !          2920: void CTFJoinTeam2(edict_t *ent, pmenuhnd_t *p);
        !          2921: void CTFCredits(edict_t *ent, pmenuhnd_t *p);
        !          2922: void CTFReturnToMain(edict_t *ent, pmenuhnd_t *p);
        !          2923: void CTFChaseCam(edict_t *ent, pmenuhnd_t *p);
        !          2924: 
        !          2925: pmenu_t creditsmenu[] = {
        !          2926:        { "*Quake II",                                          PMENU_ALIGN_CENTER, NULL },
        !          2927:        { "*ThreeWave Capture the Flag",        PMENU_ALIGN_CENTER, NULL },
        !          2928:        { NULL,                                                         PMENU_ALIGN_CENTER, NULL },
        !          2929:        { "*Programming",                                       PMENU_ALIGN_CENTER, NULL }, 
        !          2930:        { "Dave 'Zoid' Kirsch",                         PMENU_ALIGN_CENTER, NULL },
        !          2931:        { "*Level Design",                                      PMENU_ALIGN_CENTER, NULL },
        !          2932:        { "Christian Antkow",                           PMENU_ALIGN_CENTER, NULL },
        !          2933:        { "Tim Willits",                                        PMENU_ALIGN_CENTER, NULL },
        !          2934:        { "Dave 'Zoid' Kirsch",                         PMENU_ALIGN_CENTER, NULL },
        !          2935:        { "*Art",                                                       PMENU_ALIGN_CENTER, NULL },
        !          2936:        { "Adrian Carmack Paul Steed",          PMENU_ALIGN_CENTER, NULL },
        !          2937:        { "Kevin Cloud",                                        PMENU_ALIGN_CENTER, NULL },
        !          2938:        { "*Sound",                                                     PMENU_ALIGN_CENTER, NULL },
        !          2939:        { "Tom 'Bjorn' Klok",                           PMENU_ALIGN_CENTER, NULL },
        !          2940:        { "*Original CTF Art Design",           PMENU_ALIGN_CENTER, NULL },
        !          2941:        { "Brian 'Whaleboy' Cozzens",           PMENU_ALIGN_CENTER, NULL },
        !          2942:        { NULL,                                                         PMENU_ALIGN_CENTER, NULL },
        !          2943:        { "Return to Main Menu",                        PMENU_ALIGN_LEFT, CTFReturnToMain }
        !          2944: };
        !          2945: 
        !          2946: static const int jmenu_level = 2;
        !          2947: static const int jmenu_match = 3;
        !          2948: static const int jmenu_red = 5;
        !          2949: static const int jmenu_blue = 7;
        !          2950: static const int jmenu_chase = 9;
        !          2951: static const int jmenu_reqmatch = 11;
        !          2952: 
        !          2953: pmenu_t joinmenu[] = {
        !          2954:        { "*Quake II",                  PMENU_ALIGN_CENTER, NULL },
        !          2955:        { "*ThreeWave Capture the Flag",        PMENU_ALIGN_CENTER, NULL },
        !          2956:        { NULL,                                 PMENU_ALIGN_CENTER, NULL },
        !          2957:        { NULL,                                 PMENU_ALIGN_CENTER, NULL },
        !          2958:        { NULL,                                 PMENU_ALIGN_CENTER, NULL },
        !          2959:        { "Join Red Team",              PMENU_ALIGN_LEFT, CTFJoinTeam1 },
        !          2960:        { NULL,                                 PMENU_ALIGN_LEFT, NULL },
        !          2961:        { "Join Blue Team",             PMENU_ALIGN_LEFT, CTFJoinTeam2 },
        !          2962:        { NULL,                                 PMENU_ALIGN_LEFT, NULL },
        !          2963:        { "Chase Camera",               PMENU_ALIGN_LEFT, CTFChaseCam },
        !          2964:        { "Credits",                    PMENU_ALIGN_LEFT, CTFCredits },
        !          2965:        { NULL,                                 PMENU_ALIGN_LEFT, NULL },
        !          2966:        { NULL,                                 PMENU_ALIGN_LEFT, NULL },
        !          2967:        { "Use [ and ] to move cursor", PMENU_ALIGN_LEFT, NULL },
        !          2968:        { "ENTER to select",    PMENU_ALIGN_LEFT, NULL },
        !          2969:        { "ESC to Exit Menu",   PMENU_ALIGN_LEFT, NULL },
        !          2970:        { "(TAB to Return)",    PMENU_ALIGN_LEFT, NULL },
        !          2971:        { "v" CTF_STRING_VERSION,       PMENU_ALIGN_RIGHT, NULL },
        !          2972: };
        !          2973: 
        !          2974: pmenu_t nochasemenu[] = {
        !          2975:        { "*Quake II",                  PMENU_ALIGN_CENTER, NULL },
        !          2976:        { "*ThreeWave Capture the Flag",        PMENU_ALIGN_CENTER, NULL },
        !          2977:        { NULL,                                 PMENU_ALIGN_CENTER, NULL },
        !          2978:        { NULL,                                 PMENU_ALIGN_CENTER, NULL },
        !          2979:        { "No one to chase",    PMENU_ALIGN_LEFT, NULL },
        !          2980:        { NULL,                                 PMENU_ALIGN_CENTER, NULL },
        !          2981:        { "Return to Main Menu", PMENU_ALIGN_LEFT, CTFReturnToMain }
        !          2982: };
        !          2983: 
        !          2984: void CTFJoinTeam(edict_t *ent, int desired_team)
        !          2985: {
        !          2986:        char *s;
        !          2987: 
        !          2988:        PMenu_Close(ent);
        !          2989: 
        !          2990:        ent->svflags &= ~SVF_NOCLIENT;
        !          2991:        ent->client->resp.ctf_team = desired_team;
        !          2992:        ent->client->resp.ctf_state = 0;
        !          2993:        s = Info_ValueForKey (ent->client->pers.userinfo, "skin");
        !          2994:        CTFAssignSkin(ent, s);
        !          2995: 
        !          2996:        // assign a ghost if we are in match mode
        !          2997:        if (ctfgame.match == MATCH_GAME) {
        !          2998:                if (ent->client->resp.ghost)
        !          2999:                        ent->client->resp.ghost->code = 0;
        !          3000:                ent->client->resp.ghost = NULL;
        !          3001:                CTFAssignGhost(ent);
        !          3002:        }
        !          3003: 
        !          3004:        PutClientInServer (ent);
        !          3005:        // add a teleportation effect
        !          3006:        ent->s.event = EV_PLAYER_TELEPORT;
        !          3007:        // hold in place briefly
        !          3008:        ent->client->ps.pmove.pm_flags = PMF_TIME_TELEPORT;
        !          3009:        ent->client->ps.pmove.pm_time = 14;
        !          3010:        gi.bprintf(PRINT_HIGH, "%s joined the %s team.\n",
        !          3011:                ent->client->pers.netname, CTFTeamName(desired_team));
        !          3012: 
        !          3013:        if (ctfgame.match == MATCH_SETUP) {
        !          3014:                gi.centerprintf(ent,    "***********************\n"
        !          3015:                                                                "Type \"ready\" in console\n"
        !          3016:                                                                "to ready up.\n"
        !          3017:                                                                "***********************");
        !          3018:        }
        !          3019: }
        !          3020: 
        !          3021: void CTFJoinTeam1(edict_t *ent, pmenuhnd_t *p)
        !          3022: {
        !          3023:        CTFJoinTeam(ent, CTF_TEAM1);
        !          3024: }
        !          3025: 
        !          3026: void CTFJoinTeam2(edict_t *ent, pmenuhnd_t *p)
        !          3027: {
        !          3028:        CTFJoinTeam(ent, CTF_TEAM2);
        !          3029: }
        !          3030: 
        !          3031: void CTFChaseCam(edict_t *ent, pmenuhnd_t *p)
        !          3032: {
        !          3033:        int i;
        !          3034:        edict_t *e;
        !          3035: 
        !          3036:        if (ent->client->chase_target) {
        !          3037:                ent->client->chase_target = NULL;
        !          3038:                PMenu_Close(ent);
        !          3039:                return;
        !          3040:        }
        !          3041: 
        !          3042:        for (i = 1; i <= maxclients->value; i++) {
        !          3043:                e = g_edicts + i;
        !          3044:                if (e->inuse && e->solid != SOLID_NOT) {
        !          3045:                        ent->client->chase_target = e;
        !          3046:                        PMenu_Close(ent);
        !          3047:                        ent->client->update_chase = true;
        !          3048:                        return;
        !          3049:                }
        !          3050:        }
        !          3051: 
        !          3052:        SetLevelName(nochasemenu + jmenu_level);
        !          3053: 
        !          3054:        PMenu_Close(ent);
        !          3055:        PMenu_Open(ent, nochasemenu, -1, sizeof(nochasemenu) / sizeof(pmenu_t), NULL);
        !          3056: }
        !          3057: 
        !          3058: void CTFReturnToMain(edict_t *ent, pmenuhnd_t *p)
        !          3059: {
        !          3060:        PMenu_Close(ent);
        !          3061:        CTFOpenJoinMenu(ent);
        !          3062: }
        !          3063: 
        !          3064: void CTFRequestMatch(edict_t *ent, pmenuhnd_t *p)
        !          3065: {
        !          3066:        char text[1024];
        !          3067: 
        !          3068:        PMenu_Close(ent);
        !          3069: 
        !          3070:        sprintf(text, "%s has requested to switch to competition mode.",
        !          3071:                ent->client->pers.netname);
        !          3072:        CTFBeginElection(ent, ELECT_MATCH, text);
        !          3073: }
        !          3074: 
        !          3075: void DeathmatchScoreboard (edict_t *ent);
        !          3076: 
        !          3077: void CTFShowScores(edict_t *ent, pmenu_t *p)
        !          3078: {
        !          3079:        PMenu_Close(ent);
        !          3080: 
        !          3081:        ent->client->showscores = true;
        !          3082:        ent->client->showinventory = false;
        !          3083:        DeathmatchScoreboard (ent);
        !          3084: }
        !          3085: 
        !          3086: int CTFUpdateJoinMenu(edict_t *ent)
        !          3087: {
        !          3088:        static char team1players[32];
        !          3089:        static char team2players[32];
        !          3090:        int num1, num2, i;
        !          3091: 
        !          3092:        if (ctfgame.match >= MATCH_PREGAME && matchlock->value) {
        !          3093:                joinmenu[jmenu_red].text = "MATCH IS LOCKED";
        !          3094:                joinmenu[jmenu_red].SelectFunc = NULL;
        !          3095:                joinmenu[jmenu_blue].text = "  (entry is not permitted)";
        !          3096:                joinmenu[jmenu_blue].SelectFunc = NULL;
        !          3097:        } else {
        !          3098:                if (ctfgame.match >= MATCH_PREGAME) {
        !          3099:                        joinmenu[jmenu_red].text = "Join Red MATCH Team";
        !          3100:                        joinmenu[jmenu_blue].text = "Join Blue MATCH Team";
        !          3101:                } else {
        !          3102:                        joinmenu[jmenu_red].text = "Join Red Team";
        !          3103:                        joinmenu[jmenu_blue].text = "Join Blue Team";
        !          3104:                }
        !          3105:                joinmenu[jmenu_red].SelectFunc = CTFJoinTeam1;
        !          3106:                joinmenu[jmenu_blue].SelectFunc = CTFJoinTeam2;
        !          3107:        }
        !          3108: 
        !          3109:        if (ctf_forcejoin->string && *ctf_forcejoin->string) {
        !          3110:                if (stricmp(ctf_forcejoin->string, "red") == 0) {
        !          3111:                        joinmenu[jmenu_blue].text = NULL;
        !          3112:                        joinmenu[jmenu_blue].SelectFunc = NULL;
        !          3113:                } else if (stricmp(ctf_forcejoin->string, "blue") == 0) {
        !          3114:                        joinmenu[jmenu_red].text = NULL;
        !          3115:                        joinmenu[jmenu_red].SelectFunc = NULL;
        !          3116:                }
        !          3117:        }
        !          3118: 
        !          3119:        if (ent->client->chase_target)
        !          3120:                joinmenu[jmenu_chase].text = "Leave Chase Camera";
        !          3121:        else
        !          3122:                joinmenu[jmenu_chase].text = "Chase Camera";
        !          3123: 
        !          3124:        SetLevelName(joinmenu + jmenu_level);
        !          3125: 
        !          3126:        num1 = num2 = 0;
        !          3127:        for (i = 0; i < maxclients->value; i++) {
        !          3128:                if (!g_edicts[i+1].inuse)
        !          3129:                        continue;
        !          3130:                if (game.clients[i].resp.ctf_team == CTF_TEAM1)
        !          3131:                        num1++;
        !          3132:                else if (game.clients[i].resp.ctf_team == CTF_TEAM2)
        !          3133:                        num2++;
        !          3134:        }
        !          3135: 
        !          3136:        sprintf(team1players, "  (%d players)", num1);
        !          3137:        sprintf(team2players, "  (%d players)", num2);
        !          3138: 
        !          3139:        switch (ctfgame.match) {
        !          3140:        case MATCH_NONE :
        !          3141:                joinmenu[jmenu_match].text = NULL;
        !          3142:                break;
        !          3143: 
        !          3144:        case MATCH_SETUP :
        !          3145:                joinmenu[jmenu_match].text = "*MATCH SETUP IN PROGRESS";
        !          3146:                break;
        !          3147: 
        !          3148:        case MATCH_PREGAME :
        !          3149:                joinmenu[jmenu_match].text = "*MATCH STARTING";
        !          3150:                break;
        !          3151: 
        !          3152:        case MATCH_GAME :
        !          3153:                joinmenu[jmenu_match].text = "*MATCH IN PROGRESS";
        !          3154:                break;
        !          3155:        }
        !          3156: 
        !          3157:        if (joinmenu[jmenu_red].text)
        !          3158:                joinmenu[jmenu_red+1].text = team1players;
        !          3159:        else
        !          3160:                joinmenu[jmenu_red+1].text = NULL;
        !          3161:        if (joinmenu[jmenu_blue].text)
        !          3162:                joinmenu[jmenu_blue+1].text = team2players;
        !          3163:        else
        !          3164:                joinmenu[jmenu_blue+1].text = NULL;
        !          3165: 
        !          3166:        joinmenu[jmenu_reqmatch].text = NULL;
        !          3167:        joinmenu[jmenu_reqmatch].SelectFunc = NULL;
        !          3168:        if (competition->value && ctfgame.match < MATCH_SETUP) {
        !          3169:                joinmenu[jmenu_reqmatch].text = "Request Match";
        !          3170:                joinmenu[jmenu_reqmatch].SelectFunc = CTFRequestMatch;
        !          3171:        }
        !          3172:        
        !          3173:        if (num1 > num2)
        !          3174:                return CTF_TEAM1;
        !          3175:        else if (num2 > num1)
        !          3176:                return CTF_TEAM2;
        !          3177:        return (rand() & 1) ? CTF_TEAM1 : CTF_TEAM2;
        !          3178: }
        !          3179: 
        !          3180: void CTFOpenJoinMenu(edict_t *ent)
        !          3181: {
        !          3182:        int team;
        !          3183: 
        !          3184:        team = CTFUpdateJoinMenu(ent);
        !          3185:        if (ent->client->chase_target)
        !          3186:                team = 8;
        !          3187:        else if (team == CTF_TEAM1)
        !          3188:                team = 4;
        !          3189:        else
        !          3190:                team = 6;
        !          3191:        PMenu_Open(ent, joinmenu, team, sizeof(joinmenu) / sizeof(pmenu_t), NULL);
        !          3192: }
        !          3193: 
        !          3194: void CTFCredits(edict_t *ent, pmenuhnd_t *p)
        !          3195: {
        !          3196:        PMenu_Close(ent);
        !          3197:        PMenu_Open(ent, creditsmenu, -1, sizeof(creditsmenu) / sizeof(pmenu_t), NULL);
        !          3198: }
        !          3199: 
        !          3200: qboolean CTFStartClient(edict_t *ent)
        !          3201: {
        !          3202:        if (ent->client->resp.ctf_team != CTF_NOTEAM)
        !          3203:                return false;
        !          3204: 
        !          3205:        if (!((int)dmflags->value & DF_CTF_FORCEJOIN) || ctfgame.match >= MATCH_SETUP) {
        !          3206:                // start as 'observer'
        !          3207:                ent->movetype = MOVETYPE_NOCLIP;
        !          3208:                ent->solid = SOLID_NOT;
        !          3209:                ent->svflags |= SVF_NOCLIENT;
        !          3210:                ent->client->resp.ctf_team = CTF_NOTEAM;
        !          3211:                ent->client->ps.gunindex = 0;
        !          3212:                gi.linkentity (ent);
        !          3213: 
        !          3214:                CTFOpenJoinMenu(ent);
        !          3215:                return true;
        !          3216:        }
        !          3217:        return false;
        !          3218: }
        !          3219: 
        !          3220: void CTFObserver(edict_t *ent)
        !          3221: {
        !          3222:        // start as 'observer'
        !          3223:        if (ent->movetype == MOVETYPE_NOCLIP) {
        !          3224:                gi.cprintf(ent, PRINT_HIGH, "You are already an observer.\n");
        !          3225:                return;
        !          3226:        }
        !          3227: 
        !          3228:        CTFPlayerResetGrapple(ent);
        !          3229:        CTFDeadDropFlag(ent);
        !          3230:        CTFDeadDropTech(ent);
        !          3231: 
        !          3232:        ent->movetype = MOVETYPE_NOCLIP;
        !          3233:        ent->solid = SOLID_NOT;
        !          3234:        ent->svflags |= SVF_NOCLIENT;
        !          3235:        ent->client->resp.ctf_team = CTF_NOTEAM;
        !          3236:        ent->client->ps.gunindex = 0;
        !          3237:        ent->client->resp.score = 0;
        !          3238:        gi.linkentity (ent);
        !          3239:        CTFOpenJoinMenu(ent);
        !          3240: }
        !          3241: 
        !          3242: qboolean CTFInMatch(void)
        !          3243: {
        !          3244:        if (ctfgame.match > MATCH_NONE)
        !          3245:                return true;
        !          3246:        return false;
        !          3247: }
        !          3248: 
        !          3249: qboolean CTFCheckRules(void)
        !          3250: {
        !          3251:        int t;
        !          3252:        int i, j;
        !          3253:        char text[64];
        !          3254:        edict_t *ent;
        !          3255: 
        !          3256:        if (ctfgame.election != ELECT_NONE && ctfgame.electtime <= level.time) {
        !          3257:                gi.bprintf(PRINT_CHAT, "Election timed out and has been cancelled.\n");
        !          3258:                ctfgame.election = ELECT_NONE;
        !          3259:        }
        !          3260: 
        !          3261:        if (ctfgame.match != MATCH_NONE) {
        !          3262:                t = ctfgame.matchtime - level.time;
        !          3263: 
        !          3264:                if (t <= 0) { // time ended on something
        !          3265:                        switch (ctfgame.match) {
        !          3266:                        case MATCH_SETUP :
        !          3267:                                // go back to normal mode
        !          3268:                                if (competition->value < 3) {
        !          3269:                                        ctfgame.match = MATCH_NONE;
        !          3270:                                        gi.cvar_set("competition", "1");
        !          3271:                                        CTFResetAllPlayers();
        !          3272:                                } else {
        !          3273:                                        // reset the time
        !          3274:                                        ctfgame.matchtime = level.time + matchsetuptime->value * 60;
        !          3275:                                }
        !          3276:                                return false;
        !          3277: 
        !          3278:                        case MATCH_PREGAME :
        !          3279:                                // match started!
        !          3280:                                CTFStartMatch();
        !          3281:                                return false;
        !          3282: 
        !          3283:                        case MATCH_GAME :
        !          3284:                                // match ended!
        !          3285:                                CTFEndMatch();
        !          3286:                                return false;
        !          3287:                        }
        !          3288:                }
        !          3289: 
        !          3290:                if (t == ctfgame.lasttime)
        !          3291:                        return false;
        !          3292: 
        !          3293:                ctfgame.lasttime = t;
        !          3294: 
        !          3295:                switch (ctfgame.match) {
        !          3296:                case MATCH_SETUP :
        !          3297:                        for (j = 0, i = 1; i <= maxclients->value; i++) {
        !          3298:                                ent = g_edicts + i;
        !          3299:                                if (!ent->inuse)
        !          3300:                                        continue;
        !          3301:                                if (ent->client->resp.ctf_team != CTF_NOTEAM &&
        !          3302:                                        !ent->client->resp.ready)
        !          3303:                                        j++;
        !          3304:                        }
        !          3305: 
        !          3306:                        if (competition->value < 3)
        !          3307:                                sprintf(text, "%02d:%02d SETUP: %d not ready",
        !          3308:                                        t / 60, t % 60, j);
        !          3309:                        else
        !          3310:                                sprintf(text, "SETUP: %d not ready", j);
        !          3311: 
        !          3312:                        gi.configstring (CONFIG_CTF_MATCH, text);
        !          3313:                        break;
        !          3314: 
        !          3315: 
        !          3316:                case MATCH_PREGAME :
        !          3317:                        sprintf(text, "%02d:%02d UNTIL START",
        !          3318:                                t / 60, t % 60);
        !          3319:                        gi.configstring (CONFIG_CTF_MATCH, text);
        !          3320:                        break;
        !          3321: 
        !          3322:                case MATCH_GAME:
        !          3323:                        sprintf(text, "%02d:%02d MATCH",
        !          3324:                                t / 60, t % 60);
        !          3325:                        gi.configstring (CONFIG_CTF_MATCH, text);
        !          3326:                        break;
        !          3327:                }
        !          3328:                return false;
        !          3329:        }
        !          3330: 
        !          3331:        if (capturelimit->value && 
        !          3332:                (ctfgame.team1 >= capturelimit->value ||
        !          3333:                ctfgame.team2 >= capturelimit->value)) {
        !          3334:                gi.bprintf (PRINT_HIGH, "Capturelimit hit.\n");
        !          3335:                return true;
        !          3336:        }
        !          3337:        return false;
        !          3338: }
        !          3339: 
        !          3340: /*--------------------------------------------------------------------------
        !          3341:  * just here to help old map conversions
        !          3342:  *--------------------------------------------------------------------------*/
        !          3343: 
        !          3344: static void old_teleporter_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
        !          3345: {
        !          3346:        edict_t         *dest;
        !          3347:        int                     i;
        !          3348:        vec3_t          forward;
        !          3349: 
        !          3350:        if (!other->client)
        !          3351:                return;
        !          3352:        dest = G_Find (NULL, FOFS(targetname), self->target);
        !          3353:        if (!dest)
        !          3354:        {
        !          3355:                gi.dprintf ("Couldn't find destination\n");
        !          3356:                return;
        !          3357:        }
        !          3358: 
        !          3359: //ZOID
        !          3360:        CTFPlayerResetGrapple(other);
        !          3361: //ZOID
        !          3362: 
        !          3363:        // unlink to make sure it can't possibly interfere with KillBox
        !          3364:        gi.unlinkentity (other);
        !          3365: 
        !          3366:        VectorCopy (dest->s.origin, other->s.origin);
        !          3367:        VectorCopy (dest->s.origin, other->s.old_origin);
        !          3368: //     other->s.origin[2] += 10;
        !          3369: 
        !          3370:        // clear the velocity and hold them in place briefly
        !          3371:        VectorClear (other->velocity);
        !          3372:        other->client->ps.pmove.pm_time = 160>>3;               // hold time
        !          3373:        other->client->ps.pmove.pm_flags |= PMF_TIME_TELEPORT;
        !          3374: 
        !          3375:        // draw the teleport splash at source and on the player
        !          3376:        self->enemy->s.event = EV_PLAYER_TELEPORT;
        !          3377:        other->s.event = EV_PLAYER_TELEPORT;
        !          3378: 
        !          3379:        // set angles
        !          3380:        for (i=0 ; i<3 ; i++)
        !          3381:                other->client->ps.pmove.delta_angles[i] = ANGLE2SHORT(dest->s.angles[i] - other->client->resp.cmd_angles[i]);
        !          3382: 
        !          3383:        other->s.angles[PITCH] = 0;
        !          3384:        other->s.angles[YAW] = dest->s.angles[YAW];
        !          3385:        other->s.angles[ROLL] = 0;
        !          3386:        VectorCopy (dest->s.angles, other->client->ps.viewangles);
        !          3387:        VectorCopy (dest->s.angles, other->client->v_angle);
        !          3388: 
        !          3389:        // give a little forward velocity
        !          3390:        AngleVectors (other->client->v_angle, forward, NULL, NULL);
        !          3391:        VectorScale(forward, 200, other->velocity);
        !          3392: 
        !          3393:        // kill anything at the destination
        !          3394:        if (!KillBox (other))
        !          3395:        {
        !          3396:        }
        !          3397: 
        !          3398:        gi.linkentity (other);
        !          3399: }
        !          3400: 
        !          3401: /*QUAKED trigger_teleport (0.5 0.5 0.5) ?
        !          3402: Players touching this will be teleported
        !          3403: */
        !          3404: void SP_trigger_teleport (edict_t *ent)
        !          3405: {
        !          3406:        edict_t *s;
        !          3407:        int i;
        !          3408: 
        !          3409:        if (!ent->target)
        !          3410:        {
        !          3411:                gi.dprintf ("teleporter without a target.\n");
        !          3412:                G_FreeEdict (ent);
        !          3413:                return;
        !          3414:        }
        !          3415: 
        !          3416:        ent->svflags |= SVF_NOCLIENT;
        !          3417:        ent->solid = SOLID_TRIGGER;
        !          3418:        ent->touch = old_teleporter_touch;
        !          3419:        gi.setmodel (ent, ent->model);
        !          3420:        gi.linkentity (ent);
        !          3421: 
        !          3422:        // noise maker and splash effect dude
        !          3423:        s = G_Spawn();
        !          3424:        ent->enemy = s;
        !          3425:        for (i = 0; i < 3; i++)
        !          3426:                s->s.origin[i] = ent->mins[i] + (ent->maxs[i] - ent->mins[i])/2;
        !          3427:        s->s.sound = gi.soundindex ("world/hum1.wav");
        !          3428:        gi.linkentity(s);
        !          3429:        
        !          3430: }
        !          3431: 
        !          3432: /*QUAKED info_teleport_destination (0.5 0.5 0.5) (-16 -16 -24) (16 16 32)
        !          3433: Point trigger_teleports at these.
        !          3434: */
        !          3435: void SP_info_teleport_destination (edict_t *ent)
        !          3436: {
        !          3437:        ent->s.origin[2] += 16;
        !          3438: }
        !          3439: 
        !          3440: /*----------------------------------------------------------------------------------*/
        !          3441: /* ADMIN */
        !          3442: 
        !          3443: typedef struct admin_settings_s {
        !          3444:        int matchlen;
        !          3445:        int matchsetuplen;
        !          3446:        int matchstartlen;
        !          3447:        qboolean weaponsstay;
        !          3448:        qboolean instantitems;
        !          3449:        qboolean quaddrop;
        !          3450:        qboolean instantweap;
        !          3451:        qboolean matchlock;
        !          3452: } admin_settings_t;
        !          3453: 
        !          3454: #define SETMENU_SIZE (7 + 5)
        !          3455: 
        !          3456: void CTFAdmin_UpdateSettings(edict_t *ent, pmenuhnd_t *setmenu);
        !          3457: void CTFOpenAdminMenu(edict_t *ent);
        !          3458: 
        !          3459: void CTFAdmin_SettingsApply(edict_t *ent, pmenuhnd_t *p)
        !          3460: {
        !          3461:        admin_settings_t *settings = p->arg;
        !          3462:        char st[80];
        !          3463:        int i;
        !          3464: 
        !          3465:        if (settings->matchlen != matchtime->value) {
        !          3466:                gi.bprintf(PRINT_HIGH, "%s changed the match length to %d minutes.\n",
        !          3467:                        ent->client->pers.netname, settings->matchlen);
        !          3468:                if (ctfgame.match == MATCH_GAME) {
        !          3469:                        // in the middle of a match, change it on the fly
        !          3470:                        ctfgame.matchtime = (ctfgame.matchtime - matchtime->value*60) + settings->matchlen*60;
        !          3471:                } 
        !          3472:                sprintf(st, "%d", settings->matchlen);
        !          3473:                gi.cvar_set("matchtime", st);
        !          3474:        }
        !          3475: 
        !          3476:        if (settings->matchsetuplen != matchsetuptime->value) {
        !          3477:                gi.bprintf(PRINT_HIGH, "%s changed the match setup time to %d minutes.\n",
        !          3478:                        ent->client->pers.netname, settings->matchsetuplen);
        !          3479:                if (ctfgame.match == MATCH_SETUP) {
        !          3480:                        // in the middle of a match, change it on the fly
        !          3481:                        ctfgame.matchtime = (ctfgame.matchtime - matchsetuptime->value*60) + settings->matchsetuplen*60;
        !          3482:                } 
        !          3483:                sprintf(st, "%d", settings->matchsetuplen);
        !          3484:                gi.cvar_set("matchsetuptime", st);
        !          3485:        }
        !          3486: 
        !          3487:        if (settings->matchstartlen != matchstarttime->value) {
        !          3488:                gi.bprintf(PRINT_HIGH, "%s changed the match start time to %d seconds.\n",
        !          3489:                        ent->client->pers.netname, settings->matchstartlen);
        !          3490:                if (ctfgame.match == MATCH_PREGAME) {
        !          3491:                        // in the middle of a match, change it on the fly
        !          3492:                        ctfgame.matchtime = (ctfgame.matchtime - matchstarttime->value) + settings->matchstartlen;
        !          3493:                } 
        !          3494:                sprintf(st, "%d", settings->matchstartlen);
        !          3495:                gi.cvar_set("matchstarttime", st);
        !          3496:        }
        !          3497: 
        !          3498:        if (settings->weaponsstay != !!((int)dmflags->value & DF_WEAPONS_STAY)) {
        !          3499:                gi.bprintf(PRINT_HIGH, "%s turned %s weapons stay.\n",
        !          3500:                        ent->client->pers.netname, settings->weaponsstay ? "on" : "off");
        !          3501:                i = (int)dmflags->value;
        !          3502:                if (settings->weaponsstay)
        !          3503:                        i |= DF_WEAPONS_STAY;
        !          3504:                else
        !          3505:                        i &= ~DF_WEAPONS_STAY;
        !          3506:                sprintf(st, "%d", i);
        !          3507:                gi.cvar_set("dmflags", st);
        !          3508:        }
        !          3509: 
        !          3510:        if (settings->instantitems != !!((int)dmflags->value & DF_INSTANT_ITEMS)) {
        !          3511:                gi.bprintf(PRINT_HIGH, "%s turned %s instant items.\n",
        !          3512:                        ent->client->pers.netname, settings->instantitems ? "on" : "off");
        !          3513:                i = (int)dmflags->value;
        !          3514:                if (settings->instantitems)
        !          3515:                        i |= DF_INSTANT_ITEMS;
        !          3516:                else
        !          3517:                        i &= ~DF_INSTANT_ITEMS;
        !          3518:                sprintf(st, "%d", i);
        !          3519:                gi.cvar_set("dmflags", st);
        !          3520:        }
        !          3521: 
        !          3522:        if (settings->quaddrop != !!((int)dmflags->value & DF_QUAD_DROP)) {
        !          3523:                gi.bprintf(PRINT_HIGH, "%s turned %s quad drop.\n",
        !          3524:                        ent->client->pers.netname, settings->quaddrop ? "on" : "off");
        !          3525:                i = (int)dmflags->value;
        !          3526:                if (settings->quaddrop)
        !          3527:                        i |= DF_QUAD_DROP;
        !          3528:                else
        !          3529:                        i &= ~DF_QUAD_DROP;
        !          3530:                sprintf(st, "%d", i);
        !          3531:                gi.cvar_set("dmflags", st);
        !          3532:        }
        !          3533: 
        !          3534:        if (settings->instantweap != !!((int)instantweap->value)) {
        !          3535:                gi.bprintf(PRINT_HIGH, "%s turned %s instant weapons.\n",
        !          3536:                        ent->client->pers.netname, settings->instantweap ? "on" : "off");
        !          3537:                sprintf(st, "%d", (int)settings->instantweap);
        !          3538:                gi.cvar_set("instantweap", st);
        !          3539:        }
        !          3540: 
        !          3541:        if (settings->matchlock != !!((int)matchlock->value)) {
        !          3542:                gi.bprintf(PRINT_HIGH, "%s turned %s match lock.\n",
        !          3543:                        ent->client->pers.netname, settings->matchlock ? "on" : "off");
        !          3544:                sprintf(st, "%d", (int)settings->matchlock);
        !          3545:                gi.cvar_set("matchlock", st);
        !          3546:        }
        !          3547: 
        !          3548:        PMenu_Close(ent);
        !          3549:        CTFOpenAdminMenu(ent);
        !          3550: }
        !          3551: 
        !          3552: void CTFAdmin_SettingsCancel(edict_t *ent, pmenuhnd_t *p)
        !          3553: {
        !          3554:        admin_settings_t *settings = p->arg;
        !          3555: 
        !          3556:        PMenu_Close(ent);
        !          3557:        CTFOpenAdminMenu(ent);
        !          3558: }
        !          3559: 
        !          3560: void CTFAdmin_ChangeMatchLen(edict_t *ent, pmenuhnd_t *p)
        !          3561: {
        !          3562:        admin_settings_t *settings = p->arg;
        !          3563: 
        !          3564:        settings->matchlen = (settings->matchlen % 60) + 5;
        !          3565:        if (settings->matchlen < 5)
        !          3566:                settings->matchlen = 5;
        !          3567: 
        !          3568:        CTFAdmin_UpdateSettings(ent, p);
        !          3569: }
        !          3570: 
        !          3571: void CTFAdmin_ChangeMatchSetupLen(edict_t *ent, pmenuhnd_t *p)
        !          3572: {
        !          3573:        admin_settings_t *settings = p->arg;
        !          3574: 
        !          3575:        settings->matchsetuplen = (settings->matchsetuplen % 60) + 5;
        !          3576:        if (settings->matchsetuplen < 5)
        !          3577:                settings->matchsetuplen = 5;
        !          3578: 
        !          3579:        CTFAdmin_UpdateSettings(ent, p);
        !          3580: }
        !          3581: 
        !          3582: void CTFAdmin_ChangeMatchStartLen(edict_t *ent, pmenuhnd_t *p)
        !          3583: {
        !          3584:        admin_settings_t *settings = p->arg;
        !          3585: 
        !          3586:        settings->matchstartlen = (settings->matchstartlen % 600) + 10;
        !          3587:        if (settings->matchstartlen < 20)
        !          3588:                settings->matchstartlen = 20;
        !          3589: 
        !          3590:        CTFAdmin_UpdateSettings(ent, p);
        !          3591: }
        !          3592: 
        !          3593: void CTFAdmin_ChangeWeapStay(edict_t *ent, pmenuhnd_t *p)
        !          3594: {
        !          3595:        admin_settings_t *settings = p->arg;
        !          3596: 
        !          3597:        settings->weaponsstay = !settings->weaponsstay;
        !          3598:        CTFAdmin_UpdateSettings(ent, p);
        !          3599: }
        !          3600: 
        !          3601: void CTFAdmin_ChangeInstantItems(edict_t *ent, pmenuhnd_t *p)
        !          3602: {
        !          3603:        admin_settings_t *settings = p->arg;
        !          3604: 
        !          3605:        settings->instantitems = !settings->instantitems;
        !          3606:        CTFAdmin_UpdateSettings(ent, p);
        !          3607: }
        !          3608: 
        !          3609: void CTFAdmin_ChangeQuadDrop(edict_t *ent, pmenuhnd_t *p)
        !          3610: {
        !          3611:        admin_settings_t *settings = p->arg;
        !          3612: 
        !          3613:        settings->quaddrop = !settings->quaddrop;
        !          3614:        CTFAdmin_UpdateSettings(ent, p);
        !          3615: }
        !          3616: 
        !          3617: void CTFAdmin_ChangeInstantWeap(edict_t *ent, pmenuhnd_t *p)
        !          3618: {
        !          3619:        admin_settings_t *settings = p->arg;
        !          3620: 
        !          3621:        settings->instantweap = !settings->instantweap;
        !          3622:        CTFAdmin_UpdateSettings(ent, p);
        !          3623: }
        !          3624: 
        !          3625: void CTFAdmin_ChangeMatchLock(edict_t *ent, pmenuhnd_t *p)
        !          3626: {
        !          3627:        admin_settings_t *settings = p->arg;
        !          3628: 
        !          3629:        settings->matchlock = !settings->matchlock;
        !          3630:        CTFAdmin_UpdateSettings(ent, p);
        !          3631: }
        !          3632: 
        !          3633: void CTFAdmin_UpdateSettings(edict_t *ent, pmenuhnd_t *setmenu)
        !          3634: {
        !          3635:        int i = 2;
        !          3636:        char text[64];
        !          3637:        admin_settings_t *settings = setmenu->arg;
        !          3638: 
        !          3639:        sprintf(text, "Match Len:       %2d mins", settings->matchlen);
        !          3640:        PMenu_UpdateEntry(setmenu->entries + i, text, PMENU_ALIGN_LEFT, CTFAdmin_ChangeMatchLen);
        !          3641:        i++;
        !          3642: 
        !          3643:        sprintf(text, "Match Setup Len: %2d mins", settings->matchsetuplen);
        !          3644:        PMenu_UpdateEntry(setmenu->entries + i, text, PMENU_ALIGN_LEFT, CTFAdmin_ChangeMatchSetupLen);
        !          3645:        i++;
        !          3646: 
        !          3647:        sprintf(text, "Match Start Len: %2d secs", settings->matchstartlen);
        !          3648:        PMenu_UpdateEntry(setmenu->entries + i, text, PMENU_ALIGN_LEFT, CTFAdmin_ChangeMatchStartLen);
        !          3649:        i++;
        !          3650: 
        !          3651:        sprintf(text, "Weapons Stay:    %s", settings->weaponsstay ? "Yes" : "No");
        !          3652:        PMenu_UpdateEntry(setmenu->entries + i, text, PMENU_ALIGN_LEFT, CTFAdmin_ChangeWeapStay);
        !          3653:        i++;
        !          3654: 
        !          3655:        sprintf(text, "Instant Items:   %s", settings->instantitems ? "Yes" : "No");
        !          3656:        PMenu_UpdateEntry(setmenu->entries + i, text, PMENU_ALIGN_LEFT, CTFAdmin_ChangeInstantItems);
        !          3657:        i++;
        !          3658: 
        !          3659:        sprintf(text, "Quad Drop:       %s", settings->quaddrop ? "Yes" : "No");
        !          3660:        PMenu_UpdateEntry(setmenu->entries + i, text, PMENU_ALIGN_LEFT, CTFAdmin_ChangeQuadDrop);
        !          3661:        i++;
        !          3662: 
        !          3663:        sprintf(text, "Instant Weapons: %s", settings->instantweap ? "Yes" : "No");
        !          3664:        PMenu_UpdateEntry(setmenu->entries + i, text, PMENU_ALIGN_LEFT, CTFAdmin_ChangeInstantWeap);
        !          3665:        i++;
        !          3666: 
        !          3667:        sprintf(text, "Match Lock:      %s", settings->matchlock ? "Yes" : "No");
        !          3668:        PMenu_UpdateEntry(setmenu->entries + i, text, PMENU_ALIGN_LEFT, CTFAdmin_ChangeMatchLock);
        !          3669:        i++;
        !          3670: 
        !          3671:        PMenu_Update(ent);
        !          3672: }
        !          3673: 
        !          3674: pmenu_t def_setmenu[] = {
        !          3675:        { "*Settings Menu", PMENU_ALIGN_CENTER, NULL },
        !          3676:        { NULL,                         PMENU_ALIGN_CENTER, NULL },
        !          3677:        { NULL,                         PMENU_ALIGN_LEFT, NULL },       //int matchlen;         
        !          3678:        { NULL,                         PMENU_ALIGN_LEFT, NULL },       //int matchsetuplen;    
        !          3679:        { NULL,                         PMENU_ALIGN_LEFT, NULL },       //int matchstartlen;    
        !          3680:        { NULL,                         PMENU_ALIGN_LEFT, NULL },       //qboolean weaponsstay; 
        !          3681:        { NULL,                         PMENU_ALIGN_LEFT, NULL },       //qboolean instantitems;
        !          3682:        { NULL,                         PMENU_ALIGN_LEFT, NULL },       //qboolean quaddrop;    
        !          3683:        { NULL,                         PMENU_ALIGN_LEFT, NULL },       //qboolean instantweap; 
        !          3684:        { NULL,                         PMENU_ALIGN_LEFT, NULL },       //qboolean matchlock; 
        !          3685:        { NULL,                         PMENU_ALIGN_LEFT, NULL },
        !          3686:        { "Apply",                      PMENU_ALIGN_LEFT, CTFAdmin_SettingsApply },
        !          3687:        { "Cancel",                     PMENU_ALIGN_LEFT, CTFAdmin_SettingsCancel }
        !          3688: };
        !          3689: 
        !          3690: void CTFAdmin_Settings(edict_t *ent, pmenuhnd_t *p)
        !          3691: {
        !          3692:        admin_settings_t *settings;
        !          3693:        pmenuhnd_t *menu;
        !          3694: 
        !          3695:        PMenu_Close(ent);
        !          3696: 
        !          3697:        settings = malloc(sizeof(*settings));
        !          3698: 
        !          3699:        settings->matchlen = matchtime->value;
        !          3700:        settings->matchsetuplen = matchsetuptime->value;
        !          3701:        settings->matchstartlen = matchstarttime->value;
        !          3702:        settings->weaponsstay = !!((int)dmflags->value & DF_WEAPONS_STAY);
        !          3703:        settings->instantitems = !!((int)dmflags->value & DF_INSTANT_ITEMS);
        !          3704:        settings->quaddrop = !!((int)dmflags->value & DF_QUAD_DROP);
        !          3705:        settings->instantweap = instantweap->value != 0;
        !          3706:        settings->matchlock = matchlock->value != 0;
        !          3707: 
        !          3708:        menu = PMenu_Open(ent, def_setmenu, -1, sizeof(def_setmenu) / sizeof(pmenu_t), settings);
        !          3709:        CTFAdmin_UpdateSettings(ent, menu);
        !          3710: }
        !          3711: 
        !          3712: void CTFAdmin_MatchSet(edict_t *ent, pmenuhnd_t *p)
        !          3713: {
        !          3714:        PMenu_Close(ent);
        !          3715: 
        !          3716:        if (ctfgame.match == MATCH_SETUP) {
        !          3717:                gi.bprintf(PRINT_CHAT, "Match has been forced to start.\n");
        !          3718:                ctfgame.match = MATCH_PREGAME;
        !          3719:                ctfgame.matchtime = level.time + matchstarttime->value;
        !          3720:        } else if (ctfgame.match == MATCH_GAME) {
        !          3721:                gi.bprintf(PRINT_CHAT, "Match has been forced to terminate.\n");
        !          3722:                ctfgame.match = MATCH_SETUP;
        !          3723:                ctfgame.matchtime = level.time + matchsetuptime->value * 60;
        !          3724:                CTFResetAllPlayers();
        !          3725:        }
        !          3726: }
        !          3727: 
        !          3728: void CTFAdmin_MatchMode(edict_t *ent, pmenuhnd_t *p)
        !          3729: {
        !          3730:        PMenu_Close(ent);
        !          3731: 
        !          3732:        if (ctfgame.match != MATCH_SETUP) {
        !          3733:                if (competition->value < 3)
        !          3734:                        gi.cvar_set("competition", "2");
        !          3735:                ctfgame.match = MATCH_SETUP;
        !          3736:                CTFResetAllPlayers();
        !          3737:        }
        !          3738: }
        !          3739: 
        !          3740: void CTFAdmin_Cancel(edict_t *ent, pmenuhnd_t *p)
        !          3741: {
        !          3742:        PMenu_Close(ent);
        !          3743: }
        !          3744: 
        !          3745: 
        !          3746: pmenu_t adminmenu[] = {
        !          3747:        { "*Administration Menu",       PMENU_ALIGN_CENTER, NULL },
        !          3748:        { NULL,                                         PMENU_ALIGN_CENTER, NULL }, // blank
        !          3749:        { "Settings",                           PMENU_ALIGN_LEFT, CTFAdmin_Settings },
        !          3750:        { NULL,                                         PMENU_ALIGN_LEFT, NULL },
        !          3751:        { NULL,                                         PMENU_ALIGN_LEFT, NULL },
        !          3752:        { "Cancel",                                     PMENU_ALIGN_LEFT, CTFAdmin_Cancel },
        !          3753:        { NULL,                                         PMENU_ALIGN_CENTER, NULL },
        !          3754: };
        !          3755: 
        !          3756: void CTFOpenAdminMenu(edict_t *ent)
        !          3757: {
        !          3758:        adminmenu[3].text = NULL;
        !          3759:        adminmenu[3].SelectFunc = NULL;
        !          3760:        if (ctfgame.match == MATCH_SETUP) {
        !          3761:                adminmenu[3].text = "Force start match";
        !          3762:                adminmenu[3].SelectFunc = CTFAdmin_MatchSet;
        !          3763:        } else if (ctfgame.match == MATCH_GAME) {
        !          3764:                adminmenu[3].text = "Cancel match";
        !          3765:                adminmenu[3].SelectFunc = CTFAdmin_MatchSet;
        !          3766:        } else if (ctfgame.match == MATCH_NONE && competition->value) {
        !          3767:                adminmenu[3].text = "Switch to match mode";
        !          3768:                adminmenu[3].SelectFunc = CTFAdmin_MatchMode;
        !          3769:        }
        !          3770: 
        !          3771: //     if (ent->client->menu)
        !          3772: //             PMenu_Close(ent->client->menu);
        !          3773: 
        !          3774:        PMenu_Open(ent, adminmenu, -1, sizeof(adminmenu) / sizeof(pmenu_t), NULL);
        !          3775: }
        !          3776: 
        !          3777: void CTFAdmin(edict_t *ent)
        !          3778: {
        !          3779:        char text[1024];
        !          3780: 
        !          3781:        if (gi.argc() > 1 && admin_password->string && *admin_password->string &&
        !          3782:                !ent->client->resp.admin && strcmp(admin_password->string, gi.argv(1)) == 0) {
        !          3783:                ent->client->resp.admin = true;
        !          3784:                gi.bprintf(PRINT_HIGH, "%s has become an admin.\n", ent->client->pers.netname);
        !          3785:                gi.cprintf(ent, PRINT_HIGH, "Type 'admin' to access the adminstration menu.\n");
        !          3786:        }
        !          3787: 
        !          3788:        if (!ent->client->resp.admin) {
        !          3789:                sprintf(text, "%s has requested admin rights.",
        !          3790:                        ent->client->pers.netname);
        !          3791:                CTFBeginElection(ent, ELECT_ADMIN, text);
        !          3792:                return;
        !          3793:        }
        !          3794: 
        !          3795:        if (ent->client->menu)
        !          3796:                PMenu_Close(ent);
        !          3797: 
        !          3798:        CTFOpenAdminMenu(ent);
        !          3799: }
        !          3800: 
        !          3801: /*----------------------------------------------------------------*/
        !          3802: 
        !          3803: void CTFStats(edict_t *ent)
        !          3804: {
        !          3805:        int i, e;
        !          3806:        ghost_t *g;
        !          3807:        char st[80];
        !          3808:        char text[1400];
        !          3809:        edict_t *e2;
        !          3810: 
        !          3811:        *text = 0;
        !          3812:        if (ctfgame.match == MATCH_SETUP) {
        !          3813:                for (i = 1; i <= maxclients->value; i++) {
        !          3814:                        e2 = g_edicts + i;
        !          3815:                        if (!e2->inuse)
        !          3816:                                continue;
        !          3817:                        if (!e2->client->resp.ready && e2->client->resp.ctf_team != CTF_NOTEAM) {
        !          3818:                                sprintf(st, "%s is not ready.\n", e2->client->pers.netname);
        !          3819:                                if (strlen(text) + strlen(st) < sizeof(text) - 50)
        !          3820:                                        strcat(text, st);
        !          3821:                        }
        !          3822:                }
        !          3823:        }
        !          3824: 
        !          3825:        for (i = 0, g = ctfgame.ghosts; i < MAX_CLIENTS; i++, g++)
        !          3826:                if (g->ent)
        !          3827:                        break;
        !          3828: 
        !          3829:        if (i == MAX_CLIENTS) {
        !          3830:                if (*text)
        !          3831:                        gi.cprintf(ent, PRINT_HIGH, "%s", text);
        !          3832:                gi.cprintf(ent, PRINT_HIGH, "No statistics available.\n");
        !          3833:                return;
        !          3834:        }
        !          3835: 
        !          3836:        strcat(text, "  #|Name            |Score|Kills|Death|BasDf|CarDf|Effcy|\n");
        !          3837: 
        !          3838:        for (i = 0, g = ctfgame.ghosts; i < MAX_CLIENTS; i++, g++) {
        !          3839:                if (!*g->netname)
        !          3840:                        continue;
        !          3841: 
        !          3842:                if (g->deaths + g->kills == 0)
        !          3843:                        e = 50;
        !          3844:                else
        !          3845:                        e = g->kills * 100 / (g->kills + g->deaths);
        !          3846:                sprintf(st, "%3d|%-16.16s|%5d|%5d|%5d|%5d|%5d|%4d%%|\n",
        !          3847:                        g->number, 
        !          3848:                        g->netname, 
        !          3849:                        g->score, 
        !          3850:                        g->kills, 
        !          3851:                        g->deaths, 
        !          3852:                        g->basedef,
        !          3853:                        g->carrierdef, 
        !          3854:                        e);
        !          3855:                if (strlen(text) + strlen(st) > sizeof(text) - 50) {
        !          3856:                        sprintf(text+strlen(text), "And more...\n");
        !          3857:                        gi.cprintf(ent, PRINT_HIGH, "%s", text);
        !          3858:                        return;
        !          3859:                }
        !          3860:                strcat(text, st);
        !          3861:        }
        !          3862:        gi.cprintf(ent, PRINT_HIGH, "%s", text);
        !          3863: }
        !          3864: 
        !          3865: void CTFPlayerList(edict_t *ent)
        !          3866: {
        !          3867:        int i;
        !          3868:        char st[80];
        !          3869:        char text[1400];
        !          3870:        edict_t *e2;
        !          3871: 
        !          3872:        *text = 0;
        !          3873:        if (ctfgame.match == MATCH_SETUP) {
        !          3874:                for (i = 1; i <= maxclients->value; i++) {
        !          3875:                        e2 = g_edicts + i;
        !          3876:                        if (!e2->inuse)
        !          3877:                                continue;
        !          3878:                        if (!e2->client->resp.ready && e2->client->resp.ctf_team != CTF_NOTEAM) {
        !          3879:                                sprintf(st, "%s is not ready.\n", e2->client->pers.netname);
        !          3880:                                if (strlen(text) + strlen(st) < sizeof(text) - 50)
        !          3881:                                        strcat(text, st);
        !          3882:                        }
        !          3883:                }
        !          3884:        }
        !          3885: 
        !          3886:        // number, name, connect time, ping, score, admin
        !          3887: 
        !          3888:        *text = 0;
        !          3889:        for (i = 0, e2 = g_edicts + 1; i < maxclients->value; i++, e2++) {
        !          3890:                if (!e2->inuse)
        !          3891:                        continue;
        !          3892: 
        !          3893:                sprintf(st, "%3d %-16.16s %02d:%02d %4d %3d%s%s\n",
        !          3894:                        i + 1,
        !          3895:                        e2->client->pers.netname,
        !          3896:                        (level.framenum - e2->client->resp.enterframe) / 600,
        !          3897:                        ((level.framenum - e2->client->resp.enterframe) % 600)/10,
        !          3898:                        e2->client->ping,
        !          3899:                        e2->client->resp.score,
        !          3900:                        (ctfgame.match == MATCH_SETUP || ctfgame.match == MATCH_PREGAME) ?
        !          3901:                        (e2->client->resp.ready ? " (ready)" : " (notready)") : "",
        !          3902:                        e2->client->resp.admin ? " (admin)" : "");
        !          3903:                if (strlen(text) + strlen(st) > sizeof(text) - 50) {
        !          3904:                        sprintf(text+strlen(text), "And more...\n");
        !          3905:                        gi.cprintf(ent, PRINT_HIGH, "%s", text);
        !          3906:                        return;
        !          3907:                }
        !          3908:                strcat(text, st);
        !          3909:        }
        !          3910:        gi.cprintf(ent, PRINT_HIGH, "%s", text);
        !          3911: }
        !          3912: 
        !          3913: 
        !          3914: void CTFWarp(edict_t *ent)
        !          3915: {
        !          3916:        char text[1024];
        !          3917:        char *mlist, *token;
        !          3918:        static const char *seps = " \t\n\r";
        !          3919: 
        !          3920:        if (gi.argc() < 2) {
        !          3921:                gi.cprintf(ent, PRINT_HIGH, "Where do you want to warp to?\n");
        !          3922:                gi.cprintf(ent, PRINT_HIGH, "Available levels are: %s\n", warp_list->string);
        !          3923:                return;
        !          3924:        }
        !          3925: 
        !          3926:        mlist = strdup(warp_list->string);
        !          3927: 
        !          3928:        token = strtok(mlist, seps);
        !          3929:        while (token != NULL) {
        !          3930:                if (Q_stricmp(token, gi.argv(1)) == 0)
        !          3931:                        break;
        !          3932:                token = strtok(NULL, seps);
        !          3933:        }
        !          3934: 
        !          3935:        if (token == NULL) {
        !          3936:                gi.cprintf(ent, PRINT_HIGH, "Unknown CTF level.\n");
        !          3937:                gi.cprintf(ent, PRINT_HIGH, "Available levels are: %s\n", warp_list->string);
        !          3938:                free(mlist);
        !          3939:                return;
        !          3940:        }
        !          3941: 
        !          3942:        free(mlist);
        !          3943: 
        !          3944: 
        !          3945:        if (ent->client->resp.admin) {
        !          3946:                gi.bprintf(PRINT_HIGH, "%s is warping to level %s.\n", 
        !          3947:                        ent->client->pers.netname, gi.argv(1));
        !          3948:                strncpy(level.forcemap, gi.argv(1), sizeof(level.forcemap) - 1);
        !          3949:                EndDMLevel();
        !          3950:                return;
        !          3951:        }
        !          3952: 
        !          3953:        sprintf(text, "%s has requested warping to level %s.", 
        !          3954:                        ent->client->pers.netname, gi.argv(1));
        !          3955:        if (CTFBeginElection(ent, ELECT_MAP, text))
        !          3956:                strncpy(ctfgame.elevel, gi.argv(1), sizeof(ctfgame.elevel) - 1);
        !          3957: }
        !          3958: 
        !          3959: void CTFBoot(edict_t *ent)
        !          3960: {
        !          3961:        int i;
        !          3962:        edict_t *targ;
        !          3963:        char text[80];
        !          3964: 
        !          3965:        if (!ent->client->resp.admin) {
        !          3966:                gi.cprintf(ent, PRINT_HIGH, "You are not an admin.\n");
        !          3967:                return;
        !          3968:        }
        !          3969: 
        !          3970:        if (gi.argc() < 2) {
        !          3971:                gi.cprintf(ent, PRINT_HIGH, "Who do you want to kick?\n");
        !          3972:                return;
        !          3973:        }
        !          3974: 
        !          3975:        if (*gi.argv(1) < '0' && *gi.argv(1) > '9') {
        !          3976:                gi.cprintf(ent, PRINT_HIGH, "Specify the player number to kick.\n");
        !          3977:                return;
        !          3978:        }
        !          3979: 
        !          3980:        i = atoi(gi.argv(1));
        !          3981:        if (i < 1 || i > maxclients->value) {
        !          3982:                gi.cprintf(ent, PRINT_HIGH, "Invalid player number.\n");
        !          3983:                return;
        !          3984:        }
        !          3985: 
        !          3986:        targ = g_edicts + i;
        !          3987:        if (!targ->inuse) {
        !          3988:                gi.cprintf(ent, PRINT_HIGH, "That player number is not connected.\n");
        !          3989:                return;
        !          3990:        }
        !          3991: 
        !          3992:        sprintf(text, "kick %d\n", i - 1);
        !          3993:        gi.AddCommandString(text);
        !          3994: }
        !          3995: 
        !          3996: 
        !          3997:                

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.