package com.kodari.combatlogplus.manager; import com.kodari.combatlogplus.CombatLogPlus; import com.kodari.combatlogplus.util.ColorUtil; import org.bukkit.Bukkit; import org.bukkit.entity.Player; import org.bukkit.scheduler.BukkitTask; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; import java.util.UUID; public class CombatManager { private final CombatLogPlus plugin; private final Set tagged = Collections.synchronizedSet(new HashSet<>()); private final Map opponents = new HashMap<>(); private final Map timers = new HashMap<>(); private final Map expiry = new HashMap<>(); // Players who disconnected while in combat — shown rejoin message on next join private final Set combatLogged = new HashSet<>(); public CombatManager(CombatLogPlus plugin) { this.plugin = plugin; } /** * Tags both players in combat with each other. */ public void tag(Player attacker, Player defender) { tagOne(attacker, defender.getUniqueId()); tagOne(defender, attacker.getUniqueId()); } private void tagOne(Player player, UUID opponentUUID) { boolean wasTagged = tagged.contains(player.getUniqueId()); tagged.add(player.getUniqueId()); opponents.put(player.getUniqueId(), opponentUUID); // Cancel existing decay timer and reset it BukkitTask existing = timers.remove(player.getUniqueId()); if (existing != null) existing.cancel(); int duration = plugin.getConfigManager().getTimerForWorld(player.getWorld().getName()); expiry.put(player.getUniqueId(), System.currentTimeMillis() + duration * 1000L); BukkitTask task = Bukkit.getScheduler().runTaskLater(plugin, () -> naturalExpire(player), duration * 20L); timers.put(player.getUniqueId(), task); if (!wasTagged && plugin.getConfigManager().isCombatEnterEnabled()) { Player opponent = Bukkit.getPlayer(opponentUUID); String name = opponent != null ? opponent.getName() : "Unknown"; String msg = plugin.getConfigManager().getCombatEnterMessage().replace("%player%", name); player.sendMessage(ColorUtil.parse(msg)); } } /** * Removes combat tag from a player and sends the exit message. */ public void untag(Player player) { if (!tagged.contains(player.getUniqueId())) return; clearData(player.getUniqueId()); if (plugin.getConfigManager().isCombatExitEnabled()) { player.sendMessage(ColorUtil.parse(plugin.getConfigManager().getCombatExitMessage())); } } /** * Called when a player's timer expires naturally. */ private void naturalExpire(Player player) { if (!tagged.contains(player.getUniqueId())) return; clearData(player.getUniqueId()); if (plugin.getConfigManager().isCombatExitEnabled()) { player.sendMessage(ColorUtil.parse(plugin.getConfigManager().getCombatExitMessage())); } } /** * Called when 'dead' is killed. Resolves combat for the killer. */ public void handleDeath(Player dead, Player killer) { // Remove combat from the dead player without sending exit message clearData(dead.getUniqueId()); // If killer was tagged and their opponent was this dead player, stop killer's timer if (killer != null && tagged.contains(killer.getUniqueId())) { UUID killerOpponent = opponents.get(killer.getUniqueId()); if (dead.getUniqueId().equals(killerOpponent)) { clearData(killer.getUniqueId()); if (plugin.getConfigManager().isCombatExitEnabled()) { killer.sendMessage(ColorUtil.parse(plugin.getConfigManager().getCombatExitMessage())); } } } } /** * Called when a player dies without a killer (e.g. fall damage, void). */ public void handleDeathNoKiller(Player dead) { clearData(dead.getUniqueId()); } /** * Called when a tagged player disconnects — treats them as a combat logger. */ public void handleQuit(Player player) { if (!tagged.contains(player.getUniqueId())) return; UUID opponentUUID = opponents.get(player.getUniqueId()); // Flag this player as having combat logged combatLogged.add(player.getUniqueId()); // Broadcast combat log message if (plugin.getConfigManager().isCombatLogEnabled()) { String msg = plugin.getConfigManager().getCombatLogMessage().replace("%player%", player.getName()); Bukkit.getOnlinePlayers().forEach(p -> p.sendMessage(ColorUtil.parse(msg))); } // Remove the combat logger's data clearData(player.getUniqueId()); // Also resolve combat for the opponent since their target fled if (opponentUUID != null) { Player opponent = Bukkit.getPlayer(opponentUUID); if (opponent != null && tagged.contains(opponentUUID)) { clearData(opponentUUID); if (plugin.getConfigManager().isCombatExitEnabled()) { opponent.sendMessage(ColorUtil.parse(plugin.getConfigManager().getCombatExitMessage())); } } } } /** * Called when a combat-logged player rejoins. */ public void handleRejoin(Player player) { if (!combatLogged.contains(player.getUniqueId())) return; combatLogged.remove(player.getUniqueId()); if (plugin.getConfigManager().isCombatLogRejoinEnabled()) { player.sendMessage(ColorUtil.parse(plugin.getConfigManager().getCombatLogRejoinMessage())); } } public boolean isTagged(Player player) { return tagged.contains(player.getUniqueId()); } public int getTimeRemaining(UUID uuid) { Long exp = expiry.get(uuid); if (exp == null) return 0; return (int) Math.max(0, Math.ceil((exp - System.currentTimeMillis()) / 1000.0)); } public Set getTaggedPlayers() { return Collections.unmodifiableSet(tagged); } private void clearData(UUID uuid) { tagged.remove(uuid); opponents.remove(uuid); expiry.remove(uuid); BukkitTask task = timers.remove(uuid); if (task != null) task.cancel(); } public void cleanup() { timers.values().forEach(BukkitTask::cancel); timers.clear(); tagged.clear(); opponents.clear(); expiry.clear(); } }