DEADSOFTWARE

GIT / REPO / FRED-BOY
Projects / d2df-sdl.git / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
gl: implement load screen
[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_animations, 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 TAnimState;
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 FVileFireTime: LongWord;
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 VileFireTime: LongWord read FVileFireTime;
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 ANIM_LAST = ANIM_PAIN;
332
333 // Таблица характеристик монстров:
334 MONSTERTABLE: Array [MONSTER_DEMON..MONSTER_MAN] of
335 record
336 Name: String;
337 Rect: TRectWH;
338 Health: Word;
339 RunVel: Byte;
340 MinPain: Byte;
341 Pain: Byte;
342 Jump: Byte;
343 end =
344 ((Name:'DEMON'; Rect:(X:7; Y:8; Width:50; Height:52); Health:60;
345 RunVel: 7; MinPain: 10; Pain: 20; Jump: 10),
346
347 (Name:'IMP'; Rect:(X:15; Y:10; Width:34; Height:50); Health:25;
348 RunVel: 3; MinPain: 0; Pain: 15; Jump: 10),
349
350 (Name:'ZOMBY'; Rect:(X:15; Y:8; Width:34; Height:52); Health:15;
351 RunVel: 3; MinPain: 0; Pain: 10; Jump: 10),
352
353 (Name:'SERG'; Rect:(X:15; Y:8; Width:34; Height:52); Health:20;
354 RunVel: 3; MinPain: 0; Pain: 10; Jump: 10),
355
356 (Name:'CYBER'; Rect:(X:24; Y:9; Width:80; Height:110); Health:500;
357 RunVel: 5; MinPain: 50; Pain: 70; Jump: 10),
358
359 (Name:'CGUN'; Rect:(X:15; Y:4; Width:34; Height:56); Health:60;
360 RunVel: 3; MinPain: 10; Pain: 20; Jump: 10),
361
362 (Name:'BARON'; Rect:(X:39; Y:32; Width:50; Height:64); Health:150;
363 RunVel: 3; MinPain: 30; Pain: 40; Jump: 10),
364
365 (Name:'KNIGHT'; Rect:(X:39; Y:32; Width:50; Height:64); Health:75;
366 RunVel: 3; MinPain: 30; Pain: 40; Jump: 10),
367
368 (Name:'CACO'; Rect:(X:34; Y:36; Width:60; Height:56); Health:100;
369 RunVel: 4; MinPain: 0; Pain: 10; Jump: 4),
370
371 (Name:'SOUL'; Rect:(X:16; Y:14; Width:32; Height:36); Health:60;
372 RunVel: 4; MinPain: 0; Pain: 10; Jump: 4),
373
374 (Name:'PAIN'; Rect:(X:34; Y:36; Width:60; Height:56); Health:100;
375 RunVel: 4; MinPain: 0; Pain: 10; Jump: 4),
376
377 (Name:'SPIDER'; Rect:(X:23; Y:14; Width:210; Height:100); Health:500;
378 RunVel: 4; MinPain: 50; Pain: 70; Jump: 10),
379
380 (Name:'BSP'; Rect:(X:14; Y:17; Width:100; Height:42); Health:150;
381 RunVel: 4; MinPain: 0; Pain: 20; Jump: 10),
382
383 (Name:'MANCUB'; Rect:(X:28; Y:34; Width:72; Height:60); Health:200;
384 RunVel: 3; MinPain: 20; Pain: 40; Jump: 7),
385
386 (Name:'SKEL'; Rect:(X:30; Y:28; Width:68; Height:72); Health:200;
387 RunVel: 6; MinPain: 20; Pain: 40; Jump: 11),
388
389 (Name:'VILE'; Rect:(X:30; Y:28; Width:68; Height:72); Health:150;
390 RunVel: 7; MinPain: 10; Pain: 30; Jump: 12),
391
392 (Name:'FISH'; Rect:(X:6; Y:11; Width:20; Height:10); Health:35;
393 RunVel: 14; MinPain: 10; Pain: 20; Jump: 6),
394
395 (Name:'BARREL'; Rect:(X:20; Y:13; Width:24; Height:36); Health:20;
396 RunVel: 0; MinPain: 0; Pain: 0; Jump: 0),
397
398 (Name:'ROBO'; Rect:(X:30; Y:26; Width:68; Height:76); Health:20;
399 RunVel: 3; MinPain: 20; Pain: 40; Jump: 6),
400
401 (Name:'MAN'; Rect:(X:15; Y:6; Width:34; Height:52); Health:400;
402 RunVel: 8; MinPain: 50; Pain: 70; Jump: 10));
403
404 // Таблица параметров анимации монстров:
405 MONSTER_ANIMTABLE: Array [MONSTER_DEMON..MONSTER_MAN] of
406 record
407 LeftAnim: Boolean;
408 wX, wY: Integer; // Откуда вылетит пуля
409 AnimSpeed: Array [ANIM_SLEEP..ANIM_PAIN] of Byte;
410 AnimCount: Array [ANIM_SLEEP..ANIM_PAIN] of Byte;
411 AnimDeltaRight: Array [ANIM_SLEEP..ANIM_PAIN] of TDFPoint;
412 AnimDeltaLeft: Array [ANIM_SLEEP..ANIM_PAIN] of TDFPoint;
413 end = // SLEEP GO DIE MESS ATTACK ATTACK2 PAIN
414 ((LeftAnim: False; wX: 54; wY: 32; AnimSpeed:(3, 2, 3, 2, 3, 0, 4); //DEMON
415 AnimCount: (2, 4, 6, 6, 3, 0, 1);
416 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));
417 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))),
418
419 (LeftAnim: False; wX: 32; wY: 32; AnimSpeed:(3, 2, 3, 2, 3, 0, 4); //IMP
420 AnimCount: (2, 4, 5, 8, 3, 0, 1);
421 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));
422 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))),
423
424 (LeftAnim: True; wX: 32; wY: 32; AnimSpeed:(3, 2, 3, 2, 3, 0, 4); //ZOMBY
425 AnimCount: (2, 4, 6, 9, 2, 0, 1);
426 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));
427 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))),
428
429 (LeftAnim: True; wX: 32; wY: 32; AnimSpeed:(3, 2, 3, 2, 3, 0, 4); //SERG
430 AnimCount: (2, 4, 5, 9, 2, 0, 1);
431 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));
432 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))),
433
434 (LeftAnim: True; wX: 70; wY: 73; AnimSpeed:(3, 3, 3, 3, 3, 4, 3); //CYBER
435 AnimCount: (2, 4, 9, 9, 2, 2, 1);
436 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));
437 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))),
438
439 (LeftAnim: True; wX: 32; wY: 32; AnimSpeed:(3, 2, 2, 2, 1, 0, 4); //CGUN
440 AnimCount: (2, 4, 7, 6, 2, 0, 1);
441 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));
442 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))),
443
444 (LeftAnim: True; wX: 64; wY: 64; AnimSpeed:(3, 2, 3, 4, 2, 0, 4); //BARON
445 AnimCount: (2, 4, 7, 7, 3, 0, 1);
446 AnimDeltaRight: ((X: 4; Y: 0), (X: 2; Y: 0), (X: -1; Y: -1), (X: -1; Y: -1), (X: 1; Y: 0), (X: 1; Y: 0), (X: -1; Y: 0));
447 AnimDeltaLeft: ((X: 0; Y: 0), (X: 2; Y: 0), (X: -1; Y: -1), (X: -1; Y: -1), (X: -2; Y: 0), (X: -2; Y: 0), (X: 1; Y: 0))),
448
449 (LeftAnim: True; wX: 64; wY: 64; AnimSpeed:(3, 2, 3, 4, 2, 0, 4); //KNIGHT
450 AnimCount: (2, 4, 7, 7, 3, 0, 1);
451 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));
452 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))),
453
454 (LeftAnim: False; wX: 88; wY: 69; AnimSpeed:(3, 2, 3, 4, 2, 0, 4); //CACO
455 AnimCount: (1, 1, 7, 7, 6, 0, 1);
456 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));
457 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))),
458
459 (LeftAnim: False; wX: 32; wY: 32; AnimSpeed:(3, 2, 3, 4, 1, 0, 4); //SOUL
460 AnimCount: (2, 2, 7, 7, 2, 0, 1); // 10
461 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));
462 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))),
463
464 (LeftAnim: False; wX: 64; wY: 64; AnimSpeed:(3, 2, 3, 4, 2, 0, 4); //PAIN
465 AnimCount: (4, 4, 7, 7, 4, 0, 1);
466 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));
467 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))),
468
469 (LeftAnim: True; wX: 128; wY: 64; AnimSpeed:(3, 2, 4, 4, 1, 0, 4); //SPIDER
470 AnimCount: (2, 6, 10, 10, 2, 0, 1);
471 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));
472 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))),
473
474 (LeftAnim: True; wX: 64; wY: 32; AnimSpeed:(3, 2, 3, 4, 1, 0, 4); //BSP
475 AnimCount: (2, 6, 7, 7, 2, 0, 1);
476 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));
477 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))),
478
479 (LeftAnim: False; wX: 64; wY: 64; AnimSpeed:(3, 2, 2, 4, 2, 0, 4); //MANCUB
480 AnimCount: (2, 6, 10, 10, 3, 0, 1);
481 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));
482 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))),
483
484 (LeftAnim: True; wX: 64; wY: 32; AnimSpeed:(3, 3, 3, 3, 3, 3, 3); //SKEL
485 AnimCount: (2, 6, 5, 5, 2, 2, 1);
486 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));
487 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))),
488
489 (LeftAnim: True; wX: 64; wY: 32; AnimSpeed:(3, 3, 3, 3, 3, 3, 3); //VILE
490 AnimCount: (2, 6, 9, 9, 10, 3, 1);
491 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));
492 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))),
493
494 (LeftAnim: False; wX: 8; wY: 8; AnimSpeed:(2, 2, 2, 2, 3, 0, 1); //FISH
495 AnimCount: (2, 4, 1, 1, 2, 0, 3);
496 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));
497 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 ))),
498
499 (LeftAnim: False; wX: 32; wY: 32; AnimSpeed:(3, 0, 3, 0, 0, 0, 5); //BARREL
500 AnimCount: (3, 0, 4, 0, 0, 0, 1);
501 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));
502 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))),
503
504 (LeftAnim: False; wX: 95; wY: 57; AnimSpeed:(1, 2, 1, 0, 1, 1, 0); //ROBO
505 AnimCount: (1, 12, 1, 0, 2, 4, 0);
506 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));
507 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))),
508
509 (LeftAnim: False; wX: 32; wY: 32; AnimSpeed:(3, 2, 2, 2, 2, 0, 5); //MAN
510 AnimCount: (2, 4, 7, 9, 2, 0, 1);
511 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));
512 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))) );
513
514 // Таблица типов анимации монстров:
515 ANIMTABLE: Array [ANIM_SLEEP..ANIM_PAIN] of
516 record
517 name: String;
518 loop: Boolean;
519 end = ((name: 'SLEEP'; loop: True),
520 (name: 'GO'; loop: True),
521 (name: 'DIE'; loop: False),
522 (name: 'MESS'; loop: False),
523 (name: 'ATTACK'; loop: False),
524 (name: 'ATTACK2'; loop: False),
525 (name: 'PAIN'; loop: False));
526 implementation
527
528 uses
529 {$IFDEF ENABLE_MENU}
530 g_menu,
531 {$ENDIF}
532 {$IFDEF ENABLE_GFX}
533 g_gfx,
534 {$ENDIF}
535 {$IFDEF ENABLE_GIBS}
536 g_gibs,
537 {$ENDIF}
538 {$IFDEF ENABLE_SHELLS}
539 g_shells,
540 {$ENDIF}
541 {$IFDEF ENABLE_CORPSES}
542 g_corpses,
543 {$ENDIF}
544 e_log, g_sound, g_player, g_game,
545 g_weapons, g_triggers, g_items, g_options, g_window,
546 g_console, g_map, Math, wadreader,
547 g_language, g_netmsg, idpool, utils, xstreams;
548
549
550 function g_Look(a, b: PObj; d: TDirection): Boolean;
551 begin
552 if not gmon_dbg_los_enabled then begin result := false; exit; end; // always "wall hit"
553
554 if ((b^.X > a^.X) and (d = TDirection.D_LEFT)) or
555 ((b^.X < a^.X) and (d = TDirection.D_RIGHT)) then
556 begin
557 Result := False;
558 Exit;
559 end;
560
561 Result := g_TraceVector(a^.X+a^.Rect.X+(a^.Rect.Width div 2),
562 a^.Y+a^.Rect.Y+(a^.Rect.Height div 2),
563 b^.X+b^.Rect.X+(b^.Rect.Width div 2),
564 b^.Y+b^.Rect.Y+(b^.Rect.Height div 2));
565 end;
566
567 // ////////////////////////////////////////////////////////////////////////// //
568 procedure g_Mons_ProfilersBegin ();
569 begin
570 if (profMonsLOS = nil) then profMonsLOS := TProfiler.Create('LOS CALC', g_profile_history_size);
571 if (profMonsLOS <> nil) then profMonsLOS.mainBegin(g_profile_los);
572 if g_profile_los and (profMonsLOS <> nil) then
573 begin
574 profMonsLOS.sectionBegin('loscalc');
575 profMonsLOS.sectionEnd();
576 end;
577 end;
578
579 procedure g_Mons_ProfilersEnd ();
580 begin
581 if (profMonsLOS <> nil) and (g_profile_los) then profMonsLOS.mainEnd();
582 end;
583
584 procedure g_Mons_LOS_Start (); inline;
585 begin
586 if (profMonsLOS <> nil) then profMonsLOS.sectionBeginAccum('loscalc');
587 end;
588
589 procedure g_Mons_LOS_End (); inline;
590 begin
591 if (profMonsLOS <> nil) then profMonsLOS.sectionEnd();
592 end;
593
594
595 // ////////////////////////////////////////////////////////////////////////// //
596 var
597 monCheckTrapLastFrameId: DWord = 0;
598 monCheckMPlatLastFrameId: LongWord = 0;
599
600
601 procedure TMonster.getMapBox (out x, y, w, h: Integer); inline;
602 begin
603 x := FObj.X+FObj.Rect.X;
604 y := FObj.Y+FObj.Rect.Y;
605 w := FObj.Rect.Width;
606 h := FObj.Rect.Height;
607 end;
608
609 function TMonster.gncNeedSend (): Boolean; inline; begin result := mNeedSend; mNeedSend := false; end;
610
611 procedure TMonster.setDirty (); inline; begin mNeedSend := true; end;
612
613
614 // ////////////////////////////////////////////////////////////////////////// //
615 {
616 function g_Mons_AlongLine (x0, y0, x1, y1: Integer; cb: TMonsAlongLineCB; log: Boolean=false): TMonster;
617 begin
618 if not assigned(cb) then begin result := nil; exit; end;
619 result := monsGrid.forEachAlongLine(x0, y0, x1, y1, cb, -1, log);
620 end;
621 }
622
623
624 //WARNING! call this after monster position was changed, or coldet will not work right!
625 procedure TMonster.positionChanged ();
626 var
627 x, y, w, h: Integer;
628 nx, ny, nw, nh: Integer;
629 begin
630 {$IF DEFINED(D2F_DEBUG_MONS_MOVE)}
631 //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);
632 {$ENDIF}
633 if (mProxyId = -1) then
634 begin
635 //mNeedSend := true;
636 mProxyId := monsGrid.insertBody(self, FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y, FObj.Rect.Width, FObj.Rect.Height);
637 {$IF DEFINED(D2F_DEBUG_MONS_MOVE)}
638 monsGrid.getBodyXY(mProxyId, x, y);
639 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);
640 {$ENDIF}
641 end
642 else
643 begin
644 monsGrid.getBodyDims(mProxyId, x, y, w, h);
645 getMapBox(nx, ny, nw, nh);
646
647 if (w <> nw) or (h <> nh) then
648 begin
649 //mNeedSend := true;
650 {$IF DEFINED(D2F_DEBUG_MONS_MOVE)}
651 e_WriteLog(Format('monster #%d:(%u): resized; mProxyid=%d; gx=%d; gy=%d', [mArrIdx, UID, mProxyId, x-monsGrid.gridX0, y-monsGrid.gridY0]), MSG_NOTIFY);
652 {$ENDIF}
653 monsGrid.moveResizeBody(mProxyId, nx, ny, nw, nh);
654 end
655 else if (x <> nx) or (y <> ny) then
656 begin
657 //mNeedSend := true;
658 {$IF DEFINED(D2F_DEBUG_MONS_MOVE)}
659 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);
660 {$ENDIF}
661 monsGrid.moveBody(mProxyId, nx, ny);
662 end
663 else
664 begin
665 exit; // nothing to do
666 end;
667 {$IF DEFINED(D2F_DEBUG_MONS_MOVE)}
668 monsGrid.getBodyXY(mProxyId, x, y);
669 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);
670 {$ENDIF}
671 end;
672 end;
673
674
675 // ////////////////////////////////////////////////////////////////////////// //
676 const
677 MONSTER_SIGNATURE = $534E4F4D; // 'MONS'
678
679 MAX_ATM = 89; // Время ожидания после потери цели
680 MAX_SOUL = 512; // Ограничение Lost_Soul'ов
681
682
683 // ////////////////////////////////////////////////////////////////////////// //
684 var
685 uidMap: array [0..65535] of TMonster; // monster knows it's index
686 freeInds: TIdPool = nil;
687
688
689 procedure clearUidMap ();
690 var
691 idx: Integer;
692 begin
693 for idx := 0 to High(uidMap) do uidMap[idx] := nil;
694 freeInds.clear();
695 end;
696
697
698 function g_Mons_getNewTrapFrameId (): DWord; inline;
699 var
700 f: Integer;
701 begin
702 Inc(monCheckTrapLastFrameId);
703 if (monCheckTrapLastFrameId = 0) then
704 begin
705 // wraparound
706 monCheckTrapLastFrameId := 1;
707 for f := 0 to High(gMonsters) do
708 begin
709 if (gMonsters[f] <> nil) then gMonsters[f].trapCheckFrameId := 0;
710 end;
711 end;
712 result := monCheckTrapLastFrameId;
713 end;
714
715
716 function g_Mons_getNewMPlatFrameId (): LongWord; inline;
717 var
718 f: Integer;
719 begin
720 Inc(monCheckMPlatLastFrameId);
721 if (monCheckMPlatLastFrameId = 0) then
722 begin
723 // wraparound
724 monCheckMPlatLastFrameId := 1;
725 for f := 0 to High(gMonsters) do
726 begin
727 if (gMonsters[f] <> nil) then gMonsters[f].mplatCheckFrameId := 0;
728 end;
729 end;
730 result := monCheckMPlatLastFrameId;
731 end;
732
733
734 var
735 pt_x: Integer = 0;
736 pt_xs: Integer = 1;
737 pt_y: Integer = 0;
738 pt_ys: Integer = 1;
739 soulcount: Integer = 0;
740
741
742 function allocMonster (): DWORD;
743 var
744 f, olen: Integer;
745 begin
746 result := freeInds.alloc();
747 if (result > High(gMonsters)) then
748 begin
749 olen := Length(gMonsters);
750 SetLength(gMonsters, result+64);
751 for f := olen to High(gMonsters) do gMonsters[f] := nil;
752 end;
753 end;
754
755
756 function IsFriend(a, b: Byte): Boolean;
757 begin
758 Result := True;
759
760 // Бочка - всем друг:
761 if (a = MONSTER_BARREL) or (b = MONSTER_BARREL) then
762 Exit;
763
764 // Монстры одного вида:
765 if a = b then
766 case a of
767 MONSTER_IMP, MONSTER_DEMON, MONSTER_BARON, MONSTER_KNIGHT, MONSTER_CACO,
768 MONSTER_SOUL, MONSTER_PAIN, MONSTER_MANCUB, MONSTER_SKEL, MONSTER_FISH:
769 Exit; // Эти не бьют своих
770 end;
771
772 // Lost_Soul не может ранить Pain_Elemental'а:
773 if (a = MONSTER_SOUL) and (b = MONSTER_PAIN) then
774 Exit;
775 // Pain_Elemental не может ранить Lost_Soul'а:
776 if (b = MONSTER_SOUL) and (a = MONSTER_PAIN) then
777 Exit;
778
779 // В остальных случаях - будут бить друг друга:
780 Result := False;
781 end;
782
783
784 function BehaviourDamage(SpawnerUID: Word; BH, SelfType: Byte): Boolean;
785 var
786 m: TMonster;
787 UIDType, MonsterType: Byte;
788 begin
789 Result := False;
790 MonsterType := 0;
791
792 UIDType := g_GetUIDType(SpawnerUID);
793 if UIDType = UID_MONSTER then
794 begin
795 m := g_Monsters_ByUID(SpawnerUID);
796 if m = nil then Exit;
797 MonsterType := m.FMonsterType;
798 end;
799
800 case BH of
801 BH_NORMAL: Result := (UIDType = UID_PLAYER) or
802 ((UIDType = UID_MONSTER) and (not IsFriend(MonsterType, SelfType)));
803
804 BH_KILLER: Result := UIDType = UID_PLAYER;
805 BH_MANIAC: Result := (UIDType = UID_PLAYER) or
806 ((UIDType = UID_MONSTER) and (not IsFriend(MonsterType, SelfType)));
807
808 BH_INSANE: Result := (UIDType = UID_MONSTER) and (not IsFriend(MonsterType, SelfType));
809 BH_CANNIBAL: Result := (UIDType = UID_MONSTER) and (MonsterType = SelfType);
810 end;
811 end;
812
813
814 function canShoot(m: Byte): Boolean;
815 begin
816 Result := False;
817
818 case m of
819 MONSTER_DEMON, MONSTER_FISH, MONSTER_BARREL:
820 Exit;
821 else
822 Result := True;
823 end;
824 end;
825
826
827 function isCorpse (o: PObj; immediately: Boolean): Integer;
828
829 (*
830 function monsCollCheck (mon: TMonster; atag: Integer): Boolean;
831 begin
832 atag := atag; // shut up, fpc!
833 result := false; // don't stop
834 if (mon.FState = MONSTATE_DEAD) and g_Obj_Collide(o, @mon.FObj) then
835 begin
836 case mon.FMonsterType of // Не воскресить:
837 MONSTER_SOUL, MONSTER_PAIN, MONSTER_CYBER, MONSTER_SPIDER,
838 MONSTER_VILE, MONSTER_BARREL, MONSTER_ROBO: exit;
839 end;
840 // Остальных можно воскресить
841 result := true;
842 end;
843 end;
844 *)
845
846 var
847 a: Integer;
848 mon: PMonster;
849 mres: TMonster = nil;
850 it: TMonsterGrid.Iter;
851 begin
852 result := -1;
853
854 // Если нужна вероятность
855 if not immediately and (Random(8) <> 0) then exit;
856
857 // Ищем мертвых монстров поблизости
858 if gmon_debug_use_sqaccel then
859 begin
860 //mon := monsGrid.forEachInAABB(o.X+o.Rect.X, o.Y+o.Rect.Y, o.Rect.Width, o.Rect.Height, monsCollCheck);
861 //if (mon <> nil) then result := mon.mArrIdx;
862 it := monsGrid.forEachInAABB(o.X+o.Rect.X, o.Y+o.Rect.Y, o.Rect.Width, o.Rect.Height);
863 for mon in it do
864 begin
865 case mon.FMonsterType of // Не воскресить:
866 MONSTER_SOUL, MONSTER_PAIN, MONSTER_CYBER, MONSTER_SPIDER,
867 MONSTER_VILE, MONSTER_BARREL, MONSTER_ROBO: begin end;
868 // Остальных можно воскресить
869 else mres := mon^;
870 end;
871 if (mres <> nil) then break;
872 end;
873 it.release();
874 if (mres <> nil) then result := mres.mArrIdx;
875 end
876 else
877 begin
878 for a := 0 to High(gMonsters) do
879 begin
880 if (gMonsters[a] <> nil) and (gMonsters[a].FState = MONSTATE_DEAD) and g_Obj_Collide(o, @gMonsters[a].FObj) then
881 begin
882 case gMonsters[a].FMonsterType of // Не воскресить:
883 MONSTER_SOUL, MONSTER_PAIN, MONSTER_CYBER, MONSTER_SPIDER,
884 MONSTER_VILE, MONSTER_BARREL, MONSTER_ROBO: Continue;
885 else // Остальных можно воскресить
886 begin
887 Result := a;
888 Exit;
889 end;
890 end;
891 end;
892 end;
893 end;
894 end;
895
896 procedure g_Monsters_LoadData();
897 begin
898 e_WriteLog('Loading monsters data...', TMsgType.Notify);
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] := TAnimState.Create(ANIMTABLE[a].loop, MONSTER_ANIMTABLE[MonsterType].AnimSpeed[a], MONSTER_ANIMTABLE[MonsterType].AnimCount[a]);
1682 FAnim[a, TDirection.D_LEFT] := TAnimState.Create(ANIMTABLE[a].loop, MONSTER_ANIMTABLE[MonsterType].AnimSpeed[a], MONSTER_ANIMTABLE[MonsterType].AnimCount[a]);
1683 end;
1684
1685 FVileFireTime := gTime;
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].Invalidate;
1879 FAnim[a, TDirection.D_RIGHT].Invalidate;
1880 end;
1881
1882 FVileFireTime := 0;
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].IsValid() 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 {$IFDEF ENABLE_CORPSES}
2074 var co: TObj;
2075 {$ENDIF}
2076 {$IF DEFINED(ENABLE_GIBS) OR DEFINED(ENABLE_CORPSES)}
2077 var b: Integer;
2078 {$ENDIF}
2079 var
2080 a, sx, sy, wx, wy, oldvelx: Integer;
2081 st: Word;
2082 o: TObj;
2083 fall, bubbles: Boolean;
2084 mon: TMonster;
2085 mit: PMonster;
2086 it: TMonsterGrid.Iter;
2087 label
2088 _end;
2089 begin
2090 fall := True;
2091 bubbles := True;
2092
2093 // Монстр статичен пока идет warmup
2094 if (gLMSRespawn > LMS_RESPAWN_NONE) then exit;
2095
2096 // Рыбы "летают" только в воде:
2097 if FMonsterType = MONSTER_FISH then
2098 if g_Obj_CollidePanel(@FObj, 0, 0, PANEL_WATER or PANEL_ACID1 or PANEL_ACID2) then
2099 if (FState <> MONSTATE_DIE) and (FState <> MONSTATE_DEAD) then
2100 fall := False;
2101
2102 // Летающие монтсры:
2103 if ((FMonsterType = MONSTER_SOUL) or
2104 (FMonsterType = MONSTER_PAIN) or
2105 (FMonsterType = MONSTER_CACO)) and
2106 (FState <> MONSTATE_DIE) and
2107 (FState <> MONSTATE_DEAD) then
2108 fall := False;
2109
2110 // Меняем скорость только по четным кадрам:
2111 if gTime mod (GAME_TICK*2) <> 0 then
2112 begin
2113 g_Obj_Move(@FObj, fall, True, True);
2114 positionChanged(); // this updates spatial accelerators
2115 Exit;
2116 end;
2117
2118 if FPainTicks > 0 then
2119 Dec(FPainTicks)
2120 else
2121 FPainSound := False;
2122
2123 // Двигаемся:
2124 st := g_Obj_Move(@FObj, fall, True, True);
2125 positionChanged(); // this updates spatial accelerators
2126
2127 // Если горим - поджигаем других монстров, но не на 100 тиков каждый раз:
2128 if FFireTime > 0 then
2129 begin
2130 it := monsGrid.forEachInAABB(FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y, FObj.Rect.Width, FObj.Rect.Height);
2131 for mit in it do
2132 if mit.UID <> FUID then
2133 mit.CatchFire(FFireAttacker, FFireTime);
2134 end;
2135
2136 // Вылетел за карту - удаляем и запускаем триггеры:
2137 if WordBool(st and MOVE_FALLOUT) or (FObj.X < -1000) or
2138 (FObj.X > gMapInfo.Width+1000) or (FObj.Y < -1000) then
2139 begin
2140 FRemoved := True;
2141 if alive and (gLMSRespawn = LMS_RESPAWN_NONE) then
2142 begin
2143 Inc(gCoopMonstersKilled);
2144 if g_Game_IsNet then
2145 MH_SEND_GameStats;
2146 end;
2147 ActivateTriggers();
2148 Exit;
2149 end;
2150
2151 oldvelx := FObj.Vel.X;
2152
2153 // Сопротивление воздуха для трупа:
2154 if (FState = MONSTATE_DIE) or (FState = MONSTATE_DEAD) then
2155 FObj.Vel.X := z_dec(FObj.Vel.X, 1);
2156
2157 if FFireTime > 0 then
2158 begin
2159 if WordBool(st and MOVE_INWATER) then
2160 FFireTime := 0
2161 else
2162 begin
2163 OnFireFlame(1);
2164 FFireTime := FFireTime - 1;
2165 if (FState <> MONSTATE_DIE) and (FState <> MONSTATE_DEAD) then
2166 if FFirePainTime = 0 then
2167 begin
2168 Damage(5, FFireAttacker, 0, 0, HIT_FLAME);
2169 FFirePainTime := 18;
2170 end
2171 else
2172 FFirePainTime := FFirePainTime - 1;
2173 end;
2174 end;
2175
2176 // Мертвый ничего не делает:
2177 if (FState = MONSTATE_DEAD) then
2178 goto _end;
2179
2180 // AI монстров выключен:
2181 if g_debug_MonsterOff then
2182 begin
2183 FSleep := 1;
2184 if FState <> MONSTATE_SLEEP then
2185 SetState(MONSTATE_SLEEP);
2186 end;
2187
2188 // Возможно, создаем пузырьки в воде:
2189 if WordBool(st and MOVE_INWATER) and (Random(32) = 0) then
2190 begin
2191 {$IFDEF ENABLE_GFX}
2192 case FMonsterType of
2193 MONSTER_FISH:
2194 if Random(4) <> 0 then bubbles := False else
2195 g_GFX_Bubbles(FObj.X+FObj.Rect.X + Random(FObj.Rect.Width),
2196 FObj.Y+FObj.Rect.Y + Random(4), 1, 0, 0);
2197 MONSTER_ROBO, MONSTER_BARREL:
2198 g_GFX_Bubbles(FObj.X+FObj.Rect.X + Random(FObj.Rect.Width),
2199 FObj.Y+FObj.Rect.Y + Random(4), 1, 0, 0);
2200 else
2201 g_GFX_Bubbles(FObj.X+FObj.Rect.X + Random(FObj.Rect.Width-4),
2202 FObj.Y+FObj.Rect.Y + Random(4), 5, 4, 4);
2203 end;
2204 {$ENDIF}
2205 if bubbles then if Random(2) = 0
2206 then g_Sound_PlayExAt('SOUND_GAME_BUBBLE1', FObj.X, FObj.Y)
2207 else g_Sound_PlayExAt('SOUND_GAME_BUBBLE2', FObj.X, FObj.Y);
2208 end;
2209
2210 // Если прошел первый кадр анимации взрыва бочки, то взрыв:
2211 if FMonsterType = MONSTER_BARREL then
2212 begin
2213 if (FState = MONSTATE_DIE) and (FAnim[FCurAnim, FDirection].CurrentFrame = 1) and
2214 (FAnim[FCurAnim, FDirection].Counter = 0) then
2215 g_Weapon_Explode(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
2216 FObj.Y+FObj.Rect.Y+FObj.Rect.Height-16,
2217 60, FUID);
2218 end;
2219
2220 // Lost_Soul вылетел из воды => ускоряется:
2221 if FMonsterType = MONSTER_SOUL then
2222 if WordBool(st and MOVE_HITAIR) then
2223 g_Obj_SetSpeed(@FObj, 16);
2224
2225 if FAmmo < 0 then
2226 FAmmo := FAmmo + 1;
2227
2228 // Если начали всплывать, то продолжаем:
2229 if FObj.Vel.Y < 0 then
2230 if WordBool(st and MOVE_INWATER) then
2231 FObj.Vel.Y := -4;
2232
2233 // Таймер - ждем после потери цели:
2234 FTargetTime := FTargetTime + 1;
2235
2236 {$IFDEF ENABLE_SHELLS}
2237 // Гильзы
2238 if FShellTimer > -1 then
2239 begin
2240 if FShellTimer = 0 then
2241 begin
2242 if FShellType = SHELL_SHELL 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, GameVelY-2, SHELL_SHELL)
2247 end
2248 else if FShellType = SHELL_DBLSHELL then
2249 begin
2250 g_Shells_Create(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
2251 FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
2252 GameVelX-1, GameVelY-2, SHELL_SHELL);
2253 g_Shells_Create(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
2254 FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
2255 GameVelX+1, GameVelY-2, SHELL_SHELL);
2256 end;
2257 FShellTimer := -1;
2258 end
2259 else
2260 begin
2261 Dec(FShellTimer);
2262 end;
2263 end;
2264 {$ENDIF}
2265
2266 // Пробуем увернуться от летящей пули:
2267 if fall then
2268 if (FState in [MONSTATE_GO, MONSTATE_RUN, MONSTATE_RUNOUT,
2269 MONSTATE_ATTACK, MONSTATE_SHOOT]) then
2270 if g_Weapon_Danger(FUID, FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y,
2271 FObj.Rect.Width, FObj.Rect.Height, 50) then
2272 if (g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj)) and
2273 (FObj.Accel.Y = 0) then
2274 FObj.Vel.Y := -MONSTERTABLE[FMonsterType].Jump;
2275
2276 case FState of
2277 MONSTATE_PAIN: // Состояние - Боль
2278 begin
2279 // Боль сильная => монстр кричит:
2280 if FPain >= MONSTERTABLE[FMonsterType].Pain then
2281 begin
2282 FPain := MONSTERTABLE[FMonsterType].Pain;
2283 if gSoundEffectsDF then PainSound();
2284 end;
2285 if (not gSoundEffectsDF) and (FPain >= MONSTERTABLE[FMonsterType].MinPain) then
2286 PainSound();
2287
2288 // Снижаем боль со временем:
2289 FPain := FPain - 5;
2290
2291 // Боль уже не ошутимая => идем дальше:
2292 if FPain <= MONSTERTABLE[FMonsterType].MinPain then
2293 begin
2294 FPain := 0;
2295 FAmmo := -9;
2296 SetState(MONSTATE_GO);
2297 end;
2298 end;
2299
2300 MONSTATE_SLEEP: // Состояние - Сон
2301 begin
2302 // Спим:
2303 FSleep := FSleep + 1;
2304
2305 // Проспали достаточно:
2306 if FSleep >= 18 then
2307 FSleep := 0
2308 else // еще спим
2309 goto _end;
2310
2311 // На игроков идут только обычные монстры, киллеры и маньяки
2312 if (FBehaviour = BH_NORMAL) or (FBehaviour = BH_KILLER) or (FBehaviour = BH_MANIAC) then
2313 // Если есть игрок рядом, просыпаемся и идем к нему:
2314 if (gPlayers <> nil) then
2315 for a := 0 to High(gPlayers) do
2316 if (gPlayers[a] <> nil) and (gPlayers[a].alive)
2317 and (not gPlayers[a].NoTarget) and (gPlayers[a].FMegaRulez[MR_INVIS] < gTime) then
2318 with gPlayers[a] do
2319 if g_Look(@FObj, @Obj, FDirection) then
2320 begin
2321 FTargetUID := gPlayers[a].UID;
2322 FTargetTime := 0;
2323 WakeUpSound();
2324 SetState(MONSTATE_GO);
2325 Break;
2326 end;
2327
2328 // На монстров тянет маньяков, поехавших и каннибалов
2329 if (FTargetUID = 0) and ((FBehaviour = BH_MANIAC)
2330 or (FBehaviour = BH_INSANE) or (FBehaviour = BH_CANNIBAL)) then
2331 // Если есть подходящий монстр рядом:
2332 if gMonsters <> nil then
2333 for a := 0 to High(gMonsters) do
2334 if (gMonsters[a] <> nil) and (gMonsters[a].alive) and
2335 (gMonsters[a].FUID <> FUID) then
2336 begin
2337 // Маньяки нападают на всех монстров, кроме друзей
2338 if (FBehaviour = BH_MANIAC) and
2339 (IsFriend(gMonsters[a].FMonsterType, FMonsterType)) then
2340 Continue;
2341 // Поехавшие также, но могут обозлиться на бочку
2342 if (FBehaviour = BH_INSANE) and (gMonsters[a].FMonsterType <> MONSTER_BARREL) and
2343 (IsFriend(gMonsters[a].FMonsterType, FMonsterType)) then
2344 Continue;
2345 // Каннибалы нападают на себе подобных
2346 if (FBehaviour = BH_CANNIBAL) and (gMonsters[a].FMonsterType <> FMonsterType) then
2347 Continue;
2348 if g_Look(@FObj, @gMonsters[a].Obj, FDirection) then
2349 begin
2350 FTargetUID := gMonsters[a].UID;
2351 FTargetTime := 0;
2352 WakeUpSound();
2353 SetState(MONSTATE_GO);
2354 Break;
2355 end;
2356 end;
2357 end;
2358
2359 MONSTATE_WAIT: // Состояние - Ожидание
2360 begin
2361 // Ждем:
2362 FSleep := FSleep - 1;
2363
2364 // Выждали достаточно - идем:
2365 if FSleep < 0 then
2366 SetState(MONSTATE_GO);
2367 end;
2368
2369 MONSTATE_GO: // Состояние - Движение (с осмотром ситуации)
2370 begin
2371 // Если наткнулись на БлокМон - убегаем от него:
2372 if WordBool(st and MOVE_BLOCK) then
2373 begin
2374 Turn();
2375 FSleep := 40;
2376 SetState(MONSTATE_RUNOUT);
2377
2378 goto _end;
2379 end;
2380
2381 // Если монстр - колдун, то пробуем воскресить кого-нибудь:
2382 if (FMonsterType = MONSTER_VILE) then
2383 if isCorpse(@FObj, False) <> -1 then
2384 begin
2385 FObj.Vel.X := 0;
2386 SetState(MONSTATE_ATTACK, ANIM_ATTACK2);
2387
2388 goto _end;
2389 end;
2390
2391 // Цель погибла или давно ждем:
2392 if (not GetPos(FTargetUID, @o)) or (FTargetTime > MAX_ATM) then
2393 if not findNewPrey() then
2394 begin // Новых целей нет
2395 FTargetUID := 0;
2396 o.X := FObj.X+pt_x;
2397 o.Y := FObj.Y+pt_y;
2398 o.Vel.X := 0;
2399 o.Vel.Y := 0;
2400 o.Accel.X := 0;
2401 o.Accel.Y := 0;
2402 o.Rect := _Rect(0, 0, 0, 1);
2403 end
2404 else // Новая цель есть - берем ее координаты
2405 GetPos(FTargetUID, @o);
2406
2407 // Цель очень близко - пинаем:
2408 if g_Obj_Collide(@FObj, @o) and (FTargetUID <> 0) then
2409 begin
2410 FTargetTime := 0;
2411 if (FMonsterType <> MONSTER_CYBER) or (Random(2) = 0) then
2412 begin
2413 if kick(@o) then
2414 goto _end;
2415 end;
2416 end;
2417
2418 // Расстояние до цели:
2419 sx := o.X+o.Rect.X+(o.Rect.Width div 2)-(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2));
2420 sy := o.Y+o.Rect.Y+(o.Rect.Height div 2)-(FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2));
2421
2422 // Поворачиваемся в сторону цели:
2423 if sx > 0 then
2424 FDirection := TDirection.D_RIGHT
2425 else
2426 FDirection := TDirection.D_LEFT;
2427
2428 // Если монстр умеет стрелять и есть по кому - стреляем:
2429 if canShoot(FMonsterType) and (FTargetUID <> 0) then
2430 if Abs(sx) > Abs(sy) then // угол выстрела удобный
2431 if shoot(@o, False) then
2432 goto _end;
2433
2434 // Если цель почти на одной вертикали - бегаем туда-сюда:
2435 if Abs(sx) < 40 then
2436 if FMonsterType <> MONSTER_FISH then
2437 begin
2438 FSleep := 15;
2439 SetState(MONSTATE_RUN);
2440 if Random(2) = 0 then
2441 FDirection := TDirection.D_LEFT
2442 else
2443 FDirection := TDirection.D_RIGHT;
2444
2445 goto _end;
2446 end;
2447
2448 // Уперлись в стену:
2449 if WordBool(st and MOVE_HITWALL) then
2450 begin
2451 if g_Triggers_PressR(FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y, FObj.Rect.Width,
2452 FObj.Rect.Height, FUID, ACTIVATE_MONSTERPRESS) <> nil then
2453 begin // Смогли нажать кнопку - небольшое ожидание
2454 FSleep := 4;
2455 SetState(MONSTATE_WAIT);
2456
2457 goto _end;
2458 end;
2459
2460 case FMonsterType of
2461 MONSTER_CACO, MONSTER_SOUL, MONSTER_PAIN, MONSTER_FISH: ;
2462 else // Не летают:
2463 if (g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj)) and
2464 (FObj.Accel.Y = 0) then
2465 begin // Стоим на твердом полу или ступени
2466 // Прыжок через стену:
2467 FObj.Vel.Y := -MONSTERTABLE[FMonsterType].Jump;
2468 SetState(MONSTATE_CLIMB);
2469 end;
2470 end;
2471
2472 goto _end;
2473 end;
2474
2475 // Монстры, не подверженные гравитации:
2476 if (FMonsterType = MONSTER_CACO) or (FMonsterType = MONSTER_SOUL) or
2477 (FMonsterType = MONSTER_PAIN) or (FMonsterType = MONSTER_FISH) then
2478 begin
2479 if FMonsterType = MONSTER_FISH then
2480 begin // Рыба
2481 if not WordBool(st and MOVE_INWATER) then
2482 begin // Рыба вне воды:
2483 if g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj) then
2484 begin // "Стоит" твердо
2485 // Рыба трепыхается на поверхности:
2486 if FObj.Accel.Y = 0 then FObj.Vel.Y := -6;
2487 FObj.Accel.X := FObj.Accel.X - 8 + Random(17);
2488 end;
2489
2490 // Рыбе больно:
2491 SetState(MONSTATE_PAIN);
2492 FPain := FPain + 50;
2493 end
2494 else // Рыба в воде
2495 begin
2496 // Плывем в сторону цели по-вертикали:
2497 if Abs(sy) > 8 then
2498 FObj.Vel.Y := g_basic.Sign(sy)*4
2499 else
2500 FObj.Vel.Y := 0;
2501
2502 // Рыба плывет вверх:
2503 if FObj.Vel.Y < 0 then
2504 if not g_Obj_CollideLiquid(@FObj, 0, -16) then
2505 begin
2506 // Всплыли до поверхности - стоп:
2507 FObj.Vel.Y := 0;
2508 // Плаваем туда-сюда:
2509 if Random(2) = 0 then
2510 FDirection := TDirection.D_LEFT
2511 else
2512 FDirection := TDirection.D_RIGHT;
2513 FSleep := 20;
2514 SetState(MONSTATE_RUN);
2515 end;
2516 end;
2517 end
2518 else // Летающие монстры
2519 begin
2520 // Летим в сторону цели по-вертикали:
2521 if Abs(sy) > 8 then
2522 FObj.Vel.Y := g_basic.Sign(sy)*4
2523 else
2524 FObj.Vel.Y := 0;
2525 end;
2526 end
2527 else // "Наземные" монстры
2528 begin
2529 {$IFDEF ENABLE_GIBS}
2530 // Возможно, пинаем куски:
2531 if (FObj.Vel.X <> 0) and (gGibs <> nil) then
2532 begin
2533 b := Abs(FObj.Vel.X);
2534 if b > 1 then b := b * (Random(8 div b) + 1);
2535 for a := 0 to High(gGibs) do
2536 begin
2537 if gGibs[a].alive and
2538 g_Obj_Collide(FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y+FObj.Rect.Height-4,
2539 FObj.Rect.Width, 8, @gGibs[a].Obj) and (Random(3) = 0) then
2540 begin
2541 // Пинаем куски
2542 if FObj.Vel.X < 0 then
2543 begin
2544 g_Obj_PushA(@gGibs[a].Obj, b, Random(61)+120); // налево
2545 end
2546 else
2547 begin
2548 g_Obj_PushA(@gGibs[a].Obj, b, Random(61)); // направо
2549 end;
2550 end;
2551 end;
2552 end;
2553 {$ENDIF}
2554 {$IFDEF ENABLE_CORPSES}
2555 // Боссы могут пинать трупы:
2556 if (FMonsterType in [MONSTER_CYBER, MONSTER_SPIDER, MONSTER_ROBO]) and
2557 (FObj.Vel.X <> 0) and (gCorpses <> nil) then
2558 begin
2559 b := Abs(FObj.Vel.X);
2560 if b > 1 then b := b * (Random(8 div b) + 1);
2561 for a := 0 to High(gCorpses) do
2562 if (gCorpses[a] <> nil) and (gCorpses[a].State > 0) then
2563 begin
2564 co := gCorpses[a].Obj;
2565 if g_Obj_Collide(FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y+FObj.Rect.Height-4,
2566 FObj.Rect.Width, 8, @co) and (Random(3) = 0) then
2567 // Пинаем трупы
2568 if FObj.Vel.X < 0 then
2569 gCorpses[a].Damage(b*2, FUID, -b, Random(7)) // налево
2570 else
2571 gCorpses[a].Damage(b*2, FUID, b, Random(7)); // направо
2572 end;
2573 end;
2574 {$ENDIF}
2575 // Если цель высоко, то, возможно, прыгаем:
2576 if sy < -40 then
2577 if g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj) then
2578 // стоит твердо
2579 if (Random(4) = 0) and (FObj.Accel.Y = 0) then
2580 FObj.Vel.Y := -MONSTERTABLE[FMonsterType].Jump;
2581 end;
2582
2583 FSleep := FSleep + 1;
2584
2585 // Иногда рычим:
2586 if FSleep >= 8 then
2587 begin
2588 FSleep := 0;
2589 if Random(8) = 0 then
2590 ActionSound();
2591 end;
2592
2593 // Бежим в выбранную сторону:
2594 if FDirection = TDirection.D_RIGHT then
2595 FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
2596 else
2597 FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
2598
2599 // Если в воде, то замедляемся:
2600 if WordBool(st and MOVE_INWATER) then
2601 FObj.Vel.X := FObj.Vel.X div 2
2602 else // Рыбам не нужно замедляться
2603 if FMonsterType = MONSTER_FISH then
2604 FObj.Vel.X := 0;
2605 end;
2606
2607 MONSTATE_RUN: // Состояние - Бег
2608 begin
2609 // Если наткнулись на БлокМон - убегаем от него:
2610 if WordBool(st and MOVE_BLOCK) then
2611 begin
2612 Turn();
2613 FSleep := 40;
2614 SetState(MONSTATE_RUNOUT);
2615
2616 goto _end;
2617 end;
2618
2619 FSleep := FSleep - 1;
2620
2621 // Пробежали достаточно или врезались в стену => переходим на шаг:
2622 if (FSleep <= 0) or (WordBool(st and MOVE_HITWALL) and ((FObj.Vel.Y+FObj.Accel.Y) = 0)) then
2623 begin
2624 FSleep := 0;
2625 SetState(MONSTATE_GO);
2626 // Стена - идем обратно:
2627 if WordBool(st and (MOVE_HITWALL or MOVE_BLOCK)) then
2628 Turn();
2629 // Иногда рычим:
2630 if Random(8) = 0 then
2631 ActionSound();
2632 end;
2633
2634 // Бежим в выбранную сторону:
2635 if FDirection = TDirection.D_RIGHT then
2636 FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
2637 else
2638 FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
2639
2640 // Если в воде, то замедляемся:
2641 if WordBool(st and MOVE_INWATER) then
2642 FObj.Vel.X := FObj.Vel.X div 2
2643 else // Рыбам не нужно замедляться
2644 if FMonsterType = MONSTER_FISH then
2645 FObj.Vel.X := 0;
2646 end;
2647
2648 MONSTATE_RUNOUT: // Состояние - Убегает от чего-то
2649 begin
2650 // Вышли из БлокМона:
2651 if (not WordBool(st and MOVE_BLOCK)) and (FSleep > 0) then
2652 FSleep := 0;
2653
2654 FSleep := FSleep - 1;
2655
2656 // Убажели достаточно далеко => переходим на шаг:
2657 if FSleep <= -18 then
2658 begin
2659 FSleep := 0;
2660 SetState(MONSTATE_GO);
2661 // Стена/БлокМон - идем обратно:
2662 if WordBool(st and (MOVE_HITWALL or MOVE_BLOCK)) then
2663 Turn();
2664 // Иногда рычим:
2665 if Random(8) = 0 then
2666 ActionSound();
2667 end;
2668
2669 // Бежим в выбранную сторону:
2670 if FDirection = TDirection.D_RIGHT then
2671 FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
2672 else
2673 FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
2674
2675 // Если в воде, то замедляемся:
2676 if WordBool(st and MOVE_INWATER) then
2677 FObj.Vel.X := FObj.Vel.X div 2
2678 else // Рыбам не нужно замедляться
2679 if FMonsterType = MONSTER_FISH then
2680 FObj.Vel.X := 0;
2681 end;
2682
2683 MONSTATE_CLIMB: // Состояние - Прыжок (чтобы обойти стену)
2684 begin
2685 // Достигли высшей точки прыжка или стена кончилась => переходим на шаг:
2686 if ((FObj.Vel.Y+FObj.Accel.Y) >= 0) or
2687 (not WordBool(st and MOVE_HITWALL)) then
2688 begin
2689 FSleep := 0;
2690 SetState(MONSTATE_GO);
2691
2692 // Стена не кончилась => бежим от нее:
2693 if WordBool(st and (MOVE_HITWALL or MOVE_BLOCK)) then
2694 begin
2695 Turn();
2696 FSleep := 15;
2697 SetState(MONSTATE_RUN);
2698 end;
2699 end;
2700
2701 // Бежим в выбранную сторону:
2702 if FDirection = TDirection.D_RIGHT then
2703 FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
2704 else
2705 FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
2706
2707 // Если в воде, то замедляемся:
2708 if WordBool(st and MOVE_INWATER) then
2709 FObj.Vel.X := FObj.Vel.X div 2
2710 else // Рыбам не нужно замедляться
2711 if FMonsterType = MONSTER_FISH then
2712 FObj.Vel.X := 0;
2713 end;
2714
2715 MONSTATE_ATTACK, // Состояние - Атака
2716 MONSTATE_SHOOT: // Состояние - Стрельба
2717 begin
2718 // Lost_Soul врезался в стену при атаке => переходит на шаг:
2719 if FMonsterType = MONSTER_SOUL then
2720 begin
2721 if WordBool(st and (MOVE_HITWALL or MOVE_HITCEIL or MOVE_HITLAND)) then
2722 SetState(MONSTATE_GO);
2723
2724 goto _end;
2725 end;
2726
2727 // Замедляемся при атаке:
2728 if FMonsterType <> MONSTER_FISH then
2729 FObj.Vel.X := z_dec(FObj.Vel.X, 1);
2730
2731 // Нужно стрелять, а монстр - колдун:
2732 if (FMonsterType = MONSTER_VILE) and (FState = MONSTATE_SHOOT) then
2733 begin
2734 // Цель погибла => идем дальше:
2735 if not GetPos(FTargetUID, @o) then
2736 begin
2737 SetState(MONSTATE_GO);
2738
2739 goto _end;
2740 end;
2741
2742 // Цель не видно => идем дальше:
2743 if not g_Look(@FObj, @o, FDirection) then
2744 begin
2745 SetState(MONSTATE_GO);
2746
2747 goto _end;
2748 end;
2749
2750 // Цель в воде - не загорится => идем дальше:
2751 if g_Obj_CollideWater(@o, 0, 0) then
2752 begin
2753 SetState(MONSTATE_GO);
2754
2755 goto _end;
2756 end;
2757
2758 // Жарим цель:
2759 tx := o.X+o.Rect.X+(o.Rect.Width div 2);
2760 ty := o.Y+o.Rect.Y+(o.Rect.Height div 2);
2761 g_Weapon_HitUID(FTargetUID, 2, FUID, HIT_SOME);
2762 end;
2763 end;
2764 end; // case FState of ...
2765
2766 _end:
2767
2768 // Состояние - Воскрешение:
2769 if FState = MONSTATE_REVIVE then
2770 if FAnim[FCurAnim, FDirection].Played then
2771 begin // Обратная анимация умирания закончилась - идем дальше:
2772 FAnim[FCurAnim, FDirection].Revert(False);
2773 SetState(MONSTATE_GO);
2774 end;
2775
2776 // Состояние - Умирает и текущая анимация проиграна:
2777 if (FState = MONSTATE_DIE) and
2778 (FAnim[FCurAnim, FDirection].IsValid()) and
2779 (FAnim[FCurAnim, FDirection].Played) then
2780 begin
2781 // Умер:
2782 SetState(MONSTATE_DEAD);
2783
2784 // Pain_Elemental при смерти выпускает 3 Lost_Soul'а:
2785 if (FMonsterType = MONSTER_PAIN) then
2786 begin
2787 mon := g_Monsters_Create(MONSTER_SOUL, FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2)-30,
2788 FObj.Y+FObj.Rect.Y+20, TDirection.D_LEFT);
2789 if mon <> nil then
2790 begin
2791 mon.SetState(MONSTATE_GO);
2792 mon.FNoRespawn := True;
2793 Inc(gTotalMonsters);
2794 if g_Game_IsNet then MH_SEND_MonsterSpawn(mon.UID);
2795 end;
2796
2797 mon := g_Monsters_Create(MONSTER_SOUL, FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
2798 FObj.Y+FObj.Rect.Y+20, TDirection.D_RIGHT);
2799 if mon <> nil then
2800 begin
2801 mon.SetState(MONSTATE_GO);
2802 mon.FNoRespawn := True;
2803 Inc(gTotalMonsters);
2804 if g_Game_IsNet then MH_SEND_MonsterSpawn(mon.UID);
2805 end;
2806
2807 mon := g_Monsters_Create(MONSTER_SOUL, FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2)-15,
2808 FObj.Y+FObj.Rect.Y, TDirection.D_RIGHT);
2809 if mon <> nil then
2810 begin
2811 mon.SetState(MONSTATE_GO);
2812 mon.FNoRespawn := True;
2813 Inc(gTotalMonsters);
2814 if g_Game_IsNet then MH_SEND_MonsterSpawn(mon.UID);
2815 end;
2816
2817 if g_Game_IsNet then MH_SEND_CoopStats();
2818 end;
2819
2820 // У этих монстров нет трупов:
2821 if (FMonsterType = MONSTER_PAIN) or
2822 (FMonsterType = MONSTER_SOUL) or
2823 (FMonsterType = MONSTER_BARREL) then
2824 FRemoved := True;
2825 end;
2826
2827 // Совершение атаки и стрельбы:
2828 if (FState = MONSTATE_ATTACK) or (FState = MONSTATE_SHOOT) then
2829 if (FAnim[FCurAnim, FDirection].IsValid()) then
2830 // Анимация атаки есть - можно атаковать
2831 if (FAnim[FCurAnim, FDirection].Played) then
2832 begin // Анимация атаки закончилась => переходим на шаг
2833 if FState = MONSTATE_ATTACK then
2834 begin // Состояние - Атака
2835 // Если монстр не Lost_Soul, то после атаки переходим на шаг:
2836 if FMonsterType <> MONSTER_SOUL then
2837 SetState(MONSTATE_GO);
2838 end
2839 else // Состояние - Стрельба
2840 begin
2841 // Переходим на шаг, если не надо стрелять еще раз:
2842 if not FChainFire then
2843 SetState(MONSTATE_GO)
2844 else
2845 begin // Надо стрелять еще
2846 FChainFire := False;
2847 // Т.к. состояние не изменилось, и нужен
2848 // новый цикл ожидания завершения анимации:
2849 FAnim[FCurAnim, FDirection].Reset();
2850 end;
2851 end;
2852
2853 FWaitAttackAnim := False;
2854 end
2855
2856 else // Анимация атаки еще идет (исключение - Lost_Soul):
2857 if (FMonsterType = MONSTER_SOUL) or
2858 ( (not FWaitAttackAnim) and
2859 (FAnim[FCurAnim, FDirection].CurrentFrame =
2860 (FAnim[FCurAnim, FDirection].TotalFrames div 2))
2861 ) then
2862 begin // Атаки еще не было и это середина анимации атаки
2863 if FState = MONSTATE_ATTACK then
2864 begin // Состояние - Атака
2865 // Если это Lost_Soul, то сбрасываем анимацию атаки:
2866 if FMonsterType = MONSTER_SOUL then
2867 FAnim[FCurAnim, FDirection].Reset();
2868
2869 case FMonsterType of
2870 MONSTER_SOUL, MONSTER_IMP, MONSTER_DEMON:
2871 // Грызем первого попавшегося:
2872 if g_Weapon_Hit(@FObj, 15, FUID, HIT_SOME) <> 0 then
2873 // Lost_Soul укусил кого-то => переходит на шаг:
2874 if FMonsterType = MONSTER_SOUL then
2875 SetState(MONSTATE_GO);
2876
2877 MONSTER_FISH:
2878 // Рыба кусает первого попавшегося со звуком:
2879 if g_Weapon_Hit(@FObj, 10, FUID, HIT_SOME) <> 0 then
2880 g_Sound_PlayExAt('SOUND_MONSTER_FISH_ATTACK', FObj.X, FObj.Y);
2881
2882 MONSTER_SKEL, MONSTER_ROBO, MONSTER_CYBER:
2883 // Робот, кибер или скелет сильно пинаются:
2884 if FCurAnim = ANIM_ATTACK2 then
2885 begin
2886 o := FObj;
2887 o.Vel.X := IfThen(FDirection = TDirection.D_RIGHT, 1, -1)*IfThen(FMonsterType = MONSTER_CYBER, 60, 50);
2888 if g_Weapon_Hit(@o, IfThen(FMonsterType = MONSTER_CYBER, 33, 50), FUID, HIT_SOME) <> 0 then
2889 g_Sound_PlayExAt('SOUND_MONSTER_SKEL_HIT', FObj.X, FObj.Y);
2890 end;
2891
2892 MONSTER_VILE:
2893 // Колдун пытается воскрешать:
2894 if FCurAnim = ANIM_ATTACK2 then
2895 begin
2896 sx := isCorpse(@FObj, True);
2897 if sx <> -1 then
2898 begin // Нашли, кого воскресить
2899 gMonsters[sx].SetState(MONSTATE_REVIVE);
2900 g_Sound_PlayExAt('SOUND_MONSTER_SLOP', FObj.X, FObj.Y);
2901 // Воскрешать - себе вредить:
2902 {g_Weapon_HitUID(FUID, 5, 0, HIT_SOME);}
2903 end;
2904 end;
2905 end;
2906 end
2907
2908 else // Состояние - Стрельба
2909 begin
2910 // Вычисляем координаты, откуда вылетит пуля:
2911 wx := MONSTER_ANIMTABLE[FMonsterType].wX;
2912
2913 if FDirection = TDirection.D_LEFT then
2914 begin
2915 wx := MONSTER_ANIMTABLE[FMonsterType].wX-(MONSTERTABLE[FMonsterType].Rect.X+(MONSTERTABLE[FMonsterType].Rect.Width div 2));
2916 wx := MONSTERTABLE[FMonsterType].Rect.X+(MONSTERTABLE[FMonsterType].Rect.Width div 2)-wx;
2917 end; // Это значит: wx := hitX + (hitWidth / 2) - (wx - (hitX + (hitWidth / 2)))
2918
2919 wx := FObj.X + wx;
2920 wy := FObj.Y + MONSTER_ANIMTABLE[FMonsterType].wY;
2921
2922 // Монстр не может целиться в объект за спиной, стреляя влево:
2923 if (FDirection = TDirection.D_LEFT) and (tx > wx) then
2924 begin
2925 tx := wx - 32;
2926 ty := wy + Random(11) - 5;
2927 end;
2928 // И аналогично, стреляя вправо:
2929 if (FDirection = TDirection.D_RIGHT) and (tx < wx) then
2930 begin
2931 tx := wx + 32;
2932 ty := wy + Random(11) - 5;
2933 end;
2934
2935 // Делаем выстрел нужным оружием:
2936 case FMonsterType of
2937 MONSTER_IMP:
2938 g_Weapon_ball1(wx, wy, tx, ty, FUID);
2939 MONSTER_ZOMBY:
2940 begin
2941 g_Sound_PlayExAt('SOUND_WEAPON_FIREPISTOL', wx, wy);
2942 g_Weapon_gun(wx, wy, tx, ty, 1, 3, FUID, True);
2943 {$IFDEF ENABLE_SHELLS}
2944 g_Shells_Create(wx, wy, 0, -2, SHELL_BULLET);
2945 {$ENDIF}
2946 end;
2947 MONSTER_SERG:
2948 begin
2949 g_Weapon_shotgun(wx, wy, tx, ty, FUID);
2950 if not gSoundEffectsDF then g_Sound_PlayExAt('SOUND_WEAPON_FIRESHOTGUN', wx, wy);
2951 {$IFDEF ENABLE_SHELLS}
2952 FShellTimer := 10;
2953 FShellType := SHELL_SHELL;
2954 {$ENDIF}
2955 end;
2956 MONSTER_MAN:
2957 begin
2958 g_Weapon_dshotgun(wx, wy, tx, ty, FUID);
2959 {$IFDEF ENABLE_SHELLS}
2960 FShellTimer := 13;
2961 FShellType := SHELL_DBLSHELL;
2962 {$ENDIF}
2963 FAmmo := -36;
2964 end;
2965 MONSTER_CYBER:
2966 begin
2967 g_Weapon_rocket(wx, wy, tx, ty, FUID);
2968 // MH_SEND_MonsterAttack(FUID, wx, wy, tx, ty);
2969 end;
2970 MONSTER_SKEL:
2971 g_Weapon_revf(wx, wy, tx, ty, FUID, FTargetUID);
2972 MONSTER_CGUN:
2973 begin
2974 g_Weapon_mgun(wx, wy, tx, ty, FUID);
2975 if not gSoundEffectsDF then g_Sound_PlayExAt('SOUND_WEAPON_FIRECGUN', wx, wy);
2976 {$IFDEF ENABLE_SHELLS}
2977 g_Shells_Create(wx, wy, 0, -2, SHELL_BULLET);
2978 {$ENDIF}
2979 end;
2980 MONSTER_SPIDER:
2981 begin
2982 g_Weapon_mgun(wx, wy, tx, ty, FUID);
2983 if not gSoundEffectsDF then g_Sound_PlayExAt('SOUND_WEAPON_FIRECGUN', wx, wy);
2984 {$IFDEF ENABLE_SHELLS}
2985 g_Shells_Create(wx, wy, 0, -2, SHELL_SHELL);
2986 {$ENDIF}
2987 end;
2988 MONSTER_BSP:
2989 g_Weapon_aplasma(wx, wy, tx, ty, FUID);
2990 MONSTER_ROBO:
2991 g_Weapon_plasma(wx, wy, tx, ty, FUID);
2992 MONSTER_MANCUB:
2993 g_Weapon_manfire(wx, wy, tx, ty, FUID);
2994 MONSTER_BARON, MONSTER_KNIGHT:
2995 g_Weapon_ball7(wx, wy, tx, ty, FUID);
2996 MONSTER_CACO:
2997 g_Weapon_ball2(wx, wy, tx, ty, FUID);
2998 MONSTER_PAIN:
2999 begin // Создаем Lost_Soul:
3000 mon := g_Monsters_Create(MONSTER_SOUL, FObj.X+(FObj.Rect.Width div 2),
3001 FObj.Y+FObj.Rect.Y, FDirection);
3002
3003 if mon <> nil then
3004 begin // Цель - цель Pain_Elemental'а. Летим к ней:
3005 mon.FTargetUID := FTargetUID;
3006 GetPos(FTargetUID, @o);
3007 mon.FTargetTime := 0;
3008 mon.FNoRespawn := True;
3009 mon.SetState(MONSTATE_GO);
3010 mon.shoot(@o, True);
3011 Inc(gTotalMonsters);
3012
3013 if g_Game_IsNet then MH_SEND_MonsterSpawn(mon.UID);
3014 end;
3015 end;
3016 end;
3017
3018 if FMonsterType <> MONSTER_PAIN then
3019 if g_Game_IsNet then
3020 MH_SEND_MonsterShot(FUID, wx, wy, tx, ty);
3021
3022 // Скорострельные монстры:
3023 if (FMonsterType = MONSTER_CGUN) or
3024 (FMonsterType = MONSTER_SPIDER) or
3025 (FMonsterType = MONSTER_BSP) or
3026 (FMonsterType = MONSTER_MANCUB) or
3027 (FMonsterType = MONSTER_ROBO) then
3028 if not GetPos(FTargetUID, @o) then
3029 // Цель мертва - ищем новую:
3030 findNewPrey()
3031 else // Цель жива - продолжаем стрелять:
3032 if shoot(@o, False) then
3033 FChainFire := True;
3034 end;
3035
3036 // Атака только 1 раз за анимацию атаки:
3037 FWaitAttackAnim := True;
3038 end;
3039
3040 // Последний кадр текущей анимации:
3041 if FAnim[FCurAnim, FDirection].Counter = FAnim[FCurAnim, FDirection].Speed-1 then
3042 case FState of
3043 MONSTATE_GO, MONSTATE_RUN, MONSTATE_CLIMB, MONSTATE_RUNOUT:
3044 // Звуки при передвижении:
3045 case FMonsterType of
3046 MONSTER_CYBER:
3047 if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3048 (FAnim[FCurAnim, FDirection].CurrentFrame = 2) then
3049 g_Sound_PlayExAt('SOUND_MONSTER_CYBER_WALK', FObj.X, FObj.Y);
3050 MONSTER_SPIDER:
3051 if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3052 (FAnim[FCurAnim, FDirection].CurrentFrame = 2) then
3053 g_Sound_PlayExAt('SOUND_MONSTER_SPIDER_WALK', FObj.X, FObj.Y);
3054 MONSTER_BSP:
3055 if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3056 (FAnim[FCurAnim, FDirection].CurrentFrame = 2) then
3057 g_Sound_PlayExAt('SOUND_MONSTER_BSP_WALK', FObj.X, FObj.Y);
3058 MONSTER_ROBO:
3059 if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3060 (FAnim[FCurAnim, FDirection].CurrentFrame = 5) then
3061 g_Sound_PlayExAt('SOUND_MONSTER_BSP_WALK', FObj.X, FObj.Y);
3062 end;
3063 end;
3064
3065 if g_Obj_CollidePanel(@FObj, 0, 0, PANEL_LIFTLEFT or PANEL_LIFTRIGHT) and
3066 not ((FState = MONSTATE_DEAD) or (FState = MONSTATE_DIE)) then
3067 FObj.Vel.X := oldvelx;
3068
3069 // Если есть анимация, то пусть она идет:
3070 if FAnim[FCurAnim, FDirection].IsValid() then
3071 FAnim[FCurAnim, FDirection].Update();
3072 end;
3073
3074 procedure TMonster.SetDeadAnim;
3075 begin
3076 if FAnim <> nil then
3077 FAnim[FCurAnim, FDirection].CurrentFrame := FAnim[FCurAnim, FDirection].TotalFrames - 1;
3078 end;
3079
3080 procedure TMonster.RevertAnim(R: Boolean = True);
3081 begin
3082 if FAnim <> nil then
3083 if FAnim[FCurAnim, FDirection].IsReverse <> R then
3084 FAnim[FCurAnim, FDirection].Revert(R);
3085 end;
3086
3087 function TMonster.AnimIsReverse: Boolean;
3088 begin
3089 if FAnim <> nil then
3090 Result := FAnim[FCurAnim, FDirection].IsReverse
3091 else
3092 Result := False;
3093 end;
3094
3095 procedure TMonster.ClientUpdate();
3096 {$IFDEF ENABLE_CORPSES}
3097 var a, b: Integer; co: TObj;
3098 {$ENDIF}
3099 var
3100 sx, sy, oldvelx: Integer;
3101 st: Word;
3102 o: TObj;
3103 fall, bubbles: Boolean;
3104 label
3105 _end;
3106 begin
3107 sx := 0; // SHUT UP COMPILER
3108 sy := 0;
3109 fall := True;
3110 bubbles := True;
3111
3112 // Монстр статичен пока идет warmup
3113 if (gLMSRespawn > LMS_RESPAWN_NONE) then exit;
3114
3115 // Рыбы "летают" только в воде:
3116 if FMonsterType = MONSTER_FISH then
3117 if g_Obj_CollidePanel(@FObj, 0, 0, PANEL_WATER or PANEL_ACID1 or PANEL_ACID2) then
3118 if (FState <> MONSTATE_DIE) and (FState <> MONSTATE_DEAD) then
3119 fall := False;
3120
3121 // Летающие монтсры:
3122 if ((FMonsterType = MONSTER_SOUL) or
3123 (FMonsterType = MONSTER_PAIN) or
3124 (FMonsterType = MONSTER_CACO)) and
3125 (FState <> MONSTATE_DIE) and
3126 (FState <> MONSTATE_DEAD) then
3127 fall := False;
3128
3129 // Меняем скорость только по четным кадрам:
3130 if gTime mod (GAME_TICK*2) <> 0 then
3131 begin
3132 g_Obj_Move(@FObj, fall, True, True);
3133 positionChanged(); // this updates spatial accelerators
3134 Exit;
3135 end;
3136
3137 if FPainTicks > 0 then
3138 Dec(FPainTicks)
3139 else
3140 FPainSound := False;
3141
3142 // Двигаемся:
3143 st := g_Obj_Move(@FObj, fall, True, True);
3144 positionChanged(); // this updates spatial accelerators
3145
3146 // Вылетел за карту - удаляем и запускаем триггеры:
3147 if WordBool(st and MOVE_FALLOUT) or (FObj.X < -1000) or
3148 (FObj.X > gMapInfo.Width+1000) or (FObj.Y < -1000) then
3149 begin
3150 FRemoved := True;
3151 Exit;
3152 end;
3153
3154 oldvelx := FObj.Vel.X;
3155
3156 // Сопротивление воздуха для трупа:
3157 if (FState = MONSTATE_DIE) or (FState = MONSTATE_DEAD) then
3158 FObj.Vel.X := z_dec(FObj.Vel.X, 1);
3159
3160 if FFireTime > 0 then
3161 begin
3162 if WordBool(st and MOVE_INWATER) then
3163 FFireTime := 0
3164 else
3165 begin
3166 OnFireFlame(1);
3167 FFireTime := FFireTime - 1;
3168 end;
3169 end;
3170
3171 // Мертвый ничего не делает:
3172 if (FState = MONSTATE_DEAD) then
3173 goto _end;
3174
3175 // Возможно, создаем пузырьки в воде:
3176 if WordBool(st and MOVE_INWATER) and (Random(32) = 0) then
3177 begin
3178 {$IFDEF ENABLE_GFX}
3179 case FMonsterType of
3180 MONSTER_FISH:
3181 if Random(4) <> 0 then bubbles := False else
3182 g_GFX_Bubbles(FObj.X+FObj.Rect.X + Random(FObj.Rect.Width),
3183 FObj.Y+FObj.Rect.Y + Random(4), 1, 0, 0);
3184 MONSTER_ROBO, MONSTER_BARREL:
3185 g_GFX_Bubbles(FObj.X+FObj.Rect.X + Random(FObj.Rect.Width),
3186 FObj.Y+FObj.Rect.Y + Random(4), 1, 0, 0);
3187 else
3188 g_GFX_Bubbles(FObj.X+FObj.Rect.X + Random(FObj.Rect.Width-4),
3189 FObj.Y+FObj.Rect.Y + Random(4), 5, 4, 4);
3190 end;
3191 {$ENDIF}
3192 if bubbles then if Random(2) = 0
3193 then g_Sound_PlayExAt('SOUND_GAME_BUBBLE1', FObj.X, FObj.Y)
3194 else g_Sound_PlayExAt('SOUND_GAME_BUBBLE2', FObj.X, FObj.Y);
3195 end;
3196
3197 // Если прошел первый кадр анимации взрыва бочки, то взрыв:
3198 if FMonsterType = MONSTER_BARREL then
3199 begin
3200 if (FState = MONSTATE_DIE) and (FAnim[FCurAnim, FDirection].CurrentFrame = 1) and
3201 (FAnim[FCurAnim, FDirection].Counter = 0) then
3202 g_Weapon_Explode(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
3203 FObj.Y+FObj.Rect.Y+FObj.Rect.Height-16,
3204 60, FUID);
3205 end;
3206
3207 // Lost_Soul вылетел из воды => ускоряется:
3208 if FMonsterType = MONSTER_SOUL then
3209 if WordBool(st and MOVE_HITAIR) then
3210 g_Obj_SetSpeed(@FObj, 16);
3211
3212 if FAmmo < 0 then
3213 FAmmo := FAmmo + 1;
3214
3215 // Если начали всплывать, то продолжаем:
3216 if FObj.Vel.Y < 0 then
3217 if WordBool(st and MOVE_INWATER) then
3218 FObj.Vel.Y := -4;
3219
3220 // Таймер - ждем после потери цели:
3221 FTargetTime := FTargetTime + 1;
3222
3223 {$IFDEF ENABLE_SHELLS}
3224 if FShellTimer > -1 then
3225 begin
3226 if FShellTimer = 0 then
3227 begin
3228 if FShellType = SHELL_SHELL then
3229 begin
3230 g_Shells_Create(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
3231 FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
3232 GameVelX, GameVelY-2, SHELL_SHELL)
3233 end
3234 else if FShellType = SHELL_DBLSHELL then
3235 begin
3236 g_Shells_Create(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
3237 FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
3238 GameVelX-1, GameVelY-2, SHELL_SHELL);
3239 g_Shells_Create(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2),
3240 FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2),
3241 GameVelX+1, GameVelY-2, SHELL_SHELL);
3242 end;
3243 FShellTimer := -1;
3244 end
3245 else
3246 begin
3247 Dec(FShellTimer);
3248 end;
3249 end;
3250 {$ENDIF}
3251
3252 // Пробуем увернуться от летящей пули:
3253 if fall then
3254 if (FState in [MONSTATE_GO, MONSTATE_RUN, MONSTATE_RUNOUT,
3255 MONSTATE_ATTACK, MONSTATE_SHOOT]) then
3256 if g_Weapon_Danger(FUID, FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y,
3257 FObj.Rect.Width, FObj.Rect.Height, 50) then
3258 if (g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj)) and
3259 (FObj.Accel.Y = 0) then
3260 FObj.Vel.Y := -MONSTERTABLE[FMonsterType].Jump;
3261
3262 case FState of
3263 MONSTATE_PAIN: // Состояние - Боль
3264 begin
3265 // Боль сильная => монстр кричит:
3266 if FPain >= MONSTERTABLE[FMonsterType].Pain then
3267 begin
3268 FPain := MONSTERTABLE[FMonsterType].Pain;
3269 if gSoundEffectsDF then PainSound();
3270 end;
3271 if (not gSoundEffectsDF) and (FPain >= MONSTERTABLE[FMonsterType].MinPain) then
3272 PainSound();
3273
3274 // Снижаем боль со временем:
3275 FPain := FPain - 5;
3276
3277 // Боль уже не ошутимая => идем дальше:
3278 if FPain <= MONSTERTABLE[FMonsterType].MinPain then
3279 begin
3280 SetState(MONSTATE_GO);
3281 FPain := 0;
3282 end;
3283 end;
3284
3285 MONSTATE_SLEEP: // Состояние - Сон
3286 begin
3287 // Спим:
3288 FSleep := FSleep + 1;
3289
3290 // Проспали достаточно:
3291 if FSleep >= 18 then
3292 FSleep := 0
3293 else // еще спим
3294 goto _end;
3295 end;
3296
3297 MONSTATE_WAIT: // Состояние - Ожидание
3298 begin
3299 // Ждем:
3300 FSleep := FSleep - 1;
3301 end;
3302
3303 MONSTATE_GO: // Состояние - Движение (с осмотром ситуации)
3304 begin
3305 // Если наткнулись на БлокМон - убегаем от него:
3306 if WordBool(st and MOVE_BLOCK) then
3307 begin
3308 Turn();
3309 FSleep := 40;
3310 SetState(MONSTATE_RUNOUT);
3311
3312 goto _end;
3313 end;
3314
3315 // Если монстр - колдун, то пробуем воскресить кого-нибудь:
3316 if (FMonsterType = MONSTER_VILE) then
3317 if isCorpse(@FObj, False) <> -1 then
3318 begin
3319 SetState(MONSTATE_ATTACK, ANIM_ATTACK2);
3320 FObj.Vel.X := 0;
3321
3322 goto _end;
3323 end;
3324
3325 // Если цель почти на одной вертикали - бегаем туда-сюда:
3326 if Abs(sx) < 40 then
3327 if FMonsterType <> MONSTER_FISH then
3328 begin
3329 SetState(MONSTATE_RUN);
3330 FSleep := 15;
3331
3332 goto _end;
3333 end;
3334
3335 // Уперлись в стену:
3336 if WordBool(st and MOVE_HITWALL) then
3337 begin
3338 case FMonsterType of
3339 MONSTER_CACO, MONSTER_SOUL, MONSTER_PAIN, MONSTER_FISH: ;
3340 else // Не летают:
3341 if (g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj)) and
3342 (FObj.Accel.Y = 0) then
3343 begin // Стоим на твердом полу или ступени
3344 // Прыжок через стену:
3345 FObj.Vel.Y := -MONSTERTABLE[FMonsterType].Jump;
3346 SetState(MONSTATE_CLIMB);
3347 end;
3348 end;
3349
3350 goto _end;
3351 end;
3352
3353 // Монстры, не подверженные гравитации:
3354 if (FMonsterType = MONSTER_CACO) or (FMonsterType = MONSTER_SOUL) or
3355 (FMonsterType = MONSTER_PAIN) or (FMonsterType = MONSTER_FISH) then
3356 begin
3357 if FMonsterType = MONSTER_FISH then
3358 begin // Рыба
3359 if not WordBool(st and MOVE_INWATER) then
3360 begin // Рыба вне воды:
3361 if g_Obj_CollideLevel(@FObj, 0, 1) or g_Obj_StayOnStep(@FObj) then
3362 begin // "Стоит" твердо
3363 // Рыба трепыхается на поверхности:
3364 if FObj.Accel.Y = 0 then
3365 FObj.Vel.Y := -6;
3366 FObj.Accel.X := FObj.Accel.X - 8 + Random(17);
3367 end;
3368
3369 // Рыбе больно:
3370 SetState(MONSTATE_PAIN);
3371 FPain := FPain + 50;
3372 end
3373 else // Рыба в воде
3374 begin
3375 // Плывем в сторону цели по-вертикали:
3376 if Abs(sy) > 8 then
3377 FObj.Vel.Y := g_basic.Sign(sy)*4
3378 else
3379 FObj.Vel.Y := 0;
3380
3381 // Рыба плывет вверх:
3382 if FObj.Vel.Y < 0 then
3383 if not g_Obj_CollideLiquid(@FObj, 0, -16) then
3384 begin
3385 // Всплыли до поверхности - стоп:
3386 FObj.Vel.Y := 0;
3387 // Плаваем туда-сюда:
3388 SetState(MONSTATE_RUN);
3389 FSleep := 20;
3390 end;
3391 end;
3392 end
3393 else // Летающие монстры
3394 begin
3395 // Летим в сторону цели по-вертикали:
3396 if Abs(sy) > 8 then
3397 FObj.Vel.Y := g_basic.Sign(sy)*4
3398 else
3399 FObj.Vel.Y := 0;
3400 end;
3401 end
3402 else // "Наземные" монстры
3403 begin
3404 {$IFDEF ENBALE_GIBS}
3405 // Возможно, пинаем куски:
3406 if (FObj.Vel.X <> 0) and (gGibs <> nil) then
3407 begin
3408 b := Abs(FObj.Vel.X);
3409 if b > 1 then b := b * (Random(8 div b) + 1);
3410 for a := 0 to High(gGibs) do
3411 begin
3412 if gGibs[a].alive and
3413 g_Obj_Collide(FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y+FObj.Rect.Height-4,
3414 FObj.Rect.Width, 8, @gGibs[a].Obj) and (Random(3) = 0) then
3415 begin
3416 // Пинаем куски
3417 if FObj.Vel.X < 0 then
3418 begin
3419 g_Obj_PushA(@gGibs[a].Obj, b, Random(61)+120); // налево
3420 end
3421 else
3422 begin
3423 g_Obj_PushA(@gGibs[a].Obj, b, Random(61)); // направо
3424 end;
3425 positionChanged(); // this updates spatial accelerators
3426 end;
3427 end;
3428 end;
3429 {$ENDIF}
3430 {$IFDEF ENABLE_CORPSES}
3431 // Боссы могут пинать трупы:
3432 if (FMonsterType in [MONSTER_CYBER, MONSTER_SPIDER, MONSTER_ROBO]) and
3433 (FObj.Vel.X <> 0) and (gCorpses <> nil) then
3434 begin
3435 b := Abs(FObj.Vel.X);
3436 if b > 1 then b := b * (Random(8 div b) + 1);
3437 for a := 0 to High(gCorpses) do
3438 if (gCorpses[a] <> nil) and (gCorpses[a].State > 0) then
3439 begin
3440 co := gCorpses[a].Obj;
3441 if g_Obj_Collide(FObj.X+FObj.Rect.X, FObj.Y+FObj.Rect.Y+FObj.Rect.Height-4,
3442 FObj.Rect.Width, 8, @co) and (Random(3) = 0) then
3443 // Пинаем трупы
3444 if FObj.Vel.X < 0 then
3445 gCorpses[a].Damage(b*2, FUID, -b, Random(7)) // налево
3446 else
3447 gCorpses[a].Damage(b*2, FUID, b, Random(7)); // направо
3448 end;
3449 end;
3450 {$ENDIF}
3451 end;
3452
3453 FSleep := FSleep + 1;
3454
3455 // Иногда рычим:
3456 if FSleep >= 8 then
3457 begin
3458 FSleep := 0;
3459 if Random(8) = 0 then
3460 ActionSound();
3461 end;
3462
3463 // Бежим в выбранную сторону:
3464 if FDirection = TDirection.D_RIGHT then
3465 FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
3466 else
3467 FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
3468
3469 // Если в воде, то замедляемся:
3470 if WordBool(st and MOVE_INWATER) then
3471 FObj.Vel.X := FObj.Vel.X div 2
3472 else // Рыбам не нужно замедляться
3473 if FMonsterType = MONSTER_FISH then
3474 FObj.Vel.X := 0;
3475 end;
3476
3477 MONSTATE_RUN: // Состояние - Бег
3478 begin
3479 // Если наткнулись на БлокМон - убегаем от него:
3480 if WordBool(st and MOVE_BLOCK) then
3481 begin
3482 SetState(MONSTATE_RUNOUT);
3483 FSleep := 40;
3484
3485 goto _end;
3486 end;
3487
3488 FSleep := FSleep - 1;
3489
3490 // Пробежали достаточно или врезались в стену => переходим на шаг:
3491 if (FSleep <= 0) or (WordBool(st and MOVE_HITWALL) and ((FObj.Vel.Y+FObj.Accel.Y) = 0)) then
3492 begin
3493 SetState(MONSTATE_GO);
3494 FSleep := 0;
3495
3496 // Иногда рычим:
3497 if Random(8) = 0 then
3498 ActionSound();
3499 end;
3500
3501 // Бежим в выбранную сторону:
3502 if FDirection = TDirection.D_RIGHT then
3503 FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
3504 else
3505 FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
3506
3507 // Если в воде, то замедляемся:
3508 if WordBool(st and MOVE_INWATER) then
3509 FObj.Vel.X := FObj.Vel.X div 2
3510 else // Рыбам не нужно замедляться
3511 if FMonsterType = MONSTER_FISH then
3512 FObj.Vel.X := 0;
3513 end;
3514
3515 MONSTATE_RUNOUT: // Состояние - Убегает от чего-то
3516 begin
3517 // Вышли из БлокМона:
3518 if (not WordBool(st and MOVE_BLOCK)) and (FSleep > 0) then
3519 FSleep := 0;
3520
3521 FSleep := FSleep - 1;
3522
3523 // Убажели достаточно далеко => переходим на шаг:
3524 if FSleep <= -18 then
3525 begin
3526 SetState(MONSTATE_GO);
3527 FSleep := 0;
3528
3529 // Иногда рычим:
3530 if Random(8) = 0 then
3531 ActionSound();
3532 end;
3533
3534 // Бежим в выбранную сторону:
3535 if FDirection = TDirection.D_RIGHT then
3536 FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
3537 else
3538 FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
3539
3540 // Если в воде, то замедляемся:
3541 if WordBool(st and MOVE_INWATER) then
3542 FObj.Vel.X := FObj.Vel.X div 2
3543 else // Рыбам не нужно замедляться
3544 if FMonsterType = MONSTER_FISH then
3545 FObj.Vel.X := 0;
3546 end;
3547
3548 MONSTATE_CLIMB: // Состояние - Прыжок (чтобы обойти стену)
3549 begin
3550 // Достигли высшей точки прыжка или стена кончилась => переходим на шаг:
3551 if ((FObj.Vel.Y+FObj.Accel.Y) >= 0) or
3552 (not WordBool(st and MOVE_HITWALL)) then
3553 begin
3554 SetState(MONSTATE_GO);
3555 FSleep := 0;
3556
3557 // Стена не кончилась => бежим от нее:
3558 if WordBool(st and (MOVE_HITWALL or MOVE_BLOCK)) then
3559 begin
3560 SetState(MONSTATE_RUN);
3561 FSleep := 15;
3562 end;
3563 end;
3564
3565 // Бежим в выбранную сторону:
3566 if FDirection = TDirection.D_RIGHT then
3567 FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
3568 else
3569 FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
3570
3571 // Если в воде, то замедляемся:
3572 if WordBool(st and MOVE_INWATER) then
3573 FObj.Vel.X := FObj.Vel.X div 2
3574 else // Рыбам не нужно замедляться
3575 if FMonsterType = MONSTER_FISH then
3576 FObj.Vel.X := 0;
3577 end;
3578
3579 MONSTATE_ATTACK, // Состояние - Атака
3580 MONSTATE_SHOOT: // Состояние - Стрельба
3581 begin
3582 // Lost_Soul врезался в стену при атаке => переходит на шаг:
3583 if FMonsterType = MONSTER_SOUL then
3584 begin
3585 if WordBool(st and (MOVE_HITWALL or MOVE_HITCEIL or MOVE_HITLAND)) then
3586 SetState(MONSTATE_GO);
3587
3588 goto _end;
3589 end;
3590
3591 // Замедляемся при атаке:
3592 if FMonsterType <> MONSTER_FISH then
3593 FObj.Vel.X := z_dec(FObj.Vel.X, 1);
3594
3595 // Нужно стрелять, а монстр - колдун:
3596 if (FMonsterType = MONSTER_VILE) and (FState = MONSTATE_SHOOT) then
3597 begin
3598 // Цель погибла => идем дальше:
3599 if not GetPos(FTargetUID, @o) then
3600 begin
3601 SetState(MONSTATE_GO);
3602
3603 goto _end;
3604 end;
3605
3606 // Цель не видно => идем дальше:
3607 if not g_Look(@FObj, @o, FDirection) then
3608 begin
3609 SetState(MONSTATE_GO);
3610
3611 goto _end;
3612 end;
3613
3614 // Цель в воде - не загорится => идем дальше:
3615 if g_Obj_CollideWater(@o, 0, 0) then
3616 begin
3617 SetState(MONSTATE_GO);
3618
3619 goto _end;
3620 end;
3621 end;
3622 end;
3623 end; // case FState of ...
3624
3625 _end:
3626
3627 // Состояние - Воскрешение:
3628 if FState = MONSTATE_REVIVE then
3629 if FAnim[FCurAnim, FDirection].Played then
3630 begin // Обратная анимация умирания закончилась - идем дальше:
3631 FAnim[FCurAnim, FDirection].Revert(False);
3632 SetState(MONSTATE_GO);
3633 end;
3634
3635 // Состояние - Умирает и текущая анимация проиграна:
3636 if (FState = MONSTATE_DIE) and
3637 (FAnim[FCurAnim, FDirection].IsValid()) and
3638 (FAnim[FCurAnim, FDirection].Played) then
3639 begin
3640 // Умер:
3641 SetState(MONSTATE_DEAD);
3642
3643 // У этих монстров нет трупов:
3644 if (FMonsterType = MONSTER_PAIN) or
3645 (FMonsterType = MONSTER_SOUL) or
3646 (FMonsterType = MONSTER_BARREL) then
3647 FRemoved := True
3648 else
3649 FAnim[FCurAnim, FDirection].CurrentFrame := FAnim[FCurAnim, FDirection].TotalFrames - 1;
3650 end;
3651
3652 // Совершение атаки и стрельбы:
3653 if (FState = MONSTATE_ATTACK) or (FState = MONSTATE_SHOOT) then
3654 if (FAnim[FCurAnim, FDirection].IsValid()) then
3655 // Анимация атаки есть - можно атаковать
3656 if (FAnim[FCurAnim, FDirection].Played) then
3657 begin // Анимация атаки закончилась => переходим на шаг
3658 if FState = MONSTATE_ATTACK then
3659 begin // Состояние - Атака
3660 // Если монстр не Lost_Soul, то после атаки переходим на шаг:
3661 if FMonsterType <> MONSTER_SOUL then
3662 SetState(MONSTATE_GO);
3663 end
3664 else // Состояние - Стрельба
3665 begin
3666 // Переходим на шаг, если не надо стрелять еще раз:
3667 if not FChainFire then
3668 SetState(MONSTATE_GO)
3669 else
3670 begin // Надо стрелять еще
3671 FChainFire := False;
3672 // Т.к. состояние не изменилось, и нужен
3673 // новый цикл ожидания завершения анимации:
3674 FAnim[FCurAnim, FDirection].Reset();
3675 end;
3676 end;
3677
3678 FWaitAttackAnim := False;
3679 end
3680
3681 else // Анимация атаки еще идет (исключение - Lost_Soul):
3682 if (FMonsterType = MONSTER_SOUL) or
3683 ( (not FWaitAttackAnim) and
3684 (FAnim[FCurAnim, FDirection].CurrentFrame =
3685 (FAnim[FCurAnim, FDirection].TotalFrames div 2))
3686 ) then
3687 begin // Атаки еще не было и это середина анимации атаки
3688 if FState = MONSTATE_ATTACK then
3689 begin // Состояние - Атака
3690 // Если это Lost_Soul, то сбрасываем анимацию атаки:
3691 if FMonsterType = MONSTER_SOUL then
3692 FAnim[FCurAnim, FDirection].Reset();
3693
3694 case FMonsterType of
3695 MONSTER_SOUL, MONSTER_IMP, MONSTER_DEMON:
3696 // Грызем первого попавшегося:
3697 if g_Weapon_Hit(@FObj, 15, FUID, HIT_SOME) <> 0 then
3698 // Lost_Soul укусил кого-то => переходит на шаг:
3699 if FMonsterType = MONSTER_SOUL then
3700 SetState(MONSTATE_GO);
3701
3702 MONSTER_FISH:
3703 g_Weapon_Hit(@FObj, 10, FUID, HIT_SOME);
3704
3705 MONSTER_SKEL, MONSTER_ROBO, MONSTER_CYBER:
3706 // Робот, кибер или скелет сильно пинаются:
3707 if FCurAnim = ANIM_ATTACK2 then
3708 begin
3709 o := FObj;
3710 o.Vel.X := IfThen(FDirection = TDirection.D_RIGHT, 1, -1)*IfThen(FMonsterType = MONSTER_CYBER, 60, 50);
3711 g_Weapon_Hit(@o, IfThen(FMonsterType = MONSTER_CYBER, 33, 50), FUID, HIT_SOME);
3712 end;
3713
3714 MONSTER_VILE:
3715 // Колдун пытается воскрешать:
3716 if FCurAnim = ANIM_ATTACK2 then
3717 begin
3718 sx := isCorpse(@FObj, True);
3719 if sx <> -1 then
3720 begin // Нашли, кого воскресить
3721 g_Sound_PlayExAt('SOUND_MONSTER_SLOP', FObj.X, FObj.Y);
3722 // Воскрешать - себе вредить:
3723 {g_Weapon_HitUID(FUID, 5, 0, HIT_SOME);}
3724 end;
3725 end;
3726 end;
3727 end
3728
3729 else // Состояние - Стрельба
3730 begin
3731 // Скорострельные монстры:
3732 if (FMonsterType = MONSTER_CGUN) or
3733 (FMonsterType = MONSTER_SPIDER) or
3734 (FMonsterType = MONSTER_BSP) or
3735 (FMonsterType = MONSTER_MANCUB) or
3736 (FMonsterType = MONSTER_ROBO) then
3737 if not GetPos(FTargetUID, @o) then
3738 // Цель мертва - ищем новую:
3739 findNewPrey()
3740 else // Цель жива - продолжаем стрелять:
3741 if shoot(@o, False) then
3742 FChainFire := True;
3743 end;
3744
3745 // Атака только 1 раз за анимацию атаки:
3746 FWaitAttackAnim := True;
3747 end;
3748
3749 // Последний кадр текущей анимации:
3750 if FAnim[FCurAnim, FDirection].Counter = FAnim[FCurAnim, FDirection].Speed-1 then
3751 case FState of
3752 MONSTATE_GO, MONSTATE_RUN, MONSTATE_CLIMB, MONSTATE_RUNOUT:
3753 // Звуки при передвижении:
3754 case FMonsterType of
3755 MONSTER_CYBER:
3756 if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3757 (FAnim[FCurAnim, FDirection].CurrentFrame = 2) then
3758 g_Sound_PlayExAt('SOUND_MONSTER_CYBER_WALK', FObj.X, FObj.Y);
3759 MONSTER_SPIDER:
3760 if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3761 (FAnim[FCurAnim, FDirection].CurrentFrame = 2) then
3762 g_Sound_PlayExAt('SOUND_MONSTER_SPIDER_WALK', FObj.X, FObj.Y);
3763 MONSTER_BSP:
3764 if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3765 (FAnim[FCurAnim, FDirection].CurrentFrame = 2) then
3766 g_Sound_PlayExAt('SOUND_MONSTER_BSP_WALK', FObj.X, FObj.Y);
3767 MONSTER_ROBO:
3768 if (FAnim[FCurAnim, FDirection].CurrentFrame = 0) or
3769 (FAnim[FCurAnim, FDirection].CurrentFrame = 5) then
3770 g_Sound_PlayExAt('SOUND_MONSTER_BSP_WALK', FObj.X, FObj.Y);
3771 end;
3772 end;
3773
3774 // Костыль для потоков
3775 if g_Obj_CollidePanel(@FObj, 0, 0, PANEL_LIFTLEFT or PANEL_LIFTRIGHT) and
3776 not ((FState = MONSTATE_DEAD) or (FState = MONSTATE_DIE)) then
3777 FObj.Vel.X := oldvelx;
3778
3779 // Если есть анимация, то пусть она идет:
3780 if FAnim[FCurAnim, FDirection].IsValid() then
3781 FAnim[FCurAnim, FDirection].Update();
3782 end;
3783
3784 procedure TMonster.ClientAttack(wx, wy, atx, aty: Integer);
3785 begin
3786 case FMonsterType of
3787 MONSTER_ZOMBY:
3788 begin
3789 g_Sound_PlayExAt('SOUND_WEAPON_FIREPISTOL', wx, wy);
3790 {$IFDEF ENABLE_SHELLS}
3791 g_Shells_Create(wx, wy, 0, -2, SHELL_BULLET);
3792 {$ENDIF}
3793 end;
3794 MONSTER_SERG:
3795 begin
3796 g_Sound_PlayExAt('SOUND_WEAPON_FIRESHOTGUN', wx, wy);
3797 {$IFDEF ENABLE_SHELLS}
3798 FShellTimer := 10;
3799 FShellType := SHELL_SHELL;
3800 {$ENDIF}
3801 end;
3802 MONSTER_MAN:
3803 begin
3804 g_Sound_PlayExAt('SOUND_WEAPON_FIRESHOTGUN2', wx, wy);
3805 {$IFDEF ENABLE_SHELLS}
3806 FShellTimer := 13;
3807 FShellType := SHELL_DBLSHELL;
3808 {$ENDIF}
3809 end;
3810 MONSTER_CGUN, MONSTER_SPIDER:
3811 begin
3812 g_Sound_PlayExAt('SOUND_WEAPON_FIRECGUN', wx, wy);
3813 {$IFDEF ENABLE_SHELLS}
3814 g_Shells_Create(wx, wy, 0, -2, SHELL_BULLET);
3815 {$ENDIF}
3816 end;
3817 MONSTER_IMP:
3818 g_Weapon_ball1(wx, wy, atx, aty, FUID);
3819 MONSTER_CYBER:
3820 g_Weapon_rocket(wx, wy, atx, aty, FUID);
3821 MONSTER_SKEL:
3822 g_Weapon_revf(wx, wy, atx, aty, FUID, FTargetUID);
3823 MONSTER_BSP:
3824 g_Weapon_aplasma(wx, wy, atx, aty, FUID);
3825 MONSTER_ROBO:
3826 g_Weapon_plasma(wx, wy, atx, aty, FUID);
3827 MONSTER_MANCUB:
3828 g_Weapon_manfire(wx, wy, atx, aty, FUID);
3829 MONSTER_BARON, MONSTER_KNIGHT:
3830 g_Weapon_ball7(wx, wy, atx, aty, FUID);
3831 MONSTER_CACO:
3832 g_Weapon_ball2(wx, wy, atx, aty, FUID);
3833 end;
3834 end;
3835
3836 procedure TMonster.Turn();
3837 begin
3838 // Разворачиваемся:
3839 if FDirection = TDirection.D_LEFT then FDirection := TDirection.D_RIGHT else FDirection := TDirection.D_LEFT;
3840
3841 // Бежим в выбранную сторону:
3842 if FDirection = TDirection.D_RIGHT then
3843 FObj.Vel.X := MONSTERTABLE[FMonsterType].RunVel
3844 else
3845 FObj.Vel.X := -MONSTERTABLE[FMonsterType].RunVel;
3846 end;
3847
3848 function TMonster.findNewPrey(): Boolean;
3849 var
3850 a: DWORD;
3851 l, l2: Integer;
3852 PlayersSee, MonstersSee: Array of DWORD;
3853 PlayerNear, MonsterNear: Integer;
3854 begin
3855 Result := False;
3856 SetLength(MonstersSee, 0);
3857 SetLength(PlayersSee, 0);
3858
3859 FTargetUID := 0;
3860 l := 32000;
3861 PlayerNear := -1;
3862 MonsterNear := -1;
3863
3864 // Поехавшие, каннибалы, и добрые игроков не трогают
3865 if (gPlayers <> nil) and (FBehaviour <> BH_INSANE) and
3866 (FBehaviour <> BH_CANNIBAL) and (FBehaviour <> BH_GOOD) then
3867 for a := 0 to High(gPlayers) do
3868 if (gPlayers[a] <> nil) and (gPlayers[a].alive)
3869 and (not gPlayers[a].NoTarget) and (gPlayers[a].FMegaRulez[MR_INVIS] < gTime) then
3870 begin
3871 if g_Look(@FObj, @gPlayers[a].Obj, FDirection) then
3872 begin
3873 SetLength(PlayersSee, Length(PlayersSee) + 1);
3874 PlayersSee[High(PlayersSee)] := a;
3875 end;
3876 l2 := Abs(gPlayers[a].GameX-FObj.X)+
3877 Abs(gPlayers[a].GameY-FObj.Y);
3878 if l2 < l then
3879 begin
3880 l := l2;
3881 PlayerNear := Integer(a);
3882 end;
3883 end;
3884
3885 // Киллеры и добрые не трогают монстров
3886 if (gMonsters <> nil) and (FBehaviour <> BH_KILLER) and (FBehaviour <> BH_GOOD) then
3887 for a := 0 to High(gMonsters) do
3888 if (gMonsters[a] <> nil) and (gMonsters[a].alive) and
3889 (gMonsters[a].FUID <> FUID) then
3890 begin
3891 if (FBehaviour = BH_CANNIBAL) and (gMonsters[a].FMonsterType <> FMonsterType) then
3892 Continue; // Каннибалы атакуют только сородичей
3893 if (FBehaviour = BH_INSANE) and (gMonsters[a].FMonsterType <> MONSTER_BARREL)
3894 and (IsFriend(gMonsters[a].FMonsterType, FMonsterType)) then
3895 Continue; // Поехавшие не трогают друзей, но им не нравятся бочки
3896 if ((FBehaviour = BH_NORMAL) or (FBehaviour = BH_MANIAC))
3897 and (IsFriend(gMonsters[a].FMonsterType, FMonsterType)) then
3898 Continue; // Оставшиеся типы, кроме каннибалов, не трогают своих друзей
3899
3900 if g_Look(@FObj, @gMonsters[a].Obj, FDirection) then
3901 begin
3902 SetLength(MonstersSee, Length(MonstersSee) + 1);
3903 MonstersSee[High(MonstersSee)] := a;
3904 end;
3905 l2 := Abs(gMonsters[a].FObj.X-FObj.X)+
3906 Abs(gMonsters[a].FObj.Y-FObj.Y);
3907 if l2 < l then
3908 begin
3909 l := l2;
3910 MonsterNear := Integer(a);
3911 end;
3912 end;
3913
3914 case FBehaviour of
3915 BH_NORMAL, BH_KILLER:
3916 begin
3917 // Обычный и киллер сначала ищут игроков в поле зрения
3918 if (FTargetUID = 0) and (Length(PlayersSee) > 0) then
3919 begin
3920 a := PlayersSee[Random(Length(PlayersSee))];
3921 FTargetUID := gPlayers[a].UID;
3922 end;
3923 // Затем поблизости
3924 if (FTargetUID = 0) and (PlayerNear > -1) then
3925 begin
3926 a := PlayerNear;
3927 FTargetUID := gPlayers[a].UID;
3928 end;
3929 // Потом обычные ищут монстров в поле зрения
3930 if (FTargetUID = 0) and (Length(MonstersSee) > 0) then
3931 begin
3932 a := MonstersSee[Random(Length(MonstersSee))];
3933 FTargetUID := gMonsters[a].UID;
3934 end;
3935 // Затем поблизости
3936 if (FTargetUID = 0) and (MonsterNear > -1) then
3937 begin
3938 a := MonsterNear;
3939 FTargetUID := gMonsters[a].UID;
3940 end;
3941 end;
3942 BH_MANIAC, BH_INSANE, BH_CANNIBAL:
3943 begin
3944 // Маньяки, поехавшие и каннибалы сначала истребляют всё в поле зрения
3945 if (FTargetUID = 0) and (Length(PlayersSee) > 0) then
3946 begin
3947 a := PlayersSee[Random(Length(PlayersSee))];
3948 FTargetUID := gPlayers[a].UID;
3949 end;
3950 if (FTargetUID = 0) and (Length(MonstersSee) > 0) then
3951 begin
3952 a := MonstersSee[Random(Length(MonstersSee))];
3953 FTargetUID := gMonsters[a].UID;
3954 end;
3955 // Затем ищут кого-то поблизости
3956 if (FTargetUID = 0) and (PlayerNear > -1) then
3957 begin
3958 a := PlayerNear;
3959 FTargetUID := gPlayers[a].UID;
3960 end;
3961 if (FTargetUID = 0) and (MonsterNear > -1) then
3962 begin
3963 a := MonsterNear;
3964 FTargetUID := gMonsters[a].UID;
3965 end;
3966 end;
3967 end;
3968
3969 // Если и монстров нет - начинаем ждать цель:
3970 if FTargetUID = 0 then
3971 begin
3972 // Поехавший пытается самоубиться
3973 if FBehaviour = BH_INSANE then
3974 FTargetUID := FUID
3975 else
3976 FTargetTime := MAX_ATM;
3977 end
3978 else
3979 begin // Цель нашли
3980 FTargetTime := 0;
3981 Result := True;
3982 end;
3983 end;
3984
3985 function TMonster.kick(o: PObj): Boolean;
3986 begin
3987 Result := False;
3988
3989 case FMonsterType of
3990 MONSTER_FISH:
3991 begin
3992 SetState(MONSTATE_ATTACK);
3993 Result := True;
3994 end;
3995 MONSTER_DEMON:
3996 begin
3997 SetState(MONSTATE_ATTACK);
3998 g_Sound_PlayExAt('SOUND_MONSTER_DEMON_ATTACK', FObj.X, FObj.Y);
3999 Result := True;
4000 end;
4001 MONSTER_IMP:
4002 begin
4003 SetState(MONSTATE_ATTACK);
4004 g_Sound_PlayExAt('SOUND_MONSTER_IMP_ATTACK', FObj.X, FObj.Y);
4005 Result := True;
4006 end;
4007 MONSTER_SKEL, MONSTER_ROBO, MONSTER_CYBER:
4008 begin
4009 SetState(MONSTATE_ATTACK, ANIM_ATTACK2);
4010 g_Sound_PlayExAt('SOUND_MONSTER_SKEL_ATTACK', FObj.X, FObj.Y);
4011 Result := True;
4012 end;
4013 MONSTER_BARON, MONSTER_KNIGHT,
4014 MONSTER_CACO, MONSTER_MANCUB:
4015 // Эти монстры не пинают - они стреляют в упор:
4016 if not g_Game_IsClient then Result := shoot(o, True);
4017 end;
4018 end;
4019
4020 function TMonster.shoot(o: PObj; immediately: Boolean): Boolean;
4021 var
4022 xd, yd, m: Integer;
4023 begin
4024 Result := False;
4025
4026 // Стрелять рано:
4027 if FAmmo < 0 then
4028 Exit;
4029
4030 // Ждать времени готовности к выстрелу:
4031 if not immediately then
4032 case FMonsterType of
4033 MONSTER_FISH, MONSTER_BARREL, MONSTER_DEMON:
4034 Exit; // не стреляют
4035 MONSTER_CGUN, MONSTER_BSP, MONSTER_ROBO:
4036 begin
4037 FAmmo := FAmmo + 1;
4038 // Время выстрела упущено:
4039 if FAmmo >= 50 then
4040 FAmmo := IfThen(FMonsterType = MONSTER_ROBO, -200, -50);
4041 end;
4042 MONSTER_MAN: ;
4043 MONSTER_MANCUB:
4044 begin
4045 FAmmo := FAmmo + 1;
4046 // Время выстрела упущено:
4047 if FAmmo >= 5 then
4048 FAmmo := -50;
4049 end;
4050 MONSTER_SPIDER:
4051 begin
4052 FAmmo := FAmmo + 1;
4053 // Время выстрела упущено:
4054 if FAmmo >= 100 then
4055 FAmmo := -50;
4056 end;
4057 MONSTER_CYBER:
4058 begin
4059 // Стреляет не всегда:
4060 if Random(2) = 0 then
4061 Exit;
4062 FAmmo := FAmmo + 1;
4063 // Время выстрела упущено:
4064 if FAmmo >= 10 then
4065 FAmmo := -50;
4066 end;
4067 MONSTER_BARON, MONSTER_KNIGHT: if Random(8) <> 0 then Exit;
4068 MONSTER_SKEL: if Random(32) <> 0 then Exit;
4069 MONSTER_VILE: if Random(8) <> 0 then Exit;
4070 MONSTER_PAIN: if Random(8) <> 0 then Exit;
4071 else if Random(16) <> 0 then Exit;
4072 end;
4073
4074 // Цели не видно:
4075 if not g_Look(@FObj, o, FDirection) then
4076 Exit;
4077
4078 FTargetTime := 0;
4079
4080 tx := o^.X+o^.Rect.X+(o^.Rect.Width div 2)+((o^.Vel.X{+o^.Accel.X})*12);
4081 ty := o^.Y+o^.Rect.Y+(o^.Rect.Height div 2)+((o^.Vel.Y{+o^.Accel.Y})*12);
4082
4083 // Разница по высоте больше разницы по горизонтали
4084 // (не может стрелять под таким большим углом):
4085 if Abs(tx-(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2))) <
4086 Abs(ty-(FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2))) then
4087 Exit;
4088
4089 case FMonsterType of
4090 MONSTER_IMP, MONSTER_BARON, MONSTER_KNIGHT, MONSTER_CACO:
4091 begin
4092 SetState(MONSTATE_SHOOT);
4093 {nn}
4094 end;
4095 MONSTER_SKEL:
4096 begin
4097 SetState(MONSTATE_SHOOT);
4098 {nn}
4099 end;
4100 MONSTER_VILE:
4101 begin // Зажигаем огонь
4102 tx := o^.X+o^.Rect.X+(o^.Rect.Width div 2);
4103 ty := o^.Y+o^.Rect.Y;
4104 SetState(MONSTATE_SHOOT);
4105
4106 FVileFireTime := gTime;
4107
4108 g_Sound_PlayExAt('SOUND_MONSTER_VILE_ATTACK', FObj.X, FObj.Y);
4109 g_Sound_PlayExAt('SOUND_FIRE', o^.X, o^.Y);
4110 end;
4111 MONSTER_SOUL:
4112 begin // Летит в сторону цели:
4113 SetState(MONSTATE_ATTACK);
4114 g_Sound_PlayExAt('SOUND_MONSTER_SOUL_ATTACK', FObj.X, FObj.Y);
4115
4116 xd := tx-(FObj.X+FObj.Rect.X+(FObj.Rect.Width div 2));
4117 yd := ty-(FObj.Y+FObj.Rect.Y+(FObj.Rect.Height div 2));
4118 m := Max(Abs(xd), Abs(yd));
4119 if m = 0 then
4120 m := 1;
4121
4122 FObj.Vel.X := (xd*16) div m;
4123 FObj.Vel.Y := (yd*16) div m;
4124 end;
4125 MONSTER_MANCUB, MONSTER_ZOMBY, MONSTER_SERG, MONSTER_BSP, MONSTER_ROBO,
4126 MONSTER_CYBER, MONSTER_CGUN, MONSTER_SPIDER, MONSTER_PAIN, MONSTER_MAN:
4127 begin
4128 // Манкубус рявкает перед первой атакой:
4129 if FMonsterType = MONSTER_MANCUB then
4130 if FAmmo = 1 then
4131 g_Sound_PlayExAt('SOUND_MONSTER_MANCUB_ATTACK', FObj.X, FObj.Y);
4132
4133 SetState(MONSTATE_SHOOT);
4134 end;
4135 else Exit;
4136 end;
4137
4138 Result := True;
4139 end;
4140
4141 function TMonster.alive(): Boolean;
4142 begin
4143 Result := (FState <> MONSTATE_DIE) and (FState <> MONSTATE_DEAD) and (FHealth > 0);
4144 end;
4145
4146 procedure TMonster.SetHealth(aH: Integer);
4147 begin
4148 if (aH > 0) and (aH < 1000000) then
4149 begin
4150 FHealth := aH;
4151 if FHealth > FMaxHealth then
4152 FMaxHealth := FHealth;
4153 end;
4154 end;
4155
4156 procedure TMonster.WakeUp();
4157 begin
4158 if g_Game_IsClient then Exit;
4159 SetState(MONSTATE_GO);
4160 FTargetTime := MAX_ATM;
4161 WakeUpSound();
4162 end;
4163
4164 procedure TMonster.SaveState (st: TStream);
4165 var
4166 i: Integer;
4167 b: Byte;
4168 anim: Boolean;
4169 stub: TAnimState;
4170 begin
4171 assert(st <> nil);
4172
4173 // Сигнатура монстра:
4174 utils.writeSign(st, 'MONS');
4175 utils.writeInt(st, Byte(0)); // version
4176 // UID монстра:
4177 utils.writeInt(st, Word(FUID));
4178 // Направление
4179 if FDirection = TDirection.D_LEFT then b := 1 else b := 2; // D_RIGHT
4180 utils.writeInt(st, Byte(b));
4181 // Надо ли удалить его
4182 utils.writeBool(st, FRemoved);
4183 // Осталось здоровья
4184 utils.writeInt(st, LongInt(FHealth));
4185 // Состояние
4186 utils.writeInt(st, Byte(FState));
4187 // Текущая анимация
4188 utils.writeInt(st, Byte(FCurAnim));
4189 // UID цели
4190 utils.writeInt(st, Word(FTargetUID));
4191 // Время после потери цели
4192 utils.writeInt(st, LongInt(FTargetTime));
4193 // Поведение монстра
4194 utils.writeInt(st, Byte(FBehaviour));
4195 // Готовность к выстрелу
4196 utils.writeInt(st, LongInt(FAmmo));
4197 // Боль
4198 utils.writeInt(st, LongInt(FPain));
4199 // Время ожидания
4200 utils.writeInt(st, LongInt(FSleep));
4201 // Озвучивать ли боль
4202 utils.writeBool(st, FPainSound);
4203 // Была ли атака во время анимации атаки
4204 utils.writeBool(st, FWaitAttackAnim);
4205 // Надо ли стрелять на следующем шаге
4206 utils.writeBool(st, FChainFire);
4207 // Подлежит ли респавну
4208 utils.writeBool(st, FNoRespawn);
4209 // Координаты цели
4210 utils.writeInt(st, LongInt(tx));
4211 utils.writeInt(st, LongInt(ty));
4212 // ID монстра при старте карты
4213 utils.writeInt(st, LongInt(FStartID));
4214 // Индекс триггера, создавшего монстра
4215 utils.writeInt(st, LongInt(FSpawnTrigger));
4216 // Объект монстра
4217 Obj_SaveState(st, @FObj);
4218 // Есть ли анимация огня колдуна
4219 anim := FMonsterType = MONSTER_VILE;
4220 utils.writeBool(st, anim);
4221 // Если есть - сохраняем:
4222 if anim then
4223 begin
4224 stub := TAnimState.Create(true, 2, 8);
4225 stub.SaveState(st, 0, False);
4226 stub.Invalidate;
4227 end;
4228 // Анимации
4229 for i := ANIM_SLEEP to ANIM_PAIN do
4230 begin
4231 // Есть ли левая анимация
4232 anim := (FAnim[i, TDirection.D_LEFT].IsValid());
4233 utils.writeBool(st, anim);
4234 // Если есть - сохраняем
4235 if anim then FAnim[i, TDirection.D_LEFT].SaveState(st, 0, False);
4236 // Есть ли правая анимация
4237 anim := (FAnim[i, TDirection.D_RIGHT].IsValid());
4238 utils.writeBool(st, anim);
4239 // Если есть - сохраняем
4240 if anim then FAnim[i, TDirection.D_RIGHT].SaveState(st, 0, False);
4241 end;
4242 end;
4243
4244
4245 procedure TMonster.LoadState (st: TStream);
4246 var
4247 i: Integer;
4248 b, alpha: Byte;
4249 anim, blending: Boolean;
4250 stub: TAnimState;
4251 begin
4252 assert(st <> nil);
4253
4254 // Сигнатура монстра:
4255 if not utils.checkSign(st, 'MONS') then raise XStreamError.Create('invalid monster signature');
4256 if (utils.readByte(st) <> 0) then raise XStreamError.Create('invalid monster version');
4257 if (uidMap[FUID] <> nil) and (uidMap[FUID] <> self) then raise Exception.Create('internal error in monster loader (0)');
4258 uidMap[FUID] := nil;
4259 // UID монстра:
4260 FUID := utils.readWord(st);
4261 //if (arrIdx = -1) then raise Exception.Create('internal error in monster loader');
4262 if (uidMap[FUID] <> nil) then raise Exception.Create('internal error in monster loader (1)');
4263 uidMap[FUID] := self;
4264 // Направление
4265 b := utils.readByte(st);
4266 if b = 1 then FDirection := TDirection.D_LEFT else FDirection := TDirection.D_RIGHT; // b = 2
4267 // Надо ли удалить его
4268 FRemoved := utils.readBool(st);
4269 // Осталось здоровья
4270 FHealth := utils.readLongInt(st);
4271 // Состояние
4272 FState := utils.readByte(st);
4273 // Текущая анимация
4274 FCurAnim := utils.readByte(st);
4275 // UID цели
4276 FTargetUID := utils.readWord(st);
4277 // Время после потери цели
4278 FTargetTime := utils.readLongInt(st);
4279 // Поведение монстра
4280 FBehaviour := utils.readByte(st);
4281 // Готовность к выстрелу
4282 FAmmo := utils.readLongInt(st);
4283 // Боль
4284 FPain := utils.readLongInt(st);
4285 // Время ожидания
4286 FSleep := utils.readLongInt(st);
4287 // Озвучивать ли боль
4288 FPainSound := utils.readBool(st);
4289 // Была ли атака во время анимации атаки
4290 FWaitAttackAnim := utils.readBool(st);
4291 // Надо ли стрелять на следующем шаге
4292 FChainFire := utils.readBool(st);
4293 // Подлежит ли респавну
4294 FNoRespawn := utils.readBool(st);
4295 // Координаты цели
4296 tx := utils.readLongInt(st);
4297 ty := utils.readLongInt(st);
4298 // ID монстра при старте карты
4299 FStartID := utils.readLongInt(st);
4300 // Индекс триггера, создавшего монстра
4301 FSpawnTrigger := utils.readLongInt(st);
4302 // Объект монстра
4303 Obj_LoadState(@FObj, st);
4304 // Есть ли анимация огня колдуна
4305 anim := utils.readBool(st);
4306 // Если есть - загружаем:
4307 if anim then
4308 begin
4309 stub := TAnimState.Create(true, 2, 8);
4310 stub.LoadState(st, alpha, blending);
4311 stub.Invalidate;
4312 end;
4313 FVileFireTime := gTime;
4314 // Анимации
4315 for i := ANIM_SLEEP to ANIM_PAIN do
4316 begin
4317 // Есть ли левая анимация
4318 anim := utils.readBool(st);
4319 // Если есть - загружаем
4320 if anim then
4321 begin
4322 Assert(FAnim[i, TDirection.D_LEFT].IsValid(), 'TMonster.LoadState: no '+IntToStr(i)+'_left anim');
4323 FAnim[i, TDirection.D_LEFT].LoadState(st, alpha, blending);
4324 end;
4325 // Есть ли правая анимация
4326 anim := utils.readBool(st);
4327 // Если есть - загружаем
4328 if anim then
4329 begin
4330 Assert(FAnim[i, TDirection.D_RIGHT].IsValid(), 'TMonster.LoadState: no '+IntToStr(i)+'_right anim');
4331 FAnim[i, TDirection.D_RIGHT].LoadState(st, alpha, blending);
4332 end;
4333 end;
4334 // update cache
4335 self.positionChanged
4336 end;
4337
4338
4339 procedure TMonster.ActivateTriggers();
4340 var
4341 a: Integer;
4342 begin
4343 if FDieTriggers <> nil then
4344 for a := 0 to High(FDieTriggers) do
4345 g_Triggers_Press(FDieTriggers[a], ACTIVATE_MONSTERPRESS);
4346 if FSpawnTrigger > -1 then
4347 begin
4348 g_Triggers_DecreaseSpawner(FSpawnTrigger);
4349 FSpawnTrigger := -1;
4350 end;
4351 end;
4352
4353 procedure TMonster.AddTrigger(t: Integer);
4354 begin
4355 SetLength(FDieTriggers, Length(FDieTriggers)+1);
4356 FDieTriggers[High(FDieTriggers)] := t;
4357 end;
4358
4359 procedure TMonster.ClearTriggers();
4360 begin
4361 SetLength(FDieTriggers, 0);
4362 end;
4363
4364 procedure TMonster.CatchFire(Attacker: Word; Timeout: Integer = MON_BURN_TIME);
4365 begin
4366 if FMonsterType in [MONSTER_SOUL, MONSTER_VILE] then
4367 exit; // арчи не горят, черепа уже горят
4368 if Timeout <= 0 then exit;
4369 if g_Obj_CollidePanel(@FObj, 0, 0, PANEL_WATER or PANEL_ACID1 or PANEL_ACID2) then
4370 exit; // не подгораем в воде на всякий случай
4371 if FFireTime <= 0 then
4372 g_Sound_PlayExAt('SOUND_IGNITE', FObj.X, FObj.Y);
4373 FFireTime := Timeout;
4374 FFireAttacker := Attacker;
4375 if g_Game_IsNet and g_Game_IsServer then MH_SEND_MonsterState(FUID);
4376 end;
4377
4378 procedure TMonster.OnFireFlame(Times: DWORD = 1);
4379 {$IFDEF ENABLE_GFX}
4380 var i: DWORD; x, y: Integer;
4381 {$ENDIF}
4382 begin
4383 {$IFDEF ENABLE_GFX}
4384 if (Random(10) = 1) and (Times = 1) then
4385 Exit;
4386 for i := 1 to Times do
4387 begin
4388 x := Obj.X + Obj.Rect.X + Random(Obj.Rect.Width + Times * 2) - (R_GFX_FLAME_WIDTH div 2);
4389 y := Obj.Y + 8 + Random(8 + Times * 2) + IfThen(FState = MONSTATE_DEAD, 16, 0);
4390 g_GFX_QueueEffect(R_GFX_FLAME, x, y);
4391 end;
4392 {$ENDIF}
4393 end;
4394
4395
4396 // ////////////////////////////////////////////////////////////////////////// //
4397 // throws on invalid uid
4398 function g_Mons_ByIdx (uid: Integer): TMonster; inline;
4399 begin
4400 result := g_Mons_ByIdx_NC(uid);
4401 if (result = nil) then raise Exception.Create('g_Mons_ByIdx: invalid monster id');
4402 end;
4403
4404 // can return null
4405 function g_Mons_ByIdx_NC (uid: Integer): TMonster; inline;
4406 begin
4407 if (uid < 0) or (uid > High(gMonsters)) then begin result := nil; exit; end;
4408 result := gMonsters[uid];
4409 end;
4410
4411 function g_Mons_TotalCount (): Integer; inline;
4412 begin
4413 result := Length(gMonsters);
4414 end;
4415
4416
4417 function g_Mons_ForEach (cb: TEachMonsterCB): Boolean;
4418 var
4419 idx: Integer;
4420 mon: TMonster;
4421 begin
4422 result := false;
4423 if (gMonsters = nil) or not assigned(cb) then exit;
4424 for idx := 0 to High(gMonsters) do
4425 begin
4426 mon := gMonsters[idx];
4427 if (mon <> nil) then
4428 begin
4429 result := cb(mon);
4430 if result then exit;
4431 end;
4432 end;
4433 end;
4434
4435
4436 function g_Mons_ForEachAlive (cb: TEachMonsterCB): Boolean;
4437 var
4438 idx: Integer;
4439 mon: TMonster;
4440 begin
4441 result := false;
4442 if (gMonsters = nil) or not assigned(cb) then exit;
4443 for idx := 0 to High(gMonsters) do
4444 begin
4445 mon := gMonsters[idx];
4446 if (mon <> nil) and mon.alive then
4447 begin
4448 result := cb(mon);
4449 if result then exit;
4450 end;
4451 end;
4452 end;
4453
4454
4455 function g_Mons_IsAnyAliveAt (x, y: Integer; width, height: Integer): Boolean;
4456 (*
4457 function monsCollCheck (mon: TMonster; atag: Integer): Boolean;
4458 begin
4459 result := mon.alive;// and g_Obj_Collide(x, y, width, height, @mon.Obj));
4460 end;
4461 *)
4462 var
4463 idx: Integer;
4464 mon: TMonster;
4465 mit: PMonster;
4466 it: TMonsterGrid.Iter;
4467 begin
4468 result := false;
4469 if (width < 1) or (height < 1) then exit;
4470 if gmon_debug_use_sqaccel then
4471 begin
4472 //result := (monsGrid.forEachInAABB(x, y, width, height, monsCollCheck) <> nil);
4473 it := monsGrid.forEachInAABB(x, y, width, height);
4474 for mit in it do if (mit.alive) then begin result := true; break; end;
4475 it.release();
4476 end
4477 else
4478 begin
4479 for idx := 0 to High(gMonsters) do
4480 begin
4481 mon := gMonsters[idx];
4482 if (mon <> nil) and mon.alive then
4483 begin
4484 if g_Obj_Collide(x, y, width, height, @mon.Obj) then
4485 begin
4486 result := true;
4487 exit;
4488 end;
4489 end;
4490 end;
4491 end;
4492 end;
4493
4494
4495 function g_Mons_ForEachAt (x, y: Integer; width, height: Integer; cb: TEachMonsterCB): Boolean;
4496 (*
4497 function monsCollCheck (mon: TMonster; atag: Integer): Boolean;
4498 begin
4499 result := cb(mon);
4500 end;
4501 *)
4502 var
4503 idx: Integer;
4504 mon: TMonster;
4505 mit: PMonster;
4506 it: TMonsterGrid.Iter;
4507 begin
4508 result := false;
4509 if (width < 1) or (height < 1) then exit;
4510 if gmon_debug_use_sqaccel then
4511 begin
4512 //result := (monsGrid.forEachInAABB(x, y, width, height, monsCollCheck) <> nil);
4513 it := monsGrid.forEachInAABB(x, y, width, height);
4514 for mit in it do if (cb(mit^)) then begin result := true; break; end;
4515 it.release();
4516 end
4517 else
4518 begin
4519 for idx := 0 to High(gMonsters) do
4520 begin
4521 mon := gMonsters[idx];
4522 if (mon <> nil) and mon.alive then
4523 begin
4524 if g_Obj_Collide(x, y, width, height, @mon.Obj) then
4525 begin
4526 result := cb(mon);
4527 if result then exit;
4528 end;
4529 end;
4530 end;
4531 end;
4532 end;
4533
4534
4535 function g_Mons_ForEachAliveAt (x, y: Integer; width, height: Integer; cb: TEachMonsterCB): Boolean;
4536 (*
4537 function monsCollCheck (mon: TMonster; atag: Integer): Boolean;
4538 begin
4539 //result := false;
4540 //if mon.alive and g_Obj_Collide(x, y, width, height, @mon.Obj) then result := cb(mon);
4541 if mon.alive then result := cb(mon) else result := false;
4542 end;
4543 *)
4544 var
4545 idx: Integer;
4546 mon: TMonster;
4547 mit: PMonster;
4548 it: TMonsterGrid.Iter;
4549 begin
4550 result := false;
4551 if (width < 1) or (height < 1) then exit;
4552 if gmon_debug_use_sqaccel then
4553 begin
4554 {
4555 if (width = 1) and (height = 1) then
4556 begin
4557 result := (monsGrid.forEachAtPoint(x, y, monsCollCheck) <> nil);
4558 end
4559 else
4560 begin
4561 result := (monsGrid.forEachInAABB(x, y, width, height, monsCollCheck) <> nil);
4562 end;
4563 }
4564 it := monsGrid.forEachInAABB(x, y, width, height);
4565 for mit in it do
4566 begin
4567 if (mit^.alive) then
4568 begin
4569 if (cb(mit^)) then begin result := true; break; end;
4570 end;
4571 end;
4572 it.release();
4573 end
4574 else
4575 begin
4576 for idx := 0 to High(gMonsters) do
4577 begin
4578 mon := gMonsters[idx];
4579 if (mon <> nil) and mon.alive then
4580 begin
4581 if g_Obj_Collide(x, y, width, height, @mon.Obj) then
4582 begin
4583 result := cb(mon);
4584 if result then exit;
4585 end;
4586 end;
4587 end;
4588 end;
4589 end;
4590
4591
4592 end.
[MIRROR] a port of Doom 2D Forever to FPC/SDL
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024