ineanto/runnerdragon
1
0
Fork 0
Code Activity

feat: initial commit

Browse source
This commit is contained in:
aro 2023-02-20 19:04:37 +01:00
commit 80de826345
40 changed files with 1322 additions and 0 deletions

39
.gitignore vendored Normal file
View file

@ -0,0 +1,39 @@
.gradle
build/
!gradle/wrapper/gradle-wrapper.jar
!**/src/main/**/build/
!**/src/test/**/build/
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
out/
!**/src/main/**/out/
!**/src/test/**/out/
### Eclipse ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
bin/
!**/src/main/**/bin/
!**/src/test/**/bin/
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
### VS Code ###
.vscode/
### Mac OS ###
.DS_Store

8
.idea/.gitignore generated vendored Normal file
View file

@ -0,0 +1,8 @@
# Default ignored files
/shelf/
/workspace.xml
# Editor-based HTTP Client requests
/httpRequests/
# Datasource local storage ignored files
/dataSources/
/dataSources.local.xml

18
.idea/gradle.xml generated Normal file
View file

@ -0,0 +1,18 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="GradleMigrationSettings" migrationVersion="1" />
<component name="GradleSettings">
<option name="linkedExternalProjectsSettings">
<GradleProjectSettings>
<option name="distributionType" value="WRAPPED" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="gradleHome" value="/usr/share/java/gradle" />
<option name="modules">
<set>
<option value="$PROJECT_DIR$" />
</set>
</option>
</GradleProjectSettings>
</option>
</component>
</project>

8
.idea/inspectionProfiles/Project_Default.xml generated Normal file
View file

@ -0,0 +1,8 @@
<component name="InspectionProjectProfileManager">
<profile version="1.0">
<option name="myName" value="Project Default" />
<inspection_tool class="ReplaceUntilWithRangeUntil" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
<inspection_tool class="UnusedReceiverParameter" enabled="false" level="WARNING" enabled_by_default="false" />
<inspection_tool class="UnusedSymbol" enabled="false" level="WARNING" enabled_by_default="false" />
</profile>
</component>

6
.idea/kotlinc.xml generated Normal file
View file

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="KotlinJpsPluginSettings">
<option name="version" value="1.8.10" />
</component>
</project>

7
.idea/misc.xml generated Normal file
View file

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ExternalStorageConfigurationManager" enabled="true" />
<component name="ProjectRootManager" version="2" languageLevel="JDK_17" project-jdk-name="18" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" />
</component>
</project>

6
.idea/vcs.xml generated Normal file
View file

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" />
</component>
</project>

44
build.gradle.kts Normal file
View file

@ -0,0 +1,44 @@
import io.github.patrick.gradle.remapper.RemapTask
plugins {
kotlin("jvm") version "1.8.10"
id("com.github.johnrengelman.shadow") version "7.1.2"
id("io.github.patrick.remapper") version "1.4.0"
}
group = "xyz.atnrch.dragon"
version = "1.0-SNAPSHOT"
repositories {
mavenLocal()
maven("https://hub.spigotmc.org/nexus/content/repositories/snapshots/")
maven("https://oss.sonatype.org/content/repositories/snapshots")
maven("https://oss.sonatype.org/content/repositories/central")
maven("https://maven.enginehub.org/repo")
maven("https://repo.xenondevs.xyz/releases")
maven("https://haoshoku.xyz:1234/repository/public/")
}
dependencies {
// Stdlib
implementation("org.jetbrains.kotlin:kotlin-stdlib:1.8.10")
// InvUI
implementation("de.studiocode.invui:InvUI:0.10.2")
// NickAPI
compileOnly("xyz.haoshoku.nick:nickapi:6.3.3-SNAPSHOT")
// Spigot
compileOnly("org.spigotmc:spigot:1.19.3-R0.1-SNAPSHOT:remapped-mojang")
// WorldEdit
compileOnly("com.sk89q.worldedit:worldedit-core:7.2.0-SNAPSHOT")
compileOnly("com.sk89q.worldedit:worldedit-bukkit:7.2.0-SNAPSHOT")
}
kotlin { jvmToolchain(17) }
tasks {
remap {
version.set("1.19.3")
action.set(RemapTask.Action.MOJANG_TO_SPIGOT)
inputTask.set(shadowJar)
}
}

1
gradle.properties Normal file
View file

@ -0,0 +1 @@
kotlin.code.style=official

BIN
gradle/wrapper/gradle-wrapper.jar vendored Normal file
View file

Binary file not shown.

5
gradle/wrapper/gradle-wrapper.properties vendored Normal file
View file

@ -0,0 +1,5 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

234
gradlew vendored Executable file
View file

@ -0,0 +1,234 @@
#!/bin/sh
#
# Copyright © 2015-2021 the original authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
##############################################################################
#
# Gradle start up script for POSIX generated by Gradle.
#
# Important for running:
#
# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
# noncompliant, but you have some other compliant shell such as ksh or
# bash, then to run this script, type that shell name before the whole
# command line, like:
#
# ksh Gradle
#
# Busybox and similar reduced shells will NOT work, because this script
# requires all of these POSIX shell features:
# * functions;
# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
# * compound commands having a testable exit status, especially «case»;
# * various built-in commands including «command», «set», and «ulimit».
#
# Important for patching:
#
# (2) This script targets any POSIX shell, so it avoids extensions provided
# by Bash, Ksh, etc; in particular arrays are avoided.
#
# The "traditional" practice of packing multiple parameters into a
# space-separated string is a well documented source of bugs and security
# problems, so this is (mostly) avoided, by progressively accumulating
# options in "$@", and eventually passing that to Java.
#
# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
# see the in-line comments for details.
#
# There are tweaks for specific operating systems such as AIX, CygWin,
# Darwin, MinGW, and NonStop.
#
# (3) This script is generated from the Groovy template
# https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
# within the Gradle project.
#
# You can find Gradle at https://github.com/gradle/gradle/.
#
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
app_path=$0
# Need this for daisy-chained symlinks.
while
APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
[ -h "$app_path" ]
do
ls=$( ls -ld "$app_path" )
link=${ls#*' -> '}
case $link in #(
/*) app_path=$link ;; #(
*) app_path=$APP_HOME$link ;;
esac
done
APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
APP_NAME="Gradle"
APP_BASE_NAME=${0##*/}
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum
warn () {
echo "$*"
} >&2
die () {
echo
echo "$*"
echo
exit 1
} >&2
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "$( uname )" in #(
CYGWIN* ) cygwin=true ;; #(
Darwin* ) darwin=true ;; #(
MSYS* | MINGW* ) msys=true ;; #(
NONSTOP* ) nonstop=true ;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD=$JAVA_HOME/jre/sh/java
else
JAVACMD=$JAVA_HOME/bin/java
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD=java
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
case $MAX_FD in #(
max*)
MAX_FD=$( ulimit -H -n ) ||
warn "Could not query maximum file descriptor limit"
esac
case $MAX_FD in #(
'' | soft) :;; #(
*)
ulimit -n "$MAX_FD" ||
warn "Could not set maximum file descriptor limit to $MAX_FD"
esac
fi
# Collect all arguments for the java command, stacking in reverse order:
# * args from the command line
# * the main class name
# * -classpath
# * -D...appname settings
# * --module-path (only if needed)
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
JAVACMD=$( cygpath --unix "$JAVACMD" )
# Now convert the arguments - kludge to limit ourselves to /bin/sh
for arg do
if
case $arg in #(
-*) false ;; # don't mess with options #(
/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
[ -e "$t" ] ;; #(
*) false ;;
esac
then
arg=$( cygpath --path --ignore --mixed "$arg" )
fi
# Roll the args list around exactly as many times as the number of
# args, so each arg winds up back in the position where it started, but
# possibly modified.
#
# NB: a `for` loop captures its iteration list before it begins, so
# changing the positional parameters here affects neither the number of
# iterations, nor the values presented in `arg`.
shift # remove old arg
set -- "$@" "$arg" # push replacement arg
done
fi
# Collect all arguments for the java command;
# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
# shell script including quotes and variable substitutions, so put them in
# double quotes to make sure that they get re-expanded; and
# * put everything else in single quotes, so that it's not re-expanded.
set -- \
"-Dorg.gradle.appname=$APP_BASE_NAME" \
-classpath "$CLASSPATH" \
org.gradle.wrapper.GradleWrapperMain \
"$@"
# Use "xargs" to parse quoted args.
#
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
#
# In Bash we could simply go:
#
# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
# set -- "${ARGS[@]}" "$@"
#
# but POSIX shell has neither arrays nor command substitution, so instead we
# post-process each arg (as a line of input to sed) to backslash-escape any
# character that might be a shell metacharacter, then use eval to reverse
# that process (while maintaining the separation between arguments), and wrap
# the whole thing up as a single "set" statement.
#
# This will of course break if any of these variables contains a newline or
# an unmatched quote.
#
eval "set -- $(
printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
xargs -n1 |
sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
tr '\n' ' '
)" '"$@"'
exec "$JAVACMD" "$@"

89
gradlew.bat vendored Normal file
View file

@ -0,0 +1,89 @@
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto execute
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto execute
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega

3
settings.gradle.kts Normal file
View file

@ -0,0 +1,3 @@
rootProject.name = "Dragon"

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

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

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

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

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

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

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

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

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

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

30
src/main/kotlin/xyz/atnrch/dragon/event/DimensionEntranceListener.kt Normal file
View file

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

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

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

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

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

14
src/main/kotlin/xyz/atnrch/dragon/event/PlayerDeathListener.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.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)
}
}

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

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

18
src/main/kotlin/xyz/atnrch/dragon/event/PlayerQuitListener.kt Normal file
View file

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

60
src/main/kotlin/xyz/atnrch/dragon/event/waiting/WaitingListener.kt Normal file
View file

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

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

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

41
src/main/kotlin/xyz/atnrch/dragon/inventory/CandleItem.kt Normal file
View file

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

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

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

25
src/main/kotlin/xyz/atnrch/dragon/player/PlayerManager.kt Normal file
View file

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

46
src/main/kotlin/xyz/atnrch/dragon/schematic/SchematicLoader.kt Normal file
View file

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

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

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

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

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

13
src/main/kotlin/xyz/atnrch/dragon/tasks/TimerTask.kt Normal file
View file

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

27
src/main/kotlin/xyz/atnrch/dragon/teams/CandleColor.kt Normal file
View file

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

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

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

14
src/main/kotlin/xyz/atnrch/dragon/teams/TeamColor.kt Normal file
View file

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

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

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

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

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

8
src/main/resources/plugin.yml Normal file
View file

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