Add Chat-Bubbles Feature

README.md

@@ -41,6 +41,22 @@ Because we want to have a chat system that actually wOREks for us.
 | `/profile about <player>`            | `chattore.profile.about`        | Set your about             | `/playerprofile` |
 | `/profile setabout <player> <about>` | `chattore.profile.about.others` | Set another player's about | `/playerprofile` |
 
+## Chat-Bubble Commands
+
+| Command                        | Permission               | Description                                                     | Aliases                   |
+|--------------------------------|--------------------------|-----------------------------------------------------------------|---------------------------|
+| `/bubble create`               | `chattore.bubble`        | Create ("Blow") a Chat-Bubble                                   | `/bb create\|/blow`       |
+| `/bubble invite <player>`      | `chattore.bubble`        | Invite Players to your (private) Chat-Bubble                    | `/bb invite`              |
+| `/bubble join <player>`        | `chattore.bubble`        | Join a Player's Chat-Bubble                                     | `/bb join`                |
+| `/bubble leave`                | `chattore.bubble`        | Leave your current Chat-Bubble                                  | `/bb leave`               |
+| `/bubble delete`               | `chattore.bubble`        | Delete ("Pop") your current Chat-Bubble                         | `/bb delete\|/pop`        |
+| `/bubble kick <player>`        | `chattore.bubble`        | Kick a Player from your own Chat-Bubble                         | `/bb kick`                |
+| `/bubble setPrivate <boolean>` | `chattore.bubble`        | Set the visibility of your own Chat-Bubble                      | `/bb private`             |
+| `/bubble list`                 | `chattore.bubble`        | List all Chat-Bubbles                                           | `/bb list\|/bubbles`      |
+| `/shout <message>`             | `chattore.bubble`        | Send a message to global chat when inside a Chat-Bubble         | No aliases                |
+| `/bubble forcedelete <player>` | `chattore.bubble.manage` | Force-Delete ("Burst") a specific Chat-Bubble                   | `/bb forcedelete\|/burst` |
+| `seeGlobalChat <boolean>`      | `chattore.bubble`        | Toggles the visibility of global chat when inside a Chat-Bubble | `/gc`                     |
+
 ## Other Commands
 
 | Command                 | Permission            | Description                   | Aliases    |

chattore/src/main/kotlin/ChattORE.kt

@@ -46,13 +46,14 @@ class ChattORE @Inject constructor(
         }
         pluginScope.apply {
             val emojis = createEmojiFeature()
-            val messenger = createMessenger(emojis, database, luckPerms, config.format.global)
+            val messenger = createMessenger(emojis, database, luckPerms, config.format)
             val userCache = createUserCache(database.database)
             createAliasFeature()
             createChatFeature(
                 messenger,
                 ChatConfirmationConfig(config.regexes),
             )
+            createBubbleFeature(messenger, userCache, database)
             createChattoreFeature()
             createDiscordFeature(messenger, emojis, config.discord)
             createFunCommandsFeature()

chattore/src/main/kotlin/ChattOREConfig.kt

@@ -18,6 +18,7 @@ data class FormatConfig(
     val global: String = "<prefix> <gray>|</gray> <sender><gray>:</gray> <message>",
     val join: String = "<yellow><player> has joined the network",
     val leave: String = "<yellow><player> has left the network",
+    val bubbleChatBubble: String = "<gray>[</gray><gold>B</gold><gray>]</gray> <prefix> <gray>|</gray> <sender><gray>:</gray> <message>",
     val joinDiscord: String = "**%player% has joined the network**",
     val leaveDiscord: String = "**%player% has left the network**",
 )

chattore/src/main/kotlin/Messenger.kt

@@ -10,29 +10,31 @@ import net.kyori.adventure.text.Component
 import net.kyori.adventure.text.TextReplacementConfig
 import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer
 import net.luckperms.api.LuckPerms
+import org.openredstone.chattore.feature.BubbleManager
 import org.openredstone.chattore.feature.DiscordBroadcastEvent
 import org.openredstone.chattore.feature.Emojis
 import org.openredstone.chattore.feature.NickPreset
 import java.net.URI
+import java.util.UUID
 
 fun PluginScope.createMessenger(
     emojis: Emojis,
     database: Storage,
     luckPerms: LuckPerms,
-    chatBroadcastFormat: String,
+    formatConfig: FormatConfig,
 ): Messenger {
     val fileTypeMap = Json.parseToJsonElement(loadResourceAsString("filetypes.json"))
         .jsonObject.mapValues { (_, value) -> value.jsonArray.map { it.jsonPrimitive.content } }
         .onEach { (key, values) -> logger.info("Loaded ${values.size} of type $key") }
-    return Messenger(emojis, proxy, database, luckPerms, chatBroadcastFormat, fileTypeMap)
+    return Messenger(emojis, proxy, database, luckPerms, formatConfig, fileTypeMap)
 }
 
 class Messenger(
     emojis: Emojis,
     private val proxy: ProxyServer,
     private val database: Storage,
     private val luckPerms: LuckPerms,
-    private val chatBroadcastFormat: String,
+    private val formatConfig: FormatConfig,
     private val fileTypeMap: Map<String, List<String>>,
 ) {
     private val urlRegex = """<?((http|https)://([\w_-]+(?:\.[\w_-]+)+)([^\s'<>]+)?)>?""".toRegex()
@@ -45,6 +47,10 @@ class Messenger(
         buildEmojiReplacement(emojis),
     )
 
+    val bubbleManager = BubbleManager()
+    private var excludedCache: Set<UUID> = emptySet()
+    private var cacheDirty: Boolean = true
+
     private fun formatReplacement(key: String, tag: String): TextReplacementConfig =
         TextReplacementConfig.builder()
             .match("""((\\?)(${Regex.escape(key)}(.*?)${Regex.escape(key)}))""")
@@ -76,16 +82,20 @@ class Messenger(
             "<hover:show_text:'${player.username} | <i>Click for more</i>'><click:run_command:'/playerprofile info ${player.username}'><message></click></hover>"
                 .renderSimpleC(name.render(player.username))
 
-        val prefix = luckUser.cachedData.metaData.prefix
-            ?: luckUser.primaryGroup.replaceFirstChar(Char::uppercaseChar)
+        val compoPrefix = getPrefixComponent(userId, player)
 
-        val compoPrefix = prefix.legacyDeserialize()
-        proxy.all.sendRichMessage(
-            chatBroadcastFormat,
-            "message" toC prepareChatMessage(message, player),
-            "sender" toC sender,
-            "prefix" toC compoPrefix,
-        )
+        if (cacheDirty) {
+            rebuildExcludedCache()
+        }
+
+        proxy.allPlayers.filter { it.uniqueId !in excludedCache }.forEach {
+            it.sendRichMessage(
+                formatConfig.global,
+                "message" toC prepareChatMessage(message, player),
+                "sender" toC sender,
+                "prefix" toC compoPrefix
+            )
+        }
 
         val plainPrefix = PlainTextComponentSerializer.plainText().serialize(compoPrefix)
         val discordBroadcast = DiscordBroadcastEvent(
@@ -97,6 +107,31 @@ class Messenger(
         proxy.eventManager.fireAndForget(discordBroadcast)
     }
 
+    fun broadcastBubbleMessage(player: Player, message: String) {
+        val userId = player.uniqueId
+        val userManager = luckPerms.userManager
+        val luckUser = userManager.getUser(userId) ?: return
+        val name = database.getNickname(userId) ?: NickPreset(player.username)
+        val sender =
+            "<hover:show_text:'${player.username} | <i>Click for more</i>'><click:run_command:'/playerprofile info ${player.username}'><message></click></hover>"
+                .renderSimpleC(name.render(player.username))
+
+        val compoPrefix = getPrefixComponent(userId, player)
+
+        val bubble = bubbleManager.getBubbleByPlayer(player)
+
+        bubble?.players?.forEach { uuid ->
+            val target = proxy.getPlayer(uuid).orElse(null) ?: return@forEach
+
+            target.sendRichMessage(
+                formatConfig.bubbleChatBubble,
+                "message" toC prepareChatMessage(message, player),
+                "sender" toC sender,
+                "prefix" toC compoPrefix,
+            )
+        }
+    }
+
     fun prepareChatMessage(
         message: String,
         player: Player?,
@@ -145,6 +180,27 @@ class Messenger(
             "</click><reset>").render()
     }
 
+    fun rebuildExcludedCache() {
+        val bubbleExcluded = bubbleManager.getBubbles().values.flatMap { it.players }.toMutableSet()
+        bubbleExcluded.removeAll(database.getAllGlobalChatEnabled())
+
+        excludedCache = bubbleExcluded
+        cacheDirty = false
+    }
+
+    fun setCacheDirty() {
+        cacheDirty = true
+    }
+
+    private fun getPrefixComponent(userId: UUID, player: Player): Component {
+        val luckUser = luckPerms.userManager.getUser(userId) ?: return Component.empty()
+
+        val prefix = luckUser.cachedData.metaData.prefix
+            ?: luckUser.primaryGroup.replaceFirstChar(Char::uppercaseChar)
+
+        return prefix.legacyDeserialize()
+    }
+
     private fun Component.performReplacements(replacements: List<TextReplacementConfig>): Component =
         replacements.fold(this, Component::replaceText)
 }

chattore/src/main/kotlin/Storage.kt

@@ -6,6 +6,7 @@ import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.openredstone.chattore.feature.MailboxItem
 import org.openredstone.chattore.feature.NickPreset
+import org.openredstone.chattore.feature.seeGlobalChatEnabled
 import java.nio.file.Path
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
@@ -153,4 +154,10 @@ class Storage(
         val jsonString = result[JsonSetting.value]
         Json.decodeFromString<T>(jsonString)
     }
+
+    fun getAllGlobalChatEnabled(): Set<UUID> = transaction(database) {
+        JsonSetting.selectAll().where {
+                (JsonSetting.key eq seeGlobalChatEnabled.key) and (JsonSetting.value eq Json.encodeToString(true))
+            }.map { UUID.fromString(it[JsonSetting.uuid]) }.toSet()
+    }
 }