source: tags/1.2.0/UEngine.pas

unit UEngine;

{$mode delphi}
{$IFDEF DARWIN}{$modeswitch Objectivec1}{$ENDIF}

interface

uses
  {$IFDEF Darwin}MacOSAll, CocoaAll, CocoaUtils,{$ENDIF}
  Classes, SysUtils, Graphics, Controls, ExtCtrls, Math, DateUtils,
  UMetaCanvas, fgl, UMenu, UControls;

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;

  TColors = record
    Background: TColor;
    Text: TColor;
    ShapeBackground: TColor;
    MenuItemText: TColor;
    MenuItemBackground: TColor;
    MenuItemBackgroundSelected: TColor;
  end;

  { 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(TFPGObjectList<TMapStation>)
    Engine: TEngine;
    function GetRect: TRect;
    function AddNew: TMapStation;
  end;

  TLineStation = class
    Line: TMetroLine;
    MapStation: TMapStation;
    TrackPoint: TTrackPoint;
  end;

  { TLineStations }

  TLineStations = class(TFPGObjectList<TLineStation>)
    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(TFPGObjectList<TTrackPoint>)
    Track: TTrack;
    function AddNew: TTrackPoint;
  end;

  { TTrackLink }

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

  { TTrackLinks }

  TTrackLinks = class(TFPGObjectList<TTrackLink>)
    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(TFPGObjectList<TTrackLink>)
    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(TFPGObjectList<TTrackPointsAngle>)
    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(TFPGObjectList<TMetroLine>)
    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(TFPGObjectList<TMetroTrain>)
    function GetUnusedTrain: TMetroTrain;
    function GetUnusedCount: Integer;
    function AddNew: TMetroTrain;
  end;

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

  { TMetroPassengers }

  TMetroPassengers = class(TFPGObjectList<TMetroPassenger>)
    Engine: TEngine;
    function AddNew: TMetroPassenger;
  end;

  { TRiver }

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

  TRivers = class(TFPGObjectList<TRiver>)
  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, gsMenu);

  { TEngine }

  TEngine = class
  private
    FDarkMode: Boolean;
    FOnDarkModeChange: TNotifyEvent;
    FState: TGameState;
    LastMousePos: TPoint;
    LastFocusedStation: TMapStation;
    MouseHold: Boolean;
    LastNewStationTime: TDateTime;
    LastNewPassengerTime: TDateTime;
    LastNewWeekTime: TDateTime;
    LastNewShapeTime: TDateTime;
    LastTickTime: TDateTime;
    FTime: TDateTime;
    FLastTime: TDateTime;
    MetaCanvas: TMetaCanvas;
    Menu: TMenu;
    MenuMain: TMenu;
    MenuOptions: TMenu;
    MenuGame: TMenu;
    LastState: TGameState;
    TimePerSecond: TDateTime;
    function GetServedDaysCount: Integer;
    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; CanvasSize: TPoint);
    procedure DrawTrains(Canvas: TCanvas);
    procedure DrawGameOver(Canvas: TCanvas; CanvasSize: TPoint);
    procedure DrawStationPassengerOverload(Canvas: TCanvas);
    procedure DrawLines(Canvas: TCanvas);
    procedure DrawStations(Canvas: TCanvas);
    procedure DrawGameControls(Canvas: TCanvas; CanvasSize: TPoint);
    procedure ComputeShapeDistance;
    procedure ComputeShapeDistanceStation(Station: TMapStation;
      UpdatedShape: TStationShape; Distance: Integer);
    procedure SetDarkMode(AValue: Boolean);
    procedure InitColors;
    procedure SetState(AValue: TGameState);
    procedure TrainMovement;
    function GetUnusedLine: TMetroLine;
    procedure ShiftTrackPoints;
    procedure MenuItemExit(Sender: TObject);
    procedure MenuItemPlay(Sender: TObject);
    procedure MenuItemOptions(Sender: TObject);
    procedure MenuItemGameContinue(Sender: TObject);
    procedure MenuItemGameExit(Sender: TObject);
    procedure MenuItemGameRestart(Sender: TObject);
    procedure MenuItemBack(Sender: TObject);
    procedure ButtonPlay(Sender: TObject);
    procedure ButtonPause(Sender: TObject);
    procedure ButtonFastForward(Sender: TObject);
    procedure ButtonBackClick(Sender: TObject);
    procedure DarkModeChanged(Sender: TObject);
    procedure LanguageChanged(Sender: TObject);
    procedure FullScreenChanged(Sender: TObject);
    procedure UpdateInterface;
  public
    Colors: TColors;
    Passengers: TMetroPassengers;
    Stations: TMapStations;
    Lines: TMetroLines;
    Trains: TMetroTrains;
    ShapeCount: Integer;
    Map: TMap;
    View: TView;
    SelectedLine: TMetroLine;
    SelectedTrain: TMetroTrain;
    TrackStationDown: TTrackPoint;
    TrackStationUp: TTrackPoint;
    ServedPassengerCount: Integer;
    RedrawPending: Boolean;
    ButtonBack: TImage;
    ImagePassenger: TImage;
    ImageLocomotive: TImage;
    ImagePlay: TImage;
    ImagePause: TImage;
    ImageFastForward: TImage;
    HighestServedPassengerCount: Integer;
    HighestServedDaysCount: Integer;
    procedure InitMenus;
    procedure MouseMove(Position: TPoint);
    procedure MouseUp(Button: TMouseButton; Position: TPoint);
    procedure MouseDown(Button: TMouseButton; Position: TPoint);
    procedure KeyUp(Key: Word);
    procedure MainMenu;
    procedure Clear;
    procedure NewGame;
    procedure Redraw;
    constructor Create;
    destructor Destroy; override;
    procedure Tick;
    procedure Paint(Canvas: TCanvas; CanvasSize: TPoint);
    property Time: TDateTime read FTime;
    property DarkMode: Boolean read FDarkMode write SetDarkMode;
    property State: TGameState read FState write SetState;
    property ServedDaysCount: Integer read GetServedDaysCount;
    property OnDarkModeChange: TNotifyEvent read FOnDarkModeChange
      write FOnDarkModeChange;
  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';
  ImageLeftArrowName = 'Images/Left arrow.png';
  ImagePlayName = 'Images/Play.png';
  ImagePauseName = 'Images/Pause.png';
  ImageFastForwardName = 'Images/Fast forward.png';
  TrainPassengerCount = 6;
  StationMinDistance = 100;
  StationMaxDistance = 300;
  MaxWaitingPassengers = 10;
  MaxPassengersOveloadTime = 2;
  MetroLineThickness = 13;
  TrackClickDistance = 20;
  EndStationLength = 50;
  ShowDistances = False;
  TimePerSecondNormal = 60 * OneMinute;
  TimePerSecondFast = 2 * TimePerSecondNormal;
  NewStationPeriod = 1;
  NewShapePeriod = 10;
  NewTrainPeriod = 7; // Each week
  NewPassengerPeriod = 0.3 * OneSecond;
  NewPassengerProbability = 0.003;
  VisiblePassengersPerLine = 6;


implementation

uses
  UGeometric, UFormMain, ULanguages, UPixelPointer;

resourcestring
  SZeroZoomNotAlowed = 'Zero zoom not allowed';
  SAlreadyConnectedTrackPoint = 'Trying to connect already connected track point';
  SAlreadyDisconnectedTrackPoint = 'Trying to disconnect not connected track point';
  SGameOver = 'Game Over';
  SGameOverReason = 'Overcrowding at this station has forced you to resign as metro manager.';
  SGameOverStatistic = '%d passengers travelled on your metro over %d days.';
  SDay = 'Day';
  SNewHighScore = 'New high score!';
  SOldHighScore = 'Old high score was %d passengers in %d days.';

{ TTrackLinks }

function TTrackLinks.SearchPoints(Point1, Point2: TTrackPoint): TTrackLink;
var
  I: Integer;
begin
  I := 0;
  while (I < 0) and
    ((Items[I].Points.First <> Point1) or (Items[I].Points.Last <> Point2)) and
    ((Items[I].Points.First <> Point2) or (Items[I].Points.Last <> Point1)) do
  Inc(I);
  if I < 0 then Result := 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;
end;

{ TTrackLink }

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

destructor TTrackLink.Destroy;
begin
  Points.Free;
  inherited;
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;
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 (Items[I].Points[1] <> TrackPoint) and (Items[I] <> Skip) do Inc(I);
  if I < Count then Result := Items[I]
    else Result := nil;
end;

function TTracks.SearchPointDown(TrackPoint: TTrackPoint; Skip: TTrackLink): TTrackLink;
var
  I: Integer;
begin
  I := 0;
  while (I < Count) and (Items[I].Points[0] <> TrackPoint) and (Items[I] <> Skip) do Inc(I);
  if I < Count then Result := Items[I]
    else Result := nil;
end;

{ TTrackPointsAngleGroup }

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

{ TTrackPointsAngle }

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

destructor TTrackPointsAngle.Destroy;
begin
  TrackLinks.Free;
  inherited;
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(SAlreadyConnectedTrackPoint);
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(SAlreadyDisconnectedTrackPoint);
end;

function TTrackPoint.GetDown: TTrackPoint;
var
  I: Integer;
begin
  I := Track.Points.IndexOf(Self) - 1;
  while (I >= 0) and not Assigned(Track.Points[I].LineStation) do
    Dec(I);
  if I >= 0 then Result := 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(Track.Points[I].LineStation) do
    Inc(I);
  if I < Track.Points.Count then Result := 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 := 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 := 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(Track.Points[Index + 1].Position, Track.Points[Index].Position);
end;

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

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

{ TLineStations }

function TLineStations.SearchMapStation(Station: TMapStation): TLineStation;
var
  I: Integer;
begin
  I := 0;
  while (I < Count) and (Items[I].MapStation <> Station) do Inc(I);
  if I < Count then Result := 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(Items[I].Line)) do Inc(I);
  if I < Count then Result := 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(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 Items[0] do
      Result := Rect(Position.X, Position.Y, Position.X, Position.Y);
    for I := 1 to Count - 1 do
    with Items[I] do begin
      if Position.X < Result.Left then Result.Left := Position.X;
      if Position.X > Result.Right then Result.Right := Position.X;
      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(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 (Items[I].Color <> Color) do Inc(I);
  if I < Count then Result := 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(LineStations.First.TrackPoint);
    if Index = 0 then begin
      NewTrackPoint := Track.Points.AddNew;
      Track.Points.Insert(0, NewTrackPoint);
    end;
    Index := Track.Points.IndexOf(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((Track.Points[2].PositionDesigned.Y - Track.Points[1].PositionDesigned.Y),
      (Track.Points[2].PositionDesigned.X - Track.Points[1].PositionDesigned.X));
    EndPoint := Point(Round(Track.Points[1].PositionDesigned.X - EndStationLength * Cos(Angle)),
      Round(Track.Points[1].PositionDesigned.Y - EndStationLength * Sin(Angle)));
    Track.Points.First.PositionDesigned := EndPoint;
    Track.Points.First.Position := EndPoint;

    Angle := ArcTan2((Track.Points[Track.Points.Count - 2].PositionDesigned.Y - Track.Points[Track.Points.Count - 3].PositionDesigned.Y),
      (Track.Points[Track.Points.Count - 2].PositionDesigned.X - Track.Points[Track.Points.Count - 3].PositionDesigned.X));
    EndPoint := Point(Round(Track.Points[Track.Points.Count - 2].PositionDesigned.X + EndStationLength * Cos(Angle)),
      Round(Track.Points[Track.Points.Count - 2].PositionDesigned.Y + EndStationLength * Sin(Angle)));
    Track.Points.Last.PositionDesigned := EndPoint;
    Track.Points.Last.Position := EndPoint;
  end;
end;

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 := LineStations[0];
      Train.BaseTrackPoint := 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 := Track.Points.First;
  TP2 := ALineStation.TrackPoint.GetUp;
  if not Assigned(TP2) then TP2 := Track.Points.Last;

  // Remove track points from trains
  for I := 0 to Trains.Count - 1 do
  with Trains[I] do begin
    IsOnTrack := False;
    for J := Track.Points.IndexOf(TP1) to Track.Points.IndexOf(TP2) do
    if 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(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(Track.Points[Index].LineStation)) do
    Track.Points.Delete(Index);

  if ((Index - 1) >= 0) and (Index < Track.Points.Count) then
    Track.RouteTrack(Track.Points[Index - 1], Track.Points[Index]);

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

  for I := 0 to Trains.Count - 1 do
  with Trains[I] do begin
    if TargetStation = ALineStation then
      TargetStation := 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
    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 := Points[Index1].PositionDesigned;
  P2 := 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(Track.Points[I].Position, Track.Points[I - 1].Position);
end;

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

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

function TMetroLine.IsCircular: Boolean;
begin
  Result := False;
  if LineStations.Count >= 2 then
    Result := (LineStations.Last.MapStation = 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 + 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 + 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.FreeObjects := False;
  Direction := 1;
  Line := nil;
end;

destructor TMetroTrain.Destroy;
begin
  Passengers.Free;
  inherited;
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.FreeObjects := False;

  // Collect all near track points as track links
  SortLines;
  for I := 0 to Lines.Count - 1 do begin
    Line := Lines[I];
    LS := Line.LineStations.SearchMapStation(Self);
    TP := LS.TrackPoint;
    Index := Line.Track.Points.IndexOf(TP);
    if Index > 0 then begin
      NewTrackLink := Line.Track.Points[Index].GetLinkDown;
      TrackLinks.Add(NewTrackLink);
    end;
    if Index < (Line.Track.Points.Count - 1) then begin
      NewTrackLink := Line.Track.Points[Index].GetLinkUp;
      TrackLinks.Add(NewTrackLink);
    end;
    if Line.IsCircular and (Self = Line.LineStations.First.MapStation) and
    (Self = Line.LineStations.Last.MapStation) then begin
      LS := Line.LineStations.Last;
      TP := LS.TrackPoint;
      Index := Line.Track.Points.IndexOf(TP);
      if Index > 0 then begin
        NewTrackLink := Line.Track.Points[Index].GetLinkDown;
        TrackLinks.Add(NewTrackLink);
      end;
      if Index < (Line.Track.Points.Count - 1) then begin
        NewTrackLink := 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 := TrackLinks[I].Points[0].PositionDesigned;
    P2 := TrackLinks[I].Points[1].PositionDesigned;
    if ComparePoint(P1, Position) and not ComparePoint(P2, Position) then begin
      Angle := ArcTan2(P2.Y - Position.Y, P2.X - Position.X);
    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 error');

    GroupItem := TPAngleGroup.SearchAngle(Angle);
    if not Assigned(GroupItem) then begin
      GroupItem := TTrackPointsAngle.Create;
      GroupItem.Angle := Angle;
      TPAngleGroup.Add(GroupItem);
    end;
    GroupItem.TrackLinks.Add(TrackLinks[I]);
  end;

  // Shift TrackLinks according number of lines in group
  for I := 0 to TPAngleGroup.Count - 1 do
  with TPAngleGroup[I] do begin
    for J := 0 to TrackLinks.Count - 1 do
      with 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));
        Shift := NewShift;
      end;
  end;

  FreeAndNil(TPAngleGroup);
  FreeAndNil(TrackLinks);
end;

function MapStationCompareLine(const Item1, Item2: TMetroLine): Integer;
begin
  if Item1.Index > Item2.Index then Result := 1
  else if Item1.Index < 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 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 Trains[T].Direction = 1 then DirectionUp := True;
        if Trains[T].Direction = -1 then DirectionDown := True;
      end;
      if StationIndex = 0 then
        NextStationDown := LineStations[LineStations.Count - 2]
      else
      if StationIndex > 0 then
        NextStationDown := LineStations[StationIndex - 1];

      if (StationIndex >= 0) and (StationIndex = LineStations.Count - 1) then
        NextStationUp := LineStations[1]
      else
      if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then
        NextStationUp := LineStations[StationIndex + 1];
    end else begin
      if StationIndex > 0 then begin
        DirectionDown := True;
        NextStationDown := LineStations[StationIndex - 1]
      end else DirectionDown := False;
      if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then begin
        DirectionUp := True;
        NextStationUp := 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.FreeObjects := False;
  Lines := TMetroLines.Create;
  Lines.FreeObjects := False;
end;

destructor TMapStation.Destroy;
begin
  FreeAndNil(Lines);
  FreeAndNil(Passengers);
  inherited;
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.GetServedDaysCount: Integer;
begin
  Result := Trunc(Time);
end;

function TEngine.GetExistStationShapes: TStationShapeSet;
var
  Station: TMapStation;
begin
  Result := [];
  for Station in Stations do
    Result := Result + [Station.Shape];
end;

function TEngine.GetStationOnPos(Pos: TPoint): TMapStation;
var
  I: Integer;
const
  ClickDistance = 30;
begin
  I := 0;
  while (I < Stations.Count) and (Distance(Stations[I].Position, Pos) > ClickDistance) do Inc(I);
  if I < Stations.Count then Result := Stations[I]
    else Result := nil;
end;

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 Lines[I] do begin
    for T := 1 to Track.Points.Count - 1 do begin
      D := PointToLineDistance(Pos, Track.Points[T - 1].Position, Track.Points[T].Position);
      if (D < MinD) and (D < TrackClickDistance) then begin
        MinD := D;
        Result.Points[0] := Track.Points[T - 1];
        Result.Points[1] := 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 Trains[I] do begin
    D := Distance(GetPosition, Pos);
    if (D < (TrainSize div 2)) and (D < MinDistance) then begin
      Result := 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
  S: TStationShape;
  Station: TMapStation;
begin
  // NewGame all distances
  for Station in Stations do
  with Station 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 Station in Stations do
  with Station do begin
    ComputeShapeDistanceStation(Station, 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 Lines[I] do
        for StationIndex := 0 to LineStations.Count - 1 do
        if LineStations[StationIndex].MapStation = Station then begin
        if not IsCircular then begin
          // Update for all adjecent stations
          if StationIndex > 0 then
            ComputeShapeDistanceStation(LineStations[StationIndex - 1].MapStation,
            UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
          if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then
            ComputeShapeDistanceStation(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 opposite directions are wrong
          DirectionUp := False;
          DirectionDown := False;
          for T := 0 to Trains.Count - 1 do begin
            if Trains[T].Direction = 1 then DirectionUp := True;
            if Trains[T].Direction = -1 then DirectionDown := True;
          end;
          // Update for all adjecent stations
          if DirectionUp then begin
            if StationIndex = 0 then
              ComputeShapeDistanceStation(LineStations[LineStations.Count - 2].MapStation,
              UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
            if StationIndex > 0 then
              ComputeShapeDistanceStation(LineStations[StationIndex - 1].MapStation,
              UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
          end;
          if DirectionDown then begin
            if (StationIndex >= 0) and (StationIndex = LineStations.Count - 1) then
              ComputeShapeDistanceStation(LineStations[1].MapStation,
              UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
            if (StationIndex >= 0) and (StationIndex < LineStations.Count - 1) then
              ComputeShapeDistanceStation(LineStations[StationIndex + 1].MapStation,
              UpdatedShape, Station.ShapeDistance[UpdatedShape] + 1);
          end;
        end;
      end;
    end;
  end;
end;

procedure TEngine.SetDarkMode(AValue: Boolean);
begin
  if FDarkMode = AValue then Exit;
  FDarkMode := AValue;
  InitColors;
  if Assigned(FOnDarkModeChange) then FOnDarkModeChange(Self);
end;

procedure TEngine.InitColors;
begin
  with Colors do
  if FDarkMode then begin
    Background := $2f3020;
    Text := clWhite;
    ShapeBackground := clBlack;
    MenuItemText := $cccccc;
    MenuItemBackground := $b75C01;
    MenuItemBackgroundSelected := $070C81;
  end else begin
    Background := $eff0e0;
    Text := clBlack;
    ShapeBackground := clWhite;
    MenuItemText := clWhite;
    MenuItemBackground := $e78C31;
    MenuItemBackgroundSelected := $f7bC61;
  end;
end;

procedure TEngine.SetState(AValue: TGameState);
begin
  if FState = AValue then Exit;
  FState := AValue;
  UpdateInterface;
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 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 := 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 := Line.LineStations.First.TrackPoint;
              RelPos := 0;
            end else begin
              TargetStationIndex := Line.LineStations.Count - 2;
              Direction := -Direction;
            end;
          end;
          TargetStation := Line.LineStations[TargetStationIndex];

          // Unload passengers in target station
          if Assigned(CurrentStation) then
          for P := Passengers.Count - 1 downto 0 do begin
            if Passengers[P].Shape = CurrentStation.MapStation.Shape then begin
              Passenger := 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(Passengers[P].Shape,
            TargetStation, CurrentStation) then begin
              Passenger := 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 := 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 := 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 <> Line.LineStations.First.TrackPoint then begin
            BaseTrackPoint := BaseTrackPoint.GetNeighDown;
            if Assigned(BaseTrackPoint) then
              RelPos := RelPos + BaseTrackPoint.GetDistance
            else begin
              BaseTrackPoint := Line.LineStations.First.TrackPoint;
              RelPos := 0;
            end;
          end else
          if Line.IsCircular then begin
            BaseTrackPoint := 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 <> Line.LineStations.Last.TrackPoint then begin
            RelPos := RelPos - BaseTrackPoint.GetDistance;
            BaseTrackPoint := BaseTrackPoint.GetNeighUp;
            if not Assigned(BaseTrackPoint) then begin
              BaseTrackPoint := Line.LineStations.Last.TrackPoint;
              RelPos := 0;
            end;
          end else
          if Line.IsCircular then begin
            RelPos := RelPos - BaseTrackPoint.GetDistance;
            BaseTrackPoint := 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 (Lines[I].Track.Points.Count > 0) do Inc(I);
  if I < Lines.Count then Result := Lines[I]
    else Result := nil;
end;

procedure TEngine.ShiftTrackPoints;
var
  I: Integer;
  J: Integer;
  //Link1, Link2: TPoint;
  NewPoint: TPoint;
  MetroLine: TMetroLine;
  TrackPoint: TTrackPoint;
  MapStation: TMapStation;
begin
  // NewGame all trackpoints position shift
  for MetroLine in Lines do
    for TrackPoint in MetroLine.Track.Points do
      TrackPoint.Position := TrackPoint.PositionDesigned;

  // Calculate new position shifts
  for MapStation in Stations do
    MapStation.ShiftTrackPoints;

  // Compute track points from track shift
  for MetroLine in Lines do
  with MetroLine do begin
    // Update start
    if Track.Points.Count > 1 then begin
      Track.Points[0].Position := Track.Points[0].PositionDesigned +
        Track.Points[0].LinkUp.Shift;
    end;

    for I := 1 to Track.Points.Count - 1 do
    with Track.Points[I] do
    if Assigned(Track.Points[I].LinkDown) and Assigned(Track.Points[I].LinkUp) then begin
      {
      Link1 := (Track.Points[I].PositionDesigned + Track.Points[I].LinkDown.Shift) -
        (Track.Points[I - 1].PositionDesigned + Track.Points[I].LinkDown.Shift);
      if (I + 1) < Track.Points.Count then
      Link2 := (Track.Points[I + 1].PositionDesigned + Track.Points[I].LinkUp.Shift) -
          (Track.Points[I].PositionDesigned + Track.Points[I].LinkUp.Shift)
        else Link2 := Link1;

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

    // Update ending
    if Track.Points.Count > 1 then begin
      Track.Points[Track.Points.Count - 1].Position := Track.Points[Track.Points.Count - 1].PositionDesigned -
        Track.Points[Track.Points.Count - 1].LinkDown.Shift;
    end;
  end;

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

procedure TEngine.MenuItemExit(Sender: TObject);
begin
  FormMain.Close;
end;

procedure TEngine.MenuItemPlay(Sender: TObject);
begin
  NewGame;
end;

procedure TEngine.MenuItemOptions(Sender: TObject);
begin
  Menu := MenuOptions;
  Redraw;
end;

procedure TEngine.MenuItemBack(Sender: TObject);
begin
  if Assigned(Menu.Parent) then begin
    Menu := Menu.Parent;
    Redraw;
  end else MenuItemExit(nil);
end;

procedure TEngine.ButtonPlay(Sender: TObject);
begin
  TimePerSecond := TimePerSecondNormal;
  if State = gsPaused then State := gsRunning;
  UpdateInterface;
end;

procedure TEngine.ButtonPause(Sender: TObject);
begin
  if State = gsRunning then State := gsPaused;
  UpdateInterface;
end;

procedure TEngine.ButtonFastForward(Sender: TObject);
begin
  TimePerSecond := TimePerSecondFast;
  if State = gsPaused then State := gsRunning;
  UpdateInterface;
end;

procedure TEngine.MenuItemGameContinue(Sender: TObject);
begin
  State := LastState;
end;

procedure TEngine.MenuItemGameExit(Sender: TObject);
begin
  State := gsMenu;
  Clear;
  Menu := MenuMain;
  Redraw;
end;

procedure TEngine.MenuItemGameRestart(Sender: TObject);
begin
  NewGame;
end;

procedure TEngine.DarkModeChanged(Sender: TObject);
begin
  DarkMode := TMenuItemCheckBox(Sender).Checked;
  InitMenus;
end;

procedure TEngine.LanguageChanged(Sender: TObject);
var
  NewLanguage: TLanguage;
begin
  NewLanguage := TLanguage(TMenuItemComboBox(Sender).States.Objects[TMenuItemComboBox(Sender).Index]);
  if FormMain.Translator1.Language <> NewLanguage then begin
    FormMain.Translator1.Language := NewLanguage;
    FormMain.Translator1.Translate;
    InitMenus;
  end;
end;

procedure TEngine.FullScreenChanged(Sender: TObject);
begin
  FormMain.FullScreen := TMenuItemCheckBox(Sender).Checked;
  FormMain.PersistentForm1.SetFullScreen(FormMain.FullScreen);
end;

procedure TEngine.UpdateInterface;
begin
  ImagePlay.Enabled := not ((State = gsRunning) and (TimePerSecond = TimePerSecondNormal));
  ImageFastForward.Enabled := not ((State = gsRunning) and (TimePerSecond = TimePerSecondFast));
  ImagePause.Enabled := FState = gsRunning; //not (State = gsPaused);
end;

procedure TEngine.InitMenus;
begin
  with MenuMain, Items do begin
    Clear;
    with AddButton(SBigMetro, nil) do begin
      Enabled := False;
      FontSize := 60;
      FontColor := Colors.Text;
      BackgroundColor := clNone;
      BackgroundSelectedColor := clNone;
    end;
    with AddButton(SPlay, MenuItemPlay) do begin
      FontSize := 40;
      FontColor := Colors.MenuItemText;
      BackgroundColor := Colors.MenuItemBackground;
      BackgroundSelectedColor := Colors.MenuItemBackgroundSelected;
    end;
    with AddButton(SOptions, MenuItemOptions) do begin
      FontSize := 40;
      FontColor := Colors.MenuItemText;
      BackgroundColor := Colors.MenuItemBackground;
      BackgroundSelectedColor := Colors.MenuItemBackgroundSelected;
    end;
    with AddButton(SExit, MenuItemExit) do begin
      FontSize := 40;
      FontColor := Colors.MenuItemText;
      BackgroundColor := Colors.MenuItemBackground;
      BackgroundSelectedColor := Colors.MenuItemBackgroundSelected;
    end;
    OnExit := MenuItemExit;
  end;

  MenuOptions.Parent := MenuMain;
  with MenuOptions, Items do begin
    Clear;
    with AddComboBox(SLanguage, [], LanguageChanged) do begin
      FontSize := 40;
      FontColor := Colors.MenuItemText;
      BackgroundColor := Colors.MenuItemBackground;
      BackgroundSelectedColor := Colors.MenuItemBackgroundSelected;
      FormMain.Translator1.LanguageListToStrings(States);
      Index := States.IndexOfObject(FormMain.Translator1.Language);
      if Index = -1 then Index := 0;
    end;
    with AddCheckBox(SDarkMode, DarkModeChanged) do begin
      FontSize := 40;
      FontColor := Colors.MenuItemText;
      BackgroundColor := Colors.MenuItemBackground;
      BackgroundSelectedColor := Colors.MenuItemBackgroundSelected;
      Checked := DarkMode;
    end;
    with AddCheckBox(SFullScreen, FullScreenChanged) do begin
      FontSize := 40;
      FontColor := Colors.MenuItemText;
      BackgroundColor := Colors.MenuItemBackground;
      BackgroundSelectedColor := Colors.MenuItemBackgroundSelected;
      Checked := FormMain.FullScreen;
    end;
    with AddButton(SBack, MenuItemBack) do begin
      FontSize := 40;
      FontColor := Colors.MenuItemText;
      BackgroundColor := Colors.MenuItemBackground;
      BackgroundSelectedColor := Colors.MenuItemBackgroundSelected;
    end;
    OnExit := MenuItemBack;
  end;

  with MenuGame, Items do begin
    Clear;
    with AddButton(SContinue, MenuItemGameContinue) do begin
      FontSize := 40;
      FontColor := Colors.MenuItemText;
      BackgroundColor := Colors.MenuItemBackground;
      BackgroundSelectedColor := Colors.MenuItemBackgroundSelected;
    end;
    with AddButton(SRestart, MenuItemGameRestart) do begin
      FontSize := 40;
      FontColor := Colors.MenuItemText;
      BackgroundColor := Colors.MenuItemBackground;
      BackgroundSelectedColor := Colors.MenuItemBackgroundSelected;
    end;
    with AddButton(SExit, MenuItemGameExit) do begin
      FontSize := 40;
      FontColor := Colors.MenuItemText;
      BackgroundColor := Colors.MenuItemBackground;
      BackgroundSelectedColor := Colors.MenuItemBackgroundSelected;
    end;
    OnExit := MenuItemGameContinue;
  end;
end;

procedure TEngine.ButtonBackClick(Sender: TObject);
begin
  Menu := MenuGame;
  LastState := State;
  State := gsMenu;
  Redraw;
end;

procedure TEngine.DrawClock(Canvas: TCanvas; CanvasSize: TPoint);
var
  ClockCenter: TPoint;
  Angle: Double;
  Text: string;
  I: Integer;
  Y: Integer;
const
  ClockSize = 20;
begin
  Canvas.Pen.Style := psSolid;
  Canvas.Pen.Color := Colors.Text;
  Canvas.Pen.Width := 2;
  ClockCenter := Point(CanvasSize.X - 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)));
  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;
  Y := ClockCenter.Y + ScaleY(5, 96);

  Canvas.Font.Color := Colors.Text;
  Text := FormatDateTime('ddd', Time + 2);
  Canvas.TextOut(ClockCenter.X - ClockSize - Canvas.TextWidth(Text) - 10,
    Y - Canvas.TextHeight(Text) div 2, Text);
  Y := Y + Canvas.TextHeight(Text)  + ScaleY(5, 96);

  Text := SDay + ' ' + IntToStr(Trunc(Time));
  Canvas.TextOut(ClockCenter.X - ClockSize - Canvas.TextWidth(Text) - 10,
    Y - Canvas.TextHeight(Text) div 2, Text);
  Y := Y + Canvas.TextHeight(Text)  + ScaleY(5, 96);

  ImagePause.Canvas := Canvas;
  ImagePause.Bounds := Bounds(CanvasSize.X - ScaleX(20 + 10, 96), Y, ScaleX(20, 96), ScaleY(20, 96));
  ImagePause.Paint;
  Y := Y + ImagePause.Bounds.Height + ScaleY(5, 96);

  ImagePlay.Canvas := Canvas;
  ImagePlay.Bounds := Bounds(CanvasSize.X - ScaleX(20 + 10, 96) , Y, ScaleX(20, 96), ScaleY(20, 96));
  ImagePlay.Paint;
  Y := Y + ImagePlay.Bounds.Height + ScaleY(5, 96);

  ImageFastForward.Canvas := Canvas;
  ImageFastForward.Bounds := Bounds(CanvasSize.X - ScaleX(20 + 10, 96) , Y, ScaleX(20, 96), ScaleY(20, 96));
  ImageFastForward.Paint;
  Y := Y + ImageFastForward.Bounds.Height + ScaleY(5, 96);
end;

procedure TEngine.DrawTrains(Canvas: TCanvas);
var
  P: Integer;
  Pos: TPoint;
  Points: array of TPoint;
  Angle: Double;
  ShapePos: TPoint;
  Train: TMetroTrain;
  Passenger: TMetroPassenger;
begin
  for Train in Trains do
  with Train 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;
      P := 0;
      for Passenger in Passengers do
      with Passenger 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);
        Inc(P);
      end;
    end;
  end;
end;

procedure TEngine.DrawGameOver(Canvas: TCanvas; CanvasSize: TPoint);
var
  Y: Integer;
  Text: string;
begin
  with Canvas do begin
    Canvas.Font.Color := Self.Colors.Text;
    Brush.Style := bsSolid;
    Brush.Color := Self.Colors.Background;

    Y := 100;
    Font.Size := 40;
    TextOut((CanvasSize.X - TextWidth(SGameOver)) div 2, Y, SGameOver);
    Y := Y + Round(TextHeight(SGameOver) * 1.1);

    Font.Size := 14;
    TextOut((CanvasSize.X - TextWidth(SGameOverReason)) div 2, Y, SGameOverReason);
    Y := Y + Round(TextHeight(SGameOverReason) * 1.1);

    Text := Format(SGameOverStatistic, [ServedPassengerCount, ServedDaysCount]);
    TextOut((CanvasSize.X - TextWidth(Text)) div 2, Y, Text);
    Y := Y + Round(TextHeight(SGameOverStatistic) * 1.1);

    Y := Y + 16;

    // Calculate new highest score
    Text := '';
    if (ServedPassengerCount > HighestServedPassengerCount) or
      (ServedDaysCount > HighestServedDaysCount) then begin
      Text := SNewHighScore + ' ';
    end;
    Text := Text + Format(SOldHighScore, [HighestServedPassengerCount,
      HighestServedDaysCount]);
    Canvas.TextOut((CanvasSize.X - TextWidth(Text)) div 2, Y, Text);
    Y := Y + Round(TextHeight(Text) * 1.1);
    if (ServedPassengerCount > HighestServedPassengerCount) then
      HighestServedPassengerCount := ServedPassengerCount;
    if (ServedDaysCount > HighestServedDaysCount) then
      HighestServedDaysCount := ServedDaysCount;
  end;
end;

procedure TEngine.DrawStationPassengerOverload(Canvas: TCanvas);
var
  MapStation: TMapStation;
  Angle: Real;
begin
  for MapStation in Stations do
  with MapStation 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;
end;

procedure TEngine.DrawLines(Canvas: TCanvas);
var
  MetroLine: TMetroLine;
  S: Integer;
begin
  for MetroLine in Lines do
  with MetroLine do begin
    Canvas.Pen.Color := Color;
    Canvas.Pen.Style := psSolid;
    Canvas.Pen.Width := MetroLineThickness;
    if Track.Points.Count > 0 then Canvas.MoveTo(Track.Points[0].Position);
    for S := 1 to Track.Points.Count - 1 do begin
      Canvas.LineTo(Track.Points[S].Position);
{      if (S = TrackPoints.Count - 1) then begin
        Canvas.Pen.EndCap := pecSquare;
        Angle := arctan2(((TrackPoints[S].Position.Y - TrackPoints[S - 1].Position.Y),
          (TrackPoints[S].Position.X - TrackPoints[S - 1].Position.X));
        EndPoint := Point(Round(TrackPoints[S].Position.X + EndStationLength * Cos(Angle)),
          Round(TrackPoints[S].Position.Y + EndStationLength * Sin(Angle)));
        Canvas.LineTo(EndPoint);
        Canvas.MoveTo(Point(Round(EndPoint.X + Cos(Angle + Pi / 2) * EndStationLength / 3),
          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(Track.Points[0].PositionDesigned);
    for S := 1 to Track.Points.Count - 1 do begin
      Canvas.LineTo(Track.Points[S].PositionDesigned);
{      if (S = TrackPoints.Count - 1) then begin
        Canvas.Pen.EndCap := pecSquare;
        Angle := arctan2((TrackPoints[S].Position.Y - TrackPoints[S - 1].Position.Y),
          (TrackPoints[S].Position.X - TrackPoints[S - 1].Position.X));
        EndPoint := Point(Round(TrackPoints[S].Position.X + EndStationLength * Cos(Angle)),
          Round(TrackPoints[S].Position.Y + EndStationLength * Sin(Angle)));
        Canvas.LineTo(EndPoint);
        Canvas.MoveTo(Point(Round(EndPoint.X + Cos(Angle + Pi / 2) * EndStationLength / 3),
          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((TrackPoints[1].Position.Y - TrackPoints[0].Position.Y),
        (TrackPoints[1].Position.X - TrackPoints[0].Position.X));
      Canvas.MoveTo(TrackPoints[0].Position);
      EndPoint := Point(Round(TrackPoints[0].Position.X - EndStationLength * Cos(Angle)),
        Round(TrackPoints[0].Position.Y - EndStationLength * Sin(Angle)));
      Canvas.LineTo(EndPoint);
      Canvas.MoveTo(Point(Round(EndPoint.X - Cos(Angle + Pi / 2) * EndStationLength / 3),
        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;
end;

procedure TEngine.DrawStations(Canvas: TCanvas);
var
  MapStation: TMapStation;
  Passenger: TMetroPassenger;
  PassengerPos: TPoint;
  Direction: Integer;
begin
  Canvas.Pen.Width := 5;
  for MapStation in Stations do
  with MapStation 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 := Colors.ShapeBackground;
    Canvas.Brush.Style := bsSolid;
    Canvas.Pen.Color := Colors.Text;
    DrawShape(Canvas, Position, Shape, StationSize, 0);

    // Draw passengers
    Canvas.Pen.Style := psClear;
    Canvas.Brush.Color := Colors.Text;
    PassengerPos := Point(0, 0);
    Direction := 1;
    for Passenger in Passengers do
    with Passenger 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;
end;

procedure TEngine.DrawGameControls(Canvas: TCanvas; CanvasSize: TPoint);
var
  I: Integer;
  Text: string;
  Radius: Integer;
  Angle: Real;
  Pos: TPoint;
begin
  // Line selection
  Canvas.Pen.Width := 4;
  for I := 0 to High(LineColors) do begin
    if Assigned(Lines.SearchByColor(LineColors[I])) then begin
      Canvas.Brush.Color := LineColors[I];
      Radius := 15;
    end else begin
      Canvas.Brush.Color := clSilver;
      Radius := 5;
    end;
    Canvas.Pen.Color := Colors.Text;
    if Assigned(SelectedLine) and (SelectedLine.Color = LineColors[I]) then begin
      Canvas.Pen.Style := psSolid;
    end else begin
      Canvas.Pen.Style := psClear;
    end;

    Canvas.EllipseC(CanvasSize.X div 2 - Length(LineColors) div 2 * LineColorsDist + I * LineColorsDist,
      CanvasSize.Y - LineColorsDist, Radius, Radius);
  end;

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

  // Status interface
  Text := IntToStr(ServedPassengerCount);
  Canvas.Draw(CanvasSize.X - 50, CanvasSize.Y - 60, ImagePassenger.Bitmap);
  Canvas.Brush.Style := bsClear;
  Canvas.Font.Size := 14;
  Canvas.Font.Color := Colors.Text;
  Canvas.TextOut(CanvasSize.X - 70 - Canvas.TextWidth(Text),
    CanvasSize.Y - 55, Text);

  DrawClock(Canvas, CanvasSize);

  // Back button
  Canvas.Font.Size := 40;
  Canvas.Font.Color := Colors.Text;
  ButtonBack.Canvas := Canvas;
  ButtonBack.Bounds.Left := 10;
  ButtonBack.Bounds.Top := 10;
  ButtonBack.Paint;

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

    Canvas.Polygon([
      RotatePoint(Pos, Point(Pos.X - TrainSize div 2, Pos.Y - TrainSize div 3), Angle),
      RotatePoint(Pos, Point(Pos.X + TrainSize div 2, Pos.Y - TrainSize div 3), Angle),
      RotatePoint(Pos, Point(Pos.X + TrainSize div 2, Pos.Y + TrainSize div 3), Angle),
      RotatePoint(Pos, Point(Pos.X - TrainSize div 2, Pos.Y + TrainSize div 3), Angle)
    ]);
  end;
end;

procedure TEngine.Tick;
var
  Passenger: TMetroPassenger;
  MapStation: TMapStation;
begin
  if State = gsRunning then begin
    FTime := FTime + (Now - LastTickTime) / OneSecond * TimePerSecond;
    Redraw; // Redraw on every tick 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 MapStation in Stations do
    with MapStation do
    if Random < NewPassengerProbability then begin
      Passenger := Self.Passengers.AddNew;
      Passenger.Station := MapStation;
      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 MapStation in Stations do
  with MapStation 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 MapStation in Stations do
  with MapStation 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
  if State = gsMenu then begin
    Menu.MouseMove(Position);
    Redraw;
  end;

  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
        ((Line.LineStations.First.MapStation = FocusedStation) or
        (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
    if State = gsMenu then begin
      Menu.MouseUp(Button, Position);
      Redraw;
    end else begin
      // Back button
      if ButtonBack.Bounds.Contains(Position) then begin
        if Assigned(ButtonBack.OnClick) then
          ButtonBack.OnClick(ButtonBack);
      end;

      // Pause button
      if ImagePause.Bounds.Contains(Position) then begin
        if Assigned(ImagePause.OnClick) then
          ImagePause.OnClick(ImagePause);
      end;

      // Play button
      if ImagePlay.Bounds.Contains(Position) then begin
        if Assigned(ImagePlay.OnClick) then
          ImagePlay.OnClick(ImagePlay);
      end;

      // Fast forward button
      if ImageFastForward.Bounds.Contains(Position) then begin
        if Assigned(ImageFastForward.OnClick) then
          ImageFastForward.OnClick(ImageFastForward);
      end;

      // 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 := FocusedTrack.Points[0].Track.Line;
          SelectedTrain.Line.Trains.Add(SelectedTrain);
          SelectedTrain.BaseTrackPoint := FocusedTrack.Points[0];
        end else
        if Assigned(FocusedTrack.Points[1]) then begin
          SelectedTrain.Line := FocusedTrack.Points[1].Track.Line;
          SelectedTrain.Line.Trains.Add(SelectedTrain);
          SelectedTrain.BaseTrackPoint := 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 := 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(TrackStationDown.Track.Line.LineStations.First);
      end;
      if Assigned(TrackStationUp) and (TrackStationUp.Track.Line.LineStations.Count = 1) then begin
        TrackStationUp.Track.Line.DisconnectStation(TrackStationUp.Track.Line.LineStations.First);
      end;
    end;
  end else
  if Button = mbRight then begin
    SelectedLine := nil;
  end;
  MouseHold := False;
  TrackStationDown := nil;
  TrackStationUp := nil;
  SelectedTrain := nil;
  Redraw;
end;

procedure TEngine.MouseDown(Button: TMouseButton; Position: TPoint);
var
  Station: TMapStation;
  NewLine: TMetroLine;
  Track: TTrackLink;
  NewIndex: Integer;
begin
  if (Button = mbLeft) and (State <> gsMenu) 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;

    // 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 := NewLine.Track.Points.Last;
        TrackStationUp := nil;
        LastFocusedStation := Station;
        SelectedLine := NewLine;
        Exit;
      end;
    end;

    // Line selection
    Track := GetTrackOnPos(View.PointDestToSrc(Position));
    if Assigned(Track) and Assigned(Track.Points[0]) and Assigned(Track.Points[1]) then begin
      SelectedLine := Track.Points[0].Track.Line;

      TrackStationDown := Track.Points[0];
      NewIndex := TrackStationDown.Track.Points.IndexOf(TrackStationDown);
      while Assigned(TrackStationDown) and (not Assigned(TrackStationDown.LineStation)) do begin
        NewIndex := NewIndex - 1;
        if NewIndex >= 0 then TrackStationDown := TrackStationDown.Track.Points[NewIndex]
          else TrackStationDown := nil;
      end;
      TrackStationUp := Track.Points[1];
      NewIndex := TrackStationUp.Track.Points.IndexOf(TrackStationDown);
      while Assigned(TrackStationUp) and (not Assigned(TrackStationUp.LineStation)) do begin
        NewIndex := NewIndex + 1;
        if NewIndex < TrackStationUp.Track.Points.Count then
          TrackStationUp := TrackStationUp.Track.Points[NewIndex]
          else TrackStationUp := nil;
      end;
      Track.Free;
      Exit;
    end;
    if Assigned(Track) then Track.Free;
  end;
end;

procedure TEngine.KeyUp(Key: Word);
const
  KeyEsc = 27;
  KeyF2 = 113;
begin
  if Key = KeyEsc then begin
    if State = gsMenu then begin
      if Assigned(Menu.OnExit) then
        Menu.OnExit(nil);
    end else begin
      ButtonBackClick(nil);
    end;
  end;
  {$IFDEF DEBUG}
  if Key = KeyF2 then begin
    if State = gsRunning then begin
      State := gsGameOver;
      Redraw;
    end;
  end;
  {$ENDIF}
end;

procedure TEngine.MainMenu;
begin
  State := gsMenu;
  Redraw;
end;

procedure TEngine.Clear;
begin
  Trains.Clear;
  Passengers.Clear;
  Lines.Clear;
  Stations.Clear;
end;

procedure TEngine.NewGame;
var
  NewTrain: TMetroTrain;
  I: Integer;
  NewStation: TMapStation;
  InitialStationCount: Integer;
begin
  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
  TimePerSecond := TimePerSecondNormal;
  ButtonBack := TImage.Create;
  ButtonBack.OnClick := ButtonBackClick;
  ButtonBack.Bounds := Bounds(0, 0, ScaleX(80, 96), ScaleY(80, 96));
  MenuMain := TMenu.Create;
  MenuOptions := TMenu.Create;
  MenuGame := TMenu.Create;
  Menu := MenuMain;
  InitMenus;
  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;
  ImageLocomotive := TImage.Create;
  ImagePlay := TImage.Create;
  ImagePlay.OnClick := ButtonPlay;
  ImagePause := TImage.Create;
  ImagePause.OnClick := ButtonPause;
  ImageFastForward := TImage.Create;
  ImageFastForward.OnClick := ButtonFastForward;
  //if FileExists(ImagePassengerName) then
  //  ImagePassenger.Picture.LoadFromFile(ImagePassengerName);
  //if FileExists(ImageLocomotiveName) then
  //  ImageLocomotive.Picture.LoadFromFile(ImageLocomotiveName);
  MetaCanvas := TMetaCanvas.Create;
  InitColors;
end;

destructor TEngine.Destroy;
begin
  FreeAndNil(MetaCanvas);
  FreeAndNil(Trains);
  FreeAndNil(ImagePlay);
  FreeAndNil(ImageFastForward);
  FreeAndNil(ImagePause);
  FreeAndNil(ImageLocomotive);
  FreeAndNil(ImagePassenger);
  FreeAndNil(View);
  FreeAndNil(Map);
  FreeAndNil(Passengers);
  FreeAndNil(Stations);
  FreeAndNil(Lines);
  FreeAndNil(MenuMain);
  FreeAndNil(MenuOptions);
  FreeAndNil(MenuGame);
  FreeAndNil(ButtonBack);
  inherited;
end;

procedure TEngine.Paint(Canvas: TCanvas; CanvasSize: TPoint);
begin
  MetaCanvas.Size := Point(Canvas.Width, Canvas.Height);
  MetaCanvas.Reset;

  DrawStationPassengerOverload(MetaCanvas);
  DrawLines(MetaCanvas);
  DrawTrains(MetaCanvas);
  DrawStations(MetaCanvas);

  // MainMenu background
  Canvas.Brush.Color := Colors.Background;
  Canvas.Brush.Style := bsSolid;
  Canvas.Clear;

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

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

  if State <> gsMenu then begin
    DrawGameControls(Canvas, CanvasSize);
  end;

  // Game over
  if State = gsGameOver then
  begin
    DrawGameOver(Canvas, CanvasSize);
  end else
  if State = gsMenu then begin
    Menu.Paint(Canvas, CanvasSize);
  end;

  RedrawPending := False;
end;

end.