Changeset 27 for trunk

Timestamp:

Apr 12, 2015, 1:11:27 PM (10 years ago)

Author:

chronos

Message:

• Modified: Train position is now relative to nearest down point. Thanks to that trains is not repositioned if line is connected or disconnected to other stations.

Location:

trunk

Files:

• UEngine.pas (modified) (25 diffs)
• UGeometric.pas (modified) (2 diffs)

trunk/UEngine.pas

@@ -64 +64 @@
     Line: TMetroLine;
     LineStation: TLineStation;
-    Point: TPoint;
-    PointShift: TPoint;
-    DesignedPoint: TPoint;
+    Position: TPoint;
+    PositionShift: TPoint;
+    PositionDesigned: TPoint;
     Pending: Boolean;
     function GetDown: TTrackPoint;
     function GetUp: TTrackPoint;
+    function GetNeighDown: TTrackPoint;
+    function GetNeighUp: TTrackPoint;
+    // Move to TTrackLink later
+    function GetDistance: Integer;
   end;
 
@@ -118 +122 @@
     TrackPoints: TTrackPoints;
     procedure ConnectStation(Station: TMapStation; LineStationDown, LineStationUp: TLineStation);
-    procedure DisconnectStation(LineStation: TLineStation);
+    procedure DisconnectStation(ALineStation: TLineStation);
     procedure RouteTrack(TP1, TP2: TTrackPoint);
-    procedure RemoteTrackBetween(TP1, TP2: TTrackPoint);
+    procedure RemoveTrackBetween(TP1, TP2: TTrackPoint);
     function GetTrackLength: Integer;
-    function GetStationTrackPos(LineStation: TLineStation): Integer;
     constructor Create;
     destructor Destroy; override;
@@ -141 +144 @@
   private
     LastPosDelta: Integer;
+    LastTrainMoveTime: TDateTime;
+    StationStopTime: TDateTime;
   public
     Passengers: TMetroPassengers;
     Line: TMetroLine;
-    TrackPos: Integer;
-    //Angle: Double;
+    BaseTrackPoint: TTrackPoint;
+    RelPos: Double;
     Direction: Integer;
     InStation: Boolean;
-    StationStopTime: TDateTime;
-    LastTrainMoveTime: TDateTime;
     TargetStation: TLineStation;
+    function GetTargetStationDistance: Integer;
     function GetPosition: TPoint;
     function GetAngle: Double;
@@ -185 +189 @@
   TView = class
     Size: TPoint;
+    Zoom: Double;
   end;
 
@@ -332 +337 @@
 function TTrackPoint.GetDown: TTrackPoint;
 var
+  I: Integer;
+begin
+  I := Line.TrackPoints.IndexOf(Self) - 1;
+  while (I >= 0) and not Assigned(TTrackPoint(Line.TrackPoints[I]).LineStation) do
+    Dec(I);
+  if I >= 0 then Result := TTrackPoint(Line.TrackPoints[I])
+    else Result := nil;
+end;
+
+function TTrackPoint.GetUp: TTrackPoint;
+var
+  I: Integer;
+begin
+  I := Line.TrackPoints.IndexOf(Self) + 1;
+  while (I < Line.TrackPoints.Count) and not Assigned(TTrackPoint(Line.TrackPoints[I]).LineStation) do
+    Inc(I);
+  if I < Line.TrackPoints.Count then Result := TTrackPoint(Line.TrackPoints[I])
+    else Result := nil;
+end;
+
+function TTrackPoint.GetNeighDown: TTrackPoint;
+var
   NewIndex: Integer;
 begin
-  NewIndex := LineStation.Line.LineStations.IndexOf(LineStation) - 1;
-  if NewIndex >= 0 then Result := TLineStation(LineStation.Line.LineStations[NewIndex]).TrackPoint
+  NewIndex := Line.TrackPoints.IndexOf(Self) - 1;
+  if NewIndex >= 0 then Result := TTrackPoint(Line.TrackPoints[NewIndex])
     else Result := nil;
 end;
 
-function TTrackPoint.GetUp: TTrackPoint;
+function TTrackPoint.GetNeighUp: TTrackPoint;
 var
   NewIndex: Integer;
 begin
-  NewIndex := LineStation.Line.LineStations.IndexOf(LineStation) + 1;
-  if NewIndex < LineStation.Line.LineStations.Count then
-    Result := TLineStation(LineStation.Line.LineStations[NewIndex]).TrackPoint
+  NewIndex := Line.TrackPoints.IndexOf(Self) + 1;
+  if NewIndex < Line.TrackPoints.Count then Result := TTrackPoint(Line.TrackPoints[NewIndex])
     else Result := nil;
+end;
+
+function TTrackPoint.GetDistance: Integer;
+var
+  Index: Integer;
+begin
+  Index := Line.TrackPoints.IndexOf(Self);
+  Result := Distance(TTrackPoint(Line.TrackPoints[Index + 1]).Position,
+    TTrackPoint(Line.TrackPoints[Index]).Position);
 end;
 
@@ -478 +513 @@
     end;
 
-    Angle := arctan2((TTrackPoint(TrackPoints[2]).Point.Y - TTrackPoint(TrackPoints[1]).Point.Y),
-      (TTrackPoint(TrackPoints[2]).Point.X - TTrackPoint(TrackPoints[1]).Point.X));
-    EndPoint := Point(Round(TTrackPoint(TrackPoints[1]).Point.X - EndStationLength * Cos(Angle)),
-      Round(TTrackPoint(TrackPoints[1]).Point.Y - EndStationLength * Sin(Angle)));
-    TTrackPoint(TrackPoints.First).Point := EndPoint;
-    TTrackPoint(TrackPoints.First).DesignedPoint := EndPoint;
-
-    Angle := arctan2((TTrackPoint(TrackPoints[TrackPoints.Count - 2]).Point.Y - TTrackPoint(TrackPoints[TrackPoints.Count - 3]).Point.Y),
-      (TTrackPoint(TrackPoints[TrackPoints.Count - 2]).Point.X - TTrackPoint(TrackPoints[TrackPoints.Count - 3]).Point.X));
-    EndPoint := Point(Round(TTrackPoint(TrackPoints[TrackPoints.Count - 2]).Point.X + EndStationLength * Cos(Angle)),
-      Round(TTrackPoint(TrackPoints[TrackPoints.Count - 2]).Point.Y + EndStationLength * Sin(Angle)));
-    TTrackPoint(TrackPoints.Last).Point := EndPoint;
-    TTrackPoint(TrackPoints.Last).DesignedPoint := EndPoint;
+    Angle := arctan2((TTrackPoint(TrackPoints[2]).Position.Y - TTrackPoint(TrackPoints[1]).Position.Y),
+      (TTrackPoint(TrackPoints[2]).Position.X - TTrackPoint(TrackPoints[1]).Position.X));
+    EndPoint := Point(Round(TTrackPoint(TrackPoints[1]).Position.X - EndStationLength * Cos(Angle)),
+      Round(TTrackPoint(TrackPoints[1]).Position.Y - EndStationLength * Sin(Angle)));
+    TTrackPoint(TrackPoints.First).Position := EndPoint;
+    TTrackPoint(TrackPoints.First).PositionDesigned := EndPoint;
+
+    Angle := arctan2((TTrackPoint(TrackPoints[TrackPoints.Count - 2]).Position.Y - TTrackPoint(TrackPoints[TrackPoints.Count - 3]).Position.Y),
+      (TTrackPoint(TrackPoints[TrackPoints.Count - 2]).Position.X - TTrackPoint(TrackPoints[TrackPoints.Count - 3]).Position.X));
+    EndPoint := Point(Round(TTrackPoint(TrackPoints[TrackPoints.Count - 2]).Position.X + EndStationLength * Cos(Angle)),
+      Round(TTrackPoint(TrackPoints[TrackPoints.Count - 2]).Position.Y + EndStationLength * Sin(Angle)));
+    TTrackPoint(TrackPoints.Last).Position := EndPoint;
+    TTrackPoint(TrackPoints.Last).PositionDesigned := EndPoint;
   end;
 end;
@@ -516 +551 @@
   NewTrackPoint := TTrackPoint.Create;
   NewTrackPoint.LineStation := NewLineStation;
-  NewTrackPoint.Point := Station.Position;
-  NewTrackPoint.DesignedPoint := NewTrackPoint.Point;
+  NewTrackPoint.Position := Station.Position;
+  NewTrackPoint.PositionDesigned := NewTrackPoint.Position;
   NewTrackPoint.Line := TrackPoints.Line;
   Index := 0;
@@ -536 +571 @@
       Train.Line := Self;
       Train.TargetStation := TLineStation(LineStations[0]);
+      Train.BaseTrackPoint := TTrackPoint(TrackPoints.First);
       Trains.Add(Train);
     end;
@@ -544 +580 @@
 end;
 
-procedure TMetroLine.DisconnectStation(LineStation: TLineStation);
-var
-  I: Integer;
+procedure TMetroLine.DisconnectStation(ALineStation: TLineStation);
+var
+  I: Integer;
+  J: Integer;
   Index: Integer;
-begin
+  TP1, TP2: TTrackPoint;
+  IsOnTrack: Boolean;
+begin
+  // Determine track point range to be removed
+  TP1 := ALineStation.TrackPoint.GetDown;
+  if not Assigned(TP1) then TP1 := TTrackPoint(TrackPoints.First);
+  TP2 := ALineStation.TrackPoint.GetUp;
+  if not Assigned(TP2) then TP2 := TTrackPoint(TrackPoints.Last);
+
+  // Remove track points from trains
+  for I := 0 to Trains.Count - 1 do
+  with TMetroTrain(Trains[I]) do begin
+    IsOnTrack := False;
+    for J := TrackPoints.IndexOf(TP1) to TrackPoints.IndexOf(TP2) do
+    if TTrackPoint(TrackPoints[J]) = BaseTrackPoint then begin
+      IsOnTrack := True;
+      Break;
+    end;
+    if IsOnTrack then begin
+      if Assigned(BaseTrackPoint) and Assigned(BaseTrackPoint.GetUp) and (BaseTrackPoint.GetUp <> ALineStation.TrackPoint) then
+        BaseTrackPoint := BaseTrackPoint.GetUp
+      else
+      if Assigned(BaseTrackPoint) and Assigned(BaseTrackPoint.GetDown) and (BaseTrackPoint.GetDown <> ALineStation.TrackPoint) then
+        BaseTrackPoint := BaseTrackPoint.GetDown
+      else BaseTrackPoint := nil;
+    end;
+  end;
+
   // Delete old trackpoints
-
-  Index := TrackPoints.IndexOf(LineStation.TrackPoint) - 1;
+  Index := TrackPoints.IndexOf(ALineStation.TrackPoint) - 1;
   while (Index >= 0) and (not Assigned(TTrackPoint(TrackPoints[Index]).LineStation)) do begin
     TrackPoints.Delete(Index);
@@ -561 +624 @@
     TrackPoints.Delete(Index);
 
-  LineStation.MapStation.Lines.Remove(Self);
-  Index := LineStations.IndexOf(LineStation);
-
-  // Remove station from trains
+  if ((Index - 1) >= 0) and (Index < TrackPoints.Count) then
+    RouteTrack(TTrackPoint(TrackPoints[Index - 1]), TTrackPoint(TrackPoints[Index]));
+
+  ALineStation.MapStation.Lines.Remove(Self);
+  Index := LineStations.IndexOf(ALineStation);
+
   for I := 0 to Trains.Count - 1 do
-  with TMetroTrain(Trains[I]) do
-  if TargetStation = LineStation then
-    TargetStation := TLineStation(LineStations[(Index + 1) mod LineStations.Count]);
+  with TMetroTrain(Trains[I]) do begin
+    if TargetStation = ALineStation then
+      TargetStation := TLineStation(LineStations[(Index + 1) mod LineStations.Count]);
+  end;
 
   LineStations.Delete(Index);
 
-  // Remove trains if less then two stations
+  // Remove all trains if less then two stations
   if LineStations.Count < 2 then
   for I := Trains.Count - 1 downto 0 do begin
@@ -590 +656 @@
   Index1, Index2: Integer;
 begin
-  RemoteTrackBetween(TP1, TP2);
+  RemoveTrackBetween(TP1, TP2);
   Index1 := TrackPoints.IndexOf(TP1);
   Index2 := TrackPoints.IndexOf(TP2);
-  P1 := TTrackPoint(TrackPoints[Index1]).Point;
-  P2 := TTrackPoint(TrackPoints[Index2]).Point;
+  P1 := TTrackPoint(TrackPoints[Index1]).Position;
+  P2 := TTrackPoint(TrackPoints[Index2]).Position;
   NewTrackPoint := TTrackPoint.Create;
   NewTrackPoint.Line := Self;
   Delta := Point(P2.X - P1.X, P2.Y - P1.Y);
   if Abs(Delta.X) > Abs(Delta.Y) then begin
-    NewTrackPoint.Point := Point(P2.X - Sign(Delta.X) * Abs(Delta.Y), P1.Y);
-    NewTrackPoint.DesignedPoint := NewTrackPoint.Point;
+    NewTrackPoint.Position := Point(P2.X - Sign(Delta.X) * Abs(Delta.Y), P1.Y);
+    NewTrackPoint.PositionDesigned := NewTrackPoint.Position;
   end else begin
-    NewTrackPoint.Point := Point(P1.X, P2.Y - Sign(Delta.Y) * Abs(Delta.X));
-    NewTrackPoint.DesignedPoint := NewTrackPoint.Point;
+    NewTrackPoint.Position := Point(P1.X, P2.Y - Sign(Delta.Y) * Abs(Delta.X));
+    NewTrackPoint.PositionDesigned := NewTrackPoint.Position;
   end;
   TrackPoints.Insert(Index1 + 1, NewTrackPoint);
 end;
 
-procedure TMetroLine.RemoteTrackBetween(TP1, TP2: TTrackPoint);
+procedure TMetroLine.RemoveTrackBetween(TP1, TP2: TTrackPoint);
 var
   Index1, Index2: Integer;
@@ -636 +702 @@
   for I := 0 to TrackPoints.Count - 1 do
   if I > 0 then
-    Result := Result + Distance(TTrackPoint(TrackPoints[I]).Point, TTrackPoint(TrackPoints[I - 1]).Point);
-end;
-
-function TMetroLine.GetStationTrackPos(LineStation: TLineStation): Integer;
-var
-  I: Integer;
-begin
-  Result := 0;
-  for I := 0 to TrackPoints.Count - 1 do begin
-    if I > 0 then
-      Result := Result + Distance(TTrackPoint(TrackPoints[I]).Point, TTrackPoint(TrackPoints[I - 1]).Point);
-    if TTrackPoint(TrackPoints[I]).LineStation = LineStation then Break;
-  end;
+    Result := Result + Distance(TTrackPoint(TrackPoints[I]).Position, TTrackPoint(TrackPoints[I - 1]).Position);
 end;
 
@@ -678 +732 @@
 { TMetroTrain }
 
+function TMetroTrain.GetTargetStationDistance: Integer;
+var
+  Current: Integer;
+  Target: Integer;
+  I: Integer;
+begin
+  Result := 0;
+  if Assigned(BaseTrackPoint) and Assigned(TargetStation) then begin
+  Current := Line.TrackPoints.IndexOf(BaseTrackPoint);
+  Target := Line.TrackPoints.IndexOf(TargetStation.TrackPoint);
+  if Current < Target then begin
+    for I := Current to Target - 1 do
+      Result := Result + TTrackPoint(Line.TrackPoints[I]).GetDistance;
+    Result := Result - Trunc(RelPos);
+  end else
+  if Current > Target then begin
+    for I := Current - 1 downto Target do
+      Result := Result + TTrackPoint(Line.TrackPoints[I]).GetDistance;
+    Result := Result + Trunc(RelPos);
+  end else Result := Trunc(RelPos);
+  end;
+end;
+
 function TMetroTrain.GetPosition: TPoint;
 var
-  I: Integer;
-  R: TPoint;
   D: Integer;
-  Sum: Integer;
+  Delta: TPoint;
+  UpPoint: TTrackPoint;
 begin
   Result := Point(0, 0);
-  if Assigned(Line) then
-  with Line do begin
-    Sum := 0;
-    if TrackPoints.Count > 1 then
-    for I := 1 to TrackPoints.Count - 1 do begin
-      D := Distance(TTrackPoint(TrackPoints[I]).Point, TTrackPoint(TrackPoints[I - 1]).Point);
-      if (Sum + D) > Self.TrackPos then begin
-        R := Point(TTrackPoint(TrackPoints[I]).Point.X - TTrackPoint(TrackPoints[I - 1]).Point.X,
-          TTrackPoint(TrackPoints[I]).Point.Y - TTrackPoint(TrackPoints[I - 1]).Point.Y);
-        Result := Point(Trunc(TTrackPoint(TrackPoints[I - 1]).Point.X + R.X * (TrackPos - Sum) / D),
-          Trunc(TTrackPoint(TrackPoints[I - 1]).Point.Y + R.Y * (TrackPos - Sum) / D));
-        Exit;
-      end else Sum := Sum + D;
-    end;
-    if TrackPoints.Count > 0 then
-      Result := TTrackPoint(TrackPoints.Last).Point;
+  if Assigned(BaseTrackPoint) then
+  with BaseTrackPoint do begin
+    UpPoint := BaseTrackPoint.GetNeighUp;
+    if Assigned(UpPoint) then begin
+      D := Distance(UpPoint.Position, Position);
+      if D > 0 then begin
+        Delta := SubPoint(UpPoint.Position, Position);
+        Result := Point(Trunc(Position.X + Delta.X * RelPos / D),
+          Trunc(Position.Y + Delta.Y * RelPos / D));
+      end;
+    end;
   end;
 end;
@@ -707 +778 @@
 function TMetroTrain.GetAngle: Double;
 var
-  I: Integer;
-  D: Integer;
-  Sum: Integer;
+  UpPoint: TTrackPoint;
 begin
   Result := 0;
-  if Assigned(Line) then
-  with Line do begin
-    Sum := 0;
-    if TrackPoints.Count > 1 then
-    for I := 1 to TrackPoints.Count - 1 do begin
-      D := Distance(TTrackPoint(TrackPoints[I]).Point, TTrackPoint(TrackPoints[I - 1]).Point);
-      if (Sum + D) > Self.TrackPos then begin
-        Result := ArcTan2(TTrackPoint(TrackPoints[I]).Point.Y - TTrackPoint(TrackPoints[I - 1]).Point.Y,
-          TTrackPoint(TrackPoints[I]).Point.X - TTrackPoint(TrackPoints[I - 1]).Point.X);
-        Exit;
-      end else Sum := Sum + D;
+  if Assigned(BaseTrackPoint) then
+  with BaseTrackPoint do begin
+    UpPoint := BaseTrackPoint.GetNeighUp;
+    if Assigned(UpPoint) then begin
+      Result := ArcTan2(UpPoint.Position.Y - Position.Y,
+        UpPoint.Position.X - Position.X);
     end;
   end;
@@ -786 +850 @@
   TPAngleGroup := TTrackPointsAngleGroup.Create;
   for I := 0 to Tracks.Count - 1 do begin
-    Angle := ArcTan2(TTrack(Tracks[I]).PointDown.DesignedPoint.Y - Position.Y,
-      TTrack(Tracks[I]).PointDown.DesignedPoint.X - Position.X);
+    Angle := ArcTan2(TTrack(Tracks[I]).PointDown.PositionDesigned.Y - Position.Y,
+      TTrack(Tracks[I]).PointDown.PositionDesigned.X - Position.X);
     GroupItem := TPAngleGroup.SearchAngle(Angle);
     if not Assigned(GroupItem) then begin
@@ -807 +871 @@
         Shift.X := Trunc(MetroLineThickness * Cos(HAngle) * (J - (Tracks.Count - 1) / 2));
         Shift.Y := Trunc(MetroLineThickness * Sin(HAngle) * (J - (Tracks.Count - 1) / 2));
-        PointDown.PointShift := Shift;
-        PointUp.PointShift := Shift;
+        PointDown.PositionShift := Shift;
+        PointUp.PositionShift := Shift;
       end;
   end;
@@ -941 +1005 @@
   with TMetroLine(Lines[I]) do begin
     for T := 1 to TrackPoints.Count - 1 do begin
-      D := PointToLineDistance(Pos, TTrackPoint(TrackPoints[T - 1]).Point, TTrackPoint(TrackPoints[T]).Point);
+      D := PointToLineDistance(Pos, TTrackPoint(TrackPoints[T - 1]).Position, TTrackPoint(TrackPoints[T]).Position);
       if (D < MinD) and (D < TrackClickDistance) then begin
         MinD := D;
@@ -1132 +1196 @@
   PosDelta: Integer;
   TargetStationIndex: Integer;
-  PosChange: Integer;
+  PosChange: Double;
 begin
   // Move trains
@@ -1147 +1211 @@
             if Line.IsCircular then begin
               TargetStationIndex := Line.LineStations.Count - 2;
-              TrackPos := Line.GetStationTrackPos(TLineStation(Line.LineStations.Last));
+              BaseTrackPoint := TLineStation(Line.LineStations.Last).TrackPoint;
+              RelPos := 0;
             end else begin
               TargetStationIndex := 1;
               Direction := -Direction;
             end;
-          end else if TargetStationIndex >= Line.LineStations.Count then begin
+          end else
+          if TargetStationIndex >= Line.LineStations.Count then begin
             if Line.IsCircular then begin
               TargetStationIndex := 1;
-              TrackPos := 0;
+              BaseTrackPoint := TLineStation(Line.LineStations.First).TrackPoint;
+              RelPos := 0;
             end else begin
               TargetStationIndex := Line.LineStations.Count - 2;
@@ -1202 +1269 @@
           end;
 
-          LastPosDelta := Abs(TrackPos - Line.GetStationTrackPos(TargetStation));
+          LastPosDelta := Abs(GetTargetStationDistance);
           InStation := False;
           LastTrainMoveTime := Time;
         end;
       end else begin
-        PosChange := Trunc(Direction * TrainSpeed * (Time - LastTrainMoveTime));
-        TrackPos := TrackPos + PosChange;
+        PosChange := Direction + Trunc(Direction * TrainSpeed * (Time - LastTrainMoveTime));
+        RelPos := RelPos + PosChange;
         LastTrainMoveTime := Time;
-        if TrackPos < 0 then begin
-          if Line.IsCircular then TrackPos := Line.GetTrackLength
-            else TrackPos := 0;
-        end else
-        if TrackPos > Line.GetTrackLength then begin
-          if Line.IsCircular then TrackPos := 0
-            else TrackPos := Line.GetTrackLength;
+        if Assigned(BaseTrackPoint) then
+        while (Direction = -1) and (RelPos < 0) do begin
+          if BaseTrackPoint <> TLineStation(Line.LineStations.First).TrackPoint then begin
+            BaseTrackPoint := BaseTrackPoint.GetNeighDown;
+            if Assigned(BaseTrackPoint) then
+              RelPos := RelPos + BaseTrackPoint.GetDistance
+            else begin
+              BaseTrackPoint := TLineStation(Line.LineStations.First).TrackPoint;
+              RelPos := 0;
+            end;
+          end else
+          if Line.IsCircular then begin
+            BaseTrackPoint := TLineStation(Line.LineStations.Last).TrackPoint;
+            RelPos := RelPos + BaseTrackPoint.GetDistance;
+          end else begin
+            RelPos := 0;
+            Break;
+          end;
         end;
-        PosDelta := Abs(TrackPos - Line.GetStationTrackPos(TargetStation));
+        if Assigned(BaseTrackPoint) then
+        while (Direction = 1) and (RelPos > BaseTrackPoint.GetDistance) do begin
+          if BaseTrackPoint <> TLineStation(Line.LineStations.Last).TrackPoint then begin
+            RelPos := RelPos - BaseTrackPoint.GetDistance;
+            BaseTrackPoint := BaseTrackPoint.GetNeighUp;
+            if not Assigned(BaseTrackPoint) then begin
+              BaseTrackPoint := TLineStation(Line.LineStations.Last).TrackPoint;
+              RelPos := 0;
+            end;
+          end else
+          if Line.IsCircular then begin
+            RelPos := RelPos - BaseTrackPoint.GetDistance;
+            BaseTrackPoint := TLineStation(Line.LineStations.First).TrackPoint;
+          end else begin
+            RelPos := BaseTrackPoint.GetDistance;
+            Break;
+          end;
+        end;
+        PosDelta := Abs(GetTargetStationDistance);
         if PosDelta >= LastPosDelta then begin
           // We are getting far from station, stop at station
-          TrackPos := Line.GetStationTrackPos(TargetStation);
+          BaseTrackPoint := TargetStation.TrackPoint;
+          RelPos := 0;
           InStation := True;
           StationStopTime := Time;
@@ -1253 +1350 @@
   with TMetroLine(Lines[I]) do
     for J := 0 to TrackPoints.Count - 1 do
-    TTrackPoint(TrackPoints[J]).Point := TTrackPoint(TrackPoints[J]).DesignedPoint;
+    TTrackPoint(TrackPoints[J]).Position := TTrackPoint(TrackPoints[J]).PositionDesigned;
 
   // Calculate new position shifts
@@ -1263 +1360 @@
   with TMetroLine(Lines[L]) do begin
     if TrackPoints.Count > 0 then
-      TTrackPoint(TrackPoints[0]).Point := AddPoint(TTrackPoint(TrackPoints[0]).DesignedPoint,
-        TTrackPoint(TrackPoints[0]).PointShift);
+      TTrackPoint(TrackPoints[0]).Position := AddPoint(TTrackPoint(TrackPoints[0]).PositionDesigned,
+        TTrackPoint(TrackPoints[0]).PositionShift);
     for I := 1 to TrackPoints.Count - 1 do
     with TTrackPoint(TrackPoints[I]) do begin
-      Link1 := SubPoint(AddPoint(TTrackPoint(TrackPoints[I]).DesignedPoint, TTrackPoint(TrackPoints[I]).PointShift),
-        AddPoint(TTrackPoint(TrackPoints[I - 1]).DesignedPoint, TTrackPoint(TrackPoints[I - 1]).PointShift));
+      Link1 := SubPoint(AddPoint(TTrackPoint(TrackPoints[I]).PositionDesigned, TTrackPoint(TrackPoints[I]).PositionShift),
+        AddPoint(TTrackPoint(TrackPoints[I - 1]).PositionDesigned, TTrackPoint(TrackPoints[I - 1]).PositionShift));
       if (I + 1) < TrackPoints.Count then
-        Link2 := SubPoint(AddPoint(TTrackPoint(TrackPoints[I + 1]).DesignedPoint, TTrackPoint(TrackPoints[I + 1]).PointShift),
-          AddPoint(TTrackPoint(TrackPoints[I]).DesignedPoint, TTrackPoint(TrackPoints[I]).PointShift))
+        Link2 := SubPoint(AddPoint(TTrackPoint(TrackPoints[I + 1]).PositionDesigned, TTrackPoint(TrackPoints[I + 1]).PositionShift),
+          AddPoint(TTrackPoint(TrackPoints[I]).PositionDesigned, TTrackPoint(TrackPoints[I]).PositionShift))
         else Link2 := Link1;
 
       if ArcTanPoint(Link1) = ArcTanPoint(Link2) then begin
         // Parallel lines
-        TTrackPoint(TrackPoints[I]).Point := AddPoint(TTrackPoint(TrackPoints[I]).DesignedPoint,
-          TTrackPoint(TrackPoints[I]).PointShift);
+        TTrackPoint(TrackPoints[I]).Position := AddPoint(TTrackPoint(TrackPoints[I]).PositionDesigned,
+          TTrackPoint(TrackPoints[I]).PositionShift);
       end else begin
         // Intersected lines
-        NewPoint := LineIntersect(AddPoint(TTrackPoint(TrackPoints[I - 1]).DesignedPoint, TTrackPoint(TrackPoints[I - 1]).PointShift),
-          AddPoint(TTrackPoint(TrackPoints[I]).DesignedPoint, TTrackPoint(TrackPoints[I]).PointShift),
-          AddPoint(TTrackPoint(TrackPoints[I]).DesignedPoint, TTrackPoint(TrackPoints[I]).PointShift),
-          AddPoint(TTrackPoint(TrackPoints[I + 1]).DesignedPoint, TTrackPoint(TrackPoints[I + 1]).PointShift));
-        TTrackPoint(TrackPoints[I]).Point := NewPoint;
+        NewPoint := LineIntersect(AddPoint(TTrackPoint(TrackPoints[I - 1]).PositionDesigned, TTrackPoint(TrackPoints[I - 1]).PositionShift),
+          AddPoint(TTrackPoint(TrackPoints[I]).PositionDesigned, TTrackPoint(TrackPoints[I]).PositionShift),
+          AddPoint(TTrackPoint(TrackPoints[I]).PositionDesigned, TTrackPoint(TrackPoints[I]).PositionShift),
+          AddPoint(TTrackPoint(TrackPoints[I + 1]).PositionDesigned, TTrackPoint(TrackPoints[I + 1]).PositionShift));
+        TTrackPoint(TrackPoints[I]).Position := NewPoint;
       end;
     end;
@@ -1676 +1773 @@
     Canvas.Pen.Style := psSolid;
     Canvas.Pen.Width := MetroLineThickness;
-    if TrackPoints.Count > 0 then Canvas.MoveTo(TTrackPoint(TrackPoints[0]).Point);
+    if TrackPoints.Count > 0 then Canvas.MoveTo(TTrackPoint(TrackPoints[0]).Position);
     for S := 1 to TrackPoints.Count - 1 do begin
-      Canvas.LineTo(TTrackPoint(TrackPoints[S]).Point);
+      Canvas.LineTo(TTrackPoint(TrackPoints[S]).Position);
 {      if (S = TrackPoints.Count - 1) then begin
         Canvas.Pen.EndCap := pecSquare;
-        Angle := arctan2((TTrackPoint(TrackPoints[S]).Point.Y - TTrackPoint(TrackPoints[S - 1]).Point.Y),
-          (TTrackPoint(TrackPoints[S]).Point.X - TTrackPoint(TrackPoints[S - 1]).Point.X));
-        EndPoint := Point(Round(TTrackPoint(TrackPoints[S]).Point.X + EndStationLength * Cos(Angle)),
-          Round(TTrackPoint(TrackPoints[S]).Point.Y + EndStationLength * Sin(Angle)));
+        Angle := arctan2((TTrackPoint(TrackPoints[S]).Position.Y - TTrackPoint(TrackPoints[S - 1]).Position.Y),
+          (TTrackPoint(TrackPoints[S]).Position.X - TTrackPoint(TrackPoints[S - 1]).Position.X));
+        EndPoint := Point(Round(TTrackPoint(TrackPoints[S]).Position.X + EndStationLength * Cos(Angle)),
+          Round(TTrackPoint(TrackPoints[S]).Position.Y + EndStationLength * Sin(Angle)));
         Canvas.LineTo(EndPoint);
         Canvas.MoveTo(Point(Round(EndPoint.X + Cos(Angle + Pi / 2) * EndStationLength / 3),
@@ -1696 +1793 @@
     if (TrackPoints.Count > 1) then begin
       Canvas.Pen.EndCap := pecSquare;
-      Angle := arctan2((TTrackPoint(TrackPoints[1]).Point.Y - TTrackPoint(TrackPoints[0]).Point.Y),
-        (TTrackPoint(TrackPoints[1]).Point.X - TTrackPoint(TrackPoints[0]).Point.X));
-      Canvas.MoveTo(TTrackPoint(TrackPoints[0]).Point);
-      EndPoint := Point(Round(TTrackPoint(TrackPoints[0]).Point.X - EndStationLength * Cos(Angle)),
-        Round(TTrackPoint(TrackPoints[0]).Point.Y - EndStationLength * Sin(Angle)));
+      Angle := arctan2((TTrackPoint(TrackPoints[1]).Position.Y - TTrackPoint(TrackPoints[0]).Position.Y),
+        (TTrackPoint(TrackPoints[1]).Position.X - TTrackPoint(TrackPoints[0]).Position.X));
+      Canvas.MoveTo(TTrackPoint(TrackPoints[0]).Position);
+      EndPoint := Point(Round(TTrackPoint(TrackPoints[0]).Position.X - EndStationLength * Cos(Angle)),
+        Round(TTrackPoint(TrackPoints[0]).Position.Y - EndStationLength * Sin(Angle)));
       Canvas.LineTo(EndPoint);
       Canvas.MoveTo(Point(Round(EndPoint.X - Cos(Angle + Pi / 2) * EndStationLength / 3),
@@ -1713 +1810 @@
   if Assigned(TrackStationDown) and Assigned(TrackStationDown.LineStation) then begin
     Canvas.Pen.Color := TrackStationDown.Line.Color;
-    Canvas.MoveTo(TrackStationDown.LineStation.TrackPoint.Point);
+    Canvas.MoveTo(TrackStationDown.LineStation.TrackPoint.Position);
     DrawLine(Canvas, LastMousePos);
   end;
   if Assigned(TrackStationUp) and Assigned(TrackStationUp.LineStation) then begin
     Canvas.Pen.Color := TrackStationUp.Line.Color;
-    Canvas.MoveTo(TrackStationUp.LineStation.TrackPoint.Point);
+    Canvas.MoveTo(TrackStationUp.LineStation.TrackPoint.Position);
     DrawLine(Canvas, LastMousePos);
   end;

trunk/UGeometric.pas

@@ -27 +27 @@
 function Distance(P1, P2: TPoint): Integer;
 begin
-  Result := Trunc(Sqrt(Sqr(P2.x - P1.X) + Sqr(P2.Y - P1.Y)));
+  Result := Trunc(Sqrt(Sqr(P2.X - P1.X) + Sqr(P2.Y - P1.Y)));
 end;
 
@@ -122 +122 @@
 function ArcTanPoint(Point: TPoint): Float;
 begin
-  Result := ArcTan(Point.Y / Point.X);
+  Result := ArcTan(Point.X / Point.Y);
 end;