M_Viper/VelocityFall
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Update from Git Manager GUI

Browse Source
This commit is contained in:
M_Viper
2026-02-01 22:36:30 +01:00
parent 4c476a1a1d
commit b36bdaa3ec
22 changed files with 988 additions and 346 deletions
Download Patch File Download Diff File Expand all files Collapse all files

357
src/main/java/de/velocityfall/manager/GameManager.java
View File

@@ -1,6 +1,7 @@
package de.velocityfall.manager;
import de.velocityfall.VelocityFall;
import de.velocityfall.utils.ScoreboardHelper;
import de.velocityfall.utils.StatsHandler;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
@@ -18,7 +19,6 @@ import org.bukkit.scheduler.BukkitRunnable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class GameManager {
@@ -27,6 +27,7 @@ public class GameManager {
* --------------------------------------------------- */
public static void startArenaCountdown(String arenaName) {
final VelocityFall plugin = VelocityFall.getInstance();
if (plugin == null) return;
if (plugin.getGameStartedMap().getOrDefault(arenaName, false)) return;
new BukkitRunnable() {
@@ -56,12 +57,24 @@ public class GameManager {
Location spawn = plugin.getArenaManager()
.getArenaConfig().getLocation("Arenas." + arenaName + ".Spawn");
// PLAYED Stats erhöhen für alle Spieler
plugin.getPlayerArenaMap().forEach((p, a) -> {
if (arenaName.equals(a)) {
// Stats tracken
StatsHandler.addPlayed(p.getUniqueId().toString());
// Teleport & Setup
if (spawn != null) p.teleport(spawn);
p.setGameMode(GameMode.ADVENTURE);
p.setAllowFlight(false);
p.playSound(p.getLocation(), Sound.ENTITY_GENERIC_EXPLODE, 1f, 1f);
// Scoreboard auf InGame umschalten
try {
ScoreboardHelper.updateBoard(p, arenaName, true);
} catch (Exception e) {
plugin.getLogger().warning("Scoreboard Update fehlgeschlagen: " + e.getMessage());
}
}
});
cancel();
@@ -76,22 +89,24 @@ public class GameManager {
}
/* ---------------------------------------------------
* WIN HANDLING
* WIN HANDLING - MIT STATS TRACKING
* --------------------------------------------------- */
public static void checkForWinner(String arenaName) {
final VelocityFall plugin = VelocityFall.getInstance();
if (plugin == null) return;
int remaining = plugin.getArenaPlayersCountMap().getOrDefault(arenaName, 0);
if (remaining != 1) return;
// 1) Versuche Gewinner zuverlässig über playerArenaMap (Single source)
// 1) Gewinner finden (Nicht-Spectator)
Player winner = plugin.getPlayerArenaMap().entrySet().stream()
.filter(e -> arenaName.equals(e.getValue()))
.map(Map.Entry::getKey)
.filter(p -> p.getGameMode() != GameMode.SPECTATOR) // Nicht-Spectator = Gewinner
.filter(p -> p.getGameMode() != GameMode.SPECTATOR)
.findFirst()
.orElse(null);
// 2) Fallback: VelocityFall.getArenaPlayers(arenaName)
// Fallback
if (winner == null) {
List<Player> arenaPlayers = VelocityFall.getArenaPlayers(arenaName);
for (Player p : arenaPlayers) {
@@ -102,40 +117,155 @@ public class GameManager {
}
}
if (winner == null) return; // kein Gewinner auffindbar → exit
if (winner == null) return;
final Player finalWinner = winner;
// Nachricht + Stats + Scoreboard
try {
finalWinner.sendMessage(VelocityFall.prefix + ChatColor.translateAlternateColorCodes('&',
plugin.getMessages().getMessagesConfig()
.getString("WinMessage", "&aDu hast gewonnen!")));
} catch (Exception ignored) {}
// 2) Lose-Location ermitteln
Location loseLocation = findLoseLocation(arenaName);
final Location finalLoseLocation = loseLocation;
// 3) Verlierer sammeln (alle Spectators)
List<Player> losers = new ArrayList<>();
plugin.getPlayerArenaMap().forEach((p, a) -> {
if (arenaName.equals(a) && !p.equals(finalWinner) && p.getGameMode() == GameMode.SPECTATOR) {
losers.add(p);
}
});
final List<Player> finalLosers = new ArrayList<>(losers);
// 4) STATS TRACKING - GEWINNER
try {
StatsHandler.addWin(finalWinner.getUniqueId().toString());
} catch (Exception ignored) {}
} catch (Exception e) {
plugin.getLogger().warning("Win-Stats konnten nicht gespeichert werden: " + e.getMessage());
}
// 5) STATS TRACKING - VERLIERER
for (Player loser : finalLosers) {
try {
StatsHandler.addLose(loser.getUniqueId().toString());
} catch (Exception e) {
plugin.getLogger().warning("Lose-Stats konnten nicht gespeichert werden: " + e.getMessage());
}
}
// 6) GEWINNER VORBEREITEN
try {
finalWinner.setScoreboard(Bukkit.getScoreboardManager().getNewScoreboard());
} catch (Exception ignored) {}
finalWinner.setAllowFlight(true);
finalWinner.setFlying(true);
Location winnerSafeLoc = plugin.getArenaManager()
.getArenaConfig().getLocation("Arenas." + arenaName + ".Spawn");
if (winnerSafeLoc != null) {
finalWinner.teleport(winnerSafeLoc);
}
finalWinner.sendMessage(VelocityFall.prefix + ChatColor.translateAlternateColorCodes('&',
plugin.getMessages().getMessagesConfig().getString("WinMessage", "&aDu hast gewonnen!")));
finalWinner.sendTitle(
ChatColor.translateAlternateColorCodes('&', "&6&lSIEG!"),
ChatColor.translateAlternateColorCodes('&', "&eDu hast gewonnen!"),
10, 70, 20
);
finalWinner.playSound(finalWinner.getLocation(), Sound.UI_TOAST_CHALLENGE_COMPLETE, 1f, 1f);
ScoreboardHelper.clearBoard(finalWinner);
} catch (Exception e) {
plugin.getLogger().warning("Gewinner-Setup fehlgeschlagen: " + e.getMessage());
}
// Lose-Location: mehrere mögliche Keys supporten + YLose fallback
Location loseLocation = plugin.getArenaManager()
.getArenaConfig().getLocation("Arenas." + arenaName + ".Lose");
if (loseLocation == null) loseLocation = plugin.getArenaManager()
.getArenaConfig().getLocation("Arenas." + arenaName + ".LoseLocation");
if (loseLocation == null) loseLocation = plugin.getArenaManager()
.getArenaConfig().getLocation("Arenas." + arenaName + ".LosePoint");
if (loseLocation == null) loseLocation = plugin.getArenaManager()
.getArenaConfig().getLocation("Arenas." + arenaName + ".SetLose");
// 7) VERLIERER BENACHRICHTIGEN
for (Player loser : finalLosers) {
try {
if (finalLoseLocation != null && loser.getGameMode() == GameMode.SPECTATOR) {
loser.teleport(finalLoseLocation);
}
loser.sendTitle(
ChatColor.translateAlternateColorCodes('&', "&c&lNIEDERLAGE"),
ChatColor.translateAlternateColorCodes('&', "&e" + finalWinner.getName() + " &7hat gewonnen!"),
10, 70, 20
);
loser.playSound(loser.getLocation(), Sound.ENTITY_VILLAGER_NO, 1f, 1f);
ScoreboardHelper.clearBoard(loser);
} catch (Exception e) {
plugin.getLogger().warning("Verlierer-Setup fehlgeschlagen: " + e.getMessage());
}
}
// Spezial-Fallback: YLose vorhanden? Dann baue Location auf Basis von Spawn oder Lobby X/Z
// 8) FEUERWERK MIT DELAY
int delaySeconds = plugin.getConfig().getInt("PostWinDelay", 4);
delaySeconds = Math.min(5, Math.max(3, delaySeconds));
final long delayTicks = delaySeconds * 20L;
new BukkitRunnable() {
int fireworksSpawned = 0;
@Override
public void run() {
if (fireworksSpawned < 5) {
try {
spawnFireworks(finalWinner.getLocation().clone().add(0, 1, 0), 1);
finalWinner.playSound(finalWinner.getLocation(), Sound.ENTITY_FIREWORK_ROCKET_LAUNCH, 1f, 1f);
for (Player loser : finalLosers) {
if (loser != null && loser.isOnline()) {
loser.playSound(loser.getLocation(), Sound.ENTITY_FIREWORK_ROCKET_LAUNCH, 1f, 1f);
}
}
} catch (Exception e) {
plugin.getLogger().warning("Feuerwerk-Spawn fehlgeschlagen: " + e.getMessage());
}
fireworksSpawned++;
} else {
cancel();
// Nach Feuerwerk: Arena resetten
Bukkit.getScheduler().runTaskLater(plugin, () -> {
try {
performSafeResetAndLobbyTeleport(arenaName, finalWinner, finalLosers);
} catch (Exception e) {
plugin.getLogger().severe("Arena-Reset fehlgeschlagen: " + e.getMessage());
}
try {
plugin.ingameArenas.remove(arenaName);
plugin.getSignManager().updateSign(arenaName);
} catch (Exception ignored) {}
}, 40L);
}
}
}.runTaskTimer(plugin, delayTicks, 10L);
}
/* ---------------------------------------------------
* LOSE LOCATION FINDER - HELPER
* --------------------------------------------------- */
private static Location findLoseLocation(String arenaName) {
final VelocityFall plugin = VelocityFall.getInstance();
if (plugin == null) return null;
var arenaConfig = plugin.getArenaManager().getArenaConfig();
// Verschiedene mögliche Keys probieren
Location loseLocation = arenaConfig.getLocation("Arenas." + arenaName + ".Lose");
if (loseLocation == null) loseLocation = arenaConfig.getLocation("Arenas." + arenaName + ".LoseLocation");
if (loseLocation == null) loseLocation = arenaConfig.getLocation("Arenas." + arenaName + ".LosePoint");
if (loseLocation == null) loseLocation = arenaConfig.getLocation("Arenas." + arenaName + ".SetLose");
// YLose Fallback
if (loseLocation == null) {
Double yLose = plugin.getArenaManager().getArenaConfig().getDouble("Arenas." + arenaName + ".YLose", Double.NaN);
Double yLose = arenaConfig.getDouble("Arenas." + arenaName + ".YLose", Double.NaN);
if (!yLose.isNaN()) {
// Priorität: Spawn -> Lobby -> arena center (Pos1/Pos2 midpoint)
Location spawn = plugin.getArenaManager().getArenaConfig().getLocation("Arenas." + arenaName + ".Spawn");
Location lobby = plugin.getArenaManager().getArenaConfig().getLocation("Arenas." + arenaName + ".Lobby");
Location spawn = arenaConfig.getLocation("Arenas." + arenaName + ".Spawn");
Location lobby = arenaConfig.getLocation("Arenas." + arenaName + ".Lobby");
if (spawn != null) {
loseLocation = spawn.clone();
loseLocation.setY(yLose);
@@ -143,9 +273,9 @@ public class GameManager {
loseLocation = lobby.clone();
loseLocation.setY(yLose);
} else {
// midpoint of Pos1 and Pos2 if available
Location pos1 = plugin.getArenaManager().getArenaConfig().getLocation("Arenas." + arenaName + ".Pos1");
Location pos2 = plugin.getArenaManager().getArenaConfig().getLocation("Arenas." + arenaName + ".Pos2");
Location pos1 = arenaConfig.getLocation("Arenas." + arenaName + ".Pos1");
Location pos2 = arenaConfig.getLocation("Arenas." + arenaName + ".Pos2");
if (pos1 != null && pos2 != null && pos1.getWorld() != null && pos1.getWorld().equals(pos2.getWorld())) {
double midX = (pos1.getX() + pos2.getX()) / 2.0;
double midZ = (pos1.getZ() + pos2.getZ()) / 2.0;
@@ -155,112 +285,23 @@ public class GameManager {
}
}
final Location finalLoseLocation = loseLocation; // final für Lambdas
// Ermittlung der Verlierer: alle Spectator-Spieler in dieser Arena
List<Player> losers = new ArrayList<>();
// Strategie A: playerArenaMap - alle Spectators sind Verlierer
plugin.getPlayerArenaMap().forEach((p, a) -> {
if (arenaName.equals(a) && !p.equals(finalWinner) && p.getGameMode() == GameMode.SPECTATOR) {
losers.add(p);
}
});
// Strategie B: Falls keine Verlierer gefunden -> ingamePlayers Liste
if (losers.isEmpty()) {
try {
for (Player p : plugin.ingamePlayers) {
if (p != null && !p.equals(finalWinner) && p.getGameMode() == GameMode.SPECTATOR) {
losers.add(p);
}
}
} catch (Exception ignored) {}
}
// Strategie C: VelocityFall.getArenaPlayers(arenaName)
if (losers.isEmpty()) {
List<Player> arenaPlayers = VelocityFall.getArenaPlayers(arenaName);
if (!arenaPlayers.isEmpty()) {
for (Player p : arenaPlayers) {
if (p != null && !p.equals(finalWinner) && p.getGameMode() == GameMode.SPECTATOR) {
losers.add(p);
}
}
}
}
// Erstelle finale Liste der Verlierer (damit sie auch nach Delays verfügbar ist)
final List<Player> finalLosers = new ArrayList<>(losers);
// Teleportiere Verlierer SOFORT zum Lose-Punkt (sie sind bereits in GM3 durch FloorLoseListener)
for (Player loser : finalLosers) {
try {
// Sicherstellen, dass Spectator-Modus gesetzt ist
if (loser.getGameMode() != GameMode.SPECTATOR) {
loser.setGameMode(GameMode.SPECTATOR);
}
if (finalLoseLocation != null) {
loser.teleport(finalLoseLocation);
} else {
// fallback: direkt neben Gewinner
Location fallback = finalWinner.getLocation().clone().add(1.0, 0.0, 0.0);
loser.teleport(fallback);
}
} catch (Exception e) {
// Falls Teleport fehlschlägt, loggen wir es serverseitig
e.printStackTrace();
}
}
// Delay 3-5 Sekunden (konfigurierbar)
int delaySeconds = plugin.getConfig().getInt("PostWinDelay", 4);
delaySeconds = Math.min(5, Math.max(3, delaySeconds));
final long delayTicks = delaySeconds * 20L;
// Nach Delay: Feuerwerk beim Gewinner und dann Arena resetten / Lobby teleport
new BukkitRunnable() {
@Override
public void run() {
try {
spawnFireworks(finalWinner.getLocation(), 2);
finalWinner.playSound(finalWinner.getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 1f, 1f);
} catch (Exception ignored) {}
// 1 Sekunde später: Reset & Teleport aller zur Lobby (GM1)
new BukkitRunnable() {
@Override
public void run() {
try {
// Robustes Reset: teleportiere Gewinner + finale Verlierer-Liste zur Lobby
performSafeResetAndLobbyTeleport(arenaName, finalWinner, finalLosers);
} catch (Exception ignored) {}
// Aufräumen maps / Signs
try {
plugin.ingameArenas.remove(arenaName);
} catch (Exception ignored) {}
try {
plugin.getSignManager().updateSign(arenaName);
} catch (Exception ignored) {}
}
}.runTaskLater(plugin, 20L); // 1 Sekunde nach Feuerwerk
}
}.runTaskLater(plugin, delayTicks);
return loseLocation;
}
/* ---------------------------------------------------
* SAFE RESET & LOBBY TELEPORT (robust)
* SAFE RESET & LOBBY TELEPORT
* --------------------------------------------------- */
private static void performSafeResetAndLobbyTeleport(String arenaName, Player winner, List<Player> losers) {
final VelocityFall plugin = VelocityFall.getInstance();
if (plugin == null) return;
// Blöcke zurücksetzen
plugin.getArenaBlocksMap().forEach((block, matName) -> {
try {
block.setType(Material.valueOf(matName));
} catch (Exception ignored) {}
} catch (Exception e) {
plugin.getLogger().warning("Block-Reset fehlgeschlagen: " + e.getMessage());
}
});
plugin.getArenaBlocksMap().clear();
@@ -268,65 +309,42 @@ public class GameManager {
plugin.getGameStartedMap().put(arenaName, false);
plugin.getArenaPlayersCountMap().remove(arenaName);
// Lobby-Location (kann null sein)
// Lobby-Location
Location lobby = plugin.getArenaManager().getArenaConfig().getLocation("Arenas." + arenaName + ".Lobby");
// Sammle alle Spieler, die teleportiert werden müssen
// Alle Spieler sammeln
List<Player> toHandle = new ArrayList<>();
// Gewinner hinzufügen
if (winner != null) {
toHandle.add(winner);
}
// Verlierer hinzufügen (bereits als finale Liste übergeben)
if (winner != null) toHandle.add(winner);
for (Player loser : losers) {
if (loser != null && !toHandle.contains(loser)) {
toHandle.add(loser);
}
}
// Zusätzlich: alle restlichen Spieler aus playerArenaMap (Sicherheit)
// Sicherheit: Alle aus playerArenaMap
plugin.getPlayerArenaMap().forEach((p, a) -> {
if (arenaName.equals(a) && !toHandle.contains(p)) {
toHandle.add(p);
}
});
// Fallback: ingamePlayers
try {
for (Player p : new ArrayList<>(plugin.ingamePlayers)) {
if (p != null && !toHandle.contains(p)) {
// Prüfe ob Spieler möglicherweise zu dieser Arena gehört
String playerArena = plugin.getPlayerArenaMap().get(p);
if (arenaName.equals(playerArena)) {
toHandle.add(p);
}
}
}
} catch (Exception ignored) {}
// Fallback: VelocityFall.getArenaPlayers
try {
List<Player> arenaPlayers = VelocityFall.getArenaPlayers(arenaName);
for (Player p : arenaPlayers) {
if (p != null && !toHandle.contains(p)) toHandle.add(p);
}
} catch (Exception ignored) {}
// Verarbeite alle gesammelten Spieler: GM1 (SURVIVAL), Inventar clear, teleport zur Lobby, entferne aus Maps
// Alle Spieler resetten
for (Player p : toHandle) {
try {
p.setGameMode(GameMode.SURVIVAL); // GM1
p.setGameMode(GameMode.SURVIVAL);
p.setAllowFlight(false);
p.setFlying(false);
p.getInventory().clear();
p.getInventory().setArmorContents(null);
p.setHealth(20.0);
p.setFoodLevel(20);
p.resetTitle();
ScoreboardHelper.clearBoard(p);
if (lobby != null) {
p.teleport(lobby);
} else {
// Fallback: Spawn-Location oder World-Spawn
Location spawn = plugin.getArenaManager().getArenaConfig().getLocation("Arenas." + arenaName + ".Spawn");
if (spawn != null) {
p.teleport(spawn);
@@ -335,11 +353,10 @@ public class GameManager {
}
}
// Jetzt erst aus den Maps entfernen
plugin.ingamePlayers.remove(p);
plugin.getPlayerArenaMap().remove(p);
} catch (Exception e) {
e.printStackTrace();
plugin.getLogger().warning("Spieler-Reset fehlgeschlagen für " + p.getName() + ": " + e.getMessage());
}
}
@@ -364,12 +381,16 @@ public class GameManager {
for (int i = 0; i < Math.max(1, count); i++) {
try {
Firework fw = loc.getWorld().spawn(loc.clone().add(0, 1 + i * 0.5, 0), Firework.class);
Firework fw = loc.getWorld().spawn(loc.clone().add(0, i * 0.5, 0), Firework.class);
FireworkMeta meta = fw.getFireworkMeta();
Color[] colors = {Color.LIME, Color.YELLOW, Color.ORANGE, Color.RED, Color.AQUA, Color.FUCHSIA};
Color randomColor1 = colors[(int)(Math.random() * colors.length)];
Color randomColor2 = colors[(int)(Math.random() * colors.length)];
FireworkEffect effect = FireworkEffect.builder()
.with(FireworkEffect.Type.BALL_LARGE)
.withColor(Color.LIME, Color.YELLOW)
.withColor(randomColor1, randomColor2)
.withFade(Color.WHITE)
.trail(true)
.flicker(true)
@@ -379,7 +400,7 @@ public class GameManager {
meta.setPower(1);
fw.setFireworkMeta(meta);
} catch (Throwable t) {
t.printStackTrace();
VelocityFall.getInstance().getLogger().warning("Firework-Spawn fehlgeschlagen: " + t.getMessage());
}
}
}
@@ -389,10 +410,12 @@ public class GameManager {
* --------------------------------------------------- */
private static void broadcast(String arena, String msg) {
final VelocityFall plugin = VelocityFall.getInstance();
if (plugin == null) return;
plugin.getPlayerArenaMap().forEach((player, a) -> {
if (arena.equals(a)) {
player.sendMessage(VelocityFall.prefix + msg);
}
});
}
}
}