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