package com.randomidentity.manager; import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.reflect.TypeToken; import com.randomidentity.RandomIdentityPlugin; import com.randomidentity.model.StoredIdentity; import com.randomidentity.util.ColorUtil; import com.randomidentity.util.MojangAPI; import net.kyori.adventure.text.Component; import org.bukkit.Bukkit; import org.bukkit.entity.Player; import org.bukkit.profile.PlayerProfile; import org.bukkit.profile.ProfileProperty; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.lang.reflect.Type; import java.util.*; import java.util.concurrent.CompletableFuture; import java.util.stream.Collectors; /** * Manages random identities assigned to players. * Fetches real Minecraft account data from Mojang's API, * applies randomized nametags and skins, and persists identities across restarts. */ public class IdentityManager { // Curated list of well-known, verified Minecraft accounts for random selection private static final List KNOWN_USERNAMES = Arrays.asList( "Notch", "Jeb_", "Dinnerbone", "Grum", "Searge", "Dream", "GeorgeNotFound", "Sapnap", "TommyInnit", "Tubbo", "Philza", "WilburSoot", "Technoblade", "Ranboo", "Nihachu", "Fundy", "Purpled", "BadBoyHalo", "Skeppy", "Antfrost", "Grian", "MumboJumbo", "Iskall85", "Xisuma", "FalseSymmetry", "GoodTimesWithScar", "BdoubleO100", "TangoTek", "ImpulseSV", "ZedaphPlays", "PearlescentMoon", "fWhip", "SmallishBeans", "LDShadowLady", "MythicalSausage", "CaptainSparklez", "DanTDM", "SSundee", "PopularMMOs", "iBallisticSquid", "EthosLab", "VintageBeef", "Docm77", "GenerikB", "Keralis1", "SimplySarc", "ilmango", "SethBling", "C418", "EvilSeph", "md_5", "lukegb", "Deadmau5", "sk89q", "jardon", "SolidarityGaming", "Smajor1995", "ShubbleYT", "OliTheOrionSound", "MartynInTheLane", "Renthedog", "Slogoman", "Crainer", "LazarBeam", "ItsFunneh", "Krew", "PrestonPlayz" ); private final RandomIdentityPlugin plugin; private final File dataFile; private final Gson gson; // player UUID -> StoredIdentity (persisted) private final Map activeIdentities = new HashMap<>(); // Cache of fetched profile data: username -> (uuid, skinValue, skinSignature) private static final Map profileCache = new HashMap<>(); // Cache for profiles we're currently fetching to avoid duplicate requests private static final Set pendingFetches = new HashSet<>(); public IdentityManager(RandomIdentityPlugin plugin) { this.plugin = plugin; this.gson = new GsonBuilder().setPrettyPrinting().create(); this.dataFile = new File(plugin.getDataFolder(), "random_identities.json"); loadIdentities(); } /** * Assigns random identities to all online players. * Each player gets a different random account. */ public void randomizeAllPlayers() { List onlinePlayers = new ArrayList<>(Bukkit.getOnlinePlayers()); if (onlinePlayers.isEmpty()) return; // Pick unique random usernames for each player (excluding their own) Set usedNames = new HashSet<>(); List assignments = new ArrayList<>(); // Get players' own names so we don't assign them Set ownNames = onlinePlayers.stream() .map(Player::getName) .collect(Collectors.toSet()); for (Player player : onlinePlayers) { String chosen = pickRandomUsername(usedNames, ownNames); usedNames.add(chosen); assignments.add(chosen); } // Fetch and apply identities asynchronously Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> { for (int i = 0; i < onlinePlayers.size(); i++) { Player player = onlinePlayers.get(i); String randomName = assignments.get(i); applyRandomIdentity(player, randomName); } }); } /** * Restores all players to their original names and skins. */ public void resetAllPlayers() { for (Player player : Bukkit.getOnlinePlayers()) { StoredIdentity identity = activeIdentities.remove(player.getUniqueId()); if (identity != null) { restoreOriginal(player, identity); } } saveIdentities(); Bukkit.broadcast(ColorUtil.colorize("All players have been restored to their original identities!")); } /** * Restores a single player to their original identity. */ public void restorePlayer(Player player) { StoredIdentity identity = activeIdentities.remove(player.getUniqueId()); if (identity != null) { restoreOriginal(player, identity); saveIdentities(); } } /** * Applies a stored identity to a player on join (called from PlayerJoinEvent). */ public void applyStoredIdentity(Player player) { StoredIdentity identity = activeIdentities.get(player.getUniqueId()); if (identity != null) { applySkinAndName(player, identity.getRandomUUID(), identity.getRandomName(), identity.getSkinValue(), identity.getSkinSignature()); } } // --- Private methods --- /** * Fetches and applies a random identity to a player. * Runs async — fetches UUID then skin data, then applies on main thread. */ private void applyRandomIdentity(Player player, String randomName) { // Check cache first CachedProfile cached = profileCache.get(randomName.toLowerCase()); if (cached != null) { applyFromCache(player, randomName, cached); return; } // Check pending fetches to avoid duplicates synchronized (pendingFetches) { if (pendingFetches.contains(randomName.toLowerCase())) { // Wait and retry later (handled by delay) return; } pendingFetches.add(randomName.toLowerCase()); } try { // Fetch UUID Optional uuidOpt = MojangAPI.fetchUUID(randomName); if (uuidOpt.isEmpty()) { synchronized (pendingFetches) { pendingFetches.remove(randomName.toLowerCase()); } return; } UUID randomUUID = uuidOpt.get(); Thread.sleep(200); // Rate limit: 200ms between calls // Fetch skin data Optional skinOpt = MojangAPI.fetchSkinData(randomUUID); if (skinOpt.isEmpty()) { synchronized (pendingFetches) { pendingFetches.remove(randomName.toLowerCase()); } return; } MojangAPI.SkinData skin = skinOpt.get(); // Cache the profile synchronized (profileCache) { profileCache.put(randomName.toLowerCase(), new CachedProfile( randomUUID.toString(), skin.getValue(), skin.getSignature())); } synchronized (pendingFetches) { pendingFetches.remove(randomName.toLowerCase()); } // Apply on main thread Bukkit.getScheduler().runTask(plugin, () -> applySkinAndName(player, randomUUID.toString(), randomName, skin.getValue(), skin.getSignature())); } catch (InterruptedException e) { Thread.currentThread().interrupt(); synchronized (pendingFetches) { pendingFetches.remove(randomName.toLowerCase()); } } } private void applyFromCache(Player player, String randomName, CachedProfile cached) { Bukkit.getScheduler().runTask(plugin, () -> applySkinAndName(player, cached.uuid, randomName, cached.skinValue, cached.skinSignature)); } /** * Applies a new skin and nametag to a player, visible to all online viewers. */ private void applySkinAndName(Player player, String randomUUIDStr, String randomName, String skinValue, String skinSignature) { // Store the original identity if not already stored if (!activeIdentities.containsKey(player.getUniqueId())) { StoredIdentity identity = new StoredIdentity( player.getUniqueId(), player.getName(), randomName, randomUUIDStr, skinValue, skinSignature ); activeIdentities.put(player.getUniqueId(), identity); saveIdentities(); } // Create a new PlayerProfile with the random identity's data PlayerProfile profile = Bukkit.createPlayerProfile(UUID.fromString(randomUUIDStr), randomName); profile.getProperties().removeAll("textures"); profile.getProperties().add(new ProfileProperty("textures", skinValue, skinSignature)); // Apply the profile to the player player.setPlayerProfile(profile); // Update display name and tab list name Component displayName = ColorUtil.colorize("" + randomName); player.displayName(displayName); player.playerListName(displayName); // Refresh the player for all other online players so the skin updates visually for (Player viewer : Bukkit.getOnlinePlayers()) { if (!viewer.equals(player)) { viewer.hidePlayer(plugin, player); viewer.showPlayer(plugin, player); } } player.sendMessage(ColorUtil.colorize("Your identity has been changed to " + randomName)); } /** * Restores a player's original name and skin. */ private void restoreOriginal(Player player, StoredIdentity identity) { PlayerProfile originalProfile = Bukkit.createPlayerProfile(player.getUniqueId(), identity.getOriginalName()); // Fetch the original profile asynchronously Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> { try { // Fetch the player's own profile to get their real skin Optional skinOpt = MojangAPI.fetchSkinData(player.getUniqueId()); if (skinOpt.isPresent()) { MojangAPI.SkinData skin = skinOpt.get(); Bukkit.getScheduler().runTask(plugin, () -> { originalProfile.getProperties().removeAll("textures"); originalProfile.getProperties().add(new ProfileProperty("textures", skin.getValue(), skin.getSignature())); applyProfileOnMainThread(player, identity.getOriginalName(), originalProfile); }); } else { // Fall back to profile without textures property Bukkit.getScheduler().runTask(plugin, () -> applyProfileOnMainThread(player, identity.getOriginalName(), originalProfile)); } } catch (Exception e) { Bukkit.getScheduler().runTask(plugin, () -> applyProfileOnMainThread(player, identity.getOriginalName(), originalProfile)); } }); } private void applyProfileOnMainThread(Player player, String originalName, PlayerProfile profile) { player.setPlayerProfile(profile); player.displayName(null); player.playerListName(null); for (Player viewer : Bukkit.getOnlinePlayers()) { if (!viewer.equals(player)) { viewer.hidePlayer(plugin, player); viewer.showPlayer(plugin, player); } } player.sendMessage(ColorUtil.colorize("Your original identity has been restored!")); } /** * Picks a random username from the known list that hasn't been used yet, * and is not the player's own name. */ private String pickRandomUsername(Set usedNames, Set excludeNames) { List available = KNOWN_USERNAMES.stream() .filter(name -> !usedNames.contains(name)) .filter(name -> !excludeNames.contains(name)) .collect(Collectors.toList()); if (available.isEmpty()) { // Fallback: just pick any that haven't been used in this round available = KNOWN_USERNAMES.stream() .filter(name -> !usedNames.contains(name)) .collect(Collectors.toList()); } return available.get(new Random().nextInt(available.size())); } // --- Persistence --- /** * Loads stored identities from the JSON data file. */ private void loadIdentities() { if (!dataFile.exists()) return; try (FileReader reader = new FileReader(dataFile)) { Type type = new TypeToken>(){}.getType(); List list = gson.fromJson(reader, type); if (list != null) { for (StoredIdentity identity : list) { activeIdentities.put(identity.getPlayerUUID(), identity); } } } catch (Exception e) { plugin.getLogger().warning("Failed to load stored identities: " + e.getMessage()); } } /** * Saves all active identities to the JSON data file. */ private void saveIdentities() { try (FileWriter writer = new FileWriter(dataFile)) { List list = new ArrayList<>(activeIdentities.values()); gson.toJson(list, writer); } catch (Exception e) { plugin.getLogger().warning("Failed to save identities: " + e.getMessage()); } } public boolean hasIdentity(Player player) { return activeIdentities.containsKey(player.getUniqueId()); } /** * Cached profile data to avoid repeated API calls for the same username. */ private static class CachedProfile { final String uuid; final String skinValue; final String skinSignature; CachedProfile(String uuid, String skinValue, String skinSignature) { this.uuid = uuid; this.skinValue = skinValue; this.skinSignature = skinSignature; } } }