wasp_offerer.simba

{$DEFINE SCRIPT_ID := '4e797d2f-966c-4ef2-bba5-febe1c1b7284'}
{$DEFINE SCRIPT_REVISION := '30'}
{$DEFINE SCRIPT_GUI}
{$I SRL-T/osr.simba}
{$I WaspLib/osr.simba}

type
  ERSRemains = (
    FIENDISH_ASHES, VILE_ASHES, MALICIOUS_ASHES, ABYSSAL_ASHES, INFERNAL_ASHES,

    BABY_BONES, WYRM_BONES, DRAGON_BONES, WYVERN_BONES, DRAKE_BONES, LAVA_BONES,
    HYDRA_BONES, DAGANNOTH_BONES, SUPERIOR_BONES
  );

var
  CurrentBank: EBankChunk = EBankChunk.GRAND_EXCHANGE;
  CurrentRemains: ERSRemains := ERSRemains.MALICIOUS_ASHES;

type
  EOffererState = (
    OPEN_BANK,
    WITHDRAW_WRATH,
    WITHDRAW_ALT,
    WITHDRAW_REMAINS,

    OPEN_COLLECT,
    HANDLE_COLLECT,

    CLOSE_INTERFACE,

    OPEN_MAGIC,
    CAST_SPELL,
    WAIT_STATE,
    HANDLE_LEVEL,

    NO_RUNES,
    OUT_OF_SUPPLIES,
    END_SCRIPT
  );

  TRemainOfferer = record(TBaseBankScript)
    State: EOffererState;

    OfferSpell: ERSSpell;
    Remains, WrathRune, AltRune: TRSBankItem;

    RemainsLeft: Int32;
    SpellCooldown, NoRunes: Boolean;
  end;

procedure TRemainOfferer.SetupSpell();
begin
  Self.WrathRune := TRSBankItem.Setup('Wrath rune');

  case CurrentRemains of
    ERSRemains.FIENDISH_ASHES..ERSRemains.INFERNAL_ASHES:
      begin
        Self.OfferSpell := ERSSpell.DEMONIC_OFFERING;
        Self.AltRune := TRSBankItem.Setup('Soul rune');
      end;
    ERSRemains.BABY_BONES..ERSRemains.SUPERIOR_BONES:
      begin
        Self.OfferSpell := ERSSpell.SINISTER_OFFERING;
        Self.AltRune := TRSBankItem.Setup('Blood rune');
      end;
  end;
end;

procedure TRemainOfferer.SetupRemains();
begin
  case CurrentRemains of
    ERSRemains.FIENDISH_ASHES:  Self.Remains := TRSBankItem.Setup('Fiendish ashes');
    ERSRemains.VILE_ASHES:      Self.Remains := TRSBankItem.Setup('Vile ashes');
    ERSRemains.MALICIOUS_ASHES: Self.Remains := TRSBankItem.Setup('Malicious ashes');
    ERSRemains.ABYSSAL_ASHES:   Self.Remains := TRSBankItem.Setup('Abyssal ashes');
    ERSRemains.INFERNAL_ASHES:  Self.Remains := TRSBankItem.Setup('Infernal ashes');
    ERSRemains.BABY_BONES:      Self.Remains := TRSBankItem.Setup('Babydragon bones');
    ERSRemains.WYRM_BONES:      Self.Remains := TRSBankItem.Setup('Wyrm bones');
    ERSRemains.DRAGON_BONES:    Self.Remains := TRSBankItem.Setup('Dragon bones');
    ERSRemains.WYVERN_BONES:    Self.Remains := TRSBankItem.Setup('Wyvern bones');
    ERSRemains.DRAKE_BONES:     Self.Remains := TRSBankItem.Setup('Drake bones');
    ERSRemains.LAVA_BONES:      Self.Remains := TRSBankItem.Setup('Lava dragon bones');
    ERSRemains.HYDRA_BONES:     Self.Remains := TRSBankItem.Setup('Hydra bones');
    ERSRemains.DAGANNOTH_BONES: Self.Remains := TRSBankItem.Setup('Dagannoth bones');
    ERSRemains.SUPERIOR_BONES:  Self.Remains := TRSBankItem.Setup('Superior dragon bones');
  end;

  Self.ActionProfit -= ItemData.GetAverage(Self.Remains.Item) * 3;
  Self.ActionProfit -= ItemData.GetAverage(Self.WrathRune.Item);
  Self.ActionProfit -= ItemData.GetAverage(Self.AltRune.Item);
end;

procedure TRemainOfferer.Init(maxActions: UInt32; maxTime: UInt64); override;
begin
  Antiban.Skills := [ERSSkill.PRAYER, ERSSkill.TOTAL];
  Antiban.MinZoom := 10;
  Antiban.MaxZoom := 90;

  inherited;

  Map.SetupChunk(CurrentBank.Get());
  Objects.Setup(Map.Objects(), @Map.Walker);
  NPCs.Setup(Map.NPCs(), @Map.Walker);

  Self.SetupSpell();
  Self.SetupRemains();
end;


function TRemainOfferer.CanCast(): Boolean;
begin
  if Inventory.IsOpen() then
    Result := Inventory.ContainsAll([Self.WrathRune.Item, Self.AltRune.Item])
  else if not Self.SpellCooldown and Magic.IsOpen() then
    Result := WaitUntil(Magic.CanActivate(Self.OfferSpell), 300, 7000)
  else
    Result := True;
end;

function TRemainOfferer.CastSpell(): Boolean;
begin
  Result := Magic.CastSpell(Self.OfferSpell);

  if Result then
    WL.Activity.Restart();

  Self.SpellCooldown := True;

  Self.RemainsLeft -= 3;
  Self.TotalActions += 1;
  Self.TotalProfit := Self.TotalActions * Self.ActionProfit;

end;

procedure TRemainOfferer.WaitCoolDown();
begin
  case Random(0, 500) of
    0:
      begin
        if not WLSettings.Antiban.Chat then Exit
        else if (Random(20) <= 17) then Antiban.RandomChatButton()
        else Antiban.RandomChatButtonState();
      end;

    1..5:
      begin
        if not WLSettings.Antiban.Camera then Exit
        else if (Random(10) <= 3) then Antiban.RandomRotate();
      end;

    6..10:
      begin
        if not WLSettings.Antiban.Mouse then Exit
        else if (Random(10) <= 3) then Antiban.RandomRightClick()
        else Antiban.SmallRandomMouse();
      end;

    10, 14:
      begin
        if not WLSettings.Antiban.GameTabs then Exit
        else if (Random(10) <= 9) then Antiban.RandomTab()
        else Antiban.CheckCharges();
      end;
    else
      begin
        Self.SpellCooldown := not WaitUntil(Magic.CanActivate(Self.OfferSpell), 300, 7000);

        if Chat.LeveledUp() then
          Exit;

        if SpellCooldown then
        begin
          Inventory.Open();
          if Magic.Open() then
            Self.NoRunes := not WaitUntil(Magic.CanActivate(Self.OfferSpell), 300, 7000);
        end;

        if Self.NoRunes then
          SaveScreenshot('offerer' + DIRECTORYSEPARATOR + 'norunes');
        Wait(0, 2400, EWaitDir.wdLeft);
      end;
  end;
end;


function TRemainOfferer.GetState(): EOffererState;
begin
  if WL.Activity.IsFinished() then
    Exit(EOffererState.END_SCRIPT);

  if Self.NoRunes then
    Exit(EOffererState.NO_RUNES);

  if RSInterface.IsOpen() then
  begin
    Self.SpellCooldown := False;

    if Bank.IsOpen() then
    begin
      if not Inventory.ContainsItem(Self.WrathRune.Item) then
        Exit(EOffererState.WITHDRAW_WRATH);
      if not Inventory.ContainsItem(Self.AltRune.Item) then
        Exit(EOffererState.WITHDRAW_ALT);
      if (Inventory.CountItem(Self.Remains.Item) < 3) then
        Exit(EOffererState.WITHDRAW_REMAINS);

      Self.RemainsLeft := Inventory.CountItem(Self.Remains.Item);
    end;

    if CollectBox.IsOpen() and not Self.CollectEmpty then
      Exit(EOffererState.HANDLE_COLLECT);

    Exit(EOffererState.CLOSE_INTERFACE);
  end;

  if Chat.LeveledUp() then
    Exit(EOffererState.HANDLE_LEVEL);

  if (Self.RemainsLeft < 3) or not Self.CanCast() then
  begin
    if not Self.BankEmpty then
      Exit(EOffererState.OPEN_BANK);
    if not Self.CollectEmpty then
      Exit(EOffererState.OPEN_COLLECT);

    Exit(EOffererState.OUT_OF_SUPPLIES);
  end;

  if not Self.SpellCooldown then
  begin
    if Magic.IsOpen() then
    begin
      if Magic.CanActivate(OfferSpell) then
        Exit(EOffererState.CAST_SPELL)

      if not Self.BankEmpty then
        Exit(EOffererState.OPEN_BANK);

      if not Self.CollectEmpty then
        Exit(EOffererState.OPEN_COLLECT);

      Exit(EOffererState.OUT_OF_SUPPLIES);
    end;

    Exit(EOffererState.OPEN_MAGIC);
  end;

  Exit(EOffererState.WAIT_STATE);
end;

procedure TRemainOfferer.Run(maxActions: UInt32; maxTime: UInt64);
begin
  Self.Init(maxActions, maxTime);

  repeat
    Self.State := Self.GetState();
    Self.SetAction(ToStr(Self.State));

    case Self.State of
      EOffererState.OPEN_BANK:        Banks.WalkOpen();
      EOffererState.WITHDRAW_WRATH:   Self.Withdraw(Self.WrathRune);
      EOffererState.WITHDRAW_ALT:     Self.Withdraw(Self.AltRune);
      EOffererState.WITHDRAW_REMAINS: Self.Withdraw(Self.Remains);

      EOffererState.OPEN_COLLECT:   CollectBoxes.WalkOpen();
      EOffererState.HANDLE_COLLECT: Self.HandleCollectBox([Self.WrathRune.Item, Self.AltRune.Item, Self.Remains.Item]);

      EOffererState.CLOSE_INTERFACE: RSInterface.Close();

      EOffererState.OPEN_MAGIC: Magic.Open();
      EOffererState.CAST_SPELL: Self.CastSpell();
      EOffererState.WAIT_STATE: Self.WaitCoolDown();
      EOffererState.HANDLE_LEVEL: Chat.HandleLevelUp();

      EOffererState.NO_RUNES, EOffererState.OUT_OF_SUPPLIES,
      EOffererState.END_SCRIPT: Break;
    end;

    Self.DoAntiban();
  until Self.ShouldStop();
end;

var
  RemainOfferer: TRemainOfferer;

{$IFDEF SCRIPT_GUI}
type
  TOffererConfig = record(TScriptForm)
    BankSelector, RemainSelector: TLabeledCombobox;
    Config: TConfigJSON;
  end;

procedure TOffererConfig.StartScript(sender: TObject); override;
begin
  CurrentBank := EBankChunk(Self.BankSelector.GetItemIndex());
  CurrentRemains := ERSRemains(Self.RemainSelector.GetItemIndex());

  Self.Config.Put('remains', Ord(CurrentRemains));

  inherited;
end;

procedure TOffererConfig.Run(); override;
var
  tab: TTabSheet;
begin
  Self.Setup('Wasp Offerer');
  Self.Config.Setup('wasp-offerer');

  if Self.Config.Has('remains') then
    CurrentRemains := ERSRemains(Self.Config.GetInt('remains'));

  Self.Start.setOnClick(@Self.StartScript);

  Self.AddTab('Script Settings');
  tab := Self.Tabs[High(Self.Tabs)];

  Self.CreateAccountManager(tab);

  Self.BankSelector := Self.CreateBankSettingsV2(tab, [50, 200], [0,0]);
  Self.RemainSelector.Create(tab, 'Remains:', 'Pick your type of remains.', [0, 30], [0,0], [Self.BankSelector.GetLeft(), Self.BankSelector.GetBottom()], True);
  Self.RemainSelector.AddItemArray([
    'Fiendish ashes', 'Vile ashes', 'Malicious ashes', 'Abyssal ashes',
    'Infernal ashes', 'Babydragon bones', 'Wyrm bones', 'Dragon bones',
    'Wyvern bones', 'Drake bones', 'Lava dragon bones', 'Hydra bones',
    'Dagannoth bones', 'Superior dragon bones'
  ]);
  Self.RemainSelector.SetItemIndex(Ord(CurrentRemains));

  Self.CreateAntibanManager();
  Self.CreateWaspLibSettings();
  Self.CreateAPISettings();

  inherited;
end;

var
  OffererConfig: TOffererConfig;
{$ENDIF}

begin
  {$IFDEF SCRIPT_GUI}
  OffererConfig.Run();
  {$ENDIF}
  RemainOfferer.Run(WLSettings.MaxActions, WLSettings.MaxTime);
end.