Feature/better afk

src/main/java/xyz/nkomarn/harbor/listener/AfkListeners.java

@@ -0,0 +1,104 @@
+package xyz.nkomarn.harbor.listener;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.player.AsyncPlayerChatEvent;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+import xyz.nkomarn.harbor.util.PlayerManager;
+
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+public final class AfkListeners extends BukkitRunnable implements Listener {
+
+    private final PlayerManager playerManager;
+    private double checksToMake = 0;
+    private final Queue<AfkPlayer> players = new ArrayDeque<>();
+
+    public AfkListeners(PlayerManager playerManager) {
+        this.playerManager = playerManager;
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onChat(AsyncPlayerChatEvent event) {
+        playerManager.updateActivity(event.getPlayer());
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onCommand(PlayerCommandPreprocessEvent event) {
+        playerManager.updateActivity(event.getPlayer());
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onInventoryClick(InventoryClickEvent event) {
+        playerManager.updateActivity((Player) event.getWhoClicked());
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) {
+        players.add(new AfkPlayer(event.getPlayer()));
+    }
+
+    @EventHandler
+    public void onLeave(PlayerQuitEvent event) {
+        players.remove(new AfkPlayer(event.getPlayer()));
+    }
+
+    @Override
+    public void run() {
+        if (players.isEmpty()) return;
+
+        // We want every player to get a check every 20 ticks.
+        checksToMake += players.size() / 20.0;
+        long start = System.currentTimeMillis();
+
+        // We assume that a tick should take 50 ms at max.
+        // To leave some space for other plugins we only take 20 ms of a tick.
+        while (System.currentTimeMillis() - start < 20 && checksToMake > 0) {
+            AfkPlayer afkPlayer = players.poll();
+            if (afkPlayer.changed()) {
+                playerManager.updateActivity(afkPlayer.player);
+            }
+            players.add(afkPlayer);
+            checksToMake--;
+        }
+    }
+
+    private static class AfkPlayer {
+        private final Player player;
+        private int hash;
+
+        public AfkPlayer(Player player) {
+            this.player = player;
+        }
+
+        /**
+         * Check if the player changed its position since the last check
+         * @return true if the position changed
+         */
+        private boolean changed() {
+            int hash = player.getLocation().hashCode();
+            boolean changed = hash != this.hash;
+            this.hash = hash;
+            return changed;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            AfkPlayer afkPlayer = (AfkPlayer) o;
+            return player.getUniqueId().equals(afkPlayer.player.getUniqueId());
+        }
+
+        @Override
+        public int hashCode() {
+            return player.getUniqueId().hashCode();
+        }
+    }
+}

src/main/java/xyz/nkomarn/harbor/listener/BedListener.java

@@ -11,7 +11,8 @@
 import xyz.nkomarn.harbor.util.Messages;
 import xyz.nkomarn.harbor.util.PlayerManager;
 
-import java.util.concurrent.TimeUnit;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
 
 public class BedListener implements Listener {
 
@@ -37,7 +38,7 @@ public void onBedEnter(PlayerBedEnterEvent event) {
         }
 
         Bukkit.getScheduler().runTaskLater(harbor, () -> {
-            playerManager.setCooldown(player, System.currentTimeMillis());
+            playerManager.setCooldown(player, Instant.now());
             harbor.getMessages().sendWorldChatMessage(event.getBed().getWorld(), messages.prepareMessage(
                     player, harbor.getConfiguration().getString("messages.chat.player-sleeping"))
             );
@@ -51,7 +52,7 @@ public void onBedLeave(PlayerBedLeaveEvent event) {
         }
 
         Bukkit.getScheduler().runTaskLater(harbor, () -> {
-            playerManager.setCooldown(event.getPlayer(), System.currentTimeMillis());
+            playerManager.setCooldown(event.getPlayer(), Instant.now());
             harbor.getMessages().sendWorldChatMessage(event.getBed().getWorld(), messages.prepareMessage(
                     event.getPlayer(), harbor.getConfiguration().getString("messages.chat.player-left-bed"))
             );
@@ -74,6 +75,6 @@ private boolean isMessageSilenced(@NotNull Player player) {
         }
 
         int cooldown = harbor.getConfiguration().getInteger("messages.chat.message-cooldown");
-        return TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis() - playerManager.getCooldown(player)) < cooldown;
+        return playerManager.getCooldown(player).until(Instant.now(), ChronoUnit.MINUTES) < cooldown;
     }
 }

src/main/java/xyz/nkomarn/harbor/util/PlayerManager.java

@@ -5,25 +5,23 @@
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.event.player.AsyncPlayerChatEvent;
-import org.bukkit.event.player.PlayerCommandPreprocessEvent;
-import org.bukkit.event.player.PlayerMoveEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.jetbrains.annotations.NotNull;
 import xyz.nkomarn.harbor.Harbor;
+import xyz.nkomarn.harbor.listener.AfkListeners;
 
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
 import java.util.UUID;
-import java.util.concurrent.TimeUnit;
 
 public class PlayerManager implements Listener {
 
     private final Harbor harbor;
-    private final Map<UUID, Long> cooldowns;
-    private final Map<UUID, Long> playerActivity;
+    private final Map<UUID, Instant> cooldowns;
+    private final Map<UUID, Instant> playerActivity;
 
     public PlayerManager(@NotNull Harbor harbor) {
         this.harbor = harbor;
@@ -35,10 +33,11 @@ public PlayerManager(@NotNull Harbor harbor) {
      * Gets the last tracked cooldown time for a given player.
      *
      * @param player The player for which to return cooldown time.
+     *
      * @return The player's last cooldown time.
      */
-    public long getCooldown(@NotNull Player player) {
-        return cooldowns.getOrDefault(player.getUniqueId(), 0L);
+    public Instant getCooldown(@NotNull Player player) {
+        return cooldowns.getOrDefault(player.getUniqueId(), Instant.MIN);
     }
 
     /**
@@ -47,7 +46,7 @@ public long getCooldown(@NotNull Player player) {
      * @param player   The player for which to set cooldown.
      * @param cooldown The cooldown value.
      */
-    public void setCooldown(@NotNull Player player, long cooldown) {
+    public void setCooldown(@NotNull Player player, Instant cooldown) {
         cooldowns.put(player.getUniqueId(), cooldown);
     }
 
@@ -62,6 +61,7 @@ public void clearCooldowns() {
      * Checks if a player is considered "AFK" for Harbor's player checks.
      *
      * @param player The player to check.
+     *
      * @return Whether the player is considered AFK.
      */
     public boolean isAfk(@NotNull Player player) {
@@ -82,7 +82,7 @@ public boolean isAfk(@NotNull Player player) {
             return false;
         }
 
-        long minutes = TimeUnit.MILLISECONDS.toMinutes(System.currentTimeMillis() - playerActivity.get(player.getUniqueId()));
+        long minutes = playerActivity.get(player.getUniqueId()).until(Instant.now(), ChronoUnit.MINUTES);
         return minutes >= harbor.getConfiguration().getInteger("afk-detection.timeout");
     }
 
@@ -92,14 +92,16 @@ public boolean isAfk(@NotNull Player player) {
      * @param player The player to update.
      */
     public void updateActivity(@NotNull Player player) {
-        playerActivity.put(player.getUniqueId(), System.currentTimeMillis());
+        playerActivity.put(player.getUniqueId(), Instant.now());
     }
 
     /**
      * Registers Harbor's fallback listeners for AFK detection if Essentials is not present.
      */
     public void registerFallbackListeners() {
-        harbor.getServer().getPluginManager().registerEvents(new AfkListeners(), harbor);
+        AfkListeners afkListeners = new AfkListeners(this);
+        afkListeners.runTaskTimer(harbor, 1, 1);
+        harbor.getServer().getPluginManager().registerEvents(afkListeners, harbor);
     }
 
     @EventHandler
@@ -108,27 +110,4 @@ public void onQuit(PlayerQuitEvent event) {
         cooldowns.remove(uuid);
         playerActivity.remove(uuid);
     }
-
-    private final class AfkListeners implements Listener {
-
-        @EventHandler(ignoreCancelled = true)
-        public void onChat(AsyncPlayerChatEvent event) {
-            updateActivity(event.getPlayer());
-        }
-
-        @EventHandler(ignoreCancelled = true)
-        public void onCommand(PlayerCommandPreprocessEvent event) {
-            updateActivity(event.getPlayer());
-        }
-
-        @EventHandler(ignoreCancelled = true)
-        public void onMove(PlayerMoveEvent event) {
-            updateActivity(event.getPlayer());
-        }
-
-        @EventHandler(ignoreCancelled = true)
-        public void onInventoryClick(InventoryClickEvent event) {
-            updateActivity((Player) event.getWhoClicked());
-        }
-    }
 }