![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_turret.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / rogue|
Return to g_turret.c CVS log | Up to [Quake II] / quake2 / rogue |
1.1 root 1: // g_turret.c
2:
3: #include "g_local.h"
4:
5: void SpawnTargetingSystem (edict_t *turret); // PGM
6:
7: void AnglesNormalize(vec3_t vec)
8: {
9: while(vec[0] > 360)
10: vec[0] -= 360;
11: while(vec[0] < 0)
12: vec[0] += 360;
13: while(vec[1] > 360)
14: vec[1] -= 360;
15: while(vec[1] < 0)
16: vec[1] += 360;
17: }
18:
19: float SnapToEights(float x)
20: {
21: x *= 8.0;
22: if (x > 0.0)
23: x += 0.5;
24: else
25: x -= 0.5;
26: return 0.125 * (int)x;
27: }
28:
29:
30: void turret_blocked(edict_t *self, edict_t *other)
31: {
32: edict_t *attacker;
33:
34: if (other->takedamage)
35: {
36: if (self->teammaster->owner)
37: attacker = self->teammaster->owner;
38: else
39: attacker = self->teammaster;
40: T_Damage (other, self, attacker, vec3_origin, other->s.origin, vec3_origin, self->teammaster->dmg, 10, 0, MOD_CRUSH);
41: }
42: }
43:
44: /*QUAKED turret_breach (0 0 0) ?
45: This portion of the turret can change both pitch and yaw.
46: The model should be made with a flat pitch.
47: It (and the associated base) need to be oriented towards 0.
48: Use "angle" to set the starting angle.
49:
50: "speed" default 50
51: "dmg" default 10
52: "angle" point this forward
53: "target" point this at an info_notnull at the muzzle tip
54: "minpitch" min acceptable pitch angle : default -30
55: "maxpitch" max acceptable pitch angle : default 30
56: "minyaw" min acceptable yaw angle : default 0
57: "maxyaw" max acceptable yaw angle : default 360
58: */
59:
60: void turret_breach_fire (edict_t *self)
61: {
62: vec3_t f, r, u;
63: vec3_t start;
64: int damage;
65: int speed;
66:
67: AngleVectors (self->s.angles, f, r, u);
68: VectorMA (self->s.origin, self->move_origin[0], f, start);
69: VectorMA (start, self->move_origin[1], r, start);
70: VectorMA (start, self->move_origin[2], u, start);
71:
72: damage = 100 + random() * 50;
73: speed = 550 + 50 * skill->value;
74: fire_rocket (self->teammaster->owner, start, f, damage, speed, 150, damage);
75: gi.positioned_sound (start, self, CHAN_WEAPON, gi.soundindex("weapons/rocklf1a.wav"), 1, ATTN_NORM, 0);
76: }
77:
78: void turret_breach_think (edict_t *self)
79: {
80: edict_t *ent;
81: vec3_t current_angles;
82: vec3_t delta;
83:
84: VectorCopy (self->s.angles, current_angles);
85: AnglesNormalize(current_angles);
86:
87: AnglesNormalize(self->move_angles);
88: if (self->move_angles[PITCH] > 180)
89: self->move_angles[PITCH] -= 360;
90:
91: // clamp angles to mins & maxs
92: if (self->move_angles[PITCH] > self->pos1[PITCH])
93: self->move_angles[PITCH] = self->pos1[PITCH];
94: else if (self->move_angles[PITCH] < self->pos2[PITCH])
95: self->move_angles[PITCH] = self->pos2[PITCH];
96:
97: if ((self->move_angles[YAW] < self->pos1[YAW]) || (self->move_angles[YAW] > self->pos2[YAW]))
98: {
99: float dmin, dmax;
100:
101: dmin = fabs(self->pos1[YAW] - self->move_angles[YAW]);
102: if (dmin < -180)
103: dmin += 360;
104: else if (dmin > 180)
105: dmin -= 360;
106: dmax = fabs(self->pos2[YAW] - self->move_angles[YAW]);
107: if (dmax < -180)
108: dmax += 360;
109: else if (dmax > 180)
110: dmax -= 360;
111: if (fabs(dmin) < fabs(dmax))
112: self->move_angles[YAW] = self->pos1[YAW];
113: else
114: self->move_angles[YAW] = self->pos2[YAW];
115: }
116:
117: VectorSubtract (self->move_angles, current_angles, delta);
118: if (delta[0] < -180)
119: delta[0] += 360;
120: else if (delta[0] > 180)
121: delta[0] -= 360;
122: if (delta[1] < -180)
123: delta[1] += 360;
124: else if (delta[1] > 180)
125: delta[1] -= 360;
126: delta[2] = 0;
127:
128: if (delta[0] > self->speed * FRAMETIME)
129: delta[0] = self->speed * FRAMETIME;
130: if (delta[0] < -1 * self->speed * FRAMETIME)
131: delta[0] = -1 * self->speed * FRAMETIME;
132: if (delta[1] > self->speed * FRAMETIME)
133: delta[1] = self->speed * FRAMETIME;
134: if (delta[1] < -1 * self->speed * FRAMETIME)
135: delta[1] = -1 * self->speed * FRAMETIME;
136:
137: VectorScale (delta, 1.0/FRAMETIME, self->avelocity);
138:
139: self->nextthink = level.time + FRAMETIME;
140:
141: for (ent = self->teammaster; ent; ent = ent->teamchain)
142: ent->avelocity[1] = self->avelocity[1];
143:
144: // if we have adriver, adjust his velocities
145: if (self->owner)
146: {
147: float angle;
148: float target_z;
149: float diff;
150: vec3_t target;
151: vec3_t dir;
152:
153: // angular is easy, just copy ours
154: self->owner->avelocity[0] = self->avelocity[0];
155: self->owner->avelocity[1] = self->avelocity[1];
156:
157: // x & y
158: angle = self->s.angles[1] + self->owner->move_origin[1];
159: angle *= (M_PI*2 / 360);
160: target[0] = SnapToEights(self->s.origin[0] + cos(angle) * self->owner->move_origin[0]);
161: target[1] = SnapToEights(self->s.origin[1] + sin(angle) * self->owner->move_origin[0]);
162: target[2] = self->owner->s.origin[2];
163:
164: VectorSubtract (target, self->owner->s.origin, dir);
165: self->owner->velocity[0] = dir[0] * 1.0 / FRAMETIME;
166: self->owner->velocity[1] = dir[1] * 1.0 / FRAMETIME;
167:
168: // z
169: angle = self->s.angles[PITCH] * (M_PI*2 / 360);
170: target_z = SnapToEights(self->s.origin[2] + self->owner->move_origin[0] * tan(angle) + self->owner->move_origin[2]);
171:
172: diff = target_z - self->owner->s.origin[2];
173: self->owner->velocity[2] = diff * 1.0 / FRAMETIME;
174:
175: if (self->spawnflags & 65536)
176: {
177: turret_breach_fire (self);
178: self->spawnflags &= ~65536;
179: }
180: }
181: }
182:
183: void turret_breach_finish_init (edict_t *self)
184: {
185: // get and save info for muzzle location
186: if (!self->target)
187: {
188: gi.dprintf("%s at %s needs a target\n", self->classname, vtos(self->s.origin));
189: }
190: else
191: {
192: self->target_ent = G_PickTarget (self->target);
193: if(self->target_ent)
194: {
195: VectorSubtract (self->target_ent->s.origin, self->s.origin, self->move_origin);
196: G_FreeEdict(self->target_ent);
197: }
198: else
199: gi.dprintf("could not find target entity for %s at %s\n", self->classname, vtos(self->s.origin));
200: }
201:
202: self->teammaster->dmg = self->dmg;
203: self->think = turret_breach_think;
204: self->think (self);
205: }
206:
207: void SP_turret_breach (edict_t *self)
208: {
209: self->solid = SOLID_BSP;
210: self->movetype = MOVETYPE_PUSH;
211: gi.setmodel (self, self->model);
212:
213: if (!self->speed)
214: self->speed = 50;
215: if (!self->dmg)
216: self->dmg = 10;
217:
218: if (!st.minpitch)
219: st.minpitch = -30;
220: if (!st.maxpitch)
221: st.maxpitch = 30;
222: if (!st.maxyaw)
223: st.maxyaw = 360;
224:
225: self->pos1[PITCH] = -1 * st.minpitch;
226: self->pos1[YAW] = st.minyaw;
227: self->pos2[PITCH] = -1 * st.maxpitch;
228: self->pos2[YAW] = st.maxyaw;
229:
230: self->ideal_yaw = self->s.angles[YAW];
231: self->move_angles[YAW] = self->ideal_yaw;
232:
233: self->blocked = turret_blocked;
234:
235: self->think = turret_breach_finish_init;
236: self->nextthink = level.time + FRAMETIME;
237: gi.linkentity (self);
238: }
239:
240:
241: /*QUAKED turret_base (0 0 0) ?
242: This portion of the turret changes yaw only.
243: MUST be teamed with a turret_breach.
244: */
245:
246: void SP_turret_base (edict_t *self)
247: {
248: self->solid = SOLID_BSP;
249: self->movetype = MOVETYPE_PUSH;
250: gi.setmodel (self, self->model);
251: self->blocked = turret_blocked;
252: gi.linkentity (self);
253: }
254:
255:
256: /*QUAKED turret_driver (1 .5 0) (-16 -16 -24) (16 16 32)
257: Must NOT be on the team with the rest of the turret parts.
258: Instead it must target the turret_breach.
259: */
260:
261: void infantry_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage);
262: void infantry_stand (edict_t *self);
263: void monster_use (edict_t *self, edict_t *other, edict_t *activator);
264:
265: void turret_driver_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
266: {
267: edict_t *ent;
268:
269: // level the gun
270: self->target_ent->move_angles[0] = 0;
271:
272: // remove the driver from the end of them team chain
273: for (ent = self->target_ent->teammaster; ent->teamchain != self; ent = ent->teamchain)
274: ;
275: ent->teamchain = NULL;
276: self->teammaster = NULL;
277: self->flags &= ~FL_TEAMSLAVE;
278:
279: self->target_ent->owner = NULL;
280: self->target_ent->teammaster->owner = NULL;
281:
282: infantry_die (self, inflictor, attacker, damage);
283: }
284:
285: qboolean FindTarget (edict_t *self);
286:
287: void turret_driver_think (edict_t *self)
288: {
289: vec3_t target;
290: vec3_t dir;
291: float reaction_time;
292:
293: self->nextthink = level.time + FRAMETIME;
294:
295: if (self->enemy && (!self->enemy->inuse || self->enemy->health <= 0))
296: self->enemy = NULL;
297:
298: if (!self->enemy)
299: {
300: if (!FindTarget (self))
301: return;
302: self->monsterinfo.trail_time = level.time;
303: self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
304: }
305: else
306: {
307: if (visible (self, self->enemy))
308: {
309: if (self->monsterinfo.aiflags & AI_LOST_SIGHT)
310: {
311: self->monsterinfo.trail_time = level.time;
312: self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
313: }
314: }
315: else
316: {
317: self->monsterinfo.aiflags |= AI_LOST_SIGHT;
318: return;
319: }
320: }
321:
322: // let the turret know where we want it to aim
323: VectorCopy (self->enemy->s.origin, target);
324: target[2] += self->enemy->viewheight;
325: VectorSubtract (target, self->target_ent->s.origin, dir);
326: vectoangles (dir, self->target_ent->move_angles);
327:
328: // decide if we should shoot
329: if (level.time < self->monsterinfo.attack_finished)
330: return;
331:
332: reaction_time = (3 - skill->value) * 1.0;
333: if ((level.time - self->monsterinfo.trail_time) < reaction_time)
334: return;
335:
336: self->monsterinfo.attack_finished = level.time + reaction_time + 1.0;
337: //FIXME how do we really want to pass this along?
338: self->target_ent->spawnflags |= 65536;
339: }
340:
341: void turret_driver_link (edict_t *self)
342: {
343: vec3_t vec;
344: edict_t *ent;
345:
346: self->think = turret_driver_think;
347: self->nextthink = level.time + FRAMETIME;
348:
349: self->target_ent = G_PickTarget (self->target);
350: self->target_ent->owner = self;
351: self->target_ent->teammaster->owner = self;
352: VectorCopy (self->target_ent->s.angles, self->s.angles);
353:
354: vec[0] = self->target_ent->s.origin[0] - self->s.origin[0];
355: vec[1] = self->target_ent->s.origin[1] - self->s.origin[1];
356: vec[2] = 0;
357: self->move_origin[0] = VectorLength(vec);
358:
359: VectorSubtract (self->s.origin, self->target_ent->s.origin, vec);
360: vectoangles (vec, vec);
361: AnglesNormalize(vec);
362: self->move_origin[1] = vec[1];
363:
364: self->move_origin[2] = self->s.origin[2] - self->target_ent->s.origin[2];
365:
366: // add the driver to the end of them team chain
367: for (ent = self->target_ent->teammaster; ent->teamchain; ent = ent->teamchain)
368: ;
369: ent->teamchain = self;
370: self->teammaster = self->target_ent->teammaster;
371: self->flags |= FL_TEAMSLAVE;
372: }
373:
374: void SP_turret_driver (edict_t *self)
375: {
376: if (deathmatch->value)
377: {
378: G_FreeEdict (self);
379: return;
380: }
381:
382: self->movetype = MOVETYPE_PUSH;
383: self->solid = SOLID_BBOX;
384: self->s.modelindex = gi.modelindex("models/monsters/infantry/tris.md2");
385: VectorSet (self->mins, -16, -16, -24);
386: VectorSet (self->maxs, 16, 16, 32);
387:
388: self->health = 100;
389: self->gib_health = 0;
390: self->mass = 200;
391: self->viewheight = 24;
392:
393: self->die = turret_driver_die;
394: self->monsterinfo.stand = infantry_stand;
395:
396: self->flags |= FL_NO_KNOCKBACK;
397:
398: level.total_monsters++;
399:
400: self->svflags |= SVF_MONSTER;
401: self->s.renderfx |= RF_FRAMELERP;
402: self->takedamage = DAMAGE_AIM;
403: self->use = monster_use;
404: self->clipmask = MASK_MONSTERSOLID;
405: VectorCopy (self->s.origin, self->s.old_origin);
406: self->monsterinfo.aiflags |= AI_STAND_GROUND|AI_DUCKED;
407:
408: if (st.item)
409: {
410: self->item = FindItemByClassname (st.item);
411: if (!self->item)
412: gi.dprintf("%s at %s has bad item: %s\n", self->classname, vtos(self->s.origin), st.item);
413: }
414:
415: self->think = turret_driver_link;
416: self->nextthink = level.time + FRAMETIME;
417:
418: gi.linkentity (self);
419: }
420:
421: //============
422: // ROGUE
423:
424: // invisible turret drivers so we can have unmanned turrets.
425: // originally designed to shoot at func_trains and such, so they
426: // fire at the center of the bounding box, rather than the entity's
427: // origin.
428:
429: void turret_brain_think (edict_t *self)
430: {
431: vec3_t target;
432: vec3_t dir;
433: vec3_t endpos;
434: float reaction_time;
435: trace_t trace;
436:
437: self->nextthink = level.time + FRAMETIME;
438:
439: if (self->enemy)
440: {
441: if(!self->enemy->inuse)
442: self->enemy = NULL;
443: else if(self->enemy->takedamage && self->enemy->health <= 0)
444: self->enemy = NULL;
445: }
446:
447: if (!self->enemy)
448: {
449: if (!FindTarget (self))
450: return;
451: self->monsterinfo.trail_time = level.time;
452: self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
453: }
454: else
455: {
456: VectorAdd (self->enemy->absmax, self->enemy->absmin, endpos);
457: VectorScale (endpos, 0.5, endpos);
458:
459: trace = gi.trace (self->target_ent->s.origin, vec3_origin, vec3_origin, endpos, self->target_ent, MASK_SHOT);
460: if(trace.fraction == 1 || trace.ent == self->enemy)
461: {
462: if (self->monsterinfo.aiflags & AI_LOST_SIGHT)
463: {
464: self->monsterinfo.trail_time = level.time;
465: self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
466: }
467: }
468: else
469: {
470: self->monsterinfo.aiflags |= AI_LOST_SIGHT;
471: return;
472: }
473: }
474:
475: // let the turret know where we want it to aim
476: VectorCopy (endpos, target);
477: VectorSubtract (target, self->target_ent->s.origin, dir);
478: vectoangles (dir, self->target_ent->move_angles);
479:
480: // decide if we should shoot
481: if (level.time < self->monsterinfo.attack_finished)
482: return;
483:
484: if(self->delay)
485: reaction_time = self->delay;
486: else
487: reaction_time = (3 - skill->value) * 1.0;
488: if ((level.time - self->monsterinfo.trail_time) < reaction_time)
489: return;
490:
491: self->monsterinfo.attack_finished = level.time + reaction_time + 1.0;
492: //FIXME how do we really want to pass this along?
493: self->target_ent->spawnflags |= 65536;
494: }
495:
496: // =================
497: // =================
498: void turret_brain_link (edict_t *self)
499: {
500: vec3_t vec;
501: edict_t *ent;
502:
503: if (self->killtarget)
504: {
505: self->enemy = G_PickTarget (self->killtarget);
506: }
507:
508: self->think = turret_brain_think;
509: self->nextthink = level.time + FRAMETIME;
510:
511: self->target_ent = G_PickTarget (self->target);
512: self->target_ent->owner = self;
513: self->target_ent->teammaster->owner = self;
514: VectorCopy (self->target_ent->s.angles, self->s.angles);
515:
516: vec[0] = self->target_ent->s.origin[0] - self->s.origin[0];
517: vec[1] = self->target_ent->s.origin[1] - self->s.origin[1];
518: vec[2] = 0;
519: self->move_origin[0] = VectorLength(vec);
520:
521: VectorSubtract (self->s.origin, self->target_ent->s.origin, vec);
522: vectoangles (vec, vec);
523: AnglesNormalize(vec);
524: self->move_origin[1] = vec[1];
525:
526: self->move_origin[2] = self->s.origin[2] - self->target_ent->s.origin[2];
527:
528: // add the driver to the end of them team chain
529: for (ent = self->target_ent->teammaster; ent->teamchain; ent = ent->teamchain)
530: ;
531: ent->teamchain = self;
532: self->teammaster = self->target_ent->teammaster;
533: self->flags |= FL_TEAMSLAVE;
534: }
535:
536: // =================
537: // =================
538: void turret_brain_deactivate (edict_t *self, edict_t *other, edict_t *activator)
539: {
540: self->think = NULL;
541: self->nextthink = 0;
542: }
543:
544: // =================
545: // =================
546: void turret_brain_activate (edict_t *self, edict_t *other, edict_t *activator)
547: {
548: if (!self->enemy)
549: {
550: self->enemy = activator;
551: }
552:
553: // wait at least 3 seconds to fire.
554: self->monsterinfo.attack_finished = level.time + 3;
555: self->use = turret_brain_deactivate;
556:
557: self->think = turret_brain_link;
558: self->nextthink = level.time + FRAMETIME;
559: }
560:
561: /*QUAKED turret_invisible_brain (1 .5 0) (-16 -16 -16) (16 16 16)
562: Invisible brain to drive the turret.
563:
564: Does not search for targets. If targeted, can only be turned on once
565: and then off once. After that they are completely disabled.
566:
567: "delay" the delay between firing (default ramps for skill level)
568: "Target" the turret breach
569: "Killtarget" the item you want it to attack.
570: Target the brain if you want it activated later, instead of immediately. It will wait 3 seconds
571: before firing to acquire the target.
572: */
573: void SP_turret_invisible_brain (edict_t *self)
574: {
575: if (!self->killtarget)
576: {
577: gi.dprintf("turret_invisible_brain with no killtarget!\n");
578: G_FreeEdict (self);
579: return;
580: }
581: if (!self->target)
582: {
583: gi.dprintf("turret_invisible_brain with no target!\n");
584: G_FreeEdict (self);
585: return;
586: }
587:
588: if (self->targetname)
589: {
590: self->use = turret_brain_activate;
591: }
592: else
593: {
594: self->think = turret_brain_link;
595: self->nextthink = level.time + FRAMETIME;
596: }
597:
598: self->movetype = MOVETYPE_PUSH;
599: gi.linkentity (self);
600: }
601:
602: // ROGUE
603: //============
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.