No chat to show

This project's files are all here to explore.

Files
src
pom.xml
Code
5 484
src/main/java/dev/dialogui/DialogUI.java
package dev.dialogui;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandMap;
import org.bukkit.command.CommandSender;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.plugin.java.JavaPlugin;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

public class DialogUI extends JavaPlugin implements Listener {

    // Version numbers reported by ViaVersionStatus (via /uiset), in memory only
    private final Map<UUID, Long> versionNames = new ConcurrentHashMap<>();
    // Players who turned dialogs off on purpose (saved)
    private final Set<UUID> disabled = ConcurrentHashMap.newKeySet();

    private final Map<String, String> javaCmds = new HashMap<>();
    private final Map<String, String> bedrockCmds = new HashMap<>();
    // Original commands we replaced in the command map (label -> original)
    private final Map<String, Command> originals = new HashMap<>();

    private File dataFile;
    private String bedrockPrefix;
    private long minVersion;
    private int minProtocol;

    @Override
    public void onEnable() {
        saveDefaultConfig();
        dataFile = new File(getDataFolder(), "data.yml");
        loadData();
        loadSettings();
        getServer().getPluginManager().registerEvents(this, this);
        if (getServer().getPluginManager().getPlugin("PlaceholderAPI") != null) {
            new StatusExpansion(this).register();
        }
        // Wait until every plugin has registered its commands
        Bukkit.getScheduler().runTask(this, this::wrapCommands);
    }

    @Override
    public void onDisable() {
        unwrapCommands();
    }

    // ---------- settings / data ----------

    private void loadSettings() {
        reloadConfig();
        FileConfiguration c = getConfig();
        bedrockPrefix = c.getString("bedrock-prefix", ".");
        minVersion = parseVersion(c.getString("min-version", "1.21.6"));
        if (minVersion < 0) minVersion = parseVersion("1.21.6");
        minProtocol = c.getInt("min-protocol", 771);
        readMap(c.getConfigurationSection("java-commands"), javaCmds);
        readMap(c.getConfigurationSection("bedrock-commands"), bedrockCmds);
    }

    private void readMap(ConfigurationSection sec, Map<String, String> out) {
        out.clear();
        if (sec == null) return;
        for (String k : sec.getKeys(false)) {
            String v = sec.getString(k);
            if (v != null && !v.isBlank()) {
                out.put(k.toLowerCase(Locale.ROOT), v.trim());
            }
        }
    }

    private void loadData() {
        disabled.clear();
        if (!dataFile.exists()) return;
        YamlConfiguration y = YamlConfiguration.loadConfiguration(dataFile);
        for (String s : y.getStringList("disabled")) {
            try { disabled.add(UUID.fromString(s)); } catch (IllegalArgumentException ignored) { }
        }
    }

    private void saveData() {
        YamlConfiguration y = new YamlConfiguration();
        List<String> list = new ArrayList<>();
        for (UUID u : disabled) list.add(u.toString());
        y.set("disabled", list);
        try { y.save(dataFile); } catch (IOException e) { getLogger().warning("Could not save data.yml: " + e.getMessage()); }
    }

    // ---------- version detection ----------

    /** "1.21.6" or "1.21.6-1.21.7" -> comparable number, or -1 if unreadable */
    static long parseVersion(String s) {
        if (s == null) return -1;
        s = s.trim().split("-")[0];
        String[] p = s.split("\\.");
        if (p.length < 2) return -1;
        try {
            long a = Long.parseLong(p[0]);
            long b = Long.parseLong(p[1]);
            long c = p.length > 2 ? Long.parseLong(p[2]) : 0;
            return a * 1_000_000L + b * 1_000L + c;
        } catch (NumberFormatException e) {
            return -1;
        }
    }

    private Integer viaProtocol(Player p) {
        try {
            Class<?> via = Class.forName("com.viaversion.viaversion.api.Via");
            Object api = via.getMethod("getAPI").invoke(null);
            Method m = api.getClass().getMethod("getPlayerVersion", UUID.class);
            m.setAccessible(true);
            Object r = m.invoke(api, p.getUniqueId());
            if (r instanceof Integer i && i > 0) return i;
        } catch (Throwable ignored) { }
        return null;
    }

    public boolean isBedrock(Player p) {
        return !bedrockPrefix.isEmpty() && p.getName().startsWith(bedrockPrefix);
    }

    /** true only when the player definitely supports dialogs. Unknown = false. */
    public boolean supported(Player p) {
        if (p == null || !p.isOnline()) return false;
        if (isBedrock(p)) return true;
        Long v = versionNames.get(p.getUniqueId());
        if (v != null) return v >= minVersion;
        Integer proto = viaProtocol(p);
        if (proto != null) return proto >= minProtocol;
        return false;
    }

    public boolean dialogsActive(Player p) {
        return supported(p) && !disabled.contains(p.getUniqueId());
    }

    /** %ui_status%: Modern when dialogs/forms are active, Classic otherwise */
    public String status(Player p) {
        FileConfiguration c = getConfig();
        String raw = (p != null && dialogsActive(p))
                ? c.getString("placeholder.modern", "&aModern")
                : c.getString("placeholder.classic", "&aClassic");
        return ChatColor.translateAlternateColorCodes('&', raw);
    }

    // ---------- command redirect ----------

    /** The full command to run instead, or null if this command should not be redirected. */
    String redirect(Player p, String label, String args) {
        label = label.toLowerCase(Locale.ROOT);
        if (disabled.contains(p.getUniqueId())) return null;
        String target;
        if (isBedrock(p)) {
            target = bedrockCmds.get(label);
        } else {
            if (!supported(p)) return null;
            target = javaCmds.get(label);
        }
        if (target == null || target.equalsIgnoreCase(label)) return null;
        return args.isEmpty() ? target : target + " " + args;
    }

    // Typed commands
    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
    public void onCommand(PlayerCommandPreprocessEvent e) {
        String msg = e.getMessage();
        if (msg.length() < 2) return;
        String body = msg.substring(1).trim();
        if (body.isEmpty()) return;

        int sp = body.indexOf(' ');
        String label = sp == -1 ? body : body.substring(0, sp);
        String args = sp == -1 ? "" : body.substring(sp + 1).trim();

        String full = redirect(e.getPlayer(), label, args);
        if (full == null) return;

        e.setCancelled(true);