DEADSOFTWARE

`Grid.forEachInAABB()`: no more callbacks
[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, either version 3 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
15 *)
16 {$INCLUDE ../shared/a_modes.inc}
17 {$DEFINE MAP_DEBUG_ENABLED_FLAG}
18 unit g_map;
20 interface
22 uses
23 SysUtils, Classes, mempool,
24 e_graphics, g_basic, MAPDEF, g_textures,
25 g_phys, utils, g_panel, g_grid, md5, binheap, xprofiler, xparser, xdynrec;
27 type
28 TMapInfo = record
29 Map: String;
30 Name: String;
31 Description: String;
32 Author: String;
33 MusicName: String;
34 SkyName: String;
35 Height: Word;
36 Width: Word;
37 end;
39 PRespawnPoint = ^TRespawnPoint;
40 TRespawnPoint = record
41 X, Y: Integer;
42 Direction: TDirection;
43 PointType: Byte;
44 end;
46 PFlagPoint = ^TFlagPoint;
47 TFlagPoint = TRespawnPoint;
49 PFlag = ^TFlag;
50 TFlag = record
51 Obj: TObj;
52 RespawnType: Byte;
53 State: Byte;
54 Count: Integer;
55 CaptureTime: LongWord;
56 Animation: TAnimation;
57 Direction: TDirection;
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;
94 function g_Map_HaveFlagPoints(): Boolean;
96 procedure g_Map_ResetFlag(Flag: Byte);
97 procedure g_Map_DrawFlags();
99 procedure g_Map_SaveState (st: TStream);
100 procedure g_Map_LoadState (st: TStream);
102 procedure g_Map_DrawPanelShadowVolumes(lightX: Integer; lightY: Integer; radius: Integer);
104 // returns panel or nil
105 // sets `ex` and `ey` to `x1` and `y1` when no hit was detected
106 function g_Map_traceToNearestWall (x0, y0, x1, y1: Integer; hitx: PInteger=nil; hity: PInteger=nil): TPanel;
108 // returns panel or nil
109 // sets `ex` and `ey` to `x1` and `y1` when no hit was detected
110 function g_Map_traceToNearest (x0, y0, x1, y1: Integer; tag: Integer; hitx: PInteger=nil; hity: PInteger=nil): TPanel;
112 type
113 TForEachPanelCB = function (pan: TPanel): Boolean is nested; // return `true` to stop
115 function g_Map_HasAnyPanelAtPoint (x, y: Integer; panelType: Word): Boolean;
116 function g_Map_PanelAtPoint (x, y: Integer; tagmask: Integer=-1): TPanel;
118 // trace liquid, stepping by `dx` and `dy`
119 // return last seen liquid coords, and `false` if we're started outside of the liquid
120 function g_Map_TraceLiquidNonPrecise (x, y, dx, dy: Integer; out topx, topy: Integer): Boolean;
123 // return `true` from `cb` to stop
124 function g_Map_ForEachPanel (cb: TForEachPanelCB): TPanel;
126 procedure g_Map_NetSendInterestingPanels (); // yay!
129 procedure g_Map_ProfilersBegin ();
130 procedure g_Map_ProfilersEnd ();
133 function g_Map_ParseMap (data: Pointer; dataLen: Integer): TDynRecord;
136 function g_Map_MinX (): Integer; inline;
137 function g_Map_MinY (): Integer; inline;
138 function g_Map_MaxX (): Integer; inline;
139 function g_Map_MaxY (): Integer; inline;
141 const
142 NNF_NO_NAME = 0;
143 NNF_NAME_BEFORE = 1;
144 NNF_NAME_EQUALS = 2;
145 NNF_NAME_AFTER = 3;
147 function g_Texture_NumNameFindStart(name: String): Boolean;
148 function g_Texture_NumNameFindNext(var newName: String): Byte;
150 const
151 RESPAWNPOINT_PLAYER1 = 1;
152 RESPAWNPOINT_PLAYER2 = 2;
153 RESPAWNPOINT_DM = 3;
154 RESPAWNPOINT_RED = 4;
155 RESPAWNPOINT_BLUE = 5;
157 FLAG_NONE = 0;
158 FLAG_RED = 1;
159 FLAG_BLUE = 2;
160 FLAG_DOM = 3;
162 FLAG_STATE_NONE = 0;
163 FLAG_STATE_NORMAL = 1;
164 FLAG_STATE_DROPPED = 2;
165 FLAG_STATE_CAPTURED = 3;
166 FLAG_STATE_SCORED = 4; // Äëÿ ýâåíòîâ ÷åðåç ñåòêó.
167 FLAG_STATE_RETURNED = 5; // Äëÿ ýâåíòîâ ÷åðåç ñåòêó.
169 FLAG_TIME = 720; // 20 seconds
171 SKY_STRETCH: Single = 1.5;
173 const
174 GridTagInvalid = 0;
176 (* draw order:
177 PANEL_BACK
178 PANEL_STEP
179 PANEL_WALL
180 PANEL_CLOSEDOOR
181 PANEL_ACID1
182 PANEL_ACID2
183 PANEL_WATER
184 PANEL_FORE
185 *)
186 // sorted by draw priority
187 GridTagBack = 1 shl 0; // gRenderBackgrounds
188 GridTagStep = 1 shl 1; // gSteps
189 GridTagWall = 1 shl 2; // gWalls
190 GridTagDoor = 1 shl 3; // gWalls
191 GridTagAcid1 = 1 shl 4; // gAcid1
192 GridTagAcid2 = 1 shl 5; // gAcid2
193 GridTagWater = 1 shl 6; // gWater
194 GridTagFore = 1 shl 7; // gRenderForegrounds
195 // the following are invisible
196 GridTagLift = 1 shl 8; // gLifts
197 GridTagBlockMon = 1 shl 9; // gBlockMon
199 GridTagObstacle = (GridTagStep or GridTagWall or GridTagDoor);
200 GridTagLiquid = (GridTagAcid1 or GridTagAcid2 or GridTagWater);
202 GridDrawableMask = (GridTagBack or GridTagStep or GridTagWall or GridTagDoor or GridTagAcid1 or GridTagAcid2 or GridTagWater or GridTagFore);
205 type
206 TBinHeapPanelDrawCmp = class
207 public
208 class function less (const a, b: TPanel): Boolean; inline;
209 end;
211 TBinHeapPanelDraw = specialize TBinaryHeapBase<TPanel, TBinHeapPanelDrawCmp>;
213 var
214 gWalls: TPanelArray;
215 gRenderBackgrounds: TPanelArray;
216 gRenderForegrounds: TPanelArray;
217 gWater, gAcid1, gAcid2: TPanelArray;
218 gSteps: TPanelArray;
219 gLifts: TPanelArray;
220 gBlockMon: TPanelArray;
221 gFlags: array [FLAG_RED..FLAG_BLUE] of TFlag;
222 //gDOMFlags: array of TFlag;
223 gMapInfo: TMapInfo;
224 gBackSize: TDFPoint;
225 gDoorMap: array of array of DWORD;
226 gLiftMap: array of array of DWORD;
227 gWADHash: TMD5Digest;
228 BackID: DWORD = DWORD(-1);
229 gExternalResources: TStringList;
230 gMovingWallIds: array of Integer = nil;
232 gdbg_map_use_accel_render: Boolean = true;
233 gdbg_map_use_accel_coldet: Boolean = true;
234 profMapCollision: TProfiler = nil; //WARNING: FOR DEBUGGING ONLY!
235 gDrawPanelList: TBinHeapPanelDraw = nil; // binary heap of all walls we have to render, populated by `g_Map_CollectDrawPanels()`
237 gCurrentMap: TDynRecord = nil;
238 gCurrentMapFileName: AnsiString = ''; // so we can skip texture reloading
239 gTestMap: String = '';
242 function panelTypeToTag (panelType: Word): Integer; // returns GridTagXXX
245 type
246 TPanelGrid = specialize TBodyGridBase<TPanel>;
248 var
249 mapGrid: TPanelGrid = nil; // DO NOT USE! public for debugging only!
252 implementation
254 uses
255 e_input, g_main, e_log, e_texture, g_items, g_gfx, g_console,
256 GL, GLExt, g_weapons, g_game, g_sound, e_sound, CONFIG,
257 g_options, g_triggers, g_player,
258 Math, g_monsters, g_saveload, g_language, g_netmsg,
259 sfs, xstreams, hashtable, wadreader,
260 ImagingTypes, Imaging, ImagingUtility,
261 ImagingGif, ImagingNetworkGraphics;
263 const
264 FLAGRECT: TRectWH = (X:15; Y:12; Width:33; Height:52);
265 MUSIC_SIGNATURE = $4953554D; // 'MUSI'
266 FLAG_SIGNATURE = $47414C46; // 'FLAG'
269 // ////////////////////////////////////////////////////////////////////////// //
270 procedure mapWarningCB (const msg: AnsiString; line, col: Integer);
271 begin
272 if (line > 0) then
273 begin
274 e_LogWritefln('parse error at (%s,%s): %s', [line, col, msg], TMsgType.Warning);
275 end
276 else
277 begin
278 e_LogWritefln('parse error: %s', [msg], TMsgType.Warning);
279 end;
280 end;
283 // ////////////////////////////////////////////////////////////////////////// //
284 var
285 panByGUID: array of TPanel = nil;
288 // ////////////////////////////////////////////////////////////////////////// //
289 function g_Map_PanelByGUID (aguid: Integer): TPanel; inline;
290 begin
291 //if (panByGUID = nil) or (not panByGUID.get(aguid, result)) then result := nil;
292 if (aguid >= 0) and (aguid < Length(panByGUID)) then result := panByGUID[aguid] else result := nil;
293 end;
296 // return `true` from `cb` to stop
297 function g_Map_ForEachPanel (cb: TForEachPanelCB): TPanel;
298 var
299 pan: TPanel;
300 begin
301 result := nil;
302 if not assigned(cb) then exit;
303 for pan in panByGUID do
304 begin
305 if cb(pan) then begin result := pan; exit; end;
306 end;
307 end;
310 procedure g_Map_NetSendInterestingPanels ();
311 var
312 pan: TPanel;
313 begin
314 if g_Game_IsServer and g_Game_IsNet then
315 begin
316 for pan in panByGUID do
317 begin
318 if pan.gncNeedSend then MH_SEND_PanelState(pan.guid);
319 end;
320 end;
321 end;
324 // ////////////////////////////////////////////////////////////////////////// //
325 function g_Map_MinX (): Integer; inline; begin if (mapGrid <> nil) then result := mapGrid.gridX0 else result := 0; end;
326 function g_Map_MinY (): Integer; inline; begin if (mapGrid <> nil) then result := mapGrid.gridY0 else result := 0; end;
327 function g_Map_MaxX (): Integer; inline; begin if (mapGrid <> nil) then result := mapGrid.gridX0+mapGrid.gridWidth-1 else result := 0; end;
328 function g_Map_MaxY (): Integer; inline; begin if (mapGrid <> nil) then result := mapGrid.gridY0+mapGrid.gridHeight-1 else result := 0; end;
331 // ////////////////////////////////////////////////////////////////////////// //
332 var
333 dfmapdef: TDynMapDef = nil;
336 procedure loadMapDefinition ();
337 var
338 pr: TTextParser = nil;
339 st: TStream = nil;
340 WAD: TWADFile = nil;
341 begin
342 if (dfmapdef <> nil) then exit;
344 try
345 e_LogWritefln('parsing "mapdef.txt"...', []);
346 st := openDiskFileRO(DataDir+'mapdef.txt');
347 e_LogWritefln('found local "%smapdef.txt"', [DataDir]);
348 except
349 st := nil;
350 end;
352 if (st = nil) then
353 begin
354 WAD := TWADFile.Create();
355 if not WAD.ReadFile(GameWAD) then
356 begin
357 //raise Exception.Create('cannot load "game.wad"');
358 st := nil;
359 end
360 else
361 begin
362 st := WAD.openFileStream('mapdef.txt');
363 end;
364 end;
366 try
367 if (st = nil) then
368 begin
369 //raise Exception.Create('cannot open "mapdef.txt"');
370 e_LogWriteln('using default "mapdef.txt"...');
371 pr := TStrTextParser.Create(defaultMapDef);
372 end
373 else
374 begin
375 pr := TFileTextParser.Create(st);
376 end;
377 except on e: Exception do
378 begin
379 e_LogWritefln('something is VERY wrong here! -- ', [e.message]);
380 raise;
381 end;
382 end;
384 try
385 dfmapdef := TDynMapDef.Create(pr);
386 except
387 on e: TDynParseException do
388 raise Exception.CreateFmt('ERROR in "mapdef.txt" at (%s,%s): %s', [e.tokLine, e.tokCol, e.message]);
389 on e: Exception do
390 raise Exception.CreateFmt('ERROR in "mapdef.txt" at (%s,%s): %s', [pr.tokLine, pr.tokCol, e.message]);
391 end;
393 st.Free();
394 WAD.Free();
395 end;
398 // ////////////////////////////////////////////////////////////////////////// //
399 function g_Map_ParseMap (data: Pointer; dataLen: Integer): TDynRecord;
400 var
401 wst: TSFSMemoryChunkStream = nil;
402 begin
403 result := nil;
404 if (dataLen < 4) then exit;
406 if (dfmapdef = nil) then writeln('need to load mapdef');
407 loadMapDefinition();
408 if (dfmapdef = nil) then raise Exception.Create('internal map loader error');
410 wst := TSFSMemoryChunkStream.Create(data, dataLen);
411 try
412 result := dfmapdef.parseMap(wst);
413 except
414 on e: TDynParseException do
415 begin
416 e_LogWritefln('ERROR at (%s,%s): %s', [e.tokLine, e.tokCol, e.message]);
417 wst.Free();
418 result := nil;
419 exit;
420 end;
421 on e: Exception do
422 begin
423 e_LogWritefln('ERROR: %s', [e.message]);
424 wst.Free();
425 result := nil;
426 exit;
427 end;
428 end;
430 //e_LogWriteln('map parsed.');
431 end;
434 // ////////////////////////////////////////////////////////////////////////// //
435 var
436 NNF_PureName: String; // Èìÿ òåêñòóðû áåç öèôð â êîíöå
437 NNF_FirstNum: Integer; // ×èñëî ó íà÷àëüíîé òåêñòóðû
438 NNF_CurrentNum: Integer; // Ñëåäóþùåå ÷èñëî ó òåêñòóðû
441 function g_Texture_NumNameFindStart(name: String): Boolean;
442 var
443 i: Integer;
445 begin
446 Result := False;
447 NNF_PureName := '';
448 NNF_FirstNum := -1;
449 NNF_CurrentNum := -1;
451 for i := Length(name) downto 1 do
452 if (name[i] = '_') then // "_" - ñèìâîë íà÷àëà íîìåðíîãî ïîñòôèêñà
453 begin
454 if i = Length(name) then
455 begin // Íåò öèôð â êîíöå ñòðîêè
456 Exit;
457 end
458 else
459 begin
460 NNF_PureName := Copy(name, 1, i);
461 Delete(name, 1, i);
462 Break;
463 end;
464 end;
466 // Íå ïåðåâåñòè â ÷èñëî:
467 if not TryStrToInt(name, NNF_FirstNum) then
468 Exit;
470 NNF_CurrentNum := 0;
472 Result := True;
473 end;
476 function g_Texture_NumNameFindNext(var newName: String): Byte;
477 begin
478 if (NNF_PureName = '') or (NNF_CurrentNum < 0) then
479 begin
480 newName := '';
481 Result := NNF_NO_NAME;
482 Exit;
483 end;
485 newName := NNF_PureName + IntToStr(NNF_CurrentNum);
487 if NNF_CurrentNum < NNF_FirstNum then
488 Result := NNF_NAME_BEFORE
489 else
490 if NNF_CurrentNum > NNF_FirstNum then
491 Result := NNF_NAME_AFTER
492 else
493 Result := NNF_NAME_EQUALS;
495 Inc(NNF_CurrentNum);
496 end;
499 // ////////////////////////////////////////////////////////////////////////// //
500 function panelTypeToTag (panelType: Word): Integer;
501 begin
502 case panelType of
503 PANEL_WALL: result := GridTagWall; // gWalls
504 PANEL_OPENDOOR, PANEL_CLOSEDOOR: result := GridTagDoor; // gWalls
505 PANEL_BACK: result := GridTagBack; // gRenderBackgrounds
506 PANEL_FORE: result := GridTagFore; // gRenderForegrounds
507 PANEL_WATER: result := GridTagWater; // gWater
508 PANEL_ACID1: result := GridTagAcid1; // gAcid1
509 PANEL_ACID2: result := GridTagAcid2; // gAcid2
510 PANEL_STEP: result := GridTagStep; // gSteps
511 PANEL_LIFTUP, PANEL_LIFTDOWN, PANEL_LIFTLEFT, PANEL_LIFTRIGHT: result := GridTagLift; // gLifts -- this is for all lifts
512 PANEL_BLOCKMON: result := GridTagBlockMon; // gBlockMon -- this is for all blockmons
513 else result := GridTagInvalid;
514 end;
515 end;
518 class function TBinHeapPanelDrawCmp.less (const a, b: TPanel): Boolean; inline;
519 begin
520 if (a.tag < b.tag) then begin result := true; exit; end;
521 if (a.tag > b.tag) then begin result := false; exit; end;
522 result := (a.arrIdx < b.arrIdx);
523 end;
525 procedure dplClear ();
526 begin
527 if (gDrawPanelList = nil) then gDrawPanelList := TBinHeapPanelDraw.Create() else gDrawPanelList.clear();
528 end;
531 var
532 Textures: TLevelTextureArray = nil;
533 TextNameHash: THashStrInt = nil; // key: texture name; value: index in `Textures`
534 BadTextNameHash: THashStrInt = nil; // set; so we won't spam with non-existing texture messages
535 RespawnPoints: array of TRespawnPoint;
536 FlagPoints: array[FLAG_RED..FLAG_BLUE] of PFlagPoint;
537 //DOMFlagPoints: Array of TFlagPoint;
540 procedure g_Map_ProfilersBegin ();
541 begin
542 if (profMapCollision = nil) then profMapCollision := TProfiler.Create('COLSOLID', g_profile_history_size);
543 profMapCollision.mainBegin(g_profile_collision);
544 // create sections
545 if g_profile_collision then
546 begin
547 profMapCollision.sectionBegin('*solids');
548 profMapCollision.sectionEnd();
549 profMapCollision.sectionBegin('liquids');
550 profMapCollision.sectionEnd();
551 end;
552 end;
554 procedure g_Map_ProfilersEnd ();
555 begin
556 if (profMapCollision <> nil) then profMapCollision.mainEnd();
557 end;
560 // wall index in `gWalls` or -1
561 function g_Map_traceToNearestWall (x0, y0, x1, y1: Integer; hitx: PInteger=nil; hity: PInteger=nil): TPanel;
562 var
563 ex, ey: Integer;
564 begin
565 result := mapGrid.traceRay(ex, ey, x0, y0, x1, y1, nil, (GridTagWall or GridTagDoor));
566 if (result <> nil) then
567 begin
568 if (hitx <> nil) then hitx^ := ex;
569 if (hity <> nil) then hity^ := ey;
570 end
571 else
572 begin
573 if (hitx <> nil) then hitx^ := x1;
574 if (hity <> nil) then hity^ := y1;
575 end;
576 end;
578 // returns panel or nil
579 function g_Map_traceToNearest (x0, y0, x1, y1: Integer; tag: Integer; hitx: PInteger=nil; hity: PInteger=nil): TPanel;
580 var
581 ex, ey: Integer;
582 begin
583 result := mapGrid.traceRay(ex, ey, x0, y0, x1, y1, nil, tag);
584 if (result <> nil) then
585 begin
586 if (hitx <> nil) then hitx^ := ex;
587 if (hity <> nil) then hity^ := ey;
588 end
589 else
590 begin
591 if (hitx <> nil) then hitx^ := x1;
592 if (hity <> nil) then hity^ := y1;
593 end;
594 end;
597 function g_Map_HasAnyPanelAtPoint (x, y: Integer; panelType: Word): Boolean;
599 function checker (pan: TPanel; tag: Integer): Boolean;
600 begin
602 if ((tag and (GridTagWall or GridTagDoor)) <> 0) then
603 begin
604 result := pan.Enabled; // stop if wall is enabled
605 exit;
606 end;
609 if ((tag and GridTagLift) <> 0) then
610 begin
611 // stop if the lift of the right type
612 result :=
613 ((WordBool(PanelType and PANEL_LIFTUP) and (pan.LiftType = 0)) or
614 (WordBool(PanelType and PANEL_LIFTDOWN) and (pan.LiftType = 1)) or
615 (WordBool(PanelType and PANEL_LIFTLEFT) and (pan.LiftType = 2)) or
616 (WordBool(PanelType and PANEL_LIFTRIGHT) and (pan.LiftType = 3)));
617 exit;
618 end;
620 result := true; // otherwise, stop anyway, 'cause `forEachAtPoint()` is guaranteed to call this only for correct panels
621 end;
623 var
624 tagmask: Integer = 0;
625 begin
626 result := false;
628 if WordBool(PanelType and (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_OPENDOOR)) then tagmask := tagmask or (GridTagWall or GridTagDoor);
629 if WordBool(PanelType and PANEL_WATER) then tagmask := tagmask or GridTagWater;
630 if WordBool(PanelType and PANEL_ACID1) then tagmask := tagmask or GridTagAcid1;
631 if WordBool(PanelType and PANEL_ACID2) then tagmask := tagmask or GridTagAcid2;
632 if WordBool(PanelType and PANEL_STEP) then tagmask := tagmask or GridTagStep;
633 if WordBool(PanelType and (PANEL_LIFTUP or PANEL_LIFTDOWN or PANEL_LIFTLEFT or PANEL_LIFTRIGHT)) then tagmask := tagmask or GridTagLift;
634 if WordBool(PanelType and PANEL_BLOCKMON) then tagmask := tagmask or GridTagBlockMon;
636 if (tagmask = 0) then exit;// just in case
637 if ((tagmask and GridTagLift) <> 0) then
638 begin
639 // slow
640 result := (mapGrid.forEachAtPoint(x, y, checker, tagmask) <> nil);
641 end
642 else
643 begin
644 // fast
645 result := (mapGrid.forEachAtPoint(x, y, nil, tagmask) <> nil);
646 end;
647 end;
650 function g_Map_PanelAtPoint (x, y: Integer; tagmask: Integer=-1): TPanel;
651 begin
652 result := nil;
653 if (tagmask = 0) then exit;
654 result := mapGrid.forEachAtPoint(x, y, nil, tagmask);
655 end;
658 function g_Map_IsSpecialTexture(Texture: String): Boolean;
659 begin
660 Result := (Texture = TEXTURE_NAME_WATER) or
661 (Texture = TEXTURE_NAME_ACID1) or
662 (Texture = TEXTURE_NAME_ACID2);
663 end;
665 procedure CreateDoorMap();
666 var
667 PanelArray: Array of record
668 X, Y: Integer;
669 Width, Height: Word;
670 Active: Boolean;
671 PanelID: DWORD;
672 end;
673 a, b, c, m, i, len: Integer;
674 ok: Boolean;
675 begin
676 if gWalls = nil then
677 Exit;
679 i := 0;
680 len := 128;
681 SetLength(PanelArray, len);
683 for a := 0 to High(gWalls) do
684 if gWalls[a].Door then
685 begin
686 PanelArray[i].X := gWalls[a].X;
687 PanelArray[i].Y := gWalls[a].Y;
688 PanelArray[i].Width := gWalls[a].Width;
689 PanelArray[i].Height := gWalls[a].Height;
690 PanelArray[i].Active := True;
691 PanelArray[i].PanelID := a;
693 i := i + 1;
694 if i = len then
695 begin
696 len := len + 128;
697 SetLength(PanelArray, len);
698 end;
699 end;
701 // Íåò äâåðåé:
702 if i = 0 then
703 begin
704 PanelArray := nil;
705 Exit;
706 end;
708 SetLength(gDoorMap, 0);
710 g_Game_SetLoadingText(_lc[I_LOAD_DOOR_MAP], i-1, False);
712 for a := 0 to i-1 do
713 if PanelArray[a].Active then
714 begin
715 PanelArray[a].Active := False;
716 m := Length(gDoorMap);
717 SetLength(gDoorMap, m+1);
718 SetLength(gDoorMap[m], 1);
719 gDoorMap[m, 0] := PanelArray[a].PanelID;
720 ok := True;
722 while ok do
723 begin
724 ok := False;
726 for b := 0 to i-1 do
727 if PanelArray[b].Active then
728 for c := 0 to High(gDoorMap[m]) do
729 if {((gRenderWalls[PanelArray[b].RenderPanelID].TextureID = gRenderWalls[gDoorMap[m, c]].TextureID) or
730 gRenderWalls[PanelArray[b].RenderPanelID].Hide or gRenderWalls[gDoorMap[m, c]].Hide) and}
731 g_CollideAround(PanelArray[b].X, PanelArray[b].Y,
732 PanelArray[b].Width, PanelArray[b].Height,
733 gWalls[gDoorMap[m, c]].X,
734 gWalls[gDoorMap[m, c]].Y,
735 gWalls[gDoorMap[m, c]].Width,
736 gWalls[gDoorMap[m, c]].Height) then
737 begin
738 PanelArray[b].Active := False;
739 SetLength(gDoorMap[m],
740 Length(gDoorMap[m])+1);
741 gDoorMap[m, High(gDoorMap[m])] := PanelArray[b].PanelID;
742 ok := True;
743 Break;
744 end;
745 end;
747 g_Game_StepLoading();
748 end;
750 PanelArray := nil;
751 end;
753 procedure CreateLiftMap();
754 var
755 PanelArray: Array of record
756 X, Y: Integer;
757 Width, Height: Word;
758 Active: Boolean;
759 end;
760 a, b, c, len, i, j: Integer;
761 ok: Boolean;
762 begin
763 if gLifts = nil then
764 Exit;
766 len := Length(gLifts);
767 SetLength(PanelArray, len);
769 for a := 0 to len-1 do
770 begin
771 PanelArray[a].X := gLifts[a].X;
772 PanelArray[a].Y := gLifts[a].Y;
773 PanelArray[a].Width := gLifts[a].Width;
774 PanelArray[a].Height := gLifts[a].Height;
775 PanelArray[a].Active := True;
776 end;
778 SetLength(gLiftMap, len);
779 i := 0;
781 g_Game_SetLoadingText(_lc[I_LOAD_LIFT_MAP], len-1, False);
783 for a := 0 to len-1 do
784 if PanelArray[a].Active then
785 begin
786 PanelArray[a].Active := False;
787 SetLength(gLiftMap[i], 32);
788 j := 0;
789 gLiftMap[i, j] := a;
790 ok := True;
792 while ok do
793 begin
794 ok := False;
795 for b := 0 to len-1 do
796 if PanelArray[b].Active then
797 for c := 0 to j do
798 if g_CollideAround(PanelArray[b].X,
799 PanelArray[b].Y,
800 PanelArray[b].Width,
801 PanelArray[b].Height,
802 PanelArray[gLiftMap[i, c]].X,
803 PanelArray[gLiftMap[i, c]].Y,
804 PanelArray[gLiftMap[i, c]].Width,
805 PanelArray[gLiftMap[i, c]].Height) then
806 begin
807 PanelArray[b].Active := False;
808 j := j+1;
809 if j > High(gLiftMap[i]) then
810 SetLength(gLiftMap[i],
811 Length(gLiftMap[i])+32);
813 gLiftMap[i, j] := b;
814 ok := True;
816 Break;
817 end;
818 end;
820 SetLength(gLiftMap[i], j+1);
821 i := i+1;
823 g_Game_StepLoading();
824 end;
826 SetLength(gLiftMap, i);
828 PanelArray := nil;
829 end;
831 function CreatePanel (PanelRec: TDynRecord; AddTextures: TAddTextureArray; CurTex: Integer): Integer;
832 var
833 len: Integer;
834 panels: ^TPanelArray;
835 pan: TPanel;
836 pguid: Integer;
837 begin
838 Result := -1;
840 case PanelRec.PanelType of
841 PANEL_WALL, PANEL_OPENDOOR, PANEL_CLOSEDOOR: panels := @gWalls;
842 PANEL_BACK: panels := @gRenderBackgrounds;
843 PANEL_FORE: panels := @gRenderForegrounds;
844 PANEL_WATER: panels := @gWater;
845 PANEL_ACID1: panels := @gAcid1;
846 PANEL_ACID2: panels := @gAcid2;
847 PANEL_STEP: panels := @gSteps;
848 PANEL_LIFTUP, PANEL_LIFTDOWN, PANEL_LIFTLEFT, PANEL_LIFTRIGHT: panels := @gLifts;
849 PANEL_BLOCKMON: panels := @gBlockMon;
850 else exit;
851 end;
853 len := Length(panels^);
854 SetLength(panels^, len+1);
856 pguid := Length(panByGUID);
857 SetLength(panByGUID, pguid+1); //FIXME!
858 pan := TPanel.Create(PanelRec, AddTextures, CurTex, Textures, pguid);
859 assert(pguid >= 0);
860 assert(pguid < Length(panByGUID));
861 panByGUID[pguid] := pan;
862 panels^[len] := pan;
863 pan.arrIdx := len;
864 pan.proxyId := -1;
865 pan.tag := panelTypeToTag(PanelRec.PanelType);
867 PanelRec.user['panel_guid'] := pguid;
869 //result := len;
870 result := pguid;
871 end;
874 function CreateNullTexture(RecName: String): Integer;
875 begin
876 RecName := toLowerCase1251(RecName);
877 if (TextNameHash = nil) then TextNameHash := THashStrInt.Create();
878 if TextNameHash.get(RecName, result) then exit; // i found her!
880 SetLength(Textures, Length(Textures)+1);
881 result := High(Textures);
883 with Textures[High(Textures)] do
884 begin
885 TextureName := RecName;
886 Width := 1;
887 Height := 1;
888 Anim := False;
889 TextureID := LongWord(TEXTURE_NONE);
890 end;
892 TextNameHash.put(RecName, result);
893 end;
896 function CreateTexture(RecName: AnsiString; Map: string; log: Boolean): Integer;
897 var
898 WAD: TWADFile;
899 TextureData: Pointer;
900 WADName: String;
901 a, ResLength: Integer;
902 begin
903 RecName := toLowerCase1251(RecName);
904 if (TextNameHash = nil) then TextNameHash := THashStrInt.Create();
905 if TextNameHash.get(RecName, result) then
906 begin
907 // i found her!
908 //e_LogWritefln('texture ''%s'' already loaded (%s)', [RecName, result]);
909 exit;
910 end;
912 Result := -1;
914 if (BadTextNameHash <> nil) and BadTextNameHash.has(RecName) then exit; // don't do it again and again
917 if Textures <> nil then
918 begin
919 for a := 0 to High(Textures) do
920 begin
921 if (Textures[a].TextureName = RecName) then
922 begin // Òåêñòóðà ñ òàêèì èìåíåì óæå åñòü
923 e_LogWritefln('texture ''%s'' already loaded', [RecName]);
924 Result := a;
925 Exit;
926 end;
927 end;
928 end;
931 // Òåêñòóðû ñî ñïåöèàëüíûìè èìåíàìè (âîäà, ëàâà, êèñëîòà):
932 if (RecName = TEXTURE_NAME_WATER) or
933 (RecName = TEXTURE_NAME_ACID1) or
934 (RecName = TEXTURE_NAME_ACID2) then
935 begin
936 SetLength(Textures, Length(Textures)+1);
938 with Textures[High(Textures)] do
939 begin
940 TextureName := RecName;
941 if (TextureName = TEXTURE_NAME_WATER) then TextureID := LongWord(TEXTURE_SPECIAL_WATER)
942 else if (TextureName = TEXTURE_NAME_ACID1) then TextureID := LongWord(TEXTURE_SPECIAL_ACID1)
943 else if (TextureName = TEXTURE_NAME_ACID2) then TextureID := LongWord(TEXTURE_SPECIAL_ACID2);
945 Anim := False;
946 end;
948 result := High(Textures);
949 TextNameHash.put(RecName, result);
950 Exit;
951 end;
953 // Çàãðóæàåì ðåñóðñ òåêñòóðû â ïàìÿòü èç WAD'à:
954 WADName := g_ExtractWadName(RecName);
956 WAD := TWADFile.Create();
958 if WADName <> '' then WADName := GameDir+'/wads/'+WADName else WADName := Map;
960 WAD.ReadFile(WADName);
962 //txname := RecName;
964 if (WADName = Map) and WAD.GetResource(g_ExtractFilePathName(RecName), TextureData, ResLength) then
965 begin
966 FreeMem(TextureData);
967 RecName := 'COMMON\ALIEN';
968 end;
971 if WAD.GetResource(g_ExtractFilePathName(RecName), TextureData, ResLength, log) then
972 begin
973 SetLength(Textures, Length(Textures)+1);
974 if not e_CreateTextureMem(TextureData, ResLength, Textures[High(Textures)].TextureID) then
975 begin
976 e_WriteLog(Format('Error loading texture %s', [RecName]), TMsgType.Warning);
977 SetLength(Textures, Length(Textures)-1);
978 result := -1;
979 Exit;
980 end;
981 e_GetTextureSize(Textures[High(Textures)].TextureID, @Textures[High(Textures)].Width, @Textures[High(Textures)].Height);
982 FreeMem(TextureData);
983 Textures[High(Textures)].TextureName := RecName;
984 Textures[High(Textures)].Anim := False;
986 result := High(Textures);
987 TextNameHash.put(RecName, result);
988 end
989 else // Íåò òàêîãî ðåóñðñà â WAD'å
990 begin
991 //e_WriteLog(Format('SHIT! Error loading texture %s : %s', [RecName, g_ExtractFilePathName(RecName)]), MSG_WARNING);
992 if (BadTextNameHash = nil) then BadTextNameHash := THashStrInt.Create();
993 if log and (not BadTextNameHash.get(RecName, a)) then
994 begin
995 e_WriteLog(Format('Error loading texture %s', [RecName]), TMsgType.Warning);
996 //e_WriteLog(Format('WAD Reader error: %s', [WAD.GetLastErrorStr]), MSG_WARNING);
997 end;
998 BadTextNameHash.put(RecName, -1);
999 end;
1001 WAD.Free();
1002 end;
1005 function CreateAnimTexture(RecName: String; Map: string; log: Boolean): Integer;
1006 var
1007 WAD: TWADFile;
1008 TextureWAD: PChar = nil;
1009 TextData: Pointer = nil;
1010 TextureData: Pointer = nil;
1011 cfg: TConfig = nil;
1012 WADName: String;
1013 ResLength: Integer;
1014 TextureResource: String;
1015 _width, _height, _framecount, _speed: Integer;
1016 _backanimation: Boolean;
1017 //imgfmt: string;
1018 ia: TDynImageDataArray = nil;
1019 f, c, frdelay, frloop: Integer;
1020 begin
1021 RecName := toLowerCase1251(RecName);
1022 if (TextNameHash = nil) then TextNameHash := THashStrInt.Create();
1023 if TextNameHash.get(RecName, result) then
1024 begin
1025 // i found her!
1026 //e_LogWritefln('animated texture ''%s'' already loaded (%s)', [RecName, result]);
1027 exit;
1028 end;
1030 result := -1;
1032 //e_LogWritefln('*** Loading animated texture "%s"', [RecName]);
1034 if (BadTextNameHash = nil) then BadTextNameHash := THashStrInt.Create();
1035 if BadTextNameHash.get(RecName, f) then
1036 begin
1037 //e_WriteLog(Format('no animation texture %s (don''t worry)', [RecName]), MSG_NOTIFY);
1038 exit;
1039 end;
1041 // ×èòàåì WAD-ðåñóðñ àíèì.òåêñòóðû èç WAD'à â ïàìÿòü:
1042 WADName := g_ExtractWadName(RecName);
1044 WAD := TWADFile.Create();
1045 try
1046 if WADName <> '' then WADName := GameDir+'/wads/'+WADName else WADName := Map;
1048 WAD.ReadFile(WADName);
1050 if not WAD.GetResource(g_ExtractFilePathName(RecName), TextureWAD, ResLength, log) then
1051 begin
1052 if (BadTextNameHash = nil) then BadTextNameHash := THashStrInt.Create();
1053 if log and (not BadTextNameHash.get(RecName, f)) then
1054 begin
1055 e_WriteLog(Format('Error loading animation texture %s', [RecName]), TMsgType.Warning);
1056 //e_WriteLog(Format('WAD Reader error: %s', [WAD.GetLastErrorStr]), MSG_WARNING);
1057 end;
1058 BadTextNameHash.put(RecName, -1);
1059 exit;
1060 end;
1062 {TEST
1063 if WADName = Map then
1064 begin
1065 //FreeMem(TextureWAD);
1066 if not WAD.GetResource('COMMON/animation', TextureWAD, ResLength) then Halt(1);
1067 end;
1070 WAD.FreeWAD();
1072 if ResLength < 6 then
1073 begin
1074 e_WriteLog(Format('Animated texture file "%s" too short', [RecName]), TMsgType.Warning);
1075 BadTextNameHash.put(RecName, -1);
1076 exit;
1077 end;
1079 // ýòî ïòèöà? ýòî ñàìîë¸ò?
1080 if (TextureWAD[0] = 'D') and (TextureWAD[1] = 'F') and
1081 (TextureWAD[2] = 'W') and (TextureWAD[3] = 'A') and (TextureWAD[4] = 'D') then
1082 begin
1083 // íåò, ýòî ñóïåðìåí!
1084 if not WAD.ReadMemory(TextureWAD, ResLength) then
1085 begin
1086 e_WriteLog(Format('Animated texture WAD file "%s" is invalid', [RecName]), TMsgType.Warning);
1087 BadTextNameHash.put(RecName, -1);
1088 exit;
1089 end;
1091 // ×èòàåì INI-ðåñóðñ àíèì. òåêñòóðû è çàïîìèíàåì åãî óñòàíîâêè:
1092 if not WAD.GetResource('TEXT/ANIM', TextData, ResLength) then
1093 begin
1094 e_WriteLog(Format('Animated texture file "%s" has invalid INI', [RecName]), TMsgType.Warning);
1095 BadTextNameHash.put(RecName, -1);
1096 exit;
1097 end;
1099 cfg := TConfig.CreateMem(TextData, ResLength);
1101 TextureResource := cfg.ReadStr('', 'resource', '');
1102 if TextureResource = '' then
1103 begin
1104 e_WriteLog(Format('Animated texture WAD file "%s" has no "resource"', [RecName]), TMsgType.Warning);
1105 BadTextNameHash.put(RecName, -1);
1106 exit;
1107 end;
1109 _width := cfg.ReadInt('', 'framewidth', 0);
1110 _height := cfg.ReadInt('', 'frameheight', 0);
1111 _framecount := cfg.ReadInt('', 'framecount', 0);
1112 _speed := cfg.ReadInt('', 'waitcount', 0);
1113 _backanimation := cfg.ReadBool('', 'backanimation', False);
1115 cfg.Free();
1116 cfg := nil;
1118 // ×èòàåì ðåñóðñ òåêñòóð (êàäðîâ) àíèì. òåêñòóðû â ïàìÿòü:
1119 if not WAD.GetResource('TEXTURES/'+TextureResource, TextureData, ResLength) then
1120 begin
1121 e_WriteLog(Format('Animated texture WAD file "%s" has no texture "%s"', [RecName, 'TEXTURES/'+TextureResource]), TMsgType.Warning);
1122 BadTextNameHash.put(RecName, -1);
1123 exit;
1124 end;
1126 WAD.Free();
1127 WAD := nil;
1129 SetLength(Textures, Length(Textures)+1);
1130 with Textures[High(Textures)] do
1131 begin
1132 // Ñîçäàåì êàäðû àíèì. òåêñòóðû èç ïàìÿòè:
1133 if g_Frames_CreateMemory(@FramesID, '', TextureData, ResLength, _width, _height, _framecount, _backanimation) then
1134 begin
1135 TextureName := RecName;
1136 Width := _width;
1137 Height := _height;
1138 Anim := True;
1139 FramesCount := _framecount;
1140 Speed := _speed;
1141 result := High(Textures);
1142 TextNameHash.put(RecName, result);
1143 end
1144 else
1145 begin
1146 if (BadTextNameHash = nil) then BadTextNameHash := THashStrInt.Create();
1147 if log and (not BadTextNameHash.get(RecName, f)) then
1148 begin
1149 e_WriteLog(Format('Error loading animation texture %s', [RecName]), TMsgType.Warning);
1150 end;
1151 BadTextNameHash.put(RecName, -1);
1152 end;
1153 end;
1154 end
1155 else
1156 begin
1157 // try animated image
1159 imgfmt := DetermineMemoryFormat(TextureWAD, ResLength);
1160 if length(imgfmt) = 0 then
1161 begin
1162 e_WriteLog(Format('Animated texture file "%s" has unknown format', [RecName]), MSG_WARNING);
1163 exit;
1164 end;
1166 GlobalMetadata.ClearMetaItems();
1167 GlobalMetadata.ClearMetaItemsForSaving();
1168 if not LoadMultiImageFromMemory(TextureWAD, ResLength, ia) then
1169 begin
1170 e_WriteLog(Format('Animated texture file "%s" cannot be loaded', [RecName]), TMsgType.Warning);
1171 BadTextNameHash.put(RecName, -1);
1172 exit;
1173 end;
1174 if length(ia) = 0 then
1175 begin
1176 e_WriteLog(Format('Animated texture file "%s" has no frames', [RecName]), TMsgType.Warning);
1177 BadTextNameHash.put(RecName, -1);
1178 exit;
1179 end;
1181 WAD.Free();
1182 WAD := nil;
1184 _width := ia[0].width;
1185 _height := ia[0].height;
1186 _framecount := length(ia);
1187 _speed := 1;
1188 _backanimation := false;
1189 frdelay := -1;
1190 frloop := -666;
1191 if GlobalMetadata.HasMetaItem(SMetaFrameDelay) then
1192 begin
1193 //writeln(' frame delay: ', GlobalMetadata.MetaItems[SMetaFrameDelay]);
1194 try
1195 f := GlobalMetadata.MetaItems[SMetaFrameDelay];
1196 frdelay := f;
1197 if f < 0 then f := 0;
1198 // rounding ;-)
1199 c := f mod 28;
1200 if c < 13 then c := 0 else c := 1;
1201 f := (f div 28)+c;
1202 if f < 1 then f := 1 else if f > 255 then f := 255;
1203 _speed := f;
1204 except
1205 end;
1206 end;
1207 if GlobalMetadata.HasMetaItem(SMetaAnimationLoops) then
1208 begin
1209 //writeln(' frame loop : ', GlobalMetadata.MetaItems[SMetaAnimationLoops]);
1210 try
1211 f := GlobalMetadata.MetaItems[SMetaAnimationLoops];
1212 frloop := f;
1213 if f <> 0 then _backanimation := true; // non-infinite looping == forth-and-back
1214 except
1215 end;
1216 end;
1217 //writeln(' creating animated texture with ', length(ia), ' frames (delay:', _speed, '; backloop:', _backanimation, ') from "', RecName, '"...');
1218 //for f := 0 to high(ia) do writeln(' frame #', f, ': ', ia[f].width, 'x', ia[f].height);
1219 f := ord(_backanimation);
1220 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);
1222 SetLength(Textures, Length(Textures)+1);
1223 // cîçäàåì êàäðû àíèì. òåêñòóðû èç êàðòèíîê
1224 if g_CreateFramesImg(ia, @Textures[High(Textures)].FramesID, '', _backanimation) then
1225 begin
1226 Textures[High(Textures)].TextureName := RecName;
1227 Textures[High(Textures)].Width := _width;
1228 Textures[High(Textures)].Height := _height;
1229 Textures[High(Textures)].Anim := True;
1230 Textures[High(Textures)].FramesCount := length(ia);
1231 Textures[High(Textures)].Speed := _speed;
1232 result := High(Textures);
1233 TextNameHash.put(RecName, result);
1234 //writeln(' CREATED!');
1235 end
1236 else
1237 begin
1238 if (BadTextNameHash = nil) then BadTextNameHash := THashStrInt.Create();
1239 if log and (not BadTextNameHash.get(RecName, f)) then
1240 begin
1241 e_WriteLog(Format('Error loading animation texture "%s" images', [RecName]), TMsgType.Warning);
1242 end;
1243 BadTextNameHash.put(RecName, -1);
1244 end;
1245 end;
1246 finally
1247 for f := 0 to High(ia) do FreeImage(ia[f]);
1248 WAD.Free();
1249 cfg.Free();
1250 if (TextureWAD <> nil) then FreeMem(TextureWAD);
1251 if (TextData <> nil) then FreeMem(TextData);
1252 if (TextureData <> nil) then FreeMem(TextureData);
1253 end;
1254 end;
1256 procedure CreateItem(Item: TDynRecord);
1257 begin
1258 if g_Game_IsClient then Exit;
1260 if (not (gGameSettings.GameMode in [GM_DM, GM_TDM, GM_CTF])) and
1261 ByteBool(Item.Options and ITEM_OPTION_ONLYDM) then
1262 Exit;
1264 g_Items_Create(Item.X, Item.Y, Item.ItemType, ByteBool(Item.Options and ITEM_OPTION_FALL),
1265 gGameSettings.GameMode in [GM_DM, GM_TDM, GM_CTF, GM_COOP]);
1266 end;
1268 procedure CreateArea(Area: TDynRecord);
1269 var
1270 a: Integer;
1271 id: DWORD = 0;
1272 begin
1273 case Area.AreaType of
1274 AREA_DMPOINT, AREA_PLAYERPOINT1, AREA_PLAYERPOINT2,
1275 AREA_REDTEAMPOINT, AREA_BLUETEAMPOINT:
1276 begin
1277 SetLength(RespawnPoints, Length(RespawnPoints)+1);
1278 with RespawnPoints[High(RespawnPoints)] do
1279 begin
1280 X := Area.X;
1281 Y := Area.Y;
1282 Direction := TDirection(Area.Direction);
1284 case Area.AreaType of
1285 AREA_DMPOINT: PointType := RESPAWNPOINT_DM;
1286 AREA_PLAYERPOINT1: PointType := RESPAWNPOINT_PLAYER1;
1287 AREA_PLAYERPOINT2: PointType := RESPAWNPOINT_PLAYER2;
1288 AREA_REDTEAMPOINT: PointType := RESPAWNPOINT_RED;
1289 AREA_BLUETEAMPOINT: PointType := RESPAWNPOINT_BLUE;
1290 end;
1291 end;
1292 end;
1294 AREA_REDFLAG, AREA_BLUEFLAG:
1295 begin
1296 if Area.AreaType = AREA_REDFLAG then a := FLAG_RED else a := FLAG_BLUE;
1298 if FlagPoints[a] <> nil then Exit;
1300 New(FlagPoints[a]);
1302 with FlagPoints[a]^ do
1303 begin
1304 X := Area.X-FLAGRECT.X;
1305 Y := Area.Y-FLAGRECT.Y;
1306 Direction := TDirection(Area.Direction);
1307 end;
1309 with gFlags[a] do
1310 begin
1311 case a of
1312 FLAG_RED: g_Frames_Get(id, 'FRAMES_FLAG_RED');
1313 FLAG_BLUE: g_Frames_Get(id, 'FRAMES_FLAG_BLUE');
1314 end;
1316 Animation := TAnimation.Create(id, True, 8);
1317 Obj.Rect := FLAGRECT;
1319 g_Map_ResetFlag(a);
1320 end;
1321 end;
1323 AREA_DOMFLAG:
1324 begin
1325 {SetLength(DOMFlagPoints, Length(DOMFlagPoints)+1);
1326 with DOMFlagPoints[High(DOMFlagPoints)] do
1327 begin
1328 X := Area.X;
1329 Y := Area.Y;
1330 Direction := TDirection(Area.Direction);
1331 end;
1333 g_Map_CreateFlag(DOMFlagPoints[High(DOMFlagPoints)], FLAG_DOM, FLAG_STATE_NORMAL);}
1334 end;
1335 end;
1336 end;
1338 function CreateTrigger (amapIdx: Integer; Trigger: TDynRecord; atpanid, atrigpanid: Integer): Integer;
1339 var
1340 _trigger: TTrigger;
1341 begin
1342 result := -1;
1343 if g_Game_IsClient and not (Trigger.TriggerType in [TRIGGER_SOUND, TRIGGER_MUSIC]) then Exit;
1345 with _trigger do
1346 begin
1347 mapId := Trigger.id;
1348 mapIndex := amapIdx;
1349 X := Trigger.X;
1350 Y := Trigger.Y;
1351 Width := Trigger.Width;
1352 Height := Trigger.Height;
1353 Enabled := Trigger.Enabled;
1354 TexturePanelGUID := atpanid;
1355 TriggerType := Trigger.TriggerType;
1356 ActivateType := Trigger.ActivateType;
1357 Keys := Trigger.Keys;
1358 trigPanelGUID := atrigpanid;
1359 end;
1361 result := Integer(g_Triggers_Create(_trigger, Trigger));
1362 end;
1364 procedure CreateMonster(monster: TDynRecord);
1365 var
1366 a: Integer;
1367 mon: TMonster;
1368 begin
1369 if g_Game_IsClient then Exit;
1371 if (gGameSettings.GameType = GT_SINGLE)
1372 or LongBool(gGameSettings.Options and GAME_OPTION_MONSTERS) then
1373 begin
1374 mon := g_Monsters_Create(monster.MonsterType, monster.X, monster.Y, TDirection(monster.Direction));
1376 if gTriggers <> nil then
1377 begin
1378 for a := 0 to High(gTriggers) do
1379 begin
1380 if gTriggers[a].TriggerType in [TRIGGER_PRESS, TRIGGER_ON, TRIGGER_OFF, TRIGGER_ONOFF] then
1381 begin
1382 //if (gTriggers[a].Data.MonsterID-1) = Integer(mon.StartID) then mon.AddTrigger(a);
1383 if (gTriggers[a].trigDataRec.trigMonsterId) = Integer(mon.StartID) then mon.AddTrigger(a);
1384 end;
1385 end;
1386 end;
1388 if monster.MonsterType <> MONSTER_BARREL then Inc(gTotalMonsters);
1389 end;
1390 end;
1392 procedure g_Map_ReAdd_DieTriggers();
1394 function monsDieTrig (mon: TMonster): Boolean;
1395 var
1396 a: Integer;
1397 //tw: TStrTextWriter;
1398 begin
1399 result := false; // don't stop
1400 mon.ClearTriggers();
1401 for a := 0 to High(gTriggers) do
1402 begin
1403 if gTriggers[a].TriggerType in [TRIGGER_PRESS, TRIGGER_ON, TRIGGER_OFF, TRIGGER_ONOFF] then
1404 begin
1405 //if (gTriggers[a].Data.MonsterID-1) = Integer(mon.StartID) then mon.AddTrigger(a);
1407 tw := TStrTextWriter.Create();
1408 try
1409 gTriggers[a].trigData.writeTo(tw);
1410 e_LogWritefln('=== trigger #%s ==='#10'%s'#10'---', [a, tw.str]);
1411 finally
1412 tw.Free();
1413 end;
1415 if (gTriggers[a].trigDataRec.trigMonsterId) = Integer(mon.StartID) then mon.AddTrigger(a);
1416 end;
1417 end;
1418 end;
1420 begin
1421 if g_Game_IsClient then Exit;
1423 g_Mons_ForEach(monsDieTrig);
1424 end;
1426 function extractWadName(resourceName: string): string;
1427 var
1428 posN: Integer;
1429 begin
1430 posN := Pos(':', resourceName);
1431 if posN > 0 then
1432 Result:= Copy(resourceName, 0, posN-1)
1433 else
1434 Result := '';
1435 end;
1437 procedure addResToExternalResList(res: string);
1438 begin
1439 res := extractWadName(res);
1440 if (res <> '') and (gExternalResources.IndexOf(res) = -1) then
1441 gExternalResources.Add(res);
1442 end;
1444 procedure generateExternalResourcesList({mapReader: TMapReader_1}map: TDynRecord);
1445 //var
1446 //textures: TTexturesRec1Array;
1447 //textures: TDynField;
1448 //trec: TDynRecord;
1449 //mapHeader: TMapHeaderRec_1;
1450 //i: integer;
1451 //resFile: String = '';
1452 begin
1453 if gExternalResources = nil then
1454 gExternalResources := TStringList.Create;
1456 gExternalResources.Clear;
1458 (*
1460 textures := GetTextures(map);
1461 for i := 0 to High(textures) do
1462 begin
1463 addResToExternalResList(resFile);
1464 end;
1467 textures := map['texture'];
1468 if (textures <> nil) then
1469 begin
1470 for trec in textures do
1471 begin
1472 addResToExternalResList(resFile);
1473 end;
1474 end;
1476 textures := nil;
1477 *)
1479 //mapHeader := GetMapHeader(map);
1481 addResToExternalResList(map.MusicName);
1482 addResToExternalResList(map.SkyName);
1483 end;
1486 procedure mapCreateGrid ();
1487 var
1488 mapX0: Integer = $3fffffff;
1489 mapY0: Integer = $3fffffff;
1490 mapX1: Integer = -$3fffffff;
1491 mapY1: Integer = -$3fffffff;
1493 procedure calcBoundingBox (constref panels: TPanelArray);
1494 var
1495 idx: Integer;
1496 pan: TPanel;
1497 begin
1498 for idx := 0 to High(panels) do
1499 begin
1500 pan := panels[idx];
1501 if not pan.visvalid then continue;
1502 if (pan.Width < 1) or (pan.Height < 1) then continue;
1503 if (mapX0 > pan.x0) then mapX0 := pan.x0;
1504 if (mapY0 > pan.y0) then mapY0 := pan.y0;
1505 if (mapX1 < pan.x1) then mapX1 := pan.x1;
1506 if (mapY1 < pan.y1) then mapY1 := pan.y1;
1507 end;
1508 end;
1510 procedure addPanelsToGrid (constref panels: TPanelArray);
1511 var
1512 idx: Integer;
1513 pan: TPanel;
1514 newtag: Integer;
1515 begin
1516 //tag := panelTypeToTag(tag);
1517 for idx := 0 to High(panels) do
1518 begin
1519 pan := panels[idx];
1520 if not pan.visvalid then continue;
1521 if (pan.proxyId <> -1) then
1522 begin
1523 {$IF DEFINED(D2F_DEBUG)}
1524 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);
1525 {$ENDIF}
1526 continue;
1527 end;
1528 case pan.PanelType of
1529 PANEL_WALL: newtag := GridTagWall;
1530 PANEL_OPENDOOR, PANEL_CLOSEDOOR: newtag := GridTagDoor;
1531 PANEL_BACK: newtag := GridTagBack;
1532 PANEL_FORE: newtag := GridTagFore;
1533 PANEL_WATER: newtag := GridTagWater;
1534 PANEL_ACID1: newtag := GridTagAcid1;
1535 PANEL_ACID2: newtag := GridTagAcid2;
1536 PANEL_STEP: newtag := GridTagStep;
1537 PANEL_LIFTUP, PANEL_LIFTDOWN, PANEL_LIFTLEFT, PANEL_LIFTRIGHT: newtag := GridTagLift;
1538 PANEL_BLOCKMON: newtag := GridTagBlockMon;
1539 else continue; // oops
1540 end;
1541 pan.tag := newtag;
1543 pan.proxyId := mapGrid.insertBody(pan, pan.X, pan.Y, pan.Width, pan.Height, newtag);
1544 // "enabled" flag has meaning only for doors and walls (engine assumes it); but meh...
1545 mapGrid.proxyEnabled[pan.proxyId] := pan.Enabled;
1546 {$IFDEF MAP_DEBUG_ENABLED_FLAG}
1548 if ((tag and (GridTagWall or GridTagDoor)) <> 0) then
1549 begin
1550 e_WriteLog(Format('INSERTED wall #%d(%d) enabled (%d)', [Integer(idx), Integer(pan.proxyId), Integer(mapGrid.proxyEnabled[pan.proxyId])]), MSG_NOTIFY);
1551 end;
1553 {$ENDIF}
1554 end;
1555 end;
1557 begin
1558 mapGrid.Free();
1559 mapGrid := nil;
1561 calcBoundingBox(gWalls);
1562 calcBoundingBox(gRenderBackgrounds);
1563 calcBoundingBox(gRenderForegrounds);
1564 calcBoundingBox(gWater);
1565 calcBoundingBox(gAcid1);
1566 calcBoundingBox(gAcid2);
1567 calcBoundingBox(gSteps);
1568 calcBoundingBox(gLifts);
1569 calcBoundingBox(gBlockMon);
1571 e_LogWritefln('map dimensions: (%d,%d)-(%d,%d); editor size:(0,0)-(%d,%d)', [mapX0, mapY0, mapX1, mapY1, gMapInfo.Width, gMapInfo.Height]);
1573 if (mapX0 > 0) then mapX0 := 0;
1574 if (mapY0 > 0) then mapY0 := 0;
1576 if (mapX1 < gMapInfo.Width-1) then mapX1 := gMapInfo.Width-1;
1577 if (mapY1 < gMapInfo.Height-1) then mapY1 := gMapInfo.Height-1;
1579 mapGrid := TPanelGrid.Create(mapX0-128, mapY0-128, mapX1-mapX0+1+128*2, mapY1-mapY0+1+128*2);
1580 //mapGrid := TPanelGrid.Create(0, 0, gMapInfo.Width, gMapInfo.Height);
1582 addPanelsToGrid(gWalls);
1583 addPanelsToGrid(gRenderBackgrounds);
1584 addPanelsToGrid(gRenderForegrounds);
1585 addPanelsToGrid(gWater);
1586 addPanelsToGrid(gAcid1);
1587 addPanelsToGrid(gAcid2);
1588 addPanelsToGrid(gSteps);
1589 addPanelsToGrid(gLifts); // it doesn't matter which LIFT type is used here
1590 addPanelsToGrid(gBlockMon);
1592 mapGrid.dumpStats();
1594 g_Mons_InitTree(mapGrid.gridX0, mapGrid.gridY0, mapGrid.gridWidth, mapGrid.gridHeight);
1595 end;
1598 function g_Map_Load(Res: String): Boolean;
1599 const
1600 DefaultMusRes = 'Standart.wad:STDMUS\MUS1';
1601 DefaultSkyRes = 'Standart.wad:STDSKY\SKY0';
1602 type
1603 PTRec = ^TTRec;
1604 TTRec = record
1605 //TexturePanel: Integer;
1606 tnum: Integer;
1607 id: Integer;
1608 trigrec: TDynRecord;
1609 // texture pane;
1610 texPanelIdx: Integer;
1611 texPanel: TDynRecord;
1612 // "action" panel
1613 actPanelIdx: Integer;
1614 actPanel: TDynRecord;
1615 end;
1616 var
1617 WAD, TestWAD: TWADFile;
1618 //mapReader: TDynRecord = nil;
1619 mapTextureList: TDynField = nil; //TTexturesRec1Array; tagInt: texture index
1620 panels: TDynField = nil; //TPanelsRec1Array;
1621 items: TDynField = nil; //TItemsRec1Array;
1622 monsters: TDynField = nil; //TMonsterRec1Array;
1623 areas: TDynField = nil; //TAreasRec1Array;
1624 triggers: TDynField = nil; //TTriggersRec1Array;
1625 b, c, k: Integer;
1626 PanelID: DWORD;
1627 AddTextures: TAddTextureArray;
1628 TriggersTable: array of TTRec;
1629 FileName, mapResName, TexName, s: AnsiString;
1630 Data: Pointer;
1631 Len: Integer;
1632 ok, isAnim: Boolean;
1633 CurTex, ntn: Integer;
1634 rec, texrec: TDynRecord;
1635 pttit: PTRec;
1636 pannum, trignum, cnt, tgpid: Integer;
1637 stt: UInt64;
1638 moveSpeed{, moveStart, moveEnd}: TDFPoint;
1639 //moveActive: Boolean;
1640 pan: TPanel;
1641 mapOk: Boolean = false;
1642 usedTextures: THashStrInt = nil; // key: mapTextureList
1643 begin
1644 mapGrid.Free();
1645 mapGrid := nil;
1646 TestWAD := nil;
1647 Data := nil;
1649 //gCurrentMap.Free();
1650 //gCurrentMap := nil;
1652 panByGUID := nil;
1654 Result := False;
1655 gMapInfo.Map := Res;
1656 TriggersTable := nil;
1657 //mapReader := nil;
1659 sfsGCDisable(); // temporary disable removing of temporary volumes
1660 try
1661 // Çàãðóçêà WAD (åñëè ó íàñ íåò óæå çàãðóæåíîé êàðòû)
1662 if (gCurrentMap = nil) then
1663 begin
1664 FileName := g_ExtractWadName(Res);
1665 e_WriteLog('Loading map WAD: '+FileName, TMsgType.Notify);
1666 g_Game_SetLoadingText(_lc[I_LOAD_WAD_FILE], 0, False);
1668 WAD := TWADFile.Create();
1669 if not WAD.ReadFile(FileName) then
1670 begin
1671 g_FatalError(Format(_lc[I_GAME_ERROR_MAP_WAD], [FileName]));
1672 WAD.Free();
1673 Exit;
1674 end;
1676 if gTestMap <> '' then
1677 begin
1678 s := g_ExtractWadName(gTestMap);
1679 TestWAD := TWADFile.Create();
1680 if not TestWAD.ReadFile(s) then
1681 begin
1682 g_SimpleError(Format(_lc[I_GAME_ERROR_MAP_WAD], [s]));
1683 TestWAD.Free();
1684 TestWAD := nil;
1685 end;
1686 end;
1688 if TestWAD <> nil then
1689 begin
1690 mapResName := g_ExtractFileName(gTestMap);
1691 if not TestWAD.GetMapResource(mapResName, Data, Len) then
1692 begin
1693 g_SimpleError(Format(_lc[I_GAME_ERROR_MAP_RES], [mapResName]));
1694 Data := nil;
1695 end else
1696 e_WriteLog('Using test map: '+gTestMap, TMsgType.Notify);
1697 TestWAD.Free();
1698 TestWAD := nil;
1699 end;
1701 if Data = nil then
1702 begin
1703 //k8: why loader ignores path here?
1704 mapResName := g_ExtractFileName(Res);
1705 if not WAD.GetMapResource(mapResName, Data, Len) then
1706 begin
1707 g_FatalError(Format(_lc[I_GAME_ERROR_MAP_RES], [mapResName]));
1708 WAD.Free();
1709 Exit;
1710 end;
1711 end;
1713 WAD.Free();
1715 if (Len < 4) then
1716 begin
1717 e_LogWritefln('invalid map file: ''%s''', [mapResName]);
1718 FreeMem(Data);
1719 exit;
1720 end;
1722 // Çàãðóçêà êàðòû:
1723 e_LogWritefln('Loading map: %s', [mapResName], TMsgType.Notify);
1724 g_Game_SetLoadingText(_lc[I_LOAD_MAP], 0, False);
1726 stt := getTimeMicro();
1728 try
1729 gCurrentMap := g_Map_ParseMap(Data, Len);
1730 except
1731 gCurrentMap.Free();
1732 g_FatalError(Format(_lc[I_GAME_ERROR_MAP_LOAD], [Res]));
1733 FreeMem(Data);
1734 gCurrentMapFileName := '';
1735 Exit;
1736 end;
1738 FreeMem(Data);
1740 if (gCurrentMap = nil) then
1741 begin
1742 e_LogWritefln('invalid map file: ''%s''', [mapResName]);
1743 gCurrentMapFileName := '';
1744 exit;
1745 end;
1746 end
1747 else
1748 begin
1749 stt := getTimeMicro();
1750 end;
1752 //gCurrentMap := mapReader;
1754 generateExternalResourcesList(gCurrentMap);
1755 mapTextureList := gCurrentMap['texture'];
1756 // get all other lists here too
1757 panels := gCurrentMap['panel'];
1758 triggers := gCurrentMap['trigger'];
1759 items := gCurrentMap['item'];
1760 areas := gCurrentMap['area'];
1761 monsters := gCurrentMap['monster'];
1763 // Çàãðóçêà îïèñàíèÿ êàðòû:
1764 e_WriteLog(' Reading map info...', TMsgType.Notify);
1765 g_Game_SetLoadingText(_lc[I_LOAD_MAP_HEADER], 0, False);
1767 with gMapInfo do
1768 begin
1769 Name := gCurrentMap.MapName;
1770 Description := gCurrentMap.MapDesc;
1771 Author := gCurrentMap.MapAuthor;
1772 MusicName := gCurrentMap.MusicName;
1773 SkyName := gCurrentMap.SkyName;
1774 Height := gCurrentMap.Height;
1775 Width := gCurrentMap.Width;
1776 end;
1778 // Çàãðóçêà òåêñòóð:
1779 g_Game_SetLoadingText(_lc[I_LOAD_TEXTURES], 0, False);
1780 // Äîáàâëåíèå òåêñòóð â Textures[]:
1781 if (mapTextureList <> nil) and (mapTextureList.count > 0) then
1782 begin
1783 e_WriteLog(' Loading textures:', TMsgType.Notify);
1784 g_Game_SetLoadingText(_lc[I_LOAD_TEXTURES], mapTextureList.count-1, False);
1786 // find used textures
1787 usedTextures := THashStrInt.Create();
1788 try
1789 if (panels <> nil) and (panels.count > 0) then
1790 begin
1791 for rec in panels do
1792 begin
1793 texrec := rec.TextureRec;
1794 if (texrec <> nil) then usedTextures.put(toLowerCase1251(texrec.Resource), 42);
1795 end;
1796 end;
1798 cnt := -1;
1799 for rec in mapTextureList do
1800 begin
1801 Inc(cnt);
1802 if not usedTextures.has(toLowerCase1251(rec.Resource)) then
1803 begin
1804 rec.tagInt := -1; // just in case
1805 e_LogWritefln(' Unused texture #%d: %s', [cnt, rec.Resource]);
1806 end
1807 else
1808 begin
1809 {$IF DEFINED(D2F_DEBUG_TXLOAD)}
1810 e_LogWritefln(' Loading texture #%d: %s', [cnt, rec.Resource]);
1811 {$ENDIF}
1812 //if g_Map_IsSpecialTexture(s) then e_WriteLog(' SPECIAL!', MSG_NOTIFY);
1813 if rec.Anim then
1814 begin
1815 // Àíèìèðîâàííàÿ òåêñòóðà
1816 ntn := CreateAnimTexture(rec.Resource, FileName, True);
1817 if (ntn < 0) then g_SimpleError(Format(_lc[I_GAME_ERROR_TEXTURE_ANIM], [rec.Resource]));
1818 end
1819 else
1820 begin
1821 // Îáû÷íàÿ òåêñòóðà
1822 ntn := CreateTexture(rec.Resource, FileName, True);
1823 if (ntn < 0) then g_SimpleError(Format(_lc[I_GAME_ERROR_TEXTURE_SIMPLE], [rec.Resource]));
1824 end;
1825 if (ntn < 0) then ntn := CreateNullTexture(rec.Resource);
1827 rec.tagInt := ntn; // remember texture number
1828 end;
1829 g_Game_StepLoading();
1830 end;
1831 finally
1832 usedTextures.Free();
1833 end;
1835 // set panel tagInt to texture index
1836 if (panels <> nil) then
1837 begin
1838 for rec in panels do
1839 begin
1840 texrec := rec.TextureRec;
1841 if (texrec = nil) then rec.tagInt := -1 else rec.tagInt := texrec.tagInt;
1842 end;
1843 end;
1844 end;
1847 // Çàãðóçêà òðèããåðîâ
1848 gTriggerClientID := 0;
1849 e_WriteLog(' Loading triggers...', TMsgType.Notify);
1850 g_Game_SetLoadingText(_lc[I_LOAD_TRIGGERS], 0, False);
1852 // Çàãðóçêà ïàíåëåé
1853 e_WriteLog(' Loading panels...', TMsgType.Notify);
1854 g_Game_SetLoadingText(_lc[I_LOAD_PANELS], 0, False);
1856 // check texture numbers for panels
1857 if (panels <> nil) and (panels.count > 0) then
1858 begin
1859 for rec in panels do
1860 begin
1861 if (rec.tagInt < 0) then
1862 begin
1863 e_WriteLog('error loading map: invalid texture index for panel', TMsgType.Fatal);
1864 result := false;
1865 gCurrentMap.Free();
1866 gCurrentMap := nil;
1867 gCurrentMapFileName := '';
1868 exit;
1869 end;
1870 end;
1871 end;
1873 // Ñîçäàíèå òàáëèöû òðèããåðîâ (ñîîòâåòñòâèå ïàíåëåé òðèããåðàì)
1874 if (triggers <> nil) and (triggers.count > 0) then
1875 begin
1876 e_WriteLog(' Setting up trigger table...', TMsgType.Notify);
1877 //SetLength(TriggersTable, triggers.count);
1878 g_Game_SetLoadingText(_lc[I_LOAD_TRIGGERS_TABLE], triggers.count-1, False);
1880 SetLength(TriggersTable, triggers.count);
1881 trignum := -1;
1882 for rec in triggers do
1883 begin
1884 Inc(trignum);
1885 pttit := @TriggersTable[trignum];
1886 pttit.trigrec := rec;
1887 // Ñìåíà òåêñòóðû (âîçìîæíî, êíîïêè)
1888 pttit.texPanelIdx := -1; // will be fixed later
1889 pttit.texPanel := rec.TexturePanelRec;
1890 // action panel
1891 pttit.actPanelIdx := -1;
1892 if (rec.trigRec <> nil) then pttit.actPanel := rec.trigRec.tgPanelRec else pttit.actPanel := nil;
1893 // set flag
1894 if (pttit.texPanel <> nil) then pttit.texPanel.userPanelTrigRef := true;
1895 if (pttit.actPanel <> nil) then pttit.actPanel.userPanelTrigRef := true;
1896 // update progress
1897 g_Game_StepLoading();
1898 end;
1899 end;
1901 // Ñîçäàåì ïàíåëè
1902 if (panels <> nil) and (panels.count > 0) then
1903 begin
1904 e_WriteLog(' Setting up trigger links...', TMsgType.Notify);
1905 g_Game_SetLoadingText(_lc[I_LOAD_LINK_TRIGGERS], panels.count-1, False);
1907 pannum := -1;
1908 for rec in panels do
1909 begin
1910 Inc(pannum);
1911 //e_LogWritefln('PANSTART: pannum=%s', [pannum]);
1912 texrec := nil;
1913 SetLength(AddTextures, 0);
1914 CurTex := -1;
1915 ok := false;
1917 if (mapTextureList <> nil) then
1918 begin
1919 texrec := rec.TextureRec;
1920 ok := (texrec <> nil);
1921 end;
1923 if ok then
1924 begin
1925 // Ñìîòðèì, ññûëàþòñÿ ëè íà ýòó ïàíåëü òðèããåðû.
1926 // Åñëè äà - òî íàäî ñîçäàòü åùå òåêñòóð
1927 ok := false;
1928 if (TriggersTable <> nil) and (mapTextureList <> nil) then
1929 begin
1930 if rec.userPanelTrigRef then
1931 begin
1932 // e_LogWritefln('trigref for panel %s', [pannum]);
1933 ok := True;
1934 end;
1935 end;
1936 end;
1938 if ok then
1939 begin
1940 // Åñòü ññûëêè òðèããåðîâ íà ýòó ïàíåëü
1941 s := texrec.Resource;
1943 // Ñïåö-òåêñòóðû çàïðåùåíû
1944 if g_Map_IsSpecialTexture(s) then
1945 begin
1946 ok := false
1947 end
1948 else
1949 begin
1950 // Îïðåäåëÿåì íàëè÷èå è ïîëîæåíèå öèôð â êîíöå ñòðîêè
1951 ok := g_Texture_NumNameFindStart(s);
1952 end;
1954 // Åñëè ok, çíà÷èò åñòü öèôðû â êîíöå.
1955 // Çàãðóæàåì òåêñòóðû ñ îñòàëüíûìè #
1956 if ok then
1957 begin
1958 k := NNF_NAME_BEFORE;
1959 // Öèêë ïî èçìåíåíèþ èìåíè òåêñòóðû
1960 while ok or (k = NNF_NAME_BEFORE) or (k = NNF_NAME_EQUALS) do
1961 begin
1962 k := g_Texture_NumNameFindNext(TexName);
1964 if (k = NNF_NAME_BEFORE) or (k = NNF_NAME_AFTER) then
1965 begin
1966 // Ïðîáóåì äîáàâèòü íîâóþ òåêñòóðó
1967 if texrec.Anim then
1968 begin
1969 // Íà÷àëüíàÿ - àíèìèðîâàííàÿ, èùåì àíèìèðîâàííóþ
1970 isAnim := True;
1971 //e_LogWritefln('000: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
1972 ok := CreateAnimTexture(TexName, FileName, False) >= 0;
1973 //e_LogWritefln('001: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
1974 if not ok then
1975 begin
1976 // Íåò àíèìèðîâàííîé, èùåì îáû÷íóþ
1977 isAnim := False;
1978 //e_LogWritefln('002: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
1979 ok := CreateTexture(TexName, FileName, False) >= 0;
1980 //e_LogWritefln('003: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
1981 end;
1982 end
1983 else
1984 begin
1985 // Íà÷àëüíàÿ - îáû÷íàÿ, èùåì îáû÷íóþ
1986 isAnim := False;
1987 //e_LogWritefln('004: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
1988 ok := CreateTexture(TexName, FileName, False) >= 0;
1989 //e_LogWritefln('005: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
1990 if not ok then
1991 begin
1992 // Íåò îáû÷íîé, èùåì àíèìèðîâàííóþ
1993 isAnim := True;
1994 //e_LogWritefln('006: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
1995 ok := CreateAnimTexture(TexName, FileName, False) >= 0;
1996 //e_LogWritefln('007: pannum=%s; TexName=[%s]; FileName=[%s]', [pannum, TexName, FileName]);
1997 end;
1998 end;
2000 // Îíà ñóùåñòâóåò. Çàíîñèì åå ID â ñïèñîê ïàíåëè
2001 if ok then
2002 begin
2004 for c := 0 to High(Textures) do
2005 begin
2006 if (Textures[c].TextureName = TexName) then
2007 begin
2008 SetLength(AddTextures, Length(AddTextures)+1);
2009 AddTextures[High(AddTextures)].Texture := c;
2010 AddTextures[High(AddTextures)].Anim := isAnim;
2011 break;
2012 end;
2013 end;
2015 if (TextNameHash <> nil) and TextNameHash.get(toLowerCase1251(TexName), c) then
2016 begin
2017 SetLength(AddTextures, Length(AddTextures)+1);
2018 AddTextures[High(AddTextures)].Texture := c;
2019 AddTextures[High(AddTextures)].Anim := isAnim;
2020 end;
2021 end;
2022 end
2023 else
2024 begin
2025 if k = NNF_NAME_EQUALS then
2026 begin
2027 // Çàíîñèì òåêóùóþ òåêñòóðó íà ñâîå ìåñòî
2028 SetLength(AddTextures, Length(AddTextures)+1);
2029 AddTextures[High(AddTextures)].Texture := rec.tagInt; // internal texture number, not map index
2030 AddTextures[High(AddTextures)].Anim := texrec.Anim;
2031 CurTex := High(AddTextures);
2032 ok := true;
2033 end
2034 else // NNF_NO_NAME
2035 begin
2036 ok := false;
2037 end;
2038 end;
2039 end; // while ok...
2041 ok := true;
2042 end; // if ok - åñòü ñìåæíûå òåêñòóðû
2043 end; // if ok - ññûëàþòñÿ òðèããåðû
2045 if not ok then
2046 begin
2047 // Çàíîñèì òîëüêî òåêóùóþ òåêñòóðó
2048 SetLength(AddTextures, 1);
2049 AddTextures[0].Texture := rec.tagInt; // internal texture number, not map index
2050 AddTextures[0].Anim := false;
2051 if (texrec <> nil) then AddTextures[0].Anim := texrec.Anim;
2052 CurTex := 0;
2053 end;
2055 //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);
2057 //e_LogWritefln('PANADD: pannum=%s', [pannum]);
2059 // Ñîçäàåì ïàíåëü è çàïîìèíàåì åå GUID
2060 //e_LogWritefln('new panel; tcount=%s; curtex=%s', [Length(AddTextures), CurTex]);
2061 PanelID := CreatePanel(rec, AddTextures, CurTex);
2062 //e_LogWritefln('panel #%s of type %s got guid #%s', [pannum, rec.PanelType, PanelID]);
2063 rec.userPanelId := PanelID; // remember game panel id, we'll fix triggers later
2065 // setup lifts
2066 moveSpeed := rec.moveSpeed;
2067 //moveStart := rec.moveStart;
2068 //moveEnd := rec.moveEnd;
2069 //moveActive := rec['move_active'].value;
2070 if not moveSpeed.isZero then
2071 begin
2072 SetLength(gMovingWallIds, Length(gMovingWallIds)+1);
2073 gMovingWallIds[High(gMovingWallIds)] := PanelID;
2074 //e_LogWritefln('found moving panel ''%s'' (idx=%s; id=%s)', [rec.id, pannum, PanelID]);
2075 end;
2077 //e_LogWritefln('PANEND: pannum=%s', [pannum]);
2079 g_Game_StepLoading();
2080 end;
2081 end;
2083 // ×èíèì ID'û ïàíåëåé, êîòîðûå èñïîëüçóþòñÿ â òðèããåðàõ
2084 for b := 0 to High(TriggersTable) do
2085 begin
2086 if (TriggersTable[b].texPanel <> nil) then TriggersTable[b].texPanelIdx := TriggersTable[b].texPanel.userPanelId;
2087 if (TriggersTable[b].actPanel <> nil) then TriggersTable[b].actPanelIdx := TriggersTable[b].actPanel.userPanelId;
2088 end;
2090 // create map grid, init other grids (for monsters, for example)
2091 e_WriteLog('Creating map grid', TMsgType.Notify);
2092 mapCreateGrid();
2094 // Åñëè íå LoadState, òî ñîçäàåì òðèããåðû
2095 if (triggers <> nil) and (panels <> nil) and (not gLoadGameMode) then
2096 begin
2097 e_LogWritefln(' Creating triggers (%d)...', [triggers.count]);
2098 g_Game_SetLoadingText(_lc[I_LOAD_CREATE_TRIGGERS], 0, False);
2099 // Óêàçûâàåì òèï ïàíåëè, åñëè åñòü
2100 trignum := -1;
2101 for rec in triggers do
2102 begin
2103 Inc(trignum);
2104 tgpid := TriggersTable[trignum].actPanelIdx;
2105 //e_LogWritefln('creating trigger #%s; texpantype=%s; shotpantype=%s (%d,%d)', [trignum, b, c, TriggersTable[trignum].texPanIdx, TriggersTable[trignum].ShotPanelIdx]);
2106 TriggersTable[trignum].tnum := trignum;
2107 TriggersTable[trignum].id := CreateTrigger(trignum, rec, TriggersTable[trignum].texPanelIdx, tgpid);
2108 end;
2109 end;
2111 //FIXME: use hashtable!
2112 for pan in panByGUID do
2113 begin
2114 if (pan.endPosTrigId >= 0) and (pan.endPosTrigId < Length(TriggersTable)) then
2115 begin
2116 pan.endPosTrigId := TriggersTable[pan.endPosTrigId].id;
2117 end;
2118 if (pan.endSizeTrigId >= 0) and (pan.endSizeTrigId < Length(TriggersTable)) then
2119 begin
2120 pan.endSizeTrigId := TriggersTable[pan.endSizeTrigId].id;
2121 end;
2122 end;
2124 // Çàãðóçêà ïðåäìåòîâ
2125 e_WriteLog(' Loading items...', TMsgType.Notify);
2126 g_Game_SetLoadingText(_lc[I_LOAD_ITEMS], 0, False);
2128 // Åñëè íå LoadState, òî ñîçäàåì ïðåäìåòû
2129 if (items <> nil) and not gLoadGameMode then
2130 begin
2131 e_WriteLog(' Spawning items...', TMsgType.Notify);
2132 g_Game_SetLoadingText(_lc[I_LOAD_CREATE_ITEMS], 0, False);
2133 for rec in items do CreateItem(rec);
2134 end;
2136 // Çàãðóçêà îáëàñòåé
2137 e_WriteLog(' Loading areas...', TMsgType.Notify);
2138 g_Game_SetLoadingText(_lc[I_LOAD_AREAS], 0, False);
2140 // Åñëè íå LoadState, òî ñîçäàåì îáëàñòè
2141 if areas <> nil then
2142 begin
2143 e_WriteLog(' Creating areas...', TMsgType.Notify);
2144 g_Game_SetLoadingText(_lc[I_LOAD_CREATE_AREAS], 0, False);
2145 for rec in areas do CreateArea(rec);
2146 end;
2148 // Çàãðóçêà ìîíñòðîâ
2149 e_WriteLog(' Loading monsters...', TMsgType.Notify);
2150 g_Game_SetLoadingText(_lc[I_LOAD_MONSTERS], 0, False);
2152 gTotalMonsters := 0;
2154 // Åñëè íå LoadState, òî ñîçäàåì ìîíñòðîâ
2155 if (monsters <> nil) and not gLoadGameMode then
2156 begin
2157 e_WriteLog(' Spawning monsters...', TMsgType.Notify);
2158 g_Game_SetLoadingText(_lc[I_LOAD_CREATE_MONSTERS], 0, False);
2159 for rec in monsters do CreateMonster(rec);
2160 end;
2162 //gCurrentMap := mapReader; // this will be our current map now
2163 gCurrentMapFileName := Res;
2164 //mapReader := nil;
2166 // Çàãðóçêà íåáà
2167 if (gMapInfo.SkyName <> '') then
2168 begin
2169 e_WriteLog(' Loading sky: ' + gMapInfo.SkyName, TMsgType.Notify);
2170 g_Game_SetLoadingText(_lc[I_LOAD_SKY], 0, False);
2171 FileName := g_ExtractWadName(gMapInfo.SkyName);
2173 if (FileName <> '') then FileName := GameDir+'/wads/'+FileName else FileName := g_ExtractWadName(Res);
2175 if gTextureFilter then TEXTUREFILTER := GL_LINEAR else TEXTUREFILTER := GL_NEAREST;
2176 try
2177 s := FileName+':'+g_ExtractFilePathName(gMapInfo.SkyName);
2178 if g_Texture_CreateWAD(BackID, s) then
2179 begin
2180 g_Game_SetupScreenSize();
2181 end
2182 else
2183 begin
2184 g_FatalError(Format(_lc[I_GAME_ERROR_SKY], [s]));
2185 end;
2186 finally
2187 TEXTUREFILTER := GL_NEAREST;
2188 end;
2189 end;
2191 // Çàãðóçêà ìóçûêè
2192 ok := False;
2193 if gMapInfo.MusicName <> '' then
2194 begin
2195 e_WriteLog(' Loading music: ' + gMapInfo.MusicName, TMsgType.Notify);
2196 g_Game_SetLoadingText(_lc[I_LOAD_MUSIC], 0, False);
2197 FileName := g_ExtractWadName(gMapInfo.MusicName);
2199 if FileName <> '' then
2200 FileName := GameDir+'/wads/'+FileName
2201 else
2202 begin
2203 FileName := g_ExtractWadName(Res);
2204 end;
2206 s := FileName+':'+g_ExtractFilePathName(gMapInfo.MusicName);
2207 if g_Sound_CreateWADEx(gMapInfo.MusicName, s, True) then
2208 ok := True
2209 else
2210 g_FatalError(Format(_lc[I_GAME_ERROR_MUSIC], [s]));
2211 end;
2213 // Îñòàëüíûå óñòàíâêè
2214 CreateDoorMap();
2215 CreateLiftMap();
2217 g_Items_Init();
2218 g_Weapon_Init();
2219 g_Monsters_Init();
2221 // Åñëè íå LoadState, òî ñîçäàåì êàðòó ñòîëêíîâåíèé:
2222 if not gLoadGameMode then g_GFX_Init();
2224 // Ñáðîñ ëîêàëüíûõ ìàññèâîâ:
2225 mapTextureList := nil;
2226 panels := nil;
2227 items := nil;
2228 areas := nil;
2229 triggers := nil;
2230 TriggersTable := nil;
2231 AddTextures := nil;
2233 // Âêëþ÷àåì ìóçûêó, åñëè ýòî íå çàãðóçêà:
2234 if ok and (not gLoadGameMode) then
2235 begin
2236 gMusic.SetByName(gMapInfo.MusicName);
2237 gMusic.Play();
2238 end
2239 else
2240 begin
2241 gMusic.SetByName('');
2242 end;
2244 stt := getTimeMicro()-stt;
2245 e_LogWritefln('map loaded in %s.%s milliseconds', [Integer(stt div 1000), Integer(stt mod 1000)]);
2246 mapOk := true;
2247 finally
2248 sfsGCEnable(); // enable releasing unused volumes
2249 //mapReader.Free();
2250 e_ClearInputBuffer(); // why not?
2251 if not mapOk then
2252 begin
2253 gCurrentMap.Free();
2254 gCurrentMap := nil;
2255 gCurrentMapFileName := '';
2256 end;
2257 end;
2259 e_WriteLog('Done loading map.', TMsgType.Notify);
2260 Result := True;
2261 end;
2264 function g_Map_GetMapInfo(Res: String): TMapInfo;
2265 var
2266 WAD: TWADFile;
2267 mapReader: TDynRecord;
2268 //Header: TMapHeaderRec_1;
2269 FileName: String;
2270 Data: Pointer;
2271 Len: Integer;
2272 begin
2273 FillChar(Result, SizeOf(Result), 0);
2274 FileName := g_ExtractWadName(Res);
2276 WAD := TWADFile.Create();
2277 if not WAD.ReadFile(FileName) then
2278 begin
2279 WAD.Free();
2280 Exit;
2281 end;
2283 //k8: it ignores path again
2284 if not WAD.GetMapResource(g_ExtractFileName(Res), Data, Len) then
2285 begin
2286 WAD.Free();
2287 Exit;
2288 end;
2290 WAD.Free();
2292 try
2293 mapReader := g_Map_ParseMap(Data, Len);
2294 except
2295 mapReader := nil;
2296 FreeMem(Data);
2297 exit;
2298 end;
2300 FreeMem(Data);
2302 if (mapReader = nil) then exit;
2304 if (mapReader.Width > 0) and (mapReader.Height > 0) then
2305 begin
2306 Result.Name := mapReader.MapName;
2307 Result.Description := mapReader.MapDesc;
2308 Result.Map := Res;
2309 Result.Author := mapReader.MapAuthor;
2310 Result.Height := mapReader.Height;
2311 Result.Width := mapReader.Width;
2312 end
2313 else
2314 begin
2315 g_Console_Add(Format(_lc[I_GAME_ERROR_MAP_LOAD], [Res]), True);
2316 //ZeroMemory(@Header, SizeOf(Header));
2317 Result.Name := _lc[I_GAME_ERROR_MAP_SELECT];
2318 Result.Description := _lc[I_GAME_ERROR_MAP_SELECT];
2319 Result.Map := Res;
2320 Result.Author := '';
2321 Result.Height := 0;
2322 Result.Width := 0;
2323 end;
2325 mapReader.Free();
2326 end;
2328 function g_Map_GetMapsList(WADName: string): SSArray;
2329 var
2330 WAD: TWADFile;
2331 a: Integer;
2332 ResList: SSArray;
2333 begin
2334 Result := nil;
2335 WAD := TWADFile.Create();
2336 if not WAD.ReadFile(WADName) then
2337 begin
2338 WAD.Free();
2339 Exit;
2340 end;
2341 ResList := WAD.GetMapResources();
2342 if ResList <> nil then
2343 begin
2344 for a := 0 to High(ResList) do
2345 begin
2346 SetLength(Result, Length(Result)+1);
2347 Result[High(Result)] := ResList[a];
2348 end;
2349 end;
2350 WAD.Free();
2351 end;
2353 function g_Map_Exist(Res: string): Boolean;
2354 var
2355 WAD: TWADFile;
2356 FileName, mnn: string;
2357 ResList: SSArray;
2358 a: Integer;
2359 begin
2360 Result := False;
2362 FileName := addWadExtension(g_ExtractWadName(Res));
2364 WAD := TWADFile.Create;
2365 if not WAD.ReadFile(FileName) then
2366 begin
2367 WAD.Free();
2368 Exit;
2369 end;
2371 ResList := WAD.GetMapResources();
2372 WAD.Free();
2374 mnn := g_ExtractFileName(Res);
2375 if ResList <> nil then
2376 for a := 0 to High(ResList) do if StrEquCI1251(ResList[a], mnn) then
2377 begin
2378 Result := True;
2379 Exit;
2380 end;
2381 end;
2383 procedure g_Map_Free(freeTextures: Boolean=true);
2384 var
2385 a: Integer;
2387 procedure FreePanelArray(var panels: TPanelArray);
2388 var
2389 i: Integer;
2391 begin
2392 if panels <> nil then
2393 begin
2394 for i := 0 to High(panels) do
2395 panels[i].Free();
2396 panels := nil;
2397 end;
2398 end;
2400 begin
2401 g_GFX_Free();
2402 g_Weapon_Free();
2403 g_Items_Free();
2404 g_Triggers_Free();
2405 g_Monsters_Free();
2407 RespawnPoints := nil;
2408 if FlagPoints[FLAG_RED] <> nil then
2409 begin
2410 Dispose(FlagPoints[FLAG_RED]);
2411 FlagPoints[FLAG_RED] := nil;
2412 end;
2413 if FlagPoints[FLAG_BLUE] <> nil then
2414 begin
2415 Dispose(FlagPoints[FLAG_BLUE]);
2416 FlagPoints[FLAG_BLUE] := nil;
2417 end;
2418 //DOMFlagPoints := nil;
2420 //gDOMFlags := nil;
2422 if (Length(gCurrentMapFileName) <> 0) then
2423 begin
2424 e_LogWritefln('g_Map_Free: previous map was ''%s''...', [gCurrentMapFileName]);
2425 end
2426 else
2427 begin
2428 e_LogWritefln('g_Map_Free: no previous map.', []);
2429 end;
2431 if freeTextures then
2432 begin
2433 e_LogWritefln('g_Map_Free: clearing textures...', []);
2434 if (Textures <> nil) then
2435 begin
2436 for a := 0 to High(Textures) do
2437 begin
2438 if not g_Map_IsSpecialTexture(Textures[a].TextureName) then
2439 begin
2440 if Textures[a].Anim then
2441 begin
2442 g_Frames_DeleteByID(Textures[a].FramesID)
2443 end
2444 else
2445 begin
2446 if (Textures[a].TextureID <> LongWord(TEXTURE_NONE)) then
2447 begin
2448 e_DeleteTexture(Textures[a].TextureID);
2449 end;
2450 end;
2451 end;
2452 end;
2453 Textures := nil;
2454 end;
2455 TextNameHash.Free();
2456 TextNameHash := nil;
2457 BadTextNameHash.Free();
2458 BadTextNameHash := nil;
2459 gCurrentMapFileName := '';
2460 gCurrentMap.Free();
2461 gCurrentMap := nil;
2462 end;
2464 panByGUID := nil;
2466 FreePanelArray(gWalls);
2467 FreePanelArray(gRenderBackgrounds);
2468 FreePanelArray(gRenderForegrounds);
2469 FreePanelArray(gWater);
2470 FreePanelArray(gAcid1);
2471 FreePanelArray(gAcid2);
2472 FreePanelArray(gSteps);
2473 FreePanelArray(gLifts);
2474 FreePanelArray(gBlockMon);
2475 gMovingWallIds := nil;
2477 if BackID <> DWORD(-1) then
2478 begin
2479 gBackSize.X := 0;
2480 gBackSize.Y := 0;
2481 e_DeleteTexture(BackID);
2482 BackID := DWORD(-1);
2483 end;
2485 g_Game_StopAllSounds(False);
2486 gMusic.FreeSound();
2487 g_Sound_Delete(gMapInfo.MusicName);
2489 gMapInfo.Name := '';
2490 gMapInfo.Description := '';
2491 gMapInfo.MusicName := '';
2492 gMapInfo.Height := 0;
2493 gMapInfo.Width := 0;
2495 gDoorMap := nil;
2496 gLiftMap := nil;
2497 end;
2499 procedure g_Map_Update();
2500 var
2501 a, d, j: Integer;
2502 m: Word;
2503 s: String;
2505 procedure UpdatePanelArray(var panels: TPanelArray);
2506 var
2507 i: Integer;
2509 begin
2510 for i := 0 to High(panels) do panels[i].Update();
2511 end;
2513 begin
2514 if g_dbgpan_mplat_step then g_dbgpan_mplat_active := true;
2516 UpdatePanelArray(gWalls);
2517 UpdatePanelArray(gRenderBackgrounds);
2518 UpdatePanelArray(gRenderForegrounds);
2519 UpdatePanelArray(gWater);
2520 UpdatePanelArray(gAcid1);
2521 UpdatePanelArray(gAcid2);
2522 UpdatePanelArray(gSteps);
2524 if g_dbgpan_mplat_step then begin g_dbgpan_mplat_step := false; g_dbgpan_mplat_active := false; end;
2526 if gGameSettings.GameMode = GM_CTF then
2527 begin
2528 for a := FLAG_RED to FLAG_BLUE do
2529 begin
2530 if not (gFlags[a].State in [FLAG_STATE_NONE, FLAG_STATE_CAPTURED]) then
2531 begin
2532 with gFlags[a] do
2533 begin
2534 if gFlags[a].Animation <> nil then gFlags[a].Animation.Update();
2536 m := g_Obj_Move(@Obj, True, True);
2538 if gTime mod (GAME_TICK*2) <> 0 then Continue;
2540 // Ñîïðîòèâëåíèå âîçäóõà
2541 Obj.Vel.X := z_dec(Obj.Vel.X, 1);
2543 // Òàéìàóò ïîòåðÿííîãî ôëàãà, ëèáî îí âûïàë çà êàðòó
2544 if ((Count = 0) or ByteBool(m and MOVE_FALLOUT)) and g_Game_IsServer then
2545 begin
2546 g_Map_ResetFlag(a);
2547 gFlags[a].CaptureTime := 0;
2548 if a = FLAG_RED then
2549 s := _lc[I_PLAYER_FLAG_RED]
2550 else
2551 s := _lc[I_PLAYER_FLAG_BLUE];
2552 g_Game_Message(Format(_lc[I_MESSAGE_FLAG_RETURN], [AnsiUpperCase(s)]), 144);
2554 if g_Game_IsNet then
2555 MH_SEND_FlagEvent(FLAG_STATE_RETURNED, a, 0);
2556 Continue;
2557 end;
2559 if Count > 0 then Count -= 1;
2561 // Èãðîê áåðåò ôëàã
2562 if gPlayers <> nil then
2563 begin
2564 j := Random(Length(gPlayers)) - 1;
2565 for d := 0 to High(gPlayers) do
2566 begin
2567 Inc(j);
2568 if j > High(gPlayers) then j := 0;
2569 if gPlayers[j] <> nil then
2570 begin
2571 if gPlayers[j].alive and g_Obj_Collide(@Obj, @gPlayers[j].Obj) then
2572 begin
2573 if gPlayers[j].GetFlag(a) then Break;
2574 end;
2575 end;
2576 end;
2577 end;
2578 end;
2579 end;
2580 end;
2581 end;
2582 end;
2585 // old algo
2586 procedure g_Map_DrawPanels (PanelType: Word; hasAmbient: Boolean; constref ambColor: TDFColor);
2588 procedure DrawPanels (constref panels: TPanelArray; drawDoors: Boolean=False);
2589 var
2590 idx: Integer;
2591 begin
2592 if (panels <> nil) then
2593 begin
2594 // alas, no visible set
2595 for idx := 0 to High(panels) do
2596 begin
2597 if not (drawDoors xor panels[idx].Door) then panels[idx].Draw(hasAmbient, ambColor);
2598 end;
2599 end;
2600 end;
2602 begin
2603 case PanelType of
2604 PANEL_WALL: DrawPanels(gWalls);
2605 PANEL_CLOSEDOOR: DrawPanels(gWalls, True);
2606 PANEL_BACK: DrawPanels(gRenderBackgrounds);
2607 PANEL_FORE: DrawPanels(gRenderForegrounds);
2608 PANEL_WATER: DrawPanels(gWater);
2609 PANEL_ACID1: DrawPanels(gAcid1);
2610 PANEL_ACID2: DrawPanels(gAcid2);
2611 PANEL_STEP: DrawPanels(gSteps);
2612 end;
2613 end;
2616 // new algo
2617 procedure g_Map_CollectDrawPanels (x0, y0, wdt, hgt: Integer);
2618 (*
2619 function checker (pan: TPanel; tag: Integer): Boolean;
2620 begin
2621 result := false; // don't stop, ever
2622 if ((tag and GridTagDoor) <> 0) <> pan.Door then exit;
2623 gDrawPanelList.insert(pan);
2624 end;
2625 *)
2626 var
2627 pmark: PoolMark;
2628 phit: PPanel;
2629 hitcount: Integer;
2630 begin
2631 dplClear();
2632 //tagmask := panelTypeToTag(PanelType);
2633 //mapGrid.forEachInAABB(x0, y0, wdt, hgt, checker, GridDrawableMask);
2634 pmark := framePool.mark();
2635 hitcount := mapGrid.forEachInAABB(x0, y0, wdt, hgt, GridDrawableMask);
2636 if (hitcount = 0) then exit;
2637 phit := PPanel(framePool.getPtr(pmark));
2638 while (hitcount > 0) do
2639 begin
2640 if ((phit^.tag and GridTagDoor) <> 0) <> phit^.Door then
2641 begin
2642 end
2643 else
2644 begin
2645 gDrawPanelList.insert(phit^);
2646 end;
2647 Inc(phit);
2648 Dec(hitcount);
2649 end;
2650 framePool.release(pmark);
2651 // list will be rendered in `g_game.DrawPlayer()`
2652 end;
2655 procedure g_Map_DrawPanelShadowVolumes (lightX: Integer; lightY: Integer; radius: Integer);
2656 (*
2657 function checker (pan: TPanel; tag: Integer): Boolean;
2658 begin
2659 result := false; // don't stop, ever
2660 pan.DrawShadowVolume(lightX, lightY, radius);
2661 end;
2662 *)
2663 var
2664 pmark: PoolMark;
2665 phit: PPanel;
2666 hitcount: Integer;
2667 begin
2668 //mapGrid.forEachInAABB(lightX-radius, lightY-radius, radius*2, radius*2, checker, (GridTagWall or GridTagDoor));
2669 pmark := framePool.mark();
2670 hitcount := mapGrid.forEachInAABB(lightX-radius, lightY-radius, radius*2, radius*2, (GridTagWall or GridTagDoor));
2671 if (hitcount = 0) then exit;
2672 phit := PPanel(framePool.getPtr(pmark));
2673 while (hitcount > 0) do
2674 begin
2675 phit^.DrawShadowVolume(lightX, lightY, radius);
2676 Inc(phit);
2677 Dec(hitcount);
2678 end;
2679 framePool.release(pmark);
2680 end;
2683 procedure g_Map_DrawBack(dx, dy: Integer);
2684 begin
2685 if gDrawBackGround and (BackID <> DWORD(-1)) then
2686 e_DrawSize(BackID, dx, dy, 0, False, False, gBackSize.X, gBackSize.Y)
2687 else
2688 e_Clear(GL_COLOR_BUFFER_BIT, 0, 0, 0);
2689 end;
2691 function g_Map_CollidePanelOld(X, Y: Integer; Width, Height: Word;
2692 PanelType: Word; b1x3: Boolean=false): Boolean;
2693 var
2694 a, h: Integer;
2695 begin
2696 Result := False;
2698 if WordBool(PanelType and PANEL_WALL) then
2699 if gWalls <> nil then
2700 begin
2701 h := High(gWalls);
2703 for a := 0 to h do
2704 if gWalls[a].Enabled and
2705 g_Collide(X, Y, Width, Height,
2706 gWalls[a].X, gWalls[a].Y,
2707 gWalls[a].Width, gWalls[a].Height) then
2708 begin
2709 Result := True;
2710 Exit;
2711 end;
2712 end;
2714 if WordBool(PanelType and PANEL_WATER) then
2715 if gWater <> nil then
2716 begin
2717 h := High(gWater);
2719 for a := 0 to h do
2720 if g_Collide(X, Y, Width, Height,
2721 gWater[a].X, gWater[a].Y,
2722 gWater[a].Width, gWater[a].Height) then
2723 begin
2724 Result := True;
2725 Exit;
2726 end;
2727 end;
2729 if WordBool(PanelType and PANEL_ACID1) then
2730 if gAcid1 <> nil then
2731 begin
2732 h := High(gAcid1);
2734 for a := 0 to h do
2735 if g_Collide(X, Y, Width, Height,
2736 gAcid1[a].X, gAcid1[a].Y,
2737 gAcid1[a].Width, gAcid1[a].Height) then
2738 begin
2739 Result := True;
2740 Exit;
2741 end;
2742 end;
2744 if WordBool(PanelType and PANEL_ACID2) then
2745 if gAcid2 <> nil then
2746 begin
2747 h := High(gAcid2);
2749 for a := 0 to h do
2750 if g_Collide(X, Y, Width, Height,
2751 gAcid2[a].X, gAcid2[a].Y,
2752 gAcid2[a].Width, gAcid2[a].Height) then
2753 begin
2754 Result := True;
2755 Exit;
2756 end;
2757 end;
2759 if WordBool(PanelType and PANEL_STEP) then
2760 if gSteps <> nil then
2761 begin
2762 h := High(gSteps);
2764 for a := 0 to h do
2765 if g_Collide(X, Y, Width, Height,
2766 gSteps[a].X, gSteps[a].Y,
2767 gSteps[a].Width, gSteps[a].Height) then
2768 begin
2769 Result := True;
2770 Exit;
2771 end;
2772 end;
2774 if WordBool(PanelType and (PANEL_LIFTUP or PANEL_LIFTDOWN or PANEL_LIFTLEFT or PANEL_LIFTRIGHT)) then
2775 if gLifts <> nil then
2776 begin
2777 h := High(gLifts);
2779 for a := 0 to h do
2780 if ((WordBool(PanelType and (PANEL_LIFTUP)) and (gLifts[a].LiftType = 0)) or
2781 (WordBool(PanelType and (PANEL_LIFTDOWN)) and (gLifts[a].LiftType = 1)) or
2782 (WordBool(PanelType and (PANEL_LIFTLEFT)) and (gLifts[a].LiftType = 2)) or
2783 (WordBool(PanelType and (PANEL_LIFTRIGHT)) and (gLifts[a].LiftType = 3))) and
2784 g_Collide(X, Y, Width, Height,
2785 gLifts[a].X, gLifts[a].Y,
2786 gLifts[a].Width, gLifts[a].Height) then
2787 begin
2788 Result := True;
2789 Exit;
2790 end;
2791 end;
2793 if WordBool(PanelType and PANEL_BLOCKMON) then
2794 if gBlockMon <> nil then
2795 begin
2796 h := High(gBlockMon);
2798 for a := 0 to h do
2799 if ( (not b1x3) or
2800 ((gBlockMon[a].Width + gBlockMon[a].Height) >= 64) ) and
2801 g_Collide(X, Y, Width, Height,
2802 gBlockMon[a].X, gBlockMon[a].Y,
2803 gBlockMon[a].Width, gBlockMon[a].Height) then
2804 begin
2805 Result := True;
2806 Exit;
2807 end;
2808 end;
2809 end;
2811 function g_Map_CollideLiquid_TextureOld(X, Y: Integer; Width, Height: Word): DWORD;
2812 var
2813 texid: DWORD;
2815 function checkPanels (constref panels: TPanelArray): Boolean;
2816 var
2817 a: Integer;
2818 begin
2819 result := false;
2820 if panels = nil then exit;
2821 for a := 0 to High(panels) do
2822 begin
2823 if g_Collide(X, Y, Width, Height, panels[a].X, panels[a].Y, panels[a].Width, panels[a].Height) then
2824 begin
2825 result := true;
2826 texid := panels[a].GetTextureID();
2827 exit;
2828 end;
2829 end;
2830 end;
2832 begin
2833 texid := LongWord(TEXTURE_NONE);
2834 result := texid;
2835 if not checkPanels(gWater) then
2836 if not checkPanels(gAcid1) then
2837 if not checkPanels(gAcid2) then exit;
2838 result := texid;
2839 end;
2842 function g_Map_CollidePanel(X, Y: Integer; Width, Height: Word; PanelType: Word; b1x3: Boolean): Boolean;
2843 const
2844 SlowMask = GridTagLift or GridTagBlockMon;
2846 function checker (pan: TPanel; tag: Integer): Boolean;
2847 begin
2849 if ((tag and (GridTagWall or GridTagDoor)) <> 0) then
2850 begin
2851 result := pan.Enabled;
2852 exit;
2853 end;
2856 if ((tag and GridTagLift) <> 0) then
2857 begin
2858 result :=
2859 ((WordBool(PanelType and PANEL_LIFTUP) and (pan.LiftType = 0)) or
2860 (WordBool(PanelType and PANEL_LIFTDOWN) and (pan.LiftType = 1)) or
2861 (WordBool(PanelType and PANEL_LIFTLEFT) and (pan.LiftType = 2)) or
2862 (WordBool(PanelType and PANEL_LIFTRIGHT) and (pan.LiftType = 3))) {and
2863 g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height)};
2864 exit;
2865 end;
2867 if ((tag and GridTagBlockMon) <> 0) then
2868 begin
2869 result := ((not b1x3) or (pan.Width+pan.Height >= 64)); //and g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height);
2870 exit;
2871 end;
2873 // other shit
2874 //result := g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height);
2875 result := true; // i found her!
2876 end;
2878 var
2879 tagmask: Integer = 0;
2880 pmark: PoolMark;
2881 phit: PPanel;
2882 hitcount: Integer;
2883 pan: TPanel;
2884 begin
2885 result := false;
2886 if WordBool(PanelType and (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_OPENDOOR)) then tagmask := tagmask or (GridTagWall or GridTagDoor);
2887 if WordBool(PanelType and PANEL_WATER) then tagmask := tagmask or GridTagWater;
2888 if WordBool(PanelType and PANEL_ACID1) then tagmask := tagmask or GridTagAcid1;
2889 if WordBool(PanelType and PANEL_ACID2) then tagmask := tagmask or GridTagAcid2;
2890 if WordBool(PanelType and PANEL_STEP) then tagmask := tagmask or GridTagStep;
2891 if WordBool(PanelType and (PANEL_LIFTUP or PANEL_LIFTDOWN or PANEL_LIFTLEFT or PANEL_LIFTRIGHT)) then tagmask := tagmask or GridTagLift;
2892 if WordBool(PanelType and PANEL_BLOCKMON) then tagmask := tagmask or GridTagBlockMon;
2894 if (tagmask = 0) then exit; // just in case
2896 if (profMapCollision <> nil) then profMapCollision.sectionBeginAccum('*solids');
2897 if gdbg_map_use_accel_coldet then
2898 begin
2899 {if (Width = 1) and (Height = 1) then
2900 begin
2901 if ((tagmask and SlowMask) <> 0) then
2902 begin
2903 // slow
2904 result := (mapGrid.forEachAtPoint(X, Y, checker, tagmask) <> nil);
2905 end
2906 else
2907 begin
2908 // fast
2909 result := (mapGrid.forEachAtPoint(X, Y, nil, tagmask) <> nil);
2910 end;
2911 end
2912 else}
2913 begin
2914 pmark := framePool.mark();
2915 if ((tagmask and SlowMask) <> 0) then
2916 begin
2917 // slow
2918 //result := (mapGrid.forEachInAABB(X, Y, Width, Height, checker, tagmask) <> nil);
2919 hitcount := mapGrid.forEachInAABB(X, Y, Width, Height, tagmask);
2920 //if (hitcount = 0) then exit;
2921 phit := PPanel(framePool.getPtr(pmark));
2922 while (hitcount > 0) do
2923 begin
2924 pan := phit^;
2925 if ((pan.tag and GridTagLift) <> 0) then
2926 begin
2927 result :=
2928 ((WordBool(PanelType and PANEL_LIFTUP) and (pan.LiftType = 0)) or
2929 (WordBool(PanelType and PANEL_LIFTDOWN) and (pan.LiftType = 1)) or
2930 (WordBool(PanelType and PANEL_LIFTLEFT) and (pan.LiftType = 2)) or
2931 (WordBool(PanelType and PANEL_LIFTRIGHT) and (pan.LiftType = 3))) {and
2932 g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height)};
2933 end
2934 else if ((pan.tag and GridTagBlockMon) <> 0) then
2935 begin
2936 result := ((not b1x3) or (pan.Width+pan.Height >= 64)); //and g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height);
2937 end
2938 else
2939 begin
2940 // other shit
2941 result := true; // i found her!
2942 end;
2943 if (result) then break;
2944 Inc(phit);
2945 Dec(hitcount);
2946 end;
2947 end
2948 else
2949 begin
2950 // fast
2951 //result := (mapGrid.forEachInAABB(X, Y, Width, Height, nil, tagmask) <> nil);
2952 hitcount := mapGrid.forEachInAABB(X, Y, Width, Height, tagmask, false, true); // return first hit
2953 result := (hitcount > 0);
2954 end;
2955 framePool.release(pmark);
2956 end;
2957 end
2958 else
2959 begin
2960 result := g_Map_CollidePanelOld(X, Y, Width, Height, PanelType, b1x3);
2961 end;
2962 if (profMapCollision <> nil) then profMapCollision.sectionEnd();
2963 end;
2966 // returns `true` if we need to stop
2967 function liquidChecker (pan: TPanel; var texid: DWORD; var cctype: Integer): Boolean; inline;
2968 begin
2969 result := false;
2970 //if ((tag and (GridTagWater or GridTagAcid1 or GridTagAcid2)) = 0) then exit;
2971 // check priorities
2972 case cctype of
2973 0: if ((pan.tag and GridTagWater) = 0) then exit; // allowed: water
2974 1: if ((pan.tag and (GridTagWater or GridTagAcid1)) = 0) then exit; // allowed: water, acid1
2975 //2: if ((tag and (GridTagWater or GridTagAcid1 or GridTagAcid2) = 0) then exit; // allowed: water, acid1, acid2
2976 end;
2977 // collision?
2978 //if not g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height) then exit;
2979 // yeah
2980 texid := pan.GetTextureID();
2981 // water? water has the highest priority, so stop right here
2982 if ((pan.tag and GridTagWater) <> 0) then begin cctype := 0; result := true; exit; end;
2983 // acid2?
2984 if ((pan.tag and GridTagAcid2) <> 0) then cctype := 2;
2985 // acid1?
2986 if ((pan.tag and GridTagAcid1) <> 0) then cctype := 1;
2987 end;
2989 function g_Map_CollideLiquid_Texture(X, Y: Integer; Width, Height: Word): DWORD;
2990 var
2991 cctype: Integer = 3; // priority: 0: water was hit, 1: acid1 was hit, 2: acid2 was hit; 3: nothing was hit
2992 //texid: DWORD;
2994 (*
2995 // slightly different from the old code, but meh...
2996 function checker (pan: TPanel; tag: Integer): Boolean;
2997 begin
2998 result := false; // don't stop, ever
2999 //if ((tag and (GridTagWater or GridTagAcid1 or GridTagAcid2)) = 0) then exit;
3000 // check priorities
3001 case cctype of
3002 0: if ((tag and GridTagWater) = 0) then exit; // allowed: water
3003 1: if ((tag and (GridTagWater or GridTagAcid1)) = 0) then exit; // allowed: water, acid1
3004 //2: if ((tag and (GridTagWater or GridTagAcid1 or GridTagAcid2) = 0) then exit; // allowed: water, acid1, acid2
3005 end;
3006 // collision?
3007 //if not g_Collide(X, Y, Width, Height, pan.X, pan.Y, pan.Width, pan.Height) then exit;
3008 // yeah
3009 texid := pan.GetTextureID();
3010 // water? water has the highest priority, so stop right here
3011 if ((tag and GridTagWater) <> 0) then begin cctype := 0; result := true; exit; end;
3012 // acid2?
3013 if ((tag and GridTagAcid2) <> 0) then cctype := 2;
3014 // acid1?
3015 if ((tag and GridTagAcid1) <> 0) then cctype := 1;
3016 end;
3017 *)
3018 var
3019 pmark: PoolMark;
3020 phit: PPanel;
3021 hitcount: Integer;
3022 pan: TPanel;
3023 begin
3024 if (profMapCollision <> nil) then profMapCollision.sectionBeginAccum('liquids');
3025 if gdbg_map_use_accel_coldet then
3026 begin
3027 {texid}result := LongWord(TEXTURE_NONE);
3029 if (Width = 1) and (Height = 1) then
3030 begin
3031 mapGrid.forEachAtPoint(X, Y, checker, (GridTagWater or GridTagAcid1 or GridTagAcid2));
3032 end
3033 else
3034 begin
3035 mapGrid.forEachInAABB(X, Y, Width, Height, checker, (GridTagWater or GridTagAcid1 or GridTagAcid2));
3036 end;
3038 pmark := framePool.mark();
3039 hitcount := mapGrid.forEachInAABB(X, Y, Width, Height, (GridTagWater or GridTagAcid1 or GridTagAcid2));
3040 if (hitcount = 0) then exit;
3041 phit := PPanel(framePool.getPtr(pmark));
3042 while (hitcount > 0) do
3043 begin
3044 pan := phit^;
3045 Inc(phit);
3046 Dec(hitcount);
3047 if (liquidChecker(pan, result, cctype)) then break;
3048 end;
3049 framePool.release(pmark);
3050 //result := texid;
3051 end
3052 else
3053 begin
3054 result := g_Map_CollideLiquid_TextureOld(X, Y, Width, Height);
3055 end;
3056 if (profMapCollision <> nil) then profMapCollision.sectionEnd();
3057 end;
3060 procedure g_Map_EnableWall_XXX (ID: DWORD); begin if (ID < Length(gWalls)) then g_Map_EnableWallGUID(gWalls[ID].guid); end;
3061 procedure g_Map_DisableWall_XXX (ID: DWORD); begin if (ID < Length(gWalls)) then g_Map_DisableWallGUID(gWalls[ID].guid); end;
3062 procedure g_Map_SetLift_XXX (ID: DWORD; t: Integer); begin if (ID < Length(gLifts)) then g_Map_SetLiftGUID(gLifts[ID].guid, t); end;
3065 procedure g_Map_EnableWallGUID (pguid: Integer);
3066 var
3067 pan: TPanel;
3068 begin
3069 //pan := gWalls[ID];
3070 pan := g_Map_PanelByGUID(pguid);
3071 if (pan = nil) then exit;
3072 if pan.Enabled and mapGrid.proxyEnabled[pan.proxyId] then exit;
3074 pan.Enabled := True;
3075 g_Mark(pan.X, pan.Y, pan.Width, pan.Height, MARK_DOOR, true);
3077 mapGrid.proxyEnabled[pan.proxyId] := true;
3078 //if (pan.proxyId >= 0) then mapGrid.proxyEnabled[pan.proxyId] := true
3079 //else pan.proxyId := mapGrid.insertBody(pan, pan.X, pan.Y, pan.Width, pan.Height, GridTagDoor);
3081 //if g_Game_IsServer and g_Game_IsNet then MH_SEND_PanelState(pguid);
3082 // mark platform as interesting
3083 pan.setDirty();
3085 {$IFDEF MAP_DEBUG_ENABLED_FLAG}
3086 //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);
3087 {$ENDIF}
3088 end;
3091 procedure g_Map_DisableWallGUID (pguid: Integer);
3092 var
3093 pan: TPanel;
3094 begin
3095 //pan := gWalls[ID];
3096 pan := g_Map_PanelByGUID(pguid);
3097 if (pan = nil) then exit;
3098 if (not pan.Enabled) and (not mapGrid.proxyEnabled[pan.proxyId]) then exit;
3100 pan.Enabled := False;
3101 g_Mark(pan.X, pan.Y, pan.Width, pan.Height, MARK_DOOR, false);
3103 mapGrid.proxyEnabled[pan.proxyId] := false;
3104 //if (pan.proxyId >= 0) then begin mapGrid.removeBody(pan.proxyId); pan.proxyId := -1; end;
3106 //if g_Game_IsServer and g_Game_IsNet then MH_SEND_PanelState(pguid);
3107 // mark platform as interesting
3108 pan.setDirty();
3110 {$IFDEF MAP_DEBUG_ENABLED_FLAG}
3111 //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);
3112 {$ENDIF}
3113 end;
3116 procedure g_Map_SwitchTextureGUID (pguid: Integer; AnimLoop: Byte = 0);
3117 var
3118 tp: TPanel;
3119 begin
3120 tp := g_Map_PanelByGUID(pguid);
3121 if (tp = nil) then exit;
3122 tp.NextTexture(AnimLoop);
3123 if g_Game_IsServer and g_Game_IsNet then MH_SEND_PanelTexture(pguid, AnimLoop);
3124 end;
3127 procedure g_Map_SetLiftGUID (pguid: Integer; t: Integer);
3128 var
3129 pan: TPanel;
3130 begin
3131 //pan := gLifts[ID];
3132 pan := g_Map_PanelByGUID(pguid);
3133 if (pan = nil) then exit;
3134 if not pan.isGLift then exit;
3136 if ({gLifts[ID]}pan.LiftType = t) then exit; //!FIXME!TRIGANY!
3138 with {gLifts[ID]} pan do
3139 begin
3140 LiftType := t;
3142 g_Mark(X, Y, Width, Height, MARK_LIFT, false);
3143 //TODO: make separate lift tags, and change tag here
3145 case LiftType of
3146 0: g_Mark(X, Y, Width, Height, MARK_LIFTUP);
3147 1: g_Mark(X, Y, Width, Height, MARK_LIFTDOWN);
3148 2: g_Mark(X, Y, Width, Height, MARK_LIFTLEFT);
3149 3: g_Mark(X, Y, Width, Height, MARK_LIFTRIGHT);
3150 end;
3152 //if g_Game_IsServer and g_Game_IsNet then MH_SEND_PanelState(pguid);
3153 // mark platform as interesting
3154 pan.setDirty();
3155 end;
3156 end;
3159 function g_Map_GetPoint (PointType: Byte; var RespawnPoint: TRespawnPoint): Boolean;
3160 var
3161 a: Integer;
3162 PointsArray: Array of TRespawnPoint;
3163 begin
3164 Result := False;
3165 SetLength(PointsArray, 0);
3167 if RespawnPoints = nil then
3168 Exit;
3170 for a := 0 to High(RespawnPoints) do
3171 if RespawnPoints[a].PointType = PointType then
3172 begin
3173 SetLength(PointsArray, Length(PointsArray)+1);
3174 PointsArray[High(PointsArray)] := RespawnPoints[a];
3175 end;
3177 if PointsArray = nil then
3178 Exit;
3180 RespawnPoint := PointsArray[Random(Length(PointsArray))];
3181 Result := True;
3182 end;
3184 function g_Map_GetPointCount(PointType: Byte): Word;
3185 var
3186 a: Integer;
3187 begin
3188 Result := 0;
3190 if RespawnPoints = nil then
3191 Exit;
3193 for a := 0 to High(RespawnPoints) do
3194 if RespawnPoints[a].PointType = PointType then
3195 Result := Result + 1;
3196 end;
3198 function g_Map_HaveFlagPoints(): Boolean;
3199 begin
3200 Result := (FlagPoints[FLAG_RED] <> nil) and (FlagPoints[FLAG_BLUE] <> nil);
3201 end;
3203 procedure g_Map_ResetFlag(Flag: Byte);
3204 begin
3205 with gFlags[Flag] do
3206 begin
3207 Obj.X := -1000;
3208 Obj.Y := -1000;
3209 Obj.Vel.X := 0;
3210 Obj.Vel.Y := 0;
3211 Direction := TDirection.D_LEFT;
3212 State := FLAG_STATE_NONE;
3213 if FlagPoints[Flag] <> nil then
3214 begin
3215 Obj.X := FlagPoints[Flag]^.X;
3216 Obj.Y := FlagPoints[Flag]^.Y;
3217 Direction := FlagPoints[Flag]^.Direction;
3218 State := FLAG_STATE_NORMAL;
3219 end;
3220 Count := -1;
3221 end;
3222 end;
3224 procedure g_Map_DrawFlags();
3225 var
3226 i, dx: Integer;
3227 Mirror: TMirrorType;
3228 begin
3229 if gGameSettings.GameMode <> GM_CTF then
3230 Exit;
3232 for i := FLAG_RED to FLAG_BLUE do
3233 with gFlags[i] do
3234 if State <> FLAG_STATE_CAPTURED then
3235 begin
3236 if State = FLAG_STATE_NONE then
3237 continue;
3239 if Direction = TDirection.D_LEFT then
3240 begin
3241 Mirror := TMirrorType.Horizontal;
3242 dx := -1;
3243 end
3244 else
3245 begin
3246 Mirror := TMirrorType.None;
3247 dx := 1;
3248 end;
3250 Animation.Draw(Obj.X+dx, Obj.Y+1, Mirror);
3252 if g_debug_Frames then
3253 begin
3254 e_DrawQuad(Obj.X+Obj.Rect.X,
3255 Obj.Y+Obj.Rect.Y,
3256 Obj.X+Obj.Rect.X+Obj.Rect.Width-1,
3257 Obj.Y+Obj.Rect.Y+Obj.Rect.Height-1,
3258 0, 255, 0);
3259 end;
3260 end;
3261 end;
3264 procedure g_Map_SaveState (st: TStream);
3265 var
3266 str: String;
3268 procedure savePanels ();
3269 var
3270 pan: TPanel;
3271 begin
3272 // Ñîõðàíÿåì ïàíåëè
3273 utils.writeInt(st, LongInt(Length(panByGUID)));
3274 for pan in panByGUID do pan.SaveState(st);
3275 end;
3277 procedure saveFlag (flag: PFlag);
3278 var
3279 b: Byte;
3280 begin
3281 utils.writeSign(st, 'FLAG');
3282 utils.writeInt(st, Byte(0)); // version
3283 // Âðåìÿ ïåðåïîÿâëåíèÿ ôëàãà
3284 utils.writeInt(st, Byte(flag^.RespawnType));
3285 // Ñîñòîÿíèå ôëàãà
3286 utils.writeInt(st, Byte(flag^.State));
3287 // Íàïðàâëåíèå ôëàãà
3288 if flag^.Direction = TDirection.D_LEFT then b := 1 else b := 2; // D_RIGHT
3289 utils.writeInt(st, Byte(b));
3290 // Îáúåêò ôëàãà
3291 Obj_SaveState(st, @flag^.Obj);
3292 end;
3294 begin
3295 savePanels();
3297 // Ñîõðàíÿåì ìóçûêó
3298 utils.writeSign(st, 'MUSI');
3299 utils.writeInt(st, Byte(0));
3300 // Íàçâàíèå ìóçûêè
3301 assert(gMusic <> nil, 'g_Map_SaveState: gMusic = nil');
3302 if gMusic.NoMusic then str := '' else str := gMusic.Name;
3303 utils.writeStr(st, str);
3304 // Ïîçèöèÿ ïðîèãðûâàíèÿ ìóçûêè
3305 utils.writeInt(st, LongWord(gMusic.GetPosition()));
3306 // Ñòîèò ëè ìóçûêà íà ñïåö-ïàóçå
3307 utils.writeBool(st, gMusic.SpecPause);
3309 ///// Ñîõðàíÿåì êîëè÷åñòâî ìîíñòðîâ: /////
3310 utils.writeInt(st, LongInt(gTotalMonsters));
3311 ///// /////
3313 //// Ñîõðàíÿåì ôëàãè, åñëè ýòî CTF: /////
3314 if (gGameSettings.GameMode = GM_CTF) then
3315 begin
3316 // Ôëàã Êðàñíîé êîìàíäû
3317 saveFlag(@gFlags[FLAG_RED]);
3318 // Ôëàã Ñèíåé êîìàíäû
3319 saveFlag(@gFlags[FLAG_BLUE]);
3320 end;
3321 ///// /////
3323 ///// Ñîõðàíÿåì êîëè÷åñòâî ïîáåä, åñëè ýòî TDM/CTF: /////
3324 if gGameSettings.GameMode in [GM_TDM, GM_CTF] then
3325 begin
3326 // Î÷êè Êðàñíîé êîìàíäû
3327 utils.writeInt(st, SmallInt(gTeamStat[TEAM_RED].Goals));
3328 // Î÷êè Ñèíåé êîìàíäû
3329 utils.writeInt(st, SmallInt(gTeamStat[TEAM_BLUE].Goals));
3330 end;
3331 ///// /////
3332 end;
3335 procedure g_Map_LoadState (st: TStream);
3336 var
3337 dw: DWORD;
3338 str: String;
3339 boo: Boolean;
3341 procedure loadPanels ();
3342 var
3343 pan: TPanel;
3344 begin
3345 // Çàãðóæàåì ïàíåëè
3346 if (Length(panByGUID) <> utils.readLongInt(st)) then raise XStreamError.Create('invalid number of saved panels');
3347 for pan in panByGUID do
3348 begin
3349 pan.LoadState(st);
3350 if (pan.proxyId >= 0) then mapGrid.proxyEnabled[pan.proxyId] := pan.Enabled;
3351 end;
3352 end;
3354 procedure loadFlag (flag: PFlag);
3355 var
3356 b: Byte;
3357 begin
3358 // Ñèãíàòóðà ôëàãà
3359 if not utils.checkSign(st, 'FLAG') then raise XStreamError.Create('invalid flag signature');
3360 if (utils.readByte(st) <> 0) then raise XStreamError.Create('invalid flag version');
3361 // Âðåìÿ ïåðåïîÿâëåíèÿ ôëàãà
3362 flag^.RespawnType := utils.readByte(st);
3363 // Ñîñòîÿíèå ôëàãà
3364 flag^.State := utils.readByte(st);
3365 // Íàïðàâëåíèå ôëàãà
3366 b := utils.readByte(st);
3367 if (b = 1) then flag^.Direction := TDirection.D_LEFT else flag^.Direction := TDirection.D_RIGHT; // b = 2
3368 // Îáúåêò ôëàãà
3369 Obj_LoadState(@flag^.Obj, st);
3370 end;
3372 begin
3373 if (st = nil) then exit;
3375 ///// Çàãðóæàåì ñïèñêè ïàíåëåé: /////
3376 loadPanels();
3377 ///// /////
3379 // Îáíîâëÿåì êàðòó ñòîëêíîâåíèé è ñåòêó
3380 g_GFX_Init();
3381 //mapCreateGrid();
3383 ///// Çàãðóæàåì ìóçûêó: /////
3384 if not utils.checkSign(st, 'MUSI') then raise XStreamError.Create('invalid music signature');
3385 if (utils.readByte(st) <> 0) then raise XStreamError.Create('invalid music version');
3386 // Íàçâàíèå ìóçûêè
3387 assert(gMusic <> nil, 'g_Map_LoadState: gMusic = nil');
3388 str := utils.readStr(st);
3389 // Ïîçèöèÿ ïðîèãðûâàíèÿ ìóçûêè
3390 dw := utils.readLongWord(st);
3391 // Ñòîèò ëè ìóçûêà íà ñïåö-ïàóçå
3392 boo := utils.readBool(st);
3393 // Çàïóñêàåì ýòó ìóçûêó
3394 gMusic.SetByName(str);
3395 gMusic.SpecPause := boo;
3396 gMusic.Play();
3397 gMusic.Pause(true);
3398 gMusic.SetPosition(dw);
3399 ///// /////
3401 ///// Çàãðóæàåì êîëè÷åñòâî ìîíñòðîâ: /////
3402 gTotalMonsters := utils.readLongInt(st);
3403 ///// /////
3405 //// Çàãðóæàåì ôëàãè, åñëè ýòî CTF: /////
3406 if (gGameSettings.GameMode = GM_CTF) then
3407 begin
3408 // Ôëàã Êðàñíîé êîìàíäû
3409 loadFlag(@gFlags[FLAG_RED]);
3410 // Ôëàã Ñèíåé êîìàíäû
3411 loadFlag(@gFlags[FLAG_BLUE]);
3412 end;
3413 ///// /////
3415 ///// Çàãðóæàåì êîëè÷åñòâî ïîáåä, åñëè ýòî TDM/CTF: /////
3416 if gGameSettings.GameMode in [GM_TDM, GM_CTF] then
3417 begin
3418 // Î÷êè Êðàñíîé êîìàíäû
3419 gTeamStat[TEAM_RED].Goals := utils.readSmallInt(st);
3420 // Î÷êè Ñèíåé êîìàíäû
3421 gTeamStat[TEAM_BLUE].Goals := utils.readSmallInt(st);
3422 end;
3423 ///// /////
3424 end;
3427 // trace liquid, stepping by `dx` and `dy`
3428 // return last seen liquid coords, and `false` if we're started outside of the liquid
3429 function g_Map_TraceLiquidNonPrecise (x, y, dx, dy: Integer; out topx, topy: Integer): Boolean;
3430 const
3431 MaskLiquid = GridTagWater or GridTagAcid1 or GridTagAcid2;
3432 begin
3433 topx := x;
3434 topy := y;
3435 // started outside of the liquid?
3436 if (mapGrid.forEachAtPoint(x, y, nil, MaskLiquid) = nil) then begin result := false; exit; end;
3437 if (dx = 0) and (dy = 0) then begin result := false; exit; end; // sanity check
3438 result := true;
3439 while true do
3440 begin
3441 Inc(x, dx);
3442 Inc(y, dy);
3443 if (mapGrid.forEachAtPoint(x, y, nil, MaskLiquid) = nil) then exit; // out of the water, just exit
3444 topx := x;
3445 topy := y;
3446 end;
3447 end;
3450 begin
3451 DynWarningCB := mapWarningCB;
3452 end.