Untitled

package com.example.breakplugin;

import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerItemConsumeEvent;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.ChatColor;

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

public class Main extends JavaPlugin implements Listener {

    private FileConfiguration config;
    private Map<Player, Long> lastBreakTime; // Czas ostatniego wykopania bloku
    private Map<Player, Long> breakCooldown; // Czas końca przerwy
    private Map<Player, Boolean> hasStartedBreak; // Czy rozpoczęto liczenie czasu do przerwy
    private Map<Player, Boolean> warnedAboutBreak; // Flaga ostrzeżenia o przerwie
    private long blockBreakInterval; // Czas do przerwy
    private long breakResetTime; // Czas przerwy
    private long warningTime; // Czas ostrzeżenia przed przerwą

    @Override
    public void onEnable() {
        saveDefaultConfig();
        config = getConfig();
        blockBreakInterval = config.getLong("block-break-interval") * 60 * 1000; // w milisekundach
        breakResetTime = config.getLong("break-reset-time") * 60 * 1000; // w milisekundach
        warningTime = config.getLong("warning-time") * 60 * 1000; // w milisekundach

        lastBreakTime = new HashMap<>();
        breakCooldown = new HashMap<>();
        hasStartedBreak = new HashMap<>();
        warnedAboutBreak = new HashMap<>();

        getServer().getPluginManager().registerEvents(this, this);
        getCommand("przerwa").setExecutor((sender, command, label, args) -> {
            if (sender instanceof Player) {
                Player player = (Player) sender;
                long remainingTime = getRemainingBreakTime(player);
                long currentTime = System.currentTimeMillis();

                if (breakCooldown.containsKey(player)) {
                    long cooldownEnd = breakCooldown.get(player);
                    if (currentTime < cooldownEnd) {
                        player.sendMessage(ChatColor.RED + "Jesteś w przerwie! Pozostało " + formatTime(cooldownEnd - currentTime) + " do jej zakończenia.");
                    } else {
                        player.sendMessage(ChatColor.GREEN + "Przerwa zakończona. Możesz teraz kopać bloki.");
                        breakCooldown.remove(player); // Usuń z mapy po zakończeniu przerwy
                        hasStartedBreak.put(player, false); // Ustaw flagę na false
                        warnedAboutBreak.put(player, false); // Resetuj flagę ostrzeżenia
                        lastBreakTime.remove(player); // Resetuj czas ostatniego wykopania
                    }
                } else if (lastBreakTime.containsKey(player)) {
                    long timeSinceLastBreak = currentTime - lastBreakTime.get(player);
                    if (timeSinceLastBreak < blockBreakInterval) {
                        player.sendMessage(ChatColor.GREEN + "Czas do przerwy: " + formatTime(blockBreakInterval - timeSinceLastBreak));
                    } else {
                        player.sendMessage(ChatColor.GREEN + "Czas do przerwy już minął.");
                    }
                } else {
                    player.sendMessage(ChatColor.RED + "Nie rozpocząłeś jeszcze liczenia czasu do przerwy.");
                }
            } else {
                sender.sendMessage(ChatColor.RED + "Ta komenda jest dostępna tylko dla graczy.");
            }
            return true;
        });

        // Monitorowanie graczy i wysyłanie ostrzeżeń o przerwie
        new BukkitRunnable() {
            @Override
            public void run() {
                long currentTime = System.currentTimeMillis();

                for (Player player : Bukkit.getOnlinePlayers()) {
                    if (lastBreakTime.containsKey(player) && !breakCooldown.containsKey(player)) {
                        long timeSinceLastBreak = currentTime - lastBreakTime.get(player);

                        if (timeSinceLastBreak >= blockBreakInterval - warningTime && timeSinceLastBreak < blockBreakInterval) {
                            if (!warnedAboutBreak.getOrDefault(player, false)) {
                                long timeLeft = blockBreakInterval - timeSinceLastBreak;
                                player.sendMessage(ChatColor.RED + "Uwaga! Kopiesz już od dłuższego czasu. Za " + formatTime(timeLeft) + " będziesz musiał odpocząć.");
                                warnedAboutBreak.put(player, true); // Ustaw flagę, że ostrzeżenie zostało wysłane
                            }
                        }

                        if (timeSinceLastBreak >= blockBreakInterval) {
                            // Rozpocznij przerwę, jeśli gracz nie jest jeszcze w przerwie
                            if (!breakCooldown.containsKey(player)) {
                                breakCooldown.put(player, currentTime + breakResetTime);
                                hasStartedBreak.put(player, true); // Ustaw flagę, że przerwa się rozpoczęła
                                warnedAboutBreak.put(player, false); // Resetuj flagę ostrzeżenia
                                player.sendMessage(ChatColor.RED + "Przerwa! Musisz odczekać " + formatTime(breakResetTime) + " przed ponownym kopaniem.");
                            }
                        }
                    }
                }
            }
        }.runTaskTimer(this, 0L, 20L * 5); // co 5 sekund
    }

    @EventHandler
    public void onBlockBreak(BlockBreakEvent event) {
        Player player = event.getPlayer();
        Material blockType = event.getBlock().getType();

        long currentTime = System.currentTimeMillis();

        // Jeśli gracz jest w przerwie, zablokuj kopanie i zresetuj timer
        if (breakCooldown.containsKey(player)) {
            long cooldownEnd = breakCooldown.get(player);
            if (currentTime < cooldownEnd) {
                event.setCancelled(true);
                player.sendMessage(ChatColor.RED + "Jesteś w przerwie! Musisz odczekać przed ponownym kopaniem.");
                // Resetuj czas przerwy na nowo, jeśli gracz spróbuje wykopać blok podczas przerwy
                breakCooldown.put(player, currentTime + breakResetTime);
                player.sendMessage(ChatColor.RED + "Czas przerwy został przedłużony. Musisz odczekać dodatkowe " + formatTime(breakResetTime) + " przed ponownym kopaniem.");
                return;
            }
        }

        // Jeśli blok jest typu naturalnie wykopującego się kilofem
        if (isBreakableByPickaxe(blockType)) {
            // Jeśli czas ostatniego wykopania bloku nie jest zapisany, oznacza to rozpoczęcie liczenia
            if (!lastBreakTime.containsKey(player)) {
                lastBreakTime.put(player, currentTime);
                hasStartedBreak.put(player, true); // Ustaw flagę, że rozpoczęto liczenie czasu do przerwy
                warnedAboutBreak.put(player, false); // Resetuj flagę ostrzeżenia
                player.sendMessage(ChatColor.GREEN + "Rozpoczęto liczenie czasu do przerwy.");
            } else {
                // Resetowanie czasu przerwy tylko, gdy gracz nie jest w przerwie
                if (!hasStartedBreak.getOrDefault(player, false)) {
                    lastBreakTime.put(player, currentTime);
                }
            }
        }
    }


    @EventHandler
    public void onPlayerInteract(PlayerInteractEvent event) {
        Player player = event.getPlayer();
        Material blockType = event.getClickedBlock() != null ? event.getClickedBlock().getType() : null;

        // Jeśli blok jest naturalnie kopalny kilofem i gracz jest w przerwie
        if (blockType != null && isBreakableByPickaxe(blockType)) {
            if (breakCooldown.containsKey(player)) {
                long currentTime = System.currentTimeMillis();
                long cooldownEnd = breakCooldown.get(player);
                if (currentTime < cooldownEnd) {
                    event.setCancelled(true);
                    player.sendMessage(ChatColor.RED + "Jesteś w przerwie! Musisz odczekać przed ponownym kopaniem.");
                }
            }
        }
    }

    @EventHandler
    public void onPlayerEat(PlayerItemConsumeEvent event) {
        Player player = event.getPlayer();
        long currentTime = System.currentTimeMillis();

        // Jeśli gracz jest w przerwie, przedłuż przerwę
        if (breakCooldown.containsKey(player)) {
            long cooldownEnd = breakCooldown.get(player);
            if (currentTime < cooldownEnd) {
                breakCooldown.put(player, cooldownEnd + breakResetTime);
                player.sendMessage(ChatColor.GREEN + "Odczekałeś przerwę. Musisz teraz poczekać " + formatTime(breakResetTime) + " przed ponownym kopaniem.");
            }
        }
    }

    private boolean isBreakableByPickaxe(Material material) {
        // Bloki, które naturalnie wykopuje się kilofem
        switch (material) {
            case STONE:
            case IRON_ORE:
            case GOLD_ORE:
            case DIAMOND_ORE:
            case EMERALD_ORE:
            case REDSTONE_ORE:
            case LAPIS_ORE:
            case DEEPSLATE:
            case DEEPSLATE_COAL_ORE:
            case DEEPSLATE_IRON_ORE:
            case DEEPSLATE_GOLD_ORE:
            case DEEPSLATE_DIAMOND_ORE:
            case DEEPSLATE_EMERALD_ORE:
            case DEEPSLATE_REDSTONE_ORE:
            case DEEPSLATE_LAPIS_ORE:
            case OBSIDIAN:
                return true;
            default:
                return false;
        }
    }

    private String formatTime(long millis) {
        long seconds = millis / 1000;
        long minutes = seconds / 60;
        long hours = minutes / 60;
        seconds %= 60;
        minutes %= 60;

        return String.format("%02d:%02d:%02d", hours, minutes, seconds);
    }

    private long getRemainingBreakTime(Player player) {
        if (breakCooldown.containsKey(player)) {
            long currentTime = System.currentTimeMillis();
            long timeLeft = breakCooldown.get(player) - currentTime;
            return timeLeft > 0 ? timeLeft : 0;
        }
        return 0;
    }
}