wasp_ardougne_knights.simba

{$DEFINE SCRIPT_ID := '0fb23f9b-3bc2-41cd-8670-3fec0eb256f1'}
{$DEFINE SCRIPT_REVISION := '58'}
{$DEFINE SCRIPT_GUI}
{$I SRL-T/osr.simba}
{$I WaspLib/osr.simba}

var
  DiaryLevel: Int32 = 4;
  FoodAmount: Int32 := Random(16, 20);
  NeckAmount: Int32 := Random(3, 5);
  MinHealth: Int32 := Random(20, 40);

const
  BANK_POLYGON: TPointArray = [[5987, 3297], [6015, 3297], [6015, 3330], [5987, 3330]] ;

//Enum of script states. used in the GetState() function to decide what we got to do next.
type
  EThieverState = (
    OPEN_CHAT,
    CHANGE_CHAT_OFF,
    CHANGE_CHAT_FILTER,
    IS_UPSTAIRS,
    WALK_TO_BANK,

    OPEN_BANK,
    OPEN_COLLECT,
    DEPOSIT_ITEMS,
    WITHDRAW_NECK,
    DEPOSIT_NECK,
    WITHDRAW_FOOD,
    FIX_INVENTORY,
    HANDLE_COLLECT,
    CLOSE_INTERFACE,

    EQUIP_ROGUE,
    CHECK_NECK,
    EQUIP_NECK,
    EAT_FOOD,

    FIND_KNIGHT,
    PICKPOCKET,
    OPEN_POUCH,

    CLOSE_CONTEXT,

    WAIT_STATE,

    OUT_OF_SUPPLIES,
    END_SCRIPT,
    CAST_SHADOW_VEIL
  );

//script record, all variables of the script should go here.
  TKnightsThiever = record(TBaseBankScript)
    //init variables (to be set while the script is initiates)
    State: EThieverState;

    Knight: TRSNPC;

    CoinPouch: TRSItem;
    Necklace: TRSBankItem;

    LootArray: TRSItemArray;
    KeepArray: TRSItemArray;
    BankArray: TRSItemArray;
    RogueEquipment: TRSItemArray;

    NeckTimer, ShadowVeilTimer: TCountDown;

    //run variables (to be used while the script is running)
    HasNeck: Boolean;
    FreshNeck: Boolean;
    UseShadowVeil: Boolean;
    VeilAttempts: Int32;

    CoinPouchLimit: Int32;
    MaxHit: Int32;
    NextHeal: Int32;
    Pattern: Int32;
  end;


//Extra antiban specifically for this script.

procedure TAntiban.Setup(); override;
begin
  Self.Skills := [ERSSkill.THIEVING, ERSSkill.TOTAL];
  Self.MinZoom := 5;
  Self.MaxZoom := 50;

  inherited;
end;

procedure TKnightsThiever.CheckRogueEquipment();
var
  ProfitMultiplier: Double;
begin
  if Inventory.Open() then
  begin
    if Inventory.ContainsItem('Rogue mask') then
    begin
      ProfitMultiplier += 0.2;
      Self.RogueEquipment += 'Rogue mask';
    end;

    if Inventory.ContainsItem('Rogue top') then
    begin
      ProfitMultiplier += 0.2;
      Self.RogueEquipment += 'Rogue top';
    end;

    if Inventory.ContainsItem('Rogue trousers') then
    begin
      ProfitMultiplier += 0.2;
      Self.RogueEquipment += 'Rogue trousers';
    end;

    if Inventory.ContainsItem('Rogue gloves') then
    begin
      ProfitMultiplier += 0.2;
      Self.RogueEquipment += 'Rogue gloves';
    end;

    if Inventory.ContainsItem('Rogue boots') then
    begin
      ProfitMultiplier += 0.2;
      Self.RogueEquipment += 'Rogue boots';
    end;

    //This are not part of rogue equipment but are useful while thieving
    if Inventory.ContainsItem('Thieving cape') then
      Self.RogueEquipment += 'Thieving cape'
    else if Inventory.ContainsItem('Thieving cape(t)') then
      Self.RogueEquipment += 'Thieving cape(t)';

    //Lava staves for shadow veil spell
    if Inventory.ContainsItem('Lava battlestaff') then
      Self.RogueEquipment += 'Lava battlestaff'
    else if Inventory.ContainsItem('Mystic lava staff') then
      Self.RogueEquipment += 'Mystic lava staff'
    else if Inventory.ContainsItem(21200) then
      Self.RogueEquipment += 21200;
  end;

  if Equipment.Open() then
  begin
    if Equipment.ContainsItem('Rogue mask') then
    begin
      ProfitMultiplier += 0.2;
      Self.RogueEquipment += 'Rogue mask';
    end;

    if Equipment.ContainsItem('Rogue top') then
    begin
      ProfitMultiplier += 0.2;
      Self.RogueEquipment += 'Rogue top';
    end;

    if Equipment.ContainsItem('Rogue trousers') then
    begin
      ProfitMultiplier += 0.2;
      Self.RogueEquipment += 'Rogue trousers';
    end;

    if Equipment.ContainsItem('Rogue gloves') then
    begin
      ProfitMultiplier += 0.2;
      Self.RogueEquipment += 'Rogue gloves';
    end;

    if Equipment.ContainsItem('Rogue boots') then
    begin
      ProfitMultiplier += 0.2;
      Self.RogueEquipment += 'Rogue boots';
    end;


    //This are not part of rogue equipment but are useful while thieving
    if Equipment.ContainsItem('Thieving cape') then
      Self.RogueEquipment += 'Thieving cape'
    else if Equipment.ContainsItem('Thieving cape(t)') then
      Self.RogueEquipment += 'Thieving cape(t)';

    //Lava staves for shadow veil spell
    if Equipment.ContainsItem('Lava battlestaff') then
      Self.RogueEquipment += 'Lava battlestaff'
    else if Equipment.ContainsItem('Mystic lava staff') then
      Self.RogueEquipment += 'Mystic lava staff'
    else if Equipment.ContainsItem(21200) then
      Self.RogueEquipment += 21200;
  end;

  Self.ActionProfit += Round(Self.ActionProfit * ProfitMultiplier);
end;

procedure TKnightsThiever.SetupKnight();
var
  p: TPoint;
begin
  p := [6006, 3315];
  Self.Knight.SetupCoordinates([p]);
  Self.Knight.DotFilter.SetupBounds(BANK_POLYGON, True);
  Self.Knight.ShapeArray.SetShape([1, 1, 6]);
  Self.Knight.SetupUpText(['Knight', 'of', 'Ardougne']);
  Self.Knight.Finder.Colors += CTS2(10620793, 19, 0.22, 0.31);
end;

procedure TKnightsThiever.Init(maxActions: UInt32; maxTime: UInt64); override;
begin
  inherited;

  Self.RSW.SetupRegions([RSRegions.ARDOUGNE]);
  Self.SetupKnight();

  if DiaryLevel = 4 then
    DiaryLevel += 1;

  FoodHandler.Amount := FoodAmount;

  Self.CoinPouch := 'Coin pouch';
  Self.Necklace := TRSBankItem.Setup('Dodgy necklace', NeckAmount);
  Self.KeepArray := ['Coin pouch', 'Coins', 'Cosmic rune', 'Dodgy necklace'];
  Self.BankArray := ['Jug', 'Pie dish'];

  Self.MaxHit := 3;
  MinHealth := Max(Self.MaxHit, MinHealth);

  Self.ActionProfit := 50;

  Self.NeckTimer.Init(140000);

  if Antiban.BioDice() then
    Options.SetNPCAttackOption(ERSAttackOption.HIDDEN)
  else
    Options.SetNPCAttackOption(ERSAttackOption.ALWAYS_RIGHT_CLICK);
  Wait(5000);
  Self.CheckRogueEquipment();
  Self.HasNeck := Equipment.ContainsItem(Self.Necklace.Item);

  if Magic.Open() and Magic.ContainsSpell(ERSSpell.SHADOW_VEIL) then
  begin
    Self.UseShadowVeil := True;
    Magic.CastSpell(ERSSpell.SHADOW_VEIL);
    Self.ShadowVeilTimer.Init(1000 * Round(0.6 * Stats.GetLevel(ERSSkill.MAGIC)));
  end;

  if WLSettings.RemoteInput.HUDDebug then
    DebugMMDotArray += Self.Knight;

  XPBar.EarnedXP();
end;

function TKnightsThiever.CastShadowVeil(): Boolean;
begin
  if not Magic.Open() then
    Exit;

  if not Magic.CanActivate(ERSSpell.SHADOW_VEIL) then
  begin
    if Self.VeilAttempts > 2 then
    begin
      Self.DebugLn('Disabling shadow veil.');
      Self.UseShadowVeil := Result;
      Exit;
    end;

    Self.DebugLn('Shadow veil is not available yet.');
    Self.ShadowVeilTimer.Restart(Random(-5000, 5000));
    Self.VeilAttempts += 1;
    Exit;
  end;

  Result := Magic.CastSpell(ERSSpell.SHADOW_VEIL);
  Self.ShadowVeilTimer.Restart(Random(-5000, 5000));
  Self.VeilAttempts := 0;
end;

function TKnightsThiever.HasRogue(): Boolean;
begin
  Result := Inventory.ContainsAny(Self.RogueEquipment);
end;

function TKnightsThiever.EquipRogue(): Boolean;
var
  Item: TRSItem;
begin
  for Item in Self.RogueEquipment do
    if Inventory.ClickItem(Item) then
      Wait(200, 300);

  if Inventory.ClickItem(21200) then
    Wait(200, 300);

  Result := not Self.HasRogue() and not Inventory.ContainsItem('Lava battlestaff');
end;



function TKnightsThiever.HasSpace(): Boolean;
begin            //we need at least 2 spaces always.
  Result := (Inventory.CountEmptySlots() >= 2) or
            (Inventory.ContainsItem(Self.CoinPouch) and Inventory.ContainsItem('Coins')
             and not Inventory.ContainsAny(Self.BankArray));
end;


function TKnightsThiever.IsLowHP(): Boolean;
begin
  if Self.NextHeal < 1 then
  begin
    Self.NextHeal := MinHealth + Random(-Self.MaxHit, Self.MaxHit) * Antiban.GetUniqueInt(2, 0, 4);
    Self.NextHeal := EnsureRange(Self.NextHeal, Self.MaxHit, Round(Stats.GetLevel(ERSSkill.HITPOINTS) * 0.8));
  end;

  Result := Minimap.GetHPLevel() <= Self.NextHeal;
end;

function TKnightsThiever.IsPouchFull(): Boolean;
begin
  if Self.CoinPouchLimit < 1 then
    Self.CoinPouchLimit := SRL.TruncatedGauss(28 * DiaryLevel, 1);

  Result := Inventory.CountItemStack(Self.CoinPouch) >= Self.CoinPouchLimit;
end;


function TKnightsThiever.OpenCoinPouch(): Boolean;
var
  pouchCount: Int32;
begin
  pouchCount := Inventory.CountItemStack(Self.CoinPouch);
  if Inventory.ClickItem(Self.CoinPouch) then
  begin
    Wait(600);
    Result := WaitUntil(not Inventory.ContainsItem(Self.CoinPouch), 100, 2000);
  end;

  if Result then
  begin
    Self.CoinPouchLimit := SRL.TruncatedGauss(28 * DiaryLevel, 1);
    Self.TotalActions += pouchCount;
    Self.TotalProfit := Self.TotalActions * Self.ActionProfit;
    WL.Activity.Restart();
  end;
end;


function TKnightsThiever.CheckFailed(StartingHP: Int32): Boolean;
var
  HasHitSplat: Boolean;
begin
  HasHitSplat := MainScreen.FindHitsplats(MainScreen.GetPlayerBox()) <> [];

  Result := (Minimap.GetHPLevel() < StartingHP) or HasHitSplat;

  if Result then
  begin
    XPBar.EarnedXP();
    Self.OpenCoinPouch();
  end;
end;

function TKnightsThiever.NecklaceExpired(): Boolean;
begin
  Result := Chat.FindMessage('crumbles', [CHAT_COLOR_LIGHT_RED]);
  Self.HasNeck := not Result;
end;

function TKnightsThiever.Dodged(): Boolean;
begin
  Result := Chat.FindMessage('dodgy');
end;



function TKnightsThiever.Heal(): Boolean;
var
  oldHP, newHP, hpLevel: Int32;
begin
  newHP := Minimap.GetHPLevel();
  hpLevel := Stats.GetLevel(ERSSkill.HITPOINTS) - 1;
  repeat
    oldHP := newHP;
    if not Inventory.Consume(ERSConsumable.FOOD) then
      Exit;

    newHP := Minimap.GetHPLevel();
    Result := newHP > Random(oldHP, hpLevel);
  until Result;

  if Result then
    Self.NextHeal := 0; //This will be reset when TKnightsThiever.IsLowHP() is called.
end;

function TKnightsThiever.EquipNeck(): Boolean;
var
  slot: Int32;
begin
  Result := Inventory.FindItem(Self.Necklace.Item, slot);

  if Result then
  begin
    Inventory.ClickSlot(slot);
    WaitUntil(not Inventory.IsSlotUsed(slot), 300, 3000);
    Self.FreshNeck := True;
    Self.HasNeck := True;
  end;
end;

function TKnightsThiever.CheckNeck(): Boolean;
begin
  Result := Self.HasNeck := Equipment.ContainsItem(Self.Necklace.Item);

  Self.NeckTimer.Restart(Random(-30000, 60000));
end;


function TKnightsThiever.HoverKnight(): Boolean;
var
  t: TCountDown;
  TPA: TPointArray;
  ATPA: T2DPointArray;
  P: TPoint;
  B: TBox;
begin
  t.Init(1800);

  repeat
    SRL.FindColors(TPA, $00FFFF, MainScreen.Bounds());
    ATPA := TPA.Cluster(3, 1);
    ATPA.FilterDimensions(32, 10, 32, 10);
  until (ATPA <> []) or t.IsFinished();

  if ATPA <> [] then
  begin
    ATPA.SortByMiddle(MainScreen.GetPlayerBox().Middle());
    TPA := ATPA[0];
    P := TPA.Mean();
    P.X += MainScreen.NormalizeDistance(7);
    P.Y += MainScreen.NormalizeDistance(22);
    B := Box(P, MainScreen.NormalizeDistance(10), MainScreen.NormalizeDistance(14));

    if WLSettings.RemoteInput.HUDDebug then
    begin
      RSClient.Image().Clear();
      RSClient.Image().DrawBox(B, $FFFFFF);
    end;

    Mouse.Move(B);
    Result := MainScreen.IsUpText(Self.Knight.UpText);
  end
  else if Length(Minimap.GetDots(ERSMinimapDot.PLAYER)) < 10 then
    Result := Self.Knight.Hover(0);

  if not Result and MainScreen.IsUpText('Climb') then
    Antiban.RandomRotate();
end;

function TKnightsThiever.StealKnight(): Boolean;
var
  slot: Int32 := Inventory.GetSelectedSlot();
  currentHP: Int32 := Minimap.GetHPLevel();
  circle: TCircle;
  i: Int32;
begin
  if Slot > -1 then Inventory.ClickSlot(Slot);

  if Result := Self.HoverKnight() then
  begin
    case Self.Pattern of
      2, 3, 4: Wait(200, 300);
      5, 6: Wait(600, 800);
    end;

    Self.Pattern := SRL.TruncatedGauss(0, 6);

    Mouse.Click(MOUSE_LEFT);

    if MainScreen.DidYellowClick() then
      Exit(False);

    Wait(50, 100);

    case Self.Pattern of
      4:
      for i := 1 to SRL.TruncatedGauss(0, 2) do
      begin
        circle.X := Mouse.Position().X;
        circle.Y := Mouse.Position().Y;
        circle.Radius := 5;

        Mouse.Click(circle, MOUSE_LEFT, True);
        Wait(200, 350);
      end;
      6:
      for i := 1 to SRL.TruncatedGauss(0, 3) do
      begin
        circle.X := Mouse.Position().X;
        circle.Y := Mouse.Position().Y;
        circle.Radius := 5;

        Mouse.Click(circle, MOUSE_LEFT, True);
        Wait(10, 50);
      end;
    end;


    if not Self.NecklaceExpired() then
      Self.FreshNeck := False;

    Self.CheckFailed(CurrentHP);
    WL.Activity.Restart();
  end;
end;


function TKnightsThiever.Deposit(): Boolean;
begin
  Result := Bank.DepositItems(Self.BankArray, False);
end;

function TKnightsThiever.FixInventory(): Boolean;
begin
  if (Inventory.CountItem(Self.Necklace.Item) < (NeckAmount-2)) or
     not Inventory.HasEnoughConsumable(ERSConsumable.FOOD) then
  begin
    Bank.CachedQuantity := 0;
    Bank.DepositAll();
  end;

  Self.Necklace.Quantity := 1;
  Result := Bank.DepositItem(Self.Necklace, False);
end;

function TKnightsThiever.Withdraw(out item: TRSBankItem; attempts: Int32 = 3): Boolean; override;
begin
  if item = Self.Necklace then
    item.Quantity := NeckAmount - Inventory.CountItem(Self.Necklace.Item);

  Result := inherited(item, attempts);
end;

procedure TKnightsThiever.HandleUpstairs();
const
  Finder: TRSObjectFinder = [[[5395288, 3, 0.95, 0.22]], [], 0, 0, 0, 0, 0, 0, 0];
var
  TPA: TPointArray;
begin
  repeat
    for TPA in MainScreen.FindObject(Finder, MainScreen.GetPlayerBox.Expand(10)) do
    begin
      Mouse.Move(TPA);
      if MainScreen.IsUpText('down') then
      begin
        Mouse.Click(MOUSE_LEFT);
        if MainScreen.DidRedClick() then
        begin
          WaitUntil(Minimap.OnGroundLevel(), 100, 5000);
          Wait(2000);
        end;
      end;
    end;
  until Minimap.OnGroundLevel();
end;


function TKnightsThiever.GetState(): EThieverState;
begin
  if WL.Activity.IsFinished() then
    Exit(END_SCRIPT);

  if ChooseOption.IsOpen() then
    Exit(CLOSE_CONTEXT);

  if RSInterface.IsOpen() then
  begin
    if Bank.IsOpen() then
    begin
      if Self.BankEmpty then
        Exit(OUT_OF_SUPPLIES);

      if Inventory.ContainsAny(Self.BankArray) then
        Exit(DEPOSIT_ITEMS);

      if Inventory.IsFull() then
        Exit(FIX_INVENTORY);

      case Inventory.CountItem(Self.Necklace.Item) of
        0..(NeckAmount-2): Exit(WITHDRAW_NECK);
        (NeckAmount-2)..(NeckAmount+2): ;
        else Exit(DEPOSIT_NECK);
      end;

      if not Inventory.HasEnoughConsumable(ERSConsumable.FOOD) then
        Exit(WITHDRAW_FOOD);
    end;

    Exit(CLOSE_INTERFACE);
  end;

  if Self.IsPouchFull() then
    Exit(OPEN_POUCH);

  if ChatButtons.GetState(ERSChatButton.PUBLIC_CHAT) <> ERSChatButtonState.DISABLED then
    Exit(CHANGE_CHAT_OFF);

  if ChatButtons.GetState(ERSChatButton.GAME_CHAT) <> ERSChatButtonState.ENABLED then
    Exit(CHANGE_CHAT_FILTER);

  if not ChatButtons.IsActive(ERSChatButton.GAME_CHAT) then
    Exit(OPEN_CHAT);

  if Self.NeckTimer.IsFinished() then
    Exit(CHECK_NECK);

  if Self.HasRogue() then
    Exit(EQUIP_ROGUE);

  if not Self.HasSpace() then
  begin
    if Inventory.ContainsAny(Self.BankArray) then
      Exit(OPEN_BANK);
    if Inventory.FindConsumable(ERSConsumable.FOOD) then
      Exit(EAT_FOOD);

    Exit(OPEN_BANK);
  end;

  if (NeckAmount > 0) and not Self.FreshNeck and (not Self.HasNeck or Self.NecklaceExpired) then
  begin
    if Inventory.ContainsItem(Self.Necklace.Item) then
      Exit(EQUIP_NECK);

    Exit(OPEN_BANK);
  end;

  if Self.IsLowHP() then
  begin
    if Inventory.FindConsumable(ERSConsumable.FOOD) then
      Exit(EAT_FOOD);

    Exit(OPEN_BANK);
  end;

  if Self.UseShadowVeil and Self.ShadowVeilTimer.IsFinished() then
  Exit(EThieverState.CAST_SHADOW_VEIL);

  if not Minimap.OnGroundLevel() then
    Exit(IS_UPSTAIRS);

  if not Self.RSW.InPoly(BANK_POLYGON) then
    Exit(WALK_TO_BANK);

  Exit(PICKPOCKET);
end;

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

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

    case Self.State of
      OPEN_BANK: Bank.WalkOpen();
      DEPOSIT_ITEMS: Self.Deposit();
      WITHDRAW_FOOD: Self.BankEmpty := not Bank.WithdrawConsumable(ERSConsumable.FOOD);
      WITHDRAW_NECK: Self.Withdraw(Self.Necklace);
      DEPOSIT_NECK: Bank.DepositItem(Self.Necklace, False);
      FIX_INVENTORY: Self.FixInventory();
      CLOSE_INTERFACE: RSInterface.Close();

      OPEN_CHAT: ChatButtons.Open(ERSChatButton.GAME_CHAT);
      CHANGE_CHAT_OFF: ChatButtons.ChangeState(ERSChatButton.PUBLIC_CHAT, ERSChatButtonState.DISABLED);
      CHANGE_CHAT_FILTER: ChatButtons.ChangeState(ERSChatButton.GAME_CHAT, ERSChatButtonState.ENABLED);

      PICKPOCKET: Self.StealKnight();
      OPEN_POUCH: Self.OpenCoinPouch();

      CAST_SHADOW_VEIL: Self.CastShadowVeil();
      EAT_FOOD: Self.Heal();
      EQUIP_NECK: Self.EquipNeck();
      CHECK_NECK: Self.CheckNeck();
      CLOSE_CONTEXT: ChooseOption.Close();
      IS_UPSTAIRS: Self.HandleUpstairs();
      WALK_TO_BANK: Self.RSW.WebWalk(Self.Knight.Coordinates, 30, 0.2);
      EQUIP_ROGUE: Self.EquipRogue();


      OUT_OF_SUPPLIES, END_SCRIPT: Break;
    end;

    Self.DoAntiban();       //Checks for due antiban
  until Self.ShouldStop();  //Stops if MaxAtions or MaxTime have been reached.
end;

var
  KnightsThiever: TKnightsThiever;

procedure TSRL.Debug({$H-}Bitmap: TMufasaBitmap){$H+}; override;
begin
  { overriden so it doesn't show so much stuff }
end;

function TRSInventory.HasEnoughConsumable(ConsumableType: ERSConsumable): Boolean; override
var
  consumableHandler: PConsumableHandler := TConsumableHandler.GetHandler(ConsumableType);
begin
  Result := Self.CountPoints(ConsumableType) >= consumableHandler^.Amount;
end;


{$IFDEF SCRIPT_GUI}
type
  TKnightsForm = record(TScriptForm)
    DiaryLevelSelector: TLabeledComboBox;
    NeckAmountEdit: TLabeledEdit;
  end;

procedure TKnightsForm.StartScript(sender: TObject); override;
var
  foodAmountEdit, minHealthEdit: TEdit;
begin
  foodAmountEdit := Self.Form.GetChild('cm_food_amount_edit');
  minHealthEdit  := Self.Form.GetChild('cm_food_minimum_edit');

  DiaryLevel := Self.DiaryLevelSelector.GetItemIndex() + 1;
  FoodAmount := StrToInt(foodAmountEdit.GetText());
  NeckAmount := StrToInt(Self.NeckAmountEdit.GetText());
  MinHealth  := StrToint(minHealthEdit.GetText());

  inherited;
end;

function TScriptForm.CreateConsumableSettings(owner: TControl; consumableType: ERSConsumable; addInfo: Boolean = True): TPanel; override;
var
  typeStr: String;
  consumableAmount: TLabeledEdit;
  fullWidth, w, space, y: Int32;
begin
  fullWidth := Floor(Self.Size.X/3);
  space := Floor(fullWidth * 0.1);
  w := Floor(fullWidth - space * 2);
  if addInfo then
    y := Floor(Self.Size.Y/2.5)
  else
    y := TControl.AdjustToDPI(15);

  case consumableType of
    ERSConsumable.FOOD: typeStr := 'Food';
    ERSConsumable.FOOD: typeStr := 'Prayer';
    ERSConsumable.FOOD: typeStr := 'Energy';
    ERSConsumable.FOOD: typeStr := 'Boost';
  end;

  Result := inherited;

  with consumableAmount do
  begin
    Create(Result);
    SetCaption('Withdraw ' + LowerCase(typeStr) + ' amount:');
    SetName('cm_' + typeStr + '_amount');
    SetLeft(fullWidth * 2 + space);
    SetTop(y);
    SetWidth(w);
    SetText('8');
    Edit.setOnKeyPress(@Edit.NumberField);
  end;
end;

procedure TKnightsForm.Run(); override;
var
  tab: TTabSheet;
  panel: TPanel;
  foodAmountEdit, minHealthEdit: TEdit;
begin
  Self.Setup('Wasp Ardougne Knights');
  Self.Start.setOnClick(@Self.StartScript);

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

  Self.CreateAccountManager(tab);

  with Self.DiaryLevelSelector do
  begin
    Create(tab);
    SetCaption('Ardougne diaries completed:');
    SetLeft(TControl.AdjustToDPI(30));
    SetTop(TControl.AdjustToDPI(180));
    SetStyle(csDropDownList);
    AddItemArray(['None/Easy diary', 'Medium diary', 'Hard diary', 'Elite diary']);
    SetItemIndex(DiaryLevel - 1);
  end;

  with Self.NeckAmountEdit do
  begin
    Create(tab);
    SetCaption('Necklaces amount:');
    SetLeft(Self.DiaryLevelSelector.GetRight() + TControl.AdjustToDPI(30));
    SetTop(Self.DiaryLevelSelector.GetTop());
    SetWidth(TControl.AdjustToDPI(120));
    SetText(ToStr(NeckAmount));
  end;

  panel := Self.CreateConsumableSettings(tab, ERSConsumable.FOOD, False);

  panel.SetTop(TControl.AdjustToDPI(230));

  foodAmountEdit := panel.GetChild('cm_food_amount_edit');
  minHealthEdit  := panel.GetChild('cm_food_minimum_edit');

  foodAmountEdit.SetText(ToStr(FoodAmount));
  foodAmountEdit.SetVisible(True);
  minHealthEdit.SetText(ToStr(MinHealth));

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

  inherited;
end;

var
  KnightsConfig: TKnightsForm;
{$ENDIF}

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