source: tags/1.0.0/UEngine.pas

unit UEngine;

{$mode delphi}

interface

uses
  Classes, SysUtils, Contnrs, Graphics, Controls, ExtCtrls, Math, DateUtils,
  UMetaCanvas;

type
  TStationShape = (ssCircle, ssSquare, ssTriangle, ssStar, ssPlus, ssPentagon,
    ssDiamond, ssQuarterCircle, ssHexagon, ssCross, ssHalfCircle, ssHeptagon);
  TStationShapeSet = set of TStationShape;
  TEngine = class;
  TMetroPassengers = class;
  TMetroLines = class;
  TMetroLine = class;
  TMetroTrains = class;
  TTrackPoint = class;
  TLineStation = class;
  TTrackPoints = class;
  TTrack = class;
  TTrackLink = class;
  TTrackLinks = class;

  { TMapStation }

  TMapStation = class
  private
    procedure ShiftTrackPoints;
    procedure SortLines;
  public
    Engine: TEngine;
    Shape: TStationShape;
    Position: TPoint;
    Passengers: TMetroPassengers;
    Lines: TMetroLines;
    ShapeDistance: array[TStationShape] of Integer;
    OverloadDuration: TDateTime;
    function IsBestStationForShape(Shape: TStationShape; Check, Current: TLineStation): Boolean;
    constructor Create;
    destructor Destroy; override;
  end;

  { TMapStations }

  TMapStations = class(TObjectList)
    Engine: TEngine;
    function GetRect: TRect;
    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 }

  TTrackPoint = class
    LineStation: TLineStation;
    Position: TPoint;
    //PositionShift: TPoint;
    PositionDesigned: TPoint;
    Pending: Boolean;
    Track: TTrack;
    NeighPoints: TTrackPoints;
    NeighLinks: TTrackLinks;
    LinkUp: TTrackLink;
    LinkDown: TTrackLink;
    procedure Connect(TrackPoint: TTrackPoint);
    procedure Disconnect(TrackPoint: TTrackPoint);
    function GetDown: TTrackPoint;
    function GetUp: TTrackPoint;
    function GetNeighDown: TTrackPoint;
    function GetNeighUp: TTrackPoint;
    function GetLinkDown: TTrackLink;
    function GetLinkUp: TTrackLink;
    // Move to TTrackLink later
    function GetDistance: Integer;
    constructor Create;
    destructor Destroy; override;
  end;

  { TTrackPoints }

  TTrackPoints = class(TObjectList)
    Track: TTrack;
    function AddNew: TTrackPoint;
  end;

  { TTrackLink }

  TTrackLink = class
    Points: TTrackPoints;
    Shift: TPoint;
    Track: TTrack;
    constructor Create;
    destructor Destroy; override;
  end;

  { TTrackLinks }

  TTrackLinks = class(TObjectList)
    Track: TTrack;
    function SearchPoints(Point1, Point2: TTrackPoint): TTrackLink;
    function AddNew: TTrackLink;
  end;

  TTrack = class
    Points: TTrackPoints;
    Links: TTrackLinks;
    Line: TMetroLine;
    procedure RouteTrack(TP1, TP2: TTrackPoint);
    procedure RemoveTrackBetween(TP1, TP2: TTrackPoint);
    constructor Create;
    destructor Destroy; override;
  end;

  { TTracks }

  TTracks = class(TObjectList)
    function SearchPointUp(TrackPoint: TTrackPoint; Skip: TTrackLink): TTrackLink;
    function SearchPointDown(TrackPoint: TTrackPoint; Skip: TTrackLink): TTrackLink;
  end;

  { TTrackPointsAngle }

  TTrackPointsAngle = class
    Angle: Double;
    TrackLinks: TTrackLinks;
    constructor Create;
    destructor Destroy; override;
  end;

  { TTrackPointsAngleGroup }

  TTrackPointsAngleGroup = class(TObjectList)
    function SearchAngle(Angle: Double): TTrackPointsAngle;
  end;

  { TMetroLine }

  TMetroLine = class
  private
    procedure UpdateEndingLines;
  public
    Index: Integer;
    Engine: TEngine;
    Color: TColor;
    LineStations: TLineStations;
    Trains: TMetroTrains;
    Track: TTrack;
    procedure ConnectStation(Station: TMapStation; LineStationDown, LineStationUp: TLineStation);
    procedure DisconnectStation(ALineStation: TLineStation);
    function GetTrackLength: Integer;
    constructor Create;
    destructor Destroy; override;
    function IsCircular: Boolean;
  end;

  { TMetroLines }

  TMetroLines = class(TObjectList)
    Engine: TEngine;
    function AddNew: TMetroLine;
    function SearchByColor(Color: TColor): TMetroLine;
  end;

  { TMetroTrain }

  TMetroTrain = class
  private
    FLine: TMetroLine;
    LastPosDelta: Integer;
    LastTrainMoveTime: TDateTime;
    StationStopTime: TDateTime;
    procedure SetLine(AValue: TMetroLine);
  public
    Passengers: TMetroPassengers;

    BaseTrackPoint: TTrackPoint;
    RelPos: Double;
    Direction: Integer;
    InStation: Boolean;
    TargetStation: TLineStation;
    function GetTargetStationDistance: Integer;
    function GetPosition: TPoint;
    function GetAngle: Double;
    constructor Create;
    destructor Destroy; override;
    property Line: TMetroLine read FLine write SetLine;
  end;

  { TMetroTrains }

  TMetroTrains = class(TObjectList)
    function GetUnusedTrain: TMetroTrain;
    function GetUnusedCount: Integer;
    function AddNew: TMetroTrain;
  end;

  TMetroPassenger = class
    Engine: TEngine;
    Shape: TStationShape;
    Station: TMapStation;
    Train: TMetroTrain;
  end;

  { TMetroPassengers }

  TMetroPassengers = class(TObjectList)
    Engine: TEngine;
    function AddNew: TMetroPassenger;
  end;

  { TRiver }

  TRiver = class
    Points: array of TPoint;
    procedure Paint(Canvas: TCanvas);
  end;

  TRivers = class(TObjectList)
  end;

  TMap = class
    Size: TPoint;
    Rivers: TRivers;
    constructor Create;
    destructor Destroy; override;
  end;

  { TView }

  TView = class
  private
    FDestRect: TRect;
    FSourceRect: TRect;
    FZoom: Double;
    procedure SetDestRect(AValue: TRect);
    procedure SetSourceRect(AValue: TRect);
    procedure SetZoom(AValue: Double);
  public
    function PointDestToSrc(Pos: TPoint): TPoint;
    function PointSrcToDest(Pos: TPoint): TPoint;
    constructor Create;
    property SourceRect: TRect read FSourceRect write SetSourceRect;
    property DestRect: TRect read FDestRect write SetDestRect;
    property Zoom: Double read FZoom write SetZoom;
  end;

  TGameState = (gsNotStarted, gsRunning, gsPaused, gsGameOver);

  { TEngine }

  TEngine = class
  private
    LastMousePos: TPoint;
    LastFocusedStation: TMapStation;
    MouseHold: Boolean;
    LastNewStationTime: TDateTime;
    LastNewPassengerTime: TDateTime;
    LastNewWeekTime: TDateTime;
    LastNewShapeTime: TDateTime;
    LastTickTime: TDateTime;
    FTime: TDateTime;
    FLastTime: TDateTime;
    MetaCanvas: TMetaCanvas;
    procedure ResizeView;
    function GetExistStationShapes: TStationShapeSet;
    function GetStationOnPos(Pos: TPoint): TMapStation;
    function GetTrackOnPos(Pos: TPoint): TTrackLink;
    function GetTrainOnPos(Pos: TPoint): TMetroTrain;
    procedure DrawLine(Canvas: TCanvas; Pos: TPoint);
    procedure DrawShape(Canvas: TCanvas; Position: TPoint; Shape: TStationShape;
      Size: Integer; Angle: Double);
    procedure DrawClock(Canvas: TCanvas);
    procedure DrawTrains(Canvas: TCanvas);
    procedure ComputeShapeDistance;
    procedure ComputeShapeDistanceStation(Station: TMapStation;
      UpdatedShape: TStationShape; Distance: Integer);
    procedure TrainMovement;
    function GetUnusedLine: TMetroLine;
    procedure ShiftTrackPoints;
  public
    Passengers: TMetroPassengers;
    Stations: TMapStations;
    Lines: TMetroLines;
    Trains: TMetroTrains;
    ShapeCount: Integer;
    Map: TMap;
    View: TView;
    SelectedLine: TMetroLine;
    SelectedTrain: TMetroTrain;
    TrackStationDown: TTrackPoint;
    TrackStationUp: TTrackPoint;
    ServedPassengerCount: Integer;
    State: TGameState;
    RedrawPending: Boolean;
    ImagePassenger: TImage;
    ImageLocomotive: TImage;
    procedure MouseMove(Position: TPoint);
    procedure MouseUp(Button: TMouseButton; Position: TPoint);
    procedure MouseDown(Button: TMouseButton; Position: TPoint);
    procedure Reset;
    procedure Redraw;
    constructor Create;
    destructor Destroy; override;
    procedure Tick;
    procedure Paint(TargetCanvas: TCanvas);
    property Time: TDateTime read FTime;
  end;

const
  clDarkYellow = TColor($00dede);
  clOrange = TColor($0080ff);
  clBrown = TColor($003090);
  clCyan = TColor($FFFF00);
  LineColors: array[0..8] of TColor = (clBlue, clRed, clDarkYellow, clGreen,
    clPurple, clGray, clOrange, clBrown, clCyan);
  StationSize = 30;
  StationOverloadSize = 60;
  PassengerSize = 15;
  TrainSize = 40;
  LineColorsDist = 50;
  TrainSpeed = 2000;
  ImagePassengerName = 'Images/Passenger.png';
  ImageLocomotiveName = 'Images/Locomotive.png';
  TrainPassengerCount = 6;
  StationMinDistance = 100;
  StationMaxDistance = 300;
  MaxWaitingPassengers = 10;
  MaxPassengersOveloadTime = 2;
  MetroLineThickness = 13;
  TrackClickDistance = 20;
  EndStationLength = 50;
  ShowDistances = False;
  //TimePerSecond = (60 * OneMinute);
  TimePerSecond = (60 * OneMinute);
  NewStationPeriod = 1;
  NewShapePeriod = 10;
  NewTrainPeriod = 7; // Each week
  NewPassengerPeriod = 0.3 * OneSecond;
  NewPassengerProbability = 0.003;
  VisiblePassengersPerLine = 6;

implementation

uses
  UGeometric;

resourcestring
  SZeroZoomNotAlowed = 'Zero zoom not allowed';

{ TTrackLinks }

function TTrackLinks.SearchPoints(Point1, Point2: TTrackPoint): TTrackLink;
var
  I: Integer;
begin
  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
  Inc(I);
  if I < 0 then Result := TTrackLink(Items[I])
    else Result := nil;
end;

function TTrackLinks.AddNew: TTrackLink;
begin
  Result := TTrackLink.Create;
  Result.Track := Track;
end;

{ TTrackPoints }

function TTrackPoints.AddNew: TTrackPoint;
begin
  Result := TTrackPoint.Create;
  Result.Track := Track;
end;

{ TTrack }

constructor TTrack.Create;
begin
  Points := TTrackPoints.Create;
  Points.Track := Self;
  Links := TTrackLinks.Create;
  Links.Track := Self;
end;

destructor TTrack.Destroy;
begin
  Points.Free;
  Links.Free;
  inherited Destroy;
end;

{ TTrackLink }

constructor TTrackLink.Create;
begin
  Points := TTrackPoints.Create;
  Points.OwnsObjects := False;
end;

destructor TTrackLink.Destroy;
begin
  Points.Free;
  inherited Destroy;
end;

{ TRiver }

procedure TRiver.Paint(Canvas: TCanvas);
begin
  Canvas.Brush.Color := $ffffe0;
  Canvas.Brush.Style := bsSolid;
  Canvas.Polygon(Points);
end;

{ TMap }

constructor TMap.Create;
begin
  Rivers := TRivers.Create;
end;

destructor TMap.Destroy;
begin
  Rivers.Free;
  inherited Destroy;
end;

{ TView }

procedure TView.SetDestRect(AValue: TRect);
var
  Diff: TPoint;
begin
  if RectEquals(FDestRect, AValue) then Exit;
  Diff := Point(Trunc((DestRect.Right - DestRect.Left) / Zoom - (AValue.Right - AValue.Left) / Zoom) div 2,
    Trunc((DestRect.Bottom - DestRect.Top) / Zoom - (AValue.Bottom - AValue.Top) / Zoom) div 2);
  FDestRect := AValue;
  FSourceRect := Bounds(FSourceRect.Left + Diff.X, FSourceRect.Top + Diff.Y,
    Trunc((DestRect.Right - DestRect.Left) / Zoom),
    Trunc((DestRect.Bottom - DestRect.Top) / Zoom));
end;

procedure TView.SetSourceRect(AValue: TRect);
var
  ZX: Double;
  ZY: Double;
begin
  if RectEquals(FSourceRect, AValue) then Exit;
  FSourceRect := AValue;
  ZX := (FDestRect.Right - FDestRect.Left) / (FSourceRect.Right - FSourceRect.Left);
  ZY := (FDestRect.Bottom - FDestRect.Top) / (FSourceRect.Bottom - FSourceRect.Top);
  if  ZX > ZY then
    Zoom := ZY
    else Zoom := ZX;
end;

procedure TView.SetZoom(AValue: Double);
begin
  if FZoom = AValue then Exit;
  if AValue = 0 then
    raise Exception.Create(SZeroZoomNotAlowed);
  FZoom := AValue;
  FSourceRect := Bounds(Trunc(FSourceRect.Left + (FSourceRect.Right - FSourceRect.Left) div 2 - (DestRect.Right - DestRect.Left) / Zoom / 2),
    Trunc(FSourceRect.Top +  (FSourceRect.Bottom - FSourceRect.Top) div 2 - (FDestRect.Bottom - DestRect.Top) / Zoom / 2),
    Trunc((DestRect.Right - DestRect.Left) / Zoom),
    Trunc((DestRect.Bottom - DestRect.Top) / Zoom));
end;

function TView.PointDestToSrc(Pos: TPoint): TPoint;
begin
  Result := Point(Trunc(Pos.X / FZoom + FSourceRect.Left),
    Trunc(Pos.Y / FZoom + FSourceRect.Top));
end;

function TView.PointSrcToDest(Pos: TPoint): TPoint;
begin
  Result := Point(Trunc((Pos.X - FSourceRect.Left) * FZoom),
    Trunc((Pos.Y - FSourceRect.Top) * FZoom));
end;

constructor TView.Create;
begin
  Zoom := 1;
end;

{ TTracks }

function TTracks.SearchPointUp(TrackPoint: TTrackPoint; Skip: TTrackLink): TTrackLink;
var
  I: Integer;
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])
    else Result := nil;
end;

function TTracks.SearchPointDown(TrackPoint: TTrackPoint; Skip: TTrackLink): TTrackLink;
var
  I: Integer;
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])
    else Result := nil;
end;

{ TTrackPointsAngleGroup }

function TTrackPointsAngleGroup.SearchAngle(Angle: Double): TTrackPointsAngle;
var
  I: Integer;
begin
  I := 0;
  while (I < Count) and (TTrackPointsAngle(Items[I]).Angle <> Angle) do Inc(I);
  if I < Count then Result := TTrackPointsAngle(Items[I])
    else Result := nil;
end;

{ TTrackPointsAngle }

constructor TTrackPointsAngle.Create;
begin
  TrackLinks := TTrackLinks.Create;
  TrackLinks.OwnsObjects := False;
end;

destructor TTrackPointsAngle.Destroy;
begin
  TrackLinks.Free;
  inherited Destroy;
end;

{ TTrackPoint }

procedure TTrackPoint.Connect(TrackPoint: TTrackPoint);
var
  NewLink: TTrackLink;
begin
  if NeighPoints.IndexOf(TrackPoint) = -1 then begin
    NeighPoints.Add(TrackPoint);
    TrackPoint.NeighPoints.Add(Self);

    // Add new link to both self and connected track point
    NewLink := Track.Links.AddNew;
    NewLink.Points.Add(TrackPoint);
    NewLink.Points.Add(Self);
    NeighLinks.Add(NewLink);
    TrackPoint.NeighLinks.Add(NewLink);
    Track.Links.Add(NewLink);
  end else raise Exception.Create('Trying to connect already connected track point');
end;

procedure TTrackPoint.Disconnect(TrackPoint: TTrackPoint);
var
  Index: Integer;
  Link: TTrackLink;
begin
  Index := NeighPoints.IndexOf(TrackPoint);
  if NeighPoints.IndexOf(TrackPoint) <> -1 then begin
    NeighPoints.Delete(Index);
    TrackPoint.NeighPoints.Remove(Self);

    // Remove link from both track points
    Link := NeighLinks.SearchPoints(Self, TrackPoint);
    NeighLinks.Remove(Link);
    TrackPoint.NeighLinks.Remove(Link);
    Track.Links.Remove(Link);
  end else raise Exception.Create('Trying to disconnect not connected track point');
end;

function TTrackPoint.GetDown: TTrackPoint;
var
  I: Integer;
begin
  I := Track.Points.IndexOf(Self) - 1;
  while (I >= 0) and not Assigned(TTrackPoint(Track.Points[I]).LineStation) do
    Dec(I);
  if I >= 0 then Result := TTrackPoint(Track.Points[I])
    else Result := nil;
end;

function TTrackPoint.GetUp: TTrackPoint;
var
  I: Integer;
begin
  I := Track.Points.IndexOf(Self) + 1;
  while (I < Track.Points.Count) and not Assigned(TTrackPoint(Track.Points[I]).LineStation) do
    Inc(I);
  if I < Track.Points.Count then Result := TTrackPoint(Track.Points[I])
    else Result := nil;
end;

function TTrackPoint.GetNeighDown: TTrackPoint;
var
  NewIndex: Integer;
begin
  Result := nil;
  NewIndex := Track.Points.IndexOf(Self) - 1;
  if NewIndex >= 0 then Result := TTrackPoint(Track.Points[NewIndex]);
end;

function TTrackPoint.GetNeighUp: TTrackPoint;
var
  NewIndex: Integer;
begin
  Result := nil;
  if Assigned(Track) then begin
    NewIndex := Track.Points.IndexOf(Self) + 1;
    if NewIndex < Track.Points.Count then Result := TTrackPoint(Track.Points[NewIndex]);
  end;
end;

function TTrackPoint.GetLinkDown: TTrackLink;
begin
  if Assigned(LinkDown) then Result := LinkDown
    else begin
      LinkDown := TTrackLink.Create;
      LinkDown.Points.Add(GetNeighDown);
      LinkDown.Points.Add(Self);
      Result := LinkDown;
      GetNeighDown.LinkUp := LinkDown;
    end;
end;

function TTrackPoint.GetLinkUp: TTrackLink;
begin
  if Assigned(LinkUp) then Result := LinkUp
    else begin
      LinkUp := TTrackLink.Create;
      LinkUp.Points.Add(Self);
      LinkUp.Points.Add(GetNeighUp);
      Result := LinkUp;
      GetNeighUp.LinkDown := LinkUp;
    end;
end;

function TTrackPoint.GetDistance: Integer;
var
  Index: Integer;
begin
  Index := Track.Points.IndexOf(Self);
  Result := Distance(TTrackPoint(Track.Points[Index + 1]).Position,
    TTrackPoint(Track.Points[Index]).Position);
end;

constructor TTrackPoint.Create;
begin
  NeighPoints := TTrackPoints.Create;
  NeighPoints.OwnsObjects := False;
  NeighLinks := TTrackLinks.Create;
  NeighLinks.OwnsObjects := False;
end;

destructor TTrackPoint.Destroy;
begin
  NeighLinks.Free;
  NeighPoints.Free;
  inherited Destroy;
end;

{ 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 }

function TMetroPassengers.AddNew: TMetroPassenger;
begin
  Result := TMetroPassenger.Create;
  Result.Engine := Engine;
  Result.Shape := TStationShape(Random(Integer(Engine.ShapeCount)));
  Add(Result);
end;

{ TMetroTrains }

function TMetroTrains.GetUnusedTrain: TMetroTrain;
var
  I: Integer;
begin
  I := 0;
  while (I < Count) and (Assigned(TMetroTrain(Items[I]).Line)) do Inc(I);
  if I < Count then Result := TMetroTrain(Items[I])
    else Result := nil;
end;

function TMetroTrains.GetUnusedCount: Integer;
var
  I: Integer;
begin
  Result := 0;
  for I := 0 to Count - 1 do
    if not Assigned(TMetroTrain(Items[I]).Line) then Inc(Result);
end;

function TMetroTrains.AddNew: TMetroTrain;
begin
  Result := TMetroTrain.Create;
  Add(Result);
end;

{ TMapStations }

function TMapStations.GetRect: TRect;
var
  I: Integer;
begin
  if Count > 0 then begin
    with TMapStation(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
      if Position.X < Result.Left then Result.Left := Position.X;
      if Position.X > Result.Right then Result.Right := Position.X;
      if Position.Y < Result.Top then Result.Top := Position.Y;
      if Position.Y > Result.Bottom then Result.Bottom := Position.Y;
    end;
  end else Result := Rect(0, 0, 0, 0);
end;

function TMapStations.AddNew: TMapStation;
var
  D: Integer;
  MinD: Integer;
  I: Integer;
  Pass: Integer;
  Angle: Double;
  L: Integer;
const
  Step = 20;
begin
  Result := TMapStation.Create;
  Result.Engine := Engine;
  Angle := Random * 2 * Pi;
  // Ensure minimum distance between stations
  Pass := 0;
  L := Step;
  repeat
    Result.Position := Point(Trunc(Engine.Map.Size.X / 2 + Cos(Angle) * L * 1.5),
      Trunc(Engine.Map.Size.Y / 2 + Sin(Angle) * L));
    MinD := High(Integer);
    for I := 0 to Engine.Stations.Count - 1 do begin
      D := Distance(TMapStation(Engine.Stations[I]).Position, Result.Position);
      if D < MinD then MinD := D;
    end;
    Inc(Pass);
    L := L + StationMinDistance div 2;
  until (MinD > StationMinDistance) or
    (Pass > 1000) or (Engine.Stations.Count = 0);
  Result.Shape := TStationShape(Random(Integer(Engine.ShapeCount)));
  Add(Result);
  Engine.ComputeShapeDistance;
end;

{ TMetroLines }

function TMetroLines.AddNew: TMetroLine;
begin
  Result := TMetroLine.Create;
  Result.Color := LineColors[Count];
  Result.Engine := Engine;
  Result.Index := Count;
  Add(Result);
end;

function TMetroLines.SearchByColor(Color: TColor): TMetroLine;
var
  I: Integer;
begin
  I := 0;
  while (I < Count) and (TMetroLine(Items[I]).Color <> Color) do Inc(I);
  if I < Count then Result := TMetroLine(Items[I])
    else Result := nil;
end;

{ TMetroLine }

procedure TMetroLine.UpdateEndingLines;
var
  Index: Integer;
  NewTrackPoint: TTrackPoint;
  Angle: Double;
  EndPoint: TPoint;
begin
  if LineStations.Count >= 2 then begin
    Index := Track.Points.IndexOf(TLineStation(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);
    if Index = Track.Points.Count - 1 then begin
      NewTrackPoint := Track.Points.AddNew;
      Track.Points.Insert(Track.Points.Count, NewTrackPoint);
    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;
  end;
end;

procedure TMetroLine.ConnectStation(Station: TMapStation; LineStationDown, LineStationUp: TLineStation);
var
  Train: TMetroTrain;
  NewTrackPoint: TTrackPoint;
  NewLineStation: TLineStation;
  Index: Integer;
begin
  if not Assigned(Station) then
    raise Exception.Create('Station have to be defined');
  if not Assigned(LineStationDown) and not Assigned(LineStationUp) and (LineStations.Count > 0) then
    raise Exception.Create('No old line station to connect new station');
  NewLineStation := TLineStation.Create;
  NewLineStation.Line := Self;
  NewLineStation.MapStation := Station;
  Index := 0;
  if Assigned(LineStationDown) then Index := LineStations.IndexOf(LineStationDown) + 1
    else if Assigned(LineStationDown) then Index := LineStations.IndexOf(LineStationUp);
  LineStations.Insert(Index, NewLineStation);
  Station.Lines.Add(Self);

  NewTrackPoint := Track.Points.AddNew;
  NewTrackPoint.LineStation := NewLineStation;
  NewTrackPoint.Position := Station.Position;
  NewTrackPoint.PositionDesigned := NewTrackPoint.Position;
  Index := 0;
  if Assigned(LineStationDown) then Index := Track.Points.IndexOf(LineStationDown.TrackPoint) + 1
    else if Assigned(LineStationUp) then Index := Track.Points.IndexOf(LineStationUp.TrackPoint);
  Track.Points.Insert(Index, NewTrackPoint);
  NewLineStation.TrackPoint := NewTrackPoint;

  if Assigned(LineStationDown) then
    Track.RouteTrack(NewLineStation.TrackPoint.GetDown, NewLineStation.TrackPoint);
  if Assigned(LineStationUp) then
    Track.RouteTrack(NewLineStation.TrackPoint, NewLineStation.TrackPoint.GetUp);

  // 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]);
      Train.BaseTrackPoint := TTrackPoint(Track.Points.First);
      Trains.Add(Train);
    end;
  end;
  UpdateEndingLines;
  Engine.ComputeShapeDistance;
  Engine.ShiftTrackPoints;
end;

procedure TMetroLine.DisconnectStation(ALineStation: TLineStation);
var
  I: Integer;
  J: Integer;
  Index: Integer;
  TP1, TP2: TTrackPoint;
  IsOnTrack: Boolean;
begin
  // Determine track point range to be removed
  TP1 := ALineStation.TrackPoint.GetDown;
  if not Assigned(TP1) then TP1 := TTrackPoint(Track.Points.First);
  TP2 := ALineStation.TrackPoint.GetUp;
  if not Assigned(TP2) then TP2 := TTrackPoint(Track.Points.Last);

  // Remove track points from trains
  for I := 0 to Trains.Count - 1 do
  with TMetroTrain(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
      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 := Track.Points.IndexOf(ALineStation.TrackPoint) - 1;
  while (Index >= 0) and (not Assigned(TTrackPoint(Track.Points[Index]).LineStation)) do begin
    Track.Points.Delete(Index);
    Dec(Index);
  end;
  Index := Index + 1;
  Track.Points.Delete(Index);
  while (Index < Track.Points.Count) and (not Assigned(TTrackPoint(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]));

  ALineStation.MapStation.Lines.Remove(Self);
  Index := LineStations.IndexOf(ALineStation);

  for I := 0 to Trains.Count - 1 do
  with TMetroTrain(Trains[I]) do begin
    if TargetStation = ALineStation then
      TargetStation := TLineStation(LineStations[(Index + 1) mod LineStations.Count]);
  end;

  LineStations.Delete(Index);

  // Remove all trains if less then two stations
  if LineStations.Count < 2 then
  for I := Trains.Count - 1 downto 0 do begin
    TMetroTrain(Trains[I]).Line := nil;
    Trains.Delete(I);
  end;
  UpdateEndingLines;
  Engine.ComputeShapeDistance;
  Engine.ShiftTrackPoints;
end;

procedure TTrack.RouteTrack(TP1, TP2: TTrackPoint);
var
  NewTrackPoint: TTrackPoint;
  Delta: TPoint;
  P1, P2: TPoint;
  Index1, Index2: Integer;
begin
  RemoveTrackBetween(TP1, TP2);
  Index1 := Points.IndexOf(TP1);
  Index2 := Points.IndexOf(TP2);
  P1 := TTrackPoint(Points[Index1]).PositionDesigned;
  P2 := TTrackPoint(Points[Index2]).PositionDesigned;
  NewTrackPoint := Points.AddNew;
  Delta := Point(P2.X - P1.X, P2.Y - P1.Y);
  if Abs(Delta.X) > Abs(Delta.Y) then begin
    NewTrackPoint.PositionDesigned := Point(P2.X - Sign(Delta.X) * Abs(Delta.Y), P1.Y);
    NewTrackPoint.Position := NewTrackPoint.PositionDesigned;
  end else begin
    NewTrackPoint.PositionDesigned := Point(P1.X, P2.Y - Sign(Delta.Y) * Abs(Delta.X));
    NewTrackPoint.Position := NewTrackPoint.PositionDesigned;
  end;
  Points.Insert(Index1 + 1, NewTrackPoint);
end;

procedure TTrack.RemoveTrackBetween(TP1, TP2: TTrackPoint);
var
  Index1, Index2: Integer;
  Temp: Integer;
  I: Integer;
begin
  Index1 := Points.IndexOf(TP1);
  Index2 := Points.IndexOf(TP2);
  if (Index1 = -1) then
    raise Exception.Create('TrackPoint1 not found');
  if (Index2 = -1) then
    raise Exception.Create('TrackPoint2 not found');
  if Index1 > Index2 then begin
    Temp := Index1;
    Index1 := Index2;
    Index2 := Temp;
  end;
  for I := 1 to Index2 - Index1 - 1 do
    Points.Delete(Index1 + 1);
end;

function TMetroLine.GetTrackLength: Integer;
var
  I: Integer;
begin
  Result := 0;
  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);
end;

constructor TMetroLine.Create;
begin
  LineStations := TLineStations.Create;
  LineStations.OwnsObjects := True;
  Trains := TMetroTrains.Create;
  Trains.OwnsObjects := False;
  Track := TTrack.Create;
  Track.Line := Self;
end;

destructor TMetroLine.Destroy;
begin
  Trains.Free;
  LineStations.Free;
  Track.Free;
  inherited Destroy;
end;

function TMetroLine.IsCircular: Boolean;
begin
  Result := False;
  if LineStations.Count >= 2 then
    Result := (TLineStation(LineStations.Last).MapStation = TLineStation(LineStations.First).MapStation);
end;

{ TMetroTrain }

procedure TMetroTrain.SetLine(AValue: TMetroLine);
begin
  if FLine = AValue then Exit;
  FLine := AValue;
  if AValue = nil then begin
    RelPos := 0;
    BaseTrackPoint := nil;
    TargetStation := nil;
  end;
end;

function TMetroTrain.GetTargetStationDistance: Integer;
var
  Current: Integer;
  Target: Integer;
  I: Integer;
begin
  Result := 0;
  if Assigned(BaseTrackPoint) and Assigned(TargetStation) then begin
  Current := Line.Track.Points.IndexOf(BaseTrackPoint);
  Target := Line.Track.Points.IndexOf(TargetStation.TrackPoint);
  if Current < Target then begin
    for I := Current to Target - 1 do
      Result := Result + TTrackPoint(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 + Trunc(RelPos);
  end else Result := Trunc(RelPos);
  end;
end;

function TMetroTrain.GetPosition: TPoint;
var
  D: Integer;
  Delta: TPoint;
  UpPoint: TTrackPoint;
begin
  Result := Point(0, 0);
  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;

function TMetroTrain.GetAngle: Double;
var
  UpPoint: TTrackPoint;
begin
  Result := 0;
  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;
end;

constructor TMetroTrain.Create;
begin
  Passengers := TMetroPassengers.Create;
  Passengers.OwnsObjects := False;
  Direction := 1;
  Line := nil;
end;

destructor TMetroTrain.Destroy;
begin
  Passengers.Free;
  inherited Destroy;
end;

{ TMapStation }

procedure TMapStation.ShiftTrackPoints;
var
  TrackLinks: TTrackLinks;
  I: Integer;
  J: Integer;
  Index: Integer;
  TP: TTrackPoint;
  LS: TLineStation;
  Line: TMetroLine;
  Angle: Float;
  TPAngleGroup: TTrackPointsAngleGroup;
  GroupItem: TTrackPointsAngle;
  NewTrackLink: TTrackLink;
  HAngle: Double;
  P1, P2: TPoint;
  NewShift: TPoint;
begin
  TrackLinks := TTrackLinks.Create;
  TrackLinks.OwnsObjects := False;

  // Collect all near track points as track links
  SortLines;
  for I := 0 to Lines.Count - 1 do begin
    Line := TMetroLine(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;
      TrackLinks.Add(NewTrackLink);
    end;
    if Index < (Line.Track.Points.Count - 1) then begin
      NewTrackLink := TTrackPoint(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);
      TP := LS.TrackPoint;
      Index := Line.Track.Points.IndexOf(TP);
      if Index > 0 then begin
        NewTrackLink := TTrackPoint(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;
        TrackLinks.Add(NewTrackLink);
      end;
    end;
  end;

  // Make groups of TrackLinks with same angle
  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;
    if ComparePoint(P1, Position) and not ComparePoint(P2, Position) then begin
      Angle := ArcTan2(P2.Y - Position.Y, P2.X - Position.X);
    end else
    if ComparePoint(P2, Position) and not ComparePoint(P1, Position) then begin
      Angle := ArcTan2(P1.Y - Position.Y, P1.X - Position.X);
    end else Angle := 0;// else raise Exception.Create('TrackLink angle rrror');

    GroupItem := TPAngleGroup.SearchAngle(Angle);
    if not Assigned(GroupItem) then begin
      GroupItem := TTrackPointsAngle.Create;
      GroupItem.Angle := Angle;
      TPAngleGroup.Add(GroupItem);
    end;
    GroupItem.TrackLinks.Add(TTrackLink(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
    for J := 0 to TrackLinks.Count - 1 do
      with TTrackLink(TrackLinks[J]) do begin
        // Get orthogonal angle
        HAngle := Angle + Pi / 2;
        if HAngle > Pi then HAngle := HAngle - Pi;
        NewShift.X := Trunc(MetroLineThickness * Cos(HAngle) * (J - (TrackLinks.Count - 1) / 2));
        NewShift.Y := Trunc(MetroLineThickness * Sin(HAngle) * (J - (TrackLinks.Count - 1) / 2));
        //NewShift.X := TrackLinks.Count;
        Shift := NewShift;
      end;
  end;

  TPAngleGroup.Free;
  TrackLinks.Free;
end;

function MapStationCompareLine(Item1, Item2: Pointer): Integer;
begin
  if TMetroLine(Item1).Index > TMetroLine(Item2).Index then Result := 1
  else if TMetroLine(Item1).Index < TMetroLine(Item2).Index then Result := -1
  else Result := 0;
end;

procedure TMapStation.SortLines;
begin
  Lines.Sort(MapStationCompareLine);
end;

function TMapStation.IsBestStationForShape(Shape: TStationShape;
  Check, Current: TLineStation): Boolean;
var
  I: Integer;
  T: Integer;
  Distance: Integer;
  StationIndex: Integer;
  DirectionUp: Boolean;
  DirectionDown: Boolean;
  NextStationUp: TLineStation;
  NextStationDown: TLineStation;
  CurrentLineStation: TLineStation;
begin
  Distance := High(Integer);
  for I := 0 to Lines.Count - 1 do
  with TMetroLine(Lines[I]) do begin
    CurrentLineStation := LineStations.SearchMapStation(Current.MapStation);
    StationIndex := LineStations.IndexOf(CurrentLineStation);
    if IsCircular then begin
      DirectionUp := False;
      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;
      end;
      if StationIndex = 0 then
        NextStationDown := TLineStation(LineStations[LineStations.Count - 2])
      else
      if StationIndex > 0 then
        NextStationDown := TLineStation(LineStations[StationIndex - 1]);

      if (StationIndex >= 0) and (StationIndex = LineStations.Count - 1) then
        NextStationUp := TLineStation(LineStations[1])
      else
      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 := TLineStation(LineStations[StationIndex - 1])
      end else DirectionDown := False;
      if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then begin
        DirectionUp := True;
        NextStationUp := TLineStation(LineStations[StationIndex + 1]);
      end else DirectionUp := False;
    end;
    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] <> -1) and (Check.MapStation.ShapeDistance[Shape] <= Distance);
end;

constructor TMapStation.Create;
begin
  Passengers := TMetroPassengers.Create;
  Passengers.OwnsObjects := False;
  Lines := TMetroLines.Create;
  Lines.OwnsObjects := False;
end;

destructor TMapStation.Destroy;
begin
  Lines.Free;
  Passengers.Free;
  inherited Destroy;
end;

{ TEngine }

procedure TEngine.ResizeView;
var
  NewPoint: TPoint;
begin
  // Need to see all stations on screen
  View.SourceRect := RectEnlarge(Stations.GetRect, 100);

  NewPoint := Point(
    Trunc((View.SourceRect.Left + (View.SourceRect.Right - View.SourceRect.Left) / 2) -
    (View.DestRect.Left + (View.DestRect.Right - View.DestRect.Left) / 2 / View.Zoom)),
    Trunc((View.SourceRect.Top + (View.SourceRect.Bottom - View.SourceRect.Top) / 2) -
    (View.DestRect.Top + (View.DestRect.Bottom - View.DestRect.Top) / 2 / View.Zoom)));
  View.SourceRect := Bounds(NewPoint.X, NewPoint.Y, Trunc((View.DestRect.Right - View.DestRect.Left) / View.Zoom),
    Trunc((View.DestRect.Bottom - View.DestRect.Top) / View.Zoom));
end;

function TEngine.GetExistStationShapes: TStationShapeSet;
var
  I: Integer;
begin
  Result := [];
  for I := 0 to Stations.Count - 1 do
  with TMapStation(Stations[I]) do begin
    Result := Result + [Shape];
  end;
end;

function TEngine.GetStationOnPos(Pos: TPoint): TMapStation;
var
  I: Integer;
const
  ClickDistance = 30;
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])
    else Result := nil;
end;

function TEngine.GetTrackOnPos(Pos: TPoint): TTrackLink;
var
  I: Integer;
  T: Integer;
  D: Integer;
  MinD: Integer;
begin
  Result := TTrackLink.Create;
  Result.Points.Count := 2;
  Result.Points[0] := nil;
  Result.Points[1] := nil;
  I := 0;
  MinD := High(Integer);
  while (I < Lines.Count) do
  with TMetroLine(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);
      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]);
      end;
    end;
    Inc(I);
  end;
end;

function TEngine.GetTrainOnPos(Pos: TPoint): TMetroTrain;
var
  I: Integer;
  MinDistance: Integer;
  D: Integer;
begin
  Result := nil;
  MinDistance := High(Integer);
  for I := 0 to Trains.Count - 1 do
  with TMetroTrain(Trains[I]) do begin
    D := Distance(GetPosition, Pos);
    if (D < (TrainSize div 2)) and (D < MinDistance) then begin
      Result := TMetroTrain(Trains[I]);
      MinDistance := D;
    end;
  end;
end;

procedure TEngine.DrawLine(Canvas: TCanvas; Pos: TPoint);
var
  Delta: TPoint;
begin
  Delta := Point(Pos.X - Canvas.PenPos.X, Pos.Y - Canvas.PenPos.Y);
  if Abs(Delta.X) > Abs(Delta.Y) then begin
    Canvas.LineTo(Pos.X - Sign(Delta.X) * Abs(Delta.Y), Canvas.PenPos.Y);
  end else begin
    Canvas.LineTo(Canvas.PenPos.X, Pos.Y - Sign(Delta.Y) * Abs(Delta.X));
  end;
  Canvas.LineTo(Pos.X, Pos.Y);
end;

procedure TEngine.DrawShape(Canvas: TCanvas; Position: TPoint; Shape: TStationShape;
  Size: Integer; Angle: Double);
var
  Points: array of TPoint;
  I: Integer;
  Angle2: Double;
begin
  case Shape of
    ssSquare: begin
      SetLength(Points, 4);
      Points[0] := Point(Position.X - Size div 2, Position.Y - Size div 2);
      Points[1] := Point(Position.X + Size div 2, Position.Y - Size div 2);
      Points[2] := Point(Position.X + Size div 2, Position.Y + Size div 2);
      Points[3] := Point(Position.X - Size div 2, Position.Y + Size div 2);
      Points := RotatePoints(Position, Points, Angle);
      Canvas.Polygon(Points);
    end;
    ssCircle: Canvas.Ellipse(
      Position.X - Size div 2, Position.Y - Size div 2,
      Position.X + Size div 2, Position.Y + Size div 2);
    ssTriangle: begin
      SetLength(Points, 3);
      Points[0] := Point(Position.X, Position.Y - Size div 2);
      Points[1] := Point(Position.X + Size div 2, Position.Y + Size div 2);
      Points[2] := Point(Position.X - Size div 2, Position.Y + Size div 2);
      Points := RotatePoints(Position, Points, Angle);
      Canvas.Polygon(Points);
    end;
    ssStar: begin
      SetLength(Points, 10);
      for I := 0 to 9 do begin
        Angle2 := I / 10 * 2 * Pi - Pi / 2;
        if (I mod 2) = 0 then
        Points[I] := Point(Round(Position.X + Cos(Angle2) * Size / 2),
          Round(Position.Y + Sin(Angle2) * Size / 2))
        else
        Points[I] := Point(Round(Position.X + Cos(Angle2) * Size / 5),
          Round(Position.Y + Sin(Angle2) * Size / 5));
      end;
      Points := RotatePoints(Position, Points, Angle);
      Canvas.Polygon(Points);
    end;
    ssPlus: begin
      SetLength(Points, 12);
      Points[0] := Point(Position.X + Size div 6, Position.Y - Size div 6);
      Points[1] := Point(Position.X + Size div 2, Position.Y - Size div 6);
      Points[2] := Point(Position.X + Size div 2, Position.Y + Size div 6);
      Points[3] := Point(Position.X + Size div 6, Position.Y + Size div 6);
      Points[4] := Point(Position.X + Size div 6, Position.Y + Size div 2);
      Points[5] := Point(Position.X - Size div 6, Position.Y + Size div 2);
      Points[6] := Point(Position.X - Size div 6, Position.Y + Size div 6);
      Points[7] := Point(Position.X - Size div 2, Position.Y + Size div 6);
      Points[8] := Point(Position.X - Size div 2, Position.Y - Size div 6);
      Points[9] := Point(Position.X - Size div 6, Position.Y - Size div 6);
      Points[10] := Point(Position.X - Size div 6, Position.Y - Size div 2);
      Points[11] := Point(Position.X + Size div 6, Position.Y - Size div 2);
      Points := RotatePoints(Position, Points, Angle);
      Canvas.Polygon(Points);
    end;
    ssPentagon: begin
      SetLength(Points, 5);
      for I := 0 to 4 do begin
        Angle2 := I / 5 * 2 * Pi - Pi / 2;
        Points[I] := Point(Round(Position.X + Cos(Angle2) * Size / 2),
          Round(Position.Y + Sin(Angle2) * Size / 2));
      end;
      Points := RotatePoints(Position, Points, Angle);
      Canvas.Polygon(Points);
    end;
    ssHexagon: begin
      SetLength(Points, 6);
      for I := 0 to 5 do begin
        Angle2 := I / 6 * 2 * Pi - Pi / 2;
        Points[I] := Point(Round(Position.X + Cos(Angle2) * Size / 2),
          Round(Position.Y + Sin(Angle2) * Size / 2));
      end;
      Points := RotatePoints(Position, Points, Angle);
      Canvas.Polygon(Points);
    end;
    ssDiamond: begin
      SetLength(Points, 4);
      Points[0] := Point(Position.X, Position.Y - Size div 2);
      Points[1] := Point(Position.X + Size div 2, Position.Y);
      Points[2] := Point(Position.X, Position.Y + Size div 2);
      Points[3] := Point(Position.X - Size div 2, Position.Y);
      Points := RotatePoints(Position, Points, Angle);
      Canvas.Polygon(Points);
    end;
    ssCross: begin
      SetLength(Points, 12);
      Points[0] := Point(Position.X + Size div 6, Position.Y - Size div 6);
      Points[1] := Point(Position.X + Size div 2, Position.Y - Size div 6);
      Points[2] := Point(Position.X + Size div 2, Position.Y + Size div 6);
      Points[3] := Point(Position.X + Size div 6, Position.Y + Size div 6);
      Points[4] := Point(Position.X + Size div 6, Position.Y + Size div 2);
      Points[5] := Point(Position.X - Size div 6, Position.Y + Size div 2);
      Points[6] := Point(Position.X - Size div 6, Position.Y + Size div 6);
      Points[7] := Point(Position.X - Size div 2, Position.Y + Size div 6);
      Points[8] := Point(Position.X - Size div 2, Position.Y - Size div 6);
      Points[9] := Point(Position.X - Size div 6, Position.Y - Size div 6);
      Points[10] := Point(Position.X - Size div 6, Position.Y - Size div 2);
      Points[11] := Point(Position.X + Size div 6, Position.Y - Size div 2);
      Points := RotatePoints(Position, Points, Angle + Pi / 4);
      Canvas.Polygon(Points);
    end;
    ssHalfCircle: Canvas.Pie(
      Position.X - Size div 2, Position.Y - Size div 2,
      Position.X + Size div 2, Position.Y + Size div 2,
      Position.X - Size div 2, Position.Y,
      Position.X + Size div 2, Position.Y);
    ssQuarterCircle: Canvas.Pie(
      Position.X - Size div 2 - Size, Position.Y - Size div 2,
      Position.X + Size div 2, Position.Y + Size div 2 + Size,
      Position.X + Size div 2, Position.Y + Size div 2,
      Position.X - Size div 2, Position.Y - Size div 2);
    ssHeptagon: begin
      SetLength(Points, 8);
      for I := 0 to High(Points) do begin
        Angle2 := I / Length(Points) * 2 * Pi - Pi / 2;
        Points[I] := Point(Round(Position.X + Cos(Angle2) * Size / 2),
          Round(Position.Y + Sin(Angle2) * Size / 2));
      end;
      Points := RotatePoints(Position, Points, Angle);
      Canvas.Polygon(Points);
    end;
  end;
end;

procedure TEngine.ComputeShapeDistance;
var
  I: Integer;
  S: TStationShape;
begin
  // Reset all distances
  for I := 0 to Stations.Count - 1 do
  with TMapStation(Stations[I]) do begin
    for S := Low(ShapeDistance) to High(ShapeDistance) do
      ShapeDistance[S] := -1;
  end;

  // Propagate shape distance for all stations
  // Distace 0 means that station is final target
  for I := 0 to Stations.Count - 1 do
  with TMapStation(Stations[I]) do begin
    ComputeShapeDistanceStation(TMapStation(Stations[I]), Shape, 0);
  end;
end;

procedure TEngine.ComputeShapeDistanceStation(Station: TMapStation;
  UpdatedShape: TStationShape; Distance: Integer);
var
  I: Integer;
  T: Integer;
  StationIndex: Integer;
  DirectionDown: Boolean;
  DirectionUp: Boolean;
begin
  with Station do begin
    if (Distance < ShapeDistance[UpdatedShape]) or (ShapeDistance[UpdatedShape] = -1) then begin
      ShapeDistance[UpdatedShape] := Distance;
      // Do for all lines connected to station
      for I := 0 to Lines.Count - 1 do
      with TMetroLine(Lines[I]) do
        for StationIndex := 0 to LineStations.Count - 1 do
        if TLineStation(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,
            UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
          if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then
            ComputeShapeDistanceStation(TLineStation(LineStations[StationIndex + 1]).MapStation,
            UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
        end else begin
          // If circular then trains might go in single direction so passengers
          // waiting for oposite directions are wrong
          DirectionUp := False;
          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;
          end;
          // Update for all adjecent stations
          if DirectionUp then begin
            if StationIndex = 0 then
              ComputeShapeDistanceStation(TLineStation(LineStations[LineStations.Count - 2]).MapStation,
              UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
            if StationIndex > 0 then
              ComputeShapeDistanceStation(TLineStation(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,
              UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
            if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then
              ComputeShapeDistanceStation(TLineStation(LineStations[StationIndex + 1]).MapStation,
              UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
          end;
        end;
      end;
    end;
  end;
end;

procedure TEngine.TrainMovement;
var
  I: Integer;
  CurrentStation: TLineStation;
  P: Integer;
  Passenger: TMetroPassenger;
  PosDelta: Integer;
  TargetStationIndex: Integer;
  PosChange: Double;
  TP: TTrackPoint;
begin
  // Move trains
  for I := 0 to Trains.Count - 1 do
  with TMetroTrain(Trains[I]) do begin
    if not Assigned(TargetStation) and Assigned(BaseTrackPoint) then begin
      if (Direction <> 1) and (Direction <> -1) then Direction := 1
        else Direction := -Direction;
      TP := BaseTrackPoint.GetUp;
      if Assigned(TP) then TargetStation := TP.LineStation
      else begin
        TP := BaseTrackPoint.GetDown;
        if Assigned(TP) then TargetStation := TP.LineStation;
      end;
    end;
    if Assigned(Line) then begin
      if InStation then begin
        if (Time - StationStopTime) > OneHour then begin
          CurrentStation := TargetStation;

          // Choose next target station
          TargetStationIndex := Line.LineStations.IndexOf(TargetStation) + Direction;
          if TargetStationIndex < 0 then begin
            if Line.IsCircular then begin
              TargetStationIndex := Line.LineStations.Count - 2;
              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
            if Line.IsCircular then begin
              TargetStationIndex := 1;
              BaseTrackPoint := TLineStation(Line.LineStations.First).TrackPoint;
              RelPos := 0;
            end else begin
              TargetStationIndex := Line.LineStations.Count - 2;
              Direction := -Direction;
            end;
          end;
          TargetStation := TLineStation(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]);
              Passengers.Delete(P);
              Self.Passengers.Remove(Passenger);
              Inc(ServedPassengerCount);
            end;
          end;
          // Unload passengers to change line
          if Assigned(CurrentStation)  then
          for P := Passengers.Count - 1 downto 0 do begin
            if not CurrentStation.MapStation.IsBestStationForShape(TMetroPassenger(Passengers[P]).Shape,
            TargetStation, CurrentStation) then begin
              Passenger := TMetroPassenger(Passengers[P]);
              Passengers.Delete(P);
              CurrentStation.MapStation.Passengers.Add(Passenger);
              Passenger.Station := CurrentStation.MapStation;
            end;
          end;

          // Load new passengers
          if Assigned(CurrentStation) and not Assigned(CurrentStation.MapStation) then
            raise Exception.Create('Station have to have MapStation');
          if Assigned(CurrentStation)  then
          for P := CurrentStation.MapStation.Passengers.Count - 1 downto 0 do begin
            if (Passengers.Count < TrainPassengerCount) then begin
              Passenger := TMetroPassenger(CurrentStation.MapStation.Passengers[P]);
              if CurrentStation.MapStation.IsBestStationForShape(Passenger.Shape,
            TargetStation, CurrentStation) then begin
                Passenger.Station := nil;
                CurrentStation.MapStation.Passengers.Delete(P);
                Passengers.Add(Passenger);
                Passenger.Train := TMetroTrain(Trains[I]);
              end;
            end else Break; // No more space
          end;

          LastPosDelta := Abs(GetTargetStationDistance);
          InStation := False;
          LastTrainMoveTime := Time;
        end;
      end else begin
        PosChange := Direction + Trunc(Direction * TrainSpeed * (Time - LastTrainMoveTime));
        RelPos := RelPos + PosChange;
        LastTrainMoveTime := Time;
        Redraw;
        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;
        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
          BaseTrackPoint := TargetStation.TrackPoint;
          RelPos := 0;
          InStation := True;
          StationStopTime := Time;
          Redraw;
        end;
        LastPosDelta := PosDelta;
      end;
    end;
  end;
end;

function TEngine.GetUnusedLine: TMetroLine;
var
  I: Integer;
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])
    else Result := nil;
end;

procedure TEngine.ShiftTrackPoints;
var
  I: Integer;
  J: Integer;
  L: Integer;
  Link1, Link2: TPoint;
  NewPoint: TPoint;
begin
  // Reset all trackpoints position shift
  for I := 0 to Lines.Count - 1 do
  with TMetroLine(Lines[I]) do
    for J := 0 to Track.Points.Count - 1 do
    TTrackPoint(Track.Points[J]).Position := TTrackPoint(Track.Points[J]).PositionDesigned;

  // Calculate new position shifts
  for I := 0 to Stations.Count - 1 do
    TMapStation(Stations[I]).ShiftTrackPoints;

  // Compute track points from track shift
  for L := 0 to Lines.Count - 1 do
  with TMetroLine(Lines[L]) do begin
    if Track.Points.Count > 1 then begin
      TTrackPoint(Track.Points[0]).Position := AddPoint(TTrackPoint(Track.Points[0]).PositionDesigned,
        TTrackPoint(Track.Points[0]).LinkUp.Shift);
    end;
    for I := 1 to Track.Points.Count - 1 do
    with TTrackPoint(Track.Points[I]) do
    if Assigned(TTrackPoint(Track.Points[I]).LinkDown) and Assigned(TTrackPoint(Track.Points[I]).LinkUp) then begin
      Link1 := SubPoint(AddPoint(TTrackPoint(Track.Points[I]).PositionDesigned, TTrackPoint(Track.Points[I]).LinkDown.Shift),
        AddPoint(TTrackPoint(Track.Points[I - 1]).PositionDesigned, TTrackPoint(Track.Points[I]).LinkDown.Shift));
      if (I + 1) < Track.Points.Count then
        Link2 := SubPoint(AddPoint(TTrackPoint(Track.Points[I + 1]).PositionDesigned, TTrackPoint(Track.Points[I]).LinkUp.Shift),
          AddPoint(TTrackPoint(Track.Points[I]).PositionDesigned, TTrackPoint(Track.Points[I]).LinkUp.Shift))
        else Link2 := Link1;

      if ArcTanPoint(Link1) = ArcTanPoint(Link2) then begin
        // Parallel lines
        NewPoint := AddPoint(TTrackPoint(Track.Points[I]).PositionDesigned,
          TTrackPoint(Track.Points[I]).LinkDown.Shift);
        TTrackPoint(Track.Points[I]).Position := NewPoint;
      end else begin
        // Intersected lines
        NewPoint := LineIntersect(AddPoint(TTrackPoint(Track.Points[I - 1]).PositionDesigned,
          TTrackPoint(Track.Points[I]).LinkDown.Shift),
          AddPoint(TTrackPoint(Track.Points[I]).PositionDesigned, TTrackPoint(Track.Points[I]).LinkDown.Shift),
          AddPoint(TTrackPoint(Track.Points[I]).PositionDesigned, TTrackPoint(Track.Points[I]).LinkUp.Shift),
          AddPoint(TTrackPoint(Track.Points[I + 1]).PositionDesigned, TTrackPoint(Track.Points[I]).LinkUp.Shift));
        TTrackPoint(Track.Points[I]).Position := NewPoint;
      end;
    end;
  end;

  // Remove all temporal links
  for I := 0 to Lines.Count - 1 do
  with TMetroLine(Lines[I]) do
    for J := 0 to Track.Points.Count - 1 do
    if Assigned(TTrackPoint(Track.Points[J]).LinkUp) then begin
      TTrackPoint(Track.Points[J]).LinkUp.Free;
      TTrackPoint(Track.Points[J]).LinkUp := nil;
      TTrackPoint(Track.Points[J + 1]).LinkDown := nil;
    end;
end;

procedure TEngine.DrawClock(Canvas: TCanvas);
var
  ClockCenter: TPoint;
  Angle: Double;
  Text: string;
  I: Integer;
const
  ClockSize = 20;
begin
  Canvas.Pen.Style := psSolid;
  Canvas.Pen.Color := clBlack;
  Canvas.Pen.Width := 2;
  ClockCenter := Point(Canvas.Width - 30, 40);
  Angle := Time / (12 * OneHour) * 2 * Pi - Pi / 2;
  Canvas.EllipseC(ClockCenter.X, ClockCenter.Y, ClockSize, ClockSize);
  Canvas.Line(ClockCenter, Point(ClockCenter.X + Round(Cos(Angle) * ClockSize * 0.8),
    ClockCenter.Y + Round(Sin(Angle) * ClockSize * 0.8)));
  Text := FormatDateTime('ddd', Time);
  Canvas.TextOut(ClockCenter.X - ClockSize - Canvas.TextWidth(Text) - 5, ClockCenter.Y -
    Canvas.TextWidth(Text) div 2, Text);
  for I := 0 to 12 do begin
    Angle := I / 12 * 2 * Pi;
    Canvas.Line(ClockCenter.X + Round(Cos(Angle) * ClockSize * 0.8),
      ClockCenter.Y + Round(Sin(Angle) * ClockSize * 0.8),
      ClockCenter.X + Round(Cos(Angle) * ClockSize * 0.9),
      ClockCenter.Y + Round(Sin(Angle) * ClockSize * 0.9));
  end;
end;

procedure TEngine.DrawTrains(Canvas: TCanvas);
var
  I: Integer;
  P: Integer;
  Pos: TPoint;
  Points: array of TPoint;
  Angle: Double;
  ShapePos: TPoint;
begin
  // Draw trains
  for I := 0 to Trains.Count - 1 do
  with TMetroTrain(Trains[I]) do begin
    if Assigned(Line) then begin
      Canvas.Brush.Color := Line.Color;
      Canvas.Brush.Style := bsSolid;
      Canvas.Pen.Style := psClear;
      Pos := GetPosition;
      Angle := GetAngle;

      SetLength(Points, 4);
      Points[0] := RotatePoint(Pos, Point(Pos.X - TrainSize div 2, Pos.Y - TrainSize div 3), Angle);
      Points[1] := RotatePoint(Pos, Point(Pos.X + TrainSize div 2, Pos.Y - TrainSize div 3), Angle);
      Points[2] := RotatePoint(Pos, Point(Pos.X + TrainSize div 2, Pos.Y + TrainSize div 3), Angle);
      Points[3] := RotatePoint(Pos, Point(Pos.X - TrainSize div 2, Pos.Y + TrainSize div 3), Angle);
      Canvas.Polygon(Points);
      Canvas.Brush.Color := clWhite;
      for P := 0 to Passengers.Count - 1 do
      with TMetroPassenger(Passengers[P]) do begin
        ShapePos := Point(Pos.X - Trunc(TrainSize div 3 * 1) + (P mod 3) * TrainSize div 3,
          Pos.Y - Trunc(TrainSize div 6 * 1) + (P div 3) * TrainSize div 3);
        ShapePos := RotatePoint(Pos, ShapePos, Angle);
        DrawShape(Canvas, ShapePos, Shape, TrainSize div 3, Angle + Pi / 2);
      end;
    end;
  end;
end;

procedure TEngine.Tick;
var
  Passenger: TMetroPassenger;
  I: Integer;
begin
  if State = gsRunning then begin
    FTime := FTime + (Now - LastTickTime) / OneSecond * TimePerSecond;
    Redraw; // Redraw on every because engine time is changed so clock should be redrawn

  // Add new trains
  if (Time - LastNewWeekTime) > NewTrainPeriod then begin
    LastNewWeekTime := Time;
    Trains.AddNew;
    // TODO: Show notification screen with confirmation
    Redraw;
  end;

  // Add new shape
  if (Time - LastNewShapeTime) > NewShapePeriod then begin
    LastNewShapeTime := Time;
    if ShapeCount <= Integer(High(TStationShape)) then Inc(ShapeCount);
    Redraw;
  end;

  // Add new stations
  if (Time - LastNewStationTime) > NewStationPeriod then begin
    LastNewStationTime := Time;
    Stations.AddNew;
    ResizeView;
    Redraw;
  end;

  // Add new passengers
  if (Time - LastNewPassengerTime) > NewPassengerPeriod then begin
    LastNewPassengerTime := Time;
    for I := 0 to Stations.Count - 1 do
    with TMapStation(Stations[I]) do
    if Random < NewPassengerProbability then begin
      Passenger := Self.Passengers.AddNew;
      Passenger.Station := TMapStation(Stations[I]);
      Passengers.Add(Passenger);

      // Passenger is not allowed to have same shape
      while (Passenger.Shape = Passenger.Station.Shape) or not (Passenger.Shape in GetExistStationShapes) do
        Passenger.Shape := TStationShape((Integer(Passenger.Shape) + 1) mod Integer(ShapeCount));
      Redraw;
    end;
  end;

  // Check station passenger overload state
  for I := 0 to Stations.Count - 1 do
  with TMapStation(Stations[I]) do begin
    if Passengers.Count > MaxWaitingPassengers then begin
      OverloadDuration := OverloadDuration + (FTime - FLastTime);
      if OverloadDuration > MaxPassengersOveloadTime then
        OverloadDuration := MaxPassengersOveloadTime;
      if OverloadDuration < MaxPassengersOveloadTime then Redraw;
    end;
    if Passengers.Count <= MaxWaitingPassengers then begin
      if OverloadDuration > 0 then Redraw;
      OverloadDuration := OverloadDuration - (FTime - FLastTime);
      if OverloadDuration < 0 then begin
        OverloadDuration := 0;
      end;
    end;
  end;

  TrainMovement;

  // Game over
  for I := 0 to Stations.Count - 1 do
  with TMapStation(Stations[I]) do begin
    if OverloadDuration >= MaxPassengersOveloadTime then begin
      State := gsGameOver;
      Redraw;
    end;
  end;

  end;
  LastTickTime := Now;
  FLastTime := FTime;
end;

procedure TEngine.MouseMove(Position: TPoint);
var
  FocusedStation: TMapStation;
  Line: TMetroLine;
  LineStationDown: TLineStation;
  LineStationUp: TLineStation;
  CurrentTrackPoint: TTrackPoint;
begin
  LastMousePos := Position;
  if MouseHold then begin
      FocusedStation := GetStationOnPos(View.PointDestToSrc(Position));
      Line := nil;
      if Assigned(TrackStationDown) then begin
        Line := TrackStationDown.Track.Line;
        Redraw;
      end;
      if Assigned(TrackStationUp) then begin
        Line := TrackStationUp.Track.Line;
        Redraw;
      end;
      if Assigned(Line) and not Assigned(LastFocusedStation) and Assigned(FocusedStation) then begin
        if Assigned(TrackStationDown) and (TrackStationDown.LineStation.MapStation = FocusedStation) then begin
          // Disconnect down
          CurrentTrackPoint := TrackStationDown;
          TrackStationDown := TrackStationDown.GetDown;
          Line.DisconnectStation(CurrentTrackPoint.LineStation);
        end else
        if Assigned(TrackStationUp) and (TrackStationUp.LineStation.MapStation = FocusedStation) then begin
          // Disconnect up
          CurrentTrackPoint := TrackStationUp;
          if Assigned(TrackStationUp) then
            TrackStationUp := TrackStationUp.GetUp;
          Line.DisconnectStation(CurrentTrackPoint.LineStation);
        end else
        if Assigned(Line) and ((not Line.IsCircular) or ((TrackStationDown <> nil) and (TrackStationUp <> nil))) and
        ((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
        ((TrackStationDown = nil) or (TrackStationUp = nil)) and
        (not Line.IsCircular))) then begin
          if Assigned(TrackStationDown) then LineStationDown := TrackStationDown.LineStation
            else LineStationDown := nil;
          if Assigned(TrackStationUp) then LineStationUp := TrackStationUp.LineStation
            else LineStationUp := nil;
          Line.ConnectStation(FocusedStation, LineStationDown, LineStationUp);
          if Assigned(TrackStationDown) then TrackStationDown := TrackStationDown.GetUp
            else if Assigned(TrackStationUp) then TrackStationUp := TrackStationUp.GetDown;
        end;
      end;
      LastFocusedStation := FocusedStation;
  end;
end;

procedure TEngine.MouseUp(Button: TMouseButton; Position: TPoint);
var
  I: Integer;
  FocusedTrack: TTrackLink;
begin
  if Button = mbLeft then begin
    // Place selected train if focused track
    if Assigned(SelectedTrain) then begin
      SelectedTrain.TargetStation := nil;
      SelectedTrain.BaseTrackPoint := nil;
      if Assigned(SelectedTrain.Line) then begin
        SelectedTrain.Line.Trains.Remove(SelectedTrain);
        SelectedTrain.Line := nil;
      end;
      FocusedTrack := GetTrackOnPos(View.PointDestToSrc(Position));
      if Assigned(FocusedTrack.Points[0]) then begin
        SelectedTrain.Line := TTrackPoint(FocusedTrack.Points[0]).Track.Line;
        SelectedTrain.Line.Trains.Add(SelectedTrain);
        SelectedTrain.BaseTrackPoint := TTrackPoint(FocusedTrack.Points[0]);
      end else
      if Assigned(FocusedTrack.Points[1]) then begin
        SelectedTrain.Line := TTrackPoint(FocusedTrack.Points[1]).Track.Line;
        SelectedTrain.Line.Trains.Add(SelectedTrain);
        SelectedTrain.BaseTrackPoint := TTrackPoint(FocusedTrack.Points[1]);
      end;
      FocusedTrack.Free;
    end;

    // Line color selection
    for I := 0 to Lines.Count - 1 do
      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]);
          Exit;
        end;

    // 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));
    end;
    if Assigned(TrackStationUp) and (TrackStationUp.Track.Line.LineStations.Count = 1) then begin
      TrackStationUp.Track.Line.DisconnectStation(TLineStation(TrackStationUp.Track.Line.LineStations.First));
    end;
  end else
  if Button = mbRight then begin
    SelectedLine := nil;
  end;
  MouseHold := False;
  TrackStationDown := nil;
  TrackStationUp := nil;
  SelectedTrain := nil;
end;

procedure TEngine.MouseDown(Button: TMouseButton; Position: TPoint);
var
  Station: TMapStation;
  NewLine: TMetroLine;
  Track: TTrackLink;
  NewIndex: Integer;
begin
  if Button = mbLeft then begin
    MouseHold := True;
    LastFocusedStation := nil;

    // Train selection
    SelectedTrain := GetTrainOnPos(View.PointDestToSrc(Position));
    if Assigned(SelectedTrain) then begin
      Exit;
    end;

    // Select unused train
    if (Distance(Position, Point(View.DestRect.Right div 2 - Length(LineColors) div 2 * LineColorsDist - 100,
    View.DestRect.Bottom - LineColorsDist)) < 30) and
    (Trains.GetUnusedCount > 0) then begin
      SelectedTrain := Trains.GetUnusedTrain;
      Exit;
    end;

    // Line selection
    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]);
      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])
          else TrackStationDown := nil;
      end;
      TrackStationUp := TTrackPoint(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])
          else TrackStationUp := nil;
      end;
      Track.Free;
      Exit;
    end;
    if Assigned(Track) then Track.Free;

    // New track creation from selected station as start
    Station := GetStationOnPos(View.PointDestToSrc(Position));
    if Assigned(Station) then begin
      if Assigned(SelectedLine) and (SelectedLine.LineStations.Count = 0) then NewLine := SelectedLine
        else NewLine := GetUnusedLine;
      if Assigned(NewLine) then begin
        NewLine.ConnectStation(Station, nil, nil);
        TrackStationDown := TTrackPoint(NewLine.Track.Points.Last);
        TrackStationUp := nil;
        LastFocusedStation := Station;
      end;
    end;
  end;
end;

procedure TEngine.Reset;
var
  NewTrain: TMetroTrain;
  I: Integer;
  NewStation: TMapStation;
  InitialStationCount: Integer;
begin
  Passengers.Clear;
  Lines.Clear;
  Stations.Clear;

  ShapeCount := 3;
  ServedPassengerCount := 0;

  // Start with 3 stations with each different shape
  InitialStationCount := 3;
  for I := 0 to InitialStationCount - 1 do begin
    NewStation := Stations.AddNew;
    if I = 0 then NewStation.Shape := ssSquare
    else if I = 1 then NewStation.Shape := ssCircle
    else if I = 2 then NewStation.Shape := ssTriangle;
  end;

  for I := 0 to 8 do begin
    Lines.AddNew;
    NewTrain := TMetroTrain.Create;
    Trains.Add(NewTrain);
  end;

  ResizeView;

  SelectedLine := nil;
  FTime := 0;
  FLastTime := 0;
  LastNewStationTime := Time;
  LastNewPassengerTime := Time;
  LastNewWeekTime := Time;
  LastNewShapeTime := Time;
  LastTickTime := Now;
  State := gsRunning;
  Redraw;
end;

procedure TEngine.Redraw;
begin
  RedrawPending := True;
end;

constructor TEngine.Create;
begin
  Stations := TMapStations.Create;
  Stations.Engine := Self;
  Lines := TMetroLines.Create;
  Lines.Engine := Self;
  Passengers := TMetroPassengers.Create;
  Passengers.Engine := Self;
  Map := TMap.Create;
  View := TView.Create;
  Trains := TMetroTrains.Create;
  ImagePassenger := TImage.Create(nil);
  ImageLocomotive := TImage.Create(nil);
  //if FileExists(ImagePassengerName) then
  //  ImagePassenger.Picture.LoadFromFile(ImagePassengerName);
  //if FileExists(ImageLocomotiveName) then
  //  ImageLocomotive.Picture.LoadFromFile(ImageLocomotiveName);
  MetaCanvas := TMetaCanvas.Create;
end;

destructor TEngine.Destroy;
begin
  MetaCanvas.Free;
  Trains.Free;
  ImageLocomotive.Free;
  ImagePassenger.Free;
  View.Free;
  Map.Free;
  Passengers.Free;
  Stations.Free;
  Lines.Free;
  inherited Destroy;
end;

procedure TEngine.Paint(TargetCanvas: TCanvas);
var
  I: Integer;
  S: Integer;
  Size: Integer;
  P: Integer;
  Pos: TPoint;
  Text: string;
  Angle: Double;
  PassengerPos: TPoint;
  Direction: Integer;
  Points: array of TPoint;
  Canvas: TMetaCanvas;
const
  GameOverText = 'Game Over';
  GameOverReason = 'Overcrowding at this station has forced you to resign as metro manager.';
  GameOverStatistic = '%d passengers travelled on your metro over %d days.';
begin
  Canvas := MetaCanvas;
  Canvas.SetSize(Point(TargetCanvas.Width, TargetCanvas.Height));
  Canvas.Reset;

  // Draw station passenger overload
  for I := 0 to Stations.Count - 1 do
  with TMapStation(Stations[I]) do begin
    if OverloadDuration > 0 then begin
      Canvas.Brush.Color := clSilver;
      Canvas.Brush.Style := bsSolid;
      Canvas.Pen.Color := clSilver;
      Canvas.Pen.Style := psSolid;
      Angle := OverloadDuration / MaxPassengersOveloadTime * 2 * Pi;
      Canvas.Pie(Position.X - StationOverloadSize, Position.Y - StationOverloadSize,
      Position.X + StationOverloadSize, Position.Y + StationOverloadSize,
        Trunc(Position.X + StationOverloadSize * Cos(Angle)),
        Trunc(Position.Y + StationOverloadSize * Sin(Angle)), Position.X + StationOverloadSize, Position.Y);
    end;
  end;

  // Draw lines
  for I := 0 to Lines.Count - 1 do
  with TMetroLine(Lines[I]) do begin
    Canvas.Pen.Color := Color;
    Canvas.Pen.Style := psSolid;
    Canvas.Pen.Width := MetroLineThickness;
    if Track.Points.Count > 0 then Canvas.MoveTo(TTrackPoint(Track.Points[0]).Position);
    for S := 1 to Track.Points.Count - 1 do begin
      Canvas.LineTo(TTrackPoint(Track.Points[S]).Position);
{      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)));
        Canvas.LineTo(EndPoint);
        Canvas.MoveTo(Point(Round(EndPoint.X + Cos(Angle + Pi / 2) * EndStationLength / 3),
          Round(EndPoint.Y + Sin(Angle + Pi / 2) * EndStationLength / 3)));
        Canvas.LineTo(Point(Round(EndPoint.X + Cos(Angle - Pi / 2) * EndStationLength / 3),
          Round(EndPoint.Y + Sin(Angle - Pi / 2) * EndStationLength / 3)));
        Canvas.Pen.EndCap := pecRound;
      end;}
    end;
(*    Canvas.Pen.Color := Color;
    Canvas.Pen.Style := psSolid;
    Canvas.Pen.Width := MetroLineThickness div 2;
    if Track.Points.Count > 0 then Canvas.MoveTo(TTrackPoint(Track.Points[0]).PositionDesigned);
    for S := 1 to Track.Points.Count - 1 do begin
      Canvas.LineTo(TTrackPoint(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)));
        Canvas.LineTo(EndPoint);
        Canvas.MoveTo(Point(Round(EndPoint.X + Cos(Angle + Pi / 2) * EndStationLength / 3),
          Round(EndPoint.Y + Sin(Angle + Pi / 2) * EndStationLength / 3)));
        Canvas.LineTo(Point(Round(EndPoint.X + Cos(Angle - Pi / 2) * EndStationLength / 3),
          Round(EndPoint.Y + Sin(Angle - Pi / 2) * EndStationLength / 3)));
        Canvas.Pen.EndCap := pecRound;
      end;}
    end;
    {
    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)));
      Canvas.LineTo(EndPoint);
      Canvas.MoveTo(Point(Round(EndPoint.X - Cos(Angle + Pi / 2) * EndStationLength / 3),
        Round(EndPoint.Y - Sin(Angle + Pi / 2) * EndStationLength / 3)));
      Canvas.LineTo(Point(Round(EndPoint.X - Cos(Angle - Pi / 2) * EndStationLength / 3),
        Round(EndPoint.Y - Sin(Angle - Pi / 2) * EndStationLength / 3)));
      Canvas.Pen.EndCap := pecRound;
    end;  }
    *)
  end;
  // Draw design time lines
  if Assigned(TrackStationDown) and Assigned(TrackStationDown.LineStation) then begin
    Canvas.Pen.Color := TrackStationDown.Track.Line.Color;
    Canvas.MoveTo(TrackStationDown.LineStation.TrackPoint.Position);
    DrawLine(Canvas, View.PointDestToSrc(LastMousePos));
  end;
  if Assigned(TrackStationUp) and Assigned(TrackStationUp.LineStation) then begin
    Canvas.Pen.Color := TrackStationUp.Track.Line.Color;
    Canvas.MoveTo(TrackStationUp.LineStation.TrackPoint.Position);
    DrawLine(Canvas, View.PointDestToSrc(LastMousePos));
  end;

  DrawTrains(Canvas);

  // Draw stations
  Canvas.Pen.Width := 5;
  for I := 0 to Stations.Count - 1 do
  with TMapStation(Stations[I]) do begin
    Canvas.Pen.Style := psSolid;
    if Assigned(SelectedLine) and (Lines.IndexOf(SelectedLine) <> -1) then begin
      Canvas.Brush.Style := bsClear;
      Canvas.Pen.Color := SelectedLine.Color;
      DrawShape(Canvas, Position, Shape, StationSize + Canvas.Pen.Width + 4, 0);
    end;

    Canvas.Brush.Color := clWhite;
    Canvas.Brush.Style := bsSolid;
    Canvas.Pen.Color := clBlack;
    DrawShape(Canvas, Position, Shape, StationSize, 0);

    // Draw passengers
    Canvas.Pen.Style := psClear;
    Canvas.Brush.Color := clBlack;
    PassengerPos := Point(0, 0);
    Direction := 1;
    for P := 0 to Passengers.Count - 1 do
    with TMetroPassenger(Passengers[P]) do begin
      DrawShape(Canvas, Point(Position.X + StationSize + PassengerPos.X,
        Position.Y - StationSize div 2 + PassengerPos.Y),
        Shape, PassengerSize, 0);
      PassengerPos := Point(PassengerPos.X + Direction * (PassengerSize + 2), PassengerPos.Y);
      if PassengerPos.X >= (PassengerSize + 2) * VisiblePassengersPerLine then begin
        Direction := -Direction;
        PassengerPos.X := PassengerPos.X - (PassengerSize + 2);
        PassengerPos.Y := PassengerPos.Y + (PassengerSize + 2);
      end;
      if PassengerPos.X < 0 then begin
        Direction := -Direction;
        PassengerPos.X := 0;
        PassengerPos.Y := PassengerPos.Y + (PassengerSize + 2);
      end;
    end;

{    if ShowDistances then begin
      Canvas.Brush.Style := bsClear;
      Text := '';
      for P := 0 to 5 do
        Text := Text + IntToStr(ShapeDistance[TStationShape(P)]) + ',';
      Canvas.TextOut(Position.X + StationSize div 2, Position.Y + StationSize div 2, Text);
    end;
    }
  end;

  // Clear background
  TargetCanvas.Brush.Color := $eff0e0;
  TargetCanvas.Brush.Style := bsSolid;
  TargetCanvas.Clear;

  MetaCanvas.Move(Point(-View.SourceRect.Left, -View.SourceRect.Top));
  MetaCanvas.Zoom(View.Zoom);

  // Draw meta canvas to real target canvas
  MetaCanvas.DrawTo(TargetCanvas);

  // Line selection
  TargetCanvas.Pen.Width := 4;
  for I := 0 to High(LineColors) do begin
    if Assigned(Lines.SearchByColor(LineColors[I])) then begin
      TargetCanvas.Brush.Color := LineColors[I];
      Size := 15;
    end else begin
      TargetCanvas.Brush.Color := clSilver;
      Size := 5;
    end;
    TargetCanvas.Pen.Color := clBlack;
    if Assigned(SelectedLine) and (SelectedLine.Color = LineColors[I]) then begin
      TargetCanvas.Pen.Style := psSolid;
    end else begin
      TargetCanvas.Pen.Style := psClear;
    end;

    TargetCanvas.EllipseC(TargetCanvas.Width div 2 - Length(LineColors) div 2 * LineColorsDist + I * LineColorsDist,
      TargetCanvas.Height - LineColorsDist, Size, Size);
  end;

  // Draw unused trains
  Text := IntToStr(Trains.GetUnusedCount);
  TargetCanvas.Draw(Canvas.Width div 2 - Length(LineColors) div 2 * LineColorsDist - 100,
    TargetCanvas.Height - LineColorsDist - ImageLocomotive.Picture.Bitmap.Height div 2, ImageLocomotive.Picture.Bitmap);
  TargetCanvas.Brush.Style := bsClear;
  TargetCanvas.Font.Size := 14;
  TargetCanvas.Font.Color := clBlack;
  TargetCanvas.TextOut(TargetCanvas.Width div 2 - Length(LineColors) div 2 * LineColorsDist - 50 - TargetCanvas.TextWidth(Text),
    TargetCanvas.Height - LineColorsDist - TargetCanvas.TextHeight(Text) div 2, Text);

  // Status interface
  Text := IntToStr(ServedPassengerCount);
  TargetCanvas.Draw(TargetCanvas.Width - 50, TargetCanvas.Height - 60, ImagePassenger.Picture.Bitmap);
  TargetCanvas.Brush.Style := bsClear;
  TargetCanvas.Font.Size := 14;
  TargetCanvas.Font.Color := clBlack;
  TargetCanvas.TextOut(TargetCanvas.Width - 70 - TargetCanvas.TextWidth(Text), TargetCanvas.Height - 55, Text);

  DrawClock(TargetCanvas);

  // Show grabbed train by mouse
  if Assigned(SelectedTrain) then begin
    TargetCanvas.Brush.Color := clBlack; //SelectedTrain.Line.Color;
    TargetCanvas.Brush.Style := bsSolid;
    TargetCanvas.Pen.Style := psClear;
    Pos := LastMousePos;
    Angle := 0;

    SetLength(Points, 4);
    Points[0] := RotatePoint(Pos, Point(Pos.X - TrainSize div 2, Pos.Y - TrainSize div 3), Angle);
    Points[1] := RotatePoint(Pos, Point(Pos.X + TrainSize div 2, Pos.Y - TrainSize div 3), Angle);
    Points[2] := RotatePoint(Pos, Point(Pos.X + TrainSize div 2, Pos.Y + TrainSize div 3), Angle);
    Points[3] := RotatePoint(Pos, Point(Pos.X - TrainSize div 2, Pos.Y + TrainSize div 3), Angle);
    TargetCanvas.Polygon(Points);
  end;

  // Game over
  if State = gsGameOver then
  begin
    TargetCanvas.Font.Size := 40;
    TargetCanvas.Font.Color := clBlack;
    TargetCanvas.TextOut((TargetCanvas.Width - TargetCanvas.TextWidth(GameOverText)) div 2, 100, GameOverText);
    TargetCanvas.Font.Size := 14;
    TargetCanvas.TextOut((TargetCanvas.Width - TargetCanvas.TextWidth(GameOverReason)) div 2, 160, GameOverReason);
    Text := Format(GameOverStatistic, [ServedPassengerCount, Trunc(Time)]);
    TargetCanvas.TextOut((TargetCanvas.Width - TargetCanvas.TextWidth(Text)) div 2, 180, Text);
  end;
  RedrawPending := False;
end;

end.