DreamInventory.java

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2025 Dreamfire Studio
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
package com.dreamfirestudios.dreamcore.DreamInventory;
 
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
import org.bukkit.inventory.meta.Damageable;
import org.bukkit.inventory.meta.ItemMeta;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;
 
public final class DreamInventory {
 
    private DreamInventory() {}
 
    public static final int SLOT_MAIN_HAND = -1;
 
    public static final int SLOT_OFF_HAND  = -2;
 
    // ---------------------------------------------------------------------
    // Scanning
    // ---------------------------------------------------------------------
 
    public static @NotNull List<ItemRef> scan(@Nullable LivingEntity entity) {
        final List<ItemRef> out = new ArrayList<>();
        if (entity == null || entity.getEquipment() == null) return out;
 
        // Armor
        final ItemStack[] armor = entity.getEquipment().getArmorContents();
        for (int i = 0; i < armor.length; i++) {
            final ItemStack s = armor[i];
            if (s != null) out.add(new ItemRef(ItemLocation.ENTITY_ARMOR, i, s));
        }
 
        // Hands
        final ItemStack main = entity.getEquipment().getItemInMainHand();
        final ItemStack off  = entity.getEquipment().getItemInOffHand();
        if (main != null) out.add(new ItemRef(ItemLocation.ENTITY_MAIN_HAND, SLOT_MAIN_HAND, main));
        if (off  != null) out.add(new ItemRef(ItemLocation.ENTITY_OFF_HAND,  SLOT_OFF_HAND,  off));
 
        return out;
    }
 
    public static @NotNull List<ItemRef> scan(@Nullable PlayerInventory inv) {
        final List<ItemRef> out = new ArrayList<>();
        if (inv == null) return out;
 
        // Backpack
        final ItemStack[] contents = inv.getContents();
        for (int slot = 0; slot < contents.length; slot++) {
            final ItemStack s = contents[slot];
            if (s != null) out.add(new ItemRef(ItemLocation.ENTITY_INVENTORY, slot, s));
        }
 
        // Armor
        final ItemStack[] armor = inv.getArmorContents();
        for (int i = 0; i < armor.length; i++) {
            final ItemStack s = armor[i];
            if (s != null) out.add(new ItemRef(ItemLocation.ENTITY_ARMOR, i, s));
        }
 
        // Hands
        final ItemStack main = inv.getItemInMainHand();
        final ItemStack off  = inv.getItemInOffHand();
        if (main != null) out.add(new ItemRef(ItemLocation.ENTITY_MAIN_HAND, SLOT_MAIN_HAND, main));
        if (off  != null) out.add(new ItemRef(ItemLocation.ENTITY_OFF_HAND,  SLOT_OFF_HAND,  off));
 
        return out;
    }
 
    // ---------------------------------------------------------------------
    // Queries
    // ---------------------------------------------------------------------
 
    public static int totalCount(@NotNull PlayerInventory inv, @NotNull ItemStack probe) {
        Objects.requireNonNull(inv, "inventory");
        Objects.requireNonNull(probe, "itemStack");
        int total = 0;
        for (ItemStack s : inv.getContents()) {
            if (s != null && s.isSimilar(probe)) total += s.getAmount();
        }
        return total;
    }
 
    public static boolean isBroken(@Nullable ItemStack item) {
        if (item == null) return false;
        final int max = item.getType().getMaxDurability();
        if (max <= 0) return false;
        final ItemMeta meta = item.getItemMeta();
        if (!(meta instanceof Damageable dmg)) return false;
        return dmg.getDamage() >= max;
    }
 
    public static @Nullable ItemStack findByDisplayName(@NotNull PlayerInventory inv, @NotNull String plainName) {
        Objects.requireNonNull(inv, "inventory");
        Objects.requireNonNull(plainName, "plainName");
        final String target = plainName.trim();
        for (ItemStack s : inv.getContents()) {
            if (s == null) continue;
            final ItemMeta meta = s.getItemMeta();
            if (meta == null || !meta.hasDisplayName()) continue;
            final Component name = meta.displayName();
            if (name == null) continue;
            final String plain = PlainTextComponentSerializer.plainText().serialize(name);
            if (plain.equalsIgnoreCase(target)) return s;
        }
        return null;
    }
 
    public static @Nullable ItemStack findByDisplayName(@NotNull PlayerInventory inv, @NotNull Component nameComponent) {
        final String plain = PlainTextComponentSerializer.plainText().serialize(nameComponent);
        return findByDisplayName(inv, plain);
    }
 
    public static boolean hasAtLeast(@NotNull PlayerInventory inv, @NotNull ItemStack probe, int amount) {
        return totalCount(inv, probe) >= Math.max(0, amount);
    }
 
    // ---------------------------------------------------------------------
    // Mutations
    // ---------------------------------------------------------------------
 
    public static int removeAmount(@NotNull PlayerInventory inv, @NotNull ItemStack probe, int amount) {
        Objects.requireNonNull(inv, "inventory");
        Objects.requireNonNull(probe, "itemStack");
        int toRemove = Math.max(0, amount);
        if (toRemove == 0) return 0;
 
        ItemStack[] contents = inv.getContents();
        for (int slot = 0; slot < contents.length && toRemove > 0; slot++) {
            ItemStack s = contents[slot];
            if (s == null || !s.isSimilar(probe)) continue;
 
            int take = Math.min(s.getAmount(), toRemove);
            s.setAmount(s.getAmount() - take);
            toRemove -= take;
 
            if (s.getAmount() <= 0) contents[slot] = null;
        }
        inv.setContents(contents);
        return amount - toRemove;
    }
 
    public static int removeAllSimilar(@NotNull PlayerInventory inv, @NotNull ItemStack probe) {
        Objects.requireNonNull(inv, "inventory");
        Objects.requireNonNull(probe, "itemStack");
        int removed = 0;
        ItemStack[] contents = inv.getContents();
        for (int slot = 0; slot < contents.length; slot++) {
            ItemStack s = contents[slot];
            if (s != null && s.isSimilar(probe)) {
                removed += s.getAmount();
                contents[slot] = null;
            }
        }
        inv.setContents(contents);
        return removed;
    }
 
    public static boolean addItem(@NotNull PlayerInventory inv, @NotNull ItemStack stack) {
        Objects.requireNonNull(inv, "inventory");
        Objects.requireNonNull(stack, "itemStack");
        return inv.addItem(stack).isEmpty();
    }
 
    public static void swap(@NotNull Inventory inv, int slot1, int slot2) {
        Objects.requireNonNull(inv, "inventory");
        final int size = inv.getSize();
        if (slot1 < 0 || slot1 >= size || slot2 < 0 || slot2 >= size) {
            throw new IllegalArgumentException("Invalid slot(s): " + slot1 + ", " + slot2 + " (size=" + size + ")");
        }
        ItemStack a = inv.getItem(slot1);
        ItemStack b = inv.getItem(slot2);
        inv.setItem(slot1, b);
        inv.setItem(slot2, a);
    }
 
    public static void ensureMainHand(@NotNull Player player, @NotNull ItemStack stack) {
        Objects.requireNonNull(player, "player");
        Objects.requireNonNull(stack, "itemStack");
        ItemStack current = player.getInventory().getItemInMainHand();
        if (current != null && current.isSimilar(stack)) return;
        player.getInventory().setItemInMainHand(stack);
    }
 
    // ---------------------------------------------------------------------
    // Search helpers
    // ---------------------------------------------------------------------
 
    public static @Nullable ItemStack findFirst(@NotNull PlayerInventory inv, @NotNull Predicate<ItemStack> predicate) {
        Objects.requireNonNull(inv, "inventory");
        Objects.requireNonNull(predicate, "predicate");
        for (ItemStack s : inv.getContents()) {
            if (s != null && predicate.test(s)) return s;
        }
        return null;
    }
}