Changeset 39 for trunk/UGame.pas

Timestamp:

Mar 10, 2014, 11:01:14 PM (11 years ago)

Author:

chronos

Message:

• Added: Option to create hexagonal or square map. This is implemented using object inheritance and virtual methods of class TMap.
• Added: Dummy actions to load and save map.

File:

• trunk/UGame.pas (modified) (31 diffs)

trunk/UGame.pas

@@ -6 +6 @@
 
 uses
-  Classes, SysUtils, ExtCtrls, Graphics, Contnrs, XMLConf;
+  Classes, SysUtils, ExtCtrls, Graphics, Contnrs, XMLConf, XMLRead, XMLWrite,
+  DOM;
 
 const
@@ -46 +47 @@
 
   TCellArray = array of TCell;
-
-  { TMap }
-
-  TMap = class
-
-  end;
 
   { TView }
@@ -80 +75 @@
   end;
 
-  { THexMap }
-
-  THexMap = class(TMap)
+  { TMap }
+
+  TMap = class
   private
-    FSize: TPoint;
-    procedure SetSize(AValue: TPoint);
+    function GetSize: TPoint; virtual;
+    procedure SetSize(AValue: TPoint); virtual;
   public
     Game: TGame;
     MaxPower: Integer;
     DefaultCellSize: TPoint;
+    function IsCellsNeighbor(Cell1, Cell2: TCell): Boolean; virtual;
+    function IsValidIndex(Index: TPoint): Boolean; virtual;
+    procedure Assign(Source: TMap); virtual;
+    procedure LoadFromFile(FileName: string); virtual;
+    procedure SaveToFile(FileName: string); virtual;
+    function PosToCell(Pos: TPoint; View: TView): TCell; virtual;
+    function CellToPos(Cell: TCell): TPoint; virtual;
+    procedure Grow(APlayer: TPlayer); virtual;
+    procedure ComputePlayerStats; virtual;
+    constructor Create; virtual;
+    destructor Destroy; override;
+    function GetCellNeighbours(Cell: TCell): TCellArray; virtual;
+    procedure Paint(Canvas: TCanvas; View: TView); virtual;
+    function GetPixelRect: TRect; virtual;
+    function GetAllCells: TCellArray; virtual;
+    procedure ForEachCells(Method: TMethod); virtual;
+    property Size: TPoint read GetSize write SetSize;
+  end;
+
+  { THexMap }
+
+  THexMap = class(TMap)
+  private
+    FSize: TPoint;
+    function GetSize: TPoint; override;
+    procedure SetSize(AValue: TPoint); override;
+  public
     Cells: array of array of TCell;
-    function IsValidIndex(Index: TPoint): Boolean;
-    function GetCellNeighbours(Cell: TCell): TCellArray;
-    function PosToCell(Pos: TPoint; View: TView): TCell;
-    function CellToPos(Cell: TCell; View: TView): TPoint;
+    function IsCellsNeighbor(Cell1, Cell2: TCell): Boolean; override;
+    procedure Assign(Source: TMap); virtual;
+    procedure LoadFromFile(FileName: string); override;
+    procedure SaveToFile(FileName: string); override;
+    function IsValidIndex(Index: TPoint): Boolean; override;
+    function GetCellNeighbours(Cell: TCell): TCellArray; override;
+    function PosToCell(Pos: TPoint; View: TView): TCell; override;
+    function CellToPos(Cell: TCell): TPoint; override;
     function GetHexagonPolygon(Pos: TPoint; HexSize: TPoint): TPointArray;
-    procedure Paint(Canvas: TCanvas; View: TView);
-    constructor Create;
+    procedure Paint(Canvas: TCanvas; View: TView); override;
+    constructor Create; override;
     destructor Destroy; override;
-    procedure Grow(APlayer: TPlayer);
-    procedure ComputePlayerStats;
-    function GetPixelRect: TRect;
+    function GetAllCells: TCellArray; override;
+    function GetPixelRect: TRect; override;
+  end;
+
+  { TSquareMap }
+
+  TSquareMap = class(TMap)
+  private
+    FSize: TPoint;
+    function GetSize: TPoint; override;
+    procedure SetSize(AValue: TPoint); override;
+  public
+    Cells: array of array of TCell;
+    function IsCellsNeighbor(Cell1, Cell2: TCell): Boolean; override;
+    function IsValidIndex(Index: TPoint): Boolean; override;
+    function PosToCell(Pos: TPoint; View: TView): TCell; override;
+    function CellToPos(Cell: TCell): TPoint; override;
+    function GetCellNeighbours(Cell: TCell): TCellArray; override;
+    function GetAllCells: TCellArray; override;
+    function GetPixelRect: TRect; override;
+    procedure Paint(Canvas: TCanvas; View: TView); override;
+    constructor Create; override;
+    destructor Destroy; override;
     property Size: TPoint read FSize write SetSize;
   end;
-
 
   TPlayerMode = (pmHuman, pmComputer);
@@ -162 +207 @@
   TGrowAmount = (gaByOne, gaBySquareRoot);
   TGrowCells = (gcNone, gcPlayerCities, gcPlayerAll);
+  TMapType = (mtNone, mtHexagon, mtSquare);
 
   TGame = class
   private
+    FMapType: TMapType;
     FOnMove: TMoveEvent;
     FOnWin: TWinEvent;
@@ -171 +218 @@
     procedure MoveAll(Player: TPlayer);
     procedure ClearMovesFromCell(Cell: TCell);
+    procedure SetMapType(AValue: TMapType);
     procedure SetMove(CellFrom, CellTo: TCell; Power: Integer);
     procedure SetRunning(AValue: Boolean);
@@ -176 +224 @@
   public
     Players: TPlayers;
-    Map: THexMap;
+    Map: TMap;
     VoidEnabled: Boolean;
     VoidPercentage: Integer;
@@ -195 +243 @@
     procedure New;
     property Running: Boolean read FRunning write SetRunning;
+    property MapType: TMapType read FMapType write SetMapType;
   published
     property OnMove: TMoveEvent read FOnMove write FOnMove;
@@ -218 +267 @@
   SHuman = 'Human';
   SComputer = 'Computer';
+  SCannotSetPlayerStartCells = 'Cannot choose start cell for player';
 
 procedure InitStrings;
@@ -235 +285 @@
   Result := (A.Left = B.Left) and (A.Top = B.Top) and
     (A.Right = B.Right) and (A.Bottom = B.Bottom);
+end;
+
+function PtInRect(const Rect: TRect; Pos: TPoint): Boolean;
+begin
+  Result := (Pos.X >= Rect.Left) and (Pos.Y >= Rect.Top) and
+    (Pos.X <= Rect.Right) and (Pos.Y <= Rect.Bottom);
 end;
 
@@ -244 +300 @@
   Count := Length(Points) ;
   J := Count - 1;
-  for K := 0 to Count-1 do begin
+  for K := 0 to Count - 1 do begin
   if ((Points[K].Y <= Pos.Y) and (Pos.Y < Points[J].Y)) or
     ((Points[J].Y <= Pos.Y) and (Pos.Y < Points[K].Y)) then
@@ -257 +313 @@
 end;
 
-function IsCellsNeighbor(Cell1, Cell2: TCell): Boolean;
+{ TSquareMap }
+
+function TSquareMap.GetSize: TPoint;
+begin
+  Result := FSize;
+end;
+
+procedure TSquareMap.SetSize(AValue: TPoint);
+var
+  X, Y: Integer;
+  NewCell: TCell;
+  C: Integer;
+begin
+  if (FSize.X <> AValue.X) or (FSize.Y <> AValue.Y) then begin
+    // Free previous
+    for Y := 0 to FSize.Y - 1 do
+    for X := 0 to FSize.X - 1 do begin
+      TCell(Cells[Y, X]).Destroy;
+    end;
+    FSize := AValue;
+    // Allocate and init new
+    SetLength(Cells, FSize.Y, FSize.X);
+    for Y := 0 to FSize.Y - 1 do
+    for X := 0 to FSize.X - 1 do begin
+      NewCell := TCell.Create;
+      NewCell.Pos := Point(X, Y);
+      Cells[Y, X] := NewCell;
+    end;
+  end;
+end;
+
+function TSquareMap.IsCellsNeighbor(Cell1, Cell2: TCell): Boolean;
 var
   DX: Integer;
@@ -267 +354 @@
   DX := Cell2.Pos.X - Cell1.Pos.X;
   DY := Cell2.Pos.Y - Cell1.Pos.Y;
-  Result := (Abs(DX) <= 1) and (Abs(DY) <= 1) and
-  ((((MinY mod 2) = 1) and
-    not ((DX = 1) and (DY = -1)) and
-    not ((DX = -1) and (DY = 1))) or
-    (((MinY mod 2) = 0) and
-    not ((DX = -1) and (DY = -1)) and
-    not ((DX = 1) and (DY = 1))));
+  Result := (Abs(DX) <= 1) and (Abs(DY) <= 1);
   Result := Result and not (Cell1 = Cell2);
+end;
+
+function TSquareMap.IsValidIndex(Index: TPoint): Boolean;
+begin
+  Result := (Index.X >= 0) and (Index.X < Size.X) and
+    (Index.Y >= 0) and (Index.Y < Size.Y);
+end;
+
+function TSquareMap.PosToCell(Pos: TPoint; View: TView): TCell;
+var
+  CX, CY: Integer;
+  X, Y: Double;
+  HexSize: TFloatPoint;
+  CellSize: TFloatPoint;
+  Frame: TRect;
+begin
+  // TODO: This is implemented as simple sequence lookup. Needs some faster algorithm
+  Result := nil;
+  CellSize := FloatPoint(DefaultCellSize.X, DefaultCellSize.Y);
+  HexSize := FloatPoint(DefaultCellSize.X, DefaultCellSize.Y);
+  with View do
+    for CY := Trunc(SourceRect.Top / CellSize.Y) to Trunc(SourceRect.Bottom / CellSize.Y) + 1 do
+    for CX := Trunc(SourceRect.Left / CellSize.X) to Trunc(SourceRect.Right / CellSize.X) + 1 do begin
+      X := CX;
+      Y := CY;
+      if (CX >= 0) and (CY >= 0) and (CY < Size.Y) and (CX < Size.X) then
+      if Cells[CY, CX].Terrain <> ttVoid then begin
+        Frame := Rect(Trunc(X * CellSize.X - HexSize.X / 2),
+          Trunc(Y * CellSize.Y - HexSize.Y / 2),
+          Trunc(X * CellSize.X + HexSize.X / 2),
+          Trunc(Y * CellSize.Y + HexSize.Y / 2));
+        if PtInRect(Frame, Pos) then begin
+          Result := Cells[CY, CX];
+          Exit;
+        end;
+      end;
+    end;
+end;
+
+function TSquareMap.CellToPos(Cell: TCell): TPoint;
+var
+  CX, CY: Integer;
+  X, Y: Double;
+  HexSize: TFloatPoint;
+  CellSize: TFloatPoint;
+  Points: array of TPoint;
+begin
+  CellSize := FloatPoint(DefaultCellSize.X, DefaultCellSize.Y);
+  HexSize := FloatPoint(DefaultCellSize.X, DefaultCellSize.Y);
+  X := Cell.Pos.X;
+  Y := Cell.Pos.Y;
+
+  Result.X := Trunc(X * CellSize.X);
+  Result.Y := Trunc(Y * CellSize.Y);
+end;
+
+function TSquareMap.GetCellNeighbours(Cell: TCell): TCellArray;
+var
+  X, Y: Integer;
+begin
+  SetLength(Result, 0);
+  for Y := -1 to 1 do
+  for X := -1 to 1 do
+  if IsValidIndex(Point(Cell.Pos.X + X, Cell.Pos.Y + Y)) and
+  IsCellsNeighbor(Cell, Cells[Cell.Pos.Y + Y, Cell.Pos.X + X]) then begin
+    SetLength(Result, Length(Result) + 1);
+    Result[Length(Result) - 1] := Cells[Cell.Pos.Y + Y, Cell.Pos.X + X];
+  end;
+end;
+
+function TSquareMap.GetAllCells: TCellArray;
+var
+  X: Integer;
+  Y: Integer;
+  I: Integer;
+begin
+  SetLength(Result, Size.Y * Size.X);
+  for Y := 0 to Size.Y - 1 do
+  for X := 0 to Size.X - 1 do
+    Result[Y * Size.X + X] := Cells[Y, X];
+end;
+
+function TSquareMap.GetPixelRect: TRect;
+begin
+  Result := Bounds(Trunc(-0.5 * DefaultCellSize.X),
+    Trunc(-0.5 * DefaultCellSize.Y),
+    Trunc((Size.X + 0.5) * DefaultCellSize.X),
+    Trunc(((Size.Y + 0.5) * 0.78) * DefaultCellSize.Y));
+end;
+
+procedure TSquareMap.Paint(Canvas: TCanvas; View: TView);
+var
+  CX, CY: Integer;
+  X, Y: Double;
+  CellSizeZoomed: TFloatPoint;
+  CellSize: TFloatPoint;
+  HexSize: TFloatPoint;
+  I: Integer;
+  Points: array of TPoint;
+  Cell: TCell;
+  PosFrom, PosTo: TPoint;
+
+procedure PaintHexagon(Pos: TPoint; Text: string);
+begin
+  with Canvas do begin
+    if Assigned(View.FocusedCell) and (View.FocusedCell = TCell(Cells[CY, CX])) then begin
+      Pen.Color := clYellow;
+      Pen.Style := psSolid;
+      Pen.Width := 1;
+    end else
+    if TCell(Cells[CY, CX]).Terrain = ttCity then begin
+      // Cannot set clear border as it will display shifted on gtk2
+      //Pen.Style := psClear;
+      Pen.Color := clBlack;
+      Pen.Style := psSolid;
+      Pen.Width := 3;
+    end else begin
+      // Cannot set clear border as it will display shifted on gtk2
+      //Pen.Style := psClear;
+      Pen.Color := Brush.Color;
+      Pen.Style := psSolid;
+      Pen.Width := 0;
+    end;
+    FillRect(Trunc(Pos.X - HexSize.X / 2), Trunc(Pos.Y - HexSize.Y / 2), Trunc(Pos.X + HexSize.X / 2), Trunc(Pos.Y + HexSize.Y / 2));
+    //Rectangle(Trunc(Pos.X), Trunc(Pos.Y), Trunc(Pos.X + HexSize.X), Trunc(Pos.Y + HexSize.Y));
+    Pen.Style := psSolid;
+    Font.Color := clWhite;
+    Font.Size := Trunc(12 * View.Zoom);
+    TextOut(Round(Pos.X) - TextWidth(Text) div 2, Round(Pos.Y) - TextHeight(Text) div 2, Text);
+  end;
+end;
+
+begin
+  CellSize := FloatPoint(DefaultCellSize.X, DefaultCellSize.Y);
+  HexSize := FloatPoint(DefaultCellSize.X * View.Zoom, DefaultCellSize.Y * View.Zoom);
+  CellSizeZoomed := FloatPoint(CellSize.X * View.Zoom, CellSize.Y * View.Zoom);
+  with Canvas, View do try
+    Lock;
+    for CY := Trunc(SourceRect.Top / CellSize.Y) to Trunc(SourceRect.Bottom / CellSize.Y) + 1 do
+    for CX := Trunc(SourceRect.Left / CellSize.X) to Trunc(SourceRect.Right / CellSize.X) + 1 do begin
+      X := CX;
+      Y := CY;
+      if (CX >= 0) and (CY >= 0) and (CY < Size.Y) and (CX < Size.X) then begin
+        Cell := Cells[CY, CX];
+        if Cell.Terrain <> ttVoid then begin
+          if Assigned(SelectedCell) and (SelectedCell = TCell(Cells[CY, CX])) then Brush.Color := clGreen
+            else if Assigned(SelectedCell) and IsCellsNeighbor(SelectedCell, TCell(Cells[CY, CX])) then Brush.Color := clPurple
+            else Brush.Color := Cell.GetColor;
+          Pen.Color := clBlack;
+          PaintHexagon(View.CellToCanvasPos(Point(Trunc(X * CellSize.X),
+            Trunc(Y * CellSize.Y))),
+            IntToStr(Cell.GetAvialPower));
+          // Draw arrows
+          Pen.Color := clCream;
+          for I := 0 to Cell.MovesFrom.Count - 1 do begin
+            PosFrom := CellToPos(Cell);
+            PosTo := CellToPos(TMove(Cell.MovesFrom[I]).CellTo);
+            if TMove(Cell.MovesFrom[I]).CountRepeat > 0 then Pen.Width := 2
+              else Pen.Width := 1;
+            Line(View.CellToCanvasPos(Point(Trunc(PosFrom.X + (PosTo.X - PosFrom.X) / 4),
+              Trunc(PosFrom.Y + (PosTo.Y - PosFrom.Y) / 4))),
+              View.CellToCanvasPos(Point(Trunc(PosFrom.X + (PosTo.X - PosFrom.X) / 2),
+              Trunc(PosFrom.Y + (PosTo.Y - PosFrom.Y) / 2))));
+            Pen.Width := 1;
+          end;
+        end;
+      end;
+    end;
+  finally
+    Unlock;
+  end;
+end;
+
+constructor TSquareMap.Create;
+begin
+  inherited;
+end;
+
+destructor TSquareMap.Destroy;
+begin
+  inherited Destroy;
+end;
+
+{ TMap }
+
+function TMap.GetSize: TPoint;
+begin
+  Result:= Point(0, 0);
+end;
+
+procedure TMap.SetSize(AValue: TPoint);
+begin
+
+end;
+
+function TMap.IsCellsNeighbor(Cell1, Cell2: TCell): Boolean;
+begin
+  Result := False;
+end;
+
+function TMap.IsValidIndex(Index: TPoint): Boolean;
+begin
+  Result := False;
+end;
+
+procedure TMap.Assign(Source: TMap);
+begin
+  MaxPower := Source.MaxPower;
+  Game := Source.Game;
+  Size := Source.Size;
+  DefaultCellSize := Source.DefaultCellSize;
+end;
+
+procedure TMap.LoadFromFile(FileName: string);
+begin
+
+end;
+
+procedure TMap.SaveToFile(FileName: string);
+begin
+
+end;
+
+function TMap.PosToCell(Pos: TPoint; View: TView): TCell;
+begin
+  Result := nil;
+end;
+
+function TMap.CellToPos(Cell: TCell): TPoint;
+begin
+  Result := Point(0, 0);
+end;
+
+procedure TMap.Grow(APlayer: TPlayer);
+var
+  I: Integer;
+  Addition: Integer;
+  Cells: TCellArray;
+begin
+  Cells := GetAllCells;
+  for I := 0 to Length(Cells) - 1 do
+  with TCell(Cells[I]) do begin
+    if (Player = APlayer) and ((Game.GrowCells = gcPlayerAll) or
+    ((Game.GrowCells = gcPlayerCities) and (Terrain = ttCity))) then begin
+      if Game.GrowAmount = gaByOne then Addition := 1
+        else if Game.GrowAmount = gaBySquareRoot then begin
+          Addition := Trunc(Sqrt(Power));
+          if Addition = 0 then Addition := 1;
+        end;
+      Power := Power + Addition;
+      if Power > MaxPower then Power := MaxPower;
+    end;
+  end;
+end;
+
+procedure TMap.ComputePlayerStats;
+var
+  Cells: TCellArray;
+  I: Integer;
+begin
+  Cells := GetAllCells;
+  for I := 0 to Length(Cells) - 1 do
+  with Cells[I] do begin
+    if Assigned(Player) then begin
+      Player.TotalCells := Player.TotalCells + 1;
+      Player.TotalUnits := Player.TotalUnits + Power;
+    end;
+  end;
+end;
+
+constructor TMap.Create;
+begin
+  MaxPower := 99;
+  DefaultCellSize := Point(62, 62);
+end;
+
+destructor TMap.Destroy;
+begin
+  Size := Point(0, 0);
+  inherited Destroy;
+end;
+
+function TMap.GetCellNeighbours(Cell: TCell): TCellArray;
+begin
+
+end;
+
+procedure TMap.Paint(Canvas: TCanvas; View: TView);
+begin
+
+end;
+
+function TMap.GetPixelRect: TRect;
+var
+  Cells: TCellArray;
+  I: Integer;
+  CellPos: TPoint;
+begin
+  Result := Rect(0, 0, 0, 0);
+  // This is generic iterative algorithm to determine map pixel size
+  Cells := GetAllCells;
+  for I := 0 to Length(Cells) - 1 do begin
+    CellPos := CellToPos(Cells[I]);
+    if I = 0 then Result := Rect(CellPos.X, CellPos.Y, CellPos.X, CellPos.Y)
+      else begin
+        if CellPos.X > Result.Right then Result.Right := CellPos.X;
+        if CellPos.Y > Result.Bottom then Result.Bottom := CellPos.Y;
+        if CellPos.X < Result.Left then Result.Left := CellPos.X;
+        if CellPos.Y < Result.Top then  Result.Top := CellPos.Y;
+      end;
+  end;
+end;
+
+
+function TMap.GetAllCells: TCellArray;
+begin
+
+end;
+
+procedure TMap.ForEachCells(Method: TMethod);
+begin
+
 end;
 
@@ -464 +867 @@
 procedure TPlayer.ComputerTurn;
 var
+  AllCells: TCellArray;
   Cells: TCellArray;
   X, Y: Integer;
@@ -470 +874 @@
   TotalAttackPower: Integer;
   I: Integer;
+  C: Integer;
   CanAttack: Integer;
 begin
-  for Y := 0 to Game.Map.Size.Y - 1 do
-  for X := 0 to Game.Map.Size.X - 1 do
-  with TCell(Game.Map.Cells[Y, X]) do begin
+  AllCells := Game.Map.GetAllCells;
+  for C := 0 to Length(AllCells) - 1 do
+  with AllCells[C] do begin
     if (Terrain <> ttVoid) and (Player <> Self) then begin
       // Attack to not owned cell yet
       // Count own possible power
-      Cells := Game.Map.GetCellNeighbours(Game.Map.Cells[Y, X]);
+      Cells := Game.Map.GetCellNeighbours(AllCells[C]);
       TotalPower := 0;
       for I := 0 to Length(Cells) - 1 do
@@ -493 +898 @@
           if Cells[I].GetAvialPower < AttackPower then
             AttackPower := Cells[I].GetAvialPower;
-          Game.SetMove(Cells[I], Game.Map.Cells[Y, X], AttackPower);
+          Game.SetMove(Cells[I], AllCells[C], AttackPower);
           TotalAttackPower := TotalAttackPower + AttackPower;
         end;
@@ -502 +907 @@
       // We need to move available power to borders to be available for attacks
       // or defense
-      Cells := Game.Map.GetCellNeighbours(Game.Map.Cells[Y, X]);
+      Cells := Game.Map.GetCellNeighbours(AllCells[C]);
       CanAttack := 0;
       for I := 0 to Length(Cells) - 1 do
@@ -512 +917 @@
         // For simplicty just try to balance inner area cells power
         for I := 0 to Length(Cells) - 1 do
-        if (Cells[I].Player = Self) and (Cells[I].Power < Game.Map.Cells[Y, X].GetAvialPower) then begin
-          Game.SetMove(Game.Map.Cells[Y, X], Cells[I], (Game.Map.Cells[Y, X].GetAvialPower - Cells[I].Power) div 2);
+        if (Cells[I].Player = Self) and (Cells[I].Power < AllCells[C].GetAvialPower) then begin
+          Game.SetMove(AllCells[C], Cells[I], (AllCells[C].GetAvialPower - Cells[I].Power) div 2);
         end;
       end;
@@ -528 +933 @@
   NewSelectedCell := Game.Map.PosToCell(CanvasToCellPos(Pos), Self);
   if Assigned(NewSelectedCell) then begin
-    if Assigned(SelectedCell) and IsCellsNeighbor(NewSelectedCell, SelectedCell) then begin
+    if Assigned(SelectedCell) and Game.Map.IsCellsNeighbor(NewSelectedCell, SelectedCell) then begin
       Game.SetMove(SelectedCell, NewSelectedCell, SelectedCell.Power);
       SelectedCell := nil;
@@ -610 +1015 @@
   while I < Moves.Count do
   with TMove(Moves[I]) do begin
+  if CountOnce > 0 then begin
     if CellFrom.Player = Player then begin
       if CellTo.Player = Player then begin
@@ -633 +1039 @@
       CountOnce := 0;
     end;
+    end;
     Inc(I);
   end;
@@ -649 +1056 @@
   if TMove(Moves[I]).CellFrom = Cell then
     Moves.Delete(I);
+end;
+
+procedure TGame.SetMapType(AValue: TMapType);
+var
+  OldMap: TMap;
+begin
+  if FMapType = AValue then Exit;
+  OldMap := Map;
+  case AValue of
+    mtNone: Map := TMap.Create;
+    mtHexagon: Map := THexMap.Create;
+    mtSquare: Map := TSquareMap.Create;
+  end;
+  Map.Assign(OldMap);
+  OldMap.Free;
+  FMapType := AValue;
 end;
 
@@ -731 +1154 @@
 begin
   with Config do begin
+    SetValue(Path + '/GridType', Integer(MapType));
     SetValue(Path + '/VoidEnabled', VoidEnabled);
     SetValue(Path + '/VoidPercentage', VoidPercentage);
@@ -745 +1169 @@
 begin
   with Config do begin
+    MapType := TMapType(GetValue(Path + '/GridType', Integer(mtHexagon)));
     VoidEnabled := GetValue(Path + '/VoidEnabled', True);
     VoidPercentage := GetValue(Path + '/VoidPercentage', 20);
@@ -809 +1234 @@
 begin
   Moves := TObjectList.Create;
-  Map := THexMap.Create;
+  Map := TMap.Create;
   Players := TPlayers.Create;
 
@@ -848 +1273 @@
   StartCell: TCell;
   Counter: Integer;
+  AllCells: TCellArray;
+  C: Integer;
 begin
   TurnCounter := 1;
   Moves.Clear;
-  for Y := 0 to Map.Size.Y - 1 do
-  for X := 0 to Map.Size.X - 1 do
-  with Map.Cells[Y, X] do begin
+  AllCells := Map.GetAllCells;
+  for C := 0 to Length(AllCells) - 1 do
+  with AllCells[C] do begin
     if VoidEnabled and (Random < VoidPercentage / 100) then Terrain := ttVoid
       else begin
@@ -870 +1297 @@
       Counter := 0;
       while not Assigned(StartCell) or Assigned(StartCell.Player) do begin
-        StartCell := Map.Cells[Random(Map.Size.Y), Random(Map.Size.X)];
+        StartCell := AllCells[Random(Length(AllCells))];
         Inc(Counter);
         if Counter > 100 then
-          raise Exception.Create('Cannot choose start cell for player');
+          raise Exception.Create(SCannotSetPlayerStartCells);
       end;
       if CityEnabled then StartCell.Terrain := ttCity
@@ -902 +1329 @@
 end;
 
+function THexMap.GetSize: TPoint;
+begin
+  Result := FSize;
+end;
+
 procedure THexMap.SetSize(AValue: TPoint);
 var
@@ -924 +1356 @@
     end;
   end;
+end;
+
+function THexMap.IsCellsNeighbor(Cell1, Cell2: TCell): Boolean;
+var
+  DX: Integer;
+  DY: Integer;
+  MinY: Integer;
+begin
+  if Cell1.Pos.Y < Cell2.Pos.Y then MinY:= Cell1.Pos.Y
+    else MinY := Cell2.Pos.Y;
+  DX := Cell2.Pos.X - Cell1.Pos.X;
+  DY := Cell2.Pos.Y - Cell1.Pos.Y;
+  Result := (Abs(DX) <= 1) and (Abs(DY) <= 1) and
+  ((((MinY mod 2) = 1) and
+    not ((DX = 1) and (DY = -1)) and
+    not ((DX = -1) and (DY = 1))) or
+    (((MinY mod 2) = 0) and
+    not ((DX = -1) and (DY = -1)) and
+    not ((DX = 1) and (DY = 1))));
+  Result := Result and not (Cell1 = Cell2);
+end;
+
+procedure THexMap.Assign(Source: TMap);
+begin
+end;
+
+procedure THexMap.LoadFromFile(FileName: string);
+var
+  Doc: TXMLDocument;
+begin
+  try
+    ReadXMLFile(Doc, FileName);
+    if Doc.DocumentElement.TagName <> 'Map' then
+      raise Exception.Create('Invalid map format');
+  finally
+    Doc.Free;
+  end;
+  inherited LoadFromFile(FileName);
+end;
+
+procedure THexMap.SaveToFile(FileName: string);
+var
+  Doc: TXMLDocument;
+  RootNode: TDOMNode;
+begin
+  try
+    Doc := TXMLDocument.Create;
+    RootNode := Doc.CreateElement('Map');
+    Doc.Appendchild(RootNode);
+    WriteXMLFile(Doc, FileName);
+  finally
+    Doc.Free;
+  end;
+  inherited SaveToFile(FileName);
 end;
 
@@ -980 +1466 @@
 end;
 
-function THexMap.CellToPos(Cell: TCell; View: TView): TPoint;
+function THexMap.CellToPos(Cell: TCell): TPoint;
 var
   CX, CY: Integer;
@@ -1073 +1559 @@
           Pen.Color := clCream;
           for I := 0 to Cell.MovesFrom.Count - 1 do begin
-            PosFrom := CellToPos(Cell, View);
-            PosTo := CellToPos(TMove(Cell.MovesFrom[I]).CellTo, View);
+            PosFrom := CellToPos(Cell);
+            PosTo := CellToPos(TMove(Cell.MovesFrom[I]).CellTo);
             if TMove(Cell.MovesFrom[I]).CountRepeat > 0 then Pen.Width := 2
               else Pen.Width := 1;
@@ -1093 +1579 @@
 constructor THexMap.Create;
 begin
-  DefaultCellSize := Point(62, 62);
-  MaxPower := 99;
+  inherited;
 end;
 
 destructor THexMap.Destroy;
 begin
-  Size := Point(0, 0);
   inherited Destroy;
 end;
 
-procedure THexMap.Grow(APlayer: TPlayer);
-var
-  X, Y: Integer;
-  Addition: Integer;
-begin
+function THexMap.GetAllCells: TCellArray;
+var
+  X: Integer;
+  Y: Integer;
+  I: Integer;
+begin
+  SetLength(Result, Size.Y * Size.X);
   for Y := 0 to Size.Y - 1 do
   for X := 0 to Size.X - 1 do
-  with TCell(Cells[Y, X]) do begin
-    if (Player = APlayer) and ((Game.GrowCells = gcPlayerAll) or
-    ((Game.GrowCells = gcPlayerCities) and (Terrain = ttCity))) then begin
-      if Game.GrowAmount = gaByOne then Addition := 1
-        else if Game.GrowAmount = gaBySquareRoot then begin
-          Addition := Trunc(Sqrt(Power));
-          if Addition = 0 then Addition := 1;
-        end;
-      Power := Power + Addition;
-      if Power > MaxPower then Power := MaxPower;
-    end;
-  end;
-end;
-
-procedure THexMap.ComputePlayerStats;
-var
-  X, Y: Integer;
-begin
-  for Y := 0 to Size.Y - 1 do
-  for X := 0 to Size.X - 1 do
-  with Cells[Y, X] do begin
-    if Assigned(Player) then begin
-      Player.TotalCells := Player.TotalCells + 1;
-      Player.TotalUnits := Player.TotalUnits + Power;
-    end;
-  end;
+    Result[Y * Size.X + X] := Cells[Y, X];
 end;