feat: updated game systems

src/main/kotlin/xyz/atnrch/dragon/EnumHelper.kt

@@ -0,0 +1,5 @@
+package xyz.atnrch.dragon
+
+inline fun <reified T : Enum<T>> enumContains(name: String): Boolean {
+    return enumValues<T>().any { it.name == name }
+}

src/main/kotlin/xyz/atnrch/dragon/GameState.kt

@@ -2,7 +2,7 @@ package xyz.atnrch.dragon
 
 enum class GameState {
     WAITING,
-    NO_DAMAGE_PERIOD,
+    LAUNCH,
     GRACE_PERIOD,
     GAME
 }

src/main/kotlin/xyz/atnrch/dragon/RunnerDragon.kt

@@ -3,11 +3,16 @@ package xyz.atnrch.dragon
 import org.apache.commons.io.FileUtils
 import org.bukkit.*
 import org.bukkit.plugin.java.JavaPlugin
+import org.bukkit.scheduler.BukkitTask
 import xyz.atnrch.dragon.commands.MainCommand
 import xyz.atnrch.dragon.event.*
+import xyz.atnrch.dragon.event.end.EnderDragonListener
 import xyz.atnrch.dragon.event.waiting.WaitingListener
 import xyz.atnrch.dragon.player.PlayerManager
 import xyz.atnrch.dragon.schematic.SchematicLoader
+import xyz.atnrch.dragon.tasks.GracePeriodTask
+import xyz.atnrch.dragon.tasks.TimerTask
+import xyz.atnrch.dragon.teams.Team
 import xyz.atnrch.dragon.teams.TeamManager
 import xyz.atnrch.dragon.world.WorldManager
 import java.io.File
@@ -22,18 +27,21 @@ class RunnerDragon : JavaPlugin() {
         val TITLE_MSG =
             "${ChatColor.WHITE}[${ChatColor.LIGHT_PURPLE}${ChatColor.BOLD}RUNNER${ChatColor.DARK_PURPLE}${ChatColor.BOLD}DRAGON${ChatColor.WHITE}]"
 
+        var STATE = GameState.GAME
+
         const val TEAM_MAX_SIZE = 2
         const val NUMBER_OF_TEAMS = 6
-        var TEAM_LOCK = false
+        var DEAD_COWS = 0
+        var TIME = 0
+        var SPAWN_HEIGHT = 300
 
+        var TEAM_LOCK = false
         var NETHER_PORTAL_ENTERED = false
         var END_PORTAL_ENTERED = false
-        var STATE = GameState.GAME
+        var TIMER_TASK: BukkitTask? = null
-        var DEAD_COWS = 0
+        var GRACE_PERIOD_TASK: BukkitTask? = null
 
-        var TIME = 0
+        lateinit var SPAWN: Location
-
-        var SPAWN_HEIGHT = 300
         lateinit var WORLD: World
         lateinit var LOBBY_SCHEMATIC: SchematicLoader
     }
@@ -58,47 +66,90 @@ class RunnerDragon : JavaPlugin() {
 
         logger.info("Création d'un nouveau monde...")
         WORLD = Bukkit.createWorld(creator)!!
+        worldManager = WorldManager(WORLD)
 
-        logger.info("Génération du spawn...")
+        playerManager = PlayerManager()
-        LOBBY_SCHEMATIC = SchematicLoader(File("./lobby1.schem"), WORLD)
+        teamManager = TeamManager(this)
-        if (LOBBY_SCHEMATIC.spawnSchematicAt(0, SPAWN_HEIGHT, 0)) {
-            playerManager = PlayerManager()
-            teamManager = TeamManager(this)
-            worldManager = WorldManager(WORLD)
 
-            logger.info("Création des équipes...")
+        server.pluginManager.registerEvents(DimensionEntranceListener(), this)
-            teamManager.createTeams(NUMBER_OF_TEAMS)
+        server.pluginManager.registerEvents(EnderDragonListener(), this)
+        server.pluginManager.registerEvents(PlayerJoinListener(), this)
+        server.pluginManager.registerEvents(PlayerQuitListener(), this)
+        server.pluginManager.registerEvents(PlayerRespawnListener(), this)
+        server.pluginManager.registerEvents(WaitingListener(), this)
+        server.pluginManager.registerEvents(EntityDeathListener(), this)
+        server.pluginManager.registerEvents(EntityDamageListener(), this)
+        getCommand("rd")!!.setExecutor(MainCommand())
 
-            server.pluginManager.registerEvents(DimensionEntranceListener(), this)
+        if (switchState(GameState.WAITING)) {
-            server.pluginManager.registerEvents(PlayerJoinListener(), this)
-            server.pluginManager.registerEvents(PlayerQuitListener(), this)
-            server.pluginManager.registerEvents(PlayerDeathListener(), this)
-            server.pluginManager.registerEvents(WaitingListener(), this)
-            server.pluginManager.registerEvents(EntityDeathListener(), this)
-            server.pluginManager.registerEvents(EntityDamageListener(), this)
-            getCommand("rd")!!.setExecutor(MainCommand())
-
-            switchState(GameState.WAITING)
             logger.info("Runner Dragon chargé avec succès.")
         } else {
-            logger.severe("le gros caca prout")
+            logger.severe("Runner Dragon a rencontré une erreur de chargement.")
         }
     }
 
-    fun switchState(state: GameState) {
+    fun switchState(state: GameState): Boolean {
         STATE = state
-        when (state) {
+        return when (state) {
             GameState.WAITING -> {
+                Bukkit.broadcastMessage("$TITLE_MSG ${ChatColor.GOLD}Mise à zéro du jeu !")
+                logger.info("(Re)Démarrage du jeu...")
+                Bukkit.getScheduler().cancelTasks(this)
+                TIMER_TASK?.taskId?.let { Bukkit.getScheduler().cancelTask(it) }
+                GRACE_PERIOD_TASK?.taskId?.let { Bukkit.getScheduler().cancelTask(it) }
+                //TIMER_TASK?.cancel()
+                //GRACE_PERIOD_TASK?.cancel()
+                TIME = 0
+                DEAD_COWS = 0
                 worldManager.applyWaitingRules()
+
+                logger.info("Génération du spawn...")
+                LOBBY_SCHEMATIC = SchematicLoader(File("./lobby1.schem"), WORLD)
+                val schematicSpawn = LOBBY_SCHEMATIC.spawnSchematicAt(0, SPAWN_HEIGHT, 0)
+                SPAWN = Location(WORLD, 0.0, SPAWN_HEIGHT.plus(2).toDouble(), 0.0, -180f, 0f)
+                WORLD.spawnLocation = SPAWN
+                Bukkit.unloadWorld("world", true)
+
+                logger.info("Création des équipes...")
+                teamManager.clean()
+                teamManager.createTeams(NUMBER_OF_TEAMS)
+
+                Bukkit.getOnlinePlayers().forEach {
+                    it.teleport(SPAWN)
+                    it.setBedSpawnLocation(SPAWN, true)
+                    playerManager.removePlayer(it.uniqueId)
+                    playerManager.addPlayer(it.uniqueId)
+                }
+
+                playerManager.getPlayers().forEach { (_, player) ->
+                    player.setTeam(Team.DEFAULT_TEAM)
+                    player.updateDisplayName()
+                    player.updateHeaderFooter()
+                    player.setTeamItem(true)
+                }
+                return schematicSpawn
             }
 
-            GameState.GRACE_PERIOD -> {
+            GameState.LAUNCH -> {
+                Bukkit.broadcastMessage("$TITLE_MSG ${ChatColor.GOLD}Lancement de la partie !")
+                LOBBY_SCHEMATIC.removeSchematic()
+                SPAWN = WORLD.spawnLocation
+                TIMER_TASK = TimerTask().runTaskTimer(instance, 0L, 20L)
+                GRACE_PERIOD_TASK = GracePeriodTask().runTaskTimer(instance, 0L, 20L)
                 playerManager.getPlayers().forEach { (_, player) ->
                     player.impulse101()
                 }
+                true
             }
 
-            GameState.GAME, GameState.NO_DAMAGE_PERIOD -> {}
+            GameState.GAME -> {
+                Bukkit.broadcastMessage("$TITLE_MSG ${ChatColor.GOLD}${ChatColor.ITALIC}PVP activé !")
+                true
+            }
+
+            else -> {
+                true
+            }
         }
     }
 }

src/main/kotlin/xyz/atnrch/dragon/commands/GameSubCommand.kt

@@ -2,18 +2,34 @@ package xyz.atnrch.dragon.commands
 
 import org.bukkit.Bukkit
 import org.bukkit.ChatColor
+import xyz.atnrch.dragon.GameState
 import xyz.atnrch.dragon.RunnerDragon
+import xyz.atnrch.dragon.enumContains
 import xyz.atnrch.dragon.player.DragonPlayer
 import xyz.atnrch.dragon.tasks.StartGameTask
 
 class GameSubCommand {
     fun run(sender: DragonPlayer, args: Array<String>) {
         if (args.isEmpty()) {
-            sender.sendMessage("${ChatColor.RED}Argument manquant: /rd game (start/state)")
+            sender.sendMessage("Argument manquant: /rd game (start/state)")
             return
         }
 
         when (args[0]) {
+            "state" -> {
+                if (args.size == 2) {
+                    if (enumContains<GameState>(args[1])) {
+                        val state = GameState.valueOf(args[1])
+                        RunnerDragon.instance.switchState(state)
+                        sender.sendMessage("${ChatColor.RED}État de jeu défini en: ${state.name}.")
+                    } else {
+                        sender.sendMessage("${ChatColor.RED}State invalide (WAITING/LAUNCH/GAME/END).")
+                    }
+                } else {
+                    sender.sendMessage("${ChatColor.RED}Argument manquant.")
+                }
+            }
+
             "start" -> {
                 sender.sendMessage("Démarrage de la partie.")
                 Bukkit.getOnlinePlayers().forEach { it.inventory.clear() }

src/main/kotlin/xyz/atnrch/dragon/commands/MainCommand.kt

@@ -1,5 +1,6 @@
 package xyz.atnrch.dragon.commands
 
+import org.bukkit.Bukkit
 import org.bukkit.ChatColor
 import org.bukkit.command.Command
 import org.bukkit.command.CommandExecutor
@@ -9,18 +10,30 @@ import xyz.atnrch.dragon.RunnerDragon
 
 class MainCommand : CommandExecutor {
     override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array<String>): Boolean {
-        if (args.isEmpty()) {
+        if (sender is Player) {
-            sender.sendMessage("${ChatColor.RED}Arguments invalides: /rd (teams/game)")
-            return true
-        }
-
-        if(sender is Player) {
             val player: Player = sender
             val dragonPlayer = RunnerDragon.instance.playerManager.getPlayer(player.uniqueId)
 
+            if (player.isOp.not()) {
+                dragonPlayer.sendMessage("Erreur: Status d'opérateur requis.")
+                return true
+            }
+
+            if (args.isEmpty()) {
+                dragonPlayer.sendMessage("Argument manquant: /rd (teams/game/say)")
+                return true
+            }
+
             when (args[0]) {
                 "game" -> GameSubCommand().run(dragonPlayer, args.drop(1).toTypedArray())
                 "teams" -> TeamsSubCommand().run(dragonPlayer, args.drop(1).toTypedArray())
+                "say" -> {
+                    Bukkit.broadcastMessage(
+                        "${RunnerDragon.TITLE_MSG} ${ChatColor.RED}${ChatColor.BOLD}(ANNONCE) ${ChatColor.RESET}${
+                            args.drop(1).joinToString(" ", "", "")
+                        }"
+                    )
+                }
             }
         }
         return true

src/main/kotlin/xyz/atnrch/dragon/commands/TeamsSubCommand.kt

@@ -3,17 +3,21 @@ package xyz.atnrch.dragon.commands
 import org.bukkit.Bukkit
 import org.bukkit.ChatColor
 import xyz.atnrch.dragon.RunnerDragon
+import xyz.atnrch.dragon.enumContains
 import xyz.atnrch.dragon.player.DragonPlayer
 
 class TeamsSubCommand {
     fun run(player: DragonPlayer, args: Array<String>) {
-        if (args.isEmpty() || args.size < 2) {
+        if (args.isEmpty()) {
             player.sendMessage(
                 """
                 ${ChatColor.LIGHT_PURPLE}Configuration des équipes:
                 ${ChatColor.DARK_GRAY}- ${ChatColor.GOLD}Status: ${if (RunnerDragon.TEAM_LOCK) "${ChatColor.RED}fermées" else "${ChatColor.GREEN}ouvertes${ChatColor.RESET}."}
                 ${ChatColor.DARK_GRAY}- ${ChatColor.GOLD}Nombre: ${ChatColor.AQUA}${RunnerDragon.NUMBER_OF_TEAMS}
                 ${ChatColor.DARK_GRAY}- ${ChatColor.GOLD}Capacité: ${ChatColor.AQUA}${RunnerDragon.TEAM_MAX_SIZE}
+                ${ChatColor.DARK_GRAY}- ${ChatColor.GOLD}Équipes enregistrées: ${
+                    RunnerDragon.instance.teamManager.getTeamColorsNames().joinToString("${ChatColor.RESET}, ", "", "")
+                }
             """.trimIndent()
             )
             return
@@ -31,29 +35,31 @@ class TeamsSubCommand {
             }
 
             "swap" -> {
-                val target = Bukkit.getPlayer(args[1])
+                if (args.size < 2) {
-                val targetTeam = args[2]
+                    player.sendMessage("${ChatColor.RED}Argument manquant.")
-
-                if (enumContains<ChatColor>(targetTeam)) {
-                    val value: ChatColor = ChatColor.valueOf(targetTeam)
-                    target?.let {
-                        val instance = RunnerDragon.instance
-                        instance.teamManager.getOnColor(value)
-                            ?.let { coloredTeam ->
-                                val dragonPlayer = instance.playerManager.getPlayer(it.uniqueId)
-                                dragonPlayer.setTeam(coloredTeam)
-                                dragonPlayer.updateDisplayName()
-                                player.sendMessage("${target.name} est passé dans l'équipe ${coloredTeam.name}")
-                            }
-                    }
                 } else {
-                    player.sendMessage("${ChatColor.RED}Couleur invalide.")
+                    val target = Bukkit.getPlayer(args[1])
+                    val targetTeam = args[2]
+
+                    if (enumContains<ChatColor>(targetTeam)) {
+                        val value: ChatColor = ChatColor.valueOf(targetTeam)
+                        target?.let {
+                            val instance = RunnerDragon.instance
+                            instance.teamManager.getOnColor(value)
+                                ?.let { coloredTeam ->
+                                    val dragonPlayer = instance.playerManager.getPlayer(it.uniqueId)
+                                    dragonPlayer.setTeam(coloredTeam)
+                                    dragonPlayer.updateDisplayName()
+                                    player.sendMessage("${target.name} est passé dans l'équipe ${coloredTeam.name}")
+                                }
+                        }
+                    } else {
+                        player.sendMessage("${ChatColor.RED}Couleur invalide.")
+                    }
                 }
             }
         }
     }
 
-    private inline fun <reified T : Enum<T>> enumContains(name: String): Boolean {
+
-        return enumValues<T>().any { it.name == name }
-    }
 }

src/main/kotlin/xyz/atnrch/dragon/event/EntityDamageListener.kt

@@ -16,7 +16,7 @@ class EntityDamageListener : Listener {
             if (player.gameMode == GameMode.SURVIVAL) {
                 if (RunnerDragon.STATE == GameState.GRACE_PERIOD && event.cause == EntityDamageEvent.DamageCause.ENTITY_ATTACK) {
                     event.isCancelled = true
-                } else if (RunnerDragon.STATE == GameState.NO_DAMAGE_PERIOD || RunnerDragon.STATE == GameState.WAITING) {
+                } else if (RunnerDragon.STATE == GameState.LAUNCH || RunnerDragon.STATE == GameState.WAITING) {
                     event.isCancelled = true
                 }
             }

src/main/kotlin/xyz/atnrch/dragon/event/EntityDeathListener.kt

@@ -3,7 +3,6 @@ package xyz.atnrch.dragon.event
 import org.bukkit.entity.EntityType
 import org.bukkit.event.EventHandler
 import org.bukkit.event.Listener
-import org.bukkit.event.entity.EntityDamageEvent
 import org.bukkit.event.entity.EntityDeathEvent
 import xyz.atnrch.dragon.RunnerDragon
 
@@ -11,8 +10,7 @@ class EntityDeathListener : Listener {
     @EventHandler
     fun onCowDeath(event: EntityDeathEvent) {
         if (event.entity.type == EntityType.COW) {
-            val lastDamageCause = event.entity.lastDamageCause!!
+            if (event.entity.killer?.type == EntityType.PLAYER) {
-            if (lastDamageCause.cause == EntityDamageEvent.DamageCause.ENTITY_ATTACK && lastDamageCause.entity.type == EntityType.PLAYER) {
                 RunnerDragon.DEAD_COWS += 1
                 RunnerDragon.instance.playerManager.getPlayers().forEach { (_, player) ->
                     player.updateHeaderFooter()

src/main/kotlin/xyz/atnrch/dragon/event/PlayerDeathListener.kt

@@ -1,14 +0,0 @@
-package xyz.atnrch.dragon.event
-
-import org.bukkit.event.EventHandler
-import org.bukkit.event.Listener
-import org.bukkit.event.entity.PlayerDeathEvent
-import xyz.atnrch.dragon.RunnerDragon
-
-class PlayerDeathListener : Listener {
-    @EventHandler
-    fun onDeath(event: PlayerDeathEvent) {
-        val player = event.entity.player!!
-        RunnerDragon.instance.worldManager.teleportAtSpawn(player)
-    }
-}

src/main/kotlin/xyz/atnrch/dragon/event/PlayerJoinListener.kt

@@ -4,9 +4,7 @@ import org.bukkit.ChatColor
 import org.bukkit.event.EventHandler
 import org.bukkit.event.Listener
 import org.bukkit.event.player.PlayerJoinEvent
-import xyz.atnrch.dragon.GameState
 import xyz.atnrch.dragon.RunnerDragon
-import xyz.atnrch.dragon.teams.Team
 
 class PlayerJoinListener : Listener {
     @EventHandler
@@ -15,13 +13,7 @@ class PlayerJoinListener : Listener {
 
         val dragonPlayer = RunnerDragon.instance.playerManager.addPlayer(player.uniqueId)
         dragonPlayer.sendMessage("Bienvenue !")
-        if (RunnerDragon.STATE == GameState.WAITING) {
+        dragonPlayer.instantiatePlayer()
-            RunnerDragon.instance.worldManager.teleportAtSpawn(player)
-            dragonPlayer.updateHeaderFooter()
-            dragonPlayer.impulse101()
-            dragonPlayer.setTeam(Team.DEFAULT_TEAM)
-        }
-
         RunnerDragon.instance.playerManager.getPlayers().forEach { (_, player) ->
             player.updateDisplayName()
             player.setTeamItem(true)

src/main/kotlin/xyz/atnrch/dragon/event/PlayerRespawnListener.kt

@@ -0,0 +1,14 @@
+package xyz.atnrch.dragon.event
+
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.player.PlayerRespawnEvent
+import xyz.atnrch.dragon.RunnerDragon
+
+class PlayerRespawnListener : Listener {
+    @EventHandler
+    fun onRespawn(event: PlayerRespawnEvent) {
+        event.respawnLocation = RunnerDragon.SPAWN
+        println("EVENT TRIGGERED")
+    }
+}

src/main/kotlin/xyz/atnrch/dragon/event/end/EnderDragonListener.kt

@@ -0,0 +1,24 @@
+package xyz.atnrch.dragon.event.end
+
+import org.bukkit.Bukkit
+import org.bukkit.ChatColor
+import org.bukkit.entity.EnderDragon
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.entity.EntityDeathEvent
+import xyz.atnrch.dragon.RunnerDragon
+
+class EnderDragonListener : Listener {
+    @EventHandler
+    fun onEnderDragonDeath(event: EntityDeathEvent) {
+        if (event.entity is EnderDragon) {
+            val dragon: EnderDragon = event.entity as EnderDragon
+            val player = dragon.killer
+            val dragonPlayer = player?.uniqueId?.let { RunnerDragon.instance.playerManager.getPlayer(it) }
+            val team = dragonPlayer?.getTeam()
+            if (dragon.dragonBattle?.hasBeenPreviouslyKilled()?.not() == true) {
+                Bukkit.broadcastMessage("${RunnerDragon.TITLE_MSG} ${ChatColor.GOLD}${ChatColor.BOLD}LE DRAGON A ÉTÉ TUÉ PAR L'ÉQUIPE ${team?.name}!")
+            }
+        }
+    }
+}

src/main/kotlin/xyz/atnrch/dragon/inventory/CandleInventory.kt

@@ -16,7 +16,7 @@ class CandleInventory(val player: Player) {
 
     init {
         val items = arrayListOf<Item>()
-        RunnerDragon.instance.teamManager.getTeams().drop(1).forEach {
+        RunnerDragon.instance.teamManager.getTeams().forEach {
             items.add(CandleItem(it))
         }
         gui = GUIBuilder(GUIType.NORMAL)

src/main/kotlin/xyz/atnrch/dragon/player/DragonPlayer.kt

@@ -5,6 +5,7 @@ import org.bukkit.ChatColor
 import org.bukkit.GameMode
 import org.bukkit.Material
 import org.bukkit.inventory.ItemStack
+import xyz.atnrch.dragon.GameState
 import xyz.atnrch.dragon.RunnerDragon
 import xyz.atnrch.dragon.teams.Team
 import xyz.haoshoku.nick.api.NickAPI
@@ -14,6 +15,15 @@ import java.util.*
 class DragonPlayer(uuid: UUID) {
     val player = Bukkit.getPlayer(uuid)!!
 
+    fun instantiatePlayer() {
+        if (RunnerDragon.STATE == GameState.WAITING) {
+            RunnerDragon.instance.worldManager.teleportAtSpawn(player)
+            updateHeaderFooter()
+            impulse101()
+            setTeam(Team.DEFAULT_TEAM)
+        }
+    }
+
     fun updateHeaderFooter() {
         player.playerListHeader = """
             ${RunnerDragon.TITLE}
@@ -30,7 +40,7 @@ class DragonPlayer(uuid: UUID) {
     }
 
     fun sendMessage(message: String) {
-        player.sendMessage("${ChatColor.WHITE}[${RunnerDragon.TITLE}${ChatColor.WHITE}] ${ChatColor.RESET}$message")
+        player.sendMessage("${RunnerDragon.TITLE_MSG} ${ChatColor.RESET}$message")
     }
 
     fun getTeam(): Team? {

src/main/kotlin/xyz/atnrch/dragon/tasks/GracePeriodTask.kt

@@ -11,13 +11,14 @@ class GracePeriodTask : BukkitRunnable() {
 
     override fun run() {
         counter--
+        Bukkit.broadcastMessage(counter.toString())
         val base = "${ChatColor.GOLD}Activation du PVP dans"
         when (counter) {
-            in 1..5, 60 -> Bukkit.broadcastMessage("${RunnerDragon.TITLE_MSG} $base ${ChatColor.AQUA}$counter ${ChatColor.GOLD}secondes.")
-            300 -> Bukkit.broadcastMessage("${RunnerDragon.TITLE_MSG} $base ${ChatColor.AQUA}5 ${ChatColor.GOLD}minutes.")
             600 -> Bukkit.broadcastMessage("${RunnerDragon.TITLE_MSG} $base ${ChatColor.AQUA}10 ${ChatColor.GOLD}minutes.")
-            540 -> RunnerDragon.instance.switchState(GameState.GRACE_PERIOD)
+            580 -> RunnerDragon.instance.switchState(GameState.GRACE_PERIOD)
-            0 -> Bukkit.broadcastMessage("${RunnerDragon.TITLE_MSG} ${ChatColor.GOLD}${ChatColor.ITALIC}PVP activé !")
+            300 -> Bukkit.broadcastMessage("${RunnerDragon.TITLE_MSG} $base ${ChatColor.AQUA}5 ${ChatColor.GOLD}minutes.")
+            in 1..5, 60 -> Bukkit.broadcastMessage("${RunnerDragon.TITLE_MSG} $base ${ChatColor.AQUA}$counter ${ChatColor.GOLD}secondes.")
+            0 -> RunnerDragon.instance.switchState(GameState.GAME)
         }
     }
 }

src/main/kotlin/xyz/atnrch/dragon/tasks/StartGameTask.kt

@@ -14,13 +14,7 @@ class StartGameTask : BukkitRunnable() {
 
         when (counter) {
             in 1..5, 10 -> Bukkit.broadcastMessage("${RunnerDragon.TITLE_MSG} ${ChatColor.GOLD}Départ dans ${ChatColor.AQUA}$counter ${ChatColor.GOLD}secondes.")
-            0 -> {
+            0 -> RunnerDragon.instance.switchState(GameState.LAUNCH)
-                Bukkit.broadcastMessage("${RunnerDragon.TITLE_MSG} ${ChatColor.GOLD}Lancement de la partie!")
-                RunnerDragon.instance.switchState(GameState.NO_DAMAGE_PERIOD)
-                RunnerDragon.LOBBY_SCHEMATIC.removeSchematic()
-                TimerTask().runTaskTimer(RunnerDragon.instance, 0L, 20L)
-                GracePeriodTask().runTaskTimer(RunnerDragon.instance, 0L, 20L)
-            }
         }
     }
 }

src/main/kotlin/xyz/atnrch/dragon/teams/Team.kt

@@ -6,7 +6,7 @@ import java.util.*
 
 class Team(
     val color: TeamColor,
-    var name: String = "CLEMENTNIQUETAMERE",
+    var name: String = "undefined",
     val players: ArrayList<DragonPlayer> = arrayListOf(),
     private val deaths: Int = 0
 ) {

src/main/kotlin/xyz/atnrch/dragon/teams/TeamManager.kt

@@ -22,6 +22,12 @@ class TeamManager(
         instance.logger.info("$size teams créés.")
     }
 
+    fun clean() {
+        teams.clear()
+        convert.clear()
+        players.clear()
+    }
+
     fun getOnColor(color: ChatColor): Team? {
         return convert[color]
     }
@@ -37,6 +43,10 @@ class TeamManager(
     }
 
     fun getTeams(): ArrayList<Team> {
-        return teams
+        return teams.drop(1) as ArrayList<Team>
+    }
+
+    fun getTeamColorsNames(): List<String> {
+        return getTeams().map { team -> "${team.color.chatColor}${team.color.chatColor.name}" }
     }
 }

src/main/kotlin/xyz/atnrch/dragon/world/WorldManager.kt

@@ -1,7 +1,6 @@
 package xyz.atnrch.dragon.world
 
 import org.bukkit.GameRule
-import org.bukkit.Location
 import org.bukkit.World
 import org.bukkit.entity.Player
 import xyz.atnrch.dragon.RunnerDragon
@@ -12,6 +11,6 @@ class WorldManager(private val world: World) {
     }
 
     fun teleportAtSpawn(player: Player) {
-        player.teleport(Location(world, 0.0, RunnerDragon.SPAWN_HEIGHT.plus(2).toDouble(), 0.0, -180f, 0f))
+        player.teleport(RunnerDragon.SPAWN)
     }
 }