Files
src
build.gradle.kts
manifest.kod
settings.gradle.kts
Code
14 1,062
src/main/kotlin/com/kodari/serverfeatures/RoleManager.kt
package com.kodari.serverfeatures
import org.bukkit.Bukkit
import org.bukkit.ChatColor
import org.bukkit.Material
import org.bukkit.configuration.file.YamlConfiguration
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.Listener
import org.bukkit.event.player.AsyncPlayerChatEvent
import org.bukkit.event.player.PlayerJoinEvent
import org.bukkit.event.player.PlayerQuitEvent
import org.bukkit.event.inventory.InventoryClickEvent
import org.bukkit.inventory.ItemStack
import org.bukkit.plugin.java.JavaPlugin
import java.io.File
import java.util.UUID
data class KodariRole(
val name: String,
var startColor: String = "#ffffff",
var endColor: String = "#777777",
var bold: Boolean = true,
val commands: MutableSet<String> = mutableSetOf()
)
class RoleManager(private val plugin: JavaPlugin) : Listener {
private val file = File(plugin.dataFolder, "roles.yml")
private val data = YamlConfiguration.loadConfiguration(file)
private val roles = mutableMapOf<String, KodariRole>()
private val playerRoles = mutableMapOf<UUID, MutableSet<String>>()
private val attachments = mutableMapOf<UUID, org.bukkit.permissions.PermissionAttachment>()
private val pendingCommands = mutableMapOf<UUID, String>()
private val pendingCommandRemovals = mutableSetOf<UUID>()
init {
data.getConfigurationSection("roles")?.getKeys(false)?.forEach { key ->
roles[key.lowercase()] = KodariRole(
key,
data.getString("roles.$key.start", "#ffffff")!!,
data.getString("roles.$key.end", "#777777")!!,
data.getBoolean("roles.$key.bold", true),
data.getStringList("roles.$key.commands").map { it.lowercase() }.toMutableSet()
)
}
data.getConfigurationSection("players")?.getKeys(false)?.forEach { raw ->
val uuid = runCatching { UUID.fromString(raw) }.getOrNull() ?: return@forEach
playerRoles[uuid] = data.getStringList("players.$raw").map { it.lowercase() }.toMutableSet()
}
if (!roles.containsKey("owner")) {
roles["owner"] = KodariRole("Owner", "#ffd700", "#ff2020")
save()
}
}
fun create(name: String): Boolean {
val key = name.lowercase()
if (!key.matches(Regex("[a-z0-9_-]+")) || roles.containsKey(key)) return false
roles[key] = KodariRole(name)
save()
return true
}
fun role(name: String): KodariRole? = roles[name.lowercase()]
fun roleNames(): List<String> = roles.values.map { it.name }.sorted()
fun add(player: Player, roleName: String): Boolean {
val role = role(roleName) ?: return false
val assigned = playerRoles.getOrPut(player.uniqueId) { mutableSetOf() }
if (!assigned.add(role.name.lowercase())) return false
updateAttachment(player)
save()
return true
}
fun remove(player: Player, roleName: String): Boolean {
val assigned = playerRoles[player.uniqueId] ?: return false
if (!assigned.remove(roleName.lowercase())) return false
updateAttachment(player)
save()
return true
}
fun hasRole(player: Player, roleName: String): Boolean = playerRoles[player.uniqueId]?.any { it.equals(roleName, true) } == true
fun configure(player: Player) {
val inventory = Bukkit.createInventory(null, 54, "Role Configuration")
roleNames().take(54).forEachIndexed { index, name ->
inventory.setItem(index, named(Material.NAME_TAG, "§e$name", listOf("§7Click to edit this role.")))
}
player.openInventory(inventory)
}
private fun edit(player: Player, role: KodariRole) {
val inventory = Bukkit.createInventory(null, 9, "Role: ${role.name}")
inventory.setItem(0, named(Material.RED_DYE, GradientUtil.gradient("Red → Blue", "#ff2020", "#2020ff"), emptyList()))
inventory.setItem(1, named(Material.PURPLE_DYE, GradientUtil.gradient("White → Purple", "#ffffff", "#9b00ff"), emptyList()))
inventory.setItem(2, named(Material.GOLD_INGOT, "§eBold: ${if (role.bold) "ON" else "OFF"}", emptyList()))
inventory.setItem(4, named(Material.WRITABLE_BOOK, "§aAdd command", listOf("§7Type a command in chat.")))
inventory.setItem(5, named(Material.BOOK, "§bCommands", role.commands.map { "§f/$it" }))
inventory.setItem(8, named(Material.ARROW, "§cBack", emptyList()))
player.openInventory(inventory)
}
@EventHandler
fun onClick(event: InventoryClickEvent) {
val player = event.whoClicked as? Player ?: return
val title = event.view.title
if (title != "Role Configuration" && !title.startsWith("Role: ")) return
event.isCancelled = true
if (title == "Role Configuration") {
val name = roleNames().getOrNull(event.rawSlot) ?: return
role(name)?.let { edit(player, it) }
return
}
val role = role(title.removePrefix("Role: ")) ?: return
when (event.rawSlot) {
0 -> {
role.startColor = "#ff2020"
role.endColor = "#2020ff"
save()
edit(player, role)
}
1 -> {
role.startColor = "#ffffff"
role.endColor = "#9b00ff"
save()
edit(player, role)
}
2 -> {
role.bold = !role.bold
save()
edit(player, role)
}
4 -> {
pendingCommands[player.uniqueId] = role.name.lowercase()
pendingCommandRemovals.remove(player.uniqueId)
player.closeInventory()
player.sendMessage("§eType the command name to allow, or §f/cancel §eto stop.")
}
5 -> {
pendingCommands[player.uniqueId] = role.name.lowercase()
pendingCommandRemovals += player.uniqueId
player.closeInventory()
player.sendMessage("§eType the command name to remove, or §f/cancel §eto stop.")
}
8 -> configure(player)
}
}
@EventHandler
fun onChat(event: AsyncPlayerChatEvent) {
val roleName = pendingCommands.remove(event.player.uniqueId) ?: return
event.isCancelled = true
val command = event.message.removePrefix("/").trim().lowercase().split(" ").firstOrNull().orEmpty()
val remove = pendingCommandRemovals.remove(event.player.uniqueId)
if (command.isEmpty() || command == "cancel") {
event.player.sendMessage("§cRole command change cancelled.")
return
}
plugin.server.scheduler.runTask(plugin, Runnable {
val role = role(roleName)
if (remove) role?.commands?.remove(command) else role?.commands?.add(command)
save()
event.player.sendMessage(if (remove) "§aRemoved /$command from role $roleName." else "§aAllowed /$command for role $roleName.")
updateAttachment(event.player)
})
}
@EventHandler
fun onJoin(event: PlayerJoinEvent) = updateAttachment(event.player)
@EventHandler
fun onQuit(event: PlayerQuitEvent) {
attachments.remove(event.player.uniqueId)?.remove()
}
@EventHandler
fun onChatFormat(event: AsyncPlayerChatEvent) {
if (pendingCommands.containsKey(event.player.uniqueId)) return
event.format = "${formatName(event.player)}§f: %2\$s"
}
fun formatName(player: Player): String {
val assigned = playerRoles[player.uniqueId]?.mapNotNull { roles[it] }.orEmpty()
val role = assigned.firstOrNull() ?: return player.name
val roleNames = assigned.joinToString(", ") { it.name }
return GradientUtil.gradient("[$roleNames] ${player.name}", role.startColor, role.endColor, bold = role.bold)
}
private fun updateAttachment(player: Player) {
attachments.remove(player.uniqueId)?.remove()
val attachment = player.addAttachment(plugin)
playerRoles[player.uniqueId].orEmpty().mapNotNull { roles[it] }.flatMap { it.commands }.forEach { command ->
attachment.setPermission(command, true)
attachment.setPermission("minecraft.command.$command", true)
}
attachments[player.uniqueId] = attachment
}