wasp_ardougne_knights.simba

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

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

//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, CAST_SHADOW_VEIL,

    CLOSE_CONTEXT, WAIT_STATE,

    OUT_OF_SUPPLIES, END_SCRIPT
  );

//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: TRSNPCV2;

    CoinPouch: TRSItem;
    Necklace: TRSBankItem;

    LootArray, KeepArray, BankArray, RogueEquipment: TRSItemArray;

    NeckTimer, ShadowVeilTimer: TCountDown;

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

    VeilAttempts, CoinPouchLimit, MaxHit, NextHeal, Pattern, DiaryLevel: Int32;

    BankBounds: TPointArray;
  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.Init(maxActions: UInt32; maxTime: UInt64); override;
begin
  Antiban.Skills := [ERSSkill.THIEVING, ERSSkill.TOTAL];
  Antiban.MinZoom := 5;
  Antiban.MaxZoom := 50;

  inherited;

  Map.SetupChunk(ERSChunk.ARDOUGNE);
  Objects.Setup(Map.Objects(), @Map.Walker);

  Self.Knight.SetupCoordinates([[6516, 37294]]);
  Self.Knight.Size := [1,1,6];
  Self.Knight.DotFilters.SetupBounds(Self.BankBounds, True);
  Self.Knight.SetupUpText('Knight of Ardougne');
  Self.Knight.Finder.Colors += CTS2(10620793, 19, 0.22, 0.31);
  Self.Knight.Walker := @Map.Walker;

  Self.DiaryLevel := Max(Achievements.GetDiaryLevel(ERSAchievementDiary.ARDOUGNE), 1);
  if Self.DiaryLevel = 4 then Self.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)));
    Antiban.Skills += ERSSkill.MAGIC;
  end;

  XPBar.EarnedXP();
  Self.BankBounds := Box(6500,37282,6524,37310).ToRectangle().ToTPA();
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 * Self.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 * Self.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.Name);
  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(EThieverState.END_SCRIPT);

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

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

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

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

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

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

    Exit(EThieverState.CLOSE_INTERFACE);
  end;

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

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

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

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

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

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

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

    Exit(EThieverState.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(EThieverState.EQUIP_NECK);

    Exit(EThieverState.OPEN_BANK);
  end;

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

    Exit(EThieverState.OPEN_BANK);
  end;

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

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

  if not SRL.PointInPoly(Map.Position(), Self.BankBounds) then
    Exit(EThieverState.WALK_TO_BANK);

  Exit(EThieverState.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
      EThieverState.OPEN_BANK: Banks.WalkOpen();
      EThieverState.DEPOSIT_ITEMS: Self.Deposit();
      EThieverState.WITHDRAW_FOOD: Self.BankEmpty := not Bank.WithdrawConsumable(ERSConsumable.FOOD);
      EThieverState.WITHDRAW_NECK: Self.Withdraw(Self.Necklace);
      EThieverState.DEPOSIT_NECK: Bank.DepositItem(Self.Necklace, False);
      EThieverState.FIX_INVENTORY: Self.FixInventory();
      EThieverState.CLOSE_INTERFACE: RSInterface.Close();

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

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

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

      EThieverState.OUT_OF_SUPPLIES, EThieverState.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)
    NeckAmountEdit: TLabeledEdit;
    Config: TConfigJSON;
  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');

  NeckAmount := StrToInt(Self.NeckAmountEdit.GetText());
  FoodAmount := StrToInt(foodAmountEdit.GetText());
  MinHealth  := StrToint(minHealthEdit.GetText());

  Self.Config.Put('necks', NeckAmount);
  Self.Config.Put('food_amount', FoodAmount);
  Self.Config.Put('min_health', MinHealth);

  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.Config.Setup('wasp-ardougne-knights');
  Self.Start.setOnClick(@Self.StartScript);

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

  Self.CreateAccountManager(tab);

  with Self.NeckAmountEdit do
  begin
    Create(tab);
    SetCaption('Necklaces amount:');
    SetLeft(TControl.AdjustToDPI(30));
    SetTop(TControl.AdjustToDPI(180));
    SetWidth(TControl.AdjustToDPI(120));

    if Self.Config.Has('necks') then
      SetText(ToStr(Self.Config.GetInt('necks')))
    else
      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');

  if Self.Config.Has('food_amount') then
    foodAmountEdit.SetText(ToStr(Self.Config.GetInt('food_amount')))
  else
    foodAmountEdit.SetText(ToStr(FoodAmount));

  foodAmountEdit.SetVisible(True);

  if Self.Config.Has('min_health') then
    minHealthEdit.SetText(ToStr(Self.Config.GetInt('min_health')))
  else
    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.