8.0.0

.gitignore

@@ -11,7 +11,7 @@ modules/api-local/build
 modules/api-remote/build
 modules/dto/build
 # instances
-instances/fabric
-instances/forge
-instances/plugin
-instances/velocity
+instances/fabric/build
+instances/forge/build
+instances/plugin/build
+instances/velocity/build

build.gradle.kts

@@ -4,9 +4,7 @@ plugins {
     `java-library`
     alias(libs.plugins.kotlin.jvm) apply false
     alias(libs.plugins.kotlin.serialization) apply false
-    alias(libs.plugins.minecraft.fabric.loom) apply false
     alias(libs.plugins.gradle.buildconfig) apply false
-    alias(libs.plugins.gradle.shadow) apply false
 
     // klibs - core
     alias(libs.plugins.klibs.gradle.detekt) apply false
@@ -16,7 +14,6 @@ plugins {
     alias(libs.plugins.klibs.gradle.java.core) apply false
     alias(libs.plugins.klibs.gradle.publication) apply false
     alias(libs.plugins.klibs.gradle.rootinfo) apply false
-    alias(libs.plugins.klibs.minecraft.shadow) apply false
     alias(libs.plugins.klibs.minecraft.resource.processor) apply false
 }
 

gradle.properties

@@ -9,7 +9,7 @@ makeevrserg.java.ktarget=21
 # Project
 makeevrserg.project.name=AstraTemplate
 makeevrserg.project.group=ru.astrainteractive.astratemplate
-makeevrserg.project.version.string=7.8.0
+makeevrserg.project.version.string=8.0.0-alpha01
 makeevrserg.project.description=Template plugin for EmpireProjekt
 makeevrserg.project.developers=makeevrserg|Makeev Roman|makeevrserg@gmail.com
 makeevrserg.project.url=https://github.com/Astra-Interactive/AstraTemplate

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

instances/bukkit/build.gradle.kts

@@ -1,15 +1,20 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.kotlin.dsl.named
 import ru.astrainteractive.gradleplugin.property.extension.ModelPropertyValueExt.requireProjectInfo
 
+
 plugins {
     kotlin("jvm")
     alias(libs.plugins.klibs.gradle.java.core)
-    alias(libs.plugins.klibs.minecraft.shadow)
     alias(libs.plugins.klibs.minecraft.resource.processor)
+    alias(libs.plugins.gradle.shadow)
 }
 
 dependencies {
     // Kotlin
-    implementation(libs.bundles.kotlin)
+    implementation(libs.kotlin.coroutines.core)
+    implementation(libs.kotlin.serialization.json)
+    implementation(libs.kotlin.serialization.kaml)
     // AstraLibs
     implementation(libs.minecraft.astralibs.core)
     implementation(libs.minecraft.astralibs.command)
@@ -28,29 +33,63 @@ dependencies {
 }
 
 minecraftProcessResource {
-    bukkit()
+    bukkit(
+        customProperties = mapOf(
+            "libraries" to listOf(
+                libs.driver.h2.get(),
+                libs.driver.jdbc.get(),
+                libs.driver.mysql.get(),
+            ).joinToString("\",\"", "[\"", "\"]")
+        )
+    )
 }
 
-astraShadowJar {
-    requireShadowJarTask {
-        destination = File("/home/makeevrserg/Desktop/git/AstraTemplate/build/bukkit/plugins/")
-            .takeIf { it.exists() }
-            ?: File(rootDir, "jars")
-
-        val projectInfo = requireProjectInfo
-        isReproducibleFileOrder = true
-        mergeServiceFiles()
-        dependsOn(configurations)
-        archiveClassifier.set(null as String?)
-        relocate("org.bstats", projectInfo.group)
-
-        minimize {
-            exclude(dependency(libs.exposed.jdbc.get()))
-            exclude(dependency(libs.exposed.dao.get()))
-            exclude(dependency("org.jetbrains.kotlin:kotlin-stdlib:${libs.versions.kotlin.version.get()}"))
+val shadowJar = tasks.named<ShadowJar>("shadowJar")
+shadowJar.configure {
+
+    val projectInfo = requireProjectInfo
+    isReproducibleFileOrder = true
+    mergeServiceFiles()
+    dependsOn(configurations)
+    archiveClassifier.set(null as String?)
+
+    minimize {
+        exclude(dependency(libs.exposed.jdbc.get()))
+        exclude(dependency(libs.exposed.dao.get()))
+    }
+    archiveVersion.set(projectInfo.versionString)
+    archiveBaseName.set("${projectInfo.name}-bukkit")
+    destinationDirectory = rootDir.resolve("build")
+        .resolve("bukkit")
+        .resolve("plugins")
+        .takeIf(File::exists)
+        ?: File(rootDir, "jars").also(File::mkdirs)
+
+    relocate("org.bstats", projectInfo.group)
+    listOf(
+        "co.touchlab",
+        "com.mysql",
+        "google.protobuf",
+        "io.github.reactivecircus",
+        "ch.qos.logback",
+        "com.charleskorn.kaml",
+        "com.ibm.icu",
+        "it.krzeminski.snakeyaml",
+        "net.thauvin.erik",
+        "okio",
+        "org.apache",
+        "org.intellij",
+        "org.slf4j",
+        "org.jetbrains.annotations",
+        "ru.astrainteractive.klibs",
+        "ru.astrainteractive.astralibs"
+    ).forEach { pattern -> relocate(pattern, "${projectInfo.group}.$pattern") }
+    listOf(
+        "org.jetbrains.exposed",
+        "kotlinx",
+    ).forEach { pattern ->
+        relocate(pattern, "${projectInfo.group}.$pattern") {
+            exclude("kotlin/kotlin.kotlin_builtins")
         }
-        archiveVersion.set(projectInfo.versionString)
-        archiveBaseName.set("${projectInfo.name}-bukkit")
-        destinationDirectory.set(destination.get())
     }
 }

instances/bukkit/src/main/kotlin/ru/astrainteractive/astratemplate/AstraTemplate.kt

@@ -1,19 +1,17 @@
 package ru.astrainteractive.astratemplate
 
-import org.bukkit.plugin.java.JavaPlugin
-import ru.astrainteractive.astralibs.lifecycle.Lifecycle
-import ru.astrainteractive.astralibs.logging.JUtiltLogger
-import ru.astrainteractive.astralibs.logging.Logger
+import ru.astrainteractive.astralibs.lifecycle.LifecyclePlugin
 import ru.astrainteractive.astratemplate.di.RootModule
+import ru.astrainteractive.klibs.mikro.core.logging.JUtiltLogger
+import ru.astrainteractive.klibs.mikro.core.logging.Logger
 
 /**
  * Initial class for your plugin
  */
 
 class AstraTemplate :
-    JavaPlugin(),
-    Logger by JUtiltLogger("AstraTemplate"),
-    Lifecycle {
+    LifecyclePlugin(),
+    Logger by JUtiltLogger("AstraTemplate") {
     private val rootModule = RootModule(this)
 
     /**

instances/bukkit/src/main/kotlin/ru/astrainteractive/astratemplate/command/additem/AddItemCommand.kt

@@ -12,7 +12,7 @@ internal interface AddItemCommand {
     )
 
     sealed class Error(message: String) : CommandException(message) {
-        data object SenderNotPlayer : Error("SenderNotPlayer")
-        data object ItemNotfound : Error("ItemNotfound")
+        class SenderNotPlayer : Error("SenderNotPlayer")
+        class ItemNotfound : Error("ItemNotfound")
     }
 }

instances/bukkit/src/main/kotlin/ru/astrainteractive/astratemplate/command/additem/AddItemCommandRegistry.kt

@@ -1,40 +1,56 @@
 package ru.astrainteractive.astratemplate.command.additem
 
+import com.mojang.brigadier.arguments.IntegerArgumentType
+import com.mojang.brigadier.arguments.StringArgumentType
+import com.mojang.brigadier.tree.LiteralCommandNode
+import io.papermc.paper.command.brigadier.CommandSourceStack
 import org.bukkit.Bukkit
 import org.bukkit.Material
-import org.bukkit.plugin.java.JavaPlugin
-import ru.astrainteractive.astralibs.command.api.context.BukkitCommandContext
-import ru.astrainteractive.astralibs.command.api.error.ErrorHandler
-import ru.astrainteractive.astralibs.command.api.util.PluginExt.setCommandExecutor
+import ru.astrainteractive.astralibs.command.api.argumenttype.ArgumentConverter
+import ru.astrainteractive.astralibs.command.api.exception.NoPlayerException
+import ru.astrainteractive.astralibs.command.api.util.argument
+import ru.astrainteractive.astralibs.command.api.util.command
+import ru.astrainteractive.astralibs.command.api.util.requireArgument
+import ru.astrainteractive.astralibs.command.api.util.runs
 import ru.astrainteractive.astralibs.kyori.KyoriComponentSerializer
 import ru.astrainteractive.astralibs.kyori.unwrap
-import ru.astrainteractive.astralibs.util.withEntry
+import ru.astrainteractive.astratemplate.command.errorhandler.DefaultErrorHandler
 import ru.astrainteractive.klibs.kstorage.api.CachedKrate
 
 internal class AddItemCommandRegistry(
-    private val plugin: JavaPlugin,
-    private val errorHandler: ErrorHandler<BukkitCommandContext>,
-    kyoriKrate: CachedKrate<KyoriComponentSerializer>
+    kyoriKrate: CachedKrate<KyoriComponentSerializer>,
+    private val errorHandler: DefaultErrorHandler,
+    private val executor: AddItemExecutor
 ) : KyoriComponentSerializer by kyoriKrate.unwrap() {
-    private val alias = "add"
-
-    private fun tabCompleter(plugin: JavaPlugin) {
-        plugin.getCommand(alias)?.setTabCompleter { sender, command, label, args ->
-            when (args.size) {
-                2 -> Material.entries.map { it.name }.withEntry(args.last())
-                3 -> IntRange(1, 64).map { it.toString() }.withEntry(args.last())
-                else -> Bukkit.getOnlinePlayers().map { it.name }.withEntry(args.last())
-            }
+    private object MaterialArgumentConverter : ArgumentConverter<Material> {
+        override fun transform(argument: String): Material {
+            return Material.getMaterial(argument) ?: throw AddItemCommand.Error.ItemNotfound()
         }
     }
 
-    fun register() {
-        tabCompleter(plugin)
-        plugin.setCommandExecutor(
-            alias = alias,
-            commandParser = AddItemCommandParser(),
-            commandExecutor = AddItemExecutor(),
-            errorHandler = errorHandler
-        )
+    fun createNode(): LiteralCommandNode<CommandSourceStack> {
+        return command("add") {
+            argument("player", StringArgumentType.word()) { playerArg ->
+                argument("material", StringArgumentType.word()) { materialArg ->
+                    argument("amount", IntegerArgumentType.integer(1, 64)) { amountArg ->
+                        runs(errorHandler::handle) { ctx ->
+                            val playerName = ctx.requireArgument(playerArg)
+                            val player = Bukkit.getPlayerExact(playerName) ?: throw NoPlayerException(playerName)
+
+                            val material = ctx.requireArgument(materialArg, MaterialArgumentConverter)
+
+                            val amount = ctx.requireArgument(amountArg)
+                            executor.execute(
+                                AddItemCommand.Result(
+                                    player = player,
+                                    amount = amount,
+                                    item = material
+                                )
+                            )
+                        }
+                    }
+                }
+            }
+        }.build()
     }
 }

instances/bukkit/src/main/kotlin/ru/astrainteractive/astratemplate/command/additem/AddItemExecutor.kt

@@ -1,10 +1,9 @@
 package ru.astrainteractive.astratemplate.command.additem
 
 import org.bukkit.inventory.ItemStack
-import ru.astrainteractive.astralibs.command.api.executor.CommandExecutor
 
-internal class AddItemExecutor : CommandExecutor<AddItemCommand.Result> {
-    override fun execute(input: AddItemCommand.Result) {
+internal class AddItemExecutor {
+    fun execute(input: AddItemCommand.Result) {
         val itemStack = ItemStack(input.item, input.amount)
         input.player.inventory.addItem(itemStack)
     }

instances/bukkit/src/main/kotlin/ru/astrainteractive/astratemplate/command/common/CommonCommandsRegistry.kt

@@ -1,31 +1,26 @@
 package ru.astrainteractive.astratemplate.command.common
 
-import org.bukkit.plugin.java.JavaPlugin
+import com.mojang.brigadier.tree.LiteralCommandNode
+import io.papermc.paper.command.brigadier.CommandSourceStack
+import ru.astrainteractive.astralibs.command.api.util.command
+import ru.astrainteractive.astralibs.command.api.util.runs
 import ru.astrainteractive.astralibs.kyori.KyoriComponentSerializer
 import ru.astrainteractive.astralibs.kyori.unwrap
-import ru.astrainteractive.astralibs.util.withEntry
 import ru.astrainteractive.astratemplate.core.plugin.PluginTranslation
 import ru.astrainteractive.klibs.kstorage.api.CachedKrate
 import ru.astrainteractive.klibs.kstorage.util.getValue
 
 internal class CommonCommandsRegistry(
-    private val plugin: JavaPlugin,
     translationKrate: CachedKrate<PluginTranslation>,
     kyoriKrate: CachedKrate<KyoriComponentSerializer>
 ) : KyoriComponentSerializer by kyoriKrate.unwrap() {
     private val translation by translationKrate
 
-    fun register() {
-        plugin.getCommand("atemp")?.setTabCompleter { sender, command, label, args ->
-            when {
-                args.isEmpty() -> listOf("atemp", "atempreload")
-                args.size == 1 -> listOf("atemp", "atempreload").withEntry(args.last())
-                else -> emptyList()
+    fun createNode(): LiteralCommandNode<CommandSourceStack> {
+        return command("translation") {
+            runs { ctx ->
+                ctx.source.sender.sendMessage(translation.general.getByByCheck.component)
             }
-        }
-        plugin.getCommand("translation")?.setExecutor { sender, command, label, args ->
-            sender.sendMessage(translation.general.getByByCheck.component)
-            true
-        }
+        }.build()
     }
 }