Changeset 54 for trunk

Timestamp:

Aug 17, 2014, 4:40:08 PM (10 years ago)

Author:

chronos

Message:

• Added: Triangular cell type map.
• Modified: Pixel size of entire map is computed generally in TMap class method GetPixelRect.

File:

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

trunk/UGame.pas

@@ -13 +13 @@
   HexCellMulX = 1.12;
   HexCellMulY = 1.292;
-  SquareCellMulX = 1.1;
-  SquareCellMulY = 1.1;
+  SquareCellMulX = 1.05;
+  SquareCellMulY = 1.05;
+  TriangleCellMulX = 0.55;
+  TriangleCellMulY = 1.05;
   MaxPlayerCount = 8;
 
@@ -126 +128 @@
     function GetHexagonPolygon(Pos: TPoint; Size: TPoint): TPointArray;
   public
-    procedure Assign(Source: TMap); override;
     procedure LoadFromFile(FileName: string); override;
     procedure SaveToFile(FileName: string); override;
     function IsValidIndex(Index: TPoint): Boolean; override;
-    function GetPixelRect: TRect; override;
     procedure Generate; override;
-    constructor Create; override;
-    destructor Destroy; override;
   end;
 
@@ -143 +141 @@
   public
     function IsValidIndex(Index: TPoint): Boolean; override;
-    function GetPixelRect: TRect; override;
     procedure Generate; override;
-    constructor Create; override;
-    destructor Destroy; override;
+  end;
+
+  { TTriangleMap }
+
+  TTriangleMap = class(TMap)
+  private
+    function GetTrianglePolygon(Pos: TPoint; Size: TPoint; Reverse: Boolean): TPointArray;
+  public
+    function IsValidIndex(Index: TPoint): Boolean; override;
+    procedure Generate; override;
   end;
 
@@ -186 +191 @@
     FCellFrom: TCell;
     FCellTo: TCell;
-    FDestroying: Boolean;
     procedure SetCellFrom(AValue: TCell);
     procedure SetCellTo(AValue: TCell);
@@ -206 +210 @@
   TGrowAmount = (gaByOne, gaBySquareRoot);
   TGrowCells = (gcNone, gcPlayerCities, gcPlayerAll);
-  TMapType = (mtNone, mtHexagon, mtSquare);
+  TMapType = (mtNone, mtHexagon, mtSquare, mtTriangle);
   TWinObjective = (woDefeatAllOponents, woDefeatAllOponentsCities,
     woSpecialCaptureCell, woStayAliveForDefinedTurns);
@@ -341 +345 @@
 end;
 
+{ TTriangleMap }
+
+function TTriangleMap.GetTrianglePolygon(Pos: TPoint; Size: TPoint;
+  Reverse: Boolean): TPointArray;
+var
+  Rev: Integer;
+begin
+  if Reverse then Rev := -1
+    else Rev := 1;
+  SetLength(Result, 3);
+  Result[0] := Point(Trunc(Pos.X - Size.X / 2), Trunc(Pos.Y - (Size.Y * 0.8) / 2 * Rev));
+  Result[1] := Point(Trunc(Pos.X + Size.X / 2), Trunc(Pos.Y - (Size.Y * 0.8) / 2 * Rev));
+  Result[2] := Point(Trunc(Pos.X), Trunc(Pos.Y + (Size.Y * 1.2) / 2 * Rev));
+end;
+
+function TTriangleMap.IsValidIndex(Index: TPoint): Boolean;
+begin
+  Result := (Index.X >= 0) and (Index.X < Size.X) and
+    (Index.Y >= 0) and (Index.Y < Size.Y);
+end;
+
+procedure TTriangleMap.Generate;
+var
+  X, Y: Integer;
+  Rev: Integer;
+  Reverse: Boolean;
+  NewCell: TCell;
+begin
+  inherited;
+  // Free previous
+  Cells.Count := 0;
+  // Allocate and init new
+  Cells.Count := FSize.Y * FSize.X;
+  for Y := 0 to FSize.Y - 1 do
+  for X := 0 to FSize.X - 1 do begin
+    NewCell := TCell.Create;
+    Reverse := Boolean(X mod 2) xor Boolean(Y mod 2);
+    if Reverse then Rev := -1
+      else Rev := 1;
+    NewCell.PosPx := Point(Trunc(X * DefaultCellSize.X * TriangleCellMulX),
+      Trunc((Y * DefaultCellSize.Y * TriangleCellMulY) - (0.1 * Rev * DefaultCellSize.Y)));
+    NewCell.Polygon := GetTrianglePolygon(NewCell.PosPx, DefaultCellSize, Reverse);
+    Cells[Y * FSize.X + X] := NewCell;
+  end;
+
+  // Generate neighbours
+  for Y := 0 to self.FSize.Y - 1 do
+  for X := 0 to FSize.X - 1 do
+  with TCell(Cells[Y * FSize.X + X]) do begin
+    if Boolean(X mod 2) xor Boolean(Y mod 2) then Rev := -1
+      else Rev := 1;
+    if IsValidIndex(Point(X + 1, Y + 0)) then
+      Neighbors.Add(TCell(Cells[(Y + 0) * FSize.X + (X + 1)]));
+    if IsValidIndex(Point(X + 0, Y - 1 * Rev)) then
+      Neighbors.Add(TCell(Cells[(Y - 1 * Rev) * FSize.X + (X + 0)]));
+    if IsValidIndex(Point(X - 1, Y + 0)) then
+      Neighbors.Add(TCell(Cells[(Y + 0) * FSize.X + (X - 1)]));
+  end;
+end;
+
 { TSquareMap }
 
@@ -346 +410 @@
 var
   X, Y: Integer;
-  I: Integer;
   NewCell: TCell;
-  NeighCells: TCellArray;
 begin
   inherited;
@@ -367 +429 @@
   for X := 0 to FSize.X - 1 do
   with TCell(Cells[Y * FSize.X + X]) do begin
-    if IsValidIndex(Point(Y + 0, X + 1)) then
+    if IsValidIndex(Point(X + 1, Y + 0)) then
       Neighbors.Add(TCell(Cells[(Y + 0) * FSize.X + (X + 1)]));
-    if IsValidIndex(Point(Y + 1, X + 0)) then
+    if IsValidIndex(Point(X + 0, Y + 1)) then
       Neighbors.Add(TCell(Cells[(Y + 1) * FSize.X + (X + 0)]));
-    if IsValidIndex(Point(Y + 0, X - 1)) then
+    if IsValidIndex(Point(X - 1, Y + 0)) then
       Neighbors.Add(TCell(Cells[(Y + 0) * FSize.X + (X - 1)]));
-    if IsValidIndex(Point(Y - 1, X + 0)) then
+    if IsValidIndex(Point(X + 0, Y - 1)) then
       Neighbors.Add(TCell(Cells[(Y - 1) * FSize.X + (X + 0)]));
   end;
@@ -391 +453 @@
   Result[2] := Point(Trunc(Pos.X + Size.X / 2), Trunc(Pos.Y + Size.Y / 2));
   Result[3] := Point(Trunc(Pos.X - Size.X / 2), Trunc(Pos.Y + Size.Y / 2));
-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;
-
-constructor TSquareMap.Create;
-begin
-  inherited;
-end;
-
-destructor TSquareMap.Destroy;
-begin
-  inherited Destroy;
 end;
 
@@ -484 +528 @@
   Size := Source.Size;
   DefaultCellSize := Source.DefaultCellSize;
-  FSize := Source.Size;
+  //FSize := Source.Size;
 
   // Copy all cells
@@ -530 +574 @@
   I: Integer;
   Addition: Integer;
-  Cells: TCellArray;
-begin
-  Cells := GetAllCells;
-  for I := 0 to Length(Cells) - 1 do
+begin
+for I := 0 to Cells.Count - 1 do
   with TCell(Cells[I]) do begin
     if (Player = APlayer) and ((Game.GrowCells = gcPlayerAll) or
@@ -590 +632 @@
 procedure TMap.ComputePlayerStats;
 var
-  Cells: TCellArray;
-  I: Integer;
-begin
-  Cells := GetAllCells;
-  for I := 0 to Length(Cells) - 1 do
-  with Cells[I] do begin
+  I: Integer;
+begin
+  for I := 0 to Cells.Count - 1 do
+  with TCell(Cells[I]) do begin
     if Assigned(Player) then begin
       Player.TotalCells := Player.TotalCells + 1;
@@ -630 +670 @@
   DefaultCellSize := Point(62, 62);
   Cells := TObjectList.create;
+  Size := Point(0, 0);
 end;
 
@@ -650 +691 @@
 function TMap.GetPixelRect: TRect;
 var
-  Cells: TCellArray;
-  I: Integer;
-  CellPos: TPoint;
+  I: Integer;
+  CellRect: TRect;
 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)
+  // This is generic algorithm to determine pixel size of entire map
+  for I := 0 to Cells.Count - 1 do begin
+    CellRect := GetPolygonRect(TCell(Cells[I]).Polygon);
+    if I = 0 then Result := CellRect
       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;
+        if CellRect.Right > Result.Right then Result.Right := CellRect.Right;
+        if CellRect.Bottom > Result.Bottom then Result.Bottom := CellRect.Bottom;
+        if CellRect.Left < Result.Left then Result.Left := CellRect.Left;
+        if CellRect.Top < Result.Top then  Result.Top := CellRect.Top;
       end;
   end;
@@ -889 +928 @@
 procedure TPlayer.ComputerTurn;
 var
-  AllCells: TCellArray;
+  AllCells: TObjectList;
   Cells: TCellArray;
   X, Y: Integer;
@@ -899 +938 @@
   CanAttack: Integer;
 begin
-  AllCells := Game.Map.GetAllCells;
-  for C := 0 to Length(AllCells) - 1 do
-  with AllCells[C] do begin
+  AllCells := Game.Map.Cells;
+  for C := 0 to AllCells.Count - 1 do
+  with TCell(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.GetCellNeighbors(AllCells[C]);
+      Cells := Game.Map.GetCellNeighbors(TCell(AllCells[C]));
       TotalPower := 0;
       for I := 0 to Length(Cells) - 1 do
@@ -920 +959 @@
           if Cells[I].GetAvialPower < AttackPower then
             AttackPower := Cells[I].GetAvialPower;
-          Game.SetMove(Cells[I], AllCells[C], AttackPower);
+          Game.SetMove(Cells[I], TCell(AllCells[C]), AttackPower);
           TotalAttackPower := TotalAttackPower + AttackPower;
         end;
@@ -929 +968 @@
       // We need to move available power to borders to be available for attacks
       // or defense
-      Cells := Game.Map.GetCellNeighbors(AllCells[C]);
+      Cells := Game.Map.GetCellNeighbors(TCell(AllCells[C]));
       CanAttack := 0;
       for I := 0 to Length(Cells) - 1 do
@@ -939 +978 @@
         // 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 < AllCells[C].GetAvialPower) then begin
-          Game.SetMove(AllCells[C], Cells[I], (AllCells[C].GetAvialPower - Cells[I].Power) div 2);
+        if (Cells[I].Player = Self) and (Cells[I].Power < TCell(AllCells[C]).GetAvialPower) then begin
+          Game.SetMove(TCell(AllCells[C]), Cells[I], (TCell(AllCells[C]).GetAvialPower - Cells[I].Power) div 2);
         end;
       end;
@@ -950 +989 @@
 var
   NewSelectedCell: TCell;
-  TopLeft: TPoint;
-  BottomRight: TPoint;
 begin
   NewSelectedCell := Game.Map.PosToCell(CanvasToCellPos(Pos), Self);
@@ -1090 +1127 @@
     mtHexagon: Map := THexMap.Create;
     mtSquare: Map := TSquareMap.Create;
+    mtTriangle: Map := TTriangleMap.Create;
     else Map := TMap.Create;
   end;
@@ -1422 +1460 @@
 end;
 
-procedure THexMap.Assign(Source: TMap);
-begin
-  inherited;
-end;
-
 procedure THexMap.LoadFromFile(FileName: string);
 var
@@ -1560 +1593 @@
 end;
 
-constructor THexMap.Create;
-begin
-  inherited;
-  FSize := Point(0, 0);
-end;
-
-destructor THexMap.Destroy;
-begin
-  inherited Destroy;
-end;
-
-function THexMap.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;
-
 end.