package com.chaosfishing import org.bukkit.Bukkit import org.bukkit.ChatColor import org.bukkit.Material import org.bukkit.NamespacedKey import org.bukkit.block.Chest import org.bukkit.enchantments.Enchantment import org.bukkit.inventory.ItemStack import org.bukkit.inventory.meta.BlockStateMeta import org.bukkit.inventory.meta.EnchantmentStorageMeta import java.util.concurrent.ThreadLocalRandom class LootRoller(private val plugin: ChaosFishing) { /** * Returns null when the rolled entry is "keep vanilla" (caller should not replace the catch). */ fun rollLoot(): RollResult { val entries = plugin.chaosConfig.loot if (entries.isEmpty()) return RollResult.KeepVanilla val total = entries.sumOf { it.weight } if (total <= 0) return RollResult.KeepVanilla var pick = ThreadLocalRandom.current().nextInt(total) var chosen: LootEntry = entries.first() for (e in entries) { pick -= e.weight if (pick < 0) { chosen = e break } } if (chosen.keepVanilla) return RollResult.KeepVanilla return RollResult.Replace(buildItem(chosen), chosen) } private fun buildItem(entry: LootEntry): ItemStack { if (entry.lootTableKey != null) { val chest = buildStructureChest(entry) if (chest != null) return chest // Fall through to a regular chest item if the loot table key was bad. } val amount = if (entry.max <= entry.min) entry.min else ThreadLocalRandom.current().nextInt(entry.min, entry.max + 1) val effectiveMultiplier = if (isSingletonGear(entry.material)) 1 else plugin.chaosConfig.lootMultiplier.coerceAtLeast(1) val multiplied = amount.coerceAtLeast(1) * effectiveMultiplier val stack = ItemStack(entry.material, multiplied.coerceAtMost(entry.material.maxStackSize.coerceAtLeast(1) * 64)) when (entry.enchantMode) { EnchantMode.NONE -> {} EnchantMode.PARTIAL -> applyEnchants(stack, entry, partial = true) EnchantMode.FULL -> applyEnchants(stack, entry, partial = false) } if (!entry.customName.isNullOrBlank()) { val meta = stack.itemMeta if (meta != null) { meta.setDisplayName(ChatColor.translateAlternateColorCodes('&', entry.customName)) stack.itemMeta = meta } } return stack } private fun isSingletonGear(material: Material): Boolean { val name = material.name if (name == "ARROW" || name == "SPECTRAL_ARROW" || name == "TIPPED_ARROW") return false return name.endsWith("_HELMET") || name.endsWith("_CHESTPLATE") || name.endsWith("_LEGGINGS") || name.endsWith("_BOOTS") || name == "TURTLE_HELMET" || name == "ELYTRA" || name == "SHIELD" || name.endsWith("_SWORD") || name.endsWith("_AXE") || name.endsWith("_PICKAXE") || name.endsWith("_SHOVEL") || name.endsWith("_HOE") || name == "BOW" || name == "CROSSBOW" || name == "TRIDENT" || name == "MACE" || name == "FISHING_ROD" || name == "SHEARS" || name == "FLINT_AND_STEEL" || name == "BRUSH" } private fun buildStructureChest(entry: LootEntry): ItemStack? { val key = parseLootTableKey(entry.lootTableKey ?: return null) ?: run { plugin.logger.warning("Invalid loot-table key in loot entry: ${entry.lootTableKey}") return null } val table = Bukkit.getLootTable(key) if (table == null) { plugin.logger.warning("Unknown loot table: $key") return null } val stack = ItemStack(Material.CHEST, 1) val meta = stack.itemMeta as? BlockStateMeta ?: return null val state = meta.blockState as? Chest ?: return null val rolls = plugin.chaosConfig.lootMultiplier.coerceAtLeast(1) if (rolls <= 1) { state.lootTable = table state.seed = ThreadLocalRandom.current().nextLong() } else { val rolled = mutableListOf() val ctx = org.bukkit.loot.LootContext.Builder( org.bukkit.Location(plugin.server.worlds.firstOrNull(), 0.0, 0.0, 0.0) ).build() val rng = java.util.Random() repeat(rolls) { runCatching { rolled.addAll(table.populateLoot(rng, ctx)) } } val inv = state.blockInventory inv.clear() val slots = inv.size rolled.shuffle() for ((i, item) in rolled.withIndex()) { if (i >= slots) break inv.setItem(i, item) } } state.update(true, false) meta.blockState = state val display = if (!entry.customName.isNullOrBlank()) { ChatColor.translateAlternateColorCodes('&', entry.customName) } else { val pretty = key.key.substringAfterLast('/').replace('_', ' ') .split(' ').joinToString(" ") { w -> w.replaceFirstChar { it.titlecase() } } ChatColor.GOLD.toString() + ChatColor.BOLD + "Loot Chest " + ChatColor.RESET + ChatColor.GRAY + "(" + pretty + ")" } meta.setDisplayName(display) stack.itemMeta = meta return stack } private fun parseLootTableKey(raw: String): NamespacedKey? { val trimmed = raw.trim().lowercase() return if (trimmed.contains(':')) { @Suppress("DEPRECATION") NamespacedKey.fromString(trimmed) } else { NamespacedKey.minecraft(trimmed) } } private fun applyEnchants(stack: ItemStack, entry: LootEntry, partial: Boolean) { val isBook = stack.type == Material.ENCHANTED_BOOK val applicable = allEnchantments().filter { ench -> if (isBook) true else runCatching { ench.canEnchantItem(stack) }.getOrDefault(false) } if (applicable.isEmpty()) return val rng = ThreadLocalRandom.current() val pool = applicable.toMutableList() pool.shuffle() val defaultMin = 1 val defaultMax = if (partial) pool.size.coerceAtMost(3) else pool.size val rawMin = entry.minEnchants ?: defaultMin val rawMax = entry.maxEnchants ?: defaultMax val lo = rawMin.coerceIn(0, pool.size) val hi = rawMax.coerceIn(lo, pool.size) val count = if (hi <= lo) lo else rng.nextInt(lo, hi + 1) val bookMeta = if (isBook) stack.itemMeta as? EnchantmentStorageMeta else null var applied = 0 for (ench in pool) { if (applied >= count) break val maxLvl = ench.maxLevel val level = rng.nextInt(1, maxLvl + 1) val ok = if (bookMeta != null) { bookMeta.addStoredEnchant(ench, level, true) } else { runCatching { stack.addUnsafeEnchantment(ench, level) }.isSuccess } if (ok) applied++ } if (bookMeta != null) stack.itemMeta = bookMeta } private fun allEnchantments(): List { val registry = org.bukkit.Bukkit.getRegistry(Enchantment::class.java) ?: return emptyList() val list = mutableListOf() for (e in registry) list.add(e) return list } fun findEntryByMaterial(material: Material): LootEntry? = plugin.chaosConfig.loot.firstOrNull { !it.keepVanilla && it.lootTableKey == null && it.material == material } sealed class RollResult { object KeepVanilla : RollResult() data class Replace(val item: ItemStack, val entry: LootEntry) : RollResult() } fun rerollVanillaCatch(): ItemStack? { val rng = ThreadLocalRandom.current() val r = rng.nextInt(100) val mat = when { r < 5 -> when (rng.nextInt(4)) { 0 -> Material.NAUTILUS_SHELL 1 -> Material.NAME_TAG 2 -> Material.SADDLE else -> Material.ENCHANTED_BOOK } r < 15 -> when (rng.nextInt(3)) { 0 -> Material.BOW 1 -> Material.FISHING_ROD else -> Material.INK_SAC } r < 75 -> when (rng.nextInt(4)) { 0 -> Material.COD 1 -> Material.SALMON 2 -> Material.TROPICAL_FISH else -> Material.PUFFERFISH } else -> when (rng.nextInt(6)) { 0 -> Material.LEATHER 1 -> Material.STICK 2 -> Material.STRING 3 -> Material.BONE 4 -> Material.ROTTEN_FLESH else -> Material.BOWL } } return ItemStack(mat, 1) } }