![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_newweap.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_newweap.c CVS log | Up to [Quake II] / quake2 / rogue |
1.1 root 1: #include "g_local.h"
2:
3: #define INCLUDE_ETF_RIFLE 1
4: #define INCLUDE_PROX 1
5: //#define INCLUDE_FLAMETHROWER 1
6: //#define INCLUDE_INCENDIARY 1
7: #define INCLUDE_NUKE 1
8: #define INCLUDE_MELEE 1
9: #define INCLUDE_TESLA 1
10: #define INCLUDE_BEAMS 1
11:
12: extern void check_dodge (edict_t *self, vec3_t start, vec3_t dir, int speed);
13: extern void hurt_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf);
14: extern void droptofloor (edict_t *ent);
15: extern void Grenade_Explode (edict_t *ent);
16:
17: extern void drawbbox (edict_t *ent);
18:
19: #ifdef INCLUDE_ETF_RIFLE
20: /*
21: ========================
22: fire_flechette
23: ========================
24: */
25: void flechette_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
26: {
27: vec3_t dir;
28:
29: if (other == self->owner)
30: return;
31:
32: if (surf && (surf->flags & SURF_SKY))
33: {
34: G_FreeEdict (self);
35: return;
36: }
37:
38: if (self->client)
39: PlayerNoise(self->owner, self->s.origin, PNOISE_IMPACT);
40:
41: if (other->takedamage)
42: {
43: //gi.dprintf("t_damage %s\n", other->classname);
44: T_Damage (other, self, self->owner, self->velocity, self->s.origin, plane->normal,
45: self->dmg, self->dmg_radius, DAMAGE_NO_REG_ARMOR, MOD_ETF_RIFLE);
46: }
47: else
48: {
49: if(!plane)
50: VectorClear (dir);
51: else
52: VectorScale (plane->normal, 256, dir);
53: gi.WriteByte (svc_temp_entity);
54: gi.WriteByte (TE_FLECHETTE);
55: gi.WritePosition (self->s.origin);
56: gi.WriteDir (dir);
57: gi.multicast (self->s.origin, MULTICAST_PVS);
58:
59: // T_RadiusDamage(self, self->owner, 24, self, 48, MOD_ETF_RIFLE);
60: }
61:
62: G_FreeEdict (self);
63: }
64:
65: void fire_flechette (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int kick)
66: {
67: edict_t *flechette;
68:
69: VectorNormalize (dir);
70:
71: flechette = G_Spawn();
72: VectorCopy (start, flechette->s.origin);
73: VectorCopy (start, flechette->s.old_origin);
74: vectoangles2 (dir, flechette->s.angles);
75:
76: VectorScale (dir, speed, flechette->velocity);
77: flechette->movetype = MOVETYPE_FLYMISSILE;
78: flechette->clipmask = MASK_SHOT;
79: flechette->solid = SOLID_BBOX;
80: flechette->s.renderfx = RF_FULLBRIGHT;
81: VectorClear (flechette->mins);
82: VectorClear (flechette->maxs);
83:
84: flechette->s.modelindex = gi.modelindex ("models/proj/flechette/tris.md2");
85:
86: // flechette->s.sound = gi.soundindex (""); // FIXME - correct sound!
87: flechette->owner = self;
88: flechette->touch = flechette_touch;
89: flechette->nextthink = level.time + 8000/speed;
90: flechette->think = G_FreeEdict;
91: flechette->dmg = damage;
92: flechette->dmg_radius = kick;
93:
94: gi.linkentity (flechette);
95:
96: if (self->client)
97: check_dodge (self, flechette->s.origin, dir, speed);
98: }
99: #endif
100:
101: // **************************
102: // PROX
103: // **************************
104:
105: #ifdef INCLUDE_PROX
106: #define PROX_TIME_TO_LIVE 45 // 45, 30, 15, 10
107: #define PROX_TIME_DELAY 0.5
108: #define PROX_BOUND_SIZE 96
109: #define PROX_DAMAGE_RADIUS 192
110: #define PROX_HEALTH 20
111: #define PROX_DAMAGE 90
112:
113: //===============
114: //===============
115: void Prox_Explode (edict_t *ent)
116: {
117: vec3_t origin;
118: edict_t *owner;
119:
120: // free the trigger field
121:
122: //PMM - changed teammaster to "mover" .. owner of the field is the prox
123: if(ent->teamchain && ent->teamchain->owner == ent)
124: G_FreeEdict(ent->teamchain);
125:
126: owner = ent;
127: if(ent->teammaster)
128: {
129: owner = ent->teammaster;
130: PlayerNoise(owner, ent->s.origin, PNOISE_IMPACT);
131: }
132:
133: // play quad sound if appopriate
134: if (ent->dmg > PROX_DAMAGE)
135: gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage3.wav"), 1, ATTN_NORM, 0);
136:
137: ent->takedamage = DAMAGE_NO;
138: T_RadiusDamage(ent, owner, ent->dmg, ent, PROX_DAMAGE_RADIUS, MOD_PROX);
139:
140: VectorMA (ent->s.origin, -0.02, ent->velocity, origin);
141: gi.WriteByte (svc_temp_entity);
142: if (ent->groundentity)
143: gi.WriteByte (TE_GRENADE_EXPLOSION);
144: else
145: gi.WriteByte (TE_ROCKET_EXPLOSION);
146: gi.WritePosition (origin);
147: gi.multicast (ent->s.origin, MULTICAST_PVS);
148:
149: G_FreeEdict (ent);
150: }
151:
152: //===============
153: //===============
154: void prox_die(edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
155: {
156: // gi.dprintf("prox_die\n");
157: // if set off by another prox, delay a little (chained explosions)
158: if (strcmp(inflictor->classname, "prox"))
159: {
160: self->takedamage = DAMAGE_NO;
161: Prox_Explode(self);
162: }
163: else
164: {
165: self->takedamage = DAMAGE_NO;
166: self->think = Prox_Explode;
167: self->nextthink = level.time + FRAMETIME;
168: }
169: }
170:
171: //===============
172: //===============
173: void Prox_Field_Touch (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
174: {
175: edict_t *prox;
176:
177: if (!(other->svflags & SVF_MONSTER) && !other->client)
178: return;
179:
180: // trigger the prox mine if it's still there, and still mine.
181: prox = ent->owner;
182:
183: if (other == prox) // don't set self off
184: return;
185:
186: if (prox->think == Prox_Explode) // we're set to blow!
187: {
188: // if ((g_showlogic) && (g_showlogic->value))
189: // gi.dprintf ("%f - prox already gone off!\n", level.time);
190: return;
191: }
192:
193: if(prox->teamchain == ent)
194: {
195: gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/proxwarn.wav"), 1, ATTN_NORM, 0);
196: prox->think = Prox_Explode;
197: prox->nextthink = level.time + PROX_TIME_DELAY;
198: return;
199: }
200:
201: ent->solid = SOLID_NOT;
202: G_FreeEdict(ent);
203: }
204:
205: //===============
206: //===============
207: void prox_seek (edict_t *ent)
208: {
209: if(level.time > ent->wait)
210: {
211: Prox_Explode(ent);
212: }
213: else
214: {
215: ent->s.frame++;
216: if(ent->s.frame > 13)
217: ent->s.frame = 9;
218: ent->think = prox_seek;
219: ent->nextthink = level.time + 0.1;
220: }
221: }
222:
223: //===============
224: //===============
225: void prox_open (edict_t *ent)
226: {
227: edict_t *search;
228:
229: search = NULL;
230: // gi.dprintf("prox_open %d\n", ent->s.frame);
231: // gi.dprintf("%f\n", ent->velocity[2]);
232: if(ent->s.frame == 9) // end of opening animation
233: {
234: // set the owner to NULL so the owner can shoot it, etc. needs to be done here so the owner
235: // doesn't get stuck on it while it's opening if fired at point blank wall
236: ent->owner = NULL;
237: if(ent->teamchain)
238: ent->teamchain->touch = Prox_Field_Touch;
239: while ((search = findradius(search, ent->s.origin, PROX_DAMAGE_RADIUS+10)) != NULL)
240: {
241: if (!search->classname) // tag token and other weird shit
242: continue;
243:
244: // if (!search->takedamage)
245: // continue;
246: // if it's a monster or player with health > 0
247: // or it's a player start point
248: // and we can see it
249: // blow up
250: if (
251: (
252: (((search->svflags & SVF_MONSTER) || (search->client)) && (search->health > 0)) ||
253: (
254: (deathmatch->value) &&
255: (
256: (!strcmp(search->classname, "info_player_deathmatch")) ||
257: (!strcmp(search->classname, "info_player_start")) ||
258: (!strcmp(search->classname, "info_player_coop"))
259: )
260: )
261: )
262: && (visible (search, ent))
263: )
264: {
265: gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/proxwarn.wav"), 1, ATTN_NORM, 0);
266: Prox_Explode (ent);
267: return;
268: }
269: }
270:
271: switch (ent->dmg/PROX_DAMAGE)
272: {
273: case 1:
274: ent->wait = level.time + PROX_TIME_TO_LIVE;
275: break;
276: case 2:
277: ent->wait = level.time + 30;
278: break;
279: case 4:
280: ent->wait = level.time + 15;
281: break;
282: case 8:
283: ent->wait = level.time + 10;
284: break;
285: default:
286: if ((g_showlogic) && (g_showlogic->value))
287: gi.dprintf ("prox with unknown multiplier %d!\n", ent->dmg/PROX_DAMAGE);
288: ent->wait = level.time + PROX_TIME_TO_LIVE;
289: break;
290: }
291:
292: // ent->wait = level.time + PROX_TIME_TO_LIVE;
293: ent->think = prox_seek;
294: ent->nextthink = level.time + 0.2;
295: }
296: else
297: {
298: ent->s.frame++;
299: ent->think = prox_open;
300: ent->nextthink = level.time + 0.05;
301: }
302: }
303:
304: //===============
305: //===============
306: void prox_land (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
307: {
308: edict_t *field;
309: vec3_t dir;
310: vec3_t forward, right, up;
311: int makeslave = 0;
312: int movetype = MOVETYPE_NONE;
313: int stick_ok = 0;
314: vec3_t land_point;
315:
316: // must turn off owner so owner can shoot it and set it off
317: // moved to prox_open so owner can get away from it if fired at pointblank range into
318: // wall
319: // ent->owner = NULL;
320:
321: // if ((g_showlogic) && (g_showlogic->value))
322: // gi.dprintf ("land - %2.2f %2.2f %2.2f\n", ent->velocity[0], ent->velocity[1], ent->velocity[2]);
323:
324: if (surf && (surf->flags & SURF_SKY))
325: {
326: G_FreeEdict(ent);
327: return;
328: }
329:
330: if (plane->normal)
331: {
332: VectorMA (ent->s.origin, -10.0, plane->normal, land_point);
333: if (gi.pointcontents (land_point) & (CONTENTS_SLIME|CONTENTS_LAVA))
334: {
335: Prox_Explode (ent);
336: return;
337: }
338: }
339:
340: if ((other->svflags & SVF_MONSTER) || other->client || (other->svflags & SVF_DAMAGEABLE))
341: {
342: if(other != ent->teammaster)
343: Prox_Explode(ent);
344:
345: return;
346: }
347:
348: #define STOP_EPSILON 0.1
349:
350: else if (other != world)
351: {
352: //Here we need to check to see if we can stop on this entity.
353: //Note that plane can be NULL
354:
355: //PMM - code stolen from g_phys (ClipVelocity)
356: vec3_t out;
357: float backoff, change;
358: int i;
359:
360: if (!plane->normal) // this happens if you hit a point object, maybe other cases
361: {
362: // Since we can't tell what's going to happen, just blow up
363: if ((g_showlogic) && (g_showlogic->value))
364: gi.dprintf ("bad normal for surface, exploding!\n");
365:
366: Prox_Explode(ent);
367: return;
368: }
369:
370: if ((other->movetype == MOVETYPE_PUSH) && (plane->normal[2] > 0.7))
371: stick_ok = 1;
372: else
373: stick_ok = 0;
374:
375: backoff = DotProduct (ent->velocity, plane->normal) * 1.5;
376: for (i=0 ; i<3 ; i++)
377: {
378: change = plane->normal[i]*backoff;
379: out[i] = ent->velocity[i] - change;
380: if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
381: out[i] = 0;
382: }
383:
384: if (out[2] > 60)
385: return;
386:
387: movetype = MOVETYPE_BOUNCE;
388:
389: // if we're here, we're going to stop on an entity
390: if (stick_ok)
391: { // it's a happy entity
392: VectorCopy (vec3_origin, ent->velocity);
393: VectorCopy (vec3_origin, ent->avelocity);
394: }
395: else // no-stick. teflon time
396: {
397: if (plane->normal[2] > 0.7)
398: {
399: if ((g_showlogic) && (g_showlogic->value))
400: gi.dprintf ("stuck on entity, blowing up!\n");
401:
402: Prox_Explode(ent);
403: return;
404: }
405: return;
406: }
407: }
408: else if (other->s.modelindex != 1)
409: return;
410:
411: vectoangles2 (plane->normal, dir);
412: AngleVectors (dir, forward, right, up);
413:
414: if (gi.pointcontents (ent->s.origin) & (CONTENTS_LAVA|CONTENTS_SLIME))
415: {
416: Prox_Explode (ent);
417: return;
418: }
419:
420: field = G_Spawn();
421:
422: VectorCopy (ent->s.origin, field->s.origin);
423: VectorClear(field->velocity);
424: VectorClear(field->avelocity);
425: VectorSet(field->mins, -PROX_BOUND_SIZE, -PROX_BOUND_SIZE, -PROX_BOUND_SIZE);
426: VectorSet(field->maxs, PROX_BOUND_SIZE, PROX_BOUND_SIZE, PROX_BOUND_SIZE);
427: field->movetype = MOVETYPE_NONE;
428: field->solid = SOLID_TRIGGER;
429: field->owner = ent;
430: field->classname = "prox_field";
431: field->teammaster = ent;
432: gi.linkentity (field);
433:
434: VectorClear(ent->velocity);
435: VectorClear(ent->avelocity);
436: // rotate to vertical
437: dir[PITCH] = dir[PITCH] + 90;
438: VectorCopy (dir, ent->s.angles);
439: ent->takedamage = DAMAGE_AIM;
440: ent->movetype = movetype; // either bounce or none, depending on whether we stuck to something
441: ent->die = prox_die;
442: ent->teamchain = field;
443: ent->health = PROX_HEALTH;
444: ent->nextthink = level.time + 0.05;
445: ent->think = prox_open;
446: ent->touch = NULL;
447: ent->solid = SOLID_BBOX;
448: // record who we're attached to
449: // ent->teammaster = other;
450:
451: gi.linkentity(ent);
452: }
453:
454: //===============
455: //===============
456: void fire_prox (edict_t *self, vec3_t start, vec3_t aimdir, int damage_multiplier, int speed)
457: {
458: edict_t *prox;
459: vec3_t dir;
460: vec3_t forward, right, up;
461:
462: vectoangles2 (aimdir, dir);
463: AngleVectors (dir, forward, right, up);
464:
465: // if ((g_showlogic) && (g_showlogic->value))
466: // gi.dprintf ("start %s aim %s speed %d\n", vtos(start), vtos(aimdir), speed);
467: prox = G_Spawn();
468: VectorCopy (start, prox->s.origin);
469: VectorScale (aimdir, speed, prox->velocity);
470: VectorMA (prox->velocity, 200 + crandom() * 10.0, up, prox->velocity);
471: VectorMA (prox->velocity, crandom() * 10.0, right, prox->velocity);
472: VectorCopy (dir, prox->s.angles);
473: prox->s.angles[PITCH]-=90;
474: prox->movetype = MOVETYPE_BOUNCE;
475: prox->solid = SOLID_BBOX;
476: prox->s.effects |= EF_GRENADE;
477: prox->clipmask = MASK_SHOT|CONTENTS_LAVA|CONTENTS_SLIME;
478: prox->s.renderfx |= RF_IR_VISIBLE;
479: //FIXME - this needs to be bigger. Has other effects, though. Maybe have to change origin to compensate
480: // so it sinks in correctly. Also in lavacheck, might have to up the distance
481: VectorSet (prox->mins, -6, -6, -6);
482: VectorSet (prox->maxs, 6, 6, 6);
483: prox->s.modelindex = gi.modelindex ("models/weapons/g_prox/tris.md2");
484: prox->owner = self;
485: prox->teammaster = self;
486: prox->touch = prox_land;
487: // prox->nextthink = level.time + PROX_TIME_TO_LIVE;
488: prox->think = Prox_Explode;
489: prox->dmg = PROX_DAMAGE*damage_multiplier;
490: prox->classname = "prox";
491: prox->svflags |= SVF_DAMAGEABLE;
492: prox->flags |= FL_MECHANICAL;
493:
494: switch (damage_multiplier)
495: {
496: case 1:
497: prox->nextthink = level.time + PROX_TIME_TO_LIVE;
498: break;
499: case 2:
500: prox->nextthink = level.time + 30;
501: break;
502: case 4:
503: prox->nextthink = level.time + 15;
504: break;
505: case 8:
506: prox->nextthink = level.time + 10;
507: break;
508: default:
509: if ((g_showlogic) && (g_showlogic->value))
510: gi.dprintf ("prox with unknown multiplier %d!\n", damage_multiplier);
511: prox->nextthink = level.time + PROX_TIME_TO_LIVE;
512: break;
513: }
514:
515: gi.linkentity (prox);
516: }
517: #endif
518:
519: // *************************
520: // FLAMETHROWER
521: // *************************
522:
523: #ifdef INCLUDE_FLAMETHROWER
524: #define FLAMETHROWER_RADIUS 8
525:
526: void fire_remove (edict_t *ent)
527: {
528: if(ent == ent->owner->teamchain)
529: ent->owner->teamchain = NULL;
530:
531: G_FreeEdict(ent);
532: }
533:
534: void fire_flame (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed)
535: {
536: edict_t *flame;
537: vec3_t dir;
538: vec3_t forward, right, up;
539:
540: vectoangles2 (aimdir, dir);
541: AngleVectors (dir, forward, right, up);
542:
543: flame = G_Spawn();
544:
545: // the origin is the first control point, put it speed forward.
546: VectorMA(start, speed, forward, flame->s.origin);
547:
548: // record that velocity
549: VectorScale (aimdir, speed, flame->velocity);
550:
551: VectorCopy (dir, flame->s.angles);
552: flame->movetype = MOVETYPE_NONE;
553: flame->solid = SOLID_NOT;
554:
555: VectorSet(flame->mins, -FLAMETHROWER_RADIUS, -FLAMETHROWER_RADIUS, -FLAMETHROWER_RADIUS);
556: VectorSet(flame->maxs, FLAMETHROWER_RADIUS, FLAMETHROWER_RADIUS, FLAMETHROWER_RADIUS);
557:
558: flame->s.sound = gi.soundindex ("weapons/flame.wav");
559: flame->owner = self;
560: flame->dmg = damage;
561: flame->classname = "flame";
562:
563: // clear control points and velocities
564: VectorCopy (flame->s.origin, flame->flameinfo.pos1);
565: VectorCopy (flame->velocity, flame->flameinfo.vel1);
566: VectorCopy (flame->s.origin, flame->flameinfo.pos2);
567: VectorCopy (flame->velocity, flame->flameinfo.vel2);
568: VectorCopy (flame->s.origin, flame->flameinfo.pos3);
569: VectorCopy (flame->velocity, flame->flameinfo.vel3);
570: VectorCopy (flame->s.origin, flame->flameinfo.pos4);
571:
572: // hook flame stream to owner
573: self->teamchain = flame;
574:
575: gi.linkentity (flame);
576: }
577:
578: // fixme - change to use start location, not entity origin
579: void fire_maintain (edict_t *ent, edict_t *flame, vec3_t start, vec3_t aimdir, int damage, int speed)
580: {
581: trace_t tr;
582:
583: // move the control points out the appropriate direction and velocity
584: VectorAdd(flame->flameinfo.pos3, flame->flameinfo.vel3, flame->flameinfo.pos4);
585: VectorAdd(flame->flameinfo.pos2, flame->flameinfo.vel2, flame->flameinfo.pos3);
586: VectorAdd(flame->flameinfo.pos1, flame->flameinfo.vel1, flame->flameinfo.pos2);
587: VectorAdd(flame->s.origin, flame->velocity, flame->flameinfo.pos1);
588:
589: // move the velocities for the control points
590: VectorCopy(flame->flameinfo.vel2, flame->flameinfo.vel3);
591: VectorCopy(flame->flameinfo.vel1, flame->flameinfo.vel2);
592: VectorCopy(flame->velocity, flame->flameinfo.vel1);
593:
594: // set velocity and location for new control point 0.
595: VectorMA(start, speed, aimdir, flame->s.origin);
596: VectorScale(aimdir, speed, flame->velocity);
597:
598: //
599: // does it hit a wall? if so, when?
600: //
601:
602: // player fire point to flame origin.
603: tr = gi.trace(start, flame->mins, flame->maxs,
604: flame->s.origin, flame, MASK_SHOT);
605: if(tr.fraction == 1.0)
606: {
607: // origin to point 1
608: tr = gi.trace(flame->s.origin, flame->mins, flame->maxs,
609: flame->flameinfo.pos1, flame, MASK_SHOT);
610: if(tr.fraction == 1.0)
611: {
612: // point 1 to point 2
613: tr = gi.trace(flame->flameinfo.pos1, flame->mins, flame->maxs,
614: flame->flameinfo.pos2, flame, MASK_SHOT);
615: if(tr.fraction == 1.0)
616: {
617: // point 2 to point 3
618: tr = gi.trace(flame->flameinfo.pos2, flame->mins, flame->maxs,
619: flame->flameinfo.pos3, flame, MASK_SHOT);
620: if(tr.fraction == 1.0)
621: {
622: // point 3 to point 4, point 3 valid
623: tr = gi.trace(flame->flameinfo.pos3, flame->mins, flame->maxs,
624: flame->flameinfo.pos4, flame, MASK_SHOT);
625: if(tr.fraction < 1.0) // point 4 blocked
626: {
627: VectorCopy(tr.endpos, flame->flameinfo.pos4);
628: }
629: }
630: else // point 3 blocked, point 2 valid
631: {
632: VectorCopy(flame->flameinfo.vel2, flame->flameinfo.vel3);
633: VectorCopy(tr.endpos, flame->flameinfo.pos3);
634: VectorCopy(tr.endpos, flame->flameinfo.pos4);
635: }
636: }
637: else // point 2 blocked, point 1 valid
638: {
639: VectorCopy(flame->flameinfo.vel1, flame->flameinfo.vel2);
640: VectorCopy(flame->flameinfo.vel1, flame->flameinfo.vel3);
641: VectorCopy(tr.endpos, flame->flameinfo.pos2);
642: VectorCopy(tr.endpos, flame->flameinfo.pos3);
643: VectorCopy(tr.endpos, flame->flameinfo.pos4);
644: }
645: }
646: else // point 1 blocked, origin valid
647: {
648: VectorCopy(flame->velocity, flame->flameinfo.vel1);
649: VectorCopy(flame->velocity, flame->flameinfo.vel2);
650: VectorCopy(flame->velocity, flame->flameinfo.vel3);
651: VectorCopy(tr.endpos, flame->flameinfo.pos1);
652: VectorCopy(tr.endpos, flame->flameinfo.pos2);
653: VectorCopy(tr.endpos, flame->flameinfo.pos3);
654: VectorCopy(tr.endpos, flame->flameinfo.pos4);
655: }
656: }
657: else // origin blocked!
658: {
659: // gi.dprintf("point 2 blocked\n");
660: VectorCopy(flame->velocity, flame->flameinfo.vel1);
661: VectorCopy(flame->velocity, flame->flameinfo.vel2);
662: VectorCopy(flame->velocity, flame->flameinfo.vel3);
663: VectorCopy(tr.endpos, flame->s.origin);
664: VectorCopy(tr.endpos, flame->flameinfo.pos1);
665: VectorCopy(tr.endpos, flame->flameinfo.pos2);
666: VectorCopy(tr.endpos, flame->flameinfo.pos3);
667: VectorCopy(tr.endpos, flame->flameinfo.pos4);
668: }
669:
670: if(tr.fraction < 1.0 && tr.ent->takedamage)
671: {
672: T_Damage (tr.ent, flame, ent, flame->velocity, tr.endpos, tr.plane.normal,
673: damage, 0, DAMAGE_NO_KNOCKBACK | DAMAGE_ENERGY | DAMAGE_FIRE);
674: }
675:
676: gi.linkentity(flame);
677:
678: gi.WriteByte (svc_temp_entity);
679: gi.WriteByte (TE_FLAME);
680: gi.WriteShort(ent - g_edicts);
681: gi.WriteShort(6);
682: gi.WritePosition (start);
683: gi.WritePosition (flame->s.origin);
684: gi.WritePosition (flame->flameinfo.pos1);
685: gi.WritePosition (flame->flameinfo.pos2);
686: gi.WritePosition (flame->flameinfo.pos3);
687: gi.WritePosition (flame->flameinfo.pos4);
688: gi.multicast (flame->s.origin, MULTICAST_PVS);
689: }
690:
691: /*QUAKED trap_flameshooter (1 0 0) (-8 -8 -8) (8 8 8)
692: */
693: #define FLAMESHOOTER_VELOCITY 50
694: #define FLAMESHOOTER_DAMAGE 20
695: #define FLAMESHOOTER_BURST_VELOCITY 300
696: #define FLAMESHOOTER_BURST_DAMAGE 30
697:
698: //#define FLAMESHOOTER_PUFF 1
699: #define FLAMESHOOTER_STREAM 1
700:
701: void flameshooter_think (edict_t *self)
702: {
703: vec3_t forward, right, up;
704: edict_t *flame;
705:
706: if(self->delay)
707: {
708: if(self->teamchain)
709: fire_remove (self->teamchain);
710: return;
711: }
712:
713: self->s.angles[1] += self->speed;
714: if(self->s.angles[1] > 135 || self->s.angles[1] < 45)
715: self->speed = -self->speed;
716:
717: AngleVectors (self->s.angles, forward, right, up);
718:
719: #ifdef FLAMESHOOTER_STREAM
720: flame = self->teamchain;
721: if(!self->teamchain)
722: fire_flame (self, self->s.origin, forward, FLAMESHOOTER_DAMAGE, FLAMESHOOTER_VELOCITY);
723: else
724: fire_maintain (self, flame, self->s.origin, forward, FLAMESHOOTER_DAMAGE, FLAMESHOOTER_VELOCITY);
725:
726: self->think = flameshooter_think;
727: self->nextthink = level.time + 0.05;
728: #else
729: fire_burst (self, self->s.origin, forward, FLAMESHOOTER_BURST_DAMAGE, FLAMESHOOTER_BURST_VELOCITY);
730:
731: self->think = flameshooter_think;
732: self->nextthink = level.time + 0.1;
733: #endif
734: }
735:
736: void flameshooter_use (edict_t *self, edict_t *other, edict_t *activator)
737: {
738: if(self->delay)
739: {
740: self->delay = 0;
741: self->think = flameshooter_think;
742: self->nextthink = level.time + 0.1;
743: }
744: else
745: self->delay = 1;
746: }
747:
748: void SP_trap_flameshooter(edict_t *self)
749: {
750: vec3_t tempAngles;
751:
752: self->solid = SOLID_NOT;
753: self->movetype = MOVETYPE_NONE;
754:
755: self->delay = 0;
756:
757: self->use = flameshooter_use;
758: if(self->delay == 0)
759: {
760: self->think = flameshooter_think;
761: self->nextthink = level.time + 0.1;
762: }
763:
764: // self->flags |= FL_NOCLIENT;
765:
766: self->speed = 10;
767:
768: // self->speed = 0; // FIXME this stops the spraying
769:
770: VectorCopy(self->s.angles, tempAngles);
771:
772: if (!VectorCompare(self->s.angles, vec3_origin))
773: G_SetMovedir (self->s.angles, self->movedir);
774:
775: VectorCopy(tempAngles, self->s.angles);
776:
777: // gi.setmodel (self, self->model);
778: gi.linkentity (self);
779: }
780:
781: // *************************
782: // fire_burst
783: // *************************
784:
785: #define FLAME_BURST_MAX_SIZE 64
786: #define FLAME_BURST_FRAMES 20
787: #define FLAME_BURST_MIDPOINT 10
788:
789: void fire_burst_touch (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
790: {
791: int powerunits;
792: int damage, radius;
793: vec3_t origin;
794:
795: if (surf && (surf->flags & SURF_SKY))
796: {
797: // gi.dprintf("Hit sky. Removed\n");
798: G_FreeEdict (ent);
799: return;
800: }
801:
802: if(other == ent->owner || ent == other)
803: return;
804:
805: // don't let flame puffs blow each other up
806: if(other->classname && !strcmp(other->classname, ent->classname))
807: return;
808:
809: if(ent->waterlevel)
810: {
811: // gi.dprintf("Hit water. Removed\n");
812: G_FreeEdict(ent);
813: }
814:
815: if(!(other->svflags & SVF_MONSTER) && !other->client)
816: {
817: powerunits = FLAME_BURST_FRAMES - ent->s.frame;
818: damage = powerunits * 6;
819: radius = powerunits * 4;
820:
821: // T_RadiusDamage (inflictor, attacker, damage, ignore, radius)
822: T_RadiusDamage(ent, ent->owner, damage, ent, radius, DAMAGE_FIRE);
823:
824: // gi.dprintf("Hit world: %d pts, %d rad\n", damage, radius);
825:
826: // calculate position for the explosion entity
827: VectorMA (ent->s.origin, -0.02, ent->velocity, origin);
828:
829: gi.WriteByte (svc_temp_entity);
830: gi.WriteByte (TE_PLAIN_EXPLOSION);
831: gi.WritePosition (origin);
832: gi.multicast (ent->s.origin, MULTICAST_PVS);
833:
834: G_FreeEdict (ent);
835: }
836: }
837:
838: void fire_burst_think (edict_t *self)
839: {
840: int current_radius;
841:
842: if(self->waterlevel)
843: {
844: G_FreeEdict(self);
845: return;
846: }
847:
848: self->s.frame++;
849: if(self->s.frame >= FLAME_BURST_FRAMES)
850: {
851: G_FreeEdict(self);
852: return;
853: }
854:
855: else if(self->s.frame < FLAME_BURST_MIDPOINT)
856: {
857: current_radius = (FLAME_BURST_MAX_SIZE / FLAME_BURST_MIDPOINT) * self->s.frame;
858: }
859: else
860: {
861: current_radius = (FLAME_BURST_MAX_SIZE / FLAME_BURST_MIDPOINT) * (FLAME_BURST_FRAMES - self->s.frame);
862: }
863:
864: if(self->s.frame == 3)
865: self->s.skinnum = 1;
866: else if (self->s.frame == 7)
867: self->s.skinnum = 2;
868: else if (self->s.frame == 10)
869: self->s.skinnum = 3;
870: else if (self->s.frame == 13)
871: self->s.skinnum = 4;
872: else if (self->s.frame == 16)
873: self->s.skinnum = 5;
874: else if (self->s.frame == 19)
875: self->s.skinnum = 6;
876:
877: if(current_radius < 8)
878: current_radius = 8;
879: else if(current_radius > FLAME_BURST_MAX_SIZE)
880: current_radius = FLAME_BURST_MAX_SIZE;
881:
882: T_RadiusDamage(self, self->owner, self->dmg, self, current_radius, DAMAGE_FIRE);
883:
884: self->think = fire_burst_think;
885: self->nextthink = level.time + 0.1;
886: }
887:
888: void fire_burst (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed)
889: {
890: edict_t *flame;
891: vec3_t dir;
892: vec3_t baseVel;
893: vec3_t forward, right, up;
894:
895: vectoangles2 (aimdir, dir);
896: AngleVectors (dir, forward, right, up);
897:
898: flame = G_Spawn();
899: VectorCopy(start, flame->s.origin);
900: // VectorScale (aimdir, speed, flame->velocity);
901:
902: // scale down so only 30% of player's velocity is taken into account.
903: VectorScale (self->velocity, 0.3, baseVel);
904: VectorMA(baseVel, speed, aimdir, flame->velocity);
905:
906: VectorCopy (dir, flame->s.angles);
907: flame->movetype = MOVETYPE_FLY;
908: flame->solid = SOLID_TRIGGER;
909:
910: VectorSet(flame->mins, -FLAMETHROWER_RADIUS, -FLAMETHROWER_RADIUS, -FLAMETHROWER_RADIUS);
911: VectorSet(flame->maxs, FLAMETHROWER_RADIUS, FLAMETHROWER_RADIUS, FLAMETHROWER_RADIUS);
912:
913: flame->s.sound = gi.soundindex ("weapons/flame.wav");
914: flame->s.modelindex = gi.modelindex ("models/projectiles/puff/tris.md2");
915: flame->owner = self;
916: flame->touch = fire_burst_touch;
917: flame->think = fire_burst_think;
918: flame->nextthink = level.time + 0.1;
919: flame->dmg = damage;
920: flame->classname = "flameburst";
921: flame->s.effects = EF_FIRE_PUFF;
922:
923: gi.linkentity (flame);
924: }
925: #endif
926:
927: // *************************
928: // INCENDIARY GRENADES
929: // *************************
930:
931: #ifdef INCLUDE_INCENDIARY
932: void FireThink (edict_t *ent)
933: {
934: if(level.time > ent->wait)
935: G_FreeEdict(ent);
936: else
937: {
938: ent->s.frame++;
939: if(ent->s.frame>10)
940: ent->s.frame = 0;
941: ent->nextthink = level.time + 0.05;
942: ent->think = FireThink;
943: }
944: }
945:
946: #define FIRE_HEIGHT 64
947: #define FIRE_RADIUS 64
948: #define FIRE_DAMAGE 3
949: #define FIRE_DURATION 15
950:
951: edict_t *StartFire(edict_t *fireOwner, vec3_t fireOrigin, float fireDuration, float fireDamage)
952: {
953: edict_t *fire;
954:
955: fire = G_Spawn();
956: VectorCopy (fireOrigin, fire->s.origin);
957: fire->movetype = MOVETYPE_TOSS;
958: fire->solid = SOLID_TRIGGER;
959: VectorSet(fire->mins, -FIRE_RADIUS, -FIRE_RADIUS, 0);
960: VectorSet(fire->maxs, FIRE_RADIUS, FIRE_RADIUS, FIRE_HEIGHT);
961:
962: fire->s.sound = gi.soundindex ("weapons/incend.wav");
963: fire->s.modelindex = gi.modelindex ("models/objects/fire/tris.md2");
964:
965: fire->owner = fireOwner;
966: fire->touch = hurt_touch;
967: fire->nextthink = level.time + 0.05;
968: fire->wait = level.time + fireDuration;
969: fire->think = FireThink;
970: // fire->nextthink = level.time + fireDuration;
971: // fire->think = G_FreeEdict;
972: fire->dmg = fireDamage;
973: fire->classname = "incendiary_fire";
974:
975: gi.linkentity (fire);
976:
977: // gi.sound (fire, CHAN_VOICE, gi.soundindex ("weapons/incend.wav"), 1, ATTN_NORM, 0);
978: return fire;
979: }
980:
981: static void Incendiary_Explode (edict_t *ent)
982: {
983: vec3_t origin;
984:
985: if (ent->owner->client)
986: PlayerNoise(ent->owner, ent->s.origin, PNOISE_IMPACT);
987:
988: //FIXME: if we are onground then raise our Z just a bit since we are a point?
989: T_RadiusDamage(ent, ent->owner, ent->dmg, NULL, ent->dmg_radius, DAMAGE_FIRE);
990:
991: VectorMA (ent->s.origin, -0.02, ent->velocity, origin);
992: gi.WriteByte (svc_temp_entity);
993: if (ent->groundentity)
994: gi.WriteByte (TE_GRENADE_EXPLOSION);
995: else
996: gi.WriteByte (TE_ROCKET_EXPLOSION);
997: gi.WritePosition (origin);
998: gi.multicast (ent->s.origin, MULTICAST_PVS);
999:
1000: StartFire(ent->owner, ent->s.origin, FIRE_DURATION, FIRE_DAMAGE);
1001:
1002: G_FreeEdict (ent);
1003:
1004: }
1005:
1006: static void Incendiary_Touch (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
1007: {
1008: if (other == ent->owner)
1009: return;
1010:
1011: if (surf && (surf->flags & SURF_SKY))
1012: {
1013: G_FreeEdict (ent);
1014: return;
1015: }
1016:
1017: if (!(other->svflags & SVF_MONSTER) && !(ent->client))
1018: // if (!other->takedamage)
1019: {
1020: if (ent->spawnflags & 1)
1021: {
1022: if (random() > 0.5)
1023: gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/hgrenb1a.wav"), 1, ATTN_NORM, 0);
1024: else
1025: gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/hgrenb2a.wav"), 1, ATTN_NORM, 0);
1026: }
1027: else
1028: {
1029: if (random() > 0.5)
1030: gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/grenlb1b.wav"), 1, ATTN_NORM, 0);
1031: else
1032: gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/grenlb2b.wav"), 1, ATTN_NORM, 0);
1033: }
1034: return;
1035: }
1036:
1037: Incendiary_Explode (ent);
1038: }
1039:
1040: void fire_incendiary_grenade (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, float timer, float damage_radius)
1041: {
1042: edict_t *grenade;
1043: vec3_t dir;
1044: vec3_t forward, right, up;
1045:
1046: vectoangles2 (aimdir, dir);
1047: AngleVectors (dir, forward, right, up);
1048:
1049: grenade = G_Spawn();
1050: VectorCopy (start, grenade->s.origin);
1051: VectorScale (aimdir, speed, grenade->velocity);
1052: VectorMA (grenade->velocity, 200 + crandom() * 10.0, up, grenade->velocity);
1053: VectorMA (grenade->velocity, crandom() * 10.0, right, grenade->velocity);
1054: VectorSet (grenade->avelocity, 300, 300, 300);
1055: grenade->movetype = MOVETYPE_BOUNCE;
1056: grenade->clipmask = MASK_SHOT;
1057: grenade->solid = SOLID_BBOX;
1058: grenade->s.effects |= EF_GRENADE;
1059: // if (self->client)
1060: // grenade->s.effects &= ~EF_TELEPORT;
1061: VectorClear (grenade->mins);
1062: VectorClear (grenade->maxs);
1063: grenade->s.modelindex = gi.modelindex ("models/projectiles/incend/tris.md2");
1064: grenade->owner = self;
1065: grenade->touch = Incendiary_Touch;
1066: grenade->nextthink = level.time + timer;
1067: grenade->think = Incendiary_Explode;
1068: grenade->dmg = damage;
1069: grenade->dmg_radius = damage_radius;
1070: grenade->classname = "incendiary_grenade";
1071:
1072: gi.linkentity (grenade);
1073: }
1074: #endif
1075:
1076: // *************************
1077: // MELEE WEAPONS
1078: // *************************
1079:
1080: #ifdef INCLUDE_MELEE
1081: void fire_player_melee (edict_t *self, vec3_t start, vec3_t aim, int reach, int damage, int kick, int quiet, int mod)
1082: {
1083: vec3_t forward, right, up;
1084: vec3_t v;
1085: vec3_t point;
1086: trace_t tr;
1087:
1088: vectoangles2 (aim, v);
1089: AngleVectors (v, forward, right, up);
1090: VectorNormalize (forward);
1091: VectorMA( start, reach, forward, point);
1092:
1093: //see if the hit connects
1094: tr = gi.trace(start, NULL, NULL, point, self, MASK_SHOT);
1095: if(tr.fraction == 1.0)
1096: {
1097: if(!quiet)
1098: gi.sound (self, CHAN_WEAPON, gi.soundindex ("weapons/swish.wav"), 1, ATTN_NORM, 0);
1099: //FIXME some sound here?
1100: return;
1101: }
1102:
1103: if(tr.ent->takedamage == DAMAGE_YES || tr.ent->takedamage == DAMAGE_AIM)
1104: {
1105: // pull the player forward if you do damage
1106: VectorMA(self->velocity, 75, forward, self->velocity);
1107: VectorMA(self->velocity, 75, up, self->velocity);
1108:
1109: // do the damage
1110: // FIXME - make the damage appear at right spot and direction
1111: if(mod == MOD_CHAINFIST)
1112: T_Damage (tr.ent, self, self, vec3_origin, tr.ent->s.origin, vec3_origin, damage, kick/2,
1113: DAMAGE_DESTROY_ARMOR | DAMAGE_NO_KNOCKBACK, mod);
1114: else
1115: T_Damage (tr.ent, self, self, vec3_origin, tr.ent->s.origin, vec3_origin, damage, kick/2, DAMAGE_NO_KNOCKBACK, mod);
1116:
1117: if(!quiet)
1118: gi.sound (self, CHAN_WEAPON, gi.soundindex ("weapons/meatht.wav"), 1, ATTN_NORM, 0);
1119: }
1120: else
1121: {
1122: if(!quiet)
1123: gi.sound (self, CHAN_WEAPON, gi.soundindex ("weapons/tink1.wav"), 1, ATTN_NORM, 0);
1124:
1125: VectorScale (tr.plane.normal, 256, point);
1126: gi.WriteByte (svc_temp_entity);
1127: gi.WriteByte (TE_GUNSHOT);
1128: gi.WritePosition (tr.endpos);
1129: gi.WriteDir (point);
1130: gi.multicast (tr.endpos, MULTICAST_PVS);
1131: }
1132: }
1133: #endif
1134:
1135: // *************************
1136: // NUKE
1137: // *************************
1138:
1139: #ifdef INCLUDE_NUKE
1140: #define NUKE_DELAY 4
1141: #define NUKE_TIME_TO_LIVE 6
1142: //#define NUKE_TIME_TO_LIVE 40
1143: #define NUKE_RADIUS 512
1144: #define NUKE_DAMAGE 400
1145: #define NUKE_QUAKE_TIME 3
1146: #define NUKE_QUAKE_STRENGTH 100
1147:
1148: void Nuke_Quake (edict_t *self)
1149: {
1150: int i;
1151: edict_t *e;
1152:
1153: if (self->last_move_time < level.time)
1154: {
1155: gi.positioned_sound (self->s.origin, self, CHAN_AUTO, self->noise_index, 0.75, ATTN_NONE, 0);
1156: self->last_move_time = level.time + 0.5;
1157: }
1158:
1159: for (i=1, e=g_edicts+i; i < globals.num_edicts; i++,e++)
1160: {
1161: if (!e->inuse)
1162: continue;
1163: if (!e->client)
1164: continue;
1165: if (!e->groundentity)
1166: continue;
1167:
1168: e->groundentity = NULL;
1169: e->velocity[0] += crandom()* 150;
1170: e->velocity[1] += crandom()* 150;
1171: e->velocity[2] = self->speed * (100.0 / e->mass);
1172: }
1173:
1174: if (level.time < self->timestamp)
1175: self->nextthink = level.time + FRAMETIME;
1176: else
1177: G_FreeEdict (self);
1178: }
1179:
1180:
1181: static void Nuke_Explode (edict_t *ent)
1182: {
1183: // vec3_t origin;
1184:
1185: // nuke_framenum = level.framenum + 20;
1186:
1187: if (ent->teammaster->client)
1188: PlayerNoise(ent->teammaster, ent->s.origin, PNOISE_IMPACT);
1189:
1190: T_RadiusNukeDamage(ent, ent->teammaster, ent->dmg, ent, ent->dmg_radius, MOD_NUKE);
1191:
1192: // VectorMA (ent->s.origin, -0.02, ent->velocity, origin);
1193: if (ent->dmg > NUKE_DAMAGE)
1194: gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage3.wav"), 1, ATTN_NORM, 0);
1195:
1196: gi.sound (ent, CHAN_NO_PHS_ADD+CHAN_VOICE, gi.soundindex ("weapons/grenlx1a.wav"), 1, ATTN_NONE, 0);
1197: /*
1198: gi.WriteByte (svc_temp_entity);
1199: if (ent->groundentity)
1200: gi.WriteByte (TE_GRENADE_EXPLOSION);
1201: else
1202: gi.WriteByte (TE_ROCKET_EXPLOSION);
1203: gi.WritePosition (origin);
1204: gi.multicast (ent->s.origin, MULTICAST_PVS);
1205: */
1206:
1207: // BecomeExplosion1(ent);
1208:
1209: gi.WriteByte (svc_temp_entity);
1210: gi.WriteByte (TE_EXPLOSION1_BIG);
1211: gi.WritePosition (ent->s.origin);
1212: gi.multicast (ent->s.origin, MULTICAST_PVS);
1213:
1214: gi.WriteByte (svc_temp_entity);
1215: gi.WriteByte (TE_NUKEBLAST);
1216: gi.WritePosition (ent->s.origin);
1217: gi.multicast (ent->s.origin, MULTICAST_ALL);
1218:
1219: // become a quake
1220: ent->svflags |= SVF_NOCLIENT;
1221: ent->noise_index = gi.soundindex ("world/rumble.wav");
1222: ent->think = Nuke_Quake;
1223: ent->speed = NUKE_QUAKE_STRENGTH;
1224: ent->timestamp = level.time + NUKE_QUAKE_TIME;
1225: ent->nextthink = level.time + FRAMETIME;
1226: ent->last_move_time = 0;
1227: }
1228:
1229: void nuke_die(edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
1230: {
1231: self->takedamage = DAMAGE_NO;
1232: if ((attacker) && !(strcmp(attacker->classname, "nuke")))
1233: {
1234: if ((g_showlogic) && (g_showlogic->value))
1235: gi.dprintf ("nuke nuked by a nuke, not nuking\n");
1236: G_FreeEdict (self);
1237: return;
1238: }
1239: Nuke_Explode(self);
1240: }
1241:
1242: void Nuke_Think(edict_t *ent)
1243: {
1244: float attenuation, default_atten = 1.8;
1245: int damage_multiplier, muzzleflash;
1246:
1247: // gi.dprintf ("player range: %2.2f damage radius: %2.2f\n", realrange (ent, ent->teammaster), ent->dmg_radius*2);
1248:
1249: damage_multiplier = ent->dmg/NUKE_DAMAGE;
1250: switch (damage_multiplier)
1251: {
1252: case 1:
1253: attenuation = default_atten/1.4;
1254: muzzleflash = MZ_NUKE1;
1255: break;
1256: case 2:
1257: attenuation = default_atten/2.0;
1258: muzzleflash = MZ_NUKE2;
1259: break;
1260: case 4:
1261: attenuation = default_atten/3.0;
1262: muzzleflash = MZ_NUKE4;
1263: break;
1264: case 8:
1265: attenuation = default_atten/5.0;
1266: muzzleflash = MZ_NUKE8;
1267: break;
1268: default:
1269: if ((g_showlogic) && (g_showlogic->value))
1270: gi.dprintf ("default attenuation used for nuke!\n");
1271: attenuation = default_atten;
1272: muzzleflash = MZ_NUKE1;
1273: break;
1274: }
1275:
1276: if(ent->wait < level.time)
1277: Nuke_Explode(ent);
1278: else if (level.time >= (ent->wait - NUKE_TIME_TO_LIVE))
1279: {
1280: ent->s.frame++;
1281: // if ((g_showlogic) && (g_showlogic->value))
1282: // gi.dprintf ("nuke frame %d\n", ent->s.frame);
1283: if(ent->s.frame > 11)
1284: ent->s.frame = 6;
1285:
1286: if (gi.pointcontents (ent->s.origin) & (CONTENTS_SLIME|CONTENTS_LAVA))
1287: {
1288: Nuke_Explode (ent);
1289: return;
1290: }
1291:
1292: ent->think = Nuke_Think;
1293: ent->nextthink = level.time + 0.1;
1294: ent->health = 1;
1295: ent->owner = NULL;
1296:
1297: gi.WriteByte (svc_muzzleflash);
1298: gi.WriteShort (ent-g_edicts);
1299: gi.WriteByte (muzzleflash);
1300: gi.multicast (ent->s.origin, MULTICAST_PVS);
1301:
1302: if (ent->timestamp <= level.time)
1303: {
1304: /* gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/nukewarn.wav"), 1, ATTN_NORM, 0);
1305: ent->timestamp += 10.0;
1306: }
1307: */
1308:
1309: if ((ent->wait - level.time) <= (NUKE_TIME_TO_LIVE/2.0))
1310: {
1311: // ent->s.sound = gi.soundindex ("weapons/nukewarn.wav");
1312: // gi.sound (ent, CHAN_NO_PHS_ADD+CHAN_VOICE, gi.soundindex ("weapons/nukewarn2.wav"), 1, ATTN_NORM, 0);
1313: gi.sound (ent, CHAN_NO_PHS_ADD+CHAN_VOICE, gi.soundindex ("weapons/nukewarn2.wav"), 1, attenuation, 0);
1314: // gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/nukewarn2.wav"), 1, ATTN_NORM, 0);
1315: // gi.dprintf ("time %2.2f\n", ent->wait-level.time);
1316: ent->timestamp = level.time + 0.3;
1317: }
1318: else
1319: {
1320: gi.sound (ent, CHAN_NO_PHS_ADD+CHAN_VOICE, gi.soundindex ("weapons/nukewarn2.wav"), 1, attenuation, 0);
1321: // gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/nukewarn2.wav"), 1, ATTN_NORM, 0);
1322: ent->timestamp = level.time + 0.5;
1323: // gi.dprintf ("time %2.2f\n", ent->wait-level.time);
1324: }
1325: }
1326: }
1327: else
1328: {
1329: if (ent->timestamp <= level.time)
1330: {
1331: gi.sound (ent, CHAN_NO_PHS_ADD+CHAN_VOICE, gi.soundindex ("weapons/nukewarn2.wav"), 1, attenuation, 0);
1332: // gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/nukewarn2.wav"), 1, ATTN_NORM, 0);
1333: // gi.dprintf ("time %2.2f\n", ent->wait-level.time);
1334: ent->timestamp = level.time + 1.0;
1335: }
1336: ent->nextthink = level.time + FRAMETIME;
1337: }
1338: }
1339:
1340: void nuke_bounce (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
1341: {
1342: if (random() > 0.5)
1343: gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/hgrenb1a.wav"), 1, ATTN_NORM, 0);
1344: else
1345: gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/hgrenb2a.wav"), 1, ATTN_NORM, 0);
1346: }
1347:
1348:
1349: extern byte P_DamageModifier(edict_t *ent);
1350:
1351: void fire_nuke (edict_t *self, vec3_t start, vec3_t aimdir, int speed)
1352: {
1353: edict_t *nuke;
1354: vec3_t dir;
1355: vec3_t forward, right, up;
1356: int damage_modifier;
1357:
1358: damage_modifier = (int) P_DamageModifier (self);
1359:
1360: vectoangles2 (aimdir, dir);
1361: AngleVectors (dir, forward, right, up);
1362:
1363: nuke = G_Spawn();
1364: VectorCopy (start, nuke->s.origin);
1365: VectorScale (aimdir, speed, nuke->velocity);
1366:
1367: VectorMA (nuke->velocity, 200 + crandom() * 10.0, up, nuke->velocity);
1368: VectorMA (nuke->velocity, crandom() * 10.0, right, nuke->velocity);
1369: VectorClear (nuke->avelocity);
1370: VectorClear (nuke->s.angles);
1371: nuke->movetype = MOVETYPE_BOUNCE;
1372: nuke->clipmask = MASK_SHOT;
1373: nuke->solid = SOLID_BBOX;
1374: nuke->s.effects |= EF_GRENADE;
1375: nuke->s.renderfx |= RF_IR_VISIBLE;
1376: VectorSet (nuke->mins, -8, -8, 0);
1377: VectorSet (nuke->maxs, 8, 8, 16);
1378: nuke->s.modelindex = gi.modelindex ("models/weapons/g_nuke/tris.md2");
1379: nuke->owner = self;
1380: nuke->teammaster = self;
1381: nuke->nextthink = level.time + FRAMETIME;
1382: nuke->wait = level.time + NUKE_DELAY + NUKE_TIME_TO_LIVE;
1383: nuke->think = Nuke_Think;
1384: nuke->touch = nuke_bounce;
1385:
1386: nuke->health = 10000;
1387: nuke->takedamage = DAMAGE_YES;
1388: nuke->svflags |= SVF_DAMAGEABLE;
1389: nuke->dmg = NUKE_DAMAGE * damage_modifier;
1390: if (damage_modifier == 1)
1391: nuke->dmg_radius = NUKE_RADIUS;
1392: else
1393: nuke->dmg_radius = NUKE_RADIUS + NUKE_RADIUS*(0.25*(float)damage_modifier);
1394: // this yields 1.0, 1.5, 2.0, 3.0 times radius
1395:
1396: if ((g_showlogic) && (g_showlogic->value))
1397: gi.dprintf ("nuke modifier = %d, damage = %d, radius = %f\n", damage_modifier, nuke->dmg, nuke->dmg_radius);
1398:
1399: nuke->classname = "nuke";
1400: nuke->die = nuke_die;
1401:
1402: gi.linkentity (nuke);
1403: }
1404: #endif
1405:
1406: // *************************
1407: // TESLA
1408: // *************************
1409:
1410: #ifdef INCLUDE_TESLA
1411: #define TESLA_TIME_TO_LIVE 30
1412: #define TESLA_DAMAGE_RADIUS 128
1413: #define TESLA_DAMAGE 3 // 3
1414: #define TESLA_KNOCKBACK 8
1415:
1416: #define TESLA_ACTIVATE_TIME 3
1417:
1418: #define TESLA_EXPLOSION_DAMAGE_MULT 50 // this is the amount the damage is multiplied by for underwater explosions
1419: #define TESLA_EXPLOSION_RADIUS 200
1420:
1421: void tesla_remove (edict_t *self)
1422: {
1423: edict_t *cur, *next;
1424:
1425: self->takedamage = DAMAGE_NO;
1426: if(self->teamchain)
1427: {
1428: cur = self->teamchain;
1429: while(cur)
1430: {
1431: next = cur->teamchain;
1432: G_FreeEdict ( cur );
1433: cur = next;
1434: }
1435: }
1436: else if (self->air_finished)
1437: gi.dprintf ("tesla without a field!\n");
1438:
1439: self->owner = self->teammaster; // Going away, set the owner correctly.
1440: // PGM - grenade explode does damage to self->enemy
1441: self->enemy = NULL;
1442:
1443: // play quad sound if quadded and an underwater explosion
1444: if ((self->dmg_radius) && (self->dmg > (TESLA_DAMAGE*TESLA_EXPLOSION_DAMAGE_MULT)))
1445: gi.sound(self, CHAN_ITEM, gi.soundindex("items/damage3.wav"), 1, ATTN_NORM, 0);
1446:
1447: Grenade_Explode(self);
1448: }
1449:
1450: void tesla_die(edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
1451: {
1452: // gi.dprintf("tesla killed\n");
1453: tesla_remove(self);
1454: }
1455:
1456: void tesla_blow (edict_t *self)
1457: {
1458: // T_RadiusDamage(self, self->owner, TESLA_EXPLOSION_DAMAGE, NULL, TESLA_EXPLOSION_RADIUS, MOD_TESLA);
1459: self->dmg = self->dmg * TESLA_EXPLOSION_DAMAGE_MULT;
1460: self->dmg_radius = TESLA_EXPLOSION_RADIUS;
1461: tesla_remove(self);
1462: }
1463:
1464:
1465: void tesla_zap (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
1466: {
1467: }
1468:
1469: void tesla_think_active (edict_t *self)
1470: {
1471: int i,num;
1472: edict_t *touch[MAX_EDICTS], *hit;
1473: vec3_t dir, start;
1474: trace_t tr;
1475:
1476: if(level.time > self->air_finished)
1477: {
1478: tesla_remove(self);
1479: return;
1480: }
1481:
1482: VectorCopy(self->s.origin, start);
1483: start[2] += 16;
1484:
1485: num = gi.BoxEdicts(self->teamchain->absmin, self->teamchain->absmax, touch, MAX_EDICTS, AREA_SOLID);
1486: for(i=0;i<num;i++)
1487: {
1488: hit=touch[i];
1489: if(!hit->inuse)
1490: continue;
1491: if(hit == self)
1492: continue;
1493: if(hit->health < 1)
1494: continue;
1495: // don't hit clients in single-player or coop
1496: if(hit->client)
1497: if (coop->value || !deathmatch->value)
1498: continue;
1499: if(!(hit->svflags & (SVF_MONSTER | SVF_DAMAGEABLE)) && !hit->client)
1500: continue;
1501:
1502: tr = gi.trace(start, vec3_origin, vec3_origin, hit->s.origin, self, MASK_SHOT);
1503: if(tr.fraction==1 || tr.ent==hit)// || tr.ent->client || (tr.ent->svflags & (SVF_MONSTER | SVF_DAMAGEABLE)))
1504: {
1505: VectorSubtract(hit->s.origin, start, dir);
1506:
1507: // PMM - play quad sound if it's above the "normal" damage
1508: if (self->dmg > TESLA_DAMAGE)
1509: gi.sound(self, CHAN_ITEM, gi.soundindex("items/damage3.wav"), 1, ATTN_NORM, 0);
1510:
1511: // PGM - don't do knockback to walking monsters
1512: if((hit->svflags & SVF_MONSTER) && !(hit->flags & (FL_FLY|FL_SWIM)))
1513: T_Damage (hit, self, self->teammaster, dir, tr.endpos, tr.plane.normal,
1514: self->dmg, 0, 0, MOD_TESLA);
1515: else
1516: T_Damage (hit, self, self->teammaster, dir, tr.endpos, tr.plane.normal,
1517: self->dmg, TESLA_KNOCKBACK, 0, MOD_TESLA);
1518:
1519: gi.WriteByte (svc_temp_entity);
1520: gi.WriteByte (TE_LIGHTNING);
1521: gi.WriteShort (hit - g_edicts); // destination entity
1522: gi.WriteShort (self - g_edicts); // source entity
1523: gi.WritePosition (tr.endpos);
1524: gi.WritePosition (start);
1525: gi.multicast (start, MULTICAST_PVS);
1526: }
1527: }
1528:
1529: if(self->inuse)
1530: {
1531: self->think = tesla_think_active;
1532: self->nextthink = level.time + FRAMETIME;
1533: }
1534: }
1535:
1536: void tesla_activate (edict_t *self)
1537: {
1538: edict_t *trigger;
1539: edict_t *search;
1540:
1541: if (gi.pointcontents (self->s.origin) & (CONTENTS_SLIME|CONTENTS_LAVA|CONTENTS_WATER))
1542: {
1543: tesla_blow (self);
1544: return;
1545: }
1546:
1547: // only check for spawn points in deathmatch
1548: if (deathmatch->value)
1549: {
1550: search = NULL;
1551: while ((search = findradius(search, self->s.origin, 1.5*TESLA_DAMAGE_RADIUS)) != NULL)
1552: {
1553: //if (!search->takedamage)
1554: // continue;
1555: // if it's a monster or player with health > 0
1556: // or it's a deathmatch start point
1557: // and we can see it
1558: // blow up
1559: if(search->classname)
1560: {
1561: if ( ( (!strcmp(search->classname, "info_player_deathmatch"))
1562: || (!strcmp(search->classname, "info_player_start"))
1563: || (!strcmp(search->classname, "info_player_coop"))
1564: || (!strcmp(search->classname, "misc_teleporter_dest"))
1565: )
1566: && (visible (search, self))
1567: )
1568: {
1569: if ((g_showlogic) && (g_showlogic->value))
1570: gi.dprintf ("Tesla to close to %s, removing!\n", search->classname);
1571: tesla_remove (self);
1572: return;
1573: }
1574: }
1575: }
1576: }
1577:
1578: trigger = G_Spawn();
1579: // if (trigger->nextthink)
1580: // {
1581: // if ((g_showlogic) && (g_showlogic->value))
1582: // gi.dprintf ("tesla_activate: fixing nextthink\n");
1583: // trigger->nextthink = 0;
1584: // }
1585: VectorCopy (self->s.origin, trigger->s.origin);
1586: VectorSet (trigger->mins, -TESLA_DAMAGE_RADIUS, -TESLA_DAMAGE_RADIUS, self->mins[2]);
1587: VectorSet (trigger->maxs, TESLA_DAMAGE_RADIUS, TESLA_DAMAGE_RADIUS, TESLA_DAMAGE_RADIUS);
1588: trigger->movetype = MOVETYPE_NONE;
1589: trigger->solid = SOLID_TRIGGER;
1590: trigger->owner = self;
1591: trigger->touch = tesla_zap;
1592: trigger->classname = "tesla trigger";
1593: // doesn't need to be marked as a teamslave since the move code for bounce looks for teamchains
1594: gi.linkentity (trigger);
1595:
1596: VectorClear (self->s.angles);
1597: // clear the owner if in deathmatch
1598: if (deathmatch->value)
1599: self->owner = NULL;
1600: self->teamchain = trigger;
1601: self->think = tesla_think_active;
1602: self->nextthink = level.time + FRAMETIME;
1603: self->air_finished = level.time + TESLA_TIME_TO_LIVE;
1604: }
1605:
1606: void tesla_think (edict_t *ent)
1607: {
1608: if (gi.pointcontents (ent->s.origin) & (CONTENTS_SLIME|CONTENTS_LAVA))
1609: {
1610: tesla_remove (ent);
1611: return;
1612: }
1613: VectorClear (ent->s.angles);
1614: ent->s.frame++;
1615: if(ent->s.frame > 14)
1616: {
1617: ent->s.frame = 14;
1618: ent->think = tesla_activate;
1619: ent->nextthink = level.time + 0.1;
1620: }
1621: else
1622: {
1623: if(ent->s.frame > 9)
1624: {
1625: if(ent->s.frame == 10)
1626: {
1627: if (ent->owner && ent->owner->client)
1628: {
1629: PlayerNoise(ent->owner, ent->s.origin, PNOISE_WEAPON); // PGM
1630: }
1631: ent->s.skinnum = 1;
1632: }
1633: else if(ent->s.frame == 12)
1634: ent->s.skinnum = 2;
1635: else if(ent->s.frame == 14)
1636: ent->s.skinnum = 3;
1637: }
1638: ent->think = tesla_think;
1639: ent->nextthink = level.time + 0.1;
1640: }
1641: }
1642:
1643: void tesla_lava (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
1644: {
1645: vec3_t land_point;
1646:
1647: if (plane->normal)
1648: {
1649: VectorMA (ent->s.origin, -20.0, plane->normal, land_point);
1650: if (gi.pointcontents (land_point) & (CONTENTS_SLIME|CONTENTS_LAVA))
1651: {
1652: tesla_blow (ent);
1653: return;
1654: }
1655: }
1656: if (random() > 0.5)
1657: gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/hgrenb1a.wav"), 1, ATTN_NORM, 0);
1658: else
1659: gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/hgrenb2a.wav"), 1, ATTN_NORM, 0);
1660: }
1661:
1662: void fire_tesla (edict_t *self, vec3_t start, vec3_t aimdir, int damage_multiplier, int speed)
1663: {
1664: edict_t *tesla;
1665: vec3_t dir;
1666: vec3_t forward, right, up;
1667:
1668: vectoangles2 (aimdir, dir);
1669: AngleVectors (dir, forward, right, up);
1670:
1671: tesla = G_Spawn();
1672: VectorCopy (start, tesla->s.origin);
1673: VectorScale (aimdir, speed, tesla->velocity);
1674: VectorMA (tesla->velocity, 200 + crandom() * 10.0, up, tesla->velocity);
1675: VectorMA (tesla->velocity, crandom() * 10.0, right, tesla->velocity);
1676: // VectorCopy (dir, tesla->s.angles);
1677: VectorClear (tesla->s.angles);
1678: tesla->movetype = MOVETYPE_BOUNCE;
1679: tesla->solid = SOLID_BBOX;
1680: tesla->s.effects |= EF_GRENADE;
1681: tesla->s.renderfx |= RF_IR_VISIBLE;
1682: // VectorClear (tesla->mins);
1683: // VectorClear (tesla->maxs);
1684: VectorSet (tesla->mins, -12, -12, 0);
1685: VectorSet (tesla->maxs, 12, 12, 20);
1686: tesla->s.modelindex = gi.modelindex ("models/weapons/g_tesla/tris.md2");
1687:
1688: tesla->owner = self; // PGM - we don't want it owned by self YET.
1689: tesla->teammaster = self;
1690:
1691: tesla->wait = level.time + TESLA_TIME_TO_LIVE;
1692: tesla->think = tesla_think;
1693: tesla->nextthink = level.time + TESLA_ACTIVATE_TIME;
1694:
1695: // blow up on contact with lava & slime code
1696: tesla->touch = tesla_lava;
1697:
1698: if(deathmatch->value)
1699: // PMM - lowered from 50 - 7/29/1998
1700: tesla->health = 20;
1701: else
1702: tesla->health = 30; // FIXME - change depending on skill?
1703:
1704: tesla->takedamage = DAMAGE_YES;
1705: tesla->die = tesla_die;
1706: tesla->dmg = TESLA_DAMAGE*damage_multiplier;
1707: // tesla->dmg = 0;
1708: tesla->classname = "tesla";
1709: tesla->svflags |= SVF_DAMAGEABLE;
1710: tesla->clipmask = MASK_SHOT|CONTENTS_SLIME|CONTENTS_LAVA;
1711: tesla->flags |= FL_MECHANICAL;
1712:
1713: gi.linkentity (tesla);
1714: }
1715: #endif
1716:
1717: // *************************
1718: // HEATBEAM
1719: // *************************
1720:
1721: #ifdef INCLUDE_BEAMS
1722: static void fire_beams (edict_t *self, vec3_t start, vec3_t aimdir, vec3_t offset, int damage, int kick, int te_beam, int te_impact, int mod)
1723: {
1724: trace_t tr;
1725: vec3_t dir;
1726: vec3_t forward, right, up;
1727: vec3_t end;
1728: vec3_t water_start, endpoint;
1729: qboolean water = false, underwater = false;
1730: int content_mask = MASK_SHOT | MASK_WATER;
1731: vec3_t beam_endpt;
1732:
1733: // tr = gi.trace (self->s.origin, NULL, NULL, start, self, MASK_SHOT);
1734: // if (!(tr.fraction < 1.0))
1735: // {
1736: vectoangles2 (aimdir, dir);
1737: AngleVectors (dir, forward, right, up);
1738:
1739: VectorMA (start, 8192, forward, end);
1740:
1741: if (gi.pointcontents (start) & MASK_WATER)
1742: {
1743: // gi.dprintf ("Heat beam under water\n");
1744: underwater = true;
1745: VectorCopy (start, water_start);
1746: content_mask &= ~MASK_WATER;
1747: }
1748:
1749: tr = gi.trace (start, NULL, NULL, end, self, content_mask);
1750:
1751: // see if we hit water
1752: if (tr.contents & MASK_WATER)
1753: {
1754: water = true;
1755: VectorCopy (tr.endpos, water_start);
1756:
1757: if (!VectorCompare (start, tr.endpos))
1758: {
1759: gi.WriteByte (svc_temp_entity);
1760: gi.WriteByte (TE_HEATBEAM_SPARKS);
1761: // gi.WriteByte (50);
1762: gi.WritePosition (water_start);
1763: gi.WriteDir (tr.plane.normal);
1764: // gi.WriteByte (8);
1765: // gi.WriteShort (60);
1766: gi.multicast (tr.endpos, MULTICAST_PVS);
1767: }
1768: // re-trace ignoring water this time
1769: tr = gi.trace (water_start, NULL, NULL, end, self, MASK_SHOT);
1770: }
1771: VectorCopy (tr.endpos, endpoint);
1772: // }
1773:
1774: // halve the damage if target underwater
1775: if (water)
1776: {
1777: damage = damage /2;
1778: }
1779:
1780: // send gun puff / flash
1781: if (!((tr.surface) && (tr.surface->flags & SURF_SKY)))
1782: {
1783: if (tr.fraction < 1.0)
1784: {
1785: if (tr.ent->takedamage)
1786: {
1787: T_Damage (tr.ent, self, self, aimdir, tr.endpos, tr.plane.normal, damage, kick, DAMAGE_ENERGY, mod);
1788: }
1789: else
1790: {
1791: if ((!water) && (strncmp (tr.surface->name, "sky", 3)))
1792: {
1793: // This is the truncated steam entry - uses 1+1+2 extra bytes of data
1794: gi.WriteByte (svc_temp_entity);
1795: gi.WriteByte (TE_HEATBEAM_STEAM);
1796: // gi.WriteByte (20);
1797: gi.WritePosition (tr.endpos);
1798: gi.WriteDir (tr.plane.normal);
1799: // gi.WriteByte (0xe0);
1800: // gi.WriteShort (60);
1801: gi.multicast (tr.endpos, MULTICAST_PVS);
1802:
1803: if (self->client)
1804: PlayerNoise(self, tr.endpos, PNOISE_IMPACT);
1805: }
1806: }
1807: }
1808: }
1809:
1810: // if went through water, determine where the end and make a bubble trail
1811: if ((water) || (underwater))
1812: {
1813: vec3_t pos;
1814:
1815: VectorSubtract (tr.endpos, water_start, dir);
1816: VectorNormalize (dir);
1817: VectorMA (tr.endpos, -2, dir, pos);
1818: if (gi.pointcontents (pos) & MASK_WATER)
1819: VectorCopy (pos, tr.endpos);
1820: else
1821: tr = gi.trace (pos, NULL, NULL, water_start, tr.ent, MASK_WATER);
1822:
1823: VectorAdd (water_start, tr.endpos, pos);
1824: VectorScale (pos, 0.5, pos);
1825:
1826: gi.WriteByte (svc_temp_entity);
1827: gi.WriteByte (TE_BUBBLETRAIL2);
1828: // gi.WriteByte (8);
1829: gi.WritePosition (water_start);
1830: gi.WritePosition (tr.endpos);
1831: gi.multicast (pos, MULTICAST_PVS);
1832: }
1833:
1834: if ((!underwater) && (!water))
1835: {
1836: VectorCopy (tr.endpos, beam_endpt);
1837: }
1838: else
1839: {
1840: VectorCopy (endpoint, beam_endpt);
1841: }
1842:
1843: gi.WriteByte (svc_temp_entity);
1844: gi.WriteByte (te_beam);
1845: gi.WriteShort (self - g_edicts);
1846: gi.WritePosition (start);
1847: gi.WritePosition (beam_endpt);
1848: gi.multicast (self->s.origin, MULTICAST_ALL);
1849:
1850: }
1851:
1852:
1853: /*
1854: =================
1855: fire_heat
1856:
1857: Fires a single heat beam. Zap.
1858: =================
1859: */
1860: void fire_heat (edict_t *self, vec3_t start, vec3_t aimdir, vec3_t offset, int damage, int kick, qboolean monster)
1861: {
1862: if (monster)
1863: fire_beams (self, start, aimdir, offset, damage, kick, TE_MONSTER_HEATBEAM, TE_HEATBEAM_SPARKS, MOD_HEATBEAM);
1864: else
1865: fire_beams (self, start, aimdir, offset, damage, kick, TE_HEATBEAM, TE_HEATBEAM_SPARKS, MOD_HEATBEAM);
1866: }
1867:
1868: #endif
1869:
1870:
1871: // *************************
1872: // BLASTER 2
1873: // *************************
1874:
1875: /*
1876: =================
1877: fire_blaster2
1878:
1879: Fires a single green blaster bolt. Used by monsters, generally.
1880: =================
1881: */
1882: void blaster2_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
1883: {
1884: int mod;
1885: int damagestat;
1886:
1887: if (other == self->owner)
1888: return;
1889:
1890: if (surf && (surf->flags & SURF_SKY))
1891: {
1892: G_FreeEdict (self);
1893: return;
1894: }
1895:
1896: if (self->owner && self->owner->client)
1897: PlayerNoise(self->owner, self->s.origin, PNOISE_IMPACT);
1898:
1899: if (other->takedamage)
1900: {
1901: // the only time players will be firing blaster2 bolts will be from the
1902: // defender sphere.
1903: if(self->owner->client)
1904: mod = MOD_DEFENDER_SPHERE;
1905: else
1906: mod = MOD_BLASTER2;
1907:
1908: if (self->owner)
1909: {
1910: damagestat = self->owner->takedamage;
1911: self->owner->takedamage = DAMAGE_NO;
1912: if (self->dmg >= 5)
1913: T_RadiusDamage(self, self->owner, self->dmg*3, other, self->dmg_radius, 0);
1914: T_Damage (other, self, self->owner, self->velocity, self->s.origin, plane->normal, self->dmg, 1, DAMAGE_ENERGY, mod);
1915: self->owner->takedamage = damagestat;
1916: }
1917: else
1918: {
1919: if (self->dmg >= 5)
1920: T_RadiusDamage(self, self->owner, self->dmg*3, other, self->dmg_radius, 0);
1921: T_Damage (other, self, self->owner, self->velocity, self->s.origin, plane->normal, self->dmg, 1, DAMAGE_ENERGY, mod);
1922: }
1923: }
1924: else
1925: {
1926: //PMM - yeowch this will get expensive
1927: if (self->dmg >= 5)
1928: T_RadiusDamage(self, self->owner, self->dmg*3, self->owner, self->dmg_radius, 0);
1929:
1930: gi.WriteByte (svc_temp_entity);
1931: gi.WriteByte (TE_BLASTER2);
1932: gi.WritePosition (self->s.origin);
1933: if (!plane)
1934: gi.WriteDir (vec3_origin);
1935: else
1936: gi.WriteDir (plane->normal);
1937: gi.multicast (self->s.origin, MULTICAST_PVS);
1938: }
1939:
1940: G_FreeEdict (self);
1941: }
1942:
1943: void fire_blaster2 (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int effect, qboolean hyper)
1944: {
1945: edict_t *bolt;
1946: trace_t tr;
1947:
1948: VectorNormalize (dir);
1949:
1950: bolt = G_Spawn();
1951: VectorCopy (start, bolt->s.origin);
1952: VectorCopy (start, bolt->s.old_origin);
1953: vectoangles2 (dir, bolt->s.angles);
1954: VectorScale (dir, speed, bolt->velocity);
1955: bolt->movetype = MOVETYPE_FLYMISSILE;
1956: bolt->clipmask = MASK_SHOT;
1957: bolt->solid = SOLID_BBOX;
1958: bolt->s.effects |= effect;
1959: VectorClear (bolt->mins);
1960: VectorClear (bolt->maxs);
1961:
1962: if (effect)
1963: bolt->s.effects |= EF_TRACKER;
1964: bolt->dmg_radius = 128;
1965: bolt->s.modelindex = gi.modelindex ("models/proj/laser2/tris.md2");
1966: bolt->touch = blaster2_touch;
1967:
1968: bolt->owner = self;
1969: bolt->nextthink = level.time + 2;
1970: bolt->think = G_FreeEdict;
1971: bolt->dmg = damage;
1972: bolt->classname = "bolt";
1973: gi.linkentity (bolt);
1974:
1975: if (self->client)
1976: check_dodge (self, bolt->s.origin, dir, speed);
1977:
1978: tr = gi.trace (self->s.origin, NULL, NULL, bolt->s.origin, bolt, MASK_SHOT);
1979: if (tr.fraction < 1.0)
1980: {
1981: VectorMA (bolt->s.origin, -10, dir, bolt->s.origin);
1982: bolt->touch (bolt, tr.ent, NULL, NULL);
1983: }
1984: }
1985:
1986: // *************************
1987: // tracker
1988: // *************************
1989:
1990: /*
1991: void tracker_boom_think (edict_t *self)
1992: {
1993: self->s.frame--;
1994: if(self->s.frame < 0)
1995: G_FreeEdict(self);
1996: else
1997: self->nextthink = level.time + 0.1;
1998: }
1999:
2000: void tracker_boom_spawn (vec3_t origin)
2001: {
2002: edict_t *boom;
2003:
2004: boom = G_Spawn();
2005: VectorCopy (origin, boom->s.origin);
2006: boom->s.modelindex = gi.modelindex ("models/items/spawngro/tris.md2");
2007: boom->s.skinnum = 1;
2008: boom->s.frame = 2;
2009: boom->classname = "tracker boom";
2010: gi.linkentity (boom);
2011:
2012: boom->think = tracker_boom_think;
2013: boom->nextthink = level.time + 0.1;
2014: //PMM
2015: // boom->s.renderfx |= RF_TRANSLUCENT;
2016: boom->s.effects |= EF_SPHERETRANS;
2017: //pmm
2018: }
2019: */
2020:
2021: #define TRACKER_DAMAGE_FLAGS (DAMAGE_NO_POWER_ARMOR | DAMAGE_ENERGY | DAMAGE_NO_KNOCKBACK)
2022: #define TRACKER_IMPACT_FLAGS (DAMAGE_NO_POWER_ARMOR | DAMAGE_ENERGY)
2023:
2024: #define TRACKER_DAMAGE_TIME 0.5 // seconds
2025:
2026: void tracker_pain_daemon_think (edict_t *self)
2027: {
2028: static vec3_t pain_normal = { 0, 0, 1 };
2029: int hurt;
2030:
2031: if(!self->inuse)
2032: return;
2033:
2034: if((level.time - self->timestamp) > TRACKER_DAMAGE_TIME)
2035: {
2036: if(!self->enemy->client)
2037: self->enemy->s.effects &= ~EF_TRACKERTRAIL;
2038: G_FreeEdict (self);
2039: }
2040: else
2041: {
2042: if(self->enemy->health > 0)
2043: {
2044: // gi.dprintf("ouch %x\n", self);
2045: T_Damage (self->enemy, self, self->owner, vec3_origin, self->enemy->s.origin, pain_normal,
2046: self->dmg, 0, TRACKER_DAMAGE_FLAGS, MOD_TRACKER);
2047:
2048: // if we kill the player, we'll be removed.
2049: if(self->inuse)
2050: {
2051: // if we killed a monster, gib them.
2052: if (self->enemy->health < 1)
2053: {
2054: if(self->enemy->gib_health)
2055: hurt = - self->enemy->gib_health;
2056: else
2057: hurt = 500;
2058:
2059: // gi.dprintf("non-player killed. ensuring gib! %d\n", hurt);
2060: T_Damage (self->enemy, self, self->owner, vec3_origin, self->enemy->s.origin,
2061: pain_normal, hurt, 0, TRACKER_DAMAGE_FLAGS, MOD_TRACKER);
2062: }
2063:
2064: if(self->enemy->client)
2065: self->enemy->client->tracker_pain_framenum = level.framenum + 1;
2066: else
2067: self->enemy->s.effects |= EF_TRACKERTRAIL;
2068:
2069: self->nextthink = level.time + FRAMETIME;
2070: }
2071: }
2072: else
2073: {
2074: if(!self->enemy->client)
2075: self->enemy->s.effects &= ~EF_TRACKERTRAIL;
2076: G_FreeEdict (self);
2077: }
2078: }
2079: }
2080:
2081: void tracker_pain_daemon_spawn (edict_t *owner, edict_t *enemy, int damage)
2082: {
2083: edict_t *daemon;
2084:
2085: if(enemy == NULL)
2086: return;
2087:
2088: daemon = G_Spawn();
2089: daemon->classname = "pain daemon";
2090: daemon->think = tracker_pain_daemon_think;
2091: daemon->nextthink = level.time + FRAMETIME;
2092: daemon->timestamp = level.time;
2093: daemon->owner = owner;
2094: daemon->enemy = enemy;
2095: daemon->dmg = damage;
2096: }
2097:
2098: void tracker_explode (edict_t *self, cplane_t *plane)
2099: {
2100: vec3_t dir;
2101:
2102: if(!plane)
2103: VectorClear (dir);
2104: else
2105: VectorScale (plane->normal, 256, dir);
2106:
2107: gi.WriteByte (svc_temp_entity);
2108: gi.WriteByte (TE_TRACKER_EXPLOSION);
2109: gi.WritePosition (self->s.origin);
2110: gi.multicast (self->s.origin, MULTICAST_PVS);
2111:
2112: // gi.sound (self, CHAN_VOICE, gi.soundindex ("weapons/disrupthit.wav"), 1, ATTN_NORM, 0);
2113: // tracker_boom_spawn(self->s.origin);
2114:
2115: G_FreeEdict (self);
2116: }
2117:
2118: void tracker_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
2119: {
2120: float damagetime;
2121:
2122: if (other == self->owner)
2123: return;
2124:
2125: if (surf && (surf->flags & SURF_SKY))
2126: {
2127: G_FreeEdict (self);
2128: return;
2129: }
2130:
2131: if (self->client)
2132: PlayerNoise(self->owner, self->s.origin, PNOISE_IMPACT);
2133:
2134: if (other->takedamage)
2135: {
2136: if((other->svflags & SVF_MONSTER) || other->client)
2137: {
2138: if(other->health > 0) // knockback only for living creatures
2139: {
2140: // PMM - kickback was times 4 .. reduced to 3
2141: // now this does no damage, just knockback
2142: T_Damage (other, self, self->owner, self->velocity, self->s.origin, plane->normal,
2143: /* self->dmg */ 0, (self->dmg*3), TRACKER_IMPACT_FLAGS, MOD_TRACKER);
2144:
2145: if (!(other->flags & (FL_FLY|FL_SWIM)))
2146: other->velocity[2] += 140;
2147:
2148: damagetime = ((float)self->dmg)*FRAMETIME;
2149: damagetime = damagetime / TRACKER_DAMAGE_TIME;
2150: // gi.dprintf ("damage is %f\n", damagetime);
2151:
2152: tracker_pain_daemon_spawn (self->owner, other, (int)damagetime);
2153: }
2154: else // lots of damage (almost autogib) for dead bodies
2155: {
2156: T_Damage (other, self, self->owner, self->velocity, self->s.origin, plane->normal,
2157: self->dmg*4, (self->dmg*3), TRACKER_IMPACT_FLAGS, MOD_TRACKER);
2158: }
2159: }
2160: else // full damage in one shot for inanimate objects
2161: {
2162: T_Damage (other, self, self->owner, self->velocity, self->s.origin, plane->normal,
2163: self->dmg, (self->dmg*3), TRACKER_IMPACT_FLAGS, MOD_TRACKER);
2164: }
2165: }
2166:
2167: tracker_explode (self, plane);
2168: return;
2169: }
2170:
2171: void tracker_fly (edict_t *self)
2172: {
2173: vec3_t dest;
2174: vec3_t dir;
2175: vec3_t center;
2176:
2177: if ((!self->enemy) || (!self->enemy->inuse) || (self->enemy->health < 1))
2178: {
2179: tracker_explode (self, NULL);
2180: return;
2181: }
2182: /*
2183: VectorCopy (self->enemy->s.origin, dest);
2184: if(self->enemy->client)
2185: dest[2] += self->enemy->viewheight;
2186: */
2187: // PMM - try to hunt for center of enemy, if possible and not client
2188: if(self->enemy->client)
2189: {
2190: VectorCopy (self->enemy->s.origin, dest);
2191: dest[2] += self->enemy->viewheight;
2192: }
2193: // paranoia
2194: else if (VectorCompare(self->enemy->absmin, vec3_origin) || VectorCompare(self->enemy->absmax, vec3_origin))
2195: {
2196: VectorCopy (self->enemy->s.origin, dest);
2197: }
2198: else
2199: {
2200: VectorMA (vec3_origin, 0.5, self->enemy->absmin, center);
2201: VectorMA (center, 0.5, self->enemy->absmax, center);
2202: VectorCopy (center, dest);
2203: }
2204:
2205: VectorSubtract (dest, self->s.origin, dir);
2206: VectorNormalize (dir);
2207: vectoangles2 (dir, self->s.angles);
2208: VectorScale (dir, self->speed, self->velocity);
2209: VectorCopy(dest, self->monsterinfo.saved_goal);
2210:
2211: self->nextthink = level.time + 0.1;
2212: }
2213:
2214: void fire_tracker (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, edict_t *enemy)
2215: {
2216: edict_t *bolt;
2217: trace_t tr;
2218:
2219: VectorNormalize (dir);
2220:
2221: bolt = G_Spawn();
2222: VectorCopy (start, bolt->s.origin);
2223: VectorCopy (start, bolt->s.old_origin);
2224: vectoangles2 (dir, bolt->s.angles);
2225: VectorScale (dir, speed, bolt->velocity);
2226: bolt->movetype = MOVETYPE_FLYMISSILE;
2227: bolt->clipmask = MASK_SHOT;
2228: bolt->solid = SOLID_BBOX;
2229: bolt->speed = speed;
2230: bolt->s.effects = EF_TRACKER;
2231: bolt->s.sound = gi.soundindex ("weapons/disrupt.wav");
2232: VectorClear (bolt->mins);
2233: VectorClear (bolt->maxs);
2234:
2235: bolt->s.modelindex = gi.modelindex ("models/proj/disintegrator/tris.md2");
2236: bolt->touch = tracker_touch;
2237: bolt->enemy = enemy;
2238: bolt->owner = self;
2239: bolt->dmg = damage;
2240: bolt->classname = "tracker";
2241: gi.linkentity (bolt);
2242:
2243: if(enemy)
2244: {
2245: bolt->nextthink = level.time + 0.1;
2246: bolt->think = tracker_fly;
2247: }
2248: else
2249: {
2250: bolt->nextthink = level.time + 10;
2251: bolt->think = G_FreeEdict;
2252: }
2253:
2254: if (self->client)
2255: check_dodge (self, bolt->s.origin, dir, speed);
2256:
2257: tr = gi.trace (self->s.origin, NULL, NULL, bolt->s.origin, bolt, MASK_SHOT);
2258: if (tr.fraction < 1.0)
2259: {
2260: VectorMA (bolt->s.origin, -10, dir, bolt->s.origin);
2261: bolt->touch (bolt, tr.ent, NULL, NULL);
2262: }
2263: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.