Hare/simply-minecraft-db
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sync successfull

Browse Source
This commit is contained in:
Keisuke Hirata 2024-12-04 18:47:46 +09:00
parent 53f68e973e
commit 2e9f984bd4
12 changed files with 479 additions and 338 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
README.md
View File

@ -1,2 +1,7 @@
# Simply-minecraft-db # Simply-minecraft-db
## Features
- [x] Configurable sharing options
- [x] Store config to database
- [x] Sync settings across multiple servers via a database

14
build.gradle.kts
View File

@ -14,18 +14,21 @@ plugins {
repositories { repositories {
mavenCentral() mavenCentral()
maven("https://repo.papermc.io/repository/maven-public/") maven("https://repo.papermc.io/repository/maven-public/")
maven("https://repo.codemc.io/repository/maven-public/")
} }
dependencies { dependencies {
compileOnly("io.papermc.paper:paper-api:1.21.1-R0.1-SNAPSHOT") compileOnly("io.papermc.paper:paper-api:1.21.3-R0.1-SNAPSHOT")
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")
implementation("org.postgresql:postgresql:42.7.1") implementation("org.postgresql:postgresql:42.7.1")
implementation("org.jetbrains.exposed:exposed-core:$exposedVersion") implementation("org.jetbrains.exposed:exposed-core:$exposedVersion")
implementation("org.jetbrains.exposed:exposed-dao:$exposedVersion") implementation("org.jetbrains.exposed:exposed-dao:$exposedVersion")
implementation("org.jetbrains.exposed:exposed-jdbc:$exposedVersion") implementation("org.jetbrains.exposed:exposed-jdbc:$exposedVersion")
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")
compileOnly("de.tr7zw:item-nbt-api-plugin:2.14.0")
implementation("com.michael-bull.kotlin-result:kotlin-result:2.0.0")
} }
tasks { tasks {
shadowJar { shadowJar {
@ -39,11 +42,10 @@ bukkit {
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.1" apiVersion = "1.21.3"
authors = authors =
listOf( listOf("Hare-K02")
"Hare-K02", depend = listOf("NBTAPI")
)
permissions { permissions {
register("simplydb.*") { register("simplydb.*") {
children = listOf("simplydb.command", "simplydb.admin") children = listOf("simplydb.command", "simplydb.admin")

177
src/main/kotlin/net/hareworks/kommandlib/main.kt
View File

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

15
src/main/kotlin/net/hareworks/simplymcdb/App.kt
View File

@ -1,11 +1,11 @@
package net.hareworks.simplymcdb package net.hareworks.simplymcdb
import net.hareworks.simplymcdb.Config
import net.hareworks.simplymcdb.database.Database
import net.hareworks.simplymcdb.command.smcdb
import net.hareworks.kommandlib.KommandLib import net.hareworks.kommandlib.KommandLib
import net.hareworks.simplymcdb.command.smcdb
import net.hareworks.simplymcdb.database.Database
import org.bukkit.plugin.java.JavaPlugin import org.bukkit.plugin.java.JavaPlugin
enum class State { enum class State {
ACTIVE, ACTIVE,
DISCONNECTED, DISCONNECTED,
@ -24,12 +24,15 @@ public class App : JavaPlugin() {
} }
lateinit var command: KommandLib lateinit var command: KommandLib
private set private set
override fun onEnable() { override fun onEnable() {
instance = this instance = this
logger.info("simplymcdb enabled.")
Config.init() Config.init()
command = KommandLib(this, "smcdb" to smcdb) command = KommandLib(this, smcdb)
server.pluginManager.registerEvents(EventListener, this)
if (Config.check()) enable()
} }
override fun onDisable() { override fun onDisable() {
enabled = State.DISABLED enabled = State.DISABLED

309
src/main/kotlin/net/hareworks/simplymcdb/Command.kt
View File

@ -1,119 +1,202 @@
package net.hareworks.simplymcdb.command package net.hareworks.simplymcdb.command
import com.github.michaelbull.result.*
import net.hareworks.kommandlib.* import net.hareworks.kommandlib.*
import net.hareworks.simplymcdb.App import net.hareworks.simplymcdb.*
import net.hareworks.simplymcdb.State
import net.hareworks.simplymcdb.config.reload as reloadConfig
import net.hareworks.simplymcdb.database.Database import net.hareworks.simplymcdb.database.Database
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
public val smcdb: Route = public fun Audience.sendMM(message: String) {
Route( this.sendMessage(MiniMessage.miniMessage().deserialize(message))
"config" to }
Route(
"reload" to val command_buffer = mutableMapOf<java.util.UUID, String>()
Route { sender, _ -> public val smcdb =
sender.sendMessage("reloading config...") Route("smcdb") { sender, _ -> sender.sendMessage("simptlymcdb command") }
reloadConfig() .addArgs(
sender.sendMessage("reloaded.") Route("config") { sender, _ ->
} (sender as Player).performCommand("smcdb config help")
.apply { }
permission = .addArgs(
"simplydb.command.config.reload" Route("reload") { sender, _ ->
}, sender.sendMessage("reloading config...")
"fetch" to Config.reload()
Route { sender, _ -> sender.sendMessage("reloaded.")
sender.sendMessage("fetching config...") },
} Route("fetch") { sender, _ ->
.apply { sender.sendMessage("fetching config...")
permission = },
"simplydb.command.config.fetch" Route("upload") { sender, _ ->
}, sender.sendMessage("uploading config...")
"upload" to },
Route { sender, _ -> Route("help") { sender, _ ->
sender.sendMessage("uploading config...") var help =
} MiniMessage.miniMessage()
.apply { .deserialize(
permission = "<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"
"simplydb.command.config.upload" )
}, sender.sendMessage(help)
"help" to }
Route { sender, _ -> ),
var help = Route("help") { sender, _ ->
MiniMessage.miniMessage() sender.sendMM(
.deserialize( "<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"
"<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" )
) },
sender.sendMessage(help) Route("activate") { sender, _ ->
} if (App.instance.enabled == State.ACTIVE) {
.apply { sender.sendMessage("simplymcdb is already enabled.")
permission = return@Route
"simplydb.command.config" }
}, App.instance.enable()
"on" to sender.sendMessage("simplymcdb enabled.")
Route { sender, _ -> },
if (App.instance.enabled == State.ACTIVE Route("deactivate") { sender, _ ->
) { if (App.instance.enabled == State.DISABLED) {
sender.sendMessage( sender.sendMessage("simplymcdb is already disabled.")
"simplymcdb is already enabled." return@Route
) }
return@Route App.instance.disable()
} sender.sendMessage("simplymcdb disabled.")
App.instance.enable() },
sender.sendMessage("simplymcdb enabled.") Route("database") { _, _ -> }
} .addArgs(
.apply { Route("init") { sender, _ ->
permission = "simplydb.command.config.on" Database.initialize()
}, sender.sendMessage("database initialized.")
"off" to },
Route { sender, _ -> Route("reset") { sender, _ ->
if (App.instance.enabled != State.ACTIVE Database.reset()
) { sender.sendMessage("database reset.")
sender.sendMessage( },
"simplymcdb is already disabled." ),
) Route("check") { sender, _ ->
return@Route sender.sendMM(
} "${when (App.instance.enabled) {
App.instance.disable() State.ACTIVE -> "<green>●"
sender.sendMessage("simplymcdb disabled.") State.DISCONNECTED -> "<yellow>■"
} State.DISABLED -> "<red>○"
.apply { }}<white> simply-minecraft-database"
permission = )
"simplydb.command.config.off" sender.sendMM(
}, "status: ${when (App.instance.enabled) {
) { sender, _ -> State.ACTIVE -> "<green>active"
(sender as ).performCommand("smcdb config help") State.DISCONNECTED -> "<yellow>disconnected"
} State.DISABLED -> "<red>disabled"}}"
.apply { permission = "simplydb.command.config" }, )
"help" to Route { sender, _ -> sender.sendMM(
var help = "<gray>- <white>database test: ${if (Database.ping()) "success" else "failed"}"
MiniMessage.miniMessage() )
.deserialize( sender.sendMM(
"<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" "<gray>- <white>config test: ${if (Config.config.getBoolean("enabled")) "enabled" else "disabled"}"
) )
sender.sendMessage(help) },
} Route("register") { sender, _ ->
.apply { permission = "simplydb.command" }, if (sender !is Player) {
"activate" to Route { sender, _ -> sender.sendMM("This command is only available for players.")
if (App.instance.enabled == State.ACTIVE return@Route
) { } else
sender.sendMessage( when (App.instance.enabled) {
"simplymcdb is already enabled." State.DISABLED ->
) sender.sendMM(
return@Route "<red>[SMCDB] simplymcdb is disabled.<br>Run /smcdb check to check the status."
} )
App.instance.enable() State.DISCONNECTED ->
sender.sendMessage("simplymcdb enabled.") sender.sendMM(
} "<red>[SMCDB] simplymcdb is enabled but disconnected.<br>Run /smcdb check to check the status."
.apply { permission = "simplydb.command.activate" }, )
"initialize" to Route { sender, _ -> else -> {
sender.sendMessage("database initializing...") if (!isRegistered(sender.uniqueId)) {
Database.initialize() sender.sendMM(
} "<gray>[SMCDB] <red>The inventory of the other servers will be overwritten.<newline>" +
.apply { permission = "simplydb.command.setup" }, "Are you sure you want to register?<newline>" +
"confirm" to Route { sender, _ -> "<green>/smcdb confirm<gray> to confirm."
)
} } else {
.apply { permission = "simplydb.command.confirm" }, sender.sendMM("<gray>[SMCDB] You are already registered.")
) { sender, _ -> sender.sendMessage("simplymcdb command") } }
.apply { name = "simplymcdb" } }
}
},
Route("confirm") { sender, _ ->
if (sender !is Player) return@Route
when (command_buffer[sender.uniqueId]) {
"register" -> {
if (App.instance.enabled == State.ACTIVE) {
register(sender)
sender.sendMM("<gray>[SMCDB] Successfully registered.")
} else {
sender.sendMM("<red>[SMCDB] simplymcdb is disabled.")
}
}
else -> {
sender.sendMM("<red>[SMCDB] Invalid command.")
}
}
command_buffer.remove(sender.uniqueId)
}
// Route("update") { 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)) {
// update(sender)
// sender.sendMM("<gray>[SMCDB] Successfully updated.")
// } else {
// sender.sendMM("<red>[SMCDB] You are not registered.")
// }
// }
// }
// },
// 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."
// )
// }
// }
// }
// },
)

5
src/main/kotlin/net/hareworks/simplymcdb/Config.kt
View File

@ -3,7 +3,6 @@ package net.hareworks.simplymcdb
import org.bukkit.configuration.file.YamlConfiguration import org.bukkit.configuration.file.YamlConfiguration
import org.jetbrains.exposed.sql.Table import org.jetbrains.exposed.sql.Table
object ConfigTable : Table() { object ConfigTable : Table() {
val uuid = varchar("uuid", 36) val uuid = varchar("uuid", 36)
val name = varchar("name", 16) val name = varchar("name", 16)
@ -34,4 +33,8 @@ public object Config {
config.save(App.instance.dataFolder.resolve("config.yml")) config.save(App.instance.dataFolder.resolve("config.yml"))
App.instance.logger.info("config saved.") App.instance.logger.info("config saved.")
} }
public fun check(): Boolean {
return config.getBoolean("enabled")
}
} }

54
src/main/kotlin/net/hareworks/simplymcdb/Event.kt
View File

@ -1,14 +1,11 @@
package net.hareworks.simplymcdb.event package net.hareworks.simplymcdb
import net.hareworks.simplymcdb.App
import net.hareworks.simplymcdb.State
import net.hareworks.simplymcdb.database.Database
import net.kyori.adventure.text.minimessage.MiniMessage import net.kyori.adventure.text.minimessage.MiniMessage
import org.bukkit.event.EventHandler import org.bukkit.event.EventHandler
import org.bukkit.event.Listener import org.bukkit.event.Listener
import org.bukkit.event.player.PlayerJoinEvent import org.bukkit.event.player.PlayerJoinEvent
import org.bukkit.event.player.PlayerQuitEvent
import org.jetbrains.exposed.sql.* import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.transactions.transaction
public object EventListener : Listener { public object EventListener : Listener {
@EventHandler @EventHandler
@ -16,27 +13,50 @@ public object EventListener : Listener {
if (event.player.hasPermission("simplymcdb.admin")) { if (event.player.hasPermission("simplymcdb.admin")) {
when (App.instance.enabled) { when (App.instance.enabled) {
State.DISABLED -> { State.DISABLED -> {
val mm = MiniMessage.miniMessage().deserialize("<red>simplymcdb is disabled.") val mm =
MiniMessage.miniMessage()
.deserialize(
"<red>[SMCDB:admin] simplymcdb is disabled.<br>Run /smcdb check to check the status."
)
event.player.sendMessage(mm) event.player.sendMessage(mm)
} }
State.DISCONNECTED -> { State.DISCONNECTED -> {
val mm = MiniMessage.miniMessage().deserialize("<red>simplymcdb is enabled but disconnected.<br><gray>Check the database connection and try /smcdb on.") val mm =
MiniMessage.miniMessage()
.deserialize(
"<red>[SMCDB:admin] simplymcdb is enabled but disconnected.<br>Run /smcdb check to check the status."
)
event.player.sendMessage(mm) event.player.sendMessage(mm)
} }
else -> { else -> {
val mm = MiniMessage.miniMessage().deserialize("<green>simplymcdb is enabled.") val mm =
MiniMessage.miniMessage()
.deserialize("<green>[SMCDB:admin] simplymcdb is enabled.")
event.player.sendMessage(mm) event.player.sendMessage(mm)
} }
} }
} }
if (App.instance.enabled == State.ACTIVE) {
val player = event.player if (App.instance.enabled !== State.ACTIVE) return
// if player has already registered in the database, load the data if (!event.player.hasPlayedBefore()) return
Database.instance?.let {
transaction(it) { if (isRegistered(event.player.uniqueId)) {
fetch(event.player)
} } else {
} event.player.sendMessage(
MiniMessage.miniMessage()
.deserialize(
"<gray>[SMCDB] Welcome, ${event.player.name}.<newline>" +
"SMCDB is active but you have already played before.<newline>" +
"Run <green>/smcdb register<gray> to register yourself."
)
)
} }
} }
}
@EventHandler
fun onQuit(event: PlayerQuitEvent) {
if (App.instance.enabled !== State.ACTIVE) return
if (isRegistered(event.player.uniqueId)) update(event.player)
}
}

49
src/main/kotlin/net/hareworks/simplymcdb/PlayerData.kt
View File

@ -1,49 +0,0 @@
package net.hareworks.simplymcdb.playerdata
import net.hareworks.simplymcdb.App
import net.hareworks.simplymcdb.database.Database
import org.bukkit.entity.Player as BukkitPlayer
import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.transactions.transaction
public object Player : Table() {
val uuid = varchar("uuid", 36)
val name = varchar("name", 16)
val lastLogin = long("last_login")
val lastLogout = long("last_logout")
val playTime = long("play_time")
val firstLogin = long("first_login")
val lastIp = varchar("last_ip", 15)
val data = text("data").nullable()
override val primaryKey = PrimaryKey(uuid)
}
public fun register(player: BukkitPlayer) {
App.instance.logger.info("Registering player data for ${player.name}")
Database.instance?.let {
transaction {
Player.insert {
it[uuid] = player.uniqueId.toString()
it[name] = player.name
it[lastLogin] = System.currentTimeMillis()
it[firstLogin] = System.currentTimeMillis()
it[lastIp] = player.address?.address?.hostAddress ?: "unknown"
}
}
}
}
public fun push(player: BukkitPlayer) {
App.instance.logger.info("Creating player data for ${player.name}")
Database.instance?.let {
transaction {
Player.update({ Player.uuid eq player.uniqueId.toString() }) {
it[lastLogin] = System.currentTimeMillis()
it[lastIp] = player.address?.address?.hostAddress ?: "unknown"
}
}
}
}

73
src/main/kotlin/net/hareworks/simplymcdb/PlayerSerializer.kt
View File

@ -1,31 +1,68 @@
package net.hareworks.simplymcdb package net.hareworks.simplymcdb
import de.tr7zw.nbtapi.NBT
import java.util.function.Function
import org.bukkit.entity.Player as BukkitPlayer import org.bukkit.entity.Player as BukkitPlayer
import org.bukkit.inventory.ItemStack
class PlayerInventory( data class PlayerData(
val contents: Array<ItemStack>, val health: Float,
val armor: Array<ItemStack>, val hunger: Int,
val exp: Float,
val effects: String,
val inv: String,
val enderchest: String
) )
object PlayerSerializer { object PlayerSerializer {
fun serialize(player: BukkitPlayer): String { fun serialize(player: BukkitPlayer): String {
val inv = player.inventory.storageContents val result =
val armor = player.inventory.armorContents NBT.get(
val enderChest = player.enderChest player,
Function { nbt ->
var output = NBT.createNBTObject()
return "" // base64 encoded string output.setFloat("Health", player.health.toFloat())
output.setInteger("foodLevel", player.foodLevel)
output.setFloat("XpP", player.exp)
output.setInteger("SelectedItemSlot", player.inventory.heldItemSlot)
var active_effects = output.getCompoundList("active_effects")
nbt.getCompoundList("active_effects").forEach {
active_effects.addCompound(it)
}
var inventory = output.getCompoundList("Inventory")
nbt.getCompoundList("Inventory").forEach { inventory.addCompound(it) }
var enderchest = output.getCompoundList("EnderItems")
nbt.getCompoundList("EnderItems").forEach { enderchest.addCompound(it) }
output.toString()
}
)
return result
} }
fun deserialize(data: String): Map<String, Any> { fun deserialize(player: BukkitPlayer, data: String) {
return mapOf() NBT.modify(
player,
Function { nbt ->
val input = NBT.parseNBT(data)
App.instance.logger.info("Deserializing player data: $data")
App.instance.logger.info("deserialized: ${input.toString()}")
nbt.setFloat("Health", input.getFloat("Health"))
nbt.setInteger("foodLevel", input.getInteger("foodLevel"))
nbt.setFloat("XpP", input.getFloat("XpP"))
nbt.setInteger("SelectedItemSlot", input.getInteger("SelectedItemSlot"))
val active_effects = nbt.getCompoundList("active_effects")
active_effects.clear()
input.getCompoundList("active_effects").forEach { active_effects.addCompound(it) }
val inventory = nbt.getCompoundList("Inventory")
inventory.clear()
input.getCompoundList("Inventory").forEach { inventory.addCompound(it) }
val enderchest = nbt.getCompoundList("EnderItems")
enderchest.clear()
input.getCompoundList("EnderItems").forEach { enderchest.addCompound(it) }
}
)
} }
} }
fun ItemStacksToBase64(item: Array<ItemStack>): String {
return ""
}
fun fromBase64(data: String): ByteArray {
return byteArrayOf()
}

70
src/main/kotlin/net/hareworks/simplymcdb/Players.kt Normal file
View File

@ -0,0 +1,70 @@
package net.hareworks.simplymcdb
import java.util.UUID
import net.hareworks.simplymcdb.database.Database
import org.bukkit.entity.Player as BukkitPlayer
import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.transactions.transaction
public object Players : Table() {
val id = integer("id").autoIncrement()
val uuid = varchar("uuid", 36)
val name = varchar("name", 16)
val firstLogin = long("first_login")
val playTime = long("play_time").default(0)
val lastOnline = long("last_online").default(0)
val lastIp = varchar("last_ip", 15)
val data = text("data").default("")
override val primaryKey = PrimaryKey(uuid)
}
public fun isRegistered(player: UUID): Boolean {
return transaction(Database.instance) {
val data =
Players.select(Players.uuid).where { Players.uuid eq player.toString() }.map {
it[Players.uuid]
}
data.isNotEmpty()
}
}
public fun register(player: BukkitPlayer) {
transaction(Database.instance) {
Players.insert {
it[uuid] = player.uniqueId.toString()
it[name] = player.name
it[firstLogin] = System.currentTimeMillis()
it[lastOnline] = System.currentTimeMillis()
it[lastIp] = player.address?.address?.hostAddress ?: "unknown"
}
}
}
public fun update(player: BukkitPlayer) {
val dat = PlayerSerializer.serialize(player)
transaction(Database.instance) {
Players.update({ Players.uuid eq player.uniqueId.toString() }) {
it[lastOnline] = System.currentTimeMillis()
it[lastIp] = player.address?.address?.hostAddress ?: "unknown"
// player.sendMessage(dat)
it[data] = dat
}
}
}
public fun fetch(player: BukkitPlayer) {
val dat =
transaction(Database.instance) {
Players.select(Players.uuid, Players.data)
.where { Players.uuid eq player.uniqueId.toString() }
.withDistinct()
.map { it[Players.data] }
.first()
}
// player.sendMessage(dat)
PlayerSerializer.deserialize(player, dat)
}

28
src/main/kotlin/net/hareworks/simplymcdb/database/Database.kt
View File

@ -1,8 +1,8 @@
package net.hareworks.simplymcdb.database package net.hareworks.simplymcdb.database
import net.hareworks.simplymcdb.App import net.hareworks.simplymcdb.App
import net.hareworks.simplymcdb.config.config import net.hareworks.simplymcdb.Config
import net.hareworks.simplymcdb.playerdata.Player import net.hareworks.simplymcdb.Players
import org.jetbrains.exposed.sql.* import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.Database import org.jetbrains.exposed.sql.Database
import org.jetbrains.exposed.sql.transactions.transaction import org.jetbrains.exposed.sql.transactions.transaction
@ -10,7 +10,9 @@ import org.jetbrains.exposed.sql.transactions.transaction
public object Database { public object Database {
public var instance: Database? = null public var instance: Database? = null
private set private set
public fun connect() { public fun connect() {
var config = Config.config
val type = config.getString("database.type") val type = config.getString("database.type")
val host = config.getString("database.host") val host = config.getString("database.host")
val port = config.getInt("database.port") val port = config.getInt("database.port")
@ -49,11 +51,6 @@ public object Database {
} }
if (instance == null) return if (instance == null) return
App.instance.logger.info("Database connected: $host:$port/$database") App.instance.logger.info("Database connected: $host:$port/$database")
if (!ping()) {
App.instance.logger.warning("Database ping failed")
} else {
App.instance.logger.info("Database ping successful")
}
} }
public fun disconnect() { public fun disconnect() {
instance?.let { instance?.let {
@ -66,20 +63,23 @@ public object Database {
} }
public fun ping(): Boolean { public fun ping(): Boolean {
val flag = (instance == null)
if (flag) connect()
return try { return try {
transaction { transaction(instance) { exec("SELECT 1") }
addLogger(StdOutSqlLogger)
exec("SELECT 1")
}
true true
} catch (e: Exception) { } catch (e: Exception) {
false false
} finally {
if (flag) disconnect()
} }
} }
public fun initialize() { public fun initialize() {
transaction { transaction(instance) { SchemaUtils.create(Players) }
SchemaUtils.create(Player) }
}
public fun reset() {
transaction(instance) { SchemaUtils.drop(Players) }
} }
} }

18
src/main/resources/config.yml
View File

@ -1,18 +1,24 @@
enable: false
database: database:
type: postgresql type: postgresql # Supported: mysql, postgresql
host: localhost host: localhost
port: 5432 port: 5432
# You must have created a database and user.
database: smcdb database: smcdb
user: smcdb user: smcdb
password: SaN1m_wk2eh9 password: password
playerdata:
playerdata: # README for more details.
health: true health: true
hunger: true hunger: true
experience: true experience: true
status: true effects: true
inventory: true inventory: true
enderchest: true enderchest: true
# achievements: true # achievements: true
# recipebook: true # recipebook: true
gamemode: true gamemode: true
# Do not change this value manually,
# If the plugin settings are OK, enable it with the command.
enabled: false