Made claude get it to work kind of?

Signed-off-by: BT (calcastor/mame) <43831917+calcastor@users.noreply.github.com>

Author: calcastor

platform/platform-modern/src/main/java/dev/pgm/community/platform/modern/ModernPlayerUtils.java

@@ -5,10 +5,6 @@
 import com.comphenix.protocol.events.PacketEvent;
 import com.destroystokyo.paper.profile.CraftPlayerProfile;
 import com.destroystokyo.paper.profile.PlayerProfile;
-import com.google.common.collect.ImmutableMultimap;
-import com.mojang.authlib.GameProfile;
-import com.mojang.authlib.properties.Property;
-import com.mojang.authlib.properties.PropertyMap;
 import dev.pgm.community.util.PlayerUtils;
 import dev.pgm.community.util.Supports;
 import dev.pgm.community.utils.MessageUtils;
@@ -25,7 +21,6 @@
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.scores.PlayerTeam;
 import net.minecraft.world.scores.Scoreboard;
-import org.apache.commons.lang3.StringUtils;
 import org.bukkit.Material;
 import org.bukkit.craftbukkit.entity.CraftPlayer;
 import org.bukkit.entity.Player;
@@ -89,7 +84,7 @@ public Skin getPlayerSkin(Player player, Player viewer) {
     if (playerSkins.containsKey(player.getUniqueId())) {
       Map<UUID, Skin> uuidSkinMap = playerSkins.get(player.getUniqueId());
       Skin skin = uuidSkinMap.get(viewer.getUniqueId());
-      if (skin != null) return skin;
+      if (skin != null && !skin.isEmpty()) return skin;
     }
     return getPlayerSkin(player);
   }
@@ -122,41 +117,19 @@ public ItemStack customSkull(String url, String displayName, String... lore) {
 
   @Override
   public void refreshPlayer(@Nullable PacketEvent event, Player player, Player viewer) {
-    String playerDisplayName = PLAYER_UTILS.getPlayerDisplayName(player, viewer);
-    String playerName = PLAYER_UTILS.getPlayerName(player, viewer);
-
-    if (StringUtils.isBlank(playerName) || StringUtils.isBlank(playerDisplayName)) {
-      return;
-    }
-
-    if (event != null) event.setCancelled(true);
-
     ServerPlayer nmsPlayer = ((CraftPlayer) player).getHandle();
     ServerPlayer viewerNms = ((CraftPlayer) viewer).getHandle();
-    GameProfile realProfile = nmsPlayer.gameProfile;
 
-    Skin skin = PLAYER_UTILS.getPlayerSkin(player, viewer);
-    ImmutableMultimap.Builder<String, Property> builder = ImmutableMultimap.builder();
-    if (skin != null && skin.getData() != null) {
-      builder.put("textures", new Property("textures", skin.getData(), skin.getSignature()));
-    } else {
-      realProfile.properties().get("textures").forEach(p -> builder.put("textures", p));
-    }
-
-    nmsPlayer.gameProfile =
-        new GameProfile(realProfile.id(), playerName, new PropertyMap(builder.build()));
+    // Send with real profile; the PLAYER_INFO packet handler transforms name+skin if nicked
     viewerNms.connection.send(
         ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(nmsPlayer), viewerNms));
-    nmsPlayer.gameProfile = realProfile;
 
+    // Send team JOIN with real name; the SCOREBOARD_TEAM handler transforms it if nicked
     Scoreboard scoreboard = nmsPlayer.getBukkitEntity().getScoreboard().getHandle();
     PlayerTeam team = scoreboard.getPlayersTeam(player.getName());
-
     if (team != null) {
-      var teamPacket = ClientboundSetPlayerTeamPacket.createPlayerPacket(
-          team, playerName, ClientboundSetPlayerTeamPacket.Action.ADD);
-
-      viewerNms.connection.send(teamPacket);
+      viewerNms.connection.send(ClientboundSetPlayerTeamPacket.createPlayerPacket(
+          team, player.getName(), ClientboundSetPlayerTeamPacket.Action.ADD));
     }
   }
 }

platform/platform-modern/src/main/java/dev/pgm/community/platform/modern/PacketManipulations.java

@@ -3,38 +3,298 @@
 import static dev.pgm.community.util.PlayerUtils.PLAYER_UTILS;
 
 import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolLibrary;
 import com.comphenix.protocol.events.ListenerPriority;
+import com.comphenix.protocol.events.PacketContainer;
 import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.wrappers.PlayerInfoData;
+import com.mojang.authlib.GameProfile;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelOutboundHandlerAdapter;
+import io.netty.channel.ChannelPromise;
+import io.papermc.paper.profile.MutablePropertyMap;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.UUID;
+import java.util.WeakHashMap;
+import java.util.concurrent.ConcurrentHashMap;
+import net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket;
+import net.minecraft.network.protocol.game.ClientboundSetPlayerTeamPacket;
 import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
 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.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.plugin.Plugin;
 import tc.oc.pgm.platform.modern.packets.PacketSender;
 import tc.oc.pgm.platform.modern.util.Packets;
+import tc.oc.pgm.platform.modern.util.Skins;
 
-public class PacketManipulations implements PacketSender {
+public class PacketManipulations implements PacketSender, Listener {
+
+  private static final String HANDLER_NAME = "community_nickname_team";
+
+  private static final Field PLAYER_INFO_ENTRIES_FIELD;
+  private static final Field TEAM_PLAYERS_FIELD;
+  private static final ThreadLocal<Boolean> SENDING = ThreadLocal.withInitial(() -> false);
+
+  static {
+    try {
+      PLAYER_INFO_ENTRIES_FIELD =
+          ClientboundPlayerInfoUpdatePacket.class.getDeclaredField("entries");
+      PLAYER_INFO_ENTRIES_FIELD.setAccessible(true);
+      TEAM_PLAYERS_FIELD = ClientboundSetPlayerTeamPacket.class.getDeclaredField("players");
+      TEAM_PLAYERS_FIELD.setAccessible(true);
+    } catch (NoSuchFieldException e) {
+      throw new ExceptionInInitializerError(e);
+    }
+  }
+
+  private final Plugin plugin;
+
+  // Cache of per-viewer fake names for players who have just quit, keyed by real name.
+  // Populated at LOWEST priority in onPlayerQuit (before other plugins like PGM may send
+  // LEAVE packets), so we can substitute the fake name in SCOREBOARD_TEAM LEAVE packets
+  // that arrive after the player has been removed from the server player list.
+  // ConcurrentHashMap because the Netty IO thread reads this while the main thread writes.
+  // Entries are evicted after one tick.
+  private final Map<String, Map<UUID, String>> offlineFakeNames = new ConcurrentHashMap<>();
 
   public PacketManipulations(Plugin plugin) {
+    this.plugin = plugin;
     Packets.register(
         plugin,
         ListenerPriority.LOWEST,
         Map.of(PacketType.Play.Server.PLAYER_INFO, this::handlePlayerInfo));
+    plugin.getServer().getPluginManager().registerEvents(this, plugin);
+  }
+
+  @EventHandler(priority = EventPriority.MONITOR)
+  public void onPlayerJoin(PlayerJoinEvent event) {
+    injectHandler(event.getPlayer());
+  }
+
+  // LOWEST priority so the cache is populated before any plugin (including PGM) that may
+  // call team.removeEntry() inside its own quit handler, which sends LEAVE packets synchronously.
+  @EventHandler(priority = EventPriority.LOWEST)
+  public void onPlayerQuit(PlayerQuitEvent event) {
+    Player quitter = event.getPlayer();
+    removeHandler(quitter);
+
+    // Cache per-viewer fake names while the player is still in the player list.
+    // If any LEAVE packet is sent after they are removed (player == null from getPlayerExact),
+    // we can still substitute the correct fake name for each viewer.
+    Map<UUID, String> fakeNames = null;
+    for (Player viewer : Bukkit.getOnlinePlayers()) {
+      if (viewer.equals(quitter)) continue;
+      String fakeName = PLAYER_UTILS.getPlayerName(quitter, viewer);
+      if (!fakeName.equals(quitter.getName())) {
+        if (fakeNames == null) fakeNames = new HashMap<>();
+        fakeNames.put(viewer.getUniqueId(), fakeName);
+      }
+    }
+
+    if (fakeNames != null) {
+      String realName = quitter.getName();
+      offlineFakeNames.put(realName, fakeNames);
+      // One tick is enough: LEAVE packets are sent synchronously during disconnect cleanup.
+      plugin.getServer().getScheduler().runTask(plugin, () -> offlineFakeNames.remove(realName));
+    }
+  }
+
+  private void injectHandler(Player player) {
+    Channel channel = ((CraftPlayer) player).getHandle().connection.connection.channel;
+    if (channel.pipeline().get(HANDLER_NAME) == null) {
+      channel
+          .pipeline()
+          .addAfter(
+              "packet_handler", HANDLER_NAME, new ScoreboardTeamHandler(player.getUniqueId()));
+    }
+  }
+
+  private void removeHandler(Player player) {
+    try {
+      Channel channel = ((CraftPlayer) player).getHandle().connection.connection.channel;
+      if (channel.pipeline().get(HANDLER_NAME) != null) {
+        channel.pipeline().remove(HANDLER_NAME);
+      }
+    } catch (Exception ignored) {
+    }
   }
 
   private void handlePlayerInfo(PacketEvent event) {
+    if (SENDING.get()) return;
+    ClientboundPlayerInfoUpdatePacket nms =
+        (ClientboundPlayerInfoUpdatePacket) event.getPacket().getHandle();
+
+    Set<ClientboundPlayerInfoUpdatePacket.Action> actions = nms.actions();
+    boolean hasAddPlayer = actions.contains(ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER);
+    boolean hasUpdateDisplayName =
+        actions.contains(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME);
+
+    // ADD_PLAYER carries the profile (name + skin) that needs substitution.
+    // UPDATE_DISPLAY_NAME carries a tab-list display name that may contain the real name.
+    // All other actions carry no player-identifying strings, so nothing to transform.
+    if (!hasAddPlayer && !hasUpdateDisplayName) return;
+
     Player viewer = event.getPlayer();
+    List<ClientboundPlayerInfoUpdatePacket.Entry> entries = nms.entries();
+    List<ClientboundPlayerInfoUpdatePacket.Entry> modified = null;
+
+    for (int i = 0; i < entries.size(); i++) {
+      ClientboundPlayerInfoUpdatePacket.Entry entry = entries.get(i);
 
-    List<PlayerInfoData> dataList = event.getPacket().getPlayerInfoDataLists().read(0);
-    for (PlayerInfoData playerInfoData : dataList) {
-      if (playerInfoData == null) continue;
-      UUID playerId = playerInfoData.getProfileId();
-      Player player = Bukkit.getPlayer(playerId);
+      Player player = Bukkit.getPlayer(entry.profileId());
       if (player == null || player.equals(viewer) || !player.isOnline()) continue;
 
-      PLAYER_UTILS.refreshPlayer(event, player, viewer);
+      String fakeName = PLAYER_UTILS.getPlayerName(player, viewer);
+      if (fakeName.equals(player.getName())) continue;
+
+      // Build the fake profile if this packet initialises the player.
+      GameProfile profile = entry.profile();
+      if (hasAddPlayer && profile != null) {
+        profile = new GameProfile(entry.profileId(), fakeName, new MutablePropertyMap());
+        Skins.toProfile(profile, PLAYER_UTILS.getPlayerSkin(player, viewer));
+      }
+
+      if (modified == null) modified = new ArrayList<>(entries);
+      modified.set(
+          i,
+          new ClientboundPlayerInfoUpdatePacket.Entry(
+              entry.profileId(),
+              profile,
+              entry.listed(),
+              entry.latency(),
+              entry.gameMode(),
+              // Null out the display name so the client falls back to the profile name
+              // (the fake name). This prevents any real-name-based decoration that PGM
+              // may have put in the display name from leaking through the tab list.
+              null,
+              entry.showHat(),
+              entry.listOrder(),
+              entry.chatSession()));
+    }
+
+    if (modified != null) {
+      // The same NMS packet object is broadcast to all online players. Mutating it in-place
+      // would corrupt the data seen by viewers processed after this one. Clone and resend.
+      PacketContainer clone = event.getPacket().deepClone();
+      try {
+        PLAYER_INFO_ENTRIES_FIELD.set(clone.getHandle(), List.copyOf(modified));
+        SENDING.set(true);
+        ProtocolLibrary.getProtocolManager().sendServerPacket(viewer, clone, false);
+      } catch (Exception e) {
+        e.printStackTrace();
+        return;
+      } finally {
+        SENDING.set(false);
+      }
+      event.setCancelled(true);
+    }
+  }
+
+  /**
+   * Per-player Netty outbound handler that intercepts ClientboundSetPlayerTeamPacket before it
+   * reaches the encoder. Runs on the player's Netty IO thread — one instance per connected player,
+   * so all state here is naturally per-viewer with no cross-player sharing.
+   *
+   * <p>Handles two cases:
+   *
+   * <ul>
+   *   <li>Name substitution: replaces a nicked player's real name with their fake name.
+   *   <li>Duplicate suppression: PGM broadcasts to all party scoreboards (25+), so the same NMS
+   *       packet object is queued to this player's channel multiple times. Identity deduplication
+   *       via a WeakHashMap ensures only the first delivery is forwarded; duplicates are dropped.
+   *       The NMS object remains GC-alive for all duplicate deliveries because Netty holds a
+   *       reference in the pending write queue, so WeakHashMap entries are stable for the entire
+   *       duplicate run and are naturally reclaimed afterwards.
+   * </ul>
+   */
+  private class ScoreboardTeamHandler extends ChannelOutboundHandlerAdapter {
+
+    private final UUID viewerUUID;
+
+    // Identity set: the first time we see a given NMS packet object, we forward it (possibly
+    // with name substitution). Any subsequent write() call with the same object is a duplicate
+    // from the 25× scoreboard broadcast and is dropped. WeakHashMap ensures entries are
+    // reclaimed once the packet is no longer referenced by Netty's pending write queue.
+    private final Set<Object> seen = Collections.newSetFromMap(new WeakHashMap<>());
+
+    ScoreboardTeamHandler(UUID viewerUUID) {
+      this.viewerUUID = viewerUUID;
+    }
+
+    @Override
+    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
+        throws Exception {
+      if (!(msg instanceof ClientboundSetPlayerTeamPacket packet)
+          || packet.getPlayerAction() == null) {
+        super.write(ctx, msg, promise);
+        return;
+      }
+
+      // Drop duplicate deliveries of the same NMS object.
+      if (!seen.add(packet)) {
+        promise.setSuccess();
+        return;
+      }
+
+      Player viewer = Bukkit.getPlayer(viewerUUID);
+      if (viewer == null) {
+        super.write(ctx, msg, promise);
+        return;
+      }
+
+      Collection<String> players = packet.getPlayers();
+      List<String> playerList = players instanceof List<String> l ? l : new ArrayList<>(players);
+      List<String> modified = null;
+      boolean isLeave = packet.getPlayerAction() == ClientboundSetPlayerTeamPacket.Action.REMOVE;
+
+      for (int i = 0; i < playerList.size(); i++) {
+        String name = playerList.get(i);
+        Player player = Bukkit.getPlayerExact(name);
+        String fakeName = null;
+
+        if (player != null && player.isOnline()) {
+          fakeName = PLAYER_UTILS.getPlayerName(player, viewer);
+          if (fakeName.equals(name)) fakeName = null;
+        } else if (isLeave) {
+          // Player is offline. Use the fake name cached in onPlayerQuit if available.
+          Map<UUID, String> offlineFakes = offlineFakeNames.get(name);
+          if (offlineFakes != null) {
+            fakeName = offlineFakes.get(viewerUUID);
+          }
+        }
+
+        if (fakeName != null) {
+          if (modified == null) modified = new ArrayList<>(playerList);
+          modified.set(i, fakeName);
+        }
+      }
+
+      if (modified == null) {
+        super.write(ctx, msg, promise);
+        return;
+      }
+
+      // Temporarily replace the players list in-place, encode, then restore.
+      // Synchronized on the packet because the same NMS object is queued to multiple players'
+      // channels, which may be on different Netty IO threads.
+      synchronized (packet) {
+        Collection<String> original = packet.getPlayers();
+        TEAM_PLAYERS_FIELD.set(packet, modified);
+        super.write(ctx, msg, promise);
+        TEAM_PLAYERS_FIELD.set(packet, original);
+      }
     }
   }
 }