GH-1031 Add vanish feature.

eternalcore-api/src/main/java/com/eternalcode/core/feature/vanish/VanishService.java

@@ -0,0 +1,72 @@
+package com.eternalcode.core.feature.vanish;
+
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.Set;
+import java.util.UUID;
+
+public interface VanishService {
+
+    /**
+     * Enables vanish for the specified player.
+     *
+     * @param player The player to enable vanish for.
+     */
+    void enableVanish(Player player);
+
+    /**
+     * Disables vanish for the specified player.
+     *
+     * @param player The player to disable vanish for.
+     */
+    void disableVanish(Player player);
+
+    /**
+     * Checks if the specified player is vanished.
+     *
+     * @param player The player to check.
+     * @return true if the player is vanished, false otherwise.
+     */
+    boolean isVanished(Player player);
+
+    default boolean toggleVanish(Player player) {
+        if (isVanished(player)) {
+            disableVanish(player);
+            return false;
+        }
+        enableVanish(player);
+        return true;
+    }
+
+    /**
+     * Checks if the player with the specified unique ID is vanished.
+     *
+     * @param uniqueId The unique ID of the player to check.
+     * @return true if the player is vanished, false otherwise.
+     */
+    boolean isVanished(UUID uniqueId);
+
+    /**
+     * Hides vanished players from the specified player.
+     *
+     * @param observer The player from whom vanished players should be hidden.
+     */
+    @ApiStatus.Internal
+    void hideVanishedPlayersFrom(Player observer);
+
+    /**
+     * Gets a set of UUIDs of all vanished players.
+     *
+     * @return A set containing the unique IDs of all vanished players.
+     */
+    Set<UUID> getVanishedPlayers();
+
+    /**
+     * Gets a set of names of all vanished players.
+     *
+     * @return A set containing the names of all vanished players.
+     */
+    Set<String> getVanishedPlayerNames();
+
+}

eternalcore-api/src/main/java/com/eternalcode/core/feature/vanish/event/AbstractVanishEvent.java

@@ -0,0 +1,30 @@
+package com.eternalcode.core.feature.vanish.event;
+
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.entity.Player;
+
+public abstract class AbstractVanishEvent extends Event implements Cancellable {
+
+    private final Player player;
+    private boolean cancelled = false;
+
+    public AbstractVanishEvent(Player player) {
+        this.player = player;
+    }
+
+    public Player getPlayer() {
+        return this.player;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancel) {
+        this.cancelled = cancel;
+    }
+
+}

eternalcore-api/src/main/java/com/eternalcode/core/feature/vanish/event/DisableVanishEvent.java

@@ -0,0 +1,23 @@
+package com.eternalcode.core.feature.vanish.event;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+public class DisableVanishEvent extends AbstractVanishEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public DisableVanishEvent(Player player) {
+        super(player);
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+}

eternalcore-api/src/main/java/com/eternalcode/core/feature/vanish/event/EnableVanishEvent.java

@@ -0,0 +1,23 @@
+package com.eternalcode.core.feature.vanish.event;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+public class EnableVanishEvent extends AbstractVanishEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public EnableVanishEvent(Player player) {
+        super(player);
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+}

eternalcore-core/src/main/java/com/eternalcode/core/EternalCoreCommand.java

@@ -1,8 +1,11 @@
 package com.eternalcode.core;
 
 import com.eternalcode.annotations.scan.command.DescriptionDocs;
+import com.eternalcode.commons.scheduler.Scheduler;
 import com.eternalcode.core.configuration.ConfigurationManager;
 import com.eternalcode.core.injector.annotations.Inject;
+import com.eternalcode.core.publish.Publisher;
+import com.eternalcode.core.publish.event.EternalReloadEvent;
 import com.google.common.base.Stopwatch;
 import dev.rollczi.litecommands.annotations.async.Async;
 import dev.rollczi.litecommands.annotations.context.Context;
@@ -13,6 +16,7 @@
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 
+import java.time.Duration;
 import java.util.concurrent.TimeUnit;
 
 @Command(name = "eternalcore")
@@ -23,11 +27,13 @@ class EternalCoreCommand {
 
     private final ConfigurationManager configurationManager;
     private final MiniMessage miniMessage;
+    private final Publisher publisher;
 
     @Inject
-    EternalCoreCommand(ConfigurationManager configurationManager, MiniMessage miniMessage) {
+    EternalCoreCommand(ConfigurationManager configurationManager, MiniMessage miniMessage, Publisher publisher) {
         this.configurationManager = configurationManager;
         this.miniMessage = miniMessage;
+        this.publisher = publisher;
     }
 
     @Async
@@ -42,7 +48,9 @@ void reload(@Context Audience audience) {
 
     private long reload() {
         Stopwatch stopwatch = Stopwatch.createStarted();
+
         this.configurationManager.reload();
+        this.publisher.publish(new EternalReloadEvent());
 
         return stopwatch.elapsed(TimeUnit.MILLISECONDS);
     }

eternalcore-core/src/main/java/com/eternalcode/core/bridge/litecommand/argument/PlayerArgument.java

@@ -1,6 +1,5 @@
 package com.eternalcode.core.bridge.litecommand.argument;
 
-import com.eternalcode.annotations.scan.permission.PermissionDocs;
 import com.eternalcode.core.feature.vanish.VanishPermissionConstant;
 import com.eternalcode.core.feature.vanish.VanishService;
 import com.eternalcode.core.injector.annotations.Inject;
@@ -70,6 +69,6 @@ private boolean canSee(CommandSender sender, Player player) {
     }
 
     private boolean canSeeVanished(CommandSender sender) {
-        return sender.hasPermission(VanishPermissionConstant.VANISH_SEE_TABULATION_PERMISSION);
+        return sender.hasPermission(VanishPermissionConstant.VANISH_SEE_PERMISSION);
     }
 }

eternalcore-core/src/main/java/com/eternalcode/core/configuration/implementation/PluginConfiguration.java

@@ -17,6 +17,8 @@
 import com.eternalcode.core.feature.spawn.SpawnJoinConfig;
 import com.eternalcode.core.feature.spawn.SpawnSettings;
 import com.eternalcode.core.feature.teleportrequest.TeleportRequestConfig;
+import com.eternalcode.core.feature.vanish.VanishConfig;
+import com.eternalcode.core.feature.vanish.VanishSettings;
 import com.eternalcode.core.feature.warp.WarpConfig;
 import com.eternalcode.core.injector.annotations.Bean;
 import com.eternalcode.core.injector.annotations.component.ConfigurationFile;
@@ -223,6 +225,12 @@ public static class Items extends OkaeriConfig {
     @Comment("# Settings for server link management")
     ServerLinksConfig serverLinks = new ServerLinksConfig();
 
+    @Bean(proxied = VanishSettings.class)
+    @Comment("")
+    @Comment("# Vanish Configuration")
+    @Comment("# Settings responsible for player vanish functionality")
+    VanishConfig vanish = new VanishConfig();
+
     @Override
     public File getConfigFile(File dataFolder) {
         return new File(dataFolder, "config.yml");

eternalcore-core/src/main/java/com/eternalcode/core/feature/vanish/VanishCommand.java

@@ -0,0 +1,52 @@
+package com.eternalcode.core.feature.vanish;
+
+import com.eternalcode.annotations.scan.command.DescriptionDocs;
+import com.eternalcode.core.feature.vanish.messages.VanishMessages;
+import com.eternalcode.core.injector.annotations.Inject;
+import com.eternalcode.core.notice.NoticeService;
+import com.eternalcode.multification.notice.provider.NoticeProvider;
+import dev.rollczi.litecommands.annotations.argument.Arg;
+import dev.rollczi.litecommands.annotations.command.Command;
+import dev.rollczi.litecommands.annotations.context.Context;
+import dev.rollczi.litecommands.annotations.execute.Execute;
+import dev.rollczi.litecommands.annotations.permission.Permission;
+import org.bukkit.entity.Player;
+
+@Command(name = "vanish", aliases = {"v"})
+@Permission(VanishPermissionConstant.VANISH_COMMAND_PERMISSION)
+class VanishCommand {
+
+    private final NoticeService noticeService;
+    private final VanishService vanishService;
+
+    @Inject
+    public VanishCommand(NoticeService noticeService, VanishService vanishService) {
+        this.noticeService = noticeService;
+        this.vanishService = vanishService;
+    }
+
+    @Execute
+    @DescriptionDocs(description = "Toggle your vanish state")
+    void vanishSelf(@Context Player player) {
+        boolean vanished = this.vanishService.toggleVanish(player);
+        this.sendMessage(player, player, vanished ? VanishMessages::vanishEnabled : VanishMessages::vanishDisabled);
+    }
+
+    @Execute
+    @Permission(VanishPermissionConstant.VANISH_COMMAND_PERMISSION_OTHER)
+    @DescriptionDocs(description = "Toggle vanish state for another player")
+    void vanishOther(@Context Player player, @Arg Player target) {
+        boolean vanished = this.vanishService.toggleVanish(target);
+        this.sendMessage(player, target, vanished ? VanishMessages::vanishEnabledOther : VanishMessages::vanishDisabledOther);
+    }
+
+    private void sendMessage(Player sender, Player target, NoticeProvider<VanishMessages> message) {
+        this.noticeService.create()
+            .player(sender.getUniqueId())
+            .placeholder("{PLAYER}", target.getName())
+            .notice(messages -> message.extract(messages.vanish()))
+            .send();
+    }
+
+}
+

eternalcore-core/src/main/java/com/eternalcode/core/feature/vanish/VanishConfig.java

@@ -0,0 +1,49 @@
+package com.eternalcode.core.feature.vanish;
+
+import eu.okaeri.configs.OkaeriConfig;
+import eu.okaeri.configs.annotation.Comment;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import org.bukkit.ChatColor;
+
+@Getter
+@Accessors(fluent = true)
+public class VanishConfig extends OkaeriConfig implements VanishSettings {
+
+    @Comment("Should players with eternalcore.vanish.join permission join in vanish mode without join message")
+    public boolean silentJoin = false;
+
+    @Comment("Should vanished players be invulnerable to damage from other players")
+    public boolean godMode = true;
+
+    @Comment("Give night vision effect to vanished players")
+    public boolean nightVision = true;
+
+    @Comment("Should vanished players be able to silently view other players' inventories?")
+    public boolean silentInventoryAccess = true;
+
+    @Comment("Should vanished players glow to make them visible to other staff members?")
+    public boolean glowEffect = true;
+
+    @Comment("Color of the glow effect for vanished players")
+    public ChatColor color = ChatColor.LIGHT_PURPLE;
+
+    @Comment("Prevent vanished players from dropping items")
+    public boolean blockItemDropping = false;
+
+    @Comment("Prevent vanished players from picking up items")
+    public boolean blockItemPickup = true;
+
+    @Comment("Prevent vanished players from hunger loss")
+    public boolean blockHungerLoss = true;
+
+    @Comment("Prevent vanished players from using public chat")
+    public boolean blockChatUsage = false;
+
+    @Comment("Prevent vanished players from breaking blocks")
+    public boolean blockBlockBreaking = false;
+
+    @Comment("Prevent vanished players from placing blocks")
+    public boolean blockBlockPlacing = false;
+
+}