Return to g_turret.c CVS log

Up to [Quake II] / quake2 / game

Annotation of quake2/game/g_turret.c, revision 1.1

1.1     ! root        1: // g_turret.c
        !             2: 
        !             3: #include "g_local.h"
        !             4: 
        !             5: 
        !             6: void AnglesNormalize(vec3_t vec)
        !             7: {
        !             8:        while(vec[0] > 360)
        !             9:                vec[0] -= 360;
        !            10:        while(vec[0] < 0)
        !            11:                vec[0] += 360;
        !            12:        while(vec[1] > 360)
        !            13:                vec[1] -= 360;
        !            14:        while(vec[1] < 0)
        !            15:                vec[1] += 360;
        !            16: }
        !            17: 
        !            18: float SnapToEights(float x)
        !            19: {
        !            20:        x *= 8.0;
        !            21:        if (x > 0.0)
        !            22:                x += 0.5;
        !            23:        else
        !            24:                x -= 0.5;
        !            25:        return 0.125 * (int)x;
        !            26: }
        !            27: 
        !            28: 
        !            29: void turret_blocked(edict_t *self, edict_t *other)
        !            30: {
        !            31:        edict_t *attacker;
        !            32: 
        !            33:        if (other->takedamage)
        !            34:        {
        !            35:                if (self->teammaster->owner)
        !            36:                        attacker = self->teammaster->owner;
        !            37:                else
        !            38:                        attacker = self->teammaster;
        !            39:                T_Damage (other, self, attacker, vec3_origin, other->s.origin, vec3_origin, self->teammaster->dmg, 10, 0, MOD_CRUSH);
        !            40:        }
        !            41: }
        !            42: 
        !            43: /*QUAKED turret_breach (0 0 0) ?
        !            44: This portion of the turret can change both pitch and yaw.
        !            45: The model  should be made with a flat pitch.
        !            46: It (and the associated base) need to be oriented towards 0.
        !            47: Use "angle" to set the starting angle.
        !            48: 
        !            49: "speed"                default 50
        !            50: "dmg"          default 10
        !            51: "angle"                point this forward
        !            52: "target"       point this at an info_notnull at the muzzle tip
        !            53: "minpitch"     min acceptable pitch angle : default -30
        !            54: "maxpitch"     max acceptable pitch angle : default 30
        !            55: "minyaw"       min acceptable yaw angle   : default 0
        !            56: "maxyaw"       max acceptable yaw angle   : default 360
        !            57: */
        !            58: 
        !            59: void turret_breach_fire (edict_t *self)
        !            60: {
        !            61:        vec3_t  f, r, u;
        !            62:        vec3_t  start;
        !            63:        int             damage;
        !            64:        int             speed;
        !            65: 
        !            66:        AngleVectors (self->s.angles, f, r, u);
        !            67:        VectorMA (self->s.origin, self->move_origin[0], f, start);
        !            68:        VectorMA (start, self->move_origin[1], r, start);
        !            69:        VectorMA (start, self->move_origin[2], u, start);
        !            70: 
        !            71:        damage = 100 + random() * 50;
        !            72:        speed = 550 + 50 * skill->value;
        !            73:        fire_rocket (self->teammaster->owner, start, f, damage, speed, 150, damage);
        !            74:        gi.positioned_sound (start, self, CHAN_WEAPON, gi.soundindex("weapons/rocklf1a.wav"), 1, ATTN_NORM, 0);
        !            75: }
        !            76: 
        !            77: void turret_breach_think (edict_t *self)
        !            78: {
        !            79:        edict_t *ent;
        !            80:        vec3_t  current_angles;
        !            81:        vec3_t  delta;
        !            82: 
        !            83:        VectorCopy (self->s.angles, current_angles);
        !            84:        AnglesNormalize(current_angles);
        !            85: 
        !            86:        AnglesNormalize(self->move_angles);
        !            87:        if (self->move_angles[PITCH] > 180)
        !            88:                self->move_angles[PITCH] -= 360;
        !            89: 
        !            90:        // clamp angles to mins & maxs
        !            91:        if (self->move_angles[PITCH] > self->pos1[PITCH])
        !            92:                self->move_angles[PITCH] = self->pos1[PITCH];
        !            93:        else if (self->move_angles[PITCH] < self->pos2[PITCH])
        !            94:                self->move_angles[PITCH] = self->pos2[PITCH];
        !            95: 
        !            96:        if ((self->move_angles[YAW] < self->pos1[YAW]) || (self->move_angles[YAW] > self->pos2[YAW]))
        !            97:        {
        !            98:                float   dmin, dmax;
        !            99: 
        !           100:                dmin = fabs(self->pos1[YAW] - self->move_angles[YAW]);
        !           101:                if (dmin < -180)
        !           102:                        dmin += 360;
        !           103:                else if (dmin > 180)
        !           104:                        dmin -= 360;
        !           105:                dmax = fabs(self->pos2[YAW] - self->move_angles[YAW]);
        !           106:                if (dmax < -180)
        !           107:                        dmax += 360;
        !           108:                else if (dmax > 180)
        !           109:                        dmax -= 360;
        !           110:                if (fabs(dmin) < fabs(dmax))
        !           111:                        self->move_angles[YAW] = self->pos1[YAW];
        !           112:                else
        !           113:                        self->move_angles[YAW] = self->pos2[YAW];
        !           114:        }
        !           115: 
        !           116:        VectorSubtract (self->move_angles, current_angles, delta);
        !           117:        if (delta[0] < -180)
        !           118:                delta[0] += 360;
        !           119:        else if (delta[0] > 180)
        !           120:                delta[0] -= 360;
        !           121:        if (delta[1] < -180)
        !           122:                delta[1] += 360;
        !           123:        else if (delta[1] > 180)
        !           124:                delta[1] -= 360;
        !           125:        delta[2] = 0;
        !           126: 
        !           127:        if (delta[0] > self->speed * FRAMETIME)
        !           128:                delta[0] = self->speed * FRAMETIME;
        !           129:        if (delta[0] < -1 * self->speed * FRAMETIME)
        !           130:                delta[0] = -1 * self->speed * FRAMETIME;
        !           131:        if (delta[1] > self->speed * FRAMETIME)
        !           132:                delta[1] = self->speed * FRAMETIME;
        !           133:        if (delta[1] < -1 * self->speed * FRAMETIME)
        !           134:                delta[1] = -1 * self->speed * FRAMETIME;
        !           135: 
        !           136:        VectorScale (delta, 1.0/FRAMETIME, self->avelocity);
        !           137: 
        !           138:        self->nextthink = level.time + FRAMETIME;
        !           139: 
        !           140:        for (ent = self->teammaster; ent; ent = ent->teamchain)
        !           141:                ent->avelocity[1] = self->avelocity[1];
        !           142: 
        !           143:        // if we have adriver, adjust his velocities
        !           144:        if (self->owner)
        !           145:        {
        !           146:                float   angle;
        !           147:                float   target_z;
        !           148:                float   diff;
        !           149:                vec3_t  target;
        !           150:                vec3_t  dir;
        !           151: 
        !           152:                // angular is easy, just copy ours
        !           153:                self->owner->avelocity[0] = self->avelocity[0];
        !           154:                self->owner->avelocity[1] = self->avelocity[1];
        !           155: 
        !           156:                // x & y
        !           157:                angle = self->s.angles[1] + self->owner->move_origin[1];
        !           158:                angle *= (M_PI*2 / 360);
        !           159:                target[0] = SnapToEights(self->s.origin[0] + cos(angle) * self->owner->move_origin[0]);
        !           160:                target[1] = SnapToEights(self->s.origin[1] + sin(angle) * self->owner->move_origin[0]);
        !           161:                target[2] = self->owner->s.origin[2];
        !           162: 
        !           163:                VectorSubtract (target, self->owner->s.origin, dir);
        !           164:                self->owner->velocity[0] = dir[0] * 1.0 / FRAMETIME;
        !           165:                self->owner->velocity[1] = dir[1] * 1.0 / FRAMETIME;
        !           166: 
        !           167:                // z
        !           168:                angle = self->s.angles[PITCH] * (M_PI*2 / 360);
        !           169:                target_z = SnapToEights(self->s.origin[2] + self->owner->move_origin[0] * tan(angle) + self->owner->move_origin[2]);
        !           170: 
        !           171:                diff = target_z - self->owner->s.origin[2];
        !           172:                self->owner->velocity[2] = diff * 1.0 / FRAMETIME;
        !           173: 
        !           174:                if (self->spawnflags & 65536)
        !           175:                {
        !           176:                        turret_breach_fire (self);
        !           177:                        self->spawnflags &= ~65536;
        !           178:                }
        !           179:        }
        !           180: }
        !           181: 
        !           182: void turret_breach_finish_init (edict_t *self)
        !           183: {
        !           184:        // get and save info for muzzle location
        !           185:        if (!self->target)
        !           186:        {
        !           187:                gi.dprintf("%s at %s needs a target\n", self->classname, vtos(self->s.origin));
        !           188:        }
        !           189:        else
        !           190:        {
        !           191:                self->target_ent = G_PickTarget (self->target);
        !           192:                VectorSubtract (self->target_ent->s.origin, self->s.origin, self->move_origin);
        !           193:                G_FreeEdict(self->target_ent);
        !           194:        }
        !           195: 
        !           196:        self->teammaster->dmg = self->dmg;
        !           197:        self->think = turret_breach_think;
        !           198:        self->think (self);
        !           199: }
        !           200: 
        !           201: void SP_turret_breach (edict_t *self)
        !           202: {
        !           203:        self->solid = SOLID_BSP;
        !           204:        self->movetype = MOVETYPE_PUSH;
        !           205:        gi.setmodel (self, self->model);
        !           206: 
        !           207:        if (!self->speed)
        !           208:                self->speed = 50;
        !           209:        if (!self->dmg)
        !           210:                self->dmg = 10;
        !           211: 
        !           212:        if (!st.minpitch)
        !           213:                st.minpitch = -30;
        !           214:        if (!st.maxpitch)
        !           215:                st.maxpitch = 30;
        !           216:        if (!st.maxyaw)
        !           217:                st.maxyaw = 360;
        !           218: 
        !           219:        self->pos1[PITCH] = -1 * st.minpitch;
        !           220:        self->pos1[YAW]   = st.minyaw;
        !           221:        self->pos2[PITCH] = -1 * st.maxpitch;
        !           222:        self->pos2[YAW]   = st.maxyaw;
        !           223: 
        !           224:        self->ideal_yaw = self->s.angles[YAW];
        !           225:        self->move_angles[YAW] = self->ideal_yaw;
        !           226: 
        !           227:        self->blocked = turret_blocked;
        !           228: 
        !           229:        self->think = turret_breach_finish_init;
        !           230:        self->nextthink = level.time + FRAMETIME;
        !           231:        gi.linkentity (self);
        !           232: }
        !           233: 
        !           234: 
        !           235: /*QUAKED turret_base (0 0 0) ?
        !           236: This portion of the turret changes yaw only.
        !           237: MUST be teamed with a turret_breach.
        !           238: */
        !           239: 
        !           240: void SP_turret_base (edict_t *self)
        !           241: {
        !           242:        self->solid = SOLID_BSP;
        !           243:        self->movetype = MOVETYPE_PUSH;
        !           244:        gi.setmodel (self, self->model);
        !           245:        self->blocked = turret_blocked;
        !           246:        gi.linkentity (self);
        !           247: }
        !           248: 
        !           249: 
        !           250: /*QUAKED turret_driver (1 .5 0) (-16 -16 -24) (16 16 32)
        !           251: Must NOT be on the team with the rest of the turret parts.
        !           252: Instead it must target the turret_breach.
        !           253: */
        !           254: 
        !           255: void infantry_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage);
        !           256: void infantry_stand (edict_t *self);
        !           257: void monster_use (edict_t *self, edict_t *other, edict_t *activator);
        !           258: 
        !           259: void turret_driver_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
        !           260: {
        !           261:        edict_t *ent;
        !           262: 
        !           263:        // level the gun
        !           264:        self->target_ent->move_angles[0] = 0;
        !           265: 
        !           266:        // remove the driver from the end of them team chain
        !           267:        for (ent = self->target_ent->teammaster; ent->teamchain != self; ent = ent->teamchain)
        !           268:                ;
        !           269:        ent->teamchain = NULL;
        !           270:        self->teammaster = NULL;
        !           271:        self->flags &= ~FL_TEAMSLAVE;
        !           272: 
        !           273:        self->target_ent->owner = NULL;
        !           274:        self->target_ent->teammaster->owner = NULL;
        !           275: 
        !           276:        infantry_die (self, inflictor, attacker, damage);
        !           277: }
        !           278: 
        !           279: qboolean FindTarget (edict_t *self);
        !           280: 
        !           281: void turret_driver_think (edict_t *self)
        !           282: {
        !           283:        vec3_t  target;
        !           284:        vec3_t  dir;
        !           285:        float   reaction_time;
        !           286: 
        !           287:        self->nextthink = level.time + FRAMETIME;
        !           288: 
        !           289:        if (self->enemy && (!self->enemy->inuse || self->enemy->health <= 0))
        !           290:                self->enemy = NULL;
        !           291: 
        !           292:        if (!self->enemy)
        !           293:        {
        !           294:                if (!FindTarget (self))
        !           295:                        return;
        !           296:                self->monsterinfo.trail_time = level.time;
        !           297:                self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
        !           298:        }
        !           299:        else
        !           300:        {
        !           301:                if (visible (self, self->enemy))
        !           302:                {
        !           303:                        if (self->monsterinfo.aiflags & AI_LOST_SIGHT)
        !           304:                        {
        !           305:                                self->monsterinfo.trail_time = level.time;
        !           306:                                self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
        !           307:                        }
        !           308:                }
        !           309:                else
        !           310:                {
        !           311:                        self->monsterinfo.aiflags |= AI_LOST_SIGHT;
        !           312:                        return;
        !           313:                }
        !           314:        }
        !           315: 
        !           316:        // let the turret know where we want it to aim
        !           317:        VectorCopy (self->enemy->s.origin, target);
        !           318:        target[2] += self->enemy->viewheight;
        !           319:        VectorSubtract (target, self->target_ent->s.origin, dir);
        !           320:        vectoangles (dir, self->target_ent->move_angles);
        !           321: 
        !           322:        // decide if we should shoot
        !           323:        if (level.time < self->monsterinfo.attack_finished)
        !           324:                return;
        !           325: 
        !           326:        reaction_time = (3 - skill->value) * 1.0;
        !           327:        if ((level.time - self->monsterinfo.trail_time) < reaction_time)
        !           328:                return;
        !           329: 
        !           330:        self->monsterinfo.attack_finished = level.time + reaction_time + 1.0;
        !           331:        //FIXME how do we really want to pass this along?
        !           332:        self->target_ent->spawnflags |= 65536;
        !           333: }
        !           334: 
        !           335: void turret_driver_link (edict_t *self)
        !           336: {
        !           337:        vec3_t  vec;
        !           338:        edict_t *ent;
        !           339: 
        !           340:        self->think = turret_driver_think;
        !           341:        self->nextthink = level.time + FRAMETIME;
        !           342: 
        !           343:        self->target_ent = G_PickTarget (self->target);
        !           344:        self->target_ent->owner = self;
        !           345:        self->target_ent->teammaster->owner = self;
        !           346:        VectorCopy (self->target_ent->s.angles, self->s.angles);
        !           347: 
        !           348:        vec[0] = self->target_ent->s.origin[0] - self->s.origin[0];
        !           349:        vec[1] = self->target_ent->s.origin[1] - self->s.origin[1];
        !           350:        vec[2] = 0;
        !           351:        self->move_origin[0] = VectorLength(vec);
        !           352: 
        !           353:        VectorSubtract (self->s.origin, self->target_ent->s.origin, vec);
        !           354:        vectoangles (vec, vec);
        !           355:        AnglesNormalize(vec);
        !           356:        self->move_origin[1] = vec[1];
        !           357: 
        !           358:        self->move_origin[2] = self->s.origin[2] - self->target_ent->s.origin[2];
        !           359: 
        !           360:        // add the driver to the end of them team chain
        !           361:        for (ent = self->target_ent->teammaster; ent->teamchain; ent = ent->teamchain)
        !           362:                ;
        !           363:        ent->teamchain = self;
        !           364:        self->teammaster = self->target_ent->teammaster;
        !           365:        self->flags |= FL_TEAMSLAVE;
        !           366: }
        !           367: 
        !           368: void SP_turret_driver (edict_t *self)
        !           369: {
        !           370:        if (deathmatch->value)
        !           371:        {
        !           372:                G_FreeEdict (self);
        !           373:                return;
        !           374:        }
        !           375: 
        !           376:        self->movetype = MOVETYPE_PUSH;
        !           377:        self->solid = SOLID_BBOX;
        !           378:        self->s.modelindex = gi.modelindex("models/monsters/infantry/tris.md2");
        !           379:        VectorSet (self->mins, -16, -16, -24);
        !           380:        VectorSet (self->maxs, 16, 16, 32);
        !           381: 
        !           382:        self->health = 100;
        !           383:        self->gib_health = 0;
        !           384:        self->mass = 200;
        !           385:        self->viewheight = 24;
        !           386: 
        !           387:        self->die = turret_driver_die;
        !           388:        self->monsterinfo.stand = infantry_stand;
        !           389: 
        !           390:        self->flags |= FL_NO_KNOCKBACK;
        !           391: 
        !           392:        level.total_monsters++;
        !           393: 
        !           394:        self->svflags |= SVF_MONSTER;
        !           395:        self->s.renderfx |= RF_FRAMELERP;
        !           396:        self->takedamage = DAMAGE_AIM;
        !           397:        self->use = monster_use;
        !           398:        self->clipmask = MASK_MONSTERSOLID;
        !           399:        VectorCopy (self->s.origin, self->s.old_origin);
        !           400:        self->monsterinfo.aiflags |= AI_STAND_GROUND|AI_DUCKED;
        !           401: 
        !           402:        if (st.item)
        !           403:        {
        !           404:                self->item = FindItemByClassname (st.item);
        !           405:                if (!self->item)
        !           406:                        gi.dprintf("%s at %s has bad item: %s\n", self->classname, vtos(self->s.origin), st.item);
        !           407:        }
        !           408: 
        !           409:        self->think = turret_driver_link;
        !           410:        self->nextthink = level.time + FRAMETIME;
        !           411: 
        !           412:        gi.linkentity (self);
        !           413: }

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