- kommand-libの外部化
- ビルド設定の見直し
This commit is contained in:
Keisuke Hirata 2025-11-28 09:03:48 +09:00
parent f61c95f3ab
commit 302575fb29
7 changed files with 286 additions and 495 deletions

View File

@ -1,14 +1,14 @@
import net.minecrell.pluginyml.bukkit.BukkitPluginDescription import net.minecrell.pluginyml.paper.PaperPluginDescription
group = "net.hareworks" group = "net.hareworks"
version = "1.1" version = "1.2"
val exposedVersion = "0.54.0" val exposedVersion = "0.54.0"
plugins { plugins {
kotlin("jvm") version "2.0.20" kotlin("jvm") version "2.2.21"
kotlin("plugin.serialization") version "2.0.20" kotlin("plugin.serialization") version "2.2.21"
id("net.minecrell.plugin-yml.bukkit") version "0.6.0" id("de.eldoria.plugin-yml.paper") version "0.8.0"
id("com.gradleup.shadow") version "9.2.2" id("com.gradleup.shadow") version "9.2.2"
} }
repositories { repositories {
@ -18,6 +18,8 @@ repositories {
} }
dependencies { dependencies {
compileOnly("io.papermc.paper:paper-api:1.21.10-R0.1-SNAPSHOT") compileOnly("io.papermc.paper:paper-api:1.21.10-R0.1-SNAPSHOT")
compileOnly("org.jetbrains.kotlin:kotlin-stdlib")
compileOnly("net.hareworks:kommand-lib:1.1")
implementation("net.kyori:adventure-api:4.17.0") implementation("net.kyori:adventure-api:4.17.0")
implementation("net.kyori:adventure-text-minimessage:4.17.0") implementation("net.kyori:adventure-text-minimessage:4.17.0")
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.1") implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.1")
@ -28,78 +30,34 @@ dependencies {
implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1") implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
implementation("org.jetbrains.exposed:exposed-kotlin-datetime:$exposedVersion") implementation("org.jetbrains.exposed:exposed-kotlin-datetime:$exposedVersion")
implementation("de.tr7zw:item-nbt-api:2.15.3") implementation("de.tr7zw:item-nbt-api:2.15.3")
implementation("com.michael-bull.kotlin-result:kotlin-result:2.0.0")
} }
tasks { tasks {
shadowJar { shadowJar {
minimize()
archiveBaseName.set("SimplyMCDB") archiveBaseName.set("SimplyMCDB")
archiveClassifier.set("") archiveClassifier.set("")
relocate("de.tr7zw.changeme.nbtapi", "net.hareworks.simplymcdb.libs.nbtapi") relocate("de.tr7zw.changeme.nbtapi", "net.hareworks.simplymcdb.libs.nbtapi")
} }
jar {
build { enabled = false
dependsOn(shadowJar)
} }
} }
bukkit { paper {
main = "net.hareworks.simplymcdb.App" main = "net.hareworks.simplymcdb.App"
name = "Simply-Minecraft-DB" name = "Simply-Minecraft-DB"
description = "It provides a simple way to manage player data through a database." description = "It provides a simple way to manage player data through a database."
version = getVersion().toString() version = getVersion().toString()
apiVersion = "1.21.10" apiVersion = "1.21.10"
authors = authors = listOf(
listOf("Hare-K02") "Hare-K02"
permissions { )
register("simplydb.*") { serverDependencies {
children = listOf("simplydb.command", "simplydb.admin") register("kommand-lib") {
load = PaperPluginDescription.RelativeLoadOrder.BEFORE
} }
register("simplydb.command") { register("permits-lib") {
description = "Allows access to the /simplydb command" load = PaperPluginDescription.RelativeLoadOrder.BEFORE
default = BukkitPluginDescription.Permission.Default.TRUE
} }
register("simplydb.command.*") { }
children = listOf(
"simplydb.command.config",
"simplydb.command.config.*",
"simplydb.command.on",
"simplydb.command.off",
)
}
register("simplydb.command.config") {
description = "Allows access to the /simplydb config command"
default = BukkitPluginDescription.Permission.Default.OP
}
register("simplydb.command.config.*") {
children = listOf(
"simplydb.command.config.reload",
"simplydb.command.config.fetch",
"simplydb.command.config.upload",
)
}
register("simplydb.command.config.reload") {
description = "Allows access to the /simplydb config reload command"
default = BukkitPluginDescription.Permission.Default.OP
}
register("simplydb.command.config.fetch") {
description = "Allows access to the /simplydb config fetch command"
default = BukkitPluginDescription.Permission.Default.OP
}
register("simplydb.command.config.upload") {
description = "Allows access to the /simplydb config upload command"
default = BukkitPluginDescription.Permission.Default.OP
}
register("simplydb.command.on") {
description = "Allows access to the /simplydb on command"
default = BukkitPluginDescription.Permission.Default.OP
}
register("simplydb.command.off") {
description = "Allows access to the /simplydb off command"
default = BukkitPluginDescription.Permission.Default.OP
}
register("simplydb.admin") {
description = "Allows configration/manage simplydb"
default = BukkitPluginDescription.Permission.Default.OP
}
}
} }

View File

@ -36,10 +36,6 @@
export PATH="$JAVA_HOME/bin:$PATH" export PATH="$JAVA_HOME/bin:$PATH"
export GRADLE_USER_HOME="$PWD/.gradle" export GRADLE_USER_HOME="$PWD/.gradle"
echo "Loaded Minecraft dev env (JDK 21 + Gradle)"
java -version || true
gradle --version || true
''; '';
}; };
} }

1
gradle.properties Normal file
View File

@ -0,0 +1 @@
kotlin.stdlib.default.dependency=false

3
settings.gradle.kts Normal file
View File

@ -0,0 +1,3 @@
rootProject.name = "simply-mcdb"
includeBuild("../kommand-lib")

View File

@ -1,147 +0,0 @@
package net.hareworks.kommandlib
import com.github.michaelbull.result.*
import kotlin.collections.listOf
import org.bukkit.Bukkit
import org.bukkit.command.CommandMap
import org.bukkit.command.CommandSender
import org.bukkit.command.PluginCommand
import org.bukkit.command.TabCompleter
import org.bukkit.plugin.java.JavaPlugin
import net.hareworks.simplymcdb.App
class KommandLib(plugin: JavaPlugin, vararg routes: Argument) {
val entries = routes.toList()
init {
val f = Bukkit.getServer().javaClass.getDeclaredField("commandMap")
f.isAccessible = true
val commandMap = f.get(Bukkit.getServer()) as CommandMap
for (route in routes) {
commandMap.register(
plugin.getName(),
(PluginCommand::class
.java
.declaredConstructors
.first()
.apply { isAccessible = true }
.newInstance(route.name, plugin) as
PluginCommand)
.apply {
this.name = name
this.setExecutor { sender, _, alias, args ->
val routeargs = routeTreeSearch(arrayOf(alias, *args))
if (routeargs.size == args.size + 1)
routeargs.last().onCommand(sender, args)
true
}
this.tabCompleter = TabCompleter { sender, _, alias, args ->
val routeargs = routeTreeSearch(arrayOf(alias, *args))
if (routeargs.size == args.size)
routeargs.last().getCompletList(sender, args)
else listOf()
}
}
)
}
}
fun routeTreeSearch(args: Array<String>): List<Argument> {
val list =
mutableListOf<Argument>(
entries.find { it.name == args[0] } ?: throw Exception("Invalid command")
)
var i = 1
while (i + 1 <= args.size) {
if (list.last().routes.isEmpty()) break
val route = list.last().routes.sortedBy { it.priority }.find { it.name == args[i] } ?: break
list.add(route)
i += route.unit
}
return list
}
fun unregister() {
val f = Bukkit.getServer().javaClass.getDeclaredField("commandMap")
f.isAccessible = true
val commandMap = f.get(Bukkit.getServer()) as CommandMap
for (route in entries) {
commandMap.getCommand(route.name)?.unregister(commandMap)
}
}
}
abstract class Argument(
val argname: String,
vararg routes: Argument,
val execute: (CommandSender, Array<String>) -> Unit
) {
val name = argname
var routes = routes.toList()
var permission: String = ""
set(value) {
field = value
if (value.isEmpty()) return
for (route in routes) {
route.permission = value + "." + route.name
}
}
var condition: (CommandSender) -> Boolean = { true }
public fun addArgs(vararg routes: Argument): Argument {
this.routes += routes
return this
}
abstract var priority: Int
open var unit: Int = 1
open fun onCommand(sender: CommandSender, args: Array<String>) {
execute(sender, args)
}
abstract fun suggest(sender: CommandSender, args: Array<String>): List<String>
fun getCompletList(sender: CommandSender, args: Array<String>): List<String> {
return routes
.filter { sender.hasPermission(it.permission) && it.condition(sender) }
.map { it.suggest(sender, args) }
.flatten()
}
}
class Route(
name: String,
vararg routes: Argument,
execute: (CommandSender, Array<String>) -> Unit
) : Argument(name, *routes, execute = execute) {
override var priority: Int = 2
override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
return if (sender.hasPermission(this.permission) &&
this.condition(sender) &&
this.name.startsWith(args.last())
)
listOf(this.name)
else listOf()
}
}
class Text(name: String, vararg routes: Argument, execute: (CommandSender, Array<String>) -> Unit) :
Argument(name, *routes, execute = execute) {
override var priority: Int = 0
override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
return listOf(args.last())
}
}
class Integer(
name: String,
vararg routes: Argument,
execute: (CommandSender, Array<String>) -> Unit
) : Argument(name, *routes, execute = execute) {
override var priority: Int = 1
override fun suggest(sender: CommandSender, args: Array<String>): List<String> {
return listOf()
}
}

View File

@ -1,7 +1,7 @@
package net.hareworks.simplymcdb package net.hareworks.simplymcdb
import net.hareworks.kommandlib.KommandLib import net.hareworks.kommand_lib.KommandLib
import net.hareworks.simplymcdb.command.smcdb import net.hareworks.simplymcdb.command.registerCommands
import net.hareworks.simplymcdb.database.Database import net.hareworks.simplymcdb.database.Database
import org.bukkit.plugin.java.JavaPlugin import org.bukkit.plugin.java.JavaPlugin
@ -30,7 +30,7 @@ public class App : JavaPlugin() {
override fun onEnable() { override fun onEnable() {
instance = this instance = this
Config.init() Config.init()
command = KommandLib(this, smcdb) command = registerCommands(this)
server.pluginManager.registerEvents(EventListener, this) server.pluginManager.registerEvents(EventListener, this)

View File

@ -1,287 +1,267 @@
package net.hareworks.simplymcdb.command package net.hareworks.simplymcdb.command
import com.github.michaelbull.result.* import java.util.UUID
import net.hareworks.kommandlib.* import net.hareworks.kommand_lib.KommandLib
import net.hareworks.simplymcdb.* import net.hareworks.kommand_lib.kommand
import net.hareworks.simplymcdb.App
import net.hareworks.simplymcdb.Config
import net.hareworks.simplymcdb.State
import net.hareworks.simplymcdb.database.Database import net.hareworks.simplymcdb.database.Database
import net.hareworks.simplymcdb.fetch
import net.hareworks.simplymcdb.findPlayersNeedingMigration
import net.hareworks.simplymcdb.isRegistered
import net.hareworks.simplymcdb.overwritePlayerData
import net.hareworks.simplymcdb.register
import net.hareworks.simplymcdb.update
import net.hareworks.simplymcdb.PlayerSerializer
import net.kyori.adventure.audience.Audience import net.kyori.adventure.audience.Audience
import net.kyori.adventure.text.minimessage.MiniMessage import net.kyori.adventure.text.minimessage.MiniMessage
import org.bukkit.entity.Player import org.bukkit.entity.Player
import org.bukkit.plugin.java.JavaPlugin
private val miniMessage = MiniMessage.miniMessage()
private val commandBuffer = mutableMapOf<UUID, String>()
public fun Audience.sendMM(message: String) { public fun Audience.sendMM(message: String) {
this.sendMessage(MiniMessage.miniMessage().deserialize(message)) this.sendMessage(miniMessage.deserialize(message))
} }
val command_buffer = mutableMapOf<java.util.UUID, String>() private fun Audience.sendConfigHelp() {
public val smcdb = sendMM(
Route("smcdb") { sender, _ -> sender.sendMessage("simptlymcdb command") } "<red>simplymcdb config help<newline><gray>reload: <green>reload the config from config.yml<newline><gray>fetch: <green>fetch the config from the database<newline><gray>upload: <green>upload the current config to the database")
.addArgs( }
Route("config") { sender, _ ->
(sender as Player).performCommand("smcdb config help") public fun registerCommands(plugin: JavaPlugin): KommandLib =
} kommand(plugin) {
.addArgs( command("smcdb") {
Route("reload") { sender, _ -> description = "Control Simply-Minecraft-DB"
sender.sendMessage("reloading config...") permission = "simplydb.command"
Config.reload()
sender.sendMessage("reloaded.") executes {
}, sender.sendMessage("simplymcdb command")
Route("fetch") { sender, _ -> }
sender.sendMessage("fetching config...")
}, literal("config") {
Route("upload") { sender, _ -> requires("simplydb.command.config")
sender.sendMessage("uploading config...") executes { sender.sendConfigHelp() }
},
Route("help") { sender, _ -> literal("reload") {
var help = requires("simplydb.command.config.reload")
MiniMessage.miniMessage() executes {
.deserialize( sender.sendMessage("reloading config...")
"<red>simplymcdb config help<newline><gray>reload: <green>reload the config from config.yml<newline><gray>fetch: <green>fetch the config from the database<newline><gray>upload: <green>upload the current config to the database" Config.reload()
) sender.sendMessage("reloaded.")
sender.sendMessage(help) }
} }
),
Route("help") { sender, _ -> literal("fetch") {
sender.sendMM( requires("simplydb.command.config.fetch")
"<red>simplymcdb help<newline><gray>config: <green>configre the plugin<newline><gray>activate: <green>when the plugin is disabled, activate it<newline><gray>deactivate: <green>when the plugin is enabled, deactivate it" executes { sender.sendMessage("fetching config...") }
) }
},
Route("activate") { sender, _ -> literal("upload") {
if (App.instance.enabled == State.ACTIVE) { requires("simplydb.command.config.upload")
sender.sendMessage("simplymcdb is already enabled.") executes { sender.sendMessage("uploading config...") }
return@Route }
}
App.instance.enable() literal("help") { executes { sender.sendConfigHelp() } }
sender.sendMessage("simplymcdb enabled.") }
},
Route("deactivate") { sender, _ -> literal("help") {
if (App.instance.enabled == State.DISABLED) { executes {
sender.sendMessage("simplymcdb is already disabled.") sender.sendMM(
return@Route "<red>simplymcdb help<newline><gray>config: <green>configre the plugin<newline><gray>activate: <green>when the plugin is disabled, activate it<newline><gray>deactivate: <green>when the plugin is enabled, deactivate it")
} }
App.instance.disable() }
sender.sendMessage("simplymcdb disabled.")
}, literal("activate") {
Route("database") { _, _ -> } requires("simplydb.command.on")
.addArgs( executes {
Route("init") { sender, _ -> if (App.instance.enabled == State.ACTIVE) {
Database.initialize() sender.sendMessage("simplymcdb is already enabled.")
sender.sendMessage("database initialized.") return@executes
}, }
Route("reset") { sender, _ -> App.instance.enable()
Database.reset() sender.sendMessage("simplymcdb enabled.")
sender.sendMessage("database reset.") }
}, }
),
Route("migrate") { sender, _ -> literal("deactivate") {
if (sender !is Player) { requires("simplydb.command.off")
sender.sendMM("<red>[SMCDB] This command can only be run by players.") executes {
return@Route if (App.instance.enabled == State.DISABLED) {
} sender.sendMessage("simplymcdb is already disabled.")
when (App.instance.enabled) { return@executes
State.DISABLED -> { }
sender.sendMM("<red>[SMCDB] simplymcdb is disabled.") App.instance.disable()
return@Route sender.sendMessage("simplymcdb disabled.")
} }
State.DISCONNECTED -> { }
sender.sendMM("<yellow>[SMCDB] Database disconnected. Try again later.")
return@Route literal("database") {
} literal("init") {
else -> {} executes {
} Database.initialize()
if (!isRegistered(sender.uniqueId)) { sender.sendMessage("database initialized.")
sender.sendMM("<red>[SMCDB] You are not registered in the database.") }
return@Route }
} literal("reset") {
try { executes {
sender.sendMM("<gray>[SMCDB] Applying legacy data...") Database.reset()
fetch(sender) sender.sendMessage("database reset.")
update(sender) }
sender.sendMM("<green>[SMCDB] Migration complete. Data updated to the latest format.") }
} catch (e: Exception) { }
App.instance.logger.warning("Failed to migrate data for ${sender.uniqueId}: ${e.message}")
sender.sendMM("<red>[SMCDB] Migration failed. Check server logs.") literal("migrate") {
} executes {
}.addArgs( val player = sender as? Player
Route("all") { sender, _ -> if (player == null) {
if (sender !is Player) { sender.sendMM("<red>[SMCDB] This command can only be run by players.")
sender.sendMM("<red>[SMCDB] This command can only be run by players.") return@executes
return@Route }
} when (App.instance.enabled) {
when (App.instance.enabled) { State.DISABLED -> {
State.DISABLED -> { sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
sender.sendMM("<red>[SMCDB] simplymcdb is disabled.") return@executes
return@Route }
} State.DISCONNECTED -> {
State.DISCONNECTED -> { sender.sendMM("<yellow>[SMCDB] Database disconnected. Try again later.")
sender.sendMM( return@executes
"<yellow>[SMCDB] Database disconnected. Try again later." }
) else -> {}
return@Route }
} if (!isRegistered(player.uniqueId)) {
else -> {} sender.sendMM("<red>[SMCDB] You are not registered in the database.")
} return@executes
val targets = findPlayersNeedingMigration() }
if (targets.isEmpty()) { try {
sender.sendMM("<gray>[SMCDB] No legacy data found.") sender.sendMM("<gray>[SMCDB] Applying legacy data...")
return@Route fetch(player)
} update(player)
sender.sendMM( sender.sendMM("<green>[SMCDB] Migration complete. Data updated to the latest format.")
"<gray>[SMCDB] Migrating ${targets.size} legacy profiles... Please wait." } catch (e: Exception) {
) App.instance.logger.warning("Failed to migrate data for ${player.uniqueId}: ${e.message}")
val backup = PlayerSerializer.serialize(sender) sender.sendMM("<red>[SMCDB] Migration failed. Check server logs.")
var migrated = 0 }
try { }
targets.forEach { entry ->
try { literal("all") {
PlayerSerializer.deserialize(sender, entry.serialized) executes {
val updatedSnapshot = PlayerSerializer.serialize(sender) val executor = sender as? Player
overwritePlayerData(entry.uuid, updatedSnapshot) if (executor == null) {
migrated++ sender.sendMM("<red>[SMCDB] This command can only be run by players.")
} catch (ex: Exception) { return@executes
App.instance.logger.warning( }
"Failed to migrate data for ${entry.uuid}: ${ex.message}" when (App.instance.enabled) {
) State.DISABLED -> {
} sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
} return@executes
} finally { }
try { State.DISCONNECTED -> {
PlayerSerializer.deserialize(sender, backup) sender.sendMM("<yellow>[SMCDB] Database disconnected. Try again later.")
} catch (restoreEx: Exception) { return@executes
App.instance.logger.warning( }
"Failed to restore migration executor state: ${restoreEx.message}" else -> {}
) }
} val targets = findPlayersNeedingMigration()
} if (targets.isEmpty()) {
sender.sendMM( sender.sendMM("<gray>[SMCDB] No legacy data found.")
"<green>[SMCDB] Migration finished ($migrated/${targets.size}). Check logs for failures." return@executes
) }
} sender.sendMM("<gray>[SMCDB] Migrating ${targets.size} legacy profiles... Please wait.")
), val backup = PlayerSerializer.serialize(executor)
Route("check") { sender, _ -> var migrated = 0
sender.sendMM( try {
"${when (App.instance.enabled) { targets.forEach { entry ->
State.ACTIVE -> "<green>●" try {
State.DISCONNECTED -> "<yellow>■" PlayerSerializer.deserialize(executor, entry.serialized)
State.DISABLED -> "<red>○" val updatedSnapshot = PlayerSerializer.serialize(executor)
}}<white> simply-minecraft-database" overwritePlayerData(entry.uuid, updatedSnapshot)
) migrated++
sender.sendMM( } catch (ex: Exception) {
"status: ${when (App.instance.enabled) { App.instance.logger.warning("Failed to migrate data for ${entry.uuid}: ${ex.message}")
State.ACTIVE -> "<green>active" }
State.DISCONNECTED -> "<yellow>disconnected" }
State.DISABLED -> "<red>disabled"}}" } finally {
) try {
sender.sendMM( PlayerSerializer.deserialize(executor, backup)
"<gray>- <white>database test: ${if (Database.ping()) "success" else "failed"}" } catch (restoreEx: Exception) {
) App.instance.logger.warning("Failed to restore migration executor state: ${restoreEx.message}")
sender.sendMM( }
"<gray>- <white>config test: ${if (Config.config.getBoolean("enabled")) "enabled" else "disabled"}" }
) sender.sendMM("<green>[SMCDB] Migration finished ($migrated/${targets.size}). Check logs for failures.")
}, }
Route("register") { sender, _ -> }
if (sender !is Player) { }
sender.sendMM("This command is only available for players.")
return@Route literal("check") {
} else executes {
when (App.instance.enabled) { sender.sendMM(
State.DISABLED -> "${when (App.instance.enabled) {
sender.sendMM( State.ACTIVE -> "<green>●"
"<red>[SMCDB] simplymcdb is disabled.<br>Run /smcdb check to check the status." State.DISCONNECTED -> "<yellow>■"
) State.DISABLED -> "<red>○"
State.DISCONNECTED -> }}<white> simply-minecraft-database")
sender.sendMM( sender.sendMM(
"<red>[SMCDB] simplymcdb is enabled but disconnected.<br>Run /smcdb check to check the status." "status: ${when (App.instance.enabled) {
) State.ACTIVE -> "<green>active"
else -> { State.DISCONNECTED -> "<yellow>disconnected"
if (!isRegistered(sender.uniqueId)) { State.DISABLED -> "<red>disabled"
sender.sendMM( }}")
"<gray>[SMCDB] <red>The inventory of the other servers will be overwritten.<newline>" + sender.sendMM(
"Are you sure you want to register?<newline>" + "<gray>- <white>database test: ${if (Database.ping()) "success" else "failed"}")
"<green>/smcdb confirm<gray> to confirm." sender.sendMM(
) "<gray>- <white>config test: ${if (Config.config.getBoolean("enabled")) "enabled" else "disabled"}")
} else { }
sender.sendMM("<gray>[SMCDB] You are already registered.") }
}
} literal("register") {
} executes {
}, val player = sender as? Player
Route("confirm") { sender, _ -> if (player == null) {
if (sender !is Player) return@Route sender.sendMM("This command is only available for players.")
when (command_buffer[sender.uniqueId]) { return@executes
"register" -> { }
if (App.instance.enabled == State.ACTIVE) { when (App.instance.enabled) {
register(sender) State.DISABLED -> {
sender.sendMM("<gray>[SMCDB] Successfully registered.") sender.sendMM("<red>[SMCDB] simplymcdb is disabled.<br>Run /smcdb check to check the status.")
} else { return@executes
sender.sendMM("<red>[SMCDB] simplymcdb is disabled.") }
} State.DISCONNECTED -> {
} sender.sendMM("<red>[SMCDB] simplymcdb is enabled but disconnected.<br>Run /smcdb check to check the status.")
else -> { return@executes
sender.sendMM("<red>[SMCDB] Invalid command.") }
} else -> {}
} }
command_buffer.remove(sender.uniqueId) if (!isRegistered(player.uniqueId)) {
} sender.sendMM(
// Route("update") { sender, _ -> "<gray>[SMCDB] <red>The inventory of the other servers will be overwritten.<newline>" +
// if (sender !is Player) { "Are you sure you want to register?<newline>" +
// sender.sendMM("This command is only available for players.") "<green>/smcdb confirm<gray> to confirm.")
// return@Route commandBuffer[player.uniqueId] = "register"
// } else } else {
// when (App.instance.enabled) { sender.sendMM("<gray>[SMCDB] You are already registered.")
// State.DISABLED -> }
// sender.sendMM( }
// "<red>[SMCDB] simplymcdb is disabled.<br>Run }
// /smcdb check to check the status."
// ) literal("confirm") {
// State.DISCONNECTED -> executes {
// sender.sendMM( val player = sender as? Player ?: return@executes
// "<red>[SMCDB] simplymcdb is enabled but when (commandBuffer[player.uniqueId]) {
// disconnected.<br>Run /smcdb check to check the status." "register" -> {
// ) if (App.instance.enabled == State.ACTIVE) {
// else -> { register(player)
// if (isRegistered(sender.uniqueId)) { sender.sendMM("<gray>[SMCDB] Successfully registered.")
// update(sender) } else {
// sender.sendMM("<gray>[SMCDB] Successfully updated.") sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
// } else { }
// sender.sendMM("<red>[SMCDB] You are not registered.") }
// } else -> sender.sendMM("<red>[SMCDB] Invalid command.")
// } }
// } commandBuffer.remove(player.uniqueId)
// }, }
// Route("fetch") { sender, _ -> }
// if (sender !is Player) { }
// sender.sendMM("This command is only available for players.") }
// return@Route
// } else
// when (App.instance.enabled) {
// State.DISABLED ->
// sender.sendMM(
// "<red>[SMCDB] simplymcdb is disabled.<br>Run
// /smcdb check to check the status."
// )
// State.DISCONNECTED ->
// sender.sendMM(
// "<red>[SMCDB] simplymcdb is enabled but
// disconnected.<br>Run /smcdb check to check the status."
// )
// else -> {
// if (isRegistered(sender.uniqueId)) {
// sender.sendMM(
// "<gray>[SMCDB] Welcome back,
// ${sender.name}.<newline>Fetching your data..."
// )
// fetch(sender)
// } else {
// sender.sendMM(
// "<gray>[SMCDB] Welcome, ${sender.name}.<newline>"
// +
// "SMCDB is active but you have already
// played before.<newline>" +
// "Run <green>/smcdb register<gray> to
// register yourself."
// )
// }
// }
// }
// },
)