![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_newai.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_newai.c CVS log | Up to [Quake II] / quake2 / rogue |
1.1 root 1:
2: #include "g_local.h"
3:
4: //===============================
5: // BLOCKED Logic
6: //===============================
7:
8: /*
9: gi.WriteByte (svc_temp_entity);
10: gi.WriteByte (TE_DEBUGTRAIL);
11: gi.WritePosition (pt1);
12: gi.WritePosition (pt2);
13: gi.multicast (pt1, MULTICAST_PVS);
14:
15: self->nextthink = level.time + 10;
16: */
17:
18: // plat states, copied from g_func.c
19:
20: #define STATE_TOP 0
21: #define STATE_BOTTOM 1
22: #define STATE_UP 2
23: #define STATE_DOWN 3
24:
25: qboolean face_wall (edict_t *self);
26:
27:
28: // blocked_checkshot
29: // shotchance: 0-1, chance they'll take the shot if it's clear.
30: qboolean blocked_checkshot (edict_t *self, float shotChance)
31: {
32: qboolean playerVisible;
33: // float chance;
34:
35: if(!self->enemy)
36: return false;
37:
38: playerVisible = visible (self, self->enemy);
39: // always shoot at teslas
40: if(playerVisible)
41: {
42: if ((random() < shotChance) || (!strcmp(self->enemy->classname, "tesla")))
43: {
44: if(g_showlogic && g_showlogic->value)
45: gi.dprintf("blocked: taking a shot\n");
46:
47: // turn on AI_BLOCKED to let the monster know the attack is being called
48: // by the blocked functions...
49: self->monsterinfo.aiflags |= AI_BLOCKED;
50:
51: if(self->monsterinfo.attack)
52: self->monsterinfo.attack(self);
53:
54: self->monsterinfo.aiflags &= ~AI_BLOCKED;
55: return true;
56: }
57: }
58: /*
59: // if we're in coop and player is not visible, check for another player 25% of time.
60: else if (coop->value)
61: {
62: // spawned monsters are spread out between enemies already, so make
63: // them less likely to change targets.
64: if (self->monsterinfo.aiflags & AI_SPAWNED_MASK)
65: chance = 0.10;
66: else
67: chance = 0.25;
68:
69: if (random() <= chance)
70: {
71: if(blocked_checknewenemy (self))
72: {
73: return true;
74: }
75: }
76: }
77: */
78: return false;
79: }
80:
81: // blocked_checkplat
82: // dist: how far they are trying to walk.
83: qboolean blocked_checkplat (edict_t *self, float dist)
84: {
85: int playerPosition;
86: trace_t trace;
87: vec3_t pt1, pt2;
88: vec3_t forward;
89: edict_t *plat;
90:
91: if(!self->enemy)
92: return false;
93:
94: // check player's relative altitude
95: if(self->enemy->absmin[2] >= self->absmax[2])
96: playerPosition = 1;
97: else if(self->enemy->absmax[2] <= self->absmin[2])
98: playerPosition = -1;
99: else
100: playerPosition = 0;
101:
102: // if we're close to the same position, don't bother trying plats.
103: if(playerPosition == 0)
104: return false;
105:
106: plat = NULL;
107:
108: // see if we're already standing on a plat.
109: if(self->groundentity && self->groundentity != world)
110: {
111: if(!strncmp(self->groundentity->classname, "func_plat", 8))
112: plat = self->groundentity;
113: }
114:
115: // if we're not, check to see if we'll step onto one with this move
116: if(!plat)
117: {
118: AngleVectors (self->s.angles, forward, NULL, NULL);
119: VectorMA(self->s.origin, dist, forward, pt1);
120: VectorCopy (pt1, pt2);
121: pt2[2] -= 384;
122:
123: trace = gi.trace(pt1, vec3_origin, vec3_origin, pt2, self, MASK_MONSTERSOLID);
124: if(trace.fraction < 1 && !trace.allsolid && !trace.startsolid)
125: {
126: if(!strncmp(trace.ent->classname, "func_plat", 8))
127: {
128: plat = trace.ent;
129: }
130: }
131: }
132:
133: // if we've found a plat, trigger it.
134: if(plat && plat->use)
135: {
136: if (playerPosition == 1)
137: {
138: if((self->groundentity == plat && plat->moveinfo.state == STATE_BOTTOM) ||
139: (self->groundentity != plat && plat->moveinfo.state == STATE_TOP))
140: {
141: if(g_showlogic && g_showlogic->value)
142: gi.dprintf("player above, and plat will raise. using!\n");
143: plat->use (plat, self, self);
144: return true;
145: }
146: }
147: else if(playerPosition == -1)
148: {
149: if((self->groundentity == plat && plat->moveinfo.state == STATE_TOP) ||
150: (self->groundentity != plat && plat->moveinfo.state == STATE_BOTTOM))
151: {
152: if(g_showlogic && g_showlogic->value)
153: gi.dprintf("player below, and plat will lower. using!\n");
154: plat->use (plat, self, self);
155: return true;
156: }
157: }
158: // if(g_showlogic && g_showlogic->value)
159: // gi.dprintf("hit a plat, not using. ppos: %d plat: %d\n", playerPosition, plat->moveinfo.state);
160: }
161:
162: return false;
163: }
164:
165: // blocked_checkjump
166: // dist: how far they are trying to walk.
167: // maxDown/maxUp: how far they'll ok a jump for. set to 0 to disable that direction.
168: qboolean blocked_checkjump (edict_t *self, float dist, float maxDown, float maxUp)
169: {
170: int playerPosition;
171: trace_t trace;
172: vec3_t pt1, pt2;
173: vec3_t forward, up;
174:
175: if(!self->enemy)
176: return false;
177:
178: AngleVectors (self->s.angles, forward, NULL, up);
179:
180: if(self->enemy->absmin[2] > (self->absmin[2] + 16))
181: playerPosition = 1;
182: else if(self->enemy->absmin[2] < (self->absmin[2] - 16))
183: playerPosition = -1;
184: else
185: playerPosition = 0;
186:
187: if(playerPosition == -1 && maxDown)
188: {
189: // check to make sure we can even get to the spot we're going to "fall" from
190: VectorMA(self->s.origin, 48, forward, pt1);
191: trace = gi.trace(self->s.origin, self->mins, self->maxs, pt1, self, MASK_MONSTERSOLID);
192: if(trace.fraction < 1)
193: {
194: // gi.dprintf("can't get thar from hear...\n");
195: return false;
196: }
197:
198: VectorCopy (pt1, pt2);
199: pt2[2] = self->mins[2] - maxDown - 1;
200:
201: trace = gi.trace(pt1, vec3_origin, vec3_origin, pt2, self, MASK_MONSTERSOLID | MASK_WATER);
202: if(trace.fraction < 1 && !trace.allsolid && !trace.startsolid)
203: {
204: if((self->absmin[2] - trace.endpos[2]) >= 24 && trace.contents & MASK_SOLID)
205: {
206: if( (self->enemy->absmin[2] - trace.endpos[2]) > 32)
207: {
208: // if(g_showlogic && g_showlogic->value)
209: // gi.dprintf("That'll take me too far down...%0.1f\n", (self->enemy->absmin[2] - trace.endpos[2]));
210: return false;
211: }
212:
213: if(trace.plane.normal[2] < 0.9)
214: {
215: // gi.dprintf("Floor angle too much! %s\n", vtos(trace.plane.normal));
216: return false;
217: }
218: // if(g_showlogic && g_showlogic->value)
219: // gi.dprintf("Geronimo! %0.1f\n", (self->absmin[2] - trace.endpos[2]));
220: return true;
221: }
222: // else if(g_showlogic && g_showlogic->value)
223: // {
224: // if(!(trace.contents & MASK_SOLID))
225: // gi.dprintf("Ooooh... Bad stuff down there...\n");
226: // else
227: // gi.dprintf("Too far to fall\n");
228: // }
229: }
230: // else if(g_showlogic && g_showlogic->value)
231: // gi.dprintf("Ooooh... Too far to fall...\n");
232: }
233: else if(playerPosition == 1 && maxUp)
234: {
235: VectorMA(self->s.origin, 48, forward, pt1);
236: VectorCopy(pt1, pt2);
237: pt1[2] = self->absmax[2] + maxUp;
238:
239: trace = gi.trace(pt1, vec3_origin, vec3_origin, pt2, self, MASK_MONSTERSOLID | MASK_WATER);
240: if(trace.fraction < 1 && !trace.allsolid && !trace.startsolid)
241: {
242: if((trace.endpos[2] - self->absmin[2]) <= maxUp && trace.contents & MASK_SOLID)
243: {
244: // if(g_showlogic && g_showlogic->value)
245: // gi.dprintf("Jumping Up! %0.1f\n", (trace.endpos[2] - self->absmin[2]));
246:
247: face_wall(self);
248: return true;
249: }
250: // else if(g_showlogic && g_showlogic->value)
251: // gi.dprintf("Too high to jump %0.1f\n", (trace.endpos[2] - self->absmin[2]));
252: }
253: // else if(g_showlogic && g_showlogic->value)
254: // gi.dprintf("Not something I could jump onto\n");
255: }
256: // else if(g_showlogic && g_showlogic->value)
257: // gi.dprintf("Player at similar level. No need to jump up?\n");
258:
259: return false;
260: }
261:
262: // checks to see if another coop player is nearby, and will switch.
263: qboolean blocked_checknewenemy (edict_t *self)
264: {
265: /*
266: int player;
267: edict_t *ent;
268:
269: if (!(coop->value))
270: return false;
271:
272: for (player = 1; player <= game.maxclients; player++)
273: {
274: ent = &g_edicts[player];
275: if (!ent->inuse)
276: continue;
277: if (!ent->client)
278: continue;
279: if (ent == self->enemy)
280: continue;
281:
282: if (visible (self, ent))
283: {
284: if (g_showlogic && g_showlogic->value)
285: gi.dprintf ("B_CNE: %s acquired new enemy %s\n", self->classname, ent->client->pers.netname);
286:
287: self->enemy = ent;
288: FoundTarget (self);
289: return true;
290: }
291: }
292:
293: return false;
294: */
295: return false;
296: }
297:
298: // *************************
299: // HINT PATHS
300: // *************************
301:
302: #define HINT_ENDPOINT 0x0001
303: #define MAX_HINT_CHAINS 100
304:
305: int hint_paths_present;
306: edict_t *hint_path_start[MAX_HINT_CHAINS];
307: int num_hint_paths;
308:
309: //
310: // AI code
311: //
312:
313: // =============
314: // hintpath_findstart - given any hintpath node, finds the start node
315: // =============
316: edict_t *hintpath_findstart(edict_t *ent)
317: {
318: edict_t *e;
319: edict_t *last;
320: int field;
321:
322: if(ent->target) // starting point
323: {
324: last = world;
325: field = FOFS(targetname);
326: e = G_Find(NULL, field, ent->target);
327: while(e)
328: {
329: last = e;
330: if(!e->target)
331: break;
332: e = G_Find(NULL, field, e->target);
333: }
334: }
335: else // end point
336: {
337: last = world;
338: field = FOFS(target);
339: e = G_Find(NULL, field, ent->targetname);
340: while(e)
341: {
342: last = e;
343: if(!e->targetname)
344: break;
345: e = G_Find(NULL, field, e->targetname);
346: }
347: }
348:
349: if(!(last->spawnflags & HINT_ENDPOINT))
350: {
351: gi.dprintf ("end of chain is not HINT_ENDPOINT\n");
352: return NULL;
353: }
354:
355: if(last == world)
356: last = NULL;
357: return last;
358: }
359:
360: // =============
361: // hintpath_other_end - given one endpoint of a hintpath, returns the other end.
362: // =============
363: edict_t *hintpath_other_end(edict_t *ent)
364: {
365: edict_t *e;
366: edict_t *last;
367: int field;
368:
369: if(ent->target) // starting point
370: {
371: last = world;
372: field = FOFS(targetname);
373: e = G_Find(NULL, field, ent->target);
374: while(e)
375: {
376: last = e;
377: if(!e->target)
378: break;
379: e = G_Find(NULL, field, e->target);
380: }
381: }
382: else // end point
383: {
384: last = world;
385: field = FOFS(target);
386: e = G_Find(NULL, field, ent->targetname);
387: while(e)
388: {
389: last = e;
390: if(!e->targetname)
391: break;
392: e = G_Find(NULL, field, e->targetname);
393: }
394: }
395:
396: if(!(last->spawnflags & HINT_ENDPOINT))
397: {
398: gi.dprintf ("end of chain is not HINT_ENDPOINT\n");
399: return NULL;
400: }
401:
402: if(last == world)
403: last = NULL;
404: return last;
405: }
406:
407: // =============
408: // hintpath_go - starts a monster (self) moving towards the hintpath (point)
409: // disables all contrary AI flags.
410: // =============
411: void hintpath_go (edict_t *self, edict_t *point)
412: {
413: vec3_t dir;
414: vec3_t angles;
415:
416: VectorSubtract(point->s.origin, self->s.origin, dir);
417: vectoangles2(dir, angles);
418:
419: self->ideal_yaw = angles[YAW];
420: self->goalentity = self->movetarget = point;
421: self->monsterinfo.pausetime = 0;
422: self->monsterinfo.aiflags |= AI_HINT_PATH;
423: self->monsterinfo.aiflags &= ~(AI_SOUND_TARGET | AI_PURSUIT_LAST_SEEN | AI_PURSUE_NEXT | AI_PURSUE_TEMP);
424: // run for it
425: self->monsterinfo.search_time = level.time;
426: self->monsterinfo.run (self);
427: }
428:
429: // =============
430: // hintpath_stop - bails a monster out of following hint paths
431: // =============
432: void hintpath_stop (edict_t *self)
433: {
434: self->goalentity = NULL;
435: self->movetarget = NULL;
436: // self->monsterinfo.last_hint = NULL;
437: self->monsterinfo.last_hint_time = level.time;
438: self->monsterinfo.goal_hint = NULL;
439: self->monsterinfo.aiflags &= ~AI_HINT_PATH;
440: if((has_valid_enemy(self)) && (visible (self, self->enemy)))
441: FoundTarget (self);
442: else
443: {
444: // we need the pausetime otherwise the stand code
445: // will just revert to walking with no target and
446: // the monsters will wonder around aimlessly trying
447: // to hunt the world entity
448: self->monsterinfo.pausetime = level.time + 100000000;
449: self->monsterinfo.stand (self);
450: }
451: return;
452: }
453:
454: // =============
455: // monsterlost_checkhint - the monster (self) will check around for valid hintpaths.
456: // a valid hintpath is one where the two endpoints can see both the monster
457: // and the monster's enemy. if only one person is visible from the endpoints,
458: // it will not go for it.
459: // =============
460: qboolean monsterlost_checkhint2 (edict_t *self);
461:
462: qboolean monsterlost_checkhint (edict_t *self)
463: {
464: edict_t *e, *monster_pathchain, *target_pathchain, *checkpoint;
465: edict_t *closest;
466: float closest_range = 1000000;
467: edict_t *start, *destination;
468: int field;
469: int count1=0, count2=0, count3=0, count4=0, count5=0;
470: float r;
471: int i;
472: qboolean hint_path_represented[MAX_HINT_CHAINS];
473:
474: // if there are no hint paths on this map, exit immediately.
475: if(!hint_paths_present)
476: return false;
477:
478: if(!self->enemy)
479: return false;
480:
481: if (self->monsterinfo.aiflags & AI_STAND_GROUND)
482: return false;
483:
484: if (!strcmp(self->classname, "monster_turret"))
485: return false;
486:
487: monster_pathchain = NULL;
488:
489: field = FOFS(classname);
490:
491: // find all the hint_paths.
492: // FIXME - can we not do this every time?
493: for (i=0; i < num_hint_paths; i++)
494: {
495: e = hint_path_start[i];
496: while(e)
497: {
498: count1++;
499: if (e->monster_hint_chain)
500: {
501: // gi.dprintf ("uh, oh, I didn't clean up after myself\n");
502: e->monster_hint_chain = NULL;
503: }
504: if (monster_pathchain)
505: {
506: checkpoint->monster_hint_chain = e;
507: checkpoint = e;
508: }
509: else
510: {
511: monster_pathchain = e;
512: checkpoint = e;
513: }
514: e = e->hint_chain;
515: }
516: }
517:
518: // filter them by distance and visibility to the monster
519: e = monster_pathchain;
520: checkpoint = NULL;
521: while (e)
522: {
523: r = realrange (self, e);
524:
525: // if (r > 512)
526: // count3++;
527:
528: if (r > 512)
529: {
530: count2++;
531: if (g_showlogic && g_showlogic->value)
532: {
533: gi.dprintf ("MONSTER (%s) DISTANCE: ", self->classname);
534: if (e->targetname)
535: gi.dprintf ("targetname %s\n", e->targetname);
536: else
537: gi.dprintf ("start -> %s\n", e->target);
538: }
539: if (checkpoint)
540: {
541: checkpoint->monster_hint_chain = e->monster_hint_chain;
542: e->monster_hint_chain = NULL;
543: e = checkpoint->monster_hint_chain;
544: continue;
545: }
546: else
547: {
548: // use checkpoint as temp pointer
549: checkpoint = e;
550: e = e->monster_hint_chain;
551: checkpoint->monster_hint_chain = NULL;
552: // and clear it again
553: checkpoint = NULL;
554: // since we have yet to find a valid one (or else checkpoint would be set) move the
555: // start of monster_pathchain
556: monster_pathchain = e;
557: continue;
558: }
559: }
560: if (!visible(self, e))
561: {
562: count4++;
563: if (g_showlogic && g_showlogic->value)
564: {
565: gi.dprintf ("MONSTER (%s) VISIBILITY: ", self->classname);
566: if (e->targetname)
567: gi.dprintf ("targetname %s\n", e->targetname);
568: else
569: gi.dprintf ("start -> %s\n", e->target);
570: }
571: if (checkpoint)
572: {
573: checkpoint->monster_hint_chain = e->monster_hint_chain;
574: e->monster_hint_chain = NULL;
575: e = checkpoint->monster_hint_chain;
576: continue;
577: }
578: else
579: {
580: // use checkpoint as temp pointer
581: checkpoint = e;
582: e = e->monster_hint_chain;
583: checkpoint->monster_hint_chain = NULL;
584: // and clear it again
585: checkpoint = NULL;
586: // since we have yet to find a valid one (or else checkpoint would be set) move the
587: // start of monster_pathchain
588: monster_pathchain = e;
589: continue;
590: }
591: }
592: // if it passes all the tests, it's a keeper
593: if (g_showlogic && g_showlogic->value)
594: {
595: gi.dprintf ("MONSTER (%s) ACCEPT: ", self->classname);
596: if (e->targetname)
597: gi.dprintf ("targetname %s\n", e->targetname);
598: else
599: gi.dprintf ("start -> %s\n", e->target);
600: }
601: count5++;
602: checkpoint = e;
603: e = e->monster_hint_chain;
604: }
605:
606: // at this point, we have a list of all of the eligible hint nodes for the monster
607: // we now take them, figure out what hint chains they're on, and traverse down those chains,
608: // seeing whether any can see the player
609: //
610: // first, we figure out which hint chains we have represented in monster_pathchain
611: if (count5 == 0)
612: {
613: if ((g_showlogic) && (g_showlogic->value))
614: gi.dprintf ("No eligible hint paths found.\n");
615: return false;
616: }
617:
618: for (i=0; i < num_hint_paths; i++)
619: {
620: hint_path_represented[i] = false;
621: }
622: e = monster_pathchain;
623: checkpoint = NULL;
624: while (e)
625: {
626: if ((e->hint_chain_id < 0) || (e->hint_chain_id > num_hint_paths))
627: {
628: if (g_showlogic && g_showlogic->value)
629: gi.dprintf ("bad hint_chain_id! %d\n", e->hint_chain_id);
630: return false;
631: }
632: hint_path_represented[e->hint_chain_id] = true;
633: e = e->monster_hint_chain;
634: }
635:
636: count1 = 0;
637: count2 = 0;
638: count3 = 0;
639: count4 = 0;
640: count5 = 0;
641:
642: // now, build the target_pathchain which contains all of the hint_path nodes we need to check for
643: // validity (within range, visibility)
644: target_pathchain = NULL;
645: checkpoint = NULL;
646: for (i=0; i < num_hint_paths; i++)
647: {
648: // if this hint chain is represented in the monster_hint_chain, add all of it's nodes to the target_pathchain
649: // for validity checking
650: if (hint_path_represented[i])
651: {
652: e = hint_path_start[i];
653: while (e)
654: {
655: if (target_pathchain)
656: {
657: checkpoint->target_hint_chain = e;
658: checkpoint = e;
659: }
660: else
661: {
662: target_pathchain = e;
663: checkpoint = e;
664: }
665: e = e->hint_chain;
666: }
667: }
668: }
669:
670: // target_pathchain is a list of all of the hint_path nodes we need to check for validity relative to the target
671: e = target_pathchain;
672: checkpoint = NULL;
673: while (e)
674: {
675: r = realrange (self->enemy, e);
676:
677: // if (r > 512)
678: // count3++;
679:
680: if (r > 512)
681: {
682: count2++;
683: if (g_showlogic && g_showlogic->value)
684: {
685: gi.dprintf ("TARGET RANGE: ");
686: if (e->targetname)
687: gi.dprintf ("targetname %s\n", e->targetname);
688: else
689: gi.dprintf ("start -> %s\n", e->target);
690: }
691: if (checkpoint)
692: {
693: checkpoint->target_hint_chain = e->target_hint_chain;
694: e->target_hint_chain = NULL;
695: e = checkpoint->target_hint_chain;
696: continue;
697: }
698: else
699: {
700: // use checkpoint as temp pointer
701: checkpoint = e;
702: e = e->target_hint_chain;
703: checkpoint->target_hint_chain = NULL;
704: // and clear it again
705: checkpoint = NULL;
706: target_pathchain = e;
707: continue;
708: }
709: }
710: if (!visible(self->enemy, e))
711: {
712: count4++;
713: if (g_showlogic && g_showlogic->value)
714: {
715: gi.dprintf ("TARGET VISIBILITY: ");
716: if (e->targetname)
717: gi.dprintf ("targetname %s\n", e->targetname);
718: else
719: gi.dprintf ("start -> %s\n", e->target);
720: }
721: if (checkpoint)
722: {
723: checkpoint->target_hint_chain = e->target_hint_chain;
724: e->target_hint_chain = NULL;
725: e = checkpoint->target_hint_chain;
726: continue;
727: }
728: else
729: {
730: // use checkpoint as temp pointer
731: checkpoint = e;
732: e = e->target_hint_chain;
733: checkpoint->target_hint_chain = NULL;
734: // and clear it again
735: checkpoint = NULL;
736: target_pathchain = e;
737: continue;
738: }
739: }
740: // if it passes all the tests, it's a keeper
741: if (g_showlogic && g_showlogic->value)
742: {
743: gi.dprintf ("TARGET ACCEPT: ");
744: if (e->targetname)
745: gi.dprintf ("targetname %s\n", e->targetname);
746: else
747: gi.dprintf ("start -> %s\n", e->target);
748: }
749: count5++;
750: checkpoint = e;
751: e = e->target_hint_chain;
752: }
753:
754: // at this point we should have:
755: // monster_pathchain - a list of "monster valid" hint_path nodes linked together by monster_hint_chain
756: // target_pathcain - a list of "target valid" hint_path nodes linked together by target_hint_chain. these
757: // are filtered such that only nodes which are on the same chain as "monster valid" nodes
758: //
759: // Now, we figure out which "monster valid" node we want to use
760: //
761: // To do this, we first off make sure we have some target nodes. If we don't, there are no valid hint_path nodes
762: // for us to take
763: //
764: // If we have some, we filter all of our "monster valid" nodes by which ones have "target valid" nodes on them
765: //
766: // Once this filter is finished, we select the closest "monster valid" node, and go to it.
767:
768: if (count5 == 0)
769: {
770: if ((g_showlogic) && (g_showlogic->value))
771: gi.dprintf ("No valid target nodes found\n");
772: return false;
773: }
774:
775: // reuse the hint_chain_represented array, this time to see which chains are represented by the target
776: for (i=0; i < num_hint_paths; i++)
777: {
778: hint_path_represented[i] = false;
779: }
780:
781: e = target_pathchain;
782: checkpoint = NULL;
783: while (e)
784: {
785: if ((e->hint_chain_id < 0) || (e->hint_chain_id > num_hint_paths))
786: {
787: gi.dprintf ("bad hint_chain_id! %d\n", e->hint_chain_id);
788: return false;
789: }
790: hint_path_represented[e->hint_chain_id] = true;
791: e = e->target_hint_chain;
792: }
793:
794: // traverse the monster_pathchain - if the hint_node isn't represented in the "target valid" chain list,
795: // remove it
796: // if it is on the list, check it for range from the monster. If the range is the closest, keep it
797: //
798: closest = NULL;
799: e = monster_pathchain;
800: while (e)
801: {
802: if (!(hint_path_represented[e->hint_chain_id]))
803: {
804: checkpoint = e->monster_hint_chain;
805: e->monster_hint_chain = NULL;
806: e = checkpoint;
807: continue;
808: }
809: r = realrange(self, e);
810: if (r < closest_range)
811: closest = e;
812: e = e->monster_hint_chain;
813: }
814:
815: if (!closest)
816: {
817: if ((g_showlogic) && (g_showlogic->value))
818: gi.dprintf ("Failed to find closest node for monster. Shouldn't happen.\n");
819: return false;
820: }
821:
822: start = closest;
823: // now we know which one is the closest to the monster .. this is the one the monster will go to
824: // we need to finally determine what the DESTINATION node is for the monster .. walk down the hint_chain,
825: // and find the closest one to the player
826:
827: closest = NULL;
828: closest_range = 10000000;
829: e = target_pathchain;
830: while (e)
831: {
832: if (start->hint_chain_id == e->hint_chain_id)
833: {
834: r = realrange(self, e);
835: if (r < closest_range)
836: closest = e;
837: }
838: e = e->target_hint_chain;
839: }
840:
841: if (!closest)
842: {
843: if ((g_showlogic) && (g_showlogic->value))
844: gi.dprintf ("Failed to find closest node for target. Shouldn't happen.\n");
845: return false;
846: }
847:
848: destination = closest;
849:
850: self->monsterinfo.goal_hint = destination;
851: // self->monsterinfo.last_hint = NULL;
852: hintpath_go(self, start);
853:
854: if(g_showlogic && g_showlogic->value)
855: {
856: gi.dprintf ("found path. proceed to ");
857: if (start->targetname)
858: gi.dprintf ("%s to get to ", start->targetname);
859: else
860: gi.dprintf ("start (->%s) to get to ", start->target);
861: if (destination->targetname)
862: gi.dprintf ("%s.", destination->targetname);
863: else
864: gi.dprintf ("start (->%s)", destination->target);
865: }
866: // gi.dprintf("found path. proceed to %s to get to %s\n", vtos(start->s.origin), vtos(destination->s.origin));
867:
868: return true;
869: }
870: /*
871: qboolean monsterlost_checkhint2 (edict_t *self)
872: {
873: edict_t *e, *e2, *goPoint;
874: int field;
875: int playerVisible, selfVisible;
876:
877: // if there are no hint paths on this map, exit immediately.
878: if(!hint_paths_present)
879: return false;
880:
881: if(!self->enemy)
882: return false;
883:
884: goPoint = NULL;
885: field = FOFS(classname);
886:
887: // check all the hint_paths.
888: e = G_Find(NULL, field, "hint_path");
889: while(e)
890: {
891: // if it's an endpoint, check for "validity"
892: if(e->spawnflags & HINT_ENDPOINT)
893: {
894: // check visibility from this spot
895: selfVisible = visible(e, self);
896: playerVisible = visible(e, self->enemy);
897: // gi.dprintf("checking endpoint at %s %d %d\n", vtos(e->s.origin),selfVisible,playerVisible);
898:
899: // at least one of us is visible from this endpoint.
900: // now check the other one if needed.
901: if(selfVisible || playerVisible)
902: {
903: // if endpoint 1 saw me, set my destination to it.
904: if(selfVisible)
905: goPoint = e;
906:
907: // if both aren't visible, try the other endpoint
908: if(!selfVisible || !playerVisible)
909: {
910: e2 = hintpath_other_end(e);
911: if(!e2) // could not connect to the other endpoint
912: {
913: gi.dprintf("Unlinked hint paths!\n");
914: return false;
915: }
916:
917: // if endpoint 1 saw the enemy, see if endpoint 2 sees me
918: if(!selfVisible)
919: selfVisible = visible(e2, self);
920: // if endpoint 1 saw me, see if endpoint 2 sees the enemy
921: else if(!playerVisible)
922: playerVisible = visible(e2, self->enemy);
923:
924: // if endpoint 2 saw me, set my destination to it.
925: if(!goPoint && selfVisible)
926: goPoint = e2;
927:
928: // gi.dprintf("checking other endpoint at %s %d %d\n", vtos(e2->s.origin),selfVisible,playerVisible);
929: }
930:
931: // if both are visible from at least one endpoint,
932: // go for it.
933: if(selfVisible && playerVisible)
934: {
935: // set me to go to goPoint
936: if(g_showlogic && g_showlogic->value)
937: gi.dprintf("found path. proceed to %s\n", vtos(goPoint->s.origin));
938:
939: // since this is a new hint path trip, set last_hint to NULL
940: self->monsterinfo.last_hint = NULL;
941: hintpath_go(self, goPoint);
942: return true;
943: }
944: }
945: }
946: e = G_Find(e, field, "hint_path");
947: }
948:
949: // if we got here, we didn't find a valid path
950: if(g_showlogic && g_showlogic->value)
951: gi.dprintf("blocked_checkhint: found no paths\n");
952: return false;
953: }
954: */
955: //
956: // Path code
957: //
958:
959: // =============
960: // hint_path_touch - someone's touched the hint_path
961: // =============
962: void hint_path_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
963: {
964: edict_t *e, *goal, *next;
965: // int chain; // direction - (-1) = upstream, (1) = downstream, (0) = done
966: qboolean goalFound = false;
967:
968: // make sure we're the target of it's obsession
969: if(other->movetarget == self)
970: {
971: goal = other->monsterinfo.goal_hint;
972:
973: // if the monster is where he wants to be
974: if (goal == self)
975: {
976: if(g_showlogic && g_showlogic->value)
977: gi.dprintf("Got to goal, detatching\n");
978: hintpath_stop (other);
979: return;
980: }
981: else
982: {
983: // if we aren't, figure out which way we want to go
984: e = hint_path_start[self->hint_chain_id];
985: while (e)
986: {
987: // if we get up to ourselves on the hint chain, we're going down it
988: if (e == self)
989: {
990: next = e->hint_chain;
991: break;
992: }
993: if (e == goal)
994: goalFound = true;
995: // if we get to where the next link on the chain is this hint_path and have found the goal on the way
996: // we're going upstream, so remember who the previous link is
997: if ((e->hint_chain == self) && goalFound)
998: {
999: next = e;
1000: break;
1001: }
1002: e = e->hint_chain;
1003: }
1004: }
1005:
1006: // if we couldn't find it, have the monster go back to normal hunting.
1007: if(!next)
1008: {
1009: if(g_showlogic && g_showlogic->value)
1010: gi.dprintf("couldn't figure out next node, dropping hint path\n");
1011: hintpath_stop(other);
1012: return;
1013: }
1014:
1015: // set the last_hint entry to this hint_path, and
1016: // send him on his way
1017: // other->monsterinfo.last_hint = self;
1018: if(g_showlogic && g_showlogic->value)
1019: {
1020: gi.dprintf("moving to next point, ");
1021: if (next->targetname)
1022: gi.dprintf ("targetname %s\n", next->targetname);
1023: else
1024: gi.dprintf ("start -> %s\n", next->target);
1025: }
1026: hintpath_go(other, next);
1027:
1028: // have the monster freeze if the hint path we just touched has a wait time
1029: // on it, for example, when riding a plat.
1030: if(self->wait)
1031: {
1032: if(g_showlogic && g_showlogic->value)
1033: gi.dprintf("monster waiting %0.1f\n", self->wait);
1034: other->nextthink = level.time + self->wait;
1035: }
1036: }
1037: }
1038: /*
1039: void hint_path_touch2 (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
1040: {
1041: edict_t *next, *last;
1042: int chain;
1043:
1044: // make sure we're the target of it's obsession
1045: if(other->movetarget == self)
1046: {
1047: chain = 0; // direction the monster is going in the chain
1048: next = NULL; // next hint_path
1049:
1050: // gi.dprintf("hint_path %s\n", vtos(self->s.origin));
1051: // is this the first hintpath targeted? if so, we can do this easily.
1052: if(other->monsterinfo.last_hint == NULL)
1053: {
1054: if(self->target) // forward chaining
1055: chain = 1;
1056: else // backward chaining
1057: chain = -1;
1058: }
1059: else
1060: {
1061: // shortcut to last_hint
1062: last = other->monsterinfo.last_hint;
1063:
1064: // make sure it's valid...
1065: if ( (last < g_edicts) || (last >= &g_edicts[globals.num_edicts]))
1066: {
1067: if(g_showlogic && g_showlogic->value)
1068: {
1069: gi.dprintf("bogus last_hint encountered.\n");
1070: gi.dprintf("detaching from hint path %d\n", chain);
1071: }
1072: hintpath_stop (other);
1073: return;
1074: }
1075:
1076: // if we're an endpoint, then the monster is done moving.
1077: if(self->spawnflags & HINT_ENDPOINT)
1078: {
1079: chain = 0;
1080: }
1081: // if last hint's target is our targetname, it's forward chaining.
1082: else if(last->target && self->targetname && !strcmp(last->target, self->targetname))
1083: {
1084: chain = 1;
1085: }
1086: // if last hint's targetname is our target, it's backward chaining.
1087: // FIXME - last->targetname was 1, not NULL ???? was a screwed up hintpath
1088: else if(self->target && last->targetname && !strcmp(last->targetname, self->target))
1089: {
1090: chain = -1;
1091: }
1092: else // if it gets here, i'm not sure how
1093: {
1094: gi.dprintf("hit an uncovered possibility in hint_path_touch\n");
1095: chain = 0;
1096: }
1097: }
1098:
1099: // find the "next" hint_path
1100: if(chain == 1 && self->target) // forward chaining
1101: next = G_Find(NULL, FOFS(targetname), self->target);
1102: else if(chain == -1 && self->targetname) // backward chaining
1103: next = G_Find(NULL, FOFS(target), self->targetname);
1104:
1105: // if we couldn't find it, have the monster go back to normal hunting.
1106: if(!next)
1107: {
1108: if(g_showlogic && g_showlogic->value)
1109: gi.dprintf("detaching from hint path %d\n", chain);
1110: hintpath_stop(other);
1111: return;
1112: }
1113:
1114: // set the last_hint entry to this hint_path, and
1115: // send him on his way
1116: other->monsterinfo.last_hint = self;
1117: if(g_showlogic && g_showlogic->value)
1118: gi.dprintf("moving to next point, %s\n", vtos(next->s.origin));
1119: hintpath_go(other, next);
1120:
1121: // have the monster freeze if the hint path we just touched has a wait time
1122: // on it, for example, when riding a plat.
1123: if(self->wait)
1124: {
1125: if(g_showlogic && g_showlogic->value)
1126: gi.dprintf("monster waiting %0.1f\n", self->wait);
1127: other->nextthink = level.time + self->wait;
1128: }
1129: }
1130: }
1131: */
1132:
1133: /*QUAKED hint_path (.5 .3 0) (-8 -8 -8) (8 8 8) END
1134: Target: next hint path
1135:
1136: END - set this flag on the endpoints of each hintpath.
1137:
1138: "wait" - set this if you want the monster to freeze when they touch this hintpath
1139: */
1140: void SP_hint_path (edict_t *self)
1141: {
1142: if (deathmatch->value)
1143: {
1144: G_FreeEdict(self);
1145: return;
1146: }
1147:
1148: if (!self->targetname && !self->target)
1149: {
1150: gi.dprintf ("unlinked hint_path at %s\n", vtos(self->s.origin));
1151: G_FreeEdict (self);
1152: return;
1153: }
1154:
1155: self->solid = SOLID_TRIGGER;
1156: self->touch = hint_path_touch;
1157: VectorSet (self->mins, -8, -8, -8);
1158: VectorSet (self->maxs, 8, 8, 8);
1159: self->svflags |= SVF_NOCLIENT;
1160: gi.linkentity (self);
1161: }
1162:
1163: //int hint_paths_present;
1164: //edict_t *hint_path_start[100];
1165: //int num_hint_paths;
1166:
1167: // ============
1168: // InitHintPaths - Called by InitGame (g_save) to enable quick exits if valid
1169: // ============
1170: void InitHintPaths (void)
1171: {
1172: edict_t *e, *current;
1173: int field, i, count2;
1174:
1175: hint_paths_present = 0;
1176:
1177: // check all the hint_paths.
1178: field = FOFS(classname);
1179: e = G_Find(NULL, field, "hint_path");
1180: if(e)
1181: {
1182: // gi.dprintf("hint paths present on map\n");
1183: hint_paths_present = 1;
1184: }
1185: else
1186: {
1187: // if ((g_showlogic) && (g_showlogic->value))
1188: // gi.dprintf ("hint paths not present on map\n");
1189: return;
1190: }
1191:
1192: memset (hint_path_start, 0, MAX_HINT_CHAINS*sizeof (edict_t *));
1193: num_hint_paths = 0;
1194: while(e)
1195: {
1196: if(e->spawnflags & HINT_ENDPOINT)
1197: {
1198: if (e->target) // start point
1199: {
1200: if (num_hint_paths >= MAX_HINT_CHAINS)
1201: {
1202: // gi.dprintf ("Only %d hint chains allowed. Connect some together!\n", MAX_HINT_CHAINS);
1203: break;
1204: }
1205: hint_path_start[num_hint_paths++] = e;
1206: }
1207: }
1208: e = G_Find(e, field, "hint_path");
1209: }
1210:
1211: field = FOFS(targetname);
1212: for (i=0; i< num_hint_paths; i++)
1213: {
1214: count2 = 1;
1215: current = hint_path_start[i];
1216: current->hint_chain_id = i;
1217: // gi.dprintf ("start ");
1218: e = G_Find(NULL, field, current->target);
1219: while (e)
1220: {
1221: count2++;
1222: current->hint_chain = e;
1223: current = e;
1224: current->hint_chain_id = i;
1225: // gi.dprintf ("-> %s ", e->targetname);
1226: if (!e->target)
1227: break;
1228: e = G_Find(NULL, field, e->target);
1229: }
1230: // if ((g_showlogic) && (g_showlogic->value))
1231: // gi.dprintf ("\nhint_path #%d, %d elements\n", i, count2);
1232: }
1233: // if ((g_showlogic) && (g_showlogic->value))
1234: // gi.dprintf ("hint_path processing done\n");
1235: }
1236:
1237: // *****************************
1238: // MISCELLANEOUS STUFF
1239: // *****************************
1240:
1241: // PMM - inback
1242: // use to see if opponent is behind you (not to side)
1243: // if it looks a lot like infront, well, there's a reason
1244:
1245: qboolean inback (edict_t *self, edict_t *other)
1246: {
1247: vec3_t vec;
1248: float dot;
1249: vec3_t forward;
1250:
1251: AngleVectors (self->s.angles, forward, NULL, NULL);
1252: VectorSubtract (other->s.origin, self->s.origin, vec);
1253: VectorNormalize (vec);
1254: dot = DotProduct (vec, forward);
1255:
1256: if (dot < -0.3)
1257: return true;
1258: return false;
1259: }
1260:
1261: float realrange (edict_t *self, edict_t *other)
1262: {
1263: vec3_t dir;
1264:
1265: VectorSubtract (self->s.origin, other->s.origin, dir);
1266:
1267: return VectorLength(dir);
1268: }
1269:
1270: qboolean face_wall (edict_t *self)
1271: {
1272: vec3_t pt;
1273: vec3_t forward;
1274: vec3_t ang;
1275: trace_t tr;
1276:
1277: AngleVectors (self->s.angles, forward, NULL, NULL);
1278: VectorMA(self->s.origin, 64, forward, pt);
1279: tr = gi.trace(self->s.origin, vec3_origin, vec3_origin, pt, self, MASK_MONSTERSOLID);
1280: if(tr.fraction < 1 && !tr.allsolid && !tr.startsolid)
1281: {
1282: vectoangles2(tr.plane.normal, ang);
1283: self->ideal_yaw = ang[YAW] + 180;
1284: if(self->ideal_yaw > 360)
1285: self->ideal_yaw -= 360;
1286:
1287: // if(g_showlogic && g_showlogic->value)
1288: // gi.dprintf("facing wall, dir %0.1f/%0.1f\n", ang[YAW], self->ideal_yaw);
1289: M_ChangeYaw(self);
1290: return true;
1291: }
1292:
1293: return false;
1294: }
1295:
1296: //
1297: // Monster "Bad" Areas
1298: //
1299:
1300: void badarea_touch (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
1301: {
1302: // drawbbox(ent);
1303: }
1304:
1305: edict_t *SpawnBadArea(vec3_t mins, vec3_t maxs, float lifespan, edict_t *owner)
1306: {
1307: edict_t *badarea;
1308: vec3_t origin;
1309:
1310: VectorAdd(mins, maxs, origin);
1311: VectorScale(origin, 0.5, origin);
1312:
1313: VectorSubtract(maxs, origin, maxs);
1314: VectorSubtract(mins, origin, mins);
1315:
1316: badarea = G_Spawn();
1317: VectorCopy(origin, badarea->s.origin);
1318: VectorCopy(maxs, badarea->maxs);
1319: VectorCopy(mins, badarea->mins);
1320: badarea->touch = badarea_touch;
1321: badarea->movetype = MOVETYPE_NONE;
1322: badarea->solid = SOLID_TRIGGER;
1323: badarea->classname = "bad_area";
1324: gi.linkentity (badarea);
1325:
1326: // gi.dprintf("(%s)-(%s)\n", vtos(badarea->absmin), vtos(badarea->absmax));
1327:
1328: if(lifespan)
1329: {
1330: badarea->think = G_FreeEdict;
1331: badarea->nextthink = level.time + lifespan;
1332: }
1333: if(owner)
1334: {
1335: badarea->owner = owner;
1336: }
1337:
1338: // drawbbox(badarea);
1339: return badarea;
1340: }
1341:
1342: // CheckForBadArea
1343: // This is a customized version of G_TouchTriggers that will check
1344: // for bad area triggers and return them if they're touched.
1345: edict_t *CheckForBadArea(edict_t *ent)
1346: {
1347: int i, num;
1348: edict_t *touch[MAX_EDICTS], *hit;
1349: vec3_t mins, maxs;
1350:
1351: VectorAdd(ent->s.origin, ent->mins, mins);
1352: VectorAdd(ent->s.origin, ent->maxs, maxs);
1353:
1354: num = gi.BoxEdicts (mins, maxs, touch, MAX_EDICTS, AREA_TRIGGERS);
1355:
1356: // drawbbox(ent);
1357:
1358: // be careful, it is possible to have an entity in this
1359: // list removed before we get to it (killtriggered)
1360: for (i=0 ; i<num ; i++)
1361: {
1362: hit = touch[i];
1363: if (!hit->inuse)
1364: continue;
1365: if (hit->touch == badarea_touch)
1366: {
1367: return hit;
1368: }
1369: }
1370:
1371: return NULL;
1372: }
1373:
1374: #define TESLA_DAMAGE_RADIUS 128
1375:
1376: qboolean MarkTeslaArea(edict_t *self, edict_t *tesla)
1377: {
1378: vec3_t mins, maxs;
1379: edict_t *e;
1380: edict_t *tail;
1381: edict_t *area;
1382:
1383: if(!tesla || !self)
1384: return false;
1385:
1386: area = NULL;
1387:
1388: // make sure this tesla doesn't have a bad area around it already...
1389: e = tesla->teamchain;
1390: tail = tesla;
1391: while (e)
1392: {
1393: tail = tail->teamchain;
1394: if(!strcmp(e->classname, "bad_area"))
1395: {
1396: // gi.dprintf("tesla already has a bad area marked\n");
1397: return false;
1398: }
1399: e = e->teamchain;
1400: }
1401:
1402: // see if we can grab the trigger directly
1403: if(tesla->teamchain && tesla->teamchain->inuse)
1404: {
1405: edict_t *trigger;
1406:
1407: trigger = tesla->teamchain;
1408:
1409: // VectorAdd (trigger->s.origin, trigger->mins, mins);
1410: // VectorAdd (trigger->s.origin, trigger->maxs, maxs);
1411: VectorCopy(trigger->absmin, mins);
1412: VectorCopy(trigger->absmax, maxs);
1413:
1414: if(tesla->air_finished)
1415: area = SpawnBadArea (mins, maxs, tesla->air_finished, tesla);
1416: else
1417: area = SpawnBadArea (mins, maxs, tesla->nextthink, tesla);
1418: }
1419: // otherwise we just guess at how long it'll last.
1420: else
1421: {
1422:
1423: VectorSet (mins, -TESLA_DAMAGE_RADIUS, -TESLA_DAMAGE_RADIUS, tesla->mins[2]);
1424: VectorSet (maxs, TESLA_DAMAGE_RADIUS, TESLA_DAMAGE_RADIUS, TESLA_DAMAGE_RADIUS);
1425:
1426: area = SpawnBadArea(mins, maxs, 30, tesla);
1427: }
1428:
1429: // if we spawned a bad area, then link it to the tesla
1430: if(area)
1431: {
1432: // gi.dprintf("bad area marker spawned and linked to tesla\n");
1433: tail->teamchain = area;
1434: }
1435: return true;
1436: }
1437:
1438: // predictive calculator
1439: // target is who you want to shoot
1440: // start is where the shot comes from
1441: // bolt_speed is how fast the shot is
1442: // eye_height is a boolean to say whether or not to adjust to targets eye_height
1443: // offset is how much time to miss by
1444: // aimdir is the resulting aim direction (pass in NULL if you don't want it)
1445: // aimpoint is the resulting aimpoint (pass in NULL if don't want it)
1446: void PredictAim (edict_t *target, vec3_t start, float bolt_speed, qboolean eye_height, float offset, vec3_t aimdir, vec3_t aimpoint)
1447: {
1448: vec3_t dir, vec;
1449: float dist, time;
1450:
1451: if (!target || !target->inuse)
1452: {
1453: VectorCopy (vec3_origin, aimdir);
1454: return;
1455: }
1456:
1457: VectorSubtract(target->s.origin, start, dir);
1458: if (eye_height)
1459: dir[2] += target->viewheight;
1460: dist = VectorLength(dir);
1461: time = dist / bolt_speed;
1462:
1463:
1464: VectorMA(target->s.origin, time - offset, target->velocity, vec);
1465:
1466: if (eye_height)
1467: vec[2] += target->viewheight;
1468:
1469: if (aimdir)
1470: {
1471: VectorSubtract (vec, start, aimdir);
1472: VectorNormalize (aimdir);
1473: }
1474:
1475: if (aimpoint)
1476: {
1477: VectorCopy (vec, aimpoint);
1478: }
1479: }
1480:
1481:
1482: qboolean below (edict_t *self, edict_t *other)
1483: {
1484: vec3_t vec;
1485: float dot;
1486: vec3_t down;
1487:
1488: VectorSubtract (other->s.origin, self->s.origin, vec);
1489: VectorNormalize (vec);
1490: VectorSet (down, 0, 0, -1);
1491: dot = DotProduct (vec, down);
1492:
1493: if (dot > 0.95) // 18 degree arc below
1494: return true;
1495: return false;
1496: }
1497:
1498: void drawbbox (edict_t *self)
1499: {
1500: int lines[4][3] = {
1501: {1, 2, 4},
1502: {1, 2, 7},
1503: {1, 4, 5},
1504: {2, 4, 7}
1505: };
1506:
1507: int starts[4] = {0, 3, 5, 6};
1508:
1509: vec3_t pt[8];
1510: int i, j, k;
1511: vec3_t coords[2];
1512: vec3_t newbox;
1513: vec3_t f,r,u, dir;
1514:
1515: VectorCopy (self->absmin, coords[0]);
1516: VectorCopy (self->absmax, coords[1]);
1517:
1518: for (i=0; i<=1; i++)
1519: {
1520: for (j=0; j<=1; j++)
1521: {
1522: for (k=0; k<=1; k++)
1523: {
1524: pt[4*i+2*j+k][0] = coords[i][0];
1525: pt[4*i+2*j+k][1] = coords[j][1];
1526: pt[4*i+2*j+k][2] = coords[k][2];
1527: }
1528: }
1529: }
1530:
1531: for (i=0; i<= 3; i++)
1532: {
1533: for (j=0; j<= 2; j++)
1534: {
1535: gi.WriteByte (svc_temp_entity);
1536: gi.WriteByte (TE_DEBUGTRAIL);
1537: gi.WritePosition (pt[starts[i]]);
1538: gi.WritePosition (pt[lines[i][j]]);
1539: gi.multicast (pt[starts[i]], MULTICAST_ALL);
1540: }
1541: }
1542:
1543: vectoangles2 (self->s.angles, dir);
1544: AngleVectors (dir, f, r, u);
1545:
1546: VectorMA (self->s.origin, 50, f, newbox);
1547: gi.WriteByte (svc_temp_entity);
1548: gi.WriteByte (TE_DEBUGTRAIL);
1549: gi.WritePosition (self->s.origin);
1550: gi.WritePosition (newbox);
1551: gi.multicast (self->s.origin, MULTICAST_PVS);
1552: VectorClear (newbox);
1553:
1554: VectorMA (self->s.origin, 50, r, newbox);
1555: gi.WriteByte (svc_temp_entity);
1556: gi.WriteByte (TE_DEBUGTRAIL);
1557: gi.WritePosition (self->s.origin);
1558: gi.WritePosition (newbox);
1559: gi.multicast (self->s.origin, MULTICAST_PVS);
1560: VectorClear (newbox);
1561:
1562: VectorMA (self->s.origin, 50, u, newbox);
1563: gi.WriteByte (svc_temp_entity);
1564: gi.WriteByte (TE_DEBUGTRAIL);
1565: gi.WritePosition (self->s.origin);
1566: gi.WritePosition (newbox);
1567: gi.multicast (self->s.origin, MULTICAST_PVS);
1568: VectorClear (newbox);
1569: }
1570:
1571: //
1572: // New dodge code
1573: //
1574: void M_MonsterDodge (edict_t *self, edict_t *attacker, float eta, trace_t *tr)
1575: {
1576: float r = random();
1577: float height;
1578: qboolean ducker = false, dodger = false;
1579:
1580: // this needs to be here since this can be called after the monster has "died"
1581: if (self->health < 1)
1582: return;
1583:
1584: if ((self->monsterinfo.duck) && (self->monsterinfo.unduck))
1585: ducker = true;
1586: if ((self->monsterinfo.sidestep) && !(self->monsterinfo.aiflags & AI_STAND_GROUND))
1587: dodger = true;
1588:
1589: if ((!ducker) && (!dodger))
1590: return;
1591:
1592: if ((g_showlogic) && (g_showlogic->value))
1593: {
1594: if (self->monsterinfo.aiflags & AI_DODGING)
1595: gi.dprintf ("dodging - ");
1596: if (self->monsterinfo.aiflags & AI_DUCKED)
1597: gi.dprintf ("ducked - ");
1598: }
1599: if (!self->enemy)
1600: {
1601: self->enemy = attacker;
1602: FoundTarget (self);
1603: }
1604:
1605: // PMM - don't bother if it's going to hit anyway; fix for weird in-your-face etas (I was
1606: // seeing numbers like 13 and 14)
1607: if ((eta < 0.1) || (eta > 5))
1608: {
1609: if ((g_showlogic) && (g_showlogic->value))
1610: gi.dprintf ("timeout\n");
1611: return;
1612: }
1613:
1614: // skill level determination..
1615: if (r > (0.25*((skill->value)+1)))
1616: {
1617: if ((g_showlogic) && (g_showlogic->value))
1618: gi.dprintf ("skillout\n");
1619: return;
1620: }
1621:
1622: // stop charging, since we're going to dodge (somehow) instead
1623: // soldier_stop_charge (self);
1624:
1625: if (ducker)
1626: {
1627: height = self->absmax[2]-32-1; // the -1 is because the absmax is s.origin + maxs + 1
1628:
1629: // FIXME, make smarter
1630: // if we only duck, and ducking won't help or we're already ducking, do nothing
1631: //
1632: // need to add monsterinfo.abort_duck() and monsterinfo.next_duck_time
1633:
1634: if ((!dodger) && ((tr->endpos[2] <= height) || (self->monsterinfo.aiflags & AI_DUCKED)))
1635: return;
1636: }
1637: else
1638: height = self->absmax[2];
1639:
1640: if (dodger)
1641: {
1642: // if we're already dodging, just finish the sequence, i.e. don't do anything else
1643: if (self->monsterinfo.aiflags & AI_DODGING)
1644: {
1645: if ((g_showlogic) && (g_showlogic->value))
1646: gi.dprintf ("already dodging\n");
1647: return;
1648: }
1649:
1650: // if we're ducking already, or the shot is at our knees
1651: if ((tr->endpos[2] <= height) || (self->monsterinfo.aiflags & AI_DUCKED))
1652: {
1653: vec3_t right, diff;
1654:
1655: AngleVectors (self->s.angles, NULL, right, NULL);
1656: VectorSubtract (tr->endpos, self->s.origin, diff);
1657:
1658: if (DotProduct (right, diff) < 0)
1659: {
1660: self->monsterinfo.lefty = 0;
1661: // gi.dprintf ("left\n");
1662: } else {
1663: self->monsterinfo.lefty = 1;
1664: // gi.dprintf ("right\n");
1665: }
1666:
1667: // if we are currently ducked, unduck
1668:
1669: if ((ducker) && (self->monsterinfo.aiflags & AI_DUCKED))
1670: {
1671: if ((g_showlogic) && (g_showlogic->value))
1672: gi.dprintf ("unducking - ");
1673: self->monsterinfo.unduck(self);
1674: }
1675:
1676: self->monsterinfo.aiflags |= AI_DODGING;
1677: self->monsterinfo.attack_state = AS_SLIDING;
1678:
1679: // call the monster specific code here
1680: self->monsterinfo.sidestep (self);
1681: return;
1682: }
1683: }
1684:
1685: if (ducker)
1686: {
1687: if (self->monsterinfo.next_duck_time > level.time)
1688: {
1689: if ((g_showlogic) && (g_showlogic->value))
1690: gi.dprintf ("ducked too often, not ducking\n");
1691: return;
1692: }
1693:
1694: if ((g_showlogic) && (g_showlogic->value))
1695: gi.dprintf ("ducking!\n");
1696:
1697: monster_done_dodge (self);
1698: // set this prematurely; it doesn't hurt, and prevents extra iterations
1699: self->monsterinfo.aiflags |= AI_DUCKED;
1700:
1701: self->monsterinfo.duck (self, eta);
1702: }
1703: }
1704:
1705: void monster_duck_down (edict_t *self)
1706: {
1707: // if (self->monsterinfo.aiflags & AI_DUCKED)
1708: // return;
1709: self->monsterinfo.aiflags |= AI_DUCKED;
1710:
1711: if ((g_showlogic) && (g_showlogic->value))
1712: gi.dprintf ("duck down!\n");
1713: // self->maxs[2] -= 32;
1714: self->maxs[2] = self->monsterinfo.base_height - 32;
1715: self->takedamage = DAMAGE_YES;
1716: if (self->monsterinfo.duck_wait_time < level.time)
1717: self->monsterinfo.duck_wait_time = level.time + 1;
1718: gi.linkentity (self);
1719: }
1720:
1721: void monster_duck_hold (edict_t *self)
1722: {
1723: if (level.time >= self->monsterinfo.duck_wait_time)
1724: self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
1725: else
1726: self->monsterinfo.aiflags |= AI_HOLD_FRAME;
1727: }
1728:
1729: void monster_duck_up (edict_t *self)
1730: {
1731: self->monsterinfo.aiflags &= ~AI_DUCKED;
1732: // self->maxs[2] += 32;
1733: self->maxs[2] = self->monsterinfo.base_height;
1734: self->takedamage = DAMAGE_AIM;
1735: self->monsterinfo.next_duck_time = level.time + DUCK_INTERVAL;
1736: gi.linkentity (self);
1737: }
1738:
1739: //=========================
1740: //=========================
1741: qboolean has_valid_enemy (edict_t *self)
1742: {
1743: if (!self->enemy)
1744: return false;
1745:
1746: if (!self->enemy->inuse)
1747: return false;
1748:
1749: if (self->enemy->health < 1)
1750: return false;
1751:
1752: return true;
1753: }
1754:
1755: void TargetTesla (edict_t *self, edict_t *tesla)
1756: {
1757: if ((!self) || (!tesla))
1758: return;
1759:
1760: // PMM - medic bails on healing things
1761: if (self->monsterinfo.aiflags & AI_MEDIC)
1762: {
1763: if (self->enemy)
1764: cleanupHealTarget(self->enemy);
1765: self->monsterinfo.aiflags &= ~AI_MEDIC;
1766: }
1767:
1768: // store the player enemy in case we lose track of him.
1769: if(self->enemy && self->enemy->client)
1770: self->monsterinfo.last_player_enemy = self->enemy;
1771:
1772: if(self->enemy != tesla)
1773: {
1774: self->oldenemy = self->enemy;
1775: self->enemy = tesla;
1776: if(self->monsterinfo.attack)
1777: {
1778: if (self->health <= 0)
1779: {
1780: if ((g_showlogic) && (g_showlogic->value))
1781: gi.dprintf ("bad tesla attack avoided!\n");
1782: return;
1783: }
1784: self->monsterinfo.attack(self);
1785: }
1786: else
1787: {
1788: FoundTarget(self);
1789: }
1790: }
1791: }
1792:
1793: // this returns a randomly selected coop player who is visible to self
1794: // returns NULL if bad
1795:
1796: edict_t * PickCoopTarget (edict_t *self)
1797: {
1798: // no more than 4 players in coop, so..
1799: edict_t *targets[4];
1800: int num_targets = 0, targetID;
1801: edict_t *ent;
1802: int player;
1803:
1804: // if we're not in coop, this is a noop
1805: if (!coop || !coop->value)
1806: return NULL;
1807:
1808: memset (targets, 0, 4*sizeof(edict_t *));
1809:
1810: for (player = 1; player <= game.maxclients; player++)
1811: {
1812: ent = &g_edicts[player];
1813: if (!ent->inuse)
1814: continue;
1815: if (!ent->client)
1816: continue;
1817: if (visible(self, ent))
1818: {
1819: if ((g_showlogic) && (g_showlogic->value))
1820: gi.dprintf ("%s: found coop player %s - ", self->classname, ent->client->pers.netname);
1821: targets[num_targets++] = ent;
1822: }
1823: }
1824:
1825: /*
1826: ent = g_edicts+1; // skip the worldspawn
1827: // cycle through players
1828: while (ent)
1829: {
1830: if ((ent->client) && (ent->inuse))
1831: {
1832: if (visible(self, ent))
1833: {
1834: if ((g_showlogic) && (g_showlogic->value))
1835: gi.dprintf ("%s: found coop player %s - ", self->classname, ent->client->pers.netname);
1836: targets[num_targets++] = ent;
1837: }
1838: ent++;
1839: }
1840: else
1841: ent = NULL;
1842: }
1843: */
1844:
1845: if (!num_targets)
1846: return NULL;
1847:
1848: // get a number from 0 to (num_targets-1)
1849: targetID = (random() * (float)num_targets);
1850:
1851: // just in case we got a 1.0 from random
1852: if (targetID == num_targets)
1853: targetID--;
1854:
1855: if (g_showlogic && g_showlogic->value)
1856: gi.dprintf ("using player %s\n", targets[targetID]->client->pers.netname);
1857: return targets[targetID];
1858: }
1859:
1860: // only meant to be used in coop
1861: int CountPlayers (void)
1862: {
1863: edict_t *ent;
1864: int count = 0;
1865: int player;
1866:
1867: // if we're not in coop, this is a noop
1868: if (!coop || !coop->value)
1869: return 1;
1870:
1871: for (player = 1; player <= game.maxclients; player++)
1872: {
1873: ent = &g_edicts[player];
1874: if (!ent->inuse)
1875: continue;
1876: if (!ent->client)
1877: continue;
1878: count++;
1879: }
1880: /*
1881: ent = g_edicts+1; // skip the worldspawn
1882: while (ent)
1883: {
1884: if ((ent->client) && (ent->inuse))
1885: {
1886: ent++;
1887: count++;
1888: }
1889: else
1890: ent = NULL;
1891: }
1892: */
1893: return count;
1894: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.