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