src/game/g_map.pas

   1 unit g_map;
   2
   3 interface
   4
   5 uses
   6   e_graphics, g_basic, MAPSTRUCT, g_textures, Classes,
   7   g_phys, wadreader, BinEditor, g_panel, md5;
   8
   9 type
  10   TMapInfo = record
  11     Map:           String;
  12     Name:          String;
  13     Description:   String;
  14     Author:        String;
  15     MusicName:     String;
  16     SkyName:       String;
  17     Height:        Word;
  18     Width:         Word;
  19   end;
  20
  21   PRespawnPoint = ^TRespawnPoint;
  22   TRespawnPoint = record
  23     X, Y:      Integer;
  24     Direction: TDirection;
  25     PointType: Byte;
  26   end;
  27
  28   PFlagPoint = ^TFlagPoint;
  29   TFlagPoint = TRespawnPoint;
  30
  31   PFlag = ^TFlag;
  32   TFlag = record
  33     Obj:         TObj;
  34     RespawnType: Byte;
  35     State:       Byte;
  36     Count:       Integer;
  37     CaptureTime: LongWord;
  38     Animation:   TAnimation;
  39     Direction:   TDirection;
  40   end;
  41
  42
  43 function  g_Map_Load(Res: String): Boolean;
  44 function  g_Map_GetMapInfo(Res: String): TMapInfo;
  45 function  g_Map_GetMapsList(WADName: String): SArray;
  46 function  g_Map_Exist(Res: String): Boolean;
  47 procedure g_Map_Free();
  48 procedure g_Map_Update();
  49 procedure g_Map_DrawPanels(PanelType: Word);
  50 procedure g_Map_DrawBack(dx, dy: Integer);
  51 function  g_Map_CollidePanel(X, Y: Integer; Width, Height: Word;
  52                              PanelType: Word; b1x3: Boolean): Boolean;
  53 function  g_Map_CollideLiquid_Texture(X, Y: Integer; Width, Height: Word): DWORD;
  54 procedure g_Map_EnableWall(ID: DWORD);
  55 procedure g_Map_DisableWall(ID: DWORD);
  56 procedure g_Map_SwitchTexture(PanelType: Word; ID: DWORD; AnimLoop: Byte = 0);
  57 procedure g_Map_SetLift(ID: DWORD; t: Integer);
  58 procedure g_Map_ReAdd_DieTriggers();
  59 function  g_Map_IsSpecialTexture(Texture: String): Boolean;
  60
  61 function  g_Map_GetPoint(PointType: Byte; var RespawnPoint: TRespawnPoint): Boolean;
  62 function  g_Map_GetPointCount(PointType: Byte): Word;
  63
  64 function  g_Map_HaveFlagPoints(): Boolean;
  65
  66 procedure g_Map_ResetFlag(Flag: Byte);
  67 procedure g_Map_DrawFlags();
  68
  69 procedure g_Map_SaveState(Var Mem: TBinMemoryWriter);
  70 procedure g_Map_LoadState(Var Mem: TBinMemoryReader);
  71
  72 const
  73   RESPAWNPOINT_PLAYER1 = 1;
  74   RESPAWNPOINT_PLAYER2 = 2;
  75   RESPAWNPOINT_DM      = 3;
  76   RESPAWNPOINT_RED     = 4;
  77   RESPAWNPOINT_BLUE    = 5;
  78
  79   FLAG_NONE = 0;
  80   FLAG_RED  = 1;
  81   FLAG_BLUE = 2;
  82   FLAG_DOM  = 3;
  83
  84   FLAG_STATE_NONE     = 0;
  85   FLAG_STATE_NORMAL   = 1;
  86   FLAG_STATE_DROPPED  = 2;
  87   FLAG_STATE_CAPTURED = 3;
  88   FLAG_STATE_SCORED   = 4; // Äëÿ ýâåíòîâ ÷åðåç ñåòêó.
  89   FLAG_STATE_RETURNED = 5; // Äëÿ ýâåíòîâ ÷åðåç ñåòêó.
  90
  91   FLAG_TIME = 720; // 20 seconds
  92
  93   SKY_STRETCH: Single = 1.5;
  94
  95 var
  96   gWalls: TPanelArray;
  97   gRenderBackgrounds: TPanelArray;
  98   gRenderForegrounds: TPanelArray;
  99   gWater, gAcid1, gAcid2: TPanelArray;
 100   gSteps: TPanelArray;
 101   gLifts: TPanelArray;
 102   gBlockMon: TPanelArray;
 103   gFlags: array [FLAG_RED..FLAG_BLUE] of TFlag;
 104   //gDOMFlags: array of TFlag;
 105   gMapInfo: TMapInfo;
 106   gBackSize: TPoint;
 107   gDoorMap: array of array of DWORD;
 108   gLiftMap: array of array of DWORD;
 109   gWADHash: TMD5Digest;
 110   BackID:  DWORD = DWORD(-1);
 111   gExternalResources: TStringList;
 112
 113 implementation
 114
 115 uses
 116   g_main, e_log, SysUtils, g_items, g_gfx, g_console,
 117   GL, GLExt, g_weapons, g_game, g_sound, e_sound, CONFIG,
 118   g_options, MAPREADER, g_triggers, g_player, MAPDEF,
 119   Math, g_monsters, g_saveload, g_language, g_netmsg,
 120   utils, sfs;
 121
 122 const
 123   FLAGRECT: TRectWH = (X:15; Y:12; Width:33; Height:52);
 124   MUSIC_SIGNATURE = $4953554D; // 'MUSI'
 125   FLAG_SIGNATURE = $47414C46; // 'FLAG'
 126
 127 var
 128   Textures:      TLevelTextureArray;
 129   RespawnPoints: Array of TRespawnPoint;
 130   FlagPoints:    Array [FLAG_RED..FLAG_BLUE] of PFlagPoint;
 131   //DOMFlagPoints: Array of TFlagPoint;
 132
 133
 134 function g_Map_IsSpecialTexture(Texture: String): Boolean;
 135 begin
 136   Result := (Texture = TEXTURE_NAME_WATER) or
 137             (Texture = TEXTURE_NAME_ACID1) or
 138             (Texture = TEXTURE_NAME_ACID2);
 139 end;
 140
 141 procedure CreateDoorMap();
 142 var
 143   PanelArray: Array of record
 144                          X, Y: Integer;
 145                          Width, Height: Word;
 146                          Active: Boolean;
 147                          PanelID: DWORD;
 148                        end;
 149   a, b, c, m, i, len: Integer;
 150   ok: Boolean;
 151 begin
 152   if gWalls = nil then
 153     Exit;
 154
 155   i := 0;
 156   len := 128;
 157   SetLength(PanelArray, len);
 158
 159   for a := 0 to High(gWalls) do
 160     if gWalls[a].Door then
 161     begin
 162       PanelArray[i].X := gWalls[a].X;
 163       PanelArray[i].Y := gWalls[a].Y;
 164       PanelArray[i].Width := gWalls[a].Width;
 165       PanelArray[i].Height := gWalls[a].Height;
 166       PanelArray[i].Active := True;
 167       PanelArray[i].PanelID := a;
 168
 169       i := i + 1;
 170       if i = len then
 171       begin
 172         len := len + 128;
 173         SetLength(PanelArray, len);
 174       end;
 175     end;
 176
 177 // Íåò äâåðåé:
 178   if i = 0 then
 179   begin
 180     PanelArray := nil;
 181     Exit;
 182   end;
 183
 184   SetLength(gDoorMap, 0);
 185
 186   g_Game_SetLoadingText(_lc[I_LOAD_DOOR_MAP], i-1, False);
 187
 188   for a := 0 to i-1 do
 189     if PanelArray[a].Active then
 190     begin
 191       PanelArray[a].Active := False;
 192       m := Length(gDoorMap);
 193       SetLength(gDoorMap, m+1);
 194       SetLength(gDoorMap[m], 1);
 195       gDoorMap[m, 0] := PanelArray[a].PanelID;
 196       ok := True;
 197
 198       while ok do
 199       begin
 200         ok := False;
 201
 202         for b := 0 to i-1 do
 203           if PanelArray[b].Active then
 204             for c := 0 to High(gDoorMap[m]) do
 205               if {((gRenderWalls[PanelArray[b].RenderPanelID].TextureID = gRenderWalls[gDoorMap[m, c]].TextureID) or
 206                     gRenderWalls[PanelArray[b].RenderPanelID].Hide or gRenderWalls[gDoorMap[m, c]].Hide) and}
 207                 g_CollideAround(PanelArray[b].X, PanelArray[b].Y,
 208                                 PanelArray[b].Width, PanelArray[b].Height,
 209                                 gWalls[gDoorMap[m, c]].X,
 210                                 gWalls[gDoorMap[m, c]].Y,
 211                                 gWalls[gDoorMap[m, c]].Width,
 212                                 gWalls[gDoorMap[m, c]].Height) then
 213               begin
 214                 PanelArray[b].Active := False;
 215                 SetLength(gDoorMap[m],
 216                           Length(gDoorMap[m])+1);
 217                 gDoorMap[m, High(gDoorMap[m])] := PanelArray[b].PanelID;
 218                 ok := True;
 219                 Break;
 220               end;
 221       end;
 222
 223       g_Game_StepLoading();
 224     end;
 225
 226   PanelArray := nil;
 227 end;
 228
 229 procedure CreateLiftMap();
 230 var
 231   PanelArray: Array of record
 232                          X, Y: Integer;
 233                          Width, Height: Word;
 234                          Active: Boolean;
 235                        end;
 236   a, b, c, len, i, j: Integer;
 237   ok: Boolean;
 238 begin
 239   if gLifts = nil then
 240     Exit;
 241
 242   len := Length(gLifts);
 243   SetLength(PanelArray, len);
 244
 245   for a := 0 to len-1 do
 246   begin
 247     PanelArray[a].X := gLifts[a].X;
 248     PanelArray[a].Y := gLifts[a].Y;
 249     PanelArray[a].Width := gLifts[a].Width;
 250     PanelArray[a].Height := gLifts[a].Height;
 251     PanelArray[a].Active := True;
 252   end;
 253
 254   SetLength(gLiftMap, len);
 255   i := 0;
 256
 257   g_Game_SetLoadingText(_lc[I_LOAD_LIFT_MAP], len-1, False);
 258
 259   for a := 0 to len-1 do
 260     if PanelArray[a].Active then
 261     begin
 262       PanelArray[a].Active := False;
 263       SetLength(gLiftMap[i], 32);
 264       j := 0;
 265       gLiftMap[i, j] := a;
 266       ok := True;
 267
 268       while ok do
 269       begin
 270         ok := False;
 271         for b := 0 to len-1 do
 272           if PanelArray[b].Active then
 273             for c := 0 to j do
 274               if g_CollideAround(PanelArray[b].X,
 275                                  PanelArray[b].Y,
 276                                  PanelArray[b].Width,
 277                                  PanelArray[b].Height,
 278                                  PanelArray[gLiftMap[i, c]].X,
 279                                  PanelArray[gLiftMap[i, c]].Y,
 280                                  PanelArray[gLiftMap[i, c]].Width,
 281                                  PanelArray[gLiftMap[i, c]].Height) then
 282               begin
 283                 PanelArray[b].Active := False;
 284                 j := j+1;
 285                 if j > High(gLiftMap[i]) then
 286                   SetLength(gLiftMap[i],
 287                             Length(gLiftMap[i])+32);
 288
 289                 gLiftMap[i, j] := b;
 290                 ok := True;
 291
 292                 Break;
 293               end;
 294       end;
 295
 296       SetLength(gLiftMap[i], j+1);
 297       i := i+1;
 298
 299       g_Game_StepLoading();
 300     end;
 301
 302   SetLength(gLiftMap, i);
 303
 304   PanelArray := nil;
 305 end;
 306
 307 function CreatePanel(PanelRec: TPanelRec_1; AddTextures: TAddTextureArray;
 308                      CurTex: Integer; sav: Boolean): Integer;
 309 var
 310   len: Integer;
 311   panels: ^TPanelArray;
 312 begin
 313   Result := -1;
 314
 315   case PanelRec.PanelType of
 316     PANEL_WALL, PANEL_OPENDOOR, PANEL_CLOSEDOOR:
 317       panels := @gWalls;
 318     PANEL_BACK:
 319       panels := @gRenderBackgrounds;
 320     PANEL_FORE:
 321       panels := @gRenderForegrounds;
 322     PANEL_WATER:
 323       panels := @gWater;
 324     PANEL_ACID1:
 325       panels := @gAcid1;
 326     PANEL_ACID2:
 327       panels := @gAcid2;
 328     PANEL_STEP:
 329       panels := @gSteps;
 330     PANEL_LIFTUP, PANEL_LIFTDOWN, PANEL_LIFTLEFT, PANEL_LIFTRIGHT:
 331       panels := @gLifts;
 332     PANEL_BLOCKMON:
 333       panels := @gBlockMon;
 334     else
 335       Exit;
 336   end;
 337
 338   len := Length(panels^);
 339   SetLength(panels^, len + 1);
 340
 341   panels^[len] := TPanel.Create(PanelRec, AddTextures,
 342                                 CurTex, Textures);
 343   if sav then
 344     panels^[len].SaveIt := True;
 345
 346   Result := len;
 347 end;
 348
 349 function CreateNullTexture(RecName: String): Integer;
 350 begin
 351   SetLength(Textures, Length(Textures)+1);
 352   result := High(Textures);
 353
 354   with Textures[High(Textures)] do
 355   begin
 356     TextureName := RecName;
 357     Width := 1;
 358     Height := 1;
 359     Anim := False;
 360     TextureID := TEXTURE_NONE;
 361   end;
 362 end;
 363
 364 function CreateTexture(RecName: String; Map: string; log: Boolean): Integer;
 365 var
 366   WAD: TWADFile;
 367   TextureData: Pointer;
 368   WADName: String;
 369   SectionName: String;
 370   TextureName: String;
 371   a, ResLength: Integer;
 372 begin
 373   Result := -1;
 374
 375   if Textures <> nil then
 376     for a := 0 to High(Textures) do
 377       if Textures[a].TextureName = RecName then
 378       begin // Òåêñòóðà ñ òàêèì èìåíåì óæå åñòü
 379         Result := a;
 380         Exit;
 381       end;
 382
 383 // Òåêñòóðû ñî ñïåöèàëüíûìè èìåíàìè (âîäà, ëàâà, êèñëîòà):
 384   if (RecName = TEXTURE_NAME_WATER) or
 385      (RecName = TEXTURE_NAME_ACID1) or
 386      (RecName = TEXTURE_NAME_ACID2) then
 387   begin
 388     SetLength(Textures, Length(Textures)+1);
 389
 390     with Textures[High(Textures)] do
 391     begin
 392       TextureName := RecName;
 393
 394       if TextureName = TEXTURE_NAME_WATER then
 395         TextureID := TEXTURE_SPECIAL_WATER
 396       else
 397         if TextureName = TEXTURE_NAME_ACID1 then
 398           TextureID := TEXTURE_SPECIAL_ACID1
 399         else
 400           if TextureName = TEXTURE_NAME_ACID2 then
 401             TextureID := TEXTURE_SPECIAL_ACID2;
 402
 403       Anim := False;
 404     end;
 405
 406     result := High(Textures);
 407     Exit;
 408   end;
 409
 410 // Çàãðóæàåì ðåñóðñ òåêñòóðû â ïàìÿòü èç WAD'à:
 411   g_ProcessResourceStr(RecName, WADName, SectionName, TextureName);
 412
 413   WAD := TWADFile.Create();
 414
 415   if WADName <> '' then
 416     WADName := GameDir+'/wads/'+WADName
 417   else
 418     WADName := Map;
 419
 420   WAD.ReadFile(WADName);
 421
 422   if WAD.GetResource(SectionName, TextureName, TextureData, ResLength) then
 423     begin
 424       SetLength(Textures, Length(Textures)+1);
 425       if not e_CreateTextureMem(TextureData, Textures[High(Textures)].TextureID) then
 426         Exit;
 427       e_GetTextureSize(Textures[High(Textures)].TextureID,
 428                        @Textures[High(Textures)].Width,
 429                        @Textures[High(Textures)].Height);
 430       FreeMem(TextureData);
 431       Textures[High(Textures)].TextureName := RecName;
 432       Textures[High(Textures)].Anim := False;
 433
 434       result := High(Textures);
 435     end
 436   else // Íåò òàêîãî ðåóñðñà â WAD'å
 437     if log then
 438       begin
 439         e_WriteLog(Format('Error loading texture %s', [RecName]), MSG_WARNING);
 440         //e_WriteLog(Format('WAD Reader error: %s', [WAD.GetLastErrorStr]), MSG_WARNING);
 441       end;
 442
 443   WAD.Free();
 444 end;
 445
 446 function CreateAnimTexture(RecName: String; Map: string; log: Boolean): Integer;
 447 var
 448   WAD: TWADFile;
 449   TextureWAD: Pointer;
 450   TextData: Pointer;
 451   TextureData: Pointer;
 452   cfg: TConfig;
 453   WADName: String;
 454   SectionName: String;
 455   TextureName: String;
 456   ResLength: Integer;
 457   TextureResource: String;
 458   _width, _height, _framecount, _speed: Integer;
 459   _backanimation: Boolean;
 460 begin
 461   Result := -1;
 462
 463 // ×èòàåì WAD-ðåñóðñ àíèì.òåêñòóðû èç WAD'à â ïàìÿòü:
 464   g_ProcessResourceStr(RecName, WADName, SectionName, TextureName);
 465
 466   WAD := TWADFile.Create();
 467
 468   if WADName <> '' then
 469     WADName := GameDir+'/wads/'+WADName
 470   else
 471     WADName := Map;
 472
 473   WAD.ReadFile(WADName);
 474
 475   if not WAD.GetResource(SectionName, TextureName, TextureWAD, ResLength) then
 476   begin
 477     if log then
 478     begin
 479       e_WriteLog(Format('Error loading animation texture %s', [RecName]), MSG_WARNING);
 480       //e_WriteLog(Format('WAD Reader error: %s', [WAD.GetLastErrorStr]), MSG_WARNING);
 481     end;
 482     WAD.Free();
 483     Exit;
 484   end;
 485
 486   WAD.FreeWAD();
 487
 488   if not WAD.ReadMemory(TextureWAD, ResLength) then
 489   begin
 490     FreeMem(TextureWAD);
 491     WAD.Free();
 492     Exit;
 493   end;
 494
 495 // ×èòàåì INI-ðåñóðñ àíèì. òåêñòóðû è çàïîìèíàåì åãî óñòàíîâêè:
 496   if not WAD.GetResource('TEXT', 'ANIM', TextData, ResLength) then
 497   begin
 498     FreeMem(TextureWAD);
 499     WAD.Free();
 500     Exit;
 501   end;
 502
 503   cfg := TConfig.CreateMem(TextData, ResLength);
 504
 505   TextureResource := cfg.ReadStr('', 'resource', '');
 506
 507   if TextureResource = '' then
 508   begin
 509     FreeMem(TextureWAD);
 510     FreeMem(TextData);
 511     WAD.Free();
 512     cfg.Free();
 513     Exit;
 514   end;
 515
 516   _width := cfg.ReadInt('', 'framewidth', 0);
 517   _height := cfg.ReadInt('', 'frameheight', 0);
 518   _framecount := cfg.ReadInt('', 'framecount', 0);
 519   _speed := cfg.ReadInt('', 'waitcount', 0);
 520   _backanimation := cfg.ReadBool('', 'backanimation', False);
 521
 522   cfg.Free();
 523
 524 // ×èòàåì ðåñóðñ òåêñòóð (êàäðîâ) àíèì. òåêñòóðû â ïàìÿòü:
 525   if not WAD.GetResource('TEXTURES', TextureResource, TextureData, ResLength) then
 526   begin
 527     FreeMem(TextureWAD);
 528     FreeMem(TextData);
 529     WAD.Free();
 530     Exit;
 531   end;
 532
 533   WAD.Free();
 534
 535   SetLength(Textures, Length(Textures)+1);
 536   with Textures[High(Textures)] do
 537   begin
 538   // Ñîçäàåì êàäðû àíèì. òåêñòóðû èç ïàìÿòè:
 539     if g_Frames_CreateMemory(@FramesID, '', TextureData,
 540          _width, _height, _framecount, _backanimation) then
 541       begin
 542         TextureName := RecName;
 543         Width := _width;
 544         Height := _height;
 545         Anim := True;
 546         FramesCount := _framecount;
 547         Speed := _speed;
 548
 549         result := High(Textures);
 550       end
 551     else
 552       if log then
 553         e_WriteLog(Format('Error loading animation texture %s', [RecName]), MSG_WARNING);
 554   end;
 555
 556   FreeMem(TextureWAD);
 557   FreeMem(TextData);
 558 end;
 559
 560 procedure CreateItem(Item: TItemRec_1);
 561 begin
 562   if g_Game_IsClient then Exit;
 563
 564   if (not (gGameSettings.GameMode in [GM_DM, GM_TDM, GM_CTF])) and
 565      ByteBool(Item.Options and ITEM_OPTION_ONLYDM) then
 566     Exit;
 567
 568   g_Items_Create(Item.X, Item.Y, Item.ItemType, ByteBool(Item.Options and ITEM_OPTION_FALL),
 569                  gGameSettings.GameMode in [GM_DM, GM_TDM, GM_CTF, GM_COOP]);
 570 end;
 571
 572 procedure CreateArea(Area: TAreaRec_1);
 573 var
 574   a: Integer;
 575   id: DWORD;
 576 begin
 577   case Area.AreaType of
 578     AREA_DMPOINT, AREA_PLAYERPOINT1, AREA_PLAYERPOINT2,
 579     AREA_REDTEAMPOINT, AREA_BLUETEAMPOINT:
 580     begin
 581       SetLength(RespawnPoints, Length(RespawnPoints)+1);
 582       with RespawnPoints[High(RespawnPoints)] do
 583       begin
 584         X := Area.X;
 585         Y := Area.Y;
 586         Direction := TDirection(Area.Direction);
 587
 588         case Area.AreaType of
 589           AREA_DMPOINT: PointType := RESPAWNPOINT_DM;
 590           AREA_PLAYERPOINT1: PointType := RESPAWNPOINT_PLAYER1;
 591           AREA_PLAYERPOINT2: PointType := RESPAWNPOINT_PLAYER2;
 592           AREA_REDTEAMPOINT: PointType := RESPAWNPOINT_RED;
 593           AREA_BLUETEAMPOINT: PointType := RESPAWNPOINT_BLUE;
 594         end;
 595       end;
 596     end;
 597
 598     AREA_REDFLAG, AREA_BLUEFLAG:
 599     begin
 600       if Area.AreaType = AREA_REDFLAG then a := FLAG_RED else a := FLAG_BLUE;
 601
 602       if FlagPoints[a] <> nil then Exit;
 603
 604       New(FlagPoints[a]);
 605
 606       with FlagPoints[a]^ do
 607       begin
 608         X := Area.X-FLAGRECT.X;
 609         Y := Area.Y-FLAGRECT.Y;
 610         Direction := TDirection(Area.Direction);
 611       end;
 612
 613       with gFlags[a] do
 614       begin
 615         case a of
 616           FLAG_RED: g_Frames_Get(id, 'FRAMES_FLAG_RED');
 617           FLAG_BLUE: g_Frames_Get(id, 'FRAMES_FLAG_BLUE');
 618         end;
 619
 620         Animation := TAnimation.Create(id, True, 8);
 621         Obj.Rect := FLAGRECT;
 622
 623         g_Map_ResetFlag(a);
 624       end;
 625     end;
 626
 627     AREA_DOMFLAG:
 628     begin
 629       {SetLength(DOMFlagPoints, Length(DOMFlagPoints)+1);
 630       with DOMFlagPoints[High(DOMFlagPoints)] do
 631       begin
 632         X := Area.X;
 633         Y := Area.Y;
 634         Direction := TDirection(Area.Direction);
 635       end;
 636
 637       g_Map_CreateFlag(DOMFlagPoints[High(DOMFlagPoints)], FLAG_DOM, FLAG_STATE_NORMAL);}
 638     end;
 639   end;
 640 end;
 641
 642 procedure CreateTrigger(Trigger: TTriggerRec_1; fTexturePanel1Type, fTexturePanel2Type: Word);
 643 var
 644   _trigger: TTrigger;
 645 begin
 646   if g_Game_IsClient and not (Trigger.TriggerType in [TRIGGER_SOUND, TRIGGER_MUSIC]) then Exit;
 647
 648   with _trigger do
 649   begin
 650     X := Trigger.X;
 651     Y := Trigger.Y;
 652     Width := Trigger.Width;
 653     Height := Trigger.Height;
 654     Enabled := ByteBool(Trigger.Enabled);
 655     TexturePanel := Trigger.TexturePanel;
 656     TexturePanelType := fTexturePanel1Type;
 657     ShotPanelType := fTexturePanel2Type;
 658     TriggerType := Trigger.TriggerType;
 659     ActivateType := Trigger.ActivateType;
 660     Keys := Trigger.Keys;
 661     Data.Default := Trigger.DATA;
 662   end;
 663
 664   g_Triggers_Create(_trigger);
 665 end;
 666
 667 procedure CreateMonster(monster: TMonsterRec_1);
 668 var
 669   a, i: Integer;
 670 begin
 671   if g_Game_IsClient then Exit;
 672
 673   if (gGameSettings.GameType = GT_SINGLE)
 674   or LongBool(gGameSettings.Options and GAME_OPTION_MONSTERS) then
 675   begin
 676     i := g_Monsters_Create(monster.MonsterType, monster.X, monster.Y,
 677                            TDirection(monster.Direction));
 678
 679     if gTriggers <> nil then
 680       for a := 0 to High(gTriggers) do
 681         if gTriggers[a].TriggerType in [TRIGGER_PRESS,
 682              TRIGGER_ON, TRIGGER_OFF, TRIGGER_ONOFF] then
 683           if (gTriggers[a].Data.MonsterID-1) = gMonsters[i].StartID then
 684             gMonsters[i].AddTrigger(a);
 685
 686     if monster.MonsterType <> MONSTER_BARREL then
 687       Inc(gTotalMonsters);
 688   end;
 689 end;
 690
 691 procedure g_Map_ReAdd_DieTriggers();
 692 var
 693   i, a: Integer;
 694 begin
 695   if g_Game_IsClient then Exit;
 696
 697   for i := 0 to High(gMonsters) do
 698     if gMonsters[i] <> nil then
 699       begin
 700         gMonsters[i].ClearTriggers();
 701
 702         for a := 0 to High(gTriggers) do
 703           if gTriggers[a].TriggerType in [TRIGGER_PRESS,
 704                TRIGGER_ON, TRIGGER_OFF, TRIGGER_ONOFF] then
 705             if (gTriggers[a].Data.MonsterID-1) = gMonsters[i].StartID then
 706               gMonsters[i].AddTrigger(a);
 707       end;
 708 end;
 709
 710 function extractWadName(resourceName: string): string;
 711 var
 712   posN: Integer;
 713 begin
 714   posN := Pos(':', resourceName);
 715   if posN > 0 then
 716     Result:= Copy(resourceName, 0, posN-1)
 717   else
 718     Result := '';
 719 end;
 720
 721 procedure addResToExternalResList(res: string);
 722 begin
 723   res := extractWadName(res);
 724   if (res <> '') and (gExternalResources.IndexOf(res) = -1) then
 725     gExternalResources.Add(res);
 726 end;
 727
 728 procedure generateExternalResourcesList(mapReader: TMapReader_1);
 729 var
 730   textures: TTexturesRec1Array;
 731   mapHeader: TMapHeaderRec_1;
 732   i: integer;
 733   resFile: String = '';
 734 begin
 735   if gExternalResources = nil then
 736     gExternalResources := TStringList.Create;
 737
 738   gExternalResources.Clear;
 739   textures := mapReader.GetTextures();
 740   for i := 0 to High(textures) do
 741   begin
 742     addResToExternalResList(resFile);
 743   end;
 744
 745   textures := nil;
 746
 747   mapHeader := mapReader.GetMapHeader;
 748
 749   addResToExternalResList(mapHeader.MusicName);
 750   addResToExternalResList(mapHeader.SkyName);
 751 end;
 752
 753 function g_Map_Load(Res: String): Boolean;
 754 const
 755   DefaultMusRes = 'Standart.wad:STDMUS\MUS1';
 756   DefaultSkyRes = 'Standart.wad:STDSKY\SKY0';
 757 var
 758   WAD: TWADFile;
 759   MapReader: TMapReader_1;
 760   Header: TMapHeaderRec_1;
 761   _textures: TTexturesRec1Array;
 762   _texnummap: array of Integer; // `_textures` -> `Textures`
 763   panels: TPanelsRec1Array;
 764   items: TItemsRec1Array;
 765   monsters: TMonsterRec1Array;
 766   areas: TAreasRec1Array;
 767   triggers: TTriggersRec1Array;
 768   a, b, c, k: Integer;
 769   PanelID: DWORD;
 770   AddTextures: TAddTextureArray;
 771   texture: TTextureRec_1;
 772   TriggersTable: Array of record
 773                            TexturePanel: Integer;
 774                            LiftPanel: Integer;
 775                            DoorPanel: Integer;
 776                            ShotPanel: Integer;
 777                           end;
 778   FileName, SectionName, ResName,
 779   FileName2, s, TexName: String;
 780   Data: Pointer;
 781   Len: Integer;
 782   ok, isAnim, trigRef: Boolean;
 783   CurTex, ntn: Integer;
 784 begin
 785   Result := False;
 786   gMapInfo.Map := Res;
 787   TriggersTable := nil;
 788   FillChar(texture, SizeOf(texture), 0);
 789
 790   sfsGCDisable(); // temporary disable removing of temporary volumes
 791   try
 792   // Çàãðóçêà WAD:
 793     g_ProcessResourceStr(Res, FileName, SectionName, ResName);
 794     e_WriteLog('Loading map WAD: ' + FileName, MSG_NOTIFY);
 795     g_Game_SetLoadingText(_lc[I_LOAD_WAD_FILE], 0, False);
 796
 797     WAD := TWADFile.Create();
 798     if not WAD.ReadFile(FileName) then
 799     begin
 800       g_FatalError(Format(_lc[I_GAME_ERROR_MAP_WAD], [FileName]));
 801       WAD.Free();
 802       Exit;
 803     end;
 804     if not WAD.GetResource('', ResName, Data, Len) then
 805     begin
 806       g_FatalError(Format(_lc[I_GAME_ERROR_MAP_RES], [ResName]));
 807       WAD.Free();
 808       Exit;
 809     end;
 810     WAD.Free();
 811
 812   // Çàãðóçêà êàðòû:
 813     e_WriteLog('Loading map: ' + ResName, MSG_NOTIFY);
 814     g_Game_SetLoadingText(_lc[I_LOAD_MAP], 0, False);
 815     MapReader := TMapReader_1.Create();
 816
 817     if not MapReader.LoadMap(Data) then
 818     begin
 819       g_FatalError(Format(_lc[I_GAME_ERROR_MAP_LOAD], [Res]));
 820       FreeMem(Data);
 821       MapReader.Free();
 822       Exit;
 823     end;
 824
 825     FreeMem(Data);
 826     generateExternalResourcesList(MapReader);
 827   // Çàãðóçêà òåêñòóð:
 828     g_Game_SetLoadingText(_lc[I_LOAD_TEXTURES], 0, False);
 829     _textures := MapReader.GetTextures();
 830     _texnummap := nil;
 831
 832   // Äîáàâëåíèå òåêñòóð â Textures[]:
 833     if _textures <> nil then
 834     begin
 835       e_WriteLog('  Loading textures:', MSG_NOTIFY);
 836       g_Game_SetLoadingText(_lc[I_LOAD_TEXTURES], High(_textures), False);
 837       SetLength(_texnummap, length(_textures));
 838
 839       for a := 0 to High(_textures) do
 840       begin
 841         SetLength(s, 64);
 842         CopyMemory(@s[1], @_textures[a].Resource[0], 64);
 843         for b := 1 to Length(s) do
 844           if s[b] = #0 then
 845           begin
 846             SetLength(s, b-1);
 847             Break;
 848           end;
 849         e_WriteLog(Format('    Loading texture #%d: %s', [a, s]), MSG_NOTIFY);
 850         //if g_Map_IsSpecialTexture(s) then e_WriteLog('      SPECIAL!', MSG_NOTIFY);
 851       // Àíèìèðîâàííàÿ òåêñòóðà:
 852         if ByteBool(_textures[a].Anim) then
 853           begin
 854             ntn := CreateAnimTexture(_textures[a].Resource, FileName, True);
 855             if ntn < 0 then
 856             begin
 857               g_SimpleError(Format(_lc[I_GAME_ERROR_TEXTURE_ANIM], [s]));
 858               ntn := CreateNullTexture(_textures[a].Resource);
 859             end;
 860           end
 861         else // Îáû÷íàÿ òåêñòóðà:
 862           ntn := CreateTexture(_textures[a].Resource, FileName, True);
 863           if ntn < 0 then
 864           begin
 865             g_SimpleError(Format(_lc[I_GAME_ERROR_TEXTURE_SIMPLE], [s]));
 866             ntn := CreateNullTexture(_textures[a].Resource);
 867           end;
 868
 869         _texnummap[a] := ntn; // fix texture number
 870         g_Game_StepLoading();
 871       end;
 872     end;
 873
 874   // Çàãðóçêà òðèããåðîâ:
 875     gTriggerClientID := 0;
 876     e_WriteLog('  Loading triggers...', MSG_NOTIFY);
 877     g_Game_SetLoadingText(_lc[I_LOAD_TRIGGERS], 0, False);
 878     triggers := MapReader.GetTriggers();
 879
 880   // Çàãðóçêà ïàíåëåé:
 881     e_WriteLog('  Loading panels...', MSG_NOTIFY);
 882     g_Game_SetLoadingText(_lc[I_LOAD_PANELS], 0, False);
 883     panels := MapReader.GetPanels();
 884
 885     // check texture numbers for panels
 886     for a := 0 to High(panels) do
 887     begin
 888       if panels[a].TextureNum > High(_textures) then
 889       begin
 890         e_WriteLog('error loading map: invalid texture index for panel', MSG_FATALERROR);
 891         result := false;
 892         exit;
 893       end;
 894       panels[a].TextureNum := _texnummap[panels[a].TextureNum];
 895     end;
 896
 897   // Ñîçäàíèå òàáëèöû òðèããåðîâ (ñîîòâåòñòâèå ïàíåëåé òðèããåðàì):
 898     if triggers <> nil then
 899     begin
 900       e_WriteLog('  Setting up trigger table...', MSG_NOTIFY);
 901       SetLength(TriggersTable, Length(triggers));
 902       g_Game_SetLoadingText(_lc[I_LOAD_TRIGGERS_TABLE], High(TriggersTable), False);
 903
 904       for a := 0 to High(TriggersTable) do
 905       begin
 906       // Ñìåíà òåêñòóðû (âîçìîæíî, êíîïêè):
 907         TriggersTable[a].TexturePanel := triggers[a].TexturePanel;
 908       // Ëèôòû:
 909         if triggers[a].TriggerType in [TRIGGER_LIFTUP, TRIGGER_LIFTDOWN, TRIGGER_LIFT] then
 910           TriggersTable[a].LiftPanel := TTriggerData(triggers[a].DATA).PanelID
 911         else
 912           TriggersTable[a].LiftPanel := -1;
 913       // Äâåðè:
 914         if triggers[a].TriggerType in [TRIGGER_OPENDOOR,
 915             TRIGGER_CLOSEDOOR, TRIGGER_DOOR, TRIGGER_DOOR5,
 916             TRIGGER_CLOSETRAP, TRIGGER_TRAP] then
 917           TriggersTable[a].DoorPanel := TTriggerData(triggers[a].DATA).PanelID
 918         else
 919           TriggersTable[a].DoorPanel := -1;
 920       // Òóðåëü:
 921         if triggers[a].TriggerType = TRIGGER_SHOT then
 922           TriggersTable[a].ShotPanel := TTriggerData(triggers[a].DATA).ShotPanelID
 923         else
 924           TriggersTable[a].ShotPanel := -1;
 925
 926         g_Game_StepLoading();
 927       end;
 928     end;
 929
 930   // Ñîçäàåì ïàíåëè:
 931     if panels <> nil then
 932     begin
 933       e_WriteLog('  Setting up trigger links...', MSG_NOTIFY);
 934       g_Game_SetLoadingText(_lc[I_LOAD_LINK_TRIGGERS], High(panels), False);
 935
 936       for a := 0 to High(panels) do
 937       begin
 938         SetLength(AddTextures, 0);
 939         trigRef := False;
 940         CurTex := -1;
 941         if _textures <> nil then
 942           begin
 943             texture := _textures[panels[a].TextureNum];
 944             ok := True;
 945           end
 946         else
 947           ok := False;
 948
 949         if ok then
 950         begin
 951         // Ñìîòðèì, ññûëàþòñÿ ëè íà ýòó ïàíåëü òðèããåðû.
 952         // Åñëè äà - òî íàäî ñîçäàòü åùå òåêñòóð:
 953           ok := False;
 954           if (TriggersTable <> nil) and (_textures <> nil) then
 955             for b := 0 to High(TriggersTable) do
 956               if (TriggersTable[b].TexturePanel = a)
 957               or (TriggersTable[b].ShotPanel = a) then
 958               begin
 959                 trigRef := True;
 960                 ok := True;
 961                 Break;
 962               end;
 963         end;
 964
 965         if ok then
 966         begin // Åñòü ññûëêè òðèããåðîâ íà ýòó ïàíåëü
 967           SetLength(s, 64);
 968           CopyMemory(@s[1], @texture.Resource[0], 64);
 969         // Èçìåðÿåì äëèíó:
 970           Len := Length(s);
 971           for c := Len downto 1 do
 972             if s[c] <> #0 then
 973             begin
 974               Len := c;
 975               Break;
 976             end;
 977           SetLength(s, Len);
 978
 979         // Ñïåö-òåêñòóðû çàïðåùåíû:
 980           if g_Map_IsSpecialTexture(s) then
 981             ok := False
 982           else
 983         // Îïðåäåëÿåì íàëè÷èå è ïîëîæåíèå öèôð â êîíöå ñòðîêè:
 984             ok := g_Texture_NumNameFindStart(s);
 985
 986         // Åñëè ok, çíà÷èò åñòü öèôðû â êîíöå.
 987         // Çàãðóæàåì òåêñòóðû ñ îñòàëüíûìè #:
 988           if ok then
 989           begin
 990             k := NNF_NAME_BEFORE;
 991           // Öèêë ïî èçìåíåíèþ èìåíè òåêñòóðû:
 992             while ok or (k = NNF_NAME_BEFORE) or
 993                   (k = NNF_NAME_EQUALS) do
 994             begin
 995               k := g_Texture_NumNameFindNext(TexName);
 996
 997               if (k = NNF_NAME_BEFORE) or
 998                  (k = NNF_NAME_AFTER) then
 999                 begin
1000                 // Ïðîáóåì äîáàâèòü íîâóþ òåêñòóðó:
1001                   if ByteBool(texture.Anim) then
1002                     begin // Íà÷àëüíàÿ - àíèìèðîâàííàÿ, èùåì àíèìèðîâàííóþ
1003                       isAnim := True;
1004                       ok := CreateAnimTexture(TexName, FileName, False) >= 0;
1005                       if not ok then
1006                       begin // Íåò àíèìèðîâàííîé, èùåì îáû÷íóþ
1007                         isAnim := False;
1008                         ok := CreateTexture(TexName, FileName, False) >= 0;
1009                       end;
1010                     end
1011                   else
1012                     begin // Íà÷àëüíàÿ - îáû÷íàÿ, èùåì îáû÷íóþ
1013                       isAnim := False;
1014                       ok := CreateTexture(TexName, FileName, False) >= 0;
1015                       if not ok then
1016                       begin // Íåò îáû÷íîé, èùåì àíèìèðîâàííóþ
1017                         isAnim := True;
1018                         ok := CreateAnimTexture(TexName, FileName, False) >= 0;
1019                       end;
1020                     end;
1021
1022                 // Îíà ñóùåñòâóåò. Çàíîñèì åå ID â ñïèñîê ïàíåëè:
1023                   if ok then
1024                   begin
1025                     for c := 0 to High(Textures) do
1026                       if Textures[c].TextureName = TexName then
1027                       begin
1028                         SetLength(AddTextures, Length(AddTextures)+1);
1029                         AddTextures[High(AddTextures)].Texture := c;
1030                         AddTextures[High(AddTextures)].Anim := isAnim;
1031                         Break;
1032                       end;
1033                   end;
1034                 end
1035               else
1036                 if k = NNF_NAME_EQUALS then
1037                   begin
1038                   // Çàíîñèì òåêóùóþ òåêñòóðó íà ñâîå ìåñòî:
1039                     SetLength(AddTextures, Length(AddTextures)+1);
1040                     AddTextures[High(AddTextures)].Texture := panels[a].TextureNum;
1041                     AddTextures[High(AddTextures)].Anim := ByteBool(texture.Anim);
1042                     CurTex := High(AddTextures);
1043                     ok := True;
1044                   end
1045                 else // NNF_NO_NAME
1046                   ok := False;
1047             end; // while ok...
1048
1049             ok := True;
1050           end; // if ok - åñòü ñìåæíûå òåêñòóðû
1051         end; // if ok - ññûëàþòñÿ òðèããåðû
1052
1053         if not ok then
1054         begin
1055         // Çàíîñèì òîëüêî òåêóùóþ òåêñòóðó:
1056           SetLength(AddTextures, 1);
1057           AddTextures[0].Texture := panels[a].TextureNum;
1058           AddTextures[0].Anim := ByteBool(texture.Anim);
1059           CurTex := 0;
1060         end;
1061
1062         //e_WriteLog(Format('panel #%d: TextureNum=%d; ht=%d; ht1=%d; atl=%d', [a, panels[a].TextureNum, High(_textures), High(Textures), High(AddTextures)]), MSG_NOTIFY);
1063
1064       // Ñîçäàåì ïàíåëü è çàïîìèíàåì åå íîìåð:
1065         PanelID := CreatePanel(panels[a], AddTextures, CurTex, trigRef);
1066
1067       // Åñëè èñïîëüçóåòñÿ â òðèããåðàõ, òî ñòàâèì òî÷íûé ID:
1068         if TriggersTable <> nil then
1069           for b := 0 to High(TriggersTable) do
1070           begin
1071           // Òðèããåð äâåðè/ëèôòà:
1072             if (TriggersTable[b].LiftPanel = a) or
1073                (TriggersTable[b].DoorPanel = a) then
1074               TTriggerData(triggers[b].DATA).PanelID := PanelID;
1075           // Òðèããåð ñìåíû òåêñòóðû:
1076             if TriggersTable[b].TexturePanel = a then
1077               triggers[b].TexturePanel := PanelID;
1078           // Òðèããåð "Òóðåëü":
1079             if TriggersTable[b].ShotPanel = a then
1080               TTriggerData(triggers[b].DATA).ShotPanelID := PanelID;
1081           end;
1082
1083         g_Game_StepLoading();
1084       end;
1085     end;
1086
1087   // Åñëè íå LoadState, òî ñîçäàåì òðèããåðû:
1088     if (triggers <> nil) and not gLoadGameMode then
1089     begin
1090       e_WriteLog('  Creating triggers...', MSG_NOTIFY);
1091       g_Game_SetLoadingText(_lc[I_LOAD_CREATE_TRIGGERS], 0, False);
1092     // Óêàçûâàåì òèï ïàíåëè, åñëè åñòü:
1093       for a := 0 to High(triggers) do
1094       begin
1095         if triggers[a].TexturePanel <> -1 then
1096           b := panels[TriggersTable[a].TexturePanel].PanelType
1097         else
1098           b := 0;
1099         if (triggers[a].TriggerType = TRIGGER_SHOT) and
1100            (TTriggerData(triggers[a].DATA).ShotPanelID <> -1) then
1101           c := panels[TriggersTable[a].ShotPanel].PanelType
1102         else
1103           c := 0;
1104         CreateTrigger(triggers[a], b, c);
1105       end;
1106     end;
1107
1108   // Çàãðóçêà ïðåäìåòîâ:
1109     e_WriteLog('  Loading triggers...', MSG_NOTIFY);
1110     g_Game_SetLoadingText(_lc[I_LOAD_ITEMS], 0, False);
1111     items := MapReader.GetItems();
1112
1113   // Åñëè íå LoadState, òî ñîçäàåì ïðåäìåòû:
1114     if (items <> nil) and not gLoadGameMode then
1115     begin
1116       e_WriteLog('  Spawning items...', MSG_NOTIFY);
1117       g_Game_SetLoadingText(_lc[I_LOAD_CREATE_ITEMS], 0, False);
1118       for a := 0 to High(items) do
1119         CreateItem(Items[a]);
1120     end;
1121
1122   // Çàãðóçêà îáëàñòåé:
1123     e_WriteLog('  Loading areas...', MSG_NOTIFY);
1124     g_Game_SetLoadingText(_lc[I_LOAD_AREAS], 0, False);
1125     areas := MapReader.GetAreas();
1126
1127   // Åñëè íå LoadState, òî ñîçäàåì îáëàñòè:
1128     if areas <> nil then
1129     begin
1130       e_WriteLog('  Creating areas...', MSG_NOTIFY);
1131       g_Game_SetLoadingText(_lc[I_LOAD_CREATE_AREAS], 0, False);
1132       for a := 0 to High(areas) do
1133         CreateArea(areas[a]);
1134     end;
1135
1136   // Çàãðóçêà ìîíñòðîâ:
1137     e_WriteLog('  Loading monsters...', MSG_NOTIFY);
1138     g_Game_SetLoadingText(_lc[I_LOAD_MONSTERS], 0, False);
1139     monsters := MapReader.GetMonsters();
1140
1141     gTotalMonsters := 0;
1142
1143   // Åñëè íå LoadState, òî ñîçäàåì ìîíñòðîâ:
1144     if (monsters <> nil) and not gLoadGameMode then
1145     begin
1146       e_WriteLog('  Spawning monsters...', MSG_NOTIFY);
1147       g_Game_SetLoadingText(_lc[I_LOAD_CREATE_MONSTERS], 0, False);
1148       for a := 0 to High(monsters) do
1149         CreateMonster(monsters[a]);
1150     end;
1151
1152   // Çàãðóçêà îïèñàíèÿ êàðòû:
1153     e_WriteLog('  Reading map info...', MSG_NOTIFY);
1154     g_Game_SetLoadingText(_lc[I_LOAD_MAP_HEADER], 0, False);
1155     Header := MapReader.GetMapHeader();
1156
1157     MapReader.Free();
1158
1159     with gMapInfo do
1160     begin
1161       Name := Header.MapName;
1162       Description := Header.MapDescription;
1163       Author := Header.MapAuthor;
1164       MusicName := Header.MusicName;
1165       SkyName := Header.SkyName;
1166       Height := Header.Height;
1167       Width := Header.Width;
1168     end;
1169
1170   // Çàãðóçêà íåáà:
1171     if gMapInfo.SkyName <> '' then
1172     begin
1173       e_WriteLog('  Loading sky: ' + gMapInfo.SkyName, MSG_NOTIFY);
1174       g_Game_SetLoadingText(_lc[I_LOAD_SKY], 0, False);
1175       g_ProcessResourceStr(gMapInfo.SkyName, FileName, SectionName, ResName);
1176
1177       if FileName <> '' then
1178         FileName := GameDir+'/wads/'+FileName
1179       else
1180         begin
1181           g_ProcessResourceStr(Res, @FileName2, nil, nil);
1182           FileName := FileName2;
1183         end;
1184
1185       s := FileName+':'+SectionName+'/'+ResName;
1186       if g_Texture_CreateWAD(BackID, s) then
1187         begin
1188           g_Game_SetupScreenSize();
1189         end
1190       else
1191         g_FatalError(Format(_lc[I_GAME_ERROR_SKY], [s]));
1192     end;
1193
1194   // Çàãðóçêà ìóçûêè:
1195     ok := False;
1196     if gMapInfo.MusicName <> '' then
1197     begin
1198       e_WriteLog('  Loading music: ' + gMapInfo.MusicName, MSG_NOTIFY);
1199       g_Game_SetLoadingText(_lc[I_LOAD_MUSIC], 0, False);
1200       g_ProcessResourceStr(gMapInfo.MusicName, FileName, SectionName, ResName);
1201
1202       if FileName <> '' then
1203         FileName := GameDir+'/wads/'+FileName
1204       else
1205         begin
1206           g_ProcessResourceStr(Res, @FileName2, nil, nil);
1207           FileName := FileName2;
1208         end;
1209
1210       s := FileName+':'+SectionName+'/'+ResName;
1211       if g_Sound_CreateWADEx(gMapInfo.MusicName, s, True) then
1212         ok := True
1213       else
1214         g_FatalError(Format(_lc[I_GAME_ERROR_MUSIC], [s]));
1215     end;
1216
1217   // Îñòàëüíûå óñòàíâêè:
1218     CreateDoorMap();
1219     CreateLiftMap();
1220
1221     g_Items_Init();
1222     g_Weapon_Init();
1223     g_Monsters_Init();
1224
1225   // Åñëè íå LoadState, òî ñîçäàåì êàðòó ñòîëêíîâåíèé:
1226     if not gLoadGameMode then
1227       g_GFX_Init();
1228
1229   // Ñáðîñ ëîêàëüíûõ ìàññèâîâ:
1230     _textures := nil;
1231     panels := nil;
1232     items := nil;
1233     areas := nil;
1234     triggers := nil;
1235     TriggersTable := nil;
1236     AddTextures := nil;
1237
1238   // Âêëþ÷àåì ìóçûêó, åñëè ýòî íå çàãðóçêà:
1239     if ok and (not gLoadGameMode) then
1240       begin
1241         gMusic.SetByName(gMapInfo.MusicName);
1242         gMusic.Play();
1243       end
1244     else
1245       gMusic.SetByName('');
1246   finally
1247     sfsGCEnable(); // enable releasing unused volumes
1248   end;
1249
1250   e_WriteLog('Done loading map.', MSG_NOTIFY);
1251   Result := True;
1252 end;
1253
1254 function g_Map_GetMapInfo(Res: String): TMapInfo;
1255 var
1256   WAD: TWADFile;
1257   MapReader: TMapReader_1;
1258   Header: TMapHeaderRec_1;
1259   FileName, SectionName, ResName: String;
1260   Data: Pointer;
1261   Len: Integer;
1262 begin
1263   FillChar(Result, SizeOf(Result), 0);
1264   g_ProcessResourceStr(Res, FileName, SectionName, ResName);
1265
1266   WAD := TWADFile.Create();
1267   if not WAD.ReadFile(FileName) then
1268   begin
1269     WAD.Free();
1270     Exit;
1271   end;
1272
1273   if not WAD.GetResource('', ResName, Data, Len) then
1274   begin
1275     WAD.Free();
1276     Exit;
1277   end;
1278
1279   WAD.Free();
1280
1281   MapReader := TMapReader_1.Create();
1282
1283   if not MapReader.LoadMap(Data) then
1284     begin
1285       g_Console_Add(Format(_lc[I_GAME_ERROR_MAP_LOAD], [Res]), True);
1286       ZeroMemory(@Header, SizeOf(Header));
1287       Result.Name := _lc[I_GAME_ERROR_MAP_SELECT];
1288       Result.Description := _lc[I_GAME_ERROR_MAP_SELECT];
1289     end
1290   else
1291     begin
1292       Header := MapReader.GetMapHeader();
1293       Result.Name := Header.MapName;
1294       Result.Description := Header.MapDescription;
1295     end;
1296
1297   FreeMem(Data);
1298   MapReader.Free();
1299
1300   Result.Map := Res;
1301   Result.Author := Header.MapAuthor;
1302   Result.Height := Header.Height;
1303   Result.Width := Header.Width;
1304 end;
1305
1306 function g_Map_GetMapsList(WADName: string): SArray;
1307 var
1308   WAD: TWADFile;
1309   a: Integer;
1310   ResList: SArray;
1311   Data: Pointer;
1312   Len: Integer;
1313   Sign: Array [0..2] of Char;
1314 begin
1315   Result := nil;
1316
1317   WAD := TWADFile.Create();
1318   if not WAD.ReadFile(WADName) then
1319   begin
1320     WAD.Free();
1321     Exit;
1322   end;
1323
1324   ResList := WAD.GetResourcesList('');
1325
1326   if ResList <> nil then
1327     for a := 0 to High(ResList) do
1328     begin
1329       if not WAD.GetResource('', ResList[a], Data, Len) then Continue;
1330       CopyMemory(@Sign[0], Data, 3);
1331       FreeMem(Data);
1332
1333       if Sign = MAP_SIGNATURE then
1334       begin
1335         SetLength(Result, Length(Result)+1);
1336         Result[High(Result)] := ResList[a];
1337       end;
1338
1339       Sign := '';
1340     end;
1341
1342   WAD.Free();
1343 end;
1344
1345 function g_Map_Exist(Res: string): Boolean;
1346 var
1347   WAD: TWADFile;
1348   FileName, SectionName, ResName: string;
1349   ResList: SArray;
1350   a: Integer;
1351 begin
1352   Result := False;
1353
1354   g_ProcessResourceStr(Res, FileName, SectionName, ResName);
1355
1356   FileName := addWadExtension(FileName);
1357
1358   WAD := TWADFile.Create;
1359   if not WAD.ReadFile(FileName) then
1360   begin
1361     WAD.Free();
1362     Exit;
1363   end;
1364
1365   ResList := WAD.GetResourcesList('');
1366   WAD.Free();
1367
1368   if ResList <> nil then
1369     for a := 0 to High(ResList) do if ResList[a] = ResName then
1370     begin
1371       Result := True;
1372       Exit;
1373     end;
1374 end;
1375
1376 procedure g_Map_Free();
1377 var
1378   a: Integer;
1379
1380   procedure FreePanelArray(var panels: TPanelArray);
1381   var
1382     i: Integer;
1383
1384   begin
1385     if panels <> nil then
1386     begin
1387       for i := 0 to High(panels) do
1388         panels[i].Free();
1389       panels := nil;
1390     end;
1391   end;
1392
1393 begin
1394   g_GFX_Free();
1395   g_Weapon_Free();
1396   g_Items_Free();
1397   g_Triggers_Free();
1398   g_Monsters_Free();
1399
1400   RespawnPoints := nil;
1401   if FlagPoints[FLAG_RED] <> nil then
1402   begin
1403     Dispose(FlagPoints[FLAG_RED]);
1404     FlagPoints[FLAG_RED] := nil;
1405   end;
1406   if FlagPoints[FLAG_BLUE] <> nil then
1407   begin
1408     Dispose(FlagPoints[FLAG_BLUE]);
1409     FlagPoints[FLAG_BLUE] := nil;
1410   end;
1411   //DOMFlagPoints := nil;
1412
1413   //gDOMFlags := nil;
1414
1415   if Textures <> nil then
1416   begin
1417     for a := 0 to High(Textures) do
1418       if not g_Map_IsSpecialTexture(Textures[a].TextureName) then
1419         if Textures[a].Anim then
1420           g_Frames_DeleteByID(Textures[a].FramesID)
1421         else
1422           if Textures[a].TextureID <> TEXTURE_NONE then
1423             e_DeleteTexture(Textures[a].TextureID);
1424
1425     Textures := nil;
1426   end;
1427
1428   FreePanelArray(gWalls);
1429   FreePanelArray(gRenderBackgrounds);
1430   FreePanelArray(gRenderForegrounds);
1431   FreePanelArray(gWater);
1432   FreePanelArray(gAcid1);
1433   FreePanelArray(gAcid2);
1434   FreePanelArray(gSteps);
1435   FreePanelArray(gLifts);
1436   FreePanelArray(gBlockMon);
1437
1438   if BackID <> DWORD(-1) then
1439   begin
1440     gBackSize.X := 0;
1441     gBackSize.Y := 0;
1442     e_DeleteTexture(BackID);
1443     BackID := DWORD(-1);
1444   end;
1445
1446   g_Game_StopAllSounds(False);
1447   gMusic.FreeSound();
1448   g_Sound_Delete(gMapInfo.MusicName);
1449
1450   gMapInfo.Name := '';
1451   gMapInfo.Description := '';
1452   gMapInfo.MusicName := '';
1453   gMapInfo.Height := 0;
1454   gMapInfo.Width := 0;
1455
1456   gDoorMap := nil;
1457   gLiftMap := nil;
1458 end;
1459
1460 procedure g_Map_Update();
1461 var
1462   a, d, j: Integer;
1463   m: Word;
1464   s: String;
1465
1466   procedure UpdatePanelArray(var panels: TPanelArray);
1467   var
1468     i: Integer;
1469
1470   begin
1471     if panels <> nil then
1472       for i := 0 to High(panels) do
1473         panels[i].Update();
1474   end;
1475
1476 begin
1477   UpdatePanelArray(gWalls);
1478   UpdatePanelArray(gRenderBackgrounds);
1479   UpdatePanelArray(gRenderForegrounds);
1480   UpdatePanelArray(gWater);
1481   UpdatePanelArray(gAcid1);
1482   UpdatePanelArray(gAcid2);
1483   UpdatePanelArray(gSteps);
1484
1485   if gGameSettings.GameMode = GM_CTF then
1486   begin
1487     for a := FLAG_RED to FLAG_BLUE do
1488       if not (gFlags[a].State in [FLAG_STATE_NONE, FLAG_STATE_CAPTURED]) then
1489         with gFlags[a] do
1490         begin
1491           if gFlags[a].Animation <> nil then
1492             gFlags[a].Animation.Update();
1493
1494           m := g_Obj_Move(@Obj, True, True);
1495
1496           if gTime mod (GAME_TICK*2) <> 0 then
1497             Continue;
1498
1499         // Ñîïðîòèâëåíèå âîçäóõà:
1500           Obj.Vel.X := z_dec(Obj.Vel.X, 1);
1501
1502         // Òàéìàóò ïîòåðÿííîãî ôëàãà, ëèáî îí âûïàë çà êàðòó:
1503           if ((Count = 0) or ByteBool(m and MOVE_FALLOUT)) and g_Game_IsServer then
1504           begin
1505             g_Map_ResetFlag(a);
1506             gFlags[a].CaptureTime := 0;
1507             if a = FLAG_RED then
1508               s := _lc[I_PLAYER_FLAG_RED]
1509             else
1510               s := _lc[I_PLAYER_FLAG_BLUE];
1511             g_Game_Message(Format(_lc[I_MESSAGE_FLAG_RETURN], [AnsiUpperCase(s)]), 144);
1512
1513             if g_Game_IsNet then
1514               MH_SEND_FlagEvent(FLAG_STATE_RETURNED, a, 0);
1515             Continue;
1516           end;
1517
1518           if Count > 0 then
1519             Count := Count - 1;
1520
1521         // Èãðîê áåðåò ôëàã:
1522           if gPlayers <> nil then
1523           begin
1524             j := Random(Length(gPlayers)) - 1;
1525
1526             for d := 0 to High(gPlayers) do
1527             begin
1528               Inc(j);
1529               if j > High(gPlayers) then
1530                 j := 0;
1531
1532               if gPlayers[j] <> nil then
1533                 if gPlayers[j].Live and
1534                    g_Obj_Collide(@Obj, @gPlayers[j].Obj) then
1535                 begin
1536                   if gPlayers[j].GetFlag(a) then
1537                     Break;
1538                 end;
1539             end;
1540           end;
1541         end;
1542   end;
1543 end;
1544
1545 procedure g_Map_DrawPanels(PanelType: Word);
1546
1547   procedure DrawPanels(var panels: TPanelArray;
1548                        drawDoors: Boolean = False);
1549   var
1550     a: Integer;
1551
1552   begin
1553     if panels <> nil then
1554       for a := 0 to High(panels) do
1555         if not (drawDoors xor panels[a].Door) then
1556           panels[a].Draw();
1557   end;
1558
1559 begin
1560   case PanelType of
1561     PANEL_WALL:       DrawPanels(gWalls);
1562     PANEL_CLOSEDOOR:  DrawPanels(gWalls, True);
1563     PANEL_BACK:       DrawPanels(gRenderBackgrounds);
1564     PANEL_FORE:       DrawPanels(gRenderForegrounds);
1565     PANEL_WATER:      DrawPanels(gWater);
1566     PANEL_ACID1:      DrawPanels(gAcid1);
1567     PANEL_ACID2:      DrawPanels(gAcid2);
1568     PANEL_STEP:       DrawPanels(gSteps);
1569   end;
1570 end;
1571
1572 procedure g_Map_DrawBack(dx, dy: Integer);
1573 begin
1574   if gDrawBackGround and (BackID <> DWORD(-1)) then
1575     e_DrawSize(BackID, dx, dy, 0, False, False, gBackSize.X, gBackSize.Y)
1576   else
1577     e_Clear(GL_COLOR_BUFFER_BIT, 0, 0, 0);
1578 end;
1579
1580 function g_Map_CollidePanel(X, Y: Integer; Width, Height: Word;
1581                             PanelType: Word; b1x3: Boolean): Boolean;
1582 var
1583   a, h: Integer;
1584 begin
1585  Result := False;
1586
1587  if WordBool(PanelType and PANEL_WALL) then
1588     if gWalls <> nil then
1589     begin
1590       h := High(gWalls);
1591
1592       for a := 0 to h do
1593         if gWalls[a].Enabled and
1594         g_Collide(X, Y, Width, Height,
1595                   gWalls[a].X, gWalls[a].Y,
1596                   gWalls[a].Width, gWalls[a].Height) then
1597         begin
1598           Result := True;
1599           Exit;
1600         end;
1601     end;
1602
1603   if WordBool(PanelType and PANEL_WATER) then
1604     if gWater <> nil then
1605     begin
1606       h := High(gWater);
1607
1608       for a := 0 to h do
1609       if g_Collide(X, Y, Width, Height,
1610                    gWater[a].X, gWater[a].Y,
1611                    gWater[a].Width, gWater[a].Height) then
1612       begin
1613         Result := True;
1614         Exit;
1615       end;
1616     end;
1617
1618   if WordBool(PanelType and PANEL_ACID1) then
1619     if gAcid1 <> nil then
1620     begin
1621       h := High(gAcid1);
1622
1623       for a := 0 to h do
1624         if g_Collide(X, Y, Width, Height,
1625                      gAcid1[a].X, gAcid1[a].Y,
1626                      gAcid1[a].Width, gAcid1[a].Height) then
1627         begin
1628           Result := True;
1629           Exit;
1630         end;
1631     end;
1632
1633   if WordBool(PanelType and PANEL_ACID2) then
1634     if gAcid2 <> nil then
1635     begin
1636       h := High(gAcid2);
1637
1638       for a := 0 to h do
1639         if g_Collide(X, Y, Width, Height,
1640                      gAcid2[a].X, gAcid2[a].Y,
1641                      gAcid2[a].Width, gAcid2[a].Height) then
1642         begin
1643           Result := True;
1644           Exit;
1645         end;
1646     end;
1647
1648   if WordBool(PanelType and PANEL_STEP) then
1649     if gSteps <> nil then
1650     begin
1651       h := High(gSteps);
1652
1653       for a := 0 to h do
1654         if g_Collide(X, Y, Width, Height,
1655                      gSteps[a].X, gSteps[a].Y,
1656                      gSteps[a].Width, gSteps[a].Height) then
1657         begin
1658           Result := True;
1659           Exit;
1660         end;
1661     end;
1662
1663   if WordBool(PanelType and (PANEL_LIFTUP or PANEL_LIFTDOWN or PANEL_LIFTLEFT or PANEL_LIFTRIGHT)) then
1664     if gLifts <> nil then
1665     begin
1666       h := High(gLifts);
1667
1668       for a := 0 to h do
1669         if ((WordBool(PanelType and (PANEL_LIFTUP)) and (gLifts[a].LiftType = 0)) or
1670            (WordBool(PanelType and (PANEL_LIFTDOWN)) and (gLifts[a].LiftType = 1)) or
1671            (WordBool(PanelType and (PANEL_LIFTLEFT)) and (gLifts[a].LiftType = 2)) or
1672            (WordBool(PanelType and (PANEL_LIFTRIGHT)) and (gLifts[a].LiftType = 3))) and
1673            g_Collide(X, Y, Width, Height,
1674            gLifts[a].X, gLifts[a].Y,
1675            gLifts[a].Width, gLifts[a].Height) then
1676         begin
1677           Result := True;
1678           Exit;
1679         end;
1680     end;
1681
1682   if WordBool(PanelType and PANEL_BLOCKMON) then
1683     if gBlockMon <> nil then
1684     begin
1685       h := High(gBlockMon);
1686
1687       for a := 0 to h do
1688         if ( (not b1x3) or
1689              ((gBlockMon[a].Width + gBlockMon[a].Height) >= 64) ) and
1690            g_Collide(X, Y, Width, Height,
1691            gBlockMon[a].X, gBlockMon[a].Y,
1692            gBlockMon[a].Width, gBlockMon[a].Height) then
1693         begin
1694           Result := True;
1695           Exit;
1696         end;
1697     end;
1698 end;
1699
1700 function g_Map_CollideLiquid_Texture(X, Y: Integer; Width, Height: Word): DWORD;
1701 var
1702   a, h: Integer;
1703 begin
1704   Result := TEXTURE_NONE;
1705
1706   if gWater <> nil then
1707   begin
1708     h := High(gWater);
1709
1710     for a := 0 to h do
1711       if g_Collide(X, Y, Width, Height,
1712                    gWater[a].X, gWater[a].Y,
1713                    gWater[a].Width, gWater[a].Height) then
1714       begin
1715         Result := gWater[a].GetTextureID();
1716         Exit;
1717       end;
1718   end;
1719
1720   if gAcid1 <> nil then
1721   begin
1722     h := High(gAcid1);
1723
1724     for a := 0 to h do
1725       if g_Collide(X, Y, Width, Height,
1726                    gAcid1[a].X, gAcid1[a].Y,
1727                    gAcid1[a].Width, gAcid1[a].Height) then
1728       begin
1729         Result := gAcid1[a].GetTextureID();
1730         Exit;
1731       end;
1732   end;
1733
1734   if gAcid2 <> nil then
1735   begin
1736     h := High(gAcid2);
1737
1738     for a := 0 to h do
1739       if g_Collide(X, Y, Width, Height,
1740                    gAcid2[a].X, gAcid2[a].Y,
1741                    gAcid2[a].Width, gAcid2[a].Height) then
1742       begin
1743         Result := gAcid2[a].GetTextureID();
1744         Exit;
1745       end;
1746   end;
1747 end;
1748
1749 procedure g_Map_EnableWall(ID: DWORD);
1750 begin
1751   with gWalls[ID] do
1752   begin
1753     Enabled := True;
1754     g_Mark(X, Y, Width, Height, MARK_DOOR, True);
1755
1756     if g_Game_IsServer and g_Game_IsNet then MH_SEND_PanelState(PanelType, ID);
1757   end;
1758 end;
1759
1760 procedure g_Map_DisableWall(ID: DWORD);
1761 begin
1762   with gWalls[ID] do
1763   begin
1764     Enabled := False;
1765     g_Mark(X, Y, Width, Height, MARK_DOOR, False);
1766
1767     if g_Game_IsServer and g_Game_IsNet then MH_SEND_PanelState(PanelType, ID);
1768   end;
1769 end;
1770
1771 procedure g_Map_SwitchTexture(PanelType: Word; ID: DWORD; AnimLoop: Byte = 0);
1772 var
1773   tp: TPanel;
1774 begin
1775   case PanelType of
1776     PANEL_WALL, PANEL_OPENDOOR, PANEL_CLOSEDOOR:
1777       tp := gWalls[ID];
1778     PANEL_FORE:
1779       tp := gRenderForegrounds[ID];
1780     PANEL_BACK:
1781       tp := gRenderBackgrounds[ID];
1782     PANEL_WATER:
1783       tp := gWater[ID];
1784     PANEL_ACID1:
1785       tp := gAcid1[ID];
1786     PANEL_ACID2:
1787       tp := gAcid2[ID];
1788     PANEL_STEP:
1789       tp := gSteps[ID];
1790     else
1791       Exit;
1792   end;
1793
1794   tp.NextTexture(AnimLoop);
1795   if g_Game_IsServer and g_Game_IsNet then
1796     MH_SEND_PanelTexture(PanelType, ID, AnimLoop);
1797 end;
1798
1799 procedure g_Map_SetLift(ID: DWORD; t: Integer);
1800 begin
1801   if gLifts[ID].LiftType = t then
1802     Exit;
1803
1804   with gLifts[ID] do
1805   begin
1806     LiftType := t;
1807
1808     g_Mark(X, Y, Width, Height, MARK_LIFT, False);
1809
1810     if LiftType = 0 then
1811       g_Mark(X, Y, Width, Height, MARK_LIFTUP, True)
1812     else if LiftType = 1 then
1813       g_Mark(X, Y, Width, Height, MARK_LIFTDOWN, True)
1814     else if LiftType = 2 then
1815       g_Mark(X, Y, Width, Height, MARK_LIFTLEFT, True)
1816     else if LiftType = 3 then
1817       g_Mark(X, Y, Width, Height, MARK_LIFTRIGHT, True);
1818
1819     if g_Game_IsServer and g_Game_IsNet then MH_SEND_PanelState(PanelType, ID);
1820   end;
1821 end;
1822
1823 function g_Map_GetPoint(PointType: Byte; var RespawnPoint: TRespawnPoint): Boolean;
1824 var
1825   a: Integer;
1826   PointsArray: Array of TRespawnPoint;
1827 begin
1828   Result := False;
1829   SetLength(PointsArray, 0);
1830
1831   if RespawnPoints = nil then
1832     Exit;
1833
1834   for a := 0 to High(RespawnPoints) do
1835     if RespawnPoints[a].PointType = PointType then
1836     begin
1837       SetLength(PointsArray, Length(PointsArray)+1);
1838       PointsArray[High(PointsArray)] := RespawnPoints[a];
1839     end;
1840
1841   if PointsArray = nil then
1842     Exit;
1843
1844   RespawnPoint := PointsArray[Random(Length(PointsArray))];
1845   Result := True;
1846 end;
1847
1848 function g_Map_GetPointCount(PointType: Byte): Word;
1849 var
1850   a: Integer;
1851 begin
1852   Result := 0;
1853
1854   if RespawnPoints = nil then
1855     Exit;
1856
1857   for a := 0 to High(RespawnPoints) do
1858     if RespawnPoints[a].PointType = PointType then
1859       Result := Result + 1;
1860 end;
1861
1862 function g_Map_HaveFlagPoints(): Boolean;
1863 begin
1864   Result := (FlagPoints[FLAG_RED] <> nil) and (FlagPoints[FLAG_BLUE] <> nil);
1865 end;
1866
1867 procedure g_Map_ResetFlag(Flag: Byte);
1868 begin
1869   with gFlags[Flag] do
1870   begin
1871     Obj.X := -1000;
1872     Obj.Y := -1000;
1873     Obj.Vel.X := 0;
1874     Obj.Vel.Y := 0;
1875     Direction := D_LEFT;
1876     State := FLAG_STATE_NONE;
1877     if FlagPoints[Flag] <> nil then
1878     begin
1879       Obj.X := FlagPoints[Flag]^.X;
1880       Obj.Y := FlagPoints[Flag]^.Y;
1881       Direction := FlagPoints[Flag]^.Direction;
1882       State := FLAG_STATE_NORMAL;
1883     end;
1884     Count := -1;
1885   end;
1886 end;
1887
1888 procedure g_Map_DrawFlags();
1889 var
1890   i, dx: Integer;
1891   Mirror: TMirrorType;
1892 begin
1893   if gGameSettings.GameMode <> GM_CTF then
1894     Exit;
1895
1896   for i := FLAG_RED to FLAG_BLUE do
1897     with gFlags[i] do
1898       if State <> FLAG_STATE_CAPTURED then
1899       begin
1900         if State = FLAG_STATE_NONE then
1901           continue;
1902
1903         if Direction = D_LEFT then
1904           begin
1905             Mirror := M_HORIZONTAL;
1906             dx := -1;
1907           end
1908         else
1909           begin
1910             Mirror := M_NONE;
1911             dx := 1;
1912           end;
1913
1914         Animation.Draw(Obj.X+dx, Obj.Y+1, Mirror);
1915
1916         if g_debug_Frames then
1917         begin
1918           e_DrawQuad(Obj.X+Obj.Rect.X,
1919                      Obj.Y+Obj.Rect.Y,
1920                      Obj.X+Obj.Rect.X+Obj.Rect.Width-1,
1921                      Obj.Y+Obj.Rect.Y+Obj.Rect.Height-1,
1922                      0, 255, 0);
1923         end;
1924       end;
1925 end;
1926
1927 procedure g_Map_SaveState(Var Mem: TBinMemoryWriter);
1928 var
1929   dw: DWORD;
1930   b: Byte;
1931   str: String;
1932   boo: Boolean;
1933
1934   procedure SavePanelArray(var panels: TPanelArray);
1935   var
1936     PAMem: TBinMemoryWriter;
1937     i: Integer;
1938   begin
1939   // Ñîçäàåì íîâûé ñïèñîê ñîõðàíÿåìûõ ïàíåëåé:
1940     PAMem := TBinMemoryWriter.Create((Length(panels)+1) * 40);
1941
1942     i := 0;
1943     while i < Length(panels) do
1944     begin
1945       if panels[i].SaveIt then
1946       begin
1947       // ID ïàíåëè:
1948         PAMem.WriteInt(i);
1949       // Ñîõðàíÿåì ïàíåëü:
1950         panels[i].SaveState(PAMem);
1951       end;
1952       Inc(i);
1953     end;
1954
1955   // Ñîõðàíÿåì ýòîò ñïèñîê ïàíåëåé:
1956     PAMem.SaveToMemory(Mem);
1957     PAMem.Free();
1958   end;
1959
1960   procedure SaveFlag(flag: PFlag);
1961   begin
1962   // Ñèãíàòóðà ôëàãà:
1963     dw := FLAG_SIGNATURE; // 'FLAG'
1964     Mem.WriteDWORD(dw);
1965   // Âðåìÿ ïåðåïîÿâëåíèÿ ôëàãà:
1966     Mem.WriteByte(flag^.RespawnType);
1967   // Ñîñòîÿíèå ôëàãà:
1968     Mem.WriteByte(flag^.State);
1969   // Íàïðàâëåíèå ôëàãà:
1970     if flag^.Direction = D_LEFT then
1971       b := 1
1972     else // D_RIGHT
1973       b := 2;
1974     Mem.WriteByte(b);
1975   // Îáúåêò ôëàãà:
1976     Obj_SaveState(@flag^.Obj, Mem);
1977   end;
1978
1979 begin
1980   Mem := TBinMemoryWriter.Create(1024 * 1024); // 1 MB
1981
1982 ///// Ñîõðàíÿåì ñïèñêè ïàíåëåé: /////
1983 // Ñîõðàíÿåì ïàíåëè ñòåí è äâåðåé:
1984   SavePanelArray(gWalls);
1985 // Ñîõðàíÿåì ïàíåëè ôîíà:
1986   SavePanelArray(gRenderBackgrounds);
1987 // Ñîõðàíÿåì ïàíåëè ïåðåäíåãî ïëàíà:
1988   SavePanelArray(gRenderForegrounds);
1989 // Ñîõðàíÿåì ïàíåëè âîäû:
1990   SavePanelArray(gWater);
1991 // Ñîõðàíÿåì ïàíåëè êèñëîòû-1:
1992   SavePanelArray(gAcid1);
1993 // Ñîõðàíÿåì ïàíåëè êèñëîòû-2:
1994   SavePanelArray(gAcid2);
1995 // Ñîõðàíÿåì ïàíåëè ñòóïåíåé:
1996   SavePanelArray(gSteps);
1997 // Ñîõðàíÿåì ïàíåëè ëèôòîâ:
1998   SavePanelArray(gLifts);
1999 ///// /////
2000
2001 ///// Ñîõðàíÿåì ìóçûêó: /////
2002 // Ñèãíàòóðà ìóçûêè:
2003   dw := MUSIC_SIGNATURE; // 'MUSI'
2004   Mem.WriteDWORD(dw);
2005 // Íàçâàíèå ìóçûêè:
2006   Assert(gMusic <> nil, 'g_Map_SaveState: gMusic = nil');
2007   if gMusic.NoMusic then
2008     str := ''
2009   else
2010     str := gMusic.Name;
2011   Mem.WriteString(str, 64);
2012 // Ïîçèöèÿ ïðîèãðûâàíèÿ ìóçûêè:
2013   dw := gMusic.GetPosition();
2014   Mem.WriteDWORD(dw);
2015 // Ñòîèò ëè ìóçûêà íà ñïåö-ïàóçå:
2016   boo := gMusic.SpecPause;
2017   Mem.WriteBoolean(boo);
2018 ///// /////
2019
2020 ///// Ñîõðàíÿåì êîëè÷åñòâî ìîíñòðîâ: /////
2021   Mem.WriteInt(gTotalMonsters);
2022 ///// /////
2023
2024 //// Ñîõðàíÿåì ôëàãè, åñëè ýòî CTF: /////
2025   if gGameSettings.GameMode = GM_CTF then
2026   begin
2027   // Ôëàã Êðàñíîé êîìàíäû:
2028     SaveFlag(@gFlags[FLAG_RED]);
2029   // Ôëàã Ñèíåé êîìàíäû:
2030     SaveFlag(@gFlags[FLAG_BLUE]);
2031   end;
2032 ///// /////
2033
2034 ///// Ñîõðàíÿåì êîëè÷åñòâî ïîáåä, åñëè ýòî TDM/CTF: /////
2035   if gGameSettings.GameMode in [GM_TDM, GM_CTF] then
2036   begin
2037   // Î÷êè Êðàñíîé êîìàíäû:
2038     Mem.WriteSmallInt(gTeamStat[TEAM_RED].Goals);
2039   // Î÷êè Ñèíåé êîìàíäû:
2040     Mem.WriteSmallInt(gTeamStat[TEAM_BLUE].Goals);
2041   end;
2042 ///// /////
2043 end;
2044
2045 procedure g_Map_LoadState(Var Mem: TBinMemoryReader);
2046 var
2047   dw: DWORD;
2048   b: Byte;
2049   str: String;
2050   boo: Boolean;
2051
2052   procedure LoadPanelArray(var panels: TPanelArray);
2053   var
2054     PAMem: TBinMemoryReader;
2055     i, id: Integer;
2056   begin
2057   // Çàãðóæàåì òåêóùèé ñïèñîê ïàíåëåé:
2058     PAMem := TBinMemoryReader.Create();
2059     PAMem.LoadFromMemory(Mem);
2060
2061     for i := 0 to Length(panels)-1 do
2062       if panels[i].SaveIt then
2063       begin
2064       // ID ïàíåëè:
2065         PAMem.ReadInt(id);
2066         if id <> i then
2067         begin
2068           raise EBinSizeError.Create('g_Map_LoadState: LoadPanelArray: Wrong Panel ID');
2069         end;
2070       // Çàãðóæàåì ïàíåëü:
2071         panels[i].LoadState(PAMem);
2072       end;
2073
2074   // Ýòîò ñïèñîê ïàíåëåé çàãðóæåí:
2075     PAMem.Free();
2076   end;
2077
2078   procedure LoadFlag(flag: PFlag);
2079   begin
2080   // Ñèãíàòóðà ôëàãà:
2081     Mem.ReadDWORD(dw);
2082     if dw <> FLAG_SIGNATURE then // 'FLAG'
2083     begin
2084       raise EBinSizeError.Create('g_Map_LoadState: LoadFlag: Wrong Flag Signature');
2085     end;
2086   // Âðåìÿ ïåðåïîÿâëåíèÿ ôëàãà:
2087     Mem.ReadByte(flag^.RespawnType);
2088   // Ñîñòîÿíèå ôëàãà:
2089     Mem.ReadByte(flag^.State);
2090   // Íàïðàâëåíèå ôëàãà:
2091     Mem.ReadByte(b);
2092     if b = 1 then
2093       flag^.Direction := D_LEFT
2094     else // b = 2
2095       flag^.Direction := D_RIGHT;
2096   // Îáúåêò ôëàãà:
2097     Obj_LoadState(@flag^.Obj, Mem);
2098   end;
2099
2100 begin
2101   if Mem = nil then
2102     Exit;
2103
2104 ///// Çàãðóæàåì ñïèñêè ïàíåëåé: /////
2105 // Çàãðóæàåì ïàíåëè ñòåí è äâåðåé:
2106   LoadPanelArray(gWalls);
2107 // Çàãðóæàåì ïàíåëè ôîíà:
2108   LoadPanelArray(gRenderBackgrounds);
2109 // Çàãðóæàåì ïàíåëè ïåðåäíåãî ïëàíà:
2110   LoadPanelArray(gRenderForegrounds);
2111 // Çàãðóæàåì ïàíåëè âîäû:
2112   LoadPanelArray(gWater);
2113 // Çàãðóæàåì ïàíåëè êèñëîòû-1:
2114   LoadPanelArray(gAcid1);
2115 // Çàãðóæàåì ïàíåëè êèñëîòû-2:
2116   LoadPanelArray(gAcid2);
2117 // Çàãðóæàåì ïàíåëè ñòóïåíåé:
2118   LoadPanelArray(gSteps);
2119 // Çàãðóæàåì ïàíåëè ëèôòîâ:
2120   LoadPanelArray(gLifts);
2121 ///// /////
2122
2123 // Îáíîâëÿåì êàðòó ñòîëêíîâåíèé:
2124   g_GFX_Init();
2125
2126 ///// Çàãðóæàåì ìóçûêó: /////
2127 // Ñèãíàòóðà ìóçûêè:
2128   Mem.ReadDWORD(dw);
2129   if dw <> MUSIC_SIGNATURE then // 'MUSI'
2130   begin
2131     raise EBinSizeError.Create('g_Map_LoadState: Wrong Music Signature');
2132   end;
2133 // Íàçâàíèå ìóçûêè:
2134   Assert(gMusic <> nil, 'g_Map_LoadState: gMusic = nil');
2135   Mem.ReadString(str);
2136 // Ïîçèöèÿ ïðîèãðûâàíèÿ ìóçûêè:
2137   Mem.ReadDWORD(dw);
2138 // Ñòîèò ëè ìóçûêà íà ñïåö-ïàóçå:
2139   Mem.ReadBoolean(boo);
2140 // Çàïóñêàåì ýòó ìóçûêó:
2141   gMusic.SetByName(str);
2142   gMusic.SpecPause := boo;
2143   gMusic.Play();
2144   gMusic.Pause(True);
2145   gMusic.SetPosition(dw);
2146 ///// /////
2147
2148 ///// Çàãðóæàåì êîëè÷åñòâî ìîíñòðîâ: /////
2149   Mem.ReadInt(gTotalMonsters);
2150 ///// /////
2151
2152 //// Çàãðóæàåì ôëàãè, åñëè ýòî CTF: /////
2153   if gGameSettings.GameMode = GM_CTF then
2154   begin
2155   // Ôëàã Êðàñíîé êîìàíäû:
2156     LoadFlag(@gFlags[FLAG_RED]);
2157   // Ôëàã Ñèíåé êîìàíäû:
2158     LoadFlag(@gFlags[FLAG_BLUE]);
2159   end;
2160 ///// /////
2161
2162 ///// Çàãðóæàåì êîëè÷åñòâî ïîáåä, åñëè ýòî TDM/CTF: /////
2163   if gGameSettings.GameMode in [GM_TDM, GM_CTF] then
2164   begin
2165   // Î÷êè Êðàñíîé êîìàíäû:
2166     Mem.ReadSmallInt(gTeamStat[TEAM_RED].Goals);
2167   // Î÷êè Ñèíåé êîìàíäû:
2168     Mem.ReadSmallInt(gTeamStat[TEAM_BLUE].Goals);
2169   end;
2170 ///// /////
2171 end;
2172
2173 end.