DEADSOFTWARE

GIT / REPO / FRED-BOY
Projects / d2df-sdl.git / blob


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