wasp_cooker.simba

{$DEFINE SCRIPT_ID := 'de957f22-8a37-4660-a7a3-9bef52cadd70'}
{$DEFINE SCRIPT_REVISION := '38'}
{$IFNDEF SCRIPT_CHAIN}
  {$DEFINE SCRIPT_GUI}
  {$I SRL-T/osr.simba}
  {$I WaspLib/osr.simba}
{$ENDIF}

type
  ERSLocation = (HOSIDIUS, ROGUES_DEN, MYTHS_GUILD);

const
  RawFood: TRSItemArray = [
    'Custom',
    'Meat',
    'Shrimps',
    'Chicken',
    'Rabbit',
    'Anchovies',
    'Sardine',
    'Herring',
    'Mackerel',
    'Trout',
    'Cod',
    'Pike',
    'Salmon',
    'Tuna',
    'Karambwan',
    'Rainbow fish',
    'Lobster',
    'Bass',
    'Swordfish',
    'Monkfish',
    'Shark',
    'Sea turtle',
    'Anglerfish',
    'Dark crab',
    'Manta ray'
  ];

var
  CurrentFood: TRSItem   := 'Anglerfish';
  CurrentLocation := ERSLocation.HOSIDIUS;

type
  ECookerState = (
    OPEN_BANK,
    WITHDRAW_ITEMS,
    DEPOSIT_ITEMS,

    OPEN_COLLECT,
    HANDLE_COLLECT,
    CLOSE_INTERFACE,

    DO_COOKING,
    HANDLE_MAKE,
    WAIT_COOKING,

    LEVEL_UP,
    CLOSE_CONTEXT,

    END_SCRIPT
  );

  TCooker = record(TBaseBankScript)
    State: ECookerState;

    Food: TRSItem;
    Ingredient: TRSBankItem;
    Products: array of TRSBankItem;

    CookingObj: TRSObject;

    Cooking: Boolean;
    UsingFire: Boolean;
  end;


procedure TCooker.SetupItems();
var
  cookedPrefix: TStringArray;
  burntFish: TStringArray;
begin
  Self.Food := CurrentFood;
  ItemFinder.Similarity := 0.99999;

  cookedPrefix := ['chicken', 'rabbit', 'meat', 'crab meat',
                   'karambwan', 'chompy', 'fishcake', 'jubbly', 'sweetcorn'];

  burntFish := ['herring', 'mackerel', 'sardine', 'anchovies',
                'giant carp', 'trout', 'cod', 'pike', 'salmon', 'tuna', 'bass'];

  Self.Ingredient := TRSBankItem.Setup('Raw ' + ToString(Self.Food).Lower());

  if cookedPrefix.Contains(LowerCase(Self.Food)) then
    Self.Products := [
      TRSBankItem.Setup('Cooked ' + ToString(Self.Food).Lower()),
      TRSBankItem.Setup('Burnt ' + ToString(Self.Food).Lower())
    ]
  else if burntFish.Contains(LowerCase(Self.Food)) then
    Self.Products := [
      TRSBankItem.Setup(Self.Food),
      TRSBankItem.Setup('Burnt fish')
    ]
  else if 'shrimps' in LowerCase(Self.Food) then
    Self.Products := [
      TRSBankItem.Setup(Self.Food),
      TRSBankItem.Setup('Burnt shrimp')
    ]
  else
    Self.Products := [
      TRSBankItem.Setup(Self.Food),
      TRSBankItem.Setup('Burnt ' + ToString(Self.Food).Lower())
    ];

  Self.ActionProfit := (
    ItemData.GetAverage(Self.Products[0].Item) -
    ItemData.GetAverage(Self.Ingredient.Item)
  );
end;

procedure TCooker.SetupLocation();
begin
  case CurrentLocation of
    ERSLocation.HOSIDIUS:
      begin
        RSW.SetupRegions([RSRegions.HOSIDIUS_KITCHEN]);
        CookingObj := RSObjects.HosidiusKitchenOven;
      end;

    ERSLocation.ROGUES_DEN:
      begin
        RSW.SetupRegions([RSRegions.ROGUES_DEN]);
        RSNPCs.EmeraldBenedict.Filter.Finder := False;

        RSObjects.EternalFire.Filter.Finder := False;
        RSObjects.EternalFire.Filter.UpText := False;
        CookingObj := RSObjects.EternalFire;
      end;

    ERSLocation.MYTHS_GUILD:
      begin
        RSW.SetupRegions([RSRegions.MYTHS_GUILD_MID_FLOOR]);
        CookingObj := RSObjects.MythGuildRange;
      end;
  end;

end;

procedure TAntiban.Setup(); override;
begin
  Self.Skills := [ERSSkill.COOKING, ERSSkill.TOTAL];
  Self.MinZoom := 15;
  Self.MaxZoom := 60;

  inherited;
end;

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

  Self.SetupItems();
  Self.SetupLocation();

  if WLSettings.RemoteInput.HUDDebug then
    DebugObjectArray += CookingObj;
end;


function TCooker.HasProducts(): Boolean;
begin
  Result := Inventory.ContainsAny([Self.Products[0].Item, Self.Products[1].Item]);
end;

function TCooker.OpenBank(): Boolean;
begin
  case CurrentLocation of
    ERSLocation.HOSIDIUS, ERSLocation.MYTHS_GUILD:   Result := Bank.WalkOpen();
    ERSLocation.ROGUES_DEN: Result := Bank.WalkOpen(RSNPCs.EmeraldBenedict);
  end;
end;

function TCooker.Deposit(): Boolean;
var
  invCount: Int32;
begin
  invCount := Inventory.Count();
  Result := Self.DepositItem(Self.Products[0]);
  Self.DepositItem(Self.Products[1]);

  if Result then
  begin
    Self.TotalActions += invCount - Inventory.Count();
    Self.TotalProfit := Self.TotalActions * Self.ActionProfit;
  end;
end;

function TCooker.DoCooking(): Boolean;
var
  fire, tpa: TPointArray;
  playerBox: TBox;
begin
  case CurrentLocation of
    ERSLocation.ROGUES_DEN:
      begin
        playerBox := Box(Mainscreen.Center(), 100, 100);
        if SRL.FindColors(tpa, CTS2(2730450, 13, 0.09, 1.45), playerBox) > 0 then
          fire += tpa;
        if SRL.FindColors(tpa, CTS2(15432, 1, 0.15, 0.01), playerBox) > 0 then
          fire += tpa;

        Mouse.Move(fire.Cluster(1).Biggest());
        if Mainscreen.IsUpText(['Cook', 'Fire']) then
        begin
          Mouse.Click(MOUSE_LEFT);
          Minimap.WaitPlayerMoving(300, 3000);
          Exit(Make.IsOpen(4000));
        end;
      end;
  end;

  if CookingObj.WalkSelectOption(['Cook', 'Fire']) then
  begin
    Minimap.WaitPlayerMoving(300, 3000);
    Result := Make.IsOpen(4000);
  end;
end;

function TCooker.HandleMake(): Boolean;
var
  i: Int32 := 0;
begin
  if not Make.IsOpen() then //not sure if I can remove this.
    Exit;                 //it's probably not needed.

  Result := Make.Select(i, Make.QUANTITY_ALL, Antiban.BioDice());
  Self.Cooking := Result;

  if Result then
    WaitUntil(not Make.IsOpen(), 100, 4000);  
end;


function TCooker.IsCooking(waitTime: Int32 = 2500): Boolean;
var
  count: Int32;
begin
  count := Inventory.CountItem(Self.Ingredient.Item);
  if count = 0 then
    Exit;

  Result := WaitUntil(count > Inventory.CountItem(Self.Ingredient.Item), 300, waitTime);
  if Result then
    WL.Activity.Restart();
end;

function TCooker.WaitCooking(): Boolean;
begin
  Result := Self.IsCooking();
  Self.Cooking := Result;
end;


function TCooker.GetState(): ECookerState;
begin
  if WL.Activity.IsFinished() then
    Exit(ECookerState.END_SCRIPT);

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

  if XPBar.EarnedXP() then
    Exit(ECookerState.WAIT_COOKING);

  if Chat.LeveledUp() then
  begin
    Self.Cooking := False;
    Exit(ECookerState.LEVEL_UP);
  end;

  if Make.IsOpen() then
    Exit(ECookerState.HANDLE_MAKE);

  if RSInterface.IsOpen() then
  begin
    Self.Cooking := False;
    Self.HoveringBank := False;
    if not Self.BankEmpty and Bank.IsOpen() then
    begin
      if Self.HasProducts() then
        Exit(ECookerState.DEPOSIT_ITEMS);

      if not Inventory.ContainsItem(Self.Ingredient.Item) then
        Exit(ECookerState.WITHDRAW_ITEMS);
    end;

    if not Self.CollectEmpty and CollectBox.IsOpen() then
    begin
      if not CollectBox.ContainsItem(Self.Ingredient.Item) then
        Exit(ECookerState.HANDLE_COLLECT);
    end;

    Exit(ECookerState.CLOSE_INTERFACE);
  end;

  if Inventory.ContainsItem(Self.Ingredient.Item) then
  begin
    if Self.Cooking then
      Exit(ECookerState.WAIT_COOKING);

    Exit(ECookerState.DO_COOKING);
  end;

  if Self.BankEmpty and Self.CollectEmpty then
    Exit(ECookerState.END_SCRIPT);

  if Self.BankEmpty then
    Exit(ECookerState.OPEN_COLLECT);

  Exit(ECookerState.OPEN_BANK);
end;

function TCooker.Terminate(): Boolean; override;
begin
  Result := inherited();
  if Result then
    for 0 to 5 do
      if Result := Bank.WithdrawItem(Self.Products[0], True) then
        Break;
end;

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

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

    case Self.State of
      ECookerState.OPEN_BANK: Self.OpenBank();
      ECookerState.WITHDRAW_ITEMS: Self.Withdraw(Self.Ingredient);
      ECookerState.DEPOSIT_ITEMS: Self.Deposit();

      ECookerState.OPEN_COLLECT: CollectBox.WalkOpen();
      ECookerState.HANDLE_COLLECT: Self.HandleCollectBox([Self.Ingredient.Item]);
      ECookerState.CLOSE_INTERFACE: RSInterface.Close();

      ECookerState.LEVEL_UP: Chat.HandleLevelUp();
      ECookerState.DO_COOKING: Self.DoCooking();
      ECookerState.HANDLE_MAKE: Self.HandleMake();
      ECookerState.WAIT_COOKING: Self.WaitCooking();
      ECookerState.CLOSE_CONTEXT: ChooseOption.Close();

      ECookerState.END_SCRIPT: Break;
    end;

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

  if not Self.Terminate then
    TerminateScript('aio_cooker didn''t terminate properly. Stopping execution.');
end;

var
  Cooker: TCooker;

function TRSMake.Select(Index: Int32; Quantity: Int32; UseKeyboard: Boolean = True): Boolean; override;
var
  Buttons: TRSButtonArray;
begin
  Buttons := Self.GetItemButtons();
  if Index <= High(Buttons) then
    Result := Self.SelectHelper(Buttons[Index], Quantity, UseKeyboard);
end;


{$IFNDEF SCRIPT_CHAIN}
{$IFDEF SCRIPT_GUI}
type
  TCookerConfig = record(TScriptForm)
    LocSelector: TLabeledCombobox;
    CustomFoodName: TLabeledEdit;
    FoodSelector: TLabeledCombobox;
  end;

procedure TCookerConfig.StartScript(sender: TObject); override;
begin
  CurrentLocation := ERSLocation(Self.LocSelector.GetItemIndex());
  if Self.FoodSelector.GetText() = 'Custom' then
    CurrentFood := Self.CustomFoodName.GetText()
  else
    CurrentFood := Self.FoodSelector.GetText();

  inherited;
end;

procedure TCookerConfig.FoodSelectorOnChange(sender: TObject);
var
  combobox: TComboBox;
begin
  combobox := sender;
  Self.CustomFoodName.SetVisible(combobox.getText() = 'Custom');
end;

procedure TCookerConfig.Run(); override;
var
  tab: TTabSheet;
begin
  Self.Setup('Wasp Cooker');
  Self.Start.setOnClick(@Self.StartScript);

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

  Self.CreateAccountManager(tab);

  with Self.LocSelector do
  begin
    Create(tab);
    SetCaption('Location:');
    SetLeft(TControl.AdjustToDPI(20));
    SetTop(TControl.AdjustToDPI(200));
    SetWidth(TControl.AdjustToDPI(200));
    SetStyle(csDropDownList);
    AddItemArray(['Hosidius kitchen', 'Rogues den', 'Myth''s guild']);
    SetItemIndex(Ord(CurrentLocation));
  end;

  with Self.FoodSelector do
  begin
    Create(tab);
    SetCaption('Food type:');
    SetLeft(Self.LocSelector.GetRight() + TControl.AdjustToDPI(20));
    SetTop(Self.LocSelector.GetTop());
    SetWidth(TControl.AdjustToDPI(200));
    SetStyle(csDropDownList);
    AddItemArray(RawFood);
    SetItemIndex(0);
    Combobox.setOnChange(@Self.FoodSelectorOnChange);
  end;

  with Self.CustomFoodName do
  begin
    Create(tab);
    SetCaption('Food name (must be the exact name):');
    SetLeft(Self.FoodSelector.GetRight() + TControl.AdjustToDPI(20));
    SetTop(Self.LocSelector.GetTop());
    SetWidth(TControl.AdjustToDPI(200));
    SetText(CurrentFood);
    SetVisible(Self.FoodSelector.GetText() = 'Custom');
  end;

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

  inherited;
end;

var
  CookerConfig: TCookerConfig;
{$ENDIF}
{$ENDIF}

{$IFNDEF SCRIPT_CHAIN}
begin
  {$IFDEF SCRIPT_GUI}
  CookerConfig.Run();
  {$ENDIF}
  Cooker.Run(WLSettings.MaxActions, WLSettings.MaxTime);
end.
{$ENDIF}