ineanto/runnerdragon
1
0
Fork 0
Code Activity

feat: updated game systems

Browse source
This commit is contained in:
aro 2023-02-21 11:07:35 +01:00
parent 80de826345
commit fab70cee5c
19 changed files with 220 additions and 101 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
src/main/kotlin/xyz/atnrch/dragon/EnumHelper.kt Normal file
View file

@ -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 }
}

2
src/main/kotlin/xyz/atnrch/dragon/GameState.kt
View file

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

93
src/main/kotlin/xyz/atnrch/dragon/RunnerDragon.kt
View file

@ -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 DEAD_COWS = 0
var TIMER_TASK: BukkitTask? = null
var GRACE_PERIOD_TASK: BukkitTask? = null
var TIME = 0
var SPAWN_HEIGHT = 300
lateinit var SPAWN: Location
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)!!
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)
playerManager = PlayerManager()
teamManager = TeamManager(this)
server.pluginManager.registerEvents(DimensionEntranceListener(), this)
server.pluginManager.registerEvents(EnderDragonListener(), this)
server.pluginManager.registerEvents(PlayerJoinListener(), this)
server.pluginManager.registerEvents(PlayerQuitListener(), this)
server.pluginManager.registerEvents(PlayerDeathListener(), 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())
switchState(GameState.WAITING)
if (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)
}
GameState.GRACE_PERIOD -> {
playerManager.getPlayers().forEach { (_, player) ->
player.setTeam(Team.DEFAULT_TEAM)
player.updateDisplayName()
player.updateHeaderFooter()
player.setTeamItem(true)
}
return schematicSpawn
}
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
}
}
}
}

18
src/main/kotlin/xyz/atnrch/dragon/commands/GameSubCommand.kt
View file

@ -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() }

23
src/main/kotlin/xyz/atnrch/dragon/commands/MainCommand.kt
View file

@ -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()) {
sender.sendMessage("${ChatColor.RED}Arguments invalides: /rd (teams/game)")
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(sender is Player) {
val player: Player = sender
val dragonPlayer = RunnerDragon.instance.playerManager.getPlayer(player.uniqueId)
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

14
src/main/kotlin/xyz/atnrch/dragon/commands/TeamsSubCommand.kt
View file

@ -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,6 +35,9 @@ class TeamsSubCommand {
}
"swap" -> {
if (args.size < 2) {
player.sendMessage("${ChatColor.RED}Argument manquant.")
} else {
val target = Bukkit.getPlayer(args[1])
val targetTeam = args[2]
@ -52,8 +59,7 @@ class TeamsSubCommand {
}
}
}
private inline fun <reified T : Enum<T>> enumContains(name: String): Boolean {
return enumValues<T>().any { it.name == name }
}
}

2
src/main/kotlin/xyz/atnrch/dragon/event/EntityDamageListener.kt
View file

@ -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
}
}

4
src/main/kotlin/xyz/atnrch/dragon/event/EntityDeathListener.kt
View file

@ -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 (lastDamageCause.cause == EntityDamageEvent.DamageCause.ENTITY_ATTACK && lastDamageCause.entity.type == EntityType.PLAYER) {
if (event.entity.killer?.type == EntityType.PLAYER) {
RunnerDragon.DEAD_COWS += 1
RunnerDragon.instance.playerManager.getPlayers().forEach { (_, player) ->
player.updateHeaderFooter()

14
src/main/kotlin/xyz/atnrch/dragon/event/PlayerDeathListener.kt
View file

@ -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)
}
}

10
src/main/kotlin/xyz/atnrch/dragon/event/PlayerJoinListener.kt
View file

@ -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) {
RunnerDragon.instance.worldManager.teleportAtSpawn(player)
dragonPlayer.updateHeaderFooter()
dragonPlayer.impulse101()
dragonPlayer.setTeam(Team.DEFAULT_TEAM)
}
dragonPlayer.instantiatePlayer()
RunnerDragon.instance.playerManager.getPlayers().forEach { (_, player) ->
player.updateDisplayName()
player.setTeamItem(true)

14
src/main/kotlin/xyz/atnrch/dragon/event/PlayerRespawnListener.kt Normal file
View file

@ -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")
}
}

24
src/main/kotlin/xyz/atnrch/dragon/event/end/EnderDragonListener.kt Normal file
View file

@ -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}!")
}
}
}
}

2
src/main/kotlin/xyz/atnrch/dragon/inventory/CandleInventory.kt
View file

@ -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)

12
src/main/kotlin/xyz/atnrch/dragon/player/DragonPlayer.kt
View file

@ -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? {

9
src/main/kotlin/xyz/atnrch/dragon/tasks/GracePeriodTask.kt
View file

@ -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)
0 -> Bukkit.broadcastMessage("${RunnerDragon.TITLE_MSG} ${ChatColor.GOLD}${ChatColor.ITALIC}PVP activé !")
580 -> RunnerDragon.instance.switchState(GameState.GRACE_PERIOD)
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)
}
}
}

8
src/main/kotlin/xyz/atnrch/dragon/tasks/StartGameTask.kt
View file

@ -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 -> {
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)
}
0 -> RunnerDragon.instance.switchState(GameState.LAUNCH)
}
}
}

2
src/main/kotlin/xyz/atnrch/dragon/teams/Team.kt
View file

@ -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
) {

12
src/main/kotlin/xyz/atnrch/dragon/teams/TeamManager.kt
View file

@ -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}" }
}
}

3
src/main/kotlin/xyz/atnrch/dragon/world/WorldManager.kt
View file

@ -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)
}
}