DEADSOFTWARE

Always switch to berserk
[d2df-sdl.git] / src / game / g_map.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 {$DEFINE MAP_DEBUG_ENABLED_FLAG}
17 unit g_map;
19 interface
21 uses
22 SysUtils, Classes, mempool,
23 e_graphics, g_basic, MAPDEF, g_textures,
24 g_phys, utils, g_panel, g_grid, md5, binheap, xprofiler, xparser, xdynrec;
26 type
27 TMapInfo = record
28 Map: String;
29 Name: String;
30 Description: String;
31 Author: String;
32 MusicName: String;
33 SkyName: String;
34 Height: Word;
35 Width: Word;
36 end;
38 PRespawnPoint = ^TRespawnPoint;
39 TRespawnPoint = record
40 X, Y: Integer;
41 Direction: TDirection;
42 PointType: Byte;
43 end;
45 PFlagPoint = ^TFlagPoint;
46 TFlagPoint = TRespawnPoint;
48 PFlag = ^TFlag;
49 TFlag = record
50 Obj: TObj;
51 RespawnType: Byte;
52 State: Byte;
53 Count: Integer;
54 CaptureTime: LongWord;
55 Animation: TAnimation;
56 Direction: TDirection;
57 NeedSend: Boolean;
58 end;
60 function g_Map_Load(Res: String): Boolean;
61 function g_Map_GetMapInfo(Res: String): TMapInfo;
62 function g_Map_GetMapsList(WADName: String): SSArray;
63 function g_Map_Exist(Res: String): Boolean;
64 procedure g_Map_Free(freeTextures: Boolean=true);
65 procedure g_Map_Update();
67 function g_Map_PanelByGUID (aguid: Integer): TPanel; inline;
69 procedure g_Map_DrawPanels (PanelType: Word; hasAmbient: Boolean; constref ambColor: TDFColor); // unaccelerated
70 procedure g_Map_CollectDrawPanels (x0, y0, wdt, hgt: Integer);
72 procedure g_Map_DrawBack(dx, dy: Integer);
73 function g_Map_CollidePanel(X, Y: Integer; Width, Height: Word;
74 PanelType: Word; b1x3: Boolean=false): Boolean;
75 function g_Map_CollideLiquid_Texture(X, Y: Integer; Width, Height: Word): DWORD;
77 procedure g_Map_EnableWallGUID (pguid: Integer);
78 procedure g_Map_DisableWallGUID (pguid: Integer);
79 procedure g_Map_SetLiftGUID (pguid: Integer; t: Integer);
81 // HACK!!!
82 procedure g_Map_EnableWall_XXX (ID: DWORD);
83 procedure g_Map_DisableWall_XXX (ID: DWORD);
84 procedure g_Map_SetLift_XXX (ID: DWORD; t: Integer);
86 procedure g_Map_SwitchTextureGUID (pguid: Integer; AnimLoop: Byte = 0);
88 procedure g_Map_ReAdd_DieTriggers();
89 function g_Map_IsSpecialTexture(Texture: String): Boolean;
91 function g_Map_GetPoint(PointType: Byte; var RespawnPoint: TRespawnPoint): Boolean;
92 function g_Map_GetPointCount(PointType: Byte): Word;
93 function g_Map_GetRandomPointType(): Byte;
95 function g_Map_HaveFlagPoints(): Boolean;
97 procedure g_Map_ResetFlag(Flag: Byte);
98 procedure g_Map_DrawFlags();
100 procedure g_Map_SaveState (st: TStream);
101 procedure g_Map_LoadState (st: TStream);
103 procedure g_Map_DrawPanelShadowVolumes(lightX: Integer; lightY: Integer; radius: Integer);
105 // returns panel or nil
106 // sets `ex` and `ey` to `x1` and `y1` when no hit was detected
107 function g_Map_traceToNearestWall (x0, y0, x1, y1: Integer; hitx: PInteger=nil; hity: PInteger=nil): TPanel;
109 // returns panel or nil
110 // sets `ex` and `ey` to `x1` and `y1` when no hit was detected
111 function g_Map_traceToNearest (x0, y0, x1, y1: Integer; tag: Integer; hitx: PInteger=nil; hity: PInteger=nil): TPanel;
113 type
114 TForEachPanelCB = function (pan: TPanel): Boolean is nested; // return `true` to stop
116 function g_Map_HasAnyPanelAtPoint (x, y: Integer; panelType: Word): Boolean;
117 function g_Map_PanelAtPoint (x, y: Integer; tagmask: Integer=-1): TPanel;
119 // trace liquid, stepping by `dx` and `dy`
120 // return last seen liquid coords, and `false` if we're started outside of the liquid
121 function g_Map_TraceLiquidNonPrecise (x, y, dx, dy: Integer; out topx, topy: Integer): Boolean;
124 // return `true` from `cb` to stop
125 function g_Map_ForEachPanel (cb: TForEachPanelCB): TPanel;
127 procedure g_Map_NetSendInterestingPanels (); // yay!
130 procedure g_Map_ProfilersBegin ();
131 procedure g_Map_ProfilersEnd ();
134 function g_Map_ParseMap (data: Pointer; dataLen: Integer): TDynRecord;
137 function g_Map_MinX (): Integer; inline;
138 function g_Map_MinY (): Integer; inline;
139 function g_Map_MaxX (): Integer; inline;
140 function g_Map_MaxY (): Integer; inline;
142 const
143 NNF_NO_NAME = 0;
144 NNF_NAME_BEFORE = 1;
145 NNF_NAME_EQUALS = 2;
146 NNF_NAME_AFTER = 3;
148 function g_Texture_NumNameFindStart(name: String): Boolean;
149 function g_Texture_NumNameFindNext(var newName: String): Byte;
151 const
152 RESPAWNPOINT_PLAYER1 = 1;
153 RESPAWNPOINT_PLAYER2 = 2;
154 RESPAWNPOINT_DM = 3;
155 RESPAWNPOINT_RED = 4;
156 RESPAWNPOINT_BLUE = 5;
158 FLAG_NONE = 0;
159 FLAG_RED = 1;
160 FLAG_BLUE = 2;
161 FLAG_DOM = 3;
163 FLAG_STATE_NONE = 0;
164 FLAG_STATE_NORMAL = 1;
165 FLAG_STATE_DROPPED = 2;
166 FLAG_STATE_CAPTURED = 3;
167 FLAG_STATE_SCORED = 4; // Äëÿ ýâåíòîâ ÷åðåç ñåòêó.
168 FLAG_STATE_RETURNED = 5; // Äëÿ ýâåíòîâ ÷åðåç ñåòêó.
170 FLAG_TIME = 720; // 20 seconds
172 SKY_STRETCH: Single = 1.5;
174 const
175 GridTagInvalid = 0;
177 (* draw order:
178 PANEL_BACK
179 PANEL_STEP
180 PANEL_WALL
181 PANEL_CLOSEDOOR
182 PANEL_ACID1
183 PANEL_ACID2
184 PANEL_WATER
185 PANEL_FORE
186 *)
187 // sorted by draw priority
188 GridTagBack = 1 shl 0; // gRenderBackgrounds
189 GridTagStep = 1 shl 1; // gSteps
190 GridTagWall = 1 shl 2; // gWalls
191 GridTagDoor = 1 shl 3; // gWalls
192 GridTagAcid1 = 1 shl 4; // gAcid1
193 GridTagAcid2 = 1 shl 5; // gAcid2
194 GridTagWater = 1 shl 6; // gWater
195 GridTagFore = 1 shl 7; // gRenderForegrounds
196 // the following are invisible
197 GridTagLift = 1 shl 8; // gLifts
198 GridTagBlockMon = 1 shl 9; // gBlockMon
200 GridTagSolid = (GridTagWall or GridTagDoor);
201 GridTagObstacle = (GridTagStep or GridTagWall or GridTagDoor);
202 GridTagLiquid = (GridTagAcid1 or GridTagAcid2 or GridTagWater);
204 GridDrawableMask = (GridTagBack or GridTagStep or GridTagWall or GridTagDoor or GridTagAcid1 or GridTagAcid2 or GridTagWater or GridTagFore);
207 type
208 TBinHeapPanelDrawCmp = class
209 public
210 class function less (const a, b: TPanel): Boolean; inline;
211 end;
213 TBinHeapPanelDraw = specialize TBinaryHeapBase<TPanel, TBinHeapPanelDrawCmp>;
215 var
216 gWalls: TPanelArray;
217 gRenderBackgrounds: TPanelArray;
218 gRenderForegrounds: TPanelArray;
219 gWater, gAcid1, gAcid2: TPanelArray;
220 gSteps: TPanelArray;
221 gLifts: TPanelArray;
222 gBlockMon: TPanelArray;
223 gFlags: array [FLAG_RED..FLAG_BLUE] of TFlag;
224 //gDOMFlags: array of TFlag;
225 gMapInfo: TMapInfo;
226 gBackSize: TDFPoint;
227 gDoorMap: array of array of DWORD;
228 gLiftMap: array of array of DWORD;
229 gWADHash: TMD5Digest;
230 BackID: DWORD = DWORD(-1);
231 gExternalResources: array of TDiskFileInfo = nil;
232 gMovingWallIds: array of Integer = nil;
234 gdbg_map_use_accel_render: Boolean = true;
235 gdbg_map_use_accel_coldet: Boolean = true;
236 profMapCollision: TProfiler = nil; //WARNING: FOR DEBUGGING ONLY!
237 gDrawPanelList: TBinHeapPanelDraw = nil; // binary heap of all walls we have to render, populated by `g_Map_CollectDrawPanels()`
239 gCurrentMap: TDynRecord = nil;
240 gCurrentMapFileName: AnsiString = ''; // so we can skip texture reloading
241 gTestMap: String = '';
244 function panelTypeToTag (panelType: Word): Integer; // returns GridTagXXX
247 type
248 TPanelGrid = specialize TBodyGridBase<TPanel>;
250 var
251 mapGrid: TPanelGrid = nil; // DO NOT USE! public for debugging only!
254 implementation
256 uses
257 {$INCLUDE ../nogl/noGLuses.inc}
258 e_input, g_main, e_log, e_texture, e_res, g_items, g_gfx, g_console,
259 g_weapons, g_game, g_sound, e_sound, CONFIG,
260 g_options, g_triggers, g_player,
261 Math, g_monsters, g_saveload, g_language, g_netmsg,
262 sfs, xstreams, hashtable, wadreader,
263 ImagingTypes, Imaging, ImagingUtility,
264 ImagingGif, ImagingNetworkGraphics,
265 g_res_downloader;
267 const
268 FLAGRECT: TRectWH = (X:15; Y:12; Width:33; Height:52);
269 MUSIC_SIGNATURE = $4953554D; // 'MUSI'
270 FLAG_SIGNATURE = $47414C46; // 'FLAG'
273 // ////////////////////////////////////////////////////////////////////////// //
274 procedure mapWarningCB (const msg: AnsiString; line, col: Integer);
275 begin
276 if (line > 0) then
277 begin
278 e_LogWritefln('parse error at (%s,%s): %s', [line, col, msg], TMsgType.Warning);
279 end
280 else
281 begin
282 e_LogWritefln('parse error: %s', [msg], TMsgType.Warning);
283 end;
284 end;
287 // ////////////////////////////////////////////////////////////////////////// //
288 var
289 panByGUID: array of TPanel = nil;
292 // ////////////////////////////////////////////////////////////////////////// //
293 function g_Map_PanelByGUID (aguid: Integer): TPanel; inline;
294 begin
295 //if (panByGUID = nil) or (not panByGUID.get(aguid, result)) then result := nil;
296 if (aguid >= 0) and (aguid < Length(panByGUID)) then result := panByGUID[aguid] else result := nil;
297 end;
300 // return `true` from `cb` to stop
301 function g_Map_ForEachPanel (cb: TForEachPanelCB): TPanel;
302 var
303 pan: TPanel;
304 begin
305 result := nil;
306 if not assigned(cb) then exit;
307 for pan in panByGUID do
308 begin
309 if cb(pan) then begin result := pan; exit; end;
310 end;
311 end;
314 procedure g_Map_NetSendInterestingPanels ();
315 var
316 pan: TPanel;
317 begin
318 if g_Game_IsServer and g_Game_IsNet then
319 begin
320 for pan in panByGUID do
321 begin
322 if pan.gncNeedSend then MH_SEND_PanelState(pan.guid);
323 end;
324 end;
325 end;
328 // ////////////////////////////////////////////////////////////////////////// //
329 function g_Map_MinX (): Integer; inline; begin if (mapGrid <> nil) then result := mapGrid.gridX0 else result := 0; end;
330 function g_Map_MinY (): Integer; inline; begin if (mapGrid <> nil) then result := mapGrid.gridY0 else result := 0; end;
331 function g_Map_MaxX (): Integer; inline; begin if (mapGrid <> nil) then result := mapGrid.gridX0+mapGrid.gridWidth-1 else result := 0; end;
332 function g_Map_MaxY (): Integer; inline; begin if (mapGrid <> nil) then result := mapGrid.gridY0+mapGrid.gridHeight-1 else result := 0; end;
335 // ////////////////////////////////////////////////////////////////////////// //
336 var
337 dfmapdef: TDynMapDef = nil;
340 procedure loadMapDefinition ();
341 var
342 pr: TTextParser = nil;
343 st: TStream = nil;
344 WAD: TWADFile = nil;
345 begin
346 if (dfmapdef <> nil) then exit;
348 try
349 e_LogWritefln('parsing "mapdef.txt"...', []);
350 st := e_OpenResourceRO(DataDirs, 'mapdef.txt');
351 e_LogWritefln('found local "mapdef.txt"', []);
352 except
353 st := nil;
354 end;
356 if (st = nil) then
357 begin
358 WAD := TWADFile.Create();
359 if not WAD.ReadFile(GameWAD) then
360 begin
361 //raise Exception.Create('cannot load "game.wad"');
362 st := nil;
363 end
364 else
365 begin
366 st := WAD.openFileStream('mapdef.txt');
367 end;
368 end;
370 try
371 if (st = nil) then
372 begin
373 //raise Exception.Create('cannot open "mapdef.txt"');
374 e_LogWriteln('using default "mapdef.txt"...');
375 pr := TStrTextParser.Create(defaultMapDef);
376 end
377 else
378 begin
379 pr := TFileTextParser.Create(st);
380 end;
381 except on e: Exception do
382 begin
383 e_LogWritefln('something is VERY wrong here! -- ', [e.message]);
384 raise;
385 end;
386 end;
388 try
389 dfmapdef := TDynMapDef.Create(pr);
390 except
391 on e: TDynParseException do
392 raise Exception.CreateFmt('ERROR in "mapdef.txt" at (%s,%s): %s', [e.tokLine, e.tokCol, e.message]);
393 on e: Exception do
394 raise Exception.CreateFmt('ERROR in "mapdef.txt" at (%s,%s): %s', [pr.tokLine, pr.tokCol, e.message]);
395 end;
397 st.Free();
398 WAD.Free();
399 end;
402 // ////////////////////////////////////////////////////////////////////////// //
403 function g_Map_ParseMap (data: Pointer; dataLen: Integer): TDynRecord;
404 var
405 wst: TSFSMemoryChunkStream = nil;
406 begin
407 result := nil;
408 if (dataLen < 4) then exit;
410 if (dfmapdef = nil) then writeln('need to load mapdef');
411 loadMapDefinition();
412 if (dfmapdef = nil) then raise Exception.Create('internal map loader error');
414 wst := TSFSMemoryChunkStream.Create(data, dataLen);
415 try
416 result := dfmapdef.parseMap(wst);
417 except
418 on e: TDynParseException do
419 begin
420 e_LogWritefln('ERROR at (%s,%s): %s', [e.tokLine, e.tokCol, e.message]);
421 wst.Free();
422 result := nil;
423 exit;
424 end;
425 on e: Exception do
426 begin
427 e_LogWritefln('ERROR: %s', [e.message]);
428 wst.Free();
429 result := nil;
430 exit;
431 end;
432 end;
434 //e_LogWriteln('map parsed.');
435 end;
438 // ////////////////////////////////////////////////////////////////////////// //
439 var
440 NNF_PureName: String; // Èìÿ òåêñòóðû áåç öèôð â êîíöå
441 NNF_PureExt: String; // extension postfix
442 NNF_FirstNum: Integer; // ×èñëî ó íà÷àëüíîé òåêñòóðû
443 NNF_CurrentNum: Integer; // Ñëåäóþùåå ÷èñëî ó òåêñòóðû
446 function g_Texture_NumNameFindStart(name: String): Boolean;
447 var
448 i, j: Integer;
450 begin
451 Result := False;
452 NNF_PureName := '';
453 NNF_PureExt := '';
454 NNF_FirstNum := -1;
455 NNF_CurrentNum := -1;
457 for i := Length(name) downto 1 do
458 if (name[i] = '_') then // "_" - ñèìâîë íà÷àëà íîìåðíîãî ïîñòôèêñà
459 begin
460 if i = Length(name) then
461 begin // Íåò öèôð â êîíöå ñòðîêè
462 Exit;
463 end
464 else
465 begin
466 j := i + 1;
467 while (j <= Length(name)) and (name[j] <> '.') do inc(j);
468 NNF_PureName := Copy(name, 1, i);
469 NNF_PureExt := Copy(name, j);
470 name := Copy(name, i + 1, j - i - 1);
471 Break;
472 end;
473 end;
475 // Íå ïåðåâåñòè â ÷èñëî:
476 if not TryStrToInt(name, NNF_FirstNum) then
477 Exit;
479 NNF_CurrentNum := 0;
481 Result := True;
482 end;
485 function g_Texture_NumNameFindNext(var newName: String): Byte;
486 begin
487 if (NNF_PureName = '') or (NNF_CurrentNum < 0) then
488 begin
489 newName := '';
490 Result := NNF_NO_NAME;
491 Exit;
492 end;
494 newName := NNF_PureName + IntToStr(NNF_CurrentNum) + NNF_PureExt;
496 if NNF_CurrentNum < NNF_FirstNum then
497 Result := NNF_NAME_BEFORE
498 else
499 if NNF_CurrentNum > NNF_FirstNum then
500 Result := NNF_NAME_AFTER
501 else
502 Result := NNF_NAME_EQUALS;
504 Inc(NNF_CurrentNum);
505 end;
508 // ////////////////////////////////////////////////////////////////////////// //
509 function panelTypeToTag (panelType: Word): Integer;
510 begin
511 case panelType of
512 PANEL_WALL: result := GridTagWall; // gWalls
513 PANEL_OPENDOOR, PANEL_CLOSEDOOR: result := GridTagDoor; // gWalls
514 PANEL_BACK: result := GridTagBack; // gRenderBackgrounds
515 PANEL_FORE: result := GridTagFore; // gRenderForegrounds
516 PANEL_WATER: result := GridTagWater; // gWater
517 PANEL_ACID1: result := GridTagAcid1; // gAcid1
518 PANEL_ACID2: result := GridTagAcid2; // gAcid2
519 PANEL_STEP: result := GridTagStep; // gSteps
520 PANEL_LIFTUP, PANEL_LIFTDOWN, PANEL_LIFTLEFT, PANEL_LIFTRIGHT: result := GridTagLift; // gLifts -- this is for all lifts
521 PANEL_BLOCKMON: result := GridTagBlockMon; // gBlockMon -- this is for all blockmons
522 else result := GridTagInvalid;
523 end;
524 end;
527 class function TBinHeapPanelDrawCmp.less (const a, b: TPanel): Boolean; inline;
528 begin
529 if (a.tag < b.tag) then begin result := true; exit; end;
530 if (a.tag > b.tag) then begin result := false; exit; end;
531 result := (a.arrIdx < b.arrIdx);
532 end;
534 procedure dplClear ();
535 begin
536 if (gDrawPanelList = nil) then gDrawPanelList := TBinHeapPanelDraw.Create() else gDrawPanelList.clear();
537 end;
540 var
541 Textures: TLevelTextureArray = nil;
542 TextNameHash: THashStrInt = nil; // key: texture name; value: index in `Textures`
543 BadTextNameHash: THashStrInt = nil; // set; so we won't spam with non-existing texture messages
544 RespawnPoints: array of TRespawnPoint;
545 FlagPoints: array[FLAG_RED..FLAG_BLUE] of PFlagPoint;
546 //DOMFlagPoints: Array of TFlagPoint;
549 procedure g_Map_ProfilersBegin ();
550 begin
551 if (profMapCollision = nil) then profMapCollision := TProfiler.Create('COLSOLID', g_profile_history_size);
552 if (profMapCollision <> nil) then profMapCollision.mainBegin(g_profile_collision);
553 // create sections
554 if g_profile_collision and (profMapCollision <> nil) then
555 begin
556 profMapCollision.sectionBegin('*solids');
557 profMapCollision.sectionEnd();
558 profMapCollision.sectionBegin('liquids');
559 profMapCollision.sectionEnd();
560 end;
561 end;
563 procedure g_Map_ProfilersEnd ();
564 begin
565 if (profMapCollision <> nil) then profMapCollision.mainEnd();
566 end;
569 // wall index in `gWalls` or -1
570 function g_Map_traceToNearestWall (x0, y0, x1, y1: Integer; hitx: PInteger=nil; hity: PInteger=nil): TPanel;
571 var
572 ex, ey: Integer;
573 begin
574 result := mapGrid.traceRay(ex, ey, x0, y0, x1, y1, (GridTagWall or GridTagDoor));
575 if (result <> nil) then
576 begin
577 if (hitx <> nil) then hitx^ := ex;
578 if (hity <> nil) then hity^ := ey;
579 end
580 else
581 begin
582 if (hitx <> nil) then hitx^ := x1;
583 if (hity <> nil) then hity^ := y1;
584 end;
585 end;
587 // returns panel or nil
588 function g_Map_traceToNearest (x0, y0, x1, y1: Integer; tag: Integer; hitx: PInteger=nil; hity: PInteger=nil): TPanel;
589 var
590 ex, ey: Integer;
591 begin
592 result := mapGrid.traceRay(ex, ey, x0, y0, x1, y1, tag);
593 if (result <> nil) then
594 begin
595 if (hitx <> nil) then hitx^ := ex;
596 if (hity <> nil) then hity^ := ey;
597 end
598 else
599 begin
600 if (hitx <> nil) then hitx^ := x1;
601 if (hity <> nil) then hity^ := y1;
602 end;
603 end;
606 function xxPanAtPointChecker (pan: TPanel; panelType: Word): Boolean; inline;
607 begin
608 if ((pan.tag and GridTagLift) <> 0) then
609 begin
610 // stop if the lift of the right type
611 result :=
612 ((WordBool(PanelType and PANEL_LIFTUP) and (pan.LiftType = LIFTTYPE_UP)) or
613 (WordBool(PanelType and PANEL_LIFTDOWN) and (pan.LiftType = LIFTTYPE_DOWN)) or
614 (WordBool(PanelType and PANEL_LIFTLEFT) and (pan.LiftType = LIFTTYPE_LEFT)) or
615 (WordBool(PanelType and PANEL_LIFTRIGHT) and (pan.LiftType = LIFTTYPE_RIGHT)));
616 exit;
617 end;
618 result := true; // otherwise, stop anyway, 'cause `forEachAtPoint()` is guaranteed to call this only for correct panels
619 end;
621 function g_Map_HasAnyPanelAtPoint (x, y: Integer; panelType: Word): Boolean;
622 var
623 tagmask: Integer = 0;
624 mwit: PPanel;
625 it: TPanelGrid.Iter;
626 begin
627 result := false;
629 if WordBool(PanelType and (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_OPENDOOR)) then tagmask := tagmask or (GridTagWall or GridTagDoor);
630 if WordBool(PanelType and PANEL_WATER) then tagmask := tagmask or GridTagWater;
631 if WordBool(PanelType and PANEL_ACID1) then tagmask := tagmask or GridTagAcid1;
632 if WordBool(PanelType and PANEL_ACID2) then tagmask := tagmask or GridTagAcid2;
633 if WordBool(PanelType and PANEL_STEP) then tagmask := tagmask or GridTagStep;
634 if WordBool(PanelType and (PANEL_LIFTUP or PANEL_LIFTDOWN or PANEL_LIFTLEFT or PANEL_LIFTRIGHT)) then tagmask := tagmask or GridTagLift;
635 if WordBool(PanelType and PANEL_BLOCKMON) then tagmask := tagmask or GridTagBlockMon;
637 if (tagmask = 0) then exit;// just in case
639 if ((tagmask and GridTagLift) <> 0) then
640 begin
641 // slow
642 it := mapGrid.forEachAtPoint(x, y, tagmask);
643 for mwit in it do if (xxPanAtPointChecker(mwit^, PanelType)) then begin result := true; break; end;
644 end
645 else
646 begin
647 // fast
648 it := mapGrid.forEachAtPoint(x, y, tagmask, false, true);
649 result := (it.length <> 0); // firsthit
650 end;
651 it.release();
652 end;
655 function g_Map_PanelAtPoint (x, y: Integer; tagmask: Integer=-1): TPanel;
656 var
657 it: TPanelGrid.Iter;
658 begin
659 result := nil;
660 if (tagmask = 0) then exit;
661 it := mapGrid.forEachAtPoint(x, y, tagmask, false, true); // firsthit
662 if (it.length <> 0) then result := it.first^;
663 it.release();
664 end;
667 function g_Map_IsSpecialTexture(Texture: String): Boolean;
668 begin
669 Result := (Texture = TEXTURE_NAME_WATER) or
670 (Texture = TEXTURE_NAME_ACID1) or
671 (Texture = TEXTURE_NAME_ACID2);
672 end;
674 procedure CreateDoorMap();
675 var
676 PanelArray: Array of record
677 X, Y: Integer;
678 Width, Height: Word;
679 Active: Boolean;
680 PanelID: DWORD;
681 end;
682 a, b, c, m, i, len: Integer;
683 ok: Boolean;
684 begin
685 if gWalls = nil then
686 Exit;
688 i := 0;
689 len := 128;
690 SetLength(PanelArray, len);
692 for a := 0 to High(gWalls) do
693 if gWalls[a].Door then
694 begin
695 PanelArray[i].X := gWalls[a].X;
696 PanelArray[i].Y := gWalls[a].Y;
697 PanelArray[i].Width := gWalls[a].Width;
698 PanelArray[i].Height := gWalls[a].Height;
699 PanelArray[i].Active := True;
700 PanelArray[i].PanelID := a;
702 i := i + 1;
703 if i = len then
704 begin
705 len := len + 128;
706 SetLength(PanelArray, len);
707 end;
708 end;
710 // Íåò äâåðåé:
711 if i = 0 then
712 begin
713 PanelArray := nil;
714 Exit;
715 end;
717 SetLength(gDoorMap, 0);
719 g_Game_SetLoadingText(_lc[I_LOAD_DOOR_MAP], i-1, False);
721 for a := 0 to i-1 do
722 if PanelArray[a].Active then
723 begin
724 PanelArray[a].Active := False;
725 m := Length(gDoorMap);
726 SetLength(gDoorMap, m+1);
727 SetLength(gDoorMap[m], 1);
728 gDoorMap[m, 0] := PanelArray[a].PanelID;
729 ok := True;
731 while ok do
732 begin
733 ok := False;
735 for b := 0 to i-1 do
736 if PanelArray[b].Active then
737 for c := 0 to High(gDoorMap[m]) do
738 if {((gRenderWalls[PanelArray[b].RenderPanelID].TextureID = gRenderWalls[gDoorMap[m, c]].TextureID) or
739 gRenderWalls[PanelArray[b].RenderPanelID].Hide or gRenderWalls[gDoorMap[m, c]].Hide) and}
740 g_CollideAround(PanelArray[b].X, PanelArray[b].Y,
741 PanelArray[b].Width, PanelArray[b].Height,
742 gWalls[gDoorMap[m, c]].X,
743 gWalls[gDoorMap[m, c]].Y,
744 gWalls[gDoorMap[m, c]].Width,
745 gWalls[gDoorMap[m, c]].Height) then
746 begin
747 PanelArray[b].Active := False;
748 SetLength(gDoorMap[m],
749 Length(gDoorMap[m])+1);
750 gDoorMap[m, High(gDoorMap[m])] := PanelArray[b].PanelID;
751 ok := True;
752 Break;
753 end;
754 end;
756 g_Game_StepLoading();
757 end;
759 PanelArray := nil;
760 end;
762 procedure CreateLiftMap();
763 var
764 PanelArray: Array of record
765 X, Y: Integer;
766 Width, Height: Word;
767 Active: Boolean;
768 end;
769 a, b, c, len, i, j: Integer;
770 ok: Boolean;
771 begin
772 if gLifts = nil then
773 Exit;
775 len := Length(gLifts);
776 SetLength(PanelArray, len);
778 for a := 0 to len-1 do
779 begin
780 PanelArray[a].X := gLifts[a].X;
781 PanelArray[a].Y := gLifts[a].Y;
782 PanelArray[a].Width := gLifts[a].Width;
783 PanelArray[a].Height := gLifts[a].Height;
784 PanelArray[a].Active := True;
785 end;
787 SetLength(gLiftMap, len);
788 i := 0;
790 g_Game_SetLoadingText(_lc[I_LOAD_LIFT_MAP], len-1, False);
792 for a := 0 to len-1 do
793 if PanelArray[a].Active then
794 begin
795 PanelArray[a].Active := False;
796 SetLength(gLiftMap[i], 32);
797 j := 0;
798 gLiftMap[i, j] := a;
799 ok := True;
801 while ok do
802 begin
803 ok := False;
804 for b := 0 to len-1 do
805 if PanelArray[b].Active then
806 for c := 0 to j do
807 if g_CollideAround(PanelArray[b].X,
808 PanelArray[b].Y,
809 PanelArray[b].Width,
810 PanelArray[b].Height,
811 PanelArray[gLiftMap[i, c]].X,
812 PanelArray[gLiftMap[i, c]].Y,
813 PanelArray[gLiftMap[i, c]].Width,
814 PanelArray[gLiftMap[i, c]].Height) then
815 begin
816 PanelArray[b].Active := False;
817 j := j+1;
818 if j > High(gLiftMap[i]) then
819 SetLength(gLiftMap[i],
820 Length(gLiftMap[i])+32);
822 gLiftMap[i, j] := b;
823 ok := True;
825 Break;
826 end;
827 end;
829 SetLength(gLiftMap[i], j+1);
830 i := i+1;
832 g_Game_StepLoading();
833 end;
835 SetLength(gLiftMap, i);
837 PanelArray := nil;
838 end;
840 function CreatePanel (PanelRec: TDynRecord; AddTextures: TAddTextureArray; CurTex: Integer): Integer;
841 var
842 len: Integer;
843 panels: ^TPanelArray;
844 pan: TPanel;
845 pguid: Integer;
846 begin
847 Result := -1;
849 case PanelRec.PanelType of
850 PANEL_WALL, PANEL_OPENDOOR, PANEL_CLOSEDOOR: panels := @gWalls;
851 PANEL_BACK: panels := @gRenderBackgrounds;
852 PANEL_FORE: panels := @gRenderForegrounds;
853 PANEL_WATER: panels := @gWater;
854 PANEL_ACID1: panels := @gAcid1;
855 PANEL_ACID2: panels := @gAcid2;
856 PANEL_STEP: panels := @gSteps;
857 PANEL_LIFTUP, PANEL_LIFTDOWN, PANEL_LIFTLEFT, PANEL_LIFTRIGHT: panels := @gLifts;
858 PANEL_BLOCKMON: panels := @gBlockMon;
859 else exit;
860 end;
862 len := Length(panels^);
863 SetLength(panels^, len+1);
865 pguid := Length(panByGUID);
866 SetLength(panByGUID, pguid+1); //FIXME!
867 pan := TPanel.Create(PanelRec, AddTextures, CurTex, Textures, pguid);
868 assert(pguid >= 0);
869 assert(pguid < Length(panByGUID));
870 panByGUID[pguid] := pan;
871 panels^[len] := pan;
872 pan.arrIdx := len;
873 pan.proxyId := -1;
874 pan.tag := panelTypeToTag(PanelRec.PanelType);
876 PanelRec.user['panel_guid'] := pguid;
878 //result := len;
879 result := pguid;
880 end;
883 function CreateNullTexture(RecName: String): Integer;
884 begin
885 RecName := toLowerCase1251(RecName);
886 if (TextNameHash = nil) then TextNameHash := THashStrInt.Create();
887 if TextNameHash.get(RecName, result) then exit; // i found her!
889 SetLength(Textures, Length(Textures)+1);
890 result := High(Textures);
892 with Textures[High(Textures)] do
893 begin
894 TextureName := RecName;
895 Width := 1;
896 Height := 1;
897 Anim := False;
898 TextureID := LongWord(TEXTURE_NONE);
899 end;
901 TextNameHash.put(RecName, result);
902 end;
905 function extractWadName (resourceName: string): string;
906 var
907 posN: Integer;
908 begin
909 posN := Pos(':', resourceName);
910 if posN > 0 then
911 Result:= Copy(resourceName, 0, posN-1)
912 else
913 Result := '';
914 end;
917 procedure addResToExternalResList (res: AnsiString);
918 var
919 uname: AnsiString;
920 f: Integer;
921 fi: TDiskFileInfo;
922 begin
923 if g_Game_IsClient or not g_Game_IsNet then exit;
924 if (length(res) = 0) then exit; // map wad
925 //res := extractWadName(res);
926 //if (length(res) = 0) then exit; // map wad
927 uname := toLowerCase1251(res);
928 // do not add duplicates
929 for f := 0 to High(gExternalResources) do
930 begin
931 if (gExternalResources[f].userName = uname) then exit;
932 end;
933 //writeln('***(000) addResToExternalResList: res=[', res, ']');
934 // add new resource
935 fi.userName := uname;
936 if not findFileCI(res) then exit;
937 //writeln('***(001) addResToExternalResList: res=[', res, ']');
938 fi.diskName := res;
939 if (not GetDiskFileInfo(res, fi)) then
940 begin
941 fi.tag := -1;
942 end
943 else
944 begin
945 //writeln('***(002) addResToExternalResList: res=[', res, ']');
946 fi.tag := 0; // non-zero means "cannot caclucate hash"
947 try
948 fi.hash := MD5File(fi.diskName);
949 except
950 fi.tag := -1;
951 end;
952 end;
953 //e_LogWritefln('addext: res=[%s]; uname=[%s]; diskName=[%s]', [res, fi.userName, fi.diskName]);
954 SetLength(gExternalResources, length(gExternalResources)+1);
955 gExternalResources[High(gExternalResources)] := fi;
956 end;
959 procedure compactExtResList ();
960 var
961 src, dest: Integer;
962 begin
963 src := 0;
964 dest := 0;
965 for src := 0 to High(gExternalResources) do
966 begin
967 if (gExternalResources[src].tag = 0) then
968 begin
969 // copy it
970 if (dest <> src) then gExternalResources[dest] := gExternalResources[src];
971 Inc(dest);
972 end;
973 end;
974 if (dest <> length(gExternalResources)) then SetLength(gExternalResources, dest);
975 end;
978 function GetReplacementWad (WadName: AnsiString): AnsiString;
979 begin
980 result := '';
981 if WadName <> '' then
982 begin
983 result := WadName;
984 if g_Game_IsClient then result := g_Res_FindReplacementWad(WadName);
985 if (result = WadName) then result := e_FindWad(WadDirs, result)
986 end;
987 end;
990 procedure generateExternalResourcesList (map: TDynRecord);
991 begin
992 SetLength(gExternalResources, 0);
993 addResToExternalResList(GetReplacementWad(g_ExtractWadName(map.MusicName)));
994 addResToExternalResList(GetReplacementWad(g_ExtractWadName(map.SkyName)));
995 end;
998 function CreateTexture (RecName: AnsiString; Map: string; log: Boolean): Integer;
999 var
1000 WAD: TWADFile;
1001 TextureData: Pointer;
1002 WADName: String;
1003 a, ResLength: Integer;
1004 begin
1005 RecName := toLowerCase1251(RecName);
1006 if (TextNameHash = nil) then TextNameHash := THashStrInt.Create();
1007 if TextNameHash.get(RecName, result) then
1008 begin
1009 // i found her!
1010 //e_LogWritefln('texture ''%s'' already loaded (%s)', [RecName, result]);
1011 exit;
1012 end;
1014 Result := -1;
1016 if (BadTextNameHash <> nil) and BadTextNameHash.has(RecName) then exit; // don't do it again and again
1019 if Textures <> nil then
1020 begin
1021 for a := 0 to High(Textures) do
1022 begin
1023 if (Textures[a].TextureName = RecName) then
1024 begin // Òåêñòóðà ñ òàêèì èìåíåì óæå åñòü
1025 e_LogWritefln('texture ''%s'' already loaded', [RecName]);
1026 Result := a;
1027 Exit;
1028 end;
1029 end;
1030 end;
1033 // Òåêñòóðû ñî ñïåöèàëüíûìè èìåíàìè (âîäà, ëàâà, êèñëîòà):
1034 if (RecName = TEXTURE_NAME_WATER) or
1035 (RecName = TEXTURE_NAME_ACID1) or
1036 (RecName = TEXTURE_NAME_ACID2) then
1037 begin
1038 SetLength(Textures, Length(Textures)+1);
1040 with Textures[High(Textures)] do
1041 begin
1042 TextureName := RecName;
1043 if (TextureName = TEXTURE_NAME_WATER) then TextureID := LongWord(TEXTURE_SPECIAL_WATER)
1044 else if (TextureName = TEXTURE_NAME_ACID1) then TextureID := LongWord(TEXTURE_SPECIAL_ACID1)
1045 else if (TextureName = TEXTURE_NAME_ACID2) then TextureID := LongWord(TEXTURE_SPECIAL_ACID2);
1047 Anim := False;
1048 end;
1050 result := High(Textures);
1051 TextNameHash.put(RecName, result);
1052 Exit;
1053 end;
1055 // Çàãðóæàåì ðåñóðñ òåêñòóðû â ïàìÿòü èç WAD'à:
1056 WADName := GetReplacementWad(g_ExtractWadName(RecName));
1057 if (WADName <> '') then addResToExternalResList(WADName);
1058 if WADName = '' then WADName := Map; //WADName := GameDir+'/wads/'+WADName else
1060 WAD := TWADFile.Create();
1061 WAD.ReadFile(WADName);
1063 //txname := RecName;
1065 if (WADName = Map) and WAD.GetResource(g_ExtractFilePathName(RecName), TextureData, ResLength) then
1066 begin
1067 FreeMem(TextureData);
1068 RecName := 'COMMON\ALIEN';
1069 end;
1072 if WAD.GetResource(g_ExtractFilePathName(RecName), TextureData, ResLength, log) then
1073 begin
1074 SetLength(Textures, Length(Textures)+1);
1075 if not e_CreateTextureMem(TextureData, ResLength, Textures[High(Textures)].TextureID) then
1076 begin
1077 e_WriteLog(Format('Error loading texture %s', [RecName]), TMsgType.Warning);
1078 SetLength(Textures, Length(Textures)-1);
1079 result := -1;
1080 Exit;
1081 end;
1082 e_GetTextureSize(Textures[High(Textures)].TextureID, @Textures[High(Textures)].Width, @Textures[High(Textures)].Height);
1083 FreeMem(TextureData);
1084 Textures[High(Textures)].TextureName := RecName;
1085 Textures[High(Textures)].Anim := False;
1087 result := High(Textures);
1088 TextNameHash.put(RecName, result);
1089 end
1090 else // Íåò òàêîãî ðåóñðñà â WAD'å
1091 begin
1092 //e_WriteLog(Format('SHIT! Error loading texture %s : %s', [RecName, g_ExtractFilePathName(RecName)]), MSG_WARNING);
1093 if (BadTextNameHash = nil) then BadTextNameHash := THashStrInt.Create();
1094 if log and (not BadTextNameHash.get(RecName, a)) then
1095 begin
1096 e_WriteLog(Format('Error loading texture %s', [RecName]), TMsgType.Warning);
1097 //e_WriteLog(Format('WAD Reader error: %s', [WAD.GetLastErrorStr]), MSG_WARNING);
1098 end;
1099 BadTextNameHash.put(RecName, -1);
1100 end;
1102 WAD.Free();
1103 end;
1106 function CreateAnimTexture(RecName: String; Map: string; log: Boolean): Integer;
1107 var
1108 WAD: TWADFile;
1109 TextureWAD: PChar = nil;
1110 TextData: Pointer = nil;
1111 TextureData: Pointer = nil;
1112 cfg: TConfig = nil;
1113 WADName: String;
1114 ResLength: Integer;
1115 TextureResource: String;
1116 _width, _height, _framecount, _speed: Integer;
1117 _backanimation: Boolean;
1118 //imgfmt: string;
1119 ia: TDynImageDataArray = nil;
1120 f, c, frdelay, frloop: Integer;
1121 begin
1122 RecName := toLowerCase1251(RecName);
1123 if (TextNameHash = nil) then TextNameHash := THashStrInt.Create();
1124 if TextNameHash.get(RecName, result) then
1125 begin
1126 // i found her!
1127 //e_LogWritefln('animated texture ''%s'' already loaded (%s)', [RecName, result]);
1128 exit;
1129 end;
1131 result := -1;
1133 //e_LogWritefln('*** Loading animated texture "%s"', [RecName]);
1135 if (BadTextNameHash = nil) then BadTextNameHash := THashStrInt.Create();
1136 if BadTextNameHash.get(RecName, f) then
1137 begin
1138 //e_WriteLog(Format('no animation texture %s (don''t worry)', [RecName]), MSG_NOTIFY);
1139 exit;
1140 end;
1142 // ×èòàåì WAD-ðåñóðñ àíèì.òåêñòóðû èç WAD'à â ïàìÿòü:
1143 WADName := GetReplacementWad(g_ExtractWadName(RecName));
1144 if (WADName <> '') then addResToExternalResList(WADName);
1145 if WADName = '' then WADName := Map; //WADName := GameDir+'/wads/'+WADName else
1147 WAD := TWADFile.Create();
1148 try
1149 //if WADName <> '' then WADName := GameDir+'/wads/'+WADName else WADName := Map;
1151 WAD.ReadFile(WADName);
1153 if not WAD.GetResource(g_ExtractFilePathName(RecName), TextureWAD, ResLength, log) then
1154 begin
1155 if (BadTextNameHash = nil) then BadTextNameHash := THashStrInt.Create();
1156 if log and (not BadTextNameHash.get(RecName, f)) then
1157 begin
1158 e_WriteLog(Format('Error loading animation texture %s', [RecName]), TMsgType.Warning);
1159 //e_WriteLog(Format('WAD Reader error: %s', [WAD.GetLastErrorStr]), MSG_WARNING);
1160 end;
1161 BadTextNameHash.put(RecName, -1);
1162 exit;
1163 end;
1165 {TEST
1166 if WADName = Map then
1167 begin
1168 //FreeMem(TextureWAD);
1169 if not WAD.GetResource('COMMON/animation', TextureWAD, ResLength) then Halt(1);
1170 end;
1173 WAD.FreeWAD();
1175 if ResLength < 6 then
1176 begin
1177 e_WriteLog(Format('Animated texture file "%s" too short', [RecName]), TMsgType.Warning);
1178 BadTextNameHash.put(RecName, -1);
1179 exit;
1180 end;
1182 // ýòî ïòèöà? ýòî ñàìîë¸ò?
1183 if isWadData(TextureWAD, ResLength) then
1184 begin
1185 // íåò, ýòî ñóïåðìåí!
1186 if not WAD.ReadMemory(TextureWAD, ResLength) then
1187 begin
1188 e_WriteLog(Format('Animated texture WAD file "%s" is invalid', [RecName]), TMsgType.Warning);
1189 BadTextNameHash.put(RecName, -1);
1190 exit;
1191 end;
1193 // ×èòàåì INI-ðåñóðñ àíèì. òåêñòóðû è çàïîìèíàåì åãî óñòàíîâêè:
1194 if not WAD.GetResource('TEXT/ANIM', TextData, ResLength) then
1195 begin
1196 e_WriteLog(Format('Animated texture file "%s" has invalid INI', [RecName]), TMsgType.Warning);
1197 BadTextNameHash.put(RecName, -1);
1198 exit;
1199 end;
1201 cfg := TConfig.CreateMem(TextData, ResLength);
1203 TextureResource := cfg.ReadStr('', 'resource', '');
1204 if TextureResource = '' then
1205 begin
1206 e_WriteLog(Format('Animated texture WAD file "%s" has no "resource"', [RecName]), TMsgType.Warning);
1207 BadTextNameHash.put(RecName, -1);
1208 exit;
1209 end;
1211 _width := cfg.ReadInt('', 'framewidth', 0);
1212 _height := cfg.ReadInt('', 'frameheight', 0);
1213 _framecount := cfg.ReadInt('', 'framecount', 0);
1214 _speed := cfg.ReadInt('', 'waitcount', 0);
1215 _backanimation := cfg.ReadBool('', 'backanimation', False);
1217 cfg.Free();
1218 cfg := nil;
1220 // ×èòàåì ðåñóðñ òåêñòóð (êàäðîâ) àíèì. òåêñòóðû â ïàìÿòü:
1221 if not WAD.GetResource('TEXTURES/'+TextureResource, TextureData, ResLength) then
1222 begin
1223 e_WriteLog(Format('Animated texture WAD file "%s" has no texture "%s"', [RecName, 'TEXTURES/'+TextureResource]), TMsgType.Warning);
1224 BadTextNameHash.put(RecName, -1);
1225 exit;
1226 end;
1228 WAD.Free();
1229 WAD := nil;
1231 SetLength(Textures, Length(Textures)+1);
1232 with Textures[High(Textures)] do
1233 begin
1234 // Ñîçäàåì êàäðû àíèì. òåêñòóðû èç ïàìÿòè:
1235 if g_Frames_CreateMemory(@FramesID, '', TextureData, ResLength, _width, _height, _framecount, _backanimation) then
1236 begin
1237 TextureName := RecName;
1238 Width := _width;
1239 Height := _height;
1240 Anim := True;
1241 FramesCount := _framecount;
1242 Speed := _speed;
1243 result := High(Textures);
1244 TextNameHash.put(RecName, result);
1245 end
1246 else
1247 begin
1248 if (BadTextNameHash = nil) then BadTextNameHash := THashStrInt.Create();
1249 if log and (not BadTextNameHash.get(RecName, f)) then
1250 begin
1251 e_WriteLog(Format('Error loading animation texture %s', [RecName]), TMsgType.Warning);
1252 end;
1253 BadTextNameHash.put(RecName, -1);
1254 end;
1255 end;
1256 end
1257 else
1258 begin
1259 // try animated image
1261 imgfmt := DetermineMemoryFormat(TextureWAD, ResLength);
1262 if length(imgfmt) = 0 then
1263 begin
1264 e_WriteLog(Format('Animated texture file "%s" has unknown format', [RecName]), MSG_WARNING);
1265 exit;
1266 end;
1268 GlobalMetadata.ClearMetaItems();
1269 GlobalMetadata.ClearMetaItemsForSaving();
1270 if not LoadMultiImageFromMemory(TextureWAD, ResLength, ia) then
1271 begin
1272 e_WriteLog(Format('Animated texture file "%s" cannot be loaded', [RecName]), TMsgType.Warning);
1273 BadTextNameHash.put(RecName, -1);
1274 exit;
1275 end;
1276 if length(ia) = 0 then
1277 begin
1278 e_WriteLog(Format('Animated texture file "%s" has no frames', [RecName]), TMsgType.Warning);
1279 BadTextNameHash.put(RecName, -1);
1280 exit;
1281 end;
1283 WAD.Free();
1284 WAD := nil;
1286 _width := ia[0].width;
1287 _height := ia[0].height;
1288 _framecount := length(ia);
1289 _speed := 1;
1290 _backanimation := false;
1291 frdelay := -1;
1292 frloop := -666;
1293 if GlobalMetadata.HasMetaItem(SMetaFrameDelay) then
1294 begin
1295 //writeln(' frame delay: ', GlobalMetadata.MetaItems[SMetaFrameDelay]);
1296 try
1297 f := GlobalMetadata.MetaItems[SMetaFrameDelay];
1298 frdelay := f;
1299 if f < 0 then f := 0;
1300 // rounding ;-)
1301 c := f mod 28;
1302 if c < 13 then c := 0 else c := 1;
1303 f := (f div 28)+c;
1304 if f < 1 then f := 1 else if f > 255 then f := 255;
1305 _speed := f;
1306 except
1307 end;
1308 end;
1309 if GlobalMetadata.HasMetaItem(SMetaAnimationLoops) then
1310 begin
1311 //writeln(' frame loop : ', GlobalMetadata.MetaItems[SMetaAnimationLoops]);
1312 try
1313 f := GlobalMetadata.MetaItems[SMetaAnimationLoops];
1314 frloop := f;
1315 if f <> 0 then _backanimation := true; // non-infinite looping == forth-and-back
1316 except
1317 end;
1318 end;
1319 //writeln(' creating animated texture with ', length(ia), ' frames (delay:', _speed, '; backloop:', _backanimation, ') from "', RecName, '"...');
1320 //for f := 0 to high(ia) do writeln(' frame #', f, ': ', ia[f].width, 'x', ia[f].height);
1321 f := ord(_backanimation);
1322 e_WriteLog(Format('Animated texture file "%s": %d frames (delay:%d; back:%d; frdelay:%d; frloop:%d), %dx%d', [RecName, length(ia), _speed, f, frdelay, frloop, _width, _height]), TMsgType.Notify);
1324 SetLength(Textures, Length(Textures)+1);
1325 // cîçäàåì êàäðû àíèì. òåêñòóðû èç êàðòèíîê
1326 if g_CreateFramesImg(ia, @Textures[High(Textures)].FramesID, '', _backanimation) then
1327 begin
1328 Textures[High(Textures)].TextureName := RecName;
1329 Textures[High(Textures)].Width := _width;
1330 Textures[High(Textures)].Height := _height;
1331 Textures[High(Textures)].Anim := True;
1332 Textures[High(Textures)].FramesCount := length(ia);
1333 Textures[High(Textures)].Speed := _speed;
1334 result := High(Textures);
1335 TextNameHash.put(RecName, result);
1336 //writeln(' CREATED!');
1337 end
1338 else
1339 begin
1340 if (BadTextNameHash = nil) then BadTextNameHash := THashStrInt.Create();
1341 if log and (not BadTextNameHash.get(RecName, f)) then
1342 begin
1343 e_WriteLog(Format('Error loading animation texture "%s" images', [RecName]), TMsgType.Warning);
1344 end;
1345 BadTextNameHash.put(RecName, -1);
1346 end;
1347 end;
1348 finally
1349 for f := 0 to High(ia) do FreeImage(ia[f]);
1350 WAD.Free();
1351 cfg.Free();
1352 if (TextureWAD <> nil) then FreeMem(TextureWAD);
1353 if (TextData <> nil) then FreeMem(TextData);
1354 if (TextureData <> nil) then FreeMem(TextureData);
1355 end;
1356 end;
1358 procedure CreateItem(Item: TDynRecord);
1359 begin
1360 if g_Game_IsClient then Exit;
1362 if (not (gGameSettings.GameMode in [GM_DM, GM_TDM, GM_CTF])) and
1363 ByteBool(Item.Options and ITEM_OPTION_ONLYDM) then
1364 Exit;
1366 g_Items_Create(Item.X, Item.Y, Item.ItemType, ByteBool(Item.Options and ITEM_OPTION_FALL),
1367 gGameSettings.GameMode in [GM_DM, GM_TDM, GM_CTF, GM_COOP]);
1368 end;
1370 procedure CreateArea(Area: TDynRecord);
1371 var
1372 a: Integer;
1373 id: DWORD = 0;
1374 begin
1375 case Area.AreaType of
1376 AREA_DMPOINT, AREA_PLAYERPOINT1, AREA_PLAYERPOINT2,
1377 AREA_REDTEAMPOINT, AREA_BLUETEAMPOINT:
1378 begin
1379 SetLength(RespawnPoints, Length(RespawnPoints)+1);
1380 with RespawnPoints[High(RespawnPoints)] do
1381 begin
1382 X := Area.X;
1383 Y := Area.Y;
1384 Direction := TDirection(Area.Direction);
1386 case Area.AreaType of
1387 AREA_DMPOINT: PointType := RESPAWNPOINT_DM;
1388 AREA_PLAYERPOINT1: PointType := RESPAWNPOINT_PLAYER1;
1389 AREA_PLAYERPOINT2: PointType := RESPAWNPOINT_PLAYER2;
1390 AREA_REDTEAMPOINT: PointType := RESPAWNPOINT_RED;
1391 AREA_BLUETEAMPOINT: PointType := RESPAWNPOINT_BLUE;
1392 end;
1393 end;
1394 end;
1396 AREA_REDFLAG, AREA_BLUEFLAG:
1397 begin
1398 if Area.AreaType = AREA_REDFLAG then a := FLAG_RED else a := FLAG_BLUE;
1400 if FlagPoints[a] <> nil then Exit;
1402 New(FlagPoints[a]);
1404 with FlagPoints[a]^ do
1405 begin
1406 X := Area.X-FLAGRECT.X;
1407 Y := Area.Y-FLAGRECT.Y;
1408 Direction := TDirection(Area.Direction);
1409 end;
1411 with gFlags[a] do
1412 begin
1413 case a of
1414 FLAG_RED: g_Frames_Get(id, 'FRAMES_FLAG_RED');
1415 FLAG_BLUE: g_Frames_Get(id, 'FRAMES_FLAG_BLUE');
1416 end;
1418 Animation := TAnimation.Create(id, True, 8);
1419 Obj.Rect := FLAGRECT;
1421 g_Map_ResetFlag(a);
1422 end;
1423 end;
1425 AREA_DOMFLAG:
1426 begin
1427 {SetLength(DOMFlagPoints, Length(DOMFlagPoints)+1);
1428 with DOMFlagPoints[High(DOMFlagPoints)] do
1429 begin
1430 X := Area.X;
1431 Y := Area.Y;
1432 Direction := TDirection(Area.Direction);
1433 end;
1435 g_Map_CreateFlag(DOMFlagPoints[High(DOMFlagPoints)], FLAG_DOM, FLAG_STATE_NORMAL);}
1436 end;
1437 end;
1438 end;
1440 function CreateTrigger (amapIdx: Integer; Trigger: TDynRecord; atpanid, atrigpanid: Integer): Integer;
1441 var
1442 _trigger: TTrigger;
1443 tp: TPanel;
1444 begin
1445 result := -1;
1446 if g_Game_IsClient and not (Trigger.TriggerType in [TRIGGER_SOUND, TRIGGER_MUSIC]) then Exit;
1448 with _trigger do
1449 begin
1450 mapId := Trigger.id;
1451 mapIndex := amapIdx;
1452 X := Trigger.X;
1453 Y := Trigger.Y;
1454 Width := Trigger.Width;
1455 Height := Trigger.Height;
1456 Enabled := Trigger.Enabled;
1457 TexturePanelGUID := atpanid;
1458 TriggerType := Trigger.TriggerType;
1459 ActivateType := Trigger.ActivateType;
1460 Keys := Trigger.Keys;
1461 trigPanelGUID := atrigpanid;
1462 // HACK: used in TPanel.CanChangeTexture. maybe there's a better way?
1463 if TexturePanelGUID <> -1 then
1464 begin
1465 tp := g_Map_PanelByGUID(TexturePanelGUID);
1466 if (tp <> nil) then tp.hasTexTrigger := True;
1467 end;
1468 end;
1470 result := Integer(g_Triggers_Create(_trigger, Trigger));
1471 end;
1473 procedure CreateMonster(monster: TDynRecord);
1474 var
1475 a: Integer;
1476 mon: TMonster;
1477 begin
1478 if g_Game_IsClient then Exit;
1480 if (gGameSettings.GameType = GT_SINGLE)
1481 or LongBool(gGameSettings.Options and GAME_OPTION_MONSTERS) then
1482 begin
1483 mon := g_Monsters_Create(monster.MonsterType, monster.X, monster.Y, TDirection(monster.Direction));
1485 if gTriggers <> nil then
1486 begin
1487 for a := 0 to High(gTriggers) do
1488 begin
1489 if gTriggers[a].TriggerType in [TRIGGER_PRESS, TRIGGER_ON, TRIGGER_OFF, TRIGGER_ONOFF] then
1490 begin
1491 //if (gTriggers[a].Data.MonsterID-1) = Integer(mon.StartID) then mon.AddTrigger(a);
1492 if (gTriggers[a].trigDataRec.trigMonsterId) = Integer(mon.StartID) then mon.AddTrigger(a);
1493 end;
1494 end;
1495 end;
1497 if monster.MonsterType <> MONSTER_BARREL then Inc(gTotalMonsters);
1498 end;
1499 end;
1501 procedure g_Map_ReAdd_DieTriggers();
1503 function monsDieTrig (mon: TMonster): Boolean;
1504 var
1505 a: Integer;
1506 //tw: TStrTextWriter;
1507 begin
1508 result := false; // don't stop
1509 mon.ClearTriggers();
1510 for a := 0 to High(gTriggers) do
1511 begin
1512 if gTriggers[a].TriggerType in [TRIGGER_PRESS, TRIGGER_ON, TRIGGER_OFF, TRIGGER_ONOFF] then
1513 begin
1514 //if (gTriggers[a].Data.MonsterID-1) = Integer(mon.StartID) then mon.AddTrigger(a);
1516 tw := TStrTextWriter.Create();
1517 try
1518 gTriggers[a].trigData.writeTo(tw);
1519 e_LogWritefln('=== trigger #%s ==='#10'%s'#10'---', [a, tw.str]);
1520 finally
1521 tw.Free();
1522 end;
1524 if (gTriggers[a].trigDataRec.trigMonsterId) = Integer(mon.StartID) then mon.AddTrigger(a);
1525 end;
1526 end;
1527 end;
1529 begin
1530 if g_Game_IsClient then Exit;
1532 g_Mons_ForEach(monsDieTrig);
1533 end;
1535 procedure mapCreateGrid ();
1536 var
1537 mapX0: Integer = $3fffffff;
1538 mapY0: Integer = $3fffffff;
1539 mapX1: Integer = -$3fffffff;
1540 mapY1: Integer = -$3fffffff;
1542 procedure calcBoundingBox (constref panels: TPanelArray);
1543 var
1544 idx: Integer;
1545 pan: TPanel;
1546 begin
1547 for idx := 0 to High(panels) do
1548 begin
1549 pan := panels[idx];
1550 if not pan.visvalid then continue;
1551 if (pan.Width < 1) or (pan.Height < 1) then continue;
1552 if (mapX0 > pan.x0) then mapX0 := pan.x0;
1553 if (mapY0 > pan.y0) then mapY0 := pan.y0;
1554 if (mapX1 < pan.x1) then mapX1 := pan.x1;
1555 if (mapY1 < pan.y1) then mapY1 := pan.y1;
1556 end;
1557 end;
1559 procedure addPanelsToGrid (constref panels: TPanelArray);
1560 var
1561 idx: Integer;
1562 pan: TPanel;
1563 newtag: Integer;
1564 begin
1565 //tag := panelTypeToTag(tag);
1566 for idx := 0 to High(panels) do
1567 begin
1568 pan := panels[idx];
1569 if not pan.visvalid then continue;
1570 if (pan.proxyId <> -1) then
1571 begin
1572 {$IF DEFINED(D2F_DEBUG)}
1573 e_WriteLog(Format('DUPLICATE wall #%d(%d) enabled (%d); type:%08x', [Integer(idx), Integer(pan.proxyId), Integer(mapGrid.proxyEnabled[pan.proxyId]), pan.PanelType]), TMsgType.Notify);
1574 {$ENDIF}
1575 continue;
1576 end;
1577 case pan.PanelType of
1578 PANEL_WALL: newtag := GridTagWall;
1579 PANEL_OPENDOOR, PANEL_CLOSEDOOR: newtag := GridTagDoor;
1580 PANEL_BACK: newtag := GridTagBack;
1581 PANEL_FORE: newtag := GridTagFore;
1582 PANEL_WATER: newtag := GridTagWater;
1583 PANEL_ACID1: newtag := GridTagAcid1;
1584 PANEL_ACID2: newtag := GridTagAcid2;
1585 PANEL_STEP: newtag := GridTagStep;
1586 PANEL_LIFTUP, PANEL_LIFTDOWN, PANEL_LIFTLEFT, PANEL_LIFTRIGHT: newtag := GridTagLift;
1587 PANEL_BLOCKMON: newtag := GridTagBlockMon;
1588 else continue; // oops
1589 end;
1590 pan.tag := newtag;
1592 pan.proxyId := mapGrid.insertBody(pan, pan.X, pan.Y, pan.Width, pan.Height, newtag);
1593 // "enabled" flag has meaning only for doors and walls (engine assumes it); but meh...
1594 mapGrid.proxyEnabled[pan.proxyId] := pan.Enabled;
1595 {$IFDEF MAP_DEBUG_ENABLED_FLAG}
1597 if ((tag and (GridTagWall or GridTagDoor)) <> 0) then
1598 begin
1599 e_WriteLog(Format('INSERTED wall #%d(%d) enabled (%d)', [Integer(idx), Integer(pan.proxyId), Integer(mapGrid.proxyEnabled[pan.proxyId])]), MSG_NOTIFY);
1600 end;
1602 {$ENDIF}
1603 end;
1604 end;
1606 begin
1607 mapGrid.Free();
1608 mapGrid := nil;
1610 calcBoundingBox(gWalls);
1611 calcBoundingBox(gRenderBackgrounds);
1612 calcBoundingBox(gRenderForegrounds);
1613 calcBoundingBox(gWater);
1614 calcBoundingBox(gAcid1);
1615 calcBoundingBox(gAcid2);
1616 calcBoundingBox(gSteps);
1617 calcBoundingBox(gLifts);
1618 calcBoundingBox(gBlockMon);
1620 e_LogWritefln('map dimensions: (%d,%d)-(%d,%d); editor size:(0,0)-(%d,%d)', [mapX0, mapY0, mapX1, mapY1, gMapInfo.Width, gMapInfo.Height]);
1622 if (mapX0 > 0) then mapX0 := 0;
1623 if (mapY0 > 0) then mapY0 := 0;
1625 if (mapX1 < gMapInfo.Width-1) then mapX1 := gMapInfo.Width-1;
1626 if (mapY1 < gMapInfo.Height-1) then mapY1 := gMapInfo.Height-1;
1628 mapGrid := TPanelGrid.Create(mapX0-128, mapY0-128, mapX1-mapX0+1+128*2, mapY1-mapY0+1+128*2);
1629 //mapGrid := TPanelGrid.Create(0, 0, gMapInfo.Width, gMapInfo.Height);
1631 addPanelsToGrid(gWalls);
1632 addPanelsToGrid(gRenderBackgrounds);
1633 addPanelsToGrid(gRenderForegrounds);
1634 addPanelsToGrid(gWater);
1635 addPanelsToGrid(gAcid1);
1636 addPanelsToGrid(gAcid2);
1637 addPanelsToGrid(gSteps);
1638 addPanelsToGrid(gLifts); // it doesn't matter which LIFT type is used here
1639 addPanelsToGrid(gBlockMon);
1641 mapGrid.dumpStats();
1643 g_Mons_InitTree(mapGrid.gridX0, mapGrid.gridY0, mapGrid.gridWidth, mapGrid.gridHeight);
1644 end;
1647 function g_Map_Load(Res: String): Boolean;
1648 const
1649 DefaultMusRes = 'Standart.wad:STDMUS\MUS1';
1650 DefaultSkyRes = 'Standart.wad:STDSKY\SKY0';
1651 type
1652 PTRec = ^TTRec;
1653 TTRec = record
1654 //TexturePanel: Integer;
1655 tnum: Integer;
1656 id: Integer;
1657 trigrec: TDynRecord;
1658 // texture pane;
1659 texPanelIdx: Integer;
1660 texPanel: TDynRecord;
1661 // "action" panel
1662 actPanelIdx: Integer;
1663 actPanel: TDynRecord;
1664 end;
1665 var
1666 WAD, TestWAD: TWADFile;
1667 //mapReader: TDynRecord = nil;
1668 mapTextureList: TDynField = nil; //TTexturesRec1Array; tagInt: texture index
1669 panels: TDynField = nil; //TPanelsRec1Array;
1670 items: TDynField = nil; //TItemsRec1Array;
1671 monsters: TDynField = nil; //TMonsterRec1Array;
1672 areas: TDynField = nil; //TAreasRec1Array;
1673 triggers: TDynField = nil; //TTriggersRec1Array;
1674 b, c, k: Integer;
1675 PanelID: DWORD;
1676 AddTextures: TAddTextureArray;
1677 TriggersTable: array of TTRec;
1678 FileName, mapResName, TexName, s: AnsiString;
1679 Data: Pointer;
1680 Len: Integer;
1681 ok, isAnim: Boolean;
1682 CurTex, ntn: Integer;
1683 rec, texrec: TDynRecord;
1684 pttit: PTRec;
1685 pannum, trignum, cnt, tgpid: Integer;
1686 stt: UInt64;
1687 moveSpeed{, moveStart, moveEnd}: TDFPoint;
1688 //moveActive: Boolean;
1689 pan: TPanel;
1690 mapOk: Boolean = false;
1691 usedTextures: THashStrInt = nil; // key: mapTextureList
1692 begin
1693 mapGrid.Free();
1694 mapGrid := nil;
1695 TestWAD := nil;
1696 Data := nil;
1698 //gCurrentMap.Free();
1699 //gCurrentMap := nil;
1701 panByGUID := nil;
1703 Result := False;
1704 gMapInfo.Map := Res;
1705 TriggersTable := nil;
1706 //mapReader := nil;
1708 sfsGCDisable(); // temporary disable removing of temporary volumes
1709 try
1710 // Çàãðóçêà WAD (åñëè ó íàñ íåò óæå çàãðóæåíîé êàðòû)
1711 if (gCurrentMap = nil) then
1712 begin
1713 FileName := g_ExtractWadName(Res);
1714 e_LogWritefln('Loading map WAD [%s] (res=[%s])', [FileName, Res], TMsgType.Notify);
1715 g_Game_SetLoadingText(_lc[I_LOAD_WAD_FILE], 0, False);
1717 WAD := TWADFile.Create();
1718 if not WAD.ReadFile(FileName) then
1719 begin
1720 g_FatalError(Format(_lc[I_GAME_ERROR_MAP_WAD], [FileName]));
1721 WAD.Free();
1722 Exit;
1723 end;
1725 if gTestMap <> '' then
1726 begin
1727 s := g_ExtractWadName(gTestMap);
1728 TestWAD := TWADFile.Create();
1729 if not TestWAD.ReadFile(s) then
1730 begin
1731 g_SimpleError(Format(_lc[I_GAME_ERROR_MAP_WAD], [s]));
1732 TestWAD.Free();
1733 TestWAD := nil;
1734 end;
1735 end;
1737 if TestWAD <> nil then
1738 begin
1739 mapResName := g_ExtractFileName(gTestMap);
1740 if not TestWAD.GetMapResource(mapResName, Data, Len) then
1741 begin
1742 g_SimpleError(Format(_lc[I_GAME_ERROR_MAP_RES], [mapResName]));
1743 Data := nil;
1744 end else
1745 e_WriteLog('Using test map: '+gTestMap, TMsgType.Notify);
1746 TestWAD.Free();
1747 TestWAD := nil;
1748 end;
1750 if Data = nil then
1751 begin
1752 //k8: why loader ignores path here?
1753 mapResName := g_ExtractFileName(Res);
1754 if not WAD.GetMapResource(mapResName, Data, Len) then
1755 begin
1756 g_FatalError(Format(_lc[I_GAME_ERROR_MAP_RES], [mapResName]));
1757 WAD.Free();
1758 Exit;
1759 end;
1760 end;
1762 WAD.Free();
1764 if (Len < 4) then
1765 begin
1766 e_LogWritefln('invalid map file: ''%s''', [mapResName]);
1767 FreeMem(Data);
1768 exit;
1769 end;
1771 // Çàãðóçêà êàðòû:
1772 e_LogWritefln('Loading map: %s', [mapResName], TMsgType.Notify);
1773 g_Game_SetLoadingText(_lc[I_LOAD_MAP], 0, False);
1775 stt := getTimeMicro();
1777 try
1778 gCurrentMap := g_Map_ParseMap(Data, Len);
1779 except
1780 gCurrentMap.Free();
1781 g_FatalError(Format(_lc[I_GAME_ERROR_MAP_LOAD], [Res]));
1782 FreeMem(Data);
1783 gCurrentMapFileName := '';
1784 Exit;
1785 end;
1787 FreeMem(Data);
1789 if (gCurrentMap = nil) then
1790 begin
1791 e_LogWritefln('invalid map file: ''%s''', [mapResName]);
1792 gCurrentMapFileName := '';
1793 exit;
1794 end;
1795 end
1796 else
1797 begin
1798 stt := getTimeMicro();
1799 end;
1801 //gCurrentMap := mapReader;
1803 generateExternalResourcesList(gCurrentMap);
1804 mapTextureList := gCurrentMap['texture'];
1805 // get all other lists here too
1806 panels := gCurrentMap['panel'];
1807 triggers := gCurrentMap['trigger'];
1808 items := gCurrentMap['item'];
1809 areas := gCurrentMap['area'];
1810 monsters := gCurrentMap['monster'];
1812 // Çàãðóçêà îïèñàíèÿ êàðòû:
1813 e_WriteLog(' Reading map info...', TMsgType.Notify);
1814 g_Game_SetLoadingText(_lc[I_LOAD_MAP_HEADER], 0, False);
1816 with gMapInfo do
1817 begin
1818 Name := gCurrentMap.MapName;
1819 Description := gCurrentMap.MapDesc;
1820 Author := gCurrentMap.MapAuthor;
1821 MusicName := gCurrentMap.MusicName;
1822 SkyName := gCurrentMap.SkyName;
1823 Height := gCurrentMap.Height;
1824 Width := gCurrentMap.Width;
1825 end;
1827 // Çàãðóçêà òåêñòóð:
1828 g_Game_SetLoadingText(_lc[I_LOAD_TEXTURES], 0, False);
1829 // Äîáàâëåíèå òåêñòóð â Textures[]:
1830 if (mapTextureList <> nil) and (mapTextureList.count > 0) then
1831 begin
1832 e_WriteLog(' Loading textures:', TMsgType.Notify);
1833 g_Game_SetLoadingText(_lc[I_LOAD_TEXTURES], mapTextureList.count-1, False);
1835 // find used textures
1836 usedTextures := THashStrInt.Create();
1837 try
1838 if (panels <> nil) and (panels.count > 0) then
1839 begin
1840 for rec in panels do
1841 begin
1842 texrec := rec.TextureRec;
1843 if (texrec <> nil) then usedTextures.put(toLowerCase1251(texrec.Resource), 42);
1844 end;
1845 end;
1847 cnt := -1;
1848 for rec in mapTextureList do
1849 begin
1850 Inc(cnt);
1851 if not usedTextures.has(toLowerCase1251(rec.Resource)) then
1852 begin
1853 rec.tagInt := -1; // just in case
1854 e_LogWritefln(' Unused texture #%d: %s', [cnt, rec.Resource]);
1855 end
1856 else
1857 begin
1858 {$IF DEFINED(D2F_DEBUG_TXLOAD)}
1859 e_LogWritefln(' Loading texture #%d: %s', [cnt, rec.Resource]);
1860 {$ENDIF}
1861 //if g_Map_IsSpecialTexture(s) then e_WriteLog(' SPECIAL!', MSG_NOTIFY);
1862 if rec.Anim then
1863 begin
1864 // Àíèìèðîâàííàÿ òåêñòóðà
1865 ntn := CreateAnimTexture(rec.Resource, FileName, True);
1866 if (ntn < 0) then g_SimpleError(Format(_lc[I_GAME_ERROR_TEXTURE_ANIM], [rec.Resource]));
1867 end
1868 else
1869 begin
1870 // Îáû÷íàÿ òåêñòóðà
1871 ntn := CreateTexture(rec.Resource, FileName, True);
1872 if (ntn < 0) then g_SimpleError(Format(_lc[I_GAME_ERROR_TEXTURE_SIMPLE], [rec.Resource]));
1873 end;
1874 if (ntn < 0) then ntn := CreateNullTexture(rec.Resource);
1876 rec.tagInt := ntn; // remember texture number
1877 end;
1878 g_Game_StepLoading();
1879 end;
1880 finally
1881 usedTextures.Free();
1882 end;
1884 // set panel tagInt to texture index
1885 if (panels <> nil) then
1886 begin
1887 for rec in panels do
1888 begin
1889 texrec := rec.TextureRec;
1890 if (texrec = nil) then rec.tagInt := -1 else rec.tagInt := texrec.tagInt;
1891 end;
1892 end;
1893 end;
1896 // Çàãðóçêà òðèããåðîâ
1897 gTriggerClientID := 0;
1898 e_WriteLog(' Loading triggers...', TMsgType.Notify);
1899 g_Game_SetLoadingText(_lc[I_LOAD_TRIGGERS], 0, False);
1901 // Çàãðóçêà ïàíåëåé
1902 e_WriteLog(' Loading panels...', TMsgType.Notify);
1903 g_Game_SetLoadingText(_lc[I_LOAD_PANELS], 0, False);
1905 // check texture numbers for panels
1906 if (panels <> nil) and (panels.count > 0) then
1907 begin
1908 for rec in panels do
1909 begin
1910 if (rec.tagInt < 0) then
1911 begin
1912 e_WriteLog('error loading map: invalid texture index for panel', TMsgType.Fatal);
1913 result := false;
1914 gCurrentMap.Free();
1915 gCurrentMap := nil;
1916 gCurrentMapFileName := '';
1917 exit;
1918 end;
1919 end;
1920 end;
1922 // Ñîçäàíèå òàáëèöû òðèããåðîâ (ñîîòâåòñòâèå ïàíåëåé òðèããåðàì)
1923 if (triggers <> nil) and (triggers.count > 0) then
1924 begin
1925 e_WriteLog(' Setting up trigger table...', TMsgType.Notify);
1926 //SetLength(TriggersTable, triggers.count);
1927 g_Game_SetLoadingText(_lc[I_LOAD_TRIGGERS_TABLE], triggers.count-1, False);
1929 SetLength(TriggersTable, triggers.count);
1930 trignum := -1;
1931 for rec in triggers do
1932 begin
1933 Inc(trignum);
1934 pttit := @TriggersTable[trignum];
1935 pttit.trigrec := rec;
1936 // Ñìåíà òåêñòóðû (âîçìîæíî, êíîïêè)
1937 pttit.texPanelIdx := -1; // will be fixed later
1938 pttit.texPanel := rec.TexturePanelRec;
1939 // action panel
1940 pttit.actPanelIdx := -1;
1941 if (rec.trigRec <> nil) then pttit.actPanel := rec.trigRec.tgPanelRec else pttit.actPanel := nil;
1942 // set flag
1943 if (pttit.texPanel <> nil) then pttit.texPanel.userPanelTrigRef := true;
1944 if (pttit.actPanel <> nil) then pttit.actPanel.userPanelTrigRef := true;
1945 // update progress
1946 g_Game_StepLoading();
1947 end;
1948 end;
1950 // Ñîçäàåì ïàíåëè
1951 if (panels <> nil) and (panels.count > 0) then
1952 begin
1953 e_WriteLog(' Setting up trigger links...', TMsgType.Notify);
1954 g_Game_SetLoadingText(_lc[I_LOAD_LINK_TRIGGERS], panels.count-1, False);
1956 pannum := -1;
1957 for rec in panels do
1958 begin
1959 Inc(pannum);
1960 //e_LogWritefln('PANSTART: pannum=%s', [pannum]);
1961 texrec := nil;
1962 SetLength(AddTextures, 0);
1963 CurTex := -1;
1964 ok := false;
1966 if (mapTextureList <> nil) then
1967 begin
1968 texrec := rec.TextureRec;
1969 ok := (texrec <> nil);
1970 end;
1972 if ok then
1973 begin
1974 // Ñìîòðèì, ññûëàþòñÿ ëè íà ýòó ïàíåëü òðèããåðû.
1975 // Åñëè äà - òî íàäî ñîçäàòü åùå òåêñòóð
1976 ok := false;
1977 if (TriggersTable <> nil) and (mapTextureList <> nil) then
1978 begin
1979 if rec.userPanelTrigRef then
1980 begin
1981 // e_LogWritefln('trigref for panel %s', [pannum]);
1982 ok := True;
1983 end;
1984 end;
1985 end;
1987 if ok then
1988 begin
1989 // Åñòü ññûëêè òðèããåðîâ íà ýòó ïàíåëü
1990 s := texrec.Resource;
1992 // Ñïåö-òåêñòóðû çàïðåùåíû
1993 if g_Map_IsSpecialTexture(s) then
1994 begin
1995 ok := false
1996 end
1997 else
1998 begin
1999 // Îïðåäåëÿåì íàëè÷èå è ïîëîæåíèå öèôð â êîíöå ñòðîêè
2000 ok := g_Texture_NumNameFindStart(s);
2001 end;
2003 // Åñëè ok, çíà÷èò åñòü öèôðû â êîíöå.
2004 // Çàãðóæàåì òåêñòóðû ñ îñòàëüíûìè #
2005 if ok then
2006 begin
2007 k := NNF_NAME_BEFORE;
2008 // Öèêë ïî èçìåíåíèþ èìåíè òåêñòóðû
2009 while ok or (k = NNF_NAME_BEFORE) or (k = NNF_NAME_EQUALS) do
2010 begin
2011 k := g_Texture_NumNameFindNext(TexName);
2013 if (k = NNF_NAME_BEFORE) or (k = NNF_NAME_AFTER) then
2014 begin
2015 // Ïðîáóåì äîáàâèòü íîâóþ òåêñòóðó
2016 if texrec.Anim then
2017 begin
2018 // Íà÷àëüíàÿ - àíèìèðîâàííàÿ, èùåì àíèìèðîâàííóþ
2019 isAnim := True;
2020 //e_LogWritefln('000: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
2021 ok := CreateAnimTexture(TexName, FileName, False) >= 0;
2022 //e_LogWritefln('001: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
2023 if not ok then
2024 begin
2025 // Íåò àíèìèðîâàííîé, èùåì îáû÷íóþ
2026 isAnim := False;
2027 //e_LogWritefln('002: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
2028 ok := CreateTexture(TexName, FileName, False) >= 0;
2029 //e_LogWritefln('003: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
2030 end;
2031 end
2032 else
2033 begin
2034 // Íà÷àëüíàÿ - îáû÷íàÿ, èùåì îáû÷íóþ
2035 isAnim := False;
2036 //e_LogWritefln('004: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
2037 ok := CreateTexture(TexName, FileName, False) >= 0;
2038 //e_LogWritefln('005: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
2039 if not ok then
2040 begin
2041 // Íåò îáû÷íîé, èùåì àíèìèðîâàííóþ
2042 isAnim := True;
2043 //e_LogWritefln('006: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
2044 ok := CreateAnimTexture(TexName, FileName, False) >= 0;
2045 //e_LogWritefln('007: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
2046 end;
2047 end;
2049 // Îíà ñóùåñòâóåò. Çàíîñèì åå ID â ñïèñîê ïàíåëè
2050 if ok then
2051 begin
2053 for c := 0 to High(Textures) do
2054 begin
2055 if (Textures[c].TextureName = TexName) then
2056 begin
2057 SetLength(AddTextures, Length(AddTextures)+1);
2058 AddTextures[High(AddTextures)].Texture := c;
2059 AddTextures[High(AddTextures)].Anim := isAnim;
2060 break;
2061 end;
2062 end;
2064 if (TextNameHash <> nil) and TextNameHash.get(toLowerCase1251(TexName), c) then
2065 begin
2066 SetLength(AddTextures, Length(AddTextures)+1);
2067 AddTextures[High(AddTextures)].Texture := c;
2068 AddTextures[High(AddTextures)].Anim := isAnim;
2069 end;
2070 end;
2071 end
2072 else
2073 begin
2074 if k = NNF_NAME_EQUALS then
2075 begin
2076 // Çàíîñèì òåêóùóþ òåêñòóðó íà ñâîå ìåñòî
2077 SetLength(AddTextures, Length(AddTextures)+1);
2078 AddTextures[High(AddTextures)].Texture := rec.tagInt; // internal texture number, not map index
2079 AddTextures[High(AddTextures)].Anim := texrec.Anim;
2080 CurTex := High(AddTextures);
2081 ok := true;
2082 end
2083 else // NNF_NO_NAME
2084 begin
2085 ok := false;
2086 end;
2087 end;
2088 end; // while ok...
2090 ok := true;
2091 end; // if ok - åñòü ñìåæíûå òåêñòóðû
2092 end; // if ok - ññûëàþòñÿ òðèããåðû
2094 if not ok then
2095 begin
2096 // Çàíîñèì òîëüêî òåêóùóþ òåêñòóðó
2097 SetLength(AddTextures, 1);
2098 AddTextures[0].Texture := rec.tagInt; // internal texture number, not map index
2099 AddTextures[0].Anim := false;
2100 if (texrec <> nil) then AddTextures[0].Anim := texrec.Anim;
2101 CurTex := 0;
2102 end;
2104 //e_WriteLog(Format('panel #%d: TextureNum=%d; ht=%d; ht1=%d; atl=%d', [a, panels[a].TextureNum, High(mapTextureList), High(Textures), High(AddTextures)]), MSG_NOTIFY);
2106 //e_LogWritefln('PANADD: pannum=%s', [pannum]);
2108 // Ñîçäàåì ïàíåëü è çàïîìèíàåì åå GUID
2109 //e_LogWritefln('new panel; tcount=%s; curtex=%s', [Length(AddTextures), CurTex]);
2110 PanelID := CreatePanel(rec, AddTextures, CurTex);
2111 //e_LogWritefln('panel #%s of type %s got guid #%s', [pannum, rec.PanelType, PanelID]);
2112 rec.userPanelId := PanelID; // remember game panel id, we'll fix triggers later
2114 // setup lifts
2115 moveSpeed := rec.moveSpeed;
2116 //moveStart := rec.moveStart;
2117 //moveEnd := rec.moveEnd;
2118 //moveActive := rec['move_active'].value;
2119 if not moveSpeed.isZero then
2120 begin
2121 SetLength(gMovingWallIds, Length(gMovingWallIds)+1);
2122 gMovingWallIds[High(gMovingWallIds)] := PanelID;
2123 //e_LogWritefln('found moving panel ''%s'' (idx=%s; id=%s)', [rec.id, pannum, PanelID]);
2124 end;
2126 //e_LogWritefln('PANEND: pannum=%s', [pannum]);
2128 g_Game_StepLoading();
2129 end;
2130 end;
2132 // ×èíèì ID'û ïàíåëåé, êîòîðûå èñïîëüçóþòñÿ â òðèããåðàõ
2133 for b := 0 to High(TriggersTable) do
2134 begin
2135 if (TriggersTable[b].texPanel <> nil) then TriggersTable[b].texPanelIdx := TriggersTable[b].texPanel.userPanelId;
2136 if (TriggersTable[b].actPanel <> nil) then TriggersTable[b].actPanelIdx := TriggersTable[b].actPanel.userPanelId;
2137 end;
2139 // create map grid, init other grids (for monsters, for example)
2140 e_WriteLog('Creating map grid', TMsgType.Notify);
2141 mapCreateGrid();
2143 // Åñëè íå LoadState, òî ñîçäàåì òðèããåðû
2144 if (triggers <> nil) and (panels <> nil) and (not gLoadGameMode) then
2145 begin
2146 e_LogWritefln(' Creating triggers (%d)...', [triggers.count]);
2147 g_Game_SetLoadingText(_lc[I_LOAD_CREATE_TRIGGERS], 0, False);
2148 // Óêàçûâàåì òèï ïàíåëè, åñëè åñòü
2149 trignum := -1;
2150 for rec in triggers do
2151 begin
2152 Inc(trignum);
2153 tgpid := TriggersTable[trignum].actPanelIdx;
2154 //e_LogWritefln('creating trigger #%s; texpantype=%s; shotpantype=%s (%d,%d)', [trignum, b, c, TriggersTable[trignum].texPanIdx, TriggersTable[trignum].ShotPanelIdx]);
2155 TriggersTable[trignum].tnum := trignum;
2156 TriggersTable[trignum].id := CreateTrigger(trignum, rec, TriggersTable[trignum].texPanelIdx, tgpid);
2157 end;
2158 end;
2160 //FIXME: use hashtable!
2161 for pan in panByGUID do
2162 begin
2163 if (pan.endPosTrigId >= 0) and (pan.endPosTrigId < Length(TriggersTable)) then
2164 begin
2165 pan.endPosTrigId := TriggersTable[pan.endPosTrigId].id;
2166 end;
2167 if (pan.endSizeTrigId >= 0) and (pan.endSizeTrigId < Length(TriggersTable)) then
2168 begin
2169 pan.endSizeTrigId := TriggersTable[pan.endSizeTrigId].id;
2170 end;
2171 end;
2173 // Çàãðóçêà ïðåäìåòîâ
2174 e_WriteLog(' Loading items...', TMsgType.Notify);
2175 g_Game_SetLoadingText(_lc[I_LOAD_ITEMS], 0, False);
2177 // Åñëè íå LoadState, òî ñîçäàåì ïðåäìåòû
2178 if (items <> nil) and not gLoadGameMode then
2179 begin
2180 e_WriteLog(' Spawning items...', TMsgType.Notify);
2181 g_Game_SetLoadingText(_lc[I_LOAD_CREATE_ITEMS], 0, False);
2182 for rec in items do CreateItem(rec);
2183 end;
2185 // Çàãðóçêà îáëàñòåé
2186 e_WriteLog(' Loading areas...', TMsgType.Notify);
2187 g_Game_SetLoadingText(_lc[I_LOAD_AREAS], 0, False);
2189 // Åñëè íå LoadState, òî ñîçäàåì îáëàñòè
2190 if areas <> nil then
2191 begin
2192 e_WriteLog(' Creating areas...', TMsgType.Notify);
2193 g_Game_SetLoadingText(_lc[I_LOAD_CREATE_AREAS], 0, False);
2194 for rec in areas do CreateArea(rec);
2195 end;
2197 // Çàãðóçêà ìîíñòðîâ
2198 e_WriteLog(' Loading monsters...', TMsgType.Notify);
2199 g_Game_SetLoadingText(_lc[I_LOAD_MONSTERS], 0, False);
2201 gTotalMonsters := 0;
2203 // Åñëè íå LoadState, òî ñîçäàåì ìîíñòðîâ
2204 if (monsters <> nil) and not gLoadGameMode then
2205 begin
2206 e_WriteLog(' Spawning monsters...', TMsgType.Notify);
2207 g_Game_SetLoadingText(_lc[I_LOAD_CREATE_MONSTERS], 0, False);
2208 for rec in monsters do CreateMonster(rec);
2209 end;
2211 //gCurrentMap := mapReader; // this will be our current map now
2212 gCurrentMapFileName := Res;
2213 //mapReader := nil;
2215 // Çàãðóçêà íåáà
2216 if (gMapInfo.SkyName <> '') then
2217 begin
2218 e_WriteLog(' Loading sky: ' + gMapInfo.SkyName, TMsgType.Notify);
2219 g_Game_SetLoadingText(_lc[I_LOAD_SKY], 0, False);
2220 if gTextureFilter then TEXTUREFILTER := GL_LINEAR else TEXTUREFILTER := GL_NEAREST;
2221 try
2222 s := e_GetResourcePath(WadDirs, gMapInfo.SkyName, g_ExtractWadName(Res));
2223 if g_Texture_CreateWAD(BackID, s) then
2224 g_Game_SetupScreenSize
2225 else
2226 g_FatalError(Format(_lc[I_GAME_ERROR_SKY], [s]))
2227 finally
2228 TEXTUREFILTER := GL_NEAREST;
2229 end;
2230 end;
2232 // Çàãðóçêà ìóçûêè
2233 ok := False;
2234 if gMapInfo.MusicName <> '' then
2235 begin
2236 e_WriteLog(' Loading music: ' + gMapInfo.MusicName, TMsgType.Notify);
2237 g_Game_SetLoadingText(_lc[I_LOAD_MUSIC], 0, False);
2239 s := e_GetResourcePath(WadDirs, gMapInfo.MusicName, g_ExtractWadName(Res));
2240 if g_Sound_CreateWADEx(gMapInfo.MusicName, s, True) then
2241 ok := True
2242 else
2243 g_FatalError(Format(_lc[I_GAME_ERROR_MUSIC], [s]));
2244 end;
2246 // Îñòàëüíûå óñòàíâêè
2247 CreateDoorMap();
2248 CreateLiftMap();
2250 g_Items_Init();
2251 g_Weapon_Init();
2252 g_Monsters_Init();
2254 // Åñëè íå LoadState, òî ñîçäàåì êàðòó ñòîëêíîâåíèé:
2255 if not gLoadGameMode then g_GFX_Init();
2257 // Ñáðîñ ëîêàëüíûõ ìàññèâîâ:
2258 mapTextureList := nil;
2259 panels := nil;
2260 items := nil;
2261 areas := nil;
2262 triggers := nil;
2263 TriggersTable := nil;
2264 AddTextures := nil;
2266 // Âêëþ÷àåì ìóçûêó, åñëè ýòî íå çàãðóçêà:
2267 if ok and (not gLoadGameMode) then
2268 begin
2269 gMusic.SetByName(gMapInfo.MusicName);
2270 gMusic.Play();
2271 end
2272 else
2273 begin
2274 gMusic.SetByName('');
2275 end;
2277 stt := getTimeMicro()-stt;
2278 e_LogWritefln('map loaded in %s.%s milliseconds', [Integer(stt div 1000), Integer(stt mod 1000)]);
2279 mapOk := true;
2280 finally
2281 sfsGCEnable(); // enable releasing unused volumes
2282 //mapReader.Free();
2283 e_UnpressAllKeys; // why not?
2284 if not mapOk then
2285 begin
2286 gCurrentMap.Free();
2287 gCurrentMap := nil;
2288 gCurrentMapFileName := '';
2289 end;
2290 end;
2292 compactExtResList();
2293 e_WriteLog('Done loading map.', TMsgType.Notify);
2294 Result := True;
2295 end;
2298 function g_Map_GetMapInfo(Res: String): TMapInfo;
2299 var
2300 WAD: TWADFile;
2301 mapReader: TDynRecord;
2302 //Header: TMapHeaderRec_1;
2303 FileName: String;
2304 Data: Pointer;
2305 Len: Integer;
2306 begin
2307 FillChar(Result, SizeOf(Result), 0);
2308 FileName := g_ExtractWadName(Res);
2310 WAD := TWADFile.Create();
2311 if not WAD.ReadFile(FileName) then
2312 begin
2313 WAD.Free();
2314 Exit;
2315 end;
2317 //k8: it ignores path again
2318 if not WAD.GetMapResource(g_ExtractFileName(Res), Data, Len) then
2319 begin
2320 WAD.Free();
2321 Exit;
2322 end;
2324 WAD.Free();
2326 try
2327 mapReader := g_Map_ParseMap(Data, Len);
2328 except
2329 mapReader := nil;
2330 FreeMem(Data);
2331 exit;
2332 end;
2334 FreeMem(Data);
2336 if (mapReader = nil) then exit;
2338 if (mapReader.Width > 0) and (mapReader.Height > 0) then
2339 begin
2340 Result.Name := mapReader.MapName;
2341 Result.Description := mapReader.MapDesc;
2342 Result.Map := Res;
2343 Result.Author := mapReader.MapAuthor;
2344 Result.Height := mapReader.Height;
2345 Result.Width := mapReader.Width;
2346 end
2347 else
2348 begin
2349 g_Console_Add(Format(_lc[I_GAME_ERROR_MAP_LOAD], [Res]), True);
2350 //ZeroMemory(@Header, SizeOf(Header));
2351 Result.Name := _lc[I_GAME_ERROR_MAP_SELECT];
2352 Result.Description := _lc[I_GAME_ERROR_MAP_SELECT];
2353 Result.Map := Res;
2354 Result.Author := '';
2355 Result.Height := 0;
2356 Result.Width := 0;
2357 end;
2359 mapReader.Free();
2360 end;
2362 function g_Map_GetMapsList(WADName: string): SSArray;
2363 var
2364 WAD: TWADFile;
2365 a: Integer;
2366 ResList: SSArray;
2367 begin
2368 Result := nil;
2369 WAD := TWADFile.Create();
2370 if not WAD.ReadFile(WADName) then
2371 begin
2372 WAD.Free();
2373 Exit;
2374 end;
2375 ResList := WAD.GetMapResources();
2376 if ResList <> nil then
2377 begin
2378 for a := 0 to High(ResList) do
2379 begin
2380 SetLength(Result, Length(Result)+1);
2381 Result[High(Result)] := ResList[a];
2382 end;
2383 end;
2384 WAD.Free();
2385 end;
2387 function g_Map_Exist(Res: string): Boolean;
2388 var
2389 WAD: TWADFile;
2390 FileName, mnn: string;
2391 ResList: SSArray;
2392 a: Integer;
2393 begin
2394 Result := False;
2396 FileName := addWadExtension(g_ExtractWadName(Res));
2398 WAD := TWADFile.Create;
2399 if not WAD.ReadFile(FileName) then
2400 begin
2401 WAD.Free();
2402 Exit;
2403 end;
2405 ResList := WAD.GetMapResources();
2406 WAD.Free();
2408 mnn := g_ExtractFileName(Res);
2409 if ResList <> nil then
2410 for a := 0 to High(ResList) do if StrEquCI1251(ResList[a], mnn) then
2411 begin
2412 Result := True;
2413 Exit;
2414 end;
2415 end;
2417 procedure g_Map_Free(freeTextures: Boolean=true);
2418 var
2419 a: Integer;
2421 procedure FreePanelArray(var panels: TPanelArray);
2422 var
2423 i: Integer;
2425 begin
2426 if panels <> nil then
2427 begin
2428 for i := 0 to High(panels) do
2429 panels[i].Free();
2430 panels := nil;
2431 end;
2432 end;
2434 begin
2435 g_GFX_Free();
2436 g_Weapon_Free();
2437 g_Items_Free();
2438 g_Triggers_Free();
2439 g_Monsters_Free();
2441 RespawnPoints := nil;
2442 if FlagPoints[FLAG_RED] <> nil then
2443 begin
2444 Dispose(FlagPoints[FLAG_RED]);
2445 FlagPoints[FLAG_RED] := nil;
2446 end;
2447 if FlagPoints[FLAG_BLUE] <> nil then
2448 begin
2449 Dispose(FlagPoints[FLAG_BLUE]);
2450 FlagPoints[FLAG_BLUE] := nil;
2451 end;
2452 //DOMFlagPoints := nil;
2454 //gDOMFlags := nil;
2456 if (Length(gCurrentMapFileName) <> 0) then
2457 begin
2458 e_LogWritefln('g_Map_Free: previous map was ''%s''...', [gCurrentMapFileName]);
2459 end
2460 else
2461 begin
2462 e_LogWritefln('g_Map_Free: no previous map.', []);
2463 end;
2465 if freeTextures then
2466 begin
2467 e_LogWritefln('g_Map_Free: clearing textures...', []);
2468 if (Textures <> nil) then
2469 begin
2470 for a := 0 to High(Textures) do
2471 begin
2472 if not g_Map_IsSpecialTexture(Textures[a].TextureName) then
2473 begin
2474 if Textures[a].Anim then
2475 begin
2476 g_Frames_DeleteByID(Textures[a].FramesID)
2477 end
2478 else
2479 begin
2480 if (Textures[a].TextureID <> LongWord(TEXTURE_NONE)) then
2481 begin
2482 e_DeleteTexture(Textures[a].TextureID);
2483 end;
2484 end;
2485 end;
2486 end;
2487 Textures := nil;
2488 end;
2489 TextNameHash.Free();
2490 TextNameHash := nil;
2491 BadTextNameHash.Free();
2492 BadTextNameHash := nil;
2493 gCurrentMapFileName := '';
2494 gCurrentMap.Free();
2495 gCurrentMap := nil;
2496 end;
2498 panByGUID := nil;
2500 FreePanelArray(gWalls);
2501 FreePanelArray(gRenderBackgrounds);
2502 FreePanelArray(gRenderForegrounds);
2503 FreePanelArray(gWater);
2504 FreePanelArray(gAcid1);
2505 FreePanelArray(gAcid2);
2506 FreePanelArray(gSteps);
2507 FreePanelArray(gLifts);
2508 FreePanelArray(gBlockMon);
2509 gMovingWallIds := nil;
2511 if BackID <> DWORD(-1) then
2512 begin
2513 gBackSize.X := 0;
2514 gBackSize.Y := 0;
2515 e_DeleteTexture(BackID);
2516 BackID := DWORD(-1);
2517 end;
2519 g_Game_StopAllSounds(False);
2520 gMusic.FreeSound();
2521 g_Sound_Delete(gMapInfo.MusicName);
2523 gMapInfo.Name := '';
2524 gMapInfo.Description := '';
2525 gMapInfo.MusicName := '';
2526 gMapInfo.Height := 0;
2527 gMapInfo.Width := 0;
2529 gDoorMap := nil;
2530 gLiftMap := nil;
2531 end;
2533 procedure g_Map_Update();
2534 var
2535 a, d, j: Integer;
2536 m: Word;
2537 s: String;
2538 b: Byte;
2540 procedure UpdatePanelArray(var panels: TPanelArray);
2541 var
2542 i: Integer;
2544 begin
2545 for i := 0 to High(panels) do panels[i].Update();
2546 end;
2548 begin
2549 if g_dbgpan_mplat_step then g_dbgpan_mplat_active := true;
2551 UpdatePanelArray(gWalls);
2552 UpdatePanelArray(gRenderBackgrounds);
2553 UpdatePanelArray(gRenderForegrounds);
2554 UpdatePanelArray(gWater);
2555 UpdatePanelArray(gAcid1);
2556 UpdatePanelArray(gAcid2);
2557 UpdatePanelArray(gSteps);
2559 if g_dbgpan_mplat_step then begin g_dbgpan_mplat_step := false; g_dbgpan_mplat_active := false; end;
2561 if gGameSettings.GameMode = GM_CTF then
2562 begin
2563 for a := FLAG_RED to FLAG_BLUE do
2564 begin
2565 if not (gFlags[a].State in [FLAG_STATE_NONE, FLAG_STATE_CAPTURED]) then
2566 begin
2567 with gFlags[a] do
2568 begin
2569 if gFlags[a].Animation <> nil then gFlags[a].Animation.Update();
2571 Obj.oldX := Obj.X;
2572 Obj.oldY := Obj.Y;
2574 m := g_Obj_Move(@Obj, True, True);
2576 NeedSend := NeedSend or (Obj.X <> Obj.oldX) or (Obj.Y <> Obj.oldY);
2578 if gTime mod (GAME_TICK*2) <> 0 then Continue;
2580 // Ñîïðîòèâëåíèå âîçäóõà
2581 Obj.Vel.X := z_dec(Obj.Vel.X, 1);
2583 // Òàéìàóò ïîòåðÿííîãî ôëàãà, ëèáî îí âûïàë çà êàðòó
2584 if ((Count = 0) or ByteBool(m and MOVE_FALLOUT)) and g_Game_IsServer then
2585 begin
2586 g_Map_ResetFlag(a);
2587 gFlags[a].CaptureTime := 0;
2588 if a = FLAG_RED then
2589 s := _lc[I_PLAYER_FLAG_RED]
2590 else
2591 s := _lc[I_PLAYER_FLAG_BLUE];
2592 g_Game_Message(Format(_lc[I_MESSAGE_FLAG_RETURN], [AnsiUpperCase(s)]), 144);
2594 if (((gPlayer1 <> nil) and (((gPlayer1.Team = TEAM_RED) and (a = FLAG_RED)) or ((gPlayer1.Team = TEAM_BLUE) and (a = FLAG_BLUE))))
2595 or ((gPlayer2 <> nil) and (((gPlayer2.Team = TEAM_RED) and (a = FLAG_RED)) or ((gPlayer2.Team = TEAM_BLUE) and (a = FLAG_BLUE))))) then
2596 b := 0
2597 else
2598 b := 1;
2600 if not sound_ret_flag[b].IsPlaying() then
2601 sound_ret_flag[b].Play();
2603 if g_Game_IsNet then
2604 MH_SEND_FlagEvent(FLAG_STATE_RETURNED, a, 0);
2605 Continue;
2606 end;
2608 if Count > 0 then Count -= 1;
2610 // Èãðîê áåðåò ôëàã
2611 if gPlayers <> nil then
2612 begin
2613 j := Random(Length(gPlayers)) - 1;
2614 for d := 0 to High(gPlayers) do
2615 begin
2616 Inc(j);
2617 if j > High(gPlayers) then j := 0;
2618 if gPlayers[j] <> nil then
2619 begin
2620 if gPlayers[j].alive and g_Obj_Collide(@Obj, @gPlayers[j].Obj) then
2621 begin
2622 if gPlayers[j].GetFlag(a) then Break;
2623 end;
2624 end;
2625 end;
2626 end;
2627 end;
2628 end;
2629 end;
2630 end;
2631 end;
2634 // old algo
2635 procedure g_Map_DrawPanels (PanelType: Word; hasAmbient: Boolean; constref ambColor: TDFColor);
2637 procedure DrawPanels (constref panels: TPanelArray; drawDoors: Boolean=False);
2638 var
2639 idx: Integer;
2640 begin
2641 if (panels <> nil) then
2642 begin
2643 // alas, no visible set
2644 for idx := 0 to High(panels) do
2645 begin
2646 if not (drawDoors xor panels[idx].Door) then panels[idx].Draw(hasAmbient, ambColor);
2647 end;
2648 end;
2649 end;
2651 begin
2652 case PanelType of
2653 PANEL_WALL: DrawPanels(gWalls);
2654 PANEL_CLOSEDOOR: DrawPanels(gWalls, True);
2655 PANEL_BACK: DrawPanels(gRenderBackgrounds);
2656 PANEL_FORE: DrawPanels(gRenderForegrounds);
2657 PANEL_WATER: DrawPanels(gWater);
2658 PANEL_ACID1: DrawPanels(gAcid1);
2659 PANEL_ACID2: DrawPanels(gAcid2);
2660 PANEL_STEP: DrawPanels(gSteps);
2661 end;
2662 end;
2665 // new algo
2666 procedure g_Map_CollectDrawPanels (x0, y0, wdt, hgt: Integer);
2667 var
2668 mwit: PPanel;
2669 it: TPanelGrid.Iter;
2670 begin
2671 dplClear();
2672 it := mapGrid.forEachInAABB(x0, y0, wdt, hgt, GridDrawableMask);
2673 for mwit in it do if (((mwit^.tag and GridTagDoor) <> 0) = mwit^.Door) then gDrawPanelList.insert(mwit^);
2674 it.release();
2675 // list will be rendered in `g_game.DrawPlayer()`
2676 end;
2679 procedure g_Map_DrawPanelShadowVolumes (lightX: Integer; lightY: Integer; radius: Integer);
2680 var
2681 mwit: PPanel;
2682 it: TPanelGrid.Iter;
2683 begin
2684 it := mapGrid.forEachInAABB(lightX-radius, lightY-radius, radius*2, radius*2, (GridTagWall or GridTagDoor));
2685 for mwit in it do mwit^.DrawShadowVolume(lightX, lightY, radius);
2686 it.release();
2687 end;
2690 procedure g_Map_DrawBack(dx, dy: Integer);
2691 begin
2692 if gDrawBackGround and (BackID <> DWORD(-1)) then
2693 e_DrawSize(BackID, dx, dy, 0, False, False, gBackSize.X, gBackSize.Y)
2694 else
2695 e_Clear(GL_COLOR_BUFFER_BIT, 0, 0, 0);
2696 end;
2698 function g_Map_CollidePanelOld(X, Y: Integer; Width, Height: Word;
2699 PanelType: Word; b1x3: Boolean=false): Boolean;
2700 var
2701 a, h: Integer;
2702 begin
2703 Result := False;
2705 if WordBool(PanelType and PANEL_WALL) then
2706 if gWalls <> nil then
2707 begin
2708 h := High(gWalls);
2710 for a := 0 to h do
2711 if gWalls[a].Enabled and
2712 g_Collide(X, Y, Width, Height,
2713 gWalls[a].X, gWalls[a].Y,
2714 gWalls[a].Width, gWalls[a].Height) then
2715 begin
2716 Result := True;
2717 Exit;
2718 end;
2719 end;
2721 if WordBool(PanelType and PANEL_WATER) then
2722 if gWater <> nil then
2723 begin
2724 h := High(gWater);
2726 for a := 0 to h do
2727 if g_Collide(X, Y, Width, Height,
2728 gWater[a].X, gWater[a].Y,
2729 gWater[a].Width, gWater[a].Height) then
2730 begin
2731 Result := True;
2732 Exit;
2733 end;
2734 end;
2736 if WordBool(PanelType and PANEL_ACID1) then
2737 if gAcid1 <> nil then
2738 begin
2739 h := High(gAcid1);
2741 for a := 0 to h do
2742 if g_Collide(X, Y, Width, Height,
2743 gAcid1[a].X, gAcid1[a].Y,
2744 gAcid1[a].Width, gAcid1[a].Height) then
2745 begin
2746 Result := True;
2747 Exit;
2748 end;
2749 end;
2751 if WordBool(PanelType and PANEL_ACID2) then
2752 if gAcid2 <> nil then
2753 begin
2754 h := High(gAcid2);
2756 for a := 0 to h do
2757 if g_Collide(X, Y, Width, Height,
2758 gAcid2[a].X, gAcid2[a].Y,
2759 gAcid2[a].Width, gAcid2[a].Height) then
2760 begin
2761 Result := True;
2762 Exit;
2763 end;
2764 end;
2766 if WordBool(PanelType and PANEL_STEP) then
2767 if gSteps <> nil then
2768 begin
2769 h := High(gSteps);
2771 for a := 0 to h do
2772 if g_Collide(X, Y, Width, Height,
2773 gSteps[a].X, gSteps[a].Y,
2774 gSteps[a].Width, gSteps[a].Height) then
2775 begin
2776 Result := True;
2777 Exit;
2778 end;
2779 end;
2781 if WordBool(PanelType and (PANEL_LIFTUP or PANEL_LIFTDOWN or PANEL_LIFTLEFT or PANEL_LIFTRIGHT)) then
2782 if gLifts <> nil then
2783 begin
2784 h := High(gLifts);
2786 for a := 0 to h do
2787 if ((WordBool(PanelType and (PANEL_LIFTUP)) and (gLifts[a].LiftType = LIFTTYPE_UP)) or
2788 (WordBool(PanelType and (PANEL_LIFTDOWN)) and (gLifts[a].LiftType = LIFTTYPE_DOWN)) or
2789 (WordBool(PanelType and (PANEL_LIFTLEFT)) and (gLifts[a].LiftType = LIFTTYPE_LEFT)) or
2790 (WordBool(PanelType and (PANEL_LIFTRIGHT)) and (gLifts[a].LiftType = LIFTTYPE_RIGHT))) and
2791 g_Collide(X, Y, Width, Height,
2792 gLifts[a].X, gLifts[a].Y,
2793 gLifts[a].Width, gLifts[a].Height) then
2794 begin
2795 Result := True;
2796 Exit;
2797 end;
2798 end;
2800 if WordBool(PanelType and PANEL_BLOCKMON) then
2801 if gBlockMon <> nil then
2802 begin
2803 h := High(gBlockMon);
2805 for a := 0 to h do
2806 if ( (not b1x3) or
2807 ((gBlockMon[a].Width + gBlockMon[a].Height) >= 64) ) and
2808 g_Collide(X, Y, Width, Height,
2809 gBlockMon[a].X, gBlockMon[a].Y,
2810 gBlockMon[a].Width, gBlockMon[a].Height) then
2811 begin
2812 Result := True;
2813 Exit;
2814 end;
2815 end;
2816 end;
2818 function g_Map_CollideLiquid_TextureOld(X, Y: Integer; Width, Height: Word): DWORD;
2819 var
2820 texid: DWORD;
2822 function checkPanels (constref panels: TPanelArray): Boolean;
2823 var
2824 a: Integer;
2825 begin
2826 result := false;
2827 if panels = nil then exit;
2828 for a := 0 to High(panels) do
2829 begin
2830 if g_Collide(X, Y, Width, Height, panels[a].X, panels[a].Y, panels[a].Width, panels[a].Height) then
2831 begin
2832 result := true;
2833 texid := panels[a].GetTextureID();
2834 exit;
2835 end;
2836 end;
2837 end;
2839 begin
2840 texid := LongWord(TEXTURE_NONE);
2841 result := texid;
2842 if not checkPanels(gWater) then
2843 if not checkPanels(gAcid1) then
2844 if not checkPanels(gAcid2) then exit;
2845 result := texid;
2846 end;
2849 function g_Map_CollidePanel(X, Y: Integer; Width, Height: Word; PanelType: Word; b1x3: Boolean): Boolean;
2850 const
2851 SlowMask = GridTagLift or GridTagBlockMon;
2853 function checker (pan: TPanel; tag: Integer): Boolean;
2854 begin
2856 if ((tag and (GridTagWall or GridTagDoor)) <> 0) then
2857 begin
2858 result := pan.Enabled;
2859 exit;
2860 end;
2863 if ((tag and GridTagLift) <> 0) then
2864 begin
2865 result :=
2866 ((WordBool(PanelType and PANEL_LIFTUP) and (pan.LiftType = LIFTTYPE_UP)) or
2867 (WordBool(PanelType and PANEL_LIFTDOWN) and (pan.LiftType = LIFTTYPE_DOWN)) or
2868 (WordBool(PanelType and PANEL_LIFTLEFT) and (pan.LiftType = LIFTTYPE_LEFT)) or
2869 (WordBool(PanelType and PANEL_LIFTRIGHT) and (pan.LiftType = LIFTTYPE_RIGHT))) {and
2870 g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height)};
2871 exit;
2872 end;
2874 if ((tag and GridTagBlockMon) <> 0) then
2875 begin
2876 result := ((not b1x3) or (pan.Width+pan.Height >= 64)); //and g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height);
2877 exit;
2878 end;
2880 // other shit
2881 //result := g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height);
2882 result := true; // i found her!
2883 end;
2885 var
2886 tagmask: Integer = 0;
2887 mwit: PPanel;
2888 it: TPanelGrid.Iter;
2889 pan: TPanel;
2890 begin
2891 result := false;
2892 if WordBool(PanelType and (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_OPENDOOR)) then tagmask := tagmask or (GridTagWall or GridTagDoor);
2893 if WordBool(PanelType and PANEL_WATER) then tagmask := tagmask or GridTagWater;
2894 if WordBool(PanelType and PANEL_ACID1) then tagmask := tagmask or GridTagAcid1;
2895 if WordBool(PanelType and PANEL_ACID2) then tagmask := tagmask or GridTagAcid2;
2896 if WordBool(PanelType and PANEL_STEP) then tagmask := tagmask or GridTagStep;
2897 if WordBool(PanelType and (PANEL_LIFTUP or PANEL_LIFTDOWN or PANEL_LIFTLEFT or PANEL_LIFTRIGHT)) then tagmask := tagmask or GridTagLift;
2898 if WordBool(PanelType and PANEL_BLOCKMON) then tagmask := tagmask or GridTagBlockMon;
2900 if (tagmask = 0) then exit; // just in case
2902 if (profMapCollision <> nil) then profMapCollision.sectionBeginAccum('*solids');
2903 if gdbg_map_use_accel_coldet then
2904 begin
2905 if ((tagmask and SlowMask) <> 0) then
2906 begin
2907 // slow
2908 it := mapGrid.forEachInAABB(X, Y, Width, Height, tagmask);
2909 for mwit in it do
2910 begin
2911 pan := mwit^;
2912 if ((pan.tag and GridTagLift) <> 0) then
2913 begin
2914 result :=
2915 ((WordBool(PanelType and PANEL_LIFTUP) and (pan.LiftType = LIFTTYPE_UP)) or
2916 (WordBool(PanelType and PANEL_LIFTDOWN) and (pan.LiftType = LIFTTYPE_DOWN)) or
2917 (WordBool(PanelType and PANEL_LIFTLEFT) and (pan.LiftType = LIFTTYPE_LEFT)) or
2918 (WordBool(PanelType and PANEL_LIFTRIGHT) and (pan.LiftType = LIFTTYPE_RIGHT))) {and
2919 g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height)};
2920 end
2921 else if ((pan.tag and GridTagBlockMon) <> 0) then
2922 begin
2923 result := ((not b1x3) or (pan.Width+pan.Height >= 64)); //and g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height);
2924 end
2925 else
2926 begin
2927 // other shit
2928 result := true; // i found her!
2929 end;
2930 if (result) then break;
2931 end;
2932 end
2933 else
2934 begin
2935 // fast
2936 it := mapGrid.forEachInAABB(X, Y, Width, Height, tagmask, false, true); // return first hit
2937 result := (it.length > 0);
2938 end;
2939 it.release();
2940 end
2941 else
2942 begin
2943 result := g_Map_CollidePanelOld(X, Y, Width, Height, PanelType, b1x3);
2944 end;
2945 if (profMapCollision <> nil) then profMapCollision.sectionEnd();
2946 end;
2949 // returns `true` if we need to stop
2950 function liquidChecker (pan: TPanel; var texid: DWORD; var cctype: Integer): Boolean; inline;
2951 begin
2952 result := false;
2953 //if ((tag and (GridTagWater or GridTagAcid1 or GridTagAcid2)) = 0) then exit;
2954 // check priorities
2955 case cctype of
2956 0: if ((pan.tag and GridTagWater) = 0) then exit; // allowed: water
2957 1: if ((pan.tag and (GridTagWater or GridTagAcid1)) = 0) then exit; // allowed: water, acid1
2958 //2: if ((tag and (GridTagWater or GridTagAcid1 or GridTagAcid2) = 0) then exit; // allowed: water, acid1, acid2
2959 end;
2960 // collision?
2961 //if not g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height) then exit;
2962 // yeah
2963 texid := pan.GetTextureID();
2964 // water? water has the highest priority, so stop right here
2965 if ((pan.tag and GridTagWater) <> 0) then begin cctype := 0; result := true; exit; end;
2966 // acid2?
2967 if ((pan.tag and GridTagAcid2) <> 0) then cctype := 2;
2968 // acid1?
2969 if ((pan.tag and GridTagAcid1) <> 0) then cctype := 1;
2970 end;
2972 function g_Map_CollideLiquid_Texture(X, Y: Integer; Width, Height: Word): DWORD;
2973 var
2974 cctype: Integer = 3; // priority: 0: water was hit, 1: acid1 was hit, 2: acid2 was hit; 3: nothing was hit
2975 mwit: PPanel;
2976 it: TPanelGrid.Iter;
2977 begin
2978 if (profMapCollision <> nil) then profMapCollision.sectionBeginAccum('liquids');
2979 if gdbg_map_use_accel_coldet then
2980 begin
2981 result := LongWord(TEXTURE_NONE);
2982 it := mapGrid.forEachInAABB(X, Y, Width, Height, (GridTagWater or GridTagAcid1 or GridTagAcid2));
2983 for mwit in it do if (liquidChecker(mwit^, result, cctype)) then break;
2984 it.release();
2985 end
2986 else
2987 begin
2988 result := g_Map_CollideLiquid_TextureOld(X, Y, Width, Height);
2989 end;
2990 if (profMapCollision <> nil) then profMapCollision.sectionEnd();
2991 end;
2994 procedure g_Map_EnableWall_XXX (ID: DWORD); begin if (ID < Length(gWalls)) then g_Map_EnableWallGUID(gWalls[ID].guid); end;
2995 procedure g_Map_DisableWall_XXX (ID: DWORD); begin if (ID < Length(gWalls)) then g_Map_DisableWallGUID(gWalls[ID].guid); end;
2996 procedure g_Map_SetLift_XXX (ID: DWORD; t: Integer); begin if (ID < Length(gLifts)) then g_Map_SetLiftGUID(gLifts[ID].guid, t); end;
2999 procedure g_Map_EnableWallGUID (pguid: Integer);
3000 var
3001 pan: TPanel;
3002 begin
3003 //pan := gWalls[ID];
3004 pan := g_Map_PanelByGUID(pguid);
3005 if (pan = nil) then exit;
3006 if pan.Enabled and mapGrid.proxyEnabled[pan.proxyId] then exit;
3008 pan.Enabled := True;
3009 g_Mark(pan.X, pan.Y, pan.Width, pan.Height, MARK_DOOR, true);
3011 mapGrid.proxyEnabled[pan.proxyId] := true;
3012 //if (pan.proxyId >= 0) then mapGrid.proxyEnabled[pan.proxyId] := true
3013 //else pan.proxyId := mapGrid.insertBody(pan, pan.X, pan.Y, pan.Width, pan.Height, GridTagDoor);
3015 //if g_Game_IsServer and g_Game_IsNet then MH_SEND_PanelState(pguid);
3016 // mark platform as interesting
3017 pan.setDirty();
3019 {$IFDEF MAP_DEBUG_ENABLED_FLAG}
3020 //e_WriteLog(Format('ENABLE: wall #%d(%d) enabled (%d) (%d,%d)-(%d,%d)', [Integer(ID), Integer(pan.proxyId), Integer(mapGrid.proxyEnabled[pan.proxyId]), pan.x, pan.y, pan.width, pan.height]), MSG_NOTIFY);
3021 {$ENDIF}
3022 end;
3025 procedure g_Map_DisableWallGUID (pguid: Integer);
3026 var
3027 pan: TPanel;
3028 begin
3029 //pan := gWalls[ID];
3030 pan := g_Map_PanelByGUID(pguid);
3031 if (pan = nil) then exit;
3032 if (not pan.Enabled) and (not mapGrid.proxyEnabled[pan.proxyId]) then exit;
3034 pan.Enabled := False;
3035 g_Mark(pan.X, pan.Y, pan.Width, pan.Height, MARK_DOOR, false);
3037 mapGrid.proxyEnabled[pan.proxyId] := false;
3038 //if (pan.proxyId >= 0) then begin mapGrid.removeBody(pan.proxyId); pan.proxyId := -1; end;
3040 //if g_Game_IsServer and g_Game_IsNet then MH_SEND_PanelState(pguid);
3041 // mark platform as interesting
3042 pan.setDirty();
3044 {$IFDEF MAP_DEBUG_ENABLED_FLAG}
3045 //e_WriteLog(Format('DISABLE: wall #%d(%d) disabled (%d) (%d,%d)-(%d,%d)', [Integer(ID), Integer(pan.proxyId), Integer(mapGrid.proxyEnabled[pan.proxyId]), pan.x, pan.y, pan.width, pan.height]), MSG_NOTIFY);
3046 {$ENDIF}
3047 end;
3050 procedure g_Map_SwitchTextureGUID (pguid: Integer; AnimLoop: Byte = 0);
3051 var
3052 tp: TPanel;
3053 begin
3054 tp := g_Map_PanelByGUID(pguid);
3055 if (tp = nil) then exit;
3056 tp.NextTexture(AnimLoop);
3057 if g_Game_IsServer and g_Game_IsNet then MH_SEND_PanelTexture(pguid, AnimLoop);
3058 end;
3061 procedure g_Map_SetLiftGUID (pguid: Integer; t: Integer);
3062 var
3063 pan: TPanel;
3064 begin
3065 //pan := gLifts[ID];
3066 pan := g_Map_PanelByGUID(pguid);
3067 if (pan = nil) then exit;
3068 if not pan.isGLift then exit;
3070 if ({gLifts[ID]}pan.LiftType = t) then exit; //!FIXME!TRIGANY!
3072 with {gLifts[ID]} pan do
3073 begin
3074 LiftType := t;
3076 g_Mark(X, Y, Width, Height, MARK_LIFT, false);
3077 //TODO: make separate lift tags, and change tag here
3079 case LiftType of
3080 LIFTTYPE_UP: g_Mark(X, Y, Width, Height, MARK_LIFTUP);
3081 LIFTTYPE_DOWN: g_Mark(X, Y, Width, Height, MARK_LIFTDOWN);
3082 LIFTTYPE_LEFT: g_Mark(X, Y, Width, Height, MARK_LIFTLEFT);
3083 LIFTTYPE_RIGHT: g_Mark(X, Y, Width, Height, MARK_LIFTRIGHT);
3084 end;
3086 //if g_Game_IsServer and g_Game_IsNet then MH_SEND_PanelState(pguid);
3087 // mark platform as interesting
3088 pan.setDirty();
3089 end;
3090 end;
3093 function g_Map_GetPoint (PointType: Byte; var RespawnPoint: TRespawnPoint): Boolean;
3094 var
3095 a: Integer;
3096 PointsArray: Array of TRespawnPoint;
3097 begin
3098 Result := False;
3099 SetLength(PointsArray, 0);
3101 if RespawnPoints = nil then
3102 Exit;
3104 for a := 0 to High(RespawnPoints) do
3105 if RespawnPoints[a].PointType = PointType then
3106 begin
3107 SetLength(PointsArray, Length(PointsArray)+1);
3108 PointsArray[High(PointsArray)] := RespawnPoints[a];
3109 end;
3111 if PointsArray = nil then
3112 Exit;
3114 RespawnPoint := PointsArray[Random(Length(PointsArray))];
3115 Result := True;
3116 end;
3118 function g_Map_GetPointCount(PointType: Byte): Word;
3119 var
3120 a: Integer;
3121 begin
3122 Result := 0;
3124 if RespawnPoints = nil then
3125 Exit;
3127 for a := 0 to High(RespawnPoints) do
3128 if RespawnPoints[a].PointType = PointType then
3129 Result := Result + 1;
3130 end;
3132 function g_Map_GetRandomPointType(): Byte;
3133 begin
3134 if RespawnPoints = nil then
3135 Result := 255
3136 else
3137 Result := RespawnPoints[Random(Length(RespawnPoints))].PointType;
3138 end;
3140 function g_Map_HaveFlagPoints(): Boolean;
3141 begin
3142 Result := (FlagPoints[FLAG_RED] <> nil) and (FlagPoints[FLAG_BLUE] <> nil);
3143 end;
3145 procedure g_Map_ResetFlag(Flag: Byte);
3146 begin
3147 with gFlags[Flag] do
3148 begin
3149 Obj.X := -1000;
3150 Obj.Y := -1000;
3151 Obj.Vel.X := 0;
3152 Obj.Vel.Y := 0;
3153 Direction := TDirection.D_LEFT;
3154 State := FLAG_STATE_NONE;
3155 if FlagPoints[Flag] <> nil then
3156 begin
3157 Obj.X := FlagPoints[Flag]^.X;
3158 Obj.Y := FlagPoints[Flag]^.Y;
3159 Direction := FlagPoints[Flag]^.Direction;
3160 State := FLAG_STATE_NORMAL;
3161 end;
3162 Obj.oldX := Obj.X;
3163 Obj.oldY := Obj.Y;
3164 NeedSend := False; // the event will take care of this
3165 Count := -1;
3166 end;
3167 end;
3169 procedure g_Map_DrawFlags();
3170 var
3171 i, dx: Integer;
3172 tx, ty: Integer;
3173 Mirror: TMirrorType;
3174 begin
3175 if gGameSettings.GameMode <> GM_CTF then
3176 Exit;
3178 for i := FLAG_RED to FLAG_BLUE do
3179 with gFlags[i] do
3180 if State <> FLAG_STATE_CAPTURED then
3181 begin
3182 if State = FLAG_STATE_NONE then
3183 continue;
3185 Obj.lerp(gLerpFactor, tx, ty);
3187 if Direction = TDirection.D_LEFT then
3188 begin
3189 Mirror := TMirrorType.Horizontal;
3190 dx := -1;
3191 end
3192 else
3193 begin
3194 Mirror := TMirrorType.None;
3195 dx := 1;
3196 end;
3198 Animation.Draw(tx+dx, ty+1, Mirror);
3200 if g_debug_Frames then
3201 begin
3202 e_DrawQuad(Obj.X+Obj.Rect.X,
3203 Obj.Y+Obj.Rect.Y,
3204 Obj.X+Obj.Rect.X+Obj.Rect.Width-1,
3205 Obj.Y+Obj.Rect.Y+Obj.Rect.Height-1,
3206 0, 255, 0);
3207 end;
3208 end;
3209 end;
3212 procedure g_Map_SaveState (st: TStream);
3213 var
3214 str: String;
3216 procedure savePanels ();
3217 var
3218 pan: TPanel;
3219 begin
3220 // Ñîõðàíÿåì ïàíåëè
3221 utils.writeInt(st, LongInt(Length(panByGUID)));
3222 for pan in panByGUID do pan.SaveState(st);
3223 end;
3225 procedure saveFlag (flag: PFlag);
3226 var
3227 b: Byte;
3228 begin
3229 utils.writeSign(st, 'FLAG');
3230 utils.writeInt(st, Byte(0)); // version
3231 // Âðåìÿ ïåðåïîÿâëåíèÿ ôëàãà
3232 utils.writeInt(st, Byte(flag^.RespawnType));
3233 // Ñîñòîÿíèå ôëàãà
3234 utils.writeInt(st, Byte(flag^.State));
3235 // Íàïðàâëåíèå ôëàãà
3236 if flag^.Direction = TDirection.D_LEFT then b := 1 else b := 2; // D_RIGHT
3237 utils.writeInt(st, Byte(b));
3238 // Îáúåêò ôëàãà
3239 Obj_SaveState(st, @flag^.Obj);
3240 end;
3242 begin
3243 savePanels();
3245 // Ñîõðàíÿåì ìóçûêó
3246 utils.writeSign(st, 'MUSI');
3247 utils.writeInt(st, Byte(0));
3248 // Íàçâàíèå ìóçûêè
3249 assert(gMusic <> nil, 'g_Map_SaveState: gMusic = nil');
3250 if gMusic.NoMusic then str := '' else str := gMusic.Name;
3251 utils.writeStr(st, str);
3252 // Ïîçèöèÿ ïðîèãðûâàíèÿ ìóçûêè
3253 utils.writeInt(st, LongWord(gMusic.GetPosition()));
3254 // Ñòîèò ëè ìóçûêà íà ñïåö-ïàóçå
3255 utils.writeBool(st, gMusic.SpecPause);
3257 ///// Ñîõðàíÿåì êîëè÷åñòâî ìîíñòðîâ: /////
3258 utils.writeInt(st, LongInt(gTotalMonsters));
3259 ///// /////
3261 //// Ñîõðàíÿåì ôëàãè, åñëè ýòî CTF: /////
3262 if (gGameSettings.GameMode = GM_CTF) then
3263 begin
3264 // Ôëàã Êðàñíîé êîìàíäû
3265 saveFlag(@gFlags[FLAG_RED]);
3266 // Ôëàã Ñèíåé êîìàíäû
3267 saveFlag(@gFlags[FLAG_BLUE]);
3268 end;
3269 ///// /////
3271 ///// Ñîõðàíÿåì êîëè÷åñòâî ïîáåä, åñëè ýòî TDM/CTF: /////
3272 if gGameSettings.GameMode in [GM_TDM, GM_CTF] then
3273 begin
3274 // Î÷êè Êðàñíîé êîìàíäû
3275 utils.writeInt(st, SmallInt(gTeamStat[TEAM_RED].Goals));
3276 // Î÷êè Ñèíåé êîìàíäû
3277 utils.writeInt(st, SmallInt(gTeamStat[TEAM_BLUE].Goals));
3278 end;
3279 ///// /////
3280 end;
3283 procedure g_Map_LoadState (st: TStream);
3284 var
3285 dw: DWORD;
3286 str: String;
3287 boo: Boolean;
3289 procedure loadPanels ();
3290 var
3291 pan: TPanel;
3292 begin
3293 // Çàãðóæàåì ïàíåëè
3294 if (Length(panByGUID) <> utils.readLongInt(st)) then raise XStreamError.Create('invalid number of saved panels');
3295 for pan in panByGUID do
3296 begin
3297 pan.LoadState(st);
3298 if (pan.proxyId >= 0) then mapGrid.proxyEnabled[pan.proxyId] := pan.Enabled;
3299 end;
3300 end;
3302 procedure loadFlag (flag: PFlag);
3303 var
3304 b: Byte;
3305 begin
3306 // Ñèãíàòóðà ôëàãà
3307 if not utils.checkSign(st, 'FLAG') then raise XStreamError.Create('invalid flag signature');
3308 if (utils.readByte(st) <> 0) then raise XStreamError.Create('invalid flag version');
3309 // Âðåìÿ ïåðåïîÿâëåíèÿ ôëàãà
3310 flag^.RespawnType := utils.readByte(st);
3311 // Ñîñòîÿíèå ôëàãà
3312 flag^.State := utils.readByte(st);
3313 // Íàïðàâëåíèå ôëàãà
3314 b := utils.readByte(st);
3315 if (b = 1) then flag^.Direction := TDirection.D_LEFT else flag^.Direction := TDirection.D_RIGHT; // b = 2
3316 // Îáúåêò ôëàãà
3317 Obj_LoadState(@flag^.Obj, st);
3318 end;
3320 begin
3321 if (st = nil) then exit;
3323 ///// Çàãðóæàåì ñïèñêè ïàíåëåé: /////
3324 loadPanels();
3325 ///// /////
3327 // Îáíîâëÿåì êàðòó ñòîëêíîâåíèé è ñåòêó
3328 g_GFX_Init();
3329 //mapCreateGrid();
3331 ///// Çàãðóæàåì ìóçûêó: /////
3332 if not utils.checkSign(st, 'MUSI') then raise XStreamError.Create('invalid music signature');
3333 if (utils.readByte(st) <> 0) then raise XStreamError.Create('invalid music version');
3334 // Íàçâàíèå ìóçûêè
3335 assert(gMusic <> nil, 'g_Map_LoadState: gMusic = nil');
3336 str := utils.readStr(st);
3337 // Ïîçèöèÿ ïðîèãðûâàíèÿ ìóçûêè
3338 dw := utils.readLongWord(st);
3339 // Ñòîèò ëè ìóçûêà íà ñïåö-ïàóçå
3340 boo := utils.readBool(st);
3341 // Çàïóñêàåì ýòó ìóçûêó
3342 gMusic.SetByName(str);
3343 gMusic.SpecPause := boo;
3344 gMusic.Play();
3345 gMusic.Pause(true);
3346 gMusic.SetPosition(dw);
3347 ///// /////
3349 ///// Çàãðóæàåì êîëè÷åñòâî ìîíñòðîâ: /////
3350 gTotalMonsters := utils.readLongInt(st);
3351 ///// /////
3353 //// Çàãðóæàåì ôëàãè, åñëè ýòî CTF: /////
3354 if (gGameSettings.GameMode = GM_CTF) then
3355 begin
3356 // Ôëàã Êðàñíîé êîìàíäû
3357 loadFlag(@gFlags[FLAG_RED]);
3358 // Ôëàã Ñèíåé êîìàíäû
3359 loadFlag(@gFlags[FLAG_BLUE]);
3360 end;
3361 ///// /////
3363 ///// Çàãðóæàåì êîëè÷åñòâî ïîáåä, åñëè ýòî TDM/CTF: /////
3364 if gGameSettings.GameMode in [GM_TDM, GM_CTF] then
3365 begin
3366 // Î÷êè Êðàñíîé êîìàíäû
3367 gTeamStat[TEAM_RED].Goals := utils.readSmallInt(st);
3368 // Î÷êè Ñèíåé êîìàíäû
3369 gTeamStat[TEAM_BLUE].Goals := utils.readSmallInt(st);
3370 end;
3371 ///// /////
3372 end;
3375 // trace liquid, stepping by `dx` and `dy`
3376 // return last seen liquid coords, and `false` if we're started outside of the liquid
3377 function g_Map_TraceLiquidNonPrecise (x, y, dx, dy: Integer; out topx, topy: Integer): Boolean;
3378 const
3379 MaskLiquid = GridTagWater or GridTagAcid1 or GridTagAcid2;
3380 begin
3381 topx := x;
3382 topy := y;
3383 // started outside of the liquid?
3384 //if (mapGrid.forEachAtPoint(x, y, nil, MaskLiquid) = nil) then begin result := false; exit; end;
3385 if (g_Map_PanelAtPoint(x, y, MaskLiquid) = nil) then begin result := false; exit; end;
3386 if (dx = 0) and (dy = 0) then begin result := false; exit; end; // sanity check
3387 result := true;
3388 while true do
3389 begin
3390 Inc(x, dx);
3391 Inc(y, dy);
3392 //if (mapGrid.forEachAtPoint(x, y, nil, MaskLiquid) = nil) then exit; // out of the water, just exit
3393 if (g_Map_PanelAtPoint(x, y, MaskLiquid) = nil) then exit; // out of the water, just exit
3394 topx := x;
3395 topy := y;
3396 end;
3397 end;
3400 begin
3401 DynWarningCB := mapWarningCB;
3402 end.