refactor: replace mutableObjectSetOf with mutableObject2ObjectMapOf for entries, clean up unused utilities, and optimize tablist management logic

Author: TheBjoRedCraft

surf-tab-velocity/src/main/kotlin/dev/slne/surf/tab/velocity/redis/TabRedisEventListener.kt

@@ -17,7 +17,10 @@ object TabRedisEventListener {
         val seenServers = tablistService.getSeenServers(server)
         val visiblePlayers = seenServers.flatMap { it.playersConnected }
 
-        tablistService.entries.add(event.tabEntry)
+        seenServers.forEach {
+            tablistService.entries[it] =
+                tablistService.entries.getOrDefault(it, mutableListOf()) + event.tabEntry
+        }
 
         visiblePlayers.forEach {
             tablistService.addPlayer(it, event.tabEntry)
@@ -26,12 +29,18 @@ object TabRedisEventListener {
 
     @OnRedisEvent
     fun onTabEntryRemove(event: TabEntryRemoveRedisEvent) {
-        println("Removing tab entry for UUID ${event.profileUuid} from tablist via Redis event")
         val server = event.baseServer
         val seenServers = tablistService.getSeenServers(server)
         val visiblePlayers = seenServers.flatMap { it.playersConnected }
 
-        tablistService.entries.removeIf { it.profile.uuid == event.profileUuid }
+        seenServers.forEach { server ->
+            tablistService.entries[server]?.forEach {
+                if (it.profile.uuid == event.profileUuid) {
+                    tablistService.entries[server] =
+                        tablistService.entries[server]?.filter { entry -> entry.profile.uuid != event.profileUuid }
+                }
+            }
+        }
 
         visiblePlayers.forEach {
             tablistService.removePlayer(it, event.profileUuid)
@@ -47,7 +56,9 @@ object TabRedisEventListener {
     @OnRedisEvent
     fun onTabShow(event: TabShowRedisEvent) {
         val player = plugin.proxy.getPlayer(event.player).getOrNull() ?: return
-        val entry = tablistService.entries.find { it.profile.uuid == event.toShow } ?: return
+        val server = player.currentServer.getOrNull()?.server ?: return
+        val entry =
+            tablistService.entries[server]?.find { it.profile.uuid == event.toShow } ?: return
 
         player.tabList.addEntry(entry.toVelocity(player.tabList))
     }

surf-tab-velocity/src/main/kotlin/dev/slne/surf/tab/velocity/service/TablistService.kt

@@ -2,7 +2,7 @@ package dev.slne.surf.tab.velocity.service
 
 import com.velocitypowered.api.proxy.Player
 import com.velocitypowered.api.proxy.server.RegisteredServer
-import dev.slne.surf.surfapi.core.api.util.mutableObjectSetOf
+import dev.slne.surf.surfapi.core.api.util.mutableObject2ObjectMapOf
 import dev.slne.surf.tab.api.entry.TabEntry
 import dev.slne.surf.tab.api.entry.TabGameMode
 import dev.slne.surf.tab.velocity.hook.LuckPermsHook
@@ -12,11 +12,12 @@ import dev.slne.surf.tab.velocity.util.getServers
 import dev.slne.surf.tab.velocity.util.toTabProfile
 import dev.slne.surf.tab.velocity.util.toVelocity
 import java.util.*
+import kotlin.jvm.optionals.getOrNull
 
 val tablistService = VelocityTablistService()
 
 class VelocityTablistService {
-    val entries = mutableObjectSetOf<TabEntry>()
+    val entries = mutableObject2ObjectMapOf<RegisteredServer, List<TabEntry>>()
 
     fun addPlayer(viewer: Player, entry: TabEntry) {
         viewer.tabList.addEntry(entry.toVelocity(viewer.tabList))
@@ -34,7 +35,8 @@ class VelocityTablistService {
     }
 
     fun sendCurrentTablist(player: Player) {
-        entries.forEach { entry ->
+        val currentServer = player.currentServer.getOrNull()?.server ?: return
+        entries[currentServer]?.forEach { entry ->
             addPlayer(player, entry)
         }
     }

surf-tab-velocity/src/main/kotlin/dev/slne/surf/tab/velocity/util/formatting-util.kt

@@ -5,20 +5,14 @@ import dev.slne.surf.surfapi.core.api.messages.adventure.buildText
 import dev.slne.surf.tab.api.entry.TabGroup
 import dev.slne.surf.tab.velocity.plugin
 import io.github.miniplaceholders.api.MiniPlaceholders
-import io.github.miniplaceholders.api.types.RelationalAudience
-import net.kyori.adventure.audience.Audience
-import net.kyori.adventure.text.Component
-import net.kyori.adventure.text.format.TextColor
 import net.kyori.adventure.text.minimessage.MiniMessage
-import net.kyori.adventure.text.minimessage.tag.Tag
 import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver
 import java.time.ZonedDateTime
 import java.time.format.DateTimeFormatter
 import kotlin.jvm.optionals.getOrNull
 
 private val dateFormatter = DateTimeFormatter.ofPattern("dd.MM.yyyy")
 private val timeFormatter = DateTimeFormatter.ofPattern("HH:mm")
-private val miniMessage = MiniMessage.miniMessage()
 private val globalResolver = TagResolver.resolver(
     MiniPlaceholders.globalPlaceholders(),
     MiniPlaceholders.audiencePlaceholders(),
@@ -27,49 +21,8 @@ private val globalResolver = TagResolver.resolver(
     MiniPlaceholders.audienceGlobalPlaceholders()
 )
 
-private fun dynamicResolver(player: Player): TagResolver =
-    TagResolver.resolver(
-        TagResolver.resolver("server") { _, _ ->
-            val name = player.currentServer
-                .getOrNull()?.server?.serverInfo?.name ?: "N/A"
-            Tag.inserting {
-                buildText { info(name) }
-            }
-        },
-        TagResolver.resolver("players_online") { _, _ ->
-            Tag.inserting {
-                buildText { info(plugin.proxy.playerCount) }
-            }
-        },
-        TagResolver.resolver("players_max") { _, _ ->
-            Tag.inserting {
-                buildText { info(plugin.proxy.configuration.showMaxPlayers) }
-            }
-        },
-        TagResolver.resolver("date") { _, _ ->
-            Tag.inserting {
-                buildText { info(nowDate()) }
-            }
-        },
-        TagResolver.resolver("time") { _, _ ->
-            Tag.inserting {
-                buildText { info(nowTime()) }
-            }
-        }
-    )
-
-
-fun String.formatWithAdventure(player: Player, other: Audience? = null): Component {
-    if (other != null) {
-        return MiniMessage.miniMessage()
-            .deserialize(
-                this,
-                RelationalAudience(player, other),
-                TagResolver.resolver(globalResolver)
-            )
-    }
-
-    return MiniMessage.miniMessage().deserialize(this, player, TagResolver.resolver(globalResolver))
+fun String.formatWithAdventure(player: Player) =
+    MiniMessage.miniMessage().deserialize(this, player, TagResolver.resolver(globalResolver))
         .replaceText {
             it.matchLiteral("<server>")
             it.replacement(buildText {
@@ -83,7 +36,7 @@ fun String.formatWithAdventure(player: Player, other: Audience? = null): Compone
             it.matchLiteral("<players_online>")
             it.replacement(buildText {
                 info(
-                    plugin.proxy.allPlayers.size
+                    plugin.proxy.playerCount
                 )
             })
         }
@@ -107,7 +60,6 @@ fun String.formatWithAdventure(player: Player, other: Audience? = null): Compone
                 info(ZonedDateTime.now().format(timeFormatter))
             })
         }
-}
 
 @Volatile
 private var cachedMinute = -1
@@ -128,17 +80,4 @@ private fun updateTimeCache() {
     }
 }
 
-private fun nowDate(): String {
-    updateTimeCache()
-    return cachedDate
-}
-
-private fun nowTime(): String {
-    updateTimeCache()
-    return cachedTime
-}
-
-
-fun TextColor.mm() = "<${this.asHexString()}>"
-
 fun TabGroup.getServers() = clients.mapNotNull { plugin.proxy.getServer(it).getOrNull() }