Minimap.simba

{*
    This file contains all functions relating to communication with the the camera, compass and map.
    This file also contains functions for retrieving and setting the following information:

      - Local Camera Position
      - Minimap location/area
      - Player's local position
      - Compass Angles
      - Map Images
*}

{$include_once GLXCore.Simba}
{$include_once Cache.Simba}
{$include_once Misc/Graphics.Simba}

type FloatPoint = record
  X, Y: Single;
end;

{*
  Constructor for a floating point version of the TPoint structure.
*}
Function FloatPoint.Create(__X, __Y: Single): FloatPoint;
Begin
  Self.X := __X;
  Self.Y := __Y;
  Result := Self;
End;

{*
  Determines the shortest distance from one angle to another.
  Example:
    If the compass is at 20 Degrees and you want to rotate to 180 degrees.
    This function tells which way to rotate the compass to get to the specified angle.
*}
Function ShortestArcDeg(Angle, Target: Single): Single;
Begin
  If (abs(Target - Angle) < 180) Then
  Begin
    Result := Target - Angle;
    Exit;
  End;

  If (Target > Angle) Then
  Begin
    Result := Target - Angle - 360;
    Exit;
  End;
  Result := Target - Angle + 360;
End;

{*
  Determines the shortest distance from one angle to another.
  Example:
    If the compass is at 20 Degrees and you want to rotate to 180 degrees.
    This function tells which way to rotate the compass to get to the specified angle.
*}
Function ShortestArcRad(Angle, Target: Single): Single;
Begin
  If (abs(Target - Angle) < PI) Then
  Begin
    Result := Target - Angle;
    Exit;
  End;

  If (Target > Angle) Then
  Begin
    Result := Target - Angle - PI * 2;
    Exit;
  End;
  Result := Target - Angle + PI * 2;
End;

{*
  Calculates the Euler Angles in Radians from the ModelView Matrix in the specified row
  or column major order.

  Calculates the pitch, yaw, roll of the game camera.
*}
Procedure glEulerAngles(var X, Y, Z: Double; ModelView: array [0..15] of single; RowMajor: Boolean);
begin
  if (RowMajor) then
  begin
    X := FixRad(ArcTan2(ModelView[6], ModelView[10]));
    Y := FixRad(ArcTan2(-ModelView[8], sqrt(pow(ModelView[0], 2) + pow(ModelView[1], 2))));
    Z := FixRad(ArcTan2(ModelView[1], ModelView[0]));
  end else
  begin
    X := FixRad(ArcTan2(ModelView[9], ModelView[10]));
    Y := FixRad(ArcTan2(-ModelView[8], sqrt(pow(ModelView[0], 2) + pow(ModelView[4], 2))));
    Z := FixRad(ArcTan2(ModelView[4], ModelView[0]));
  end;
end;

{*
  Returns the Camera's local position from the ModelView Matrix in row or column major order.
*}
Procedure glCameraPos(var X, Y, Z: Double; ModelView: array [0..15] of Single; RowMajor: Boolean);
begin
  if (RowMajor) then
  begin
    X := ModelView[12];
    Y := ModelView[13];
    Z := ModelView[14];
  end else
    begin
      X := ModelView[3];
      Y := ModelView[7];
      Z := ModelView[11];
    end;
end;

{*
  Returns the Bounding-Box of the Minimap.

  Developer Info:
    3786240   - TextureID of the minimap background (found in the middle of the minimap).
    386460    - TextureID of the corners of the minimap.
*}
Function GL_MMBounds: TBox;
var
  I, J: Integer;
  TBA: TBoxArray;
  Background, Corners: glTextureArray;
Begin
  If (UseSysCache) Then
  Begin
    I := SysCache.Contains(TCacheType.CACHE_MINIMAP);
    if (I <> -1) Then
    Begin
      Result := SysCache[I].Area;
      Exit;
    End;
  End;

  Background := glGetTextures(3786240);
  Corners := glGetTextures(386460);
  If (Length(Background) < 1) or (Length(Corners) < 1) Then Exit;

  For I := 0 To High(Background) Do
    If (PointInBox(Point(Corners[0].X, Corners[0].Y), Background[I].Bounds)) then
    Begin
      Result := Background[I].Bounds;
      If (UseSysCache) Then
        SysCache.CacheMinimap(Result);
      Exit;
    End;

  Result := IntToBox(-1, -1, -1, -1);
End;

{*
  Returns the coordinates of the MAP within the minimap.
*}
Procedure GL_GetMapCoords(var TL, BL, BR, TR: FloatPoint);
var
  T: FloatPoint;
  X, Y: Array[0..3] of single;
begin
  GLXMapCoords(X, Y);
  TL := T.Create(X[0], Y[0]);
  BL := T.Create(X[1], Y[1]);
  BR := T.Create(X[2], Y[2]);
  TR := T.Create(X[3], Y[3]);
end;

{*
  Converts the specified Main Screen Point to the corresponding location on the
  Minimap.
*}
Function GL_MSToMM(MSP: TPoint): TPoint;
var
  Loc: TPoint;
  MMBounds: TBox;
  TL, BL, BR, TR: FloatPoint;
  X, Y, X1, Y1, X2, Y2: Integer;
  W, H, DX, DY, RatioX, RatioY, Angle: Extended;
begin
  MMBounds := GL_MMBounds;
  GLXViewPort(X1, Y1, X2, Y2);
  W := X2 - X1; H := Y2 - Y1;
  RatioX := W / MMBounds.Width;
  RatioY := H / MMBounds.Height;

  DX := (MSP.X - (W / 2));
  DY := (MSP.Y - (H / 2));
  DX := DX / RatioX;
  DY := DY / RatioY;

  MSP.X := MMBounds.MidPoint.X;
  MSP.Y := MMBounds.MidPoint.Y;

  GL_GetMapCoords(TL, BL, BR, TR);
  Angle := FixRad(ArcTan2(TR.Y - TL.Y, TR.X - TL.X));
  Result.X := Round(MSP.X + DX);
  Result.Y := Round(MSP.Y + DY);
  Result := RotatePoint(Result, Angle, MSP.X, MSP.Y);
  Result.X := Result.X + (MMBounds.Width div 256);
  Result.Y := Result.Y - (MMBounds.Height div 64);
end;

{*
  Returns the player's local position within the current MAP.
*}
Function GL_GetLocalPos: TPoint;
var
  Player: TPoint;
  TL, BL, BR, TR: FloatPoint;
  PPX, PPY, PPZ: Double;
  TVX, TVY, BVX, BVY: Double;
Begin
  If (Not GL_LoggedIn) Then Exit;
  GL_GetMapCoords(TL, BL, BR, TR);
  Player := MiddleBox(GL_MMBounds);

  TVX := TR.X - TL.X;
  TVY := TR.Y - TL.Y;
  BVX := BL.X - TL.X;
  BVY := BL.Y - TL.Y;
  PPX := Player.X - TL.X;
  PPY := Player.Y - TL.Y;
  PPZ := (TVX * BVY) - (TVY * BVX);
  Result.X := Round(((PPX * BVY) - (PPY * BVX)) * 512.0 / PPZ);
  Result.Y := Round(((PPY * TVX) - (PPX * TVY)) * 512.0 / PPZ);
End;

Function GL_GetLocalMapPos(var MapPtr: Pointer): TPoint;
var
  Player: TPoint;
  PPX, PPY, PPZ: Double;
  TVX, TVY, BVX, BVY: Double;
  X, Y: Array[0..3] of Single;
Begin
  If (Not GL_LoggedIn) Then Exit;

  Player.X := 512;
  Player.Y := 512;
  MapPtr := GLXMap(Player.X, Player.Y, X, Y);
  Player := MiddleBox(GL_MMBounds);

  TVX := X[3] - X[0];
  TVY := Y[3] - Y[0];
  BVX := X[1] - X[0];
  BVY := Y[1] - Y[0];
  PPX := Player.X - X[0];
  PPY := Player.Y - Y[0];
  PPZ := (TVX * BVY) - (TVY * BVX);
  Result.X := Round(((PPX * BVY) - (PPY * BVX)) * 512.0 / PPZ);
  Result.Y := Round(((PPY * TVX) - (PPX * TVY)) * 512.0 / PPZ);
End;

{*
  Returns the current compass angle in Degrees and Radians.
*}
Procedure GL_CompassAngle(var DA, RA: Single);
var
  TL, BL, BR, TR: FloatPoint;
Begin
  If (Not GL_LoggedIn) Then Exit;
  GL_GetMapCoords(TL, BL, BR, TR);
  RA := FixRad(ArcTan2(TR.Y - TL.Y, TR.X - TL.X));
  DA := FixD(Degrees(RA));
End;

{*
  Rotates the compass to the specified angle (in degrees).
*}
Function GL_MakeCompass(Angle: Single; Tolerance: Integer = 5): Boolean;
var
  T: Timer;
  Left: Boolean;
  AngleDistance: Single;
  CurrentAngle, RA: Single;
Begin
  GL_CompassAngle(CurrentAngle, RA);
  If ((CurrentAngle < 0) or (Not GL_LoggedIn)) Then
    Exit;

  Angle := FixD(Angle);
  T.Start();

  While ((Abs(ShortestArcDeg(CurrentAngle, Angle)) > Tolerance) and (T.TimeElapsed() < 10000)) do
  Begin
    AngleDistance := CurrentAngle - Angle;
    Left := ((AngleDistance > 0) and (abs(AngleDistance) <= 180)) or ((AngleDistance < 0) and (abs(AngleDistance) > 180));
    if (Left) Then
      KeyDown(VK_LEFT)
    Else
      KeyDown(VK_RIGHT);

    GL_CompassAngle(CurrentAngle, RA);
    Result := Abs(ShortestArcDeg(CurrentAngle, Angle)) <= Tolerance;
    If (Result) Then
    Begin
      If (Left) Then
        KeyUp(VK_LEFT)
      Else
        KeyUp(VK_RIGHT);
      Break;
    End;
    Wait(RandomRange(16, 20));
  End;

  If (Left) Then
    KeyUp(VK_LEFT)
  Else
    KeyUp(VK_RIGHT);
  Result := Abs(ShortestArcDeg(CurrentAngle, Angle)) <= Tolerance;
End;

{*
  Returns the compass angle in degrees. Angle is found using EulerAngles + Math. VERY ACCURATE!
  NOTE: This function was previously disabled out. It works now and should be used!
*}
Function GL_CompassDeg: Integer;
var
  X, Y, Z: Double;
begin
  glEulerAngles(X, Y, Z, GLXMatrices^, True);
  Result := Round(Degrees(Z));
end;

{*
  Returns the compass angle in radians. Angle is found using EulerAngles + Math. VERY ACCURATE!
  NOTE: This function was previously disabled out. It works now and should be used!
*}
Function GL_CompassRad: Single;
var
  X, Y, Z: Double;
begin
  glEulerAngles(X, Y, Z, GLXMatrices^, True);
  Result := Z;
end;

{*
  Returns the compass height in degrees. Height is found using EulerAngles + Math. VERY ACCURATE!
  NOTE: This function was previously disabled out. It works now and should be used!
*}
Function GL_CompassHeightDeg: Integer;
var
  X, Y, Z: Double;
begin
  glEulerAngles(X, Y, Z, GLXMatrices^, True);
  Result := Round(Degrees(X));
end;

{*
  Returns the compass angle in radians. Height is found using EulerAngles + Math. VERY ACCURATE!
  NOTE: This function was previously disabled out. It works now and should be used!
*}
Function GL_CompassHeightRad: Single;
var
  X, Y, Z: Double;
begin
  glEulerAngles(X, Y, Z, GLXMatrices^, True);
  Result := X;
end;

{*
  Sets the height of the compass in degrees.
  Tolerance is the threshold of accuracy. 4 is a nice tolerance.
  My personal tests show that the lowest angle is: 8 and the highest is 65.
  The LOWEST possible value you can specify is: 0  - according to my tests at 4 tolerance.
  The HIGHEST possible value you can specify is: 69 - according to my tests at 4 tolerance.
  NOTE: This function was previously disabled out. It works now and should be used!
*}
Function GL_MakeCompassHeight(Height: Integer; Tolerance: Integer = 4): Boolean;
var
  T: Timer;
  Up: Boolean;
  CurrentHeight: Integer;
Begin
  CurrentHeight := GL_CompassHeightDeg;
  If ((CurrentHeight < 0) or (Not GL_LoggedIn)) Then
    Exit;

  T.Start();
  If (Height <= 5) Then Height := RandomRange(5, 7);

  While((abs(CurrentHeight - Height) > Tolerance) and (T.TimeElapsed() < 10000)) do
  Begin
    Up := Height > CurrentHeight;
    If (Up) Then
      KeyDown(VK_UP)
    Else
      KeyDown(VK_DOWN);

    CurrentHeight := GL_CompassHeightDeg;
    Result := abs(CurrentHeight - Height) <= Tolerance;
    If (Result) Then
    Begin
      If (Up) Then
        KeyUp(VK_UP)
      Else
        KeyUp(VK_DOWN);
      Break;
    End;
    Wait(RandomRange(5, 10));
  End;

  If (Up) Then
    KeyUp(VK_UP)
  Else
    KeyUp(VK_DOWN);
  Result := Abs(CurrentHeight - Height) <= Tolerance;
End;

{*
  Returns the current loaded map as a bitmap with outline stripped.

  Developer Notes:
    Original Size:        512x512
    Returned Bitmap Size: 408x408
*}
Function GL_MapToImage: Integer;
var
  Ptr: Pointer;
  Chunk: Integer = 52;
  Width, Height, Offset: Integer;
  X, Y: Array[0..3] of Single;
  Bmp: TGraphics;
begin
  Width := 512;
  Height := 512;
  Offset := Width * Chunk * (sizeof(byte) * 4) + (Chunk * (sizeof(byte) * 4));
  Bmp.Create(Width, Height - (2 * Chunk), UInt32(GLXMap(Width, Height, X, Y) + Offset));
  Result := CreateMirroredBitmapEx(Bmp.GetInternalBitmap().GetIndex, MirrorHeight);
  SetBitmapSize(Result, 512 - (2 * Chunk), 512 - (2 * Chunk));
  Bmp.Free();
end;

{*
  Returns the current loaded map as a bitmap.

  Developer Notes:
    Returned Bitmap Size:  512x512
*}
Function GL_MapToImageEx: Integer;
var
  X, Y: Array[0..3] of Single;
  Bmp: TGraphics;
  W, H: Integer;
begin
  W := 512;
  H := 512;
  Bmp.Create(W, H, UInt32(GLXMap(W, H, X, Y)));
  Result := CreateMirroredBitmapEx(Bmp.GetInternalBitmap().GetIndex, MirrorHeight);
  Bmp.Free();
end;