Initial commit

src/main/kotlin/dev/marrow/plugin/Core.kt

@@ -0,0 +1,49 @@
+package dev.marrow.plugin
+
+import com.github.shynixn.mccoroutine.bukkit.SuspendingJavaPlugin
+import dev.marrow.plugin.commands.Example
+import dev.marrow.plugin.utils.CommonUtils.gson
+import dev.marrow.plugin.utils.ComponentExtension.deserializeMiniMessage
+import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents
+import java.io.BufferedReader
+import java.io.File
+import java.io.FileReader
+import java.io.FileWriter
+import java.util.logging.Logger
+
+class Core : SuspendingJavaPlugin() {
+
+    companion object {
+        lateinit var instance: Core
+        lateinit var config: Configuration
+        lateinit var console: Logger
+    }
+
+    override suspend fun onEnableAsync() {
+        instance = this
+        console = logger
+
+        this.lifecycleManager.registerEventHandler(LifecycleEvents.COMMANDS, {
+            it.registrar().register(Example("example"), listOf("example_alias"))
+        })
+
+        server.consoleSender.sendMessage(Companion.config.enabledMessage.deserializeMiniMessage())
+    }
+
+    data class Configuration(
+        val enabledMessage: String = "<green>example plugin enabled"
+    )
+
+    override suspend fun onLoadAsync() {
+        File("${System.getProperty("user.dir")}/plugins/${this.name}").mkdir()
+        val file = File("${System.getProperty("user.dir")}/plugins/${this.name}/config.json")
+        if (!file.exists()) {
+            logger.warning("Configuration file is missing, generating default one.")
+            FileWriter(file).use { gson.toJson(Configuration(), it) }
+        }
+        val reader = BufferedReader(FileReader(file))
+        val gsonReader = gson.newJsonReader(reader)
+        val config: Configuration = gson.fromJson(gsonReader, Configuration::class.java)
+        Companion.config = config
+    }
+}

src/main/kotlin/dev/marrow/plugin/commands/Example.kt

@@ -0,0 +1,40 @@
+package dev.marrow.plugin.commands
+
+import com.mojang.brigadier.arguments.StringArgumentType
+import com.mojang.brigadier.tree.LiteralCommandNode
+import kotlinx.coroutines.*
+import net.kyori.adventure.text.Component
+import com.github.shynixn.mccoroutine.bukkit.launch
+import com.mojang.brigadier.Command
+import dev.marrow.plugin.Core
+import io.papermc.paper.command.brigadier.CommandSourceStack
+import io.papermc.paper.command.brigadier.Commands
+import io.papermc.paper.command.brigadier.Commands.argument
+import io.papermc.paper.command.brigadier.argument.ArgumentTypes
+import io.papermc.paper.command.brigadier.argument.resolvers.selector.PlayerSelectorArgumentResolver
+
+class Example private constructor() {
+    companion object {
+        operator fun invoke(command: String): LiteralCommandNode<CommandSourceStack> {
+            return Commands.literal(command).apply {
+                then(argument("player", ArgumentTypes.player()).apply {
+                    then(argument("message", StringArgumentType.greedyString()).apply {
+                        executes {
+                            val sender = it.source.sender
+                            val targetResolver = it.getArgument("player", PlayerSelectorArgumentResolver::class.java)
+                            val target = targetResolver.resolve(it.source).first()
+                            val message = it.getArgument("message", String::class.java)
+                            sender.sendMessage("${target.name} will receive your message in 1 second")
+
+                            Core.instance.launch {
+                                delay(1000)
+                                target.sendMessage(Component.text("${sender.name}: $message"))
+                            }
+                            Command.SINGLE_SUCCESS
+                        }
+                    })
+                })
+            }.build()
+        }
+    }
+}

src/main/kotlin/dev/marrow/plugin/utils/CommonUtils.kt

@@ -0,0 +1,12 @@
+package dev.marrow.plugin.utils
+
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+
+object CommonUtils {
+    val gson: Gson = GsonBuilder().apply {
+        enableComplexMapKeySerialization()
+        setPrettyPrinting()
+        serializeNulls()
+    }.create()
+}

src/main/kotlin/dev/marrow/plugin/utils/ComponentExtension.kt

@@ -0,0 +1,29 @@
+@file:Suppress("unused")
+
+package dev.marrow.plugin.utils
+
+import net.kyori.adventure.text.Component
+import net.kyori.adventure.text.format.TextDecoration
+import net.kyori.adventure.text.minimessage.MiniMessage
+import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer
+
+object ComponentExtension {
+    private val miniMessage: MiniMessage = MiniMessage.miniMessage()
+    fun Component.serializeMiniMessage(): String = miniMessage.serialize(this)
+    fun String.deserializeMiniMessage(): Component = miniMessage.deserialize(this)
+    fun String.deserializeMiniMessageNI(): Component = miniMessage.deserialize(this).decoration(TextDecoration.ITALIC, false)
+
+    private val gsonSerializer: GsonComponentSerializer = GsonComponentSerializer.gson()
+    fun Component.serializeGson(): String = gsonSerializer.serialize(this)
+    fun String.deserializeGson(): Component = gsonSerializer.deserialize(this)
+
+    private val legacySerializer: LegacyComponentSerializer = LegacyComponentSerializer.legacyAmpersand()
+    fun Component.serializeLegacy(): String = legacySerializer.serialize(this)
+    fun String.deserializeLegacy(): Component =  legacySerializer.deserialize(this)
+
+    private val plainSerializer: PlainTextComponentSerializer = PlainTextComponentSerializer.plainText()
+    fun Component.serializePlain(): String = plainSerializer.serialize(this)
+    fun String.deserializePlain(): Component =  plainSerializer.deserialize(this)
+}