Changeset 171 for trunk

Timestamp:

Nov 23, 2017, 7:05:37 PM (7 years ago)

Author:

chronos

Message:

• Modified: Use specialized TPointF type from generic class.
• Modified: Part of fixes for Voronoi map generation.

Location:

trunk

Files:

• Forms/UFormMain.pas (modified) (2 diffs)
• Packages/Common/UGeometry.pas (modified) (9 diffs)
• Packages/Common/UGeometryClasses.pas (modified) (2 diffs)
• UGame.pas (modified) (5 diffs)
• UMap.pas (modified) (6 diffs)

trunk/Forms/UFormMain.pas

@@ -247 +247 @@
 procedure TFormMain.AZoomAllExecute(Sender: TObject);
 var
-  Factor: TFloatPoint;
+  Factor: TPointF;
   MapRect: TRect;
   NewZoom: Single;
@@ -253 +253 @@
   with Core, Game, CurrentClient, View do begin
     MapRect := Map.CalculatePixelRect;
-    Factor := FloatPoint(DestRect.Size.X / MapRect.Size.X,
+    Factor := TPointF.Create(DestRect.Size.X / MapRect.Size.X,
       DestRect.Size.Y / MapRect.Size.Y);
     if Factor.X < Factor.Y then NewZoom := Factor.X

trunk/Packages/Common/UGeometry.pas

@@ -6 +6 @@
 
 uses
-  Classes, SysUtils, Math;
+  Classes, SysUtils, Math, typinfo;
 
 type
@@ -16 +16 @@
     Y: T;
     constructor Create(const X, Y: T);
-    procedure Rotate(Base: TGPoint<T>; Angle: Double);
     class operator Add(const A, B: TGPoint<T>): TGPoint<T>;
     class operator Subtract(const A, B: TGPoint<T>): TGPoint<T>;
     class operator GreaterThan(const A, B: TGPoint<T>): Boolean;
+    class operator GreaterThanOrEqual(const A, B: TGPoint<T>): Boolean;
     class operator LessThan(const A, B: TGPoint<T>): Boolean;
+    class operator LessThanOrEqual(const A, B: TGPoint<T>): Boolean;
     class operator Equal(const A, B: TGPoint<T>): Boolean;
     function Min(const A, B: TGPoint<T>): TGPoint<T>;
     function Max(const A, B: TGPoint<T>): TGPoint<T>;
+    procedure Rotate(Base: TGPoint<T>; Angle: Double);
   end;
 
@@ -94 +96 @@
     procedure AddPoint(const P: T);
     procedure Clear;
-    procedure CutLine(const Vector: TGLine<T>; const PointInside: T);
+    procedure CutLine(Vector: TGLine<T>; const PointInside: T);
     property Items[Index: Integer]: T read GetPoint write SetPoint; default;
   end;
@@ -185 +187 @@
 end;
 
-function PtInPoly(const Points: array of TPoint; Pos: TPoint): Boolean;
-var
-  Count, K, J : Integer;
-begin
-  Result := False;
-  Count := Length(Points) ;
-  J := Count - 1;
-  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
-    begin
-    if (Pos.X < (Points[j].X - Points[K].X) *
-       (Pos.Y - Points[K].Y) /
-       (Points[j].Y - Points[K].Y) + Points[K].X) then
-        Result := not Result;
-    end;
-    J := K;
-  end;
-end;
-
-
 constructor TGPolygon<T>.Create(const Points: TPointArray);
 var
@@ -227 +208 @@
 var
   I: Integer;
-  P1: TGPoint<T>;
 begin
   if Length(Points) = 0 then
@@ -252 +232 @@
 end;
 
-procedure TGPolygon<T>.CutLine(const Vector: TGLine<T>; const PointInside: T);
+procedure TGPolygon<T>.CutLine(Vector: TGLine<T>; const PointInside: T);
 var
   I: Integer;
@@ -359 +339 @@
 end;
 
-{ TGPoint3D }
-
-constructor TGPoint3D<T>.Create(const X, Y, Z: T);
-begin
-  Self.X := X;
-  Self.Y := Y;
-  Self.Z := Z;
-end;
-
-{ TGPoint }
-
-constructor TGPoint<T>.Create(const X, Y: T);
-begin
-  Self.X := X;
-  Self.Y := Y;
-end;
-
-class operator TGPoint<T>.Equal(const A, B: TGPoint<T>): Boolean;
-begin
-  Result := (A.X = B.X) and (A.Y = B.Y);
-end;
-
-class operator TGPoint<T>.Add(const A, B: TGPoint<T>): TGPoint<T>;
-begin
-  Result.X := A.X + B.X;
-  Result.Y := A.Y + B.Y;
-end;
-
-class operator TGPoint<T>.Subtract(const A, B: TGPoint<T>): TGPoint<T>;
-begin
-  Result.X := A.X - B.X;
-  Result.Y := A.Y - B.Y;
-end;
-
-class operator TGPoint<T>.GreaterThan(const A, B: TGPoint<T>): Boolean;
-begin
-  Result := (B.X > A.X) and (B.Y > A.Y);
-end;
-
-class operator TGPoint<T>.LessThan(const A, B: TGPoint<T>): Boolean;
-begin
-  Result := (B.X < A.X) and (B.Y < A.Y);
-end;
-
-{ TGLine }
-
 class function TGLine<T>.LineIntersect(const LineA, LineB: TGLine<T>; out
   Intersection: T): Boolean;
@@ -435 +369 @@
 end;
 
-procedure TGPoint<T>.Rotate(Base: TGPoint<T>; Angle: Double);
-var
-  D: TGPoint<T>;
-begin
-  D := TGPoint<T>.Create(X - Base.X, Y - Base.Y);
-  //X := Base.X + TypedRound(D.X * Cos(Angle) - D.Y * Sin(Angle));
-  //Y := Base.Y + TypedRound(D.X * Sin(Angle) + D.Y * Cos(Angle));
+{ TGPoint3D }
+
+constructor TGPoint3D<T>.Create(const X, Y, Z: T);
+begin
+  Self.X := X;
+  Self.Y := Y;
+  Self.Z := Z;
+end;
+
+{ TGPoint }
+
+constructor TGPoint<T>.Create(const X, Y: T);
+begin
+  Self.X := X;
+  Self.Y := Y;
+end;
+
+class operator TGPoint<T>.Equal(const A, B: TGPoint<T>): Boolean;
+begin
+  Result := (A.X = B.X) and (A.Y = B.Y);
+end;
+
+class operator TGPoint<T>.Add(const A, B: TGPoint<T>): TGPoint<T>;
+begin
+  Result.X := A.X + B.X;
+  Result.Y := A.Y + B.Y;
+end;
+
+class operator TGPoint<T>.Subtract(const A, B: TGPoint<T>): TGPoint<T>;
+begin
+  Result.X := A.X - B.X;
+  Result.Y := A.Y - B.Y;
+end;
+
+class operator TGPoint<T>.GreaterThan(const A, B: TGPoint<T>): Boolean;
+begin
+  Result := (A.X > B.X) and (A.Y > B.Y);
+end;
+
+class operator TGPoint<T>.GreaterThanOrEqual(const A, B: TGPoint<T>): Boolean;
+begin
+  Result := (A.X >= B.X) and (A.Y >= B.Y);
+end;
+
+class operator TGPoint<T>.LessThan(const A, B: TGPoint<T>): Boolean;
+begin
+  Result := (A.X < B.X) and (A.Y < B.Y);
+end;
+
+class operator TGPoint<T>.LessThanOrEqual(const A, B: TGPoint<T>): Boolean;
+begin
+  Result := (A.X <= B.X) and (A.Y <= B.Y);
 end;
 
@@ -456 +435 @@
 end;
 
+procedure TGPoint<T>.Rotate(Base: TGPoint<T>; Angle: Double);
+var
+  D: TGPoint<T>;
+begin
+  D := TGPoint<T>.Create(X - Base.X, Y - Base.Y);
+  X := Base.X + TypedRound(D.X * Cos(Angle) - D.Y * Sin(Angle));
+  Y := Base.Y + TypedRound(D.X * Sin(Angle) + D.Y * Cos(Angle));
+end;
+
 { TGRect }
 
 function TGRect<T>.IsPointInside(const P: T): Boolean;
 begin
-  Result := (P > P1) and (P < P2);
+  Result := (P >= P1) and (P <= P2);
 end;
 

trunk/Packages/Common/UGeometryClasses.pas

@@ -26 +26 @@
 function PointsToRect(const P1, P2: TPoint): TRect;
 function PointInRect(const P: TPoint; aRect: TRect): Boolean;
+function PtInPoly(const Points: array of TPoint; Pos: TPoint): Boolean;
 function HalfDistancePoint(const P1, P2: TPoint): TPoint;
 function NormalizeAngle(const Angle: Double): Double;
@@ -172 +173 @@
 end;
 
+function PtInPoly(const Points: array of TPoint; Pos: TPoint): Boolean;
+var
+  Count, K, J : Integer;
+begin
+  Result := False;
+  Count := Length(Points) ;
+  J := Count - 1;
+  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
+    begin
+    if (Pos.X < (Points[j].X - Points[K].X) *
+       (Pos.Y - Points[K].Y) /
+       (Points[j].Y - Points[K].Y) + Points[K].X) then
+        Result := not Result;
+    end;
+    J := K;
+  end;
+end;
 
 end.

trunk/UGame.pas

@@ -30 +30 @@
   TMapArea = class;
   TClient = class;
-
-  TFloatPoint = record
-    X, Y: Double;
-  end;
 
   TTerrainType = (ttVoid, ttNormal, ttCity);
@@ -525 +521 @@
 
 procedure InitStrings;
-function FloatPoint(AX, AY: Double): TFloatPoint;
 
 resourcestring
@@ -554 +549 @@
   PlayerModeText[pmHuman] := SHuman;
   PlayerModeText[pmComputer] := SComputer;
-end;
-
-function FloatPoint(AX, AY: Double): TFloatPoint;
-begin
-  Result.X := AX;
-  Result.Y := AY;
 end;
 
@@ -1393 +1382 @@
 var
   Points: array of Classes.TPoint;
-  FPoints: array of TFloatPoint;
+  FPoints: array of TPointF;
   I: Integer;
   ArrowSize: TPoint;
@@ -1403 +1392 @@
   ArrowSize := TPoint.Create(Trunc(DefaultCellSize.X / 3 * View.Zoom),
     Trunc(DefaultCellSize.Y / 3 * View.Zoom));
-  FPoints[0] := FloatPoint(+0.5 * ArrowSize.X, +0 * ArrowSize.Y);
-  FPoints[1] := FloatPoint(+0 * ArrowSize.X, +0.5 * ArrowSize.Y);
-  FPoints[2] := FloatPoint(+0 * ArrowSize.X, +0.25 * ArrowSize.Y);
-  FPoints[3] := FloatPoint(-0.5 * ArrowSize.X, +0.25 * ArrowSize.Y);
-  FPoints[4] := FloatPoint(-0.5 * ArrowSize.X, -0.25 * ArrowSize.Y);
-  FPoints[5] := FloatPoint(+0 * ArrowSize.X, -0.25 * ArrowSize.Y);
-  FPoints[6] := FloatPoint(+0 * ArrowSize.X, -0.5 * ArrowSize.Y);
-  FPoints[7] := FloatPoint(+0.5 * ArrowSize.X, 0 * ArrowSize.Y);
+  FPoints[0] := TPointF.Create(+0.5 * ArrowSize.X, +0 * ArrowSize.Y);
+  FPoints[1] := TPointF.Create(+0 * ArrowSize.X, +0.5 * ArrowSize.Y);
+  FPoints[2] := TPointF.Create(+0 * ArrowSize.X, +0.25 * ArrowSize.Y);
+  FPoints[3] := TPointF.Create(-0.5 * ArrowSize.X, +0.25 * ArrowSize.Y);
+  FPoints[4] := TPointF.Create(-0.5 * ArrowSize.X, -0.25 * ArrowSize.Y);
+  FPoints[5] := TPointF.Create(+0 * ArrowSize.X, -0.25 * ArrowSize.Y);
+  FPoints[6] := TPointF.Create(+0 * ArrowSize.X, -0.5 * ArrowSize.Y);
+  FPoints[7] := TPointF.Create(+0.5 * ArrowSize.X, 0 * ArrowSize.Y);
   // Rotate
   for I := 0 to Length(Points) - 1 do
-    FPoints[I] := FloatPoint(FPoints[I].X * Cos(Angle) - FPoints[I].Y * Sin(Angle),
+    FPoints[I] := TPointF.Create(FPoints[I].X * Cos(Angle) - FPoints[I].Y * Sin(Angle),
       FPoints[I].X * Sin(Angle) + FPoints[I].Y * Cos(Angle));
   // Shift

trunk/UMap.pas

@@ -6 +6 @@
 
 uses
-  Classes, SysUtils, UGame, XMLRead, XMLWrite, DOM, Contnrs, UGeometryClasses,
-  UGeometry;
+  Classes, SysUtils, UGame, XMLRead, XMLWrite, DOM, UGeometryClasses,
+  UGeometry, fgl;
 
 type
@@ -64 +64 @@
 function THexMap.GetHexagonPolygon(Pos: TPoint; Size: TPoint): TPolygon;
 var
-  Shift: TFloatPoint;
-begin
-  Shift := FloatPoint(0.5 * cos(30 / 180 * Pi), 0.5 * sin(30 / 180 * Pi));
+  Shift: TPointF;
+begin
+  Shift := TPointF.Create(0.5 * cos(30 / 180 * Pi), 0.5 * sin(30 / 180 * Pi));
   SetLength(Result.Points, 6);
   Result.Points[0] := TPoint.Create(Trunc(Pos.X + 0 * Size.X), Trunc(Pos.Y - 0.5 * Size.Y));
@@ -246 +246 @@
 end;
 
-function CompareDistanceReverse(C1, C2: Pointer): Integer;
-begin
-  if TCellsDistance(C1).Distance > TCellsDistance(C2).Distance then Result := -1
-  else if TCellsDistance(C1).Distance < TCellsDistance(C2).Distance then Result := 1
+function CompareDistanceReverse(const C1, C2: TCellsDistance): Integer;
+begin
+  if C1.Distance > C2.Distance then Result := -1
+  else if C1.Distance < C2.Distance then Result := 1
   else Result := 0;
 end;
@@ -258 +258 @@
   I1, I2: Integer;
   NewCell: TCell;
-  CellsDistance: TObjectList; // TObjectList<TCellsDistance>
+  CellsDistance: TFPGObjectList<TCellsDistance>;
   NewCellDist: TCellsDistance;
-  SelectedCells: TObjectList; // TObjectList<TCellsDistance>
+  SelectedCells: TFPGObjectList<TCellsDistance>;
   I, J: Integer;
   Intersected: Boolean;
@@ -312 +312 @@
 
   // Calculate distance between all cells
-  CellsDistance := TObjectList.Create;
+  CellsDistance := TFPGObjectList<TCellsDistance>.Create;
   for I1 := 1 to Cells.Count - 1 do
   for I2 := I1 + 1 to Cells.Count - 1 do begin
@@ -324 +324 @@
 
   // Keep shortest non-intersected cell pairs
-  SelectedCells := TObjectList.Create;
-  SelectedCells.OwnsObjects := False;
+  SelectedCells := TFPGObjectList<TCellsDistance>.Create;
+  SelectedCells.FreeObjects := False;
   I := CellsDistance.Count - 1;
   while I >= 0 do begin