DemoMountains

{ Main state, where most of the application logic takes place.

  Feel free to use this code as a starting point for your own projects.
  (This code is in public domain, unlike most other CGE code which
  is covered by the LGPL license variant, see the COPYING.txt file.) }
unit GameStateMain;

interface

uses Classes,
  CastleVectors, CastleUIState, CastleComponentSerialize,
  CastleUIControls, CastleControls, CastleKeysMouse, CastleTimeUtils, Math;

type
  { Main state, where most of the application logic takes place. }
  TStateMain = class(TUIState)

  const
    { Interval between two clicks }
    DblClick: Single = 300;
    { Rotation speed of the plane }
    RotFactor: Single = 0.03;
  private
    { Components designed using CGE editor, loaded from gamestatemain.castle-user-interface. }
    LabelFps: TCastleLabel;
    LabelRot: TCastleLabel;
    ImagePlayer: TCastleImageControl;
    ImgFlying: Boolean;
    ImgTarget: TVector2;
    ImgRotStart, ImgRotStop: TVector2;
    PlayerPosition: TVector2;
    PlayerRotation: Single;
    ImgSpeed: TVector2;
    FirstClick: QWord;
    MoveStart, MoveStop: Boolean;
  public
    constructor Create(AOwner: TComponent); override;
    procedure Start; override;
    procedure Update(const SecondsPassed: Single; var HandleInput: Boolean); override;
    procedure GetRadians(PlayerPos, PlayerTarget: TVector2);
    function Press(const Event: TInputPressRelease): Boolean; override;
  end;

var
  StateMain: TStateMain;

implementation

uses SysUtils;

{ TStateMain ----------------------------------------------------------------- }


constructor TStateMain.Create(AOwner: TComponent);
begin
  inherited;
  DesignUrl := 'castle-data:/gamestatemain.castle-user-interface';
end;

procedure TStateMain.Start;
begin
  inherited;

  { Find components, by name, that we need to access from code }
  LabelFps := DesignedComponent('LabelFps') as TCastleLabel;
  LabelRot := DesignedComponent('LabelRot') as TCastleLabel;
  ImagePlayer := DesignedComponent('ImagePlayer') as TCastleImageControl;

  ImgSpeed := Vector2(300, 300);
  FirstClick := 0;
end;

procedure TStateMain.Update(const SecondsPassed: Single; var HandleInput: Boolean);
{ const
    MoveSpeed = 800; Moved to ImgSpeed }
  var
    //PlayerPosition: TVector2;
    CheckDblClick: QWord;
begin
  inherited;
  { This virtual method is executed every frame.}
  LabelFps.Caption := 'FPS: ' + Container.Fps.ToString;
  LabelRot.Caption := 'Plane Rotation: ' + ImagePlayer.Rotation.ToString + ' (rad)';

  { Reset the first click if the double click has not occurred }
  if (FirstClick > 0) then
  begin
    CheckDblClick := CastleGetTickCount64;
    if ((CheckDblClick - FirstClick) > DblClick) then FirstClick := 0;
  end;

  { update player position [to fall down] }
  PlayerPosition := ImagePlayer.AnchorDelta;

  // NEW CODE WE ADD:
  if Container.Pressed[keyArrowLeft] then
    PlayerPosition := PlayerPosition + Vector2(-ImgSpeed.X * SecondsPassed, 0);
  if Container.Pressed[keyArrowRight] then
    PlayerPosition := PlayerPosition + Vector2( ImgSpeed.X * SecondsPassed, 0);
  if Container.Pressed[keyArrowDown] then
    PlayerPosition := PlayerPosition + Vector2(0, -ImgSpeed.Y * SecondsPassed);
  if Container.Pressed[keyArrowUp] then
    PlayerPosition := PlayerPosition + Vector2(0,  ImgSpeed.Y * SecondsPassed);

  //PlayerPosition.Y := Max(PlayerPosition.Y - SecondsPassed * 400, 0);

  if ImgFlying then
  begin
    { Rotate the plane when it starts
      PlayerRotation returned by the GetRadians procedure }
    if MoveStart then
    begin
      if ImagePlayer.Rotation <> PlayerRotation then
      begin
      if PlayerRotation < 0 then
        begin
          if ImagePlayer.Rotation > PlayerRotation then ImagePlayer.Rotation := ImagePlayer.Rotation - RotFactor
            else
             ImagePlayer.Rotation := PlayerRotation;
        end
        else
        begin
          if ImagePlayer.Rotation < PlayerRotation then ImagePlayer.Rotation := ImagePlayer.Rotation + RotFactor
            else
             ImagePlayer.Rotation := PlayerRotation;
        end;
      end
      else
      begin
        MoveStart := false;
        MoveStop := true;
        { Stores the distance of the plane from the starting point when it finishes rotating
          When the plane is at the same distance from the point of arrival it will begin to rotate in reverse
          The action will be complete only if the distance between the two starting and ending points is not too short }
        ImgRotStop.X := Abs(ImgRotStart.X - PlayerPosition.X);
        imgRotStop.Y := Abs(ImgRotStart.Y - PlayerPosition.Y);
        LabelFps.Caption := ImgRotStop.X.ToString + '   ' + ImgRotStop.Y.ToString;
      end;
    end;

    { Rotate the plane when it arrives }
    if MoveStop then
    begin
      if (Abs(PlayerPosition.X - ImgTarget.X) < ImgRotStop.X) or (Abs(PlayerPosition.Y - ImgTarget.Y) < ImgRotStop.Y) then
      begin
        if ImagePlayer.Rotation < 0 then
          ImagePlayer.Rotation := ImagePlayer.Rotation + RotFactor
        else
          ImagePlayer.Rotation := ImagePlayer.Rotation - RotFactor
      end;
    end;

    if PlayerPosition.x < ImgTarget.X then
      PlayerPosition.X := (Min(ImgTarget.X, (PlayerPosition.X) + ImgSpeed.X * SecondsPassed))
    else
      PlayerPosition.X := (Max(ImgTarget.X, (PlayerPosition.X) - ImgSpeed.X * SecondsPassed));

    if PlayerPosition.Y < ImgTarget.Y then
      PlayerPosition.Y := (Min(ImgTarget.Y, (PlayerPosition.Y) + ImgSpeed.Y * SecondsPassed))
    else
      PlayerPosition.Y := (Max(ImgTarget.Y, (PlayerPosition.Y) - ImgSpeed.Y * SecondsPassed));
  end;

  ImagePlayer.AnchorDelta := PlayerPosition;

  if (PlayerPosition.X = ImgTarget.X) and
     (PlayerPosition.Y = ImgTarget.Y) then
  begin
    ImagePlayer.Rotation := 0;
    ImgSpeed := Vector2(300, 300);
    ImgFlying := false;
    MoveStop := false;
  end;
end;

function TStateMain.Press(const Event: TInputPressRelease): Boolean;
var
  FactorX: Single = 300;
  FactorY: Single = 300;
  LengthX, LengthY: Single;
begin
  Result := inherited;
  if Result then Exit; // allow the ancestor to handle keys

  if Event.IsKey(keyArrowLeft) then
  begin
    ImagePlayer.FlipHorizontal:=true;
    Exit(true);
  end;

  if Event.IsKey(keyArrowRight) then
  begin
    ImagePlayer.FlipHorizontal:=false;
    Exit(true);
  end;

  if Event.IsKey(keySpace) then
  begin
    ImagePlayer.Color := Vector4(Random, Random, Random, 1);
    Exit(true); // event was handled
  end;

  if Event.IsMouseButton(buttonLeft) then
  begin
    ImgTarget := ImagePlayer.Parent.ContainerToLocalPosition(Event.Position);

    { Routine to intercept the double click
      Note: at the first click the plane will start to move and only at the
      second click will it increase its speed
      This can be useful if the moving object is a character because you will
      get the impression that it starts running
      It would be good to introduce a control to check if the two clicks occur
      close together in space }
    if FirstClick = 0 then FirstClick := CastleGetTickCount64
    else
    begin
        FactorX := 700;
        FactorY := 700;
    end;

    ImgTarget := ImagePlayer.Parent.ContainerToLocalPosition(Event.Position);

    { Move the arrival point to the center of the plane }
    ImgTarget.X := ImgTarget.X - ImagePlayer.EffectiveWidth/2;
    ImgTarget.Y := ImgTarget.Y - ImagePlayer.EffectiveHeight/2;

    { By changing the two speeds of the plane on the X and Y axis it will
      arrive directly at the arrival point (unlike the Dragon demo,
      it depends on the game }
    LengthX := Abs(PlayerPosition.X - ImgTarget.X);
    LengthY := Abs(PlayerPosition.Y - ImgTarget.Y);
    if LengthX > LengthY then
    begin
      ImgSpeed.X:= FactorX;
      ImgSpeed.Y := FactorY * LengthY / LengthX;
    end
    else
    begin
      ImgSpeed.Y := FactorY;
      ImgSpeed.X := FactorX * LengthX / LengthY;
    end;
    GetRadians(PlayerPosition, imgTarget);
    ImgFlying := true;
    Exit(true); // event was handled
  end;

  { This virtual method is executed when user presses
    a key, a mouse button, or touches a touch-screen.

    Note that each UI control has also events like OnPress and OnClick.
    These events can be used to handle the "press", if it should do something
    specific when used in that UI control.
    The TStateMain.Press method should be used to handle keys
    not handled in children controls.
  }

  // Use this to handle keys:
  {
  if Event.IsKey(keyXxx) then
  begin
    // DoSomething;
    Exit(true); // key was handled
  end;
  }
end;

{ Get direction of plane in radians }
procedure TStateMain.GetRadians(PlayerPos, PlayerTarget: TVector2);
var
  MouseX, MouseY,
  PlayerX, PlayerY,
  DiffX, DiffY,
  ArcTanXY: single;
begin
  ImgRotStart := PlayerPos;
  if PlayerPos.X > PlayerTarget.X then
    ImagePlayer.FlipHorizontal:=true
  else
    ImagePlayer.FlipHorizontal:=false;
  MouseX := PlayerTarget.X;
  MouseY := PlayerTarget.y;
  PlayerX := PlayerPos.X;
  PlayerY := PlayerPos.Y;
  if (PlayerY < MouseY) then
  begin
    DiffY := (MouseY - PlayerY);
    if (PlayerX < MouseX) then
    begin
      DiffX := (MouseX - PlayerX);
      ArcTanXY := (PI/2) - Math.arctan2(DiffX, DiffY);
    end
    else
    begin
      DiffX := (PlayerX - MouseX);
      ArcTanXY := Math.arctan2(DiffX, DiffY) - (PI/2);
    end;
  end
  else if PlayerY > MouseY then
  begin
    DiffY := (PlayerY - MouseY);
    if (PlayerX < MouseX) then
    begin
      DiffX := (MouseX - PlayerX);
      ArcTanXY := Math.arctan2(DiffX, DiffY) - (PI/2);
    end
    else
    begin
      DiffX := (PlayerX - MouseX);
      ArcTanXY := (PI/2) - Math.arctan2(DiffX, DiffY);
    end;
  end;
  PlayerRotation := ArcTanXY;
  MoveStart := true;
end;

end.