package com.adminai.managers import com.adminai.AdminAIToolkit import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.Player import org.bukkit.scheduler.BukkitRunnable import kotlin.math.* import kotlin.random.Random class BuildManager(private val plugin: AdminAIToolkit) { fun buildFromDescription(player: Player, description: String) { val location = player.location.clone() player.sendMessage(plugin.getPrefix() + "§aAnalyzing your request: §e$description") player.sendMessage(plugin.getPrefix() + "§7Building in progress...") val speed = plugin.config.getInt("ai-building.animation-speed", 5).toLong() val interpreter = AIBuildInterpreter(description) interpreter.build(location, plugin, speed) { player.sendMessage(plugin.getPrefix() + plugin.msg("building-complete")) } } } class AIBuildInterpreter(private val description: String) { private val words = description.lowercase().split(" ") private val materials = extractMaterials() private val structureType = extractStructureType() private val size = extractSize() private val height = extractHeight() private val style = extractStyle() private val features = extractFeatures() private val pattern = extractPattern() private val shape = extractShape() fun build(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { when (structureType) { StructureType.HOUSE -> buildHouse(location, plugin, speed, onComplete) StructureType.TOWER -> buildTower(location, plugin, speed, onComplete) StructureType.WALL -> buildWall(location, plugin, speed, onComplete) StructureType.BRIDGE -> buildBridge(location, plugin, speed, onComplete) StructureType.CASTLE -> buildCastle(location, plugin, speed, onComplete) StructureType.PYRAMID -> buildPyramid(location, plugin, speed, onComplete) StructureType.SPHERE -> buildSphere(location, plugin, speed, onComplete) StructureType.DOME -> buildDome(location, plugin, speed, onComplete) StructureType.STATUE -> buildStatue(location, plugin, speed, onComplete) StructureType.TREE -> buildTree(location, plugin, speed, onComplete) StructureType.FOUNTAIN -> buildFountain(location, plugin, speed, onComplete) StructureType.ROAD -> buildRoad(location, plugin, speed, onComplete) StructureType.PLATFORM -> buildPlatform(location, plugin, speed, onComplete) StructureType.CIRCLE -> buildCircle(location, plugin, speed, onComplete) StructureType.SPIRAL -> buildSpiral(location, plugin, speed, onComplete) StructureType.CUBE -> buildCube(location, plugin, speed, onComplete) StructureType.TUNNEL -> buildTunnel(location, plugin, speed, onComplete) StructureType.ARENA -> buildArena(location, plugin, speed, onComplete) StructureType.TEMPLE -> buildTemple(location, plugin, speed, onComplete) StructureType.FARM -> buildFarm(location, plugin, speed, onComplete) StructureType.MAZE -> buildMaze(location, plugin, speed, onComplete) StructureType.PARKOUR -> buildParkour(location, plugin, speed, onComplete) StructureType.GARDEN -> buildGarden(location, plugin, speed, onComplete) StructureType.LAKE -> buildLake(location, plugin, speed, onComplete) StructureType.MOUNTAIN -> buildMountain(location, plugin, speed, onComplete) StructureType.CAVE -> buildCave(location, plugin, speed, onComplete) StructureType.SHIP -> buildShip(location, plugin, speed, onComplete) StructureType.LIGHTHOUSE -> buildLighthouse(location, plugin, speed, onComplete) StructureType.WINDMILL -> buildWindmill(location, plugin, speed, onComplete) StructureType.WELL -> buildWell(location, plugin, speed, onComplete) StructureType.ARCH -> buildArch(location, plugin, speed, onComplete) StructureType.OBELISK -> buildObelisk(location, plugin, speed, onComplete) StructureType.PORTAL -> buildPortal(location, plugin, speed, onComplete) StructureType.THRONE -> buildThrone(location, plugin, speed, onComplete) StructureType.ALTAR -> buildAltar(location, plugin, speed, onComplete) StructureType.TENT -> buildTent(location, plugin, speed, onComplete) StructureType.BARN -> buildBarn(location, plugin, speed, onComplete) StructureType.GREENHOUSE -> buildGreenhouse(location, plugin, speed, onComplete) StructureType.DOCK -> buildDock(location, plugin, speed, onComplete) StructureType.WATCHTOWER -> buildWatchtower(location, plugin, speed, onComplete) StructureType.RUINS -> buildRuins(location, plugin, speed, onComplete) else -> buildGeneric(location, plugin, speed, onComplete) } } private fun extractMaterials(): List { val found = mutableListOf() val materialMap = mapOf( "stone" to Material.STONE, "smooth stone" to Material.SMOOTH_STONE, "cobblestone" to Material.COBBLESTONE, "mossy cobblestone" to Material.MOSSY_COBBLESTONE, "stone brick" to Material.STONE_BRICKS, "mossy stone brick" to Material.MOSSY_STONE_BRICKS, "cracked stone brick" to Material.CRACKED_STONE_BRICKS, "chiseled stone brick" to Material.CHISELED_STONE_BRICKS, "brick" to Material.BRICKS, "wood" to Material.OAK_PLANKS, "oak" to Material.OAK_PLANKS, "spruce" to Material.SPRUCE_PLANKS, "birch" to Material.BIRCH_PLANKS, "jungle" to Material.JUNGLE_PLANKS, "acacia" to Material.ACACIA_PLANKS, "dark oak" to Material.DARK_OAK_PLANKS, "mangrove" to Material.MANGROVE_PLANKS, "cherry" to Material.CHERRY_PLANKS, "bamboo" to Material.BAMBOO_PLANKS, "crimson" to Material.CRIMSON_PLANKS, "warped" to Material.WARPED_PLANKS, "glass" to Material.GLASS, "white glass" to Material.WHITE_STAINED_GLASS, "black glass" to Material.BLACK_STAINED_GLASS, "red glass" to Material.RED_STAINED_GLASS, "blue glass" to Material.BLUE_STAINED_GLASS, "green glass" to Material.GREEN_STAINED_GLASS, "yellow glass" to Material.YELLOW_GLASS, "purple glass" to Material.PURPLE_STAINED_GLASS, "iron" to Material.IRON_BLOCK, "gold" to Material.GOLD_BLOCK, "diamond" to Material.DIAMOND_BLOCK, "emerald" to Material.EMERALD_BLOCK, "netherite" to Material.NETHERITE_BLOCK, "quartz" to Material.QUARTZ_BLOCK, "smooth quartz" to Material.SMOOTH_QUARTZ, "chiseled quartz" to Material.CHISELED_QUARTZ_BLOCK, "quartz pillar" to Material.QUARTZ_PILLAR, "sandstone" to Material.SANDSTONE, "smooth sandstone" to Material.SMOOTH_SANDSTONE, "chiseled sandstone" to Material.CHISELED_SANDSTONE, "cut sandstone" to Material.CUT_SANDSTONE, "red sandstone" to Material.RED_SANDSTONE, "concrete" to Material.WHITE_CONCRETE, "white concrete" to Material.WHITE_CONCRETE, "black concrete" to Material.BLACK_CONCRETE, "red concrete" to Material.RED_CONCRETE, "blue concrete" to Material.BLUE_CONCRETE, "green concrete" to Material.GREEN_CONCRETE, "yellow concrete" to Material.YELLOW_CONCRETE, "purple concrete" to Material.PURPLE_CONCRETE, "pink concrete" to Material.PINK_CONCRETE, "orange concrete" to Material.ORANGE_CONCRETE, "cyan concrete" to Material.CYAN_CONCRETE, "lime concrete" to Material.LIME_CONCRETE, "gray concrete" to Material.GRAY_CONCRETE, "light gray concrete" to Material.LIGHT_GRAY_CONCRETE, "brown concrete" to Material.BROWN_CONCRETE, "magenta concrete" to Material.MAGENTA_CONCRETE, "light blue concrete" to Material.LIGHT_BLUE_CONCRETE, "wool" to Material.WHITE_WOOL, "white wool" to Material.WHITE_WOOL, "black wool" to Material.BLACK_WOOL, "red wool" to Material.RED_WOOL, "blue wool" to Material.BLUE_WOOL, "terracotta" to Material.TERRACOTTA, "white terracotta" to Material.WHITE_TERRACOTTA, "black terracotta" to Material.BLACK_TERRACOTTA, "red terracotta" to Material.RED_TERRACOTTA, "obsidian" to Material.OBSIDIAN, "crying obsidian" to Material.CRYING_OBSIDIAN, "prismarine" to Material.PRISMARINE, "dark prismarine" to Material.DARK_PRISMARINE, "prismarine brick" to Material.PRISMARINE_BRICKS, "purpur" to Material.PURPUR_BLOCK, "purpur pillar" to Material.PURPUR_PILLAR, "ice" to Material.ICE, "packed ice" to Material.PACKED_ICE, "blue ice" to Material.BLUE_ICE, "snow" to Material.SNOW_BLOCK, "clay" to Material.CLAY, "andesite" to Material.ANDESITE, "polished andesite" to Material.POLISHED_ANDESITE, "diorite" to Material.DIORITE, "polished diorite" to Material.POLISHED_DIORITE, "granite" to Material.GRANITE, "polished granite" to Material.POLISHED_GRANITE, "blackstone" to Material.BLACKSTONE, "polished blackstone" to Material.POLISHED_BLACKSTONE, "gilded blackstone" to Material.GILDED_BLACKSTONE, "basalt" to Material.BASALT, "smooth basalt" to Material.SMOOTH_BASALT, "polished basalt" to Material.POLISHED_BASALT, "copper" to Material.COPPER_BLOCK, "exposed copper" to Material.EXPOSED_COPPER, "weathered copper" to Material.WEATHERED_COPPER, "oxidized copper" to Material.OXIDIZED_COPPER, "cut copper" to Material.CUT_COPPER, "amethyst" to Material.AMETHYST_BLOCK, "calcite" to Material.CALCITE, "tuff" to Material.TUFF, "dripstone" to Material.DRIPSTONE_BLOCK, "deepslate" to Material.DEEPSLATE, "cobbled deepslate" to Material.COBBLED_DEEPSLATE, "polished deepslate" to Material.POLISHED_DEEPSLATE, "deepslate brick" to Material.DEEPSLATE_BRICKS, "deepslate tile" to Material.DEEPSLATE_TILES, "mud" to Material.MUD, "packed mud" to Material.PACKED_MUD, "mud brick" to Material.MUD_BRICKS, "nether brick" to Material.NETHER_BRICKS, "red nether brick" to Material.RED_NETHER_BRICKS, "chiseled nether brick" to Material.CHISELED_NETHER_BRICKS, "cracked nether brick" to Material.CRACKED_NETHER_BRICKS, "end stone" to Material.END_STONE, "end stone brick" to Material.END_STONE_BRICKS, "glowstone" to Material.GLOWSTONE, "sea lantern" to Material.SEA_LANTERN, "redstone lamp" to Material.REDSTONE_LAMP, "bone" to Material.BONE_BLOCK, "hay" to Material.HAY_BLOCK, "dried kelp" to Material.DRIED_KELP_BLOCK, "sponge" to Material.SPONGE, "slime" to Material.SLIME_BLOCK, "honey" to Material.HONEY_BLOCK, "melon" to Material.MELON, "pumpkin" to Material.PUMPKIN, "carved pumpkin" to Material.CARVED_PUMPKIN, "jack o lantern" to Material.JACK_O_LANTERN, "mushroom" to Material.RED_MUSHROOM_BLOCK, "red mushroom" to Material.RED_MUSHROOM_BLOCK, "brown mushroom" to Material.BROWN_MUSHROOM_BLOCK ) for ((keyword, material) in materialMap) { if (description.lowercase().contains(keyword)) { found.add(material) } } if (found.isEmpty()) { found.add(Material.STONE_BRICKS) } return found } private fun extractStructureType(): StructureType { return when { words.any { it in listOf("house", "home", "hut", "cabin", "cottage") } -> StructureType.HOUSE words.any { it in listOf("tower", "spire", "pillar", "column") } -> StructureType.TOWER words.any { it in listOf("wall", "fence", "barrier", "rampart") } -> StructureType.WALL words.any { it in listOf("bridge", "walkway", "overpass") } -> StructureType.BRIDGE words.any { it in listOf("castle", "fortress", "fort", "citadel") } -> StructureType.CASTLE words.any { it in listOf("pyramid", "triangle") } -> StructureType.PYRAMID words.any { it in listOf("sphere", "ball", "orb", "globe") } -> StructureType.SPHERE words.any { it in listOf("dome", "hemisphere", "cupola") } -> StructureType.DOME words.any { it in listOf("statue", "sculpture", "monument", "effigy") } -> StructureType.STATUE words.any { it in listOf("tree", "oak", "pine") } -> StructureType.TREE words.any { it in listOf("fountain", "pool") } -> StructureType.FOUNTAIN words.any { it in listOf("road", "street", "highway", "path") } -> StructureType.ROAD words.any { it in listOf("platform", "floor", "base", "foundation") } -> StructureType.PLATFORM words.any { it in listOf("circle", "ring", "round") } -> StructureType.CIRCLE words.any { it in listOf("spiral", "helix", "coil", "twist") } -> StructureType.SPIRAL words.any { it in listOf("cube", "box", "square") } -> StructureType.CUBE words.any { it in listOf("tunnel", "passage", "corridor") } -> StructureType.TUNNEL words.any { it in listOf("arena", "stadium", "colosseum", "amphitheater") } -> StructureType.ARENA words.any { it in listOf("temple", "shrine", "church", "cathedral") } -> StructureType.TEMPLE words.any { it in listOf("farm", "field") } -> StructureType.FARM words.any { it in listOf("maze", "labyrinth") } -> StructureType.MAZE words.any { it in listOf("parkour", "obstacle", "course") } -> StructureType.PARKOUR words.any { it in listOf("garden", "park", "grove") } -> StructureType.GARDEN words.any { it in listOf("lake", "pond", "reservoir") } -> StructureType.LAKE words.any { it in listOf("mountain", "hill", "peak", "volcano") } -> StructureType.MOUNTAIN words.any { it in listOf("cave", "cavern", "grotto") } -> StructureType.CAVE words.any { it in listOf("ship", "boat", "vessel", "galleon") } -> StructureType.SHIP words.any { it in listOf("lighthouse", "beacon") } -> StructureType.LIGHTHOUSE words.any { it in listOf("windmill", "mill") } -> StructureType.WINDMILL words.any { it in listOf("well", "waterwell") } -> StructureType.WELL words.any { it in listOf("arch", "archway", "gateway") } -> StructureType.ARCH words.any { it in listOf("obelisk", "monolith") } -> StructureType.OBELISK words.any { it in listOf("portal", "gateway", "rift") } -> StructureType.PORTAL words.any { it in listOf("throne", "seat", "chair") } -> StructureType.THRONE words.any { it in listOf("altar", "pedestal", "dais") } -> StructureType.ALTAR words.any { it in listOf("tent", "pavilion", "canopy") } -> StructureType.TENT words.any { it in listOf("barn", "stable", "shed") } -> StructureType.BARN words.any { it in listOf("greenhouse", "conservatory") } -> StructureType.GREENHOUSE words.any { it in listOf("dock", "pier", "wharf", "jetty") } -> StructureType.DOCK words.any { it in listOf("watchtower", "lookout") } -> StructureType.WATCHTOWER words.any { it in listOf("ruins", "rubble", "destroyed", "broken") } -> StructureType.RUINS else -> StructureType.GENERIC } } private fun extractSize(): Int { return when { words.any { it in listOf("tiny", "mini", "small", "little") } -> 5 words.any { it in listOf("medium", "normal", "average") } -> 10 words.any { it in listOf("large", "big", "huge") } -> 20 words.any { it in listOf("massive", "giant", "enormous", "colossal") } -> 40 else -> { words.firstOrNull { it.toIntOrNull() != null }?.toInt() ?: 10 } } } private fun extractHeight(): Int { return when { words.any { it in listOf("tall", "high", "towering") } -> size * 2 words.any { it in listOf("short", "low", "flat", "squat") } -> max(3, size / 2) else -> size } } private fun extractStyle(): BuildStyle { return when { words.any { it in listOf("medieval", "old", "ancient", "gothic") } -> BuildStyle.MEDIEVAL words.any { it in listOf("modern", "futuristic", "sleek", "contemporary") } -> BuildStyle.MODERN words.any { it in listOf("japanese", "asian", "oriental", "pagoda") } -> BuildStyle.JAPANESE words.any { it in listOf("fantasy", "magical", "mystical", "enchanted") } -> BuildStyle.FANTASY words.any { it in listOf("rustic", "wooden", "natural", "primitive") } -> BuildStyle.RUSTIC words.any { it in listOf("nether", "hellish", "infernal") } -> BuildStyle.NETHER words.any { it in listOf("end", "ender", "void") } -> BuildStyle.END words.any { it in listOf("underwater", "aquatic", "ocean", "sea") } -> BuildStyle.UNDERWATER words.any { it in listOf("ice", "frozen", "arctic", "winter") } -> BuildStyle.ICE words.any { it in listOf("desert", "sand", "arid") } -> BuildStyle.DESERT else -> BuildStyle.DEFAULT } } private fun extractFeatures(): Set { val features = mutableSetOf() if (words.any { it in listOf("door", "entrance", "gate", "doorway") }) features.add(BuildFeature.DOOR) if (words.any { it in listOf("window", "windows") }) features.add(BuildFeature.WINDOWS) if (words.any { it in listOf("roof", "top", "ceiling") }) features.add(BuildFeature.ROOF) if (words.any { it in listOf("stairs", "steps", "staircase") }) features.add(BuildFeature.STAIRS) if (words.any { it in listOf("hollow", "empty", "inside", "interior") }) features.add(BuildFeature.HOLLOW) if (words.any { it in listOf("decorated", "fancy", "detailed", "ornate") }) features.add(BuildFeature.DECORATED) if (words.any { it in listOf("lit", "light", "glowing", "illuminated") }) features.add(BuildFeature.LIGHTING) if (words.any { it in listOf("random", "varied", "mixed") }) features.add(BuildFeature.RANDOM) if (words.any { it in listOf("symmetrical", "symmetric", "mirrored") }) features.add(BuildFeature.SYMMETRICAL) if (words.any { it in listOf("layered", "tiered", "levels") }) features.add(BuildFeature.LAYERED) return features } private fun extractPattern(): BuildPattern { return when { words.any { it in listOf("checkered", "checkerboard", "chess") } -> BuildPattern.CHECKERED words.any { it in listOf("striped", "stripes", "lines") } -> BuildPattern.STRIPED words.any { it in listOf("spiral", "swirl") } -> BuildPattern.SPIRAL words.any { it in listOf("gradient", "fade", "transition") } -> BuildPattern.GRADIENT words.any { it in listOf("mosaic", "tiled") } -> BuildPattern.MOSAIC words.any { it in listOf("brick", "brickwork") } -> BuildPattern.BRICK else -> BuildPattern.SOLID } } private fun extractShape(): BuildShape { return when { words.any { it in listOf("circular", "round") } -> BuildShape.CIRCULAR words.any { it in listOf("square", "rectangular") } -> BuildShape.SQUARE words.any { it in listOf("triangular", "triangle") } -> BuildShape.TRIANGULAR words.any { it in listOf("hexagonal", "hexagon") } -> BuildShape.HEXAGONAL words.any { it in listOf("octagonal", "octagon") } -> BuildShape.OCTAGONAL words.any { it in listOf("star", "starred") } -> BuildShape.STAR words.any { it in listOf("cross", "plus") } -> BuildShape.CROSS words.any { it in listOf("organic", "natural", "irregular") } -> BuildShape.ORGANIC else -> BuildShape.SQUARE } } private fun getPrimaryMaterial(): Material = materials.firstOrNull() ?: Material.STONE_BRICKS private fun getSecondaryMaterial(): Material = materials.getOrNull(1) ?: Material.OAK_PLANKS private fun getTertiaryMaterial(): Material = materials.getOrNull(2) ?: Material.COBBLESTONE private fun getMaterialForPattern(x: Int, y: Int, z: Int): Material { return when (pattern) { BuildPattern.CHECKERED -> if ((x + z) % 2 == 0) getPrimaryMaterial() else getSecondaryMaterial() BuildPattern.STRIPED -> if (x % 2 == 0) getPrimaryMaterial() else getSecondaryMaterial() BuildPattern.SPIRAL -> { val angle = atan2(z.toDouble(), x.toDouble()) if ((angle + y * 0.1) % (PI / 2) < PI / 4) getPrimaryMaterial() else getSecondaryMaterial() } BuildPattern.GRADIENT -> { val ratio = y.toDouble() / height if (ratio < 0.33) getPrimaryMaterial() else if (ratio < 0.66) getSecondaryMaterial() else getTertiaryMaterial() } BuildPattern.MOSAIC -> { when ((x + y + z) % 3) { 0 -> getPrimaryMaterial() 1 -> getSecondaryMaterial() else -> getTertiaryMaterial() } } BuildPattern.BRICK -> if ((x + (y % 2)) % 2 == 0) getPrimaryMaterial() else getSecondaryMaterial() else -> getPrimaryMaterial() } } private fun buildHouse(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() val roofMaterial = getSecondaryMaterial() object : BukkitRunnable() { var progress = 0 val maxProgress = size + height + 5 override fun run() { val blocksPerTick = max(1, (size * size) / 20) for (i in 0 until blocksPerTick) { when { progress < size -> { for (bx in 0..size) { for (bz in 0..size) { world.getBlockAt(x + bx, y, z + bz).type = material } } } progress < size + height -> { val currentHeight = progress - size for (bx in 0..size) { world.getBlockAt(x + bx, y + currentHeight, z).type = material world.getBlockAt(x + bx, y + currentHeight, z + size).type = material } for (bz in 0..size) { world.getBlockAt(x, y + currentHeight, z + bz).type = material world.getBlockAt(x + size, y + currentHeight, z + bz).type = material } if (BuildFeature.DOOR in features && currentHeight <= 2) { world.getBlockAt(x + size / 2, y + currentHeight, z).type = Material.AIR } if (BuildFeature.WINDOWS in features && currentHeight > 1 && currentHeight < height - 1) { world.getBlockAt(x + size / 4, y + currentHeight, z + size).type = Material.GLASS_PANE world.getBlockAt(x + 3 * size / 4, y + currentHeight, z + size).type = Material.GLASS_PANE } } else -> { if (BuildFeature.ROOF in features || features.isEmpty()) { val roofLevel = progress - size - height val roofSize = max(0, size / 2 - roofLevel) for (bx in roofLevel..(size - roofLevel)) { for (bz in roofLevel..(size - roofLevel)) { world.getBlockAt(x + bx, y + height + roofLevel, z + bz).type = roofMaterial } } } } } progress++ if (progress >= maxProgress) { cancel() onComplete() return } } } }.runTaskTimer(plugin, 0L, speed) } private fun buildTower(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val radius = size / 2 object : BukkitRunnable() { var currentY = 0 override fun run() { for (bx in -radius..radius) { for (bz in -radius..radius) { val dist = sqrt((bx * bx + bz * bz).toDouble()) if (dist <= radius) { if (BuildFeature.HOLLOW in features && dist < radius - 1) { continue } val material = getMaterialForPattern(bx, currentY, bz) world.getBlockAt(x + bx, y + currentY, z + bz).type = material } } } currentY++ if (currentY >= height) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildWall(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ object : BukkitRunnable() { var progress = 0 override fun run() { val currentX = progress % size val currentY = progress / size if (currentY < height) { val material = getMaterialForPattern(currentX, currentY, 0) world.getBlockAt(x + currentX, y + currentY, z).type = material } progress++ if (progress >= size * height) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildBridge(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() val width = max(3, size / 3) object : BukkitRunnable() { var progress = 0 override fun run() { for (w in 0 until width) { world.getBlockAt(x + progress, y, z + w).type = material if (BuildFeature.DECORATED in features) { if (w == 0 || w == width - 1) { world.getBlockAt(x + progress, y + 1, z + w).type = Material.OAK_FENCE } } } progress++ if (progress >= size) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildCastle(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var stage = 0 override fun run() { when (stage) { 0 -> { for (bx in 0..size) { for (bz in 0..size) { world.getBlockAt(x + bx, y, z + bz).type = Material.COBBLESTONE } } } in 1..height -> { for (bx in 0..size) { world.getBlockAt(x + bx, y + stage, z).type = material world.getBlockAt(x + bx, y + stage, z + size).type = material } for (bz in 0..size) { world.getBlockAt(x, y + stage, z + bz).type = material world.getBlockAt(x + size, y + stage, z + bz).type = material } } else -> { val towerHeight = height + 5 val corners = listOf(Pair(0, 0), Pair(size, 0), Pair(0, size), Pair(size, size)) for ((tx, tz) in corners) { for (ty in 0..towerHeight) { for (dx in -1..1) { for (dz in -1..1) { world.getBlockAt(x + tx + dx, y + ty, z + tz + dz).type = material } } } } cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed * 2) } private fun buildPyramid(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ object : BukkitRunnable() { var level = 0 override fun run() { val currentSize = size - level if (currentSize <= 0) { cancel() onComplete() return } for (bx in 0..currentSize) { for (bz in 0..currentSize) { val material = getMaterialForPattern(bx, level, bz) world.getBlockAt(x + level + bx, y + level, z + level + bz).type = material } } level++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildSphere(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val radius = size / 2 object : BukkitRunnable() { var currentY = -radius override fun run() { for (bx in -radius..radius) { for (bz in -radius..radius) { val distSq = bx * bx + currentY * currentY + bz * bz if (distSq <= radius * radius) { if (BuildFeature.HOLLOW in features && distSq < (radius - 1) * (radius - 1)) { continue } val material = getMaterialForPattern(bx, currentY, bz) world.getBlockAt(x + bx, y + currentY, z + bz).type = material } } } currentY++ if (currentY > radius) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildDome(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val radius = size / 2 object : BukkitRunnable() { var currentY = 0 override fun run() { for (bx in -radius..radius) { for (bz in -radius..radius) { val distSq = bx * bx + currentY * currentY + bz * bz if (distSq <= radius * radius) { if (BuildFeature.HOLLOW in features && distSq < (radius - 1) * (radius - 1)) { continue } val material = getMaterialForPattern(bx, currentY, bz) world.getBlockAt(x + bx, y + currentY, z + bz).type = material } } } currentY++ if (currentY > radius) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildStatue(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var stage = 0 override fun run() { when (stage) { in 0..2 -> { for (bx in 0..size / 3) { for (bz in 0..size / 3) { world.getBlockAt(x + bx, y + stage, z + bz).type = material } } } in 3..(height / 2) -> { for (bx in 0..size / 4) { for (bz in 0..size / 4) { world.getBlockAt(x + bx, y + stage, z + bz).type = material } } } in (height / 2 + 1)..height -> { for (bx in 0..size / 3) { for (bz in 0..size / 3) { world.getBlockAt(x + bx, y + stage, z + bz).type = material } } } else -> { cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildTree(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val trunkHeight = height val leafRadius = size / 3 object : BukkitRunnable() { var stage = 0 override fun run() { when { stage < trunkHeight -> { world.getBlockAt(x, y + stage, z).type = Material.OAK_LOG } else -> { val leafLevel = stage - trunkHeight if (leafLevel < leafRadius) { for (bx in -leafRadius..leafRadius) { for (bz in -leafRadius..leafRadius) { if (abs(bx) + abs(bz) <= leafRadius) { world.getBlockAt(x + bx, y + trunkHeight + leafLevel, z + bz).type = Material.OAK_LEAVES } } } } else { cancel() onComplete() } } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildFountain(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val radius = size / 2 object : BukkitRunnable() { var stage = 0 override fun run() { when (stage) { 0 -> { for (bx in -radius..radius) { for (bz in -radius..radius) { if (bx * bx + bz * bz <= radius * radius) { world.getBlockAt(x + bx, y, z + bz).type = Material.STONE_BRICKS world.getBlockAt(x + bx, y + 1, z + bz).type = Material.WATER } } } } in 1..height -> { world.getBlockAt(x, y + stage, z).type = Material.STONE_BRICKS } else -> { world.getBlockAt(x, y + height + 1, z).type = Material.WATER cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildRoad(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() val width = max(3, size / 4) object : BukkitRunnable() { var progress = 0 override fun run() { for (w in 0 until width) { world.getBlockAt(x + progress, y, z + w).type = material } progress++ if (progress >= size * 2) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed / 2) } private fun buildPlatform(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ object : BukkitRunnable() { var progress = 0 override fun run() { val bx = progress % size val bz = progress / size if (bz < size) { val material = getMaterialForPattern(bx, 0, bz) world.getBlockAt(x + bx, y, z + bz).type = material } progress++ if (progress >= size * size) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed / 4) } private fun buildCircle(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() val radius = size / 2 object : BukkitRunnable() { var angle = 0.0 override fun run() { val bx = (radius * cos(angle)).toInt() val bz = (radius * sin(angle)).toInt() world.getBlockAt(x + bx, y, z + bz).type = material angle += 0.1 if (angle >= 2 * PI) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed / 2) } private fun buildSpiral(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var angle = 0.0 var currentY = 0 override fun run() { val radius = (angle / (2 * PI)) * size / 2 val bx = (radius * cos(angle)).toInt() val bz = (radius * sin(angle)).toInt() world.getBlockAt(x + bx, y + currentY, z + bz).type = material angle += 0.2 if (angle % (PI / 2) < 0.2) { currentY++ } if (currentY >= height) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed / 2) } private fun buildCube(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ object : BukkitRunnable() { var progress = 0 val totalBlocks = size * size * size override fun run() { val bx = progress % size val bz = (progress / size) % size val by = progress / (size * size) if (by < size) { if (BuildFeature.HOLLOW in features) { if (bx == 0 || bx == size - 1 || bz == 0 || bz == size - 1 || by == 0 || by == size - 1) { val material = getMaterialForPattern(bx, by, bz) world.getBlockAt(x + bx, y + by, z + bz).type = material } } else { val material = getMaterialForPattern(bx, by, bz) world.getBlockAt(x + bx, y + by, z + bz).type = material } } progress++ if (progress >= totalBlocks) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed / 4) } private fun buildTunnel(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val tunnelHeight = max(3, size / 3) val tunnelWidth = max(3, size / 3) object : BukkitRunnable() { var progress = 0 override fun run() { for (h in 0 until tunnelHeight) { for (w in 0 until tunnelWidth) { world.getBlockAt(x + progress, y + h, z + w).type = Material.AIR } } progress++ if (progress >= size) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildArena(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() val radius = size / 2 object : BukkitRunnable() { var stage = 0 override fun run() { when { stage == 0 -> { for (bx in -radius..radius) { for (bz in -radius..radius) { if (bx * bx + bz * bz <= radius * radius) { world.getBlockAt(x + bx, y, z + bz).type = Material.SAND } } } } stage <= height -> { for (angle in 0 until 360 step 10) { val rad = Math.toRadians(angle.toDouble()) val bx = (radius * cos(rad)).toInt() val bz = (radius * sin(rad)).toInt() world.getBlockAt(x + bx, y + stage, z + bz).type = material } } else -> { cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildTemple(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var stage = 0 override fun run() { when { stage < 3 -> { for (bx in 0..size) { for (bz in 0..size) { world.getBlockAt(x + bx, y + stage, z + bz).type = material } } } stage < height -> { for (bx in 0..size) { world.getBlockAt(x + bx, y + stage, z).type = Material.STONE_BRICK_STAIRS world.getBlockAt(x + bx, y + stage, z + size).type = Material.STONE_BRICK_STAIRS } for (bz in 0..size) { world.getBlockAt(x, y + stage, z + bz).type = Material.STONE_BRICK_STAIRS world.getBlockAt(x + size, y + stage, z + bz).type = Material.STONE_BRICK_STAIRS } } else -> { for (bx in 0..size) { for (bz in 0..size) { world.getBlockAt(x + bx, y + height, z + bz).type = material } } cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildFarm(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ object : BukkitRunnable() { var progress = 0 override fun run() { val bx = progress % size val bz = progress / size if (bz < size) { world.getBlockAt(x + bx, y, z + bz).type = Material.FARMLAND if ((bx + bz) % 2 == 0) { world.getBlockAt(x + bx, y + 1, z + bz).type = Material.WHEAT } } progress++ if (progress >= size * size) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed / 4) } private fun buildMaze(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() val wallHeight = max(3, height / 2) object : BukkitRunnable() { var progress = 0 override fun run() { val bx = progress % size val bz = progress / size if (bz < size) { if ((bx % 4 == 0 && bz % 2 == 0) || (bz % 4 == 0 && bx % 2 == 0)) { for (h in 0 until wallHeight) { world.getBlockAt(x + bx, y + h, z + bz).type = material } } } progress++ if (progress >= size * size) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed / 4) } private fun buildParkour(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var progress = 0 var currentHeight = 0 override fun run() { if (progress < size) { world.getBlockAt(x + progress, y + currentHeight, z).type = material if (progress % 3 == 0) { currentHeight += Random.nextInt(1, 3) } } progress++ if (progress >= size) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildGarden(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ object : BukkitRunnable() { var progress = 0 override fun run() { val bx = progress % size val bz = progress / size if (bz < size) { world.getBlockAt(x + bx, y, z + bz).type = Material.GRASS_BLOCK if (Random.nextInt(10) < 3) { val plant = listOf(Material.POPPY, Material.DANDELION, Material.BLUE_ORCHID, Material.ALLIUM).random() world.getBlockAt(x + bx, y + 1, z + bz).type = plant } } progress++ if (progress >= size * size) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed / 4) } private fun buildLake(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val radius = size / 2 val depth = max(3, height / 2) object : BukkitRunnable() { var currentDepth = 0 override fun run() { for (bx in -radius..radius) { for (bz in -radius..radius) { if (bx * bx + bz * bz <= radius * radius) { world.getBlockAt(x + bx, y - currentDepth, z + bz).type = Material.WATER } } } currentDepth++ if (currentDepth >= depth) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildMountain(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var level = 0 override fun run() { if (level >= height) { cancel() onComplete() return } val currentRadius = size / 2 - (level * size) / (height * 2) if (currentRadius <= 0) { cancel() onComplete() return } for (bx in -currentRadius..currentRadius) { for (bz in -currentRadius..currentRadius) { if (bx * bx + bz * bz <= currentRadius * currentRadius) { world.getBlockAt(x + bx, y + level, z + bz).type = material } } } level++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildCave(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val radius = size / 3 object : BukkitRunnable() { var progress = 0 override fun run() { val bx = progress % size val bz = (progress / size) % size val by = progress / (size * size) if (by < height) { val centerDist = sqrt(((bx - size / 2) * (bx - size / 2) + (bz - size / 2) * (bz - size / 2)).toDouble()) if (centerDist <= radius) { world.getBlockAt(x + bx, y - by, z + bz).type = Material.AIR } } progress++ if (progress >= size * size * height) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed / 4) } private fun buildShip(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var stage = 0 override fun run() { when { stage < height / 2 -> { val width = size - stage * 2 for (bx in 0..size) { for (bz in stage..(size - stage)) { world.getBlockAt(x + bx, y + stage, z + bz).type = material } } } stage < height -> { for (bx in size / 3..(2 * size / 3)) { for (bz in size / 3..(2 * size / 3)) { world.getBlockAt(x + bx, y + stage, z + bz).type = material } } } else -> { world.getBlockAt(x + size / 2, y + height, z + size / 2).type = Material.OAK_FENCE world.getBlockAt(x + size / 2, y + height + 5, z + size / 2).type = Material.WHITE_WOOL cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildLighthouse(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() val radius = max(2, size / 4) object : BukkitRunnable() { var currentY = 0 override fun run() { for (bx in -radius..radius) { for (bz in -radius..radius) { if (bx * bx + bz * bz <= radius * radius) { world.getBlockAt(x + bx, y + currentY, z + bz).type = material } } } if (currentY == height) { world.getBlockAt(x, y + currentY + 1, z).type = Material.GLOWSTONE } currentY++ if (currentY > height + 1) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildWindmill(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var stage = 0 override fun run() { when { stage < height -> { for (bx in 0..size / 3) { for (bz in 0..size / 3) { world.getBlockAt(x + bx, y + stage, z + bz).type = material } } } else -> { val centerX = x + size / 6 val centerZ = z + size / 6 for (i in -size / 2..size / 2) { world.getBlockAt(centerX + i, y + height, centerZ).type = Material.OAK_PLANKS world.getBlockAt(centerX, y + height, centerZ + i).type = Material.OAK_PLANKS } cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildWell(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() val radius = max(2, size / 4) object : BukkitRunnable() { var stage = 0 override fun run() { when { stage < height -> { for (angle in 0 until 360 step 30) { val rad = Math.toRadians(angle.toDouble()) val bx = (radius * cos(rad)).toInt() val bz = (radius * sin(rad)).toInt() world.getBlockAt(x + bx, y + stage, z + bz).type = material } } else -> { for (bx in -radius..radius) { for (bz in -radius..radius) { if (bx * bx + bz * bz <= radius * radius) { world.getBlockAt(x + bx, y - 3, z + bz).type = Material.WATER } } } cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildArch(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() val archHeight = height val archWidth = size object : BukkitRunnable() { var progress = 0 override fun run() { if (progress < archWidth) { val archY = (archHeight * sin((progress.toDouble() / archWidth) * PI)).toInt() for (h in 0..archY) { world.getBlockAt(x + progress, y + h, z).type = material } } progress++ if (progress >= archWidth) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildObelisk(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var currentY = 0 override fun run() { val currentSize = max(1, size - (currentY * size) / height) for (bx in 0 until currentSize) { for (bz in 0 until currentSize) { world.getBlockAt(x + bx, y + currentY, z + bz).type = material } } currentY++ if (currentY >= height) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildPortal(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() val portalWidth = size val portalHeight = height object : BukkitRunnable() { var stage = 0 override fun run() { when { stage < portalHeight -> { world.getBlockAt(x, y + stage, z).type = material world.getBlockAt(x + portalWidth, y + stage, z).type = material } stage < portalHeight + portalWidth -> { val offset = stage - portalHeight world.getBlockAt(x + offset, y, z).type = material world.getBlockAt(x + offset, y + portalHeight, z).type = material } else -> { for (bx in 1 until portalWidth) { for (by in 1 until portalHeight) { world.getBlockAt(x + bx, y + by, z).type = Material.NETHER_PORTAL } } cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildThrone(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var stage = 0 override fun run() { when (stage) { 0 -> { for (bx in 0..size) { for (bz in 0..size) { world.getBlockAt(x + bx, y, z + bz).type = material } } } in 1..height -> { world.getBlockAt(x, y + stage, z).type = material world.getBlockAt(x + size, y + stage, z).type = material world.getBlockAt(x + size / 2, y + stage, z + size).type = material } else -> { cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildAltar(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var stage = 0 override fun run() { when { stage < 3 -> { for (bx in 0..size) { for (bz in 0..size) { world.getBlockAt(x + bx, y + stage, z + bz).type = material } } } else -> { world.getBlockAt(x + size / 2, y + 3, z + size / 2).type = Material.GLOWSTONE cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildTent(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var level = 0 override fun run() { if (level >= height) { cancel() onComplete() return } val currentSize = size - level for (bx in 0..currentSize) { for (bz in 0..currentSize) { world.getBlockAt(x + level + bx, y + level, z + level + bz).type = material } } level++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildBarn(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var stage = 0 override fun run() { when { stage == 0 -> { for (bx in 0..size) { for (bz in 0..size) { world.getBlockAt(x + bx, y, z + bz).type = Material.OAK_PLANKS } } } stage < height -> { for (bx in 0..size) { world.getBlockAt(x + bx, y + stage, z).type = material world.getBlockAt(x + bx, y + stage, z + size).type = material } for (bz in 0..size) { world.getBlockAt(x, y + stage, z + bz).type = material world.getBlockAt(x + size, y + stage, z + bz).type = material } } else -> { for (bx in 0..size) { for (bz in 0..size) { world.getBlockAt(x + bx, y + height, z + bz).type = Material.RED_TERRACOTTA } } cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildGreenhouse(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ object : BukkitRunnable() { var stage = 0 override fun run() { when { stage == 0 -> { for (bx in 0..size) { for (bz in 0..size) { world.getBlockAt(x + bx, y, z + bz).type = Material.OAK_PLANKS } } } stage < height -> { for (bx in 0..size) { world.getBlockAt(x + bx, y + stage, z).type = Material.GLASS world.getBlockAt(x + bx, y + stage, z + size).type = Material.GLASS } for (bz in 0..size) { world.getBlockAt(x, y + stage, z + bz).type = Material.GLASS world.getBlockAt(x + size, y + stage, z + bz).type = Material.GLASS } } else -> { for (bx in 0..size) { for (bz in 0..size) { world.getBlockAt(x + bx, y + height, z + bz).type = Material.GLASS } } cancel() onComplete() } } stage++ } }.runTaskTimer(plugin, 0L, speed) } private fun buildDock(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var progress = 0 override fun run() { for (w in 0..size / 3) { world.getBlockAt(x + progress, y, z + w).type = material if (progress % 3 == 0) { world.getBlockAt(x + progress, y + 1, z + w).type = Material.OAK_FENCE } } progress++ if (progress >= size) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildWatchtower(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() val radius = max(2, size / 4) object : BukkitRunnable() { var currentY = 0 override fun run() { for (bx in -radius..radius) { for (bz in -radius..radius) { if (bx * bx + bz * bz <= radius * radius) { if (currentY == 0 || bx * bx + bz * bz >= (radius - 1) * (radius - 1)) { world.getBlockAt(x + bx, y + currentY, z + bz).type = material } } } } if (currentY == height) { for (bx in -radius - 1..radius + 1) { for (bz in -radius - 1..radius + 1) { if (abs(bx) == radius + 1 || abs(bz) == radius + 1) { world.getBlockAt(x + bx, y + currentY, z + bz).type = Material.STONE_BRICK_WALL } } } } currentY++ if (currentY > height) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed) } private fun buildRuins(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ val material = getPrimaryMaterial() object : BukkitRunnable() { var progress = 0 override fun run() { val bx = progress % size val bz = (progress / size) % size val by = progress / (size * size) if (by < height) { if (Random.nextInt(10) < 4) { world.getBlockAt(x + bx, y + by, z + bz).type = material } else if (Random.nextInt(10) < 2) { world.getBlockAt(x + bx, y + by, z + bz).type = Material.MOSSY_COBBLESTONE } } progress++ if (progress >= size * size * height) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed / 4) } private fun buildGeneric(location: Location, plugin: AdminAIToolkit, speed: Long, onComplete: () -> Unit) { val world = location.world ?: return val x = location.blockX val y = location.blockY val z = location.blockZ object : BukkitRunnable() { var progress = 0 override fun run() { val bx = progress % size val bz = (progress / size) % size val by = progress / (size * size) if (by < height) { val material = getMaterialForPattern(bx, by, bz) world.getBlockAt(x + bx, y + by, z + bz).type = material } progress++ if (progress >= size * size * height) { cancel() onComplete() } } }.runTaskTimer(plugin, 0L, speed / 4) } } enum class StructureType { HOUSE, TOWER, WALL, BRIDGE, CASTLE, PYRAMID, SPHERE, DOME, STATUE, TREE, FOUNTAIN, ROAD, PLATFORM, CIRCLE, SPIRAL, CUBE, TUNNEL, ARENA, TEMPLE, FARM, MAZE, PARKOUR, GARDEN, LAKE, MOUNTAIN, CAVE, SHIP, LIGHTHOUSE, WINDMILL, WELL, ARCH, OBELISK, PORTAL, THRONE, ALTAR, TENT, BARN, GREENHOUSE, DOCK, WATCHTOWER, RUINS, GENERIC } enum class BuildStyle { DEFAULT, MEDIEVAL, MODERN, JAPANESE, FANTASY, RUSTIC, NETHER, END, UNDERWATER, ICE, DESERT } enum class BuildFeature { DOOR, WINDOWS, ROOF, STAIRS, HOLLOW, DECORATED, LIGHTING, RANDOM, SYMMETRICAL, LAYERED } enum class BuildPattern { SOLID, CHECKERED, STRIPED, SPIRAL, GRADIENT, MOSAIC, BRICK } enum class BuildShape { SQUARE, CIRCULAR, TRIANGULAR, HEXAGONAL, OCTAGONAL, STAR, CROSS, ORGANIC }