InventoryManager.java

Go to the documentation of this file.

package com.dreamfirestudios.dreamcore.DreamSmartInvs;
 
import com.dreamfirestudios.dreamcore.DreamSmartInvs.content.InventoryContents;
import com.dreamfirestudios.dreamcore.DreamSmartInvs.opener.ChestInventoryOpener;
import com.dreamfirestudios.dreamcore.DreamSmartInvs.opener.InventoryOpener;
import com.dreamfirestudios.dreamcore.DreamSmartInvs.opener.SpecialInventoryOpener;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.*;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.server.PluginDisableEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;
 
import java.util.*;
import java.util.logging.Level;
 
public class InventoryManager {
    private JavaPlugin plugin;
    private PluginManager pluginManager;
 
    private Map<UUID, SmartInventory> inventories;
    private Map<UUID, InventoryContents> contents;
 
    private List<InventoryOpener> defaultOpeners;
    private List<InventoryOpener> openers;
 
    public InventoryManager(JavaPlugin plugin) {
        this.plugin = plugin;
        this.pluginManager = Bukkit.getPluginManager();
 
        this.inventories = new HashMap<>();
        this.contents = new HashMap<>();
 
        this.defaultOpeners = Arrays.asList(
                new ChestInventoryOpener(),
                new SpecialInventoryOpener()
        );
 
        this.openers = new ArrayList<>();
    }
 
    public void init() {
        pluginManager.registerEvents(new InvListener(), plugin);
 
        new InvTask().runTaskTimer(plugin, 1, 1);
    }
 
    public Optional<InventoryOpener> findOpener(InventoryType type) {
        Optional<InventoryOpener> opInv = this.openers.stream()
                .filter(opener -> opener.supports(type))
                .findAny();
 
        if (!opInv.isPresent()) {
            opInv = this.defaultOpeners.stream()
                    .filter(opener -> opener.supports(type))
                    .findAny();
        }
 
        return opInv;
    }
 
    public void registerOpeners(InventoryOpener... openers) {
        this.openers.addAll(Arrays.asList(openers));
    }
 
    public List<Player> getOpenedPlayers(SmartInventory inv) {
        List<Player> list = new ArrayList<>();
 
        this.inventories.forEach((player, playerInv) -> {
            if (inv.equals(playerInv))
                list.add(Bukkit.getPlayer(player));
        });
 
        return list;
    }
 
    public Optional<SmartInventory> getInventory(Player p) {
        return Optional.ofNullable(this.inventories.get(p.getUniqueId()));
    }
 
    protected void setInventory(Player p, SmartInventory inv) {
        if (inv == null) {
            this.inventories.remove(p.getUniqueId());
        }
        else{
            this.inventories.put(p.getUniqueId(), inv);
        }
 
    }
 
    public Optional<InventoryContents> getContents(Player p) {
        return Optional.ofNullable(this.contents.get(p.getUniqueId()));
    }
 
    protected void setContents(Player p, InventoryContents contents) {
        if (contents == null)
            this.contents.remove(p.getUniqueId());
        else
            this.contents.put(p.getUniqueId(), contents);
    }
 
    public void handleInventoryOpenError(SmartInventory inventory, Player player, Exception exception) {
        inventory.close(player);
 
        Bukkit.getLogger().log(Level.SEVERE, "Error while opening SmartInventory:", exception);
    }
 
    public void handleInventoryUpdateError(SmartInventory inventory, Player player, Exception exception) {
        inventory.close(player);
 
        Bukkit.getLogger().log(Level.SEVERE, "Error while updating SmartInventory:", exception);
    }
 
    @SuppressWarnings("unchecked")
    class InvListener implements Listener {
 
        @EventHandler(priority = EventPriority.LOW)
        public void onInventoryClick(InventoryClickEvent e) {
            Player p = (Player) e.getWhoClicked();
 
            Bukkit.getConsoleSender().sendMessage(NamedTextColor.RED + "looking for inventory");
 
            if (!inventories.containsKey(p.getUniqueId()))
                return;
 
            Inventory clickedInventory = e.getClickedInventory();
            SmartInventory smartInventory = inventories.get(p.getUniqueId());
 
            // Restrict putting items from the bottom inventory into the top inventory
 
            Bukkit.getConsoleSender().sendMessage(NamedTextColor.RED + "checking is bottom clickable");
            if(!smartInventory.getBottomClickable()){
                Bukkit.getConsoleSender().sendMessage(NamedTextColor.RED + "checking Is bottom ivnentory");
                if (clickedInventory == p.getOpenInventory().getBottomInventory()) {
                    Bukkit.getConsoleSender().sendMessage(NamedTextColor.RED + "Is bottom ivnentory");
                    if (e.getAction() == InventoryAction.COLLECT_TO_CURSOR || e.getAction() == InventoryAction.MOVE_TO_OTHER_INVENTORY) {
                        int slot = e.getSlot();
                        if(!smartInventory.getClickableTiles().contains(slot)) e.setCancelled(true);
                        return;
                    }
 
                    if (e.getAction() == InventoryAction.NOTHING && e.getClick() != ClickType.MIDDLE) {
                        e.setCancelled(true);
                        return;
                    }
                }
            }
 
            Bukkit.getConsoleSender().sendMessage(NamedTextColor.RED + "checking top ivnentory");
            if (clickedInventory == p.getOpenInventory().getTopInventory()) {
                int slot = e.getSlot();
                Bukkit.getConsoleSender().sendMessage(NamedTextColor.RED + "Is top ivnentory");
                if(!smartInventory.getClickableTiles().contains(slot)){
                    e.setCancelled(true);
 
                    int row = e.getSlot() / 9;
                    int column = e.getSlot() % 9;
 
                    if (row < 0 || column < 0)
                        return;
 
                    SmartInventory inv = inventories.get(p.getUniqueId());
 
                    if (row >= inv.getRows() || column >= inv.getColumns())
                        return;
 
                    Bukkit.getConsoleSender().sendMessage(NamedTextColor.RED + "FIRE CLICK");
                    inv.getListeners().stream()
                            .filter(listener -> listener.getType() == InventoryClickEvent.class)
                            .forEach(listener -> ((InventoryListener<InventoryClickEvent>) listener).accept(e));
 
                    contents.get(p.getUniqueId()).get(row, column).ifPresent(item -> item.run(e));
 
                    p.updateInventory();
                }
            }
        }
 
        @EventHandler(priority = EventPriority.LOW)
        public void onInventoryDrag(InventoryDragEvent e) {
            Player p = (Player) e.getWhoClicked();
 
            if (!inventories.containsKey(p.getUniqueId()))
                return;
 
            SmartInventory smartInventory = inventories.get(p.getUniqueId());
 
            for (int slot : e.getRawSlots()) {
                if (slot >= p.getOpenInventory().getTopInventory().getSize())
                    continue;
 
                if(!smartInventory.getClickableTiles().contains(slot)) e.setCancelled(true);
                break;
            }
 
            smartInventory.getListeners().stream()
                    .filter(listener -> listener.getType() == InventoryDragEvent.class)
                    .forEach(listener -> ((InventoryListener<InventoryDragEvent>) listener).accept(e));
        }
 
        @EventHandler(priority = EventPriority.LOW)
        public void onInventoryOpen(InventoryOpenEvent e) {
            Player p = (Player) e.getPlayer();
 
            if (!inventories.containsKey(p.getUniqueId()))
                return;
 
            SmartInventory inv = inventories.get(p.getUniqueId());
 
            inv.getListeners().stream()
                    .filter(listener -> listener.getType() == InventoryOpenEvent.class)
                    .forEach(listener -> ((InventoryListener<InventoryOpenEvent>) listener).accept(e));
        }
 
        @EventHandler(priority = EventPriority.LOW)
        public void onInventoryClose(InventoryCloseEvent e) {
            Player p = (Player) e.getPlayer();
 
            if (!inventories.containsKey(p.getUniqueId()))
                return;
 
            SmartInventory inv = inventories.get(p.getUniqueId());
 
            inv.getListeners().stream()
                    .filter(listener -> listener.getType() == InventoryCloseEvent.class)
                    .forEach(listener -> ((InventoryListener<InventoryCloseEvent>) listener).accept(e));
 
            inv.getProvider().closeinventory(p, contents.get(p.getUniqueId()), e.getView().getTopInventory());
 
            if (inv.isCloseable()) {
                e.getInventory().clear();
                inventories.remove(p.getUniqueId());
                contents.remove(p.getUniqueId());
            } else
                Bukkit.getScheduler().runTask(plugin, () -> p.openInventory(e.getInventory()));
        }
 
        @EventHandler(priority = EventPriority.LOW)
        public void onPlayerQuit(PlayerQuitEvent e) {
            Player p = e.getPlayer();
 
            if (!inventories.containsKey(p.getUniqueId()))
                return;
 
            SmartInventory inv = inventories.get(p.getUniqueId());
 
            inv.getListeners().stream()
                    .filter(listener -> listener.getType() == PlayerQuitEvent.class)
                    .forEach(listener -> ((InventoryListener<PlayerQuitEvent>) listener).accept(e));
 
            inventories.remove(p.getUniqueId());
            contents.remove(p.getUniqueId());
        }
 
        @EventHandler(priority = EventPriority.LOW)
        public void onPluginDisable(PluginDisableEvent e) {
            new HashMap<>(inventories).forEach((player, inv) -> {
                inv.getListeners().stream()
                        .filter(listener -> listener.getType() == PluginDisableEvent.class)
                        .forEach(listener -> ((InventoryListener<PluginDisableEvent>) listener).accept(e));
 
                inv.close(Bukkit.getPlayer(player));
            });
 
            inventories.clear();
            contents.clear();
        }
 
    }
 
    class InvTask extends BukkitRunnable {
 
        @Override
        public void run() {
            new HashMap<>(inventories).forEach((uuid, inv) -> {
                Player player = Bukkit.getPlayer(uuid);
 
                try {
                    inv.getProvider().update(player, contents.get(uuid));
                } catch (Exception e) {
                    handleInventoryUpdateError(inv, player, e);
                }
            });
        }
 
    }
}