Universal_Miner - no-smart.simba

program Universal_Miner_V040;
{$I SRL/OSR.simba}
{$I SRL/utils/rsclient.simba}
{$I SRL/utils/rsclient_overrides.simba}
{$I SRL/utils/slackdebug.simba}
{$I WindowOverlay/WindowOverlay.simba}
{$I RSWalker/Walker.simba}
{$H-}{$R+}{$X+}
{==============================================================================]
| Universal Miner ™
|
| Steps to use:
|   1. For longer runs you need to declare login details bellow
|   2. Start the script at your min.ing site, and run setup.
[==============================================================================}
type
  EDropStyle = (dsRegular, dsIntense, dsAdaptive);

const
  LOGIN_NAME   = '';
  LOGIN_PASS   = '';
  RS_WORLD     = -1;          // preferred world
  IS_MEMBER    = False;       //
  SHIFT_DROP   = True;        // use shift to drop
  INTENSE_DROP = dsAdaptive;  // dsIntense, and dsAdaptive = mine some drop some (can be higher XP)

  INTENSITY_LEVEL = 80;       // min energy before intensive dropping is disabled
  CHANCE_OF_MISS  = 0;        // % fraction chance of clicking a nearby point;
  MINING_TIMEOUT  = 35000;    // max time it takes to mine a rock

  SLEEP_AT_CLOCK  = '07:00';  // when does the bot go to bed?


  // --- Probably dont wanna touch bellow here ---------------------------------
  CONFIG_PATH = IncludePath+'Universal_Miner/';
  CONFIG_FILE = 'config.cfg';
  CONFIG_MAP  = 'map.png';

type
  TClickHistory = record
    Data: TRectArray;
  end;

  TStatistics = record
    Trips: Int32;
    StartInfo: TSkillInfo;
    CurrLvl: Int32;
    Count: Int32;
    PrcToNextLvl: Int32;
    Gains,Rem,CurrXP:Double;
    XPPerOre: Int32;
    DismissedRandoms: Int32;
    Isset_XPPerOre: Boolean;
  end;

  TMiner = record
    ConfigPath: String;

    StartTime: Int64;
    QuickDeposit: Boolean;
    BotStats: TStatistics;
    StatsDebugTick: Int64;
    StatsDebugArea: TBox;

    RockSpots,  BankSpots: TPointArray;
    RockColors, BankColors: array of TCTS2Color;
    BankPath: TPointArray;

    Offset: Vector2;

    ClickOrder: TClickHistory;
    FailCount: Int32;

    Antiban, StockAB: TAntiban;
  end;


var
  Bot: TMiner;
  RSW: TRSWalker;

  {$ifdecl TWindowOverlay}
  Overlay: TWindowOverlay;
  Debug: TMufasaBitmap;
  {$endif}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// UTILITY FUNCTIONS

function GetTimeRunning(): UInt32; override;
begin
  if Bot.StartTime = 0 then Exit(0);
  Result := GetTickCount() - Bot.StartTime;
end;

function StrToTPA(s:String): TPointArray;
var
  i: Int32;
  Arr: TExtArray;
begin
  Arr := s.ExtractNumbers();
  SetLength(Result, Length(Arr) div 2);
  for i:=0 to High(Result) do
  begin
    Result[i].x := Trunc(Arr[i*2]);
    Result[i].y := Trunc(Arr[i*2+1]);
  end;
end;

function StrToCTS2(s:String): array of TCTS2Color;
var
  i: Int32;
  Arr: TExtArray;
begin
  Arr := s.ExtractNumbers();
  SetLength(Result, Length(Arr) div 4);
  for i:=0 to High(Result) do
  begin
    Result[i].Color     := Trunc(Arr[i*4]);
    Result[i].Tolerance := Trunc(Arr[i*4+1]);
    Result[i].HueMod    := Arr[i*4+2];
    Result[i].SatMod    := Arr[i*4+3];
  end;
end;

procedure TMouse.Move(P: TPoint); override;
var
  dist: Double;
  q: TPoint;
  maxSpeed := Random(20,22);
  minSpeed := Random(4,6);
begin
  q := Self.GetPosition;
  dist := Hypot(q.x-p.x, q.y-p.y);
  self.Speed := Trunc(minSpeed + (maxSpeed-minSpeed) * Power(dist / 1000, 1/2));
  inherited;
end;


// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// MISC BOT FUNCTIONS

procedure TClickHistory.Push(x: TRectangle);
begin
  Insert(x, Self.Data, 0);
end;

function TClickHistory.Pop(): TRectangle;
begin
  if Length(Self.Data) < Length(Bot.RockSpots)  then
    Exit(Self.Data[High(Self.Data)]);
  Result := Self.Data[High(Self.Data)];
  SetLength(Self.Data, High(Self.Data));
end;


// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Extensions to TAntiban

procedure TAntiban.EnergyAdjustInterval(Base: TAntiban; Fact:Double);
var
  z,e: Double;
  i: Int32;
begin
  e := 1 - Self.EnergyLevel / 100;
  for i:=0 to High(Self.Tasks) do
  begin
    z := Base.Tasks[i].Interval;
    Self.Tasks[i].Interval := z-z*e*fact;
  end;
end;

procedure Wait(min, max:Double; weight:EWaitDir=wdMean); override;
var t:Double := GetTickCount();
begin
  inherited(min, max, weight);
  Bot.Antiban.WaitFatigue(GetTickCount() - t);
end;

procedure WaitEx(mean, dev:Double); override;
var t:Double := GetTickCount();
begin
  inherited(mean, dev);
  Bot.Antiban.WaitFatigue(GetTickCount() - t);
end;


// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// MINER

procedure TMiner.DeclarePlayers();
begin
  with Players.New()^ do
  begin
    LoginName := LOGIN_NAME;
    Password  := LOGIN_PASS;
    IsActive  := True;
    IsMember  := IS_MEMBER;
    World     := RS_WORLD;
  end;
  Players.SetCurrent(0);
end;

procedure TMiner.SetupAntiban();
var
  i:Int32;
  sum: Double;
begin
  StockAB.Init(SKILL_MINING);

  StockAB.AddTask([@Antiban.LoseFocus,         ONE_MINUTE*8,  0.20]);
  StockAB.AddTask([@Antiban.HoverPlayers,      ONE_MINUTE*10, 0.20]);
  StockAB.AddTask([@Antiban.CheckSkill,        ONE_MINUTE*13, 0.20]);
  StockAB.AddTask([@Antiban.CheckStats,        ONE_MINUTE*18, 0.20]);
  StockAB.AddTask([@Antiban.OpenRandomTab,     ONE_MINUTE*20, 0.20]);
  StockAB.AddTask([@Antiban.RandomCompassNESW, ONE_MINUTE*40, 0.25]);
  StockAB.AddTask([@Antiban.DoMiscStuff,       ONE_MINUTE*45, 0.25]);
  StockAB.AddTask([@Antiban.VeryShortBreak,    ONE_MINUTE*50, 0.25]);

  StockAB.AddBreak([2.0 * ONE_HOUR, 05 * ONE_MINUTE, 0.50, 0.33]);
  StockAB.AddBreak([4.0 * ONE_HOUR, 40 * ONE_MINUTE, 0.96, 0.20]);
  StockAB.AddBreak([16  * ONE_HOUR, 08 * ONE_HOUR,   0.99, 0.03]);

  Antiban := StockAB.Copy();
  with Antiban.Breaks[High(Antiban.Breaks)] do
    NextAtTime := Antiban.TimeRunningAtClock(SLEEP_AT_CLOCK, '00:25');

  for i:=0 to High(Antiban.Tasks) do
    sum += ONE_HOUR / Antiban.Tasks[i].Interval;
  WriteLn('Doing ',Round(sum,2),' antibans per hour');
end;

function TMiner.HasBanking(): Boolean;
begin
  Result := (Self.BankColors <> []) and (Self.BankPath <> []) and (Self.BankSpots <> []);
end;

procedure TMiner.DoAntiban();
var
  Id: Int32;
begin
  if Self.Antiban.DoBreak(Id) and (Id = Self.Antiban.GetSleepId()) then
  begin
    // Reset the sleeptimer after having performed a sleep
    // to about 07:30 / 7:30am +/- 25 min normal variation
    Self.Antiban.Breaks[Id].NextAtTime := Self.Antiban.TimeRunningAtClock(SLEEP_AT_CLOCK, '00:25');
  end;

  if Self.Antiban.DoAntiban(False) then
    Players.GetCurrent()^.Login();

  Antiban.EnergyAdjustInterval(Self.StockAB, 0.35);
end;

procedure TMiner.PostAction(CheckAntiban: Boolean = True);
begin
  WaitEx(500,70);
  if CheckAntiban then Self.DoAntiban;
end;

procedure TMiner.ProcessWhileWaiting();
var
  n,atNextLvl,atCurrLvl:Int32;
begin
  BotStats.Gains   := BotStats.count * BotStats.XPPerOre;
  BotStats.CurrXP  := BotStats.StartInfo.XP + BotStats.Gains;
  BotStats.CurrLvl := srl.GetLevelAtXP(Ceil(BotStats.CurrXP));
  atNextLvl := srl.GetXPAtLevel(BotStats.CurrLvl+1);
  atCurrLvl := srl.GetXPAtLevel(BotStats.CurrLvl);
  BotStats.Rem := atNextLvl - BotStats.CurrXP;
  BotStats.PrcToNextLvl := 100 - Round((BotStats.Rem / (atNextLvl - atCurrLvl)) * 100);

  if GetTickCount() - StatsDebugTick > 2000 then
  begin
    ClearDebug();
    WriteLn('+---| STATS |----------------------------------------');
    WriteLn('|- Script Runtime      : ', SRL.MsToTime(GetTimeRunning, Time_Short));
    WriteLn('|- Trips / Drops       : ', BotStats.Trips);
    WriteLn('|- Ores Mined          : ', BotStats.Count);
    WriteLn('|- Experience Gained   : ', BotStats.Gains);
    WriteLn('|- Experience Per Hour : ', Round(BotStats.Gains / (GetTimeRunning()/1000/60/60)) );
    WriteLn('+----------------------------------------------------');
    WriteLn('|- Current Map Offset  : ', Self.Offset);
    WriteLn('|- Dismissed Randoms   : ', BotStats.DismissedRandoms);
    WriteLn('|- Energy (profile)    : ', Round(Antiban.EnergyLevel,2), '%  (', Round(Antiban.Patience,3), ', ', Round(Antiban.Endurance,3),')');
    WriteLn('|- Time Since Break    : ', SRL.MsToTime(Antiban.TimeSinceBreak, Time_Short));
    WriteLn('|- Time Till Sleep     : ', SRL.MsToTime(Trunc(Antiban.Breaks[Antiban.GetSleepId].NextAtTime - Antiban.TimeRunning), Time_Short));
    WriteLn('+----------------------------------------------------');

    {$ifdecl TWindowOverlay}
    StatsDebugArea := Debug.DrawSkillReport([288,3], clProgBrown, Trunc(BotStats.CurrXP), Trunc(BotStats.Gains), BotStats.Count, 'Mining');
    {$ENDIF}

    StatsDebugTick := GetTickCount();
  end;
  Self.DoAntiban;
end;

function TMiner.CountColors(R: TRectangle; Colors: array of TCTS2Color; Estimate:Boolean=True): Int32;
var
  TPA: TPointArray;
  i, count: Int32;
begin
  for i:=0 to High(Colors) do
  begin
    count := srl.FindColors(TPA, Colors[i], R.Bounds);
    if not Estimate then
      count := Length(R.Filter(TPA));
    Result += Count;
  end;
end;

function TMiner.Find(Locations: TPointArray): TRectArray;
var
  i: Int32;
  me: TPoint;
  rect: TRectangle;
begin
  me := RSW.GetMyPos();

  for i:=0 to High(Locations) do
  begin
    rect := RSW.GetTileMSEx(me, Locations[i], Offset.X, Offset.Y, 1).Expand(-2);
    if MainScreen.GetBounds.Contains(rect.Bounds) then
      Result += rect;
  end;

  if (Length(Result) = 0) then
  begin
    if (Self.FailCount in [2,6]) then
      Minimap.RandomCompass(0,359)
    else if (Self.FailCount = 7) then
    begin
      WriteLn('Trying to recover from failure');
      Logout.ClickLogout();
      Wait(5000,30000,wdLeft);
      Players.GetCurrent^.Login();
      MainScreen.SetAngle(True);
      WaitEx(500,150);
    end else if (Self.FailCount > 10) then
      TerminateScript('Not close enough to objects: ('+ ToStr(me.x) +','+ToStr(me.y)+') -> '+ ToStr(locations));

    Inc(Self.FailCount);
    WaitEx(1600,450);
  end else
    Self.FailCount := 0;
end;

procedure TMiner.SetBestOffset(Locations: TPointArray; Colors:array of TCTS2Color);
var
  i: Int32;
  x,y,sum, best: Double;
  rect: TRectangle;
  me: TPoint;
begin
  me := RSW.GetMyPos();
  x := -1.8;
  while (x <= 1.8) do begin
    y := -1.8;
    while (y <= 1.8) do begin
      sum := 0;
      for i:=0 to High(Locations) do
      begin
        rect := RSW.GetTileMSEx(me, Locations[i], X,Y, 1);
        if MainScreen.GetBounds.Contains(rect.Bounds) then
          sum += Self.CountColors(rect, Colors+CTS2(5263446,16), False);
      end;

      if sum > best then
      begin
        best := sum;
        Self.Offset := [x,y];
      end;
      y += 0.2;
    end;
    x += 0.2;
  end;
end;


function TMiner.DoWork(): Boolean;
var
  i: Int32;
  T: TCountDown;
  TRA: TRectArray;
  next: TRectangle;
  tmpCurrXP, invCount: Int32;

  function MaybeMiss(): Boolean;
  var
    R: TRectangle;
  begin
    Result := True;
    if Random() <= CHANCE_OF_MISS then
    begin
      R := Minimap.PointToMsRect(Point(MM2MS.MMCX+Random(-6,6), MM2MS.MMCY+Random(-6,6)));
      Mouse.Move(R, True);
      WaitEx(65,10);
      if MainScreen.IsUpText(['Walk here', 'Mine', 'Rocks']) then
        Exit();
      Result := False;
    end;
  end;

  function ClickRock(rect: TRectangle): Int8;
  begin
    mouse.Move(rect, Random(10) = 0);
    WaitEx(65,10);
    if not Mainscreen.IsUpText(['Mine', 'Rocks']) then
      Exit(1);

    if (not MaybeMiss()) then
      Exit(0);

    if (Random() <= 0.05) and ChooseOption.Select('Mine Rocks') then
      ClickOrder.Push(TRA[i])
    else if Mouse.Click(ctRed) then
    begin
      ClickOrder.Push(TRA[i]);
      for 6 to Round(srl.TruncatedGauss(0,12)) do
      begin
        Mouse.Click(mouse_Left);
        WaitEx(65,10);
      end;
    end else
    begin
      Wait(400,7000,wdLeft);
      Self.DoAntiban;
      Antiban.WaitFatigue(Random(1500,3000), 0.6);
      Exit(0);
    end;

    WaitEx(300,60);
    Result := 2;
  end;

begin
  {$ifdecl TWindowOverlay}
  Debug.ClearAllBut(Self.StatsDebugArea);
  {$endif}

  invCount := Inventory.Count;
  TRA := Self.Find(self.RockSpots);

  {$ifdecl TWindowOverlay}
  for i:=0 to High(TRA) do
    Debug.DrawRect(TRA[i], 255);
  {$endif}

  if (Self.BotStats.StartInfo = []) and (Self.BotStats.XPPerOre = 0) then
  begin
    Self.BotStats.StartInfo := Stats.GetSkillInfo(SKILL_MINING);
    Self.BotStats.XPPerOre  := BotStats.StartInfo.XP;
  end;

  for i:=0 to High(TRA) do
  begin
    if Self.CountColors(TRA[i], Self.RockColors) < 100 then
      Continue;

    Antiban.WaitFatigue(Random(700,1200), 0.5);
    case ClickRock(TRA[i]) of
      0: Exit;
      1: Continue;
      2: Minimap.WaitPlayerMoving(False);
    end;

    next := ClickOrder.Pop();
    if (Self.Antiban.EnergyLevel > 40) or (Random() < 0.05) then
    begin
      if(Random() > 0.05) then
        Mouse.Move(next, Random() < 0.1)
      else if(Random() < 0.05) then
      begin
        Mouse.Move(srl.DefaultClientBounds, True, rndRandom);
        Antiban.WaitFatigue(5000);
      end;
    end;

    TRA := Find(self.RockSpots); // update the TRA in case we moved
    T.Init(Trunc(srl.NormalRange(MINING_TIMEOUT, MINING_TIMEOUT*1.25)));
    while (not T.IsFinished) and (Self.CountColors(TRA[i], Self.RockColors) > 100) do
    begin
      if(Chatbox.GotLevelUp()) then
        if(Random(9) = 0) then
          Chatbox.HandleLevelUp()
        else
          Break;

      if 'inventory is too full' in Chatbox.GetNotification() then
        Break;

      Self.ProcessWhileWaiting();
      Wait(30);
    end;

    if (Inventory.Count > invCount) then
    begin
      Inc(Self.BotStats.Count);
      if (not Self.BotStats.Isset_XPPerOre) then //XXXXXXXXXXXX
      begin
        Self.BotStats.XPPerOre := Stats.GetSkillInfo(SKILL_MINING).XP - Self.BotStats.XPPerOre;
        Self.BotStats.Isset_XPPerOre := Self.BotStats.XPPerOre > 0;
      end;
    end;

    Exit(True);
  end;
end;


procedure TMiner.DoBanking();
  function OpenBank(): Boolean;
  var Rect: TRectangle;
  begin
    for 0 to 3 do begin
      for Rect in Find(self.BankSpots) do
        if (Self.CountColors(Rect, Self.BankColors) > 100) and
           BankScreen.OpenAt(srl.RandomPoint(Rect.Mean, Trunc(Rect.Radius))) then
          Exit(True);
      Wait(800,1300);
    end;
  end;

  function BankInventory(): Boolean;
  var
    slots: TIntArray;
    t: TCountDown;
  begin
    if Self.QuickDeposit then
      Exit(BankScreen.DepositAll);

    slots := Inventory.GetUsedSlots();
    slots.Remove(0); //reserved
    while Length(slots) > 0 do
    begin
      Inventory.MouseSlot(slots[0]);
      ChooseOption.Select('Deposit-All');
      t.Init(2000);
      while Inventory.IsSlotUsed(slots[0]) and (not t.IsFinished) do
        WaitEx(90,10);

      slots := Inventory.GetUsedSlots();
      slots.Remove(0);
    end;
    Wait(1, 1200, wdLeft);
    Result := not Inventory.IsFull();

    if Inventory.Count = 0 then
      Self.QuickDeposit := True;
  end;

  function Walk(path: TPointArray): Boolean;
  begin
    for 0 to 2 do
      if RSW.WalkPath(Path) then
        Exit(True)
      else
        Wait(800, 3200, wdRight);
  end;

begin
  {$ifdecl TWindowOverlay}
  Debug.ClearAllBut(Self.StatsDebugArea);
  {$endif}

  if(not Walk(self.BankPath)) then
    TerminateScript('Failed to walk path [1]');
  Self.DoAntiban;

  if(not OpenBank()) then
    TerminateScript('Failed to open bank');
  PostAction(False);

  if(not BankInventory()) then
    TerminateScript('Failed to deposit items');
  PostAction;

  if(not Walk(self.BankPath.Reversed)) then
    TerminateScript('Failed to walk path [2]');
  Self.DoAntiban;
end;


procedure TMiner.IntenseDrop(Test: function: Boolean of Object);
var
  p: TPoint;
  Slots: TIntArray;
  n: Int32 = 3;
begin
  if Test() then Exit;

  if Random(5) = 0 then
    n := Random(2,4);

  p := Mouse.GetPosition();
  Slots := Inventory.GetUsedSlots();
  if (Length(Slots) >= 3)then
  begin
    if(not Self.QuickDeposit) then Slots.Remove(0);

    SetLength(Slots, Min(Length(Slots), n));
    Inventory.DropItems(Inventory.ErrorPattern(Slots,2));
    Mouse.Move(p,20);
  end;
end;

procedure TMiner.DropInventory();
begin
  if Self.QuickDeposit then
    Inventory.DropItems(Inventory.ErrorPattern())
  else
    Inventory.DropItemsExcept([0], Inventory.ErrorPattern());
end;


procedure TMiner.Run();
var
  loc: TPoint;
  timer: TCountDown;

  procedure TryDropWhileMining();
  begin
    if (not HasBanking) and (INTENSE_DROP in [dsIntense,dsAdaptive])  then
    begin
      if (INTENSE_DROP = dsIntense) then
        Self.IntenseDrop(@Self.DoWork)
      else if (INTENSE_DROP = dsAdaptive) and (Antiban.EnergyLevel > INTENSITY_LEVEL) then
        Self.IntenseDrop(@Self.DoWork);
    end;
  end;

begin
  Self.StartTime := GetTickCount();
  MainScreen.SetAngle(True);

  if Inventory.Count = 0 then
    Self.QuickDeposit := True;

  if Self.HasBanking() then
  begin
    loc := RSW.GetMyPos();
    if (Distance(loc, self.BankPath[high(self.BankPath)]) < Distance(loc, self.BankPath[0])) and
       (not RSW.WalkPath(self.BankPath.Reversed)) then
      TerminateScript('Failed to walk from bank on startup');
  end;

  // --------- bot loop
  repeat
    // handle inventory
    if (Random(5000) <> 0) and Inventory.IsFull() then
    begin
      if HasBanking then Self.DoBanking()
      else               Self.DropInventory();
      Inc(BotStats.Trips);
    end;

    // tweak coordinates for our rocks
    if timer.IsFinished() then
    begin
      Self.SetBestOffset(Self.RockSpots, Self.RockColors);
      timer.Init(ONE_MINUTE);
    end;

    // do some mining
    if Self.DoWork() then
    begin
      TryDropWhileMining();
      Self.DoAntiban;
    end else
      Players.GetCurrent()^.Login();

    Wait(1);
  until False;
end;

procedure TMiner.Init();
const H = 0.5; O = 1;
begin
  {$ifdecl TWindowOverlay}
  Overlay := TWindowOverlay.Create();
  Overlay.PaintInterval(100);
  Debug := Overlay.ToMufasaBitmap();
  {$endif}

  self.DeclarePlayers();
  Self.SetupAntiban();

  Mouse.Speed := 10;
  Inventory.ShiftDrop := SHIFT_DROP;
  TerminateScript;
  Players.GetCurrent()^.Login();
end;

procedure TMiner.Setup();
  function LoadConfig(): Boolean;
  begin
    if not FileExists(ConfigPath+CONFIG_FILE) then
      Exit(False);

    BankPath   := StrToTPA (ReadINI('settings', 'BankPath',   ConfigPath+CONFIG_FILE));
    RockSpots  := StrToTPA (ReadINI('settings', 'RockSpots',  ConfigPath+CONFIG_FILE));
    RockColors := StrToCTS2(ReadINI('settings', 'RockColors', ConfigPath+CONFIG_FILE));
    BankSpots  := StrToTPA (ReadINI('settings', 'BankSpots',  ConfigPath+CONFIG_FILE));
    BankColors := StrToCTS2(ReadINI('settings', 'BankColors', ConfigPath+CONFIG_FILE));
    Result := True;
  end;
begin
  InputQuery('Load config','Name of config', Self.ConfigPath);
  Self.ConfigPath := CONFIG_PATH + Self.ConfigPath + '/';

  if not LoadConfig() then
    TerminateScript('Unknown config');

  RSClient.SetFocus();
end;

procedure TMiner.Free();
begin
  RSW.Free();
  {$ifdecl TWindowOverlay}
  Overlay.Free();
  Debug.Free();
  {$endif}
end;


begin
  srl.SetupForClient('',[soDebugAntiban]);
  Bot.Setup();
  Bot.Init();
  AddOnTerminate(@Bot.Free);

  RSW.Init(Bot.ConfigPath+CONFIG_MAP);
  RSW.MemScanEnabled := False;

  AddOnTerminate(@RSW.Free);

  Bot.Run();
end.