From 946ddfc69aba3e42a79fb5dc3d4d5b3a82695eab Mon Sep 17 00:00:00 2001 From: Yaruma3341 Date: Thu, 14 Feb 2019 18:37:38 +0100 Subject: [PATCH] =?UTF-8?q?FightSystem=20hinzugef=C3=BCgt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Yaruma3341 --- config.yml | 42 +++ plugin.yml | 8 + src/me/yaruma/fightsystem/FightSystem.java | 251 ++++++++++++++++++ .../fightsystem/commands/AkCommand.java | 159 +++++++++++ src/me/yaruma/fightsystem/fight/Fight.java | 43 +++ .../fightsystem/fight/FightCreator.java | 12 + .../fightsystem/fight/FightManager.java | 40 +++ .../yaruma/fightsystem/fight/FightPlayer.java | 49 ++++ .../yaruma/fightsystem/fight/FightState.java | 9 + .../yaruma/fightsystem/fight/FightTeam.java | 140 ++++++++++ .../listener/BlockBreakListener.java | 32 +++ .../listener/BlockPlaceListener.java | 32 +++ .../listener/PlayerChatListener.java | 46 ++++ .../listener/PlayerDeathListener.java | 32 +++ .../listener/PlayerInteractListener.java | 86 ++++++ .../listener/PlayerJoinListener.java | 62 +++++ .../listener/PlayerMoveListener.java | 32 +++ .../listener/PlayerQuitListener.java | 43 +++ .../fightsystem/manager/FileManager.java | 77 ++++++ .../yaruma/fightsystem/utils/Coordinates.java | 85 ++++++ .../yaruma/fightsystem/utils/ItemBuilder.java | 61 +++++ src/me/yaruma/fightsystem/utils/Region.java | 17 ++ .../yaruma/fightsystem/utils/WorldEdit.java | 50 ++++ .../utils/countdown/Countdown.java | 57 ++++ .../utils/countdown/CountdownCallback.java | 9 + .../countdown/FinishNoPlayersOnline.java | 17 ++ .../utils/countdown/FinishNoneEntern.java | 16 ++ .../utils/countdown/FinishPreRunning.java | 24 ++ .../utils/countdown/FinishSetupOver.java | 17 ++ .../utils/countdown/FinishSpectateOver.java | 17 ++ .../utils/countdown/FinishTimeOver.java | 16 ++ .../utils/inventory/SetupItems.java | 18 ++ 32 files changed, 1599 insertions(+) create mode 100644 config.yml create mode 100644 plugin.yml create mode 100644 src/me/yaruma/fightsystem/FightSystem.java create mode 100644 src/me/yaruma/fightsystem/commands/AkCommand.java create mode 100644 src/me/yaruma/fightsystem/fight/Fight.java create mode 100644 src/me/yaruma/fightsystem/fight/FightCreator.java create mode 100644 src/me/yaruma/fightsystem/fight/FightManager.java create mode 100644 src/me/yaruma/fightsystem/fight/FightPlayer.java create mode 100644 src/me/yaruma/fightsystem/fight/FightState.java create mode 100644 src/me/yaruma/fightsystem/fight/FightTeam.java create mode 100644 src/me/yaruma/fightsystem/listener/BlockBreakListener.java create mode 100644 src/me/yaruma/fightsystem/listener/BlockPlaceListener.java create mode 100644 src/me/yaruma/fightsystem/listener/PlayerChatListener.java create mode 100644 src/me/yaruma/fightsystem/listener/PlayerDeathListener.java create mode 100644 src/me/yaruma/fightsystem/listener/PlayerInteractListener.java create mode 100644 src/me/yaruma/fightsystem/listener/PlayerJoinListener.java create mode 100644 src/me/yaruma/fightsystem/listener/PlayerMoveListener.java create mode 100644 src/me/yaruma/fightsystem/listener/PlayerQuitListener.java create mode 100644 src/me/yaruma/fightsystem/manager/FileManager.java create mode 100644 src/me/yaruma/fightsystem/utils/Coordinates.java create mode 100644 src/me/yaruma/fightsystem/utils/ItemBuilder.java create mode 100644 src/me/yaruma/fightsystem/utils/Region.java create mode 100644 src/me/yaruma/fightsystem/utils/WorldEdit.java create mode 100644 src/me/yaruma/fightsystem/utils/countdown/Countdown.java create mode 100644 src/me/yaruma/fightsystem/utils/countdown/CountdownCallback.java create mode 100644 src/me/yaruma/fightsystem/utils/countdown/FinishNoPlayersOnline.java create mode 100644 src/me/yaruma/fightsystem/utils/countdown/FinishNoneEntern.java create mode 100644 src/me/yaruma/fightsystem/utils/countdown/FinishPreRunning.java create mode 100644 src/me/yaruma/fightsystem/utils/countdown/FinishSetupOver.java create mode 100644 src/me/yaruma/fightsystem/utils/countdown/FinishSpectateOver.java create mode 100644 src/me/yaruma/fightsystem/utils/countdown/FinishTimeOver.java create mode 100644 src/me/yaruma/fightsystem/utils/inventory/SetupItems.java diff --git a/config.yml b/config.yml new file mode 100644 index 0000000..dfefe28 --- /dev/null +++ b/config.yml @@ -0,0 +1,42 @@ +Times: + SetupDuration: 0 + PreFightDuration: 0 + FightDuration: 0 + EnterPhaseBegin: 0 + SpectatorDuration: 0 + +Arena: + WorldName: + Schemsize: + x: 0 + y: 0 + z: 0 + Team1corner: + x: 0 + y: 0 + z: 0 + Team1toTeam2distance: + x: 0 + y: 0 + z: 0 + Schem2Border: + x: 0 + z: 0 + underArenaBorder: 0 + BorderFromWarGear: 0 + +Output: + TeamRedColor: &c + TeamBlueColor: &3 + TeamRedName: Team1 + TeamBlueName: Team2 + GameName: AirWargear + TeamChatDetection: + + +ActiveWinConditions: + - Timeout + - AllDead + - CaptainDead + +WinConditionParams: + TimeoutTime: 0 diff --git a/plugin.yml b/plugin.yml new file mode 100644 index 0000000..cded55f --- /dev/null +++ b/plugin.yml @@ -0,0 +1,8 @@ +name: FightSystem +version: 1.0 +author: Yaruma3341 +main: me.yaruma.fightsystem.FightSystem +depend: [WorldEdit, FastAsyncWorldEdit] + +commands: + ak: \ No newline at end of file diff --git a/src/me/yaruma/fightsystem/FightSystem.java b/src/me/yaruma/fightsystem/FightSystem.java new file mode 100644 index 0000000..a8df71c --- /dev/null +++ b/src/me/yaruma/fightsystem/FightSystem.java @@ -0,0 +1,251 @@ +package me.yaruma.fightsystem; + +import com.sk89q.worldedit.bukkit.WorldEditPlugin; +import me.yaruma.fightsystem.commands.AkCommand; +import me.yaruma.fightsystem.fight.FightManager; +import me.yaruma.fightsystem.fight.FightState; +import me.yaruma.fightsystem.listener.*; +import me.yaruma.fightsystem.manager.FileManager; +import me.yaruma.fightsystem.utils.Coordinates; +import me.yaruma.fightsystem.utils.countdown.Countdown; +import me.yaruma.fightsystem.utils.countdown.FinishSetupOver; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.plugin.PluginManager; +import org.bukkit.plugin.java.JavaPlugin; + +import java.io.File; + +public class FightSystem extends JavaPlugin { + + public static String PREFIX = "[FightSystem] "; + public static String NOPERM = PREFIX + "§4Du darfst das nicht!"; + + private static FightSystem plugin; + private FileManager fileManager; + private FightManager fightManager; + private Coordinates coordinates; + + private FightState fightState; + + + public Location Team1SpawnLoc = null; + public Location Team2SpawnLoc = null; + public Location Team1PasteLoc = null; + public Location Team2PasteLoc = null; + + public int ArenaMinX; + public int ArenaMaxX; + public int ArenaMinZ; + public int ArenaMaxZ; + + public int schemsizeX; + public int schemsizeY; + public int schemsizeZ; + + public int team1cornerX; + public int team1cornerY; + public int team1cornerZ; + + public void onEnable() { + + plugin = this; + this.fileManager = new FileManager(plugin); + this.fightManager = new FightManager(); + this.coordinates = new Coordinates(); + + int schemsizeX = this.schemsizeX = fileManager.getIntegerFromConfig("Arena.Schemsize.x"); + int schemsizeY = this.schemsizeZ = fileManager.getIntegerFromConfig("Arena.Schemsize.y"); + int schemsizeZ = this.schemsizeY = fileManager.getIntegerFromConfig("Arena.Schemsize.z"); + + int team1cornerX = this.team1cornerX = fileManager.getIntegerFromConfig("Arena.Team1corner.x"); + int team1cornerY = this.team1cornerY = fileManager.getIntegerFromConfig("Arena.Team1corner.y"); + int team1cornerZ = this.team1cornerZ = fileManager.getIntegerFromConfig("Arena.Team1corner.z"); + + int team1toTeam2distanceX = fileManager.getIntegerFromConfig("Arena.Team1toTeam2distance.x"); + int team1toTeam2distanceY = fileManager.getIntegerFromConfig("Arena.Team1toTeam2distance.y"); + int team1toTeam2distanceZ = fileManager.getIntegerFromConfig("Arena.Team1toTeam2distance.z"); + + int schem2BorderX = fileManager.getIntegerFromConfig("Arena.Schem2Border.x"); + int schem2BorderZ = fileManager.getIntegerFromConfig("Arena.Schem2Border.z"); + + + + coordinates.computePositions(schemsizeX, schemsizeY, schemsizeZ, team1cornerX, team1cornerY, team1cornerZ, team1toTeam2distanceX, team1toTeam2distanceY, team1toTeam2distanceZ, schem2BorderX, schem2BorderZ); + + loadConfig(); + + init(); + + fightState = FightState.SETUP; + int setupDuration = fileManager.getIntegerFromConfig("Times.SetupDuration"); + Countdown countdown = new Countdown(setupDuration, new FinishSetupOver()); + countdown.startTimer(getPlugin()); + + System.out.println(PREFIX + "§aPlugin gestartet!"); + } + + public void onDisable() { + + System.out.println(PREFIX + "§cPlugin deaktiviert!"); + + } + + public void init() { + PluginManager pm = Bukkit.getPluginManager(); + pm.registerEvents(new PlayerJoinListener(), plugin); + pm.registerEvents(new PlayerQuitListener(), plugin); + pm.registerEvents(new PlayerDeathListener(), plugin); + pm.registerEvents(new PlayerInteractListener(), plugin); + pm.registerEvents(new PlayerChatListener(), plugin); + pm.registerEvents(new BlockPlaceListener(), plugin); + pm.registerEvents(new BlockBreakListener(), plugin); + + getCommand("ak").setExecutor(new AkCommand()); + } + + public void loadConfig() { + if(!new File("plugins/" + this.getName() + "/config.yml").exists()) { + saveDefaultConfig(); + System.out.println(PREFIX + "config.yml erstellt und geladen!"); + Bukkit.shutdown(); + } + } + + public static FightSystem getPlugin() { + return plugin; + } + + public FightState getCurrentFightState() { + return fightState; + } + + public FileManager getFileManager() { + return this.fileManager; + } + + public FightManager getFightManager() { + return this.fightManager; + } + + public FightState getFightState() { + return fightState; + } + + public void setSetupState() { + if(this.fightState == null) { + this.fightState = FightState.SETUP; + } + } + + public void setPreRunningState() { + if(this.fightState == FightState.SETUP) { + this.fightState = FightState.PRE_RUNNING; + } + } + + public void setRunningState() { + if(this.fightState == FightState.PRE_RUNNING) { + this.fightState = FightState.RUNNING; + } + } + + public void setSpectateState() { + if(this.fightState == FightState.RUNNING) { + this.fightState = FightState.SPECTATE; + } + } + + public static WorldEditPlugin getWorldEditPlugin() { + return (WorldEditPlugin) Bukkit.getPluginManager().getPlugin("WorldEdit"); + } + + + public Location getTeam1SpawnLoc() { + return Team1SpawnLoc; + } + + public Location getTeam2SpawnLoc() { + return Team2SpawnLoc; + } + + public Location getTeam1PasteLoc() { + return Team1PasteLoc; + } + + public Location getTeam2PasteLoc() { + return Team2PasteLoc; + } + + public int getArenaMinX() { + return ArenaMinX; + } + + public int getArenaMaxX() { + return ArenaMaxX; + } + + public int getArenaMinZ() { + return ArenaMinZ; + } + + public int getArenaMaxZ() { + return ArenaMaxZ; + } + + public int getSchemsizeX() { + return schemsizeX; + } + + public int getSchemsizeY() { + return schemsizeY; + } + + public int getSchemsizeZ() { + return schemsizeZ; + } + + public int getTeam1cornerX() { + return team1cornerX; + } + + public int getTeam1cornerY() { + return team1cornerY; + } + + public int getTeam1cornerZ() { + return team1cornerZ; + } + + public void setTeam1SpawnLoc(Location team1SpawnLoc) { + Team1SpawnLoc = team1SpawnLoc; + } + + public void setTeam2SpawnLoc(Location team2SpawnLoc) { + Team2SpawnLoc = team2SpawnLoc; + } + + public void setTeam1PasteLoc(Location team1PasteLoc) { + Team1PasteLoc = team1PasteLoc; + } + + public void setTeam2PasteLoc(Location team2PasteLoc) { + Team2PasteLoc = team2PasteLoc; + } + + public void setArenaMinX(int arenaMinX) { + ArenaMinX = arenaMinX; + } + + public void setArenaMaxX(int arenaMaxX) { + ArenaMaxX = arenaMaxX; + } + + public void setArenaMinZ(int arenaMinZ) { + ArenaMinZ = arenaMinZ; + } + + public void setArenaMaxZ(int arenaMaxZ) { + ArenaMaxZ = arenaMaxZ; + } +} diff --git a/src/me/yaruma/fightsystem/commands/AkCommand.java b/src/me/yaruma/fightsystem/commands/AkCommand.java new file mode 100644 index 0000000..9c1e085 --- /dev/null +++ b/src/me/yaruma/fightsystem/commands/AkCommand.java @@ -0,0 +1,159 @@ +package me.yaruma.fightsystem.commands; + +import me.yaruma.fightsystem.FightSystem; +import me.yaruma.fightsystem.fight.Fight; +import me.yaruma.fightsystem.fight.FightPlayer; +import me.yaruma.fightsystem.fight.FightState; +import me.yaruma.fightsystem.fight.FightTeam; +import me.yaruma.fightsystem.manager.FileManager; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class AkCommand implements CommandExecutor { + + FileManager fileManager = FightSystem.getPlugin().getFileManager(); + + @Override + public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { + + if(sender instanceof Player) { + Player player = (Player) sender; + + if(args.length == 0) { + sendHelp(player); + } + + if(args.length == 1) { + + if(args[0].equalsIgnoreCase("help")) { + sendHelp(player); + return false; + } + + if(args[0].equalsIgnoreCase("ready")) { + if(FightSystem.getPlugin().getFightState() == FightState.SETUP) { + FightTeam fightTeam = Fight.getPlayerTeam(player); + if(fightTeam != null) { + if(!fightTeam.isReady()) { + fightTeam.setReady(true); + fightTeam.broadcast(FightSystem.PREFIX + "§aEuer Team ist nun bereit!"); + } else { + fightTeam.setReady(false); + fightTeam.broadcast(FightSystem.PREFIX + "§cEuer Team ist nicht mehr bereit!"); + } + } + } + return false; + } + + if(args[0].equalsIgnoreCase("accept")) { + if(FightSystem.getPlugin().getFightState() == FightState.SETUP) { + if(Fight.getRedTeam().getInvited().contains(player)) { + FightPlayer leader = Fight.getRedTeam().getLeader(); + Fight.getRedTeam().addMember(player); + player.sendMessage(FightSystem.PREFIX + "§aDu bist dem Team von §6" + leader.getPlayer().getName() + " §abeigetreten!"); + leader.sendMessage(FightSystem.PREFIX + "§aDer Spieler §6" + player.getName() + " §aist deinem Team beigetreten"); + } + + if(Fight.getBlueTeam().getInvited().contains(player)) { + FightPlayer leader = Fight.getRedTeam().getLeader(); + Fight.getRedTeam().addMember(player); + player.sendMessage(FightSystem.PREFIX + "§aDu bist dem Team von §6" + leader.getPlayer().getName() + " §abeigetreten!"); + leader.sendMessage(FightSystem.PREFIX + "§aDer Spieler §6" + player.getName() + " §aist deinem Team beigetreten"); + } + } + return false; + } + + if(args[0].equalsIgnoreCase("decline")) { + if(FightSystem.getPlugin().getFightState() == FightState.SETUP) { + if(Fight.getRedTeam().getInvited().contains(player)) { + FightPlayer leader = Fight.getRedTeam().getLeader(); + Fight.getRedTeam().getInvited().remove(player); + player.sendMessage(FightSystem.PREFIX + "§aDu hast die Einladung von §6" + leader.getPlayer().getName() + " §aabgelehnt!"); + leader.sendMessage(FightSystem.PREFIX + "§cDer Spieler §6" + player.getName() + " §chat deine Einladung abgelehnt!"); + } + + if(Fight.getBlueTeam().getInvited().contains(player)) { + FightPlayer leader = Fight.getBlueTeam().getLeader(); + Fight.getBlueTeam().getInvited().remove(player); + player.sendMessage(FightSystem.PREFIX + "§aDu hast die Einladung von §6" + leader.getPlayer().getName() + " §aabgelehnt!"); + leader.sendMessage(FightSystem.PREFIX + "§cDer Spieler §6" + player.getName() + " §chat deine Einladung abgelehnt!"); + } + } + return false; + } + + if(args[0].equalsIgnoreCase("leader")) { + if(!Fight.getBlueTeam().hasTeamLeader()) { + FightPlayer fightPlayer = new FightPlayer(player, false); + Fight.getBlueTeam().setLeader(fightPlayer); + player.sendMessage(FightSystem.PREFIX + "§aDu bist nun Leader von " + fileManager.getStringFromConfig("Output.TeamBlueColor") + fileManager.getStringFromConfig("Output.TeamBlueName")); + return false; + } else if(!Fight.getRedTeam().hasTeamLeader()) { + FightPlayer fightPlayer = new FightPlayer(player, false); + Fight.getBlueTeam().setLeader(fightPlayer); + player.sendMessage(FightSystem.PREFIX + "§aDu bist nun Leader von " + fileManager.getStringFromConfig("Output.TeamRedColor") + fileManager.getStringFromConfig("Output.TeamRedName")); + return false; + } else + player.sendMessage(FightSystem.PREFIX + "§cEs sind bereits zwei Leader vorhanden!"); + return false; + } + } + + if(args.length == 2) { + + if(args[0].equalsIgnoreCase("invite")) { + if(FightSystem.getPlugin().getFightState() == FightState.SETUP) { + FightTeam fightTeam = Fight.getPlayerTeam(player); + if(fightTeam != null) { + FightPlayer fightPlayer = fightTeam.getFightPlayer(player); + if(fightPlayer.isLeader()) { + + Player target = Bukkit.getPlayer(args[1]); + if(target != null) { + if(!(Fight.getOpposite(fightTeam).getInvited().contains(player) && fightTeam.getInvited().contains(target))) { + fightTeam.getInvited().add(target); + player.sendMessage(FightSystem.PREFIX + "§aDu hast den Spieler §6" + target.getName() + " §ain dein Team eingeladen!"); + } else + player.sendMessage(FightSystem.PREFIX + "§cDieser Spieler wurde bereits eingeladen!"); + } else + player.sendMessage(FightSystem.PREFIX + "§cDieser Spieler ist nicht online!"); + } else + player.sendMessage(FightSystem.PREFIX + "§cDu bist nicht der Leader des Teams!"); + } + } + return false; + } + + if(args[0].equalsIgnoreCase("remove")) { + if(FightSystem.getPlugin().getFightState() == FightState.SETUP) { + FightTeam fightTeam = Fight.getPlayerTeam(player); + if(fightTeam != null) { + Player target = Bukkit.getPlayer(args[1]); + if(target != null) { + FightPlayer fightPlayer = fightTeam.getFightPlayer(player); + if(fightPlayer.isLeader()) { + if(fightTeam.isPlayerInTeam(target)) { + fightTeam.removePlayer(target); + player.sendMessage(FightSystem.PREFIX + "§aDu hast den Spieler §6" + target.getName() + " §aaus dem Team entfernt!"); + target.sendMessage(FightSystem.PREFIX + "§4Du wurdest auf deinem Team entfernt!"); + } + } + } + } + } + return false; + } + } + } + return false; + } + + private void sendHelp(Player player) { + player.sendMessage("-----[ Hilfe ]-----"); + } +} diff --git a/src/me/yaruma/fightsystem/fight/Fight.java b/src/me/yaruma/fightsystem/fight/Fight.java new file mode 100644 index 0000000..6abe334 --- /dev/null +++ b/src/me/yaruma/fightsystem/fight/Fight.java @@ -0,0 +1,43 @@ +package me.yaruma.fightsystem.fight; + +import org.bukkit.entity.Player; + +public class Fight { + + public static FightTeam redTeam; + public static FightTeam blueTeam; + + + public static FightTeam getPlayerTeam(Player player) { + if(redTeam.isPlayerInTeam(player)) { + return redTeam; + } + if(blueTeam.isPlayerInTeam(player)) { + return blueTeam; + } + return null; + } + + public static FightTeam getOpposite(FightTeam fightTeam) { + if(fightTeam == redTeam) { + return blueTeam; + } + if(fightTeam == blueTeam) { + return redTeam; + } + return null; + } + + public void broadcast(String message) { + blueTeam.broadcast(message); + redTeam.broadcast(message); + } + + public static FightTeam getRedTeam() { + return redTeam; + } + + public static FightTeam getBlueTeam() { + return blueTeam; + } +} diff --git a/src/me/yaruma/fightsystem/fight/FightCreator.java b/src/me/yaruma/fightsystem/fight/FightCreator.java new file mode 100644 index 0000000..69c38fb --- /dev/null +++ b/src/me/yaruma/fightsystem/fight/FightCreator.java @@ -0,0 +1,12 @@ +package me.yaruma.fightsystem.fight; + +import org.bukkit.entity.Player; + +public class FightCreator { + + public static void invitePlayerToTeam(Player player) { + + } + + +} diff --git a/src/me/yaruma/fightsystem/fight/FightManager.java b/src/me/yaruma/fightsystem/fight/FightManager.java new file mode 100644 index 0000000..5ad0b25 --- /dev/null +++ b/src/me/yaruma/fightsystem/fight/FightManager.java @@ -0,0 +1,40 @@ +package me.yaruma.fightsystem.fight; + +import me.yaruma.fightsystem.FightSystem; +import me.yaruma.fightsystem.manager.FileManager; +import org.bukkit.Location; +import org.bukkit.entity.Player; + +public class FightManager { + + public FileManager fileManager = FightSystem.getPlugin().getFileManager(); + + public void teleportAllToFightSpawn() { + + for(FightPlayer fightPlayer : Fight.getBlueTeam().getPlayers()) { + fightPlayer.getPlayer().teleport(getBlueTeleportLocation()); + } + for(FightPlayer fightPlayer : Fight.getRedTeam().getPlayers()) { + fightPlayer.getPlayer().teleport(getRedTeleportLocation()); + } + + } + + public Location getBlueTeleportLocation() { + return FightSystem.getPlugin().getTeam1SpawnLoc(); + } + + public Location getRedTeleportLocation() { + return FightSystem.getPlugin().getTeam2SpawnLoc(); + } + + public Location getBlueTeamPasteLocation() { + return null; + } + + public Location getRedTeamPasteLocation() { + return null; + } + + +} diff --git a/src/me/yaruma/fightsystem/fight/FightPlayer.java b/src/me/yaruma/fightsystem/fight/FightPlayer.java new file mode 100644 index 0000000..cb05c92 --- /dev/null +++ b/src/me/yaruma/fightsystem/fight/FightPlayer.java @@ -0,0 +1,49 @@ +package me.yaruma.fightsystem.fight; + +import org.bukkit.entity.Player; + +public class FightPlayer { + + private final Player player; + private boolean isOut; + + public boolean equals(Object obj) { + if (!(obj instanceof Player)) { + return false; + } + Player comp = (Player)obj; + return this.player.getUniqueId().equals(comp.getUniqueId()); + } + + public void sendMessage(String message) { + if (this.player.isOnline()) { + this.player.sendMessage(message); + } + } + + public FightPlayer(Player player, boolean isOut) { + this.player = player; + this.isOut = isOut; + } + + public void setOut(boolean isOut) { + this.isOut = isOut; + } + + public Player getPlayer() { + return this.player; + } + + public boolean isOut() { + return this.isOut; + } + + public boolean isLeader() { + if(Fight.getPlayerTeam(player).getLeader().getPlayer() == player) { + return true; + } else + return false; + } + + +} diff --git a/src/me/yaruma/fightsystem/fight/FightState.java b/src/me/yaruma/fightsystem/fight/FightState.java new file mode 100644 index 0000000..3df2b81 --- /dev/null +++ b/src/me/yaruma/fightsystem/fight/FightState.java @@ -0,0 +1,9 @@ +package me.yaruma.fightsystem.fight; + +public enum FightState { + + SETUP, + PRE_RUNNING, + RUNNING, + SPECTATE; +} diff --git a/src/me/yaruma/fightsystem/fight/FightTeam.java b/src/me/yaruma/fightsystem/fight/FightTeam.java new file mode 100644 index 0000000..451e620 --- /dev/null +++ b/src/me/yaruma/fightsystem/fight/FightTeam.java @@ -0,0 +1,140 @@ +package me.yaruma.fightsystem.fight; + +import me.yaruma.fightsystem.FightSystem; +import org.bukkit.entity.Player; + +import java.util.ArrayList; + +public class FightTeam { + + private FightPlayer leader; + private ArrayList players; + private FightSystem plugin; + private boolean ready; + private ArrayList invited; + + public FightTeam(Player leader, FightSystem plugin) { + this.plugin = plugin; + this.leader = new FightPlayer(leader, false); + this.players = new ArrayList<>(); + this.invited = new ArrayList<>(); + } + + public FightPlayer getFightPlayer(Player player) { + if(this.leader.getPlayer().equals(player)) { + return this.leader; + } + for(FightPlayer fightPlayer : this.players) { + if(!fightPlayer.getPlayer().equals(player)) continue; + return fightPlayer; + } + return null; + } + + public void setPlayerOut(Player player) { + this.getFightPlayer(player).setOut(true); + } + + public boolean allPlayersOut() { + boolean allout = true; + if(!this.leader.isOut()) { + allout = false; + } + for(FightPlayer fightPlayer : this.players) { + if(fightPlayer.isOut()) continue; + allout = false; + } + return allout; + } + + public boolean isPlayerInTeam(Player player) { + if(this.leader.getPlayer().equals(player)) { + return true; + } + for(FightPlayer fightPlayer : this.players) { + if(!fightPlayer.getPlayer().equals(player)) continue; + return true; + } + return false; + } + + public boolean isPlayerLeader(Player player) { + if(this.leader.getPlayer().equals(player)) { + return true; + } + return false; + } + + public boolean isPlayerMember(Player player) { + for(FightPlayer fightPlayer : this.players) { + if(!fightPlayer.getPlayer().equals(player)) continue; + return true; + } + return false; + } + + public void broadcast(String message) { + this.leader.sendMessage(message); + for(FightPlayer fightPlayer : this.players) { + fightPlayer.sendMessage(message); + } + } + + public void addMember(Player player) { + FightPlayer fightPlayer = new FightPlayer(player, false); + this.players.add(fightPlayer); + this.invited.remove(player); + } + + public void removePlayer(Player player) { + FightPlayer fightPlayer = Fight.getPlayerTeam(player).getFightPlayer(player); + this.players.remove(fightPlayer); + } + + public boolean hasTeamLeader() { + if(this.leader != null) { + return true; + } else + return false; + } + + public FightPlayer getLeader() { + return leader; + } + + public void setLeader(FightPlayer leader) { + this.leader = leader; + } + + public ArrayList getPlayers() { + return players; + } + + public void setPlayers(ArrayList players) { + this.players = players; + } + + public FightSystem getPlugin() { + return plugin; + } + + public void setPlugin(FightSystem plugin) { + this.plugin = plugin; + } + + public boolean isReady() { + return ready; + } + + public void setReady(boolean ready) { + this.ready = ready; + } + + public ArrayList getInvited() { + return invited; + } + + public void setInvited(ArrayList invited) { + this.invited = invited; + } +} diff --git a/src/me/yaruma/fightsystem/listener/BlockBreakListener.java b/src/me/yaruma/fightsystem/listener/BlockBreakListener.java new file mode 100644 index 0000000..c6280dc --- /dev/null +++ b/src/me/yaruma/fightsystem/listener/BlockBreakListener.java @@ -0,0 +1,32 @@ +package me.yaruma.fightsystem.listener; + +import me.yaruma.fightsystem.FightSystem; +import me.yaruma.fightsystem.fight.Fight; +import me.yaruma.fightsystem.fight.FightState; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockBreakEvent; + +public class BlockBreakListener implements Listener { + + @EventHandler + public void handleBlockBreak(BlockBreakEvent event) { + Player player = event.getPlayer(); + + if(Fight.getPlayerTeam(player) == null) { + event.setCancelled(true); + return; + } + if(FightSystem.getPlugin().getFightState() != FightState.RUNNING) { + event.setCancelled(true); + if(FightSystem.getPlugin().getFightState() == FightState.RUNNING || FightSystem.getPlugin().getFightState() == FightState.PRE_RUNNING) { + player.sendMessage(FightSystem.PREFIX + "§cDu darfst erst nach Fightbeginn Blöcke setzen!"); + } else + player.sendMessage(FightSystem.PREFIX + "§cDu darfst keine Blöcke mehr setzen!"); + return; + } + } + + +} diff --git a/src/me/yaruma/fightsystem/listener/BlockPlaceListener.java b/src/me/yaruma/fightsystem/listener/BlockPlaceListener.java new file mode 100644 index 0000000..0bd2911 --- /dev/null +++ b/src/me/yaruma/fightsystem/listener/BlockPlaceListener.java @@ -0,0 +1,32 @@ +package me.yaruma.fightsystem.listener; + +import me.yaruma.fightsystem.FightSystem; +import me.yaruma.fightsystem.fight.Fight; +import me.yaruma.fightsystem.fight.FightState; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockPlaceEvent; + +public class BlockPlaceListener implements Listener { + + @EventHandler + public void handleBlockPlace(BlockPlaceEvent event) { + Player player = event.getPlayer(); + + if(Fight.getPlayerTeam(player) == null) { + event.setCancelled(true); + return; + } + if(FightSystem.getPlugin().getFightState() != FightState.RUNNING) { + event.setCancelled(true); + if(FightSystem.getPlugin().getFightState() == FightState.RUNNING || FightSystem.getPlugin().getFightState() == FightState.PRE_RUNNING) { + player.sendMessage(FightSystem.PREFIX + "§cDu darfst erst nach Fightbeginn Blöcke setzen!"); + } else + player.sendMessage(FightSystem.PREFIX + "§cDu darfst keine Blöcke mehr setzen!"); + return; + } + } + + +} diff --git a/src/me/yaruma/fightsystem/listener/PlayerChatListener.java b/src/me/yaruma/fightsystem/listener/PlayerChatListener.java new file mode 100644 index 0000000..88b691b --- /dev/null +++ b/src/me/yaruma/fightsystem/listener/PlayerChatListener.java @@ -0,0 +1,46 @@ +package me.yaruma.fightsystem.listener; + +import me.yaruma.fightsystem.FightSystem; +import me.yaruma.fightsystem.fight.Fight; +import me.yaruma.fightsystem.fight.FightTeam; +import me.yaruma.fightsystem.manager.FileManager; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerChatEvent; + +public class PlayerChatListener implements Listener { + + FileManager fileManager = FightSystem.getPlugin().getFileManager(); + + @EventHandler + public void handlePlayerChat(PlayerChatEvent event) { + Player player = event.getPlayer(); + String message = event.getMessage(); + + String teamChatDetection = fileManager.getStringFromConfig("Output.TeamChatDetection"); + + if(message.startsWith(teamChatDetection)) { + FightTeam fightTeam = Fight.getPlayerTeam(player); + if(fightTeam != null) { + event.setCancelled(true); + fightTeam.broadcast("§5" + player.getName() + "§e--> §2" + message); + } + } else { + FightTeam fightTeam = Fight.getPlayerTeam(player); + if(fightTeam == Fight.redTeam) { + String prefixColorCode = fileManager.getStringFromConfig("Output.TeamRedColor"); + String teamName = fileManager.getStringFromConfig("Output.TeamRedName"); + Bukkit.broadcastMessage(prefixColorCode + teamName + " " + player.getName() + " §8>> " + message); + } + if(fightTeam == Fight.blueTeam) { + String prefixColorCode = fileManager.getStringFromConfig("Output.TeamBlueColor"); + String teamName = fileManager.getStringFromConfig("Output.TeamBlueName"); + Bukkit.broadcastMessage(prefixColorCode + teamName + " " + player.getName() + " §8>> " + message); + } + } + } + + +} diff --git a/src/me/yaruma/fightsystem/listener/PlayerDeathListener.java b/src/me/yaruma/fightsystem/listener/PlayerDeathListener.java new file mode 100644 index 0000000..d9bed34 --- /dev/null +++ b/src/me/yaruma/fightsystem/listener/PlayerDeathListener.java @@ -0,0 +1,32 @@ +package me.yaruma.fightsystem.listener; + +import me.yaruma.fightsystem.FightSystem; +import me.yaruma.fightsystem.fight.Fight; +import me.yaruma.fightsystem.fight.FightTeam; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.PlayerDeathEvent; + +public class PlayerDeathListener implements Listener { + + @EventHandler + public void handlePlayerDeath(PlayerDeathEvent event) { + Player player = event.getEntity(); + if(Fight.getPlayerTeam(player) == null) return; + FightTeam fightTeam = Fight.getPlayerTeam(player); + FightTeam oppositeFightTeam = Fight.getOpposite(fightTeam); + fightTeam.getFightPlayer(player).setOut(true); + Bukkit.broadcastMessage(FightSystem.PREFIX + "§cDer Spieler §6" + player.getName() + " §cist gestorben!"); + if(fightTeam.allPlayersOut()) { + FightSystem.getPlugin().setSpectateState(); + Bukkit.broadcastMessage(FightSystem.PREFIX + "§cAlle Spieler aus dem Team von " + fightTeam.getLeader().getPlayer().getName() + " §csind gestorben!"); + Bukkit.broadcastMessage(" "); + Bukkit.broadcastMessage(FightSystem.PREFIX + "§aDas Team von §6" + oppositeFightTeam.getLeader().getPlayer().getName() + " §ahat gewonnen!"); + FightSystem.getPlugin().getFightManager().teleportAllToFightSpawn(); + } + } + + +} diff --git a/src/me/yaruma/fightsystem/listener/PlayerInteractListener.java b/src/me/yaruma/fightsystem/listener/PlayerInteractListener.java new file mode 100644 index 0000000..9e07b7e --- /dev/null +++ b/src/me/yaruma/fightsystem/listener/PlayerInteractListener.java @@ -0,0 +1,86 @@ +package me.yaruma.fightsystem.listener; + +import me.yaruma.fightsystem.FightSystem; +import me.yaruma.fightsystem.fight.Fight; +import me.yaruma.fightsystem.fight.FightPlayer; +import me.yaruma.fightsystem.fight.FightState; +import me.yaruma.fightsystem.fight.FightTeam; +import me.yaruma.fightsystem.manager.FileManager; +import me.yaruma.fightsystem.utils.ItemBuilder; +import me.yaruma.fightsystem.utils.WorldEdit; +import me.yaruma.fightsystem.utils.countdown.Countdown; +import me.yaruma.fightsystem.utils.countdown.FinishNoPlayersOnline; +import me.yaruma.fightsystem.utils.countdown.FinishPreRunning; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.enchantments.Enchantment; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.inventory.meta.ItemMeta; + +public class PlayerInteractListener implements Listener { + + FileManager fileManager = FightSystem.getPlugin().getFileManager(); + FightSystem instance = FightSystem.getPlugin(); + + @EventHandler + public void handlePlayerInteract(PlayerInteractEvent event) { + Player player = event.getPlayer(); + Material material = event.getItem().getType(); + ItemMeta itemMeta = event.getItem().getItemMeta(); + String displayName = itemMeta.getDisplayName(); + + if(instance.getFightState() == FightState.SETUP) { + if(Fight.getPlayerTeam(player) == null) return; + FightPlayer fightPlayer = Fight.getPlayerTeam(player).getFightPlayer(player); + if(fightPlayer.isLeader()) { + + if(material == null) return; + if(material == Material.INK_SACK) { + + FightTeam fightTeam = Fight.getPlayerTeam(player); + + switch (displayName) { + case "§cNicht bereit": + fightTeam.setReady(true); + fightPlayer.getPlayer().getInventory().setItem(3, new ItemBuilder(Material.INK_SACK, (short) 8).removeAllAtributs().addEnchantment(Enchantment.DURABILITY,1 ).setDisplayName("§aBereit").build()); + fightTeam.broadcast(FightSystem.PREFIX + "§aEuer Team ist nun bereit!"); + if(Fight.getOpposite(fightTeam).isReady()) { + FightSystem.getPlugin().setPreRunningState(); + int time = fileManager.getIntegerFromConfig("Times.PreFightDuration"); + Countdown countdown = new Countdown(time, new FinishPreRunning()); + countdown.startTimer(FightSystem.getPlugin()); + for(FightPlayer allFightPlayers : fightTeam.getPlayers()) { + allFightPlayers.getPlayer().getInventory().clear(); + } + for(FightPlayer allFightPlayers : Fight.getOpposite(fightTeam).getPlayers()) { + allFightPlayers.getPlayer().getInventory().clear(); + } + FightSystem.getPlugin().getFightManager().teleportAllToFightSpawn(); + WorldEdit.replace(player, instance.getTeam1cornerX(), instance.getTeam1cornerY(), instance.getTeam1cornerZ(), instance.getSchemsizeX(), instance.getSchemsizeY(), instance.getSchemsizeZ()); + } + break; + case "§aBereit": + fightTeam.setReady(false); + fightPlayer.getPlayer().getInventory().setItem(3, new ItemBuilder(Material.INK_SACK, (short) 10).removeAllAtributs().addEnchantment(Enchantment.DURABILITY, 1).setDisplayName("§cNicht bereit").build()); + fightTeam.broadcast(FightSystem.PREFIX + "§cEuer Team ist nicht mehr bereit!"); + break; + case "§4Abbrechen": + Bukkit.broadcastMessage(FightSystem.PREFIX + "§6Das Team von §a" + fightTeam.getLeader().getPlayer().getName() + " §6hat den Kampf abgebrochen! \n Server stoppt in 30 Sekunden..."); + Countdown countdown = new Countdown(20*30, new FinishNoPlayersOnline()); + countdown.startTimer(instance); + break; + + default: + event.setCancelled(true); + break; + } + } + } + } + } + + +} diff --git a/src/me/yaruma/fightsystem/listener/PlayerJoinListener.java b/src/me/yaruma/fightsystem/listener/PlayerJoinListener.java new file mode 100644 index 0000000..8bb7fbd --- /dev/null +++ b/src/me/yaruma/fightsystem/listener/PlayerJoinListener.java @@ -0,0 +1,62 @@ +package me.yaruma.fightsystem.listener; + +import me.yaruma.fightsystem.FightSystem; +import me.yaruma.fightsystem.fight.Fight; +import me.yaruma.fightsystem.fight.FightPlayer; +import me.yaruma.fightsystem.fight.FightState; +import me.yaruma.fightsystem.fight.FightTeam; +import me.yaruma.fightsystem.utils.inventory.SetupItems; +import org.bukkit.Bukkit; +import org.bukkit.GameMode; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; + +public class PlayerJoinListener implements Listener { + + @EventHandler + public void handlePlayerJoin(PlayerJoinEvent event) { + Player player = event.getPlayer(); + if (Fight.getPlayerTeam(player) == null) { + player.setGameMode(GameMode.SPECTATOR); + return; + } + + FightTeam fightTeam = Fight.getPlayerTeam(player); + FightPlayer fightPlayer = fightTeam.getFightPlayer(player); + if (fightTeam == Fight.blueTeam) { + if (FightSystem.getPlugin().getFightState() == FightState.SETUP) { + player.teleport(FightSystem.getPlugin().getFightManager().getBlueTeleportLocation()); + player.setGameMode(GameMode.SURVIVAL); + player.setHealth(20); + player.setFoodLevel(20); + player.getInventory().clear(); + if(fightPlayer.isLeader()) SetupItems.giveSetupItems(player); + if(fightPlayer.isOut()) { + fightPlayer.setOut(false); + Bukkit.broadcastMessage(FightSystem.PREFIX + "§aDer Spieler §6" + fightPlayer.getPlayer().getName() + " §aist dem Kampf wieder beigetreten!"); + } + } else + player.setGameMode(GameMode.SPECTATOR); + } + + if (fightTeam == Fight.redTeam) { + if (FightSystem.getPlugin().getFightState() == FightState.SETUP) { + player.teleport(FightSystem.getPlugin().getFightManager().getRedTeleportLocation()); + player.setGameMode(GameMode.SURVIVAL); + player.setHealth(20); + player.setFoodLevel(20); + player.getInventory().clear(); + if(fightPlayer.isLeader()) SetupItems.giveSetupItems(player); + if(fightPlayer.isOut()) { + fightPlayer.setOut(false); + Bukkit.broadcastMessage(FightSystem.PREFIX + "§aDer Spieler §6" + fightPlayer.getPlayer().getName() + " §aist dem Kampf wieder beigetreten!"); + } + } else + player.setGameMode(GameMode.SPECTATOR); + } + } + + +} diff --git a/src/me/yaruma/fightsystem/listener/PlayerMoveListener.java b/src/me/yaruma/fightsystem/listener/PlayerMoveListener.java new file mode 100644 index 0000000..72f9af8 --- /dev/null +++ b/src/me/yaruma/fightsystem/listener/PlayerMoveListener.java @@ -0,0 +1,32 @@ +package me.yaruma.fightsystem.listener; + +import me.yaruma.fightsystem.FightSystem; +import me.yaruma.fightsystem.fight.Fight; +import me.yaruma.fightsystem.fight.FightTeam; +import me.yaruma.fightsystem.utils.Region; +import org.bukkit.Location; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerMoveEvent; + +public class PlayerMoveListener implements Listener { + + FightSystem instance = FightSystem.getPlugin(); + + @EventHandler + public void handlePlayerMove(PlayerMoveEvent event) { + Player player = event.getPlayer(); + Location to = event.getTo(); + Location from = event.getFrom(); + + if(!Region.isInRegion(to, instance.getTeam1cornerX(), instance.getTeam1cornerY(), instance.getTeam1cornerZ(), instance.getSchemsizeX(), instance.getSchemsizeY(), instance.getSchemsizeZ())) { + FightTeam fightTeam = Fight.getPlayerTeam(player); + if(fightTeam == Fight.redTeam) { + player.teleport(from); + } + } + } + + +} diff --git a/src/me/yaruma/fightsystem/listener/PlayerQuitListener.java b/src/me/yaruma/fightsystem/listener/PlayerQuitListener.java new file mode 100644 index 0000000..27879c1 --- /dev/null +++ b/src/me/yaruma/fightsystem/listener/PlayerQuitListener.java @@ -0,0 +1,43 @@ +package me.yaruma.fightsystem.listener; + +import me.yaruma.fightsystem.FightSystem; +import me.yaruma.fightsystem.fight.Fight; +import me.yaruma.fightsystem.fight.FightState; +import me.yaruma.fightsystem.fight.FightTeam; +import me.yaruma.fightsystem.utils.countdown.Countdown; +import me.yaruma.fightsystem.utils.countdown.FinishNoPlayersOnline; +import me.yaruma.fightsystem.utils.countdown.FinishSpectateOver; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerQuitEvent; + +public class PlayerQuitListener implements Listener { + + @EventHandler + public void handlePlayerQuit(PlayerQuitEvent event) { + + Player player = event.getPlayer(); + if(Fight.getPlayerTeam(player) == null) return; + FightTeam fightTeam = Fight.getPlayerTeam(player); + fightTeam.getFightPlayer(player).setOut(true); + Bukkit.broadcastMessage(FightSystem.PREFIX + "§cDer Spieler §6" + player.getName() + " §chat den Fight verlassen!"); + if(fightTeam.allPlayersOut()) { + if(FightSystem.getPlugin().getFightState() == FightState.SETUP) { + Bukkit.broadcastMessage(FightSystem.PREFIX + "§cAlle Spieler aus dem Team von §6" + fightTeam.getLeader().getPlayer() + " §csind tot oder haben den Kampf verlassen! \n §4Stoppe Server in 30 Sekunden..."); + Countdown countdown = new Countdown(30*20, new FinishNoPlayersOnline()); + countdown.startTimer(FightSystem.getPlugin()); + return; + } else { + Bukkit.broadcastMessage(FightSystem.PREFIX + "§cAlle Spieler aus dem Team von §6" + fightTeam.getLeader().getPlayer() + " §csind tot oder haben den Kampf verlassen! \n §60 Sekunden Zeit zum Begutachten!"); + Countdown cancelAllCountdowns = new Countdown(); + cancelAllCountdowns.cancelAllTimers(FightSystem.getPlugin()); + Countdown countdown = new Countdown(20*60, new FinishSpectateOver()); + countdown.startTimer(FightSystem.getPlugin()); + } + } + } + + +} diff --git a/src/me/yaruma/fightsystem/manager/FileManager.java b/src/me/yaruma/fightsystem/manager/FileManager.java new file mode 100644 index 0000000..ca4b6be --- /dev/null +++ b/src/me/yaruma/fightsystem/manager/FileManager.java @@ -0,0 +1,77 @@ +package me.yaruma.fightsystem.manager; + +import me.yaruma.fightsystem.FightSystem; +import java.io.File; +import java.io.IOException; + +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.World; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.FileConfigurationOptions; + +public class FileManager +{ + public File file; + public FileConfiguration config; + + public FileManager(FightSystem instance) { + this.config = instance.getConfig(); + this.config.options().copyDefaults(true); + this.file = new File(instance.getDataFolder(), "config.yml"); + instance.saveConfig(); + } + + public void reloadFiles(FightSystem instance) { + instance.reloadConfig(); + } + + public void addNewPath(String path, String data) { + if ((this.config.contains(path)) || (this.config.contains(data))) { + return; + } + this.config.set(path, data); + + save(); + } + + public String getStringFromConfig(String path) { + return this.config.getString(path).replaceAll("&", "§"); + } + + public int getIntegerFromConfig(String path) { + return this.config.getInt(path); + } + + public boolean getBooleanFromConfig(String path) { + return this.config.getBoolean(path); + } + + public File getFile() { + return this.file; + } + + public FileConfiguration getConfig() { + return this.config; + } + + public void save() { + try { + this.config.save(this.file); + } + catch (IOException e) { + e.printStackTrace(); + } + } + + public Location getLocationFormConfig(String path) { + + World world = Bukkit.getWorld(getStringFromConfig(path + ".world")); + int x = getIntegerFromConfig(path + ".x"); + int y = getIntegerFromConfig(path + ".y"); + int z = getIntegerFromConfig(path + ".z"); + + Location location = new Location(world, x, y, z); + return location; + } +} \ No newline at end of file diff --git a/src/me/yaruma/fightsystem/utils/Coordinates.java b/src/me/yaruma/fightsystem/utils/Coordinates.java new file mode 100644 index 0000000..65d3508 --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/Coordinates.java @@ -0,0 +1,85 @@ +package me.yaruma.fightsystem.utils; + +import me.yaruma.fightsystem.FightSystem; +import me.yaruma.fightsystem.fight.Fight; +import me.yaruma.fightsystem.manager.FileManager; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.World; + +public class Coordinates { + + FileManager fileManager = FightSystem.getPlugin().getFileManager(); + + public void computePositions( + int SchemsizeX, int SchemsizeY, int SchemsizeZ, + int Team1cornerX, int Team1cornerY, int Team1cornerZ, + int Team1toTeam2distanceX, int Team1toTeam2distanceY, int Team1toTeam2distanceZ, + int Schem2BorderX, int Schem2BorderZ){ + + if(SchemsizeX < 0){ + SchemsizeX = -SchemsizeX; + Team1cornerX = -Team1cornerX; + } + if(SchemsizeY < 0){ + SchemsizeY = -SchemsizeY; + Team1cornerY = -Team1cornerY; + } + if(SchemsizeZ < 0){ + SchemsizeZ = -SchemsizeZ; + Team1cornerZ = -Team1cornerZ; + } + + if(Team1toTeam2distanceX < 0){ + Team1cornerX += Team1toTeam2distanceX; + Team1toTeam2distanceX = -Team1toTeam2distanceX; + } + if(Team1toTeam2distanceY < 0){ + Team1cornerY += Team1toTeam2distanceY; + Team1toTeam2distanceY = -Team1toTeam2distanceY; + } + if(Team1toTeam2distanceZ < 0){ + Team1cornerZ += Team1toTeam2distanceZ; + Team1toTeam2distanceZ = -Team1toTeam2distanceZ; + } + + //Team1corner hat nun kleinste X- Y- und Z-Koordinate + //Schemsize und Team1toTeam2distance sind nun ausschließlich positiv + + int Team1centerX = Team1cornerX + SchemsizeX/2; + int Team1centerY = Team1cornerY; + int Team1centerZ = Team1cornerZ + SchemsizeZ/2; + + int Team2centerX = Team1centerX + Team1toTeam2distanceX; + int Team2centerY = Team1centerY + Team1toTeam2distanceY; + int Team2centerZ = Team1centerZ + Team1toTeam2distanceZ; + + + World world = Bukkit.getWorld(fileManager.getStringFromConfig("Arena.WorldName")); + + + Location Team1SpawnLoc = new Location(world, Team1centerX, Team1centerY + SchemsizeY, Team1centerZ); + Location Team2SpawnLoc = new Location(world, Team1centerX, Team1centerY + SchemsizeY, Team1centerZ); + Location Team1PasteLoc = new Location(world, Team1centerX, Team1centerY, Team1centerZ); + Location Team2PasteLoc = new Location(world, Team2centerX, Team2centerY, Team2centerZ); + + int ArenaMinX = Team1cornerX - Schem2BorderX; + int ArenaMaxX = Team1cornerX + Team1toTeam2distanceX + Schem2BorderX; + int ArenaMinZ = Team1cornerZ - Schem2BorderZ; + int ArenaMaxZ = Team1cornerZ + Team1toTeam2distanceZ + Schem2BorderZ; + + + FightSystem.getPlugin().setTeam1SpawnLoc(Team1SpawnLoc); + FightSystem.getPlugin().setTeam2SpawnLoc(Team2SpawnLoc); + FightSystem.getPlugin().setTeam1PasteLoc(Team1PasteLoc); + FightSystem.getPlugin().setTeam2PasteLoc(Team2PasteLoc); + + FightSystem.getPlugin().setArenaMinX(ArenaMinX); + FightSystem.getPlugin().setArenaMaxX(ArenaMaxX); + FightSystem.getPlugin().setArenaMinZ(ArenaMinZ); + FightSystem.getPlugin().setArenaMaxZ(ArenaMaxZ); + + } + + +} diff --git a/src/me/yaruma/fightsystem/utils/ItemBuilder.java b/src/me/yaruma/fightsystem/utils/ItemBuilder.java new file mode 100644 index 0000000..5fbe357 --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/ItemBuilder.java @@ -0,0 +1,61 @@ +package me.yaruma.fightsystem.utils; + +import java.util.ArrayList; + +import org.bukkit.Material; +import org.bukkit.enchantments.Enchantment; +import org.bukkit.inventory.ItemFlag; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; + +public class ItemBuilder { + + private ItemStack item; + private ItemMeta meta; + + public ItemBuilder(Material matrial) { + item = new ItemStack(matrial); + meta = item.getItemMeta(); + } + + + public ItemBuilder(Material matrial, int amount) { + item = new ItemStack(matrial, amount); + meta = item.getItemMeta(); + } + public ItemBuilder(Material matrial, short subid) { + item = new ItemStack(matrial, 1, subid); + meta = item.getItemMeta(); + } + + public ItemBuilder removeAllAtributs() { + meta.addItemFlags(ItemFlag.HIDE_ATTRIBUTES); + meta.addItemFlags(ItemFlag.HIDE_DESTROYS); + meta.addItemFlags(ItemFlag.HIDE_UNBREAKABLE); + meta.addItemFlags(ItemFlag.HIDE_ENCHANTS); + meta.addItemFlags(ItemFlag.HIDE_PLACED_ON); + meta.addItemFlags(ItemFlag.HIDE_POTION_EFFECTS); + return this; + } + + public ItemBuilder setDisplayName(String name) { + meta.setDisplayName(name); + return this; + } + + public ItemBuilder addLore(ArrayList lore) { + meta.setLore(lore); + return this; + } + + public ItemBuilder addEnchantment(Enchantment enchantment, int level) { + meta.addEnchant(enchantment, level, true); + return this; + } + + public ItemStack build() { + item.setItemMeta(meta); + return item; + } + +} diff --git a/src/me/yaruma/fightsystem/utils/Region.java b/src/me/yaruma/fightsystem/utils/Region.java new file mode 100644 index 0000000..72fdeee --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/Region.java @@ -0,0 +1,17 @@ +package me.yaruma.fightsystem.utils; + +import org.bukkit.Location; +import org.bukkit.entity.Player; + +public class Region { + + public static boolean isInRegion(Location location, int minX, int minY, int minZ, int maxX, int maxY, int maxZ) { + + if(location.getBlockX() >= minX && location.getBlockX() <= maxX && location.getBlockY() >= minY && location.getBlockY() <= maxY && location.getBlockZ() >= minZ && location.getBlockZ() <= maxX) { + return true; + } else + return false; + } + + +} diff --git a/src/me/yaruma/fightsystem/utils/WorldEdit.java b/src/me/yaruma/fightsystem/utils/WorldEdit.java new file mode 100644 index 0000000..04a9333 --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/WorldEdit.java @@ -0,0 +1,50 @@ +package me.yaruma.fightsystem.utils; + +import com.boydti.fawe.FaweAPI; +import com.boydti.fawe.util.EditSessionBuilder; +import com.sk89q.worldedit.EditSession; +import com.sk89q.worldedit.Vector; +import com.sk89q.worldedit.blocks.BaseBlock; +import com.sk89q.worldedit.bukkit.BukkitWorld; +import com.sk89q.worldedit.bukkit.selections.CuboidSelection; +import com.sk89q.worldedit.math.transform.AffineTransform; +import com.sk89q.worldedit.world.World; +import org.bukkit.Location; +import org.bukkit.entity.Player; + +import java.io.File; +import java.io.IOException; +import java.util.HashSet; +import java.util.Set; + +public class WorldEdit { + + public static void replace(Player player, int minX, int minY, int minZ, int maxX, int maxY, int maxZ) { + World weWorld = new BukkitWorld(player.getWorld()); + EditSession editSession = new EditSessionBuilder(weWorld).fastmode(true).build(); + CuboidSelection cuboidSelection = new CuboidSelection(player.getWorld(), new Location(player.getWorld(), minX, minY, minZ), new Location(player.getWorld(), maxX, maxY, maxZ)); + + Set targetObsidian = new HashSet<>(); + targetObsidian.add(new BaseBlock(49)); + + Set targetBedrock = new HashSet<>(); + targetBedrock.add(new BaseBlock(7)); + + try { + int tnt = editSession.replaceBlocks(cuboidSelection.getRegionSelector().getRegion(), targetObsidian, new BaseBlock(46)); + int slime = editSession.replaceBlocks(cuboidSelection.getRegionSelector().getRegion(), targetObsidian, new BaseBlock(7)); + + editSession.flushQueue(); + } catch (Exception ex){ + ex.printStackTrace(); + } + } + + public static void pasteSchematic(File file, World world, Vector vector, boolean allowUndo, boolean pasteAir, AffineTransform affineTransform) { + try { + FaweAPI.load(file).paste(world, vector, allowUndo, pasteAir, affineTransform).flushQueue(); + } catch (IOException e) { } + } + + +} diff --git a/src/me/yaruma/fightsystem/utils/countdown/Countdown.java b/src/me/yaruma/fightsystem/utils/countdown/Countdown.java new file mode 100644 index 0000000..93957ab --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/countdown/Countdown.java @@ -0,0 +1,57 @@ +package me.yaruma.fightsystem.utils.countdown; + +import me.yaruma.fightsystem.FightSystem; +import org.bukkit.Bukkit; +import org.bukkit.scheduler.BukkitScheduler; + +import java.util.ArrayList; + +public class Countdown { + + private int time; + private CountdownCallback countdownCallback; + private int taskID; + + public Countdown() { + + } + + public Countdown(int time, CountdownCallback countdownCallback) { + this.time = time; + this.countdownCallback = countdownCallback; + } + + + public void startTimer(FightSystem plugin) { + BukkitScheduler bukkitScheduler = Bukkit.getServer().getScheduler(); + this.taskID = bukkitScheduler.scheduleSyncRepeatingTask(plugin, new Runnable() { + @Override + public void run() { + + switch (time) { + case 600: case 300: + Bukkit.broadcastMessage("§6Noch §a" + time / 60 + " §6Minuten" + countdownCallback.countdownCounting()); + break; + case 60: case 30: case 20: case 15: case 10: case 5: case 4: case 3: case 2: + Bukkit.broadcastMessage("§6Noch §a" + time + " §6Sekunden " + countdownCallback.countdownCounting()); + break; + case 1: + Bukkit.broadcastMessage("§6Noch §aeine §6Sekunde " + countdownCallback.countdownCounting()); + break; + case 0: + countdownCallback.countdownFinished(); + break; + } + time--; + } + }, 0, 20); + } + + public void cancelTimer(int taskID) { + Bukkit.getScheduler().cancelTask(taskID); + } + + public void cancelAllTimers(FightSystem plugin) { + Bukkit.getScheduler().cancelTasks(plugin); + } +} diff --git a/src/me/yaruma/fightsystem/utils/countdown/CountdownCallback.java b/src/me/yaruma/fightsystem/utils/countdown/CountdownCallback.java new file mode 100644 index 0000000..0f4e733 --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/countdown/CountdownCallback.java @@ -0,0 +1,9 @@ +package me.yaruma.fightsystem.utils.countdown; + +public interface CountdownCallback { + + String countdownCounting(); + void countdownFinished(); + + +} diff --git a/src/me/yaruma/fightsystem/utils/countdown/FinishNoPlayersOnline.java b/src/me/yaruma/fightsystem/utils/countdown/FinishNoPlayersOnline.java new file mode 100644 index 0000000..cc864d4 --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/countdown/FinishNoPlayersOnline.java @@ -0,0 +1,17 @@ +package me.yaruma.fightsystem.utils.countdown; + +import org.bukkit.Bukkit; + +public class FinishNoPlayersOnline implements CountdownCallback { + + @Override + public String countdownCounting() { + return "bis der Server gestoppt wird!"; + } + + @Override + public void countdownFinished() { + Bukkit.broadcastMessage("§aStoppe Server..."); + Bukkit.getServer().shutdown(); + } +} diff --git a/src/me/yaruma/fightsystem/utils/countdown/FinishNoneEntern.java b/src/me/yaruma/fightsystem/utils/countdown/FinishNoneEntern.java new file mode 100644 index 0000000..1d5b134 --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/countdown/FinishNoneEntern.java @@ -0,0 +1,16 @@ +package me.yaruma.fightsystem.utils.countdown; + +import org.bukkit.Bukkit; + +public class FinishNoneEntern implements CountdownCallback { + + @Override + public String countdownCounting() { + return "bis Entern erlaubt ist!"; + } + + @Override + public void countdownFinished() { + Bukkit.broadcastMessage("§aEntern ist nun erlaubt!"); + } +} diff --git a/src/me/yaruma/fightsystem/utils/countdown/FinishPreRunning.java b/src/me/yaruma/fightsystem/utils/countdown/FinishPreRunning.java new file mode 100644 index 0000000..39aced1 --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/countdown/FinishPreRunning.java @@ -0,0 +1,24 @@ +package me.yaruma.fightsystem.utils.countdown; + +import me.yaruma.fightsystem.FightSystem; +import me.yaruma.fightsystem.manager.FileManager; +import org.bukkit.Bukkit; + +public class FinishPreRunning implements CountdownCallback { + + FileManager fileManager = FightSystem.getPlugin().getFileManager(); + + @Override + public String countdownCounting() { + return "bis die Arena freigegeben ist!"; + } + + @Override + public void countdownFinished() { + FightSystem.getPlugin().setRunningState(); + int time = fileManager.getIntegerFromConfig("Times.FightDuration"); + Countdown countdown = new Countdown(time, new FinishTimeOver()); + countdown.startTimer(FightSystem.getPlugin()); + Bukkit.broadcastMessage("§aArena freigegeben!"); + } +} diff --git a/src/me/yaruma/fightsystem/utils/countdown/FinishSetupOver.java b/src/me/yaruma/fightsystem/utils/countdown/FinishSetupOver.java new file mode 100644 index 0000000..4f2f0e5 --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/countdown/FinishSetupOver.java @@ -0,0 +1,17 @@ +package me.yaruma.fightsystem.utils.countdown; + +import org.bukkit.Bukkit; + +public class FinishSetupOver implements CountdownCallback { + + @Override + public String countdownCounting() { + return "bis die Teams bereit sein müssen!"; + } + + @Override + public void countdownFinished() { + Bukkit.broadcastMessage("Fight wird abgebrochen! \n Stoppe Server..."); + Bukkit.getServer().shutdown(); + } +} diff --git a/src/me/yaruma/fightsystem/utils/countdown/FinishSpectateOver.java b/src/me/yaruma/fightsystem/utils/countdown/FinishSpectateOver.java new file mode 100644 index 0000000..2add84b --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/countdown/FinishSpectateOver.java @@ -0,0 +1,17 @@ +package me.yaruma.fightsystem.utils.countdown; + +import org.bukkit.Bukkit; + +public class FinishSpectateOver implements CountdownCallback { + + @Override + public String countdownCounting() { + return "bis der Server gestoppt wird!"; + } + + @Override + public void countdownFinished() { + Bukkit.broadcastMessage("§aStoppe Server..."); + Bukkit.getServer().shutdown(); + } +} diff --git a/src/me/yaruma/fightsystem/utils/countdown/FinishTimeOver.java b/src/me/yaruma/fightsystem/utils/countdown/FinishTimeOver.java new file mode 100644 index 0000000..345217c --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/countdown/FinishTimeOver.java @@ -0,0 +1,16 @@ +package me.yaruma.fightsystem.utils.countdown; + +import org.bukkit.Bukkit; + +public class FinishTimeOver implements CountdownCallback { + + @Override + public String countdownCounting() { + return "bis die Zeit abgelaufen ist!"; + } + + @Override + public void countdownFinished() { + Bukkit.broadcastMessage("§aZeit abgelaufen!"); + } +} diff --git a/src/me/yaruma/fightsystem/utils/inventory/SetupItems.java b/src/me/yaruma/fightsystem/utils/inventory/SetupItems.java new file mode 100644 index 0000000..06467c0 --- /dev/null +++ b/src/me/yaruma/fightsystem/utils/inventory/SetupItems.java @@ -0,0 +1,18 @@ +package me.yaruma.fightsystem.utils.inventory; + +import me.yaruma.fightsystem.utils.ItemBuilder; +import org.bukkit.Material; +import org.bukkit.enchantments.Enchantment; +import org.bukkit.entity.Player; +import org.bukkit.inventory.Inventory; + +public class SetupItems { + + public static void giveSetupItems(Player player) { + Inventory inventory = player.getInventory(); + inventory.setItem(3, new ItemBuilder(Material.INK_SACK, (short) 10).removeAllAtributs().addEnchantment(Enchantment.DURABILITY, 1).setDisplayName("§cNicht bereit").build()); + inventory.setItem(3, new ItemBuilder(Material.INK_SACK, (short) 1).removeAllAtributs().addEnchantment(Enchantment.DURABILITY, 1).setDisplayName("§4Abbrechen").build()); + } + + +}