Maxpro Lets

.ja

Kodari AI
KodariOct 3 at 3:35 pm 1

Did you mean Java? What would you like me to do with the project?

Kodari can make mistakes. Review important code before using.
Files
src
pom.xml
Code
4 364
src/main/java/com/maxpro/maxspawner/MaxSpawner.java
package com.maxpro.maxspawner;

import org.bukkit.*;
import org.bukkit.block.Block;
import org.bukkit.block.CreatureSpawner;
import org.bukkit.command.*;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.block.Action;
import org.bukkit.event.entity.SpawnerSpawnEvent;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.persistence.PersistentDataType;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;

import java.util.*;

public class MaxSpawner extends JavaPlugin implements Listener, CommandExecutor, TabCompleter {
    private static final String TITLE = "§8MaxSpawner • ";
    private static final int GUI_SIZE = 54;
    private final Map<String, SpawnerData> spawners = new HashMap<>();
    private final Map<String, Map<Material,Integer>> lootTable = new LinkedHashMap<>();
    private NamespacedKey itemKey, typeKey;
    private int interval;

    @Override public void onEnable() {
        saveDefaultConfig();
        itemKey = new NamespacedKey(this, "spawner_item");
        typeKey = new NamespacedKey(this, "spawner_type");
        interval = Math.max(1, getConfig().getInt("interval-seconds", 40));
        loadLootTable(); loadSpawners();
        Bukkit.getPluginManager().registerEvents(this, this);
        PluginCommand cmd = getCommand("spawner");
        if (cmd != null) { cmd.setExecutor(this); cmd.setTabCompleter(this); }
        new BukkitRunnable() { public void run() { tick(); } }.runTaskTimer(this, 20L, 20L);
        getLogger().info("MaxSpawner enabled. Interval=" + interval + "s, tracked=" + spawners.size());
    }

    @Override public void onDisable() { saveSpawners(); }

    private void loadLootTable() {
        lootTable.clear();
        addLoot("ZOMBIE", "ROTTEN_FLESH", 4, "IRON_INGOT", 1);
        addLoot("SKELETON", "BONE", 4, "ARROW", 4);
        addLoot("CREEPER", "GUNPOWDER", 4);
        addLoot("IRON_GOLEM", "IRON_INGOT", 4, "POPPY", 1);
        addLoot("BLAZE", "BLAZE_ROD", 2);
        addLoot("ENDERMAN", "ENDER_PEARL", 2);
        addLoot("PIG", "PORKCHOP", 4);
        addLoot("COW", "BEEF", 4, "LEATHER", 2);
        addLoot("CHICKEN", "CHICKEN", 4, "FEATHER", 4);
        addLoot("SHEEP", "MUTTON", 4, "WHITE_WOOL", 2);
        addLoot("ZOMBIFIED_PIGLIN", "ROTTEN_FLESH", 4, "GOLD_NUGGET", 2);
    }

    private void addLoot(String type, Object... values) {
        Map<Material,Integer> map = new LinkedHashMap<>();
        for (int i = 0; i + 1 < values.length; i += 2) {
            Material m = Material.matchMaterial(String.valueOf(values[i]));
            if (m == null) continue;
            int amount = Math.max(1, ((Number) values[i + 1]).intValue());
            map.put(m, amount);
        }
        lootTable.put(type, map);
    }

    private String key(Location l) {
        return l.getWorld().getUID() + ":" + l.getBlockX() + ":" + l.getBlockY() + ":" + l.getBlockZ();
    }
    private String key(Block b) { return key(b.getLocation()); }

    private void loadSpawners() {
        spawners.clear();
        java.io.File f = new java.io.File(getDataFolder(), "spawners.data");
        if (!f.exists()) return;
        try (java.io.BufferedReader r = new java.io.BufferedReader(new java.io.FileReader(f))) {
            String line;
            while ((line = r.readLine()) != null) {
                if (line.isBlank() || line.startsWith("#")) continue;
                String[] a = line.split("\\|", -1);
                if (a.length < 7) continue;
                try {
                    UUID uid = UUID.fromString(a[1]);
                    int x = Integer.parseInt(a[2]);
                    int y = Integer.parseInt(a[3]);
                    int z = Integer.parseInt(a[4]);
                    String type = a[5].toUpperCase(Locale.ROOT);
                    long next = Long.parseLong(a[6]);
                    List<ItemStack> stored = decodeLoot(a.length >= 8 ? a[7] : "");
                    spawners.put(a[0], new SpawnerData(uid, x, y, z, type, next, stored));
                } catch (Exception ignored) {}
            }
        } catch (Exception ex) {
            getLogger().warning("Could not load spawners.data: " + ex.getMessage());
        }
    }

    private void saveSpawners() {
        if (!getDataFolder().exists()) getDataFolder().mkdirs();
        java.io.File f = new java.io.File(getDataFolder(), "spawners.data");
        java.io.File tmp = new java.io.File(getDataFolder(), "spawners.data.tmp");
        try (java.io.PrintWriter w = new java.io.PrintWriter(new java.io.BufferedWriter(new java.io.FileWriter(tmp)))) {
            w.println("# MaxSpawner data v2");
            for (SpawnerData d : spawners.values()) {
                w.println(d.key() + "|" + d.world + "|" + d.x + "|" + d.y + "|" + d.z + "|" + d.type + "|" + d.next + "|" + encodeLoot(d.loot));
            }
        } catch (Exception ex) {
            getLogger().warning("Could not save spawners.data: " + ex.getMessage());
            return;
        }
        if (!tmp.renameTo(f)) {
            try {
                java.nio.file.Files.move(tmp.toPath(), f.toPath(), java.nio.file.StandardCopyOption.REPLACE_EXISTING, java.nio.file.StandardCopyOption.ATOMIC_MOVE);
            } catch (Exception ignored) {
                try { java.nio.file.Files.move(tmp.toPath(), f.toPath(), java.nio.file.StandardCopyOption.REPLACE_EXISTING); } catch (Exception ignored2) {}
            }
        }
    }

    private String encodeLoot(List<ItemStack> loot) {
        StringBuilder b = new StringBuilder();
        for (ItemStack i : loot) {
            if (i == null || i.getType() == Material.AIR) continue;
            if (b.length() > 0) b.append(',');
            b.append(i.getType().name()).append(':').append(itemAmount(i));
        }
        return b.toString();
    }


    private int itemAmount(ItemStack i) {
        try { return ((Number) i.getClass().getMethod("getAmount").invoke(i)).intValue(); }
        catch (Exception ignored) { return 1; }
    }
    private List<ItemStack> decodeLoot(String value) {
        List<ItemStack> list = new ArrayList<>();
        if (value == null || value.isBlank()) return list;
        for (String part : value.split(",")) {
            String[] a = part.split(":", 2);
            if (a.length != 2) continue;
            Material m = Material.matchMaterial(a[0]);
            try {
                int amount = Integer.parseInt(a[1]);
                if (m != null && amount > 0) list.add(new ItemStack(m, Math.min(amount, m.getMaxStackSize())));
            } catch (Exception ignored) {}
        }
        return list;
    }

    private boolean isShopSpawner(ItemStack item) {
        if (item == null || item.getType() != Material.SPAWNER || !item.hasItemMeta()) return false;
        var pdc = item.getItemMeta().getPersistentDataContainer();
        // MaxShopGUI's existing shop items use these keys. No dependency is required.
        NamespacedKey shopMarker = new NamespacedKey("maxshopgui", "money_spawner");
        NamespacedKey shopType = new NamespacedKey("maxshopgui", "spawner_type");
        return pdc.has(shopMarker, PersistentDataType.BYTE) && pdc.has(shopType, PersistentDataType.STRING);
    }
    private String itemType(ItemStack item) {
        if (item == null || !item.hasItemMeta()) return "";
        var pdc = item.getItemMeta().getPersistentDataContainer();
        String t = pdc.get(typeKey, PersistentDataType.STRING);
        if (t != null) return t.toUpperCase(Locale.ROOT);
        t = pdc.get(new NamespacedKey("maxshopgui", "spawner_type"), PersistentDataType.STRING);
        return t == null ? "" : t.toUpperCase(Locale.ROOT);
    }

    public ItemStack createSpawnerItem(String type) {
        type = type.toUpperCase(Locale.ROOT);
        ItemStack item = new ItemStack(Material.SPAWNER);
        ItemMeta meta = item.getItemMeta();
        meta.setDisplayName("§d" + pretty(type) + " Spawner");
        meta.setLore(List.of("§7MaxSpawner", "§7Place and right-click to open the loot GUI", "§7Loot every §e" + interval + " seconds", "§7Silk Touch required to break"));
        meta.getPersistentDataContainer().set(itemKey, PersistentDataType.BYTE, (byte)1);
        meta.getPersistentDataContainer().set(typeKey, PersistentDataType.STRING, type);
        item.setItemMeta(meta); return item;
    }

    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onPlace(BlockPlaceEvent e) {
        ItemStack item = e.getItemInHand();
        if (item.getType() != Material.SPAWNER) return;
        String type = itemType(item);
        if (type.isBlank() || !lootTable.containsKey(type)) return;
        Block b = e.getBlockPlaced();
        if (b.getState() instanceof CreatureSpawner cs) {
            try { cs.setSpawnedType(EntityType.valueOf(type)); } catch (Exception ignored) {}
            cs.setDelay(999999); cs.setMinSpawnDelay(999999); cs.setMaxSpawnDelay(999999); cs.update(true, false);
        }
        long next = System.currentTimeMillis() + interval * 1000L;