![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_ai.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / game|
Return to g_ai.c CVS log | Up to [Quake II] / quake2 / game |
1.1 ! root 1: // g_ai.c ! 2: ! 3: #include "g_local.h" ! 4: ! 5: qboolean FindTarget (edict_t *self); ! 6: extern cvar_t *maxclients; ! 7: ! 8: qboolean ai_checkattack (edict_t *self, float dist); ! 9: ! 10: qboolean enemy_vis; ! 11: qboolean enemy_infront; ! 12: int enemy_range; ! 13: float enemy_yaw; ! 14: ! 15: //============================================================================ ! 16: ! 17: ! 18: /* ! 19: ================= ! 20: AI_SetSightClient ! 21: ! 22: Called once each frame to set level.sight_client to the ! 23: player to be checked for in findtarget. ! 24: ! 25: If all clients are either dead or in notarget, sight_client ! 26: will be null. ! 27: ! 28: In coop games, sight_client will cycle between the clients. ! 29: ================= ! 30: */ ! 31: void AI_SetSightClient (void) ! 32: { ! 33: edict_t *ent; ! 34: int start, check; ! 35: ! 36: if (level.sight_client == NULL) ! 37: start = 1; ! 38: else ! 39: start = level.sight_client - g_edicts; ! 40: ! 41: check = start; ! 42: while (1) ! 43: { ! 44: check++; ! 45: if (check > game.maxclients) ! 46: check = 1; ! 47: ent = &g_edicts[check]; ! 48: if (ent->inuse ! 49: && ent->health > 0 ! 50: && !(ent->flags & FL_NOTARGET) ) ! 51: { ! 52: level.sight_client = ent; ! 53: return; // got one ! 54: } ! 55: if (check == start) ! 56: { ! 57: level.sight_client = NULL; ! 58: return; // nobody to see ! 59: } ! 60: } ! 61: } ! 62: ! 63: //============================================================================ ! 64: ! 65: /* ! 66: ============= ! 67: ai_move ! 68: ! 69: Move the specified distance at current facing. ! 70: This replaces the QC functions: ai_forward, ai_back, ai_pain, and ai_painforward ! 71: ============== ! 72: */ ! 73: void ai_move (edict_t *self, float dist) ! 74: { ! 75: M_walkmove (self, self->s.angles[YAW], dist); ! 76: } ! 77: ! 78: ! 79: /* ! 80: ============= ! 81: ai_stand ! 82: ! 83: Used for standing around and looking for players ! 84: Distance is for slight position adjustments needed by the animations ! 85: ============== ! 86: */ ! 87: void ai_stand (edict_t *self, float dist) ! 88: { ! 89: vec3_t v; ! 90: ! 91: if (dist) ! 92: M_walkmove (self, self->s.angles[YAW], dist); ! 93: ! 94: if (self->monsterinfo.aiflags & AI_STAND_GROUND) ! 95: { ! 96: if (self->enemy) ! 97: { ! 98: VectorSubtract (self->enemy->s.origin, self->s.origin, v); ! 99: self->ideal_yaw = vectoyaw(v); ! 100: if (self->s.angles[YAW] != self->ideal_yaw && self->monsterinfo.aiflags & AI_TEMP_STAND_GROUND) ! 101: { ! 102: self->monsterinfo.aiflags &= ~(AI_STAND_GROUND | AI_TEMP_STAND_GROUND); ! 103: self->monsterinfo.run (self); ! 104: } ! 105: M_ChangeYaw (self); ! 106: ai_checkattack (self, 0); ! 107: } ! 108: else ! 109: FindTarget (self); ! 110: return; ! 111: } ! 112: ! 113: if (FindTarget (self)) ! 114: return; ! 115: ! 116: if (level.time > self->monsterinfo.pausetime) ! 117: { ! 118: self->monsterinfo.walk (self); ! 119: return; ! 120: } ! 121: ! 122: if (!(self->spawnflags & 1) && (self->monsterinfo.idle) && (level.time > self->monsterinfo.idle_time)) ! 123: { ! 124: if (self->monsterinfo.idle_time) ! 125: { ! 126: self->monsterinfo.idle (self); ! 127: self->monsterinfo.idle_time = level.time + 15 + random() * 15; ! 128: } ! 129: else ! 130: { ! 131: self->monsterinfo.idle_time = level.time + random() * 15; ! 132: } ! 133: } ! 134: } ! 135: ! 136: ! 137: /* ! 138: ============= ! 139: ai_walk ! 140: ! 141: The monster is walking it's beat ! 142: ============= ! 143: */ ! 144: void ai_walk (edict_t *self, float dist) ! 145: { ! 146: M_MoveToGoal (self, dist); ! 147: ! 148: // check for noticing a player ! 149: if (FindTarget (self)) ! 150: return; ! 151: ! 152: if ((self->monsterinfo.search) && (level.time > self->monsterinfo.idle_time)) ! 153: { ! 154: if (self->monsterinfo.idle_time) ! 155: { ! 156: self->monsterinfo.search (self); ! 157: self->monsterinfo.idle_time = level.time + 15 + random() * 15; ! 158: } ! 159: else ! 160: { ! 161: self->monsterinfo.idle_time = level.time + random() * 15; ! 162: } ! 163: } ! 164: } ! 165: ! 166: ! 167: /* ! 168: ============= ! 169: ai_charge ! 170: ! 171: Turns towards target and advances ! 172: Use this call with a distnace of 0 to replace ai_face ! 173: ============== ! 174: */ ! 175: void ai_charge (edict_t *self, float dist) ! 176: { ! 177: vec3_t v; ! 178: ! 179: VectorSubtract (self->enemy->s.origin, self->s.origin, v); ! 180: self->ideal_yaw = vectoyaw(v); ! 181: M_ChangeYaw (self); ! 182: ! 183: if (dist) ! 184: M_walkmove (self, self->s.angles[YAW], dist); ! 185: } ! 186: ! 187: ! 188: /* ! 189: ============= ! 190: ai_turn ! 191: ! 192: don't move, but turn towards ideal_yaw ! 193: Distance is for slight position adjustments needed by the animations ! 194: ============= ! 195: */ ! 196: void ai_turn (edict_t *self, float dist) ! 197: { ! 198: if (dist) ! 199: M_walkmove (self, self->s.angles[YAW], dist); ! 200: ! 201: if (FindTarget (self)) ! 202: return; ! 203: ! 204: M_ChangeYaw (self); ! 205: } ! 206: ! 207: ! 208: /* ! 209: ! 210: .enemy ! 211: Will be world if not currently angry at anyone. ! 212: ! 213: .movetarget ! 214: The next path spot to walk toward. If .enemy, ignore .movetarget. ! 215: When an enemy is killed, the monster will try to return to it's path. ! 216: ! 217: .hunt_time ! 218: Set to time + something when the player is in sight, but movement straight for ! 219: him is blocked. This causes the monster to use wall following code for ! 220: movement direction instead of sighting on the player. ! 221: ! 222: .ideal_yaw ! 223: A yaw angle of the intended direction, which will be turned towards at up ! 224: to 45 deg / state. If the enemy is in view and hunt_time is not active, ! 225: this will be the exact line towards the enemy. ! 226: ! 227: .pausetime ! 228: A monster will leave it's stand state and head towards it's .movetarget when ! 229: time > .pausetime. ! 230: ! 231: walkmove(angle, speed) primitive is all or nothing ! 232: */ ! 233: ! 234: /* ! 235: ============= ! 236: range ! 237: ! 238: returns the range catagorization of an entity reletive to self ! 239: 0 melee range, will become hostile even if back is turned ! 240: 1 visibility and infront, or visibility and show hostile ! 241: 2 infront and show hostile ! 242: 3 only triggered by damage ! 243: ============= ! 244: */ ! 245: int range (edict_t *self, edict_t *other) ! 246: { ! 247: vec3_t v; ! 248: float len; ! 249: ! 250: VectorSubtract (self->s.origin, other->s.origin, v); ! 251: len = VectorLength (v); ! 252: if (len < MELEE_DISTANCE) ! 253: return RANGE_MELEE; ! 254: if (len < 500) ! 255: return RANGE_NEAR; ! 256: if (len < 1000) ! 257: return RANGE_MID; ! 258: return RANGE_FAR; ! 259: } ! 260: ! 261: /* ! 262: ============= ! 263: visible ! 264: ! 265: returns 1 if the entity is visible to self, even if not infront () ! 266: ============= ! 267: */ ! 268: qboolean visible (edict_t *self, edict_t *other) ! 269: { ! 270: vec3_t spot1; ! 271: vec3_t spot2; ! 272: trace_t trace; ! 273: ! 274: VectorCopy (self->s.origin, spot1); ! 275: spot1[2] += self->viewheight; ! 276: VectorCopy (other->s.origin, spot2); ! 277: spot2[2] += other->viewheight; ! 278: trace = gi.trace (spot1, vec3_origin, vec3_origin, spot2, self, MASK_OPAQUE); ! 279: ! 280: if (trace.fraction == 1.0) ! 281: return true; ! 282: return false; ! 283: } ! 284: ! 285: ! 286: /* ! 287: ============= ! 288: infront ! 289: ! 290: returns 1 if the entity is in front (in sight) of self ! 291: ============= ! 292: */ ! 293: qboolean infront (edict_t *self, edict_t *other) ! 294: { ! 295: vec3_t vec; ! 296: float dot; ! 297: vec3_t forward; ! 298: ! 299: AngleVectors (self->s.angles, forward, NULL, NULL); ! 300: VectorSubtract (other->s.origin, self->s.origin, vec); ! 301: VectorNormalize (vec); ! 302: dot = DotProduct (vec, forward); ! 303: ! 304: if (dot > 0.3) ! 305: return true; ! 306: return false; ! 307: } ! 308: ! 309: ! 310: //============================================================================ ! 311: ! 312: void HuntTarget (edict_t *self) ! 313: { ! 314: vec3_t vec; ! 315: ! 316: self->goalentity = self->enemy; ! 317: if (self->monsterinfo.aiflags & AI_STAND_GROUND) ! 318: self->monsterinfo.stand (self); ! 319: else ! 320: self->monsterinfo.run (self); ! 321: VectorSubtract (self->enemy->s.origin, self->s.origin, vec); ! 322: self->ideal_yaw = vectoyaw(vec); ! 323: // wait a while before first attack ! 324: if (!(self->monsterinfo.aiflags & AI_STAND_GROUND)) ! 325: AttackFinished (self, 1); ! 326: } ! 327: ! 328: void FoundTarget (edict_t *self) ! 329: { ! 330: // let other monsters see this monster for a while ! 331: if (self->enemy->client) ! 332: { ! 333: level.sight_entity = self; ! 334: level.sight_entity_framenum = level.framenum; ! 335: level.sight_entity->light_level = 128; ! 336: } ! 337: ! 338: self->show_hostile = level.time + 1; // wake up other monsters ! 339: ! 340: VectorCopy(self->enemy->s.origin, self->monsterinfo.last_sighting); ! 341: self->monsterinfo.trail_time = level.time; ! 342: ! 343: if (!self->combattarget) ! 344: { ! 345: HuntTarget (self); ! 346: return; ! 347: } ! 348: ! 349: self->goalentity = self->movetarget = G_PickTarget(self->combattarget); ! 350: if (!self->movetarget) ! 351: { ! 352: self->goalentity = self->movetarget = self->enemy; ! 353: HuntTarget (self); ! 354: gi.dprintf("%s at %s, combattarget %s not found\n", self->classname, vtos(self->s.origin), self->combattarget); ! 355: return; ! 356: } ! 357: ! 358: // clear out our combattarget, these are a one shot deal ! 359: self->combattarget = NULL; ! 360: self->monsterinfo.aiflags |= AI_COMBAT_POINT; ! 361: ! 362: // clear the targetname, that point is ours! ! 363: self->movetarget->targetname = NULL; ! 364: self->monsterinfo.pausetime = 0; ! 365: ! 366: // run for it ! 367: self->monsterinfo.run (self); ! 368: } ! 369: ! 370: ! 371: /* ! 372: =========== ! 373: FindTarget ! 374: ! 375: Self is currently not attacking anything, so try to find a target ! 376: ! 377: Returns TRUE if an enemy was sighted ! 378: ! 379: When a player fires a missile, the point of impact becomes a fakeplayer so ! 380: that monsters that see the impact will respond as if they had seen the ! 381: player. ! 382: ! 383: To avoid spending too much time, only a single client (or fakeclient) is ! 384: checked each frame. This means multi player games will have slightly ! 385: slower noticing monsters. ! 386: ============ ! 387: */ ! 388: qboolean FindTarget (edict_t *self) ! 389: { ! 390: edict_t *client; ! 391: qboolean heardit; ! 392: int r; ! 393: ! 394: if (self->monsterinfo.aiflags & AI_GOOD_GUY) ! 395: { ! 396: if (self->goalentity && self->goalentity->inuse && self->goalentity->classname) ! 397: { ! 398: if (strcmp(self->goalentity->classname, "target_actor") == 0) ! 399: return false; ! 400: } ! 401: ! 402: //FIXME look for monsters? ! 403: return false; ! 404: } ! 405: ! 406: // if we're going to a combat point, just proceed ! 407: if (self->monsterinfo.aiflags & AI_COMBAT_POINT) ! 408: return false; ! 409: ! 410: // if the first spawnflag bit is set, the monster will only wake up on ! 411: // really seeing the player, not another monster getting angry or hearing ! 412: // something ! 413: ! 414: // revised behavior so they will wake up if they "see" a player make a noise ! 415: // but not weapon impact/explosion noises ! 416: ! 417: heardit = false; ! 418: if ((level.sight_entity_framenum >= (level.framenum - 1)) && !(self->spawnflags & 1) ) ! 419: { ! 420: client = level.sight_entity; ! 421: if (client->enemy == self->enemy) ! 422: { ! 423: return false; ! 424: } ! 425: } ! 426: else if (level.sound_entity_framenum >= (level.framenum - 1)) ! 427: { ! 428: client = level.sound_entity; ! 429: heardit = true; ! 430: } ! 431: else if (!(self->enemy) && (level.sound2_entity_framenum >= (level.framenum - 1)) && !(self->spawnflags & 1) ) ! 432: { ! 433: client = level.sound2_entity; ! 434: heardit = true; ! 435: } ! 436: else ! 437: { ! 438: client = level.sight_client; ! 439: if (!client) ! 440: return false; // no clients to get mad at ! 441: } ! 442: ! 443: // if the entity went away, forget it ! 444: if (!client->inuse) ! 445: return false; ! 446: ! 447: if (client == self->enemy) ! 448: return true; // JDC false; ! 449: ! 450: if (client->client) ! 451: { ! 452: if (client->flags & FL_NOTARGET) ! 453: return false; ! 454: } ! 455: else if (client->svflags & SVF_MONSTER) ! 456: { ! 457: if (!client->enemy) ! 458: return false; ! 459: if (client->enemy->flags & FL_NOTARGET) ! 460: return false; ! 461: } ! 462: else if (heardit) ! 463: { ! 464: if (client->owner->flags & FL_NOTARGET) ! 465: return false; ! 466: } ! 467: else ! 468: return false; ! 469: ! 470: if (!heardit) ! 471: { ! 472: r = range (self, client); ! 473: ! 474: if (r == RANGE_FAR) ! 475: return false; ! 476: ! 477: // this is where we would check invisibility ! 478: ! 479: // is client in an spot too dark to be seen? ! 480: if (client->light_level <= 5) ! 481: return false; ! 482: ! 483: if (!visible (self, client)) ! 484: { ! 485: return false; ! 486: } ! 487: ! 488: if (r == RANGE_NEAR) ! 489: { ! 490: if (client->show_hostile < level.time && !infront (self, client)) ! 491: { ! 492: return false; ! 493: } ! 494: } ! 495: else if (r == RANGE_MID) ! 496: { ! 497: if (!infront (self, client)) ! 498: { ! 499: return false; ! 500: } ! 501: } ! 502: ! 503: self->enemy = client; ! 504: ! 505: if (strcmp(self->enemy->classname, "player_noise") != 0) ! 506: { ! 507: self->monsterinfo.aiflags &= ~AI_SOUND_TARGET; ! 508: ! 509: if (!self->enemy->client) ! 510: { ! 511: self->enemy = self->enemy->enemy; ! 512: if (!self->enemy->client) ! 513: { ! 514: self->enemy = NULL; ! 515: return false; ! 516: } ! 517: } ! 518: } ! 519: } ! 520: else // heardit ! 521: { ! 522: vec3_t temp; ! 523: ! 524: if (self->spawnflags & 1) ! 525: { ! 526: if (!visible (self, client)) ! 527: return false; ! 528: } ! 529: else ! 530: { ! 531: if (!gi.inPHS(self->s.origin, client->s.origin)) ! 532: return false; ! 533: } ! 534: ! 535: VectorSubtract (client->s.origin, self->s.origin, temp); ! 536: ! 537: if (VectorLength(temp) > 1000) // too far to hear ! 538: { ! 539: return false; ! 540: } ! 541: ! 542: // check area portals - if they are different and not connected then we can't hear it ! 543: if (client->areanum != self->areanum) ! 544: if (!gi.AreasConnected(self->areanum, client->areanum)) ! 545: return false; ! 546: ! 547: self->ideal_yaw = vectoyaw(temp); ! 548: M_ChangeYaw (self); ! 549: ! 550: // hunt the sound for a bit; hopefully find the real player ! 551: self->monsterinfo.aiflags |= AI_SOUND_TARGET; ! 552: self->enemy = client; ! 553: } ! 554: ! 555: // ! 556: // got one ! 557: // ! 558: FoundTarget (self); ! 559: ! 560: if (!(self->monsterinfo.aiflags & AI_SOUND_TARGET) && (self->monsterinfo.sight)) ! 561: self->monsterinfo.sight (self, self->enemy); ! 562: ! 563: return true; ! 564: } ! 565: ! 566: ! 567: //============================================================================= ! 568: ! 569: /* ! 570: ============ ! 571: FacingIdeal ! 572: ! 573: ============ ! 574: */ ! 575: qboolean FacingIdeal(edict_t *self) ! 576: { ! 577: float delta; ! 578: ! 579: delta = anglemod(self->s.angles[YAW] - self->ideal_yaw); ! 580: if (delta > 45 && delta < 315) ! 581: return false; ! 582: return true; ! 583: } ! 584: ! 585: ! 586: //============================================================================= ! 587: ! 588: qboolean M_CheckAttack (edict_t *self) ! 589: { ! 590: vec3_t spot1, spot2; ! 591: float chance; ! 592: trace_t tr; ! 593: ! 594: if (self->enemy->health > 0) ! 595: { ! 596: // see if any entities are in the way of the shot ! 597: VectorCopy (self->s.origin, spot1); ! 598: spot1[2] += self->viewheight; ! 599: VectorCopy (self->enemy->s.origin, spot2); ! 600: spot2[2] += self->enemy->viewheight; ! 601: ! 602: tr = gi.trace (spot1, NULL, NULL, spot2, self, CONTENTS_SOLID|CONTENTS_MONSTER|CONTENTS_SLIME|CONTENTS_LAVA|CONTENTS_WINDOW); ! 603: ! 604: // do we have a clear shot? ! 605: if (tr.ent != self->enemy) ! 606: return false; ! 607: } ! 608: ! 609: // melee attack ! 610: if (enemy_range == RANGE_MELEE) ! 611: { ! 612: // don't always melee in easy mode ! 613: if (skill->value == 0 && (rand()&3) ) ! 614: return false; ! 615: if (self->monsterinfo.melee) ! 616: self->monsterinfo.attack_state = AS_MELEE; ! 617: else ! 618: self->monsterinfo.attack_state = AS_MISSILE; ! 619: return true; ! 620: } ! 621: ! 622: // missile attack ! 623: if (!self->monsterinfo.attack) ! 624: return false; ! 625: ! 626: if (level.time < self->monsterinfo.attack_finished) ! 627: return false; ! 628: ! 629: if (enemy_range == RANGE_FAR) ! 630: return false; ! 631: ! 632: if (self->monsterinfo.aiflags & AI_STAND_GROUND) ! 633: { ! 634: chance = 0.4; ! 635: } ! 636: else if (enemy_range == RANGE_MELEE) ! 637: { ! 638: chance = 0.2; ! 639: } ! 640: else if (enemy_range == RANGE_NEAR) ! 641: { ! 642: chance = 0.1; ! 643: } ! 644: else if (enemy_range == RANGE_MID) ! 645: { ! 646: chance = 0.02; ! 647: } ! 648: else ! 649: { ! 650: return false; ! 651: } ! 652: ! 653: if (skill->value == 0) ! 654: chance *= 0.5; ! 655: else if (skill->value >= 2) ! 656: chance *= 2; ! 657: ! 658: if (random () < chance) ! 659: { ! 660: self->monsterinfo.attack_state = AS_MISSILE; ! 661: self->monsterinfo.attack_finished = level.time + 2*random(); ! 662: return true; ! 663: } ! 664: ! 665: if (self->flags & FL_FLY) ! 666: { ! 667: if (random() < 0.3) ! 668: self->monsterinfo.attack_state = AS_SLIDING; ! 669: else ! 670: self->monsterinfo.attack_state = AS_STRAIGHT; ! 671: } ! 672: ! 673: return false; ! 674: } ! 675: ! 676: ! 677: /* ! 678: ============= ! 679: ai_run_melee ! 680: ! 681: Turn and close until within an angle to launch a melee attack ! 682: ============= ! 683: */ ! 684: void ai_run_melee(edict_t *self) ! 685: { ! 686: self->ideal_yaw = enemy_yaw; ! 687: M_ChangeYaw (self); ! 688: ! 689: if (FacingIdeal(self)) ! 690: { ! 691: self->monsterinfo.melee (self); ! 692: self->monsterinfo.attack_state = AS_STRAIGHT; ! 693: } ! 694: } ! 695: ! 696: ! 697: /* ! 698: ============= ! 699: ai_run_missile ! 700: ! 701: Turn in place until within an angle to launch a missile attack ! 702: ============= ! 703: */ ! 704: void ai_run_missile(edict_t *self) ! 705: { ! 706: self->ideal_yaw = enemy_yaw; ! 707: M_ChangeYaw (self); ! 708: ! 709: if (FacingIdeal(self)) ! 710: { ! 711: self->monsterinfo.attack (self); ! 712: self->monsterinfo.attack_state = AS_STRAIGHT; ! 713: } ! 714: }; ! 715: ! 716: ! 717: /* ! 718: ============= ! 719: ai_run_slide ! 720: ! 721: Strafe sideways, but stay at aproximately the same range ! 722: ============= ! 723: */ ! 724: void ai_run_slide(edict_t *self, float distance) ! 725: { ! 726: float ofs; ! 727: ! 728: self->ideal_yaw = enemy_yaw; ! 729: M_ChangeYaw (self); ! 730: ! 731: if (self->monsterinfo.lefty) ! 732: ofs = 90; ! 733: else ! 734: ofs = -90; ! 735: ! 736: if (M_walkmove (self, self->ideal_yaw + ofs, distance)) ! 737: return; ! 738: ! 739: self->monsterinfo.lefty = 1 - self->monsterinfo.lefty; ! 740: M_walkmove (self, self->ideal_yaw - ofs, distance); ! 741: } ! 742: ! 743: ! 744: /* ! 745: ============= ! 746: ai_checkattack ! 747: ! 748: Decides if we're going to attack or do something else ! 749: used by ai_run and ai_stand ! 750: ============= ! 751: */ ! 752: qboolean ai_checkattack (edict_t *self, float dist) ! 753: { ! 754: vec3_t temp; ! 755: qboolean hesDeadJim; ! 756: ! 757: // this causes monsters to run blindly to the combat point w/o firing ! 758: if (self->goalentity) ! 759: { ! 760: if (self->monsterinfo.aiflags & AI_COMBAT_POINT) ! 761: return false; ! 762: ! 763: if (self->monsterinfo.aiflags & AI_SOUND_TARGET) ! 764: { ! 765: if ((level.time - self->enemy->teleport_time) > 5.0) ! 766: { ! 767: if (self->goalentity == self->enemy) ! 768: if (self->movetarget) ! 769: self->goalentity = self->movetarget; ! 770: else ! 771: self->goalentity = NULL; ! 772: self->monsterinfo.aiflags &= ~AI_SOUND_TARGET; ! 773: if (self->monsterinfo.aiflags & AI_TEMP_STAND_GROUND) ! 774: self->monsterinfo.aiflags &= ~(AI_STAND_GROUND | AI_TEMP_STAND_GROUND); ! 775: } ! 776: else ! 777: { ! 778: self->show_hostile = level.time + 1; ! 779: return false; ! 780: } ! 781: } ! 782: } ! 783: ! 784: enemy_vis = false; ! 785: ! 786: // see if the enemy is dead ! 787: hesDeadJim = false; ! 788: if ((!self->enemy) || (!self->enemy->inuse)) ! 789: { ! 790: hesDeadJim = true; ! 791: } ! 792: else if (self->monsterinfo.aiflags & AI_MEDIC) ! 793: { ! 794: if (self->enemy->health > 0) ! 795: { ! 796: hesDeadJim = true; ! 797: self->monsterinfo.aiflags &= ~AI_MEDIC; ! 798: } ! 799: } ! 800: else ! 801: { ! 802: if (self->monsterinfo.aiflags & AI_BRUTAL) ! 803: { ! 804: if (self->enemy->health <= -80) ! 805: hesDeadJim = true; ! 806: } ! 807: else ! 808: { ! 809: if (self->enemy->health <= 0) ! 810: hesDeadJim = true; ! 811: } ! 812: } ! 813: ! 814: if (hesDeadJim) ! 815: { ! 816: self->enemy = NULL; ! 817: // FIXME: look all around for other targets ! 818: if (self->oldenemy && self->oldenemy->health > 0) ! 819: { ! 820: self->enemy = self->oldenemy; ! 821: self->oldenemy = NULL; ! 822: HuntTarget (self); ! 823: } ! 824: else ! 825: { ! 826: if (self->movetarget) ! 827: { ! 828: self->goalentity = self->movetarget; ! 829: self->monsterinfo.walk (self); ! 830: } ! 831: else ! 832: { ! 833: // we need the pausetime otherwise the stand code ! 834: // will just revert to walking with no target and ! 835: // the monsters will wonder around aimlessly trying ! 836: // to hunt the world entity ! 837: self->monsterinfo.pausetime = level.time + 100000000; ! 838: self->monsterinfo.stand (self); ! 839: } ! 840: return true; ! 841: } ! 842: } ! 843: ! 844: self->show_hostile = level.time + 1; // wake up other monsters ! 845: ! 846: // check knowledge of enemy ! 847: enemy_vis = visible(self, self->enemy); ! 848: if (enemy_vis) ! 849: { ! 850: self->monsterinfo.search_time = level.time + 5; ! 851: VectorCopy (self->enemy->s.origin, self->monsterinfo.last_sighting); ! 852: } ! 853: ! 854: // look for other coop players here ! 855: // if (coop && self->monsterinfo.search_time < level.time) ! 856: // { ! 857: // if (FindTarget (self)) ! 858: // return true; ! 859: // } ! 860: ! 861: enemy_infront = infront(self, self->enemy); ! 862: enemy_range = range(self, self->enemy); ! 863: VectorSubtract (self->enemy->s.origin, self->s.origin, temp); ! 864: enemy_yaw = vectoyaw(temp); ! 865: ! 866: ! 867: // JDC self->ideal_yaw = enemy_yaw; ! 868: ! 869: if (self->monsterinfo.attack_state == AS_MISSILE) ! 870: { ! 871: ai_run_missile (self); ! 872: return true; ! 873: } ! 874: if (self->monsterinfo.attack_state == AS_MELEE) ! 875: { ! 876: ai_run_melee (self); ! 877: return true; ! 878: } ! 879: ! 880: // if enemy is not currently visible, we will never attack ! 881: if (!enemy_vis) ! 882: return false; ! 883: ! 884: return self->monsterinfo.checkattack (self); ! 885: } ! 886: ! 887: ! 888: /* ! 889: ============= ! 890: ai_run ! 891: ! 892: The monster has an enemy it is trying to kill ! 893: ============= ! 894: */ ! 895: void ai_run (edict_t *self, float dist) ! 896: { ! 897: vec3_t v; ! 898: edict_t *tempgoal; ! 899: edict_t *save; ! 900: qboolean new; ! 901: edict_t *marker; ! 902: float d1, d2; ! 903: trace_t tr; ! 904: vec3_t v_forward, v_right; ! 905: float left, center, right; ! 906: vec3_t left_target, right_target; ! 907: ! 908: // if we're going to a combat point, just proceed ! 909: if (self->monsterinfo.aiflags & AI_COMBAT_POINT) ! 910: { ! 911: M_MoveToGoal (self, dist); ! 912: return; ! 913: } ! 914: ! 915: if (self->monsterinfo.aiflags & AI_SOUND_TARGET) ! 916: { ! 917: VectorSubtract (self->s.origin, self->enemy->s.origin, v); ! 918: if (VectorLength(v) < 64) ! 919: { ! 920: self->monsterinfo.aiflags |= (AI_STAND_GROUND | AI_TEMP_STAND_GROUND); ! 921: self->monsterinfo.stand (self); ! 922: return; ! 923: } ! 924: ! 925: M_MoveToGoal (self, dist); ! 926: ! 927: if (!FindTarget (self)) ! 928: return; ! 929: } ! 930: ! 931: if (ai_checkattack (self, dist)) ! 932: return; ! 933: ! 934: if (self->monsterinfo.attack_state == AS_SLIDING) ! 935: { ! 936: ai_run_slide (self, dist); ! 937: return; ! 938: } ! 939: ! 940: if (enemy_vis) ! 941: { ! 942: // if (self.aiflags & AI_LOST_SIGHT) ! 943: // dprint("regained sight\n"); ! 944: M_MoveToGoal (self, dist); ! 945: self->monsterinfo.aiflags &= ~AI_LOST_SIGHT; ! 946: VectorCopy (self->enemy->s.origin, self->monsterinfo.last_sighting); ! 947: self->monsterinfo.trail_time = level.time; ! 948: return; ! 949: } ! 950: ! 951: // coop will change to another enemy if visible ! 952: if (coop->value) ! 953: { // FIXME: insane guys get mad with this, which causes crashes! ! 954: if (FindTarget (self)) ! 955: return; ! 956: } ! 957: ! 958: if ((self->monsterinfo.search_time) && (level.time > (self->monsterinfo.search_time + 20))) ! 959: { ! 960: M_MoveToGoal (self, dist); ! 961: self->monsterinfo.search_time = 0; ! 962: // dprint("search timeout\n"); ! 963: return; ! 964: } ! 965: ! 966: save = self->goalentity; ! 967: tempgoal = G_Spawn(); ! 968: self->goalentity = tempgoal; ! 969: ! 970: new = false; ! 971: ! 972: if (!(self->monsterinfo.aiflags & AI_LOST_SIGHT)) ! 973: { ! 974: // just lost sight of the player, decide where to go first ! 975: // dprint("lost sight of player, last seen at "); dprint(vtos(self.last_sighting)); dprint("\n"); ! 976: self->monsterinfo.aiflags |= (AI_LOST_SIGHT | AI_PURSUIT_LAST_SEEN); ! 977: self->monsterinfo.aiflags &= ~(AI_PURSUE_NEXT | AI_PURSUE_TEMP); ! 978: new = true; ! 979: } ! 980: ! 981: if (self->monsterinfo.aiflags & AI_PURSUE_NEXT) ! 982: { ! 983: self->monsterinfo.aiflags &= ~AI_PURSUE_NEXT; ! 984: // dprint("reached current goal: "); dprint(vtos(self.origin)); dprint(" "); dprint(vtos(self.last_sighting)); dprint(" "); dprint(ftos(vlen(self.origin - self.last_sighting))); dprint("\n"); ! 985: ! 986: // give ourself more time since we got this far ! 987: self->monsterinfo.search_time = level.time + 5; ! 988: ! 989: if (self->monsterinfo.aiflags & AI_PURSUE_TEMP) ! 990: { ! 991: // dprint("was temp goal; retrying original\n"); ! 992: self->monsterinfo.aiflags &= ~AI_PURSUE_TEMP; ! 993: marker = NULL; ! 994: VectorCopy (self->monsterinfo.saved_goal, self->monsterinfo.last_sighting); ! 995: new = true; ! 996: } ! 997: else if (self->monsterinfo.aiflags & AI_PURSUIT_LAST_SEEN) ! 998: { ! 999: self->monsterinfo.aiflags &= ~AI_PURSUIT_LAST_SEEN; ! 1000: marker = PlayerTrail_PickFirst (self); ! 1001: } ! 1002: else ! 1003: { ! 1004: marker = PlayerTrail_PickNext (self); ! 1005: } ! 1006: ! 1007: if (marker) ! 1008: { ! 1009: VectorCopy (marker->s.origin, self->monsterinfo.last_sighting); ! 1010: self->monsterinfo.trail_time = marker->timestamp; ! 1011: self->s.angles[YAW] = self->ideal_yaw = marker->s.angles[YAW]; ! 1012: // dprint("heading is "); dprint(ftos(self.ideal_yaw)); dprint("\n"); ! 1013: ! 1014: // debug_drawline(self.origin, self.last_sighting, 52); ! 1015: new = true; ! 1016: } ! 1017: } ! 1018: ! 1019: VectorSubtract (self->s.origin, self->monsterinfo.last_sighting, v); ! 1020: d1 = VectorLength(v); ! 1021: if (d1 <= dist) ! 1022: { ! 1023: self->monsterinfo.aiflags |= AI_PURSUE_NEXT; ! 1024: dist = d1; ! 1025: } ! 1026: ! 1027: VectorCopy (self->monsterinfo.last_sighting, self->goalentity->s.origin); ! 1028: ! 1029: if (new) ! 1030: { ! 1031: // gi.dprintf("checking for course correction\n"); ! 1032: ! 1033: tr = gi.trace(self->s.origin, self->mins, self->maxs, self->monsterinfo.last_sighting, self, MASK_PLAYERSOLID); ! 1034: if (tr.fraction < 1) ! 1035: { ! 1036: VectorSubtract (self->goalentity->s.origin, self->s.origin, v); ! 1037: d1 = VectorLength(v); ! 1038: center = tr.fraction; ! 1039: d2 = d1 * ((center+1)/2); ! 1040: self->s.angles[YAW] = self->ideal_yaw = vectoyaw(v); ! 1041: AngleVectors(self->s.angles, v_forward, v_right, NULL); ! 1042: ! 1043: VectorSet(v, d2, -16, 0); ! 1044: G_ProjectSource (self->s.origin, v, v_forward, v_right, left_target); ! 1045: tr = gi.trace(self->s.origin, self->mins, self->maxs, left_target, self, MASK_PLAYERSOLID); ! 1046: left = tr.fraction; ! 1047: ! 1048: VectorSet(v, d2, 16, 0); ! 1049: G_ProjectSource (self->s.origin, v, v_forward, v_right, right_target); ! 1050: tr = gi.trace(self->s.origin, self->mins, self->maxs, right_target, self, MASK_PLAYERSOLID); ! 1051: right = tr.fraction; ! 1052: ! 1053: center = (d1*center)/d2; ! 1054: if (left >= center && left > right) ! 1055: { ! 1056: if (left < 1) ! 1057: { ! 1058: VectorSet(v, d2 * left * 0.5, -16, 0); ! 1059: G_ProjectSource (self->s.origin, v, v_forward, v_right, left_target); ! 1060: // gi.dprintf("incomplete path, go part way and adjust again\n"); ! 1061: } ! 1062: VectorCopy (self->monsterinfo.last_sighting, self->monsterinfo.saved_goal); ! 1063: self->monsterinfo.aiflags |= AI_PURSUE_TEMP; ! 1064: VectorCopy (left_target, self->goalentity->s.origin); ! 1065: VectorCopy (left_target, self->monsterinfo.last_sighting); ! 1066: VectorSubtract (self->goalentity->s.origin, self->s.origin, v); ! 1067: self->s.angles[YAW] = self->ideal_yaw = vectoyaw(v); ! 1068: // gi.dprintf("adjusted left\n"); ! 1069: // debug_drawline(self.origin, self.last_sighting, 152); ! 1070: } ! 1071: else if (right >= center && right > left) ! 1072: { ! 1073: if (right < 1) ! 1074: { ! 1075: VectorSet(v, d2 * right * 0.5, 16, 0); ! 1076: G_ProjectSource (self->s.origin, v, v_forward, v_right, right_target); ! 1077: // gi.dprintf("incomplete path, go part way and adjust again\n"); ! 1078: } ! 1079: VectorCopy (self->monsterinfo.last_sighting, self->monsterinfo.saved_goal); ! 1080: self->monsterinfo.aiflags |= AI_PURSUE_TEMP; ! 1081: VectorCopy (right_target, self->goalentity->s.origin); ! 1082: VectorCopy (right_target, self->monsterinfo.last_sighting); ! 1083: VectorSubtract (self->goalentity->s.origin, self->s.origin, v); ! 1084: self->s.angles[YAW] = self->ideal_yaw = vectoyaw(v); ! 1085: // gi.dprintf("adjusted right\n"); ! 1086: // debug_drawline(self.origin, self.last_sighting, 152); ! 1087: } ! 1088: } ! 1089: // else gi.dprintf("course was fine\n"); ! 1090: } ! 1091: ! 1092: M_MoveToGoal (self, dist); ! 1093: ! 1094: G_FreeEdict(tempgoal); ! 1095: ! 1096: if (self) ! 1097: self->goalentity = save; ! 1098: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.