![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g_monster.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_monster.c CVS log | Up to [Quake II] / quake2 / rogue |
1.1 ! root 1: #include "g_local.h" ! 2: ! 3: ! 4: // ! 5: // monster weapons ! 6: // ! 7: ! 8: //FIXME mosnters should call these with a totally accurate direction ! 9: // and we can mess it up based on skill. Spread should be for normal ! 10: // and we can tighten or loosen based on skill. We could muck with ! 11: // the damages too, but I'm not sure that's such a good idea. ! 12: void monster_fire_bullet (edict_t *self, vec3_t start, vec3_t dir, int damage, int kick, int hspread, int vspread, int flashtype) ! 13: { ! 14: fire_bullet (self, start, dir, damage, kick, hspread, vspread, MOD_UNKNOWN); ! 15: ! 16: gi.WriteByte (svc_muzzleflash2); ! 17: gi.WriteShort (self - g_edicts); ! 18: gi.WriteByte (flashtype); ! 19: gi.multicast (start, MULTICAST_PVS); ! 20: } ! 21: ! 22: void monster_fire_shotgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int hspread, int vspread, int count, int flashtype) ! 23: { ! 24: fire_shotgun (self, start, aimdir, damage, kick, hspread, vspread, count, MOD_UNKNOWN); ! 25: ! 26: gi.WriteByte (svc_muzzleflash2); ! 27: gi.WriteShort (self - g_edicts); ! 28: gi.WriteByte (flashtype); ! 29: gi.multicast (start, MULTICAST_PVS); ! 30: } ! 31: ! 32: void monster_fire_blaster (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype, int effect) ! 33: { ! 34: fire_blaster (self, start, dir, damage, speed, effect, false); ! 35: ! 36: gi.WriteByte (svc_muzzleflash2); ! 37: gi.WriteShort (self - g_edicts); ! 38: gi.WriteByte (flashtype); ! 39: gi.multicast (start, MULTICAST_PVS); ! 40: } ! 41: ! 42: //ROGUE ! 43: void monster_fire_blaster2 (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype, int effect) ! 44: { ! 45: fire_blaster2 (self, start, dir, damage, speed, effect, false); ! 46: ! 47: gi.WriteByte (svc_muzzleflash2); ! 48: gi.WriteShort (self - g_edicts); ! 49: gi.WriteByte (flashtype); ! 50: gi.multicast (start, MULTICAST_PVS); ! 51: } ! 52: ! 53: // FIXME -- add muzzle flash ! 54: void monster_fire_tracker (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, edict_t *enemy, int flashtype) ! 55: { ! 56: fire_tracker (self, start, dir, damage, speed, enemy); ! 57: ! 58: gi.WriteByte (svc_muzzleflash2); ! 59: gi.WriteShort (self - g_edicts); ! 60: gi.WriteByte (flashtype); ! 61: gi.multicast (start, MULTICAST_PVS); ! 62: } ! 63: ! 64: void monster_fire_heat (edict_t *self, vec3_t start, vec3_t dir, vec3_t offset, int damage, int kick, int flashtype) ! 65: { ! 66: fire_heat (self, start, dir, offset, damage, kick, true); ! 67: ! 68: gi.WriteByte (svc_muzzleflash2); ! 69: gi.WriteShort (self - g_edicts); ! 70: gi.WriteByte (flashtype); ! 71: gi.multicast (start, MULTICAST_PVS); ! 72: } ! 73: //ROGUE ! 74: ! 75: void monster_fire_grenade (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int flashtype) ! 76: { ! 77: fire_grenade (self, start, aimdir, damage, speed, 2.5, damage+40); ! 78: ! 79: gi.WriteByte (svc_muzzleflash2); ! 80: gi.WriteShort (self - g_edicts); ! 81: gi.WriteByte (flashtype); ! 82: gi.multicast (start, MULTICAST_PVS); ! 83: } ! 84: ! 85: void monster_fire_rocket (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype) ! 86: { ! 87: fire_rocket (self, start, dir, damage, speed, damage+20, damage); ! 88: ! 89: gi.WriteByte (svc_muzzleflash2); ! 90: gi.WriteShort (self - g_edicts); ! 91: gi.WriteByte (flashtype); ! 92: gi.multicast (start, MULTICAST_PVS); ! 93: } ! 94: ! 95: void monster_fire_railgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int flashtype) ! 96: { ! 97: // PMM ! 98: if (!(gi.pointcontents (start) & MASK_SOLID)) ! 99: fire_rail (self, start, aimdir, damage, kick); ! 100: ! 101: gi.WriteByte (svc_muzzleflash2); ! 102: gi.WriteShort (self - g_edicts); ! 103: gi.WriteByte (flashtype); ! 104: gi.multicast (start, MULTICAST_PVS); ! 105: } ! 106: ! 107: void monster_fire_bfg (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int kick, float damage_radius, int flashtype) ! 108: { ! 109: fire_bfg (self, start, aimdir, damage, speed, damage_radius); ! 110: ! 111: gi.WriteByte (svc_muzzleflash2); ! 112: gi.WriteShort (self - g_edicts); ! 113: gi.WriteByte (flashtype); ! 114: gi.multicast (start, MULTICAST_PVS); ! 115: } ! 116: ! 117: ! 118: ! 119: // ! 120: // Monster utility functions ! 121: // ! 122: ! 123: void M_FliesOff (edict_t *self) ! 124: { ! 125: self->s.effects &= ~EF_FLIES; ! 126: self->s.sound = 0; ! 127: } ! 128: ! 129: void M_FliesOn (edict_t *self) ! 130: { ! 131: if (self->waterlevel) ! 132: return; ! 133: self->s.effects |= EF_FLIES; ! 134: self->s.sound = gi.soundindex ("infantry/inflies1.wav"); ! 135: self->think = M_FliesOff; ! 136: self->nextthink = level.time + 60; ! 137: } ! 138: ! 139: void M_FlyCheck (edict_t *self) ! 140: { ! 141: if (self->waterlevel) ! 142: return; ! 143: ! 144: if (random() > 0.5) ! 145: return; ! 146: ! 147: self->think = M_FliesOn; ! 148: self->nextthink = level.time + 5 + 10 * random(); ! 149: } ! 150: ! 151: void AttackFinished (edict_t *self, float time) ! 152: { ! 153: self->monsterinfo.attack_finished = level.time + time; ! 154: } ! 155: ! 156: ! 157: void M_CheckGround (edict_t *ent) ! 158: { ! 159: vec3_t point; ! 160: trace_t trace; ! 161: ! 162: if (ent->flags & (FL_SWIM|FL_FLY)) ! 163: return; ! 164: ! 165: #ifdef ROGUE_GRAVITY ! 166: if ((ent->velocity[2] * ent->gravityVector[2]) < -100) // PGM ! 167: #else ! 168: if (ent->velocity[2] > 100) ! 169: #endif ! 170: { ! 171: ent->groundentity = NULL; ! 172: return; ! 173: } ! 174: ! 175: // if the hull point one-quarter unit down is solid the entity is on ground ! 176: point[0] = ent->s.origin[0]; ! 177: point[1] = ent->s.origin[1]; ! 178: #ifdef ROGUE_GRAVITY ! 179: point[2] = ent->s.origin[2] + (0.25 * ent->gravityVector[2]); //PGM ! 180: #else ! 181: point[2] = ent->s.origin[2] - 0.25; ! 182: #endif ! 183: ! 184: trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, point, ent, MASK_MONSTERSOLID); ! 185: ! 186: // check steepness ! 187: #ifdef ROGUE_GRAVITY ! 188: //PGM ! 189: if ( ent->gravityVector[2] < 0) // normal gravity ! 190: { ! 191: if ( trace.plane.normal[2] < 0.7 && !trace.startsolid) ! 192: { ! 193: ent->groundentity = NULL; ! 194: return; ! 195: } ! 196: } ! 197: else // inverted gravity ! 198: { ! 199: if ( trace.plane.normal[2] > -0.7 && !trace.startsolid) ! 200: { ! 201: ent->groundentity = NULL; ! 202: return; ! 203: } ! 204: } ! 205: //PGM ! 206: #else ! 207: if ( trace.plane.normal[2] < 0.7 && !trace.startsolid) ! 208: { ! 209: ent->groundentity = NULL; ! 210: return; ! 211: } ! 212: #endif ! 213: ! 214: // ent->groundentity = trace.ent; ! 215: // ent->groundentity_linkcount = trace.ent->linkcount; ! 216: // if (!trace.startsolid && !trace.allsolid) ! 217: // VectorCopy (trace.endpos, ent->s.origin); ! 218: if (!trace.startsolid && !trace.allsolid) ! 219: { ! 220: VectorCopy (trace.endpos, ent->s.origin); ! 221: ent->groundentity = trace.ent; ! 222: ent->groundentity_linkcount = trace.ent->linkcount; ! 223: ent->velocity[2] = 0; ! 224: } ! 225: } ! 226: ! 227: ! 228: void M_CatagorizePosition (edict_t *ent) ! 229: { ! 230: vec3_t point; ! 231: int cont; ! 232: ! 233: // ! 234: // get waterlevel ! 235: // ! 236: point[0] = ent->s.origin[0]; ! 237: point[1] = ent->s.origin[1]; ! 238: point[2] = ent->s.origin[2] + ent->mins[2] + 1; ! 239: cont = gi.pointcontents (point); ! 240: ! 241: if (!(cont & MASK_WATER)) ! 242: { ! 243: ent->waterlevel = 0; ! 244: ent->watertype = 0; ! 245: return; ! 246: } ! 247: ! 248: ent->watertype = cont; ! 249: ent->waterlevel = 1; ! 250: point[2] += 26; ! 251: cont = gi.pointcontents (point); ! 252: if (!(cont & MASK_WATER)) ! 253: return; ! 254: ! 255: ent->waterlevel = 2; ! 256: point[2] += 22; ! 257: cont = gi.pointcontents (point); ! 258: if (cont & MASK_WATER) ! 259: ent->waterlevel = 3; ! 260: } ! 261: ! 262: ! 263: void M_WorldEffects (edict_t *ent) ! 264: { ! 265: int dmg; ! 266: ! 267: if (ent->health > 0) ! 268: { ! 269: if (!(ent->flags & FL_SWIM)) ! 270: { ! 271: if (ent->waterlevel < 3) ! 272: { ! 273: ent->air_finished = level.time + 12; ! 274: } ! 275: else if (ent->air_finished < level.time) ! 276: { // drown! ! 277: if (ent->pain_debounce_time < level.time) ! 278: { ! 279: dmg = 2 + 2 * floor(level.time - ent->air_finished); ! 280: if (dmg > 15) ! 281: dmg = 15; ! 282: T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, dmg, 0, DAMAGE_NO_ARMOR, MOD_WATER); ! 283: ent->pain_debounce_time = level.time + 1; ! 284: } ! 285: } ! 286: } ! 287: else ! 288: { ! 289: if (ent->waterlevel > 0) ! 290: { ! 291: ent->air_finished = level.time + 9; ! 292: } ! 293: else if (ent->air_finished < level.time) ! 294: { // suffocate! ! 295: if (ent->pain_debounce_time < level.time) ! 296: { ! 297: dmg = 2 + 2 * floor(level.time - ent->air_finished); ! 298: if (dmg > 15) ! 299: dmg = 15; ! 300: T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, dmg, 0, DAMAGE_NO_ARMOR, MOD_WATER); ! 301: ent->pain_debounce_time = level.time + 1; ! 302: } ! 303: } ! 304: } ! 305: } ! 306: ! 307: if (ent->waterlevel == 0) ! 308: { ! 309: if (ent->flags & FL_INWATER) ! 310: { ! 311: gi.sound (ent, CHAN_BODY, gi.soundindex("player/watr_out.wav"), 1, ATTN_NORM, 0); ! 312: ent->flags &= ~FL_INWATER; ! 313: } ! 314: return; ! 315: } ! 316: ! 317: if ((ent->watertype & CONTENTS_LAVA) && !(ent->flags & FL_IMMUNE_LAVA)) ! 318: { ! 319: if (ent->damage_debounce_time < level.time) ! 320: { ! 321: ent->damage_debounce_time = level.time + 0.2; ! 322: T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, 10*ent->waterlevel, 0, 0, MOD_LAVA); ! 323: } ! 324: } ! 325: if ((ent->watertype & CONTENTS_SLIME) && !(ent->flags & FL_IMMUNE_SLIME)) ! 326: { ! 327: if (ent->damage_debounce_time < level.time) ! 328: { ! 329: ent->damage_debounce_time = level.time + 1; ! 330: T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, 4*ent->waterlevel, 0, 0, MOD_SLIME); ! 331: } ! 332: } ! 333: ! 334: if ( !(ent->flags & FL_INWATER) ) ! 335: { ! 336: if (!(ent->svflags & SVF_DEADMONSTER)) ! 337: { ! 338: if (ent->watertype & CONTENTS_LAVA) ! 339: if (random() <= 0.5) ! 340: gi.sound (ent, CHAN_BODY, gi.soundindex("player/lava1.wav"), 1, ATTN_NORM, 0); ! 341: else ! 342: gi.sound (ent, CHAN_BODY, gi.soundindex("player/lava2.wav"), 1, ATTN_NORM, 0); ! 343: else if (ent->watertype & CONTENTS_SLIME) ! 344: gi.sound (ent, CHAN_BODY, gi.soundindex("player/watr_in.wav"), 1, ATTN_NORM, 0); ! 345: else if (ent->watertype & CONTENTS_WATER) ! 346: gi.sound (ent, CHAN_BODY, gi.soundindex("player/watr_in.wav"), 1, ATTN_NORM, 0); ! 347: } ! 348: ! 349: ent->flags |= FL_INWATER; ! 350: ent->damage_debounce_time = 0; ! 351: } ! 352: } ! 353: ! 354: ! 355: void M_droptofloor (edict_t *ent) ! 356: { ! 357: vec3_t end; ! 358: trace_t trace; ! 359: ! 360: #ifdef ROGUE_GRAVITY ! 361: //PGM ! 362: if(ent->gravityVector[2] < 0) ! 363: { ! 364: ent->s.origin[2] += 1; ! 365: VectorCopy (ent->s.origin, end); ! 366: end[2] -= 256; ! 367: } ! 368: else ! 369: { ! 370: ent->s.origin[2] -= 1; ! 371: VectorCopy (ent->s.origin, end); ! 372: end[2] += 256; ! 373: } ! 374: //PGM ! 375: #else ! 376: ent->s.origin[2] += 1; ! 377: VectorCopy (ent->s.origin, end); ! 378: end[2] -= 256; ! 379: #endif ! 380: ! 381: trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, end, ent, MASK_MONSTERSOLID); ! 382: ! 383: if (trace.fraction == 1 || trace.allsolid) ! 384: return; ! 385: ! 386: VectorCopy (trace.endpos, ent->s.origin); ! 387: ! 388: gi.linkentity (ent); ! 389: M_CheckGround (ent); ! 390: M_CatagorizePosition (ent); ! 391: } ! 392: ! 393: ! 394: void M_SetEffects (edict_t *ent) ! 395: { ! 396: int remaining; ! 397: ! 398: ent->s.effects &= ~(EF_COLOR_SHELL|EF_POWERSCREEN|EF_DOUBLE|EF_QUAD|EF_PENT); ! 399: ent->s.renderfx &= ~(RF_SHELL_RED|RF_SHELL_GREEN|RF_SHELL_BLUE|RF_SHELL_DOUBLE); ! 400: ! 401: if (ent->monsterinfo.aiflags & AI_RESURRECTING) ! 402: { ! 403: ent->s.effects |= EF_COLOR_SHELL; ! 404: ent->s.renderfx |= RF_SHELL_RED; ! 405: } ! 406: ! 407: if (ent->health <= 0) ! 408: return; ! 409: ! 410: if (ent->powerarmor_time > level.time) ! 411: { ! 412: if (ent->monsterinfo.power_armor_type == POWER_ARMOR_SCREEN) ! 413: { ! 414: ent->s.effects |= EF_POWERSCREEN; ! 415: } ! 416: else if (ent->monsterinfo.power_armor_type == POWER_ARMOR_SHIELD) ! 417: { ! 418: ent->s.effects |= EF_COLOR_SHELL; ! 419: ent->s.renderfx |= RF_SHELL_GREEN; ! 420: } ! 421: } ! 422: // PMM - new monster powerups ! 423: if (ent->monsterinfo.quad_framenum > level.framenum) ! 424: { ! 425: remaining = ent->monsterinfo.quad_framenum - level.framenum; ! 426: if (remaining > 30 || (remaining & 4) ) ! 427: ent->s.effects |= EF_QUAD; ! 428: } ! 429: else ! 430: ent->s.effects &= ~EF_QUAD; ! 431: ! 432: if (ent->monsterinfo.double_framenum > level.framenum) ! 433: { ! 434: remaining = ent->monsterinfo.double_framenum - level.framenum; ! 435: if (remaining > 30 || (remaining & 4) ) ! 436: ent->s.effects |= EF_DOUBLE; ! 437: } ! 438: else ! 439: ent->s.effects &= ~EF_DOUBLE; ! 440: ! 441: if (ent->monsterinfo.invincible_framenum > level.framenum) ! 442: { ! 443: remaining = ent->monsterinfo.invincible_framenum - level.framenum; ! 444: if (remaining > 30 || (remaining & 4) ) ! 445: ent->s.effects |= EF_PENT; ! 446: } ! 447: else ! 448: ent->s.effects &= ~EF_PENT; ! 449: ! 450: // PMM ! 451: // PMM - testing ! 452: // ent->s.effects |= EF_COLOR_SHELL; ! 453: // ent->s.renderfx |= RF_SHELL_HALF_DAM; ! 454: /* ! 455: if (fmod (level.time, 4.0) > 2.0) ! 456: { ! 457: gi.dprintf ("invulnerable "); ! 458: ent->s.renderfx |= RF_SHELL_RED; ! 459: } ! 460: else ! 461: ent->s.renderfx &= ~RF_SHELL_RED; ! 462: ! 463: if (fmod (level.time, 8.0) > 4.0) ! 464: { ! 465: gi.dprintf ("shield "); ! 466: ent->s.renderfx |= RF_SHELL_GREEN; ! 467: } ! 468: else ! 469: ent->s.renderfx &= ~RF_SHELL_GREEN; ! 470: ! 471: if (fmod (level.time, 16.0) > 8.0) ! 472: { ! 473: gi.dprintf ("quad "); ! 474: ent->s.renderfx |= RF_SHELL_BLUE;\ ! 475: } ! 476: else ! 477: ent->s.renderfx &= ~RF_SHELL_BLUE; ! 478: ! 479: if (fmod (level.time, 32.0) > 16.0) ! 480: { ! 481: gi.dprintf ("double "); ! 482: ent->s.renderfx |= RF_SHELL_DOUBLE; ! 483: } ! 484: else ! 485: ent->s.renderfx &= ~RF_SHELL_DOUBLE; ! 486: ! 487: if (fmod (level.time, 64.0) > 32.0) ! 488: { ! 489: gi.dprintf ("half "); ! 490: ent->s.renderfx |= RF_SHELL_HALF_DAM; ! 491: } ! 492: else ! 493: ent->s.renderfx &= ~RF_SHELL_HALF_DAM; ! 494: ! 495: gi.dprintf ("\n"); ! 496: */ ! 497: } ! 498: ! 499: ! 500: void M_MoveFrame (edict_t *self) ! 501: { ! 502: mmove_t *move; ! 503: int index; ! 504: ! 505: move = self->monsterinfo.currentmove; ! 506: self->nextthink = level.time + FRAMETIME; ! 507: ! 508: if ((self->monsterinfo.nextframe) && (self->monsterinfo.nextframe >= move->firstframe) && (self->monsterinfo.nextframe <= move->lastframe)) ! 509: { ! 510: self->s.frame = self->monsterinfo.nextframe; ! 511: self->monsterinfo.nextframe = 0; ! 512: } ! 513: else ! 514: { ! 515: if (self->s.frame == move->lastframe) ! 516: { ! 517: if (move->endfunc) ! 518: { ! 519: move->endfunc (self); ! 520: ! 521: // regrab move, endfunc is very likely to change it ! 522: move = self->monsterinfo.currentmove; ! 523: ! 524: // check for death ! 525: if (self->svflags & SVF_DEADMONSTER) ! 526: return; ! 527: } ! 528: } ! 529: ! 530: if (self->s.frame < move->firstframe || self->s.frame > move->lastframe) ! 531: { ! 532: self->monsterinfo.aiflags &= ~AI_HOLD_FRAME; ! 533: self->s.frame = move->firstframe; ! 534: } ! 535: else ! 536: { ! 537: if (!(self->monsterinfo.aiflags & AI_HOLD_FRAME)) ! 538: { ! 539: self->s.frame++; ! 540: if (self->s.frame > move->lastframe) ! 541: self->s.frame = move->firstframe; ! 542: } ! 543: } ! 544: } ! 545: ! 546: index = self->s.frame - move->firstframe; ! 547: ! 548: if (move->frame[index].aifunc) ! 549: if (!(self->monsterinfo.aiflags & AI_HOLD_FRAME)) ! 550: move->frame[index].aifunc (self, move->frame[index].dist * self->monsterinfo.scale); ! 551: else ! 552: move->frame[index].aifunc (self, 0); ! 553: ! 554: if (move->frame[index].thinkfunc) ! 555: move->frame[index].thinkfunc (self); ! 556: } ! 557: ! 558: ! 559: void monster_think (edict_t *self) ! 560: { ! 561: M_MoveFrame (self); ! 562: if (self->linkcount != self->monsterinfo.linkcount) ! 563: { ! 564: self->monsterinfo.linkcount = self->linkcount; ! 565: M_CheckGround (self); ! 566: } ! 567: M_CatagorizePosition (self); ! 568: M_WorldEffects (self); ! 569: M_SetEffects (self); ! 570: } ! 571: ! 572: ! 573: /* ! 574: ================ ! 575: monster_use ! 576: ! 577: Using a monster makes it angry at the current activator ! 578: ================ ! 579: */ ! 580: void monster_use (edict_t *self, edict_t *other, edict_t *activator) ! 581: { ! 582: if (self->enemy) ! 583: return; ! 584: if (self->health <= 0) ! 585: return; ! 586: if (activator->flags & FL_NOTARGET) ! 587: return; ! 588: if (!(activator->client) && !(activator->monsterinfo.aiflags & AI_GOOD_GUY)) ! 589: return; ! 590: if (activator->flags & FL_DISGUISED) // PGM ! 591: return; // PGM ! 592: ! 593: // delay reaction so if the monster is teleported, its sound is still heard ! 594: self->enemy = activator; ! 595: FoundTarget (self); ! 596: } ! 597: ! 598: ! 599: void monster_start_go (edict_t *self); ! 600: ! 601: ! 602: void monster_triggered_spawn (edict_t *self) ! 603: { ! 604: self->s.origin[2] += 1; ! 605: KillBox (self); ! 606: ! 607: self->solid = SOLID_BBOX; ! 608: self->movetype = MOVETYPE_STEP; ! 609: self->svflags &= ~SVF_NOCLIENT; ! 610: self->air_finished = level.time + 12; ! 611: gi.linkentity (self); ! 612: ! 613: monster_start_go (self); ! 614: ! 615: if (self->enemy && !(self->spawnflags & 1) && !(self->enemy->flags & FL_NOTARGET)) ! 616: { ! 617: if(!(self->enemy->flags & FL_DISGUISED)) // PGM ! 618: FoundTarget (self); ! 619: } ! 620: else ! 621: { ! 622: self->enemy = NULL; ! 623: } ! 624: } ! 625: ! 626: void monster_triggered_spawn_use (edict_t *self, edict_t *other, edict_t *activator) ! 627: { ! 628: // we have a one frame delay here so we don't telefrag the guy who activated us ! 629: self->think = monster_triggered_spawn; ! 630: self->nextthink = level.time + FRAMETIME; ! 631: if (activator->client) ! 632: self->enemy = activator; ! 633: self->use = monster_use; ! 634: } ! 635: ! 636: void monster_triggered_start (edict_t *self) ! 637: { ! 638: self->solid = SOLID_NOT; ! 639: self->movetype = MOVETYPE_NONE; ! 640: self->svflags |= SVF_NOCLIENT; ! 641: self->nextthink = 0; ! 642: self->use = monster_triggered_spawn_use; ! 643: } ! 644: ! 645: ! 646: /* ! 647: ================ ! 648: monster_death_use ! 649: ! 650: When a monster dies, it fires all of its targets with the current ! 651: enemy as activator. ! 652: ================ ! 653: */ ! 654: void monster_death_use (edict_t *self) ! 655: { ! 656: self->flags &= ~(FL_FLY|FL_SWIM); ! 657: self->monsterinfo.aiflags &= AI_GOOD_GUY; ! 658: ! 659: if (self->item) ! 660: { ! 661: Drop_Item (self, self->item); ! 662: self->item = NULL; ! 663: } ! 664: ! 665: if (self->deathtarget) ! 666: self->target = self->deathtarget; ! 667: ! 668: if (!self->target) ! 669: return; ! 670: ! 671: G_UseTargets (self, self->enemy); ! 672: } ! 673: ! 674: ! 675: //============================================================================ ! 676: ! 677: qboolean monster_start (edict_t *self) ! 678: { ! 679: if (deathmatch->value) ! 680: { ! 681: G_FreeEdict (self); ! 682: return false; ! 683: } ! 684: ! 685: if ((self->spawnflags & 4) && !(self->monsterinfo.aiflags & AI_GOOD_GUY)) ! 686: { ! 687: self->spawnflags &= ~4; ! 688: self->spawnflags |= 1; ! 689: // gi.dprintf("fixed spawnflags on %s at %s\n", self->classname, vtos(self->s.origin)); ! 690: } ! 691: ! 692: if ((!(self->monsterinfo.aiflags & AI_GOOD_GUY)) && (!(self->monsterinfo.aiflags & AI_DO_NOT_COUNT))) ! 693: level.total_monsters++; ! 694: ! 695: self->nextthink = level.time + FRAMETIME; ! 696: self->svflags |= SVF_MONSTER; ! 697: self->s.renderfx |= RF_FRAMELERP; ! 698: self->takedamage = DAMAGE_AIM; ! 699: self->air_finished = level.time + 12; ! 700: self->use = monster_use; ! 701: self->max_health = self->health; ! 702: self->clipmask = MASK_MONSTERSOLID; ! 703: ! 704: self->s.skinnum = 0; ! 705: self->deadflag = DEAD_NO; ! 706: self->svflags &= ~SVF_DEADMONSTER; ! 707: ! 708: if (!self->monsterinfo.checkattack) ! 709: self->monsterinfo.checkattack = M_CheckAttack; ! 710: VectorCopy (self->s.origin, self->s.old_origin); ! 711: ! 712: if (st.item) ! 713: { ! 714: self->item = FindItemByClassname (st.item); ! 715: if (!self->item) ! 716: gi.dprintf("%s at %s has bad item: %s\n", self->classname, vtos(self->s.origin), st.item); ! 717: } ! 718: ! 719: // randomize what frame they start on ! 720: if (self->monsterinfo.currentmove) ! 721: self->s.frame = self->monsterinfo.currentmove->firstframe + (rand() % (self->monsterinfo.currentmove->lastframe - self->monsterinfo.currentmove->firstframe + 1)); ! 722: ! 723: // PMM - get this so I don't have to do it in all of the monsters ! 724: self->monsterinfo.base_height = self->maxs[2]; ! 725: ! 726: // PMM - clear these ! 727: self->monsterinfo.quad_framenum = 0; ! 728: self->monsterinfo.double_framenum = 0; ! 729: self->monsterinfo.invincible_framenum = 0; ! 730: ! 731: return true; ! 732: } ! 733: ! 734: void monster_start_go (edict_t *self) ! 735: { ! 736: vec3_t v; ! 737: ! 738: if (self->health <= 0) ! 739: return; ! 740: ! 741: // check for target to combat_point and change to combattarget ! 742: if (self->target) ! 743: { ! 744: qboolean notcombat; ! 745: qboolean fixup; ! 746: edict_t *target; ! 747: ! 748: target = NULL; ! 749: notcombat = false; ! 750: fixup = false; ! 751: while ((target = G_Find (target, FOFS(targetname), self->target)) != NULL) ! 752: { ! 753: if (strcmp(target->classname, "point_combat") == 0) ! 754: { ! 755: self->combattarget = self->target; ! 756: fixup = true; ! 757: } ! 758: else ! 759: { ! 760: notcombat = true; ! 761: } ! 762: } ! 763: if (notcombat && self->combattarget) ! 764: gi.dprintf("%s at %s has target with mixed types\n", self->classname, vtos(self->s.origin)); ! 765: if (fixup) ! 766: self->target = NULL; ! 767: } ! 768: ! 769: // validate combattarget ! 770: if (self->combattarget) ! 771: { ! 772: edict_t *target; ! 773: ! 774: target = NULL; ! 775: while ((target = G_Find (target, FOFS(targetname), self->combattarget)) != NULL) ! 776: { ! 777: if (strcmp(target->classname, "point_combat") != 0) ! 778: { ! 779: gi.dprintf("%s at (%i %i %i) has a bad combattarget %s : %s at (%i %i %i)\n", ! 780: self->classname, (int)self->s.origin[0], (int)self->s.origin[1], (int)self->s.origin[2], ! 781: self->combattarget, target->classname, (int)target->s.origin[0], (int)target->s.origin[1], ! 782: (int)target->s.origin[2]); ! 783: } ! 784: } ! 785: } ! 786: ! 787: if (self->target) ! 788: { ! 789: self->goalentity = self->movetarget = G_PickTarget(self->target); ! 790: if (!self->movetarget) ! 791: { ! 792: gi.dprintf ("%s can't find target %s at %s\n", self->classname, self->target, vtos(self->s.origin)); ! 793: self->target = NULL; ! 794: self->monsterinfo.pausetime = 100000000; ! 795: self->monsterinfo.stand (self); ! 796: } ! 797: else if (strcmp (self->movetarget->classname, "path_corner") == 0) ! 798: { ! 799: VectorSubtract (self->goalentity->s.origin, self->s.origin, v); ! 800: self->ideal_yaw = self->s.angles[YAW] = vectoyaw(v); ! 801: self->monsterinfo.walk (self); ! 802: self->target = NULL; ! 803: } ! 804: else ! 805: { ! 806: self->goalentity = self->movetarget = NULL; ! 807: self->monsterinfo.pausetime = 100000000; ! 808: self->monsterinfo.stand (self); ! 809: } ! 810: } ! 811: else ! 812: { ! 813: self->monsterinfo.pausetime = 100000000; ! 814: self->monsterinfo.stand (self); ! 815: } ! 816: ! 817: self->think = monster_think; ! 818: self->nextthink = level.time + FRAMETIME; ! 819: } ! 820: ! 821: ! 822: void walkmonster_start_go (edict_t *self) ! 823: { ! 824: if (!(self->spawnflags & 2) && level.time < 1) ! 825: { ! 826: M_droptofloor (self); ! 827: ! 828: if (self->groundentity) ! 829: if (!M_walkmove (self, 0, 0)) ! 830: gi.dprintf ("%s in solid at %s\n", self->classname, vtos(self->s.origin)); ! 831: } ! 832: ! 833: if (!self->yaw_speed) ! 834: self->yaw_speed = 20; ! 835: // PMM - stalkers are too short for this ! 836: if (!(strcmp(self->classname, "monster_stalker"))) ! 837: self->viewheight = 15; ! 838: else ! 839: self->viewheight = 25; ! 840: ! 841: monster_start_go (self); ! 842: ! 843: if (self->spawnflags & 2) ! 844: monster_triggered_start (self); ! 845: } ! 846: ! 847: void walkmonster_start (edict_t *self) ! 848: { ! 849: self->think = walkmonster_start_go; ! 850: monster_start (self); ! 851: } ! 852: ! 853: ! 854: void flymonster_start_go (edict_t *self) ! 855: { ! 856: if (!M_walkmove (self, 0, 0)) ! 857: gi.dprintf ("%s in solid at %s\n", self->classname, vtos(self->s.origin)); ! 858: ! 859: if (!self->yaw_speed) ! 860: self->yaw_speed = 10; ! 861: self->viewheight = 25; ! 862: ! 863: monster_start_go (self); ! 864: ! 865: if (self->spawnflags & 2) ! 866: monster_triggered_start (self); ! 867: } ! 868: ! 869: ! 870: void flymonster_start (edict_t *self) ! 871: { ! 872: self->flags |= FL_FLY; ! 873: self->think = flymonster_start_go; ! 874: monster_start (self); ! 875: } ! 876: ! 877: ! 878: void swimmonster_start_go (edict_t *self) ! 879: { ! 880: if (!self->yaw_speed) ! 881: self->yaw_speed = 10; ! 882: self->viewheight = 10; ! 883: ! 884: monster_start_go (self); ! 885: ! 886: if (self->spawnflags & 2) ! 887: monster_triggered_start (self); ! 888: } ! 889: ! 890: void swimmonster_start (edict_t *self) ! 891: { ! 892: self->flags |= FL_SWIM; ! 893: self->think = swimmonster_start_go; ! 894: monster_start (self); ! 895: } ! 896: ! 897: //ROGUE ! 898: ! 899: void stationarymonster_start_go (edict_t *self); ! 900: ! 901: void stationarymonster_triggered_spawn (edict_t *self) ! 902: { ! 903: KillBox (self); ! 904: ! 905: self->solid = SOLID_BBOX; ! 906: self->movetype = MOVETYPE_NONE; ! 907: self->svflags &= ~SVF_NOCLIENT; ! 908: self->air_finished = level.time + 12; ! 909: gi.linkentity (self); ! 910: ! 911: // FIXME - why doesn't this happen with real monsters? ! 912: self->spawnflags &= ~2; ! 913: ! 914: stationarymonster_start_go (self); ! 915: ! 916: if (self->enemy && !(self->spawnflags & 1) && !(self->enemy->flags & FL_NOTARGET)) ! 917: { ! 918: if(!(self->enemy->flags & FL_DISGUISED)) // PGM ! 919: FoundTarget (self); ! 920: } ! 921: else ! 922: { ! 923: self->enemy = NULL; ! 924: } ! 925: } ! 926: ! 927: void stationarymonster_triggered_spawn_use (edict_t *self, edict_t *other, edict_t *activator) ! 928: { ! 929: // we have a one frame delay here so we don't telefrag the guy who activated us ! 930: self->think = stationarymonster_triggered_spawn; ! 931: self->nextthink = level.time + FRAMETIME; ! 932: if (activator->client) ! 933: self->enemy = activator; ! 934: self->use = monster_use; ! 935: } ! 936: ! 937: void stationarymonster_triggered_start (edict_t *self) ! 938: { ! 939: self->solid = SOLID_NOT; ! 940: self->movetype = MOVETYPE_NONE; ! 941: self->svflags |= SVF_NOCLIENT; ! 942: self->nextthink = 0; ! 943: self->use = stationarymonster_triggered_spawn_use; ! 944: } ! 945: ! 946: void stationarymonster_start_go (edict_t *self) ! 947: { ! 948: if (!M_walkmove (self, 0, 0)) ! 949: gi.dprintf ("%s in solid at %s\n", self->classname, vtos(self->s.origin)); ! 950: ! 951: if (!self->yaw_speed) ! 952: self->yaw_speed = 20; ! 953: // self->viewheight = 25; ! 954: ! 955: monster_start_go (self); ! 956: ! 957: if (self->spawnflags & 2) ! 958: stationarymonster_triggered_start (self); ! 959: } ! 960: ! 961: void stationarymonster_start (edict_t *self) ! 962: { ! 963: self->think = stationarymonster_start_go; ! 964: monster_start (self); ! 965: } ! 966: ! 967: void monster_done_dodge (edict_t *self) ! 968: { ! 969: // if ((g_showlogic) && (g_showlogic->value)) ! 970: // gi.dprintf ("%s done dodging\n", self->classname); ! 971: self->monsterinfo.aiflags &= ~AI_DODGING; ! 972: } ! 973: //ROGUE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.