No chat to show

This project's files are all here to explore.

Files
src
build.gradle
pom.xml
settings.gradle
Code
6 2,018
src/main/java/dev/loyolabeat/LoyolaBeatPlugin.java
package dev.loyolabeat;

import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.mojang.brigadier.Command;
import com.mojang.brigadier.arguments.IntegerArgumentType;
import com.mojang.brigadier.arguments.StringArgumentType;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.builder.RequiredArgumentBuilder;
import com.mojang.brigadier.context.CommandContext;
import com.mojang.brigadier.suggestion.Suggestions;
import com.mojang.brigadier.suggestion.SuggestionsBuilder;
import de.maxhenkel.voicechat.api.BukkitVoicechatService;
import de.maxhenkel.voicechat.api.VoicechatApi;
import de.maxhenkel.voicechat.api.VoicechatConnection;
import de.maxhenkel.voicechat.api.VoicechatPlugin;
import de.maxhenkel.voicechat.api.VoicechatServerApi;
import de.maxhenkel.voicechat.api.audiochannel.StaticAudioChannel;
import de.maxhenkel.voicechat.api.events.EventRegistration;
import de.maxhenkel.voicechat.api.events.VoicechatServerStartedEvent;
import de.maxhenkel.voicechat.api.events.VoicechatServerStoppedEvent;
import de.maxhenkel.voicechat.api.opus.OpusEncoder;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import io.papermc.paper.command.brigadier.Commands;
import io.papermc.paper.command.brigadier.MessageComponentSerializer;
import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents;
import io.papermc.paper.threadedregions.scheduler.ScheduledTask;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Base64;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Set;
import java.util.TreeMap;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.Bukkit;
import org.bukkit.Color;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Display;
import org.bukkit.entity.Player;
import org.bukkit.entity.TextDisplay;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerChangedWorldEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.permissions.Permission;
import org.bukkit.permissions.PermissionDefault;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.util.Transformation;
import org.bukkit.util.Vector;
import org.joml.AxisAngle4f;
import org.joml.Vector3f;

public final class LoyolaBeatPlugin extends JavaPlugin {

    private final Set<UUID> mutedPlayers = ConcurrentHashMap.newKeySet();
    private File mutedFile;
    private SpotifyResolver spotify;
    private AudioManager audio;
    private LyricManager lyrics;
    private SuggestionManager suggestions;

    @Override
    public void onEnable() {
        saveDefaultConfig();
        mutedFile = new File(getDataFolder(), "muted-players.yml");
        loadMuted();
        loadVolumes();

        BukkitVoicechatService service = getServer().getServicesManager().load(BukkitVoicechatService.class);
        if (service == null) {
            getLogger().severe("Simple Voice Chat service not found - disabling LoyolaBeat.");
            getServer().getPluginManager().disablePlugin(this);
            return;
        }

        spotify = new SpotifyResolver(this);
        lyrics = new LyricManager(this);
        audio = new AudioManager(this);
        service.registerPlugin(audio);
        suggestions = new SuggestionManager(this);

        getServer().getPluginManager().addPermission(
                new Permission("loyolabeat.admin", "Control LoyolaBeat playback", PermissionDefault.OP));
        getServer().getPluginManager().addPermission(
                new Permission("loyolabeat.use", "Use LoyolaBeat player commands", PermissionDefault.TRUE));

        getServer().getPluginManager().registerEvents(new PlayerListener(this), this);

        CommandRegistrar registrar = new CommandRegistrar(this);
        getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS,
                event -> registrar.register(event.registrar()));
    }

    @Override
    public void onDisable() {
        if (lyrics != null) lyrics.shutdown();
        if (audio != null) audio.shutdown();
        saveMuted();
    }

    public SpotifyResolver spotify() { return spotify; }
    public AudioManager audio() { return audio; }
    public LyricManager lyrics() { return lyrics; }
    public SuggestionManager suggestions() { return suggestions; }

    private final Map<UUID, Integer> volumes = new ConcurrentHashMap<>();

    /** Per-player volume percent (100 = normal). */
    public int volumeOf(UUID id) {
        return volumes.getOrDefault(id, 100);
    }

    public void setVolume(UUID id, int percent) {
        if (percent == 100) volumes.remove(id);
        else volumes.put(id, Math.max(0, Math.min(200, percent)));
        if (isEnabled()) getServer().getAsyncScheduler().runNow(this, task -> saveVolumes());
    }

    private void loadVolumes() {
        File f = new File(getDataFolder(), "volumes.yml");
        if (!f.exists()) return;
        YamlConfiguration y = YamlConfiguration.loadConfiguration(f);
        for (String k : y.getKeys(false)) {
            try {
                volumes.put(UUID.fromString(k), Math.max(0, Math.min(200, y.getInt(k, 100))));
            } catch (IllegalArgumentException ignored) { }
        }
    }

    private synchronized void saveVolumes() {
        YamlConfiguration y = new YamlConfiguration();
        for (var e : volumes.entrySet()) y.set(e.getKey().toString(), e.getValue());
        try {
            getDataFolder().mkdirs();
            y.save(new File(getDataFolder(), "volumes.yml"));
        } catch (IOException e) {
            getLogger().warning("Could not save volumes.yml: " + e.getMessage());
        }
    }

    public boolean isMuted(UUID id) {
        return mutedPlayers.contains(id);
    }

    /** Toggles mute for a player; returns true if the player is now muted. */
    public boolean toggleMute(Player player) {
        UUID id = player.getUniqueId();
        boolean nowMuted;
        if (mutedPlayers.remove(id)) {
            nowMuted = false;
            lyrics.refresh(player);
        } else {
            mutedPlayers.add(id);
            nowMuted = true;
            audio.dropChannel(id);
            lyrics.hideFor(id);
        }
        if (isEnabled()) {
            getServer().getAsyncScheduler().runNow(this, task -> saveMuted());
            if (suggestions != null) getServer().getAsyncScheduler().runNow(this, task -> suggestions.recheck());
        }
        return nowMuted;
    }

    private void loadMuted() {