Return to g_chase.c CVS log

Up to [Quake II] / quake2 / ctf

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

1.1     ! root        1: #include "g_local.h"
        !             2: 
        !             3: 
        !             4: void UpdateChaseCam(edict_t *ent)
        !             5: {
        !             6:        vec3_t o, ownerv, goal;
        !             7:        edict_t *targ;
        !             8:        vec3_t forward, right;
        !             9:        trace_t trace;
        !            10:        int i;
        !            11:        vec3_t oldgoal;
        !            12:        vec3_t angles;
        !            13: 
        !            14:        // is our chase target gone?
        !            15:        if (!ent->client->chase_target->inuse) {
        !            16:                ent->client->chase_target = NULL;
        !            17:                return;
        !            18:        }
        !            19: 
        !            20:        targ = ent->client->chase_target;
        !            21: 
        !            22:        VectorCopy(targ->s.origin, ownerv);
        !            23:        VectorCopy(ent->s.origin, oldgoal);
        !            24: 
        !            25:        ownerv[2] += targ->viewheight;
        !            26: 
        !            27:        VectorCopy(targ->client->v_angle, angles);
        !            28:        if (angles[PITCH] > 56)
        !            29:                angles[PITCH] = 56;
        !            30:        AngleVectors (angles, forward, right, NULL);
        !            31:        VectorNormalize(forward);
        !            32:        VectorMA(ownerv, -30, forward, o);
        !            33: 
        !            34:        if (o[2] < targ->s.origin[2] + 20)
        !            35:                o[2] = targ->s.origin[2] + 20;
        !            36: 
        !            37:        // jump animation lifts
        !            38:        if (!targ->groundentity)
        !            39:                o[2] += 16;
        !            40: 
        !            41:        trace = gi.trace(ownerv, vec3_origin, vec3_origin, o, targ, MASK_SOLID);
        !            42: 
        !            43:        VectorCopy(trace.endpos, goal);
        !            44: 
        !            45:        VectorMA(goal, 2, forward, goal);
        !            46: 
        !            47:        // pad for floors and ceilings
        !            48:        VectorCopy(goal, o);
        !            49:        o[2] += 6;
        !            50:        trace = gi.trace(goal, vec3_origin, vec3_origin, o, targ, MASK_SOLID);
        !            51:        if (trace.fraction < 1) {
        !            52:                VectorCopy(trace.endpos, goal);
        !            53:                goal[2] -= 6;
        !            54:        }
        !            55: 
        !            56:        VectorCopy(goal, o);
        !            57:        o[2] -= 6;
        !            58:        trace = gi.trace(goal, vec3_origin, vec3_origin, o, targ, MASK_SOLID);
        !            59:        if (trace.fraction < 1) {
        !            60:                VectorCopy(trace.endpos, goal);
        !            61:                goal[2] += 6;
        !            62:        }
        !            63: 
        !            64:        ent->client->ps.pmove.pm_type = PM_FREEZE;
        !            65: 
        !            66:        VectorCopy(goal, ent->s.origin);
        !            67:        for (i=0 ; i<3 ; i++)
        !            68:                ent->client->ps.pmove.delta_angles[i] = ANGLE2SHORT(targ->client->v_angle[i] - ent->client->resp.cmd_angles[i]);
        !            69: 
        !            70:        VectorCopy(targ->client->v_angle, ent->client->ps.viewangles);
        !            71:        VectorCopy(targ->client->v_angle, ent->client->v_angle);
        !            72: 
        !            73:        ent->viewheight = 0;
        !            74:        ent->client->ps.pmove.pm_flags |= PMF_NO_PREDICTION;
        !            75:        gi.linkentity(ent);
        !            76: 
        !            77:        if ((!ent->client->showscores && !ent->client->menu &&
        !            78:                !ent->client->showinventory && !ent->client->showhelp &&
        !            79:                !(level.framenum & 31)) || ent->client->update_chase) {
        !            80:                char s[1024];
        !            81: 
        !            82:                ent->client->update_chase = false;
        !            83:                sprintf(s, "xv 0 yb -68 string2 \"Chasing %s\"",
        !            84:                        targ->client->pers.netname);
        !            85:                gi.WriteByte (svc_layout);
        !            86:                gi.WriteString (s);
        !            87:                gi.unicast(ent, false);
        !            88:        }
        !            89: 
        !            90: }
        !            91: 
        !            92: void ChaseNext(edict_t *ent)
        !            93: {
        !            94:        int i;
        !            95:        edict_t *e;
        !            96: 
        !            97:        if (!ent->client->chase_target)
        !            98:                return;
        !            99: 
        !           100:        i = ent->client->chase_target - g_edicts;
        !           101:        do {
        !           102:                i++;
        !           103:                if (i > maxclients->value)
        !           104:                        i = 1;
        !           105:                e = g_edicts + i;
        !           106:                if (!e->inuse)
        !           107:                        continue;
        !           108:                if (e->solid != SOLID_NOT)
        !           109:                        break;
        !           110:        } while (e != ent->client->chase_target);
        !           111: 
        !           112:        ent->client->chase_target = e;
        !           113:        ent->client->update_chase = true;
        !           114: }
        !           115: 
        !           116: void ChasePrev(edict_t *ent)
        !           117: {
        !           118:        int i;
        !           119:        edict_t *e;
        !           120: 
        !           121:        if (!ent->client->chase_target)
        !           122:                return;
        !           123: 
        !           124:        i = ent->client->chase_target - g_edicts;
        !           125:        do {
        !           126:                i--;
        !           127:                if (i < 1)
        !           128:                        i = maxclients->value;
        !           129:                e = g_edicts + i;
        !           130:                if (!e->inuse)
        !           131:                        continue;
        !           132:                if (e->solid != SOLID_NOT)
        !           133:                        break;
        !           134:        } while (e != ent->client->chase_target);
        !           135: 
        !           136:        ent->client->chase_target = e;
        !           137:        ent->client->update_chase = true;
        !           138: }

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