Stage 12: Data storage system

src/main/java/dev/loki/damage/AttackListener.java

@@ -0,0 +1,71 @@
+package dev.loki.damage;
+
+import dev.loki.player.BasePlayer;
+import dev.loki.player.Killer;
+import dev.loki.player.PlayerManager;
+import dev.loki.player.Survivor;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+
+public class AttackListener implements Listener {
+    private final PlayerManager playerManager;
+    private final DamageHandler damageHandler;
+    private final java.util.function.BiConsumer<Killer, Survivor> onAttackAttempt;
+
+    public AttackListener(PlayerManager playerManager, DamageHandler damageHandler,
+                         java.util.function.BiConsumer<Killer, Survivor> onAttackAttempt) {
+        this.playerManager = playerManager;
+        this.damageHandler = damageHandler;
+        this.onAttackAttempt = onAttackAttempt;
+    }
+
+    @EventHandler
+    public void onEntityDamage(EntityDamageByEntityEvent event) {
+        if (!(event.getDamager() instanceof Player attacker)) return;
+        if (!(event.getEntity() instanceof Player target)) return;
+
+        BasePlayer attackerBase = playerManager.getPlayer(attacker);
+        BasePlayer targetBase = playerManager.getPlayer(target);
+
+        if (attackerBase == null || targetBase == null) return;
+        if (!attackerBase.isKiller()) return;
+        if (targetBase.isKiller()) {
+            event.setCancelled(true);
+            return;
+        }
+
+        event.setCancelled(true);
+
+        Killer killer = (Killer) attackerBase;
+        Survivor survivor = (Survivor) targetBase;
+
+        if (onAttackAttempt != null) {
+            onAttackAttempt.accept(killer, survivor);
+        }
+    }
+
+    @EventHandler
+    public void onPlayerInteract(PlayerInteractEvent event) {
+        if (event.getHand() != EquipmentSlot.HAND) return;
+        if (!event.getAction().isLeftClick()) return;
+
+        Player player = event.getPlayer();
+        BasePlayer basePlayer = playerManager.getPlayer(player);
+
+        if (basePlayer == null || !basePlayer.isKiller()) return;
+
+        event.setCancelled(true);
+    }
+
+    public void register(org.bukkit.plugin.Plugin plugin) {
+        org.bukkit.Bukkit.getPluginManager().registerEvents(this, plugin);
+    }
+
+    public void unregister() {
+        org.bukkit.event.HandlerList.unregisterAll(this);
+    }
+}

src/main/java/dev/loki/damage/DamageHandler.java

@@ -0,0 +1,87 @@
+package dev.loki.damage;
+
+import dev.loki.player.Survivor;
+import dev.loki.state.StateMachine;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+public class DamageHandler {
+    private final StateMachine stateMachine;
+    private final Map<UUID, Long> lastDamageTime;
+    private Consumer<Survivor> onSurvivorInjured;
+    private Consumer<Survivor> onSurvivorDowned;
+    private static final long DAMAGE_COOLDOWN_MS = 500;
+
+    public DamageHandler(StateMachine stateMachine) {
+        this.stateMachine = stateMachine;
+        this.lastDamageTime = new HashMap<>();
+    }
+
+    public void setOnSurvivorInjured(Consumer<Survivor> callback) {
+        this.onSurvivorInjured = callback;
+    }
+
+    public void setOnSurvivorDowned(Consumer<Survivor> callback) {
+        this.onSurvivorDowned = callback;
+    }
+
+    public boolean applyDamage(Survivor survivor) {
+        if (!canTakeDamage(survivor)) {
+            return false;
+        }
+
+        if (!checkCooldown(survivor.getUuid())) {
+            return false;
+        }
+
+        boolean wasHealthy = survivor.getState().name().equals("HEALTHY");
+
+        if (!stateMachine.damageSurvivor(survivor)) {
+            return false;
+        }
+
+        recordDamage(survivor.getUuid());
+
+        if (survivor.getState().name().equals("DOWNED")) {
+            if (onSurvivorDowned != null) {
+                onSurvivorDowned.accept(survivor);
+            }
+        } else if (wasHealthy && onSurvivorInjured != null) {
+            onSurvivorInjured.accept(survivor);
+        }
+
+        return true;
+    }
+
+    public boolean canTakeDamage(Survivor survivor) {
+        return switch (survivor.getState()) {
+            case HEALTHY, INJURED -> true;
+            default -> false;
+        };
+    }
+
+    private boolean checkCooldown(UUID uuid) {
+        Long lastTime = lastDamageTime.get(uuid);
+        if (lastTime == null) return true;
+        return System.currentTimeMillis() - lastTime >= DAMAGE_COOLDOWN_MS;
+    }
+
+    private void recordDamage(UUID uuid) {
+        lastDamageTime.put(uuid, System.currentTimeMillis());
+    }
+
+    public boolean isKillable(Survivor survivor) {
+        return survivor.getHooksTaken() >= 2;
+    }
+
+    public void clearCooldown(UUID uuid) {
+        lastDamageTime.remove(uuid);
+    }
+
+    public void reset() {
+        lastDamageTime.clear();
+    }
+}