feat: initial commit

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

@@ -0,0 +1,8 @@
+package xyz.atnrch.dragon
+
+enum class GameState {
+    WAITING,
+    NO_DAMAGE_PERIOD,
+    GRACE_PERIOD,
+    GAME
+}

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

@@ -0,0 +1,104 @@
+package xyz.atnrch.dragon
+
+import org.apache.commons.io.FileUtils
+import org.bukkit.*
+import org.bukkit.plugin.java.JavaPlugin
+import xyz.atnrch.dragon.commands.MainCommand
+import xyz.atnrch.dragon.event.*
+import xyz.atnrch.dragon.event.waiting.WaitingListener
+import xyz.atnrch.dragon.player.PlayerManager
+import xyz.atnrch.dragon.schematic.SchematicLoader
+import xyz.atnrch.dragon.teams.TeamManager
+import xyz.atnrch.dragon.world.WorldManager
+import java.io.File
+
+class RunnerDragon : JavaPlugin() {
+    companion object {
+        lateinit var instance: RunnerDragon
+
+        val TITLE =
+            "${ChatColor.LIGHT_PURPLE}${ChatColor.BOLD}${ChatColor.ITALIC}Runner${ChatColor.DARK_PURPLE}${ChatColor.BOLD}${ChatColor.ITALIC}Dragon"
+
+        val TITLE_MSG =
+            "${ChatColor.WHITE}[${ChatColor.LIGHT_PURPLE}${ChatColor.BOLD}RUNNER${ChatColor.DARK_PURPLE}${ChatColor.BOLD}DRAGON${ChatColor.WHITE}]"
+
+        const val TEAM_MAX_SIZE = 2
+        const val NUMBER_OF_TEAMS = 6
+        var TEAM_LOCK = false
+
+        var NETHER_PORTAL_ENTERED = false
+        var END_PORTAL_ENTERED = false
+        var STATE = GameState.GAME
+        var DEAD_COWS = 0
+
+        var TIME = 0
+
+        var SPAWN_HEIGHT = 300
+        lateinit var WORLD: World
+        lateinit var LOBBY_SCHEMATIC: SchematicLoader
+    }
+
+    lateinit var teamManager: TeamManager
+    lateinit var playerManager: PlayerManager
+    lateinit var worldManager: WorldManager
+
+    override fun onEnable() {
+        instance = this
+
+        val previousWorldFolder = File("runnerdragon")
+        if (previousWorldFolder.exists()) {
+            logger.warning("Ancien monde détecté! Suppression...")
+            FileUtils.deleteDirectory(previousWorldFolder)
+        }
+
+        val creator = WorldCreator("runnerdragon")
+        creator.environment(World.Environment.NORMAL)
+        creator.generateStructures(true)
+        creator.type(WorldType.NORMAL)
+
+        logger.info("Création d'un nouveau monde...")
+        WORLD = Bukkit.createWorld(creator)!!
+
+        logger.info("Génération du spawn...")
+        LOBBY_SCHEMATIC = SchematicLoader(File("./lobby1.schem"), WORLD)
+        if (LOBBY_SCHEMATIC.spawnSchematicAt(0, SPAWN_HEIGHT, 0)) {
+            playerManager = PlayerManager()
+            teamManager = TeamManager(this)
+            worldManager = WorldManager(WORLD)
+
+            logger.info("Création des équipes...")
+            teamManager.createTeams(NUMBER_OF_TEAMS)
+
+            server.pluginManager.registerEvents(DimensionEntranceListener(), this)
+            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")
+        }
+    }
+
+    fun switchState(state: GameState) {
+        STATE = state
+        when (state) {
+            GameState.WAITING -> {
+                worldManager.applyWaitingRules()
+            }
+
+            GameState.GRACE_PERIOD -> {
+                playerManager.getPlayers().forEach { (_, player) ->
+                    player.impulse101()
+                }
+            }
+
+            GameState.GAME, GameState.NO_DAMAGE_PERIOD -> {}
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+package xyz.atnrch.dragon.commands
+
+import org.bukkit.Bukkit
+import org.bukkit.ChatColor
+import xyz.atnrch.dragon.RunnerDragon
+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)")
+            return
+        }
+
+        when (args[0]) {
+            "start" -> {
+                sender.sendMessage("Démarrage de la partie.")
+                Bukkit.getOnlinePlayers().forEach { it.inventory.clear() }
+                StartGameTask().runTaskTimer(RunnerDragon.instance, 0L, 20L)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+package xyz.atnrch.dragon.commands
+
+import org.bukkit.ChatColor
+import org.bukkit.command.Command
+import org.bukkit.command.CommandExecutor
+import org.bukkit.command.CommandSender
+import org.bukkit.entity.Player
+import xyz.atnrch.dragon.RunnerDragon
+
+class MainCommand : CommandExecutor {
+    override fun onCommand(sender: CommandSender, command: Command, label: String, args: Array<String>): Boolean {
+        if (args.isEmpty()) {
+            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)
+
+            when (args[0]) {
+                "game" -> GameSubCommand().run(dragonPlayer, args.drop(1).toTypedArray())
+                "teams" -> TeamsSubCommand().run(dragonPlayer, args.drop(1).toTypedArray())
+            }
+        }
+        return true
+    }
+}

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

@@ -0,0 +1,59 @@
+package xyz.atnrch.dragon.commands
+
+import org.bukkit.Bukkit
+import org.bukkit.ChatColor
+import xyz.atnrch.dragon.RunnerDragon
+import xyz.atnrch.dragon.player.DragonPlayer
+
+class TeamsSubCommand {
+    fun run(player: DragonPlayer, args: Array<String>) {
+        if (args.isEmpty() || args.size < 2) {
+            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}
+            """.trimIndent()
+            )
+            return
+        }
+
+        when (args[0]) {
+            "lock" -> {
+                RunnerDragon.TEAM_LOCK = RunnerDragon.TEAM_LOCK.not()
+                Bukkit.getOnlinePlayers()
+                    .forEach {
+                        RunnerDragon.instance.playerManager.getPlayer(it.uniqueId)
+                            .setTeamItem(RunnerDragon.TEAM_LOCK.not())
+                    }
+                player.sendMessage("Les équipes sont désormais: ${if (RunnerDragon.TEAM_LOCK) "${ChatColor.RED}fermées" else "${ChatColor.GREEN}ouvertes${ChatColor.RESET}."}")
+            }
+
+            "swap" -> {
+                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/DimensionEntranceListener.kt

@@ -0,0 +1,30 @@
+package xyz.atnrch.dragon.event
+
+import org.bukkit.Bukkit
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.player.PlayerPortalEvent
+import org.bukkit.event.player.PlayerTeleportEvent
+import xyz.atnrch.dragon.GameState
+import xyz.atnrch.dragon.RunnerDragon
+
+class DimensionEntranceListener : Listener {
+    @EventHandler
+    fun onDimensionEntrance(event: PlayerPortalEvent) {
+        if (RunnerDragon.STATE == GameState.GAME) {
+            when (event.cause) {
+                PlayerTeleportEvent.TeleportCause.NETHER_PORTAL -> if (RunnerDragon.NETHER_PORTAL_ENTERED.not()) {
+                    RunnerDragon.NETHER_PORTAL_ENTERED = true
+                    Bukkit.broadcastMessage("Nether portal 1st time!")
+                }
+
+                PlayerTeleportEvent.TeleportCause.END_PORTAL -> if (RunnerDragon.END_PORTAL_ENTERED.not()) {
+                    RunnerDragon.END_PORTAL_ENTERED = true
+                    Bukkit.broadcastMessage("End portal 1st time!")
+                }
+
+                else -> {}
+            }
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+package xyz.atnrch.dragon.event
+
+import org.bukkit.GameMode
+import org.bukkit.entity.Player
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.entity.EntityDamageEvent
+import xyz.atnrch.dragon.GameState
+import xyz.atnrch.dragon.RunnerDragon
+
+class EntityDamageListener : Listener {
+    @EventHandler
+    fun onEntityDamage(event: EntityDamageEvent) {
+        if (event.entity is Player) {
+            val player = (event.entity as Player)
+            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) {
+                    event.isCancelled = true
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+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
+
+class EntityDeathListener : Listener {
+    @EventHandler
+    fun onCowDeath(event: EntityDeathEvent) {
+        if (event.entity.type == EntityType.COW) {
+            val lastDamageCause = event.entity.lastDamageCause!!
+            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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,31 @@
+package xyz.atnrch.dragon.event
+
+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
+    fun onPlayerJoin(event: PlayerJoinEvent) {
+        val player = event.player
+
+        val dragonPlayer = RunnerDragon.instance.playerManager.addPlayer(player.uniqueId)
+        dragonPlayer.sendMessage("Bienvenue !")
+        if (RunnerDragon.STATE == GameState.WAITING) {
+            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)
+        }
+        event.joinMessage = "(${ChatColor.GREEN}+${ChatColor.WHITE}) ${player.name}"
+    }
+}

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

@@ -0,0 +1,18 @@
+package xyz.atnrch.dragon.event
+
+import org.bukkit.ChatColor
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.player.PlayerQuitEvent
+import xyz.atnrch.dragon.RunnerDragon
+
+class PlayerQuitListener : Listener {
+    @EventHandler
+    fun onPlayerJoin(event: PlayerQuitEvent) {
+        val player = event.player
+
+        RunnerDragon.instance.teamManager.getPlayerTeam(player)!!.removePlayer(player.uniqueId)
+        RunnerDragon.instance.playerManager.removePlayer(player.uniqueId)
+        event.quitMessage = "(${ChatColor.RED}-${ChatColor.WHITE}) ${player.name}"
+    }
+}

src/main/kotlin/xyz/atnrch/dragon/event/waiting/WaitingListener.kt

@@ -0,0 +1,60 @@
+package xyz.atnrch.dragon.event.waiting
+
+import org.bukkit.ChatColor
+import org.bukkit.GameMode
+import org.bukkit.entity.Player
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.block.BlockBreakEvent
+import org.bukkit.event.block.BlockPlaceEvent
+import org.bukkit.event.entity.EntityDamageEvent
+import org.bukkit.event.entity.FoodLevelChangeEvent
+import org.bukkit.event.player.PlayerInteractEvent
+import xyz.atnrch.dragon.GameState
+import xyz.atnrch.dragon.RunnerDragon
+import xyz.atnrch.dragon.inventory.CandleInventory
+
+class WaitingListener : Listener {
+    @EventHandler
+    fun onBlockBreak(event: BlockPlaceEvent) {
+        val player = event.player
+        if (RunnerDragon.STATE == GameState.WAITING && player.gameMode == GameMode.SURVIVAL) {
+            event.isCancelled = true
+        }
+    }
+
+    @EventHandler
+    fun onBlockBreak(event: BlockBreakEvent) {
+        val player = event.player
+        if (RunnerDragon.STATE == GameState.WAITING && player.gameMode == GameMode.SURVIVAL) {
+            event.isCancelled = true
+        }
+    }
+
+    @EventHandler
+    fun onEntityDamage(event: EntityDamageEvent) {
+        if (event.entity is Player) {
+            val player = (event.entity as Player)
+            if (RunnerDragon.STATE == GameState.WAITING && player.gameMode == GameMode.SURVIVAL) {
+                event.isCancelled = true
+            }
+        }
+    }
+
+    @EventHandler
+    fun onFoodLevelChange(event: FoodLevelChangeEvent) {
+        if (RunnerDragon.STATE == GameState.WAITING && event.entity.gameMode == GameMode.SURVIVAL) {
+            event.isCancelled = true
+        }
+    }
+
+    @EventHandler
+    fun onItemInteract(event: PlayerInteractEvent) {
+        if (RunnerDragon.STATE == GameState.WAITING && event.player.gameMode == GameMode.SURVIVAL) {
+            if (event.item?.itemMeta?.displayName == "${ChatColor.GOLD}Choisir une équipe") {
+                CandleInventory(event.player)
+            }
+            event.isCancelled = true
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+package xyz.atnrch.dragon.inventory
+
+import de.studiocode.invui.gui.GUI
+import de.studiocode.invui.gui.builder.GUIBuilder
+import de.studiocode.invui.gui.builder.guitype.GUIType
+import de.studiocode.invui.item.Item
+import de.studiocode.invui.item.builder.ItemBuilder
+import de.studiocode.invui.item.impl.SimpleItem
+import de.studiocode.invui.window.impl.single.SimpleWindow
+import org.bukkit.Material
+import org.bukkit.entity.Player
+import xyz.atnrch.dragon.RunnerDragon
+
+class CandleInventory(val player: Player) {
+    private var gui: GUI
+
+    init {
+        val items = arrayListOf<Item>()
+        RunnerDragon.instance.teamManager.getTeams().drop(1).forEach {
+            items.add(CandleItem(it))
+        }
+        gui = GUIBuilder(GUIType.NORMAL)
+            .setStructure(
+                "# # # # # # # # #",
+                "# x x x x x x x #",
+                "# x x x x x x x #",
+                "# # # # # # # # #"
+            )
+            .addIngredient('#', SimpleItem(ItemBuilder(Material.BLACK_STAINED_GLASS_PANE)))
+            .build()
+        items.forEach { item -> gui.addItems(item) }
+        SimpleWindow(player, "RunnerDragon", gui).show()
+    }
+}

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

@@ -0,0 +1,41 @@
+package xyz.atnrch.dragon.inventory
+
+import de.studiocode.invui.item.ItemProvider
+import de.studiocode.invui.item.builder.ItemBuilder
+import de.studiocode.invui.item.impl.BaseItem
+import org.bukkit.ChatColor
+import org.bukkit.entity.Player
+import org.bukkit.event.inventory.ClickType
+import org.bukkit.event.inventory.InventoryClickEvent
+import xyz.atnrch.dragon.RunnerDragon
+import xyz.atnrch.dragon.teams.CandleColor
+import xyz.atnrch.dragon.teams.Team
+
+class CandleItem(private val team: Team) : BaseItem() {
+
+    override fun getItemProvider(): ItemProvider {
+        val material = CandleColor.getFromTeamColor(team.color)
+        val itemBuilder = ItemBuilder(material)
+        itemBuilder.setDisplayName("${team.color.chatColor}Rejoindre l'équipe")
+        team.players.forEach { player ->
+            itemBuilder.addLoreLines("${ChatColor.DARK_GRAY}- ${team.color.chatColor}${player.player.name}")
+        }
+        return itemBuilder
+    }
+
+    override fun handleClick(clickType: ClickType, player: Player, event: InventoryClickEvent) {
+        RunnerDragon.instance.playerManager.getPlayer(player.uniqueId).let {
+            if (team.players.size == 2) {
+                it.sendMessage("${ChatColor.RED}L'équipe est complète.")
+            } else if (it.getTeam()!! == team) {
+                it.sendMessage("${ChatColor.RED}Vous êtes déjà dans cette équipe.")
+            } else {
+                it.sendMessage("Vous êtes désormais dans l'équipe: ${team.name}")
+                it.setTeam(team)
+                it.updateDisplayName()
+            }
+        }
+        notifyWindows()
+        event.view.close()
+    }
+}

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

@@ -0,0 +1,80 @@
+package xyz.atnrch.dragon.player
+
+import org.bukkit.Bukkit
+import org.bukkit.ChatColor
+import org.bukkit.GameMode
+import org.bukkit.Material
+import org.bukkit.inventory.ItemStack
+import xyz.atnrch.dragon.RunnerDragon
+import xyz.atnrch.dragon.teams.Team
+import xyz.haoshoku.nick.api.NickAPI
+import java.util.*
+
+
+class DragonPlayer(uuid: UUID) {
+    val player = Bukkit.getPlayer(uuid)!!
+
+    fun updateHeaderFooter() {
+        player.playerListHeader = """
+            ${RunnerDragon.TITLE}
+            ${ChatColor.DARK_PURPLE}${ChatColor.BOLD}Met@${ChatColor.DARK_AQUA}${ChatColor.BOLD}Gaming
+            
+            ${ChatColor.GOLD}Temps: ${ChatColor.RED}${formatDuration(RunnerDragon.TIME)}
+            ${ChatColor.GOLD}Vaches tuées: ${ChatColor.RED}${RunnerDragon.DEAD_COWS} ${ChatColor.GRAY}${ChatColor.ITALIC}(c'est horrible)
+            
+        """.trimIndent()
+        player.playerListFooter = """
+            
+            ${ChatColor.GOLD}${ChatColor.ITALIC}Plugin: ${ChatColor.BLUE}Ineanto ${ChatColor.DARK_GRAY}/ ${ChatColor.GOLD}${ChatColor.ITALIC}Concept: ${ChatColor.BLUE}Linkxss
+        """.trimIndent()
+    }
+
+    fun sendMessage(message: String) {
+        player.sendMessage("${ChatColor.WHITE}[${RunnerDragon.TITLE}${ChatColor.WHITE}] ${ChatColor.RESET}$message")
+    }
+
+    fun getTeam(): Team? {
+        return RunnerDragon.instance.teamManager.getPlayerTeam(player)
+    }
+
+    fun setTeam(team: Team) {
+        RunnerDragon.instance.teamManager.setPlayerTeam(player, team)
+    }
+
+    fun impulse101() {
+        player.gameMode = GameMode.SURVIVAL
+        player.inventory.clear()
+        player.health = 20.0
+        player.foodLevel = 20
+        player.activePotionEffects.clear()
+        player.walkSpeed = 0.2f
+        player.flySpeed = 0.1f
+        player.exp = 0f
+        player.level = 0
+        player.totalExperience = 0
+    }
+
+    fun setTeamItem(value: Boolean) {
+        if (value) {
+            val item = ItemStack(Material.CANDLE)
+            val meta = item.itemMeta!!
+            meta.setDisplayName("${ChatColor.GOLD}Choisir une équipe")
+            item.itemMeta = meta
+            player.inventory.setItem(4, item)
+        } else {
+            player.inventory.setItem(4, ItemStack(Material.AIR))
+        }
+    }
+
+    fun updateDisplayName() {
+        NickAPI.nick(player, "${getTeam()!!.color.chatColor}${player.name}")
+        NickAPI.refreshPlayer(player)
+    }
+
+    private fun formatDuration(totalSeconds: Int): String {
+        val hours = totalSeconds / 3600
+        val minutes = (totalSeconds % 3600) / 60
+        val seconds = totalSeconds % 60
+        return String.format("%02d:%02d:%02d", hours, minutes, seconds)
+    }
+}

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

@@ -0,0 +1,25 @@
+package xyz.atnrch.dragon.player
+
+import java.util.*
+
+class PlayerManager(
+    private val players: HashMap<UUID, DragonPlayer> = hashMapOf(),
+) {
+    fun addPlayer(uuid: UUID): DragonPlayer {
+        val dragonPlayer = DragonPlayer(uuid)
+        if (uuid !in players) players[uuid] = dragonPlayer
+        return dragonPlayer
+    }
+
+    fun removePlayer(uuid: UUID) {
+        if (uuid in players) players.remove(uuid)
+    }
+
+    fun getPlayer(uuid: UUID): DragonPlayer {
+        return players[uuid]!!
+    }
+
+    fun getPlayers(): HashMap<UUID, DragonPlayer> {
+        return players
+    }
+}

src/main/kotlin/xyz/atnrch/dragon/schematic/SchematicLoader.kt

@@ -0,0 +1,46 @@
+package xyz.atnrch.dragon.schematic
+
+import com.sk89q.worldedit.EditSession
+import com.sk89q.worldedit.WorldEdit
+import com.sk89q.worldedit.WorldEditException
+import com.sk89q.worldedit.bukkit.BukkitAdapter
+import com.sk89q.worldedit.extent.clipboard.Clipboard
+import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormats
+import com.sk89q.worldedit.function.operation.Operation
+import com.sk89q.worldedit.function.operation.Operations
+import com.sk89q.worldedit.math.BlockVector3
+import com.sk89q.worldedit.session.ClipboardHolder
+import org.bukkit.World
+import java.io.File
+import java.io.FileInputStream
+
+
+class SchematicLoader(private val schematic: File, private val world: World) {
+    private lateinit var session: EditSession
+
+    fun spawnSchematicAt(x: Int, y: Int, z: Int): Boolean {
+        // probably terribly unoptimized, couldn't care less!
+        var clipboard: Clipboard?
+        val format = ClipboardFormats.findByFile(schematic)
+        format!!.getReader(FileInputStream(schematic)).use { reader -> clipboard = reader.read() }
+        WorldEdit.getInstance().newEditSession(BukkitAdapter.adapt(world)).use operation@{ weSession ->
+            session = weSession
+            val operation: Operation = ClipboardHolder(clipboard!!)
+                .createPaste(weSession)
+                .to(BlockVector3.at(x, y, z))
+                .copyEntities(true)
+                .build()
+            try {
+                Operations.complete(operation)
+                return true
+            } catch (exception: WorldEditException) {
+                exception.printStackTrace()
+                return false
+            }
+        }
+    }
+
+    fun removeSchematic() {
+        session.undo(session)
+    }
+}

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

@@ -0,0 +1,23 @@
+package xyz.atnrch.dragon.tasks
+
+import org.bukkit.Bukkit
+import org.bukkit.ChatColor
+import org.bukkit.scheduler.BukkitRunnable
+import xyz.atnrch.dragon.GameState
+import xyz.atnrch.dragon.RunnerDragon
+
+class GracePeriodTask : BukkitRunnable() {
+    private var counter: Int = 601
+
+    override fun run() {
+        counter--
+        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)
+            0 -> Bukkit.broadcastMessage("${RunnerDragon.TITLE_MSG} ${ChatColor.GOLD}${ChatColor.ITALIC}PVP activé !")
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+package xyz.atnrch.dragon.tasks
+
+import org.bukkit.Bukkit
+import org.bukkit.ChatColor
+import org.bukkit.scheduler.BukkitRunnable
+import xyz.atnrch.dragon.GameState
+import xyz.atnrch.dragon.RunnerDragon
+
+class StartGameTask : BukkitRunnable() {
+    private var counter: Int = 15
+
+    override fun run() {
+        counter--
+
+        when (counter) {
+            in 1..5, 10 -> Bukkit.broadcastMessage("${RunnerDragon.TITLE_MSG} ${ChatColor.GOLD}Départ dans ${ChatColor.AQUA}$counter ${ChatColor.GOLD}secondes.")
+            0 -> {
+                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/tasks/TimerTask.kt

@@ -0,0 +1,13 @@
+package xyz.atnrch.dragon.tasks
+
+import org.bukkit.scheduler.BukkitRunnable
+import xyz.atnrch.dragon.RunnerDragon
+
+class TimerTask : BukkitRunnable() {
+    override fun run() {
+        RunnerDragon.instance.playerManager.getPlayers().forEach { (_, player) ->
+            player.updateHeaderFooter()
+        }
+        RunnerDragon.TIME++
+    }
+}

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

@@ -0,0 +1,27 @@
+package xyz.atnrch.dragon.teams
+
+import org.bukkit.Material
+
+enum class CandleColor(val teamColor: TeamColor, val candle: Material) {
+    NONE(TeamColor.NONE, Material.GRAY_CANDLE),
+    BLUE(TeamColor.BLUE, Material.BLUE_CANDLE),
+    YELLOW(TeamColor.YELLOW, Material.YELLOW_CANDLE),
+    RED(TeamColor.RED, Material.RED_CANDLE),
+    GREEN(TeamColor.GREEN, Material.GREEN_CANDLE),
+    ORANGE(TeamColor.ORANGE, Material.ORANGE_CANDLE),
+    PURPLE(TeamColor.PURPLE, Material.PURPLE_CANDLE);
+
+    companion object {
+        private val map = HashMap<TeamColor, Material>()
+
+        init {
+            CandleColor.values().forEach {
+                map[it.teamColor] = it.candle
+            }
+        }
+
+        fun getFromTeamColor(teamColor: TeamColor): Material {
+            return map[teamColor]!!
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+package xyz.atnrch.dragon.teams
+
+import xyz.atnrch.dragon.RunnerDragon
+import xyz.atnrch.dragon.player.DragonPlayer
+import java.util.*
+
+class Team(
+    val color: TeamColor,
+    var name: String = "CLEMENTNIQUETAMERE",
+    val players: ArrayList<DragonPlayer> = arrayListOf(),
+    private val deaths: Int = 0
+) {
+    init {
+        name = "${color.chatColor}${color.chatColor.name}"
+    }
+
+    companion object {
+        val DEFAULT_TEAM = Team(TeamColor.NONE)
+    }
+
+    fun addPlayer(uuid: UUID) {
+        val player = RunnerDragon.instance.playerManager.getPlayer(uuid)
+        if (player !in players) players.add(player)
+    }
+
+    fun removePlayer(uuid: UUID) {
+        val player = RunnerDragon.instance.playerManager.getPlayer(uuid)
+        if (player in players) players.remove(player)
+    }
+
+    fun clearTeam() {
+        players.clear()
+    }
+}

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

@@ -0,0 +1,14 @@
+package xyz.atnrch.dragon.teams
+
+import org.bukkit.ChatColor
+import org.bukkit.Color
+
+enum class TeamColor(val chatColor: ChatColor, val color: Color) {
+    NONE(ChatColor.GRAY, Color.GRAY),
+    BLUE(ChatColor.BLUE, Color.BLUE),
+    YELLOW(ChatColor.YELLOW, Color.YELLOW),
+    RED(ChatColor.RED, Color.RED),
+    GREEN(ChatColor.DARK_GREEN, Color.GREEN),
+    ORANGE(ChatColor.GOLD, Color.ORANGE),
+    PURPLE(ChatColor.LIGHT_PURPLE, Color.PURPLE)
+}

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

@@ -0,0 +1,42 @@
+package xyz.atnrch.dragon.teams
+
+import org.bukkit.ChatColor
+import org.bukkit.entity.Player
+import xyz.atnrch.dragon.RunnerDragon
+import java.util.*
+
+class TeamManager(
+    private val instance: RunnerDragon,
+    private val teams: ArrayList<Team> = arrayListOf(),
+    private val convert: HashMap<ChatColor, Team> = hashMapOf(),
+    private val players: HashMap<UUID, Team> = hashMapOf()
+) {
+    fun createTeams(size: Int) {
+        teams.clear()
+        for (i in 0..size) {
+            val color = TeamColor.values()[i]
+            val team = Team(color)
+            teams.add(team)
+            convert[color.chatColor] = team
+        }
+        instance.logger.info("$size teams créés.")
+    }
+
+    fun getOnColor(color: ChatColor): Team? {
+        return convert[color]
+    }
+
+    fun setPlayerTeam(player: Player, team: Team) {
+        getPlayerTeam(player)?.removePlayer(player.uniqueId)
+        players[player.uniqueId] = team
+        team.addPlayer(player.uniqueId)
+    }
+
+    fun getPlayerTeam(player: Player): Team? {
+        return players[player.uniqueId]
+    }
+
+    fun getTeams(): ArrayList<Team> {
+        return teams
+    }
+}

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

@@ -0,0 +1,17 @@
+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
+
+class WorldManager(private val world: World) {
+    fun applyWaitingRules() {
+        world.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, false)
+    }
+
+    fun teleportAtSpawn(player: Player) {
+        player.teleport(Location(world, 0.0, RunnerDragon.SPAWN_HEIGHT.plus(2).toDouble(), 0.0, -180f, 0f))
+    }
+}

src/main/resources/plugin.yml

@@ -0,0 +1,8 @@
+name: RunnerDragon
+main: xyz.atnrch.dragon.RunnerDragon
+version: 1.0
+api-version: 1.19
+depend: [NickAPI, WorldEdit]
+commands:
+  rd:
+    description: "Contrôle RunnerDragon."