General performance improvements & Improved Tab Groups config checker (#261)

* Added more caches
Improved internal logic performance
Added check on reload to prevent the plugin from crashing if an invalid yaml is used

* Changed debug command tab completer logic

gradle.properties

@@ -3,7 +3,7 @@ javaVersion=17
 org.gradle.jvmargs='-Dfile.encoding=UTF-8'
 org.gradle.daemon=true
 
-plugin_version=1.7.5
+plugin_version=1.7.6
 plugin_archive=velocitab
 plugin_description=A beautiful and versatile TAB list plugin for Velocity proxies
 

src/main/java/net/william278/velocitab/commands/VelocitabCommand.java

@@ -31,9 +31,14 @@ import net.kyori.adventure.text.format.TextColor;
 import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
 import net.william278.desertwell.about.AboutMenu;
 import net.william278.velocitab.Velocitab;
+import net.william278.velocitab.config.Group;
+import net.william278.velocitab.config.Settings;
+import net.william278.velocitab.config.TabGroups;
 import net.william278.velocitab.player.TabPlayer;
 import org.jetbrains.annotations.NotNull;
+import org.slf4j.event.Level;
 
+import java.util.Map;
 import java.util.Optional;
 import java.util.UUID;
 
@@ -146,7 +151,28 @@ public final class VelocitabCommand {
                 .then(LiteralArgumentBuilder.<CommandSource>literal("reload")
                         .requires(src -> hasPermission(src, "reload"))
                         .executes(ctx -> {
-                            plugin.loadConfigs();
+                            final Settings settings = plugin.getSettings();
+                            try {
+                                plugin.loadSettings();
+                            } catch (Throwable e) {
+                                plugin.setSettings(settings);
+                                ctx.getSource().sendRichMessage("<red>An error occurred while reloading the settings file");
+                                plugin.log(Level.ERROR, "An error occurred while reloading the settings file", e);
+                                return Command.SINGLE_SUCCESS;
+                            }
+
+                            final Map<String, Group> groups = Map.copyOf(plugin.getTabGroupsManager().getGroupsMap());
+                            final Map<TabGroups, String> groupsFiles = Map.copyOf(plugin.getTabGroupsManager().getGroupsFilesMap());
+
+                            try {
+                                plugin.getTabGroupsManager().loadGroups();
+                            } catch (Throwable e) {
+                                plugin.getTabGroupsManager().loadGroupsBackup(groups, groupsFiles);
+                                ctx.getSource().sendRichMessage("<red>An error occurred while reloading the tab groups file");
+                                plugin.log(Level.ERROR, "An error occurred while reloading the tab groups file", e);
+                                return Command.SINGLE_SUCCESS;
+                            }
+
                             plugin.getTabList().reloadUpdate();
                             ctx.getSource().sendRichMessage(systemReloaded);
                             return Command.SINGLE_SUCCESS;
@@ -157,13 +183,13 @@ public final class VelocitabCommand {
                         .then(LiteralArgumentBuilder.<CommandSource>literal("tablist")
                                 .then(RequiredArgumentBuilder.<CommandSource, String>argument("player", StringArgumentType.string())
                                         .suggests((ctx, builder1) -> {
-                                            final String input = ctx.getInput();
+                                            final String input = builder1.getRemainingLowerCase();
                                             if (input.isEmpty()) {
                                                 return builder1.buildFuture();
                                             }
                                             plugin.getServer().getAllPlayers().stream()
                                                     .map(Player::getUsername)
-                                                    .filter(s -> s.toLowerCase().startsWith(input.toLowerCase()))
+                                                    .filter(s -> s.toLowerCase().contains(input))
                                                     .forEach(builder1::suggest);
                                             return builder1.buildFuture();
                                         })

src/main/java/net/william278/velocitab/config/Group.java

@@ -20,7 +20,6 @@
 package net.william278.velocitab.config;
 
 import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
 import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.server.RegisteredServer;
 import net.william278.velocitab.Velocitab;
@@ -34,13 +33,13 @@ import org.slf4j.event.Level;
 
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
 import java.util.stream.Collectors;
 
-@SuppressWarnings("unused")
 public record Group(
         String name,
         List<String> headers,
@@ -76,23 +75,28 @@ public record Group(
     }
 
     @NotNull
-    public Set<RegisteredServer> registeredServers(@NotNull Velocitab plugin) {
+    public List<RegisteredServer> registeredServers(@NotNull Velocitab plugin) {
         return registeredServers(plugin, true);
     }
 
     @NotNull
-    public Set<RegisteredServer> registeredServers(@NotNull Velocitab plugin, boolean includeAllPlayers) {
+    public List<RegisteredServer> registeredServers(@NotNull Velocitab plugin, boolean includeAllPlayers) {
         if ((includeAllPlayers && plugin.getSettings().isShowAllPlayersFromAllGroups()) ||
                 (isDefault(plugin) && plugin.getSettings().isFallbackEnabled())) {
-            return Sets.newHashSet(plugin.getServer().getAllServers());
+            return Lists.newArrayList(plugin.getServer().getAllServers());
         }
 
         return getRegexServers(plugin);
     }
 
     @NotNull
-    private Set<RegisteredServer> getRegexServers(@NotNull Velocitab plugin) {
-        final Set<RegisteredServer> totalServers = Sets.newHashSet();
+    private List<RegisteredServer> getRegexServers(@NotNull Velocitab plugin) {
+        final Optional<List<RegisteredServer>> cachedServers = plugin.getTabGroupsManager().getCachedServers(this);
+        if (cachedServers.isPresent()) {
+            return cachedServers.get();
+        }
+
+        final List<RegisteredServer> totalServers = Lists.newArrayList();
         for (String server : servers) {
             try {
                 final Matcher matcher = Pattern.compile(server, Pattern.CASE_INSENSITIVE).matcher("");
@@ -105,6 +109,7 @@ public record Group(
             }
         }
 
+        plugin.getTabGroupsManager().cacheServers(this, totalServers);
         return totalServers;
     }
 
@@ -113,17 +118,7 @@ public record Group(
     }
 
     @NotNull
-    public Set<Player> getPlayers(@NotNull Velocitab plugin) {
-        final Set<Player> players = Sets.newHashSet();
-        for (RegisteredServer server : registeredServers(plugin)) {
-            players.addAll(server.getPlayersConnected());
-        }
-
-        return players;
-    }
-
-    @NotNull
-    public List<Player> getPlayersAsList(@NotNull Velocitab plugin) {
+    public List<Player> getPlayers(@NotNull Velocitab plugin) {
         final List<Player> players = Lists.newArrayList();
         for (RegisteredServer server : registeredServers(plugin)) {
             players.addAll(server.getPlayersConnected());
@@ -133,22 +128,7 @@ public record Group(
     }
 
     @NotNull
-    public Set<Player> getPlayers(@NotNull Velocitab plugin, @NotNull TabPlayer tabPlayer) {
-        if (plugin.getSettings().isShowAllPlayersFromAllGroups()) {
-            return Sets.newHashSet(plugin.getServer().getAllPlayers());
-        }
-
-        if (onlyListPlayersInSameServer) {
-            return tabPlayer.getPlayer().getCurrentServer()
-                    .map(s -> Sets.newHashSet(s.getServer().getPlayersConnected()))
-                    .orElseGet(Sets::newHashSet);
-        }
-
-        return getPlayers(plugin);
-    }
-
-    @NotNull
-    public List<Player> getPlayersAsList(@NotNull Velocitab plugin, @NotNull TabPlayer tabPlayer) {
+    public List<Player> getPlayers(@NotNull Velocitab plugin, @NotNull TabPlayer tabPlayer) {
         if (plugin.getSettings().isShowAllPlayersFromAllGroups()) {
             return Lists.newArrayList(plugin.getServer().getAllPlayers());
         }
@@ -159,30 +139,10 @@ public record Group(
                     .orElseGet(Lists::newArrayList);
         }
 
-        return getPlayersAsList(plugin);
+        return getPlayers(plugin);
     }
 
-    /**
-     * Retrieves the set of TabPlayers associated with the given Velocitab plugin instance.
-     * If the plugin is configured to show all players from all groups, all players will be returned.
-     *
-     * @param plugin The Velocitab plugin instance.
-     * @return A set of TabPlayers.
-     */
-    @NotNull
-    public Set<TabPlayer> getTabPlayers(@NotNull Velocitab plugin) {
-        if (plugin.getSettings().isShowAllPlayersFromAllGroups()) {
-            return plugin.getTabList().getPlayers().values().stream().filter(TabPlayer::isLoaded).collect(Collectors.toSet());
-        }
-
-        return plugin.getTabList().getPlayers()
-                .values()
-                .stream()
-                .filter(tabPlayer -> tabPlayer.isLoaded() && tabPlayer.getGroup().equals(this))
-                .collect(Collectors.toSet());
-    }
-
-    public List<TabPlayer> getTabPlayersAsList(@NotNull Velocitab plugin) {
+    public List<TabPlayer> getTabPlayers(@NotNull Velocitab plugin) {
         if (plugin.getSettings().isShowAllPlayersFromAllGroups()) {
             return plugin.getTabList().getPlayers().values().stream().filter(TabPlayer::isLoaded).collect(Collectors.toList());
         }
@@ -195,24 +155,12 @@ public record Group(
     }
 
     @NotNull
-    public Set<TabPlayer> getTabPlayers(@NotNull Velocitab plugin, @NotNull TabPlayer tabPlayer) {
-        if (plugin.getSettings().isShowAllPlayersFromAllGroups()) {
-            return plugin.getTabList().getPlayers().values().stream().filter(TabPlayer::isLoaded).collect(Collectors.toSet());
-        }
-
-        if (onlyListPlayersInSameServer) {
-            return plugin.getTabList().getPlayers()
-                    .values()
-                    .stream()
-                    .filter(player -> player.isLoaded() && player.getGroup().equals(this) && player.getServerName().equals(tabPlayer.getServerName()))
-                    .collect(Collectors.toSet());
-        }
-
-        return getTabPlayers(plugin);
+    public List<TabPlayer> getTabPlayers(@NotNull Velocitab plugin, @NotNull TabPlayer tabPlayer) {
+        return getTabPlayers(plugin, tabPlayer, false);
     }
 
     @NotNull
-    public List<TabPlayer> getTabPlayersAsList(@NotNull Velocitab plugin, @NotNull TabPlayer tabPlayer) {
+    public List<TabPlayer> getTabPlayers(@NotNull Velocitab plugin, @NotNull TabPlayer tabPlayer, boolean force) {
         if (plugin.getSettings().isShowAllPlayersFromAllGroups()) {
             return plugin.getTabList().getPlayers().values().stream().filter(TabPlayer::isLoaded).collect(Collectors.toList());
         }
@@ -221,11 +169,11 @@ public record Group(
             return plugin.getTabList().getPlayers()
                     .values()
                     .stream()
-                    .filter(player -> player.isLoaded() && player.getGroup().equals(this) && player.getServerName().equals(tabPlayer.getServerName()))
+                    .filter(player -> (player.isLoaded() || force) && player.getGroup().equals(this) && player.getServerName().equals(tabPlayer.getServerName()))
                     .collect(Collectors.toList());
         }
 
-        return getTabPlayersAsList(plugin);
+        return getTabPlayers(plugin);
     }
 
     @NotNull

src/main/java/net/william278/velocitab/config/TabGroupsManager.java

@@ -25,12 +25,15 @@ import com.google.common.collect.Sets;
 import com.velocitypowered.api.proxy.server.RegisteredServer;
 import de.exlll.configlib.YamlConfigurationProperties;
 import de.exlll.configlib.YamlConfigurations;
+import net.jodah.expiringmap.ExpiringMap;
 import net.william278.velocitab.Velocitab;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
 import java.nio.file.Path;
 import java.util.*;
+import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
 public class TabGroupsManager {
@@ -39,17 +42,22 @@ public class TabGroupsManager {
     private final Map<String, Group> groups;
     private final Map<TabGroups, String> groupsFiles;
     private List<Group> groupsList;
+    private final Map<Group, List<RegisteredServer>> cachedServers;
 
     public TabGroupsManager(@NotNull Velocitab plugin) {
         this.plugin = plugin;
         this.groups = Maps.newConcurrentMap();
         this.groupsFiles = Maps.newConcurrentMap();
         this.groupsList = Lists.newArrayList();
+        this.cachedServers = ExpiringMap.builder()
+                .expiration(30, TimeUnit.SECONDS)
+                .build();
     }
 
     public void loadGroups() {
         groups.clear();
         groupsFiles.clear();
+        cachedServers.clear();
         final Path configDirectory = plugin.getConfigDirectory();
         final File defaultFile = configDirectory.resolve("tab_groups.yml").toFile();
         final YamlConfigurationProperties properties = ConfigProvider.YAML_CONFIGURATION_PROPERTIES.header(TabGroups.CONFIG_HEADER).build();
@@ -110,7 +118,7 @@ public class TabGroupsManager {
 
         outer:
         for (Group group1 : group.groups) {
-            final Set<RegisteredServer> current = group1.registeredServers(plugin, false);
+            final List<RegisteredServer> current = group1.registeredServers(plugin, false);
             final boolean isDefault = group1.isDefault(plugin);
 
             if (groups.containsKey(group1.name())) {
@@ -133,10 +141,10 @@ public class TabGroupsManager {
 
         outer:
         for (Group group1 : groups.values()) {
-            final Set<RegisteredServer> current = group1.registeredServers(plugin, false);
+            final List<RegisteredServer> current = group1.registeredServers(plugin, false);
 
             for (Group loadingGroup : eligibleGroups) {
-                final Set<RegisteredServer> loadingGroupServers = loadingGroup.registeredServers(plugin, false);
+                final List<RegisteredServer> loadingGroupServers = loadingGroup.registeredServers(plugin, false);
                 final boolean isDefault = loadingGroup.isDefault(plugin);
 
                 if(!(isDefault && plugin.getSettings().isFallbackEnabled())) {
@@ -200,4 +208,30 @@ public class TabGroupsManager {
     public Collection<Group> getGroups() {
         return groups.values();
     }
+
+    public Optional<List<RegisteredServer>> getCachedServers(@NotNull Group group) {
+        return Optional.ofNullable(cachedServers.get(group));
+    }
+
+    public void cacheServers(@NotNull Group group, @NotNull List<RegisteredServer> servers) {
+        cachedServers.put(group, servers);
+    }
+
+    @ApiStatus.Internal
+    public Map<String, Group> getGroupsMap() {
+        return groups;
+    }
+
+    @ApiStatus.Internal
+    public Map<TabGroups, String> getGroupsFilesMap() {
+        return groupsFiles;
+    }
+
+    public void loadGroupsBackup(@NotNull Map<String, Group> groups, @NotNull Map<TabGroups, String> groupsFiles) {
+        this.groups.clear();
+        this.groups.putAll(groups);
+        this.groupsFiles.clear();
+        this.groupsFiles.putAll(groupsFiles);
+    }
+
 }

src/main/java/net/william278/velocitab/packet/ScoreboardManager.java

@@ -153,7 +153,7 @@ public class ScoreboardManager {
         if (teamName == null) {
             return;
         }
-        final Set<RegisteredServer> siblings = tabPlayer.getGroup().registeredServers(plugin);
+        final List<RegisteredServer> siblings = tabPlayer.getGroup().registeredServers(plugin);
         final boolean isNameTagEmpty = tabPlayer.getGroup().nametag().isEmpty() && !plugin.getSettings().isRemoveNametags();
 
         final Optional<Nametag> cachedTag = Optional.ofNullable(nametags.getOrDefault(teamName, null));
@@ -231,7 +231,7 @@ public class ScoreboardManager {
         }
 
         final Player player = tabPlayer.getPlayer();
-        final Set<Player> players = tabPlayer.getGroup().getPlayers(plugin, tabPlayer);
+        final List<Player> players = tabPlayer.getGroup().getPlayers(plugin, tabPlayer);
 
         final Set<String> roles = Sets.newHashSet();
         players.forEach(p -> {
@@ -367,7 +367,7 @@ public class ScoreboardManager {
             return;
         }
 
-        final Set<Player> players = tabPlayer.getGroup().getPlayers(plugin);
+        final List<Player> players = tabPlayer.getGroup().getPlayers(plugin);
         final boolean isNameTagEmpty = tabPlayer.getGroup().nametag().isEmpty() && !plugin.getSettings().isRemoveNametags();
         players.forEach(connected -> {
             try {

src/main/java/net/william278/velocitab/placeholder/Placeholder.java

@@ -49,7 +49,7 @@ public enum Placeholder {
             .orElse("")),
     GROUP_PLAYERS_ONLINE((param, plugin, player) -> {
         if (param.isEmpty()) {
-            return Integer.toString(player.getGroup().getPlayers(plugin).size());
+            return Integer.toString(player.getGroup().getTabPlayers(plugin).size());
         }
         return plugin.getTabGroupsManager().getGroup(param)
                 .map(group -> Integer.toString(group.getPlayers(plugin).size()))

src/main/java/net/william278/velocitab/placeholder/PlaceholderManager.java

@@ -83,7 +83,7 @@ public class PlaceholderManager {
 
     public void fetchPlaceholders(@NotNull Group group) {
         final List<String> texts = cachedTexts.computeIfAbsent(group, g -> g.getTextsWithPlaceholders(plugin));
-        group.getPlayersAsList(plugin).forEach(player -> fetchPlaceholders(player.getUniqueId(), texts, group));
+        group.getPlayers(plugin).forEach(player -> fetchPlaceholders(player.getUniqueId(), texts, group));
     }
 
     public void reload() {
@@ -231,10 +231,24 @@ public class PlaceholderManager {
 
     @NotNull
     private String applyPlaceholders(@NotNull String text, @NotNull Map<String, String> replacements) {
-        for (Map.Entry<String, String> entry : replacements.entrySet()) {
-            text = text.replace(entry.getKey(), entry.getValue());
+        final Matcher matcher = PLACEHOLDER_PATTERN.matcher(text);
+        final StringBuilder builder = new StringBuilder();
+        int lastAppendPosition = 0;
+
+        while (matcher.find()) {
+            builder.append(text, lastAppendPosition, matcher.start());
+            final String placeholder = matcher.group();
+            final String replacement = replacements.get(placeholder);
+            if (replacement != null) {
+                builder.append(replacement);
+            } else {
+                builder.append(placeholder);
+            }
+            lastAppendPosition = matcher.end();
         }
-        return text;
+
+        builder.append(text.substring(lastAppendPosition));
+        return builder.toString();
     }
 
     public Optional<String> getCachedPlaceholderValue(@NotNull String text, @NotNull UUID uuid) {
@@ -334,4 +348,4 @@ public class PlaceholderManager {
         result.append(text.substring(lastEnd));
         return result.toString();
     }
-}
+}

src/main/java/net/william278/velocitab/providers/DumpProvider.java

@@ -196,7 +196,7 @@ public interface DumpProvider {
         final Map<PluginStatus.ChartKey, Integer> players = getPlugin().getTabGroupsManager().getGroups().stream()
                 .collect(Collectors.toMap(
                         g -> new PluginStatus.ChartKey(g.name(), "fa6-solid:server", COLORS.get(colorIndex.getAndIncrement() % COLORS.size())),
-                        group -> group.getTabPlayersAsList(getPlugin()).size()
+                        group -> group.getTabPlayers(getPlugin()).size()
                 ));
         return new PluginStatus.ChartStatusBlock(
                 players,

src/main/java/net/william278/velocitab/sorting/SortingManager.java

@@ -67,7 +67,7 @@ public class SortingManager {
     }
 
     private boolean isLongTeamNotAllowed(@NotNull TabPlayer player) {
-        return !player.getGroup().getPlayersAsList(plugin, player).stream()
+        return !player.getGroup().getPlayers(plugin, player).stream()
                 .allMatch(t -> t.getProtocolVersion().noLessThan(ProtocolVersion.MINECRAFT_1_18));
     }
 

src/main/java/net/william278/velocitab/tab/PlayerTabList.java

@@ -43,6 +43,7 @@ import net.william278.velocitab.player.Role;
 import net.william278.velocitab.player.TabPlayer;
 import net.william278.velocitab.util.DebugSystem;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.event.Level;
 
 import java.lang.reflect.Field;
@@ -173,7 +174,7 @@ public class PlayerTabList {
                 return;
             }
 
-            final Set<RegisteredServer> serversInGroup = tabPlayer.getGroup().registeredServers(plugin);
+            final List<RegisteredServer> serversInGroup = tabPlayer.getGroup().registeredServers(plugin);
             if (serversInGroup.isEmpty()) {
                 return;
             }
@@ -219,7 +220,7 @@ public class PlayerTabList {
         players.putIfAbsent(joined.getUniqueId(), tabPlayer);
         tabPlayer.sendHeaderAndFooter(this);
         tabPlayer.setLoaded(true);
-        final List<TabPlayer> tabPlayers = group.getTabPlayersAsList(plugin, tabPlayer);
+        final List<TabPlayer> tabPlayers = group.getTabPlayers(plugin, tabPlayer);
         updateTabListOnJoin(tabPlayer, group, tabPlayers, isVanished);
     }
 
@@ -311,31 +312,23 @@ public class PlayerTabList {
         }
     }
 
-    /**
-     * Remove a player from the tab list
-     *
-     * @param uuid {@link UUID} of the {@link TabPlayer player} to remove
-     */
-    protected void removeTabListUUID(@NotNull UUID uuid) {
-        getPlayers().forEach((key, value) -> value.getPlayer().getTabList().getEntry(uuid).ifPresent(
-                entry -> value.getPlayer().getTabList().removeEntry(uuid)
-        ));
-    }
-
     protected void removePlayer(@NotNull Player target) {
         final UUID uuid = target.getUniqueId();
         final Optional<TabPlayer> tabPlayer = getTabPlayer(target.getUniqueId());
         if (tabPlayer.isEmpty()) {
             return;
         }
+
         final Group group = tabPlayer.get().getGroup();
-        final List<TabPlayer> list = group.getTabPlayersAsList(plugin, tabPlayer.get());
         tabPlayer.get().setLoaded(false);
 
-        taskManager.runDelayed(() -> list.forEach(player -> {
-            player.getPlayer().getTabList().removeEntry(uuid);
-            player.sendHeaderAndFooter(this);
-        }), 250, TimeUnit.MILLISECONDS);
+        taskManager.runDelayed(() -> {
+            final List<TabPlayer> list = group.getTabPlayers(plugin, tabPlayer.get());
+            list.forEach(player -> {
+                player.getPlayer().getTabList().removeEntry(uuid);
+                player.sendHeaderAndFooter(this);
+            });
+        }, 250, TimeUnit.MILLISECONDS);
 
         // Delete player team
         plugin.getScoreboardManager().resetCache(target);
@@ -416,7 +409,7 @@ public class PlayerTabList {
     }
 
     public void updateHeaderFooter(@NotNull Group group) {
-        group.getTabPlayersAsList(plugin).forEach(p -> {
+        group.getTabPlayers(plugin).forEach(p -> {
             p.incrementIndexes();
             p.sendHeaderAndFooter(this);
         });
@@ -437,12 +430,12 @@ public class PlayerTabList {
 
 
     public void updateSorting(@NotNull Group group) {
-        final List<TabPlayer> players = group.getTabPlayersAsList(plugin);
+        final List<TabPlayer> players = group.getTabPlayers(plugin);
         players.forEach(p -> updateSorting(p, false, players));
     }
 
     private void updateSorting(@NotNull TabPlayer tabPlayer, boolean force) {
-        final List<TabPlayer> players = tabPlayer.getGroup().getTabPlayersAsList(plugin, tabPlayer);
+        final List<TabPlayer> players = tabPlayer.getGroup().getTabPlayers(plugin, tabPlayer);
         updateSorting(tabPlayer, force, players);
     }
 
@@ -490,7 +483,7 @@ public class PlayerTabList {
     }
 
     public void updateGroupNames(@NotNull Group group) {
-        final List<TabPlayer> players = group.getTabPlayersAsList(plugin);
+        final List<TabPlayer> players = group.getTabPlayers(plugin);
         if (plugin.getSettings().isEnableRelationalPlaceholders()) {
             updateRelationalGroupNames(players);
             return;
@@ -504,7 +497,7 @@ public class PlayerTabList {
         checkStrippedString(stripped, group);
 
         for (TabPlayer player : players) {
-            updateNormalDisplayName(player, players);
+            updateNormalDisplayName(player, players, stripped);
         }
     }
 
@@ -519,18 +512,21 @@ public class PlayerTabList {
     }
 
     public void updateDisplayName(@NotNull TabPlayer tabPlayer) {
-        final List<TabPlayer> players = tabPlayer.getGroup().getTabPlayersAsList(plugin, tabPlayer);
+        final List<TabPlayer> players = tabPlayer.getGroup().getTabPlayers(plugin, tabPlayer);
         if (plugin.getSettings().isEnableRelationalPlaceholders()) {
             updateRelationalDisplayName(tabPlayer, players);
             return;
         }
 
-        updateNormalDisplayName(tabPlayer, players);
+        final String stripped = plugin.getPlaceholderManager().stripVelocitabRelPlaceholders(tabPlayer.getGroup().format());
+        updateNormalDisplayName(tabPlayer, players, stripped);
     }
 
-    private void updateNormalDisplayName(@NotNull TabPlayer tabPlayer, @NotNull List<TabPlayer> players) {
+    private void updateNormalDisplayName(@NotNull TabPlayer tabPlayer, @NotNull List<TabPlayer> players, @Nullable String stripped) {
         final Group group = tabPlayer.getGroup();
-        final String stripped = plugin.getPlaceholderManager().stripVelocitabRelPlaceholders(group.format());
+        if (stripped == null) {
+            stripped = plugin.getPlaceholderManager().stripVelocitabRelPlaceholders(group.format());
+        }
         final String withPlaceholders = plugin.getPlaceholderManager().applyPlaceholders(tabPlayer, stripped);
         final String unformatted = plugin.getPlaceholderManager().formatVelocitabPlaceholders(withPlaceholders, tabPlayer, null);
         final Component displayName = formatComponent(tabPlayer, unformatted);
@@ -689,7 +685,7 @@ public class PlayerTabList {
     }
 
     public void removeOldEntry(@NotNull Group group, @NotNull UUID uuid) {
-        final Set<TabPlayer> players = group.getTabPlayers(plugin);
+        final List<TabPlayer> players = group.getTabPlayers(plugin);
         players.forEach(player -> player.getPlayer().getTabList().removeEntry(uuid));
     }
 

src/main/java/net/william278/velocitab/tab/TabListListener.java

@@ -90,13 +90,11 @@ public class TabListListener {
     }
 
 
-    @SuppressWarnings("UnstableApiUsage")
     @Subscribe(priority = Short.MIN_VALUE)
     private void onPlayerJoin(@NotNull ServerPostConnectEvent event) {
         plugin.getTabList().getTaskManager().run(() -> handlePlayerJoin(event));
     }
 
-    @SuppressWarnings("UnstableApiUsage")
     private void handlePlayerJoin(@NotNull ServerPostConnectEvent event) {
         final Player joined = event.getPlayer();
         final String serverName = joined.getCurrentServer()
@@ -162,9 +160,7 @@ public class TabListListener {
         final Group group = groupOptional.get();
         plugin.getScoreboardManager().resetCache(joined, group);
 
-        plugin.getServer().getScheduler().buildTask(plugin, () -> {
-            plugin.getPlaceholderManager().unblockPlayer(joined.getUniqueId());
-        }).delay(10, TimeUnit.MILLISECONDS).schedule();
+        plugin.getServer().getScheduler().buildTask(plugin, () -> plugin.getPlaceholderManager().unblockPlayer(joined.getUniqueId())).delay(10, TimeUnit.MILLISECONDS).schedule();
 
         tabList.loadPlayer(joined, group, justQuit.contains(joined.getUniqueId()) ? 400 : 500);
     }

src/main/java/net/william278/velocitab/tab/TaskManager.java

@@ -30,7 +30,6 @@ import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
@@ -149,7 +148,7 @@ public class TaskManager {
     }
 
     private void updatePlaceholders(@NotNull Group group) {
-        final List<TabPlayer> players = group.getTabPlayersAsList(plugin);
+        final List<TabPlayer> players = group.getTabPlayers(plugin);
         if (players.isEmpty()) {
             return;
         }
@@ -159,7 +158,7 @@ public class TaskManager {
     }
 
     private void updateLatency(@NotNull Group group) {
-        final List<TabPlayer> groupPlayers = group.getTabPlayersAsList(plugin);
+        final List<TabPlayer> groupPlayers = group.getTabPlayers(plugin);
         if (groupPlayers.isEmpty()) {
             return;
         }