src/game/g_monsters.pas

   1 (* Copyright (C)  Doom 2D: Forever Developers
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, version 3 of the License ONLY.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  14  *)
  15 {$INCLUDE ../shared/a_modes.inc}
  16 {$M+}
  17 {.$DEFINE D2F_DEBUG_MONS_MOVE}
  18 unit g_monsters;
  19
  20 interface
  21
  22 uses
  23   SysUtils, Classes,
  24   mempool,
  25   MAPDEF,
  26   g_base, g_basic, g_phys, g_textures, g_grid,
  27   g_saveload, g_panel, xprofiler;
  28
  29 const
  30   MONSTATE_SLEEP  = 0;
  31   MONSTATE_GO     = 1;
  32   MONSTATE_RUN    = 2;
  33   MONSTATE_CLIMB  = 3;
  34   MONSTATE_DIE    = 4;
  35   MONSTATE_DEAD   = 5;
  36   MONSTATE_ATTACK = 6;
  37   MONSTATE_SHOOT  = 7;
  38   MONSTATE_PAIN   = 8;
  39   MONSTATE_WAIT   = 9;
  40   MONSTATE_REVIVE = 10;
  41   MONSTATE_RUNOUT = 11;
  42
  43   MON_BURN_TIME   = 100;
  44
  45 { in mapdef now
  46   BH_NORMAL   = 0;
  47   BH_KILLER   = 1;
  48   BH_MANIAC   = 2;
  49   BH_INSANE   = 3;
  50   BH_CANNIBAL = 4;
  51   BH_GOOD     = 5;
  52 }
  53
  54 type
  55   ADirectedAnim = Array of Array [TDirection.D_LEFT..TDirection.D_RIGHT] of TAnimationState;
  56
  57   PMonster = ^TMonster;
  58   TMonster = class{$IFDEF USE_MEMPOOL}(TPoolObject){$ENDIF}
  59   private
  60     FMonsterType: Byte;
  61     FUID: Word;
  62     FDirection: TDirection;
  63     FStartDirection: TDirection;
  64     FStartX, FStartY: Integer;
  65     FRemoved: Boolean;
  66     FHealth: Integer;
  67     FMaxHealth: Integer;
  68     FState: Byte;
  69     FCurAnim: Byte;
  70     FAnim: ADirectedAnim;
  71     FTargetUID: Word;
  72     FTargetTime: Integer;
  73     FBehaviour: Byte;
  74     FAmmo: Integer;
  75     FPain: Integer;
  76     FSleep: Integer;
  77     FPainSound: Boolean;
  78     FPainTicks: Integer;
  79     FWaitAttackAnim: Boolean;
  80     FChainFire: Boolean;
  81     tx, ty: Integer;
  82     FStartID: Integer;
  83     FObj: TObj;
  84     {$IFDEF ENABLE_GFX}
  85       FBloodRed: Byte;
  86       FBloodGreen: Byte;
  87       FBloodBlue: Byte;
  88       FBloodKind: Byte;
  89     {$ENDIF}
  90     {$IFDEF ENABLE_SHELLS}
  91       FShellTimer: Integer;
  92       FShellType: Byte;
  93     {$ENDIF}
  94     FFirePainTime: Integer;
  95     FFireAttacker: Word;
  96     vilefire: TAnimationState;
  97     mProxyId: Integer; // node in dyntree or -1
  98     mArrIdx: Integer; // in gMonsters
  99
 100     FDieTriggers: Array of Integer;
 101     FSpawnTrigger: Integer;
 102
 103     mNeedSend: Boolean; // for network
 104
 105     mEDamageType: Integer;
 106
 107     procedure Turn();
 108     function findNewPrey(): Boolean;
 109     procedure ActivateTriggers();
 110
 111     procedure setGameX (v: Integer); inline;
 112     procedure setGameY (v: Integer); inline;
 113
 114     procedure doDamage (v: Integer);
 115
 116   public
 117     FNoRespawn: Boolean;
 118     FFireTime: Integer;
 119     trapCheckFrameId: DWord; // for `g_weapons.CheckTrap()`
 120     mplatCheckFrameId: LongWord;
 121
 122     constructor Create(MonsterType: Byte; aID: Integer; ForcedUID: Integer = -1);
 123     destructor Destroy(); override;
 124     function Collide(X, Y: Integer; Width, Height: Word): Boolean; overload;
 125     function Collide(Panel: TPanel): Boolean; overload;
 126     function Collide(X, Y: Integer): Boolean; overload;
 127     function TeleportTo(X, Y: Integer; silent: Boolean; dir: Byte): Boolean;
 128     function alive(): Boolean;
 129     procedure SetHealth(aH: Integer);
 130     procedure Push(vx, vy: Integer);
 131     function Damage(aDamage: Word; VelX, VelY: Integer; SpawnerUID: Word; t: Byte): Boolean;
 132     function Heal(Value: Word): Boolean;
 133     procedure BFGHit();
 134     procedure PreUpdate();
 135     procedure Update();
 136     procedure ClientUpdate();
 137     procedure ClientAttack(wx, wy, atx, aty: Integer);
 138     procedure SetDeadAnim;
 139     procedure WakeUp();
 140     procedure WakeUpSound();
 141     procedure DieSound();
 142     procedure PainSound();
 143     procedure ActionSound();
 144     procedure AddTrigger(t: Integer);
 145     procedure ClearTriggers();
 146     procedure Respawn();
 147     procedure SaveState (st: TStream);
 148     procedure LoadState (st: TStream);
 149     procedure SetState(State: Byte; ForceAnim: Byte = 255);
 150     procedure MakeBloodVector(Count: Word; VelX, VelY: Integer);
 151     procedure MakeBloodSimple(Count: Word);
 152     procedure RevertAnim(R: Boolean = True);
 153     function  AnimIsReverse: Boolean;
 154     function  shoot(o: PObj; immediately: Boolean): Boolean;
 155     function  kick(o: PObj): Boolean;
 156     procedure CatchFire(Attacker: Word; Timeout: Integer = MON_BURN_TIME);
 157     procedure OnFireFlame(Times: DWORD = 1);
 158
 159     procedure positionChanged (); //WARNING! call this after monster position was changed, or coldet will not work right!
 160
 161     procedure setPosition (ax, ay: Integer; callPosChanged: Boolean=true); inline;
 162     procedure moveBy (dx, dy: Integer); inline;
 163
 164     procedure getMapBox (out x, y, w, h: Integer); inline;
 165
 166     // get-and-clear
 167     function gncNeedSend (): Boolean; inline;
 168     procedure setDirty (); inline; // why `dirty`? 'cause i may introduce property `needSend` later
 169
 170   public
 171     property Obj: TObj read FObj;
 172
 173     property proxyId: Integer read mProxyId;
 174     property arrIdx: Integer read mArrIdx;
 175
 176     property MonsterType: Byte read FMonsterType;
 177     property MonsterHealth: Integer read FHealth write FHealth;
 178     property MonsterAmmo: Integer read FAmmo write FAmmo;
 179     property MonsterTargetUID: Word read FTargetUID write FTargetUID;
 180     property MonsterTargetTime: Integer read FTargetTime write FTargetTime;
 181     property MonsterBehaviour: Byte read FBehaviour write FBehaviour;
 182     property MonsterSleep: Integer read FSleep write FSleep;
 183     property MonsterState: Byte read FState write FState;
 184     property MonsterRemoved: Boolean read FRemoved write FRemoved;
 185     property MonsterPain: Integer read FPain write FPain;
 186     property MonsterAnim: Byte read FCurAnim write FCurAnim;
 187
 188     property UID: Word read FUID write FUID;
 189     property SpawnTrigger: Integer read FSpawnTrigger write FSpawnTrigger;
 190
 191     property GameX: Integer read FObj.X write setGameX;
 192     property GameY: Integer read FObj.Y write setGameY;
 193     property GameVelX: Integer read FObj.Vel.X write FObj.Vel.X;
 194     property GameVelY: Integer read FObj.Vel.Y write FObj.Vel.Y;
 195     property GameAccelX: Integer read FObj.Accel.X write FObj.Accel.X;
 196     property GameAccelY: Integer read FObj.Accel.Y write FObj.Accel.Y;
 197     property GameDirection: TDirection read FDirection write FDirection;
 198
 199     property StartID: Integer read FStartID;
 200
 201     property VileFireAnim: TAnimationState read vilefire;
 202     property DirAnim: ADirectedAnim read FAnim;
 203
 204   published
 205     property eMonsterType: Byte read FMonsterType;
 206     property eMonsterHealth: Integer read FHealth write FHealth;
 207     property eMonsterAmmo: Integer read FAmmo write FAmmo;
 208     property eMonsterTargetUID: Word read FTargetUID write FTargetUID;
 209     property eMonsterTargetTime: Integer read FTargetTime write FTargetTime;
 210     property eMonsterBehaviour: Byte read FBehaviour write FBehaviour;
 211     property eMonsterSleep: Integer read FSleep write FSleep;
 212     property eMonsterState: Byte read FState write FState;
 213     property eMonsterRemoved: Boolean read FRemoved;
 214     property eMonsterPain: Integer read FPain write FPain;
 215     property eMonsterAnim: Byte read FCurAnim;
 216
 217     property eUID: Word read FUID;
 218     property eSpawnTrigger: Integer read FSpawnTrigger;
 219
 220     property eGameX: Integer read FObj.X write setGameX;
 221     property eGameY: Integer read FObj.Y write setGameY;
 222     property eGameVelX: Integer read FObj.Vel.X write FObj.Vel.X;
 223     property eGameVelY: Integer read FObj.Vel.Y write FObj.Vel.Y;
 224     property eGameAccelX: Integer read FObj.Accel.X write FObj.Accel.X;
 225     property eGameAccelY: Integer read FObj.Accel.Y write FObj.Accel.Y;
 226     property eGameDirection: TDirection read FDirection write FDirection;
 227
 228     property eStartID: Integer read FStartID;
 229
 230     // set this before assigning something to `eDamage`
 231     property eDamageType: Integer read mEDamageType write mEDamageType;
 232     property eDamage: Integer write doDamage;
 233   end;
 234
 235
 236 // will be called from map loader
 237 procedure g_Mons_InitTree (x, y, w, h: Integer);
 238
 239 procedure g_Monsters_LoadData ();
 240 procedure g_Monsters_FreeData ();
 241 procedure g_Monsters_Init ();
 242 procedure g_Monsters_Free (clearGrid: Boolean=true);
 243 function g_Monsters_Create (MonsterType: Byte; X, Y: Integer; Direction: TDirection;
 244   AdjCoord: Boolean = False; ForcedUID: Integer = -1): TMonster;
 245 procedure g_Monsters_PreUpdate ();
 246 procedure g_Monsters_Update ();
 247 function  g_Monsters_ByUID (UID: Word): TMonster;
 248 procedure g_Monsters_killedp ();
 249 procedure g_Monsters_SaveState (st: TStream);
 250 procedure g_Monsters_LoadState (st: TStream);
 251
 252 function g_Mons_SpawnAt (monType: Integer; x, y: Integer; dir: TDirection=TDirection.D_LEFT): TMonster; overload;
 253 function g_Mons_SpawnAt (const typeName: AnsiString; x, y: Integer; dir: TDirection=TDirection.D_LEFT): TMonster; overload;
 254
 255 function g_Mons_TypeLo (): Integer; inline;
 256 function g_Mons_TypeHi (): Integer; inline;
 257
 258 function g_Mons_TypeIdByName (const name: AnsiString): Integer;
 259 function g_Mons_NameByTypeId (monType: Integer): AnsiString;
 260 function g_Mons_GetKilledByTypeId (monType: Integer): AnsiString;
 261
 262
 263 type
 264   TEachMonsterCB = function (mon: TMonster): Boolean is nested; // return `true` to stop
 265
 266 // throws on invalid uid
 267 function g_Mons_ByIdx (uid: Integer): TMonster; inline;
 268
 269 // can return null
 270 function g_Mons_ByIdx_NC (uid: Integer): TMonster; inline;
 271
 272 function g_Mons_TotalCount (): Integer; inline;
 273
 274 function g_Mons_IsAnyAliveAt (x, y: Integer; width, height: Integer): Boolean;
 275
 276 function g_Mons_ForEach (cb: TEachMonsterCB): Boolean;
 277 function g_Mons_ForEachAlive (cb: TEachMonsterCB): Boolean;
 278
 279 function g_Mons_ForEachAt (x, y: Integer; width, height: Integer; cb: TEachMonsterCB): Boolean;
 280 function g_Mons_ForEachAliveAt (x, y: Integer; width, height: Integer; cb: TEachMonsterCB): Boolean;
 281
 282 function g_Mons_getNewTrapFrameId (): DWord; inline;
 283 function g_Mons_getNewMPlatFrameId (): LongWord; inline;
 284
 285
 286 {
 287 type
 288   TMonsAlongLineCB = function (mon: TMonster; tag: Integer): Boolean is nested;
 289
 290 function g_Mons_AlongLine (x0, y0, x1, y1: Integer; cb: TMonsAlongLineCB; log: Boolean=false): TMonster;
 291 }
 292
 293
 294 var
 295   gmon_debug_use_sqaccel: Boolean = true;
 296
 297
 298 //HACK!
 299 procedure g_Mons_ProfilersBegin ();
 300 procedure g_Mons_ProfilersEnd ();
 301
 302 procedure g_Mons_LOS_Start (); inline;
 303 procedure g_Mons_LOS_End (); inline;
 304
 305 var
 306   profMonsLOS: TProfiler = nil; //WARNING: FOR DEBUGGING ONLY!
 307
 308
 309 type
 310   TMonsterGrid = specialize TBodyGridBase<TMonster>;
 311
 312 var
 313   monsGrid: TMonsterGrid = nil; // DO NOT USE! public for debugging only!
 314
 315
 316 var
 317   gmon_debug_think: Boolean = true;
 318   gmon_debug_one_think_step: Boolean = false;
 319
 320   var (* private state *)
 321     gMonsters: array of TMonster;
 322
 323   const
 324     ANIM_SLEEP   = 0;
 325     ANIM_GO      = 1;
 326     ANIM_DIE     = 2;
 327     ANIM_MESS    = 3;
 328     ANIM_ATTACK  = 4;
 329     ANIM_ATTACK2 = 5;
 330     ANIM_PAIN    = 6;
 331
 332 // Таблица характеристик монстров:
 333   MONSTERTABLE: Array [MONSTER_DEMON..MONSTER_MAN] of
 334                   record
 335                     Name: String;
 336                     Rect: TRectWH;
 337                     Health: Word;
 338                     RunVel: Byte;
 339                     MinPain: Byte;
 340                     Pain: Byte;
 341                     Jump: Byte;
 342                   end =
 343    ((Name:'DEMON'; Rect:(X:7; Y:8; Width:50; Height:52); Health:60;
 344      RunVel: 7; MinPain: 10; Pain: 20; Jump: 10),
 345
 346     (Name:'IMP'; Rect:(X:15; Y:10; Width:34; Height:50); Health:25;
 347      RunVel: 3; MinPain: 0; Pain: 15; Jump: 10),
 348
 349     (Name:'ZOMBY'; Rect:(X:15; Y:8; Width:34; Height:52); Health:15;
 350      RunVel: 3; MinPain: 0; Pain: 10; Jump: 10),
 351
 352     (Name:'SERG'; Rect:(X:15; Y:8; Width:34; Height:52); Health:20;
 353      RunVel: 3; MinPain: 0; Pain: 10; Jump: 10),
 354
 355     (Name:'CYBER'; Rect:(X:24; Y:9; Width:80; Height:110); Health:500;
 356      RunVel: 5; MinPain: 50; Pain: 70; Jump: 10),
 357
 358     (Name:'CGUN'; Rect:(X:15; Y:4; Width:34; Height:56); Health:60;
 359      RunVel: 3; MinPain: 10; Pain: 20; Jump: 10),
 360
 361     (Name:'BARON'; Rect:(X:39; Y:32; Width:50; Height:64); Health:150;
 362      RunVel: 3; MinPain: 30; Pain: 40; Jump: 10),
 363
 364     (Name:'KNIGHT'; Rect:(X:39; Y:32; Width:50; Height:64); Health:75;
 365      RunVel: 3; MinPain: 30; Pain: 40; Jump: 10),
 366
 367     (Name:'CACO'; Rect:(X:34; Y:36; Width:60; Height:56); Health:100;
 368      RunVel: 4; MinPain: 0; Pain: 10; Jump: 4),
 369
 370     (Name:'SOUL'; Rect:(X:16; Y:14; Width:32; Height:36); Health:60;
 371      RunVel: 4; MinPain: 0; Pain: 10; Jump: 4),
 372
 373     (Name:'PAIN'; Rect:(X:34; Y:36; Width:60; Height:56); Health:100;
 374      RunVel: 4; MinPain: 0; Pain: 10; Jump: 4),
 375
 376     (Name:'SPIDER'; Rect:(X:23; Y:14; Width:210; Height:100); Health:500;
 377      RunVel: 4; MinPain: 50; Pain: 70; Jump: 10),
 378
 379     (Name:'BSP'; Rect:(X:14; Y:17; Width:100; Height:42); Health:150;
 380      RunVel: 4; MinPain: 0; Pain: 20; Jump: 10),
 381
 382     (Name:'MANCUB'; Rect:(X:28; Y:34; Width:72; Height:60); Health:200;
 383      RunVel: 3; MinPain: 20; Pain: 40; Jump: 7),
 384
 385     (Name:'SKEL'; Rect:(X:30; Y:28; Width:68; Height:72); Health:200;
 386      RunVel: 6; MinPain: 20; Pain: 40; Jump: 11),
 387
 388     (Name:'VILE'; Rect:(X:30; Y:28; Width:68; Height:72); Health:150;
 389      RunVel: 7; MinPain: 10; Pain: 30; Jump: 12),
 390
 391     (Name:'FISH'; Rect:(X:6; Y:11; Width:20; Height:10); Health:35;
 392      RunVel: 14; MinPain: 10; Pain: 20; Jump: 6),
 393
 394     (Name:'BARREL'; Rect:(X:20; Y:13; Width:24; Height:36); Health:20;
 395      RunVel: 0; MinPain: 0; Pain: 0; Jump: 0),
 396
 397     (Name:'ROBO'; Rect:(X:30; Y:26; Width:68; Height:76); Health:20;
 398      RunVel: 3; MinPain: 20; Pain: 40; Jump: 6),
 399
 400     (Name:'MAN'; Rect:(X:15; Y:6; Width:34; Height:52); Health:400;
 401      RunVel: 8; MinPain: 50; Pain: 70; Jump: 10));
 402
 403 // Таблица параметров анимации монстров:
 404   MONSTER_ANIMTABLE: Array [MONSTER_DEMON..MONSTER_MAN] of
 405      record
 406        LeftAnim: Boolean;
 407        wX, wY: Integer; // Откуда вылетит пуля
 408        AnimSpeed: Array [ANIM_SLEEP..ANIM_PAIN] of Byte;
 409        AnimCount: Array [ANIM_SLEEP..ANIM_PAIN] of Byte;
 410        AnimDeltaRight: Array [ANIM_SLEEP..ANIM_PAIN] of TDFPoint;
 411        AnimDeltaLeft: Array [ANIM_SLEEP..ANIM_PAIN] of TDFPoint;
 412      end =          // SLEEP           GO              DIE             MESS            ATTACK          ATTACK2         PAIN
 413    ((LeftAnim: False; wX: 54; wY: 32; AnimSpeed:(3, 2, 3, 2, 3, 0, 4); //DEMON
 414      AnimCount: (2, 4, 6, 6, 3, 0, 1);
 415      AnimDeltaRight: ((X:  1; Y:  4), (X:  1; Y:  4), (X:  0; Y:  4), (X:  0; Y:  4), (X:  2; Y:  6), (X:  2; Y:  6), (X:  2; Y:  5));
 416      AnimDeltaLeft:  ((X:  1; Y:  4), (X:  1; Y:  4), (X:  0; Y:  4), (X:  0; Y:  4), (X:  2; Y:  6), (X:  2; Y:  6), (X:  2; Y:  5))),
 417
 418     (LeftAnim: False; wX: 32; wY: 32; AnimSpeed:(3, 2, 3, 2, 3, 0, 4); //IMP
 419      AnimCount: (2, 4, 5, 8, 3, 0, 1);
 420      AnimDeltaRight: ((X:  8; Y: -4), (X:  8; Y: -4), (X: -2; Y: -1), (X:  3; Y: -2), (X: 14; Y: -4), (X: 14; Y: -4), (X: -5; Y: -4));
 421      AnimDeltaLeft:  ((X:  8; Y: -4), (X:  8; Y: -4), (X: -2; Y: -1), (X:  3; Y: -2), (X: 14; Y: -4), (X: 14; Y: -4), (X: -5; Y: -4))),
 422
 423     (LeftAnim: True; wX: 32; wY: 32; AnimSpeed:(3, 2, 3, 2, 3, 0, 4); //ZOMBY
 424      AnimCount: (2, 4, 6, 9, 2, 0, 1);
 425      AnimDeltaRight: ((X:  1; Y: -4), (X:  1; Y: -4), (X:  3; Y: -1), (X:  2; Y: -1), (X:  2; Y: -4), (X:  2; Y: -4), (X:  1; Y: -4));
 426      AnimDeltaLeft:  ((X:  1; Y: -4), (X:  1; Y: -4), (X:  3; Y: -1), (X:  2; Y: -1), (X:  2; Y: -4), (X:  2; Y: -4), (X:  1; Y: -4))),
 427
 428     (LeftAnim: True; wX: 32; wY: 32; AnimSpeed:(3, 2, 3, 2, 3, 0, 4); //SERG
 429      AnimCount: (2, 4, 5, 9, 2, 0, 1);
 430      AnimDeltaRight: ((X:  0; Y: -4), (X:  0; Y: -4), (X: -3; Y: -1), (X: -4; Y: -1), (X:  1; Y: -4), (X:  1; Y: -4), (X:  0; Y: -4));
 431      AnimDeltaLeft:  ((X:  0; Y: -4), (X:  0; Y: -4), (X: -3; Y: -1), (X: -4; Y: -1), (X:  1; Y: -4), (X:  1; Y: -4), (X:  0; Y: -4))),
 432
 433     (LeftAnim: True; wX: 70; wY: 73; AnimSpeed:(3, 3, 3, 3, 3, 4, 3);  //CYBER
 434      AnimCount: (2, 4, 9, 9, 2, 2, 1);
 435      AnimDeltaRight: ((X:  2; Y: -6), (X:  2; Y: -6), (X: -3; Y: -4), (X: -3; Y: -4), (X: 25; Y: -6), (X: 0; Y: -6), (X: -2; Y: -6));
 436      AnimDeltaLeft:  ((X:  3; Y: -3), (X:  3; Y: -3), (X: -3; Y: -4), (X: -3; Y: -4), (X:-26; Y: -3), (X:-1; Y: -3), (X:  1; Y: -3))),
 437
 438     (LeftAnim: True; wX: 32; wY: 32; AnimSpeed:(3, 2, 2, 2, 1, 0, 4);  //CGUN
 439      AnimCount: (2, 4, 7, 6, 2, 0, 1);
 440      AnimDeltaRight: ((X: -1; Y: -2), (X: -1; Y: -2), (X: -2; Y:  0), (X: -2; Y:  0), (X:  0; Y: -3), (X:  0; Y: -3), (X: -1; Y: -2));
 441      AnimDeltaLeft:  ((X: -1; Y: -2), (X: -1; Y: -2), (X: -2; Y:  0), (X: -2; Y:  0), (X: -1; Y: -4), (X: -1; Y: -4), (X:  2; Y: -4))),
 442
 443     (LeftAnim: True; wX: 64; wY: 64; AnimSpeed:(3, 2, 3, 4, 2, 0, 4);  //BARON
 444      AnimCount: (2, 4, 7, 7, 3, 0, 1);
 445      AnimDeltaRight: ((X:  4; Y:  0), (X:  2; Y:  0), (X: -1; Y: -1), (X: -1; Y: -1), (X:  1; Y:  0), (X:  1; Y:  0), (X: -1; Y:  0));
 446      AnimDeltaLeft:  ((X:  0; Y:  0), (X:  2; Y:  0), (X: -1; Y: -1), (X: -1; Y: -1), (X: -2; Y:  0), (X: -2; Y:  0), (X:  1; Y:  0))),
 447
 448     (LeftAnim: True; wX: 64; wY: 64; AnimSpeed:(3, 2, 3, 4, 2, 0, 4);  //KNIGHT
 449      AnimCount: (2, 4, 7, 7, 3, 0, 1);
 450      AnimDeltaRight: ((X:  4; Y:  0), (X:  2; Y:  0), (X: -1; Y: -1), (X: -1; Y: -1), (X:  1; Y:  0), (X:  1; Y:  0), (X: -1; Y:  0));
 451      AnimDeltaLeft:  ((X:  0; Y:  0), (X:  2; Y:  0), (X: -1; Y: -1), (X: -1; Y: -1), (X: -2; Y:  0), (X: -2; Y:  0), (X:  1; Y:  0))),
 452
 453     (LeftAnim: False; wX: 88; wY: 69; AnimSpeed:(3, 2, 3, 4, 2, 0, 4); //CACO
 454      AnimCount: (1, 1, 7, 7, 6, 0, 1);
 455      AnimDeltaRight: ((X:  0; Y: -4), (X:  0; Y: -4), (X:  0; Y: -5), (X:  0; Y: -5), (X:  0; Y: -4), (X:  0; Y: -4), (X:  0; Y: -4));
 456      AnimDeltaLeft:  ((X:  0; Y: -4), (X:  0; Y: -4), (X:  0; Y: -5), (X:  0; Y: -5), (X:  0; Y: -4), (X:  0; Y: -4), (X:  0; Y: -4))),
 457
 458     (LeftAnim: False; wX: 32; wY: 32; AnimSpeed:(3, 2, 3, 4, 1, 0, 4); //SOUL
 459      AnimCount: (2, 2, 7, 7, 2, 0, 1); // 10
 460      AnimDeltaRight: ((X:  1; Y:-10), (X:  1; Y:-10), (X:-33; Y:-34), (X:-33; Y:-34), (X:-16; Y:-10), (X:-16; Y:-10), (X: -1; Y: -7));
 461      AnimDeltaLeft:  ((X:  1; Y:-10), (X:  1; Y:-10), (X:-33; Y:-34), (X:-33; Y:-34), (X:-16; Y:-10), (X:-16; Y:-10), (X: -1; Y: -7))),
 462
 463     (LeftAnim: False; wX: 64; wY: 64; AnimSpeed:(3, 2, 3, 4, 2, 0, 4); //PAIN
 464      AnimCount: (4, 4, 7, 7, 4, 0, 1);
 465      AnimDeltaRight: ((X: -1; Y: -3), (X: -1; Y: -3), (X: -3; Y:  0), (X: -3; Y:  0), (X: -1; Y: -3), (X: -1; Y: -3), (X: -1; Y: -4));
 466      AnimDeltaLeft:  ((X: -1; Y: -3), (X: -1; Y: -3), (X: -3; Y:  0), (X: -3; Y:  0), (X: -1; Y: -3), (X: -1; Y: -3), (X: -1; Y: -4))),
 467
 468     (LeftAnim: True; wX: 128; wY: 64; AnimSpeed:(3, 2, 4, 4, 1, 0, 4); //SPIDER
 469      AnimCount: (2, 6, 10, 10, 2, 0, 1);
 470      AnimDeltaRight: ((X: -4; Y: -4), (X: -4; Y: -4), (X: -2; Y:  8), (X: -2; Y:  8), (X: -3; Y: -3), (X: -3; Y: -3), (X: -3; Y: -4));
 471      AnimDeltaLeft:  ((X: -4; Y: -4), (X: -4; Y: -4), (X: -2; Y:  8), (X: -2; Y:  8), (X: -3; Y: -3), (X: -3; Y: -3), (X: 18; Y: -5))),
 472
 473     (LeftAnim: True; wX: 64; wY: 32; AnimSpeed:(3, 2, 3, 4, 1, 0, 4);  //BSP
 474      AnimCount: (2, 6, 7, 7, 2, 0, 1);
 475      AnimDeltaRight: ((X:  0; Y: -1), (X:  0; Y: -1), (X: -3; Y:  5), (X: -3; Y:  5), (X:  7; Y: -1), (X:  7; Y: -1), (X:  1; Y: -3));
 476      AnimDeltaLeft:  ((X:  0; Y: -1), (X:  0; Y: -1), (X: -3; Y:  5), (X: -3; Y:  5), (X:  7; Y: -1), (X:  7; Y: -1), (X:  6; Y: -3))),
 477
 478     (LeftAnim: False; wX: 64; wY: 64; AnimSpeed:(3, 2, 2, 4, 2, 0, 4); //MANCUB
 479      AnimCount: (2, 6, 10, 10, 3, 0, 1);
 480      AnimDeltaRight: ((X: -2; Y: -7), (X: -2; Y: -7), (X: -4; Y: -2), (X: -4; Y: -2), (X: -4; Y: -7), (X: -4; Y: -7), (X:-14; Y: -7));
 481      AnimDeltaLeft:  ((X: -2; Y: -7), (X: -2; Y: -7), (X: -4; Y: -2), (X: -4; Y: -2), (X: -4; Y: -7), (X: -4; Y: -7), (X:-14; Y: -7))),
 482
 483     (LeftAnim: True; wX: 64; wY: 32; AnimSpeed:(3, 3, 3, 3, 3, 3, 3);  //SKEL
 484      AnimCount: (2, 6, 5, 5, 2, 2, 1);
 485      AnimDeltaRight: ((X: -1; Y:  4), (X: -1; Y:  4), (X: -2; Y:  4), (X: -2; Y:  4), (X: -1; Y:  4), (X:  6; Y:  2), (X:-24; Y:  4));
 486      AnimDeltaLeft:  ((X:  1; Y:  4), (X: -1; Y:  4), (X: -2; Y:  4), (X: -2; Y:  4), (X: -2; Y:  2), (X: -5; Y:  4), (X: 26; Y:  4))),
 487
 488     (LeftAnim: True; wX: 64; wY: 32; AnimSpeed:(3, 3, 3, 3, 3, 3, 3);  //VILE
 489      AnimCount: (2, 6, 9, 9, 10, 3, 1);
 490      AnimDeltaRight: ((X:  5; Y:-21), (X:  5; Y:-21), (X:  1; Y:-21), (X:  1; Y:-21), (X:  8; Y:-23), (X: -1; Y:-23), (X:  4; Y:-20));
 491      AnimDeltaLeft:  ((X: -8; Y:-21), (X:  5; Y:-21), (X:  1; Y:-21), (X:  1; Y:-21), (X:-10; Y:-24), (X:  3; Y:-23), (X: -4; Y:-22))),
 492
 493     (LeftAnim: False; wX: 8; wY: 8; AnimSpeed:(2, 2, 2, 2, 3, 0, 1);   //FISH
 494      AnimCount: (2, 4, 1, 1, 2, 0, 3);
 495      AnimDeltaRight: ((X: -1; Y:  0), (X: -1; Y:  0), (X: -2; Y: -1), (X: -2; Y: -1), (X: -1; Y: -1), (X: -1; Y: -1), (X: -1; Y: -1));
 496      AnimDeltaLeft:  ((X: -1; Y:  0), (X: -1; Y:  0), (X: -2; Y: -1), (X: -2; Y: -1), (X: -1; Y: -1), (X: -1; Y: -1), (X: -1; Y: -1 ))),
 497
 498     (LeftAnim: False; wX: 32; wY: 32; AnimSpeed:(3, 0, 3, 0, 0, 0, 5); //BARREL
 499      AnimCount: (3, 0, 4, 0, 0, 0, 1);
 500      AnimDeltaRight: ((X:  0; Y:-15), (X:  0; Y:-15), (X: -1; Y:-15), (X: -1; Y:-15), (X:  0; Y:-15), (X:  0; Y:-15), (X:  0; Y:-15));
 501      AnimDeltaLeft:  ((X:  0; Y:-15), (X:  0; Y:-15), (X: -1; Y:-15), (X: -1; Y:-15), (X:  0; Y:-15), (X:  0; Y:-15), (X:  0; Y:-15))),
 502
 503     (LeftAnim: False; wX: 95; wY: 57; AnimSpeed:(1, 2, 1, 0, 1, 1, 0); //ROBO
 504      AnimCount: (1, 12, 1, 0, 2, 4, 0);
 505      AnimDeltaRight: ((X: -2; Y:-26), (X: -2; Y:-26), (X:  0; Y:-26), (X:  0; Y:-26), (X:  2; Y:-26), (X: 15; Y:-26), (X: -2; Y:-26));
 506      AnimDeltaLeft:  ((X: -2; Y:-26), (X: -2; Y:-26), (X:  0; Y:-26), (X:  0; Y:-26), (X:  2; Y:-26), (X: 15; Y:-26), (X: -2; Y:-26))),
 507
 508     (LeftAnim: False; wX: 32; wY: 32; AnimSpeed:(3, 2, 2, 2, 2, 0, 5); //MAN
 509      AnimCount: (2, 4, 7, 9, 2, 0, 1);
 510      AnimDeltaRight: ((X:  0; Y: -6), (X:  0; Y: -6), (X: -2; Y:  0), (X:  2; Y:  0), (X:  1; Y: -6), (X:  1; Y: -6), (X:  0; Y: -6));
 511      AnimDeltaLeft:  ((X:  0; Y: -6), (X:  0; Y: -6), (X: -2; Y:  0), (X:  2; Y:  0), (X:  1; Y: -6), (X:  1; Y: -6), (X:  0; Y: -6))) );
 512
 513 // Таблица типов анимации монстров:
 514   ANIMTABLE: Array [ANIM_SLEEP..ANIM_PAIN] of
 515                record
 516                  name: String;
 517                  loop: Boolean;
 518                end = ((name: 'SLEEP'; loop: True),
 519                       (name: 'GO'; loop: True),
 520                       (name: 'DIE'; loop: False),
 521                       (name: 'MESS'; loop: False),
 522                       (name: 'ATTACK'; loop: False),
 523                       (name: 'ATTACK2'; loop: False),
 524                       (name: 'PAIN'; loop: False));
 525 implementation
 526
 527 uses
 528   {$IFDEF ENABLE_MENU}
 529     g_menu,
 530   {$ENDIF}
 531   {$IFDEF ENABLE_GFX}
 532     g_gfx,
 533   {$ENDIF}
 534   {$IFDEF ENABLE_GIBS}
 535     g_gibs,
 536   {$ENDIF}
 537   {$IFDEF ENABLE_SHELLS}
 538     g_shells,
 539   {$ENDIF}
 540   e_log, g_sound, g_player, g_game,
 541   g_weapons, g_triggers, g_items, g_options,
 542   g_console, g_map, Math, wadreader,
 543   g_language, g_netmsg, idpool, utils, xstreams;
 544
 545
 546 function g_Look(a, b: PObj; d: TDirection): Boolean;
 547 begin
 548   if not gmon_dbg_los_enabled then begin result := false; exit; end; // always "wall hit"
 549
 550   if ((b^.X > a^.X) and (d = TDirection.D_LEFT)) or
 551      ((b^.X < a^.X) and (d = TDirection.D_RIGHT)) then
 552   begin
 553     Result := False;
 554     Exit;
 555   end;
 556
 557   Result := g_TraceVector(a^.X+a^.Rect.X+(a^.Rect.Width div 2),
 558                           a^.Y+a^.Rect.Y+(a^.Rect.Height div 2),
 559                           b^.X+b^.Rect.X+(b^.Rect.Width div 2),
 560                           b^.Y+b^.Rect.Y+(b^.Rect.Height div 2));
 561 end;
 562
 563 // ////////////////////////////////////////////////////////////////////////// //
 564 procedure g_Mons_ProfilersBegin ();
 565 begin
 566   if (profMonsLOS = nil) then profMonsLOS := TProfiler.Create('LOS CALC', g_profile_history_size);
 567   if (profMonsLOS <> nil) then profMonsLOS.mainBegin(g_profile_los);
 568   if g_profile_los and (profMonsLOS <> nil) then
 569   begin
 570     profMonsLOS.sectionBegin('loscalc');
 571     profMonsLOS.sectionEnd();
 572   end;
 573 end;
 574
 575 procedure g_Mons_ProfilersEnd ();
 576 begin
 577   if (profMonsLOS <> nil) and (g_profile_los) then profMonsLOS.mainEnd();
 578 end;
 579
 580 procedure g_Mons_LOS_Start (); inline;
 581 begin
 582   if (profMonsLOS <> nil) then profMonsLOS.sectionBeginAccum('loscalc');
 583 end;
 584
 585 procedure g_Mons_LOS_End (); inline;
 586 begin
 587   if (profMonsLOS <> nil) then profMonsLOS.sectionEnd();
 588 end;
 589
 590
 591 // ////////////////////////////////////////////////////////////////////////// //
 592 var
 593   monCheckTrapLastFrameId: DWord = 0;
 594   monCheckMPlatLastFrameId: LongWord = 0;
 595
 596
 597 procedure TMonster.getMapBox (out x, y, w, h: Integer); inline;
 598 begin
 599   x := FObj.X+FObj.Rect.X;
 600   y := FObj.Y+FObj.Rect.Y;
 601   w := FObj.Rect.Width;
 602   h := FObj.Rect.Height;
 603 end;
 604
 605 function TMonster.gncNeedSend (): Boolean; inline; begin result := mNeedSend; mNeedSend := false; end;
 606
 607 procedure TMonster.setDirty (); inline; begin mNeedSend := true; end;
 608
 609
 610 // ////////////////////////////////////////////////////////////////////////// //
 611 {
 612 function g_Mons_AlongLine (x0, y0, x1, y1: Integer; cb: TMonsAlongLineCB; log: Boolean=false): TMonster;
 613 begin
 614   if not assigned(cb) then begin result := nil; exit; end;
 615   result := monsGrid.forEachAlongLine(x0, y0, x1, y1, cb, -1, log);
 616 end;
 617 }
 618
 619
 620 //WARNING! call this after monster position was changed, or coldet will not work right!
 621 procedure TMonster.positionChanged ();
 622 var
 623   x, y, w, h: Integer;
 624   nx, ny, nw, nh: Integer;
 625 begin
 626   {$IF DEFINED(D2F_DEBUG_MONS_MOVE)}
 627   //e_WriteLog(Format('monster #%d(%u): pos=(%d,%d); rpos=(%d,%d)', [mArrIdx, UID, FObj.X, FObj.Y, FObj.Rect.X, FObj.Rect.Y]), MSG_NOTIFY);
 628   {$ENDIF}
 629   if (mProxyId = -1) then
 630   begin
 631     //mNeedSend := true;
 632     mProxyId := monsGrid.insertBody(self, FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y, FObj.Rect.Width, FObj.Rect.Height);
 633     {$IF DEFINED(D2F_DEBUG_MONS_MOVE)}
 634     monsGrid.getBodyXY(mProxyId, x, y);
 635     e_WriteLog(Format('monster #%d:(%u): inserted into the grid; mProxyid=%d; gx=%d; gy=%d', [mArrIdx, UID, mProxyId, x-monsGrid.gridX0, y-monsGrid.gridY0]), MSG_NOTIFY);
 636     {$ENDIF}
 637   end
 638   else
 639   begin
 640     monsGrid.getBodyDims(mProxyId, x, y, w, h);
 641     getMapBox(nx, ny, nw, nh);
 642
 643     if (w <> nw) or (h <> nh) then
 644     begin
 645       //mNeedSend := true;
 646       {$IF DEFINED(D2F_DEBUG_MONS_MOVE)}
 647       e_WriteLog(Format('monster #%d:(%u): resized; mProxyid=%d; gx=%d; gy=%d', [mArrIdx, UID, mProxyId, x-monsGrid.gridX0, y-monsGrid.gridY0]), MSG_NOTIFY);
 648       {$ENDIF}
 649       monsGrid.moveResizeBody(mProxyId, nx, ny, nw, nh);
 650     end
 651     else if (x <> nx) or (y <> ny) then
 652     begin
 653       //mNeedSend := true;
 654       {$IF DEFINED(D2F_DEBUG_MONS_MOVE)}
 655       e_WriteLog(Format('monster #%d:(%u): updating grid; mProxyid=%d; gx=%d; gy=%d', [mArrIdx, UID, mProxyId, x-monsGrid.gridX0, y-monsGrid.gridY0]), MSG_NOTIFY);
 656       {$ENDIF}
 657       monsGrid.moveBody(mProxyId, nx, ny);
 658     end
 659     else
 660     begin
 661       exit; // nothing to do
 662     end;
 663     {$IF DEFINED(D2F_DEBUG_MONS_MOVE)}
 664     monsGrid.getBodyXY(mProxyId, x, y);
 665     e_WriteLog(Format('monster #%d:(%u): updated grid; mProxyid=%d; gx=%d; gy=%d', [mArrIdx, UID, mProxyId, x-monsGrid.gridX0, y-monsGrid.gridY0]), MSG_NOTIFY);
 666     {$ENDIF}
 667   end;
 668 end;
 669
 670
 671 // ////////////////////////////////////////////////////////////////////////// //
 672 const
 673   MONSTER_SIGNATURE = $534E4F4D; // 'MONS'
 674
 675   MAX_ATM = 89; // Время ожидания после потери цели
 676   MAX_SOUL = 512; // Ограничение Lost_Soul'ов
 677
 678
 679 // ////////////////////////////////////////////////////////////////////////// //
 680 var
 681   uidMap: array [0..65535] of TMonster; // monster knows it's index
 682   freeInds: TIdPool = nil;
 683
 684
 685 procedure clearUidMap ();
 686 var
 687   idx: Integer;
 688 begin
 689   for idx := 0 to High(uidMap) do uidMap[idx] := nil;
 690   freeInds.clear();
 691 end;
 692
 693
 694 function g_Mons_getNewTrapFrameId (): DWord; inline;
 695 var
 696   f: Integer;
 697 begin
 698   Inc(monCheckTrapLastFrameId);
 699   if (monCheckTrapLastFrameId = 0) then
 700   begin
 701     // wraparound
 702     monCheckTrapLastFrameId := 1;
 703     for f := 0 to High(gMonsters) do
 704     begin
 705       if (gMonsters[f] <> nil) then gMonsters[f].trapCheckFrameId := 0;
 706     end;
 707   end;
 708   result := monCheckTrapLastFrameId;
 709 end;
 710
 711
 712 function g_Mons_getNewMPlatFrameId (): LongWord; inline;
 713 var
 714   f: Integer;
 715 begin
 716   Inc(monCheckMPlatLastFrameId);
 717   if (monCheckMPlatLastFrameId = 0) then
 718   begin
 719     // wraparound
 720     monCheckMPlatLastFrameId := 1;
 721     for f := 0 to High(gMonsters) do
 722     begin
 723       if (gMonsters[f] <> nil) then gMonsters[f].mplatCheckFrameId := 0;
 724     end;
 725   end;
 726   result := monCheckMPlatLastFrameId;
 727 end;
 728
 729
 730 var
 731   pt_x: Integer = 0;
 732   pt_xs: Integer = 1;
 733   pt_y: Integer = 0;
 734   pt_ys: Integer = 1;
 735   soulcount: Integer = 0;
 736
 737
 738 function allocMonster (): DWORD;
 739 var
 740   f, olen: Integer;
 741 begin
 742   result := freeInds.alloc();
 743   if (result > High(gMonsters)) then
 744   begin
 745     olen := Length(gMonsters);
 746     SetLength(gMonsters, result+64);
 747     for f := olen to High(gMonsters) do gMonsters[f] := nil;
 748   end;
 749 end;
 750
 751
 752 function IsFriend(a, b: Byte): Boolean;
 753 begin
 754   Result := True;
 755
 756 // Бочка - всем друг:
 757   if (a = MONSTER_BARREL) or (b = MONSTER_BARREL) then
 758     Exit;
 759
 760 // Монстры одного вида:
 761   if a = b then
 762     case a of
 763       MONSTER_IMP, MONSTER_DEMON, MONSTER_BARON, MONSTER_KNIGHT, MONSTER_CACO,
 764       MONSTER_SOUL, MONSTER_PAIN, MONSTER_MANCUB, MONSTER_SKEL, MONSTER_FISH:
 765         Exit; // Эти не бьют своих
 766     end;
 767
 768 // Lost_Soul не может ранить Pain_Elemental'а:
 769   if (a = MONSTER_SOUL) and (b = MONSTER_PAIN) then
 770     Exit;
 771 // Pain_Elemental не может ранить Lost_Soul'а:
 772   if (b = MONSTER_SOUL) and (a = MONSTER_PAIN) then
 773     Exit;
 774
 775 // В остальных случаях - будут бить друг друга:
 776   Result := False;
 777 end;
 778
 779
 780 function BehaviourDamage(SpawnerUID: Word; BH, SelfType: Byte): Boolean;
 781 var
 782   m: TMonster;
 783   UIDType, MonsterType: Byte;
 784 begin
 785   Result := False;
 786   MonsterType := 0;
 787
 788   UIDType := g_GetUIDType(SpawnerUID);
 789   if UIDType = UID_MONSTER then
 790   begin
 791     m := g_Monsters_ByUID(SpawnerUID);
 792     if m = nil then Exit;
 793     MonsterType := m.FMonsterType;
 794   end;
 795
 796   case BH of
 797     BH_NORMAL: Result := (UIDType = UID_PLAYER) or
 798       ((UIDType = UID_MONSTER) and (not IsFriend(MonsterType, SelfType)));
 799
 800     BH_KILLER: Result := UIDType = UID_PLAYER;
 801     BH_MANIAC: Result := (UIDType = UID_PLAYER) or
 802       ((UIDType = UID_MONSTER) and (not IsFriend(MonsterType, SelfType)));
 803
 804     BH_INSANE: Result := (UIDType = UID_MONSTER) and (not IsFriend(MonsterType, SelfType));
 805     BH_CANNIBAL: Result := (UIDType = UID_MONSTER) and (MonsterType = SelfType);
 806   end;
 807 end;
 808
 809
 810 function canShoot(m: Byte): Boolean;
 811 begin
 812   Result := False;
 813
 814   case m of
 815     MONSTER_DEMON, MONSTER_FISH, MONSTER_BARREL:
 816       Exit;
 817     else
 818       Result := True;
 819   end;
 820 end;
 821
 822
 823 function isCorpse (o: PObj; immediately: Boolean): Integer;
 824
 825   (*
 826   function monsCollCheck (mon: TMonster; atag: Integer): Boolean;
 827   begin
 828     atag := atag; // shut up, fpc!
 829     result := false; // don't stop
 830     if (mon.FState = MONSTATE_DEAD) and g_Obj_Collide(o, @mon.FObj) then
 831     begin
 832       case mon.FMonsterType of // Не воскресить:
 833         MONSTER_SOUL, MONSTER_PAIN, MONSTER_CYBER, MONSTER_SPIDER,
 834         MONSTER_VILE, MONSTER_BARREL, MONSTER_ROBO: exit;
 835       end;
 836       // Остальных можно воскресить
 837       result := true;
 838     end;
 839   end;
 840   *)
 841
 842 var
 843   a: Integer;
 844   mon: PMonster;
 845   mres: TMonster = nil;
 846   it: TMonsterGrid.Iter;
 847 begin
 848   result := -1;
 849
 850   // Если нужна вероятность
 851   if not immediately and (Random(8) <> 0) then exit;
 852
 853   // Ищем мертвых монстров поблизости
 854   if gmon_debug_use_sqaccel then
 855   begin
 856     //mon := monsGrid.forEachInAABB(o.X+o.Rect.X, o.Y+o.Rect.Y, o.Rect.Width, o.Rect.Height, monsCollCheck);
 857     //if (mon <> nil) then result := mon.mArrIdx;
 858     it := monsGrid.forEachInAABB(o.X+o.Rect.X, o.Y+o.Rect.Y, o.Rect.Width, o.Rect.Height);
 859     for mon in it do
 860     begin
 861       case mon.FMonsterType of // Не воскресить:
 862         MONSTER_SOUL, MONSTER_PAIN, MONSTER_CYBER, MONSTER_SPIDER,
 863         MONSTER_VILE, MONSTER_BARREL, MONSTER_ROBO: begin end;
 864         // Остальных можно воскресить
 865         else mres := mon^;
 866       end;
 867       if (mres <> nil) then break;
 868     end;
 869     it.release();
 870     if (mres <> nil) then result := mres.mArrIdx;
 871   end
 872   else
 873   begin
 874     for a := 0 to High(gMonsters) do
 875     begin
 876       if (gMonsters[a] <> nil) and (gMonsters[a].FState = MONSTATE_DEAD) and g_Obj_Collide(o, @gMonsters[a].FObj) then
 877       begin
 878         case gMonsters[a].FMonsterType of // Не воскресить:
 879           MONSTER_SOUL, MONSTER_PAIN, MONSTER_CYBER, MONSTER_SPIDER,
 880           MONSTER_VILE, MONSTER_BARREL, MONSTER_ROBO: Continue;
 881           else // Остальных можно воскресить
 882             begin
 883               Result := a;
 884               Exit;
 885             end;
 886         end;
 887       end;
 888     end;
 889   end;
 890 end;
 891
 892 procedure g_Monsters_LoadData();
 893 begin
 894   e_WriteLog('Loading monsters data...', TMsgType.Notify);
 895
 896   g_Game_SetLoadingText(_lc[I_LOAD_MONSTER_TEXTURES], 133, False);
 897   g_Game_StepLoading(133);
 898
 899   g_Game_SetLoadingText(_lc[I_LOAD_MONSTER_SOUNDS], 0, False);
 900
 901   g_Sound_CreateWADEx('SOUND_MONSTER_BARREL_DIE', GameWAD+':MSOUNDS\BARREL_DIE');
 902
 903   g_Sound_CreateWADEx('SOUND_MONSTER_PAIN', GameWAD+':MSOUNDS\PAIN');
 904   g_Sound_CreateWADEx('SOUND_MONSTER_PAIN2', GameWAD+':MSOUNDS\PAIN2');
 905   g_Sound_CreateWADEx('SOUND_MONSTER_ACTION', GameWAD+':MSOUNDS\ACTION');
 906   g_Sound_CreateWADEx('SOUND_MONSTER_ACTION2', GameWAD+':MSOUNDS\ACTION2');
 907   g_Sound_CreateWADEx('SOUND_MONSTER_ALERT_1', GameWAD+':MSOUNDS\ALERT_1');
 908   g_Sound_CreateWADEx('SOUND_MONSTER_ALERT_2', GameWAD+':MSOUNDS\ALERT_2');
 909   g_Sound_CreateWADEx('SOUND_MONSTER_ALERT_3', GameWAD+':MSOUNDS\ALERT_3');
 910   g_Sound_CreateWADEx('SOUND_MONSTER_DIE_1', GameWAD+':MSOUNDS\DIE_1');
 911   g_Sound_CreateWADEx('SOUND_MONSTER_DIE_2', GameWAD+':MSOUNDS\DIE_2');
 912   g_Sound_CreateWADEx('SOUND_MONSTER_DIE_3', GameWAD+':MSOUNDS\DIE_3');
 913   g_Sound_CreateWADEx('SOUND_MONSTER_SLOP', GameWAD+':MSOUNDS\SLOP');
 914
 915   g_Sound_CreateWADEx('SOUND_MONSTER_DEMON_ATTACK', GameWAD+':MSOUNDS\DEMON_ATTACK');
 916   g_Sound_CreateWADEx('SOUND_MONSTER_DEMON_ALERT', GameWAD+':MSOUNDS\DEMON_ALERT');
 917   g_Sound_CreateWADEx('SOUND_MONSTER_DEMON_DIE', GameWAD+':MSOUNDS\DEMON_DIE');
 918
 919   g_Sound_CreateWADEx('SOUND_MONSTER_IMP_ALERT_1', GameWAD+':MSOUNDS\IMP_ALERT_1');
 920   g_Sound_CreateWADEx('SOUND_MONSTER_IMP_ALERT_2', GameWAD+':MSOUNDS\IMP_ALERT_2');
 921   g_Sound_CreateWADEx('SOUND_MONSTER_IMP_DIE_1', GameWAD+':MSOUNDS\IMP_DIE_1');
 922   g_Sound_CreateWADEx('SOUND_MONSTER_IMP_DIE_2', GameWAD+':MSOUNDS\IMP_DIE_2');
 923   g_Sound_CreateWADEx('SOUND_MONSTER_IMP_ACTION', GameWAD+':MSOUNDS\IMP_ACTION');
 924   g_Sound_CreateWADEx('SOUND_MONSTER_IMP_ATTACK', GameWAD+':MSOUNDS\IMP_ATTACK');
 925
 926   g_Sound_CreateWADEx('SOUND_MONSTER_MAN_PAIN', GameWAD+':MSOUNDS\MAN_PAIN');
 927   g_Sound_CreateWADEx('SOUND_MONSTER_MAN_ALERT', GameWAD+':MSOUNDS\MAN_ALERT');
 928   g_Sound_CreateWADEx('SOUND_MONSTER_MAN_DIE', GameWAD+':MSOUNDS\MAN_DIE');
 929   g_Sound_CreateWADEx('SOUND_MONSTER_HAHA', GameWAD+':MSOUNDS\HAHA');
 930   g_Sound_CreateWADEx('SOUND_MONSTER_TRUP', GameWAD+':MSOUNDS\TRUP');
 931
 932   g_Sound_CreateWADEx('SOUND_MONSTER_SOUL_ATTACK', GameWAD+':MSOUNDS\SOUL_ATTACK');
 933   g_Sound_CreateWADEx('SOUND_MONSTER_SOUL_DIE', GameWAD+':MSOUNDS\SOUL_DIE');
 934
 935   g_Sound_CreateWADEx('SOUND_MONSTER_BSP_ACTION', GameWAD+':MSOUNDS\BSP_ACTION');
 936   g_Sound_CreateWADEx('SOUND_MONSTER_BSP_DIE', GameWAD+':MSOUNDS\BSP_DIE');
 937   g_Sound_CreateWADEx('SOUND_MONSTER_BSP_ALERT', GameWAD+':MSOUNDS\BSP_ALERT');
 938   g_Sound_CreateWADEx('SOUND_MONSTER_BSP_WALK', GameWAD+':MSOUNDS\BSP_WALK');
 939
 940   g_Sound_CreateWADEx('SOUND_MONSTER_VILE_ACTION', GameWAD+':MSOUNDS\VILE_ACTION');
 941   g_Sound_CreateWADEx('SOUND_MONSTER_VILE_PAIN', GameWAD+':MSOUNDS\VILE_PAIN');
 942   g_Sound_CreateWADEx('SOUND_MONSTER_VILE_DIE', GameWAD+':MSOUNDS\VILE_DIE');
 943   g_Sound_CreateWADEx('SOUND_MONSTER_VILE_ALERT', GameWAD+':MSOUNDS\VILE_ALERT');
 944   g_Sound_CreateWADEx('SOUND_MONSTER_VILE_ATTACK', GameWAD+':MSOUNDS\VILE_ATTACK');
 945
 946   g_Sound_CreateWADEx('SOUND_MONSTER_SKEL_ACTION', GameWAD+':MSOUNDS\SKEL_ACTION');
 947   g_Sound_CreateWADEx('SOUND_MONSTER_SKEL_DIE', GameWAD+':MSOUNDS\SKEL_DIE');
 948   g_Sound_CreateWADEx('SOUND_MONSTER_SKEL_ALERT', GameWAD+':MSOUNDS\SKEL_ALERT');
 949   g_Sound_CreateWADEx('SOUND_MONSTER_SKEL_ATTACK', GameWAD+':MSOUNDS\SKEL_ATTACK');
 950   g_Sound_CreateWADEx('SOUND_MONSTER_SKEL_HIT', GameWAD+':MSOUNDS\SKEL_HIT');
 951
 952   g_Sound_CreateWADEx('SOUND_MONSTER_MANCUB_PAIN', GameWAD+':MSOUNDS\MANCUB_PAIN');
 953   g_Sound_CreateWADEx('SOUND_MONSTER_MANCUB_DIE', GameWAD+':MSOUNDS\MANCUB_DIE');
 954   g_Sound_CreateWADEx('SOUND_MONSTER_MANCUB_ALERT', GameWAD+':MSOUNDS\MANCUB_ALERT');
 955   g_Sound_CreateWADEx('SOUND_MONSTER_MANCUB_ATTACK', GameWAD+':MSOUNDS\MANCUB_ATTACK');
 956
 957   g_Sound_CreateWADEx('SOUND_MONSTER_PAIN_PAIN', GameWAD+':MSOUNDS\PAIN_PAIN');
 958   g_Sound_CreateWADEx('SOUND_MONSTER_PAIN_DIE', GameWAD+':MSOUNDS\PAIN_DIE');
 959   g_Sound_CreateWADEx('SOUND_MONSTER_PAIN_ALERT', GameWAD+':MSOUNDS\PAIN_ALERT');
 960
 961   g_Sound_CreateWADEx('SOUND_MONSTER_BARON_DIE', GameWAD+':MSOUNDS\BARON_DIE');
 962   g_Sound_CreateWADEx('SOUND_MONSTER_BARON_ALERT', GameWAD+':MSOUNDS\BARON_ALERT');
 963
 964   g_Sound_CreateWADEx('SOUND_MONSTER_CACO_DIE', GameWAD+':MSOUNDS\CACO_DIE');
 965   g_Sound_CreateWADEx('SOUND_MONSTER_CACO_ALERT', GameWAD+':MSOUNDS\CACO_ALERT');
 966
 967   g_Sound_CreateWADEx('SOUND_MONSTER_CYBER_DIE', GameWAD+':MSOUNDS\CYBER_DIE');
 968   g_Sound_CreateWADEx('SOUND_MONSTER_CYBER_ALERT', GameWAD+':MSOUNDS\CYBER_ALERT');
 969   g_Sound_CreateWADEx('SOUND_MONSTER_CYBER_WALK', GameWAD+':MSOUNDS\CYBER_WALK');
 970
 971   g_Sound_CreateWADEx('SOUND_MONSTER_KNIGHT_DIE', GameWAD+':MSOUNDS\KNIGHT_DIE');
 972   g_Sound_CreateWADEx('SOUND_MONSTER_KNIGHT_ALERT', GameWAD+':MSOUNDS\KNIGHT_ALERT');
 973
 974   g_Sound_CreateWADEx('SOUND_MONSTER_SPIDER_DIE', GameWAD+':MSOUNDS\SPIDER_DIE');
 975   g_Sound_CreateWADEx('SOUND_MONSTER_SPIDER_ALERT', GameWAD+':MSOUNDS\SPIDER_ALERT');
 976   g_Sound_CreateWADEx('SOUND_MONSTER_SPIDER_WALK', GameWAD+':MSOUNDS\SPIDER_WALK');
 977
 978   g_Sound_CreateWADEx('SOUND_MONSTER_FISH_ATTACK', GameWAD+':MSOUNDS\FISH_ATTACK');
 979
 980   freeInds := TIdPool.Create();
 981   clearUidMap();
 982   monCheckTrapLastFrameId := 0;
 983   monCheckMPlatLastFrameId := 0;
 984 end;
 985
 986 procedure g_Monsters_FreeData();
 987 begin
 988   e_WriteLog('Releasing monsters data...', TMsgType.Notify);
 989
 990   g_Sound_Delete('SOUND_MONSTER_BARREL_DIE');
 991
 992   g_Sound_Delete('SOUND_MONSTER_PAIN');
 993   g_Sound_Delete('SOUND_MONSTER_PAIN2');
 994   g_Sound_Delete('SOUND_MONSTER_ACTION');
 995   g_Sound_Delete('SOUND_MONSTER_ACTION2');
 996   g_Sound_Delete('SOUND_MONSTER_ALERT_1');
 997   g_Sound_Delete('SOUND_MONSTER_ALERT_2');
 998   g_Sound_Delete('SOUND_MONSTER_ALERT_3');
 999   g_Sound_Delete('SOUND_MONSTER_DIE_1');
1000   g_Sound_Delete('SOUND_MONSTER_DIE_2');
1001   g_Sound_Delete('SOUND_MONSTER_DIE_3');
1002   g_Sound_Delete('SOUND_MONSTER_SLOP');
1003
1004   g_Sound_Delete('SOUND_MONSTER_DEMON_ATTACK');
1005   g_Sound_Delete('SOUND_MONSTER_DEMON_ALERT');
1006   g_Sound_Delete('SOUND_MONSTER_DEMON_DIE');
1007
1008   g_Sound_Delete('SOUND_MONSTER_IMP_ALERT_1');
1009   g_Sound_Delete('SOUND_MONSTER_IMP_ALERT_2');
1010   g_Sound_Delete('SOUND_MONSTER_IMP_DIE_1');
1011   g_Sound_Delete('SOUND_MONSTER_IMP_DIE_2');
1012   g_Sound_Delete('SOUND_MONSTER_IMP_ACTION');
1013   g_Sound_Delete('SOUND_MONSTER_IMP_ATTACK');
1014
1015   g_Sound_Delete('SOUND_MONSTER_MAN_PAIN');
1016   g_Sound_Delete('SOUND_MONSTER_MAN_ALERT');
1017   g_Sound_Delete('SOUND_MONSTER_MAN_DIE');
1018   g_Sound_Delete('SOUND_MONSTER_HAHA');
1019   g_Sound_Delete('SOUND_MONSTER_TRUP');
1020
1021   g_Sound_Delete('SOUND_MONSTER_SOUL_ATTACK');
1022   g_Sound_Delete('SOUND_MONSTER_SOUL_DIE');
1023
1024   g_Sound_Delete('SOUND_MONSTER_BSP_ACTION');
1025   g_Sound_Delete('SOUND_MONSTER_BSP_DIE');
1026   g_Sound_Delete('SOUND_MONSTER_BSP_ALERT');
1027   g_Sound_Delete('SOUND_MONSTER_BSP_WALK');
1028
1029   g_Sound_Delete('SOUND_MONSTER_VILE_ACTION');
1030   g_Sound_Delete('SOUND_MONSTER_VILE_PAIN');
1031   g_Sound_Delete('SOUND_MONSTER_VILE_DIE');
1032   g_Sound_Delete('SOUND_MONSTER_VILE_ALERT');
1033   g_Sound_Delete('SOUND_MONSTER_VILE_ATTACK');
1034
1035   g_Sound_Delete('SOUND_MONSTER_SKEL_ACTION');
1036   g_Sound_Delete('SOUND_MONSTER_SKEL_DIE');
1037   g_Sound_Delete('SOUND_MONSTER_SKEL_ALERT');
1038   g_Sound_Delete('SOUND_MONSTER_SKEL_ATTACK');
1039   g_Sound_Delete('SOUND_MONSTER_SKEL_HIT');
1040
1041   g_Sound_Delete('SOUND_MONSTER_MANCUB_PAIN');
1042   g_Sound_Delete('SOUND_MONSTER_MANCUB_DIE');
1043   g_Sound_Delete('SOUND_MONSTER_MANCUB_ALERT');
1044   g_Sound_Delete('SOUND_MONSTER_MANCUB_ATTACK');
1045
1046   g_Sound_Delete('SOUND_MONSTER_PAIN_PAIN');
1047   g_Sound_Delete('SOUND_MONSTER_PAIN_DIE');
1048   g_Sound_Delete('SOUND_MONSTER_PAIN_ALERT');
1049
1050   g_Sound_Delete('SOUND_MONSTER_BARON_DIE');
1051   g_Sound_Delete('SOUND_MONSTER_BARON_ALERT');
1052
1053   g_Sound_Delete('SOUND_MONSTER_CACO_DIE');
1054   g_Sound_Delete('SOUND_MONSTER_CACO_ALERT');
1055
1056   g_Sound_Delete('SOUND_MONSTER_CYBER_DIE');
1057   g_Sound_Delete('SOUND_MONSTER_CYBER_ALERT');
1058   g_Sound_Delete('SOUND_MONSTER_CYBER_WALK');
1059
1060   g_Sound_Delete('SOUND_MONSTER_KNIGHT_DIE');
1061   g_Sound_Delete('SOUND_MONSTER_KNIGHT_ALERT');
1062
1063   g_Sound_Delete('SOUND_MONSTER_SPIDER_DIE');
1064   g_Sound_Delete('SOUND_MONSTER_SPIDER_ALERT');
1065   g_Sound_Delete('SOUND_MONSTER_SPIDER_WALK');
1066
1067   g_Sound_Delete('SOUND_MONSTER_FISH_ATTACK');
1068
1069   freeInds.Free();
1070   freeInds := nil;
1071 end;
1072
1073 procedure g_Monsters_Init();
1074 begin
1075   soulcount := 0;
1076 end;
1077
1078 procedure g_Monsters_Free (clearGrid: Boolean=true);
1079 var
1080   a: Integer;
1081 begin
1082   e_LogWritefln('Cleared monster data (clearGrid=%s)', [clearGrid]);
1083   if (clearGrid) then
1084   begin
1085     monsGrid.Free();
1086     monsGrid := nil;
1087   end;
1088   for a := 0 to High(gMonsters) do gMonsters[a].Free();
1089   gMonsters := nil;
1090   clearUidMap();
1091   monCheckTrapLastFrameId := 0;
1092   monCheckMPlatLastFrameId := 0;
1093 end;
1094
1095
1096 // will be called from map loader
1097 procedure g_Mons_InitTree (x, y, w, h: Integer);
1098 begin
1099   monsGrid.Free();
1100   monsGrid := TMonsterGrid.Create(x, y, w, h);
1101   //clearUidMap(); // why not?
1102   e_LogWritefln('%s', ['Recreated monster tree']);
1103 end;
1104
1105
1106 function g_Monsters_Create(MonsterType: Byte; X, Y: Integer;
1107            Direction: TDirection; AdjCoord: Boolean = False; ForcedUID: Integer = -1): TMonster;
1108 var
1109   find_id: DWORD;
1110   mon: TMonster;
1111 begin
1112   result := nil;
1113
1114   // Нет такого монстра
1115   if (MonsterType > MONSTER_MAN) or (MonsterType = 0) then exit;
1116
1117   // Соблюдаем ограничение Lost_Soul'ов
1118   if MonsterType = MONSTER_SOUL then
1119   begin
1120     if soulcount > MAX_SOUL then exit;
1121     soulcount := soulcount + 1;
1122   end;
1123
1124   find_id := allocMonster();
1125
1126   mon := TMonster.Create(MonsterType, find_id, ForcedUID);
1127   gMonsters[find_id] := mon;
1128   mon.mArrIdx := find_id;
1129   mon.mProxyId := -1;
1130
1131   uidMap[mon.FUID] := mon;
1132
1133   // Настраиваем положение
1134   with mon do
1135   begin
1136     if AdjCoord then
1137     begin
1138       FObj.X := X-FObj.Rect.X - (FObj.Rect.Width div 2);
1139       FObj.Y := Y-FObj.Rect.Y - FObj.Rect.Height;
1140     end
1141     else
1142     begin
1143       FObj.X := X-FObj.Rect.X;
1144       FObj.Y := Y-FObj.Rect.Y;
1145     end;
1146
1147     FDirection := Direction;
1148     FStartDirection := Direction;
1149     FStartX := GameX;
1150     FStartY := GameY;
1151     FObj.oldX := FObj.X;
1152     FObj.oldY := FObj.Y;
1153   end;
1154
1155   mon.positionChanged();
1156
1157   result := mon;
1158 end;
1159
1160 procedure g_Monsters_killedp();
1161 var
1162   a, h: Integer;
1163 begin
1164   if gMonsters = nil then
1165     Exit;
1166
1167   // Приколист смеется над смертью игрока:
1168   h := High(gMonsters);
1169   for a := 0 to h do
1170   begin
1171     if (gMonsters[a] <> nil) then
1172     begin
1173       with gMonsters[a] do
1174       begin
1175         if (FMonsterType = MONSTER_MAN) and
1176            (FState <> MONSTATE_DEAD) and
1177            (FState <> MONSTATE_SLEEP) and
1178            (FState <> MONSTATE_DIE) then
1179         begin
1180           g_Sound_PlayExAt('SOUND_MONSTER_TRUP', FObj.X, FObj.Y);
1181           Exit;
1182         end;
1183       end;
1184     end;
1185   end;
1186 end;
1187
1188 procedure g_Monsters_PreUpdate();
1189 var
1190   a: Integer;
1191 begin
1192   if gMonsters = nil then Exit;
1193   for a := 0 to High(gMonsters) do
1194     if (gMonsters[a] <> nil) and (not gMonsters[a].FRemoved) then
1195       gMonsters[a].PreUpdate();
1196 end;
1197
1198 procedure g_Monsters_Update();
1199 var
1200   a: Integer;
1201 begin
1202   // Целеуказатель
1203   if gTime mod (GAME_TICK*2) = 0 then
1204   begin
1205     pt_x := pt_x+pt_xs;
1206     pt_y := pt_y+pt_ys;
1207     if abs(pt_x) > 246 then pt_xs := -pt_xs;
1208     if abs(pt_y) > 100 then pt_ys := -pt_ys;
1209   end;
1210
1211   gMon := True; // Для работы BlockMon'а
1212
1213   if gmon_debug_think or gmon_debug_one_think_step then
1214   begin
1215     gmon_debug_one_think_step := false;
1216     for a := 0 to High(gMonsters) do
1217     begin
1218       if (gMonsters[a] = nil) then continue;
1219       if not gMonsters[a].FRemoved then
1220       begin
1221         if g_Game_IsClient then
1222           gMonsters[a].ClientUpdate()
1223         else
1224           gMonsters[a].Update();
1225       end
1226       else
1227       begin
1228         gMonsters[a].Free();
1229         gMonsters[a] := nil;
1230       end;
1231     end;
1232   end;
1233
1234   gMon := False;
1235 end;
1236
1237 function g_Monsters_ByUID (UID: Word): TMonster;
1238 begin
1239   result := uidMap[UID];
1240 end;
1241
1242 procedure g_Monsters_SaveState (st: TStream);
1243 var
1244   count, i: Integer;
1245 begin
1246   // Считаем количество существующих монстров
1247   count := 0;
1248   for i := 0 to High(gMonsters) do
1249   begin
1250     if (gMonsters[i] <> nil) and (gMonsters[i].FMonsterType <> MONSTER_NONE) then count += 1;
1251   end;
1252
1253   // Сохраняем информацию целеуказателя
1254   utils.writeInt(st, LongInt(pt_x));
1255   utils.writeInt(st, LongInt(pt_xs));
1256   utils.writeInt(st, LongInt(pt_y));
1257   utils.writeInt(st, LongInt(pt_ys));
1258
1259   // Количество монстров
1260   utils.writeInt(st, LongInt(count));
1261
1262   if (count = 0) then exit;
1263
1264   // Сохраняем монстров
1265   for i := 0 to High(gMonsters) do
1266   begin
1267     if (gMonsters[i] <> nil) and (gMonsters[i].FMonsterType <> MONSTER_NONE) then
1268     begin
1269       // Тип монстра
1270       utils.writeInt(st, Byte(gMonsters[i].MonsterType));
1271       // Сохраняем данные монстра:
1272       gMonsters[i].SaveState(st);
1273     end;
1274   end;
1275 end;
1276
1277
1278 procedure g_Monsters_LoadState (st: TStream);
1279 var
1280   count, a: Integer;
1281   b: Byte;
1282   mon: TMonster;
1283 begin
1284   assert(st <> nil);
1285
1286   g_Monsters_Free(false);
1287
1288   // Загружаем информацию целеуказателя
1289   pt_x := utils.readLongInt(st);
1290   pt_xs := utils.readLongInt(st);
1291   pt_y := utils.readLongInt(st);
1292   pt_ys := utils.readLongInt(st);
1293
1294   // Количество монстров
1295   count := utils.readLongInt(st);
1296
1297   if (count = 0) then exit;
1298   if (count < 0) or (count > 1024*1024) then raise XStreamError.Create('invalid monster count');
1299
1300   // Загружаем монстров
1301   for a := 0 to count-1 do
1302   begin
1303     // Тип монстра
1304     b := utils.readByte(st);
1305     // Создаем монстра
1306     mon := g_Monsters_Create(b, 0, 0, TDirection.D_LEFT);
1307     if (mon = nil) then raise XStreamError.Create('g_Monsters_LoadState: ID = -1 (can''t create)');
1308     // Загружаем данные монстра
1309     mon.LoadState(st);
1310   end;
1311 end;
1312
1313
1314 // ////////////////////////////////////////////////////////////////////////// //
1315 function g_Mons_SpawnAt (monType: Integer; x, y: Integer; dir: TDirection=TDirection.D_LEFT): TMonster; overload;
1316 begin
1317   result := nil;
1318   if (monType >= MONSTER_DEMON) and (monType <= MONSTER_MAN) then
1319   begin
1320     result := g_Monsters_Create(monType, x, y, dir);
1321   end;
1322 end;
1323
1324
1325 function g_Mons_SpawnAt (const typeName: AnsiString; x, y: Integer; dir: TDirection=TDirection.D_LEFT): TMonster; overload;
1326 begin
1327   result := g_Mons_SpawnAt(g_Mons_TypeIdByName(typeName), x, y, dir);
1328 end;
1329
1330
1331
1332 // ////////////////////////////////////////////////////////////////////////// //
1333 function g_Mons_TypeLo (): Integer; inline; begin result := Low(MONSTERTABLE); end;
1334 function g_Mons_TypeHi (): Integer; inline; begin result := High(MONSTERTABLE); end;
1335
1336
1337 function g_Mons_TypeIdByName (const name: String): Integer;
1338 var
1339   i: Integer;
1340 begin
1341   i := MONSTER_DEMON;
1342   while (i <= MONSTER_MAN) do
1343   begin
1344     if (CompareText(name, MONSTERTABLE[i].Name) = 0) then
1345     begin
1346       result := i;
1347       exit;
1348     end;
1349     Inc(i);
1350   end;
1351   result := -1;
1352   // HACK!
1353   if (CompareText(name, 'zombie') = 0) then result := MONSTER_ZOMBY;
1354 end;
1355
1356
1357 function g_Mons_NameByTypeId (monType: Integer): AnsiString;
1358 begin
1359   if (monType >= MONSTER_DEMON) and (monType <= MONSTER_MAN) then
1360     result := MONSTERTABLE[monType].Name
1361   else
1362     result := '?';
1363 end;
1364
1365
1366 function g_Mons_GetKilledByTypeId (monType: Integer): AnsiString;
1367 begin
1368   if (monType >= MONSTER_DEMON) and (monType <= MONSTER_MAN) then
1369     Result := KilledByMonster[monType]
1370   else
1371     Result := '?';
1372 end;
1373
1374
1375 // ////////////////////////////////////////////////////////////////////////// //
1376 { T M o n s t e r : }
1377
1378 procedure TMonster.setGameX (v: Integer); inline; begin FObj.X := v; positionChanged(); end;
1379 procedure TMonster.setGameY (v: Integer); inline; begin FObj.Y := v; positionChanged(); end;
1380
1381 procedure TMonster.setPosition (ax, ay: Integer; callPosChanged: Boolean=true); inline; begin FObj.X := ax; FObj.Y := ay; if callPosChanged then positionChanged(); end;
1382
1383 procedure TMonster.moveBy (dx, dy: Integer); inline;
1384 begin
1385   if (dx <> 0) or (dy <> 0) then
1386   begin
1387     FObj.X += dx;
1388     FObj.Y += dy;
1389     positionChanged();
1390   end;
1391 end;
1392
1393 procedure TMonster.doDamage (v: Integer);
1394 begin
1395   if (v <= 0) then exit;
1396   if (v > 32767) then v := 32767;
1397   Damage(v, 0, 0, 0, mEDamageType);
1398 end;
1399
1400 procedure TMonster.ActionSound();
1401 begin
1402   case FMonsterType of
1403     MONSTER_IMP:
1404       g_Sound_PlayExAt('SOUND_MONSTER_IMP_ACTION', FObj.X, FObj.Y);
1405     MONSTER_ZOMBY, MONSTER_SERG, MONSTER_CGUN,
1406     MONSTER_MANCUB:
1407       g_Sound_PlayExAt('SOUND_MONSTER_ACTION', FObj.X, FObj.Y);
1408     MONSTER_SOUL, MONSTER_BARON, MONSTER_CACO,
1409     MONSTER_KNIGHT, MONSTER_PAIN, MONSTER_DEMON,
1410     MONSTER_SPIDER:
1411       g_Sound_PlayExAt('SOUND_MONSTER_ACTION2', FObj.X, FObj.Y);
1412     MONSTER_BSP:
1413       g_Sound_PlayExAt('SOUND_MONSTER_BSP_ACTION', FObj.X, FObj.Y);
1414     MONSTER_VILE:
1415       g_Sound_PlayExAt('SOUND_MONSTER_VILE_ACTION', FObj.X, FObj.Y);
1416     MONSTER_SKEL:
1417       g_Sound_PlayExAt('SOUND_MONSTER_SKEL_ACTION', FObj.X, FObj.Y);
1418     MONSTER_CYBER:
1419       ;
1420     MONSTER_MAN:
1421       g_Sound_PlayExAt('SOUND_MONSTER_HAHA', FObj.X, FObj.Y);
1422   end;
1423 end;
1424
1425 procedure TMonster.PainSound();
1426 begin
1427   if FPainSound then
1428     Exit;
1429
1430   FPainSound := True;
1431   FPainTicks := 20;
1432
1433   case FMonsterType of
1434     MONSTER_IMP, MONSTER_ZOMBY, MONSTER_SERG,
1435     MONSTER_SKEL, MONSTER_CGUN:
1436       g_Sound_PlayExAt('SOUND_MONSTER_PAIN', FObj.X, FObj.Y);
1437     MONSTER_SOUL, MONSTER_BARON, MONSTER_CACO,
1438     MONSTER_KNIGHT, MONSTER_DEMON, MONSTER_SPIDER,
1439     MONSTER_BSP, MONSTER_CYBER:
1440       g_Sound_PlayExAt('SOUND_MONSTER_PAIN2', FObj.X, FObj.Y);
1441     MONSTER_VILE:
1442       g_Sound_PlayExAt('SOUND_MONSTER_VILE_PAIN', FObj.X, FObj.Y);
1443     MONSTER_MANCUB:
1444       g_Sound_PlayExAt('SOUND_MONSTER_MANCUB_PAIN', FObj.X, FObj.Y);
1445     MONSTER_PAIN:
1446       g_Sound_PlayExAt('SOUND_MONSTER_PAIN_PAIN', FObj.X, FObj.Y);
1447     MONSTER_MAN:
1448       g_Sound_PlayExAt('SOUND_MONSTER_MAN_PAIN', FObj.X, FObj.Y);
1449   end;
1450 end;
1451
1452 procedure TMonster.DieSound();
1453 begin
1454   case FMonsterType of
1455     MONSTER_IMP:
1456       case Random(2) of
1457         0: g_Sound_PlayExAt('SOUND_MONSTER_IMP_DIE_1', FObj.X, FObj.Y);
1458         1: g_Sound_PlayExAt('SOUND_MONSTER_IMP_DIE_2', FObj.X, FObj.Y);
1459       end;
1460     MONSTER_ZOMBY, MONSTER_SERG, MONSTER_CGUN:
1461       case Random(3) of
1462         0: g_Sound_PlayExAt('SOUND_MONSTER_DIE_1', FObj.X, FObj.Y);
1463         1: g_Sound_PlayExAt('SOUND_MONSTER_DIE_2', FObj.X, FObj.Y);
1464         2: g_Sound_PlayExAt('SOUND_MONSTER_DIE_3', FObj.X, FObj.Y);
1465       end;
1466     MONSTER_DEMON:
1467       g_Sound_PlayExAt('SOUND_MONSTER_DEMON_DIE', FObj.X, FObj.Y);
1468     MONSTER_BARREL:
1469       g_Sound_PlayExAt('SOUND_MONSTER_BARREL_DIE', FObj.X, FObj.Y);
1470     MONSTER_SOUL:
1471       g_Sound_PlayExAt('SOUND_MONSTER_SOUL_DIE', FObj.X, FObj.Y);
1472     MONSTER_BSP:
1473       g_Sound_PlayExAt('SOUND_MONSTER_BSP_DIE', FObj.X, FObj.Y);
1474     MONSTER_VILE:
1475       g_Sound_PlayExAt('SOUND_MONSTER_VILE_DIE', FObj.X, FObj.Y);
1476     MONSTER_BARON:
1477       g_Sound_PlayExAt('SOUND_MONSTER_BARON_DIE', FObj.X, FObj.Y);
1478     MONSTER_CACO:
1479       g_Sound_PlayExAt('SOUND_MONSTER_CACO_DIE', FObj.X, FObj.Y);
1480     MONSTER_CYBER:
1481       g_Sound_PlayExAt('SOUND_MONSTER_CYBER_DIE', FObj.X, FObj.Y);
1482     MONSTER_KNIGHT:
1483       g_Sound_PlayExAt('SOUND_MONSTER_KNIGHT_DIE', FObj.X, FObj.Y);
1484     MONSTER_MANCUB:
1485       g_Sound_PlayExAt('SOUND_MONSTER_MANCUB_DIE', FObj.X, FObj.Y);
1486     MONSTER_PAIN:
1487       g_Sound_PlayExAt('SOUND_MONSTER_PAIN_DIE', FObj.X, FObj.Y);
1488     MONSTER_SKEL:
1489       g_Sound_PlayExAt('SOUND_MONSTER_SKEL_DIE', FObj.X, FObj.Y);
1490     MONSTER_SPIDER:
1491       g_Sound_PlayExAt('SOUND_MONSTER_SPIDER_DIE', FObj.X, FObj.Y);
1492     MONSTER_MAN:
1493       g_Sound_PlayExAt('SOUND_MONSTER_MAN_DIE', FObj.X, FObj.Y);
1494   end;
1495 end;
1496
1497 procedure TMonster.WakeUpSound();
1498 begin
1499   case FMonsterType of
1500     MONSTER_IMP:
1501       case Random(2) of
1502         0: g_Sound_PlayExAt('SOUND_MONSTER_IMP_ALERT_1', FObj.X, FObj.Y);
1503         1: g_Sound_PlayExAt('SOUND_MONSTER_IMP_ALERT_2', FObj.X, FObj.Y);
1504       end;
1505     MONSTER_ZOMBY, MONSTER_SERG, MONSTER_CGUN:
1506       case Random(3) of
1507         0: g_Sound_PlayExAt('SOUND_MONSTER_ALERT_1', FObj.X, FObj.Y);
1508         1: g_Sound_PlayExAt('SOUND_MONSTER_ALERT_2', FObj.X, FObj.Y);
1509         2: g_Sound_PlayExAt('SOUND_MONSTER_ALERT_3', FObj.X, FObj.Y);
1510       end;
1511     MONSTER_MAN:
1512       g_Sound_PlayExAt('SOUND_MONSTER_MAN_ALERT', FObj.X, FObj.Y);
1513     MONSTER_BSP:
1514       g_Sound_PlayExAt('SOUND_MONSTER_BSP_ALERT', FObj.X, FObj.Y);
1515     MONSTER_VILE:
1516       g_Sound_PlayExAt('SOUND_MONSTER_VILE_ALERT', FObj.X, FObj.Y);
1517     MONSTER_BARON:
1518       g_Sound_PlayExAt('SOUND_MONSTER_BARON_ALERT', FObj.X, FObj.Y);
1519     MONSTER_CACO:
1520       g_Sound_PlayExAt('SOUND_MONSTER_CACO_ALERT', FObj.X, FObj.Y);
1521     MONSTER_CYBER:
1522       g_Sound_PlayExAt('SOUND_MONSTER_CYBER_ALERT', FObj.X, FObj.Y);
1523     MONSTER_KNIGHT:
1524       g_Sound_PlayExAt('SOUND_MONSTER_KNIGHT_ALERT', FObj.X, FObj.Y);
1525     MONSTER_MANCUB:
1526       g_Sound_PlayExAt('SOUND_MONSTER_MANCUB_ALERT', FObj.X, FObj.Y);
1527     MONSTER_PAIN:
1528       g_Sound_PlayExAt('SOUND_MONSTER_PAIN_ALERT', FObj.X, FObj.Y);
1529     MONSTER_DEMON:
1530       g_Sound_PlayExAt('SOUND_MONSTER_DEMON_ALERT', FObj.X, FObj.Y);
1531     MONSTER_SKEL:
1532       g_Sound_PlayExAt('SOUND_MONSTER_SKEL_ALERT', FObj.X, FObj.Y);
1533     MONSTER_SPIDER:
1534       g_Sound_PlayExAt('SOUND_MONSTER_SPIDER_ALERT', FObj.X, FObj.Y);
1535     MONSTER_SOUL:
1536       ;
1537   end;
1538 end;
1539
1540 procedure TMonster.BFGHit();
1541 begin
1542   if FMonsterType = MONSTER_FISH then
1543     Exit;
1544
1545   g_Weapon_BFGHit(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
1546                   FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2));
1547   {if g_Game_IsServer and g_Game_IsNet then
1548     MH_SEND_Effect(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
1549                    FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
1550                    0, NET_GFX_BFG);}
1551 end;
1552
1553 function TMonster.Collide(X, Y: Integer; Width, Height: Word): Boolean;
1554 begin
1555   Result := g_Collide(FObj.X+FObj.Rect.X,
1556                       FObj.Y+FObj.Rect.Y,
1557                       FObj.Rect.Width,
1558                       FObj.Rect.Height,
1559                       X, Y,
1560                       Width, Height);
1561 end;
1562
1563 function TMonster.Collide(Panel: TPanel): Boolean;
1564 begin
1565   Result := g_Collide(FObj.X+FObj.Rect.X,
1566                       FObj.Y+FObj.Rect.Y,
1567                       FObj.Rect.Width,
1568                       FObj.Rect.Height,
1569                       Panel.X, Panel.Y,
1570                       Panel.Width, Panel.Height);
1571 end;
1572
1573 function TMonster.Collide(X, Y: Integer): Boolean;
1574 begin
1575   X := X - FObj.X - FObj.Rect.X;
1576   Y := Y - FObj.Y - FObj.Rect.Y;
1577   Result := (x >= 0) and (x <= FObj.Rect.Width) and
1578             (y >= 0) and (y <= FObj.Rect.Height);
1579 end;
1580
1581 procedure TMonster.Respawn;
1582 begin
1583   FObj.Vel.X := 0;
1584   FObj.Vel.Y := 0;
1585   FObj.Accel.X := 0;
1586   FObj.Accel.Y := 0;
1587   FDirection := FStartDirection;
1588   {GameX}FObj.X := FStartX;
1589   {GameY}FObj.Y := FStartY;
1590   FObj.Rect := MONSTERTABLE[FMonsterType].Rect;
1591   FHealth := MONSTERTABLE[FMonsterType].Health;
1592   FAmmo := 0;
1593   FPain := 0;
1594   FTargetUID := 0;
1595   FTargetTime := 0;
1596   FDieTriggers := nil;
1597   FWaitAttackAnim := False;
1598   FChainFire := False;
1599   {$IFDEF ENABLE_SHELLS}
1600     FShellTimer := -1;
1601   {$ENDIF}
1602
1603   FState := MONSTATE_SLEEP;
1604   FCurAnim := ANIM_SLEEP;
1605
1606   positionChanged(); // this updates spatial accelerators
1607
1608   if g_Game_IsNet and g_Game_IsServer then
1609   begin
1610     MH_SEND_MonsterPos(FUID);
1611     MH_SEND_MonsterState(FUID);
1612   end;
1613 end;
1614
1615 constructor TMonster.Create(MonsterType: Byte; aID: Integer; ForcedUID: Integer = -1);
1616   var a: Integer;
1617 begin
1618   if ForcedUID < 0 then
1619     FUID := g_CreateUID(UID_MONSTER)
1620   else
1621     FUID := ForcedUID;
1622
1623   FMonsterType := MonsterType;
1624
1625   g_Obj_Init(@FObj);
1626
1627   FState := MONSTATE_SLEEP;
1628   FCurAnim := ANIM_SLEEP;
1629   FHealth := MONSTERTABLE[MonsterType].Health;
1630   FMaxHealth := FHealth;
1631   FObj.Rect := MONSTERTABLE[MonsterType].Rect;
1632   FDieTriggers := nil;
1633   FSpawnTrigger := -1;
1634   FWaitAttackAnim := False;
1635   FChainFire := False;
1636   FStartID := aID;
1637   FNoRespawn := False;
1638   {$IFDEF ENABLE_SHELLS}
1639     FShellTimer := -1;
1640   {$ENDIF}
1641   FBehaviour := BH_NORMAL;
1642   FFireTime := 0;
1643   FFirePainTime := 0;
1644   FFireAttacker := 0;
1645   mEDamageType := HIT_SOME;
1646
1647   mProxyId := -1;
1648   mArrIdx := -1;
1649   trapCheckFrameId := 0;
1650   mplatCheckFrameId := 0;
1651   mNeedSend := false;
1652
1653 {$IFDEF ENABLE_GFX}
1654   if FMonsterType in [MONSTER_ROBO, MONSTER_BARREL] then
1655     FBloodKind := BLOOD_SPARKS
1656   else
1657     FBloodKind := BLOOD_NORMAL;
1658   if FMonsterType = MONSTER_CACO then
1659   begin
1660     FBloodRed := 0;
1661     FBloodGreen := 0;
1662     FBloodBlue := 150;
1663   end
1664   else if FMonsterType in [MONSTER_BARON, MONSTER_KNIGHT] then
1665   begin
1666     FBloodRed := 0;
1667     FBloodGreen := 150;
1668     FBloodBlue := 0;
1669   end
1670   else
1671   begin
1672     FBloodRed := 150;
1673     FBloodGreen := 0;
1674     FBloodBlue := 0;
1675   end;
1676 {$ENDIF}
1677
1678   SetLength(FAnim, Length(ANIMTABLE));
1679   for a := ANIM_SLEEP to ANIM_PAIN do
1680   begin
1681     FAnim[a, TDirection.D_RIGHT] := TAnimationState.Create(ANIMTABLE[a].loop, MONSTER_ANIMTABLE[MonsterType].AnimSpeed[a], MONSTER_ANIMTABLE[MonsterType].AnimCount[a]);
1682     FAnim[a, TDirection.D_LEFT] := TAnimationState.Create(ANIMTABLE[a].loop, MONSTER_ANIMTABLE[MonsterType].AnimSpeed[a], MONSTER_ANIMTABLE[MonsterType].AnimCount[a]);
1683   end;
1684   if MonsterType = MONSTER_VILE then
1685     vilefire := TAnimationState.Create(True, 2, 8);
1686 end;
1687
1688 function TMonster.Damage(aDamage: Word; VelX, VelY: Integer; SpawnerUID: Word; t: Byte): Boolean;
1689 var
1690   c, it: Integer;
1691   p: TPlayer;
1692 begin
1693   Result := False;
1694
1695 // Монстр статичен пока идет warmup
1696   if (gLMSRespawn > LMS_RESPAWN_NONE) then exit;
1697
1698 // Умирает, умер или воскрешается => урон делать некому:
1699   if (FState = MONSTATE_DEAD) or (FState = MONSTATE_DIE) or (FState = MONSTATE_REVIVE) then
1700     Exit;
1701
1702 // Рыбу в воде бьет током => паника без урона:
1703   if (t = HIT_ELECTRO) and (FMonsterType = MONSTER_FISH) and g_Game_IsServer then
1704   begin
1705     FSleep := 20;
1706     if Random(2) = 0 then FDirection := TDirection.D_RIGHT else FDirection := TDirection.D_LEFT;
1707     Result := True;
1708     SetState(MONSTATE_RUN);
1709     Exit;
1710   end;
1711
1712 // Арчи не горят, черепа уже горят
1713   if (t = HIT_FLAME) and (FMonsterType in [MONSTER_VILE, MONSTER_SOUL]) then
1714   begin
1715   // Проснуться все-таки стоит
1716     if FState = MONSTATE_SLEEP then
1717       SetState(MONSTATE_GO);
1718     Exit;
1719   end;
1720
1721 // Ловушка убивает сразу:
1722   if t = HIT_TRAP then
1723     FHealth := -100;
1724
1725 // Роботу урона нет:
1726   if FMonsterType = MONSTER_ROBO then
1727     aDamage := 0;
1728
1729 // Наносим урон:
1730   if g_Game_IsServer then Dec(FHealth, aDamage);
1731
1732 // Усиливаем боль монстра от урона:
1733   if FPain = 0 then
1734     FPain := 3;
1735   FPain := FPain+aDamage;
1736
1737 // Если боль существенная, то меняем состояние на болевое:
1738   if FState <> MONSTATE_PAIN then
1739     if (FPain >= MONSTERTABLE[FMonsterType].MinPain) and
1740        (FMonsterType <> MONSTER_BARREL) then
1741          SetState(MONSTATE_PAIN);
1742
1743 // Если разрешена кровь - создаем брызги крови:
1744   if (gBloodCount > 0) then
1745   begin
1746     c := Min(aDamage, 200);
1747     c := c*gBloodCount - (aDamage div 4) + Random(c div 2);
1748
1749     if (VelX = 0) and (VelY = 0) then
1750       MakeBloodSimple(c)
1751     else
1752       case t of
1753         HIT_TRAP, HIT_ACID, HIT_ELECTRO, HIT_FLAME: MakeBloodSimple(c);
1754         HIT_BFG, HIT_ROCKET, HIT_SOME: MakeBloodVector(c, VelX, VelY);
1755       end;
1756   end;
1757
1758 // Теперь цель - ударивший, если только не сам себя:
1759   if (SpawnerUID <> FUID) and (BehaviourDamage(SpawnerUID, FBehaviour, FMonsterType)) then
1760   begin
1761     FTargetUID := SpawnerUID;
1762     FTargetTime := 0;
1763   end;
1764
1765 // Здоровье закончилось:
1766   if FHealth <= 0 then
1767     begin
1768     // Если это не бочка и убил игрок, то ему +1:
1769       if (FMonsterType <> MONSTER_BARREL) then
1770       begin
1771         if (g_GetUIDType(SpawnerUID) = UID_PLAYER) then
1772         begin
1773           p := g_Player_Get(SpawnerUID);
1774           if (p <> nil) and (gLMSRespawn = LMS_RESPAWN_NONE) then
1775           begin
1776             p.MonsterKills := p.MonsterKills+1;
1777             if gGameSettings.GameMode = GM_COOP then
1778               p.Frags := p.Frags + 1;
1779             // Uncomment this if you want to double-kill monsters
1780             //p.FragCombo();
1781           end;
1782         end;
1783         if gLMSRespawn = LMS_RESPAWN_NONE then
1784         begin
1785           Inc(gCoopMonstersKilled);
1786           if g_Game_IsNet then
1787             MH_SEND_GameStats;
1788         end;
1789       end;
1790
1791     // Выбираем лут:
1792       case FMonsterType of
1793         MONSTER_ZOMBY: c := ITEM_AMMO_BULLETS;
1794         MONSTER_SERG: c := ITEM_WEAPON_SHOTGUN1;
1795         MONSTER_CGUN: c := ITEM_WEAPON_CHAINGUN;
1796         MONSTER_MAN: c := ITEM_KEY_RED;
1797         else c := 0;
1798       end;
1799
1800     // Бросаем лут:
1801       if c <> 0 then
1802       begin
1803         it := g_Items_Create(FObj.X + (FObj.Rect.Width div 2),
1804                              FObj.Y + (FObj.Rect.Height div 2),
1805                              c, True, False);
1806         g_Items_SetDrop(it); // mark it as monster drop
1807         g_Obj_Push(g_Items_ObjByIdx(it), (FObj.Vel.X div 2)-3+Random(7),
1808                                         (FObj.Vel.Y div 2)-Random(4));
1809         //positionChanged(); // this updates spatial accelerators
1810         if g_Game_IsServer and g_Game_IsNet then
1811           MH_SEND_ItemSpawn(True, it);
1812       end;
1813
1814     // Труп дальше не идет:
1815       FObj.Vel.X := 0;
1816
1817     // У трупа размеры меньше:
1818       if (FMonsterType <> MONSTER_FISH) and (FMonsterType <> MONSTER_PAIN) then
1819       begin
1820         FObj.Rect.Y := FObj.Rect.Y + FObj.Rect.Height-12;
1821         FObj.Rect.Height := 12;
1822         positionChanged();
1823       end;
1824
1825     // Урон был сильным => слабые - в кашу:
1826       if (FHealth <= -30) and
1827          ((FMonsterType = MONSTER_IMP) or (FMonsterType = MONSTER_ZOMBY) or
1828           (FMonsterType = MONSTER_SERG) or (FMonsterType = MONSTER_CGUN) or
1829           (FMonsterType = MONSTER_MAN)) then
1830         begin
1831           g_Sound_PlayExAt('SOUND_MONSTER_SLOP', FObj.X, FObj.Y);
1832           SetState(MONSTATE_DIE, ANIM_MESS);
1833         end
1834       else
1835         begin
1836           DieSound();
1837           SetState(MONSTATE_DIE);
1838         end;
1839
1840     // Активировать триггеры, ждущие смерти этого монстра:
1841       if g_Game_IsServer then ActivateTriggers();
1842
1843       FHealth := 0;
1844     end
1845   else
1846     if FState = MONSTATE_SLEEP then
1847     begin // Спал, разбудили несмертельным ударом:
1848       FPain := MONSTERTABLE[FMonsterType].Pain;
1849       SetState(MONSTATE_GO);
1850     end;
1851
1852   if g_Game_IsServer and g_Game_IsNet then MH_SEND_MonsterState(FUID);
1853   Result := True;
1854 end;
1855
1856 function TMonster.Heal(Value: Word): Boolean;
1857 begin
1858   Result := False;
1859   if g_Game_IsClient then
1860     Exit;
1861   if not alive then
1862     Exit;
1863
1864   if FHealth < FMaxHealth then
1865   begin
1866     IncMax(FHealth, Value, FMaxHealth);
1867     if g_Game_IsServer and g_Game_IsNet then MH_SEND_MonsterState(FUID);
1868     Result := True;
1869   end;
1870 end;
1871
1872 destructor TMonster.Destroy();
1873 var
1874   a: Integer;
1875 begin
1876   for a := 0 to High(FAnim) do
1877   begin
1878     FAnim[a, TDirection.D_LEFT].Free();
1879     FAnim[a, TDirection.D_RIGHT].Free();
1880   end;
1881
1882   vilefire.Free();
1883
1884   if (mProxyId <> -1) then
1885   begin
1886     if (monsGrid <> nil) then
1887     begin
1888       monsGrid.removeBody(mProxyId);
1889       {$IF DEFINED(D2F_DEBUG_MONS_MOVE)}
1890       e_WriteLog(Format('monster #%d:(%u): removed from grid; mProxyid=%d', [mArrIdx, UID, mProxyId]), MSG_NOTIFY);
1891       {$ENDIF}
1892     end;
1893     mProxyId := -1;
1894   end;
1895
1896   if (mArrIdx <> -1) and (mArrIdx < Length(gMonsters)) then
1897   begin
1898     freeInds.release(mArrIdx);
1899     gMonsters[mArrIdx] := nil;
1900   end;
1901   mArrIdx := -1;
1902
1903   uidMap[FUID] := nil;
1904
1905   inherited Destroy();
1906 end;
1907
1908 procedure TMonster.MakeBloodSimple(Count: Word);
1909 begin
1910 {$IFDEF ENABLE_GFX}
1911   g_GFX_Blood(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2)+8,
1912               FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
1913               Count div 2, 3, -1, 16, (FObj.Rect.Height*2 div 3),
1914               FBloodRed, FBloodGreen, FBloodBlue, FBloodKind);
1915   g_GFX_Blood(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2)-8,
1916               FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
1917               Count div 2, -3, -1, 16, (FObj.Rect.Height*2) div 3,
1918               FBloodRed, FBloodGreen, FBloodBlue, FBloodKind);
1919 {$ENDIF}
1920 end;
1921
1922 procedure TMonster.MakeBloodVector(Count: Word; VelX, VelY: Integer);
1923 begin
1924 {$IFDEF ENABLE_GFX}
1925   g_GFX_Blood(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
1926               FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
1927               Count, VelX, VelY, 16, (FObj.Rect.Height*2) div 3,
1928               FBloodRed, FBloodGreen, FBloodBlue, FBloodKind);
1929 {$ENDIF}
1930 end;
1931
1932 procedure TMonster.Push(vx, vy: Integer);
1933 begin
1934   FObj.Accel.X := FObj.Accel.X + vx;
1935   FObj.Accel.Y := FObj.Accel.Y + vy;
1936   if g_Game_IsServer and g_Game_IsNet then MH_SEND_MonsterPos(FUID);
1937 end;
1938
1939 procedure TMonster.SetState(State: Byte; ForceAnim: Byte = 255);
1940 var
1941   Anim: Byte;
1942 begin
1943 // Если состояние = начали умирать, а этот монстр = Lost_Soul,
1944 // то соблюдаем ограничение количества Lost_Soul'ов:
1945   if (State = MONSTATE_DIE) and (MonsterType = MONSTER_SOUL) then
1946     soulcount := soulcount-1;
1947
1948 // Присмерти - нельзя сразу начинать атаковать или бегать:
1949   case FState of
1950     MONSTATE_DIE, MONSTATE_DEAD, MONSTATE_REVIVE:
1951       if (State <> MONSTATE_DEAD) and (State <> MONSTATE_REVIVE) and
1952          (State <> MONSTATE_GO) then
1953         Exit;
1954   end;
1955
1956 // Смена состояния:
1957   FState := State;
1958
1959   if g_Game_IsServer and g_Game_IsNet then MH_SEND_MonsterState(FUID, ForceAnim);
1960
1961 // Новая анимация при новом состоянии:
1962   case FState of
1963     MONSTATE_SLEEP: Anim := ANIM_SLEEP;
1964     MONSTATE_PAIN: Anim := ANIM_PAIN;
1965     MONSTATE_WAIT: Anim := ANIM_SLEEP;
1966     MONSTATE_CLIMB, MONSTATE_RUN, MONSTATE_RUNOUT, MONSTATE_GO: Anim := ANIM_GO;
1967     MONSTATE_SHOOT: Anim := ANIM_ATTACK;
1968     MONSTATE_ATTACK: Anim := ANIM_ATTACK;
1969     MONSTATE_DIE: Anim := ANIM_DIE;
1970     MONSTATE_REVIVE:
1971       begin // начали восрешаться
1972         Anim := FCurAnim;
1973         FAnim[Anim, FDirection].Revert(True);
1974
1975         FObj.Rect := MONSTERTABLE[FMonsterType].Rect;
1976         FHealth := MONSTERTABLE[FMonsterType].Health;
1977         FAmmo := 0;
1978         FPain := 0;
1979       end;
1980     else Exit;
1981   end;
1982
1983 // Надо сменить анимацию на нестандартную:
1984   if ForceAnim <> 255 then
1985     Anim := ForceAnim;
1986
1987 // Если анимация новая - перезапускаем её:
1988   if FCurAnim <> Anim then
1989     if FAnim[Anim, FDirection] <> nil then
1990     begin
1991       FAnim[Anim, FDirection].Reset();
1992       FCurAnim := Anim;
1993     end;
1994 end;
1995
1996 function TMonster.TeleportTo(X, Y: Integer; silent: Boolean; dir: Byte): Boolean;
1997 begin
1998   Result := False;
1999
2000 // В точке назначения стена:
2001   if g_CollideLevel(X, Y, FObj.Rect.Width, FObj.Rect.Height) then
2002   begin
2003     g_Sound_PlayExAt('SOUND_GAME_NOTELEPORT', FObj.X, FObj.Y);
2004     if g_Game_IsServer and g_Game_IsNet then
2005       MH_SEND_Sound(FObj.X, FObj.Y, 'SOUND_GAME_NOTELEPORT');
2006     Exit;
2007   end;
2008
2009 // Эффект телепорта в позиции монстра:
2010   if not silent then
2011   begin
2012     g_Sound_PlayExAt('SOUND_GAME_TELEPORT', Obj.X, Obj.Y);
2013 {$IFDEF ENABLE_GFX}
2014     g_GFX_QueueEffect(
2015       R_GFX_TELEPORT,
2016       FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2)-32,
2017       FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2)-32
2018     );
2019 {$ENDIF}
2020     if g_Game_IsServer and g_Game_IsNet then
2021       MH_SEND_Effect(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2)-32,
2022                      FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2)-32, 1,
2023                      NET_GFX_TELE);
2024   end;
2025
2026   FObj.X := X - FObj.Rect.X;
2027   FObj.Y := Y - FObj.Rect.Y;
2028   FObj.oldX := FObj.X; // don't interpolate after teleport
2029   FObj.oldY := FObj.Y;
2030   positionChanged();
2031
2032   if dir = 1 then
2033     FDirection := TDirection.D_LEFT
2034   else
2035     if dir = 2 then
2036       FDirection := TDirection.D_RIGHT
2037     else
2038       if dir = 3 then
2039       begin // обратное
2040         if FDirection = TDirection.D_RIGHT then
2041           FDirection := TDirection.D_LEFT
2042         else
2043           FDirection := TDirection.D_RIGHT;
2044       end;
2045
2046 // Эффект телепорта в точке назначения:
2047   if not silent then
2048   begin
2049 {$IFDEF ENABLE_GFX}
2050     g_GFX_QueueEffect(
2051       R_GFX_TELEPORT,
2052       FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2)-32,
2053       FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2)-32
2054     );
2055 {$ENDIF}
2056     if g_Game_IsServer and g_Game_IsNet then
2057      MH_SEND_Effect(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2)-32,
2058                     FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2)-32, 0,
2059                     NET_GFX_TELE);
2060   end;
2061
2062   if g_Game_IsServer and g_Game_IsNet then MH_SEND_MonsterPos(FUID);
2063   Result := True;
2064 end;
2065
2066 procedure TMonster.PreUpdate();
2067 begin
2068   FObj.oldX := FObj.X;
2069   FObj.oldY := FObj.Y;
2070 end;
2071
2072 procedure TMonster.Update();
2073 var
2074   a, b, sx, sy, wx, wy, oldvelx: Integer;
2075   st: Word;
2076   o, co: TObj;
2077   fall: Boolean;
2078   mon: TMonster;
2079   mit: PMonster;
2080   it: TMonsterGrid.Iter;
2081 label
2082   _end;
2083 begin
2084   fall := True;
2085
2086 // Монстр статичен пока идет warmup
2087   if (gLMSRespawn > LMS_RESPAWN_NONE) then exit;
2088
2089 // Рыбы "летают" только в воде:
2090   if FMonsterType = MONSTER_FISH then
2091     if g_Obj_CollidePanel(@FObj, 0, 0, PANEL_WATER or PANEL_ACID1 or PANEL_ACID2) then
2092       if (FState <> MONSTATE_DIE) and (FState <> MONSTATE_DEAD) then
2093         fall := False;
2094
2095 // Летающие монтсры:
2096   if ((FMonsterType = MONSTER_SOUL) or
2097       (FMonsterType = MONSTER_PAIN) or
2098       (FMonsterType = MONSTER_CACO)) and
2099      (FState <> MONSTATE_DIE) and
2100      (FState <> MONSTATE_DEAD) then
2101     fall := False;
2102
2103 // Меняем скорость только по четным кадрам:
2104   if gTime mod (GAME_TICK*2) <> 0 then
2105   begin
2106     g_Obj_Move(@FObj, fall, True, True);
2107     positionChanged(); // this updates spatial accelerators
2108     Exit;
2109   end;
2110
2111   if FPainTicks > 0 then
2112     Dec(FPainTicks)
2113   else
2114     FPainSound := False;
2115
2116 // Двигаемся:
2117   st := g_Obj_Move(@FObj, fall, True, True);
2118   positionChanged(); // this updates spatial accelerators
2119
2120 // Если горим - поджигаем других монстров, но не на 100 тиков каждый раз:
2121   if FFireTime > 0 then
2122   begin
2123     it := monsGrid.forEachInAABB(FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y, FObj.Rect.Width, FObj.Rect.Height);
2124     for mit in it do
2125       if mit.UID <> FUID then
2126         mit.CatchFire(FFireAttacker, FFireTime);
2127   end;
2128
2129 // Вылетел за карту - удаляем и запускаем триггеры:
2130   if WordBool(st and MOVE_FALLOUT) or (FObj.X < -1000) or
2131      (FObj.X > gMapInfo.Width+1000) or (FObj.Y < -1000) then
2132   begin
2133     FRemoved := True;
2134     if alive and (gLMSRespawn = LMS_RESPAWN_NONE) then
2135     begin
2136       Inc(gCoopMonstersKilled);
2137       if g_Game_IsNet then
2138         MH_SEND_GameStats;
2139     end;
2140     ActivateTriggers();
2141     Exit;
2142   end;
2143
2144   oldvelx := FObj.Vel.X;
2145
2146 // Сопротивление воздуха для трупа:
2147   if (FState = MONSTATE_DIE) or (FState = MONSTATE_DEAD) then
2148     FObj.Vel.X := z_dec(FObj.Vel.X, 1);
2149
2150   if FFireTime > 0 then
2151   begin
2152     if WordBool(st and MOVE_INWATER) then
2153       FFireTime := 0
2154     else
2155     begin
2156       OnFireFlame(1);
2157       FFireTime := FFireTime - 1;
2158       if (FState <> MONSTATE_DIE) and (FState <> MONSTATE_DEAD) then
2159         if FFirePainTime = 0 then
2160         begin
2161           Damage(5, FFireAttacker, 0, 0, HIT_FLAME);
2162           FFirePainTime := 18;
2163         end
2164         else
2165           FFirePainTime := FFirePainTime - 1;
2166     end;
2167   end;
2168
2169 // Мертвый ничего не делает:
2170   if (FState = MONSTATE_DEAD) then
2171     goto _end;
2172
2173 // AI монстров выключен:
2174   if g_debug_MonsterOff then
2175   begin
2176     FSleep := 1;
2177     if FState <> MONSTATE_SLEEP then
2178       SetState(MONSTATE_SLEEP);
2179   end;
2180
2181 // Возможно, создаем пузырьки в воде:
2182   if WordBool(st and MOVE_INWATER) and (Random(32) = 0) then
2183     case FMonsterType of
2184       MONSTER_FISH:
2185       begin
2186         {$IFDEF ENABLE_GFX}
2187           if Random(4) = 0 then
2188           begin
2189             g_GFX_Bubbles(
2190               FObj.X + FObj.Rect.X + Random(FObj.Rect.Width),
2191               FObj.Y + FObj.Rect.Y + Random(4),
2192               1,
2193               0,
2194               0
2195             );
2196           end;
2197         {$ENDIF}
2198       end;
2199       MONSTER_ROBO, MONSTER_BARREL:
2200       begin
2201         {$IFDEF ENABLE_GFX}
2202           g_GFX_Bubbles(
2203             FObj.X + FObj.Rect.X + Random(FObj.Rect.Width),
2204             FObj.Y + FObj.Rect.Y + Random(4),
2205             1,
2206             0,
2207             0
2208           );
2209         {$ENDIF}
2210       end;
2211       else
2212       begin
2213         {$IFDEF ENABLE_GFX}
2214           g_GFX_Bubbles(
2215             FObj.X + FObj.Rect.X + Random(FObj.Rect.Width - 4),
2216             FObj.Y+FObj.Rect.Y + Random(4),
2217             5,
2218             4,
2219             4
2220           );
2221         {$ENDIF}
2222         if Random(2) = 0 then
2223           g_Sound_PlayExAt('SOUND_GAME_BUBBLE1', FObj.X, FObj.Y)
2224         else
2225           g_Sound_PlayExAt('SOUND_GAME_BUBBLE2', FObj.X, FObj.Y);
2226       end;
2227     end;
2228
2229 // Если прошел первый кадр анимации взрыва бочки, то взрыв:
2230   if FMonsterType = MONSTER_BARREL then
2231   begin
2232     if (FState = MONSTATE_DIE) and (FAnim[FCurAnim, FDirection].CurrentFrame = 1) and
2233        (FAnim[FCurAnim, FDirection].Counter = 0) then
2234       g_Weapon_Explode(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
2235                        FObj.Y+FObj.Rect.Y+FObj.Rect.Height-16,
2236                        60, FUID);
2237   end;
2238
2239 // Lost_Soul вылетел из воды => ускоряется:
2240   if FMonsterType = MONSTER_SOUL then
2241     if WordBool(st and MOVE_HITAIR) then
2242       g_Obj_SetSpeed(@FObj, 16);
2243
2244   if FAmmo < 0 then
2245     FAmmo := FAmmo + 1;
2246
2247 // Если начали всплывать, то продолжаем:
2248   if FObj.Vel.Y < 0 then
2249     if WordBool(st and MOVE_INWATER) then
2250       FObj.Vel.Y := -4;
2251
2252 // Таймер - ждем после потери цели:
2253   FTargetTime := FTargetTime + 1;
2254
2255 {$IFDEF ENABLE_SHELLS}
2256   // Гильзы
2257   if FShellTimer > -1 then
2258   begin
2259     if FShellTimer = 0 then
2260     begin
2261       if FShellType = SHELL_SHELL then
2262       begin
2263         g_Shells_Create(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
2264                              FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
2265                              GameVelX, GameVelY-2, SHELL_SHELL)
2266       end
2267       else if FShellType = SHELL_DBLSHELL then
2268       begin
2269         g_Shells_Create(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
2270                              FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
2271                              GameVelX-1, GameVelY-2, SHELL_SHELL);
2272         g_Shells_Create(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
2273                              FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
2274                              GameVelX+1, GameVelY-2, SHELL_SHELL);
2275       end;
2276       FShellTimer := -1;
2277     end
2278     else
2279     begin
2280       Dec(FShellTimer);
2281     end;
2282   end;
2283 {$ENDIF}
2284
2285 // Пробуем увернуться от летящей пули:
2286   if fall then
2287     if (FState in [MONSTATE_GO, MONSTATE_RUN, MONSTATE_RUNOUT,
2288                    MONSTATE_ATTACK, MONSTATE_SHOOT]) then
2289       if g_Weapon_Danger(FUID, FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y,
2290                          FObj.Rect.Width, FObj.Rect.Height, 50) then
2291         if (g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj)) and
2292            (FObj.Accel.Y = 0) then
2293           FObj.Vel.Y := -MONSTERTABLE[FMonsterType].Jump;
2294
2295   case FState of
2296     MONSTATE_PAIN: // Состояние - Боль
2297       begin
2298       // Боль сильная => монстр кричит:
2299         if FPain >= MONSTERTABLE[FMonsterType].Pain then
2300         begin
2301           FPain := MONSTERTABLE[FMonsterType].Pain;
2302           if gSoundEffectsDF then PainSound();
2303         end;
2304         if (not gSoundEffectsDF) and (FPain >= MONSTERTABLE[FMonsterType].MinPain) then
2305           PainSound();
2306
2307       // Снижаем боль со временем:
2308         FPain := FPain - 5;
2309
2310       // Боль уже не ошутимая => идем дальше:
2311         if FPain <= MONSTERTABLE[FMonsterType].MinPain then
2312         begin
2313           FPain := 0;
2314           FAmmo := -9;
2315           SetState(MONSTATE_GO);
2316         end;
2317       end;
2318
2319     MONSTATE_SLEEP: // Состояние - Сон
2320       begin
2321       // Спим:
2322         FSleep := FSleep + 1;
2323
2324       // Проспали достаточно:
2325         if FSleep >= 18 then
2326           FSleep := 0
2327         else // еще спим
2328           goto _end;
2329
2330       // На игроков идут только обычные монстры, киллеры и маньяки
2331         if (FBehaviour = BH_NORMAL) or (FBehaviour = BH_KILLER) or (FBehaviour = BH_MANIAC) then
2332         // Если есть игрок рядом, просыпаемся и идем к нему:
2333           if (gPlayers <> nil) then
2334             for a := 0 to High(gPlayers) do
2335               if (gPlayers[a] <> nil) and (gPlayers[a].alive)
2336               and (not gPlayers[a].NoTarget) and (gPlayers[a].FMegaRulez[MR_INVIS] < gTime) then
2337                 with gPlayers[a] do
2338                   if g_Look(@FObj, @Obj, FDirection) then
2339                   begin
2340                     FTargetUID := gPlayers[a].UID;
2341                     FTargetTime := 0;
2342                     WakeUpSound();
2343                     SetState(MONSTATE_GO);
2344                     Break;
2345                   end;
2346
2347       // На монстров тянет маньяков, поехавших и каннибалов
2348         if (FTargetUID = 0) and ((FBehaviour = BH_MANIAC)
2349         or (FBehaviour = BH_INSANE) or (FBehaviour = BH_CANNIBAL)) then
2350         // Если есть подходящий монстр рядом:
2351           if gMonsters <> nil then
2352             for a := 0 to High(gMonsters) do
2353               if (gMonsters[a] <> nil) and (gMonsters[a].alive) and
2354                  (gMonsters[a].FUID <> FUID) then
2355               begin
2356                 // Маньяки нападают на всех монстров, кроме друзей
2357                 if (FBehaviour = BH_MANIAC) and
2358                 (IsFriend(gMonsters[a].FMonsterType, FMonsterType)) then
2359                   Continue;
2360                 // Поехавшие также, но могут обозлиться на бочку
2361                 if (FBehaviour = BH_INSANE) and (gMonsters[a].FMonsterType <> MONSTER_BARREL) and
2362                 (IsFriend(gMonsters[a].FMonsterType, FMonsterType)) then
2363                   Continue;
2364                 // Каннибалы нападают на себе подобных
2365                 if (FBehaviour = BH_CANNIBAL) and (gMonsters[a].FMonsterType <> FMonsterType) then
2366                   Continue;
2367                 if g_Look(@FObj, @gMonsters[a].Obj, FDirection) then
2368                 begin
2369                   FTargetUID := gMonsters[a].UID;
2370                   FTargetTime := 0;
2371                   WakeUpSound();
2372                   SetState(MONSTATE_GO);
2373                   Break;
2374                 end;
2375               end;
2376       end;
2377
2378     MONSTATE_WAIT: // Состояние - Ожидание
2379       begin
2380       // Ждем:
2381         FSleep := FSleep - 1;
2382
2383       // Выждали достаточно - идем:
2384         if FSleep < 0 then
2385           SetState(MONSTATE_GO);
2386       end;
2387
2388     MONSTATE_GO: // Состояние - Движение (с осмотром ситуации)
2389       begin
2390       // Если наткнулись на БлокМон - убегаем от него:
2391         if WordBool(st and MOVE_BLOCK) then
2392         begin
2393           Turn();
2394           FSleep := 40;
2395           SetState(MONSTATE_RUNOUT);
2396
2397           goto _end;
2398         end;
2399
2400       // Если монстр - колдун, то пробуем воскресить кого-нибудь:
2401         if (FMonsterType = MONSTER_VILE) then
2402           if isCorpse(@FObj, False) <> -1 then
2403           begin
2404             FObj.Vel.X := 0;
2405             SetState(MONSTATE_ATTACK, ANIM_ATTACK2);
2406
2407             goto _end;
2408           end;
2409
2410       // Цель погибла или давно ждем:
2411          if (not GetPos(FTargetUID, @o)) or (FTargetTime > MAX_ATM) then
2412            if not findNewPrey() then
2413              begin // Новых целей нет
2414               FTargetUID := 0;
2415               o.X := FObj.X+pt_x;
2416               o.Y := FObj.Y+pt_y;
2417               o.Vel.X := 0;
2418               o.Vel.Y := 0;
2419               o.Accel.X := 0;
2420               o.Accel.Y := 0;
2421               o.Rect := _Rect(0, 0, 0, 1);
2422              end
2423            else // Новая цель есть - берем ее координаты
2424             GetPos(FTargetUID, @o);
2425
2426       // Цель очень близко - пинаем:
2427         if g_Obj_Collide(@FObj, @o) and (FTargetUID <> 0) then
2428         begin
2429           FTargetTime := 0;
2430           if (FMonsterType <> MONSTER_CYBER) or (Random(2) = 0) then
2431           begin
2432             if kick(@o) then
2433               goto _end;
2434           end;
2435         end;
2436
2437       // Расстояние до цели:
2438         sx := o.X+o.Rect.X+(o.Rect.Width div 2)-(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2));
2439         sy := o.Y+o.Rect.Y+(o.Rect.Height div 2)-(FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2));
2440
2441       // Поворачиваемся в сторону цели:
2442         if sx > 0 then
2443           FDirection := TDirection.D_RIGHT
2444         else
2445           FDirection := TDirection.D_LEFT;
2446
2447       // Если монстр умеет стрелять и есть по кому - стреляем:
2448         if canShoot(FMonsterType) and (FTargetUID <> 0) then
2449           if Abs(sx) > Abs(sy) then // угол выстрела удобный
2450             if shoot(@o, False) then
2451               goto _end;
2452
2453       // Если цель почти на одной вертикали - бегаем туда-сюда:
2454         if Abs(sx) < 40 then
2455           if FMonsterType <> MONSTER_FISH then
2456           begin
2457             FSleep := 15;
2458             SetState(MONSTATE_RUN);
2459             if Random(2) = 0 then
2460               FDirection := TDirection.D_LEFT
2461             else
2462               FDirection := TDirection.D_RIGHT;
2463
2464             goto _end;
2465           end;
2466
2467       // Уперлись в стену:
2468         if WordBool(st and MOVE_HITWALL) then
2469         begin
2470           if g_Triggers_PressR(FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y, FObj.Rect.Width,
2471                                FObj.Rect.Height, FUID, ACTIVATE_MONSTERPRESS) <> nil then
2472           begin // Смогли нажать кнопку - небольшое ожидание
2473             FSleep := 4;
2474             SetState(MONSTATE_WAIT);
2475
2476             goto _end;
2477           end;
2478
2479           case FMonsterType of
2480             MONSTER_CACO, MONSTER_SOUL, MONSTER_PAIN, MONSTER_FISH: ;
2481             else // Не летают:
2482               if (g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj)) and
2483                  (FObj.Accel.Y = 0) then
2484               begin // Стоим на твердом полу или ступени
2485               // Прыжок через стену:
2486                 FObj.Vel.Y := -MONSTERTABLE[FMonsterType].Jump;
2487                 SetState(MONSTATE_CLIMB);
2488               end;
2489           end;
2490
2491           goto _end;
2492         end;
2493
2494       // Монстры, не подверженные гравитации:
2495         if (FMonsterType = MONSTER_CACO) or (FMonsterType = MONSTER_SOUL) or
2496            (FMonsterType = MONSTER_PAIN) or (FMonsterType = MONSTER_FISH) then
2497           begin
2498             if FMonsterType = MONSTER_FISH then
2499               begin // Рыба
2500                 if not WordBool(st and MOVE_INWATER) then
2501                   begin // Рыба вне воды:
2502                     if g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj) then
2503                     begin // "Стоит" твердо
2504                     // Рыба трепыхается на поверхности:
2505                       if FObj.Accel.Y = 0 then FObj.Vel.Y := -6;
2506                       FObj.Accel.X := FObj.Accel.X - 8 + Random(17);
2507                     end;
2508
2509                   // Рыбе больно:
2510                     SetState(MONSTATE_PAIN);
2511                     FPain := FPain + 50;
2512                   end
2513                 else // Рыба в воде
2514                   begin
2515                   // Плывем в сторону цели по-вертикали:
2516                     if Abs(sy) > 8 then
2517                       FObj.Vel.Y := g_basic.Sign(sy)*4
2518                     else
2519                       FObj.Vel.Y := 0;
2520
2521                   // Рыба плывет вверх:
2522                     if FObj.Vel.Y < 0 then
2523                       if not g_Obj_CollideLiquid(@FObj, 0, -16) then
2524                       begin
2525                       // Всплыли до поверхности - стоп:
2526                         FObj.Vel.Y := 0;
2527                       // Плаваем туда-сюда:
2528                         if Random(2) = 0 then
2529                           FDirection := TDirection.D_LEFT
2530                         else
2531                           FDirection := TDirection.D_RIGHT;
2532                         FSleep := 20;
2533                         SetState(MONSTATE_RUN);
2534                       end;
2535                    end;
2536               end
2537             else // Летающие монстры
2538               begin
2539               // Летим в сторону цели по-вертикали:
2540                 if Abs(sy) > 8 then
2541                   FObj.Vel.Y := g_basic.Sign(sy)*4
2542                 else
2543                   FObj.Vel.Y := 0;
2544               end;
2545           end
2546         else // "Наземные" монстры
2547           begin
2548             {$IFDEF ENABLE_GIBS}
2549               // Возможно, пинаем куски:
2550               if (FObj.Vel.X <> 0) and (gGibs <> nil) then
2551               begin
2552                 b := Abs(FObj.Vel.X);
2553                 if b > 1 then b := b * (Random(8 div b) + 1);
2554                 for a := 0 to High(gGibs) do
2555                 begin
2556                   if gGibs[a].alive and
2557                      g_Obj_Collide(FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y+FObj.Rect.Height-4,
2558                                    FObj.Rect.Width, 8, @gGibs[a].Obj) and (Random(3) = 0) then
2559                   begin
2560                     // Пинаем куски
2561                     if FObj.Vel.X < 0 then
2562                     begin
2563                       g_Obj_PushA(@gGibs[a].Obj, b, Random(61)+120); // налево
2564                     end
2565                     else
2566                     begin
2567                       g_Obj_PushA(@gGibs[a].Obj, b, Random(61));    // направо
2568                     end;
2569                   end;
2570                 end;
2571               end;
2572             {$ENDIF}
2573           // Боссы могут пинать трупы:
2574             if (FMonsterType in [MONSTER_CYBER, MONSTER_SPIDER, MONSTER_ROBO]) and
2575                (FObj.Vel.X <> 0) and (gCorpses <> nil) then
2576             begin
2577               b := Abs(FObj.Vel.X);
2578               if b > 1 then b := b * (Random(8 div b) + 1);
2579               for a := 0 to High(gCorpses) do
2580                 if (gCorpses[a] <> nil) and (gCorpses[a].State > 0) then
2581                 begin
2582                   co := gCorpses[a].Obj;
2583                   if g_Obj_Collide(FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y+FObj.Rect.Height-4,
2584                                    FObj.Rect.Width, 8, @co) and (Random(3) = 0) then
2585                     // Пинаем трупы
2586                     if FObj.Vel.X < 0 then
2587                       gCorpses[a].Damage(b*2, FUID, -b, Random(7)) // налево
2588                     else
2589                       gCorpses[a].Damage(b*2, FUID, b, Random(7)); // направо
2590                 end;
2591             end;
2592           // Если цель высоко, то, возможно, прыгаем:
2593             if sy < -40 then
2594               if g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj) then
2595               // стоит твердо
2596                 if (Random(4) = 0) and (FObj.Accel.Y = 0) then
2597                   FObj.Vel.Y := -MONSTERTABLE[FMonsterType].Jump;
2598           end;
2599
2600         FSleep := FSleep + 1;
2601
2602       // Иногда рычим:
2603         if FSleep >= 8 then
2604         begin
2605           FSleep := 0;
2606           if Random(8) = 0 then
2607             ActionSound();
2608         end;
2609
2610       // Бежим в выбранную сторону:
2611         if FDirection = TDirection.D_RIGHT then
2612           FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
2613         else
2614           FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
2615
2616       // Если в воде, то замедляемся:
2617         if WordBool(st and MOVE_INWATER) then
2618           FObj.Vel.X := FObj.Vel.X div 2
2619         else // Рыбам не нужно замедляться
2620           if FMonsterType = MONSTER_FISH then
2621             FObj.Vel.X := 0;
2622       end;
2623
2624     MONSTATE_RUN: // Состояние - Бег
2625       begin
2626       // Если наткнулись на БлокМон - убегаем от него:
2627         if WordBool(st and MOVE_BLOCK) then
2628         begin
2629           Turn();
2630           FSleep := 40;
2631           SetState(MONSTATE_RUNOUT);
2632
2633           goto _end;
2634         end;
2635
2636         FSleep := FSleep - 1;
2637
2638       // Пробежали достаточно или врезались в стену => переходим на шаг:
2639         if (FSleep <= 0) or (WordBool(st and MOVE_HITWALL) and ((FObj.Vel.Y+FObj.Accel.Y) = 0)) then
2640         begin
2641           FSleep := 0;
2642           SetState(MONSTATE_GO);
2643         // Стена - идем обратно:
2644           if WordBool(st and (MOVE_HITWALL or MOVE_BLOCK)) then
2645             Turn();
2646         // Иногда рычим:
2647           if Random(8) = 0 then
2648             ActionSound();
2649         end;
2650
2651       // Бежим в выбранную сторону:
2652         if FDirection = TDirection.D_RIGHT then
2653           FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
2654         else
2655           FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
2656
2657       // Если в воде, то замедляемся:
2658         if WordBool(st and MOVE_INWATER) then
2659           FObj.Vel.X := FObj.Vel.X div 2
2660         else // Рыбам не нужно замедляться
2661           if FMonsterType = MONSTER_FISH then
2662             FObj.Vel.X := 0;
2663       end;
2664
2665     MONSTATE_RUNOUT: // Состояние - Убегает от чего-то
2666       begin
2667       // Вышли из БлокМона:
2668         if (not WordBool(st and MOVE_BLOCK)) and (FSleep > 0) then
2669           FSleep := 0;
2670
2671         FSleep := FSleep - 1;
2672
2673       // Убажели достаточно далеко => переходим на шаг:
2674         if FSleep <= -18 then
2675         begin
2676           FSleep := 0;
2677           SetState(MONSTATE_GO);
2678         // Стена/БлокМон - идем обратно:
2679           if WordBool(st and (MOVE_HITWALL or MOVE_BLOCK)) then
2680             Turn();
2681         // Иногда рычим:
2682           if Random(8) = 0 then
2683             ActionSound();
2684         end;
2685
2686       // Бежим в выбранную сторону:
2687         if FDirection = TDirection.D_RIGHT then
2688           FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
2689         else
2690           FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
2691
2692       // Если в воде, то замедляемся:
2693         if WordBool(st and MOVE_INWATER) then
2694           FObj.Vel.X := FObj.Vel.X div 2
2695         else // Рыбам не нужно замедляться
2696           if FMonsterType = MONSTER_FISH then
2697             FObj.Vel.X := 0;
2698       end;
2699
2700     MONSTATE_CLIMB: // Состояние - Прыжок (чтобы обойти стену)
2701       begin
2702       // Достигли высшей точки прыжка или стена кончилась => переходим на шаг:
2703         if ((FObj.Vel.Y+FObj.Accel.Y) >= 0) or
2704            (not WordBool(st and MOVE_HITWALL)) then
2705         begin
2706           FSleep := 0;
2707           SetState(MONSTATE_GO);
2708
2709         // Стена не кончилась => бежим от нее:
2710           if WordBool(st and (MOVE_HITWALL or MOVE_BLOCK)) then
2711           begin
2712             Turn();
2713             FSleep := 15;
2714             SetState(MONSTATE_RUN);
2715           end;
2716         end;
2717
2718       // Бежим в выбранную сторону:
2719         if FDirection = TDirection.D_RIGHT then
2720           FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
2721         else
2722           FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
2723
2724       // Если в воде, то замедляемся:
2725         if WordBool(st and MOVE_INWATER) then
2726           FObj.Vel.X := FObj.Vel.X div 2
2727         else // Рыбам не нужно замедляться
2728           if FMonsterType = MONSTER_FISH then
2729             FObj.Vel.X := 0;
2730       end;
2731
2732     MONSTATE_ATTACK, // Состояние - Атака
2733     MONSTATE_SHOOT:  // Состояние - Стрельба
2734       begin
2735       // Lost_Soul врезался в стену при атаке => переходит на шаг:
2736         if FMonsterType = MONSTER_SOUL then
2737         begin
2738           if WordBool(st and (MOVE_HITWALL or MOVE_HITCEIL or MOVE_HITLAND)) then
2739             SetState(MONSTATE_GO);
2740
2741           goto _end;
2742         end;
2743
2744       // Замедляемся при атаке:
2745         if FMonsterType <> MONSTER_FISH then
2746           FObj.Vel.X := z_dec(FObj.Vel.X, 1);
2747
2748       // Нужно стрелять, а монстр - колдун:
2749         if (FMonsterType = MONSTER_VILE) and (FState = MONSTATE_SHOOT) then
2750         begin
2751         // Цель погибла => идем дальше:
2752           if not GetPos(FTargetUID, @o) then
2753           begin
2754             SetState(MONSTATE_GO);
2755
2756             goto _end;
2757           end;
2758
2759         // Цель не видно => идем дальше:
2760           if not g_Look(@FObj, @o, FDirection) then
2761           begin
2762             SetState(MONSTATE_GO);
2763
2764             goto _end;
2765           end;
2766
2767         // Цель в воде - не загорится => идем дальше:
2768           if g_Obj_CollideWater(@o, 0, 0) then
2769           begin
2770             SetState(MONSTATE_GO);
2771
2772             goto _end;
2773           end;
2774
2775         // Жарим цель:
2776           tx := o.X+o.Rect.X+(o.Rect.Width div 2);
2777           ty := o.Y+o.Rect.Y+(o.Rect.Height div 2);
2778           g_Weapon_HitUID(FTargetUID, 2, FUID, HIT_SOME);
2779         end;
2780       end;
2781   end; // case FState of ...
2782
2783 _end:
2784
2785 // Состояние - Воскрешение:
2786   if FState = MONSTATE_REVIVE then
2787     if FAnim[FCurAnim, FDirection].Played then
2788     begin // Обратная анимация умирания закончилась - идем дальше:
2789       FAnim[FCurAnim, FDirection].Revert(False);
2790       SetState(MONSTATE_GO);
2791     end;
2792
2793 // Если есть анимация огня колдуна - пусть она идет:
2794   if vilefire <> nil then
2795     vilefire.Update();
2796
2797 // Состояние - Умирает и текущая анимация проиграна:
2798   if (FState = MONSTATE_DIE) and
2799      (FAnim[FCurAnim, FDirection] <> nil) and
2800      (FAnim[FCurAnim, FDirection].Played) then
2801     begin
2802     // Умер:
2803       SetState(MONSTATE_DEAD);
2804
2805     // Pain_Elemental при смерти выпускает 3 Lost_Soul'а:
2806       if (FMonsterType = MONSTER_PAIN) then
2807       begin
2808         mon := g_Monsters_Create(MONSTER_SOUL, FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2)-30,
2809                                  FObj.Y+FObj.Rect.Y+20, TDirection.D_LEFT);
2810         if mon <> nil then
2811         begin
2812           mon.SetState(MONSTATE_GO);
2813           mon.FNoRespawn := True;
2814           Inc(gTotalMonsters);
2815           if g_Game_IsNet then MH_SEND_MonsterSpawn(mon.UID);
2816         end;
2817
2818         mon := g_Monsters_Create(MONSTER_SOUL, FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
2819                                  FObj.Y+FObj.Rect.Y+20, TDirection.D_RIGHT);
2820         if mon <> nil then
2821         begin
2822           mon.SetState(MONSTATE_GO);
2823           mon.FNoRespawn := True;
2824           Inc(gTotalMonsters);
2825           if g_Game_IsNet then MH_SEND_MonsterSpawn(mon.UID);
2826         end;
2827
2828         mon := g_Monsters_Create(MONSTER_SOUL, FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2)-15,
2829                                  FObj.Y+FObj.Rect.Y, TDirection.D_RIGHT);
2830         if mon <> nil then
2831         begin
2832           mon.SetState(MONSTATE_GO);
2833           mon.FNoRespawn := True;
2834           Inc(gTotalMonsters);
2835           if g_Game_IsNet then MH_SEND_MonsterSpawn(mon.UID);
2836         end;
2837
2838         if g_Game_IsNet then MH_SEND_CoopStats();
2839       end;
2840
2841     // У этих монстров нет трупов:
2842       if (FMonsterType = MONSTER_PAIN) or
2843          (FMonsterType = MONSTER_SOUL) or
2844          (FMonsterType = MONSTER_BARREL) then
2845         FRemoved := True;
2846     end;
2847
2848 // Совершение атаки и стрельбы:
2849   if (FState = MONSTATE_ATTACK) or (FState = MONSTATE_SHOOT) then
2850     if (FAnim[FCurAnim, FDirection] <> nil) then
2851     // Анимация атаки есть - можно атаковать
2852       if (FAnim[FCurAnim, FDirection].Played) then
2853         begin // Анимация атаки закончилась => переходим на шаг
2854           if FState = MONSTATE_ATTACK then
2855             begin // Состояние - Атака
2856             // Если монстр не Lost_Soul, то после атаки переходим на шаг:
2857               if FMonsterType <> MONSTER_SOUL then
2858                 SetState(MONSTATE_GO);
2859             end
2860           else // Состояние - Стрельба
2861             begin
2862             // Переходим на шаг, если не надо стрелять еще раз:
2863               if not FChainFire then
2864                 SetState(MONSTATE_GO)
2865               else
2866                 begin // Надо стрелять еще
2867                   FChainFire := False;
2868                 // Т.к. состояние не изменилось, и нужен
2869                 // новый цикл ожидания завершения анимации:
2870                   FAnim[FCurAnim, FDirection].Reset();
2871                 end;
2872             end;
2873
2874           FWaitAttackAnim := False;
2875         end
2876
2877       else // Анимация атаки еще идет (исключение - Lost_Soul):
2878         if (FMonsterType = MONSTER_SOUL) or
2879            ( (not FWaitAttackAnim) and
2880              (FAnim[FCurAnim, FDirection].CurrentFrame =
2881               (FAnim[FCurAnim, FDirection].TotalFrames div 2))
2882            ) then
2883         begin // Атаки еще не было и это середина анимации атаки
2884           if FState = MONSTATE_ATTACK then
2885             begin // Состояние - Атака
2886             // Если это Lost_Soul, то сбрасываем анимацию атаки:
2887               if FMonsterType = MONSTER_SOUL then
2888                 FAnim[FCurAnim, FDirection].Reset();
2889
2890               case FMonsterType of
2891                 MONSTER_SOUL, MONSTER_IMP, MONSTER_DEMON:
2892                 // Грызем первого попавшегося:
2893                   if g_Weapon_Hit(@FObj, 15, FUID, HIT_SOME) <> 0 then
2894                   // Lost_Soul укусил кого-то => переходит на шаг:
2895                     if FMonsterType = MONSTER_SOUL then
2896                       SetState(MONSTATE_GO);
2897
2898                 MONSTER_FISH:
2899                 // Рыба кусает первого попавшегося со звуком:
2900                   if g_Weapon_Hit(@FObj, 10, FUID, HIT_SOME) <> 0 then
2901                     g_Sound_PlayExAt('SOUND_MONSTER_FISH_ATTACK', FObj.X, FObj.Y);
2902
2903                 MONSTER_SKEL, MONSTER_ROBO, MONSTER_CYBER:
2904                 // Робот, кибер или скелет сильно пинаются:
2905                   if FCurAnim = ANIM_ATTACK2 then
2906                   begin
2907                     o := FObj;
2908                     o.Vel.X := IfThen(FDirection = TDirection.D_RIGHT, 1, -1)*IfThen(FMonsterType = MONSTER_CYBER, 60, 50);
2909                     if g_Weapon_Hit(@o, IfThen(FMonsterType = MONSTER_CYBER, 33, 50), FUID, HIT_SOME) <> 0 then
2910                       g_Sound_PlayExAt('SOUND_MONSTER_SKEL_HIT', FObj.X, FObj.Y);
2911                   end;
2912
2913                 MONSTER_VILE:
2914                 // Колдун пытается воскрешать:
2915                   if FCurAnim = ANIM_ATTACK2 then
2916                   begin
2917                     sx := isCorpse(@FObj, True);
2918                     if sx <> -1 then
2919                     begin // Нашли, кого воскресить
2920                       gMonsters[sx].SetState(MONSTATE_REVIVE);
2921                       g_Sound_PlayExAt('SOUND_MONSTER_SLOP', FObj.X, FObj.Y);
2922                     // Воскрешать - себе вредить:
2923                       {g_Weapon_HitUID(FUID, 5, 0, HIT_SOME);}
2924                     end;
2925                   end;
2926               end;
2927             end
2928
2929           else // Состояние - Стрельба
2930             begin
2931             // Вычисляем координаты, откуда вылетит пуля:
2932               wx := MONSTER_ANIMTABLE[FMonsterType].wX;
2933
2934               if FDirection = TDirection.D_LEFT then
2935               begin
2936                 wx := MONSTER_ANIMTABLE[FMonsterType].wX-(MONSTERTABLE[FMonsterType].Rect.X+(MONSTERTABLE[FMonsterType].Rect.Width div 2));
2937                 wx := MONSTERTABLE[FMonsterType].Rect.X+(MONSTERTABLE[FMonsterType].Rect.Width div 2)-wx;
2938               end; // Это значит: wx := hitX + (hitWidth / 2) - (wx - (hitX + (hitWidth / 2)))
2939
2940               wx := FObj.X + wx;
2941               wy := FObj.Y + MONSTER_ANIMTABLE[FMonsterType].wY;
2942
2943             // Монстр не может целиться в объект за спиной, стреляя влево:
2944               if (FDirection = TDirection.D_LEFT) and (tx > wx) then
2945               begin
2946                 tx := wx - 32;
2947                 ty := wy + Random(11) - 5;
2948               end;
2949             // И аналогично, стреляя вправо:
2950               if (FDirection = TDirection.D_RIGHT) and (tx < wx) then
2951               begin
2952                 tx := wx + 32;
2953                 ty := wy + Random(11) - 5;
2954               end;
2955
2956             // Делаем выстрел нужным оружием:
2957               case FMonsterType of
2958                 MONSTER_IMP:
2959                   g_Weapon_ball1(wx, wy, tx, ty, FUID);
2960                 MONSTER_ZOMBY:
2961                   begin
2962                     g_Sound_PlayExAt('SOUND_WEAPON_FIREPISTOL', wx, wy);
2963                     g_Weapon_gun(wx, wy, tx, ty, 1, 3, FUID, True);
2964                     {$IFDEF ENABLE_SHELLS}
2965                       g_Shells_Create(wx, wy, 0, -2, SHELL_BULLET);
2966                     {$ENDIF}
2967                   end;
2968                 MONSTER_SERG:
2969                   begin
2970                     g_Weapon_shotgun(wx, wy, tx, ty, FUID);
2971                     if not gSoundEffectsDF then g_Sound_PlayExAt('SOUND_WEAPON_FIRESHOTGUN', wx, wy);
2972                     {$IFDEF ENABLE_SHELLS}
2973                       FShellTimer := 10;
2974                       FShellType := SHELL_SHELL;
2975                     {$ENDIF}
2976                   end;
2977                 MONSTER_MAN:
2978                   begin
2979                     g_Weapon_dshotgun(wx, wy, tx, ty, FUID);
2980                     {$IFDEF ENABLE_SHELLS}
2981                       FShellTimer := 13;
2982                       FShellType := SHELL_DBLSHELL;
2983                     {$ENDIF}
2984                     FAmmo := -36;
2985                   end;
2986                 MONSTER_CYBER:
2987                 begin
2988                   g_Weapon_rocket(wx, wy, tx, ty, FUID);
2989                   // MH_SEND_MonsterAttack(FUID, wx, wy, tx, ty);
2990                 end;
2991                 MONSTER_SKEL:
2992                   g_Weapon_revf(wx, wy, tx, ty, FUID, FTargetUID);
2993                 MONSTER_CGUN:
2994                   begin
2995                     g_Weapon_mgun(wx, wy, tx, ty, FUID);
2996                     if not gSoundEffectsDF then g_Sound_PlayExAt('SOUND_WEAPON_FIRECGUN', wx, wy);
2997                     {$IFDEF ENABLE_SHELLS}
2998                       g_Shells_Create(wx, wy, 0, -2, SHELL_BULLET);
2999                     {$ENDIF}
3000                   end;
3001                 MONSTER_SPIDER:
3002                   begin
3003                     g_Weapon_mgun(wx, wy, tx, ty, FUID);
3004                     if not gSoundEffectsDF then g_Sound_PlayExAt('SOUND_WEAPON_FIRECGUN', wx, wy);
3005                     {$IFDEF ENABLE_SHELLS}
3006                       g_Shells_Create(wx, wy, 0, -2, SHELL_SHELL);
3007                     {$ENDIF}
3008                   end;
3009                 MONSTER_BSP:
3010                   g_Weapon_aplasma(wx, wy, tx, ty, FUID);
3011                 MONSTER_ROBO:
3012                   g_Weapon_plasma(wx, wy, tx, ty, FUID);
3013                 MONSTER_MANCUB:
3014                   g_Weapon_manfire(wx, wy, tx, ty, FUID);
3015                 MONSTER_BARON, MONSTER_KNIGHT:
3016                   g_Weapon_ball7(wx, wy, tx, ty, FUID);
3017                 MONSTER_CACO:
3018                   g_Weapon_ball2(wx, wy, tx, ty, FUID);
3019                 MONSTER_PAIN:
3020                   begin // Создаем Lost_Soul:
3021                     mon := g_Monsters_Create(MONSTER_SOUL, FObj.X+(FObj.Rect.Width div 2),
3022                                              FObj.Y+FObj.Rect.Y, FDirection);
3023
3024                     if mon <> nil then
3025                     begin // Цель - цель Pain_Elemental'а. Летим к ней:
3026                       mon.FTargetUID := FTargetUID;
3027                       GetPos(FTargetUID, @o);
3028                       mon.FTargetTime := 0;
3029                       mon.FNoRespawn := True;
3030                       mon.SetState(MONSTATE_GO);
3031                       mon.shoot(@o, True);
3032                       Inc(gTotalMonsters);
3033
3034                       if g_Game_IsNet then MH_SEND_MonsterSpawn(mon.UID);
3035                     end;
3036                   end;
3037               end;
3038
3039               if FMonsterType <> MONSTER_PAIN then
3040                 if g_Game_IsNet then
3041                   MH_SEND_MonsterShot(FUID, wx, wy, tx, ty);
3042
3043             // Скорострельные монстры:
3044               if (FMonsterType = MONSTER_CGUN) or
3045                  (FMonsterType = MONSTER_SPIDER) or
3046                  (FMonsterType = MONSTER_BSP) or
3047                  (FMonsterType = MONSTER_MANCUB) or
3048                  (FMonsterType = MONSTER_ROBO) then
3049                 if not GetPos(FTargetUID, @o) then
3050                 // Цель мертва - ищем новую:
3051                   findNewPrey()
3052                 else // Цель жива - продолжаем стрелять:
3053                   if shoot(@o, False) then
3054                     FChainFire := True;
3055             end;
3056
3057         // Атака только 1 раз за анимацию атаки:
3058           FWaitAttackAnim := True;
3059         end;
3060
3061 // Последний кадр текущей анимации:
3062   if FAnim[FCurAnim, FDirection].Counter = FAnim[FCurAnim, FDirection].Speed-1 then
3063     case FState of
3064       MONSTATE_GO, MONSTATE_RUN, MONSTATE_CLIMB, MONSTATE_RUNOUT:
3065       // Звуки при передвижении:
3066         case FMonsterType of
3067           MONSTER_CYBER:
3068             if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3069                (FAnim[FCurAnim, FDirection].CurrentFrame = 2) then
3070               g_Sound_PlayExAt('SOUND_MONSTER_CYBER_WALK', FObj.X, FObj.Y);
3071           MONSTER_SPIDER:
3072             if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3073                (FAnim[FCurAnim, FDirection].CurrentFrame = 2) then
3074               g_Sound_PlayExAt('SOUND_MONSTER_SPIDER_WALK', FObj.X, FObj.Y);
3075           MONSTER_BSP:
3076             if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3077                (FAnim[FCurAnim, FDirection].CurrentFrame = 2) then
3078               g_Sound_PlayExAt('SOUND_MONSTER_BSP_WALK', FObj.X, FObj.Y);
3079           MONSTER_ROBO:
3080             if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3081                (FAnim[FCurAnim, FDirection].CurrentFrame = 5) then
3082               g_Sound_PlayExAt('SOUND_MONSTER_BSP_WALK', FObj.X, FObj.Y);
3083         end;
3084     end;
3085
3086   if g_Obj_CollidePanel(@FObj, 0, 0, PANEL_LIFTLEFT or PANEL_LIFTRIGHT) and
3087      not ((FState = MONSTATE_DEAD) or (FState = MONSTATE_DIE))  then
3088     FObj.Vel.X := oldvelx;
3089
3090 // Если есть анимация, то пусть она идет:
3091   if FAnim[FCurAnim, FDirection] <> nil then
3092     FAnim[FCurAnim, FDirection].Update();
3093 end;
3094
3095 procedure TMonster.SetDeadAnim;
3096 begin
3097   if FAnim <> nil then
3098     FAnim[FCurAnim, FDirection].CurrentFrame := FAnim[FCurAnim, FDirection].TotalFrames - 1;
3099 end;
3100
3101 procedure TMonster.RevertAnim(R: Boolean = True);
3102 begin
3103   if FAnim <> nil then
3104     if FAnim[FCurAnim, FDirection].IsReverse <> R then
3105       FAnim[FCurAnim, FDirection].Revert(R);
3106 end;
3107
3108 function TMonster.AnimIsReverse: Boolean;
3109 begin
3110   if FAnim <> nil then
3111     Result := FAnim[FCurAnim, FDirection].IsReverse
3112   else
3113     Result := False;
3114 end;
3115
3116 procedure TMonster.ClientUpdate();
3117 var
3118   a, b, sx, sy, oldvelx: Integer;
3119   st: Word;
3120   o, co: TObj;
3121   fall: Boolean;
3122 label
3123   _end;
3124 begin
3125   sx := 0; // SHUT UP COMPILER
3126   sy := 0;
3127   fall := True;
3128
3129 // Монстр статичен пока идет warmup
3130   if (gLMSRespawn > LMS_RESPAWN_NONE) then exit;
3131
3132 // Рыбы "летают" только в воде:
3133   if FMonsterType = MONSTER_FISH then
3134     if g_Obj_CollidePanel(@FObj, 0, 0, PANEL_WATER or PANEL_ACID1 or PANEL_ACID2) then
3135       if (FState <> MONSTATE_DIE) and (FState <> MONSTATE_DEAD) then
3136         fall := False;
3137
3138 // Летающие монтсры:
3139   if ((FMonsterType = MONSTER_SOUL) or
3140       (FMonsterType = MONSTER_PAIN) or
3141       (FMonsterType = MONSTER_CACO)) and
3142      (FState <> MONSTATE_DIE) and
3143      (FState <> MONSTATE_DEAD) then
3144     fall := False;
3145
3146 // Меняем скорость только по четным кадрам:
3147   if gTime mod (GAME_TICK*2) <> 0 then
3148   begin
3149     g_Obj_Move(@FObj, fall, True, True);
3150     positionChanged(); // this updates spatial accelerators
3151     Exit;
3152   end;
3153
3154   if FPainTicks > 0 then
3155     Dec(FPainTicks)
3156   else
3157     FPainSound := False;
3158
3159 // Двигаемся:
3160   st := g_Obj_Move(@FObj, fall, True, True);
3161   positionChanged(); // this updates spatial accelerators
3162
3163 // Вылетел за карту - удаляем и запускаем триггеры:
3164   if WordBool(st and MOVE_FALLOUT) or (FObj.X < -1000) or
3165      (FObj.X > gMapInfo.Width+1000) or (FObj.Y < -1000) then
3166   begin
3167     FRemoved := True;
3168     Exit;
3169   end;
3170
3171   oldvelx := FObj.Vel.X;
3172
3173 // Сопротивление воздуха для трупа:
3174   if (FState = MONSTATE_DIE) or (FState = MONSTATE_DEAD) then
3175     FObj.Vel.X := z_dec(FObj.Vel.X, 1);
3176
3177   if FFireTime > 0 then
3178   begin
3179     if WordBool(st and MOVE_INWATER) then
3180       FFireTime := 0
3181     else
3182     begin
3183       OnFireFlame(1);
3184       FFireTime := FFireTime - 1;
3185     end;
3186   end;
3187
3188 // Мертвый ничего не делает:
3189   if (FState = MONSTATE_DEAD) then
3190     goto _end;
3191
3192 // Возможно, создаем пузырьки в воде:
3193   if WordBool(st and MOVE_INWATER) and (Random(32) = 0) then
3194     case FMonsterType of
3195       MONSTER_FISH:
3196       begin
3197         {$IFDEF ENABLE_GFX}
3198           if Random(4) = 0 then
3199           begin
3200             g_GFX_Bubbles(
3201               FObj.X + FObj.Rect.X + Random(FObj.Rect.Width),
3202               FObj.Y + FObj.Rect.Y + Random(4),
3203               1,
3204               0,
3205               0
3206             );
3207           end;
3208         {$ENDIF}
3209       end;
3210       MONSTER_ROBO, MONSTER_BARREL:
3211       begin
3212         {$IFDEF ENABLE_GFX}
3213           g_GFX_Bubbles(
3214             FObj.X + FObj.Rect.X + Random(FObj.Rect.Width),
3215             FObj.Y + FObj.Rect.Y + Random(4),
3216             1,
3217             0,
3218             0
3219           );
3220         {$ENDIF}
3221       end;
3222       else
3223       begin
3224         {$IFDEF ENABLE_GFX}
3225           g_GFX_Bubbles(
3226             FObj.X + FObj.Rect.X + Random(FObj.Rect.Width - 4),
3227             FObj.Y + FObj.Rect.Y + Random(4),
3228             5,
3229             4,
3230             4
3231           );
3232         {$ENDIF}
3233         if Random(2) = 0 then
3234           g_Sound_PlayExAt('SOUND_GAME_BUBBLE1', FObj.X, FObj.Y)
3235         else
3236           g_Sound_PlayExAt('SOUND_GAME_BUBBLE2', FObj.X, FObj.Y);
3237       end;
3238     end;
3239
3240 // Если прошел первый кадр анимации взрыва бочки, то взрыв:
3241   if FMonsterType = MONSTER_BARREL then
3242   begin
3243     if (FState = MONSTATE_DIE) and (FAnim[FCurAnim, FDirection].CurrentFrame = 1) and
3244        (FAnim[FCurAnim, FDirection].Counter = 0) then
3245       g_Weapon_Explode(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
3246                        FObj.Y+FObj.Rect.Y+FObj.Rect.Height-16,
3247                        60, FUID);
3248   end;
3249
3250 // Lost_Soul вылетел из воды => ускоряется:
3251   if FMonsterType = MONSTER_SOUL then
3252     if WordBool(st and MOVE_HITAIR) then
3253       g_Obj_SetSpeed(@FObj, 16);
3254
3255   if FAmmo < 0 then
3256     FAmmo := FAmmo + 1;
3257
3258 // Если начали всплывать, то продолжаем:
3259   if FObj.Vel.Y < 0 then
3260     if WordBool(st and MOVE_INWATER) then
3261       FObj.Vel.Y := -4;
3262
3263 // Таймер - ждем после потери цели:
3264   FTargetTime := FTargetTime + 1;
3265
3266 {$IFDEF ENABLE_SHELLS}
3267   if FShellTimer > -1 then
3268   begin
3269     if FShellTimer = 0 then
3270     begin
3271       if FShellType = SHELL_SHELL then
3272       begin
3273         g_Shells_Create(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
3274                              FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
3275                              GameVelX, GameVelY-2, SHELL_SHELL)
3276       end
3277       else if FShellType = SHELL_DBLSHELL then
3278       begin
3279         g_Shells_Create(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
3280                              FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
3281                              GameVelX-1, GameVelY-2, SHELL_SHELL);
3282         g_Shells_Create(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
3283                              FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
3284                              GameVelX+1, GameVelY-2, SHELL_SHELL);
3285       end;
3286       FShellTimer := -1;
3287     end
3288     else
3289     begin
3290       Dec(FShellTimer);
3291     end;
3292   end;
3293 {$ENDIF}
3294
3295 // Пробуем увернуться от летящей пули:
3296   if fall then
3297     if (FState in [MONSTATE_GO, MONSTATE_RUN, MONSTATE_RUNOUT,
3298                    MONSTATE_ATTACK, MONSTATE_SHOOT]) then
3299       if g_Weapon_Danger(FUID, FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y,
3300                          FObj.Rect.Width, FObj.Rect.Height, 50) then
3301         if (g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj)) and
3302            (FObj.Accel.Y = 0) then
3303           FObj.Vel.Y := -MONSTERTABLE[FMonsterType].Jump;
3304
3305   case FState of
3306     MONSTATE_PAIN: // Состояние - Боль
3307       begin
3308       // Боль сильная => монстр кричит:
3309         if FPain >= MONSTERTABLE[FMonsterType].Pain then
3310         begin
3311           FPain := MONSTERTABLE[FMonsterType].Pain;
3312           if gSoundEffectsDF then PainSound();
3313         end;
3314         if (not gSoundEffectsDF) and (FPain >= MONSTERTABLE[FMonsterType].MinPain) then
3315           PainSound();
3316
3317       // Снижаем боль со временем:
3318         FPain := FPain - 5;
3319
3320       // Боль уже не ошутимая => идем дальше:
3321         if FPain <= MONSTERTABLE[FMonsterType].MinPain then
3322         begin
3323           SetState(MONSTATE_GO);
3324           FPain := 0;
3325         end;
3326       end;
3327
3328     MONSTATE_SLEEP: // Состояние - Сон
3329       begin
3330       // Спим:
3331         FSleep := FSleep + 1;
3332
3333       // Проспали достаточно:
3334         if FSleep >= 18 then
3335           FSleep := 0
3336         else // еще спим
3337           goto _end;
3338       end;
3339
3340     MONSTATE_WAIT: // Состояние - Ожидание
3341       begin
3342       // Ждем:
3343         FSleep := FSleep - 1;
3344       end;
3345
3346     MONSTATE_GO: // Состояние - Движение (с осмотром ситуации)
3347       begin
3348       // Если наткнулись на БлокМон - убегаем от него:
3349         if WordBool(st and MOVE_BLOCK) then
3350         begin
3351           Turn();
3352           FSleep := 40;
3353           SetState(MONSTATE_RUNOUT);
3354
3355           goto _end;
3356         end;
3357
3358       // Если монстр - колдун, то пробуем воскресить кого-нибудь:
3359         if (FMonsterType = MONSTER_VILE) then
3360           if isCorpse(@FObj, False) <> -1 then
3361           begin
3362             SetState(MONSTATE_ATTACK, ANIM_ATTACK2);
3363             FObj.Vel.X := 0;
3364
3365             goto _end;
3366           end;
3367
3368       // Если цель почти на одной вертикали - бегаем туда-сюда:
3369         if Abs(sx) < 40 then
3370           if FMonsterType <> MONSTER_FISH then
3371           begin
3372             SetState(MONSTATE_RUN);
3373             FSleep := 15;
3374
3375             goto _end;
3376           end;
3377
3378       // Уперлись в стену:
3379         if WordBool(st and MOVE_HITWALL) then
3380         begin
3381           case FMonsterType of
3382             MONSTER_CACO, MONSTER_SOUL, MONSTER_PAIN, MONSTER_FISH: ;
3383             else // Не летают:
3384               if (g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj)) and
3385                  (FObj.Accel.Y = 0) then
3386               begin // Стоим на твердом полу или ступени
3387               // Прыжок через стену:
3388                 FObj.Vel.Y := -MONSTERTABLE[FMonsterType].Jump;
3389                 SetState(MONSTATE_CLIMB);
3390               end;
3391           end;
3392
3393           goto _end;
3394         end;
3395
3396       // Монстры, не подверженные гравитации:
3397         if (FMonsterType = MONSTER_CACO) or (FMonsterType = MONSTER_SOUL) or
3398            (FMonsterType = MONSTER_PAIN) or (FMonsterType = MONSTER_FISH) then
3399           begin
3400             if FMonsterType = MONSTER_FISH then
3401               begin // Рыба
3402                 if not WordBool(st and MOVE_INWATER) then
3403                   begin // Рыба вне воды:
3404                     if g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj) then
3405                     begin // "Стоит" твердо
3406                     // Рыба трепыхается на поверхности:
3407                       if FObj.Accel.Y = 0 then
3408                         FObj.Vel.Y := -6;
3409                       FObj.Accel.X := FObj.Accel.X - 8 + Random(17);
3410                     end;
3411
3412                   // Рыбе больно:
3413                     SetState(MONSTATE_PAIN);
3414                     FPain := FPain + 50;
3415                   end
3416                 else // Рыба в воде
3417                   begin
3418                   // Плывем в сторону цели по-вертикали:
3419                     if Abs(sy) > 8 then
3420                       FObj.Vel.Y := g_basic.Sign(sy)*4
3421                     else
3422                       FObj.Vel.Y := 0;
3423
3424                   // Рыба плывет вверх:
3425                     if FObj.Vel.Y < 0 then
3426                       if not g_Obj_CollideLiquid(@FObj, 0, -16) then
3427                       begin
3428                       // Всплыли до поверхности - стоп:
3429                         FObj.Vel.Y := 0;
3430                       // Плаваем туда-сюда:
3431                         SetState(MONSTATE_RUN);
3432                         FSleep := 20;
3433                       end;
3434                    end;
3435               end
3436             else // Летающие монстры
3437               begin
3438               // Летим в сторону цели по-вертикали:
3439                 if Abs(sy) > 8 then
3440                   FObj.Vel.Y := g_basic.Sign(sy)*4
3441                 else
3442                   FObj.Vel.Y := 0;
3443               end;
3444           end
3445         else // "Наземные" монстры
3446           begin
3447             {$IFDEF ENBALE_GIBS}
3448               // Возможно, пинаем куски:
3449               if (FObj.Vel.X <> 0) and (gGibs <> nil) then
3450               begin
3451                 b := Abs(FObj.Vel.X);
3452                 if b > 1 then b := b * (Random(8 div b) + 1);
3453                 for a := 0 to High(gGibs) do
3454                 begin
3455                   if gGibs[a].alive and
3456                      g_Obj_Collide(FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y+FObj.Rect.Height-4,
3457                                    FObj.Rect.Width, 8, @gGibs[a].Obj) and (Random(3) = 0) then
3458                   begin
3459                     // Пинаем куски
3460                     if FObj.Vel.X < 0 then
3461                     begin
3462                       g_Obj_PushA(@gGibs[a].Obj, b, Random(61)+120); // налево
3463                     end
3464                     else
3465                     begin
3466                       g_Obj_PushA(@gGibs[a].Obj, b, Random(61));    // направо
3467                     end;
3468                     positionChanged(); // this updates spatial accelerators
3469                   end;
3470                 end;
3471               end;
3472             {$ENDIF}
3473           // Боссы могут пинать трупы:
3474             if (FMonsterType in [MONSTER_CYBER, MONSTER_SPIDER, MONSTER_ROBO]) and
3475                (FObj.Vel.X <> 0) and (gCorpses <> nil) then
3476             begin
3477               b := Abs(FObj.Vel.X);
3478               if b > 1 then b := b * (Random(8 div b) + 1);
3479               for a := 0 to High(gCorpses) do
3480                 if (gCorpses[a] <> nil) and (gCorpses[a].State > 0) then
3481                 begin
3482                   co := gCorpses[a].Obj;
3483                   if g_Obj_Collide(FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y+FObj.Rect.Height-4,
3484                                    FObj.Rect.Width, 8, @co) and (Random(3) = 0) then
3485                     // Пинаем трупы
3486                     if FObj.Vel.X < 0 then
3487                       gCorpses[a].Damage(b*2, FUID, -b, Random(7)) // налево
3488                     else
3489                       gCorpses[a].Damage(b*2, FUID, b, Random(7)); // направо
3490                 end;
3491             end;
3492           end;
3493
3494         FSleep := FSleep + 1;
3495
3496       // Иногда рычим:
3497         if FSleep >= 8 then
3498         begin
3499           FSleep := 0;
3500           if Random(8) = 0 then
3501             ActionSound();
3502         end;
3503
3504       // Бежим в выбранную сторону:
3505         if FDirection = TDirection.D_RIGHT then
3506           FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
3507         else
3508           FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
3509
3510       // Если в воде, то замедляемся:
3511         if WordBool(st and MOVE_INWATER) then
3512           FObj.Vel.X := FObj.Vel.X div 2
3513         else // Рыбам не нужно замедляться
3514           if FMonsterType = MONSTER_FISH then
3515             FObj.Vel.X := 0;
3516       end;
3517
3518     MONSTATE_RUN: // Состояние - Бег
3519       begin
3520       // Если наткнулись на БлокМон - убегаем от него:
3521         if WordBool(st and MOVE_BLOCK) then
3522         begin
3523           SetState(MONSTATE_RUNOUT);
3524           FSleep := 40;
3525
3526           goto _end;
3527         end;
3528
3529         FSleep := FSleep - 1;
3530
3531       // Пробежали достаточно или врезались в стену => переходим на шаг:
3532         if (FSleep <= 0) or (WordBool(st and MOVE_HITWALL) and ((FObj.Vel.Y+FObj.Accel.Y) = 0)) then
3533         begin
3534           SetState(MONSTATE_GO);
3535           FSleep := 0;
3536
3537         // Иногда рычим:
3538           if Random(8) = 0 then
3539             ActionSound();
3540         end;
3541
3542       // Бежим в выбранную сторону:
3543         if FDirection = TDirection.D_RIGHT then
3544           FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
3545         else
3546           FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
3547
3548       // Если в воде, то замедляемся:
3549         if WordBool(st and MOVE_INWATER) then
3550           FObj.Vel.X := FObj.Vel.X div 2
3551         else // Рыбам не нужно замедляться
3552           if FMonsterType = MONSTER_FISH then
3553             FObj.Vel.X := 0;
3554       end;
3555
3556     MONSTATE_RUNOUT: // Состояние - Убегает от чего-то
3557       begin
3558       // Вышли из БлокМона:
3559         if (not WordBool(st and MOVE_BLOCK)) and (FSleep > 0) then
3560           FSleep := 0;
3561
3562         FSleep := FSleep - 1;
3563
3564       // Убажели достаточно далеко => переходим на шаг:
3565         if FSleep <= -18 then
3566         begin
3567           SetState(MONSTATE_GO);
3568           FSleep := 0;
3569
3570         // Иногда рычим:
3571           if Random(8) = 0 then
3572             ActionSound();
3573         end;
3574
3575       // Бежим в выбранную сторону:
3576         if FDirection = TDirection.D_RIGHT then
3577           FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
3578         else
3579           FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
3580
3581       // Если в воде, то замедляемся:
3582         if WordBool(st and MOVE_INWATER) then
3583           FObj.Vel.X := FObj.Vel.X div 2
3584         else // Рыбам не нужно замедляться
3585           if FMonsterType = MONSTER_FISH then
3586             FObj.Vel.X := 0;
3587       end;
3588
3589     MONSTATE_CLIMB: // Состояние - Прыжок (чтобы обойти стену)
3590       begin
3591       // Достигли высшей точки прыжка или стена кончилась => переходим на шаг:
3592         if ((FObj.Vel.Y+FObj.Accel.Y) >= 0) or
3593            (not WordBool(st and MOVE_HITWALL)) then
3594         begin
3595           SetState(MONSTATE_GO);
3596           FSleep := 0;
3597
3598         // Стена не кончилась => бежим от нее:
3599           if WordBool(st and (MOVE_HITWALL or MOVE_BLOCK)) then
3600           begin
3601             SetState(MONSTATE_RUN);
3602             FSleep := 15;
3603           end;
3604         end;
3605
3606       // Бежим в выбранную сторону:
3607         if FDirection = TDirection.D_RIGHT then
3608           FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
3609         else
3610           FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
3611
3612       // Если в воде, то замедляемся:
3613         if WordBool(st and MOVE_INWATER) then
3614           FObj.Vel.X := FObj.Vel.X div 2
3615         else // Рыбам не нужно замедляться
3616           if FMonsterType = MONSTER_FISH then
3617             FObj.Vel.X := 0;
3618       end;
3619
3620     MONSTATE_ATTACK, // Состояние - Атака
3621     MONSTATE_SHOOT:  // Состояние - Стрельба
3622       begin
3623       // Lost_Soul врезался в стену при атаке => переходит на шаг:
3624         if FMonsterType = MONSTER_SOUL then
3625         begin
3626           if WordBool(st and (MOVE_HITWALL or MOVE_HITCEIL or MOVE_HITLAND)) then
3627             SetState(MONSTATE_GO);
3628
3629           goto _end;
3630         end;
3631
3632       // Замедляемся при атаке:
3633         if FMonsterType <> MONSTER_FISH then
3634           FObj.Vel.X := z_dec(FObj.Vel.X, 1);
3635
3636       // Нужно стрелять, а монстр - колдун:
3637         if (FMonsterType = MONSTER_VILE) and (FState = MONSTATE_SHOOT) then
3638         begin
3639         // Цель погибла => идем дальше:
3640           if not GetPos(FTargetUID, @o) then
3641           begin
3642             SetState(MONSTATE_GO);
3643
3644             goto _end;
3645           end;
3646
3647         // Цель не видно => идем дальше:
3648           if not g_Look(@FObj, @o, FDirection) then
3649           begin
3650             SetState(MONSTATE_GO);
3651
3652             goto _end;
3653           end;
3654
3655         // Цель в воде - не загорится => идем дальше:
3656           if g_Obj_CollideWater(@o, 0, 0) then
3657           begin
3658             SetState(MONSTATE_GO);
3659
3660             goto _end;
3661           end;
3662         end;
3663       end;
3664   end; // case FState of ...
3665
3666 _end:
3667
3668 // Состояние - Воскрешение:
3669   if FState = MONSTATE_REVIVE then
3670     if FAnim[FCurAnim, FDirection].Played then
3671     begin // Обратная анимация умирания закончилась - идем дальше:
3672       FAnim[FCurAnim, FDirection].Revert(False);
3673       SetState(MONSTATE_GO);
3674     end;
3675
3676 // Если есть анимация огня колдуна - пусть она идет:
3677   if vilefire <> nil then
3678     vilefire.Update();
3679
3680 // Состояние - Умирает и текущая анимация проиграна:
3681   if (FState = MONSTATE_DIE) and
3682      (FAnim[FCurAnim, FDirection] <> nil) and
3683      (FAnim[FCurAnim, FDirection].Played) then
3684     begin
3685     // Умер:
3686       SetState(MONSTATE_DEAD);
3687
3688     // У этих монстров нет трупов:
3689       if (FMonsterType = MONSTER_PAIN) or
3690          (FMonsterType = MONSTER_SOUL) or
3691          (FMonsterType = MONSTER_BARREL) then
3692         FRemoved := True
3693       else
3694         FAnim[FCurAnim, FDirection].CurrentFrame := FAnim[FCurAnim, FDirection].TotalFrames - 1;
3695     end;
3696
3697 // Совершение атаки и стрельбы:
3698   if (FState = MONSTATE_ATTACK) or (FState = MONSTATE_SHOOT) then
3699     if (FAnim[FCurAnim, FDirection] <> nil) then
3700     // Анимация атаки есть - можно атаковать
3701       if (FAnim[FCurAnim, FDirection].Played) then
3702         begin // Анимация атаки закончилась => переходим на шаг
3703           if FState = MONSTATE_ATTACK then
3704             begin // Состояние - Атака
3705             // Если монстр не Lost_Soul, то после атаки переходим на шаг:
3706               if FMonsterType <> MONSTER_SOUL then
3707                 SetState(MONSTATE_GO);
3708             end
3709           else // Состояние - Стрельба
3710             begin
3711             // Переходим на шаг, если не надо стрелять еще раз:
3712               if not FChainFire then
3713                 SetState(MONSTATE_GO)
3714               else
3715                 begin // Надо стрелять еще
3716                   FChainFire := False;
3717                 // Т.к. состояние не изменилось, и нужен
3718                 // новый цикл ожидания завершения анимации:
3719                   FAnim[FCurAnim, FDirection].Reset();
3720                 end;
3721             end;
3722
3723           FWaitAttackAnim := False;
3724         end
3725
3726       else // Анимация атаки еще идет (исключение - Lost_Soul):
3727         if (FMonsterType = MONSTER_SOUL) or
3728            ( (not FWaitAttackAnim) and
3729              (FAnim[FCurAnim, FDirection].CurrentFrame =
3730               (FAnim[FCurAnim, FDirection].TotalFrames div 2))
3731            ) then
3732         begin // Атаки еще не было и это середина анимации атаки
3733           if FState = MONSTATE_ATTACK then
3734             begin // Состояние - Атака
3735             // Если это Lost_Soul, то сбрасываем анимацию атаки:
3736               if FMonsterType = MONSTER_SOUL then
3737                 FAnim[FCurAnim, FDirection].Reset();
3738
3739               case FMonsterType of
3740                 MONSTER_SOUL, MONSTER_IMP, MONSTER_DEMON:
3741                 // Грызем первого попавшегося:
3742                   if g_Weapon_Hit(@FObj, 15, FUID, HIT_SOME) <> 0 then
3743                   // Lost_Soul укусил кого-то => переходит на шаг:
3744                     if FMonsterType = MONSTER_SOUL then
3745                       SetState(MONSTATE_GO);
3746
3747                 MONSTER_FISH:
3748                   g_Weapon_Hit(@FObj, 10, FUID, HIT_SOME);
3749
3750                 MONSTER_SKEL, MONSTER_ROBO, MONSTER_CYBER:
3751                 // Робот, кибер или скелет сильно пинаются:
3752                   if FCurAnim = ANIM_ATTACK2 then
3753                   begin
3754                     o := FObj;
3755                     o.Vel.X := IfThen(FDirection = TDirection.D_RIGHT, 1, -1)*IfThen(FMonsterType = MONSTER_CYBER, 60, 50);
3756                     g_Weapon_Hit(@o, IfThen(FMonsterType = MONSTER_CYBER, 33, 50), FUID, HIT_SOME);
3757                   end;
3758
3759                 MONSTER_VILE:
3760                 // Колдун пытается воскрешать:
3761                   if FCurAnim = ANIM_ATTACK2 then
3762                   begin
3763                     sx := isCorpse(@FObj, True);
3764                     if sx <> -1 then
3765                     begin // Нашли, кого воскресить
3766                       g_Sound_PlayExAt('SOUND_MONSTER_SLOP', FObj.X, FObj.Y);
3767                     // Воскрешать - себе вредить:
3768                       {g_Weapon_HitUID(FUID, 5, 0, HIT_SOME);}
3769                     end;
3770                   end;
3771               end;
3772             end
3773
3774           else // Состояние - Стрельба
3775             begin
3776             // Скорострельные монстры:
3777               if (FMonsterType = MONSTER_CGUN) or
3778                  (FMonsterType = MONSTER_SPIDER) or
3779                  (FMonsterType = MONSTER_BSP) or
3780                  (FMonsterType = MONSTER_MANCUB) or
3781                  (FMonsterType = MONSTER_ROBO) then
3782                 if not GetPos(FTargetUID, @o) then
3783                 // Цель мертва - ищем новую:
3784                   findNewPrey()
3785                 else // Цель жива - продолжаем стрелять:
3786                   if shoot(@o, False) then
3787                     FChainFire := True;
3788             end;
3789
3790         // Атака только 1 раз за анимацию атаки:
3791           FWaitAttackAnim := True;
3792         end;
3793
3794 // Последний кадр текущей анимации:
3795   if FAnim[FCurAnim, FDirection].Counter = FAnim[FCurAnim, FDirection].Speed-1 then
3796     case FState of
3797       MONSTATE_GO, MONSTATE_RUN, MONSTATE_CLIMB, MONSTATE_RUNOUT:
3798       // Звуки при передвижении:
3799         case FMonsterType of
3800           MONSTER_CYBER:
3801             if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3802                (FAnim[FCurAnim, FDirection].CurrentFrame = 2) then
3803               g_Sound_PlayExAt('SOUND_MONSTER_CYBER_WALK', FObj.X, FObj.Y);
3804           MONSTER_SPIDER:
3805             if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3806                (FAnim[FCurAnim, FDirection].CurrentFrame = 2) then
3807               g_Sound_PlayExAt('SOUND_MONSTER_SPIDER_WALK', FObj.X, FObj.Y);
3808           MONSTER_BSP:
3809             if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3810                (FAnim[FCurAnim, FDirection].CurrentFrame = 2) then
3811               g_Sound_PlayExAt('SOUND_MONSTER_BSP_WALK', FObj.X, FObj.Y);
3812           MONSTER_ROBO:
3813             if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3814                (FAnim[FCurAnim, FDirection].CurrentFrame = 5) then
3815               g_Sound_PlayExAt('SOUND_MONSTER_BSP_WALK', FObj.X, FObj.Y);
3816         end;
3817     end;
3818
3819 // Костыль для потоков
3820   if g_Obj_CollidePanel(@FObj, 0, 0, PANEL_LIFTLEFT or PANEL_LIFTRIGHT) and
3821      not ((FState = MONSTATE_DEAD) or (FState = MONSTATE_DIE))  then
3822     FObj.Vel.X := oldvelx;
3823
3824 // Если есть анимация, то пусть она идет:
3825   if FAnim[FCurAnim, FDirection] <> nil then
3826     FAnim[FCurAnim, FDirection].Update();
3827 end;
3828
3829 procedure TMonster.ClientAttack(wx, wy, atx, aty: Integer);
3830 begin
3831   case FMonsterType of
3832     MONSTER_ZOMBY:
3833     begin
3834       g_Sound_PlayExAt('SOUND_WEAPON_FIREPISTOL', wx, wy);
3835       {$IFDEF ENABLE_SHELLS}
3836         g_Shells_Create(wx, wy, 0, -2, SHELL_BULLET);
3837       {$ENDIF}
3838     end;
3839     MONSTER_SERG:
3840     begin
3841       g_Sound_PlayExAt('SOUND_WEAPON_FIRESHOTGUN', wx, wy);
3842       {$IFDEF ENABLE_SHELLS}
3843         FShellTimer := 10;
3844         FShellType := SHELL_SHELL;
3845       {$ENDIF}
3846     end;
3847     MONSTER_MAN:
3848     begin
3849       g_Sound_PlayExAt('SOUND_WEAPON_FIRESHOTGUN2', wx, wy);
3850       {$IFDEF ENABLE_SHELLS}
3851         FShellTimer := 13;
3852         FShellType := SHELL_DBLSHELL;
3853       {$ENDIF}
3854     end;
3855     MONSTER_CGUN, MONSTER_SPIDER:
3856     begin
3857       g_Sound_PlayExAt('SOUND_WEAPON_FIRECGUN', wx, wy);
3858       {$IFDEF ENABLE_SHELLS}
3859         g_Shells_Create(wx, wy, 0, -2, SHELL_BULLET);
3860       {$ENDIF}
3861     end;
3862     MONSTER_IMP:
3863       g_Weapon_ball1(wx, wy, atx, aty, FUID);
3864     MONSTER_CYBER:
3865       g_Weapon_rocket(wx, wy, atx, aty, FUID);
3866     MONSTER_SKEL:
3867       g_Weapon_revf(wx, wy, atx, aty, FUID, FTargetUID);
3868     MONSTER_BSP:
3869       g_Weapon_aplasma(wx, wy, atx, aty, FUID);
3870     MONSTER_ROBO:
3871       g_Weapon_plasma(wx, wy, atx, aty, FUID);
3872     MONSTER_MANCUB:
3873       g_Weapon_manfire(wx, wy, atx, aty, FUID);
3874     MONSTER_BARON, MONSTER_KNIGHT:
3875       g_Weapon_ball7(wx, wy, atx, aty, FUID);
3876     MONSTER_CACO:
3877       g_Weapon_ball2(wx, wy, atx, aty, FUID);
3878   end;
3879 end;
3880
3881 procedure TMonster.Turn();
3882 begin
3883 // Разворачиваемся:
3884   if FDirection = TDirection.D_LEFT then FDirection := TDirection.D_RIGHT else FDirection := TDirection.D_LEFT;
3885
3886 // Бежим в выбранную сторону:
3887   if FDirection = TDirection.D_RIGHT then
3888     FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
3889   else
3890     FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
3891 end;
3892
3893 function TMonster.findNewPrey(): Boolean;
3894 var
3895   a: DWORD;
3896   l, l2: Integer;
3897   PlayersSee, MonstersSee: Array of DWORD;
3898   PlayerNear, MonsterNear: Integer;
3899 begin
3900   Result := False;
3901   SetLength(MonstersSee, 0);
3902   SetLength(PlayersSee, 0);
3903
3904   FTargetUID := 0;
3905   l := 32000;
3906   PlayerNear := -1;
3907   MonsterNear := -1;
3908
3909   // Поехавшие, каннибалы, и добрые игроков не трогают
3910   if (gPlayers <> nil) and (FBehaviour <> BH_INSANE) and
3911   (FBehaviour <> BH_CANNIBAL) and (FBehaviour <> BH_GOOD) then
3912     for a := 0 to High(gPlayers) do
3913       if (gPlayers[a] <> nil) and (gPlayers[a].alive)
3914       and (not gPlayers[a].NoTarget) and (gPlayers[a].FMegaRulez[MR_INVIS] < gTime) then
3915       begin
3916         if g_Look(@FObj, @gPlayers[a].Obj, FDirection) then
3917         begin
3918           SetLength(PlayersSee, Length(PlayersSee) + 1);
3919           PlayersSee[High(PlayersSee)] := a;
3920         end;
3921         l2 := Abs(gPlayers[a].GameX-FObj.X)+
3922               Abs(gPlayers[a].GameY-FObj.Y);
3923         if l2 < l then
3924         begin
3925           l := l2;
3926           PlayerNear := Integer(a);
3927         end;
3928       end;
3929
3930   // Киллеры и добрые не трогают монстров
3931   if (gMonsters <> nil) and (FBehaviour <> BH_KILLER) and (FBehaviour <> BH_GOOD) then
3932     for a := 0 to High(gMonsters) do
3933       if (gMonsters[a] <> nil) and (gMonsters[a].alive) and
3934          (gMonsters[a].FUID <> FUID) then
3935       begin
3936         if (FBehaviour = BH_CANNIBAL) and (gMonsters[a].FMonsterType <> FMonsterType) then
3937           Continue; // Каннибалы атакуют только сородичей
3938         if (FBehaviour = BH_INSANE) and (gMonsters[a].FMonsterType <> MONSTER_BARREL)
3939         and (IsFriend(gMonsters[a].FMonsterType, FMonsterType)) then
3940           Continue; // Поехавшие не трогают друзей, но им не нравятся бочки
3941         if ((FBehaviour = BH_NORMAL) or (FBehaviour = BH_MANIAC))
3942         and (IsFriend(gMonsters[a].FMonsterType, FMonsterType)) then
3943           Continue; // Оставшиеся типы, кроме каннибалов, не трогают своих друзей
3944
3945         if g_Look(@FObj, @gMonsters[a].Obj, FDirection) then
3946         begin
3947           SetLength(MonstersSee, Length(MonstersSee) + 1);
3948           MonstersSee[High(MonstersSee)] := a;
3949         end;
3950         l2 := Abs(gMonsters[a].FObj.X-FObj.X)+
3951               Abs(gMonsters[a].FObj.Y-FObj.Y);
3952         if l2 < l then
3953         begin
3954           l := l2;
3955           MonsterNear := Integer(a);
3956         end;
3957       end;
3958
3959   case FBehaviour of
3960     BH_NORMAL, BH_KILLER:
3961     begin
3962       // Обычный и киллер сначала ищут игроков в поле зрения
3963       if (FTargetUID = 0) and (Length(PlayersSee) > 0) then
3964       begin
3965         a := PlayersSee[Random(Length(PlayersSee))];
3966         FTargetUID := gPlayers[a].UID;
3967       end;
3968       // Затем поблизости
3969       if (FTargetUID = 0) and (PlayerNear > -1) then
3970       begin
3971         a := PlayerNear;
3972         FTargetUID := gPlayers[a].UID;
3973       end;
3974       // Потом обычные ищут монстров в поле зрения
3975       if (FTargetUID = 0) and (Length(MonstersSee) > 0) then
3976       begin
3977         a := MonstersSee[Random(Length(MonstersSee))];
3978         FTargetUID := gMonsters[a].UID;
3979       end;
3980       // Затем поблизости
3981       if (FTargetUID = 0) and (MonsterNear > -1) then
3982       begin
3983         a := MonsterNear;
3984         FTargetUID := gMonsters[a].UID;
3985       end;
3986     end;
3987     BH_MANIAC, BH_INSANE, BH_CANNIBAL:
3988     begin
3989       // Маньяки, поехавшие и каннибалы сначала истребляют всё в поле зрения
3990       if (FTargetUID = 0) and (Length(PlayersSee) > 0) then
3991       begin
3992         a := PlayersSee[Random(Length(PlayersSee))];
3993         FTargetUID := gPlayers[a].UID;
3994       end;
3995       if (FTargetUID = 0) and (Length(MonstersSee) > 0) then
3996       begin
3997         a := MonstersSee[Random(Length(MonstersSee))];
3998         FTargetUID := gMonsters[a].UID;
3999       end;
4000       // Затем ищут кого-то поблизости
4001       if (FTargetUID = 0) and (PlayerNear > -1) then
4002       begin
4003         a := PlayerNear;
4004         FTargetUID := gPlayers[a].UID;
4005       end;
4006       if (FTargetUID = 0) and (MonsterNear > -1) then
4007       begin
4008         a := MonsterNear;
4009         FTargetUID := gMonsters[a].UID;
4010       end;
4011     end;
4012   end;
4013
4014 // Если и монстров нет - начинаем ждать цель:
4015   if FTargetUID = 0 then
4016     begin
4017       // Поехавший пытается самоубиться
4018       if FBehaviour = BH_INSANE then
4019         FTargetUID := FUID
4020       else
4021         FTargetTime := MAX_ATM;
4022     end
4023   else
4024     begin // Цель нашли
4025       FTargetTime := 0;
4026       Result := True;
4027     end;
4028 end;
4029
4030 function TMonster.kick(o: PObj): Boolean;
4031 begin
4032   Result := False;
4033
4034   case FMonsterType of
4035     MONSTER_FISH:
4036       begin
4037         SetState(MONSTATE_ATTACK);
4038         Result := True;
4039       end;
4040     MONSTER_DEMON:
4041       begin
4042         SetState(MONSTATE_ATTACK);
4043         g_Sound_PlayExAt('SOUND_MONSTER_DEMON_ATTACK', FObj.X, FObj.Y);
4044         Result := True;
4045       end;
4046     MONSTER_IMP:
4047       begin
4048         SetState(MONSTATE_ATTACK);
4049         g_Sound_PlayExAt('SOUND_MONSTER_IMP_ATTACK', FObj.X, FObj.Y);
4050         Result := True;
4051       end;
4052     MONSTER_SKEL, MONSTER_ROBO, MONSTER_CYBER:
4053       begin
4054         SetState(MONSTATE_ATTACK, ANIM_ATTACK2);
4055         g_Sound_PlayExAt('SOUND_MONSTER_SKEL_ATTACK', FObj.X, FObj.Y);
4056         Result := True;
4057       end;
4058     MONSTER_BARON, MONSTER_KNIGHT,
4059     MONSTER_CACO, MONSTER_MANCUB:
4060     // Эти монстры не пинают - они стреляют в упор:
4061       if not g_Game_IsClient then Result := shoot(o, True);
4062   end;
4063 end;
4064
4065 function TMonster.shoot(o: PObj; immediately: Boolean): Boolean;
4066 var
4067   xd, yd, m: Integer;
4068 begin
4069   Result := False;
4070
4071 // Стрелять рано:
4072   if FAmmo < 0 then
4073     Exit;
4074
4075 // Ждать времени готовности к выстрелу:
4076   if not immediately then
4077     case FMonsterType of
4078       MONSTER_FISH, MONSTER_BARREL, MONSTER_DEMON:
4079         Exit; // не стреляют
4080       MONSTER_CGUN, MONSTER_BSP, MONSTER_ROBO:
4081         begin
4082           FAmmo := FAmmo + 1;
4083         // Время выстрела упущено:
4084           if FAmmo >= 50 then
4085             FAmmo := IfThen(FMonsterType = MONSTER_ROBO, -200, -50);
4086         end;
4087       MONSTER_MAN: ;
4088       MONSTER_MANCUB:
4089         begin
4090           FAmmo := FAmmo + 1;
4091         // Время выстрела упущено:
4092           if FAmmo >= 5 then
4093             FAmmo := -50;
4094         end;
4095       MONSTER_SPIDER:
4096         begin
4097           FAmmo := FAmmo + 1;
4098         // Время выстрела упущено:
4099           if FAmmo >= 100 then
4100             FAmmo := -50;
4101         end;
4102       MONSTER_CYBER:
4103         begin
4104         // Стреляет не всегда:
4105           if Random(2) = 0 then
4106             Exit;
4107           FAmmo := FAmmo + 1;
4108         // Время выстрела упущено:
4109           if FAmmo >= 10 then
4110             FAmmo := -50;
4111         end;
4112       MONSTER_BARON, MONSTER_KNIGHT: if Random(8) <> 0 then Exit;
4113       MONSTER_SKEL: if Random(32) <> 0 then Exit;
4114       MONSTER_VILE: if Random(8) <> 0 then Exit;
4115       MONSTER_PAIN: if Random(8) <> 0 then Exit;
4116       else if Random(16) <> 0 then Exit;
4117     end;
4118
4119 // Цели не видно:
4120   if not g_Look(@FObj, o, FDirection) then
4121     Exit;
4122
4123   FTargetTime := 0;
4124
4125   tx := o^.X+o^.Rect.X+(o^.Rect.Width div 2)+((o^.Vel.X{+o^.Accel.X})*12);
4126   ty := o^.Y+o^.Rect.Y+(o^.Rect.Height div 2)+((o^.Vel.Y{+o^.Accel.Y})*12);
4127
4128 // Разница по высоте больше разницы по горизонтали
4129 // (не может стрелять под таким большим углом):
4130   if Abs(tx-(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2))) <
4131      Abs(ty-(FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2))) then
4132     Exit;
4133
4134   case FMonsterType of
4135     MONSTER_IMP, MONSTER_BARON, MONSTER_KNIGHT, MONSTER_CACO:
4136       begin
4137         SetState(MONSTATE_SHOOT);
4138         {nn}
4139       end;
4140     MONSTER_SKEL:
4141       begin
4142         SetState(MONSTATE_SHOOT);
4143         {nn}
4144       end;
4145     MONSTER_VILE:
4146       begin // Зажигаем огонь
4147         tx := o^.X+o^.Rect.X+(o^.Rect.Width div 2);
4148         ty := o^.Y+o^.Rect.Y;
4149         SetState(MONSTATE_SHOOT);
4150
4151         vilefire.Reset();
4152
4153         g_Sound_PlayExAt('SOUND_MONSTER_VILE_ATTACK', FObj.X, FObj.Y);
4154         g_Sound_PlayExAt('SOUND_FIRE', o^.X, o^.Y);
4155       end;
4156     MONSTER_SOUL:
4157       begin // Летит в сторону цели:
4158         SetState(MONSTATE_ATTACK);
4159         g_Sound_PlayExAt('SOUND_MONSTER_SOUL_ATTACK', FObj.X, FObj.Y);
4160
4161         xd := tx-(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2));
4162         yd := ty-(FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2));
4163         m := Max(Abs(xd), Abs(yd));
4164         if m = 0 then
4165           m := 1;
4166
4167         FObj.Vel.X := (xd*16) div m;
4168         FObj.Vel.Y := (yd*16) div m;
4169       end;
4170     MONSTER_MANCUB, MONSTER_ZOMBY, MONSTER_SERG, MONSTER_BSP, MONSTER_ROBO,
4171     MONSTER_CYBER, MONSTER_CGUN, MONSTER_SPIDER, MONSTER_PAIN, MONSTER_MAN:
4172       begin
4173       // Манкубус рявкает перед первой атакой:
4174         if FMonsterType = MONSTER_MANCUB then
4175           if FAmmo = 1 then
4176             g_Sound_PlayExAt('SOUND_MONSTER_MANCUB_ATTACK', FObj.X, FObj.Y);
4177
4178         SetState(MONSTATE_SHOOT);
4179       end;
4180     else Exit;
4181   end;
4182
4183   Result := True;
4184 end;
4185
4186 function TMonster.alive(): Boolean;
4187 begin
4188   Result := (FState <> MONSTATE_DIE) and (FState <> MONSTATE_DEAD) and (FHealth > 0);
4189 end;
4190
4191 procedure TMonster.SetHealth(aH: Integer);
4192 begin
4193   if (aH > 0) and (aH < 1000000) then
4194   begin
4195     FHealth := aH;
4196     if FHealth > FMaxHealth then
4197       FMaxHealth := FHealth;
4198   end;
4199 end;
4200
4201 procedure TMonster.WakeUp();
4202 begin
4203   if g_Game_IsClient then Exit;
4204   SetState(MONSTATE_GO);
4205   FTargetTime := MAX_ATM;
4206   WakeUpSound();
4207 end;
4208
4209 procedure TMonster.SaveState (st: TStream);
4210 var
4211   i: Integer;
4212   b: Byte;
4213   anim: Boolean;
4214 begin
4215   assert(st <> nil);
4216
4217   // Сигнатура монстра:
4218   utils.writeSign(st, 'MONS');
4219   utils.writeInt(st, Byte(0)); // version
4220   // UID монстра:
4221   utils.writeInt(st, Word(FUID));
4222   // Направление
4223   if FDirection = TDirection.D_LEFT then b := 1 else b := 2; // D_RIGHT
4224   utils.writeInt(st, Byte(b));
4225   // Надо ли удалить его
4226   utils.writeBool(st, FRemoved);
4227   // Осталось здоровья
4228   utils.writeInt(st, LongInt(FHealth));
4229   // Состояние
4230   utils.writeInt(st, Byte(FState));
4231   // Текущая анимация
4232   utils.writeInt(st, Byte(FCurAnim));
4233   // UID цели
4234   utils.writeInt(st, Word(FTargetUID));
4235   // Время после потери цели
4236   utils.writeInt(st, LongInt(FTargetTime));
4237   // Поведение монстра
4238   utils.writeInt(st, Byte(FBehaviour));
4239   // Готовность к выстрелу
4240   utils.writeInt(st, LongInt(FAmmo));
4241   // Боль
4242   utils.writeInt(st, LongInt(FPain));
4243   // Время ожидания
4244   utils.writeInt(st, LongInt(FSleep));
4245   // Озвучивать ли боль
4246   utils.writeBool(st, FPainSound);
4247   // Была ли атака во время анимации атаки
4248   utils.writeBool(st, FWaitAttackAnim);
4249   // Надо ли стрелять на следующем шаге
4250   utils.writeBool(st, FChainFire);
4251   // Подлежит ли респавну
4252   utils.writeBool(st, FNoRespawn);
4253   // Координаты цели
4254   utils.writeInt(st, LongInt(tx));
4255   utils.writeInt(st, LongInt(ty));
4256   // ID монстра при старте карты
4257   utils.writeInt(st, LongInt(FStartID));
4258   // Индекс триггера, создавшего монстра
4259   utils.writeInt(st, LongInt(FSpawnTrigger));
4260   // Объект монстра
4261   Obj_SaveState(st, @FObj);
4262   // Есть ли анимация огня колдуна
4263   anim := (vilefire <> nil);
4264   utils.writeBool(st, anim);
4265   // Если есть - сохраняем:
4266   if anim then vilefire.SaveState(st, 0, False);
4267   // Анимации
4268   for i := ANIM_SLEEP to ANIM_PAIN do
4269   begin
4270     // Есть ли левая анимация
4271     anim := (FAnim[i, TDirection.D_LEFT] <> nil);
4272     utils.writeBool(st, anim);
4273     // Если есть - сохраняем
4274     if anim then FAnim[i, TDirection.D_LEFT].SaveState(st, 0, False);
4275     // Есть ли правая анимация
4276     anim := (FAnim[i, TDirection.D_RIGHT] <> nil);
4277     utils.writeBool(st, anim);
4278     // Если есть - сохраняем
4279     if anim then FAnim[i, TDirection.D_RIGHT].SaveState(st, 0, False);
4280   end;
4281 end;
4282
4283
4284 procedure TMonster.LoadState (st: TStream);
4285 var
4286   i: Integer;
4287   b, alpha: Byte;
4288   anim, blending: Boolean;
4289 begin
4290   assert(st <> nil);
4291
4292   // Сигнатура монстра:
4293   if not utils.checkSign(st, 'MONS') then raise XStreamError.Create('invalid monster signature');
4294   if (utils.readByte(st) <> 0) then raise XStreamError.Create('invalid monster version');
4295   if (uidMap[FUID] <> nil) and (uidMap[FUID] <> self) then raise Exception.Create('internal error in monster loader (0)');
4296   uidMap[FUID] := nil;
4297   // UID монстра:
4298   FUID := utils.readWord(st);
4299   //if (arrIdx = -1) then raise Exception.Create('internal error in monster loader');
4300   if (uidMap[FUID] <> nil) then raise Exception.Create('internal error in monster loader (1)');
4301   uidMap[FUID] := self;
4302   // Направление
4303   b := utils.readByte(st);
4304   if b = 1 then FDirection := TDirection.D_LEFT else FDirection := TDirection.D_RIGHT; // b = 2
4305   // Надо ли удалить его
4306   FRemoved := utils.readBool(st);
4307   // Осталось здоровья
4308   FHealth := utils.readLongInt(st);
4309   // Состояние
4310   FState := utils.readByte(st);
4311   // Текущая анимация
4312   FCurAnim := utils.readByte(st);
4313   // UID цели
4314   FTargetUID := utils.readWord(st);
4315   // Время после потери цели
4316   FTargetTime := utils.readLongInt(st);
4317   // Поведение монстра
4318   FBehaviour := utils.readByte(st);
4319   // Готовность к выстрелу
4320   FAmmo := utils.readLongInt(st);
4321   // Боль
4322   FPain := utils.readLongInt(st);
4323   // Время ожидания
4324   FSleep := utils.readLongInt(st);
4325   // Озвучивать ли боль
4326   FPainSound := utils.readBool(st);
4327   // Была ли атака во время анимации атаки
4328   FWaitAttackAnim := utils.readBool(st);
4329   // Надо ли стрелять на следующем шаге
4330   FChainFire := utils.readBool(st);
4331   // Подлежит ли респавну
4332   FNoRespawn := utils.readBool(st);
4333   // Координаты цели
4334   tx := utils.readLongInt(st);
4335   ty := utils.readLongInt(st);
4336   // ID монстра при старте карты
4337   FStartID := utils.readLongInt(st);
4338   // Индекс триггера, создавшего монстра
4339   FSpawnTrigger := utils.readLongInt(st);
4340   // Объект монстра
4341   Obj_LoadState(@FObj, st);
4342   // Есть ли анимация огня колдуна
4343   anim := utils.readBool(st);
4344   // Если есть - загружаем:
4345   if anim then
4346   begin
4347     Assert(vilefire <> nil, 'TMonster.LoadState: no vilefire anim');
4348     vilefire.LoadState(st, alpha, blending);
4349   end;
4350   // Анимации
4351   for i := ANIM_SLEEP to ANIM_PAIN do
4352   begin
4353     // Есть ли левая анимация
4354     anim := utils.readBool(st);
4355     // Если есть - загружаем
4356     if anim then
4357     begin
4358       Assert(FAnim[i, TDirection.D_LEFT] <> nil, 'TMonster.LoadState: no '+IntToStr(i)+'_left anim');
4359       FAnim[i, TDirection.D_LEFT].LoadState(st, alpha, blending);
4360     end;
4361     // Есть ли правая анимация
4362      anim := utils.readBool(st);
4363     // Если есть - загружаем
4364     if anim then
4365     begin
4366       Assert(FAnim[i, TDirection.D_RIGHT] <> nil, 'TMonster.LoadState: no '+IntToStr(i)+'_right anim');
4367       FAnim[i, TDirection.D_RIGHT].LoadState(st, alpha, blending);
4368     end;
4369   end;
4370 end;
4371
4372
4373 procedure TMonster.ActivateTriggers();
4374 var
4375   a: Integer;
4376 begin
4377   if FDieTriggers <> nil then
4378     for a := 0 to High(FDieTriggers) do
4379       g_Triggers_Press(FDieTriggers[a], ACTIVATE_MONSTERPRESS);
4380   if FSpawnTrigger > -1 then
4381   begin
4382     g_Triggers_DecreaseSpawner(FSpawnTrigger);
4383     FSpawnTrigger := -1;
4384   end;
4385 end;
4386
4387 procedure TMonster.AddTrigger(t: Integer);
4388 begin
4389   SetLength(FDieTriggers, Length(FDieTriggers)+1);
4390   FDieTriggers[High(FDieTriggers)] := t;
4391 end;
4392
4393 procedure TMonster.ClearTriggers();
4394 begin
4395   SetLength(FDieTriggers, 0);
4396 end;
4397
4398 procedure TMonster.CatchFire(Attacker: Word; Timeout: Integer = MON_BURN_TIME);
4399 begin
4400   if FMonsterType in [MONSTER_SOUL, MONSTER_VILE] then
4401     exit; // арчи не горят, черепа уже горят
4402   if Timeout <= 0 then exit;
4403   if g_Obj_CollidePanel(@FObj, 0, 0, PANEL_WATER or PANEL_ACID1 or PANEL_ACID2) then
4404     exit; // не подгораем в воде на всякий случай
4405   if FFireTime <= 0 then
4406     g_Sound_PlayExAt('SOUND_IGNITE', FObj.X, FObj.Y);
4407   FFireTime := Timeout;
4408   FFireAttacker := Attacker;
4409   if g_Game_IsNet and g_Game_IsServer then MH_SEND_MonsterState(FUID);
4410 end;
4411
4412 procedure TMonster.OnFireFlame(Times: DWORD = 1);
4413   {$IFDEF ENABLE_GFX}
4414     var i: DWORD; x, y: Integer;
4415   {$ENDIF}
4416 begin
4417   {$IFDEF ENABLE_GFX}
4418     if (Random(10) = 1) and (Times = 1) then
4419       Exit;
4420     for i := 1 to Times do
4421     begin
4422       x := Obj.X + Obj.Rect.X + Random(Obj.Rect.Width + Times * 2) - (R_GFX_FLAME_WIDTH div 2);
4423       y := Obj.Y + 8 + Random(8 + Times * 2) + IfThen(FState = MONSTATE_DEAD, 16, 0);
4424       g_GFX_QueueEffect(R_GFX_FLAME, x, y);
4425     end;
4426   {$ENDIF}
4427 end;
4428
4429
4430 // ////////////////////////////////////////////////////////////////////////// //
4431 // throws on invalid uid
4432 function g_Mons_ByIdx (uid: Integer): TMonster; inline;
4433 begin
4434   result := g_Mons_ByIdx_NC(uid);
4435   if (result = nil) then raise Exception.Create('g_Mons_ByIdx: invalid monster id');
4436 end;
4437
4438 // can return null
4439 function g_Mons_ByIdx_NC (uid: Integer): TMonster; inline;
4440 begin
4441   if (uid < 0) or (uid > High(gMonsters)) then begin result := nil; exit; end;
4442   result := gMonsters[uid];
4443 end;
4444
4445 function g_Mons_TotalCount (): Integer; inline;
4446 begin
4447   result := Length(gMonsters);
4448 end;
4449
4450
4451 function g_Mons_ForEach (cb: TEachMonsterCB): Boolean;
4452 var
4453   idx: Integer;
4454   mon: TMonster;
4455 begin
4456   result := false;
4457   if (gMonsters = nil) or not assigned(cb) then exit;
4458   for idx := 0 to High(gMonsters) do
4459   begin
4460     mon := gMonsters[idx];
4461     if (mon <> nil) then
4462     begin
4463       result := cb(mon);
4464       if result then exit;
4465     end;
4466   end;
4467 end;
4468
4469
4470 function g_Mons_ForEachAlive (cb: TEachMonsterCB): Boolean;
4471 var
4472   idx: Integer;
4473   mon: TMonster;
4474 begin
4475   result := false;
4476   if (gMonsters = nil) or not assigned(cb) then exit;
4477   for idx := 0 to High(gMonsters) do
4478   begin
4479     mon := gMonsters[idx];
4480     if (mon <> nil) and mon.alive then
4481     begin
4482       result := cb(mon);
4483       if result then exit;
4484     end;
4485   end;
4486 end;
4487
4488
4489 function g_Mons_IsAnyAliveAt (x, y: Integer; width, height: Integer): Boolean;
4490   (*
4491   function monsCollCheck (mon: TMonster; atag: Integer): Boolean;
4492   begin
4493     result := mon.alive;// and g_Obj_Collide(x, y, width, height, @mon.Obj));
4494   end;
4495   *)
4496 var
4497   idx: Integer;
4498   mon: TMonster;
4499   mit: PMonster;
4500   it: TMonsterGrid.Iter;
4501 begin
4502   result := false;
4503   if (width < 1) or (height < 1) then exit;
4504   if gmon_debug_use_sqaccel then
4505   begin
4506     //result := (monsGrid.forEachInAABB(x, y, width, height, monsCollCheck) <> nil);
4507     it := monsGrid.forEachInAABB(x, y, width, height);
4508     for mit in it do if (mit.alive) then begin result := true; break; end;
4509     it.release();
4510   end
4511   else
4512   begin
4513     for idx := 0 to High(gMonsters) do
4514     begin
4515       mon := gMonsters[idx];
4516       if (mon <> nil) and mon.alive then
4517       begin
4518         if g_Obj_Collide(x, y, width, height, @mon.Obj) then
4519         begin
4520           result := true;
4521           exit;
4522         end;
4523       end;
4524     end;
4525   end;
4526 end;
4527
4528
4529 function g_Mons_ForEachAt (x, y: Integer; width, height: Integer; cb: TEachMonsterCB): Boolean;
4530   (*
4531   function monsCollCheck (mon: TMonster; atag: Integer): Boolean;
4532   begin
4533     result := cb(mon);
4534   end;
4535   *)
4536 var
4537   idx: Integer;
4538   mon: TMonster;
4539   mit: PMonster;
4540   it: TMonsterGrid.Iter;
4541 begin
4542   result := false;
4543   if (width < 1) or (height < 1) then exit;
4544   if gmon_debug_use_sqaccel then
4545   begin
4546     //result := (monsGrid.forEachInAABB(x, y, width, height, monsCollCheck) <> nil);
4547     it := monsGrid.forEachInAABB(x, y, width, height);
4548     for mit in it do if (cb(mit^)) then begin result := true; break; end;
4549     it.release();
4550   end
4551   else
4552   begin
4553     for idx := 0 to High(gMonsters) do
4554     begin
4555       mon := gMonsters[idx];
4556       if (mon <> nil) and mon.alive then
4557       begin
4558         if g_Obj_Collide(x, y, width, height, @mon.Obj) then
4559         begin
4560           result := cb(mon);
4561           if result then exit;
4562         end;
4563       end;
4564     end;
4565   end;
4566 end;
4567
4568
4569 function g_Mons_ForEachAliveAt (x, y: Integer; width, height: Integer; cb: TEachMonsterCB): Boolean;
4570   (*
4571   function monsCollCheck (mon: TMonster; atag: Integer): Boolean;
4572   begin
4573     //result := false;
4574     //if mon.alive and g_Obj_Collide(x, y, width, height, @mon.Obj) then result := cb(mon);
4575     if mon.alive then result := cb(mon) else result := false;
4576   end;
4577   *)
4578 var
4579   idx: Integer;
4580   mon: TMonster;
4581   mit: PMonster;
4582   it: TMonsterGrid.Iter;
4583 begin
4584   result := false;
4585   if (width < 1) or (height < 1) then exit;
4586   if gmon_debug_use_sqaccel then
4587   begin
4588     {
4589     if (width = 1) and (height = 1) then
4590     begin
4591       result := (monsGrid.forEachAtPoint(x, y, monsCollCheck) <> nil);
4592     end
4593     else
4594     begin
4595       result := (monsGrid.forEachInAABB(x, y, width, height, monsCollCheck) <> nil);
4596     end;
4597     }
4598     it := monsGrid.forEachInAABB(x, y, width, height);
4599     for mit in it do
4600     begin
4601       if (mit^.alive) then
4602       begin
4603         if (cb(mit^)) then begin result := true; break; end;
4604       end;
4605     end;
4606     it.release();
4607   end
4608   else
4609   begin
4610     for idx := 0 to High(gMonsters) do
4611     begin
4612       mon := gMonsters[idx];
4613       if (mon <> nil) and mon.alive then
4614       begin
4615         if g_Obj_Collide(x, y, width, height, @mon.Obj) then
4616         begin
4617           result := cb(mon);
4618           if result then exit;
4619         end;
4620       end;
4621     end;
4622   end;
4623 end;
4624
4625
4626 end.