Add Chat-Bubbles Feature

.gitignore

@@ -2,3 +2,4 @@
 .idea/*
 !.idea/codeStyles/
 build/
+.kotlin/

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` |
 
+## Bubble Commands
+
+| Command                            | Permission               | Description                                            | Aliases                |
+|------------------------------------|--------------------------|--------------------------------------------------------|------------------------|
+| `/bubble create [players]`         | `chattore.bubble`        | Create ("blow") a bubble and invite players            | `/bb create\|/bb blow` |
+| `/bubble invite <players>`         | `chattore.bubble`        | Invite players to your bubble (if it is private)       | `/bb invite`           |
+| `/bubble join <player>`            | `chattore.bubble`        | Join a player's bubble                                 | `/bb join`             |
+| `/bubble leave`                    | `chattore.bubble`        | Leave your current bubble                              | `/bb leave`            |
+| `/bubble delete`                   | `chattore.bubble`        | Delete ("pop") your own bubble                         | `/bb delete\|/bb pop`  |
+| `/bubble kick <player>`            | `chattore.bubble`        | Kick a player from your own bubble                     | `/bb kick`             |
+| `/bubble setprivate <boolean>`     | `chattore.bubble`        | Set the visibility of your own bubble                  | `/bb setprivate`       |
+| `/bubble list`                     | `chattore.bubble`        | List all bubbles                                       | `/bb list`             |
+| `/shout <message>`                 | `chattore.bubble`        | Send a message to global chat when in a bubble         | No aliases             |
+| `/bubble burst <player>`           | `chattore.bubble.manage` | Burst (delete) someone's bubble                        | `/bb burst`            |
+| `/bubble showglobalchat <boolean>` | `chattore.bubble`        | Control the visibility of global chat when in a bubble | `/bb sgc`              |
+
 ## Other Commands
 
 | Command                 | Permission            | Description                   | Aliases    |

build.gradle.kts

@@ -6,3 +6,9 @@ plugins {
     alias(libs.plugins.pluginYml) apply false
     alias(libs.plugins.buildconfig) apply false
 }
+
+allprojects {
+    tasks.withType<Test> {
+        failOnNoDiscoveredTests = false
+    }
+}

chattore/src/main/kotlin/ChattORE.kt

@@ -1,16 +1,13 @@
 package org.openredstone.chattore
 
-import co.aikar.commands.BaseCommand
-import co.aikar.commands.CommandIssuer
-import co.aikar.commands.RegisteredCommand
-import co.aikar.commands.VelocityCommandManager
+import co.aikar.commands.*
+import co.aikar.commands.velocity.contexts.OnlinePlayer
 import com.google.inject.Inject
 import com.velocitypowered.api.event.Subscribe
 import com.velocitypowered.api.event.proxy.ProxyInitializeEvent
 import com.velocitypowered.api.plugin.Dependency
 import com.velocitypowered.api.plugin.Plugin
 import com.velocitypowered.api.plugin.annotation.DataDirectory
-import com.velocitypowered.api.proxy.Player
 import com.velocitypowered.api.proxy.ProxyServer
 import net.luckperms.api.LuckPermsProvider
 import org.openredstone.chattore.feature.*
@@ -26,12 +23,12 @@ import kotlin.io.path.exists
     url = "https://openredstone.org",
     description = "Because we want to have a chat system that actually wOREks for us.",
     authors = ["Nickster258", "PaukkuPalikka", "StackDoubleFlow", "sodiboo", "Waffle [Wueffi]"],
-    dependencies = [Dependency(id = "luckperms")]
+    dependencies = [Dependency(id = "luckperms")],
 )
 class ChattORE @Inject constructor(
     private val proxy: ProxyServer,
     private val logger: Logger,
-    @DataDirectory private val dataFolder: Path,
+    @param:DataDirectory private val dataFolder: Path,
 ) {
     @Subscribe
     fun onProxyInitialization(event: ProxyInitializeEvent) {
@@ -42,33 +39,37 @@ class ChattORE @Inject constructor(
         val pluginScope = PluginScope(this, ChattORE::class.java, proxy, dataFolder, logger, commandManager)
         commandManager.apply {
             setDefaultExceptionHandler(::handleCommandException, false)
-            commandCompletions.registerCompletion("username") { listOf(it.player.username) }
+            commandCompletions.registerStaticCompletion("boolean", arrayOf("true", "false"))
+            commandCompletions.setDefaultCompletion("boolean", Boolean::class.java)
+            commandCompletions.setDefaultCompletion("players", OnlinePlayer::class.java)
+            @Suppress("DEPRECATION")
+            enableUnstableAPI("help")
         }
         pluginScope.apply {
             val emojis = createEmojiFeature()
-            val messenger = createMessenger(emojis, database, luckPerms, config.format.global)
             val userCache = createUserCache(database.database)
+            val wiretap = createSpyingFeature(database, config.format)
+            val messenger = createMessenger(emojis, database, luckPerms, config.format, wiretap, userCache)
+            val chatConfirmations = createChatConfirmations(ChatConfirmationConfig(config.regexes))
+            val bubbleManager = createBubbleFeature(messenger, database, chatConfirmations, config.format, userCache)
             createAliasFeature()
-            createChatFeature(
-                messenger,
-                ChatConfirmationConfig(config.regexes),
-            )
+            createChatFeature(messenger, chatConfirmations, bubbleManager)
             createChattoreFeature()
             createDiscordFeature(messenger, emojis, config.discord)
-            createFunCommandsFeature()
-            createHelpOpFeature()
+            createFunCommandsFeature(chatConfirmations)
+            createHelpOpFeature(chatConfirmations)
             createJoinLeaveFeature(config.format)
-            createMailFeature(database, userCache)
-            createMessageFeature(messenger)
+            createMailFeature(database, userCache, chatConfirmations, wiretap)
+            createMessageFeature(messenger, chatConfirmations, wiretap)
             createNicknameFeature(
-                database, userCache, NicknameConfig(
+                database, userCache,
+                NicknameConfig(
                     config.clearNicknameOnChange,
                     // IDK, this when config
                     config.nicknamePresets.mapValues { (_, v) -> NickPreset(v) }.toSortedMap(),
-                )
+                ),
             )
-            createProfileFeature(database, luckPerms, userCache)
-            createSpyingFeature(database)
+            createProfileFeature(database, luckPerms, userCache, chatConfirmations)
         }
     }
 
@@ -91,11 +92,8 @@ class ChattORE @Inject constructor(
     ): Boolean {
         val exception = throwable as? ChattoreException ?: return false
         val message = exception.message ?: "Something went wrong!"
-        if (sender is Player) {
-            sender.sendSimpleS("<b><red>Oh NO ! </red></b><gray>:</gray> <red><message></red>", message)
-        } else {
-            sender.sendMessage("Error: $message")
-        }
+        // cast ok because we're running on Velocity
+        (sender as VelocityCommandIssuer).issuer.sendError(message)
         return true
     }
     // TODO reloading functionality

chattore/src/main/kotlin/ChattOREConfig.kt

@@ -15,9 +15,12 @@ data class ChattOREConfig(
 )
 
 data class FormatConfig(
-    val global: String = "<prefix> <gray>|</gray> <sender><gray>:</gray> <message>",
+    val chatMessage: 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 bubblePrefix: String = "<bubble_info>\uD83D\uDCAC</bubble_info>",
+    val spyPrefix: String = "<hover:show_text:'Spy'>\uD83D\uDD75</hover>",
+    val shoutPrefix: String = "<hover:show_text:'You've disabled global chat in bubbles. You won't see if anyone responds.'>\uD83D\uDD15</hover>",
     val joinDiscord: String = "**%player% has joined the network**",
     val leaveDiscord: String = "**%player% has left the network**",
 )

chattore/src/main/kotlin/Config.kt

@@ -99,8 +99,17 @@ private val removeUnnecessaryStuffAndReorganize: Migration = {
     }
 }
 
-private val migrations = arrayOf<Migration>(
+private val bubbleIntroduction: Migration = {
+    // format.global -> format.chatMessage
+    getObject("format").apply {
+        replace("chatMessage", get("global"))
+        remove("global")
+    }
+}
+
+private val migrations = arrayOf(
     removeUnnecessaryStuffAndReorganize,
+    bubbleIntroduction,
 )
 
 private val currentConfigVersion: ConfigVersion = migrations.size

chattore/src/main/kotlin/Messenger.kt

@@ -7,33 +7,42 @@ import kotlinx.serialization.json.jsonArray
 import kotlinx.serialization.json.jsonObject
 import kotlinx.serialization.json.jsonPrimitive
 import net.kyori.adventure.text.Component
+import net.kyori.adventure.text.Component.space
 import net.kyori.adventure.text.TextReplacementConfig
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder
 import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer
 import net.luckperms.api.LuckPerms
-import org.openredstone.chattore.feature.DiscordBroadcastEvent
-import org.openredstone.chattore.feature.Emojis
-import org.openredstone.chattore.feature.NickPreset
+import org.openredstone.chattore.feature.*
+import org.slf4j.Logger
 import java.net.URI
+import java.util.*
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.jvm.optionals.getOrNull
 
 fun PluginScope.createMessenger(
     emojis: Emojis,
     database: Storage,
     luckPerms: LuckPerms,
-    chatBroadcastFormat: String,
+    formatConfig: FormatConfig,
+    wiretap: Wiretap,
+    userCache: UserCache,
 ): 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, wiretap, logger, userCache)
 }
 
 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 wiretap: Wiretap,
+    private val logger: Logger,
+    private val userCache: UserCache,
 ) {
     private val urlRegex = """<?((http|https)://([\w_-]+(?:\.[\w_-]+)+)([^\s'<>]+)?)>?""".toRegex()
 
@@ -44,6 +53,7 @@ class Messenger(
         formatReplacement("~~", "st"),
         buildEmojiReplacement(emojis),
     )
+    val excludedFromGlobalChat: MutableSet<UUID> = ConcurrentHashMap.newKeySet()
 
     private fun formatReplacement(key: String, tag: String): TextReplacementConfig =
         TextReplacementConfig.builder()
@@ -67,36 +77,60 @@ class Messenger(
             }
             .build()
 
-    fun broadcastChatMessage(originServer: String, 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))
-
+    private fun formatPrefix(player: Player): Component {
+        val luckUser = luckPerms.userManager.getUser(player.uniqueId)!! // online users guaranteed to be loaded
         val prefix = luckUser.cachedData.metaData.prefix
             ?: luckUser.primaryGroup.replaceFirstChar(Char::uppercaseChar)
+        return prefix.legacyDeserialize()
+    }
 
-        val compoPrefix = prefix.legacyDeserialize()
-        proxy.all.sendRichMessage(
-            chatBroadcastFormat,
-            "message" toC prepareChatMessage(message, player),
-            "sender" toC sender,
-            "prefix" toC compoPrefix,
-        )
+    private fun formatSender(player: Player): Component {
+        val name = database.getNickname(player.uniqueId) ?: NickPreset(player.username)
+        return "<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))
+    }
+
+    fun formatChatMessage(
+        message: String,
+        player: Player,
+        sender: Component = formatSender(player),
+        prefix: Component = formatPrefix(player),
+    ) = formatConfig.chatMessage.render(
+        "message" toC prepareChatMessage(message, player),
+        "sender" toC sender,
+        "prefix" toC prefix,
+    )
+
+    val globalChat = proxy.all { it.uniqueId !in excludedFromGlobalChat }
+
+    fun broadcastChatMessage(player: Player, message: String) {
+        logger.info("${player.username} (${player.uniqueId}): $message")
+        val originServer = player.currentServer.getOrNull()?.serverInfo?.name ?: "VOID"
+        val compoPrefix = formatPrefix(player)
+        globalChat.sendMessage(formatChatMessage(message, player, prefix = compoPrefix))
 
         val plainPrefix = PlainTextComponentSerializer.plainText().serialize(compoPrefix)
         val discordBroadcast = DiscordBroadcastEvent(
             plainPrefix,
             player.username,
             originServer,
-            message
+            message,
         )
         proxy.eventManager.fireAndForget(discordBroadcast)
     }
 
+    fun broadcastBubbleMessage(player: Player, message: String, bubble: Bubble) {
+        logger.info("[Bubble] ${player.username} (${player.uniqueId}): $message")
+        val formattedMessage = formatChatMessage(message, player)
+        val bubbleInfo = Placeholder.styling("bubble_info", bubble.formatInfo(userCache))
+        val renderedMessage =
+            Component.textOfChildren(formatConfig.bubblePrefix.render(bubbleInfo), space(), formattedMessage)
+        bubble.players.forEach { uuid ->
+            proxy.playerOrNull(uuid)?.sendMessage(renderedMessage)
+        }
+        wiretap(renderedMessage)
+    }
+
     fun prepareChatMessage(
         message: String,
         player: Player?,