Untitled

avatar
unknown
java
5 months ago
12 kB
4
Indexable
package de.cozy.worldguardaddon.oraxen;

import io.th0rgal.oraxen.OraxenPlugin;
import io.th0rgal.oraxen.mechanics.Mechanic;
import io.th0rgal.oraxen.mechanics.MechanicFactory;
import org.bukkit.NamespacedKey;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.persistence.PersistentDataType;

public class CustomSmelterMechanic extends Mechanic {

    // Definiere NAMESPACED_KEY als public static final
    public static final NamespacedKey NAMESPACED_KEY = new NamespacedKey(OraxenPlugin.get(), "custom_smelter");

    public CustomSmelterMechanic(MechanicFactory mechanicFactory, ConfigurationSection section) {
        super(mechanicFactory, section,
                item -> item.setCustomTag(NAMESPACED_KEY, PersistentDataType.STRING, "custom_smelter"));
    }
}



package de.cozy.worldguardaddon.oraxen;

import io.th0rgal.oraxen.mechanics.Mechanic;
import io.th0rgal.oraxen.mechanics.MechanicFactory;
import org.bukkit.configuration.ConfigurationSection;

public class CustomSmelterMechanicFactory extends MechanicFactory {

    // Konstruktor erwartet ConfigurationSection
    public CustomSmelterMechanicFactory(ConfigurationSection section) {
        super(section);
        // Optional: Hier spezifische Listener registrieren, falls notwendig
    }

    @Override
    public Mechanic parse(ConfigurationSection itemMechanicConfiguration) {
        CustomSmelterMechanic mechanic = new CustomSmelterMechanic(this, itemMechanicConfiguration);
        addToImplemented(mechanic);
        return mechanic;
    }
}


package de.cozy.worldguardaddon.oraxen;

import io.th0rgal.oraxen.OraxenPlugin;
import io.th0rgal.oraxen.api.OraxenItems;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.block.Block;
import org.bukkit.block.TileState;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.inventory.*;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.*;
import org.bukkit.persistence.PersistentDataType;
import org.bukkit.scheduler.BukkitRunnable;

import java.util.HashMap;
import java.util.Map;

public class CustomSmelterMechanicListener implements Listener {

    private final CustomSmelterMechanicFactory factory;
    private final Map<Block, CustomSmelterInventory> smelterInventories = new HashMap<>();

    public CustomSmelterMechanicListener(CustomSmelterMechanicFactory factory) {
        this.factory = factory;
    }

    @EventHandler
    public void onPlayerInteract(PlayerInteractEvent event) {
        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
        Block block = event.getClickedBlock();
        if (block == null) return;

        // Überprüfe, ob der Block unsere Mechanik hat
        if (!isCustomSmelterBlock(block)) return;

        event.setCancelled(true);
        Player player = event.getPlayer();

        CustomSmelterInventory smelterInventory = smelterInventories.computeIfAbsent(block, b -> new CustomSmelterInventory(block));
        smelterInventory.open(player);
    }

    // Event-Handler für Inventar-Klicks und Schließen des Inventars
    @EventHandler
    public void onInventoryClick(InventoryClickEvent event) {
        if (!(event.getInventory().getHolder() instanceof CustomSmelterInventory)) return;

        CustomSmelterInventory smelterInventory = (CustomSmelterInventory) event.getInventory().getHolder();
        smelterInventory.handleInventoryClick(event);
    }

    @EventHandler
    public void onInventoryClose(InventoryCloseEvent event) {
        if (!(event.getInventory().getHolder() instanceof CustomSmelterInventory)) return;

        CustomSmelterInventory smelterInventory = (CustomSmelterInventory) event.getInventory().getHolder();
        smelterInventory.handleInventoryClose(event);
    }

    private boolean isCustomSmelterBlock(Block block) {
        if (!(block.getState() instanceof TileState)) return false;
        TileState tileState = (TileState) block.getState();
        // Zugriff auf NAMESPACED_KEY aus CustomSmelterMechanic
        return tileState.getPersistentDataContainer().has(CustomSmelterMechanic.NAMESPACED_KEY, PersistentDataType.STRING);
    }

    // Innere Klasse oder separate Klasse für CustomSmelterInventory
    public class CustomSmelterInventory implements InventoryHolder {

        private final Inventory inventory;
        private final Block smelterBlock;
        private SmeltingProcess smeltingProcess;

        // Definiere die Slots
        private final int INPUT_SLOT = 0;
        private final int FUEL_SLOT = 1;
        private final int OUTPUT_SLOT = 2;

        public CustomSmelterInventory(Block smelterBlock) {
            this.smelterBlock = smelterBlock;
            this.inventory = Bukkit.createInventory(this, InventoryType.FURNACE, ChatColor.GOLD + "Netherit-Schmelzofen");

            // Starte den Schmelzprozess
            startSmeltingProcess();
        }

        @Override
        public Inventory getInventory() {
            return inventory;
        }

        public void open(Player player) {
            player.openInventory(inventory);
        }

        public void handleInventoryClick(InventoryClickEvent event) {
            int slot = event.getRawSlot();

            // Verhindere unerlaubte Aktionen
            if (slot != INPUT_SLOT && slot != FUEL_SLOT && slot != OUTPUT_SLOT) {
                event.setCancelled(true);
                return;
            }

            // Verhindere, dass Spieler Items in den Ausgabe-Slot legen
            if (slot == OUTPUT_SLOT && (event.isShiftClick() || event.getCursor() != null)) {
                event.setCancelled(true);
            }
        }

        public void handleInventoryClose(InventoryCloseEvent event) {
            // Optional: Schmelzprozess stoppen, wenn kein Spieler mehr das Inventar betrachtet
            if (inventory.getViewers().isEmpty()) {
                stopSmeltingProcess();
            }
        }

        private void startSmeltingProcess() {
            smeltingProcess = new SmeltingProcess(this);
            smeltingProcess.runTaskTimerAsynchronously(OraxenPlugin.get(), 0L, 20L); // Läuft jede Sekunde
        }

        private void stopSmeltingProcess() {
            if (smeltingProcess != null) {
                smeltingProcess.cancel();
            }
        }

        // Getter und Setter für die Slots wie zuvor

        // Innere Klasse für den Schmelzprozess
        public class SmeltingProcess extends BukkitRunnable {

            private final CustomSmelterInventory smelterInventory;
            private int smeltTime = 0;
            private int fuelTime = 0;
            private final int maxSmeltTime = 200; // Beispielwert für Schmelzzeit
            private final int maxFuelTime = 600;  // Beispielwert für Brenndauer

            public SmeltingProcess(CustomSmelterInventory smelterInventory) {
                this.smelterInventory = smelterInventory;
            }

            @Override
            public void run() {
                // Schmelzlogik wie zuvor
            }
        }
    }
}


package de.cozy.worldguardaddon.oraxen;

import de.cozy.worldguardaddon.Main;
import io.th0rgal.oraxen.api.OraxenItems;
import io.th0rgal.oraxen.api.events.OraxenNativeMechanicsRegisteredEvent;
import io.th0rgal.oraxen.mechanics.MechanicsManager;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.plugin.java.JavaPlugin;

public class MechanicRegisterListener implements Listener {

    @EventHandler
    public void onMechanicRegister(OraxenNativeMechanicsRegisteredEvent event) {
        // Verwende hier einen Lambda-Ausdruck mit dem passenden Typ
        MechanicsManager.registerMechanicFactory("custom_smelter", section -> {
            return new CustomSmelterMechanicFactory(section);
        }, true);

        // Lade die Items neu, um den Mechanic anzuwenden
        OraxenItems.loadItems();

        // Registriere den CustomSmelterMechanicListener nach der Registrierung
        CustomSmelterMechanicFactory factory = (CustomSmelterMechanicFactory) MechanicsManager.getMechanicFactory("custom_smelter");
        if (factory != null) {
            Bukkit.getPluginManager().registerEvents(new CustomSmelterMechanicListener(factory), JavaPlugin.getPlugin(Main.class));
        }
    }
}


package de.cozy.worldguardaddon;

import de.cozy.worldguardaddon.Listener.PortalWarpListener;
import de.cozy.worldguardaddon.Listener.VoidFallingListener;
import de.cozy.worldguardaddon.Manager.FlagManager;
import de.cozy.worldguardaddon.Manager.PlaceholderManager;
import de.cozy.worldguardaddon.Manager.StatsManager;
import de.cozy.worldguardaddon.Scripts.DataCreation;
import de.cozy.worldguardaddon.adminmode.adminmode;
import de.cozy.worldguardaddon.buildmode.OnBuildInteract;
import de.cozy.worldguardaddon.buildmode.OnJL;
import de.cozy.worldguardaddon.buildmode.buildmode;
import de.cozy.worldguardaddon.dungeons.DungeonChecker;
import de.cozy.worldguardaddon.dungeons.DungeonScoreboardManager;
import de.cozy.worldguardaddon.dungeons.DungeonStatsListener;
import de.cozy.worldguardaddon.oraxen.MechanicRegisterListener;
import de.cozy.worldguardaddon.pvp.CombatManager;
import de.cozy.worldguardaddon.pvp.PvPChecker;
import de.cozy.worldguardaddon.pvp.PvPScoreboardManager;
import de.cozy.worldguardaddon.pvp.StatsListener;
import org.bukkit.Bukkit;
import org.bukkit.plugin.java.JavaPlugin;

public final class Main extends JavaPlugin {

    private PvPScoreboardManager pvpScoreboardManager; // Instanzvariable für PvPScoreboardManager
    private DungeonScoreboardManager dungeonScoreboardManager; // Instanzvariable für DungeonScoreboardManager
    private static Main instance;

    @Override
    public void onLoad() {
        DataCreation.create();
        FlagManager.InitializeWG(); // Initialisiere WorldGuard-Flags
    }

    @Override
    public void onEnable() {
        instance = this;

        Bukkit.getPluginManager().registerEvents(new MechanicRegisterListener(), this);

        saveDefaultConfig();
        FlagManager.Initialize();

        CombatManager.loadCombatTime(getConfig());

        pvpScoreboardManager = new PvPScoreboardManager(getConfig());
        dungeonScoreboardManager = new DungeonScoreboardManager(getConfig());

        // Registriere Events und Listener
        PvPChecker pvpChecker = new PvPChecker(this, pvpScoreboardManager);
        Bukkit.getPluginManager().registerEvents(pvpChecker, this);

        DungeonChecker dungeonChecker = new DungeonChecker(this, dungeonScoreboardManager);
        Bukkit.getPluginManager().registerEvents(dungeonChecker, this);

        Bukkit.getPluginManager().registerEvents(new OnBuildInteract(), this);
        Bukkit.getPluginManager().registerEvents(new OnJL(), this);
        Bukkit.getPluginManager().registerEvents(new StatsListener(), this);
        Bukkit.getPluginManager().registerEvents(new DungeonStatsListener(), this);
        Bukkit.getPluginManager().registerEvents(new VoidFallingListener(), this);
        Bukkit.getPluginManager().registerEvents(new PortalWarpListener(this), this);

        StatsManager.setup();
        new PlaceholderManager().register();

        getCommand("buildmode").setExecutor(new buildmode());
        getCommand("adminmode").setExecutor(new adminmode());
    }


    @Override
    public void onDisable() {
        // Nachricht in der Konsole bei Plugin-Disable
        Bukkit.getConsoleSender().sendMessage("§7[§8§lWorldguardAddon§7]§c Good bye!");
    }

    public static Main getInstance() {
        return instance;
    }
}
Editor is loading...
Leave a Comment