Changeset 59

Timestamp:

Nov 25, 2020, 11:59:46 AM (4 years ago)

Author:

chronos

Message:

• Modified: Code cleanup. Removed explicit class typecasts.

Location:

trunk

Files:

• BigMetro.lpi (modified) (2 diffs)
• UEngine.pas (modified) (68 diffs)
• UTrack.pas (modified) (8 diffs)

trunk/BigMetro.lpi

@@ -58 +58 @@
           <Other>
             <CompilerMessages>
-              <IgnoredMessages idx5024="True"/>
+              <IgnoredMessages idx6058="True" idx5024="True" idx3124="True"/>
             </CompilerMessages>
           </Other>
@@ -151 +151 @@
     <Other>
       <CompilerMessages>
-        <IgnoredMessages idx5024="True"/>
+        <IgnoredMessages idx6058="True" idx5024="True" idx3124="True"/>
       </CompilerMessages>
       <CustomOptions Value="-dDEBUG"/>

trunk/UEngine.pas

@@ -188 +188 @@
   public
     Passengers: TMetroPassengers;
-
     BaseTrackPoint: TTrackPoint;
     RelPos: Double;
@@ -371 +370 @@
   I := 0;
   while (I < 0) and
-  ((TTrackLink(Items[I]).Points.First <> Point1) or (TTrackLink(Items[I]).Points.Last <> Point2))
-  and ((TTrackLink(Items[I]).Points.First <> Point2) or (TTrackLink(Items[I]).Points.Last <> Point1)) do
+  ((Items[I].Points.First <> Point1) or (Items[I].Points.Last <> Point2))
+  and ((Items[I].Points.First <> Point2) or (Items[I].Points.Last <> Point1)) do
   Inc(I);
-  if I < 0 then Result := TTrackLink(Items[I])
+  if I < 0 then Result := Items[I]
     else Result := nil;
 end;
@@ -406 +405 @@
   Points.Free;
   Links.Free;
-  inherited Destroy;
+  inherited;
 end;
 
@@ -420 +419 @@
 begin
   Points.Free;
-  inherited Destroy;
+  inherited;
 end;
 
@@ -442 +441 @@
 begin
   Rivers.Free;
-  inherited Destroy;
+  inherited;
 end;
 
@@ -510 +509 @@
 begin
   I := 0;
-  while (I < Count) and (TTrackLink(Items[I]).Points[1] <> TrackPoint) and (TTrackLink(Items[I]) <> Skip) do Inc(I);
-  if I < Count then Result := TTrackLink(Items[I])
+  while (I < Count) and (Items[I].Points[1] <> TrackPoint) and (Items[I] <> Skip) do Inc(I);
+  if I < Count then Result := Items[I]
     else Result := nil;
 end;
@@ -520 +519 @@
 begin
   I := 0;
-  while (I < Count) and (TTrackLink(Items[I]).Points[0] <> TrackPoint) and (TTrackLink(Items[I]) <> Skip) do Inc(I);
-  if I < Count then Result := TTrackLink(Items[I])
+  while (I < Count) and (Items[I].Points[0] <> TrackPoint) and (Items[I] <> Skip) do Inc(I);
+  if I < Count then Result := Items[I]
     else Result := nil;
 end;
@@ -532 +531 @@
 begin
   I := 0;
-  while (I < Count) and (TTrackPointsAngle(Items[I]).Angle <> Angle) do Inc(I);
-  if I < Count then Result := TTrackPointsAngle(Items[I])
+  while (I < Count) and (Items[I].Angle <> Angle) do Inc(I);
+  if I < Count then Result := Items[I]
     else Result := nil;
 end;
@@ -548 +547 @@
 begin
   TrackLinks.Free;
-  inherited Destroy;
+  inherited;
 end;
 
@@ -594 +593 @@
 begin
   I := Track.Points.IndexOf(Self) - 1;
-  while (I >= 0) and not Assigned(TTrackPoint(Track.Points[I]).LineStation) do
+  while (I >= 0) and not Assigned(Track.Points[I].LineStation) do
     Dec(I);
-  if I >= 0 then Result := TTrackPoint(Track.Points[I])
+  if I >= 0 then Result := Track.Points[I]
     else Result := nil;
 end;
@@ -605 +604 @@
 begin
   I := Track.Points.IndexOf(Self) + 1;
-  while (I < Track.Points.Count) and not Assigned(TTrackPoint(Track.Points[I]).LineStation) do
+  while (I < Track.Points.Count) and not Assigned(Track.Points[I].LineStation) do
     Inc(I);
-  if I < Track.Points.Count then Result := TTrackPoint(Track.Points[I])
+  if I < Track.Points.Count then Result := Track.Points[I]
     else Result := nil;
 end;
@@ -617 +616 @@
   Result := nil;
   NewIndex := Track.Points.IndexOf(Self) - 1;
-  if NewIndex >= 0 then Result := TTrackPoint(Track.Points[NewIndex]);
+  if NewIndex >= 0 then Result := Track.Points[NewIndex];
 end;
 
@@ -627 +626 @@
   if Assigned(Track) then begin
     NewIndex := Track.Points.IndexOf(Self) + 1;
-    if NewIndex < Track.Points.Count then Result := TTrackPoint(Track.Points[NewIndex]);
+    if NewIndex < Track.Points.Count then Result := Track.Points[NewIndex];
   end;
 end;
@@ -660 +659 @@
 begin
   Index := Track.Points.IndexOf(Self);
-  Result := Distance(TTrackPoint(Track.Points[Index + 1]).Position,
-    TTrackPoint(Track.Points[Index]).Position);
+  Result := Distance(Track.Points[Index + 1].Position, Track.Points[Index].Position);
 end;
 
@@ -676 +674 @@
   NeighLinks.Free;
   NeighPoints.Free;
-  inherited Destroy;
+  inherited;
 end;
 
@@ -686 +684 @@
 begin
   I := 0;
-  while (I < Count) and (TLineStation(Items[I]).MapStation <> Station) do Inc(I);
-  if I < Count then Result := TLineStation(Items[I])
+  while (I < Count) and (Items[I].MapStation <> Station) do Inc(I);
+  if I < Count then Result := Items[I]
     else Result := nil;
 end;
@@ -708 +706 @@
 begin
   I := 0;
-  while (I < Count) and (Assigned(TMetroTrain(Items[I]).Line)) do Inc(I);
-  if I < Count then Result := TMetroTrain(Items[I])
+  while (I < Count) and (Assigned(Items[I].Line)) do Inc(I);
+  if I < Count then Result := Items[I]
     else Result := nil;
 end;
@@ -719 +717 @@
   Result := 0;
   for I := 0 to Count - 1 do
-    if not Assigned(TMetroTrain(Items[I]).Line) then Inc(Result);
+    if not Assigned(Items[I].Line) then Inc(Result);
 end;
 
@@ -735 +733 @@
 begin
   if Count > 0 then begin
-    with TMapStation(Items[0]) do
+    with Items[0] do
       Result := Rect(Position.X, Position.Y, Position.X, Position.Y);
     for I := 1 to Count - 1 do
-    with TMapStation(Items[I]) do begin
+    with Items[I] do begin
       if Position.X < Result.Left then Result.Left := Position.X;
       if Position.X > Result.Right then Result.Right := Position.X;
@@ -769 +767 @@
     MinD := High(Integer);
     for I := 0 to Engine.Stations.Count - 1 do begin
-      D := Distance(TMapStation(Engine.Stations[I]).Position, Result.Position);
+      D := Distance(Engine.Stations[I].Position, Result.Position);
       if D < MinD then MinD := D;
     end;
@@ -797 +795 @@
 begin
   I := 0;
-  while (I < Count) and (TMetroLine(Items[I]).Color <> Color) do Inc(I);
-  if I < Count then Result := TMetroLine(Items[I])
+  while (I < Count) and (Items[I].Color <> Color) do Inc(I);
+  if I < Count then Result := Items[I]
     else Result := nil;
 end;
@@ -812 +810 @@
 begin
   if LineStations.Count >= 2 then begin
-    Index := Track.Points.IndexOf(TLineStation(LineStations.First).TrackPoint);
+    Index := Track.Points.IndexOf(LineStations.First.TrackPoint);
     if Index = 0 then begin
       NewTrackPoint := Track.Points.AddNew;
       Track.Points.Insert(0, NewTrackPoint);
     end;
-    Index := Track.Points.IndexOf(TLineStation(LineStations.Last).TrackPoint);
+    Index := Track.Points.IndexOf(LineStations.Last.TrackPoint);
     if Index = Track.Points.Count - 1 then begin
       NewTrackPoint := Track.Points.AddNew;
@@ -823 +821 @@
     end;
 
-    Angle := ArcTan2((TTrackPoint(Track.Points[2]).PositionDesigned.Y - TTrackPoint(Track.Points[1]).PositionDesigned.Y),
-      (TTrackPoint(Track.Points[2]).PositionDesigned.X - TTrackPoint(Track.Points[1]).PositionDesigned.X));
-    EndPoint := Point(Round(TTrackPoint(Track.Points[1]).PositionDesigned.X - EndStationLength * Cos(Angle)),
-      Round(TTrackPoint(Track.Points[1]).PositionDesigned.Y - EndStationLength * Sin(Angle)));
-    TTrackPoint(Track.Points.First).PositionDesigned := EndPoint;
-    TTrackPoint(Track.Points.First).Position := EndPoint;
-
-    Angle := ArcTan2((TTrackPoint(Track.Points[Track.Points.Count - 2]).PositionDesigned.Y - TTrackPoint(Track.Points[Track.Points.Count - 3]).PositionDesigned.Y),
-      (TTrackPoint(Track.Points[Track.Points.Count - 2]).PositionDesigned.X - TTrackPoint(Track.Points[Track.Points.Count - 3]).PositionDesigned.X));
-    EndPoint := Point(Round(TTrackPoint(Track.Points[Track.Points.Count - 2]).PositionDesigned.X + EndStationLength * Cos(Angle)),
-      Round(TTrackPoint(Track.Points[Track.Points.Count - 2]).PositionDesigned.Y + EndStationLength * Sin(Angle)));
-    TTrackPoint(Track.Points.Last).PositionDesigned := EndPoint;
-    TTrackPoint(Track.Points.Last).Position := EndPoint;
+    Angle := ArcTan2((Track.Points[2].PositionDesigned.Y - Track.Points[1].PositionDesigned.Y),
+      (Track.Points[2].PositionDesigned.X - Track.Points[1].PositionDesigned.X));
+    EndPoint := Point(Round(Track.Points[1].PositionDesigned.X - EndStationLength * Cos(Angle)),
+      Round(Track.Points[1].PositionDesigned.Y - EndStationLength * Sin(Angle)));
+    Track.Points.First.PositionDesigned := EndPoint;
+    Track.Points.First.Position := EndPoint;
+
+    Angle := ArcTan2((Track.Points[Track.Points.Count - 2].PositionDesigned.Y - Track.Points[Track.Points.Count - 3].PositionDesigned.Y),
+      (Track.Points[Track.Points.Count - 2].PositionDesigned.X - Track.Points[Track.Points.Count - 3].PositionDesigned.X));
+    EndPoint := Point(Round(Track.Points[Track.Points.Count - 2].PositionDesigned.X + EndStationLength * Cos(Angle)),
+      Round(Track.Points[Track.Points.Count - 2].PositionDesigned.Y + EndStationLength * Sin(Angle)));
+    Track.Points.Last.PositionDesigned := EndPoint;
+    Track.Points.Last.Position := EndPoint;
   end;
 end;
@@ -879 +877 @@
     if Assigned(Train) then begin
       Train.Line := Self;
-      Train.TargetStation := TLineStation(LineStations[0]);
-      Train.BaseTrackPoint := TTrackPoint(Track.Points.First);
+      Train.TargetStation := LineStations[0];
+      Train.BaseTrackPoint := Track.Points.First;
       Trains.Add(Train);
     end;
@@ -899 +897 @@
   // Determine track point range to be removed
   TP1 := ALineStation.TrackPoint.GetDown;
-  if not Assigned(TP1) then TP1 := TTrackPoint(Track.Points.First);
+  if not Assigned(TP1) then TP1 := Track.Points.First;
   TP2 := ALineStation.TrackPoint.GetUp;
-  if not Assigned(TP2) then TP2 := TTrackPoint(Track.Points.Last);
+  if not Assigned(TP2) then TP2 := Track.Points.Last;
 
   // Remove track points from trains
   for I := 0 to Trains.Count - 1 do
-  with TMetroTrain(Trains[I]) do begin
+  with Trains[I] do begin
     IsOnTrack := False;
     for J := Track.Points.IndexOf(TP1) to Track.Points.IndexOf(TP2) do
-    if TTrackPoint(Track.Points[J]) = BaseTrackPoint then begin
+    if Track.Points[J] = BaseTrackPoint then begin
       IsOnTrack := True;
       Break;
@@ -924 +922 @@
   // Delete old trackpoints
   Index := Track.Points.IndexOf(ALineStation.TrackPoint) - 1;
-  while (Index >= 0) and (not Assigned(TTrackPoint(Track.Points[Index]).LineStation)) do begin
+  while (Index >= 0) and (not Assigned(Track.Points[Index].LineStation)) do begin
     Track.Points.Delete(Index);
     Dec(Index);
@@ -930 +928 @@
   Index := Index + 1;
   Track.Points.Delete(Index);
-  while (Index < Track.Points.Count) and (not Assigned(TTrackPoint(Track.Points[Index]).LineStation)) do
+  while (Index < Track.Points.Count) and (not Assigned(Track.Points[Index].LineStation)) do
     Track.Points.Delete(Index);
 
   if ((Index - 1) >= 0) and (Index < Track.Points.Count) then
-    Track.RouteTrack(TTrackPoint(Track.Points[Index - 1]), TTrackPoint(Track.Points[Index]));
+    Track.RouteTrack(Track.Points[Index - 1], Track.Points[Index]);
 
   ALineStation.MapStation.Lines.Remove(Self);
@@ -940 +938 @@
 
   for I := 0 to Trains.Count - 1 do
-  with TMetroTrain(Trains[I]) do begin
+  with Trains[I] do begin
     if TargetStation = ALineStation then
-      TargetStation := TLineStation(LineStations[(Index + 1) mod LineStations.Count]);
+      TargetStation := LineStations[(Index + 1) mod LineStations.Count];
   end;
 
@@ -950 +948 @@
   if LineStations.Count < 2 then
   for I := Trains.Count - 1 downto 0 do begin
-    TMetroTrain(Trains[I]).Line := nil;
+    Trains[I].Line := nil;
     Trains.Delete(I);
   end;
@@ -968 +966 @@
   Index1 := Points.IndexOf(TP1);
   Index2 := Points.IndexOf(TP2);
-  P1 := TTrackPoint(Points[Index1]).PositionDesigned;
-  P2 := TTrackPoint(Points[Index2]).PositionDesigned;
+  P1 := Points[Index1].PositionDesigned;
+  P2 := Points[Index2].PositionDesigned;
   NewTrackPoint := Points.AddNew;
   Delta := Point(P2.X - P1.X, P2.Y - P1.Y);
@@ -1010 +1008 @@
   for I := 0 to Track.Points.Count - 1 do
   if I > 0 then
-    Result := Result + Distance(TTrackPoint(Track.Points[I]).Position, TTrackPoint(Track.Points[I - 1]).Position);
+    Result := Result + Distance(Track.Points[I].Position, Track.Points[I - 1].Position);
 end;
 
@@ -1028 +1026 @@
   LineStations.Free;
   Track.Free;
-  inherited Destroy;
+  inherited;
 end;
 
@@ -1035 +1033 @@
   Result := False;
   if LineStations.Count >= 2 then
-    Result := (TLineStation(LineStations.Last).MapStation = TLineStation(LineStations.First).MapStation);
+    Result := (LineStations.Last.MapStation = LineStations.First.MapStation);
 end;
 
@@ -1063 +1061 @@
   if Current < Target then begin
     for I := Current to Target - 1 do
-      Result := Result + TTrackPoint(Line.Track.Points[I]).GetDistance;
+      Result := Result + Line.Track.Points[I].GetDistance;
     Result := Result - Trunc(RelPos);
   end else
   if Current > Target then begin
     for I := Current - 1 downto Target do
-      Result := Result + TTrackPoint(Line.Track.Points[I]).GetDistance;
+      Result := Result + Line.Track.Points[I].GetDistance;
     Result := Result + Trunc(RelPos);
   end else Result := Trunc(RelPos);
@@ -1121 +1119 @@
 begin
   Passengers.Free;
-  inherited Destroy;
+  inherited;
 end;
 
@@ -1149 +1147 @@
   SortLines;
   for I := 0 to Lines.Count - 1 do begin
-    Line := TMetroLine(Lines[I]);
+    Line := Lines[I];
     LS := Line.LineStations.SearchMapStation(Self);
     TP := LS.TrackPoint;
     Index := Line.Track.Points.IndexOf(TP);
     if Index > 0 then begin
-      NewTrackLink := TTrackPoint(Line.Track.Points[Index]).GetLinkDown;
+      NewTrackLink := Line.Track.Points[Index].GetLinkDown;
       TrackLinks.Add(NewTrackLink);
     end;
     if Index < (Line.Track.Points.Count - 1) then begin
-      NewTrackLink := TTrackPoint(Line.Track.Points[Index]).GetLinkUp;
+      NewTrackLink := Line.Track.Points[Index].GetLinkUp;
       TrackLinks.Add(NewTrackLink);
     end;
-    if Line.IsCircular and (Self = TLineStation(Line.LineStations.First).MapStation) and
-    (Self = TLineStation(Line.LineStations.Last).MapStation) then begin
-      LS := TLineStation(Line.LineStations.Last);
+    if Line.IsCircular and (Self = Line.LineStations.First.MapStation) and
+    (Self = Line.LineStations.Last.MapStation) then begin
+      LS := Line.LineStations.Last;
       TP := LS.TrackPoint;
       Index := Line.Track.Points.IndexOf(TP);
       if Index > 0 then begin
-        NewTrackLink := TTrackPoint(Line.Track.Points[Index]).GetLinkDown;
+        NewTrackLink := Line.Track.Points[Index].GetLinkDown;
         TrackLinks.Add(NewTrackLink);
       end;
       if Index < (Line.Track.Points.Count - 1) then begin
-        NewTrackLink := TTrackPoint(Line.Track.Points[Index]).GetLinkUp;
+        NewTrackLink := Line.Track.Points[Index].GetLinkUp;
         TrackLinks.Add(NewTrackLink);
       end;
@@ -1180 +1178 @@
   TPAngleGroup := TTrackPointsAngleGroup.Create;
   for I := 0 to TrackLinks.Count - 1 do begin
-    P1 := TTrackPoint(TTrackLink(TrackLinks[I]).Points[0]).PositionDesigned;
-    P2 := TTrackPoint(TTrackLink(TrackLinks[I]).Points[1]).PositionDesigned;
+    P1 := TrackLinks[I].Points[0].PositionDesigned;
+    P2 := TrackLinks[I].Points[1].PositionDesigned;
     if ComparePoint(P1, Position) and not ComparePoint(P2, Position) then begin
       Angle := ArcTan2(P2.Y - Position.Y, P2.X - Position.X);
@@ -1195 +1193 @@
       TPAngleGroup.Add(GroupItem);
     end;
-    GroupItem.TrackLinks.Add(TTrackLink(TrackLinks[I]))
+    GroupItem.TrackLinks.Add(TrackLinks[I])
   end;
 
   // Shift TrackLinks according number of lines in group
   for I := 0 to TPAngleGroup.Count - 1 do
-  with TTrackPointsAngle(TPAngleGroup[I]) do begin
+  with TPAngleGroup[I] do begin
     for J := 0 to TrackLinks.Count - 1 do
-      with TTrackLink(TrackLinks[J]) do begin
+      with TrackLinks[J] do begin
         // Get orthogonal angle
         HAngle := Angle + Pi / 2;
@@ -1244 +1242 @@
   Distance := High(Integer);
   for I := 0 to Lines.Count - 1 do
-  with TMetroLine(Lines[I]) do begin
+  with Lines[I] do begin
     CurrentLineStation := LineStations.SearchMapStation(Current.MapStation);
     StationIndex := LineStations.IndexOf(CurrentLineStation);
@@ -1251 +1249 @@
       DirectionDown := False;
       for T := 0 to Trains.Count - 1 do begin
-        if TMetroTrain(Trains[T]).Direction = 1 then DirectionUp := True;
-        if TMetroTrain(Trains[T]).Direction = -1 then DirectionDown := True;
+        if Trains[T].Direction = 1 then DirectionUp := True;
+        if Trains[T].Direction = -1 then DirectionDown := True;
       end;
       if StationIndex = 0 then
-        NextStationDown := TLineStation(LineStations[LineStations.Count - 2])
+        NextStationDown := LineStations[LineStations.Count - 2]
       else
       if StationIndex > 0 then
-        NextStationDown := TLineStation(LineStations[StationIndex - 1]);
+        NextStationDown := LineStations[StationIndex - 1];
 
       if (StationIndex >= 0) and (StationIndex = LineStations.Count - 1) then
-        NextStationUp := TLineStation(LineStations[1])
+        NextStationUp := LineStations[1]
       else
       if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then
-        NextStationUp := TLineStation(LineStations[StationIndex + 1]);
+        NextStationUp := LineStations[StationIndex + 1];
     end else begin
       if StationIndex > 0 then begin
         DirectionDown := True;
-        NextStationDown := TLineStation(LineStations[StationIndex - 1])
+        NextStationDown := LineStations[StationIndex - 1]
       end else DirectionDown := False;
       if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then begin
         DirectionUp := True;
-        NextStationUp := TLineStation(LineStations[StationIndex + 1]);
+        NextStationUp := LineStations[StationIndex + 1];
       end else DirectionUp := False;
     end;
@@ -1284 +1282 @@
     end;
   end;
-  Result := (Check.MapStation.ShapeDistance[Shape] <> -1) and (Check.MapStation.ShapeDistance[Shape] <= Distance);
+  Result := (Check.MapStation.ShapeDistance[Shape] <> -1) and
+    (Check.MapStation.ShapeDistance[Shape] <= Distance);
 end;
 
@@ -1299 +1298 @@
   FreeAndNil(Lines);
   FreeAndNil(Passengers);
-  inherited Destroy;
+  inherited;
 end;
 
@@ -1336 +1335 @@
 begin
   I := 0;
-  while (I < Stations.Count) and (Distance(TMapStation(Stations[I]).Position, Pos) > ClickDistance) do Inc(I);
-  if I < Stations.Count then Result := TMapStation(Stations[I])
+  while (I < Stations.Count) and (Distance(Stations[I].Position, Pos) > ClickDistance) do Inc(I);
+  if I < Stations.Count then Result := Stations[I]
     else Result := nil;
 end;
@@ -1355 +1354 @@
   MinD := High(Integer);
   while (I < Lines.Count) do
-  with TMetroLine(Lines[I]) do begin
+  with Lines[I] do begin
     for T := 1 to Track.Points.Count - 1 do begin
-      D := PointToLineDistance(Pos, TTrackPoint(Track.Points[T - 1]).Position, TTrackPoint(Track.Points[T]).Position);
+      D := PointToLineDistance(Pos, Track.Points[T - 1].Position, Track.Points[T].Position);
       if (D < MinD) and (D < TrackClickDistance) then begin
         MinD := D;
-        Result.Points[0] := TTrackPoint(Track.Points[T - 1]);
-        Result.Points[1] := TTrackPoint(Track.Points[T]);
+        Result.Points[0] := Track.Points[T - 1];
+        Result.Points[1] := Track.Points[T];
       end;
     end;
@@ -1377 +1376 @@
   MinDistance := High(Integer);
   for I := 0 to Trains.Count - 1 do
-  with TMetroTrain(Trains[I]) do begin
+  with Trains[I] do begin
     D := Distance(GetPosition, Pos);
     if (D < (TrainSize div 2)) and (D < MinDistance) then begin
-      Result := TMetroTrain(Trains[I]);
+      Result := Trains[I];
       MinDistance := D;
     end;
@@ -1561 +1560 @@
       // Do for all lines connected to station
       for I := 0 to Lines.Count - 1 do
-      with TMetroLine(Lines[I]) do
+      with Lines[I] do
         for StationIndex := 0 to LineStations.Count - 1 do
-        if TLineStation(LineStations[StationIndex]).MapStation = Station then begin
+        if LineStations[StationIndex].MapStation = Station then begin
         if not IsCircular then begin
           // Update for all adjecent stations
           if StationIndex > 0 then
-            ComputeShapeDistanceStation(TLineStation(LineStations[StationIndex - 1]).MapStation,
+            ComputeShapeDistanceStation(LineStations[StationIndex - 1].MapStation,
             UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
           if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then
-            ComputeShapeDistanceStation(TLineStation(LineStations[StationIndex + 1]).MapStation,
+            ComputeShapeDistanceStation(LineStations[StationIndex + 1].MapStation,
             UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
         end else begin
@@ -1578 +1577 @@
           DirectionDown := False;
           for T := 0 to Trains.Count - 1 do begin
-            if TMetroTrain(Trains[T]).Direction = 1 then DirectionUp := True;
-            if TMetroTrain(Trains[T]).Direction = -1 then DirectionDown := True;
+            if Trains[T].Direction = 1 then DirectionUp := True;
+            if Trains[T].Direction = -1 then DirectionDown := True;
           end;
           // Update for all adjecent stations
           if DirectionUp then begin
             if StationIndex = 0 then
-              ComputeShapeDistanceStation(TLineStation(LineStations[LineStations.Count - 2]).MapStation,
+              ComputeShapeDistanceStation(LineStations[LineStations.Count - 2].MapStation,
               UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
             if StationIndex > 0 then
-              ComputeShapeDistanceStation(TLineStation(LineStations[StationIndex - 1]).MapStation,
+              ComputeShapeDistanceStation(LineStations[StationIndex - 1].MapStation,
               UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
           end;
           if DirectionDown then begin
             if (StationIndex >= 0) and (StationIndex = LineStations.Count - 1) then
-              ComputeShapeDistanceStation(TLineStation(LineStations[1]).MapStation,
+              ComputeShapeDistanceStation(LineStations[1].MapStation,
               UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
             if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then
-              ComputeShapeDistanceStation(TLineStation(LineStations[StationIndex + 1]).MapStation,
+              ComputeShapeDistanceStation(LineStations[StationIndex + 1].MapStation,
               UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
           end;
@@ -1617 +1616 @@
   // Move trains
   for I := 0 to Trains.Count - 1 do
-  with TMetroTrain(Trains[I]) do begin
+  with Trains[I] do begin
     if not Assigned(TargetStation) and Assigned(BaseTrackPoint) then begin
       if (Direction <> 1) and (Direction <> -1) then Direction := 1
@@ -1638 +1637 @@
             if Line.IsCircular then begin
               TargetStationIndex := Line.LineStations.Count - 2;
-              BaseTrackPoint := TLineStation(Line.LineStations.Last).TrackPoint;
+              BaseTrackPoint := Line.LineStations.Last.TrackPoint;
               RelPos := 0;
             end else begin
@@ -1648 +1647 @@
             if Line.IsCircular then begin
               TargetStationIndex := 1;
-              BaseTrackPoint := TLineStation(Line.LineStations.First).TrackPoint;
+              BaseTrackPoint := Line.LineStations.First.TrackPoint;
               RelPos := 0;
             end else begin
@@ -1655 +1654 @@
             end;
           end;
-          TargetStation := TLineStation(Line.LineStations[TargetStationIndex]);
+          TargetStation := Line.LineStations[TargetStationIndex];
 
           // Unload passengers in target station
           if Assigned(CurrentStation) then
           for P := Passengers.Count - 1 downto 0 do begin
-            if TMetroPassenger(Passengers[P]).Shape = CurrentStation.MapStation.Shape then begin
-              Passenger := TMetroPassenger(Passengers[P]);
+            if Passengers[P].Shape = CurrentStation.MapStation.Shape then begin
+              Passenger := Passengers[P];
               Passengers.Delete(P);
               Self.Passengers.Remove(Passenger);
@@ -1670 +1669 @@
           if Assigned(CurrentStation)  then
           for P := Passengers.Count - 1 downto 0 do begin
-            if not CurrentStation.MapStation.IsBestStationForShape(TMetroPassenger(Passengers[P]).Shape,
+            if not CurrentStation.MapStation.IsBestStationForShape(Passengers[P].Shape,
             TargetStation, CurrentStation) then begin
-              Passenger := TMetroPassenger(Passengers[P]);
+              Passenger := Passengers[P];
               Passengers.Delete(P);
               CurrentStation.MapStation.Passengers.Add(Passenger);
@@ -1685 +1684 @@
           for P := CurrentStation.MapStation.Passengers.Count - 1 downto 0 do begin
             if (Passengers.Count < TrainPassengerCount) then begin
-              Passenger := TMetroPassenger(CurrentStation.MapStation.Passengers[P]);
+              Passenger := CurrentStation.MapStation.Passengers[P];
               if CurrentStation.MapStation.IsBestStationForShape(Passenger.Shape,
             TargetStation, CurrentStation) then begin
@@ -1691 +1690 @@
                 CurrentStation.MapStation.Passengers.Delete(P);
                 Passengers.Add(Passenger);
-                Passenger.Train := TMetroTrain(Trains[I]);
+                Passenger.Train := Trains[I];
               end;
             end else Break; // No more space
@@ -1707 +1706 @@
         if Assigned(BaseTrackPoint) then
         while (Direction = -1) and (RelPos < 0) do begin
-          if BaseTrackPoint <> TLineStation(Line.LineStations.First).TrackPoint then begin
+          if BaseTrackPoint <> 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;
+              BaseTrackPoint := Line.LineStations.First.TrackPoint;
               RelPos := 0;
             end;
           end else
           if Line.IsCircular then begin
-            BaseTrackPoint := TLineStation(Line.LineStations.Last).TrackPoint;
+            BaseTrackPoint := Line.LineStations.Last.TrackPoint;
             RelPos := RelPos + BaseTrackPoint.GetDistance;
           end else begin
@@ -1726 +1725 @@
         if Assigned(BaseTrackPoint) then
         while (Direction = 1) and (RelPos > BaseTrackPoint.GetDistance) do begin
-          if BaseTrackPoint <> TLineStation(Line.LineStations.Last).TrackPoint then begin
+          if BaseTrackPoint <> 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;
+              BaseTrackPoint := Line.LineStations.Last.TrackPoint;
               RelPos := 0;
             end;
@@ -1736 +1735 @@
           if Line.IsCircular then begin
             RelPos := RelPos - BaseTrackPoint.GetDistance;
-            BaseTrackPoint := TLineStation(Line.LineStations.First).TrackPoint;
+            BaseTrackPoint := Line.LineStations.First.TrackPoint;
           end else begin
             RelPos := BaseTrackPoint.GetDistance;
@@ -1762 +1761 @@
 begin
   I := 0;
-  while (I < Lines.Count) and (TMetroLine(Lines[I]).Track.Points.Count > 0) do Inc(I);
-  if I < Lines.Count then Result := TMetroLine(Lines[I])
+  while (I < Lines.Count) and (Lines[I].Track.Points.Count > 0) do Inc(I);
+  if I < Lines.Count then Result := Lines[I]
     else Result := nil;
 end;
@@ -2025 +2024 @@
         ((Line.LineStations.SearchMapStation(FocusedStation) = nil) or
         ((Line.LineStations.Count > 0) and
-        ((TLineStation(Line.LineStations.First).MapStation = FocusedStation) or
-        (TLineStation(Line.LineStations.Last).MapStation = FocusedStation)) and
+        ((Line.LineStations.First.MapStation = FocusedStation) or
+        (Line.LineStations.Last.MapStation = FocusedStation)) and
         ((TrackStationDown = nil) or (TrackStationUp = nil)) and
         (not Line.IsCircular))) then begin
@@ -2058 +2057 @@
       FocusedTrack := GetTrackOnPos(View.PointDestToSrc(Position));
       if Assigned(FocusedTrack.Points[0]) then begin
-        SelectedTrain.Line := TTrackPoint(FocusedTrack.Points[0]).Track.Line;
+        SelectedTrain.Line := FocusedTrack.Points[0].Track.Line;
         SelectedTrain.Line.Trains.Add(SelectedTrain);
-        SelectedTrain.BaseTrackPoint := TTrackPoint(FocusedTrack.Points[0]);
+        SelectedTrain.BaseTrackPoint := FocusedTrack.Points[0];
       end else
       if Assigned(FocusedTrack.Points[1]) then begin
-        SelectedTrain.Line := TTrackPoint(FocusedTrack.Points[1]).Track.Line;
+        SelectedTrain.Line := FocusedTrack.Points[1].Track.Line;
         SelectedTrain.Line.Trains.Add(SelectedTrain);
-        SelectedTrain.BaseTrackPoint := TTrackPoint(FocusedTrack.Points[1]);
+        SelectedTrain.BaseTrackPoint := FocusedTrack.Points[1];
       end;
       FocusedTrack.Free;
@@ -2074 +2073 @@
       if Distance(Point(View.DestRect.Right div 2 - Length(LineColors) div 2 * LineColorsDist + I * LineColorsDist,
         View.DestRect.Bottom - LineColorsDist), Position) < 20 then begin
-          SelectedLine := TMetroLine(Lines[I]);
+          SelectedLine := Lines[I];
           Exit;
         end;
@@ -2080 +2079 @@
     // Remove single line station on line
     if Assigned(TrackStationDown) and (TrackStationDown.Track.Line.LineStations.Count = 1) then begin
-      TrackStationDown.Track.Line.DisconnectStation(TLineStation(TrackStationDown.Track.Line.LineStations.First));
+      TrackStationDown.Track.Line.DisconnectStation(TrackStationDown.Track.Line.LineStations.First);
     end;
     if Assigned(TrackStationUp) and (TrackStationUp.Track.Line.LineStations.Count = 1) then begin
-      TrackStationUp.Track.Line.DisconnectStation(TLineStation(TrackStationUp.Track.Line.LineStations.First));
+      TrackStationUp.Track.Line.DisconnectStation(TrackStationUp.Track.Line.LineStations.First);
     end;
   end else
@@ -2123 +2122 @@
     Track := GetTrackOnPos(View.PointDestToSrc(Position));
     if Assigned(Track) and Assigned(Track.Points[0]) and Assigned(Track.Points[1]) then begin
-      SelectedLine := TTrackPoint(Track.Points[0]).Track.Line;
-
-      TrackStationDown := TTrackPoint(Track.Points[0]);
+      SelectedLine := Track.Points[0].Track.Line;
+
+      TrackStationDown := Track.Points[0];
       NewIndex := TrackStationDown.Track.Points.IndexOf(TrackStationDown);
       while Assigned(TrackStationDown) and (not Assigned(TrackStationDown.LineStation)) do begin
         NewIndex := NewIndex - 1;
-        if NewIndex >= 0 then TrackStationDown := TTrackPoint(TrackStationDown.Track.Points[NewIndex])
+        if NewIndex >= 0 then TrackStationDown := TrackStationDown.Track.Points[NewIndex]
           else TrackStationDown := nil;
       end;
-      TrackStationUp := TTrackPoint(Track.Points[1]);
+      TrackStationUp := Track.Points[1];
       NewIndex := TrackStationUp.Track.Points.IndexOf(TrackStationDown);
       while Assigned(TrackStationUp) and (not Assigned(TrackStationUp.LineStation)) do begin
         NewIndex := NewIndex + 1;
         if NewIndex < TrackStationUp.Track.Points.Count then
-          TrackStationUp := TTrackPoint(TrackStationUp.Track.Points[NewIndex])
+          TrackStationUp := TrackStationUp.Track.Points[NewIndex]
           else TrackStationUp := nil;
       end;
@@ -2152 +2151 @@
       if Assigned(NewLine) then begin
         NewLine.ConnectStation(Station, nil, nil);
-        TrackStationDown := TTrackPoint(NewLine.Track.Points.Last);
+        TrackStationDown := NewLine.Track.Points.Last;
         TrackStationUp := nil;
         LastFocusedStation := Station;
@@ -2239 +2238 @@
   FreeAndNil(Stations);
   FreeAndNil(Lines);
-  inherited Destroy;
+  inherited;
 end;
 
@@ -2293 +2292 @@
 {      if (S = TrackPoints.Count - 1) then begin
         Canvas.Pen.EndCap := pecSquare;
-        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)));
+        Angle := arctan2(((TrackPoints[S].Position.Y - TrackPoints[S - 1].Position.Y),
+          (TrackPoints[S].Position.X - TrackPoints[S - 1].Position.X));
+        EndPoint := Point(Round(TrackPoints[S].Position.X + EndStationLength * Cos(Angle)),
+          Round(TrackPoints[S].Position.Y + EndStationLength * Sin(Angle)));
         Canvas.LineTo(EndPoint);
         Canvas.MoveTo(Point(Round(EndPoint.X + Cos(Angle + Pi / 2) * EndStationLength / 3),
@@ -2308 +2307 @@
     Canvas.Pen.Style := psSolid;
     Canvas.Pen.Width := MetroLineThickness div 2;
-    if Track.Points.Count > 0 then Canvas.MoveTo(TTrackPoint(Track.Points[0]).PositionDesigned);
+    if Track.Points.Count > 0 then Canvas.MoveTo(Track.Points[0].PositionDesigned);
     for S := 1 to Track.Points.Count - 1 do begin
-      Canvas.LineTo(TTrackPoint(Track.Points[S]).PositionDesigned);
+      Canvas.LineTo(Track.Points[S].PositionDesigned);
 {      if (S = TrackPoints.Count - 1) then begin
         Canvas.Pen.EndCap := pecSquare;
-        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)));
+        Angle := arctan2((TrackPoints[S].Position.Y - TrackPoints[S - 1].Position.Y),
+          (TrackPoints[S].Position.X - TrackPoints[S - 1].Position.X));
+        EndPoint := Point(Round(TrackPoints[S].Position.X + EndStationLength * Cos(Angle)),
+          Round(TrackPoints[S].Position.Y + EndStationLength * Sin(Angle)));
         Canvas.LineTo(EndPoint);
         Canvas.MoveTo(Point(Round(EndPoint.X + Cos(Angle + Pi / 2) * EndStationLength / 3),
@@ -2328 +2327 @@
     if (TrackPoints.Count > 1) then begin
       Canvas.Pen.EndCap := pecSquare;
-      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)));
+      Angle := arctan2((TrackPoints[1].Position.Y - TrackPoints[0].Position.Y),
+        (TrackPoints[1].Position.X - TrackPoints[0].Position.X));
+      Canvas.MoveTo(TrackPoints[0].Position);
+      EndPoint := Point(Round(TrackPoints[0].Position.X - EndStationLength * Cos(Angle)),
+        Round(TrackPoints[0].Position.Y - EndStationLength * Sin(Angle)));
       Canvas.LineTo(EndPoint);
       Canvas.MoveTo(Point(Round(EndPoint.X - Cos(Angle + Pi / 2) * EndStationLength / 3),

trunk/UTrack.pas

@@ -6 +6 @@
 
 uses
-  Classes, SysUtils, Contnrs;
+  Classes, SysUtils, fgl;
 
 type
@@ -28 +28 @@
   { TTrackPoints }
 
-  TTrackPoints = class(TObjectList)
+  TTrackPoints = class(TFPGObjectList<TTrackPoint>)
   end;
 
@@ -42 +42 @@
   { TTrackLinks }
 
-  TTrackLinks = class(TObjectList)
+  TTrackLinks = class(TFPGObjectList<TTrackLink>)
     function SearchPoints(Point1, Point2: TTrackPoint): TTrackLink;
   end;
@@ -58 +58 @@
   end;
 
+
 implementation
 
@@ -68 +69 @@
   I := 0;
   while (I < 0) and
-  ((TTrackLink(Items[I]).Points.First <> Point1) or (TTrackLink(Items[I]).Points.Last <> Point2))
-  and ((TTrackLink(Items[I]).Points.First <> Point2) or (TTrackLink(Items[I]).Points.Last <> Point1)) do
+  ((Items[I].Points.First <> Point1) or (Items[I].Points.Last <> Point2))
+  and ((Items[I].Points.First <> Point2) or (Items[I].Points.Last <> Point1)) do
   Inc(I);
-  if I < 0 then Result := TTrackLink(Items[I])
+  if I < 0 then Result := Items[I]
     else Result := nil;
 end;
@@ -86 +87 @@
 begin
   Points.Free;
-  inherited Destroy;
+  inherited;
 end;
 
@@ -146 +147 @@
   // Disconnect from all before destruction
   for I := NeighPoints.Count - 1 downto 0 do
-    TTrackPoint(NeighPoints[I]).Disconnect(Self);
+    NeighPoints[I].Disconnect(Self);
   if Assigned(Track) then Track.Points.Remove(Self);
   NeighPoints.Free;
-  inherited Destroy;
+  inherited;
 end;
 
@@ -162 +163 @@
 begin
   Points.Free;
-  inherited Destroy;
+  inherited;
 end;