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