Games/Doom/p_enemy.c

   1 // Emacs style mode select   -*- C++ -*-
   2 //-----------------------------------------------------------------------------
   3 //
   4 // $Id$
   5 //
   6 // Copyright (C) 1993-1996 by id Software, Inc.
   7 //
   8 // This source is available for distribution and/or modification
   9 // only under the terms of the DOOM Source Code License as
  10 // published by id Software. All rights reserved.
  11 //
  12 // The source is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15 // for more details.
  16 //
  17 // $Log$
  18 // Revision 1.3  2004/04/28 10:17:39  hkiel
  19 // For consistency use __AMIGAOS__ instead of AMIGAOS and enable Xaos again
  20 //
  21 // Revision 1.2  2004/04/27 16:42:56  hkiel
  22 // Fixed #ifdef AMIGA to #ifdef AMIGAOS
  23 //
  24 // Revision 1.1  2000/02/29 18:21:04  stegerg
  25 // Doom port based on ADoomPPC. Read README.AROS!
  26 //
  27 //
  28 // DESCRIPTION:
  29 //      Enemy thinking, AI.
  30 //      Action Pointer Functions
  31 //      that are associated with states/frames.
  32 //
  33 //-----------------------------------------------------------------------------
  34
  35 static const char
  36 rcsid[] = "$Id$";
  37
  38 #ifdef AROS
  39 #define iabs abs
  40 #endif
  41
  42 #include <stdlib.h>
  43 #ifdef __AMIGAOS__
  44 #include <dos.h>
  45 #endif
  46
  47 #include "m_random.h"
  48 #include "i_system.h"
  49
  50 #include "doomdef.h"
  51 #include "p_local.h"
  52
  53 #include "s_sound.h"
  54
  55 #include "g_game.h"
  56
  57 // State.
  58 #include "doomstat.h"
  59 #include "r_state.h"
  60
  61 // Data.
  62 #include "sounds.h"
  63
  64
  65
  66
  67 typedef enum
  68 {
  69     DI_EAST,
  70     DI_NORTHEAST,
  71     DI_NORTH,
  72     DI_NORTHWEST,
  73     DI_WEST,
  74     DI_SOUTHWEST,
  75     DI_SOUTH,
  76     DI_SOUTHEAST,
  77     DI_NODIR,
  78     NUMDIRS
  79
  80 } dirtype_t;
  81
  82
  83 //
  84 // P_NewChaseDir related LUT.
  85 //
  86 dirtype_t opposite[] =
  87 {
  88   DI_WEST, DI_SOUTHWEST, DI_SOUTH, DI_SOUTHEAST,
  89   DI_EAST, DI_NORTHEAST, DI_NORTH, DI_NORTHWEST, DI_NODIR
  90 };
  91
  92 dirtype_t diags[] =
  93 {
  94     DI_NORTHWEST, DI_NORTHEAST, DI_SOUTHWEST, DI_SOUTHEAST
  95 };
  96
  97
  98
  99
 100
 101 void A_Fall (mobj_t *actor);
 102
 103
 104 //
 105 // ENEMY THINKING
 106 // Enemies are allways spawned
 107 // with targetplayer = -1, threshold = 0
 108 // Most monsters are spawned unaware of all players,
 109 // but some can be made preaware
 110 //
 111
 112
 113 //
 114 // Called by P_NoiseAlert.
 115 // Recursively traverse adjacent sectors,
 116 // sound blocking lines cut off traversal.
 117 //
 118
 119 mobj_t*         soundtarget;
 120
 121 void
 122 P_RecursiveSound
 123 ( sector_t*     sec,
 124   int           soundblocks )
 125 {
 126     int         i;
 127     line_t*     check;
 128     sector_t*   other;
 129
 130     // wake up all monsters in this sector
 131     if (sec->validcount == validcount
 132         && sec->soundtraversed <= soundblocks+1)
 133     {
 134         return;         // already flooded
 135     }
 136
 137     sec->validcount = validcount;
 138     sec->soundtraversed = soundblocks+1;
 139     sec->soundtarget = soundtarget;
 140
 141     for (i=0 ;i<sec->linecount ; i++)
 142     {
 143         check = sec->lines[i];
 144         if (! (check->flags & ML_TWOSIDED) )
 145             continue;
 146
 147         P_LineOpening (check);
 148
 149         if (openrange <= 0)
 150             continue;   // closed door
 151
 152         if ( sides[ check->sidenum[0] ].sector == sec)
 153             other = sides[ check->sidenum[1] ] .sector;
 154         else
 155             other = sides[ check->sidenum[0] ].sector;
 156
 157         if (check->flags & ML_SOUNDBLOCK)
 158         {
 159             if (!soundblocks)
 160                 P_RecursiveSound (other, 1);
 161         }
 162         else
 163             P_RecursiveSound (other, soundblocks);
 164     }
 165 }
 166
 167
 168
 169 //
 170 // P_NoiseAlert
 171 // If a monster yells at a player,
 172 // it will alert other monsters to the player.
 173 //
 174 void
 175 P_NoiseAlert
 176 ( mobj_t*       target,
 177   mobj_t*       emmiter )
 178 {
 179     soundtarget = target;
 180     validcount++;
 181     P_RecursiveSound (emmiter->subsector->sector, 0);
 182 }
 183
 184
 185
 186
 187 //
 188 // P_CheckMeleeRange
 189 //
 190 boolean P_CheckMeleeRange (mobj_t*      actor)
 191 {
 192     mobj_t*     pl;
 193     fixed_t     dist;
 194
 195     if (!actor->target)
 196         return false;
 197
 198     pl = actor->target;
 199     dist = P_AproxDistance (pl->x-actor->x, pl->y-actor->y);
 200
 201     if (dist >= MELEERANGE-20*FRACUNIT+pl->info->radius)
 202         return false;
 203
 204     if (! P_CheckSight (actor, actor->target) )
 205         return false;
 206
 207     return true;
 208 }
 209
 210 //
 211 // P_CheckMissileRange
 212 //
 213 boolean P_CheckMissileRange (mobj_t* actor)
 214 {
 215     fixed_t     dist;
 216
 217     if (! P_CheckSight (actor, actor->target) )
 218         return false;
 219
 220     if ( actor->flags & MF_JUSTHIT )
 221     {
 222         // the target just hit the enemy,
 223         // so fight back!
 224         actor->flags &= ~MF_JUSTHIT;
 225         return true;
 226     }
 227
 228     if (actor->reactiontime)
 229         return false;   // do not attack yet
 230
 231     // OPTIMIZE: get this from a global checksight
 232     dist = P_AproxDistance ( actor->x-actor->target->x,
 233                              actor->y-actor->target->y) - 64*FRACUNIT;
 234
 235     if (!actor->info->meleestate)
 236         dist -= 128*FRACUNIT;   // no melee attack, so fire more
 237
 238     dist >>= 16;
 239
 240     if (actor->type == MT_VILE)
 241     {
 242         if (dist > 14*64)
 243             return false;       // too far away
 244     }
 245
 246
 247     if (actor->type == MT_UNDEAD)
 248     {
 249         if (dist < 196)
 250             return false;       // close for fist attack
 251         dist >>= 1;
 252     }
 253
 254
 255     if (actor->type == MT_CYBORG
 256         || actor->type == MT_SPIDER
 257         || actor->type == MT_SKULL)
 258     {
 259         dist >>= 1;
 260     }
 261
 262     if (dist > 200)
 263         dist = 200;
 264
 265     if (actor->type == MT_CYBORG && dist > 160)
 266         dist = 160;
 267
 268     if (P_Random () < dist)
 269         return false;
 270
 271     return true;
 272 }
 273
 274
 275 //
 276 // P_Move
 277 // Move in the current direction,
 278 // returns false if the move is blocked.
 279 //
 280 fixed_t xspeed[8] = {FRACUNIT,47000,0,-47000,-FRACUNIT,-47000,0,47000};
 281 fixed_t yspeed[8] = {0,47000,FRACUNIT,47000,0,-47000,-FRACUNIT,-47000};
 282
 283 #define MAXSPECIALCROSS 20  /* was 8 */
 284
 285 extern  line_t* spechit[MAXSPECIALCROSS];
 286 extern  int     numspechit;
 287
 288 boolean P_Move (mobj_t* actor)
 289 {
 290     fixed_t     tryx;
 291     fixed_t     tryy;
 292
 293     line_t*     ld;
 294
 295     // warning: 'catch', 'throw', and 'try'
 296     // are all C++ reserved words
 297     boolean     try_ok;
 298     boolean     good;
 299
 300     if (actor->movedir == DI_NODIR)
 301         return false;
 302
 303     if ((unsigned)actor->movedir >= 8)
 304         I_Error ("Weird actor->movedir!");
 305
 306     tryx = actor->x + actor->info->speed*xspeed[actor->movedir];
 307     tryy = actor->y + actor->info->speed*yspeed[actor->movedir];
 308
 309     try_ok = P_TryMove (actor, tryx, tryy);
 310
 311     if (!try_ok)
 312     {
 313         // open any specials
 314         if (actor->flags & MF_FLOAT && floatok)
 315         {
 316             // must adjust height
 317             if (actor->z < tmfloorz)
 318                 actor->z += FLOATSPEED;
 319             else
 320                 actor->z -= FLOATSPEED;
 321
 322             actor->flags |= MF_INFLOAT;
 323             return true;
 324         }
 325
 326         if (!numspechit)
 327             return false;
 328
 329         actor->movedir = DI_NODIR;
 330         good = false;
 331         while (numspechit--)
 332         {
 333             ld = spechit[numspechit];
 334             // if the special is not a door
 335             // that can be opened,
 336             // return false
 337             if (P_UseSpecialLine (actor, ld,0))
 338                 good = true;
 339         }
 340         return good;
 341     }
 342     else
 343     {
 344         actor->flags &= ~MF_INFLOAT;
 345     }
 346
 347
 348     if (! (actor->flags & MF_FLOAT) )
 349         actor->z = actor->floorz;
 350     return true;
 351 }
 352
 353
 354 //
 355 // TryWalk
 356 // Attempts to move actor on
 357 // in its current (ob->moveangle) direction.
 358 // If blocked by either a wall or an actor
 359 // returns FALSE
 360 // If move is either clear or blocked only by a door,
 361 // returns TRUE and sets...
 362 // If a door is in the way,
 363 // an OpenDoor call is made to start it opening.
 364 //
 365 boolean P_TryWalk (mobj_t* actor)
 366 {
 367     if (!P_Move (actor))
 368     {
 369         return false;
 370     }
 371
 372     actor->movecount = P_Random()&15;
 373     return true;
 374 }
 375
 376
 377
 378
 379 void P_NewChaseDir (mobj_t*     actor)
 380 {
 381     fixed_t     deltax;
 382     fixed_t     deltay;
 383
 384     dirtype_t   d[3];
 385
 386     int         tdir;
 387     dirtype_t   olddir;
 388
 389     dirtype_t   turnaround;
 390
 391     if (!actor->target)
 392         I_Error ("P_NewChaseDir: called with no target");
 393
 394     olddir = actor->movedir;
 395     turnaround=opposite[olddir];
 396
 397     deltax = actor->target->x - actor->x;
 398     deltay = actor->target->y - actor->y;
 399
 400     if (deltax>10*FRACUNIT)
 401         d[1]= DI_EAST;
 402     else if (deltax<-10*FRACUNIT)
 403         d[1]= DI_WEST;
 404     else
 405         d[1]=DI_NODIR;
 406
 407     if (deltay<-10*FRACUNIT)
 408         d[2]= DI_SOUTH;
 409     else if (deltay>10*FRACUNIT)
 410         d[2]= DI_NORTH;
 411     else
 412         d[2]=DI_NODIR;
 413
 414     // try direct route
 415     if (d[1] != DI_NODIR
 416         && d[2] != DI_NODIR)
 417     {
 418         actor->movedir = diags[((deltay<0)<<1)+(deltax>0)];
 419         if (actor->movedir != turnaround && P_TryWalk(actor))
 420             return;
 421     }
 422
 423     // try other directions
 424     if (P_Random() > 200
 425         ||  iabs(deltay)>iabs(deltax))
 426     {
 427         tdir=d[1];
 428         d[1]=d[2];
 429         d[2]=tdir;
 430     }
 431
 432     if (d[1]==turnaround)
 433         d[1]=DI_NODIR;
 434     if (d[2]==turnaround)
 435         d[2]=DI_NODIR;
 436
 437     if (d[1]!=DI_NODIR)
 438     {
 439         actor->movedir = d[1];
 440         if (P_TryWalk(actor))
 441         {
 442             // either moved forward or attacked
 443             return;
 444         }
 445     }
 446
 447     if (d[2]!=DI_NODIR)
 448     {
 449         actor->movedir =d[2];
 450
 451         if (P_TryWalk(actor))
 452             return;
 453     }
 454
 455     // there is no direct path to the player,
 456     // so pick another direction.
 457     if (olddir!=DI_NODIR)
 458     {
 459         actor->movedir =olddir;
 460
 461         if (P_TryWalk(actor))
 462             return;
 463     }
 464
 465     // randomly determine direction of search
 466     if (P_Random()&1)
 467     {
 468         for ( tdir=DI_EAST;
 469               tdir<=DI_SOUTHEAST;
 470               tdir++ )
 471         {
 472             if (tdir!=turnaround)
 473             {
 474                 actor->movedir =tdir;
 475
 476                 if ( P_TryWalk(actor) )
 477                     return;
 478             }
 479         }
 480     }
 481     else
 482     {
 483         for ( tdir=DI_SOUTHEAST;
 484               tdir != (DI_EAST-1);
 485               tdir-- )
 486         {
 487             if (tdir!=turnaround)
 488             {
 489                 actor->movedir =tdir;
 490
 491                 if ( P_TryWalk(actor) )
 492                     return;
 493             }
 494         }
 495     }
 496
 497     if (turnaround !=  DI_NODIR)
 498     {
 499         actor->movedir =turnaround;
 500         if ( P_TryWalk(actor) )
 501             return;
 502     }
 503
 504     actor->movedir = DI_NODIR;  // can not move
 505 }
 506
 507
 508
 509 //
 510 // P_LookForPlayers
 511 // If allaround is false, only look 180 degrees in front.
 512 // Returns true if a player is targeted.
 513 //
 514 boolean
 515 P_LookForPlayers
 516 ( mobj_t*       actor,
 517   boolean       allaround )
 518 {
 519     int         c;
 520     int         stop;
 521     player_t*   player;
 522     sector_t*   sector;
 523     angle_t     an;
 524     fixed_t     dist;
 525
 526     sector = actor->subsector->sector;
 527
 528     c = 0;
 529     stop = (actor->lastlook-1)&3;
 530
 531     for ( ; ; actor->lastlook = (actor->lastlook+1)&3 )
 532     {
 533         if (!playeringame[actor->lastlook]) {
 534 #ifdef __AMIGAOS__
 535             chkabort ();
 536 #endif
 537             continue;
 538         }
 539
 540         if (c++ == 2
 541             || actor->lastlook == stop)
 542         {
 543             // done looking
 544             return false;
 545         }
 546
 547         player = &players[actor->lastlook];
 548
 549         if (player->health <= 0)
 550             continue;           // dead
 551
 552         if (!P_CheckSight (actor, player->mo))
 553             continue;           // out of sight
 554
 555         if (!allaround)
 556         {
 557             an = R_PointToAngle2 (actor->x,
 558                                   actor->y,
 559                                   player->mo->x,
 560                                   player->mo->y)
 561                 - actor->angle;
 562
 563             if (an > ANG90 && an < ANG270)
 564             {
 565                 dist = P_AproxDistance (player->mo->x - actor->x,
 566                                         player->mo->y - actor->y);
 567                 // if real close, react anyway
 568                 if (dist > MELEERANGE)
 569                     continue;   // behind back
 570             }
 571         }
 572
 573         actor->target = player->mo;
 574         return true;
 575     }
 576
 577     return false;
 578 }
 579
 580
 581 //
 582 // A_KeenDie
 583 // DOOM II special, map 32.
 584 // Uses special tag 666.
 585 //
 586 void A_KeenDie (mobj_t* mo)
 587 {
 588     thinker_t*  th;
 589     mobj_t*     mo2;
 590     line_t      junk;
 591
 592     A_Fall (mo);
 593
 594     // scan the remaining thinkers
 595     // to see if all Keens are dead
 596     for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
 597     {
 598         if (th->function.acp1 != (actionf_p1)P_MobjThinker)
 599             continue;
 600
 601         mo2 = (mobj_t *)th;
 602         if (mo2 != mo
 603             && mo2->type == mo->type
 604             && mo2->health > 0)
 605         {
 606             // other Keen not dead
 607             return;
 608         }
 609     }
 610
 611     junk.tag = 666;
 612     EV_DoDoor(&junk,open);
 613 }
 614
 615
 616 //
 617 // ACTION ROUTINES
 618 //
 619
 620 //
 621 // A_Look
 622 // Stay in state until a player is sighted.
 623 //
 624 void A_Look (mobj_t* actor)
 625 {
 626     mobj_t*     targ;
 627
 628     actor->threshold = 0;       // any shot will wake up
 629     targ = actor->subsector->sector->soundtarget;
 630
 631     if (targ
 632         && (targ->flags & MF_SHOOTABLE) )
 633     {
 634         actor->target = targ;
 635
 636         if ( actor->flags & MF_AMBUSH )
 637         {
 638             if (P_CheckSight (actor, actor->target))
 639                 goto seeyou;
 640         }
 641         else
 642             goto seeyou;
 643     }
 644
 645
 646     if (!P_LookForPlayers (actor, false) )
 647         return;
 648
 649     // go into chase state
 650   seeyou:
 651     if (actor->info->seesound)
 652     {
 653         int             sound;
 654
 655         switch (actor->info->seesound)
 656         {
 657           case sfx_posit1:
 658           case sfx_posit2:
 659           case sfx_posit3:
 660             sound = sfx_posit1+P_Random()%3;
 661             break;
 662
 663           case sfx_bgsit1:
 664           case sfx_bgsit2:
 665             sound = sfx_bgsit1+P_Random()%2;
 666             break;
 667
 668           default:
 669             sound = actor->info->seesound;
 670             break;
 671         }
 672
 673         if (actor->type==MT_SPIDER
 674             || actor->type == MT_CYBORG)
 675         {
 676             // full volume
 677             S_StartSound (NULL, sound);
 678         }
 679         else
 680             S_StartSound (actor, sound);
 681     }
 682
 683     P_SetMobjState (actor, actor->info->seestate);
 684 }
 685
 686
 687 //
 688 // A_Chase
 689 // Actor has a melee attack,
 690 // so it tries to close as fast as possible
 691 //
 692 void A_Chase (mobj_t*   actor)
 693 {
 694     int         delta;
 695
 696     if (actor->reactiontime)
 697         actor->reactiontime--;
 698
 699
 700     // modify target threshold
 701     if  (actor->threshold)
 702     {
 703         if (!actor->target
 704             || actor->target->health <= 0)
 705         {
 706             actor->threshold = 0;
 707         }
 708         else
 709             actor->threshold--;
 710     }
 711
 712     // turn towards movement direction if not there yet
 713     if (actor->movedir < 8)
 714     {
 715         actor->angle &= (7<<29);
 716         delta = actor->angle - (actor->movedir << 29);
 717
 718         if (delta > 0)
 719             actor->angle -= ANG90/2;
 720         else if (delta < 0)
 721             actor->angle += ANG90/2;
 722     }
 723
 724     if (!actor->target
 725         || !(actor->target->flags&MF_SHOOTABLE))
 726     {
 727         // look for a new target
 728         if (P_LookForPlayers(actor,true))
 729             return;     // got a new target
 730
 731         P_SetMobjState (actor, actor->info->spawnstate);
 732         return;
 733     }
 734
 735     // do not attack twice in a row
 736     if (actor->flags & MF_JUSTATTACKED)
 737     {
 738         actor->flags &= ~MF_JUSTATTACKED;
 739         if (gameskill != sk_nightmare && !fastparm)
 740             P_NewChaseDir (actor);
 741         return;
 742     }
 743
 744     // check for melee attack
 745     if (actor->info->meleestate
 746         && P_CheckMeleeRange (actor))
 747     {
 748         if (actor->info->attacksound)
 749             S_StartSound (actor, actor->info->attacksound);
 750
 751         P_SetMobjState (actor, actor->info->meleestate);
 752         return;
 753     }
 754
 755     // check for missile attack
 756     if (actor->info->missilestate)
 757     {
 758         if (gameskill < sk_nightmare
 759             && !fastparm && actor->movecount)
 760         {
 761             goto nomissile;
 762         }
 763
 764         if (!P_CheckMissileRange (actor))
 765             goto nomissile;
 766
 767         P_SetMobjState (actor, actor->info->missilestate);
 768         actor->flags |= MF_JUSTATTACKED;
 769         return;
 770     }
 771
 772     // ?
 773   nomissile:
 774     // possibly choose another target
 775     if (netgame
 776         && !actor->threshold
 777         && !P_CheckSight (actor, actor->target) )
 778     {
 779         if (P_LookForPlayers(actor,true))
 780             return;     // got a new target
 781     }
 782
 783     // chase towards player
 784     if (--actor->movecount<0
 785         || !P_Move (actor))
 786     {
 787         P_NewChaseDir (actor);
 788     }
 789
 790     // make active sound
 791     if (actor->info->activesound
 792         && P_Random () < 3)
 793     {
 794         S_StartSound (actor, actor->info->activesound);
 795     }
 796 }
 797
 798
 799 //
 800 // A_FaceTarget
 801 //
 802 void A_FaceTarget (mobj_t* actor)
 803 {
 804     if (!actor->target)
 805         return;
 806
 807     actor->flags &= ~MF_AMBUSH;
 808
 809     actor->angle = R_PointToAngle2 (actor->x,
 810                                     actor->y,
 811                                     actor->target->x,
 812                                     actor->target->y);
 813
 814     if (actor->target->flags & MF_SHADOW)
 815         actor->angle += (P_Random()-P_Random())<<21;
 816 }
 817
 818
 819 //
 820 // A_PosAttack
 821 //
 822 void A_PosAttack (mobj_t* actor)
 823 {
 824     int         angle;
 825     int         damage;
 826     int         slope;
 827
 828     if (!actor->target)
 829         return;
 830
 831     A_FaceTarget (actor);
 832     angle = actor->angle;
 833     slope = P_AimLineAttack (actor, angle, MISSILERANGE);
 834
 835     S_StartSound (actor, sfx_pistol);
 836     angle += (P_Random()-P_Random())<<20;
 837     damage = ((P_Random()%5)+1)*3;
 838     P_LineAttack (actor, angle, MISSILERANGE, slope, damage);
 839 }
 840
 841 void A_SPosAttack (mobj_t* actor)
 842 {
 843     int         i;
 844     int         angle;
 845     int         bangle;
 846     int         damage;
 847     int         slope;
 848
 849     if (!actor->target)
 850         return;
 851
 852     S_StartSound (actor, sfx_shotgn);
 853     A_FaceTarget (actor);
 854     bangle = actor->angle;
 855     slope = P_AimLineAttack (actor, bangle, MISSILERANGE);
 856
 857     for (i=0 ; i<3 ; i++)
 858     {
 859         angle = bangle + ((P_Random()-P_Random())<<20);
 860         damage = ((P_Random()%5)+1)*3;
 861         P_LineAttack (actor, angle, MISSILERANGE, slope, damage);
 862     }
 863 }
 864
 865 void A_CPosAttack (mobj_t* actor)
 866 {
 867     int         angle;
 868     int         bangle;
 869     int         damage;
 870     int         slope;
 871
 872     if (!actor->target)
 873         return;
 874
 875     S_StartSound (actor, sfx_shotgn);
 876     A_FaceTarget (actor);
 877     bangle = actor->angle;
 878     slope = P_AimLineAttack (actor, bangle, MISSILERANGE);
 879
 880     angle = bangle + ((P_Random()-P_Random())<<20);
 881     damage = ((P_Random()%5)+1)*3;
 882     P_LineAttack (actor, angle, MISSILERANGE, slope, damage);
 883 }
 884
 885 void A_CPosRefire (mobj_t* actor)
 886 {
 887     // keep firing unless target got out of sight
 888     A_FaceTarget (actor);
 889
 890     if (P_Random () < 40)
 891         return;
 892
 893     if (!actor->target
 894         || actor->target->health <= 0
 895         || !P_CheckSight (actor, actor->target) )
 896     {
 897         P_SetMobjState (actor, actor->info->seestate);
 898     }
 899 }
 900
 901
 902 void A_SpidRefire (mobj_t* actor)
 903 {
 904     // keep firing unless target got out of sight
 905     A_FaceTarget (actor);
 906
 907     if (P_Random () < 10)
 908         return;
 909
 910     if (!actor->target
 911         || actor->target->health <= 0
 912         || !P_CheckSight (actor, actor->target) )
 913     {
 914         P_SetMobjState (actor, actor->info->seestate);
 915     }
 916 }
 917
 918 void A_BspiAttack (mobj_t *actor)
 919 {
 920     if (!actor->target)
 921         return;
 922
 923     A_FaceTarget (actor);
 924
 925     // launch a missile
 926     P_SpawnMissile (actor, actor->target, MT_ARACHPLAZ);
 927 }
 928
 929
 930 //
 931 // A_TroopAttack
 932 //
 933 void A_TroopAttack (mobj_t* actor)
 934 {
 935     int         damage;
 936
 937     if (!actor->target)
 938         return;
 939
 940     A_FaceTarget (actor);
 941     if (P_CheckMeleeRange (actor))
 942     {
 943         S_StartSound (actor, sfx_claw);
 944         damage = (P_Random()%8+1)*3;
 945         P_DamageMobj (actor->target, actor, actor, damage);
 946         return;
 947     }
 948
 949
 950     // launch a missile
 951     P_SpawnMissile (actor, actor->target, MT_TROOPSHOT);
 952 }
 953
 954
 955 void A_SargAttack (mobj_t* actor)
 956 {
 957     int         damage;
 958
 959     if (!actor->target)
 960         return;
 961
 962     A_FaceTarget (actor);
 963     if (P_CheckMeleeRange (actor))
 964     {
 965         damage = ((P_Random()%10)+1)*4;
 966         P_DamageMobj (actor->target, actor, actor, damage);
 967     }
 968 }
 969
 970 void A_HeadAttack (mobj_t* actor)
 971 {
 972     int         damage;
 973
 974     if (!actor->target)
 975         return;
 976
 977     A_FaceTarget (actor);
 978     if (P_CheckMeleeRange (actor))
 979     {
 980         damage = (P_Random()%6+1)*10;
 981         P_DamageMobj (actor->target, actor, actor, damage);
 982         return;
 983     }
 984
 985     // launch a missile
 986     P_SpawnMissile (actor, actor->target, MT_HEADSHOT);
 987 }
 988
 989 void A_CyberAttack (mobj_t* actor)
 990 {
 991     if (!actor->target)
 992         return;
 993
 994     A_FaceTarget (actor);
 995     P_SpawnMissile (actor, actor->target, MT_ROCKET);
 996 }
 997
 998
 999 void A_BruisAttack (mobj_t* actor)
1000 {
1001     int         damage;
1002
1003     if (!actor->target)
1004         return;
1005
1006     if (P_CheckMeleeRange (actor))
1007     {
1008         S_StartSound (actor, sfx_claw);
1009         damage = (P_Random()%8+1)*10;
1010         P_DamageMobj (actor->target, actor, actor, damage);
1011         return;
1012     }
1013
1014     // launch a missile
1015     P_SpawnMissile (actor, actor->target, MT_BRUISERSHOT);
1016 }
1017
1018
1019 //
1020 // A_SkelMissile
1021 //
1022 void A_SkelMissile (mobj_t* actor)
1023 {
1024     mobj_t*     mo;
1025
1026     if (!actor->target)
1027         return;
1028
1029     A_FaceTarget (actor);
1030     actor->z += 16*FRACUNIT;    // so missile spawns higher
1031     mo = P_SpawnMissile (actor, actor->target, MT_TRACER);
1032     actor->z -= 16*FRACUNIT;    // back to normal
1033
1034     mo->x += mo->momx;
1035     mo->y += mo->momy;
1036     mo->tracer = actor->target;
1037 }
1038
1039 int     TRACEANGLE = 0xc000000;
1040
1041 void A_Tracer (mobj_t* actor)
1042 {
1043     angle_t     exact;
1044     fixed_t     dist;
1045     fixed_t     slope;
1046     mobj_t*     dest;
1047     mobj_t*     th;
1048
1049     if (gametic & 3)
1050         return;
1051
1052     // spawn a puff of smoke behind the rocket
1053     P_SpawnPuff (actor->x, actor->y, actor->z);
1054
1055     th = P_SpawnMobj (actor->x-actor->momx,
1056                       actor->y-actor->momy,
1057                       actor->z, MT_SMOKE);
1058
1059     th->momz = FRACUNIT;
1060     th->tics -= P_Random()&3;
1061     if (th->tics < 1)
1062         th->tics = 1;
1063
1064     // adjust direction
1065     dest = actor->tracer;
1066
1067     if (!dest || dest->health <= 0)
1068         return;
1069
1070     // change angle
1071     exact = R_PointToAngle2 (actor->x,
1072                              actor->y,
1073                              dest->x,
1074                              dest->y);
1075
1076     if (exact != actor->angle)
1077     {
1078         if (exact - actor->angle > 0x80000000)
1079         {
1080             actor->angle -= TRACEANGLE;
1081             if (exact - actor->angle < 0x80000000)
1082                 actor->angle = exact;
1083         }
1084         else
1085         {
1086             actor->angle += TRACEANGLE;
1087             if (exact - actor->angle > 0x80000000)
1088                 actor->angle = exact;
1089         }
1090     }
1091
1092     exact = actor->angle>>ANGLETOFINESHIFT;
1093     actor->momx = FixedMul (actor->info->speed, finecosine[exact]);
1094     actor->momy = FixedMul (actor->info->speed, finesine[exact]);
1095
1096     // change slope
1097     dist = P_AproxDistance (dest->x - actor->x,
1098                             dest->y - actor->y);
1099
1100     dist = dist / actor->info->speed;
1101
1102     if (dist < 1)
1103         dist = 1;
1104     slope = (dest->z+40*FRACUNIT - actor->z) / dist;
1105
1106     if (slope < actor->momz)
1107         actor->momz -= FRACUNIT/8;
1108     else
1109         actor->momz += FRACUNIT/8;
1110 }
1111
1112
1113 void A_SkelWhoosh (mobj_t*      actor)
1114 {
1115     if (!actor->target)
1116         return;
1117     A_FaceTarget (actor);
1118     S_StartSound (actor,sfx_skeswg);
1119 }
1120
1121 void A_SkelFist (mobj_t*        actor)
1122 {
1123     int         damage;
1124
1125     if (!actor->target)
1126         return;
1127
1128     A_FaceTarget (actor);
1129
1130     if (P_CheckMeleeRange (actor))
1131     {
1132         damage = ((P_Random()%10)+1)*6;
1133         S_StartSound (actor, sfx_skepch);
1134         P_DamageMobj (actor->target, actor, actor, damage);
1135     }
1136 }
1137
1138
1139
1140 //
1141 // PIT_VileCheck
1142 // Detect a corpse that could be raised.
1143 //
1144 mobj_t*         corpsehit;
1145 mobj_t*         vileobj;
1146 fixed_t         viletryx;
1147 fixed_t         viletryy;
1148
1149 boolean PIT_VileCheck (mobj_t*  thing)
1150 {
1151     int         maxdist;
1152     boolean     check;
1153
1154     if (!(thing->flags & MF_CORPSE) )
1155         return true;    // not a monster
1156
1157     if (thing->tics != -1)
1158         return true;    // not lying still yet
1159
1160     if (thing->info->raisestate == S_NULL)
1161         return true;    // monster doesn't have a raise state
1162
1163     maxdist = thing->info->radius + mobjinfo[MT_VILE].radius;
1164
1165     if ( iabs(thing->x - viletryx) > maxdist
1166          || iabs(thing->y - viletryy) > maxdist )
1167         return true;            // not actually touching
1168
1169     corpsehit = thing;
1170     corpsehit->momx = corpsehit->momy = 0;
1171     corpsehit->height <<= 2;
1172     check = P_CheckPosition (corpsehit, corpsehit->x, corpsehit->y);
1173     corpsehit->height >>= 2;
1174
1175     if (!check)
1176         return true;            // doesn't fit here
1177
1178     return false;               // got one, so stop checking
1179 }
1180
1181
1182
1183 //
1184 // A_VileChase
1185 // Check for ressurecting a body
1186 //
1187 void A_VileChase (mobj_t* actor)
1188 {
1189     int                 xl;
1190     int                 xh;
1191     int                 yl;
1192     int                 yh;
1193
1194     int                 bx;
1195     int                 by;
1196
1197     mobjinfo_t*         info;
1198     mobj_t*             temp;
1199
1200     if (actor->movedir != DI_NODIR)
1201     {
1202         // check for corpses to raise
1203         viletryx =
1204             actor->x + actor->info->speed*xspeed[actor->movedir];
1205         viletryy =
1206             actor->y + actor->info->speed*yspeed[actor->movedir];
1207
1208         xl = (viletryx - bmaporgx - MAXRADIUS*2)>>MAPBLOCKSHIFT;
1209         xh = (viletryx - bmaporgx + MAXRADIUS*2)>>MAPBLOCKSHIFT;
1210         yl = (viletryy - bmaporgy - MAXRADIUS*2)>>MAPBLOCKSHIFT;
1211         yh = (viletryy - bmaporgy + MAXRADIUS*2)>>MAPBLOCKSHIFT;
1212
1213         vileobj = actor;
1214         for (bx=xl ; bx<=xh ; bx++)
1215         {
1216             for (by=yl ; by<=yh ; by++)
1217             {
1218                 // Call PIT_VileCheck to check
1219                 // whether object is a corpse
1220                 // that canbe raised.
1221                 if (!P_BlockThingsIterator(bx,by,PIT_VileCheck))
1222                 {
1223                     // got one!
1224                     temp = actor->target;
1225                     actor->target = corpsehit;
1226                     A_FaceTarget (actor);
1227                     actor->target = temp;
1228
1229                     P_SetMobjState (actor, S_VILE_HEAL1);
1230                     S_StartSound (corpsehit, sfx_slop);
1231                     info = corpsehit->info;
1232
1233                     P_SetMobjState (corpsehit,info->raisestate);
1234                     corpsehit->height <<= 2;
1235                     corpsehit->flags = info->flags;
1236                     corpsehit->health = info->spawnhealth;
1237                     corpsehit->target = NULL;
1238
1239                     return;
1240                 }
1241             }
1242         }
1243     }
1244
1245     // Return to normal attack.
1246     A_Chase (actor);
1247 }
1248
1249
1250 //
1251 // A_VileStart
1252 //
1253 void A_VileStart (mobj_t* actor)
1254 {
1255     S_StartSound (actor, sfx_vilatk);
1256 }
1257
1258
1259 //
1260 // A_Fire
1261 // Keep fire in front of player unless out of sight
1262 //
1263 void A_Fire (mobj_t* actor);
1264
1265 void A_StartFire (mobj_t* actor)
1266 {
1267     S_StartSound(actor,sfx_flamst);
1268     A_Fire(actor);
1269 }
1270
1271 void A_FireCrackle (mobj_t* actor)
1272 {
1273     S_StartSound(actor,sfx_flame);
1274     A_Fire(actor);
1275 }
1276
1277 void A_Fire (mobj_t* actor)
1278 {
1279     mobj_t*     dest;
1280     unsigned    an;
1281
1282     dest = actor->tracer;
1283     if (!dest)
1284         return;
1285
1286     // don't move it if the vile lost sight
1287     if (!P_CheckSight (actor->target, dest) )
1288         return;
1289
1290     an = dest->angle >> ANGLETOFINESHIFT;
1291
1292     P_UnsetThingPosition (actor);
1293     actor->x = dest->x + FixedMul (24*FRACUNIT, finecosine[an]);
1294     actor->y = dest->y + FixedMul (24*FRACUNIT, finesine[an]);
1295     actor->z = dest->z;
1296     P_SetThingPosition (actor);
1297 }
1298
1299
1300
1301 //
1302 // A_VileTarget
1303 // Spawn the hellfire
1304 //
1305 void A_VileTarget (mobj_t*      actor)
1306 {
1307     mobj_t*     fog;
1308
1309     if (!actor->target)
1310         return;
1311
1312     A_FaceTarget (actor);
1313
1314     fog = P_SpawnMobj (actor->target->x,
1315                        actor->target->x,
1316                        actor->target->z, MT_FIRE);
1317
1318     actor->tracer = fog;
1319     fog->target = actor;
1320     fog->tracer = actor->target;
1321     A_Fire (fog);
1322 }
1323
1324
1325
1326
1327 //
1328 // A_VileAttack
1329 //
1330 void A_VileAttack (mobj_t* actor)
1331 {
1332     mobj_t*     fire;
1333     int         an;
1334
1335     if (!actor->target)
1336         return;
1337
1338     A_FaceTarget (actor);
1339
1340     if (!P_CheckSight (actor, actor->target) )
1341         return;
1342
1343     S_StartSound (actor, sfx_barexp);
1344     P_DamageMobj (actor->target, actor, actor, 20);
1345     actor->target->momz = 1000*FRACUNIT/actor->target->info->mass;
1346
1347     an = actor->angle >> ANGLETOFINESHIFT;
1348
1349     fire = actor->tracer;
1350
1351     if (!fire)
1352         return;
1353
1354     // move the fire between the vile and the player
1355     fire->x = actor->target->x - FixedMul (24*FRACUNIT, finecosine[an]);
1356     fire->y = actor->target->y - FixedMul (24*FRACUNIT, finesine[an]);
1357     P_RadiusAttack (fire, actor, 70 );
1358 }
1359
1360
1361
1362
1363 //
1364 // Mancubus attack,
1365 // firing three missiles (bruisers)
1366 // in three different directions?
1367 // Doesn't look like it.
1368 //
1369 #define FATSPREAD       (ANG90/8)
1370
1371 void A_FatRaise (mobj_t *actor)
1372 {
1373     A_FaceTarget (actor);
1374     S_StartSound (actor, sfx_manatk);
1375 }
1376
1377
1378 void A_FatAttack1 (mobj_t* actor)
1379 {
1380     mobj_t*     mo;
1381     int         an;
1382
1383     A_FaceTarget (actor);
1384     // Change direction  to ...
1385     actor->angle += FATSPREAD;
1386     P_SpawnMissile (actor, actor->target, MT_FATSHOT);
1387
1388     mo = P_SpawnMissile (actor, actor->target, MT_FATSHOT);
1389     mo->angle += FATSPREAD;
1390     an = mo->angle >> ANGLETOFINESHIFT;
1391     mo->momx = FixedMul (mo->info->speed, finecosine[an]);
1392     mo->momy = FixedMul (mo->info->speed, finesine[an]);
1393 }
1394
1395 void A_FatAttack2 (mobj_t* actor)
1396 {
1397     mobj_t*     mo;
1398     int         an;
1399
1400     A_FaceTarget (actor);
1401     // Now here choose opposite deviation.
1402     actor->angle -= FATSPREAD;
1403     P_SpawnMissile (actor, actor->target, MT_FATSHOT);
1404
1405     mo = P_SpawnMissile (actor, actor->target, MT_FATSHOT);
1406     mo->angle -= FATSPREAD*2;
1407     an = mo->angle >> ANGLETOFINESHIFT;
1408     mo->momx = FixedMul (mo->info->speed, finecosine[an]);
1409     mo->momy = FixedMul (mo->info->speed, finesine[an]);
1410 }
1411
1412 void A_FatAttack3 (mobj_t*      actor)
1413 {
1414     mobj_t*     mo;
1415     int         an;
1416
1417     A_FaceTarget (actor);
1418
1419     mo = P_SpawnMissile (actor, actor->target, MT_FATSHOT);
1420     mo->angle -= FATSPREAD/2;
1421     an = mo->angle >> ANGLETOFINESHIFT;
1422     mo->momx = FixedMul (mo->info->speed, finecosine[an]);
1423     mo->momy = FixedMul (mo->info->speed, finesine[an]);
1424
1425     mo = P_SpawnMissile (actor, actor->target, MT_FATSHOT);
1426     mo->angle += FATSPREAD/2;
1427     an = mo->angle >> ANGLETOFINESHIFT;
1428     mo->momx = FixedMul (mo->info->speed, finecosine[an]);
1429     mo->momy = FixedMul (mo->info->speed, finesine[an]);
1430 }
1431
1432
1433 //
1434 // SkullAttack
1435 // Fly at the player like a missile.
1436 //
1437 #define SKULLSPEED              (20*FRACUNIT)
1438
1439 void A_SkullAttack (mobj_t* actor)
1440 {
1441     mobj_t*             dest;
1442     angle_t             an;
1443     int                 dist;
1444
1445     if (!actor->target)
1446         return;
1447
1448     dest = actor->target;
1449     actor->flags |= MF_SKULLFLY;
1450
1451     S_StartSound (actor, actor->info->attacksound);
1452     A_FaceTarget (actor);
1453     an = actor->angle >> ANGLETOFINESHIFT;
1454     actor->momx = FixedMul (SKULLSPEED, finecosine[an]);
1455     actor->momy = FixedMul (SKULLSPEED, finesine[an]);
1456     dist = P_AproxDistance (dest->x - actor->x, dest->y - actor->y);
1457     dist = dist / SKULLSPEED;
1458
1459     if (dist < 1)
1460         dist = 1;
1461     actor->momz = (dest->z+(dest->height>>1) - actor->z) / dist;
1462 }
1463
1464
1465 //
1466 // A_PainShootSkull
1467 // Spawn a lost soul and launch it at the target
1468 //
1469 void
1470 A_PainShootSkull
1471 ( mobj_t*       actor,
1472   angle_t       angle )
1473 {
1474     fixed_t     x;
1475     fixed_t     y;
1476     fixed_t     z;
1477
1478     mobj_t*     newmobj;
1479     angle_t     an;
1480     int         prestep;
1481     int         count;
1482     thinker_t*  currentthinker;
1483
1484     // count total number of skull currently on the level
1485     count = 0;
1486
1487     currentthinker = thinkercap.next;
1488     while (currentthinker != &thinkercap)
1489     {
1490         if (   (currentthinker->function.acp1 == (actionf_p1)P_MobjThinker)
1491             && ((mobj_t *)currentthinker)->type == MT_SKULL)
1492             count++;
1493         currentthinker = currentthinker->next;
1494     }
1495
1496     // if there are allready 20 skulls on the level,
1497     // don't spit another one
1498     if (count > 20)
1499         return;
1500
1501
1502     // okay, there's playe for another one
1503     an = angle >> ANGLETOFINESHIFT;
1504
1505     prestep =
1506         4*FRACUNIT
1507         + 3*(actor->info->radius + mobjinfo[MT_SKULL].radius)/2;
1508
1509     x = actor->x + FixedMul (prestep, finecosine[an]);
1510     y = actor->y + FixedMul (prestep, finesine[an]);
1511     z = actor->z + 8*FRACUNIT;
1512
1513     newmobj = P_SpawnMobj (x , y, z, MT_SKULL);
1514
1515     // Check for movements.
1516     if (!P_TryMove (newmobj, newmobj->x, newmobj->y))
1517     {
1518         // kill it immediately
1519         P_DamageMobj (newmobj,actor,actor,10000);
1520         return;
1521     }
1522
1523     newmobj->target = actor->target;
1524     A_SkullAttack (newmobj);
1525 }
1526
1527
1528 //
1529 // A_PainAttack
1530 // Spawn a lost soul and launch it at the target
1531 //
1532 void A_PainAttack (mobj_t* actor)
1533 {
1534     if (!actor->target)
1535         return;
1536
1537     A_FaceTarget (actor);
1538     A_PainShootSkull (actor, actor->angle);
1539 }
1540
1541
1542 void A_PainDie (mobj_t* actor)
1543 {
1544     A_Fall (actor);
1545     A_PainShootSkull (actor, actor->angle+ANG90);
1546     A_PainShootSkull (actor, actor->angle+ANG180);
1547     A_PainShootSkull (actor, actor->angle+ANG270);
1548 }
1549
1550
1551
1552
1553
1554
1555 void A_Scream (mobj_t* actor)
1556 {
1557     int         sound;
1558
1559     switch (actor->info->deathsound)
1560     {
1561       case 0:
1562         return;
1563
1564       case sfx_podth1:
1565       case sfx_podth2:
1566       case sfx_podth3:
1567         sound = sfx_podth1 + P_Random ()%3;
1568         break;
1569
1570       case sfx_bgdth1:
1571       case sfx_bgdth2:
1572         sound = sfx_bgdth1 + P_Random ()%2;
1573         break;
1574
1575       default:
1576         sound = actor->info->deathsound;
1577         break;
1578     }
1579
1580     // Check for bosses.
1581     if (actor->type==MT_SPIDER
1582         || actor->type == MT_CYBORG)
1583     {
1584         // full volume
1585         S_StartSound (NULL, sound);
1586     }
1587     else
1588         S_StartSound (actor, sound);
1589 }
1590
1591
1592 void A_XScream (mobj_t* actor)
1593 {
1594     S_StartSound (actor, sfx_slop);
1595 }
1596
1597 void A_Pain (mobj_t* actor)
1598 {
1599     if (actor->info->painsound)
1600         S_StartSound (actor, actor->info->painsound);
1601 }
1602
1603
1604
1605 void A_Fall (mobj_t *actor)
1606 {
1607     // actor is on ground, it can be walked over
1608     actor->flags &= ~MF_SOLID;
1609
1610     // So change this if corpse objects
1611     // are meant to be obstacles.
1612 }
1613
1614
1615 //
1616 // A_Explode
1617 //
1618 void A_Explode (mobj_t* thingy)
1619 {
1620     P_RadiusAttack ( thingy, thingy->target, 128 );
1621 }
1622
1623
1624 //
1625 // A_BossDeath
1626 // Possibly trigger special effects
1627 // if on first boss level
1628 //
1629 void A_BossDeath (mobj_t* mo)
1630 {
1631     thinker_t*  th;
1632     mobj_t*     mo2;
1633     line_t      junk;
1634     int         i;
1635
1636     if ( gamemode == commercial)
1637     {
1638         if (gamemap != 7)
1639             return;
1640
1641         if ((mo->type != MT_FATSO)
1642             && (mo->type != MT_BABY))
1643             return;
1644     }
1645     else
1646     {
1647         switch(gameepisode)
1648         {
1649           case 1:
1650             if (gamemap != 8)
1651                 return;
1652
1653             if (mo->type != MT_BRUISER)
1654                 return;
1655             break;
1656
1657           case 2:
1658             if (gamemap != 8)
1659                 return;
1660
1661             if (mo->type != MT_CYBORG)
1662                 return;
1663             break;
1664
1665           case 3:
1666             if (gamemap != 8)
1667                 return;
1668
1669             if (mo->type != MT_SPIDER)
1670                 return;
1671
1672             break;
1673
1674           case 4:
1675             switch(gamemap)
1676             {
1677               case 6:
1678                 if (mo->type != MT_CYBORG)
1679                     return;
1680                 break;
1681
1682               case 8:
1683                 if (mo->type != MT_SPIDER)
1684                     return;
1685                 break;
1686
1687               default:
1688                 return;
1689                 break;
1690             }
1691             break;
1692
1693           default:
1694             if (gamemap != 8)
1695                 return;
1696             break;
1697         }
1698
1699     }
1700
1701
1702     // make sure there is a player alive for victory
1703     for (i=0 ; i<MAXPLAYERS ; i++)
1704         if (playeringame[i] && players[i].health > 0)
1705             break;
1706
1707     if (i==MAXPLAYERS)
1708         return; // no one left alive, so do not end game
1709
1710     // scan the remaining thinkers to see
1711     // if all bosses are dead
1712     for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
1713     {
1714         if (th->function.acp1 != (actionf_p1)P_MobjThinker)
1715             continue;
1716
1717         mo2 = (mobj_t *)th;
1718         if (mo2 != mo
1719             && mo2->type == mo->type
1720             && mo2->health > 0)
1721         {
1722             // other boss not dead
1723             return;
1724         }
1725     }
1726
1727     // victory!
1728     if ( gamemode == commercial)
1729     {
1730         if (gamemap == 7)
1731         {
1732             if (mo->type == MT_FATSO)
1733             {
1734                 junk.tag = 666;
1735                 EV_DoFloor(&junk,lowerFloorToLowest);
1736                 return;
1737             }
1738
1739             if (mo->type == MT_BABY)
1740             {
1741                 junk.tag = 667;
1742                 EV_DoFloor(&junk,raiseToTexture);
1743                 return;
1744             }
1745         }
1746     }
1747     else
1748     {
1749         switch(gameepisode)
1750         {
1751           case 1:
1752             junk.tag = 666;
1753             EV_DoFloor (&junk, lowerFloorToLowest);
1754             return;
1755             break;
1756
1757           case 4:
1758             switch(gamemap)
1759             {
1760               case 6:
1761                 junk.tag = 666;
1762                 EV_DoDoor (&junk, blazeOpen);
1763                 return;
1764                 break;
1765
1766               case 8:
1767                 junk.tag = 666;
1768                 EV_DoFloor (&junk, lowerFloorToLowest);
1769                 return;
1770                 break;
1771             }
1772         }
1773     }
1774
1775     G_ExitLevel ();
1776 }
1777
1778
1779 void A_Hoof (mobj_t* mo)
1780 {
1781     S_StartSound (mo, sfx_hoof);
1782     A_Chase (mo);
1783 }
1784
1785 void A_Metal (mobj_t* mo)
1786 {
1787     S_StartSound (mo, sfx_metal);
1788     A_Chase (mo);
1789 }
1790
1791 void A_BabyMetal (mobj_t* mo)
1792 {
1793     S_StartSound (mo, sfx_bspwlk);
1794     A_Chase (mo);
1795 }
1796
1797 void
1798 A_OpenShotgun2
1799 ( player_t*     player,
1800   pspdef_t*     psp )
1801 {
1802     S_StartSound (player->mo, sfx_dbopn);
1803 }
1804
1805 void
1806 A_LoadShotgun2
1807 ( player_t*     player,
1808   pspdef_t*     psp )
1809 {
1810     S_StartSound (player->mo, sfx_dbload);
1811 }
1812
1813 void
1814 A_ReFire
1815 ( player_t*     player,
1816   pspdef_t*     psp );
1817
1818 void
1819 A_CloseShotgun2
1820 ( player_t*     player,
1821   pspdef_t*     psp )
1822 {
1823     S_StartSound (player->mo, sfx_dbcls);
1824     A_ReFire(player,psp);
1825 }
1826
1827
1828
1829 mobj_t*         braintargets[32];
1830 int             numbraintargets;
1831 int             braintargeton;
1832
1833 void A_BrainAwake (mobj_t* mo)
1834 {
1835     thinker_t*  thinker;
1836     mobj_t*     m;
1837
1838     // find all the target spots
1839     numbraintargets = 0;
1840     braintargeton = 0;
1841
1842     thinker = thinkercap.next;
1843     for (thinker = thinkercap.next ;
1844          thinker != &thinkercap ;
1845          thinker = thinker->next)
1846     {
1847         if (thinker->function.acp1 != (actionf_p1)P_MobjThinker)
1848             continue;   // not a mobj
1849
1850         m = (mobj_t *)thinker;
1851
1852         if (m->type == MT_BOSSTARGET )
1853         {
1854             braintargets[numbraintargets] = m;
1855             numbraintargets++;
1856         }
1857     }
1858
1859     S_StartSound (NULL,sfx_bossit);
1860 }
1861
1862
1863 void A_BrainPain (mobj_t*       mo)
1864 {
1865     S_StartSound (NULL,sfx_bospn);
1866 }
1867
1868
1869 void A_BrainScream (mobj_t*     mo)
1870 {
1871     int         x;
1872     int         y;
1873     int         z;
1874     mobj_t*     th;
1875
1876     for (x=mo->x - 196*FRACUNIT ; x< mo->x + 320*FRACUNIT ; x+= FRACUNIT*8)
1877     {
1878         y = mo->y - 320*FRACUNIT;
1879         z = 128 + P_Random()*2*FRACUNIT;
1880         th = P_SpawnMobj (x,y,z, MT_ROCKET);
1881         th->momz = P_Random()*512;
1882
1883         P_SetMobjState (th, S_BRAINEXPLODE1);
1884
1885         th->tics -= P_Random()&7;
1886         if (th->tics < 1)
1887             th->tics = 1;
1888     }
1889
1890     S_StartSound (NULL,sfx_bosdth);
1891 }
1892
1893
1894
1895 void A_BrainExplode (mobj_t* mo)
1896 {
1897     int         x;
1898     int         y;
1899     int         z;
1900     mobj_t*     th;
1901
1902     x = mo->x + (P_Random () - P_Random ())*2048;
1903     y = mo->y;
1904     z = 128 + P_Random()*2*FRACUNIT;
1905     th = P_SpawnMobj (x,y,z, MT_ROCKET);
1906     th->momz = P_Random()*512;
1907
1908     P_SetMobjState (th, S_BRAINEXPLODE1);
1909
1910     th->tics -= P_Random()&7;
1911     if (th->tics < 1)
1912         th->tics = 1;
1913 }
1914
1915
1916 void A_BrainDie (mobj_t*        mo)
1917 {
1918     G_ExitLevel ();
1919 }
1920
1921 void A_BrainSpit (mobj_t*       mo)
1922 {
1923     mobj_t*     targ;
1924     mobj_t*     newmobj;
1925
1926     static int  easy = 0;
1927
1928     easy ^= 1;
1929     if (gameskill <= sk_easy && (!easy))
1930         return;
1931
1932     // shoot a cube at current target
1933     targ = braintargets[braintargeton];
1934     braintargeton = (braintargeton+1)%numbraintargets;
1935
1936     // spawn brain missile
1937     newmobj = P_SpawnMissile (mo, targ, MT_SPAWNSHOT);
1938     newmobj->target = targ;
1939     newmobj->reactiontime =
1940         ((targ->y - mo->y)/newmobj->momy) / newmobj->state->tics;
1941
1942     S_StartSound(NULL, sfx_bospit);
1943 }
1944
1945
1946
1947 void A_SpawnFly (mobj_t* mo);
1948
1949 // travelling cube sound
1950 void A_SpawnSound (mobj_t* mo)
1951 {
1952     S_StartSound (mo,sfx_boscub);
1953     A_SpawnFly(mo);
1954 }
1955
1956 void A_SpawnFly (mobj_t* mo)
1957 {
1958     mobj_t*     newmobj;
1959     mobj_t*     fog;
1960     mobj_t*     targ;
1961     int         r;
1962     mobjtype_t  type;
1963
1964     if (--mo->reactiontime)
1965         return; // still flying
1966
1967     targ = mo->target;
1968
1969     // First spawn teleport fog.
1970     fog = P_SpawnMobj (targ->x, targ->y, targ->z, MT_SPAWNFIRE);
1971     S_StartSound (fog, sfx_telept);
1972
1973     // Randomly select monster to spawn.
1974     r = P_Random ();
1975
1976     // Probability distribution (kind of :),
1977     // decreasing likelihood.
1978     if ( r<50 )
1979         type = MT_TROOP;
1980     else if (r<90)
1981         type = MT_SERGEANT;
1982     else if (r<120)
1983         type = MT_SHADOWS;
1984     else if (r<130)
1985         type = MT_PAIN;
1986     else if (r<160)
1987         type = MT_HEAD;
1988     else if (r<162)
1989         type = MT_VILE;
1990     else if (r<172)
1991         type = MT_UNDEAD;
1992     else if (r<192)
1993         type = MT_BABY;
1994     else if (r<222)
1995         type = MT_FATSO;
1996     else if (r<246)
1997         type = MT_KNIGHT;
1998     else
1999         type = MT_BRUISER;
2000
2001     newmobj     = P_SpawnMobj (targ->x, targ->y, targ->z, type);
2002     if (P_LookForPlayers (newmobj, true) )
2003         P_SetMobjState (newmobj, newmobj->info->seestate);
2004
2005     // telefrag anything in this spot
2006     P_TeleportMove (newmobj, newmobj->x, newmobj->y);
2007
2008     // remove self (i.e., cube).
2009     P_RemoveMobj (mo);
2010 }
2011
2012
2013
2014 void A_PlayerScream (mobj_t* mo)
2015 {
2016     // Default death sound.
2017     int         sound = sfx_pldeth;
2018
2019     if ( (gamemode == commercial)
2020         &&      (mo->health < -50))
2021     {
2022         // IF THE PLAYER DIES
2023         // LESS THAN -50% WITHOUT GIBBING
2024         sound = sfx_pdiehi;
2025     }
2026
2027     S_StartSound (mo, sound);
2028 }