package com.entitystacker.manager import com.entitystacker.EntityStacker import com.entitystacker.model.StackedEntity import com.entitystacker.model.StackedItem import com.entitystacker.model.StackedXpOrb import com.entitystacker.util.NmsGoalUtil import org.bukkit.ChatColor import org.bukkit.entity.* import java.util.UUID import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.ConcurrentHashMap.newKeySet private val MONSTER_CLASS: Class<*> = Monster::class.java private val WATER_MOB_CLASS: Class<*> = WaterMob::class.java class StackManager(private val plugin: EntityStacker) { private val entityStacks: MutableMap = ConcurrentHashMap() private val itemStacks: MutableMap = ConcurrentHashMap() private val xpStacks: MutableMap = ConcurrentHashMap() private val noAiEntities: MutableSet = newKeySet() fun tryStackEntity(entity: LivingEntity) { val cfg = plugin.configManager if (!cfg.entitiesEnabled) return if (!cfg.isEntityAllowed(entity.type)) return if (entity is Player) return val radius = cfg.getEntityRadius(entity.type) val maxStack = cfg.getEntityMaxStack(entity.type) val existingStack = entity.getNearbyEntities(radius, radius, radius) .filterIsInstance() .filter { it.type == entity.type && it !is Player } .mapNotNull { nearby -> entityStacks[nearby.uniqueId]?.let { nearby to it } } .filter { (_, stack) -> stack.stackSize < maxStack } .minByOrNull { (_, stack) -> stack.stackSize } if (existingStack != null) { val (host, stack) = existingStack stack.stackSize += entityStacks[entity.uniqueId]?.stackSize ?: 1 entityStacks.remove(entity.uniqueId) noAiEntities.remove(entity.uniqueId) entity.remove() updateEntityDisplay(host, stack) } else { val current = entityStacks[entity.uniqueId] val stack = current ?: StackedEntity(entity.uniqueId, entity.type, 1) if (current == null) entityStacks[entity.uniqueId] = stack updateEntityDisplay(entity, stack) } } fun handleEntityDeath(entity: LivingEntity): Int { val stack = entityStacks.remove(entity.uniqueId) ?: return 1 val wasNoAi = noAiEntities.remove(entity.uniqueId) val cfg = plugin.configManager if (cfg.unstackOnDeath && stack.stackSize > 1) { if (!cfg.killEntireStackOnDeath) { stack.stackSize-- val loc = entity.location plugin.server.scheduler.runTask(plugin, Runnable { val spawned = loc.world?.spawnEntity(loc, entity.type) as? LivingEntity ?: return@Runnable if (wasNoAi && spawned is Mob) { noAiEntities.add(spawned.uniqueId) NmsGoalUtil.clearGoals(spawned) } val newStack = StackedEntity(spawned.uniqueId, spawned.type, stack.stackSize) entityStacks[spawned.uniqueId] = newStack updateEntityDisplay(spawned, newStack) }) return 1 } else { return stack.stackSize } } return stack.stackSize } fun tryStackItem(item: Item) { val cfg = plugin.configManager if (!cfg.itemsEnabled) return val material = item.itemStack.type val radius = cfg.getItemRadius(material) val maxStack = cfg.getItemMaxStack(material) val nearby = item.getNearbyEntities(radius, radius, radius) .filterIsInstance() .filter { it.itemStack.type == material && it.uniqueId != item.uniqueId } var remaining = itemStacks[item.uniqueId]?.amount ?: item.itemStack.amount for (other in nearby) { if (remaining <= 0) break val otherStack = itemStacks[other.uniqueId] val otherAmount = otherStack?.amount ?: other.itemStack.amount val space = maxStack - otherAmount if (space <= 0) continue val transfer = minOf(space, remaining) remaining -= transfer val newAmount = otherAmount + transfer if (otherStack != null) { otherStack.amount = newAmount } else { itemStacks[other.uniqueId] = StackedItem(other.uniqueId, newAmount) } updateItemDisplay(other, newAmount, cfg.itemDisplayName) } if (remaining <= 0) { itemStacks.remove(item.uniqueId) item.remove() } else { val existingStack = itemStacks[item.uniqueId] if (existingStack != null) { existingStack.amount = remaining } else { itemStacks[item.uniqueId] = StackedItem(item.uniqueId, remaining) } updateItemDisplay(item, remaining, cfg.itemDisplayName) } } fun tryStackXpOrb(orb: ExperienceOrb) { val cfg = plugin.configManager if (!cfg.xpEnabled) return val radius = cfg.xpMergeRadius val maxStack = cfg.xpMaxStack val nearby = orb.getNearbyEntities(radius, radius, radius) .filterIsInstance() .filter { it.uniqueId != orb.uniqueId } .filter { (xpStacks[it.uniqueId]?.experience ?: it.experience) < maxStack } if (nearby.isEmpty()) { xpStacks.getOrPut(orb.uniqueId) { StackedXpOrb(orb.uniqueId, orb.experience) } return } val target = nearby.first() val targetStack = xpStacks[target.uniqueId] val targetXp = targetStack?.experience ?: target.experience val orbXp = xpStacks[orb.uniqueId]?.experience ?: orb.experience val combined = minOf(targetXp + orbXp, maxStack) val leftover = (targetXp + orbXp) - combined if (targetStack != null) { targetStack.experience = combined } else { xpStacks[target.uniqueId] = StackedXpOrb(target.uniqueId, combined) } target.experience = combined xpStacks.remove(orb.uniqueId) if (leftover > 0) { xpStacks[orb.uniqueId] = StackedXpOrb(orb.uniqueId, leftover) orb.experience = leftover } else { orb.remove() } } fun mergeNearbyEntityStacks() { val cfg = plugin.configManager if (!cfg.entitiesEnabled) return val processed = HashSet(entityStacks.size * 2) val entries = entityStacks.entries.toList() for ((uuid, stack) in entries) { if (uuid in processed) continue val entity = plugin.server.getEntity(uuid) if (entity == null || !entity.isValid) { entityStacks.remove(uuid) noAiEntities.remove(uuid) processed.add(uuid) continue } if (entity !is LivingEntity) continue val type = entity.type if (!cfg.isEntityAllowed(type) || !cfg.shouldMergeEntityType(type)) continue val maxStack = cfg.getEntityMaxStack(type) if (stack.stackSize >= maxStack) continue val radius = cfg.getEntityRadius(type) val candidates = entity.getNearbyEntities(radius, radius, radius) .filterIsInstance() .filter { it.type == type && it.uniqueId != uuid && it.uniqueId !in processed } .mapNotNull { nearby -> entityStacks[nearby.uniqueId]?.let { nearby to it } } for ((nearbyEntity, nearbyStack) in candidates) { if (stack.stackSize >= maxStack) break val canAbsorb = minOf(nearbyStack.stackSize, maxStack - stack.stackSize) stack.stackSize += canAbsorb nearbyStack.stackSize -= canAbsorb if (nearbyStack.stackSize <= 0) { entityStacks.remove(nearbyEntity.uniqueId) noAiEntities.remove(nearbyEntity.uniqueId) nearbyEntity.remove() processed.add(nearbyEntity.uniqueId) } else { updateEntityDisplay(nearbyEntity, nearbyStack) } updateEntityDisplay(entity, stack) } processed.add(uuid) } } fun mergeNearbyItemStacks() { val cfg = plugin.configManager if (!cfg.itemsEnabled) return val processed = HashSet(itemStacks.size * 2) val entries = itemStacks.entries.toList() for ((uuid, stack) in entries) { if (uuid in processed) continue val entity = plugin.server.getEntity(uuid) if (entity == null || !entity.isValid) { itemStacks.remove(uuid) processed.add(uuid) continue } val item = entity as? Item ?: continue val material = item.itemStack.type if (!cfg.shouldMergeItemType(material)) continue val maxStack = cfg.getItemMaxStack(material) if (stack.amount >= maxStack) continue val radius = cfg.getItemRadius(material) val candidates = item.getNearbyEntities(radius, radius, radius) .filterIsInstance() .filter { it.itemStack.type == material && it.uniqueId != uuid && it.uniqueId !in processed } .mapNotNull { nearby -> itemStacks[nearby.uniqueId]?.let { nearby to it } } for ((nearbyItem, nearbyStack) in candidates) { if (stack.amount >= maxStack) break val canAbsorb = minOf(nearbyStack.amount, maxStack - stack.amount) stack.amount += canAbsorb nearbyStack.amount -= canAbsorb if (nearbyStack.amount <= 0) { itemStacks.remove(nearbyItem.uniqueId) nearbyItem.remove() processed.add(nearbyItem.uniqueId) } else { updateItemDisplay(nearbyItem, nearbyStack.amount, cfg.itemDisplayName) } updateItemDisplay(item, stack.amount, cfg.itemDisplayName) } processed.add(uuid) } } fun getEntityStackSize(uuid: UUID): Int = entityStacks[uuid]?.stackSize ?: 1 fun getItemStackAmount(uuid: UUID): Int = itemStacks[uuid]?.amount ?: -1 fun getEntityStack(uuid: UUID): StackedEntity? = entityStacks[uuid] fun removeEntityStack(uuid: UUID) { entityStacks.remove(uuid) } fun removeItemStack(uuid: UUID) { itemStacks.remove(uuid) } fun removeXpStack(uuid: UUID) { xpStacks.remove(uuid) } fun markNoAi(uuid: UUID) { noAiEntities.add(uuid) } fun enforceNoAiEntities() { val stale = mutableListOf() for (uuid in noAiEntities) { val mob = plugin.server.getEntity(uuid) as? Mob if (mob == null || !mob.isValid) { stale.add(uuid) continue } mob.target = null if (NmsGoalUtil.hasGoals(mob)) NmsGoalUtil.clearGoals(mob) } if (stale.isNotEmpty()) noAiEntities.removeAll(stale.toSet()) } fun killAllHostile(): Int { var count = 0 for (world in plugin.server.worlds) { for (entity in world.entities.toList()) { if (entity !is LivingEntity || entity is Player) continue if (!MONSTER_CLASS.isInstance(entity) && !WATER_MOB_CLASS.isInstance(entity)) continue count += entityStacks.remove(entity.uniqueId)?.stackSize ?: 1 noAiEntities.remove(entity.uniqueId) entity.health = 0.0 } } return count } fun killAllPassive(): Int { var count = 0 for (world in plugin.server.worlds) { for (entity in world.entities.toList()) { if (entity !is LivingEntity || entity is Player) continue if (MONSTER_CLASS.isInstance(entity) || WATER_MOB_CLASS.isInstance(entity)) continue count += entityStacks.remove(entity.uniqueId)?.stackSize ?: 1 noAiEntities.remove(entity.uniqueId) entity.health = 0.0 } } return count } fun clearItems(): Int { var count = 0 for (world in plugin.server.worlds) { for (entity in world.entities.toList()) { if (entity !is Item) continue count += itemStacks.remove(entity.uniqueId)?.amount ?: entity.itemStack.amount entity.remove() } } return count } fun clearAll() { entityStacks.clear() itemStacks.clear() xpStacks.clear() noAiEntities.clear() } private fun updateEntityDisplay(entity: LivingEntity, stack: StackedEntity) { if (stack.stackSize <= 1) { entity.customName = null entity.isCustomNameVisible = false return } val typeName = stack.entityType.name.replace('_', ' ').lowercase() .replaceFirstChar { it.uppercase() } val display = plugin.configManager.entityDisplayName .replace("{count}", stack.stackSize.toString()) .replace("{name}", typeName) entity.customName = ChatColor.translateAlternateColorCodes('&', display) entity.isCustomNameVisible = true } private fun updateItemDisplay(item: Item, amount: Int, template: String) { if (amount <= 1) { item.customName = null item.isCustomNameVisible = false return } val typeName = item.itemStack.type.name.replace('_', ' ').lowercase() .replaceFirstChar { it.uppercase() } val display = template .replace("{count}", amount.toString()) .replace("{name}", typeName) item.customName = ChatColor.translateAlternateColorCodes('&', display) item.isCustomNameVisible = true } }