Changeset 17

Timestamp:

Mar 27, 2015, 11:19:18 PM (10 years ago)

Author:

chronos

Message:

• Modified: Divided TMetroStation to TMapStation which are stations on map and TLineStation which are stations of TMetroLine. TMetroLine.LineStations items can refer to same TMapStation from First and Last item. Then line is closed and train can travel in round in single direction. Even in such case TMetroLine.LineStations.IndexOf(CurrentStation) can determine properly current station index.

Also refering to station from TTrackPoint was replaced from numeric index to object reference. So no absolute addressing is used and further improvement of TLineStation chain manipulation is simplified.

File:

• trunk/UEngine.pas (modified) (46 diffs)

trunk/UEngine.pas

@@ -17 +17 @@
   TMetroLine = class;
   TMetroTrains = class;
-
-  { TMetroStation }
-
-  TMetroStation = class
+  TTrackPoint = class;
+  TLineStation = class;
+
+  { TMapStation }
+
+  TMapStation = class
   private
   public
@@ -29 +31 @@
     Lines: TMetroLines;
     ShapeDistance: array[TStationShape] of Integer;
-    function GetBestStationForShape(Shape: TStationShape; Check: TMetroStation;
-      CurrentStationIndex: Integer): Boolean;
+    function GetBestStationForShape(Shape: TStationShape; Check, Current: TLineStation): Boolean;
     constructor Create;
     destructor Destroy; override;
   end;
 
-  { TMetroStations }
-
-  TMetroStations = class(TObjectList)
+  { TMapStations }
+
+  TMapStations = class(TObjectList)
     Engine: TEngine;
-    function AddNew: TMetroStation;
+    function AddNew: TMapStation;
+  end;
+
+  TLineStation = class
+    Line: TMetroLine;
+    MapStation: TMapStation;
+    TrackPoint: TTrackPoint;
+  end;
+
+  { TLineStations }
+
+  TLineStations = class(TObjectList)
+    Line: TMetroLine;
+    function SearchMapStation(Station: TMapStation): TLineStation;
   end;
 
   TTrackPoint = class
     Line: TMetroLine;
-    StationIndex: Integer;
+    LineStation: TLineStation;
     Point: TPoint;
     Pending: Boolean;
@@ -58 +72 @@
     Engine: TEngine;
     Color: TColor;
-    Stations: TMetroStations;
+    LineStations: TLineStations;
     Trains: TMetroTrains;
     TrackPoints: TTrackPoints;
-    procedure ConnectStation(Station: TMetroStation);
-    procedure DisconnectStation(Station: TMetroStation);
-    procedure AddTrack(P1, P2: TPoint; StationIndex: Integer);
+    procedure ConnectStation(Station: TMapStation);
+    procedure DisconnectStation(Station: TMapStation);
+    procedure RouteTrack(TP1, TP2: TTrackPoint);
     function GetTrackLength: Integer;
-    function GetStationTrackPos(StationIndex: Integer): Integer;
+    function GetStationTrackPos(LineStation: TLineStation): Integer;
     constructor Create;
     destructor Destroy; override;
@@ -84 +98 @@
   private
     LastPosDelta: Integer;
-    function GetTargetStation: TMetroStation;
   public
     Passengers: TMetroPassengers;
@@ -93 +106 @@
     InStation: Boolean;
     StationStopTime: TDateTime;
-    TargetStationIndex: Integer;
+    TargetStation: TLineStation;
     function GetPosition: TPoint;
     function GetAngle: Double;
     constructor Create;
     destructor Destroy; override;
-    property TargetStation: TMetroStation read GetTargetStation;
   end;
 
@@ -112 +124 @@
     Engine: TEngine;
     Shape: TStationShape;
-    Station: TMetroStation;
+    Station: TMapStation;
     Train: TMetroTrain;
   end;
@@ -138 +150 @@
   private
     LastMousePos: TPoint;
-    LastSelectedStation: TMetroStation;
+    LastSelectedStation: TMapStation;
     MouseHold: Boolean;
     LastNewStationTime: TDateTime;
@@ -149 +161 @@
     FTime: TDateTime;
     function GetExistStationShapes: TStationShapeSet;
-    function GetStationOnPos(Pos: TPoint): TMetroStation;
+    function GetStationOnPos(Pos: TPoint): TMapStation;
     function GetLineOnPos(Pos: TPoint): TMetroLine;
     procedure DrawLine(Canvas: TCanvas; Pos: TPoint);
@@ -157 +169 @@
     procedure DrawTrains(Canvas: TCanvas);
     procedure ComputeShapeDistance;
-    procedure ComputeShapeDistanceStation(Station: TMetroStation;
+    procedure ComputeShapeDistanceStation(Station: TMapStation;
       UpdatedShape: TStationShape; Distance: Integer);
     procedure TrainMovement;
+    function GetUnusedLine: TMetroLine;
   public
     Passengers: TMetroPassengers;
-    Stations: TMetroStations;
+    Stations: TMapStations;
     Lines: TMetroLines;
     Trains: TMetroTrains;
@@ -169 +182 @@
     View: TView;
     SelectedLine: TMetroLine;
-    SelectedStation: TMetroStation;
+    SelectedStation: TMapStation;
     ServedPassengerCount: Integer;
     State: TGameState;
@@ -206 +219 @@
   UGeometric;
 
+{ TLineStations }
+
+function TLineStations.SearchMapStation(Station: TMapStation): TLineStation;
+var
+  I: Integer;
+begin
+  I := 0;
+  while (I < Count) and (TLineStation(Items[I]).MapStation <> Station) do Inc(I);
+  if I < Count then Result := TLineStation(Items[I])
+    else Result := nil;
+end;
+
 { TMetroPassengers }
 
@@ -243 +268 @@
 end;
 
-{ TMetroStations }
-
-function TMetroStations.AddNew: TMetroStation;
+{ TMapStations }
+
+function TMapStations.AddNew: TMapStation;
 var
   D: Integer;
@@ -256 +281 @@
   Step = 20;
 begin
-  Result := TMetroStation.Create;
+  Result := TMapStation.Create;
   Result.Engine := Engine;
   Angle := Random * 2 * Pi;
@@ -267 +292 @@
     MinD := High(Integer);
     for I := 0 to Engine.Stations.Count - 1 do begin
-      D := Distance(TMetroStation(Engine.Stations[I]).Position, Result.Position);
+      D := Distance(TMapStation(Engine.Stations[I]).Position, Result.Position);
       if D < MinD then MinD := D;
     end;
@@ -301 +326 @@
 { TMetroLine }
 
-procedure TMetroLine.ConnectStation(Station: TMetroStation);
+procedure TMetroLine.ConnectStation(Station: TMapStation);
 var
   Train: TMetroTrain;
+  NewTrackPoint: TTrackPoint;
+  NewLineStation: TLineStation;
+begin
+  NewLineStation := TLineStation.Create;
+  NewLineStation.Line := Self;
+  NewLineStation.MapStation := Station;
+  LineStations.Add(NewLineStation);
+  Station.Lines.Add(Self);
+
+  NewTrackPoint := TTrackPoint.Create;
+  NewTrackPoint.LineStation := NewLineStation;
+  NewTrackPoint.Point := Station.Position;
+  NewTrackPoint.Line := TrackPoints.Line;
+  TrackPoints.Add(NewTrackPoint);
+
+  NewLineStation.TrackPoint := NewTrackPoint;
+
+  if LineStations.Count >= 2 then
+    RouteTrack(TLineStation(LineStations[LineStations.Count - 2]).TrackPoint, NewLineStation.TrackPoint);
+
+  // Place one train if at least two stations present
+  if (LineStations.Count = 2) then begin
+    Train := Engine.Trains.GetUnusedTrain;
+    if Assigned(Train) then begin
+      Train.Line := Self;
+      Train.TargetStation := TLineStation(LineStations[0]);
+      Trains.Add(Train);
+    end;
+  end;
+  Engine.ComputeShapeDistance;
+end;
+
+procedure TMetroLine.DisconnectStation(Station: TMapStation);
+var
+  I: Integer;
   StationIndex: Integer;
-  NewTrackPoint: TTrackPoint;
-begin
-  Stations.Add(Station);
-  Station.Lines.Add(Self);
-  StationIndex := Stations.Count - 1;
-  if Stations.Count = 1 then begin
-    NewTrackPoint := TTrackPoint.Create;
-    NewTrackPoint.StationIndex := StationIndex;
-    NewTrackPoint.Point := Station.Position;
-    NewTrackPoint.Line := TrackPoints.Line;
-    TrackPoints.Add(NewTrackPoint);
-  end else begin
-     if Stations.Count > 1 then
-       AddTrack(TMetroStation(Stations[Stations.Count - 2]).Position, Station.Position, StationIndex);
-       // Place one train if at least two stations present
-       if (Stations.Count = 2) then begin
-         Train := Engine.Trains.GetUnusedTrain;
-         if Assigned(Train) then begin
-           Train.Line := Self;
-           Train.TargetStationIndex := 0;
-           Trains.Add(Train);
-         end;
-       end;
-  end;
-  Engine.ComputeShapeDistance;
-end;
-
-procedure TMetroLine.DisconnectStation(Station: TMetroStation);
-var
-  I: Integer;
-  StationIndex: Integer;
-begin
-  if (Stations.Count > 0) and (Stations.Last = Station) then begin
-    StationIndex := Stations.Count - 1;
-    Stations.Delete(StationIndex);
+begin
+  if (LineStations.Count > 0) and (TLineStation(LineStations.Last).MapStation = Station) then begin
+    StationIndex := LineStations.Count - 1;
+    LineStations.Delete(StationIndex);
     Station.Lines.Remove(Self);
-    if Stations.Count > 0 then begin
+    if LineStations.Count > 0 then begin
       while (TrackPoints.Count > 0) and (not ComparePoint(TTrackPoint(TrackPoints.Last).Point,
-        TMetroStation(Stations.Last).Position)) do
+        TLineStation(LineStations.Last).MapStation.Position)) do
         TrackPoints.Delete(TrackPoints.Count - 1);
     end else TrackPoints.Clear;
+
     // Remove trains if less then two stations
-    if Stations.Count < 2 then
+    if LineStations.Count < 2 then
       for I := Trains.Count - 1 downto 0 do begin
         TMetroTrain(Trains[I]).Line := nil;
@@ -356 +386 @@
 end;
 
-procedure TMetroLine.AddTrack(P1, P2: TPoint; StationIndex: Integer);
-var
+procedure TMetroLine.RouteTrack(TP1, TP2: TTrackPoint);
+var
+  NewTrackPoint: TTrackPoint;
   Delta: TPoint;
-  NewTrackPoint: TTrackPoint;
-begin
+  P1, P2: TPoint;
+  Index1, Index2: Integer;
+begin
+  Index1 := TrackPoints.IndexOf(TP1);
+  Index2 := TrackPoints.IndexOf(TP2);
+  if Index2 <> Index1 + 1 then
+    raise Exception.Create('Supported only two neighbor track points for routing');
+  P1 := TTrackPoint(TrackPoints[Index1]).Point;
+  P2 := TTrackPoint(TrackPoints[Index2]).Point;
+  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 := TTrackPoint.Create;
-    NewTrackPoint.Line := TrackPoints.Line;
     NewTrackPoint.Point := Point(P2.X - Sign(Delta.X) * Abs(Delta.Y), P1.Y);
-    NewTrackPoint.StationIndex := StationIndex - 1;
-    TrackPoints.Add(NewTrackPoint);
   end else begin
-    NewTrackPoint := TTrackPoint.Create;
-    NewTrackPoint.Line := TrackPoints.Line;
     NewTrackPoint.Point := Point(P1.X, P2.Y - Sign(Delta.Y) * Abs(Delta.X));
-    NewTrackPoint.StationIndex := StationIndex - 1;
-    TrackPoints.Add(NewTrackPoint);
-  end;
-  NewTrackPoint := TTrackPoint.Create;
-  NewTrackPoint.Line := TrackPoints.Line;
-  NewTrackPoint.Point := P2;
-  NewTrackPoint.StationIndex := StationIndex;
-  TrackPoints.Add(NewTrackPoint);
+  end;
+  TrackPoints.Insert(Index1 + 1, NewTrackPoint);
 end;
 
@@ -392 +420 @@
 end;
 
-function TMetroLine.GetStationTrackPos(StationIndex: Integer): Integer;
+function TMetroLine.GetStationTrackPos(LineStation: TLineStation): Integer;
 var
   I: Integer;
@@ -400 +428 @@
     if I > 0 then
       Result := Result + Distance(TTrackPoint(TrackPoints[I]).Point, TTrackPoint(TrackPoints[I - 1]).Point);
-    if TTrackPoint(TrackPoints[I]).StationIndex = StationIndex then Break;
+    if TTrackPoint(TrackPoints[I]).LineStation = LineStation then Break;
   end;
 end;
@@ -406 +434 @@
 constructor TMetroLine.Create;
 begin
-  Stations := TMetroStations.Create;
-  Stations.OwnsObjects := False;
+  LineStations := TLineStations.Create;
+  LineStations.OwnsObjects := False;
   Trains := TMetroTrains.Create;
   Trains.OwnsObjects := False;
@@ -418 +446 @@
   TrackPoints.Free;
   Trains.Free;
-  Stations.Free;
+  LineStations.Free;
   inherited Destroy;
 end;
@@ -425 +453 @@
 begin
   Result := False;
-  if Stations.Count >= 2 then
-    Result := (Stations.Last = Stations.First);
+  if LineStations.Count >= 2 then
+    Result := (TLineStation(LineStations.Last).MapStation = TLineStation(LineStations.First).MapStation);
 end;
 
 { TMetroTrain }
-
-function TMetroTrain.GetTargetStation: TMetroStation;
-begin
-  Result := nil;
-  if Assigned(Line) then
-  if (TargetStationIndex >= 0) and (TargetStationIndex < Line.Stations.Count) then
-    Result := TMetroStation(Line.Stations[TargetStationIndex]);
-end;
 
 function TMetroTrain.GetPosition: TPoint;
@@ -502 +522 @@
 end;
 
-{ TMetroStation }
-
-function TMetroStation.GetBestStationForShape(Shape: TStationShape;
-  Check: TMetroStation; CurrentStationIndex: Integer): Boolean;
+{ TMapStation }
+
+function TMapStation.GetBestStationForShape(Shape: TStationShape;
+  Check, Current: TLineStation): Boolean;
 var
   I: Integer;
@@ -513 +533 @@
   DirectionUp: Boolean;
   DirectionDown: Boolean;
-  NextStationUp: TMetroStation;
-  NextStationDown: TMetroStation;
+  NextStationUp: TLineStation;
+  NextStationDown: TLineStation;
 begin
   Distance := High(Integer);
   for I := 0 to Lines.Count - 1 do
   with TMetroLine(Lines[I]) do begin
-    StationIndex := CurrentStationIndex;
+    StationIndex := LineStations.IndexOf(Current);
     if IsCircular then begin
       DirectionUp := False;
@@ -528 +548 @@
       end;
       if StationIndex = 0 then
-        NextStationDown := TMetroStation(Stations[Stations.Count - 2])
+        NextStationDown := TLineStation(LineStations[LineStations.Count - 2])
       else
       if StationIndex > 0 then
-        NextStationDown := TMetroStation(Stations[StationIndex - 1]);
-
-      if (StationIndex >= 0) and (StationIndex = Stations.Count - 1) then
-        NextStationUp := TMetroStation(Stations[1])
+        NextStationDown := TLineStation(LineStations[StationIndex - 1]);
+
+      if (StationIndex >= 0) and (StationIndex = LineStations.Count - 1) then
+        NextStationUp := TLineStation(LineStations[1])
       else
-      if (StationIndex >= 0) and (StationIndex < Stations.Count - 1) then
-        NextStationUp := TMetroStation(Stations[StationIndex + 1]);
+      if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then
+        NextStationUp := TLineStation(LineStations[StationIndex + 1]);
     end else begin
       if StationIndex > 0 then begin
         DirectionDown := True;
-        NextStationDown := TMetroStation(Stations[StationIndex - 1])
+        NextStationDown := TLineStation(LineStations[StationIndex - 1])
       end else DirectionDown := False;
-      if (StationIndex >= 0) and (StationIndex < Stations.Count - 1) then begin
+      if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then begin
         DirectionUp := True;
-        NextStationUp := TMetroStation(Stations[StationIndex + 1]);
+        NextStationUp := TLineStation(LineStations[StationIndex + 1]);
       end else DirectionUp := False;
     end;
-    if DirectionDown and (NextStationDown.ShapeDistance[Shape] <> -1) and
-      (NextStationDown.ShapeDistance[Shape] < Distance) then begin
-      Distance := NextStationDown.ShapeDistance[Shape];
-    end;
-    if DirectionUp and (NextStationUp.ShapeDistance[Shape] <> -1) and
-      (NextStationUp.ShapeDistance[Shape] < Distance) then begin
-      Distance := NextStationUp.ShapeDistance[Shape];
-    end;
-  end;
-  Result := Check.ShapeDistance[Shape] = Distance;
-end;
-
-constructor TMetroStation.Create;
+    if DirectionDown and (NextStationDown.MapStation.ShapeDistance[Shape] <> -1) and
+      (NextStationDown.MapStation.ShapeDistance[Shape] < Distance) then begin
+      Distance := NextStationDown.MapStation.ShapeDistance[Shape];
+    end;
+    if DirectionUp and (NextStationUp.MapStation.ShapeDistance[Shape] <> -1) and
+      (NextStationUp.MapStation.ShapeDistance[Shape] < Distance) then begin
+      Distance := NextStationUp.MapStation.ShapeDistance[Shape];
+    end;
+  end;
+  Result := Check.MapStation.ShapeDistance[Shape] = Distance;
+end;
+
+constructor TMapStation.Create;
 begin
   Passengers := TMetroPassengers.Create;
@@ -568 +588 @@
 end;
 
-destructor TMetroStation.Destroy;
+destructor TMapStation.Destroy;
 begin
   Lines.Free;
@@ -583 +603 @@
   Result := [];
   for I := 0 to Stations.Count - 1 do
-  with TMetroStation(Stations[I]) do begin
+  with TMapStation(Stations[I]) do begin
     Result := Result + [Shape];
   end;
 end;
 
-function TEngine.GetStationOnPos(Pos: TPoint): TMetroStation;
+function TEngine.GetStationOnPos(Pos: TPoint): TMapStation;
 var
   I: Integer;
@@ -595 +615 @@
 begin
   I := 0;
-  while (I < Stations.Count) and (Distance(TMetroStation(Stations[I]).Position, Pos) > ClickDistance) do Inc(I);
-  if I < Stations.Count then Result := TMetroStation(Stations[I])
+  while (I < Stations.Count) and (Distance(TMapStation(Stations[I]).Position, Pos) > ClickDistance) do Inc(I);
+  if I < Stations.Count then Result := TMapStation(Stations[I])
     else Result := nil;
 end;
@@ -727 +747 @@
   // Reset all distances
   for I := 0 to Stations.Count - 1 do
-  with TMetroStation(Stations[I]) do begin
+  with TMapStation(Stations[I]) do begin
     for S := Low(ShapeDistance) to High(ShapeDistance) do
       ShapeDistance[S] := -1;
@@ -735 +755 @@
   // Distace 0 means that station is final target
   for I := 0 to Stations.Count - 1 do
-  with TMetroStation(Stations[I]) do begin
-    ComputeShapeDistanceStation(TMetroStation(Stations[I]), Shape, 0);
-  end;
-end;
-
-procedure TEngine.ComputeShapeDistanceStation(Station: TMetroStation;
+  with TMapStation(Stations[I]) do begin
+    ComputeShapeDistanceStation(TMapStation(Stations[I]), Shape, 0);
+  end;
+end;
+
+procedure TEngine.ComputeShapeDistanceStation(Station: TMapStation;
   UpdatedShape: TStationShape; Distance: Integer);
 var
@@ -756 +776 @@
       with TMetroLine(Lines[I]) do
         for StationIndex := 0 to Stations.Count - 1 do
-        if TMetroStation(Stations[StationIndex]) = Station then begin
+        if TMapStation(Stations[StationIndex]) = Station then begin
         if not IsCircular then begin
           // Update for all adjecent stations
           if StationIndex > 0 then
-            ComputeShapeDistanceStation(TMetroStation(Stations[StationIndex - 1]), UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
+            ComputeShapeDistanceStation(TMapStation(Stations[StationIndex - 1]), UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
           if (StationIndex >= 0) and (StationIndex < Stations.Count - 1) then
-            ComputeShapeDistanceStation(TMetroStation(Stations[StationIndex + 1]), UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
+            ComputeShapeDistanceStation(TMapStation(Stations[StationIndex + 1]), UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
         end else begin
           // If circular then trains might go in single direction so passengers
@@ -775 +795 @@
           if DirectionUp then begin
             if StationIndex = 0 then
-              ComputeShapeDistanceStation(TMetroStation(Stations[Stations.Count - 2]), UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
+              ComputeShapeDistanceStation(TMapStation(Stations[Stations.Count - 2]), UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
             if StationIndex > 0 then
-              ComputeShapeDistanceStation(TMetroStation(Stations[StationIndex - 1]), UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
+              ComputeShapeDistanceStation(TMapStation(Stations[StationIndex - 1]), UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
           end;
           if DirectionDown then begin
             if (StationIndex >= 0) and (StationIndex = Stations.Count - 1) then
-              ComputeShapeDistanceStation(TMetroStation(Stations[1]), UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
+              ComputeShapeDistanceStation(TMapStation(Stations[1]), UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
             if (StationIndex >= 0) and (StationIndex < Stations.Count - 1) then
-              ComputeShapeDistanceStation(TMetroStation(Stations[StationIndex + 1]), UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
+              ComputeShapeDistanceStation(TMapStation(Stations[StationIndex + 1]), UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
           end;
         end;
@@ -794 +814 @@
 var
   I: Integer;
-  CurrentStationIndex: Integer;
-  CurrentStation: TMetroStation;
+  CurrentStation: TLineStation;
   P: Integer;
   Passenger: TMetroPassenger;
   PosDelta: Integer;
+  TargetStationIndex: Integer;
 begin
   // Move trains
@@ -806 +826 @@
       if InStation then begin
         if (Now - StationStopTime) > OneSecond then begin
-          CurrentStationIndex := TargetStationIndex;
-          if CurrentStationIndex >= Line.Stations.Count then
-            CurrentStationIndex := Line.Stations.Count - 1;
-          CurrentStation := nil;
-          if Assigned(Line) then
-            if (CurrentStationIndex >= 0) and (CurrentStationIndex < Line.Stations.Count) then
-          CurrentStation := TMetroStation(Line.Stations[CurrentStationIndex]);
+          CurrentStation := TargetStation;
 
           // Choose next target station
-          TargetStationIndex := TargetStationIndex + Direction;
+          TargetStationIndex := Line.LineStations.IndexOf(TargetStation) + Direction;
           if TargetStationIndex < 0 then begin
-            if Line.Stations.Last = Line.Stations.First then begin
-              TargetStationIndex := Line.Stations.Count - 2;
-              TrackPos := Line.GetStationTrackPos(Line.Stations.Count - 1);
+            if Line.IsCircular then begin
+              TargetStationIndex := Line.LineStations.Count - 2;
+              TrackPos := Line.GetStationTrackPos(TLineStation(Line.LineStations.Last));
             end else begin
               TargetStationIndex := 1;
               Direction := -Direction;
             end;
-          end else if TargetStationIndex >= Line.Stations.Count then begin
-            if Line.Stations.Last = Line.Stations.First then begin
+          end else if TargetStationIndex >= Line.LineStations.Count then begin
+            if Line.IsCircular then begin
               TargetStationIndex := 1;
               TrackPos := 0;
             end else begin
-              TargetStationIndex := Line.Stations.Count - 2;
+              TargetStationIndex := Line.LineStations.Count - 2;
               Direction := -Direction;
             end;
           end;
+          TargetStation := TLineStation(Line.LineStations[TargetStationIndex]);
 
           // Unload passengers in target station
-          if Assigned(CurrentStation) and (CurrentStationIndex < Line.Stations.Count) then
+          if Assigned(CurrentStation) then
           for P := Passengers.Count - 1 downto 0 do begin
-            if TMetroPassenger(Passengers[P]).Shape = CurrentStation.Shape then begin
+            if TMetroPassenger(Passengers[P]).Shape = CurrentStation.MapStation.Shape then begin
               Passenger := TMetroPassenger(Passengers[P]);
               Passengers.Delete(P);
@@ -845 +860 @@
           end;
           // Unload passengers to change line
-          if Assigned(CurrentStation) and (CurrentStationIndex < Line.Stations.Count) then
+          if Assigned(CurrentStation)  then
           for P := Passengers.Count - 1 downto 0 do begin
-            if not CurrentStation.GetBestStationForShape(TMetroPassenger(Passengers[P]).Shape,
-            TargetStation, CurrentStationIndex) then begin
+            if not CurrentStation.MapStation.GetBestStationForShape(TMetroPassenger(Passengers[P]).Shape,
+            TargetStation, CurrentStation) then begin
               Passenger := TMetroPassenger(Passengers[P]);
               Passengers.Delete(P);
-              CurrentStation.Passengers.Add(Passenger);
-              Passenger.Station := CurrentStation;
+              CurrentStation.MapStation.Passengers.Add(Passenger);
+              Passenger.Station := CurrentStation.MapStation;
             end;
           end;
 
           // Load new passengers
-          if Assigned(CurrentStation) and (CurrentStationIndex < Line.Stations.Count) then
-          for P := CurrentStation.Passengers.Count - 1 downto 0 do begin
+          if Assigned(CurrentStation)  then
+          for P := CurrentStation.MapStation.Passengers.Count - 1 downto 0 do begin
             if (Passengers.Count < TrainPassengerCount) then begin
-              Passenger := TMetroPassenger(CurrentStation.Passengers[P]);
-              if CurrentStation.GetBestStationForShape(Passenger.Shape, TargetStation, CurrentStationIndex) then begin
+              Passenger := TMetroPassenger(CurrentStation.MapStation.Passengers[P]);
+              if CurrentStation.MapStation.GetBestStationForShape(Passenger.Shape,
+            TargetStation, CurrentStation) then begin
                 Passenger.Station := nil;
-                CurrentStation.Passengers.Delete(P);
+                CurrentStation.MapStation.Passengers.Delete(P);
                 Passengers.Add(Passenger);
                 Passenger.Train := TMetroTrain(Trains[I]);
@@ -870 +886 @@
           end;
 
-          LastPosDelta := Abs(TrackPos - Line.GetStationTrackPos(TargetStationIndex));
+          LastPosDelta := Abs(TrackPos - Line.GetStationTrackPos(TargetStation));
           InStation := False;
         end;
       end else begin
-      TrackPos := TrackPos + Direction * TrainSpeed;
-      if TrackPos < 0 then begin
-        if Line.Stations.First = Line.Stations.Last then TrackPos := Line.GetTrackLength
-          else TrackPos := 0;
-      end else
-      if TrackPos > Line.GetTrackLength then begin
-        if Line.Stations.First = Line.Stations.Last then TrackPos := 0
-          else TrackPos := Line.GetTrackLength;
+        TrackPos := TrackPos + Direction * TrainSpeed;
+        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;
+        end;
+        PosDelta := Abs(TrackPos - Line.GetStationTrackPos(TargetStation));
+        if PosDelta >= LastPosDelta then begin
+          // We are getting far from station, stop at station
+          TrackPos := Line.GetStationTrackPos(TargetStation);
+          InStation := True;
+          StationStopTime := Now;
+        end;
+        LastPosDelta := PosDelta;
       end;
-      PosDelta := Abs(TrackPos - Line.GetStationTrackPos(TargetStationIndex));
-      if PosDelta >= LastPosDelta then begin
-        // We are getting far from station, stop at station
-        TrackPos := Line.GetStationTrackPos(TargetStationIndex);
-        InStation := True;
-        StationStopTime := Now;
-      end;
-      LastPosDelta := PosDelta;
-      end;
-    end;
-  end;
+    end;
+  end;
+end;
+
+function TEngine.GetUnusedLine: TMetroLine;
+var
+  I: Integer;
+begin
+  I := 0;
+  while (I < Lines.Count) and (TMetroLine(Lines[I]).TrackPoints.Count > 0) do Inc(I);
+  if I < Lines.Count then Result := TMetroLine(Lines[I])
+    else Result := nil;
 end;
 
@@ -998 +1024 @@
     LastNewPassengerTime := Now;
     for I := 0 to Stations.Count - 1 do
-    with TMetroStation(Stations[I]) do
+    with TMapStation(Stations[I]) do
     if Random < NewPassengerProbability then begin
       Passenger := Self.Passengers.AddNew;
-      Passenger.Station := TMetroStation(Stations[I]);
+      Passenger.Station := TMapStation(Stations[I]);
       Passengers.Add(Passenger);
 
@@ -1014 +1040 @@
   // Game over
   for I := 0 to Stations.Count - 1 do
-  with TMetroStation(Stations[I]) do begin
+  with TMapStation(Stations[I]) do begin
     if Passengers.Count > MaxWaitingPassengers then State := gsGameOver;
   end;
@@ -1024 +1050 @@
 procedure TEngine.MouseMove(Position: TPoint);
 var
-  Station: TMetroStation;
+  Station: TMapStation;
 begin
   LastMousePos := Position;
@@ -1031 +1057 @@
       Station := GetStationOnPos(Position);
       if not Assigned(LastSelectedStation) and Assigned(Station) then begin
-        if (SelectedLine.Stations.IndexOf(Station) = -1) then begin
+        if (SelectedLine.LineStations.SearchMapStation(Station) = nil) then begin
           SelectedLine.ConnectStation(Station);
           SelectedStation := Station;
         end else
-        if (SelectedLine.Stations.Count > 0) and (SelectedLine.Stations.Last = Station) then begin
+        if (SelectedLine.LineStations.Count > 0) and (TLineStation(SelectedLine.LineStations.Last).MapStation = Station) then begin
           SelectedLine.DisconnectStation(Station);
-          SelectedStation := TMetroStation(SelectedLine.Stations.Last);
-        end else if (SelectedLine.Stations.Count > 0) and (SelectedLine.Stations.First = Station) then begin
+          if SelectedLine.LineStations.Count > 0 then
+            SelectedStation := TLineStation(SelectedLine.LineStations.Last).MapStation
+            else SelectedStation := nil;
+        end else if (SelectedLine.LineStations.Count > 0) and (TLineStation(SelectedLine.LineStations.First).MapStation = Station) then begin
           SelectedLine.ConnectStation(Station);
           SelectedStation := Station;
@@ -1050 +1078 @@
 procedure TEngine.MouseUp(Button: TMouseButton; Position: TPoint);
 var
-  Station: TMetroStation;
+  Station: TMapStation;
   Line: TMetroLine;
   I: Integer;
@@ -1073 +1101 @@
 procedure TEngine.MouseDown(Button: TMouseButton; Position: TPoint);
 var
-  Station: TMetroStation;
+  Station: TMapStation;
   Line: TMetroLine;
   I: Integer;
+  NewLine: TMetroLine;
 begin
   if Button = mbLeft then begin
@@ -1087 +1116 @@
       if not Assigned(SelectedLine) then
       for I := 0 to Lines.Count - 1 do
-      if TMetroLine(Lines[I]).Stations.Count = 0 then begin
+      if TMetroLine(Lines[I]).LineStations.Count = 0 then begin
         SelectedLine := TMetroLine(Lines[I]);
         Break;
@@ -1099 +1128 @@
       Exit;
     end;
+
+    // New track creation from selected station as start
+    Station := GetStationOnPos(Position);
+    if Assigned(Station) then begin
+      NewLine := GetUnusedLine;
+      if Assigned(NewLine) then begin
+        NewLine.ConnectStation(Station);
+        SelectedStation := Station;
+        LastSelectedStation := Station;
+      end;
+    end;
   end;
 end;
@@ -1106 +1146 @@
   NewTrain: TMetroTrain;
   I: Integer;
-  NewStation: TMetroStation;
+  NewStation: TMapStation;
   InitialStationCount: Integer;
 begin
@@ -1143 +1183 @@
 constructor TEngine.Create;
 begin
-  Stations := TMetroStations.Create;
+  Stations := TMapStations.Create;
   Stations.Engine := Self;
   Lines := TMetroLines.Create;
@@ -1243 +1283 @@
   Canvas.Pen.Width := 5;
   for I := 0 to Stations.Count - 1 do
-  with TMetroStation(Stations[I]) do begin
+  with TMapStation(Stations[I]) do begin
     Canvas.Pen.Style := psSolid;
     if Assigned(SelectedLine) and (Lines.IndexOf(SelectedLine) <> -1) then begin