zephyr.storm.pk

Develop a Schematic Paster plugin that allows players to easily paste and manipulate schematics with an intuitive command interface. Include features such as multi-block pasting, support for WorldEdit schematics, configurable permissions, and a preview mode to visualize the schematic before placement. Optimize loading times and ensure compatibility with different server setups for improved performance.

Kodari AI
KodariAug 10 at 6:07 pm 2
SchematicPaster
A Minecraft plugin enabling players to paste WorldEdit schematics with an intuitive command interface. Features multi-block pasting, configurable permissions, and a preview mode to visualize schematics before placement. Supports loading .schematic files from disk, rotation and flipping options, async pasting for optimized performance, and compatibility across different server versions. Includes commands for listing available schematics, previewing with ghost blocks, and pasting at player location or specified coordinates. Permission nodes control access to each feature, with configurable messages and cooldowns. Designed for efficient memory usage and fast loading times.
  1. Create a Maven/Kotlin Paper plugin with WorldEdit integration and runtime configuration.

  2. Add asynchronous schematic loading, safe file resolution, multi-block pasting, rotation, and preview visualization.

  3. Add the /schematic command interface, permissions, lifecycle handling, and default config.

Created the Schematic Paster plugin with:

  • Maven/Kotlin setup targeting Paper 1.20.6 and WorldEdit 7.3.0

  • /schematic commands for listing, pasting, previewing, rotating, confirming, cancelling, and reloading

  • Asynchronous schematic loading

  • .schem, .schematic, and .schematic.gz support

  • Configurable permissions and block limits

  • Air-block handling

  • Particle-based preview rendering

  • Safe schematic path resolution

  • Default config.yml, plugin.yml, and manifest.kod

Kodari can make mistakes. Review important code before using.
Files
src
manifest.kod
pom.xml
Code
9 617
src/main/kotlin/com/kodari/schematicpaster/command/SchematicCommand.kt
package com.kodari.schematicpaster.command

import com.kodari.schematicpaster.SchematicPasterPlugin
import com.kodari.schematicpaster.preview.PreviewManager
import com.kodari.schematicpaster.preview.PreviewState
import com.kodari.schematicpaster.schematic.InvalidSchematicException
import com.kodari.schematicpaster.schematic.PasteOrigin
import com.kodari.schematicpaster.schematic.SchematicManager
import com.kodari.schematicpaster.schematic.SchematicNotFoundException
import com.kodari.schematicpaster.schematic.SchematicPaster
import org.bukkit.Bukkit
import org.bukkit.ChatColor
import org.bukkit.command.Command
import org.bukkit.command.CommandExecutor
import org.bukkit.command.CommandSender
import org.bukkit.command.TabCompleter
import org.bukkit.entity.Player

class SchematicCommand(
    private val plugin: SchematicPasterPlugin,
    private val schematics: SchematicManager,
    private val previews: PreviewManager,
    private val paster: SchematicPaster
) : CommandExecutor, TabCompleter {
    override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array<out String>): Boolean {
        if (!has(sender, "use")) return reply(sender, "no-permission")
        if (args.isEmpty()) return reply(sender, "usage")

        return when (args[0].lowercase()) {
            "list" -> list(sender)
            "paste" -> paste(sender, args.drop(1))
            "preview" -> preview(sender, args.drop(1))
            "confirm" -> confirm(sender)
            "cancel" -> cancel(sender)
            "rotate" -> rotate(sender, args.drop(1))
            "reload" -> reload(sender)
            else -> reply(sender, "usage")
        }
    }

    private fun list(sender: CommandSender): Boolean {
        val names = schematics.list()
        if (names.isEmpty()) return reply(sender, "list-empty")
        message(sender, "list-header")
        sender.sendMessage(names.joinToString("§7, §f".prependIndent("§f")))
        return true
    }

    private fun paste(sender: CommandSender, arguments: List<String>): Boolean {
        if (!has(sender, "paste")) return reply(sender, "no-permission")
        val player = player(sender) ?: return true
        val name = arguments.firstOrNull { !it.startsWith("--") } ?: return reply(sender, "usage")
        val preview = arguments.any { it.equals("--preview", true) }
        val ignoreAir = if (arguments.any { it.equals("--air", true) }) false
        else plugin.config.getBoolean("paste.ignore-air-by-default", true)
        if (preview) return previewLoaded(player, name, ignoreAir)
        loadAndPaste(player, name, ignoreAir)
        return true
    }

    private fun preview(sender: CommandSender, arguments: List<String>): Boolean {
        if (!has(sender, "preview")) return reply(sender, "no-permission")
        val player = player(sender) ?: return true
        if (!plugin.config.getBoolean("preview.enabled", true)) return reply(sender, "preview-disabled")
        val name = arguments.firstOrNull() ?: return reply(sender, "usage")
        return previewLoaded(player, name, plugin.config.getBoolean("paste.ignore-air-by-default", true))
    }

    private fun previewLoaded(player: Player, name: String, ignoreAir: Boolean): Boolean {
        if (!plugin.config.getBoolean("preview.enabled", true)) {
            reply(player, "preview-disabled")
            return true
        }
        loadAsync(player, name) { schematic ->
            val state = PreviewState(schematic, paster.origin(player.location), 0, ignoreAir)
            previews.show(player, state)
            message(player, "preview-started", "name" to schematic.name)
        }
        return true
    }

    private fun loadAndPaste(player: Player, name: String, ignoreAir: Boolean) {
        message(player, "loading", "name" to name)
        loadAsync(player, name) { schematic ->
            try {
                paster.paste(schematic, paster.origin(player.location), 0, ignoreAir)
                message(player, "pasted", "name" to schematic.name)
            } catch (exception: Exception) {
                operationError(player, exception)
            }
        }
    }

    private fun confirm(sender: CommandSender): Boolean {
        if (!has(sender, "paste")) return reply(sender, "no-permission")
        val player = player(sender) ?: return true
        val state = previews.take(player) ?: return reply(sender, "no-preview")
        try {
            paster.paste(state.schematic, state.origin, state.rotation, state.ignoreAir)
            message(player, "pasted", "name" to state.schematic.name)
        } catch (exception: Exception) {
            operationError(player, exception)
        }
        return true
    }

    private fun cancel(sender: CommandSender): Boolean {
        val player = player(sender) ?: return true
        if (previews.get(player) == null) return reply(sender, "no-preview")
        previews.clear(player)
        return reply(sender, "preview-cancelled")
    }

    private fun rotate(sender: CommandSender, arguments: List<String>): Boolean {
        if (!has(sender, "preview")) return reply(sender, "no-permission")
        val player = player(sender) ?: return true
        val state = previews.get(player) ?: return reply(sender, "no-preview")
        val rotation = arguments.firstOrNull()?.toIntOrNull() ?: return reply(sender, "usage")
        if (rotation !in setOf(0, 90, 180, 270)) return reply(sender, "usage")
        state.rotation = rotation
        previews.refresh(player)
        return message(player, "rotation", "rotation" to rotation)
    }

    private fun reload(sender: CommandSender): Boolean {
        if (!has(sender, "admin")) return reply(sender, "no-permission")
        plugin.reloadConfig()
        schematics.reload()
        return reply(sender, "reload")
    }

    private fun loadAsync(player: Player, name: String, success: (com.kodari.schematicpaster.schematic.LoadedSchematic) -> Unit) {
        message(player, "loading", "name" to name)
        schematics.loadAsync(name).whenComplete { schematic, throwable ->
            Bukkit.getScheduler().runTask(plugin, Runnable {
                if (!player.isOnline) return@Runnable
                if (throwable != null) {
                    val cause = throwable.cause ?: throwable
                    when (cause) {
                        is SchematicNotFoundException -> message(player, "not-found", "name" to cause.schematicName)
                        is InvalidSchematicException -> reply(player, "invalid-file")
                        else -> operationError(player, cause)
                    }
                } else {
                    val max = plugin.config.getLong("paste.max-blocks", 500_000L)
                    if (schematic.blocks > max) message(player, "too-large", "blocks" to schematic.blocks, "max" to max)
                    else success(schematic)
                }
            })
        }
    }

    private fun player(sender: CommandSender): Player? {
        if (sender !is Player) {
            reply(sender, "players-only")
            return null
        }
        return sender
    }

    private fun has(sender: CommandSender, key: String): Boolean =
        sender.hasPermission(plugin.config.getString("permissions.$key", "schematicpaster.$key")!!)

    private fun operationError(player: Player, exception: Throwable) {
        val message = exception.message ?: exception.javaClass.simpleName
        message(player, "failed", "error" to message.take(120))
    }

    private fun reply(sender: CommandSender, key: String): Boolean {
        message(sender, key)
        return true
    }

    private fun message(sender: CommandSender, key: String, vararg replacements: Pair<String, Any>): Boolean {
        var text = plugin.config.getString("messages.$key", "") ?: ""
        replacements.forEach { (name, value) -> text = text.replace("{$name}", value.toString()) }
        val prefix = plugin.config.getString("messages.prefix", "") ?: ""
        sender.sendMessage(ChatColor.translateAlternateColorCodes('&', prefix + text))
        return true
    }

    override fun onTabComplete(sender: CommandSender, command: Command, alias: String, args: Array<out String>): List<String> {
        if (args.size == 1) return listOf("list", "paste", "preview", "confirm", "cancel", "rotate", "reload")
            .filter { it.startsWith(args[0], true) }
        if (args.size == 2 && (args[0].equals("paste", true) || args[0].equals("preview", true))) {
            return schematics.list().filter { it.startsWith(args[1], true) }
        }
        if (args.size == 2 && args[0].equals("rotate", true)) return listOf("0", "90", "180", "270")
        return emptyList()
    }
}