BukkitPlayerVanishService.java

package net.onelitefeather.stardust.service;

import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.onelitefeather.stardust.StardustPlugin;
import net.onelitefeather.stardust.api.PlayerVanishService;
import net.onelitefeather.stardust.user.UserPropertyType;
import net.onelitefeather.stardust.util.Constants;
import net.onelitefeather.stardust.util.PlayerUtil;
import org.bukkit.NamespacedKey;
import org.bukkit.entity.Player;
import org.bukkit.persistence.PersistentDataType;

import java.util.UUID;
import java.util.function.Consumer;
import java.util.function.Predicate;

public final class BukkitPlayerVanishService implements PlayerVanishService {

    private static final String VANISH_PERMISSION = "stardust.command.vanish";
    private final StardustPlugin plugin;
    private final UserService userService;
    private final NamespacedKey vanishedKey;
    private static final String VANISH_SEE_OTHERS_PERMISSION = "stardust.vanish.others";

    public BukkitPlayerVanishService(UserService userService, StardustPlugin plugin) {
        this.plugin = plugin;
        this.userService = userService;
        this.vanishedKey = new NamespacedKey(plugin, "vanished");
    }

    @Override
    public void hidePlayer(UUID playerId) {
        Player player = plugin.getServer().getPlayer(playerId);
        if (player == null) return;

        Predicate<Player> cannotSeePredicate = onlinePlayer -> !canSee(onlinePlayer.getUniqueId(), playerId);
        Consumer<Player> hideAction = onlinePlayer -> onlinePlayer.hidePlayer(plugin, player);

        plugin.getServer()
                .getScheduler()
                .getMainThreadExecutor(plugin)
                .execute(() -> plugin.getServer().getOnlinePlayers().stream().filter(cannotSeePredicate).forEach(hideAction));
    }

    @Override
    public void showPlayer(UUID playerId) {
        Player player = plugin.getServer().getPlayer(playerId);
        if (player == null) return;

        plugin.getServer()
                .getScheduler()
                .getMainThreadExecutor(plugin)
                .execute(() -> plugin.getServer().getOnlinePlayers().forEach(onlinePlayer -> {
                    onlinePlayer.showPlayer(plugin, player);
                    onlinePlayer.sendMessage(Component.translatable("listener.join-message").arguments(player.displayName()));
                }));
    }

    @Override
    public boolean toggle(UUID playerId) {
        Player player = plugin.getServer().getPlayer(playerId);
        if (player == null) return false;
        var currentState = isVanished(playerId);

        if (currentState) {
            showPlayer(playerId);
            sendReappearedMessage(player);
        } else {
            hidePlayer(playerId);
            sendDisappearedMessage(player);
        }

        var newState = !currentState;
        setVanished(playerId, newState);
        togglePlayerProperties(player, newState);

        return newState;
    }

    @Override
    public boolean isVanished(UUID playerId) {

        var user = userService.getUser(playerId);
        if (user == null) return false;

        Player player = plugin.getServer().getPlayer(playerId);
        var vanished = player != null && Boolean.TRUE.equals(player.getPersistentDataContainer().get(vanishedKey, PersistentDataType.BOOLEAN));
        return Boolean.logicalAnd(user.isVanished(), vanished);
    }

    @Override
    public void setVanished(UUID playerId, boolean vanished) {

        var user = userService.getUser(playerId);
        if (user == null) return;

        this.userService.setUserProperty(user, UserPropertyType.VANISHED, vanished);

        Player player = plugin.getServer().getPlayer(playerId);
        if (player != null) {
            player.getPersistentDataContainer().set(vanishedKey, PersistentDataType.BOOLEAN, vanished);
        }
    }

    @Override
    public boolean handlePlayerJoin(UUID playerId) {

        Player player = plugin.getServer().getPlayer(playerId);
        if (player == null) return false;

        player.getServer().getOnlinePlayers().stream().map(Player::getUniqueId).filter(this::isVanished).forEach(this::hidePlayer);

        if (handleAutoVanish(player)) return true;

        if (isVanished(playerId)) {

            if (!player.hasPermission("stardust.command.vanish")) {
                setVanished(playerId, false);
                showPlayer(playerId);
                togglePlayerProperties(player, false);
                return true;
            }

            player.sendMessage(Component.translatable("vanish.join.self").arguments(plugin.getPrefix()));
            broadcastMessage(player,
                    Component.translatable("vanish.join.silently").arguments(vanishDisplayName(player)));
            hidePlayer(playerId);
            togglePlayerProperties(player, true);
        }

        return false;
    }

    @Override
    public void handlePlayerQuit(UUID playerId) {
        var player = plugin.getServer().getPlayer(playerId);
        if (player == null) return;
        if (!isVanished(playerId)) return;
        broadcastMessage(player,
                Component.translatable("vanish.quit.silently")
                        .arguments(plugin.getPrefix(), vanishDisplayName(player)));
    }

    @Override
    public boolean canSee(UUID playerId, UUID targetId) {

        Player player = plugin.getServer().getPlayer(playerId);
        Player target = plugin.getServer().getPlayer(targetId);
        if (player == null) return false;

        if (!isGroupWeightBased()) return player.hasPermission(VANISH_SEE_OTHERS_PERMISSION);
        var playerGroupPriority = plugin.getLuckPermsService().getGroupPriority(player);
        var targetGroupPriority = plugin.getLuckPermsService().getGroupPriority(target);
        return playerGroupPriority >= targetGroupPriority;
    }

    @Override
    public boolean isVanishPermitted(UUID playerId) {
        Player player = plugin.getServer().getPlayer(playerId);
        return player != null && player.hasPermission(VANISH_PERMISSION);
    }

    private void sendReappearedMessage(Player player) {
        player.sendMessage(Component.translatable("vanish.self.reappeared")
                .arguments(plugin.getPrefix()));

        broadcastMessage(
                player,
                Component.translatable("vanish.reappeared")
                        .arguments(plugin.getPrefix(), vanishDisplayName(player))
        );
    }

    private void togglePlayerProperties(Player player, boolean vanished) {
        if (vanished) {
            player.setInvulnerable(true);
            PlayerUtil.removeEnemies(player, Constants.RADIUS_REMOVE_ENEMIES);
            player.setAllowFlight(true);
            player.setSleepingIgnored(true);
            player.setAffectsSpawning(false);
        } else {
            player.setInvulnerable(false);
            player.setAllowFlight(PlayerUtil.canEnterFlyMode(player));
            player.setSleepingIgnored(false);
            player.setAffectsSpawning(true);
        }
    }

    private void sendDisappearedMessage(Player player) {
        player.sendMessage(Component.translatable("vanish.self.disappeared")
                .arguments(plugin.getPrefix()));

        broadcastMessage(
                player,
                Component.translatable("vanish.disappeared")
                        .arguments(plugin.getPrefix(), vanishDisplayName(player))
        );

        plugin.getServer().getOnlinePlayers().stream()
                .filter(p -> !p.hasPermission(VANISH_SEE_OTHERS_PERMISSION))
                .forEach(p -> p.sendMessage(Component.translatable("listener.quit-message").arguments(player.displayName())));
    }

    private boolean handleAutoVanish(Player player) {
        if (player.hasPermission("stardust.vanish.auto")) {
            var displayName = vanishDisplayName(player);

            setVanished(player.getUniqueId(), true);
            hidePlayer(player.getUniqueId());
            togglePlayerProperties(player, true);
            player.sendMessage(Component.translatable("vanish.join.self").arguments(plugin.getPrefix()));

            broadcastMessage(
                    player,
                    Component.translatable("vanish.join.silently")
                            .arguments(plugin.getPrefix(), displayName)
            );
            return true;
        }
        return false;
    }

    private void broadcastMessage(Player player, Component message) {
        plugin.getServer().getOnlinePlayers().stream()
                .filter(p -> !p.equals(player))
                .filter(p -> p.hasPermission(VANISH_SEE_OTHERS_PERMISSION))
                .forEach(p -> p.sendMessage(message));
    }

    private Component vanishDisplayName(Player player) {
        var team = player.getScoreboard().getPlayerTeam(player);
        if (team == null) return Component.text(player.getName());

        return MiniMessage.miniMessage().deserialize(player.getName()).color(team.color());
    }

    private boolean isGroupWeightBased() {
        if (!plugin.getLuckPermsService().isEnabled()) return false;
        return plugin.getConfig().getBoolean("vanish.group-weight-based-visibility", false);
    }
}