package com.seacurse.managers; import com.seacurse.SeaCursePlugin; import org.bukkit.Bukkit; import org.bukkit.Chunk; import org.bukkit.Material; import org.bukkit.World; import org.bukkit.block.Block; import org.bukkit.configuration.file.FileConfiguration; import org.bukkit.configuration.file.YamlConfiguration; import org.bukkit.scheduler.BukkitTask; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class TsunamiManager { private final SeaCursePlugin plugin; private final File dataFile; private final File blocksFile; private FileConfiguration dataConfig; private long nextTsunamiTick; private long tsunamiEndTick; private boolean tsunamiActive; private BukkitTask schedulerTask; private Map savedBlocks = new HashMap<>(); public TsunamiManager(SeaCursePlugin plugin) { this.plugin = plugin; this.dataFile = new File(plugin.getDataFolder(), "tsunami_data.yml"); this.blocksFile = new File(plugin.getDataFolder(), "tsunami_blocks.yml"); loadData(); } private void loadData() { if (!dataFile.exists()) { try { dataFile.getParentFile().mkdirs(); dataFile.createNewFile(); } catch (IOException e) { e.printStackTrace(); } } dataConfig = YamlConfiguration.loadConfiguration(dataFile); World world = Bukkit.getWorlds().get(0); long currentTick = world.getFullTime(); if (dataConfig.contains("next_tsunami_tick")) { nextTsunamiTick = dataConfig.getLong("next_tsunami_tick"); tsunamiEndTick = dataConfig.getLong("tsunami_end_tick", 0); tsunamiActive = dataConfig.getBoolean("tsunami_active", false); } else { int days = plugin.getConfig().getInt("tsunami.interval-days", 7); nextTsunamiTick = currentTick + (days * 24000L); tsunamiEndTick = 0; tsunamiActive = false; saveData(); } if (tsunamiActive && currentTick >= tsunamiEndTick) { endTsunami(); } else if (tsunamiActive) { loadSavedBlocks(); } } public void saveData() { dataConfig.set("next_tsunami_tick", nextTsunamiTick); dataConfig.set("tsunami_end_tick", tsunamiEndTick); dataConfig.set("tsunami_active", tsunamiActive); try { dataConfig.save(dataFile); } catch (IOException e) { e.printStackTrace(); } } private void loadSavedBlocks() { if (!blocksFile.exists()) return; FileConfiguration blocksConfig = YamlConfiguration.loadConfiguration(blocksFile); for (String key : blocksConfig.getKeys(false)) { String matName = blocksConfig.getString(key); try { savedBlocks.put(key, Material.valueOf(matName)); } catch (Exception ignored) {} } } private void saveSavedBlocks() { try { if (!blocksFile.exists()) { blocksFile.getParentFile().mkdirs(); blocksFile.createNewFile(); } FileConfiguration blocksConfig = new YamlConfiguration(); for (Map.Entry entry : savedBlocks.entrySet()) { blocksConfig.set(entry.getKey(), entry.getValue().name()); } blocksConfig.save(blocksFile); } catch (IOException e) { e.printStackTrace(); } } public void startScheduler() { schedulerTask = Bukkit.getScheduler().runTaskTimer(plugin, () -> { World world = Bukkit.getWorlds().get(0); long currentTick = world.getFullTime(); if (tsunamiActive) { if (currentTick >= tsunamiEndTick) { endTsunami(); } } else { long ticksUntil = nextTsunamiTick - currentTick; if (ticksUntil <= 0) { startTsunami(); } else { // تحذيرات قبل التسونامي (يوم واحد = 24000 تيك) if (ticksUntil == 24000 || ticksUntil == 12000 || ticksUntil == 6000 || ticksUntil == 1200) { long daysLeft = ticksUntil / 24000; long hoursLeft = (ticksUntil % 24000) / 1000; String timeStr = daysLeft > 0 ? daysLeft + "d " + hoursLeft + "h" : hoursLeft + "h"; String message = plugin.getConfig().getString("messages.tsunami-warning"); Bukkit.broadcastMessage(message.replace("{time}", timeStr) .replace("&", "§")); } } } }, 0L, 20L); } public void startTsunami() { if (!plugin.getConfig().getBoolean("tsunami.enabled", true)) { scheduleNextTsunami(); return; } tsunamiActive = true; int durationDays = plugin.getConfig().getInt("tsunami.duration-days", 2); World world = Bukkit.getWorlds().get(0); tsunamiEndTick = world.getFullTime() + (durationDays * 24000L); String message = plugin.getConfig().getString("messages.tsunami-started"); Bukkit.broadcastMessage(message.replace("{duration}", String.valueOf(durationDays)) .replace("&", "§")); floodWorld(); saveData(); } private void floodWorld() { int waterLevel = plugin.getConfig().getInt("tsunami.water-level", 200); List worldNames = plugin.getConfig().getStringList("tsunami.worlds"); List targetWorlds = new ArrayList<>(); if (worldNames.isEmpty()) { targetWorlds.addAll(Bukkit.getWorlds()); } else { for (String worldName : worldNames) { World w = Bukkit.getWorld(worldName); if (w != null) targetWorlds.add(w); } } savedBlocks.clear(); for (World world : targetWorlds) { if (world.getEnvironment() != World.Environment.NORMAL) continue; for (Chunk chunk : world.getLoadedChunks()) { placeWaterInChunk(chunk, waterLevel); } } saveSavedBlocks(); } public void placeWaterInChunk(Chunk chunk, int waterLevel) { for (int x = 0; x < 16; x++) { for (int z = 0; z < 16; z++) { int worldX = chunk.getX() * 16 + x; int worldZ = chunk.getZ() * 16 + z; int highestY = chunk.getWorld().getHighestBlockYAt(worldX, worldZ); // وضع الماء من أعلى نقطة حتى water level for (int y = Math.max(highestY, 0); y <= waterLevel; y++) { Block block = chunk.getWorld().getBlockAt(worldX, y, worldZ); Material current = block.getType(); if (current == Material.AIR || current == Material.CAVE_AIR || current == Material.VOID_AIR) { String key = worldX + "," + y + "," + worldZ + "," + chunk.getWorld().getName(); savedBlocks.put(key, current); block.setType(Material.WATER); } } } } } public void endTsunami() { tsunamiActive = false; String message = plugin.getConfig().getString("messages.tsunami-ended"); Bukkit.broadcastMessage(message.replace("&", "§")); removeWater(); scheduleNextTsunami(); } private void removeWater() { Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> { for (Map.Entry entry : savedBlocks.entrySet()) { String[] parts = entry.getKey().split(","); if (parts.length < 4) continue; try { int x = Integer.parseInt(parts[0]); int y = Integer.parseInt(parts[1]); int z = Integer.parseInt(parts[2]); String worldName = parts[3]; World world = Bukkit.getWorld(worldName); if (world == null) continue; Bukkit.getScheduler().runTask(plugin, () -> { Block block = world.getBlockAt(x, y, z); if (block.getType() == Material.WATER) { block.setType(entry.getValue()); } }); } catch (Exception ignored) {} } }); savedBlocks.clear(); if (blocksFile.exists()) { blocksFile.delete(); } } private void scheduleNextTsunami() { World world = Bukkit.getWorlds().get(0); int days = plugin.getConfig().getInt("tsunami.interval-days", 7); nextTsunamiTick = world.getFullTime() + (days * 24000L); saveData(); } public void forceTsunami() { if (tsunamiActive) { endTsunami(); } else { startTsunami(); } } public boolean isTsunamiActive() { return tsunamiActive; } public long getTicksUntilNextTsunami() { World world = Bukkit.getWorlds().get(0); long currentTick = world.getFullTime(); if (tsunamiActive) { return tsunamiEndTick - currentTick; } return nextTsunamiTick - currentTick; } public String getFormattedTimeUntilTsunami() { long ticks = getTicksUntilNextTsunami(); if (ticks < 0) return "0d 0h"; long days = ticks / 24000; long hours = (ticks % 24000) / 1000; if (tsunamiActive) { return days + "d " + hours + "h (ينتهي)"; } return days + "d " + hours + "h"; } public long getTimeUntilNextTsunami() { return getTicksUntilNextTsunami() / 1000; } }