package com.guildmaster.commands import com.guildmaster.GuildMaster import com.guildmaster.guild.Guild import com.guildmaster.guild.GuildPermission import com.guildmaster.guild.GuildRole import com.guildmaster.gui.AuditGUI import com.guildmaster.gui.BannerDesignerGUI import com.guildmaster.gui.DiplomacyGUI import com.guildmaster.gui.BrowseGuildsGUI import com.guildmaster.gui.MainGuildGUI import com.guildmaster.gui.PerkTreeGUI import com.guildmaster.gui.QuestGUI import com.guildmaster.gui.VaultGUI import com.guildmaster.gui.WarGUI import com.guildmaster.util.ValidationUtil import org.bukkit.Bukkit 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 GuildCommand(private val plugin: GuildMaster) : CommandExecutor, TabCompleter { override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array): Boolean { if (sender !is Player) { plugin.messageManager.send(sender, "errors.player-only") return true } if (args.isEmpty()) { openGui(sender) return true } when (args[0].lowercase()) { "create" -> create(sender, args) "disband" -> disband(sender) "invite" -> invite(sender, args) "accept" -> accept(sender, args) "deny" -> deny(sender, args) "kick" -> kick(sender, args) "promote" -> promote(sender, args) "demote" -> demote(sender, args) "leave" -> leave(sender) "info" -> info(sender, args) "deposit" -> deposit(sender, args) "withdraw" -> withdraw(sender, args) "sethome" -> setHome(sender) "home" -> home(sender) "pvp" -> pvp(sender) "gui", "menu" -> openGui(sender) "list" -> list(sender) "chat", "c" -> chat(sender, args) "help" -> help(sender) "setdesc" -> setDesc(sender, args) "vault" -> openVault(sender) "perks" -> openPerks(sender) "quests" -> openQuests(sender) "diplomacy", "diplo" -> openDiplomacy(sender) "wars", "war" -> openWars(sender) "audit", "log" -> openAudit(sender) "banner" -> openBanner(sender) else -> openGui(sender) } return true } private fun openGui(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) if (guild == null) { if (plugin.bedrockUtil.isBedrockPlayer(player) && plugin.bedrockFormManager.isAvailable()) { plugin.bedrockFormManager.openBrowseGuilds(player) return } BrowseGuildsGUI(plugin).open(player) return } if (plugin.bedrockUtil.isBedrockPlayer(player) && plugin.bedrockFormManager.isAvailable()) { plugin.bedrockFormManager.openMainMenu(player) return } MainGuildGUI(plugin, guild).open(player) } private fun openVault(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } VaultGUI(plugin, guild).open(player) } private fun openPerks(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } PerkTreeGUI(plugin, guild).open(player) } private fun openQuests(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } QuestGUI(plugin, guild).open(player) } private fun openDiplomacy(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } DiplomacyGUI(plugin, guild).open(player) } private fun openWars(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } WarGUI(plugin, guild).open(player) } private fun openAudit(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } AuditGUI(plugin, guild).open(player) } private fun openBanner(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (!guild.hasPermission(player.uniqueId, GuildPermission.SET_BANNER, plugin.permissionManager)) { plugin.messageManager.send(player, "errors.no-guild-permission"); return } BannerDesignerGUI(plugin, guild).open(player) } private fun create(player: Player, args: Array) { if (!player.hasPermission("guildmaster.create")) { plugin.messageManager.send(player, "errors.no-permission") return } if (plugin.guildManager.getGuildOf(player.uniqueId) != null) { plugin.messageManager.send(player, "errors.already-in-guild") return } if (args.size < 3) { plugin.messageManager.sendRaw(player, "&cUsage: /guild create ") return } val name = args[1] val tag = args[2] val minName = plugin.config.getInt("guild.min-name-length", 3) val maxName = plugin.config.getInt("guild.max-name-length", 16) val minTag = plugin.config.getInt("guild.min-tag-length", 2) val maxTag = plugin.config.getInt("guild.max-tag-length", 5) if (!ValidationUtil.isValidName(name, minName, maxName)) { plugin.messageManager.send(player, "errors.invalid-name") return } if (!ValidationUtil.isValidTag(tag, minTag, maxTag)) { plugin.messageManager.send(player, "errors.invalid-tag") return } if (plugin.guildManager.getGuildByName(name) != null) { plugin.messageManager.send(player, "errors.name-taken") return } if (plugin.guildManager.getGuildByTag(tag) != null) { plugin.messageManager.send(player, "errors.tag-taken") return } val cost = plugin.config.getDouble("guild.creation-cost", 1000.0) if (cost > 0 && !plugin.economyManager.has(player, cost)) { plugin.messageManager.send(player, "errors.insufficient-funds") return } if (cost > 0 && !plugin.economyManager.withdraw(player, cost)) { plugin.messageManager.send(player, "errors.insufficient-funds") return } val guild = plugin.guildManager.createGuild(name, tag, player) if (guild == null) { plugin.messageManager.sendRaw(player, "&cFailed to create guild.") if (cost > 0) plugin.economyManager.deposit(player, cost) return } plugin.messageManager.send(player, "success.guild-created", "name" to name) } private fun disband(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (!guild.isOwner(player.uniqueId)) { plugin.messageManager.send(player, "errors.not-owner") return } for (uuid in guild.members.keys) { val p = Bukkit.getPlayer(uuid) ?: continue plugin.messageManager.send(p, "success.guild-disbanded") } plugin.guildManager.deleteGuild(guild) } private fun invite(player: Player, args: Array) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (!guild.hasPermission(player.uniqueId, GuildPermission.INVITE, plugin.permissionManager)) { plugin.messageManager.send(player, "errors.no-guild-permission") return } if (args.size < 2) { plugin.messageManager.sendRaw(player, "&cUsage: /guild invite ") return } val target = Bukkit.getPlayerExact(args[1]) ?: run { plugin.messageManager.send(player, "errors.player-not-found"); return } if (plugin.guildManager.getGuildOf(target.uniqueId) != null) { plugin.messageManager.send(player, "errors.already-in-guild") return } if (guild.memberCount() >= plugin.guildManager.memberLimit(guild)) { plugin.messageManager.send(player, "errors.member-limit-reached") return } if (!plugin.inviteManager.invite(guild, target.uniqueId, player.uniqueId)) { plugin.messageManager.sendRaw(player, "&cAlready invited.") return } plugin.messageManager.send(player, "success.player-invited", "player" to target.name) plugin.messageManager.send(target, "success.invite-received", "guild" to guild.name) } private fun accept(player: Player, args: Array) { if (plugin.guildManager.getGuildOf(player.uniqueId) != null) { plugin.messageManager.send(player, "errors.already-in-guild") return } if (args.size < 2) { plugin.messageManager.sendRaw(player, "&cUsage: /guild accept ") return } val guild = plugin.guildManager.getGuildByName(args[1]) ?: run { plugin.messageManager.send(player, "errors.guild-not-found"); return } if (!plugin.inviteManager.consumeInvite(player.uniqueId, guild.id)) { plugin.messageManager.send(player, "errors.no-pending-invite") return } if (guild.memberCount() >= plugin.guildManager.memberLimit(guild)) { plugin.messageManager.send(player, "errors.member-limit-reached") return } if (!plugin.guildManager.addPlayerToGuild(guild, player)) { plugin.messageManager.send(player, "errors.already-in-guild") return } plugin.messageManager.send(player, "success.invite-accepted", "guild" to guild.name) for (uuid in guild.members.keys) { if (uuid == player.uniqueId) continue val p = Bukkit.getPlayer(uuid) ?: continue plugin.messageManager.send(p, "info.guild-joined", "player" to player.name) } } private fun deny(player: Player, args: Array) { if (args.size < 2) { plugin.messageManager.sendRaw(player, "&cUsage: /guild deny ") return } val guild = plugin.guildManager.getGuildByName(args[1]) ?: run { plugin.messageManager.send(player, "errors.guild-not-found"); return } if (!plugin.inviteManager.hasInvite(player.uniqueId, guild.id)) { plugin.messageManager.send(player, "errors.no-pending-invite") return } plugin.inviteManager.removeInvite(player.uniqueId, guild.id) plugin.messageManager.send(player, "success.invite-denied", "guild" to guild.name) } private fun kick(player: Player, args: Array) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (!guild.hasPermission(player.uniqueId, GuildPermission.KICK, plugin.permissionManager)) { plugin.messageManager.send(player, "errors.no-guild-permission") return } if (args.size < 2) { plugin.messageManager.sendRaw(player, "&cUsage: /guild kick ") return } val targetName = args[1] val targetMember = guild.members.values.firstOrNull { it.name.equals(targetName, true) } ?: run { plugin.messageManager.send(player, "errors.player-not-found"); return } if (targetMember.uuid == player.uniqueId) { plugin.messageManager.send(player, "errors.cannot-kick-self"); return } if (targetMember.role == GuildRole.OWNER) { plugin.messageManager.send(player, "errors.cannot-kick-owner"); return } val actorRole = guild.getMember(player.uniqueId)?.role ?: return if (!guild.isOwner(player.uniqueId) && targetMember.role.weight >= actorRole.weight) { plugin.messageManager.send(player, "errors.no-guild-permission"); return } plugin.guildManager.removePlayerFromGuild(guild, targetMember.uuid) guild.auditLog.add(player.uniqueId, player.name, "MEMBER_KICK", "Kicked ${targetMember.name}") plugin.messageManager.send(player, "success.player-kicked", "player" to targetMember.name) val tp = Bukkit.getPlayer(targetMember.uuid) if (tp != null) plugin.messageManager.sendRaw(tp, "&cYou were kicked from the guild.") for (uuid in guild.members.keys) { val p = Bukkit.getPlayer(uuid) ?: continue plugin.messageManager.send(p, "info.guild-kicked", "player" to targetMember.name) } } private fun promote(player: Player, args: Array) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (!guild.hasPermission(player.uniqueId, GuildPermission.PROMOTE, plugin.permissionManager)) { plugin.messageManager.send(player, "errors.no-guild-permission"); return } if (args.size < 2) { plugin.messageManager.sendRaw(player, "&cUsage: /guild promote "); return } val targetMember = guild.members.values.firstOrNull { it.name.equals(args[1], true) } ?: run { plugin.messageManager.send(player, "errors.player-not-found"); return } val actorRole = guild.getMember(player.uniqueId)?.role ?: return if (targetMember.role == GuildRole.OWNER) { plugin.messageManager.send(player, "errors.cannot-promote-owner"); return } val nextRole = when (targetMember.role) { GuildRole.MEMBER -> GuildRole.OFFICER GuildRole.OFFICER -> GuildRole.CO_OWNER else -> { plugin.messageManager.sendRaw(player, "&cThat player cannot be promoted further."); return } } if (!guild.isOwner(player.uniqueId) && nextRole.weight >= actorRole.weight) { plugin.messageManager.send(player, "errors.no-guild-permission"); return } targetMember.role = nextRole guild.auditLog.add(player.uniqueId, player.name, "PROMOTE", "Promoted ${targetMember.name} to ${nextRole.displayName}") plugin.guildManager.saveGuild(guild) plugin.messageManager.send( player, "success.player-promoted", "player" to targetMember.name, "role" to nextRole.displayName ) } private fun demote(player: Player, args: Array) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (!guild.hasPermission(player.uniqueId, GuildPermission.DEMOTE, plugin.permissionManager)) { plugin.messageManager.send(player, "errors.no-guild-permission"); return } if (args.size < 2) { plugin.messageManager.sendRaw(player, "&cUsage: /guild demote "); return } val targetMember = guild.members.values.firstOrNull { it.name.equals(args[1], true) } ?: run { plugin.messageManager.send(player, "errors.player-not-found"); return } val actorRole = guild.getMember(player.uniqueId)?.role ?: return val prevRole = when (targetMember.role) { GuildRole.CO_OWNER -> GuildRole.OFFICER GuildRole.OFFICER -> GuildRole.MEMBER else -> { plugin.messageManager.sendRaw(player, "&cThat player cannot be demoted further."); return } } if (!guild.isOwner(player.uniqueId) && targetMember.role.weight >= actorRole.weight) { plugin.messageManager.send(player, "errors.no-guild-permission"); return } targetMember.role = prevRole guild.auditLog.add(player.uniqueId, player.name, "DEMOTE", "Demoted ${targetMember.name} to ${prevRole.displayName}") plugin.guildManager.saveGuild(guild) plugin.messageManager.send( player, "success.player-demoted", "player" to targetMember.name, "role" to prevRole.displayName ) } private fun leave(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (guild.isOwner(player.uniqueId)) { plugin.messageManager.sendRaw(player, "&cAs the owner, use /guild disband instead."); return } plugin.guildManager.removePlayerFromGuild(guild, player.uniqueId) plugin.messageManager.send(player, "success.player-left") for (uuid in guild.members.keys) { val p = Bukkit.getPlayer(uuid) ?: continue plugin.messageManager.send(p, "info.guild-left", "player" to player.name) } } private fun info(player: Player, args: Array) { val guild: Guild? = if (args.size >= 2) { plugin.guildManager.getGuildByName(args[1]) } else { plugin.guildManager.getGuildOf(player.uniqueId) } if (guild == null) { plugin.messageManager.send(player, "errors.guild-not-found"); return } sendInfo(player, guild) } private fun sendInfo(player: Player, guild: Guild) { val owner = Bukkit.getOfflinePlayer(guild.ownerUuid).name ?: "Unknown" plugin.messageManager.sendRaw(player, "&6=== ${guild.name} [${guild.tag}] ===") plugin.messageManager.sendRaw(player, "&7Owner: &e$owner") plugin.messageManager.sendRaw(player, "&7Level: &e${guild.level}") plugin.messageManager.sendRaw(player, "&7Members: &e${guild.memberCount()}/${plugin.guildManager.memberLimit(guild)}") plugin.messageManager.sendRaw(player, "&7Balance: &e$${"%.2f".format(guild.balance)}") plugin.messageManager.sendRaw(player, "&7PvP: &e${if (guild.pvpEnabled) "ON" else "OFF"}") plugin.messageManager.sendRaw(player, "&7Description: &f${guild.description}") } private fun deposit(player: Player, args: Array) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (args.size < 2) { plugin.messageManager.sendRaw(player, "&cUsage: /guild deposit "); return } val amount = ValidationUtil.parseAmount(args[1]) ?: run { plugin.messageManager.send(player, "errors.invalid-amount"); return } val bonus = plugin.perkManager.depositBonus(guild) val credited = amount * (1.0 + bonus) val max = plugin.config.getDouble("economy.max-bank-balance", 10000000.0) if (guild.balance + credited > max) { plugin.messageManager.sendRaw(player, "&cThe guild bank cannot hold more."); return } if (!plugin.economyManager.has(player, amount)) { plugin.messageManager.send(player, "errors.insufficient-funds"); return } if (!plugin.economyManager.withdraw(player, amount)) { plugin.messageManager.send(player, "errors.insufficient-funds"); return } guild.balance += credited guild.auditLog.add(player.uniqueId, player.name, "DEPOSIT", "+$${"%.2f".format(credited)}") plugin.questManager.progressEvent(guild, com.guildmaster.quests.QuestType.DEPOSIT, "*", amount.toInt()) plugin.guildManager.saveGuild(guild) plugin.messageManager.send(player, "success.deposited", "amount" to "%.2f".format(credited)) } private fun withdraw(player: Player, args: Array) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (!guild.hasPermission(player.uniqueId, GuildPermission.WITHDRAW, plugin.permissionManager)) { plugin.messageManager.send(player, "errors.no-guild-permission"); return } if (args.size < 2) { plugin.messageManager.sendRaw(player, "&cUsage: /guild withdraw "); return } val amount = ValidationUtil.parseAmount(args[1]) ?: run { plugin.messageManager.send(player, "errors.invalid-amount"); return } if (guild.balance < amount) { plugin.messageManager.send(player, "errors.insufficient-guild-funds"); return } guild.balance -= amount plugin.economyManager.deposit(player, amount) guild.auditLog.add(player.uniqueId, player.name, "WITHDRAW", "-$${"%.2f".format(amount)}") plugin.guildManager.saveGuild(guild) plugin.messageManager.send(player, "success.withdrawn", "amount" to "%.2f".format(amount)) } private fun setHome(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (!guild.hasPermission(player.uniqueId, GuildPermission.SET_HOME, plugin.permissionManager)) { plugin.messageManager.send(player, "errors.no-guild-permission"); return } guild.home = player.location guild.auditLog.add(player.uniqueId, player.name, "HOME_SET", "Set guild home") plugin.guildManager.saveGuild(guild) plugin.messageManager.send(player, "success.home-set") } private fun home(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } val home = guild.home ?: run { plugin.messageManager.send(player, "errors.home-not-set"); return } if (plugin.teleportManager.isOnCooldown(player.uniqueId)) { plugin.messageManager.send( player, "errors.home-cooldown", "seconds" to plugin.teleportManager.cooldownRemaining(player.uniqueId).toString() ) return } plugin.teleportManager.startTeleport(player, home, guild) } private fun pvp(player: Player) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (!guild.hasPermission(player.uniqueId, GuildPermission.TOGGLE_PVP, plugin.permissionManager)) { plugin.messageManager.send(player, "errors.no-guild-permission"); return } guild.pvpEnabled = !guild.pvpEnabled plugin.guildManager.saveGuild(guild) plugin.messageManager.send( player, "success.pvp-toggled", "state" to if (guild.pvpEnabled) "ON" else "OFF" ) } private fun list(player: Player) { val guilds = plugin.guildManager.getAllGuilds().sortedByDescending { it.level } plugin.messageManager.sendRaw(player, "&6=== Guilds (${guilds.size}) ===") for (g in guilds.take(20)) { plugin.messageManager.sendRaw( player, "&e${g.name} &7[&b${g.tag}&7] &7- Lv&e${g.level} &7Members: &e${g.memberCount()}" ) } } private fun chat(player: Player, args: Array) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (args.size < 2) { plugin.messageManager.sendRaw(player, "&cUsage: /guild chat "); return } val msg = args.drop(1).joinToString(" ") val formatted = plugin.messageManager.color( "&8[&6Guild&8] &e${player.name}&7: &f$msg" ) for (uuid in guild.members.keys) { val p = Bukkit.getPlayer(uuid) ?: continue p.sendMessage(formatted) } } private fun setDesc(player: Player, args: Array) { val guild = plugin.guildManager.getGuildOf(player.uniqueId) ?: run { plugin.messageManager.send(player, "errors.not-in-guild"); return } if (!guild.hasPermission(player.uniqueId, GuildPermission.SET_DESCRIPTION, plugin.permissionManager)) { plugin.messageManager.send(player, "errors.no-guild-permission"); return } if (args.size < 2) { plugin.messageManager.sendRaw(player, "&cUsage: /guild setdesc "); return } val desc = args.drop(1).joinToString(" ").take(64) guild.description = desc plugin.guildManager.saveGuild(guild) plugin.messageManager.sendRaw(player, "&aDescription updated.") } private fun help(player: Player) { val lines = listOf( "&6=== GuildMaster Commands ===", "&e/guild create &7- Create a guild", "&e/guild disband &7- Disband your guild (owner)", "&e/guild invite &7- Invite a player", "&e/guild accept &7- Accept invite", "&e/guild deny &7- Deny invite", "&e/guild kick &7- Kick a member", "&e/guild promote/demote &7- Manage roles", "&e/guild leave &7- Leave your guild", "&e/guild info [guild] &7- View guild info", "&e/guild deposit/withdraw &7- Bank ops", "&e/guild sethome / home &7- Home management", "&e/guild pvp &7- Toggle guild PvP", "&e/guild chat &7- Guild chat (or @g )", "&e/guild setdesc &7- Set description", "&e/guild list &7- List all guilds", "&e/guild gui &7- Open guild menu", "&6--- Advanced ---", "&e/guild vault &7- Open shared item vault", "&e/guild perks &7- View perk tree", "&e/guild quests &7- View daily quests", "&e/guild diplomacy &7- Manage relations", "&e/guild wars &7- Active wars / declare", "&e/guild audit &7- View audit log", "&e/guild banner &7- Edit guild banner" ) for (line in lines) plugin.messageManager.sendRaw(player, line) } override fun onTabComplete( sender: CommandSender, command: Command, alias: String, args: Array ): List { if (args.size == 1) { val sub = listOf( "create", "disband", "invite", "accept", "deny", "kick", "promote", "demote", "leave", "info", "deposit", "withdraw", "sethome", "home", "pvp", "gui", "list", "chat", "help", "setdesc", "vault", "perks", "quests", "diplomacy", "wars", "audit", "banner" ) return sub.filter { it.startsWith(args[0].lowercase()) } } if (args.size == 2) { when (args[0].lowercase()) { "invite" -> return Bukkit.getOnlinePlayers().map { it.name }.filter { it.startsWith(args[1], true) } "info", "accept", "deny" -> return plugin.guildManager.getAllGuilds() .map { it.name } .filter { it.startsWith(args[1], true) } "kick", "promote", "demote" -> { if (sender is Player) { val guild = plugin.guildManager.getGuildOf(sender.uniqueId) ?: return emptyList() return guild.members.values.map { it.name }.filter { it.startsWith(args[1], true) } } } } } return emptyList() } }