diff --git a/FightSystem_API/src/de/steamwar/fightsystem/Config.java b/FightSystem_API/src/de/steamwar/fightsystem/Config.java index 5f3c451..7152d59 100644 --- a/FightSystem_API/src/de/steamwar/fightsystem/Config.java +++ b/FightSystem_API/src/de/steamwar/fightsystem/Config.java @@ -19,6 +19,7 @@ package de.steamwar.fightsystem; +import de.steamwar.fightsystem.winconditions.Winconditions; import de.steamwar.sql.Event; import de.steamwar.sql.EventFight; import de.steamwar.sql.Team; @@ -33,6 +34,7 @@ import org.bukkit.util.Vector; import java.io.File; import java.util.*; import java.util.logging.Level; +import java.util.stream.Collectors; public class Config { @@ -104,16 +106,7 @@ public class Config { public static final boolean Ranked; //Active win conditions - public static final boolean Timeout; - public static final boolean HeartRatioTimeout; - public static final boolean AllDead; - public static final boolean CaptainDead; - public static final boolean PercentSystem; - public static final boolean RelativePercent; - public static final boolean Points; - public static final boolean TechKO; - public static final boolean WaterTechKO; - public static final boolean PumpkinTechKO; + public static final Set ActiveWinconditions; //win condition parameters public static final int TimeoutTime; @@ -202,16 +195,7 @@ public class Config { GameName = config.getString("Output.GameName"); TeamChatDetection = config.getString("Output.TeamChatDetection"); - Timeout = config.getBoolean("WinConditions.Timeout"); - HeartRatioTimeout = config.getBoolean("WinConditions.HeartRatioTimeout"); - AllDead = config.getBoolean("WinConditions.AllDead"); - CaptainDead = config.getBoolean("WinConditions.CaptainDead"); - PercentSystem = config.getBoolean("WinConditions.PercentSystem"); - RelativePercent = config.getBoolean("WinConditions.RelativePercent"); - Points = config.getBoolean("WinConditions.Points"); - TechKO = config.getBoolean("WinConditions.TechKO"); - WaterTechKO = config.getBoolean("WinConditions.WaterTechKO"); - PumpkinTechKO = config.getBoolean("WinConditions.PumpkinTechKO"); + ActiveWinconditions = config.getStringList("WinConditions").stream().map(Winconditions::valueOf).collect(Collectors.toSet()); TimeoutTime = config.getInt("WinConditionParams.TimeoutTime"); PercentWin = config.getDouble("WinConditionParams.PercentWin"); diff --git a/FightSystem_API/src/de/steamwar/fightsystem/winconditions/Winconditions.java b/FightSystem_API/src/de/steamwar/fightsystem/winconditions/Winconditions.java new file mode 100644 index 0000000..0394ee7 --- /dev/null +++ b/FightSystem_API/src/de/steamwar/fightsystem/winconditions/Winconditions.java @@ -0,0 +1,34 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.fightsystem.winconditions; + +public enum Winconditions { + TIMEOUT, + HEART_RATIO_TIMEOUT, + PERCENT_TIMEOUT, + ALL_DEAD, + CAPTAIN_DEAD, + PERCENT_SYSTEM, + RELATIVE_PERCENT, + POINTS, + TIME_TECH_KO, + WATER_TECH_KO, + PUMPKIN_TECH_KO +} diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/FightSystem.java b/FightSystem_Main/src/de/steamwar/fightsystem/FightSystem.java index 400af23..2eca2ee 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/FightSystem.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/FightSystem.java @@ -96,8 +96,10 @@ public class FightSystem extends JavaPlugin { new WinconditionPoints(); new WinconditionTimeout(); new WinconditionHeartRatioTimeout(); - new WinconditionTechKO(); + new WinconditionTimeTechKO(); new EventTeamOffWincondition(); + new RankedPlayerLeftWincondition(); + new WinconditionPercentTimeout(); new NoPlayersOnlineCountdown(); new PreSchemPasteCountdown(); diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/countdown/TimeOverCountdown.java b/FightSystem_Main/src/de/steamwar/fightsystem/countdown/TimeOverCountdown.java index c138d99..acb6d6f 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/countdown/TimeOverCountdown.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/countdown/TimeOverCountdown.java @@ -25,14 +25,11 @@ import org.bukkit.Bukkit; public class TimeOverCountdown extends Countdown { - private static TimeOverCountdown instance = null; - private final Runnable timeOver; public TimeOverCountdown(Runnable timeOver) { super(Config.TimeoutTime, SWSound.BLOCK_NOTE_BASS, false); this.timeOver = timeOver; - instance = this; enable(); } @@ -46,10 +43,4 @@ public class TimeOverCountdown extends Countdown { Bukkit.broadcastMessage(FightSystem.PREFIX +"§aZeit abgelaufen!"); timeOver.run(); } - - public static int getRemainingTime(){ - if(instance == null) - return -1; - return instance.getTimeLeft(); - } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/fight/FightSchematic.java b/FightSystem_Main/src/de/steamwar/fightsystem/fight/FightSchematic.java index 6d63711..4835b41 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/fight/FightSchematic.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/fight/FightSchematic.java @@ -1,3 +1,22 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + package de.steamwar.fightsystem.fight; import com.sk89q.worldedit.EditSession; diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/fight/FightTeam.java b/FightSystem_Main/src/de/steamwar/fightsystem/fight/FightTeam.java index 7cfe8cc..265dee2 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/fight/FightTeam.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/fight/FightTeam.java @@ -29,7 +29,6 @@ import de.steamwar.fightsystem.states.FightState; import de.steamwar.fightsystem.utils.FightScoreboard; import de.steamwar.fightsystem.utils.ItemBuilder; import de.steamwar.fightsystem.utils.TechHider; -import de.steamwar.fightsystem.winconditions.RankedPlayerLeftWincondition; import de.steamwar.inventory.SWItem; import de.steamwar.sql.Schematic; import de.steamwar.sql.SteamwarUser; @@ -204,9 +203,7 @@ public class FightTeam implements IFightTeam{ if(!players.isEmpty()) { setLeader(players.values().iterator().next()); Bukkit.broadcastMessage(FightSystem.PREFIX + "§aDer Spieler §e" + this.leader.getPlayer().getName() + " §aist nun Leader von Team " + getColoredName() + "§a!"); - }else if(Config.Ranked){ - RankedPlayerLeftWincondition.leaderQuit(this); - }else if(!Config.event()){ + }else if(!Config.event() && !Config.Ranked){ FightSystem.shutdown(FightSystem.PREFIX + "§cTeam " + getColoredName() + " §chat keine Spieler mehr.\n Arena schließt..."); } return; diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/utils/FightScoreboard.java b/FightSystem_Main/src/de/steamwar/fightsystem/utils/FightScoreboard.java index 1652f53..5e92c7b 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/utils/FightScoreboard.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/utils/FightScoreboard.java @@ -34,11 +34,10 @@ import org.bukkit.Bukkit; import org.bukkit.entity.Player; import org.bukkit.scoreboard.Scoreboard; -import java.util.EnumSet; -import java.util.HashMap; -import java.util.Set; +import java.util.*; public class FightScoreboard { + private FightScoreboard(){} private static final Set fullScoreboard = EnumSet.of(FightState.RUNNING, FightState.SPECTATE); private static int index = 0; @@ -72,9 +71,7 @@ public class FightScoreboard { } private static void teamScoreboard(FightTeam fightTeam){ - title = fightTeam.getColoredName(); - if(Config.recording()) - RecordSystem.scoreboardTitle(title); + setTitle(fightTeam.getColoredName()); fightTeam.getPlayers().forEach(fp -> { if(fp.isLiving()) addScore(fightTeam.getPrefix() + fp.getPlayer().getName(), (int) Math.ceil(fp.getPlayer().getHealth())); @@ -82,37 +79,31 @@ public class FightScoreboard { } private static void generalScoreboard(){ - title = "§6Kampf"; - if(Config.recording()) - RecordSystem.scoreboardTitle(title); - int fightTime = TimeOverCountdown.getRemainingTime(); - if (fightTime != -1) { + setTitle("§eKampf"); + List scores = new ArrayList<>(); + + TimeOverCountdown timeOverCountdown = TimeoutWincondition.getTimeOverCountdown(); + if(timeOverCountdown != null){ + int fightTime = timeOverCountdown.getTimeLeft(); if (fightTime >= 60) - addScore("§7Zeit: §a" + fightTime / 60 + "m " + fightTime % 60 + "s", 4); + scores.add("§7Zeit: §a" + fightTime / 60 + "m " + fightTime % 60 + "s"); else - addScore("§7Zeit: §a" + fightTime + "s", 4); + scores.add("§7Zeit: §a" + fightTime + "s"); } - addScore("§7TPS: §e" + TPSWatcher.getTPS(), 3); + scores.add("§7TPS: §e" + TPSWatcher.getTPS()); if(fullScoreboard.contains(FightState.getFightState())){ - if (Config.PercentSystem){ - addScore(Fight.getRedTeam().getPrefix() + "Schaden: " + (Math.round(100.0 * WinconditionPercentSystem.getRedPercent()) / 100.0) + "%", 1); - addScore(Fight.getBlueTeam().getPrefix() + "Schaden: " + (Math.round(100.0 * WinconditionPercentSystem.getBluePercent()) / 100.0) + "%", 0); - }else if(Config.WaterTechKO){ - addScore(Fight.getRedTeam().getPrefix() + "Wasser: " + WinconditionWaterTechKO.getTeamRedWater(), 1); - addScore(Fight.getBlueTeam().getPrefix() + "Wasser: " + WinconditionWaterTechKO.getTeamBlueWater(), 0); - }else if(Config.RelativePercent){ - addScore(Fight.getRedTeam().getPrefix() + "Schaden: " + WinconditionRelativePercent.getRed().getPrintablePercent() + "%", 1); - addScore(Fight.getBlueTeam().getPrefix() + "Schaden: " + WinconditionRelativePercent.getBlue().getPrintablePercent() + "%", 0); - }else if(Config.Points){ - addScore(Fight.getRedTeam().getPrefix() + "Punkte: " + WinconditionPoints.getRed().getPoints(), 1); - addScore(Fight.getBlueTeam().getPrefix() + "Punkte: " + WinconditionPoints.getBlue().getPoints(), 0); - }else if(Config.PumpkinTechKO){ - addScore(Fight.getRedTeam().getPrefix() + "Kanonen: " + WinconditionPumpkinTechKO.getTeamRedPumpkins(), 1); - addScore(Fight.getBlueTeam().getPrefix() + "Kanonen: " + WinconditionPumpkinTechKO.getTeamBluePumpkins(), 0); + for(PrintableWincondition wincondition : Wincondition.getPrintableWinconditions()){ + scores.add(wincondition.getDisplay(Fight.getRedTeam())); + scores.add(wincondition.getDisplay(Fight.getBlueTeam())); } } + + int value = scores.size(); + for(String score : scores){ + addScore(score, value--); + } } private static void nextIndexDisplay() { @@ -131,6 +122,12 @@ public class FightScoreboard { generalScoreboard(); } + private static void setTitle(String t) { + title = t; + if(Config.recording()) + RecordSystem.scoreboardTitle(t); + } + private static void addScore(String string, int i) { if(Config.recording()) RecordSystem.scoreboardData(string, i); diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/utils/FightStatistics.java b/FightSystem_Main/src/de/steamwar/fightsystem/utils/FightStatistics.java index e95fa3b..a65d25b 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/utils/FightStatistics.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/utils/FightStatistics.java @@ -25,6 +25,7 @@ import de.steamwar.fightsystem.countdown.TimeOverCountdown; import de.steamwar.fightsystem.fight.Fight; import de.steamwar.fightsystem.fight.FightPlayer; import de.steamwar.fightsystem.fight.FightTeam; +import de.steamwar.fightsystem.winconditions.TimeoutWincondition; import de.steamwar.sql.Elo; import de.steamwar.sql.Schematic; import de.steamwar.sql.SteamwarUser; @@ -76,8 +77,14 @@ public class FightStatistics { redSchem = null; } + int remainingTime = 0; + TimeOverCountdown timeOverCountdown = TimeoutWincondition.getTimeOverCountdown(); + if(timeOverCountdown != null){ + remainingTime = timeOverCountdown.getTimeLeft(); + } + try { - int fightId = create(gameMode, Bukkit.getWorlds().get(0).getName(), starttime, TimeOverCountdown.getRemainingTime(), + int fightId = create(gameMode, Bukkit.getWorlds().get(0).getName(), starttime, remainingTime, blueLeader.getId(), redLeader.getId(), blueSchem, redSchem, win, windescription); for (FightPlayer fp : Fight.getBlueTeam().getPlayers()) diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/EventTeamOffWincondition.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/EventTeamOffWincondition.java index b89c1c0..638cabe 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/EventTeamOffWincondition.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/EventTeamOffWincondition.java @@ -20,24 +20,26 @@ package de.steamwar.fightsystem.winconditions; import de.steamwar.fightsystem.Config; -import de.steamwar.fightsystem.FightSystem; import de.steamwar.fightsystem.fight.Fight; import de.steamwar.fightsystem.fight.FightTeam; import de.steamwar.fightsystem.states.FightState; -import org.bukkit.Bukkit; import java.util.EnumSet; public class EventTeamOffWincondition extends Wincondition { public EventTeamOffWincondition(){ - super(Config.event(), EnumSet.of(FightState.PRE_RUNNING)); + super(Config.event(), EnumSet.of(FightState.PRE_RUNNING), "TeamOffline"); } @Override public void enable() { - teamOff(Fight.getBlueTeam()); - teamOff(Fight.getRedTeam()); + if(Fight.getBlueTeam().allPlayersOut() && Fight.getRedTeam().allPlayersOut()){ + win(null, null, null, "§cBeide Teams sind offline!"); + }else{ + teamOff(Fight.getBlueTeam()); + teamOff(Fight.getRedTeam()); + } } @Override @@ -47,8 +49,7 @@ public class EventTeamOffWincondition extends Wincondition { private void teamOff(FightTeam team){ if(team.allPlayersOut()){ - Bukkit.broadcastMessage(FightSystem.PREFIX + "§6Das Team " + team.getColoredName() + " §6ist Offline!"); - FightSystem.setSpectateState(Fight.getOpposite(team), "TeamOffline"); + win(Fight.getOpposite(team), "§cDas Team ", " §cist offline!"); } } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/ListenerWincondition.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/ListenerWincondition.java index 311285b..2eaf446 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/ListenerWincondition.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/ListenerWincondition.java @@ -29,9 +29,12 @@ import java.util.Set; abstract class ListenerWincondition extends Wincondition implements Listener { - ListenerWincondition(boolean condition, Set enabled){ - //If the condition is not met, never enable - super(condition, enabled); + protected ListenerWincondition(Winconditions condition, Set enabled, String windescription){ + super(condition, enabled, windescription); + } + + protected ListenerWincondition(boolean condition, Set enabled, String windescription) { + super(condition, enabled, windescription); } /** diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/PercentWincondition.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/PercentWincondition.java new file mode 100644 index 0000000..4997c13 --- /dev/null +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/PercentWincondition.java @@ -0,0 +1,7 @@ +package de.steamwar.fightsystem.winconditions; + +import de.steamwar.fightsystem.fight.FightTeam; + +public interface PercentWincondition { + double getPercent(FightTeam team); +} diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/PlayerWincondition.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/PrintableWincondition.java similarity index 59% rename from FightSystem_Main/src/de/steamwar/fightsystem/winconditions/PlayerWincondition.java rename to FightSystem_Main/src/de/steamwar/fightsystem/winconditions/PrintableWincondition.java index 472a7c5..31053a8 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/PlayerWincondition.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/PrintableWincondition.java @@ -1,6 +1,6 @@ -/* +/* This file is a part of the SteamWar software. - + Copyright (C) 2020 SteamWar.de-Serverteam This program is free software: you can redistribute it and/or modify @@ -19,25 +19,8 @@ package de.steamwar.fightsystem.winconditions; -import de.steamwar.fightsystem.fight.Fight; import de.steamwar.fightsystem.fight.FightTeam; -import de.steamwar.fightsystem.states.FightState; -import org.bukkit.entity.Player; -import java.util.EnumSet; - -abstract class PlayerWincondition extends ListenerWincondition { - - PlayerWincondition(boolean condition) { - super(condition, EnumSet.of(FightState.PRE_RUNNING, FightState.RUNNING)); - } - - boolean isTarget(Player player){ - FightTeam fightTeam = Fight.getPlayerTeam(player); - if(fightTeam == null) - return false; - - fightTeam.getFightPlayer(player).setOut(); - return true; - } +public interface PrintableWincondition { + String getDisplay(FightTeam team); } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/RankedPlayerLeftWincondition.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/RankedPlayerLeftWincondition.java index 77a8a38..371ee08 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/RankedPlayerLeftWincondition.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/RankedPlayerLeftWincondition.java @@ -19,14 +19,29 @@ package de.steamwar.fightsystem.winconditions; -import de.steamwar.fightsystem.FightSystem; +import de.steamwar.fightsystem.Config; import de.steamwar.fightsystem.fight.Fight; import de.steamwar.fightsystem.fight.FightTeam; +import de.steamwar.fightsystem.states.FightState; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.player.PlayerQuitEvent; -public class RankedPlayerLeftWincondition { - private RankedPlayerLeftWincondition(){} +public class RankedPlayerLeftWincondition extends ListenerWincondition{ - public static void leaderQuit(FightTeam leaderlessTeam){ - FightSystem.setSpectateState(Fight.getOpposite(leaderlessTeam), "LeaderQuit"); + public RankedPlayerLeftWincondition(){ + super(Config.Ranked, FightState.INGAME, "LeaderQuit"); + } + + @EventHandler + public void handlePlayerQuit(PlayerQuitEvent event) { + Player player = event.getPlayer(); + FightTeam team = isTarget(player); + if(team == null) + return; + + if(team.isPlayerLeader(player)) { + win(Fight.getOpposite(team), "§cDer Leader von ", " §chat den Kampf verlassen!"); + } } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/TimeoutWincondition.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/TimeoutWincondition.java new file mode 100644 index 0000000..9529474 --- /dev/null +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/TimeoutWincondition.java @@ -0,0 +1,56 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +package de.steamwar.fightsystem.winconditions; + +import de.steamwar.fightsystem.countdown.TimeOverCountdown; +import de.steamwar.fightsystem.states.FightState; + +import java.util.EnumSet; +import java.util.Set; + +public abstract class TimeoutWincondition extends Wincondition { + + private static TimeOverCountdown timeOverCountdown = null; + + protected TimeoutWincondition(Winconditions condition, Set enabled, String windescription) { + super(condition, enabled, windescription); + } + + protected TimeoutWincondition(Winconditions condition, String windescription) { + super(condition, EnumSet.of(FightState.RUNNING), windescription); + } + + protected abstract void timeOver(); + + @Override + public void enable() { + timeOverCountdown = new TimeOverCountdown(this::timeOver); + } + + @Override + public void disable() { + if(timeOverCountdown != null) + timeOverCountdown.disable(); + } + + public static TimeOverCountdown getTimeOverCountdown(){ + return timeOverCountdown; + } +} diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/Wincondition.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/Wincondition.java index 78b4645..bd265d9 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/Wincondition.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/Wincondition.java @@ -19,23 +19,66 @@ package de.steamwar.fightsystem.winconditions; +import de.steamwar.fightsystem.Config; +import de.steamwar.fightsystem.FightSystem; +import de.steamwar.fightsystem.fight.Fight; +import de.steamwar.fightsystem.fight.FightTeam; import de.steamwar.fightsystem.states.FightState; import de.steamwar.fightsystem.states.StateDependent; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import java.util.ArrayList; +import java.util.List; import java.util.Set; -abstract class Wincondition implements StateDependent { +public abstract class Wincondition implements StateDependent { + + protected static PercentWincondition percentWincondition = null; + protected static final List printableWinconditions = new ArrayList<>(); private final Set enabled; + private final String windescription; - Wincondition(boolean condition, Set enabled){ + protected Wincondition(Winconditions condition, Set enabled, String windescription){ + this(Config.ActiveWinconditions.contains(condition), enabled, windescription); + } + + protected Wincondition(boolean condition, Set enabled, String windescription){ this.enabled = enabled; + this.windescription = windescription; if(condition) FightState.registerStateDependent(this); } + protected void win(FightTeam team, String preteammessage, String postteammessage){ + win(team, preteammessage, postteammessage, null); + } + + protected void win(FightTeam team, String preteammessage, String postteammessage, String tiemessage){ + if(team != null){ + Bukkit.broadcastMessage(FightSystem.PREFIX + preteammessage + team.getColoredName() + postteammessage); + }else{ + Bukkit.broadcastMessage(FightSystem.PREFIX + tiemessage); + } + FightSystem.setSpectateState(team, windescription); + } + + protected FightTeam isTarget(Player player){ + FightTeam fightTeam = Fight.getPlayerTeam(player); + if(fightTeam == null) + return null; + + fightTeam.getFightPlayer(player).setOut(); + return fightTeam; + } + @Override public Set enabled(){ return enabled; } + + public static List getPrintableWinconditions(){ + return printableWinconditions; + } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionAllDead.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionAllDead.java index 3f03582..d1c37d0 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionAllDead.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionAllDead.java @@ -19,20 +19,18 @@ package de.steamwar.fightsystem.winconditions; -import de.steamwar.fightsystem.FightSystem; import de.steamwar.fightsystem.fight.Fight; import de.steamwar.fightsystem.fight.FightTeam; -import de.steamwar.fightsystem.Config; -import org.bukkit.Bukkit; +import de.steamwar.fightsystem.states.FightState; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.entity.PlayerDeathEvent; import org.bukkit.event.player.PlayerQuitEvent; -public class WinconditionAllDead extends PlayerWincondition { +public class WinconditionAllDead extends ListenerWincondition { public WinconditionAllDead(){ - super(Config.AllDead); + super(Winconditions.ALL_DEAD, FightState.INGAME, "AllDead"); } @EventHandler @@ -46,14 +44,12 @@ public class WinconditionAllDead extends PlayerWincondition { } private void handleDeath(Player player, String message){ - if(!isTarget(player)) + FightTeam team = isTarget(player); + if(team == null) return; - FightTeam fightTeam = Fight.getPlayerTeam(player); - assert fightTeam != null; // Checked with isTarget - if(fightTeam.allPlayersOut()) { - Bukkit.broadcastMessage(FightSystem.PREFIX + "§cDer letzte Spieler aus " + fightTeam.getColoredName() + message); - FightSystem.setSpectateState(Fight.getOpposite(fightTeam), "AllDead"); + if(team.allPlayersOut()) { + win(Fight.getOpposite(team), "§cDer letzte Spieler aus ", message); } } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionCaptainDead.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionCaptainDead.java index 94b3726..c86092c 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionCaptainDead.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionCaptainDead.java @@ -19,20 +19,18 @@ package de.steamwar.fightsystem.winconditions; -import de.steamwar.fightsystem.FightSystem; import de.steamwar.fightsystem.fight.Fight; import de.steamwar.fightsystem.fight.FightTeam; -import de.steamwar.fightsystem.Config; -import org.bukkit.Bukkit; +import de.steamwar.fightsystem.states.FightState; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.entity.PlayerDeathEvent; import org.bukkit.event.player.PlayerQuitEvent; -public class WinconditionCaptainDead extends PlayerWincondition { +public class WinconditionCaptainDead extends ListenerWincondition { public WinconditionCaptainDead(){ - super(Config.CaptainDead); + super(Winconditions.CAPTAIN_DEAD, FightState.INGAME, "LeaderDead"); } @EventHandler @@ -46,14 +44,12 @@ public class WinconditionCaptainDead extends PlayerWincondition { } private void handleDeath(Player player, String message){ - if(!isTarget(player)) + FightTeam team = isTarget(player); + if(team == null) return; - FightTeam fightTeam = Fight.getPlayerTeam(player); - assert fightTeam != null; // Checked with isTarget - if(fightTeam.isPlayerLeader(player)) { - Bukkit.broadcastMessage(FightSystem.PREFIX + "§cDer Leader von " + fightTeam.getColoredName() + message); - FightSystem.setSpectateState(Fight.getOpposite(fightTeam), "LeaderDead"); + if(team.isPlayerLeader(player)) { + win(Fight.getOpposite(team), "§cDer Leader von ", message); } } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionHeartRatioTimeout.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionHeartRatioTimeout.java index 74f1843..d400671 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionHeartRatioTimeout.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionHeartRatioTimeout.java @@ -19,39 +19,26 @@ package de.steamwar.fightsystem.winconditions; -import de.steamwar.fightsystem.Config; -import de.steamwar.fightsystem.FightSystem; -import de.steamwar.fightsystem.countdown.TimeOverCountdown; import de.steamwar.fightsystem.fight.Fight; -import de.steamwar.fightsystem.states.FightState; +import de.steamwar.fightsystem.fight.FightTeam; -import java.util.EnumSet; - -public class WinconditionHeartRatioTimeout extends Wincondition { - - private TimeOverCountdown countdown; +public class WinconditionHeartRatioTimeout extends TimeoutWincondition { public WinconditionHeartRatioTimeout() { - super(Config.HeartRatioTimeout, EnumSet.of(FightState.RUNNING)); + super(Winconditions.HEART_RATIO_TIMEOUT, "HeartTimeout"); } @Override - public void enable() { - countdown = new TimeOverCountdown(() -> { - double blueHeartRatio = Fight.getBlueTeam().getHeartRatio(); - double redHeartRatio = Fight.getRedTeam().getHeartRatio(); + protected void timeOver() { + double blueHeartRatio = Fight.getBlueTeam().getHeartRatio(); + double redHeartRatio = Fight.getRedTeam().getHeartRatio(); - if(blueHeartRatio > redHeartRatio) - FightSystem.setSpectateState(Fight.getBlueTeam(), "HeartTimeout"); - else if(blueHeartRatio < redHeartRatio) - FightSystem.setSpectateState(Fight.getRedTeam(), "HeartTimeout"); - else - FightSystem.setSpectateState(null, "HeartTimeout"); - }); - } + FightTeam team = null; + if(blueHeartRatio > redHeartRatio) + team = Fight.getBlueTeam(); + else if(blueHeartRatio < redHeartRatio) + team = Fight.getRedTeam(); - @Override - public void disable(){ - countdown.disable(); + win(team, "§cDie Zeit ist abgelaufen, und Team ", " §chatte mehr verbleibende Leben!", "§cDie Zeit ist abgelaufen, und beide Teams hatten die gleiche Anzahl an verbleibenden Leben!"); } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPercentSystem.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPercentSystem.java index 2d4309d..7766081 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPercentSystem.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPercentSystem.java @@ -20,60 +20,66 @@ package de.steamwar.fightsystem.winconditions; import de.steamwar.fightsystem.Config; -import de.steamwar.fightsystem.FightSystem; import de.steamwar.fightsystem.fight.Fight; +import de.steamwar.fightsystem.fight.FightTeam; import de.steamwar.fightsystem.states.FightState; import de.steamwar.fightsystem.utils.Region; -import org.bukkit.entity.Entity; import org.bukkit.event.EventHandler; import org.bukkit.event.entity.EntityExplodeEvent; import java.util.EnumSet; +import java.util.HashMap; +import java.util.Map; -public class WinconditionPercentSystem extends ListenerWincondition { +public class WinconditionPercentSystem extends ListenerWincondition implements PrintableWincondition, PercentWincondition { - private static double bluePercent = 0D; - private static double redPercent = 0D; + private static final int SCHEMATIC_SIZE = Math.abs(Config.SchemsizeX * Config.SchemsizeY * Config.SchemsizeZ); - private static int blueDestroyedBlocks; - private static int redDestroyedBlocks; - - private static final int schematicSize = Math.abs(Config.SchemsizeX * Config.SchemsizeY * Config.SchemsizeZ); + private final Map teamMap = new HashMap<>(); public WinconditionPercentSystem() { - super(Config.PercentSystem, EnumSet.of(FightState.RUNNING)); + super(Winconditions.PERCENT_SYSTEM, EnumSet.of(FightState.RUNNING), "Percent"); + printableWinconditions.add(this); + percentWincondition = this; + teamMap.put(Fight.getBlueTeam(), new TeamPercent(Fight.getBlueTeam())); + teamMap.put(Fight.getRedTeam(), new TeamPercent(Fight.getRedTeam())); } @EventHandler public void handleEntityExplode(EntityExplodeEvent event) { - Entity entity = event.getEntity(); + teamMap.values().forEach(teamPercent -> teamPercent.check(event)); + } - //Team Blue - if(Region.isInRange(entity.getLocation(), Config.TeamBlueCornerX, Config.TeamBlueCornerY, Config.TeamBlueCornerZ, Config.SchemsizeX, Config.SchemsizeY, Config.SchemsizeZ, Config.BorderFromSchematic)){ - blueDestroyedBlocks = blueDestroyedBlocks + event.blockList().size(); - double doubleBlueDestroyedBlocks = blueDestroyedBlocks; - double destroyPercent = doubleBlueDestroyedBlocks * 100 / schematicSize; - bluePercent = destroyPercent; - if(destroyPercent >= Config.PercentWin) { - FightSystem.setSpectateState(Fight.getRedTeam(), "Percent"); + @Override + public String getDisplay(FightTeam team) { + return team.getPrefix() + "Schaden: " + (Math.round(100.0 * getPercent(team)) / 100.0) + "%"; + } + + @Override + public double getPercent(FightTeam team) { + return teamMap.get(team).percent; + } + + private class TeamPercent { + + private final FightTeam team; + private double percent; + private int destroyedBlocks; + + private TeamPercent(FightTeam team) { + this.team = team; + } + + private void check(EntityExplodeEvent event) { + if(!Region.isInRange(event.getEntity().getLocation(), team.getCornerX(), team.getCornerY(), team.getCornerZ(), Config.SchemsizeX, Config.SchemsizeY, Config.SchemsizeZ, Config.BorderFromSchematic)){ + return; } - //Team Red - }else if(Region.isInRange(entity.getLocation(), Config.TeamRedCornerX, Config.TeamRedCornerY, Config.TeamRedCornerZ, Config.SchemsizeX, Config.SchemsizeY, Config.SchemsizeZ, Config.BorderFromSchematic)) { - redDestroyedBlocks = redDestroyedBlocks + event.blockList().size(); - double doubleRedDestroyedBlocks = redDestroyedBlocks; - double destroyPercent = doubleRedDestroyedBlocks * 100 / schematicSize; - redPercent = destroyPercent; - if(destroyPercent >= Config.PercentWin) { - FightSystem.setSpectateState(Fight.getBlueTeam(), "Percent"); + + destroyedBlocks += event.blockList().size(); + percent = (double)destroyedBlocks * 100 / SCHEMATIC_SIZE; + if(percent >= Config.PercentWin) { + win(Fight.getOpposite(team), "§cTeam ", " §chat den Gegnern"); } } } - - public static double getBluePercent() { - return bluePercent; - } - - public static double getRedPercent() { - return redPercent; - } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPercentTimeout.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPercentTimeout.java index 97d0c14..7cdd9d5 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPercentTimeout.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPercentTimeout.java @@ -1,40 +1,43 @@ +/* + This file is a part of the SteamWar software. + + Copyright (C) 2020 SteamWar.de-Serverteam + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + package de.steamwar.fightsystem.winconditions; -import de.steamwar.fightsystem.Config; -import de.steamwar.fightsystem.FightSystem; -import de.steamwar.fightsystem.countdown.TimeOverCountdown; import de.steamwar.fightsystem.fight.Fight; -import de.steamwar.fightsystem.states.FightState; +import de.steamwar.fightsystem.fight.FightTeam; -import java.util.EnumSet; - -public class WinconditionPercentTimeout extends Wincondition { - - private static final String WINDESCRIPTION = "PercentTimeout"; - - private TimeOverCountdown countdown; +public class WinconditionPercentTimeout extends TimeoutWincondition { public WinconditionPercentTimeout() { - super(Config.HeartRatioTimeout, EnumSet.of(FightState.RUNNING)); + super(Winconditions.HEART_RATIO_TIMEOUT, "PercentTimeout"); } @Override - public void enable() { - countdown = new TimeOverCountdown(() -> { - double bluePercent = WinconditionPercentSystem.getBluePercent(); - double redPercent = WinconditionPercentSystem.getRedPercent(); + protected void timeOver() { + double bluePercent = Wincondition.percentWincondition.getPercent(Fight.getBlueTeam()); + double redPercent = Wincondition.percentWincondition.getPercent(Fight.getRedTeam()); - if(bluePercent > redPercent) - FightSystem.setSpectateState(Fight.getBlueTeam(), WINDESCRIPTION); - else if(bluePercent < redPercent) - FightSystem.setSpectateState(Fight.getRedTeam(), WINDESCRIPTION); - else - FightSystem.setSpectateState(null, WINDESCRIPTION); - }); - } - - @Override - public void disable(){ - countdown.disable(); + FightTeam team = null; + if(bluePercent > redPercent) + team = Fight.getRedTeam(); + else if(bluePercent < redPercent) + team = Fight.getBlueTeam(); + win(team, "§cDie Zeit ist abgelaufen, und Team ", " §chatte weniger Schaden erlitten!", "§cDie Zeit ist abgelaufen, und beide Teams hatten gleichen Schaden!"); } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPoints.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPoints.java index 6292b2e..beaa543 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPoints.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPoints.java @@ -19,54 +19,67 @@ package de.steamwar.fightsystem.winconditions; -import de.steamwar.fightsystem.Config; import de.steamwar.fightsystem.FightSystem; -import de.steamwar.fightsystem.countdown.TimeOverCountdown; import de.steamwar.fightsystem.fight.Fight; import de.steamwar.fightsystem.fight.FightTeam; import de.steamwar.fightsystem.states.FightState; import org.bukkit.Bukkit; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; +import org.bukkit.event.HandlerList; +import org.bukkit.event.Listener; import org.bukkit.event.entity.PlayerDeathEvent; import org.bukkit.event.player.PlayerQuitEvent; -public class WinconditionPoints extends PlayerWincondition { +import java.util.HashMap; +import java.util.Map; - private static TeamPoints blue; - private static TeamPoints red; - private TimeOverCountdown countdown; +public class WinconditionPoints extends TimeoutWincondition implements PrintableWincondition, Listener { + + private final Map percentMap = new HashMap<>(); + private final Map teamMap = new HashMap<>(); public WinconditionPoints(){ - super(Config.Points); + super(Winconditions.POINTS, FightState.INGAME, "Points"); + + percentMap.put(Fight.getBlueTeam(), new WinconditionRelativePercent.TeamPercent(Fight.getBlueTeam())); + percentMap.put(Fight.getRedTeam(), new WinconditionRelativePercent.TeamPercent(Fight.getRedTeam())); + + teamMap.put(Fight.getBlueTeam(), new TeamPoints(Fight.getBlueTeam())); + teamMap.put(Fight.getRedTeam(), new TeamPoints(Fight.getRedTeam())); + printableWinconditions.add(this); } - public static TeamPoints getRed(){ - return red; - } + @Override + protected void timeOver() { + int redPoints = teamMap.get(Fight.getRedTeam()).getPoints(); + int bluePoints = teamMap.get(Fight.getBlueTeam()).getPoints(); - public static TeamPoints getBlue(){ - return blue; + FightTeam team = null; + if(redPoints > bluePoints) + team = Fight.getRedTeam(); + else if(redPoints < bluePoints) + team = Fight.getBlueTeam(); + + win(team, "§cDas Team ", " §chat mehr Punkte!", "§cBeide Teams haben gleich viele Punkte!"); } @Override public void enable() { - super.enable(); - blue = new TeamPoints(Fight.getRedTeam(), WinconditionRelativePercent.getBlue(), WinconditionRelativePercent.getRed()); - red = new TeamPoints(Fight.getBlueTeam(), WinconditionRelativePercent.getRed(), WinconditionRelativePercent.getBlue()); + Bukkit.getPluginManager().registerEvents(this, FightSystem.getPlugin()); + teamMap.values().forEach(TeamPoints::enable); } @Override public void disable() { super.disable(); - if(countdown != null) - countdown.disable(); + HandlerList.unregisterAll(this); } @Override public void stateChange(FightState state){ if(state == FightState.RUNNING){ - countdown = new TimeOverCountdown(this::fightEnds); + super.enable(); } } @@ -81,73 +94,63 @@ public class WinconditionPoints extends PlayerWincondition { } private void handleDeath(Player player, String message){ - if(!isTarget(player)) + FightTeam team = isTarget(player); + if(team == null) return; - FightTeam fightTeam = Fight.getPlayerTeam(player); - TeamPoints enemy = getEnemyByTeam(fightTeam); - assert fightTeam != null; // Checked by isTarget - if(fightTeam.isPlayerLeader(player)) { + TeamPoints enemy = teamMap.get(Fight.getOpposite(team)); + if(team.isPlayerLeader(player)) { enemy.points += 500; - Bukkit.broadcastMessage(FightSystem.PREFIX + "§cDer Leader von " + fightTeam.getPrefix() + fightTeam.getColoredName() + message); - fightEnds(); - }else if(fightTeam.getPlayers().size() <= 5) + Bukkit.broadcastMessage(FightSystem.PREFIX + "§cDer Leader von " + team.getColoredName() + message); + timeOver(); + }else if(team.getPlayers().size() <= 5) enemy.points += 300; else enemy.points += 200; } - private void fightEnds(){ - if(red.getPoints() > blue.getPoints()) - FightSystem.setSpectateState(blue.enemy, "Points"); - else if(red.getPoints() < blue.getPoints()) - FightSystem.setSpectateState(red.enemy, "Points"); - else - FightSystem.setSpectateState(null, "Points"); + @Override + public String getDisplay(FightTeam team) { + return team.getPrefix() + "Punkte: " + teamMap.get(team).getPoints(); } - private TeamPoints getEnemyByTeam(FightTeam team){ - if(team == blue.enemy) - return blue; - else - return red; - } + private class TeamPoints { + private static final int MAX_POINTS = 2000; + + private final FightTeam team; - public static class TeamPoints { - private final FightTeam enemy; - private final WinconditionRelativePercent.TeamPercent enemyPercent; private double factor; - private static final int maxPoints = 2000; - private int points; - TeamPoints(FightTeam enemy, WinconditionRelativePercent.TeamPercent ownPercent, WinconditionRelativePercent.TeamPercent enemyPercent){ - this.enemy = enemy; - this.enemyPercent = enemyPercent; + TeamPoints(FightTeam team){ + this.team = team; points = 0; + } - //Prevent NPE - Bukkit.getScheduler().runTask(FightSystem.getPlugin(), () ->{ - if(enemyPercent.getBlockCount() < ownPercent.getBlockCount()) - this.factor = 10000; //Original mit 20 (20% = 0.2 ergeben 2000 Punkte - else{ - double f = 10000.0 * ownPercent.getBlockCount() / enemyPercent.getBlockCount(); + public void enable() { + percentMap.get(team).enable(); + int ownBlocks = percentMap.get(team).getBlockCount(); + int enemyBlocks = percentMap.get(Fight.getOpposite(team)).getBlockCount(); - if(f > 10000) - f = 10000; - else if(f < 4000) - f = 4000; + if(enemyBlocks < ownBlocks) { + this.factor = 10000; //Original mit 20 (20% = 0.2 ergeben 2000 Punkte + } else { + double f = 10000.0 * ownBlocks / enemyBlocks; - this.factor = f; - } - }); + if(f > 10000) + f = 10000; + else if(f < 4000) + f = 4000; + + this.factor = f; + } } public int getPoints(){ - int damagePoints = (int)(enemyPercent.getPercent() * factor); - if(damagePoints > maxPoints) - damagePoints = maxPoints; + int damagePoints = (int)(percentMap.get(Fight.getOpposite(team)).getPercent() * factor); + if(damagePoints > MAX_POINTS) + damagePoints = MAX_POINTS; return points + damagePoints; } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPumpkinTechKO.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPumpkinTechKO.java index 6194b94..2355cbc 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPumpkinTechKO.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionPumpkinTechKO.java @@ -30,31 +30,26 @@ import org.bukkit.Material; import org.bukkit.World; import org.bukkit.scheduler.BukkitTask; -import java.util.EnumSet; +import java.util.HashMap; +import java.util.Map; -public class WinconditionPumpkinTechKO extends Wincondition { +public class WinconditionPumpkinTechKO extends Wincondition implements PrintableWincondition { - private static int teamRedPumpkins = -1; - private static int teamBluePumpkins = -1; - private static final World WORLD = Bukkit.getWorlds().get(0); + private static final World world = Bukkit.getWorlds().get(0); private static final Material PUMPKIN_LANTERN = SWItem.getMaterial("JACK_O_LANTERN"); + + private final Map teamMap = new HashMap<>(); private BukkitTask task; - private static boolean running = false; public WinconditionPumpkinTechKO(){ - super(Config.PumpkinTechKO, EnumSet.of(FightState.PRE_RUNNING, FightState.RUNNING)); - } - - public static int getTeamBluePumpkins() { - return teamBluePumpkins; - } - public static int getTeamRedPumpkins() { - return teamRedPumpkins; + super(Winconditions.PUMPKIN_TECH_KO, FightState.INGAME, "PumpkinTechKO"); + teamMap.put(Fight.getRedTeam(), new TeamPumpkin(Fight.getRedTeam())); + teamMap.put(Fight.getBlueTeam(), new TeamPumpkin(Fight.getBlueTeam())); } @Override public void enable() { - task = Bukkit.getScheduler().runTaskTimerAsynchronously(FightSystem.getPlugin(), WinconditionPumpkinTechKO::recursiveCheck, 0, 200); + task = Bukkit.getScheduler().runTaskTimer(FightSystem.getPlugin(), this::check, 0, 200); } @Override @@ -62,45 +57,38 @@ public class WinconditionPumpkinTechKO extends Wincondition { task.cancel(); } - private static void recursiveCheck(){ - if(running) - return; - running = true; - teamRedPumpkins = getPumpkins(Config.TeamRedCornerX, - Config.TeamRedCornerY, - Config.TeamRedCornerZ, - Config.TeamRedCornerX + Config.SchemsizeX, - Config.TeamRedCornerY + Config.SchemsizeY, - Config.TeamRedCornerZ + Config.SchemsizeZ); - teamBluePumpkins = getPumpkins(Config.TeamBlueCornerX, - Config.TeamBlueCornerY, - Config.TeamBlueCornerZ, - Config.TeamBlueCornerX + Config.SchemsizeX, - Config.TeamBlueCornerY + Config.SchemsizeY, - Config.TeamBlueCornerZ + Config.SchemsizeZ); - - checkKO(Fight.getRedTeam(), teamRedPumpkins); - checkKO(Fight.getBlueTeam(), teamBluePumpkins); - running = false; + private void check(){ + teamMap.values().forEach(TeamPumpkin::check); } - private static int getPumpkins(int minX, int minY, int minZ, int maxX, int maxY, int maxZ){ - int pumpkins = 0; - for(int x = minX; x <= maxX; x++) { - for(int y = minY; y <= maxY; y++) { - for (int z = minZ; z <= maxZ; z++) { - if (WORLD.getBlockAt(x, y, z).getType() == PUMPKIN_LANTERN) - pumpkins++; + @Override + public String getDisplay(FightTeam team) { + return team.getPrefix() + "Kanonen: " + teamMap.get(team).pumpkins; + } + + private class TeamPumpkin { + private final FightTeam team; + + private int pumpkins; + + private TeamPumpkin (FightTeam team) { + this.team = team; + } + + private void check(){ + pumpkins = 0; + for(int x = team.getCornerX(); x <= team.getCornerX() + Config.SchemsizeX; x++) { + for(int y = team.getCornerY(); y <= team.getCornerY() + Config.SchemsizeY; y++) { + for (int z = team.getCornerZ(); z <= team.getCornerZ() + Config.SchemsizeZ; z++) { + if (world.getBlockAt(x, y, z).getType() == PUMPKIN_LANTERN) + pumpkins++; + } } } - } - return pumpkins; - } - private static void checkKO(FightTeam team, int pumpkins){ - if(pumpkins == 0){ - Bukkit.broadcastMessage(FightSystem.PREFIX + "§eDas Team " + team.getColoredName() + " §eist Tech K.O.!"); - Bukkit.getScheduler().runTask(FightSystem.getPlugin(), () -> FightSystem.setSpectateState(Fight.getOpposite(team), "PumpkinTechKO")); + if(pumpkins == 0) { + win(Fight.getOpposite(team), "§cDas Team ", " §cist Tech K.O.!"); + } } } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionRelativePercent.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionRelativePercent.java index c8d762f..78cad8e 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionRelativePercent.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionRelativePercent.java @@ -21,7 +21,6 @@ package de.steamwar.fightsystem.winconditions; import de.steamwar.fightsystem.Config; import de.steamwar.fightsystem.FightSystem; -import de.steamwar.fightsystem.countdown.TimeOverCountdown; import de.steamwar.fightsystem.fight.Fight; import de.steamwar.fightsystem.fight.FightTeam; import de.steamwar.fightsystem.states.FightState; @@ -30,16 +29,12 @@ import org.bukkit.Material; import org.bukkit.World; import org.bukkit.scheduler.BukkitTask; -import java.util.Collections; -import java.util.EnumSet; -import java.util.HashSet; -import java.util.Set; +import java.util.*; -public class WinconditionRelativePercent extends Wincondition{ +public class WinconditionRelativePercent extends Wincondition implements PrintableWincondition, PercentWincondition { + private static final World world = Bukkit.getWorlds().get(0); private static final Set ignoredBlocks; - private static TeamPercent blue = null; - private static TeamPercent red = null; static{ Set ignored = new HashSet<>(); @@ -48,74 +43,78 @@ public class WinconditionRelativePercent extends Wincondition{ ignoredBlocks = Collections.unmodifiableSet(ignored); } + private final Map teamMap = new HashMap<>(); + public WinconditionRelativePercent(){ - super(Config.RelativePercent || Config.Points, EnumSet.of(FightState.PRE_RUNNING, FightState.RUNNING)); - } - - public static TeamPercent getBlue(){ - if(blue == null) - blue = new TeamPercent(Fight.getBlueTeam()); - return blue; - } - - public static TeamPercent getRed(){ - if(red == null) - red = new TeamPercent(Fight.getRedTeam()); - return red; + super(Winconditions.RELATIVE_PERCENT, EnumSet.of(FightState.PRE_RUNNING, FightState.RUNNING), "RelativePercent"); + teamMap.put(Fight.getBlueTeam(), new TeamPercent(Fight.getBlueTeam())); + teamMap.put(Fight.getRedTeam(), new TeamPercent(Fight.getRedTeam())); + printableWinconditions.add(this); + percentWincondition = this; } @Override public void enable() { - getBlue(); - getRed(); + teamMap.values().forEach(TeamPercent::enable); } @Override public void disable() { - blue.task.cancel(); - red.task.cancel(); + teamMap.values().forEach(teamPercent -> teamPercent.task.cancel()); + } + + @Override + public double getPercent(FightTeam team) { + return teamMap.get(team).getPercent(); + } + + @Override + public String getDisplay(FightTeam team) { + return team.getPrefix() + "Schaden: " + (Math.round(100.0 * getPercent(team)) / 100.0) + "%"; } public static class TeamPercent { - private static final World world = Bukkit.getWorlds().get(0); private final FightTeam team; - private final int blockCount; - private final BukkitTask task; - private boolean running = false; + private int blockCount; + private BukkitTask task; private int currentBlocks; - private TeamPercent(FightTeam team){ + public TeamPercent(FightTeam team){ this.team = team; - this.blockCount = currentBlocks(); - this.currentBlocks = blockCount; - - task = Bukkit.getScheduler().runTaskTimerAsynchronously(FightSystem.getPlugin(), () -> { - if(running) - return; - running = true; - currentBlocks = currentBlocks(); - checkPercentDefeat(); - running = false; - }, 400, 400); + this.currentBlocks = 1; } - public double getPrintablePercent(){ - return Math.round(10000.0 * getPercent()) / 100.0; + public void enable(){ + blockCount = currentBlocks(); + task = Bukkit.getScheduler().runTaskTimer(FightSystem.getPlugin(), this::check, 400, 400); } - final int getBlockCount(){ + private void check(){ + currentBlocks = currentBlocks(); + + if(!Config.ActiveWinconditions.contains(Winconditions.RELATIVE_PERCENT)) + return; + + if(getPercent() >= Config.PercentWin){ + Bukkit.broadcastMessage(FightSystem.PREFIX + "§cDer Schiff von " + team.getColoredName() + " §cwurde zu stark beschädigt!"); + FightSystem.setSpectateState(Fight.getOpposite(team), "RelativePercent"); + } + } + + public double getPercent(){ + if(currentBlocks > blockCount) + return 0; + return (blockCount - currentBlocks) * 100 / (double) blockCount; + } + + public int getBlockCount(){ return blockCount; } - double getPercent(){ - int blocksDestroyed = blockCount - currentBlocks; - return blocksDestroyed > 0 ? blocksDestroyed / (double) blockCount : 0; - } - private int currentBlocks(){ // Entern active - if(!Config.EnterStages.isEmpty() && Config.EnterStages.get(0) >= Config.TimeoutTime - TimeOverCountdown.getRemainingTime()) + if(!Config.EnterStages.isEmpty() && Config.EnterStages.get(0) >= Config.TimeoutTime - TimeoutWincondition.getTimeOverCountdown().getTimeLeft()) return currentBlocks; int blocks = 0; @@ -129,14 +128,5 @@ public class WinconditionRelativePercent extends Wincondition{ } return blocks; } - - private void checkPercentDefeat(){ - if(!Config.RelativePercent) - return; - if(getPercent() * 100 >= Config.PercentWin){ - Bukkit.broadcastMessage(FightSystem.PREFIX + "§cDer Schiff von " + team.getColoredName() + " §cwurde zu stark beschädigt!"); - Bukkit.getScheduler().runTask(FightSystem.getPlugin(), () -> FightSystem.setSpectateState(Fight.getOpposite(team), "RelativePercent")); - } - } } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionTechKO.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionTimeTechKO.java similarity index 95% rename from FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionTechKO.java rename to FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionTimeTechKO.java index 1652e2d..b6a8b08 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionTechKO.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionTimeTechKO.java @@ -32,7 +32,7 @@ import org.bukkit.scheduler.BukkitTask; import java.util.EnumSet; -public class WinconditionTechKO extends ListenerWincondition { +public class WinconditionTimeTechKO extends ListenerWincondition { private static final int TECH_KO_TIME_IN_S = 90; private static final int TECH_KO_HALF_TIME = TECH_KO_TIME_IN_S*10; @@ -51,8 +51,8 @@ public class WinconditionTechKO extends ListenerWincondition { /** * Works only for z-Axis fight direction for performance reasons */ - public WinconditionTechKO(){ - super(Config.TechKO, EnumSet.of(FightState.RUNNING)); + public WinconditionTimeTechKO(){ + super(Winconditions.TIME_TECH_KO, EnumSet.of(FightState.RUNNING), null); if(Config.TeamBluetoReddistanceZ > 0) { smallerZteam = Fight.getBlueTeam(); diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionTimeout.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionTimeout.java index 9143d22..4151852 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionTimeout.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionTimeout.java @@ -19,28 +19,14 @@ package de.steamwar.fightsystem.winconditions; -import de.steamwar.fightsystem.Config; -import de.steamwar.fightsystem.FightSystem; -import de.steamwar.fightsystem.countdown.TimeOverCountdown; -import de.steamwar.fightsystem.states.FightState; - -import java.util.EnumSet; - -public class WinconditionTimeout extends Wincondition { - - private TimeOverCountdown countdown; +public class WinconditionTimeout extends TimeoutWincondition { public WinconditionTimeout() { - super(Config.Timeout, EnumSet.of(FightState.RUNNING)); + super(Winconditions.TIMEOUT, "Timeout"); } @Override - public void enable() { - countdown = new TimeOverCountdown(() -> FightSystem.setSpectateState(null, "Timeout")); - } - - @Override - public void disable() { - countdown.disable(); + protected void timeOver() { + win(null, null, null, "§cDie Zeit ist abgelaufen!"); } } diff --git a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionWaterTechKO.java b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionWaterTechKO.java index c3ec8d8..845aa25 100644 --- a/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionWaterTechKO.java +++ b/FightSystem_Main/src/de/steamwar/fightsystem/winconditions/WinconditionWaterTechKO.java @@ -30,32 +30,26 @@ import org.bukkit.World; import org.bukkit.scheduler.BukkitTask; import java.util.EnumSet; +import java.util.HashMap; +import java.util.Map; -public class WinconditionWaterTechKO extends Wincondition { +public class WinconditionWaterTechKO extends Wincondition implements PrintableWincondition { - private static int teamRedWater; - private static int teamBlueWater; private static final World WORLD = Bukkit.getWorlds().get(0); + private final Map teamMap = new HashMap<>(); private BukkitTask task; - private boolean running = false; public WinconditionWaterTechKO() { - super(Config.WaterTechKO, EnumSet.of(FightState.PRE_RUNNING, FightState.RUNNING)); - } - - public static int getTeamBlueWater() { - return teamBlueWater; - } - - public static int getTeamRedWater() { - return teamRedWater; + super(Winconditions.WATER_TECH_KO, EnumSet.of(FightState.PRE_RUNNING, FightState.RUNNING), "WaterTechKO"); + teamMap.put(Fight.getBlueTeam(), new TeamWater(Fight.getBlueTeam())); + teamMap.put(Fight.getRedTeam(), new TeamWater(Fight.getRedTeam())); + printableWinconditions.add(this); } @Override public void enable() { - checkTask(); - task = Bukkit.getScheduler().runTaskTimerAsynchronously(FightSystem.getPlugin(), this::checkTask, 200, 200); + task = Bukkit.getScheduler().runTaskTimer(FightSystem.getPlugin(), this::check, 200, 200); } @Override @@ -63,47 +57,37 @@ public class WinconditionWaterTechKO extends Wincondition { task.cancel(); } - private void checkEmpty(FightTeam team, int teamWater){ - if(teamWater == 0){ - Bukkit.broadcastMessage(FightSystem.PREFIX + "§eDas Team " + team.getColoredName() + " §eist Tech K.O.!"); - Bukkit.getScheduler().runTask(FightSystem.getPlugin(), () -> FightSystem.setSpectateState(Fight.getOpposite(team), "WaterTechKO")); + private void check() { + teamMap.values().forEach(TeamWater::check); + } + + @Override + public String getDisplay(FightTeam team) { + return team.getPrefix() + "Wasser: " + teamMap.get(team).water; + } + + private class TeamWater { + private final FightTeam team; + private int water; + + private TeamWater(FightTeam team) { + this.team = team; } - } - private void checkTask() { - if(running) - return; - running = true; - teamRedWater = calcWater( - Config.TeamRedCornerX, - Config.TeamRedCornerY, - Config.TeamRedCornerZ, - Config.TeamRedCornerX + Config.SchemsizeX, - Config.TeamRedCornerY + Config.SchemsizeY, - Config.TeamRedCornerZ + Config.SchemsizeZ); - teamBlueWater = calcWater( - Config.TeamBlueCornerX, - Config.TeamBlueCornerY, - Config.TeamBlueCornerZ, - Config.TeamBlueCornerX + Config.SchemsizeX, - Config.TeamBlueCornerY + Config.SchemsizeY, - Config.TeamBlueCornerZ + Config.SchemsizeZ); - - checkEmpty(Fight.getRedTeam(), teamRedWater); - checkEmpty(Fight.getBlueTeam(), teamBlueWater); - running = false; - } - - private int calcWater(int minX, int minY, int minZ, int maxX, int maxY, int maxZ){ - int teamWater = 0; - for(int x = minX; x <= maxX; x++) { - for(int y = minY; y <= maxY; y++) { - for (int z = minZ; z <= maxZ; z++) { - if (WaterRemover.isWater(WORLD.getBlockAt(x, y, z))) - teamWater++; + private void check() { + water = 0; + for(int x = team.getCornerX(); x <= team.getCornerX() + Config.SchemsizeX; x++) { + for(int y = team.getCornerY(); y <= team.getCornerY() + Config.SchemsizeY; y++) { + for (int z = team.getCornerZ(); z <= team.getCornerZ() + Config.SchemsizeZ; z++) { + if (WaterRemover.isWater(WORLD.getBlockAt(x, y, z))) + water++; + } } } + + if(water == 0){ + win(Fight.getOpposite(team), "§cDas Team ", " §cist Tech K.O.!"); + } } - return teamWater; } }