![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_misc.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_misc.c CVS log | Up to [Quake II] / quake2 / rogue |
1.1 root 1: // g_misc.c
2:
3: #include "g_local.h"
4:
5: extern void M_WorldEffects (edict_t *ent);
6:
7: /*QUAKED func_group (0 0 0) ?
8: Used to group brushes together just for editor convenience.
9: */
10:
11: //=====================================================
12:
13: void Use_Areaportal (edict_t *ent, edict_t *other, edict_t *activator)
14: {
15: ent->count ^= 1; // toggle state
16: // gi.dprintf ("portalstate: %i = %i\n", ent->style, ent->count);
17: gi.SetAreaPortalState (ent->style, ent->count);
18: }
19:
20: /*QUAKED func_areaportal (0 0 0) ?
21:
22: This is a non-visible object that divides the world into
23: areas that are seperated when this portal is not activated.
24: Usually enclosed in the middle of a door.
25: */
26: void SP_func_areaportal (edict_t *ent)
27: {
28: ent->use = Use_Areaportal;
29: ent->count = 0; // always start closed;
30: }
31:
32: //=====================================================
33:
34:
35: /*
36: =================
37: Misc functions
38: =================
39: */
40: void VelocityForDamage (int damage, vec3_t v)
41: {
42: v[0] = 100.0 * crandom();
43: v[1] = 100.0 * crandom();
44: v[2] = 200.0 + 100.0 * random();
45:
46: if (damage < 50)
47: VectorScale (v, 0.7, v);
48: else
49: VectorScale (v, 1.2, v);
50: }
51:
52: void ClipGibVelocity (edict_t *ent)
53: {
54: if (ent->velocity[0] < -300)
55: ent->velocity[0] = -300;
56: else if (ent->velocity[0] > 300)
57: ent->velocity[0] = 300;
58: if (ent->velocity[1] < -300)
59: ent->velocity[1] = -300;
60: else if (ent->velocity[1] > 300)
61: ent->velocity[1] = 300;
62: if (ent->velocity[2] < 200)
63: ent->velocity[2] = 200; // always some upwards
64: else if (ent->velocity[2] > 500)
65: ent->velocity[2] = 500;
66: }
67:
68:
69: /*
70: =================
71: gibs
72: =================
73: */
74: void gib_think (edict_t *self)
75: {
76: self->s.frame++;
77: self->nextthink = level.time + FRAMETIME;
78:
79: if (self->s.frame == 10)
80: {
81: self->think = G_FreeEdict;
82: self->nextthink = level.time + 8 + random()*10;
83: }
84: }
85:
86: void gib_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
87: {
88: vec3_t normal_angles, right;
89:
90: if (!self->groundentity)
91: return;
92:
93: self->touch = NULL;
94:
95: if (plane)
96: {
97: gi.sound (self, CHAN_VOICE, gi.soundindex ("misc/fhit3.wav"), 1, ATTN_NORM, 0);
98:
99: vectoangles (plane->normal, normal_angles);
100: AngleVectors (normal_angles, NULL, right, NULL);
101: vectoangles (right, self->s.angles);
102:
103: if (self->s.modelindex == sm_meat_index)
104: {
105: self->s.frame++;
106: self->think = gib_think;
107: self->nextthink = level.time + FRAMETIME;
108: }
109: }
110: }
111:
112: void gib_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
113: {
114: G_FreeEdict (self);
115: }
116:
117: void ThrowGib (edict_t *self, char *gibname, int damage, int type)
118: {
119: edict_t *gib;
120: vec3_t vd;
121: vec3_t origin;
122: vec3_t size;
123: float vscale;
124:
125: gib = G_Spawn();
126:
127: VectorScale (self->size, 0.5, size);
128: VectorAdd (self->absmin, size, origin);
129: gib->s.origin[0] = origin[0] + crandom() * size[0];
130: gib->s.origin[1] = origin[1] + crandom() * size[1];
131: gib->s.origin[2] = origin[2] + crandom() * size[2];
132:
133: gi.setmodel (gib, gibname);
134: gib->solid = SOLID_NOT;
135: gib->s.effects |= EF_GIB;
136: gib->flags |= FL_NO_KNOCKBACK;
137: gib->takedamage = DAMAGE_YES;
138: gib->die = gib_die;
139:
140: if (type == GIB_ORGANIC)
141: {
142: gib->movetype = MOVETYPE_TOSS;
143: gib->touch = gib_touch;
144: vscale = 0.5;
145: }
146: else
147: {
148: gib->movetype = MOVETYPE_BOUNCE;
149: vscale = 1.0;
150: }
151:
152: VelocityForDamage (damage, vd);
153: VectorMA (self->velocity, vscale, vd, gib->velocity);
154: ClipGibVelocity (gib);
155: gib->avelocity[0] = random()*600;
156: gib->avelocity[1] = random()*600;
157: gib->avelocity[2] = random()*600;
158:
159: gib->think = G_FreeEdict;
160: gib->nextthink = level.time + 10 + random()*10;
161:
162: //PGM
163: gib->s.renderfx |= RF_IR_VISIBLE;
164: //PGM
165:
166: gi.linkentity (gib);
167: }
168:
169: void ThrowHead (edict_t *self, char *gibname, int damage, int type)
170: {
171: vec3_t vd;
172: float vscale;
173:
174: self->s.skinnum = 0;
175: self->s.frame = 0;
176: VectorClear (self->mins);
177: VectorClear (self->maxs);
178:
179: self->s.modelindex2 = 0;
180: gi.setmodel (self, gibname);
181: self->solid = SOLID_NOT;
182: self->s.effects |= EF_GIB;
183: self->s.effects &= ~EF_FLIES;
184: self->s.sound = 0;
185: self->flags |= FL_NO_KNOCKBACK;
186: self->svflags &= ~SVF_MONSTER;
187: self->takedamage = DAMAGE_YES;
188: self->die = gib_die;
189:
190: if (type == GIB_ORGANIC)
191: {
192: self->movetype = MOVETYPE_TOSS;
193: self->touch = gib_touch;
194: vscale = 0.5;
195: }
196: else
197: {
198: self->movetype = MOVETYPE_BOUNCE;
199: vscale = 1.0;
200: }
201:
202: VelocityForDamage (damage, vd);
203: VectorMA (self->velocity, vscale, vd, self->velocity);
204: ClipGibVelocity (self);
205:
206: self->avelocity[YAW] = crandom()*600;
207:
208: self->think = G_FreeEdict;
209: self->nextthink = level.time + 10 + random()*10;
210:
211: gi.linkentity (self);
212: }
213:
214:
215: void ThrowClientHead (edict_t *self, int damage)
216: {
217: vec3_t vd;
218: char *gibname;
219:
220: if (rand()&1)
221: {
222: gibname = "models/objects/gibs/head2/tris.md2";
223: self->s.skinnum = 1; // second skin is player
224: }
225: else
226: {
227: gibname = "models/objects/gibs/skull/tris.md2";
228: self->s.skinnum = 0;
229: }
230:
231: self->s.origin[2] += 32;
232: self->s.frame = 0;
233: gi.setmodel (self, gibname);
234: VectorSet (self->mins, -16, -16, 0);
235: VectorSet (self->maxs, 16, 16, 16);
236:
237: self->takedamage = DAMAGE_NO;
238: self->solid = SOLID_NOT;
239: self->s.effects = EF_GIB;
240: self->s.sound = 0;
241: self->flags |= FL_NO_KNOCKBACK;
242:
243: self->movetype = MOVETYPE_BOUNCE;
244: VelocityForDamage (damage, vd);
245: VectorAdd (self->velocity, vd, self->velocity);
246:
247: if (self->client) // bodies in the queue don't have a client anymore
248: {
249: self->client->anim_priority = ANIM_DEATH;
250: self->client->anim_end = self->s.frame;
251: }
252: else
253: {
254: self->think = NULL;
255: self->nextthink = 0;
256: }
257:
258: gi.linkentity (self);
259: }
260:
261:
262: /*
263: =================
264: debris
265: =================
266: */
267: void debris_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
268: {
269: G_FreeEdict (self);
270: }
271:
272: void ThrowDebris (edict_t *self, char *modelname, float speed, vec3_t origin)
273: {
274: edict_t *chunk;
275: vec3_t v;
276:
277: chunk = G_Spawn();
278: VectorCopy (origin, chunk->s.origin);
279: gi.setmodel (chunk, modelname);
280: v[0] = 100 * crandom();
281: v[1] = 100 * crandom();
282: v[2] = 100 + 100 * crandom();
283: VectorMA (self->velocity, speed, v, chunk->velocity);
284: chunk->movetype = MOVETYPE_BOUNCE;
285: chunk->solid = SOLID_NOT;
286: chunk->avelocity[0] = random()*600;
287: chunk->avelocity[1] = random()*600;
288: chunk->avelocity[2] = random()*600;
289: chunk->think = G_FreeEdict;
290: chunk->nextthink = level.time + 5 + random()*5;
291: chunk->s.frame = 0;
292: chunk->flags = 0;
293: chunk->classname = "debris";
294: chunk->takedamage = DAMAGE_YES;
295: chunk->die = debris_die;
296: gi.linkentity (chunk);
297: }
298:
299:
300: void BecomeExplosion1 (edict_t *self)
301: {
302: gi.WriteByte (svc_temp_entity);
303: gi.WriteByte (TE_EXPLOSION1);
304: gi.WritePosition (self->s.origin);
305: gi.multicast (self->s.origin, MULTICAST_PVS);
306:
307: G_FreeEdict (self);
308: }
309:
310:
311: void BecomeExplosion2 (edict_t *self)
312: {
313: gi.WriteByte (svc_temp_entity);
314: gi.WriteByte (TE_EXPLOSION2);
315: gi.WritePosition (self->s.origin);
316: gi.multicast (self->s.origin, MULTICAST_PVS);
317:
318: G_FreeEdict (self);
319: }
320:
321:
322: /*QUAKED path_corner (.5 .3 0) (-8 -8 -8) (8 8 8) TELEPORT
323: Target: next path corner
324: Pathtarget: gets used when an entity that has
325: this path_corner targeted touches it
326: */
327:
328: void path_corner_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
329: {
330: vec3_t v;
331: edict_t *next;
332:
333: if (other->movetarget != self)
334: return;
335:
336: if (other->enemy)
337: return;
338:
339: if (self->pathtarget)
340: {
341: char *savetarget;
342:
343: savetarget = self->target;
344: self->target = self->pathtarget;
345: G_UseTargets (self, other);
346: self->target = savetarget;
347: }
348:
349: if (self->target)
350: next = G_PickTarget(self->target);
351: else
352: next = NULL;
353:
354: if ((next) && (next->spawnflags & 1))
355: {
356: VectorCopy (next->s.origin, v);
357: v[2] += next->mins[2];
358: v[2] -= other->mins[2];
359: VectorCopy (v, other->s.origin);
360: next = G_PickTarget(next->target);
361: other->s.event = EV_OTHER_TELEPORT;
362: }
363:
364: other->goalentity = other->movetarget = next;
365:
366: if (self->wait)
367: {
368: other->monsterinfo.pausetime = level.time + self->wait;
369: other->monsterinfo.stand (other);
370: return;
371: }
372:
373: if (!other->movetarget)
374: {
375: other->monsterinfo.pausetime = level.time + 100000000;
376: other->monsterinfo.stand (other);
377: }
378: else
379: {
380: VectorSubtract (other->goalentity->s.origin, other->s.origin, v);
381: other->ideal_yaw = vectoyaw (v);
382: }
383: }
384:
385: void SP_path_corner (edict_t *self)
386: {
387: if (!self->targetname)
388: {
389: gi.dprintf ("path_corner with no targetname at %s\n", vtos(self->s.origin));
390: G_FreeEdict (self);
391: return;
392: }
393:
394: self->solid = SOLID_TRIGGER;
395: self->touch = path_corner_touch;
396: VectorSet (self->mins, -8, -8, -8);
397: VectorSet (self->maxs, 8, 8, 8);
398: self->svflags |= SVF_NOCLIENT;
399: gi.linkentity (self);
400: }
401:
402:
403: /*QUAKED point_combat (0.5 0.3 0) (-8 -8 -8) (8 8 8) Hold
404: Makes this the target of a monster and it will head here
405: when first activated before going after the activator. If
406: hold is selected, it will stay here.
407: */
408: void point_combat_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
409: {
410: edict_t *activator;
411:
412: if (other->movetarget != self)
413: return;
414:
415: if (self->target)
416: {
417: other->target = self->target;
418: other->goalentity = other->movetarget = G_PickTarget(other->target);
419: if (!other->goalentity)
420: {
421: gi.dprintf("%s at %s target %s does not exist\n", self->classname, vtos(self->s.origin), self->target);
422: other->movetarget = self;
423: }
424: self->target = NULL;
425: }
426: else if ((self->spawnflags & 1) && !(other->flags & (FL_SWIM|FL_FLY)))
427: {
428: other->monsterinfo.pausetime = level.time + 100000000;
429: other->monsterinfo.aiflags |= AI_STAND_GROUND;
430: other->monsterinfo.stand (other);
431: }
432:
433: if (other->movetarget == self)
434: {
435: other->target = NULL;
436: other->movetarget = NULL;
437: other->goalentity = other->enemy;
438: other->monsterinfo.aiflags &= ~AI_COMBAT_POINT;
439: }
440:
441: if (self->pathtarget)
442: {
443: char *savetarget;
444:
445: savetarget = self->target;
446: self->target = self->pathtarget;
447: if (other->enemy && other->enemy->client)
448: activator = other->enemy;
449: else if (other->oldenemy && other->oldenemy->client)
450: activator = other->oldenemy;
451: else if (other->activator && other->activator->client)
452: activator = other->activator;
453: else
454: activator = other;
455: G_UseTargets (self, activator);
456: self->target = savetarget;
457: }
458: }
459:
460: void SP_point_combat (edict_t *self)
461: {
462: if (deathmatch->value)
463: {
464: G_FreeEdict (self);
465: return;
466: }
467: self->solid = SOLID_TRIGGER;
468: self->touch = point_combat_touch;
469: VectorSet (self->mins, -8, -8, -16);
470: VectorSet (self->maxs, 8, 8, 16);
471: self->svflags = SVF_NOCLIENT;
472: gi.linkentity (self);
473: };
474:
475:
476: /*QUAKED viewthing (0 .5 .8) (-8 -8 -8) (8 8 8)
477: Just for the debugging level. Don't use
478: */
479: void TH_viewthing(edict_t *ent)
480: {
481: ent->s.frame = (ent->s.frame + 1) % 7;
482: ent->nextthink = level.time + FRAMETIME;
483: }
484:
485: void SP_viewthing(edict_t *ent)
486: {
487: gi.dprintf ("viewthing spawned\n");
488:
489: ent->movetype = MOVETYPE_NONE;
490: ent->solid = SOLID_BBOX;
491: ent->s.renderfx = RF_FRAMELERP;
492: VectorSet (ent->mins, -16, -16, -24);
493: VectorSet (ent->maxs, 16, 16, 32);
494: ent->s.modelindex = gi.modelindex ("models/objects/banner/tris.md2");
495: gi.linkentity (ent);
496: ent->nextthink = level.time + 0.5;
497: ent->think = TH_viewthing;
498: return;
499: }
500:
501:
502: /*QUAKED info_null (0 0.5 0) (-4 -4 -4) (4 4 4)
503: Used as a positional target for spotlights, etc.
504: */
505: void SP_info_null (edict_t *self)
506: {
507: G_FreeEdict (self);
508: };
509:
510:
511: /*QUAKED info_notnull (0 0.5 0) (-4 -4 -4) (4 4 4)
512: Used as a positional target for lightning.
513: */
514: void SP_info_notnull (edict_t *self)
515: {
516: VectorCopy (self->s.origin, self->absmin);
517: VectorCopy (self->s.origin, self->absmax);
518: };
519:
520:
521: /*QUAKED light (0 1 0) (-8 -8 -8) (8 8 8) START_OFF
522: Non-displayed light.
523: Default light value is 300.
524: Default style is 0.
525: If targeted, will toggle between on and off.
526: Default _cone value is 10 (used to set size of light for spotlights)
527: */
528:
529: #define START_OFF 1
530:
531: static void light_use (edict_t *self, edict_t *other, edict_t *activator)
532: {
533: if (self->spawnflags & START_OFF)
534: {
535: gi.configstring (CS_LIGHTS+self->style, "m");
536: self->spawnflags &= ~START_OFF;
537: }
538: else
539: {
540: gi.configstring (CS_LIGHTS+self->style, "a");
541: self->spawnflags |= START_OFF;
542: }
543: }
544:
545: void SP_light (edict_t *self)
546: {
547: // no targeted lights in deathmatch, because they cause global messages
548: if (!self->targetname || deathmatch->value)
549: {
550: G_FreeEdict (self);
551: return;
552: }
553:
554: if (self->style >= 32)
555: {
556: self->use = light_use;
557: if (self->spawnflags & START_OFF)
558: gi.configstring (CS_LIGHTS+self->style, "a");
559: else
560: gi.configstring (CS_LIGHTS+self->style, "m");
561: }
562: }
563:
564:
565: /*QUAKED func_wall (0 .5 .8) ? TRIGGER_SPAWN TOGGLE START_ON ANIMATED ANIMATED_FAST
566: This is just a solid wall if not inhibited
567:
568: TRIGGER_SPAWN the wall will not be present until triggered
569: it will then blink in to existance; it will
570: kill anything that was in it's way
571:
572: TOGGLE only valid for TRIGGER_SPAWN walls
573: this allows the wall to be turned on and off
574:
575: START_ON only valid for TRIGGER_SPAWN walls
576: the wall will initially be present
577: */
578:
579: void func_wall_use (edict_t *self, edict_t *other, edict_t *activator)
580: {
581: if (self->solid == SOLID_NOT)
582: {
583: self->solid = SOLID_BSP;
584: self->svflags &= ~SVF_NOCLIENT;
585: KillBox (self);
586: }
587: else
588: {
589: self->solid = SOLID_NOT;
590: self->svflags |= SVF_NOCLIENT;
591: }
592: gi.linkentity (self);
593:
594: if (!(self->spawnflags & 2))
595: self->use = NULL;
596: }
597:
598: void SP_func_wall (edict_t *self)
599: {
600: self->movetype = MOVETYPE_PUSH;
601: gi.setmodel (self, self->model);
602:
603: if (self->spawnflags & 8)
604: self->s.effects |= EF_ANIM_ALL;
605: if (self->spawnflags & 16)
606: self->s.effects |= EF_ANIM_ALLFAST;
607:
608: // just a wall
609: if ((self->spawnflags & 7) == 0)
610: {
611: self->solid = SOLID_BSP;
612: gi.linkentity (self);
613: return;
614: }
615:
616: // it must be TRIGGER_SPAWN
617: if (!(self->spawnflags & 1))
618: {
619: // gi.dprintf("func_wall missing TRIGGER_SPAWN\n");
620: self->spawnflags |= 1;
621: }
622:
623: // yell if the spawnflags are odd
624: if (self->spawnflags & 4)
625: {
626: if (!(self->spawnflags & 2))
627: {
628: gi.dprintf("func_wall START_ON without TOGGLE\n");
629: self->spawnflags |= 2;
630: }
631: }
632:
633: self->use = func_wall_use;
634: if (self->spawnflags & 4)
635: {
636: self->solid = SOLID_BSP;
637: }
638: else
639: {
640: self->solid = SOLID_NOT;
641: self->svflags |= SVF_NOCLIENT;
642: }
643: gi.linkentity (self);
644: }
645:
646:
647: /*QUAKED func_object (0 .5 .8) ? TRIGGER_SPAWN ANIMATED ANIMATED_FAST
648: This is solid bmodel that will fall if it's support it removed.
649: */
650:
651: void func_object_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
652: {
653: // only squash thing we fall on top of
654: if (!plane)
655: return;
656: if (plane->normal[2] < 1.0)
657: return;
658: if (other->takedamage == DAMAGE_NO)
659: return;
660: T_Damage (other, self, self, vec3_origin, self->s.origin, vec3_origin, self->dmg, 1, 0, MOD_CRUSH);
661: }
662:
663: void func_object_release (edict_t *self)
664: {
665: self->movetype = MOVETYPE_TOSS;
666: self->touch = func_object_touch;
667: }
668:
669: void func_object_use (edict_t *self, edict_t *other, edict_t *activator)
670: {
671: self->solid = SOLID_BSP;
672: self->svflags &= ~SVF_NOCLIENT;
673: self->use = NULL;
674: KillBox (self);
675: func_object_release (self);
676: }
677:
678: void SP_func_object (edict_t *self)
679: {
680: gi.setmodel (self, self->model);
681:
682: self->mins[0] += 1;
683: self->mins[1] += 1;
684: self->mins[2] += 1;
685: self->maxs[0] -= 1;
686: self->maxs[1] -= 1;
687: self->maxs[2] -= 1;
688:
689: if (!self->dmg)
690: self->dmg = 100;
691:
692: if (self->spawnflags == 0)
693: {
694: self->solid = SOLID_BSP;
695: self->movetype = MOVETYPE_PUSH;
696: self->think = func_object_release;
697: self->nextthink = level.time + 2 * FRAMETIME;
698: }
699: else
700: {
701: self->solid = SOLID_NOT;
702: self->movetype = MOVETYPE_PUSH;
703: self->use = func_object_use;
704: self->svflags |= SVF_NOCLIENT;
705: }
706:
707: if (self->spawnflags & 2)
708: self->s.effects |= EF_ANIM_ALL;
709: if (self->spawnflags & 4)
710: self->s.effects |= EF_ANIM_ALLFAST;
711:
712: self->clipmask = MASK_MONSTERSOLID;
713:
714: gi.linkentity (self);
715: }
716:
717:
718: /*QUAKED func_explosive (0 .5 .8) ? Trigger_Spawn ANIMATED ANIMATED_FAST INACTIVE
719: Any brush that you want to explode or break apart. If you want an
720: ex0plosion, set dmg and it will do a radius explosion of that amount
721: at the center of the bursh.
722:
723: If targeted it will not be shootable.
724:
725: INACTIVE - specifies that the entity is not explodable until triggered. If you use this you must
726: target the entity you want to trigger it. This is the only entity approved to activate it.
727:
728: health defaults to 100.
729:
730: mass defaults to 75. This determines how much debris is emitted when
731: it explodes. You get one large chunk per 100 of mass (up to 8) and
732: one small chunk per 25 of mass (up to 16). So 800 gives the most.
733: */
734: void func_explosive_explode (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
735: {
736: vec3_t origin;
737: vec3_t chunkorigin;
738: vec3_t size;
739: int count;
740: int mass;
741: edict_t *master;
742: qboolean done = false;
743:
744: // bmodel origins are (0 0 0), we need to adjust that here
745: VectorScale (self->size, 0.5, size);
746: VectorAdd (self->absmin, size, origin);
747: VectorCopy (origin, self->s.origin);
748:
749: self->takedamage = DAMAGE_NO;
750:
751: if (self->dmg)
752: T_RadiusDamage (self, attacker, self->dmg, NULL, self->dmg+40, MOD_EXPLOSIVE);
753:
754: VectorSubtract (self->s.origin, inflictor->s.origin, self->velocity);
755: VectorNormalize (self->velocity);
756: VectorScale (self->velocity, 150, self->velocity);
757:
758: // start chunks towards the center
759: VectorScale (size, 0.5, size);
760:
761: mass = self->mass;
762: if (!mass)
763: mass = 75;
764:
765: // big chunks
766: if (mass >= 100)
767: {
768: count = mass / 100;
769: if (count > 8)
770: count = 8;
771: while(count--)
772: {
773: chunkorigin[0] = origin[0] + crandom() * size[0];
774: chunkorigin[1] = origin[1] + crandom() * size[1];
775: chunkorigin[2] = origin[2] + crandom() * size[2];
776: ThrowDebris (self, "models/objects/debris1/tris.md2", 1, chunkorigin);
777: }
778: }
779:
780: // small chunks
781: count = mass / 25;
782: if (count > 16)
783: count = 16;
784: while(count--)
785: {
786: chunkorigin[0] = origin[0] + crandom() * size[0];
787: chunkorigin[1] = origin[1] + crandom() * size[1];
788: chunkorigin[2] = origin[2] + crandom() * size[2];
789: ThrowDebris (self, "models/objects/debris2/tris.md2", 2, chunkorigin);
790: }
791:
792: // PMM - if we're part of a train, clean ourselves out of it
793: if (self->flags & FL_TEAMSLAVE)
794: {
795: if ((g_showlogic) && (g_showlogic->value))
796: gi.dprintf ("Removing func_explosive from train!\n");
797:
798: if (self->teammaster)
799: {
800: master = self->teammaster;
801: if(master && master->inuse) // because mappers (other than jim (usually)) are stupid....
802: {
803: while (!done)
804: {
805: if (master->teamchain == self)
806: {
807: master->teamchain = self->teamchain;
808: done = true;
809: }
810: master = master->teamchain;
811: if (!master)
812: {
813: if ((g_showlogic) && (g_showlogic->value))
814: gi.dprintf ("Couldn't find myself in master's chain, ignoring!\n");
815: }
816: }
817: }
818: }
819: else
820: {
821: if ((g_showlogic) && (g_showlogic->value))
822: gi.dprintf ("No master to free myself from, ignoring!\n");
823: }
824: }
825:
826: G_UseTargets (self, attacker);
827:
828: if (self->dmg)
829: BecomeExplosion1 (self);
830: else
831: G_FreeEdict (self);
832: }
833:
834: void func_explosive_use(edict_t *self, edict_t *other, edict_t *activator)
835: {
836: func_explosive_explode (self, self, other, self->health, vec3_origin);
837: }
838:
839: //PGM
840: void func_explosive_activate(edict_t *self, edict_t *other, edict_t *activator)
841: {
842: int approved;
843:
844: approved = 0;
845: // PMM - looked like target and targetname were flipped here
846: if (other != NULL && other->target)
847: {
848: if(!strcmp(other->target, self->targetname))
849: approved = 1;
850: }
851: if (!approved && activator!=NULL && activator->target)
852: {
853: if(!strcmp(activator->target, self->targetname))
854: approved = 1;
855: }
856:
857: if (!approved)
858: {
859: // gi.dprintf("func_explosive_activate: incorrect activator\n");
860: return;
861: }
862:
863: // PMM - according to mappers, they don't need separate cases for blowupable and triggerable
864: // if (self->target)
865: // {
866: self->use = func_explosive_use;
867: // }
868: // else
869: // {
870: if (!self->health)
871: self->health = 100;
872: self->die = func_explosive_explode;
873: self->takedamage = DAMAGE_YES;
874: // }
875: }
876: //PGM
877:
878: void func_explosive_spawn (edict_t *self, edict_t *other, edict_t *activator)
879: {
880: self->solid = SOLID_BSP;
881: self->svflags &= ~SVF_NOCLIENT;
882: self->use = NULL;
883: KillBox (self);
884: gi.linkentity (self);
885: }
886:
887: void SP_func_explosive (edict_t *self)
888: {
889: if (deathmatch->value)
890: { // auto-remove for deathmatch
891: G_FreeEdict (self);
892: return;
893: }
894:
895: self->movetype = MOVETYPE_PUSH;
896:
897: gi.modelindex ("models/objects/debris1/tris.md2");
898: gi.modelindex ("models/objects/debris2/tris.md2");
899:
900: gi.setmodel (self, self->model);
901:
902: if (self->spawnflags & 1)
903: {
904: self->svflags |= SVF_NOCLIENT;
905: self->solid = SOLID_NOT;
906: self->use = func_explosive_spawn;
907: }
908: //PGM
909: else if(self->spawnflags & 8)
910: {
911: self->solid = SOLID_BSP;
912: if(self->targetname)
913: self->use = func_explosive_activate;
914: }
915: //PGM
916: else
917: {
918: self->solid = SOLID_BSP;
919: if (self->targetname)
920: self->use = func_explosive_use;
921: }
922:
923: if (self->spawnflags & 2)
924: self->s.effects |= EF_ANIM_ALL;
925: if (self->spawnflags & 4)
926: self->s.effects |= EF_ANIM_ALLFAST;
927:
928: //PGM
929: if ((self->use != func_explosive_use) && (self->use != func_explosive_activate))
930: //PGM
931: {
932: if (!self->health)
933: self->health = 100;
934: self->die = func_explosive_explode;
935: self->takedamage = DAMAGE_YES;
936: }
937:
938: gi.linkentity (self);
939: }
940:
941:
942: /*QUAKED misc_explobox (0 .5 .8) (-16 -16 0) (16 16 40)
943: Large exploding box. You can override its mass (100),
944: health (80), and dmg (150).
945: */
946:
947: void barrel_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
948:
949: {
950: float ratio;
951: vec3_t v;
952:
953: if ((!other->groundentity) || (other->groundentity == self))
954: return;
955:
956: ratio = (float)other->mass / (float)self->mass;
957: VectorSubtract (self->s.origin, other->s.origin, v);
958: M_walkmove (self, vectoyaw(v), 20 * ratio * FRAMETIME);
959: }
960:
961: void barrel_explode (edict_t *self)
962: {
963: vec3_t org;
964: float spd;
965: vec3_t save;
966:
967: T_RadiusDamage (self, self->activator, self->dmg, NULL, self->dmg+40, MOD_BARREL);
968:
969: VectorCopy (self->s.origin, save);
970: VectorMA (self->absmin, 0.5, self->size, self->s.origin);
971:
972: // a few big chunks
973: spd = 1.5 * (float)self->dmg / 200.0;
974: org[0] = self->s.origin[0] + crandom() * self->size[0];
975: org[1] = self->s.origin[1] + crandom() * self->size[1];
976: org[2] = self->s.origin[2] + crandom() * self->size[2];
977: ThrowDebris (self, "models/objects/debris1/tris.md2", spd, org);
978: org[0] = self->s.origin[0] + crandom() * self->size[0];
979: org[1] = self->s.origin[1] + crandom() * self->size[1];
980: org[2] = self->s.origin[2] + crandom() * self->size[2];
981: ThrowDebris (self, "models/objects/debris1/tris.md2", spd, org);
982:
983: // bottom corners
984: spd = 1.75 * (float)self->dmg / 200.0;
985: VectorCopy (self->absmin, org);
986: ThrowDebris (self, "models/objects/debris3/tris.md2", spd, org);
987: VectorCopy (self->absmin, org);
988: org[0] += self->size[0];
989: ThrowDebris (self, "models/objects/debris3/tris.md2", spd, org);
990: VectorCopy (self->absmin, org);
991: org[1] += self->size[1];
992: ThrowDebris (self, "models/objects/debris3/tris.md2", spd, org);
993: VectorCopy (self->absmin, org);
994: org[0] += self->size[0];
995: org[1] += self->size[1];
996: ThrowDebris (self, "models/objects/debris3/tris.md2", spd, org);
997:
998: // a bunch of little chunks
999: spd = 2 * self->dmg / 200;
1000: org[0] = self->s.origin[0] + crandom() * self->size[0];
1001: org[1] = self->s.origin[1] + crandom() * self->size[1];
1002: org[2] = self->s.origin[2] + crandom() * self->size[2];
1003: ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
1004: org[0] = self->s.origin[0] + crandom() * self->size[0];
1005: org[1] = self->s.origin[1] + crandom() * self->size[1];
1006: org[2] = self->s.origin[2] + crandom() * self->size[2];
1007: ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
1008: org[0] = self->s.origin[0] + crandom() * self->size[0];
1009: org[1] = self->s.origin[1] + crandom() * self->size[1];
1010: org[2] = self->s.origin[2] + crandom() * self->size[2];
1011: ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
1012: org[0] = self->s.origin[0] + crandom() * self->size[0];
1013: org[1] = self->s.origin[1] + crandom() * self->size[1];
1014: org[2] = self->s.origin[2] + crandom() * self->size[2];
1015: ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
1016: org[0] = self->s.origin[0] + crandom() * self->size[0];
1017: org[1] = self->s.origin[1] + crandom() * self->size[1];
1018: org[2] = self->s.origin[2] + crandom() * self->size[2];
1019: ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
1020: org[0] = self->s.origin[0] + crandom() * self->size[0];
1021: org[1] = self->s.origin[1] + crandom() * self->size[1];
1022: org[2] = self->s.origin[2] + crandom() * self->size[2];
1023: ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
1024: org[0] = self->s.origin[0] + crandom() * self->size[0];
1025: org[1] = self->s.origin[1] + crandom() * self->size[1];
1026: org[2] = self->s.origin[2] + crandom() * self->size[2];
1027: ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
1028: org[0] = self->s.origin[0] + crandom() * self->size[0];
1029: org[1] = self->s.origin[1] + crandom() * self->size[1];
1030: org[2] = self->s.origin[2] + crandom() * self->size[2];
1031: ThrowDebris (self, "models/objects/debris2/tris.md2", spd, org);
1032:
1033: VectorCopy (save, self->s.origin);
1034: if (self->groundentity)
1035: BecomeExplosion2 (self);
1036: else
1037: BecomeExplosion1 (self);
1038: }
1039:
1040: void barrel_delay (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
1041: {
1042: self->takedamage = DAMAGE_NO;
1043: self->nextthink = level.time + 2 * FRAMETIME;
1044: self->think = barrel_explode;
1045: self->activator = attacker;
1046: }
1047:
1048: //=========
1049: //PGM - change so barrels will think and hence, blow up
1050: void barrel_think (edict_t *self)
1051: {
1052: // the think needs to be first since later stuff may override.
1053: self->think = barrel_think;
1054: self->nextthink = level.time + FRAMETIME;
1055:
1056: M_CatagorizePosition (self);
1057: self->flags |= FL_IMMUNE_SLIME;
1058: self->air_finished = level.time + 100;
1059: M_WorldEffects (self);
1060: }
1061:
1062: void barrel_start (edict_t *self)
1063: {
1064: M_droptofloor(self);
1065: self->think = barrel_think;
1066: self->nextthink = level.time + FRAMETIME;
1067: }
1068: //PGM
1069: //=========
1070:
1071: void SP_misc_explobox (edict_t *self)
1072: {
1073: if (deathmatch->value)
1074: { // auto-remove for deathmatch
1075: G_FreeEdict (self);
1076: return;
1077: }
1078:
1079: gi.modelindex ("models/objects/debris1/tris.md2");
1080: gi.modelindex ("models/objects/debris2/tris.md2");
1081: gi.modelindex ("models/objects/debris3/tris.md2");
1082:
1083: self->solid = SOLID_BBOX;
1084: self->movetype = MOVETYPE_STEP;
1085:
1086: self->model = "models/objects/barrels/tris.md2";
1087: self->s.modelindex = gi.modelindex (self->model);
1088: VectorSet (self->mins, -16, -16, 0);
1089: VectorSet (self->maxs, 16, 16, 40);
1090:
1091: if (!self->mass)
1092: self->mass = 400;
1093: if (!self->health)
1094: self->health = 10;
1095: if (!self->dmg)
1096: self->dmg = 150;
1097:
1098: self->die = barrel_delay;
1099: self->takedamage = DAMAGE_YES;
1100: self->monsterinfo.aiflags = AI_NOSTEP;
1101:
1102: self->touch = barrel_touch;
1103:
1104: //PGM - change so barrels will think and hence, blow up
1105: self->think = barrel_start;
1106: self->nextthink = level.time + 2 * FRAMETIME;
1107: //PGM
1108:
1109: gi.linkentity (self);
1110: }
1111:
1112:
1113: //
1114: // miscellaneous specialty items
1115: //
1116:
1117: /*QUAKED misc_blackhole (1 .5 0) (-8 -8 -8) (8 8 8)
1118: */
1119:
1120: void misc_blackhole_use (edict_t *ent, edict_t *other, edict_t *activator)
1121: {
1122: /*
1123: gi.WriteByte (svc_temp_entity);
1124: gi.WriteByte (TE_BOSSTPORT);
1125: gi.WritePosition (ent->s.origin);
1126: gi.multicast (ent->s.origin, MULTICAST_PVS);
1127: */
1128: G_FreeEdict (ent);
1129: }
1130:
1131: void misc_blackhole_think (edict_t *self)
1132: {
1133: if (++self->s.frame < 19)
1134: self->nextthink = level.time + FRAMETIME;
1135: else
1136: {
1137: self->s.frame = 0;
1138: self->nextthink = level.time + FRAMETIME;
1139: }
1140: }
1141:
1142: void SP_misc_blackhole (edict_t *ent)
1143: {
1144: ent->movetype = MOVETYPE_NONE;
1145: ent->solid = SOLID_NOT;
1146: VectorSet (ent->mins, -64, -64, 0);
1147: VectorSet (ent->maxs, 64, 64, 8);
1148: ent->s.modelindex = gi.modelindex ("models/objects/black/tris.md2");
1149: ent->s.renderfx = RF_TRANSLUCENT;
1150: ent->use = misc_blackhole_use;
1151: ent->think = misc_blackhole_think;
1152: ent->nextthink = level.time + 2 * FRAMETIME;
1153: gi.linkentity (ent);
1154: }
1155:
1156: /*QUAKED misc_eastertank (1 .5 0) (-32 -32 -16) (32 32 32)
1157: */
1158:
1159: void misc_eastertank_think (edict_t *self)
1160: {
1161: if (++self->s.frame < 293)
1162: self->nextthink = level.time + FRAMETIME;
1163: else
1164: {
1165: self->s.frame = 254;
1166: self->nextthink = level.time + FRAMETIME;
1167: }
1168: }
1169:
1170: void SP_misc_eastertank (edict_t *ent)
1171: {
1172: ent->movetype = MOVETYPE_NONE;
1173: ent->solid = SOLID_BBOX;
1174: VectorSet (ent->mins, -32, -32, -16);
1175: VectorSet (ent->maxs, 32, 32, 32);
1176: ent->s.modelindex = gi.modelindex ("models/monsters/tank/tris.md2");
1177: ent->s.frame = 254;
1178: ent->think = misc_eastertank_think;
1179: ent->nextthink = level.time + 2 * FRAMETIME;
1180: gi.linkentity (ent);
1181: }
1182:
1183: /*QUAKED misc_easterchick (1 .5 0) (-32 -32 0) (32 32 32)
1184: */
1185:
1186:
1187: void misc_easterchick_think (edict_t *self)
1188: {
1189: if (++self->s.frame < 247)
1190: self->nextthink = level.time + FRAMETIME;
1191: else
1192: {
1193: self->s.frame = 208;
1194: self->nextthink = level.time + FRAMETIME;
1195: }
1196: }
1197:
1198: void SP_misc_easterchick (edict_t *ent)
1199: {
1200: ent->movetype = MOVETYPE_NONE;
1201: ent->solid = SOLID_BBOX;
1202: VectorSet (ent->mins, -32, -32, 0);
1203: VectorSet (ent->maxs, 32, 32, 32);
1204: ent->s.modelindex = gi.modelindex ("models/monsters/bitch/tris.md2");
1205: ent->s.frame = 208;
1206: ent->think = misc_easterchick_think;
1207: ent->nextthink = level.time + 2 * FRAMETIME;
1208: gi.linkentity (ent);
1209: }
1210:
1211: /*QUAKED misc_easterchick2 (1 .5 0) (-32 -32 0) (32 32 32)
1212: */
1213:
1214:
1215: void misc_easterchick2_think (edict_t *self)
1216: {
1217: if (++self->s.frame < 287)
1218: self->nextthink = level.time + FRAMETIME;
1219: else
1220: {
1221: self->s.frame = 248;
1222: self->nextthink = level.time + FRAMETIME;
1223: }
1224: }
1225:
1226: void SP_misc_easterchick2 (edict_t *ent)
1227: {
1228: ent->movetype = MOVETYPE_NONE;
1229: ent->solid = SOLID_BBOX;
1230: VectorSet (ent->mins, -32, -32, 0);
1231: VectorSet (ent->maxs, 32, 32, 32);
1232: ent->s.modelindex = gi.modelindex ("models/monsters/bitch/tris.md2");
1233: ent->s.frame = 248;
1234: ent->think = misc_easterchick2_think;
1235: ent->nextthink = level.time + 2 * FRAMETIME;
1236: gi.linkentity (ent);
1237: }
1238:
1239:
1240: /*QUAKED monster_commander_body (1 .5 0) (-32 -32 0) (32 32 48)
1241: Not really a monster, this is the Tank Commander's decapitated body.
1242: There should be a item_commander_head that has this as it's target.
1243: */
1244:
1245: void commander_body_think (edict_t *self)
1246: {
1247: if (++self->s.frame < 24)
1248: self->nextthink = level.time + FRAMETIME;
1249: else
1250: self->nextthink = 0;
1251:
1252: if (self->s.frame == 22)
1253: gi.sound (self, CHAN_BODY, gi.soundindex ("tank/thud.wav"), 1, ATTN_NORM, 0);
1254: }
1255:
1256: void commander_body_use (edict_t *self, edict_t *other, edict_t *activator)
1257: {
1258: self->think = commander_body_think;
1259: self->nextthink = level.time + FRAMETIME;
1260: gi.sound (self, CHAN_BODY, gi.soundindex ("tank/pain.wav"), 1, ATTN_NORM, 0);
1261: }
1262:
1263: void commander_body_drop (edict_t *self)
1264: {
1265: self->movetype = MOVETYPE_TOSS;
1266: self->s.origin[2] += 2;
1267: }
1268:
1269: void SP_monster_commander_body (edict_t *self)
1270: {
1271: self->movetype = MOVETYPE_NONE;
1272: self->solid = SOLID_BBOX;
1273: self->model = "models/monsters/commandr/tris.md2";
1274: self->s.modelindex = gi.modelindex (self->model);
1275: VectorSet (self->mins, -32, -32, 0);
1276: VectorSet (self->maxs, 32, 32, 48);
1277: self->use = commander_body_use;
1278: self->takedamage = DAMAGE_YES;
1279: self->flags = FL_GODMODE;
1280: self->s.renderfx |= RF_FRAMELERP;
1281: gi.linkentity (self);
1282:
1283: gi.soundindex ("tank/thud.wav");
1284: gi.soundindex ("tank/pain.wav");
1285:
1286: self->think = commander_body_drop;
1287: self->nextthink = level.time + 5 * FRAMETIME;
1288: }
1289:
1290:
1291: /*QUAKED misc_banner (1 .5 0) (-4 -4 -4) (4 4 4)
1292: The origin is the bottom of the banner.
1293: The banner is 128 tall.
1294: */
1295: void misc_banner_think (edict_t *ent)
1296: {
1297: ent->s.frame = (ent->s.frame + 1) % 16;
1298: ent->nextthink = level.time + FRAMETIME;
1299: }
1300:
1301: void SP_misc_banner (edict_t *ent)
1302: {
1303: ent->movetype = MOVETYPE_NONE;
1304: ent->solid = SOLID_NOT;
1305: ent->s.modelindex = gi.modelindex ("models/objects/banner/tris.md2");
1306: ent->s.frame = rand() % 16;
1307: gi.linkentity (ent);
1308:
1309: ent->think = misc_banner_think;
1310: ent->nextthink = level.time + FRAMETIME;
1311: }
1312:
1313: /*QUAKED misc_deadsoldier (1 .5 0) (-16 -16 0) (16 16 16) ON_BACK ON_STOMACH BACK_DECAP FETAL_POS SIT_DECAP IMPALED
1314: This is the dead player model. Comes in 6 exciting different poses!
1315: */
1316: void misc_deadsoldier_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
1317: {
1318: int n;
1319:
1320: // if (self->health > -80)
1321: if (self->health > -30)
1322: return;
1323:
1324: gi.sound (self, CHAN_BODY, gi.soundindex ("misc/udeath.wav"), 1, ATTN_NORM, 0);
1325: for (n= 0; n < 4; n++)
1326: ThrowGib (self, "models/objects/gibs/sm_meat/tris.md2", damage, GIB_ORGANIC);
1327: ThrowHead (self, "models/objects/gibs/head2/tris.md2", damage, GIB_ORGANIC);
1328: }
1329:
1330: void SP_misc_deadsoldier (edict_t *ent)
1331: {
1332: if (deathmatch->value)
1333: { // auto-remove for deathmatch
1334: G_FreeEdict (ent);
1335: return;
1336: }
1337:
1338: ent->movetype = MOVETYPE_NONE;
1339: ent->solid = SOLID_BBOX;
1340: ent->s.modelindex=gi.modelindex ("models/deadbods/dude/tris.md2");
1341:
1342: // Defaults to frame 0
1343: if (ent->spawnflags & 2)
1344: ent->s.frame = 1;
1345: else if (ent->spawnflags & 4)
1346: ent->s.frame = 2;
1347: else if (ent->spawnflags & 8)
1348: ent->s.frame = 3;
1349: else if (ent->spawnflags & 16)
1350: ent->s.frame = 4;
1351: else if (ent->spawnflags & 32)
1352: ent->s.frame = 5;
1353: else
1354: ent->s.frame = 0;
1355:
1356: VectorSet (ent->mins, -16, -16, 0);
1357: VectorSet (ent->maxs, 16, 16, 16);
1358: ent->deadflag = DEAD_DEAD;
1359: ent->takedamage = DAMAGE_YES;
1360: ent->svflags |= SVF_MONSTER|SVF_DEADMONSTER;
1361: ent->die = misc_deadsoldier_die;
1362: ent->monsterinfo.aiflags |= AI_GOOD_GUY;
1363:
1364: gi.linkentity (ent);
1365: }
1366:
1367: /*QUAKED misc_viper (1 .5 0) (-16 -16 0) (16 16 32)
1368: This is the Viper for the flyby bombing.
1369: It is trigger_spawned, so you must have something use it for it to show up.
1370: There must be a path for it to follow once it is activated.
1371:
1372: "speed" How fast the Viper should fly
1373: */
1374:
1375: extern void train_use (edict_t *self, edict_t *other, edict_t *activator);
1376: extern void func_train_find (edict_t *self);
1377:
1378: void misc_viper_use (edict_t *self, edict_t *other, edict_t *activator)
1379: {
1380: self->svflags &= ~SVF_NOCLIENT;
1381: self->use = train_use;
1382: train_use (self, other, activator);
1383: }
1384:
1385: void SP_misc_viper (edict_t *ent)
1386: {
1387: if (!ent->target)
1388: {
1389: gi.dprintf ("misc_viper without a target at %s\n", vtos(ent->absmin));
1390: G_FreeEdict (ent);
1391: return;
1392: }
1393:
1394: if (!ent->speed)
1395: ent->speed = 300;
1396:
1397: ent->movetype = MOVETYPE_PUSH;
1398: ent->solid = SOLID_NOT;
1399: ent->s.modelindex = gi.modelindex ("models/ships/viper/tris.md2");
1400: VectorSet (ent->mins, -16, -16, 0);
1401: VectorSet (ent->maxs, 16, 16, 32);
1402:
1403: ent->think = func_train_find;
1404: ent->nextthink = level.time + FRAMETIME;
1405: ent->use = misc_viper_use;
1406: ent->svflags |= SVF_NOCLIENT;
1407: ent->moveinfo.accel = ent->moveinfo.decel = ent->moveinfo.speed = ent->speed;
1408:
1409: gi.linkentity (ent);
1410: }
1411:
1412:
1413: /*QUAKED misc_bigviper (1 .5 0) (-176 -120 -24) (176 120 72)
1414: This is a large stationary viper as seen in Paul's intro
1415: */
1416: void SP_misc_bigviper (edict_t *ent)
1417: {
1418: ent->movetype = MOVETYPE_NONE;
1419: ent->solid = SOLID_BBOX;
1420: VectorSet (ent->mins, -176, -120, -24);
1421: VectorSet (ent->maxs, 176, 120, 72);
1422: ent->s.modelindex = gi.modelindex ("models/ships/bigviper/tris.md2");
1423: gi.linkentity (ent);
1424: }
1425:
1426:
1427: /*QUAKED misc_viper_bomb (1 0 0) (-8 -8 -8) (8 8 8)
1428: "dmg" how much boom should the bomb make?
1429: */
1430: void misc_viper_bomb_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
1431: {
1432: G_UseTargets (self, self->activator);
1433:
1434: self->s.origin[2] = self->absmin[2] + 1;
1435: T_RadiusDamage (self, self, self->dmg, NULL, self->dmg+40, MOD_BOMB);
1436: BecomeExplosion2 (self);
1437: }
1438:
1439: void misc_viper_bomb_prethink (edict_t *self)
1440: {
1441: vec3_t v;
1442: float diff;
1443:
1444: self->groundentity = NULL;
1445:
1446: diff = self->timestamp - level.time;
1447: if (diff < -1.0)
1448: diff = -1.0;
1449:
1450: VectorScale (self->moveinfo.dir, 1.0 + diff, v);
1451: v[2] = diff;
1452:
1453: diff = self->s.angles[2];
1454: vectoangles (v, self->s.angles);
1455: self->s.angles[2] = diff + 10;
1456: }
1457:
1458: void misc_viper_bomb_use (edict_t *self, edict_t *other, edict_t *activator)
1459: {
1460: edict_t *viper;
1461:
1462: self->solid = SOLID_BBOX;
1463: self->svflags &= ~SVF_NOCLIENT;
1464: self->s.effects |= EF_ROCKET;
1465: self->use = NULL;
1466: self->movetype = MOVETYPE_TOSS;
1467: self->prethink = misc_viper_bomb_prethink;
1468: self->touch = misc_viper_bomb_touch;
1469: self->activator = activator;
1470:
1471: viper = G_Find (NULL, FOFS(classname), "misc_viper");
1472: VectorScale (viper->moveinfo.dir, viper->moveinfo.speed, self->velocity);
1473:
1474: self->timestamp = level.time;
1475: VectorCopy (viper->moveinfo.dir, self->moveinfo.dir);
1476: }
1477:
1478: void SP_misc_viper_bomb (edict_t *self)
1479: {
1480: self->movetype = MOVETYPE_NONE;
1481: self->solid = SOLID_NOT;
1482: VectorSet (self->mins, -8, -8, -8);
1483: VectorSet (self->maxs, 8, 8, 8);
1484:
1485: self->s.modelindex = gi.modelindex ("models/objects/bomb/tris.md2");
1486:
1487: if (!self->dmg)
1488: self->dmg = 1000;
1489:
1490: self->use = misc_viper_bomb_use;
1491: self->svflags |= SVF_NOCLIENT;
1492:
1493: gi.linkentity (self);
1494: }
1495:
1496:
1497: /*QUAKED misc_strogg_ship (1 .5 0) (-16 -16 0) (16 16 32)
1498: This is a Storgg ship for the flybys.
1499: It is trigger_spawned, so you must have something use it for it to show up.
1500: There must be a path for it to follow once it is activated.
1501:
1502: "speed" How fast it should fly
1503: */
1504:
1505: extern void train_use (edict_t *self, edict_t *other, edict_t *activator);
1506: extern void func_train_find (edict_t *self);
1507:
1508: void misc_strogg_ship_use (edict_t *self, edict_t *other, edict_t *activator)
1509: {
1510: self->svflags &= ~SVF_NOCLIENT;
1511: self->use = train_use;
1512: train_use (self, other, activator);
1513: }
1514:
1515: void SP_misc_strogg_ship (edict_t *ent)
1516: {
1517: if (!ent->target)
1518: {
1519: gi.dprintf ("%s without a target at %s\n", ent->classname, vtos(ent->absmin));
1520: G_FreeEdict (ent);
1521: return;
1522: }
1523:
1524: if (!ent->speed)
1525: ent->speed = 300;
1526:
1527: ent->movetype = MOVETYPE_PUSH;
1528: ent->solid = SOLID_NOT;
1529: ent->s.modelindex = gi.modelindex ("models/ships/strogg1/tris.md2");
1530: VectorSet (ent->mins, -16, -16, 0);
1531: VectorSet (ent->maxs, 16, 16, 32);
1532:
1533: ent->think = func_train_find;
1534: ent->nextthink = level.time + FRAMETIME;
1535: ent->use = misc_strogg_ship_use;
1536: ent->svflags |= SVF_NOCLIENT;
1537: ent->moveinfo.accel = ent->moveinfo.decel = ent->moveinfo.speed = ent->speed;
1538:
1539: gi.linkentity (ent);
1540: }
1541:
1542:
1543: /*QUAKED misc_satellite_dish (1 .5 0) (-64 -64 0) (64 64 128)
1544: */
1545: void misc_satellite_dish_think (edict_t *self)
1546: {
1547: self->s.frame++;
1548: if (self->s.frame < 38)
1549: self->nextthink = level.time + FRAMETIME;
1550: }
1551:
1552: void misc_satellite_dish_use (edict_t *self, edict_t *other, edict_t *activator)
1553: {
1554: self->s.frame = 0;
1555: self->think = misc_satellite_dish_think;
1556: self->nextthink = level.time + FRAMETIME;
1557: }
1558:
1559: void SP_misc_satellite_dish (edict_t *ent)
1560: {
1561: ent->movetype = MOVETYPE_NONE;
1562: ent->solid = SOLID_BBOX;
1563: VectorSet (ent->mins, -64, -64, 0);
1564: VectorSet (ent->maxs, 64, 64, 128);
1565: ent->s.modelindex = gi.modelindex ("models/objects/satellite/tris.md2");
1566: ent->use = misc_satellite_dish_use;
1567: gi.linkentity (ent);
1568: }
1569:
1570:
1571: /*QUAKED light_mine1 (0 1 0) (-2 -2 -12) (2 2 12)
1572: */
1573: void SP_light_mine1 (edict_t *ent)
1574: {
1575: ent->movetype = MOVETYPE_NONE;
1576: ent->solid = SOLID_BBOX;
1577: ent->s.modelindex = gi.modelindex ("models/objects/minelite/light1/tris.md2");
1578: gi.linkentity (ent);
1579: }
1580:
1581:
1582: /*QUAKED light_mine2 (0 1 0) (-2 -2 -12) (2 2 12)
1583: */
1584: void SP_light_mine2 (edict_t *ent)
1585: {
1586: ent->movetype = MOVETYPE_NONE;
1587: ent->solid = SOLID_BBOX;
1588: ent->s.modelindex = gi.modelindex ("models/objects/minelite/light2/tris.md2");
1589: gi.linkentity (ent);
1590: }
1591:
1592:
1593: /*QUAKED misc_gib_arm (1 0 0) (-8 -8 -8) (8 8 8)
1594: Intended for use with the target_spawner
1595: */
1596: void SP_misc_gib_arm (edict_t *ent)
1597: {
1598: gi.setmodel (ent, "models/objects/gibs/arm/tris.md2");
1599: ent->solid = SOLID_NOT;
1600: ent->s.effects |= EF_GIB;
1601: ent->takedamage = DAMAGE_YES;
1602: ent->die = gib_die;
1603: ent->movetype = MOVETYPE_TOSS;
1604: ent->svflags |= SVF_MONSTER;
1605: ent->deadflag = DEAD_DEAD;
1606: ent->avelocity[0] = random()*200;
1607: ent->avelocity[1] = random()*200;
1608: ent->avelocity[2] = random()*200;
1609: ent->think = G_FreeEdict;
1610: ent->nextthink = level.time + 30;
1611: gi.linkentity (ent);
1612: }
1613:
1614: /*QUAKED misc_gib_leg (1 0 0) (-8 -8 -8) (8 8 8)
1615: Intended for use with the target_spawner
1616: */
1617: void SP_misc_gib_leg (edict_t *ent)
1618: {
1619: gi.setmodel (ent, "models/objects/gibs/leg/tris.md2");
1620: ent->solid = SOLID_NOT;
1621: ent->s.effects |= EF_GIB;
1622: ent->takedamage = DAMAGE_YES;
1623: ent->die = gib_die;
1624: ent->movetype = MOVETYPE_TOSS;
1625: ent->svflags |= SVF_MONSTER;
1626: ent->deadflag = DEAD_DEAD;
1627: ent->avelocity[0] = random()*200;
1628: ent->avelocity[1] = random()*200;
1629: ent->avelocity[2] = random()*200;
1630: ent->think = G_FreeEdict;
1631: ent->nextthink = level.time + 30;
1632: gi.linkentity (ent);
1633: }
1634:
1635: /*QUAKED misc_gib_head (1 0 0) (-8 -8 -8) (8 8 8)
1636: Intended for use with the target_spawner
1637: */
1638: void SP_misc_gib_head (edict_t *ent)
1639: {
1640: gi.setmodel (ent, "models/objects/gibs/head/tris.md2");
1641: ent->solid = SOLID_NOT;
1642: ent->s.effects |= EF_GIB;
1643: ent->takedamage = DAMAGE_YES;
1644: ent->die = gib_die;
1645: ent->movetype = MOVETYPE_TOSS;
1646: ent->svflags |= SVF_MONSTER;
1647: ent->deadflag = DEAD_DEAD;
1648: ent->avelocity[0] = random()*200;
1649: ent->avelocity[1] = random()*200;
1650: ent->avelocity[2] = random()*200;
1651: ent->think = G_FreeEdict;
1652: ent->nextthink = level.time + 30;
1653: gi.linkentity (ent);
1654: }
1655:
1656: //=====================================================
1657:
1658: /*QUAKED target_character (0 0 1) ?
1659: used with target_string (must be on same "team")
1660: "count" is position in the string (starts at 1)
1661: */
1662:
1663: void SP_target_character (edict_t *self)
1664: {
1665: self->movetype = MOVETYPE_PUSH;
1666: gi.setmodel (self, self->model);
1667: self->solid = SOLID_BSP;
1668: self->s.frame = 12;
1669: gi.linkentity (self);
1670: return;
1671: }
1672:
1673:
1674: /*QUAKED target_string (0 0 1) (-8 -8 -8) (8 8 8)
1675: */
1676:
1677: void target_string_use (edict_t *self, edict_t *other, edict_t *activator)
1678: {
1679: edict_t *e;
1680: int n, l;
1681: char c;
1682:
1683: l = strlen(self->message);
1684: for (e = self->teammaster; e; e = e->teamchain)
1685: {
1686: if (!e->count)
1687: continue;
1688: n = e->count - 1;
1689: if (n > l)
1690: {
1691: e->s.frame = 12;
1692: continue;
1693: }
1694:
1695: c = self->message[n];
1696: if (c >= '0' && c <= '9')
1697: e->s.frame = c - '0';
1698: else if (c == '-')
1699: e->s.frame = 10;
1700: else if (c == ':')
1701: e->s.frame = 11;
1702: else
1703: e->s.frame = 12;
1704: }
1705: }
1706:
1707: void SP_target_string (edict_t *self)
1708: {
1709: if (!self->message)
1710: self->message = "";
1711: self->use = target_string_use;
1712: }
1713:
1714:
1715: /*QUAKED func_clock (0 0 1) (-8 -8 -8) (8 8 8) TIMER_UP TIMER_DOWN START_OFF MULTI_USE
1716: target a target_string with this
1717:
1718: The default is to be a time of day clock
1719:
1720: TIMER_UP and TIMER_DOWN run for "count" seconds and the fire "pathtarget"
1721: If START_OFF, this entity must be used before it starts
1722:
1723: "style" 0 "xx"
1724: 1 "xx:xx"
1725: 2 "xx:xx:xx"
1726: */
1727:
1728: #define CLOCK_MESSAGE_SIZE 16
1729:
1730: // don't let field width of any clock messages change, or it
1731: // could cause an overwrite after a game load
1732:
1733: static void func_clock_reset (edict_t *self)
1734: {
1735: self->activator = NULL;
1736: if (self->spawnflags & 1)
1737: {
1738: self->health = 0;
1739: self->wait = self->count;
1740: }
1741: else if (self->spawnflags & 2)
1742: {
1743: self->health = self->count;
1744: self->wait = 0;
1745: }
1746: }
1747:
1748: static void func_clock_format_countdown (edict_t *self)
1749: {
1750: if (self->style == 0)
1751: {
1752: Com_sprintf (self->message, CLOCK_MESSAGE_SIZE, "%2i", self->health);
1753: return;
1754: }
1755:
1756: if (self->style == 1)
1757: {
1758: Com_sprintf(self->message, CLOCK_MESSAGE_SIZE, "%2i:%2i", self->health / 60, self->health % 60);
1759: if (self->message[3] == ' ')
1760: self->message[3] = '0';
1761: return;
1762: }
1763:
1764: if (self->style == 2)
1765: {
1766: Com_sprintf(self->message, CLOCK_MESSAGE_SIZE, "%2i:%2i:%2i", self->health / 3600, (self->health - (self->health / 3600) * 3600) / 60, self->health % 60);
1767: if (self->message[3] == ' ')
1768: self->message[3] = '0';
1769: if (self->message[6] == ' ')
1770: self->message[6] = '0';
1771: return;
1772: }
1773: }
1774:
1775: void func_clock_think (edict_t *self)
1776: {
1777: if (!self->enemy)
1778: {
1779: self->enemy = G_Find (NULL, FOFS(targetname), self->target);
1780: if (!self->enemy)
1781: return;
1782: }
1783:
1784: if (self->spawnflags & 1)
1785: {
1786: func_clock_format_countdown (self);
1787: self->health++;
1788: }
1789: else if (self->spawnflags & 2)
1790: {
1791: func_clock_format_countdown (self);
1792: self->health--;
1793: }
1794: else
1795: {
1796: struct tm *ltime;
1797: time_t gmtime;
1798:
1799: time(&gmtime);
1800: ltime = localtime(&gmtime);
1801: Com_sprintf (self->message, CLOCK_MESSAGE_SIZE, "%2i:%2i:%2i", ltime->tm_hour, ltime->tm_min, ltime->tm_sec);
1802: if (self->message[3] == ' ')
1803: self->message[3] = '0';
1804: if (self->message[6] == ' ')
1805: self->message[6] = '0';
1806: }
1807:
1808: self->enemy->message = self->message;
1809: self->enemy->use (self->enemy, self, self);
1810:
1811: if (((self->spawnflags & 1) && (self->health > self->wait)) ||
1812: ((self->spawnflags & 2) && (self->health < self->wait)))
1813: {
1814: if (self->pathtarget)
1815: {
1816: char *savetarget;
1817: char *savemessage;
1818:
1819: savetarget = self->target;
1820: savemessage = self->message;
1821: self->target = self->pathtarget;
1822: self->message = NULL;
1823: G_UseTargets (self, self->activator);
1824: self->target = savetarget;
1825: self->message = savemessage;
1826: }
1827:
1828: if (!(self->spawnflags & 8))
1829: return;
1830:
1831: func_clock_reset (self);
1832:
1833: if (self->spawnflags & 4)
1834: return;
1835: }
1836:
1837: self->nextthink = level.time + 1;
1838: }
1839:
1840: void func_clock_use (edict_t *self, edict_t *other, edict_t *activator)
1841: {
1842: if (!(self->spawnflags & 8))
1843: self->use = NULL;
1844: if (self->activator)
1845: return;
1846: self->activator = activator;
1847: self->think (self);
1848: }
1849:
1850: void SP_func_clock (edict_t *self)
1851: {
1852: if (!self->target)
1853: {
1854: gi.dprintf("%s with no target at %s\n", self->classname, vtos(self->s.origin));
1855: G_FreeEdict (self);
1856: return;
1857: }
1858:
1859: if ((self->spawnflags & 2) && (!self->count))
1860: {
1861: gi.dprintf("%s with no count at %s\n", self->classname, vtos(self->s.origin));
1862: G_FreeEdict (self);
1863: return;
1864: }
1865:
1866: if ((self->spawnflags & 1) && (!self->count))
1867: self->count = 60*60;;
1868:
1869: func_clock_reset (self);
1870:
1871: self->message = gi.TagMalloc (CLOCK_MESSAGE_SIZE, TAG_LEVEL);
1872:
1873: self->think = func_clock_think;
1874:
1875: if (self->spawnflags & 4)
1876: self->use = func_clock_use;
1877: else
1878: self->nextthink = level.time + 1;
1879: }
1880:
1881: //=================================================================================
1882:
1883: void teleporter_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
1884: {
1885: edict_t *dest;
1886: int i;
1887:
1888: if (!other->client)
1889: return;
1890: dest = G_Find (NULL, FOFS(targetname), self->target);
1891: if (!dest)
1892: {
1893: gi.dprintf ("Couldn't find destination\n");
1894: return;
1895: }
1896:
1897: // unlink to make sure it can't possibly interfere with KillBox
1898: gi.unlinkentity (other);
1899:
1900: VectorCopy (dest->s.origin, other->s.origin);
1901: VectorCopy (dest->s.origin, other->s.old_origin);
1902: other->s.origin[2] += 10;
1903:
1904: // clear the velocity and hold them in place briefly
1905: VectorClear (other->velocity);
1906: other->client->ps.pmove.pm_time = 160>>3; // hold time
1907: other->client->ps.pmove.pm_flags |= PMF_TIME_TELEPORT;
1908:
1909: // draw the teleport splash at source and on the player
1910: self->owner->s.event = EV_PLAYER_TELEPORT;
1911: other->s.event = EV_PLAYER_TELEPORT;
1912:
1913: // set angles
1914: for (i=0 ; i<3 ; i++)
1915: other->client->ps.pmove.delta_angles[i] = ANGLE2SHORT(dest->s.angles[i] - other->client->resp.cmd_angles[i]);
1916:
1917: VectorClear (other->s.angles);
1918: VectorClear (other->client->ps.viewangles);
1919: VectorClear (other->client->v_angle);
1920:
1921: // kill anything at the destination
1922: KillBox (other);
1923:
1924: gi.linkentity (other);
1925: }
1926:
1927: /*QUAKED misc_teleporter (1 0 0) (-32 -32 -24) (32 32 -16)
1928: Stepping onto this disc will teleport players to the targeted misc_teleporter_dest object.
1929: */
1930: void SP_misc_teleporter (edict_t *ent)
1931: {
1932: edict_t *trig;
1933:
1934: if (!ent->target)
1935: {
1936: gi.dprintf ("teleporter without a target.\n");
1937: G_FreeEdict (ent);
1938: return;
1939: }
1940:
1941: gi.setmodel (ent, "models/objects/dmspot/tris.md2");
1942: ent->s.skinnum = 1;
1943: ent->s.effects = EF_TELEPORTER;
1944: ent->s.sound = gi.soundindex ("world/amb10.wav");
1945: ent->solid = SOLID_BBOX;
1946:
1947: VectorSet (ent->mins, -32, -32, -24);
1948: VectorSet (ent->maxs, 32, 32, -16);
1949: gi.linkentity (ent);
1950:
1951: trig = G_Spawn ();
1952: trig->touch = teleporter_touch;
1953: trig->solid = SOLID_TRIGGER;
1954: trig->target = ent->target;
1955: trig->owner = ent;
1956: VectorCopy (ent->s.origin, trig->s.origin);
1957: VectorSet (trig->mins, -8, -8, 8);
1958: VectorSet (trig->maxs, 8, 8, 24);
1959: gi.linkentity (trig);
1960:
1961: }
1962:
1963: /*QUAKED misc_teleporter_dest (1 0 0) (-32 -32 -24) (32 32 -16)
1964: Point teleporters at these.
1965: */
1966: void SP_misc_teleporter_dest (edict_t *ent)
1967: {
1968: gi.setmodel (ent, "models/objects/dmspot/tris.md2");
1969: ent->s.skinnum = 0;
1970: ent->solid = SOLID_BBOX;
1971: // ent->s.effects |= EF_FLIES;
1972: VectorSet (ent->mins, -32, -32, -24);
1973: VectorSet (ent->maxs, 32, 32, -16);
1974: gi.linkentity (ent);
1975: }
1976:
1977: //======================
1978: //ROGUE
1979: void misc_nuke_core_use (edict_t *self, edict_t *other, edict_t *activator)
1980: {
1981: if(self->svflags & SVF_NOCLIENT)
1982: self->svflags &= ~SVF_NOCLIENT;
1983: else
1984: self->svflags |= SVF_NOCLIENT;
1985: }
1986:
1987: /*QUAKED misc_nuke_core (1 0 0) (-16 -16 -16) (16 16 16)
1988: toggles visible/not visible. starts visible.
1989: */
1990: void SP_misc_nuke_core (edict_t *ent)
1991: {
1992: gi.setmodel (ent, "models/objects/core/tris.md2");
1993: gi.linkentity (ent);
1994:
1995: ent->use = misc_nuke_core_use;
1996: }
1997: //ROGUE
1998: //======================
1999:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.