src/game/g_monsters.pas

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