GH-148 Implement mentions system with @player detection and sound notifications

README.md

@@ -26,6 +26,7 @@
 - Template System
 - Custom Placeholders System
 - Per-permission miniMessages Tags (see permissions below)
+- Mentions System - mention players with @playername and they will hear a sound (toggleable through `/chatformatter mentiontoggle`)
 
 ## 🔗 Useful links:
 
@@ -79,6 +80,7 @@
 | `chatformatter.nbt`                       | `<nbt>`                                                                                               |
 | `chatformatter.reload`                    | `/chatformatter reload`                                                                               |
 | `chatformatter.receiveupdates`            | receive update announcements for this plugin                                                          |
+| `chatformatter.mentiontoggle`             | toggle mention sound (`/chatformatter mentiontoggle`)                                                |
 
 ### config.yml
 
@@ -151,6 +153,18 @@ placeholders:
 # It is used to shorten the text even more and keep the clean file!
 templates:
   - "$hoverName($name) -> '<hover:show_text:'<dark_gray>Name: <white>$name<br><br>{rankDescription}<br>{joinDate}<br>{health}<br>{lvl}<br><br>{privateMessage}'><click:suggest_command:'/msg {displayname} '>{displayname}</click></hover>'"
+
+# Mention system settings
+mentions:
+  # When a player mentions another player with @playername, the mentioned player will hear a sound
+  enabled: true
+  # The sound to play when a player is mentioned
+  # Available sounds: https://hub.spigotmc.org/javadocs/bukkit/org/bukkit/Sound.html
+  sound: "BLOCK_NOTE_BLOCK_PLING"
+  # The volume of the mention sound (0.0 to 1.0)
+  volume: 1.0
+  # The pitch of the mention sound (0.5 to 2.0)
+  pitch: 1.0
 ```
 
 

build.gradle.kts

@@ -1,6 +1,7 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import java.io.FileOutputStream
 import java.io.IOException
+import java.io.Serializable
 import java.util.jar.JarEntry
 import java.util.jar.JarFile
 import java.util.jar.JarOutputStream
@@ -23,110 +24,114 @@ tasks.register<ShadowJar>("shadowChatFormatter") {
         this.dependsOn("${targetProject.name}:shadowJar")
     }
 
-    this.doLast {
-        this@register.mergeJars(
-            "ChatFormatter v${project.version}.jar",
-            targetProjects
-        )
-    }
-}
+    val projectVersion = project.version.toString()
+    val outputFile = project.layout.buildDirectory.file("libs/ChatFormatter v${projectVersion}.jar")
+        .map { it.asFile }
 
-fun ShadowJar.mergeJars(archiveFileName: String, projects: List<Project>) {
-    val outputFile = File(
-        this.project.layout.buildDirectory.asFile.get(),
-        "libs/$archiveFileName"
-    )
-    val outputDir = outputFile.parentFile
-        ?: throw IllegalStateException("Cannot find output directory")
+    val shadowJarFiles = targetProjects
+        .map { targetProject -> targetProject.tasks.named("shadowJar", ShadowJar::class.java).get().archiveFile.get().asFile }
 
-    if (!outputDir.exists() && !outputDir.mkdirs()) {
-        throw IllegalStateException("Failed to create directory: ${outputDir.absolutePath}")
-    }
+    val merger = JarMerger(outputFile.get(), shadowJarFiles)
 
-    if (outputFile.exists() && !outputFile.delete()) {
-        throw IllegalStateException("Cannot delete existing file: ${outputFile.absolutePath}")
-    }
+    inputs.files(shadowJarFiles)
+    outputs.files(outputFile)
 
-    if (!outputFile.createNewFile()) {
-        throw IllegalStateException("Cannot create output file: ${outputFile.absolutePath}")
+    doLast {
+        merger.mergeJars()
     }
-
-    mergeShadowJarsIntoOutput(outputFile, projects)
 }
 
-private fun mergeShadowJarsIntoOutput(
-    outputFile: File,
-    projects: List<Project>
-) {
-    JarOutputStream(FileOutputStream(outputFile)).use { outputJar ->
-        val processedEntries = mutableSetOf<String>()
+class JarMerger(
+    private val outputFile: File,
+    private val inputFiles: List<File>
+) : Serializable {
+
+    fun mergeJars() {
+        val outputDir = outputFile.parentFile
+            ?: throw IllegalStateException("Cannot find output directory")
+
+        if (!outputDir.exists() && !outputDir.mkdirs()) {
+            throw IllegalStateException("Failed to create directory: ${outputDir.absolutePath}")
+        }
+
+        if (outputFile.exists() && !outputFile.delete()) {
+            throw IllegalStateException("Cannot delete existing file: ${outputFile.absolutePath}")
+        }
+
+        if (!outputFile.createNewFile()) {
+            throw IllegalStateException("Cannot create output file: ${outputFile.absolutePath}")
+        }
 
-        for (targetProject in projects) {
-            val shadowJarTask = targetProject.tasks.named("shadowJar", ShadowJar::class.java).get()
+        JarOutputStream(FileOutputStream(outputFile)).use { outputJar ->
+            val processedEntries = mutableSetOf<String>()
 
-            for (jarFile in shadowJarTask.outputs.files.files) {
+            for (jarFile in inputFiles) {
                 processJarFile(jarFile, outputJar, processedEntries)
             }
         }
     }
-}
 
-private fun processJarFile(
-    jarFile: File,
-    outputJar: JarOutputStream,
-    processedEntries: MutableSet<String>
-) {
-    JarFile(jarFile).use { sourceJar ->
-        for (entry in sourceJar.entries()) {
-            if (entry.isDirectory || processedEntries.contains(entry.name)) {
-                continue
-            }
 
-            try {
-                copyJarEntry(sourceJar, entry, outputJar)
-                processedEntries.add(entry.name)
-            } catch (exception: IOException) {
-                if (exception.message?.contains("duplicate entry:") != true) {
-                    throw exception
+    private fun processJarFile(
+        jarFile: File,
+        outputJar: JarOutputStream,
+        processedEntries: MutableSet<String>
+    ) {
+        JarFile(jarFile).use { sourceJar ->
+            for (entry in sourceJar.entries()) {
+                if (entry.isDirectory || processedEntries.contains(entry.name)) {
+                    continue
+                }
+
+                try {
+                    copyJarEntry(sourceJar, entry, outputJar)
+                    processedEntries.add(entry.name)
+                } catch (exception: IOException) {
+                    if (exception.message?.contains("duplicate entry:") != true) {
+                        throw exception
+                    }
                 }
             }
         }
     }
-}
 
-private fun copyJarEntry(
-    sourceJar: JarFile,
-    entry: JarEntry,
-    outputJar: JarOutputStream
-) {
-    val entryBytes = sourceJar.getInputStream(entry).use { it.readBytes() }
-    val newEntry = JarEntry(entry.name).apply {
-        this.time = System.currentTimeMillis()
-        this.size = entryBytes.size.toLong()
+    private fun copyJarEntry(
+        sourceJar: JarFile,
+        entry: JarEntry,
+        outputJar: JarOutputStream
+    ) {
+        val entryBytes = sourceJar.getInputStream(entry).use { it.readBytes() }
+        val newEntry = JarEntry(entry.name).apply {
+            this.time = System.currentTimeMillis()
+            this.size = entryBytes.size.toLong()
+        }
+
+        outputJar.putNextEntry(newEntry)
+        outputJar.write(entryBytes)
+        outputJar.closeEntry()
     }
 
-    outputJar.putNextEntry(newEntry)
-    outputJar.write(entryBytes)
-    outputJar.closeEntry()
 }
 
 runPaper {
     this.disablePluginJarDetection()
 }
 
 tasks.runServer {
-    minecraftVersion("1.21.10")
+    minecraftVersion("1.21.11")
     dependsOn("shadowChatFormatter")
     pluginJars.from(layout.buildDirectory.file("libs/ChatFormatter v${project.version}.jar"))
+    jvmArgs("-Dcom.mojang.eula.agree=true", "-XX:+AllowEnhancedClassRedefinition")
 
     javaLauncher.set(
         javaToolchains.launcherFor {
+            this.vendor = JvmVendorSpec.JETBRAINS
             this.languageVersion.set(JavaLanguageVersion.of(21))
         }
     )
 
     downloadPlugins {
-        this.modrinth("luckperms", "v5.5.0-bukkit")
-        this.modrinth("VaultUnlocked", "2.16.0")
+        this.modrinth("luckperms", "v5.5.17-bukkit")
+        this.modrinth("VaultUnlocked", "2.19.0")
     }
 }

buildSrc/build.gradle.kts

@@ -10,5 +10,5 @@ repositories {
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.3.10")
     implementation("com.gradleup.shadow:com.gradleup.shadow.gradle.plugin:9.3.1")
-    implementation("net.minecrell:plugin-yml:0.6.0")
+    implementation("de.eldoria.plugin-yml.bukkit:de.eldoria.plugin-yml.bukkit.gradle.plugin:0.8.0")
 }

buildSrc/src/main/kotlin/eternalcode.java.gradle.kts

@@ -13,7 +13,7 @@ repositories {
     maven { url = uri("https://repo.extendedclip.com/content/repositories/placeholderapi/") }
     maven { url = uri("https://jitpack.io") }
     maven { url = uri("https://repo.eternalcode.pl/releases") }
-    maven(url = "https://s01.oss.sonatype.org/content/repositories/snapshots/")
+    maven { url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/") }
 }
 
 java {

chatformatter-core/build.gradle.kts

@@ -30,6 +30,9 @@ dependencies {
     compileOnly("me.clip:placeholderapi:2.12.1")
     compileOnly("com.github.MilkBowl:VaultAPI:1.7.1")
 
+    // LuckPerms API
+    compileOnly("net.luckperms:api:5.4")
+
     // GitCheck
     implementation("com.eternalcode:gitcheck:1.0.0")
 

chatformatter-core/src/main/java/com/eternalcode/formatter/ChatFormatterApi.java

@@ -1,5 +1,6 @@
 package com.eternalcode.formatter;
 
+import com.eternalcode.formatter.mention.MentionService;
 import com.eternalcode.formatter.rank.ChatRankProvider;
 import com.eternalcode.formatter.template.TemplateService;
 import com.eternalcode.formatter.placeholder.PlaceholderRegistry;
@@ -14,4 +15,6 @@ public interface ChatFormatterApi {
 
     ChatHandler getChatHandler();
 
+    MentionService getMentionService();
+
 }

chatformatter-core/src/main/java/com/eternalcode/formatter/ChatFormatterCommand.java

@@ -1,6 +1,7 @@
 package com.eternalcode.formatter;
 
 import com.eternalcode.formatter.config.ConfigManager;
+import com.eternalcode.formatter.mention.MentionPlayerSettings;
 import com.google.common.base.Stopwatch;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.platform.AudienceProvider;
@@ -14,59 +15,86 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Collections;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
 class ChatFormatterCommand implements CommandExecutor, TabCompleter {
 
     private static final String RELOAD_MESSAGE = "<b><gradient:#29fbff:#38b3ff>ChatFormatter:</gradient></b> <green>Successfully reloaded configs in %sms!";
-    public static final String RELOAD_PERMISSION = "chatformatter.reload";
+    private static final String PLAYER_ONLY = "<b><gradient:#29fbff:#38b3ff>ChatFormatter:</gradient></b> <red>Only players can use this command!";
+    private static final String TOGGLED_MENTION = "<b><gradient:#29fbff:#38b3ff>ChatFormatter:</gradient></b> <green>Toggled mention sound";
+    private static final String RELOAD_PERMISSION = "chatformatter.reload";
+    private static final String MENTION_TOGGLE_PERMISSION = "chatformatter.mentiontoggle";
 
     private final ConfigManager configManager;
     private final AudienceProvider provider;
     private final MiniMessage miniMessage;
+    private final MentionPlayerSettings playerSettings;
 
-    ChatFormatterCommand(ConfigManager configManager, AudienceProvider provider, MiniMessage miniMessage) {
+
+    ChatFormatterCommand(ConfigManager configManager, AudienceProvider provider, MiniMessage miniMessage, MentionPlayerSettings playerSettings) {
         this.configManager = configManager;
         this.provider = provider;
         this.miniMessage = miniMessage;
+        this.playerSettings = playerSettings;
     }
 
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (args.length == 0 || !args[0].equalsIgnoreCase("reload")) {
+        if (args.length == 0) {
             sender.sendMessage(command.getUsage());
             return true;
         }
 
-        if (sender.hasPermission(RELOAD_PERMISSION)) {
+        Audience audience = sender instanceof Player player
+                ? this.provider.player(player.getUniqueId())
+                : this.provider.console();
+
+        // /chatformatter reload
+        if (args[0].equalsIgnoreCase("reload") && sender.hasPermission(RELOAD_PERMISSION)) {
             Stopwatch stopwatch = Stopwatch.createStarted();
 
             this.configManager.loadAndRenderConfigs();
             long millis = stopwatch.elapsed(TimeUnit.MILLISECONDS);
 
             Component deserialized = this.miniMessage.deserialize(String.format(RELOAD_MESSAGE, millis));
-            Audience audience = sender instanceof Player player
-                ? this.provider.player(player.getUniqueId())
-                : this.provider.console();
 
             audience.sendMessage(deserialized);
 
             return true;
         }
 
+        // /chatformatter mentiontoggle
+        if (args[0].equalsIgnoreCase("mentiontoggle")) {
+            if (!(sender instanceof Player player)) {
+                audience.sendMessage(this.miniMessage.deserialize(PLAYER_ONLY));
+                return true;
+            }
+
+            if (sender.hasPermission(MENTION_TOGGLE_PERMISSION)) {
+                boolean enabled = this.playerSettings.toggleMentionSound(player.getUniqueId());
+                audience.sendMessage(this.miniMessage.deserialize(TOGGLED_MENTION + (enabled ? " <green>on." : " <red>off.")));
+                return true;
+            }
+        }
+
         return false;
     }
 
 
     @Nullable
     @Override
     public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
-        if (args.length == 1 && sender.hasPermission(RELOAD_PERMISSION)) {
-            return List.of("reload");
+        List<String> suggestions = new ArrayList<>();
+        if (args.length == 1) {
+            if (sender.hasPermission(RELOAD_PERMISSION)) {
+                suggestions.add("reload");
+            }
+            if (sender.hasPermission(MENTION_TOGGLE_PERMISSION)) {
+                suggestions.add("mentiontoggle");
+            }
         }
-
-        return Collections.emptyList();
+        return suggestions;
     }
 }