Basic Hill Giant Script

[Deep Slayer 20]

import org.dreambot.api.Client;
import org.dreambot.api.methods.Calculations;
import org.dreambot.api.methods.container.impl.Inventory;
import org.dreambot.api.methods.container.impl.bank.Bank;
import org.dreambot.api.methods.container.impl.equipment.Equipment;
import org.dreambot.api.methods.interactive.NPCs;
import org.dreambot.api.methods.interactive.Players;
import org.dreambot.api.methods.item.GroundItems;
import org.dreambot.api.methods.map.Area;
import org.dreambot.api.methods.walking.impl.Walking;
import org.dreambot.api.script.AbstractScript;
import org.dreambot.api.script.Category;
import org.dreambot.api.script.ScriptManifest;
import org.dreambot.api.utilities.Sleep;
import org.dreambot.api.wrappers.interactive.NPC;
import org.dreambot.api.wrappers.items.GroundItem;
import org.dreambot.api.wrappers.items.Item;

import java.awt.*;


import static org.dreambot.api.methods.Calculations.random;

@ScriptManifest(author = "Deep Slayer", name = "F2P Hill Giant Killer", version = 1.0, description = "Kills and loots Hill Giants", category = Category.COMBAT)
public class GiantBoneCollector extends AbstractScript {


    private final Area hillGiantArea = new Area(3102, 9823, 3124, 9854, 0);

    private final Area bankArea = new Area(3159, 3487, 3168, 3484, 0);

    
    String food = "Tuna";
    int foodAmount = 15;
    String weapon = "Mithril Scimitar";

    private enum State {
        EATING,
        CHECK_GEAR,
        GET_KEY,
        TRAVEL_TO_HILL_GIANTS,
        FIGHT_HILL_GIANTS,
        LOOTING,
        BANKING,
        IDLE
    }

    private State getState() {
        if (shouldEat()) {
            return State.EATING;
        }
        if (!hasRequiredGear() || !hasBrassKey()) {
            return State.CHECK_GEAR;
        }

        if (shouldTravelToHillGiants()) {
            return State.TRAVEL_TO_HILL_GIANTS;
        }

        if (shouldFightHillGiants()) {
            return State.FIGHT_HILL_GIANTS;
        }

        if (shouldLoot()) {
            return State.LOOTING;
        }

        if (shouldBank()) {
            return State.BANKING;
        }

        return State.IDLE;
    }
    

    public void onStart() {
      
    }

    @Override
    public int onLoop() {
        switch (getState()) {
            case EATING:
                eatFood();
                break;
            case CHECK_GEAR:
                checkGear();
                break;
            case GET_KEY:
                getKey();
                break;
            case TRAVEL_TO_HILL_GIANTS:
                travelToHillGiants();
                break;
            case FIGHT_HILL_GIANTS:
                fightHillGiants();
                break;
            case LOOTING:
                lootItems();
                break;
            case BANKING:
                bankItems();
                break;
            case IDLE:
                idle();
                break;
        }

        return random(200, 300);
    }


    private boolean checkGear() {


        // Check if the Scimitar is in the player's inventory
        if (Inventory.contains(weapon)) {
            log("cimitar is in the inventory.");

            // Attempt to equip the Scimitar
            Item scimitar = Inventory.get(weapon);
            if (scimitar != null && scimitar.interact("Wield")) {
                log("Equipped Scimitar.");
                return true;
            }
        }

        // Check if the Scimitar is equipped
        if (Equipment.contains(weapon)) {
            log(" Scimitar is already equipped.");
            return true;
        }

        // Check if the Scimitar is in the bank
        if (Bank.isOpen() || Bank.open()) {
            if (Bank.contains(weapon)) {
                log("Scimitar is in the bank. Withdrawing and equipping...");

                // Ensure there's enough space in the inventory
                if (!Inventory.isFull() || Inventory.contains("Coins")) {
                    if (Bank.withdraw(weapon, 1)) {
                        Bank.close();
                        Sleep.sleepUntil(() -> !Bank.isOpen(), 5000); // Wait for the bank to close

                        Item scimitarInInv = Inventory.get(weapon);
                        if (scimitarInInv != null && scimitarInInv.interact("Wield")) {
                            log("Equipped Scimitar from bank.");
                            return true;
                        }
                    } else {
                        log("Failed to withdraw Scimitar. Ensure inventory space.");
                    }
                } else {
                    log("Not enough space in inventory to withdraw  Scimitar.");
                }
            }
        }

        // If Scimitar is not found in inventory, equipment, or bank
        log(" Scimitar not found. Stopping script.");
        this.stop();
        return false;
    }

    private void getKey() {
        String brassKey = "Brass key";

        // Check if the Brass Key is in the player's inventory
        if (Inventory.contains(brassKey)) {
            log("Brass Key is in the inventory.");
            return;
        }

        // Check if the Brass Key is in the bank
        if (Bank.isOpen() || Bank.open()) {
            if (Bank.contains(brassKey)) {
                log("Brass Key is in the bank. Withdrawing...");

                if (Bank.withdraw(brassKey, 1)) {
                    log("Brass Key withdrawn from the bank.");
                    // Optional: Close the bank after withdrawing the key
                    Bank.close();
                    return;
                } else {
                    log("Failed to withdraw Brass Key. Ensure inventory space.");
                    this.stop();
                    return;
                }
            }
        }

        // If Brass Key is not found in inventory or bank
        log("Brass Key not found. Stopping script.");
        this.stop();
    }

    private void travelToHillGiants() {
        log("Traveling to the Hill Giants location...");

        // Check if we are already in the Hill Giants area
        if (hillGiantArea.contains(Players.getLocal())) {
            log("Arrived at the Hill Giants area.");
            return;
        }

        // Walking to the Hill Giants area
        if (Walking.shouldWalk()) {
            Walking.walk(hillGiantArea.getRandomTile());
        }


    }


    private void fightHillGiants() {
        NPC hillGiant = NPCs.closest(giant -> giant != null && giant.getName().equals("Hill Giant") && giant.canAttack());

        if (hillGiant != null && !Players.getLocal().isInCombat()) {
            if (hillGiant.interact("Attack")) {
                log("Engaging with Hill Giant.");
                Sleep.sleepUntil(() -> !hillGiant.isHealthBarVisible() || hillGiant.exists(), random(1200, 2000));
            }
        } else {
            log("No Hill Giants available to attack or already in combat.");
            sleep(random(600, 800));
        }
    }

    private void lootItems() {
        // Define the items you want to loot
        String[] lootableItems = {"Big bones", "Uncut sapphire", "Limpwurt root", "Cosmic rune", "Chaos rune","Nature rune", "Law rune"}; // Replace with actual items

        for (String itemName : lootableItems) {
            GroundItem item = GroundItems.closest(itemName);
            if (item != null && item.isOnScreen()) {
                if (Inventory.isFull()) {
                    eatFoodToMakeSpace();  // Call method to eat food to make space
                }

                if (item.interact("Take")) {
                    log("Looting: " + itemName);
                    Sleep.sleepUntil(() -> !item.exists(), Calculations.random(5000, 8000));
                }
            }
        }
    }
    private void eatFoodToMakeSpace() {

        if (Inventory.contains(food)) {
            Inventory.interact(food, "Eat");
            log("Eating food to make space for loot.");
            Sleep.sleepUntil(() -> !Inventory.isFull(), Calculations.random(800, 1200));
        } else {
            log("No food available to eat for making space.");
        }
    }

    private void bankItems() {
        log("Banking items...");

        // Navigate to the bank
        if (!bankArea.contains(Players.getLocal())) {
            log("Traveling to the bank...");
            if (Walking.shouldWalk()) {
                Walking.walk(bankArea.getRandomTile());
            }
        }

        // Interact with the bank
        if (bankArea.contains(Players.getLocal())) {
            if (Bank.open()) {
                log("Bank opened. Depositing items...");
                Bank.depositAllItems();
                Sleep.sleepUntil(Inventory::isEmpty, random(1000, 2000));
                // Retrieve necessary items like food and gear here, if needed
                Bank.withdraw("Brass key");;
                sleep(500,1000);
                Bank.withdraw(food,foodAmount);
            }
        }

    }

    private void eatFood() {

        if (Inventory.contains(food)) {
            Inventory.interact(food,"Eat");
            log("Eating food for health.");
            Sleep.sleepUntil(() -> Players.getLocal().getHealthPercent() > random(50,60), random(1000, 2000));
        }
    }

    private void idle() {
        // Implement idle behavior / antiban stuff

    }
    private boolean shouldEat() {
        // Example condition: eat if health is below 50%
        return Players.getLocal().getHealthPercent() < 50 && Inventory.contains(food);
    }
    private boolean hasRequiredGear() {


        // Check if the Scimitar is equipped
        if (Equipment.contains(weapon)) {
            log("Player has the required gear: " + weapon);
            return true;
        } else {
            log("Player does not have the required gear: "+ weapon);
            return false;
        }
    }

    private boolean hasBrassKey() {
        String brassKey = "Brass key";

        // Check if the Brass Key is in the player's inventory
        if (Inventory.contains(brassKey)) {
            log("Player has the Brass Key.");
            return true;
        } else {
            log("Player does not have the Brass Key.");
            return false;
        }
    }

    private boolean shouldTravelToHillGiants() {
        // Check if already in the Hill Giants area
        if (hillGiantArea.contains(Players.getLocal())) {
            log("Already in the Hill Giants area.");
            return false;
        }

        // Check if the inventory contains the Brass Key
        if (!Inventory.contains("Brass key")) {
            log("Brass key is missing. Cannot travel to Hill Giants.");
            return false;
        }

        // Check if the inventory contains food
         if (!Inventory.contains(food)) {
            log("Food is missing. Cannot safely travel to Hill Giants.");
            return false;
        }

        // All conditions met, should travel to Hill Giants
        return true;
    }

    private boolean shouldFightHillGiants() {
        // Ensure we are in the Hill Giants area
        if (!hillGiantArea.contains(Players.getLocal())) {
            log("Not in the Hill Giants area.");
            return false;
        }

        // Check if there are Hill Giants available to fight
        NPC hillGiant = NPCs.closest(giant -> giant != null && giant.getName().equals("Hill Giant") && giant.canAttack());
        if (hillGiant == null) {
            log("No Hill Giants available to fight.");
            return false;
        }

        // Check if the player is already in combat
        if (Players.getLocal().isInCombat()) {
            log("Already in combat.");
            return false;
        }

        // Check if the player has enough health
        if (Players.getLocal().getHealthPercent() < 50) {
            log("Health too low to safely engage in combat.");
            return false;
        }

        // Check if the player has enough food
        if (!Inventory.contains(food)) { // Replace "food" with your actual food item
            log("Not enough food to continue fighting.");
            return false;
        }

        // All conditions met to fight Hill Giants
        return true;
    }

    private boolean shouldLoot() {
        // Define the items you consider valuable for looting
        String[] valuableItems = {"Big bones", "Item2", "Item3"}; // Replace with actual valuable items from Hill Giants


        // Check if lootable items exist and i have food
        if(Inventory.contains(food)) {
            for (String itemName : valuableItems) {
                GroundItem item = GroundItems.closest(itemName);
                if (item != null && item.isOnScreen()) {
                    log("Valuable item found on the ground. Time to loot: " + itemName);
                    return true;
                }
            }
        }




        log("No items to loot");
        return false;
    }

    private boolean shouldBank() {
        // Check if the player is out of food
        if (!Inventory.contains(food)) {
            log("Out of food, time to bank.");
            return true;
        }

        // Other conditions can be added here if needed, like checking the inventory for loot space

        return false;
    }

}

Edited January 27 by Deep Slayer

[Deep Slayer 20]

Quick points:

Start with a brass key and a scimitar.

Customize food and weapon in global variables.

You can define lootable items in the lootItems method.

Recommended to have some armor for lower levels.

Note: This script has no anti-ban features.  You can implement your own in the idle() method. Use at your own risk.

Let me know your thoughts or suggestions!

Thanks!

 

Edited January 27 by Deep Slayer

[OgCross 12]

nice man!  kinda kicking myself, wish i saw this sooner! t would of been great to learn from