src/game/g_monsters.pas

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