Develop

src/main/kotlin/net/integr/backbone/Backbone.kt

@@ -13,7 +13,11 @@
 
 package net.integr.backbone
 
+import net.integr.backbone.systems.command.CommandHandler
+import net.integr.backbone.systems.entity.EntityHandler
 import net.integr.backbone.systems.event.EventBus
+import net.integr.backbone.systems.gui.GuiHandler
+import net.integr.backbone.systems.item.ItemHandler
 import net.integr.backbone.systems.permission.PermissionNode
 import net.integr.backbone.systems.placeholder.PlaceholderGroup
 import net.integr.backbone.systems.storage.ResourcePool
@@ -77,5 +81,19 @@ object Backbone {
     fun getKey(namespace: String, key: String): NamespacedKey {
         return NamespacedKey(namespace, key)
     }
+
+    object Handler {
+        val COMMAND
+            get() = CommandHandler
+
+        val ITEM
+            get() = ItemHandler
+
+        val ENTITY
+            get() = EntityHandler
+
+        val GUI
+            get() = GuiHandler
+    }
 }
 

src/main/kotlin/net/integr/backbone/BackboneLogger.kt

@@ -14,14 +14,25 @@
 package net.integr.backbone
 
 import org.bukkit.plugin.java.JavaPlugin
+import java.nio.file.Path
 import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.logging.*
+import kotlin.io.path.appendText
+import kotlin.io.path.createDirectories
+import kotlin.io.path.createFile
 
 class BackboneLogger(name: String, private val plugin: JavaPlugin?) : Logger(name, null) {
-    private val dateFormat = SimpleDateFormat("HH:mm:ss")
+    private val logFile = Path.of("./logs/backbone.log")
+    private val customFormat = CustomFormat(name, true)
+    private val customFileFormat = CustomFormat(name, false)
 
     init {
+        logFile.parent.createDirectories()
+        if (!logFile.toFile().exists()) {
+            logFile.createFile()
+        }
+
         useParentHandlers = false
         level = Level.ALL
 
@@ -35,86 +46,91 @@ class BackboneLogger(name: String, private val plugin: JavaPlugin?) : Logger(nam
     private inner class CustomHandler : Handler() {
         override fun publish(record: LogRecord) {
             if (!isLoggable(record) || plugin == null) return
-            val message = format(record)
+            val message = customFormat.format(record)
+            val fileMessage = customFileFormat.format(record)
             println(message)
+            if (record.level == Level.SEVERE) logFile.appendText(fileMessage + "\n")
         }
 
         override fun flush() {}
         override fun close() {}
     }
 
-    fun format(record: LogRecord): String {
-        val builder = StringBuilder()
-
-        builder.append(dateFormat.format(Date(record.millis)))
-        builder.append(" ")
-
-        when (record.level) {
-            Level.SEVERE -> {
-                builder.append(ANSI_BACKGROUND_RED)
-                builder.append(ANSI_BLACK)
-                builder.append("ERRO")
-                builder.append(ANSI_RESET)
-                builder.append(ANSI_RED)
-            }
-            Level.WARNING -> {
-                builder.append(ANSI_BACKGROUND_YELLOW)
-                builder.append(ANSI_BLACK)
-                builder.append("WARN")
-                builder.append(ANSI_RESET)
-                builder.append(ANSI_YELLOW)
-            }
-            Level.INFO -> {
-                builder.append(ANSI_BACKGROUND_CYAN)
-                builder.append(ANSI_BLACK)
-                builder.append("INFO")
-                builder.append(ANSI_RESET)
-                builder.append(ANSI_CYAN)
+    class CustomFormat(val name: String, val color: Boolean) : Formatter() {
+        private val dateFormat = SimpleDateFormat("HH:mm:ss")
+
+        override fun format(record: LogRecord): String {
+            val builder = StringBuilder()
+
+            builder.append(dateFormat.format(Date(record.millis)))
+            builder.append(" ")
+
+            when (record.level) {
+                Level.SEVERE -> {
+                    if (color) builder.append(ANSI_BACKGROUND_RED)
+                    if (color) builder.append(ANSI_BLACK)
+                    builder.append("ERRO")
+                    if (color) builder.append(ANSI_RESET)
+                    if (color) builder.append(ANSI_RED)
+                }
+                Level.WARNING -> {
+                    if (color) builder.append(ANSI_BACKGROUND_YELLOW)
+                    if (color) builder.append(ANSI_BLACK)
+                    builder.append("WARN")
+                    if (color) builder.append(ANSI_RESET)
+                    if (color) builder.append(ANSI_YELLOW)
+                }
+                Level.INFO -> {
+                    if (color) builder.append(ANSI_BACKGROUND_CYAN)
+                    if (color) builder.append(ANSI_BLACK)
+                    builder.append("INFO")
+                    if (color) builder.append(ANSI_RESET)
+                    if (color) builder.append(ANSI_CYAN)
+                }
             }
-        }
 
-        builder.append(" [")
-        builder.append(name)
-        builder.append("]")
+            builder.append(" [")
+            builder.append(name)
+            builder.append("]")
 
-        builder.append(ANSI_BLACK)
-        builder.append(" - ")
-        builder.append(ANSI_WHITE)
-        builder.append(record.message)
+            if (color) builder.append(ANSI_BLACK)
+            builder.append(" - ")
+            if (color) builder.append(ANSI_WHITE)
+            builder.append(record.message)
 
-        val params = record.parameters
+            val params = record.parameters
 
-        if (params != null) {
-            builder.append("\t")
-            for (i in params.indices) {
-                builder.append(params[i])
-                if (i < params.size - 1) builder.append(", ")
+            if (params != null) {
+                builder.append("\t")
+                for (i in params.indices) {
+                    builder.append(params[i])
+                    if (i < params.size - 1) builder.append(", ")
+                }
             }
-        }
-
-        builder.append(ANSI_RESET)
-        return builder.toString()
-    }
 
+            if (color) builder.append(ANSI_RESET)
+            return builder.toString()
+        }
 
-    companion object {
-        const val ANSI_RESET: String = "\u001B[0m"
-        const val ANSI_BLACK: String = "\u001B[30m"
-        const val ANSI_RED: String = "\u001B[31m"
-        const val ANSI_GREEN: String = "\u001B[32m"
-        const val ANSI_YELLOW: String = "\u001B[33m"
-        const val ANSI_BLUE: String = "\u001B[34m"
-        const val ANSI_PURPLE: String = "\u001B[35m"
-        const val ANSI_CYAN: String = "\u001B[36m"
-        const val ANSI_WHITE: String = "\u001B[37m"
-
-        const val ANSI_BACKGROUND_BLACK: String = "\u001B[40m"
-        const val ANSI_BACKGROUND_RED: String = "\u001B[41m"
-        const val ANSI_BACKGROUND_GREEN: String = "\u001B[42m"
-        const val ANSI_BACKGROUND_YELLOW: String = "\u001B[43m"
-        const val ANSI_BACKGROUND_BLUE: String = "\u001B[44m"
-        const val ANSI_BACKGROUND_PURPLE: String = "\u001B[45m"
-        const val ANSI_BACKGROUND_CYAN: String = "\u001B[46m"
-        const val ANSI_BACKGROUND_WHITE: String = "\u001B[47m"
+        companion object {
+            const val ANSI_RESET: String = "\u001B[0m"
+            const val ANSI_BLACK: String = "\u001B[30m"
+            const val ANSI_RED: String = "\u001B[31m"
+            const val ANSI_GREEN: String = "\u001B[32m"
+            const val ANSI_YELLOW: String = "\u001B[33m"
+            const val ANSI_BLUE: String = "\u001B[34m"
+            const val ANSI_PURPLE: String = "\u001B[35m"
+            const val ANSI_CYAN: String = "\u001B[36m"
+            const val ANSI_WHITE: String = "\u001B[37m"
+
+            const val ANSI_BACKGROUND_BLACK: String = "\u001B[40m"
+            const val ANSI_BACKGROUND_RED: String = "\u001B[41m"
+            const val ANSI_BACKGROUND_GREEN: String = "\u001B[42m"
+            const val ANSI_BACKGROUND_YELLOW: String = "\u001B[43m"
+            const val ANSI_BACKGROUND_BLUE: String = "\u001B[44m"
+            const val ANSI_BACKGROUND_PURPLE: String = "\u001B[45m"
+            const val ANSI_BACKGROUND_CYAN: String = "\u001B[46m"
+            const val ANSI_BACKGROUND_WHITE: String = "\u001B[47m"
+        }
     }
 }

src/main/kotlin/net/integr/backbone/BackboneServer.kt

@@ -15,8 +15,9 @@ package net.integr.backbone
 
 import kotlinx.coroutines.runBlocking
 import net.integr.backbone.commands.BackboneCommand
+import net.integr.backbone.entities.TestEntity
 import net.integr.backbone.events.TickEvent
-import net.integr.backbone.systems.command.CommandHandler
+import net.integr.backbone.systems.entity.EntityHandler
 import net.integr.backbone.systems.event.EventBus
 import net.integr.backbone.systems.gui.GuiHandler
 import net.integr.backbone.systems.hotloader.ScriptEngine
@@ -32,6 +33,7 @@ class BackboneServer : JavaPlugin() {
         val fdOut = FileOutputStream(FileDescriptor.out)
         val originalOut = PrintStream(fdOut, true)
 
+        // Bypass papers println intercept
         System.setOut(originalOut)
         System.setErr(PrintStream(FileOutputStream(FileDescriptor.err), true))
 
@@ -45,8 +47,10 @@ class BackboneServer : JavaPlugin() {
 
         Backbone.registerListener(GuiHandler)
         Backbone.registerListener(ItemHandler)
+        Backbone.registerListener(EntityHandler)
 
-        CommandHandler.register(BackboneCommand)
+        Backbone.Handler.COMMAND.register(BackboneCommand)
+        Backbone.Handler.ENTITY.register(TestEntity)
 
         Backbone.SERVER.scheduler.runTaskTimer(Backbone.PLUGIN, Runnable {
             EventBus.post(TickEvent)

src/main/kotlin/net/integr/backbone/Utils.kt

@@ -21,4 +21,12 @@ object Utils {
             null
         }
     }
+
+    fun isSnakeCase(string: String): Boolean {
+        return string.matches("^[a-z0-9]+(_[a-z0-9]+)*$".toRegex())
+    }
+
+    fun isUid(string: String): Boolean {
+        return string.matches("^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$".toRegex())
+    }
 }

src/main/kotlin/net/integr/backbone/commands/BackboneCommand.kt

@@ -14,11 +14,13 @@
 package net.integr.backbone.commands
 
 import net.integr.backbone.Backbone
+import net.integr.backbone.commands.arguments.customEntityArgument
 import net.integr.backbone.commands.arguments.customItemArgument
 import net.integr.backbone.commands.arguments.scriptArgument
 import net.integr.backbone.commands.arguments.stringArgument
 import net.integr.backbone.systems.command.Command
 import net.integr.backbone.systems.command.Execution
+import net.integr.backbone.systems.entity.EntityHandler
 import net.integr.backbone.systems.hotloader.ScriptEngine
 import net.integr.backbone.systems.hotloader.ScriptLinker
 import net.integr.backbone.systems.hotloader.ScriptStore
@@ -29,16 +31,18 @@ import net.kyori.adventure.text.event.HoverEvent
 import java.awt.Color
 
 object BackboneCommand : Command("backbone", "Base command for Backbone", listOf("bb")) {
+    val perm = Backbone.ROOT_PERMISSION.derive("command")
+
     override fun onBuild() {
-        subCommands(Scripting, Item)
+        subCommands(Scripting, Item, Entity)
     }
 
     override suspend fun exec(ctx: Execution) {
         ctx.respond("Backbone v${Backbone.VERSION}")
     }
 
     object Scripting : Command("scripting", "Commands for Backbone scripting system") {
-        val scriptingPerm = Backbone.ROOT_PERMISSION.derive("scripting")
+        val scriptingPerm = perm.derive("scripting")
 
         override fun onBuild() {
             subCommands(Reload, Enable, Disable, Wipe)
@@ -170,7 +174,7 @@ object BackboneCommand : Command("backbone", "Base command for Backbone", listOf
     }
 
     object Item : Command("item", "Commands for Backbone item system") {
-        val itemPerm = Backbone.ROOT_PERMISSION.derive("item")
+        val itemPerm = perm.derive("item")
 
         override fun onBuild() {
             subCommands(Give, Replicate, Read)
@@ -206,12 +210,14 @@ object BackboneCommand : Command("backbone", "Base command for Backbone", listOf
 
                 ctx.respond("Generating item...")
 
-                try {
-                    val stack = ItemHandler.generate(item)
-                    ctx.getPlayer().inventory.addItem(stack)
-                    ctx.respond("Item generated.")
-                } catch (e: Exception) {
-                    ctx.fail(e.message ?: "An error occurred while generating the item.")
+                Backbone.dispatchMain {
+                    try {
+                        val stack = ItemHandler.generate(item)
+                        ctx.getPlayer().inventory.addItem(stack)
+                        ctx.respond("Item generated.")
+                    } catch (e: Exception) {
+                        ctx.fail(e.message ?: "An error occurred while generating the item.")
+                    }
                 }
             }
         }
@@ -267,4 +273,61 @@ object BackboneCommand : Command("backbone", "Base command for Backbone", listOf
             }
         }
     }
+
+    object Entity : Command("entity", "Commands for Backbone entity system") {
+        val entityPerm = perm.derive("entity")
+
+        override fun onBuild() {
+            subCommands(Spawn)
+        }
+
+        override suspend fun exec(ctx: Execution) {
+            ctx.requirePermission(entityPerm)
+
+            ctx.respond("Entities [${EntityHandler.entities.size}]:")
+            for (entity in EntityHandler.entities) {
+                ctx.respondComponent(component {
+                    append("  - ${entity.key}: ") {
+                        color(Color(169, 173, 168))
+                    }
+
+                    append(entity.value.type.name.lowercase()) {
+                        color(
+                            Color(141, 184, 130)
+                        )
+                    }
+                })
+            }
+        }
+
+        object Spawn : Command("spawn", "Spawns a custom entity") {
+            val entitySpawnPerm = entityPerm.derive("spawn")
+
+            override fun onBuild() {
+                arguments(
+                    customEntityArgument("entity", "The custom entity to spawn")
+                )
+            }
+
+            override suspend fun exec(ctx: Execution) {
+                ctx.requirePermission(entitySpawnPerm)
+                ctx.requirePlayer()
+
+                val entity = ctx.get<String>("entity")
+
+                ctx.respond("Spawning entity...")
+
+                val player = ctx.getPlayer()
+
+                Backbone.dispatchMain {
+                    try {
+                        EntityHandler.spawn(entity, player.location, player.world)
+                        ctx.respond("Entity spawned.")
+                    } catch (e: Exception) {
+                        ctx.fail(e.message ?: "An error occurred while spawning the entity.")
+                    }
+                }
+            }
+        }
+    }
 }