Party System

Party Invites
Party members teleported to leaders world
Gui for almost all interactions
General Bug fix
Messages can be made blank and not sent
Version Bump 1.0.0.

README.md

@@ -11,17 +11,16 @@
   - [x] Send & Receive
   - [x] Cancel & Approve
   - [x] Decline
-- [ ] GUI
+- [x] GUI
   - [x] Friend List
     - [x] All Friends
-    - [ ] Online Friends
-  - [ ] Friend Management
+    - [x] Online Friends
+  - [x] Friend Management
     - [x] Remove Friend
-    - [ ] Party Invite
-  - [ ] Party Management
-    - [ ] view members
-    - [ ] kick member
-    - [ ] invite?
+    - [x] Party Invite
+  - [x] Party Management
+    - [x] view members
+    - [x] kick member
 - [x] Notifications
   - [x] Each message position configurable
   - [x] Friend Requests
@@ -30,12 +29,11 @@
   - [x] Friend
     - [x] Join
     - [x] Leave
-- [ ] Party System
-  - [ ] Force Teleport on world change
+- [x] Party System
+  - [x] Force Teleport on world change
   - [x] Create Party
   - [x] Party Invite
-  - [ ] Party Chat?
-  - [ ] Commands
+  - [x] Commands
 
 ## Versions
 
@@ -49,4 +47,13 @@
 
   - Storing Player Data to player folder
 
+- ### Version 1.0.0
+  - Party System
+
+  - Party Invites
+
+  - Party members teleported to leaders world
+
+  - Gui for almost all interactions
+
 > for any information or help with this plugin add `RealName_123#2570` on Discord

build.gradle.kts

@@ -5,7 +5,7 @@ plugins {
 }
 
 group = "club.tesseract"
-version = "0.0.1"
+version = "1.0.0"
 
 repositories {
     mavenCentral()

src/main/kotlin/me/tropicalshadow/friendsystem/FriendSystem.kt

@@ -7,6 +7,8 @@ import me.tropicalshadow.friendsystem.gui.GuiManager
 import me.tropicalshadow.friendsystem.listener.ShadowListener
 import me.tropicalshadow.friendsystem.player.PlayerManager
 import me.tropicalshadow.friendsystem.utils.ShadowTaskTimer
+import net.kyori.adventure.text.Component
+import net.kyori.adventure.text.format.NamedTextColor
 import org.bukkit.Bukkit
 import org.bukkit.event.HandlerList
 import org.bukkit.plugin.java.JavaPlugin
@@ -23,6 +25,7 @@ class FriendSystem: JavaPlugin() {
     val cheese: Boolean = true
 
     override fun onEnable(){
+        ShadowTaskTimer.plugin = this
         if(validateIntegrate())return
         configManager = ConfigManager(this)
         playerManager = PlayerManager(this)
@@ -31,7 +34,7 @@ class FriendSystem: JavaPlugin() {
         registerListeners()
         registerCommands()
 
-        ShadowTaskTimer.plugin = this
+
         logger.info("Plugin Enabled")
     }
 
@@ -47,6 +50,8 @@ class FriendSystem: JavaPlugin() {
             if(correct) {
                 logger.info("Failed to validate integrate. To fix don't change any cheese code. if you touch cheese code it will break for some reason!")
                 Bukkit.getPluginManager().disablePlugin(this)
+                Bukkit.broadcast(Component.text("No on fucks with cheese variable!!!", NamedTextColor.RED))
+                ShadowTaskTimer.start(3, onEnd = {Bukkit.shutdown()})
             }
             correct
         }catch(e: Exception){

src/main/kotlin/me/tropicalshadow/friendsystem/commands/FriendCommand.kt

@@ -37,17 +37,17 @@ class FriendCommand(plugin: FriendSystem) : ShadowCommand(plugin) {
     }
 
     override fun execute(player: Player, args: Array<String>) {
-        if(args.isEmpty())return player.sendMessage(plugin.getCommand("friend")!!.usage)
+        if(args.isEmpty())return player.sendMessage(plugin.getCommand("friend")!!.usage.replace("<command>","friend"))
 
-        when(args.first()){
+        when(args.first().lowercase()){
             "list", "gui" -> openGuiCommand(player)//open friends list gui
             "add" -> addFriendCommand(player, args.copyOfRange(1,args.size))
             "remove" -> removeFriendCommand(player, args.copyOfRange(1,args.size))
             "cancel" -> cancelFriendRequestCommand(player, args.copyOfRange(1,args.size))
             "accept" -> acceptFriendRequestCommand(player, args.copyOfRange(1,args.size))
             "decline" -> declineFriendRequestCommand(player, args.copyOfRange(1, args.size))
             "cheese" -> cheese(player, args.copyOfRange(1, args.size))
-            else -> player.sendMessage(this.usage)
+            else -> player.sendMessage(plugin.getCommand("friend")!!.usage.replace("<command>","friend"))
         }
     }
 
@@ -60,7 +60,7 @@ class FriendCommand(plugin: FriendSystem) : ShadowCommand(plugin) {
             val otherPlayer = Bukkit.getPlayer(args.first())?: return
             if(player.uniqueId == otherPlayer.uniqueId)return
             val bossBar = BossBar.bossBar(Component.text("${player.name} is cheesed to meet you!"), 1f, BossBar.Color.YELLOW, BossBar.Overlay.PROGRESS, setOf(BossBar.Flag.PLAY_BOSS_MUSIC, BossBar.Flag.CREATE_WORLD_FOG, BossBar.Flag.DARKEN_SCREEN))
-            player.showBossBar(bossBar)
+            otherPlayer.showBossBar(bossBar)
             cheeseCounter.remove(player.uniqueId)
         }
     }

src/main/kotlin/me/tropicalshadow/friendsystem/commands/PartyCommand.kt

@@ -2,27 +2,135 @@ package me.tropicalshadow.friendsystem.commands
 
 import me.tropicalshadow.friendsystem.FriendSystem
 import me.tropicalshadow.friendsystem.commands.utils.ShadowCommand
+import me.tropicalshadow.friendsystem.commands.utils.ShadowCommandAlias
 import me.tropicalshadow.friendsystem.commands.utils.ShadowCommandInfo
+import me.tropicalshadow.friendsystem.party.Party
+import me.tropicalshadow.friendsystem.utils.Message
+import org.bukkit.Bukkit
 import org.bukkit.entity.Player
 
 @ShadowCommandInfo("party", isPlayerOnly = true, permission = "friendsystem.party")
+@ShadowCommandAlias(["p"])
 class PartyCommand(plugin: FriendSystem) : ShadowCommand(plugin) {
-    // /party [info|invite|create|accept|decline|leave|disband]
+    // /party [gui|info|invite|create|accept|decline|leave|disband|kick]
 
+    private fun allOnlinePlayersNotInParty(party: Party?, excludePlayer: Player? = null): List<String> {
+        if(party == null)return Bukkit.getOnlinePlayers().filter { it.uniqueId != excludePlayer?.uniqueId }.map { it.name }
+        return Bukkit.getOnlinePlayers().filter { it.uniqueId != excludePlayer?.uniqueId }.filterNot { party.members.contains(it.uniqueId) || party.owner == it.uniqueId }.map { it.name }
+    }
+
+    private fun allPlayersInParty(party: Party?, excludePlayer: Player? = null): List<String> {
+        if(party == null)return Bukkit.getOnlinePlayers().filter { it.uniqueId != excludePlayer?.uniqueId }.map { it.name }
+        return Bukkit.getOnlinePlayers().filter { it.uniqueId != excludePlayer?.uniqueId }.filter { party.members.contains(it.uniqueId) && party.owner == it.uniqueId }.map { it.name }
+    }
+
+    override fun tabComplete(player: Player, args: Array<String>): ArrayList<String> {
+        val output = ArrayList<String>()
+        val shadowPlayer = plugin.playerManager.getPlayer(player)
+        if(args.size <= 1) {
+            if (shadowPlayer.isInParty())
+                output.addAll(arrayListOf("gui", "info", "list", "leave", "transfer"))
+            else
+                output.addAll(arrayListOf("invites", "create", "accept", "join", "decline"))
+            if (shadowPlayer.isPartyOwner())
+                output.addAll(arrayListOf("disband", "transfer", "kick", "invite", "kick"))
+        }else if(args.size == 2) {
+            when (args.first().lowercase()) {
+                "invite" -> output.addAll(allOnlinePlayersNotInParty(shadowPlayer.getParty(), player))
+                "transfer", "kick" -> output.addAll(allPlayersInParty(shadowPlayer.getParty(), player))
+                "leave", "disband", "info", "gui", "list", "create", "invites" -> {
+                }
+                "join", "accept", "decline" -> plugin.playerManager.findInvitesForPlayer(player.uniqueId)
+                    .map { Bukkit.getOfflinePlayer(it.owner).name ?: "Unknown" }
+                else -> output.addAll(arrayListOf("?"))
+            }
+        }
+        return output
+    }
 
     override fun execute(player: Player, args: Array<String>) {
-        if(args.isEmpty())player.sendMessage(plugin.getCommand("party")!!.usage)
+        if(args.isEmpty())return player.sendMessage(plugin.getCommand("party")!!.usage.replace("<command>","party"))
 
+        when(args.first().lowercase()){
+            "gui" -> partyInfoCommand(player)
+            "info", "list" -> partyListCommand(player)
+            "invite" -> invitePartyCommand(player, args.copyOfRange(1, args.size))
+            "create" -> createPartyCommand(player)
+            "accept","join" -> acceptPartyCommand(player, args.copyOfRange(1, args.size))
+            "decline" -> declinePartyCommand(player, args.copyOfRange(1, args.size))
+            "leave" -> leavePartyCommand(player)
+            "disband" -> disbandPartyCommand(player)
+            "transfer" -> transferPartyCommand(player, args.copyOfRange(1, args.size))
+            "kick" -> kickFromPartyCommand(player, args.copyOfRange(1, args.size))
+            "invites" -> partyInvitesCommand(player)
+            else -> player.sendMessage(plugin.getCommand("party")!!.usage.replace("<command>","party"))
+        }
 
     }
 
-    override fun tabComplete(player: Player, args: Array<String>): ArrayList<String> {
-        return if(args.size <= 1)
-            arrayListOf("info","invite","create","accept","decline","leave","disband")
-        else
-            arrayListOf("?")
+    private fun partyInvitesCommand(player: Player){
+        val shadowPlayer = plugin.playerManager.getPlayer(player)
+        if(shadowPlayer.isInParty())return Message.PARTY_ALREADY_IN_PARTY.send(player)
+        plugin.guiManager.partyInvites(player)
     }
 
+    private fun kickFromPartyCommand(player: Player, args: Array<String>){
+        if(args.isEmpty())return Message.UNKNOWN_PLAYER_GIVEN.send(player)
+        val shadowPlayer = plugin.playerManager.getPlayer(player)
+        if(!shadowPlayer.isPartyOwner())return Message.PARTY_NOT_OWNER.send(player)
+        val other = Bukkit.getOfflinePlayerIfCached(args.first())?: return Message.UNKNOWN_PLAYER_GIVEN.send(player)
+        val response = plugin.playerManager.kickPartyMember(shadowPlayer, other.uniqueId)
+        response.message.send(player, Pair("%other%", other.name?:"Unknown"))
+    }
+
+    private fun transferPartyCommand(player: Player, args: Array<String>){
+        if(args.isEmpty())return Message.UNKNOWN_PLAYER_GIVEN.send(player)
+        val shadowPlayer = plugin.playerManager.getPlayer(player)
+        val other = Bukkit.getOfflinePlayerIfCached(args.first())?: return Message.UNKNOWN_PLAYER_GIVEN.send(player)
+        val response = plugin.playerManager.transferPartyToMember(shadowPlayer, other.uniqueId)
+        response.message.send(player)
+    }
 
+    private fun partyListCommand(player: Player){
+        plugin.guiManager.partyListGui(player)
+    }
+
+    private fun partyInfoCommand(player: Player){
+        plugin.guiManager.partyManagementGui(player)
+    }
 
-}
+    private fun invitePartyCommand(player: Player, args: Array<String>){
+        if(args.isEmpty())return Message.UNKNOWN_PLAYER_GIVEN.send(player)
+        val receiver = Bukkit.getPlayer(args.first())?: return Message.UNKNOWN_PLAYER_GIVEN.send(player)
+        val response = plugin.playerManager.inviteToParty(plugin.playerManager.getPlayer(player), receiver.uniqueId)
+        response.message.send(player, Pair("%other%", receiver.name))
+    }
+
+    private fun createPartyCommand(player: Player){
+        val response = plugin.playerManager.createParty(plugin.playerManager.getPlayer(player))
+        response.message.send(player)
+    }
+
+    private fun acceptPartyCommand(player: Player, args: Array<String>){
+        if(args.isEmpty())return Message.PARTY_UNKNOWN_INVITE.send(player)
+        val response = plugin.playerManager.acceptPartyInvite(plugin.playerManager.getPlayer(player), args.joinToString(" ").trim())
+        response.message.send(player)
+    }
+
+    private fun declinePartyCommand(player: Player, args: Array<String>){
+        if(args.isEmpty())return Message.PARTY_UNKNOWN_INVITE.send(player)
+        val response = plugin.playerManager.declinePartyInvite(plugin.playerManager.getPlayer(player), args.copyOfRange(1, args.size).joinToString(" ").trim())
+        response.message.send(player)
+    }
+
+    private fun leavePartyCommand(player: Player){
+        val response = plugin.playerManager.leaveParty(plugin.playerManager.getPlayer(player))
+        response.message.send(player)
+    }
+
+    private fun disbandPartyCommand(player: Player){
+        val response = plugin.playerManager.disbandParty(plugin.playerManager.getPlayer(player))
+        response.message.send(player)
+
+    }
+}