Changeset 703 for trunk/MiniMap.pas

Timestamp:

Aug 12, 2025, 3:03:54 PM (36 hours ago)

Author:

chronos

Message:

• Fixed: Potential mini map loading memory issue if saved map is too big.
• Fixed: Drawing map preview last line.

File:

• trunk/MiniMap.pas (modified) (9 diffs)

trunk/MiniMap.pas

@@ -10 +10 @@
 type
   TMiniMode = (mmNone, mmPicture, mmMultiPlayer);
-  TMapArray = array[0 .. lxmax * lymax - 1] of Byte;
+  TMapArray = array [0 .. lxmax * lymax - 1] of Byte;
 
   { TMiniMap }
@@ -70 +70 @@
 var
   SaveMap: TMapArray;
-  y: Integer;
-  Dummy: Integer;
+  Version: Cardinal;
   FileLandMass: Integer;
-  LogFile: file;
-  s: string[255];
-  MapRow: array [0 .. lxmax - 1] of Cardinal;
-begin
-  AssignFile(LogFile, FileName);
+  LogFile: TFileStream;
+  ReadFileId: string;
+  ExeInfoTime: LongInt;
+  RNG: Integer;
+  MaxTurn: Integer;
+const
+  FileId = 'cEvoBook';
+begin
+  Version := 0;
+  ExeInfoTime := 0;
+  FileLandMass := 0;
+  MaxTurn := 0;
+  RNG := 0;
+
+  LogFile := TFileStream.Create(FileName, fmOpenRead or fmShareExclusive);
   try
-    Reset(LogFile, 4);
-    BlockRead(LogFile, s[1], 2); { file id }
-    BlockRead(LogFile, Dummy, 1); { format id }
-    if Dummy >= $000E01 then
-      BlockRead(LogFile, Dummy, 1); { item stored since 0.14.1 }
-    BlockRead(LogFile, Size.X, 1);
-    BlockRead(LogFile, Size.Y, 1);
-    BlockRead(LogFile, FileLandMass, 1);
+    ReadFileId := default(string);
+    SetLength(ReadFileId, 8);
+    LogFile.Read(ReadFileId[1], 8); { file id }
+    if ReadFileId <> FileId then
+      raise Exception.Create('Incorrect game file id. Expected ''' + Trim(FileId) +
+        ''' but ''' + Trim(ReadFileId) + ''' read.');
+    LogFile.Read(Version, 4); { format id }
+    if Version >= $000E01 then
+      LogFile.Read(ExeInfoTime, 4); { item stored since 0.14.1 }
+    LogFile.Read(Size.X, 4);
+    LogFile.Read(Size.Y, 4);
+    LogFile.Read(FileLandMass, 4);
+
     if FileLandMass = 0 then
-      for y := 0 to Size.Y - 1 do
-        BlockRead(LogFile, MapRow, Size.X);
-    BlockRead(LogFile, Dummy, 1);
-    BlockRead(LogFile, Dummy, 1);
-    BlockRead(LogFile, LastTurn, 1);
-    BlockRead(LogFile, SaveMap, 1);
+      LogFile.Seek(Size.Y * Size.X * 4, soCurrent);
+    LogFile.Read(MaxTurn, 4);
+    LogFile.Read(RNG, 4);
+    LogFile.Read(LastTurn, 4);
+    LogFile.Read(SaveMap, 4);
     if SaveMap[0] = $80 then
       Mode := mmMultiPlayer
@@ -99 +112 @@
       Mode := mmPicture;
     if Mode = mmPicture then
-      BlockRead(LogFile, SaveMap[4], (Size.X * Size.Y - 1) div 4);
-    CloseFile(LogFile);
+      if Size.X * Size.Y <= Length(SaveMap) then
+        LogFile.Read(SaveMap[4], Size.X * Size.Y - 4)
+        else raise Exception.Create('Saved map data too big [' + IntToStr(Size.X) + 'x' + IntToStr(Size.Y) + ']');
+    LogFile.Free;
   except
-    CloseFile(LogFile);
+    LogFile.Free;
     LastTurn := 0;
     Size := DefaultSize;
@@ -163 +178 @@
 procedure TMiniMap.PaintMap(Map: TMap);
 var
-  i, x, y, xm, cm, Tile: Integer;
+  I, X, Y, XM, CM, Tile: Integer;
   MiniPixel: TPixelPointer;
   PrevMiniPixel: TPixelPointer;
-  xx, yy: Integer;
+  XX, YY: Integer;
 begin
   Bitmap.PixelFormat := TPixelFormat.pf24bit;
@@ -174 +189 @@
     MiniPixel := TPixelPointer.Create(Bitmap);
     PrevMiniPixel := TPixelPointer.Create(Bitmap);
-    xx := ScaleToNative(Size.X);
-    yy := ScaleToNative(Size.Y);
-    for y := 0 to yy - 1 do begin
-      for x := 0 to xx - 1 do begin
-        for i := 0 to 1 do begin
-          xm := (x * 2 + i + y and 1) mod (xx * 2);
-          MiniPixel.SetX(xm);
-          Tile := Map.Tiles[ScaleFromNative(x) + Size.X * ScaleFromNative(y)];
-          if Tile and fTerrain = fUNKNOWN then cm := $000000
-            else cm := Colors[Tile and fTerrain, i];
-          // TODO: Needs to use (yy - 1) to avoid access violation for unknown reason
+    XX := ScaleToNative(Size.X);
+    YY := ScaleToNative(Size.Y);
+    for Y := 0 to YY - 1 do begin
+      for X := 0 to XX - 1 do begin
+        for I := 0 to 1 do begin
+          XM := (X * 2 + I + Y and 1) mod (XX * 2);
+          MiniPixel.SetX(XM);
+          Tile := Map.Tiles[ScaleFromNative(X) + Size.X * ScaleFromNative(Y)];
+          if Tile and fTerrain = fUNKNOWN then CM := $000000
+            else CM := Colors[Tile and fTerrain, I];
           if (PByte(MiniPixel.Pixel) >= Bitmap.RawImage.Data) and
-          (PByte(MiniPixel.Pixel) < (Bitmap.RawImage.Data + (yy - 1) * MiniPixel.BytesPerLine)) then begin
-            MiniPixel.PixelB := (cm shr 16) and $ff;
-            MiniPixel.PixelG := (cm shr 8) and $ff;
-            MiniPixel.PixelR := (cm shr 0) and $ff;
+          (PByte(MiniPixel.Pixel) < (Bitmap.RawImage.Data + YY * MiniPixel.BytesPerLine)) then begin
+            MiniPixel.PixelB := (CM shr 16) and $ff;
+            MiniPixel.PixelG := (CM shr 8) and $ff;
+            MiniPixel.PixelR := (CM shr 0) and $ff;
           end;
         end;
       end;
       MiniPixel.NextLine;
-      if y > 0 then PrevMiniPixel.NextLine;
+      if Y > 0 then PrevMiniPixel.NextLine;
     end;
     Bitmap.EndUpdate;
@@ -202 +216 @@
 procedure TMiniMap.PaintRandom(Brightness, StartLandMass: Integer; WorldSize: TPoint);
 var
-  i, x, y, xm, cm: Integer;
+  I, X, Y, XM, CM: Integer;
   MiniPixel: TPixelPointer;
   Map: ^TTileList;
-  xx, yy: Integer;
+  XX, YY: Integer;
 begin
   Map := PreviewMap(StartLandMass);
@@ -214 +228 @@
   Bitmap.BeginUpdate;
   MiniPixel := TPixelPointer.Create(Bitmap);
-  xx := ScaleToNative(Size.X);
-  yy := ScaleToNative(Size.Y);
-  for y := 0 to yy - 1 do begin
-    for x := 0 to xx - 1 do begin
-      for i := 0 to 1 do begin
-        xm := (x * 2 + i + y and 1) mod (xx * 2);
-        MiniPixel.SetX(xm);
-        cm := Colors[Map[ScaleFromNative(x) * lxmax div Size.X + lxmax *
-          ((ScaleFromNative(y) * (lymax - 1) + Size.Y div 2) div (Size.Y - 1))] and
+  XX := ScaleToNative(Size.X);
+  YY := ScaleToNative(Size.Y);
+  for Y := 0 to YY - 1 do begin
+    for X := 0 to XX - 1 do begin
+      for I := 0 to 1 do begin
+        XM := (X * 2 + I + Y and 1) mod (XX * 2);
+        MiniPixel.SetX(XM);
+        CM := Colors[Map[ScaleFromNative(X) * lxmax div Size.X + lxmax *
+          ((ScaleFromNative(Y) * (lymax - 1) + Size.Y div 2) div (Size.Y - 1))] and
           fTerrain, I];
         if (PByte(MiniPixel.Pixel) >= Bitmap.RawImage.Data) and
-        (PByte(MiniPixel.Pixel) < (Bitmap.RawImage.Data + yy * MiniPixel.BytesPerLine)) then begin
-          MiniPixel.PixelB := ((cm shr 16) and $FF) * Brightness div 3;
-          MiniPixel.PixelG := ((cm shr 8) and $FF) * Brightness div 3;
-          MiniPixel.PixelR := ((cm shr 0) and $FF) * Brightness div 3;
+        (PByte(MiniPixel.Pixel) < (Bitmap.RawImage.Data + YY * MiniPixel.BytesPerLine)) then begin
+          MiniPixel.PixelB := ((CM shr 16) and $FF) * Brightness div 3;
+          MiniPixel.PixelG := ((CM shr 8) and $FF) * Brightness div 3;
+          MiniPixel.PixelR := ((CM shr 0) and $FF) * Brightness div 3;
         end;
       end;
@@ -239 +253 @@
 procedure TMiniMap.PaintFile(SaveMap: TMapArray);
 var
-  i, x, y, xm, cm, Tile, OwnColor, EnemyColor: integer;
+  I, X, Y, XM, CM, Tile, OwnColor, EnemyColor: Integer;
   MiniPixel: TPixelPointer;
   PrevMiniPixel: TPixelPointer;
-  xx, yy: Integer;
+  XX, YY: Integer;
 begin
   OwnColor := HGrSystem.Data.Canvas.Pixels[95, 67];
@@ -252 +266 @@
     MiniPixel := TPixelPointer.Create(Bitmap);
     PrevMiniPixel := TPixelPointer.Create(Bitmap);
-    xx := ScaleToNative(Size.X);
-    yy := ScaleToNative(Size.Y);
-    for y := 0 to yy - 1 do begin
-      for x := 0 to xx - 1 do begin
-        for i := 0 to 1 do begin
-          xm := (x * 2 + i + y and 1) mod (xx * 2);
-          MiniPixel.SetX(xm);
-          Tile := SaveMap[ScaleFromNative(x) + Size.X * ScaleFromNative(y)];
+    XX := ScaleToNative(Size.X);
+    YY := ScaleToNative(Size.Y);
+    for Y := 0 to YY - 1 do begin
+      for X := 0 to XX - 1 do begin
+        for I := 0 to 1 do begin
+          XM := (X * 2 + I + Y and 1) mod (XX * 2);
+          MiniPixel.SetX(XM);
+          Tile := SaveMap[ScaleFromNative(X) + Size.X * ScaleFromNative(Y)];
           if Tile and fTerrain = fUNKNOWN then
-            cm := $000000
+            CM := $000000
           else if Tile and smCity <> 0 then begin
-            if Tile and smOwned <> 0 then cm := OwnColor
-              else cm := EnemyColor;
-            if y > 0 then begin
+            if Tile and smOwned <> 0 then CM := OwnColor
+              else CM := EnemyColor;
+            if Y > 0 then begin
               // 2x2 city dot covers two lines
-              PrevMiniPixel.SetX(xm);
+              PrevMiniPixel.SetX(XM);
               if (PByte(PrevMiniPixel.Pixel) >= Bitmap.RawImage.Data) and
-              (PByte(PrevMiniPixel.Pixel) < (Bitmap.RawImage.Data + yy * PrevMiniPixel.BytesPerLine)) then begin
-                PrevMiniPixel.PixelB := cm shr 16;
-                PrevMiniPixel.PixelG:= cm shr 8 and $FF;
-                PrevMiniPixel.PixelR := cm and $FF;
+              (PByte(PrevMiniPixel.Pixel) < (Bitmap.RawImage.Data + YY * PrevMiniPixel.BytesPerLine)) then begin
+                PrevMiniPixel.PixelB := CM shr 16;
+                PrevMiniPixel.PixelG:= CM shr 8 and $FF;
+                PrevMiniPixel.PixelR := CM and $FF;
               end;
             end;
           end
-          else if (i = 0) and (Tile and smUnit <> 0) then begin
-            if Tile and smOwned <> 0 then cm := OwnColor
-              else cm := EnemyColor;
+          else if (I = 0) and (Tile and smUnit <> 0) then begin
+            if Tile and smOwned <> 0 then CM := OwnColor
+              else CM := EnemyColor;
           end else
-            cm := Colors[Tile and fTerrain, i];
+            CM := Colors[Tile and fTerrain, I];
           if (PByte(MiniPixel.Pixel) >= Bitmap.RawImage.Data) and
-          (PByte(MiniPixel.Pixel) < (Bitmap.RawImage.Data + yy * MiniPixel.BytesPerLine)) then begin
-            MiniPixel.PixelB := (cm shr 16) and $ff;
-            MiniPixel.PixelG := (cm shr 8) and $ff;
-            MiniPixel.PixelR := (cm shr 0) and $ff;
+          (PByte(MiniPixel.Pixel) < (Bitmap.RawImage.Data + YY * MiniPixel.BytesPerLine)) then begin
+            MiniPixel.PixelB := (CM shr 16) and $ff;
+            MiniPixel.PixelG := (CM shr 8) and $ff;
+            MiniPixel.PixelR := (CM shr 0) and $ff;
           end;
         end;
       end;
       MiniPixel.NextLine;
-      if y > 0 then PrevMiniPixel.NextLine;
+      if Y > 0 then PrevMiniPixel.NextLine;
     end;
     Bitmap.EndUpdate;