package com.mcspeedrun.core.game; import com.mcspeedrun.core.MCSpeedrunCore; import com.mcspeedrun.core.database.PlayerRepository; import com.mcspeedrun.core.elo.EloManager; import com.mcspeedrun.core.matchmaking.QueueManager; import com.mcspeedrun.core.rewards.RewardManager; import com.mcspeedrun.core.utils.ConfigManager; import com.mcspeedrun.core.utils.MessageManager; import com.mcspeedrun.core.world.LobbyManager; import com.mcspeedrun.core.world.MatchWorld; import com.mcspeedrun.core.world.WorldManager; import net.kyori.adventure.bossbar.BossBar; import net.kyori.adventure.text.Component; import net.kyori.adventure.title.Title; import org.bukkit.*; import org.bukkit.entity.Player; import org.bukkit.potion.PotionEffect; import java.time.Duration; import java.util.*; import java.util.concurrent.ConcurrentHashMap; /** * Manages all active game sessions and match lifecycle. */ public class GameManager { private final MCSpeedrunCore plugin; private final QueueManager queueManager; private final WorldManager worldManager; private final LobbyManager lobbyManager; private final TargetItemManager targetItemManager; private final EloManager eloManager; private final RewardManager rewardManager; private final PlayerRepository playerRepository; private final MessageManager messageManager; private final ConfigManager configManager; private final Map activeSessions; private final Map playerToSession; private final Map sessionBossBars; public GameManager(MCSpeedrunCore plugin, QueueManager queueManager, WorldManager worldManager, LobbyManager lobbyManager, TargetItemManager targetItemManager, EloManager eloManager, RewardManager rewardManager, PlayerRepository playerRepository, MessageManager messageManager, ConfigManager configManager) { this.plugin = plugin; this.queueManager = queueManager; this.worldManager = worldManager; this.lobbyManager = lobbyManager; this.targetItemManager = targetItemManager; this.eloManager = eloManager; this.rewardManager = rewardManager; this.playerRepository = playerRepository; this.messageManager = messageManager; this.configManager = configManager; this.activeSessions = new ConcurrentHashMap<>(); this.playerToSession = new ConcurrentHashMap<>(); this.sessionBossBars = new ConcurrentHashMap<>(); } /** * Create and start a new match between two players. * * @param player1Uuid first player UUID * @param player2Uuid second player UUID */ public void createMatch(UUID player1Uuid, UUID player2Uuid) { Player player1 = Bukkit.getPlayer(player1Uuid); Player player2 = Bukkit.getPlayer(player2Uuid); if (player1 == null || player2 == null) { plugin.getLogger().warning("Cannot create match: one or both players are offline"); return; } // Notify players messageManager.sendMessage(player1, "match-found"); messageManager.sendMessage(player2, "match-found"); messageManager.sendMessage(player1, "opponent-found", MessageManager.placeholder("opponent", player2.getName())); messageManager.sendMessage(player2, "opponent-found", MessageManager.placeholder("opponent", player1.getName())); playSoundIfEnabled(player1, "match-found"); playSoundIfEnabled(player2, "match-found"); // Create match world async Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> { MatchWorld matchWorld = worldManager.createMatchWorld(); if (matchWorld == null) { Bukkit.getScheduler().runTask(plugin, () -> { messageManager.sendMessage(player1, "world-create-error"); messageManager.sendMessage(player2, "world-create-error"); queueManager.addToQueue(player1Uuid); queueManager.addToQueue(player2Uuid); }); return; } // Continue on main thread Bukkit.getScheduler().runTask(plugin, () -> setupMatch(player1, player2, matchWorld)); }); } /** * Setup the match after world creation. */ private void setupMatch(Player player1, Player player2, MatchWorld matchWorld) { // Create game session GameSession session = new GameSession(player1.getUniqueId(), player2.getUniqueId(), matchWorld.getWorld()); activeSessions.put(session.getSessionId(), session); playerToSession.put(player1.getUniqueId(), session.getSessionId()); playerToSession.put(player2.getUniqueId(), session.getSessionId()); // Teleport players messageManager.sendMessage(player1, "teleporting"); messageManager.sendMessage(player2, "teleporting"); Location spawn1 = matchWorld.getPlayer1Spawn(); Location spawn2 = matchWorld.getPlayer2Spawn(); player1.teleport(spawn1); player2.teleport(spawn2); // Reset players resetPlayer(player1); resetPlayer(player2); // Select target item Material targetItem = targetItemManager.selectRandomItem(); session.setTargetItem(targetItem); // Notify players of target Map itemPlaceholder = MessageManager.placeholder("item", formatItemName(targetItem)); messageManager.sendMessage(player1, "target-item-selected", itemPlaceholder); messageManager.sendMessage(player2, "target-item-selected", itemPlaceholder); // Create boss bar createBossBar(session); // Start countdown startCountdown(session); } /** * Start the countdown before match begins. */ private void startCountdown(GameSession session) { session.setState(GameState.COUNTDOWN); int countdownSeconds = configManager.getInt("match-settings.countdown-seconds", 5); new CountdownTask(session, countdownSeconds).runTaskTimer(plugin, 0L, 20L); } /** * Countdown task runner. */ private class CountdownTask extends org.bukkit.scheduler.BukkitRunnable { private final GameSession session; private int remaining; public CountdownTask(GameSession session, int seconds) { this.session = session; this.remaining = seconds; } @Override public void run() { if (session.isFinished() || !session.isCountdown()) { cancel(); return; } Player player1 = Bukkit.getPlayer(session.getPlayer1Uuid()); Player player2 = Bukkit.getPlayer(session.getPlayer2Uuid()); if (player1 == null || player2 == null) { cancel(); endMatch(session, null); return; } if (remaining > 0) { // Show countdown Map placeholders = MessageManager.placeholder("seconds", String.valueOf(remaining)); Component title = messageManager.getComponent("countdown-line1"); Component subtitle = messageManager.getComponent("countdown-line2", placeholders); player1.showTitle(Title.title(title, subtitle, Title.Times.times(Duration.ZERO, Duration.ofSeconds(1), Duration.ZERO))); player2.showTitle(Title.title(title, subtitle, Title.Times.times(Duration.ZERO, Duration.ofSeconds(1), Duration.ZERO))); String actionBarMsg = messageManager.getMessage("countdown-actionbar", placeholders); player1.sendActionBar(Component.text(actionBarMsg)); player2.sendActionBar(Component.text(actionBarMsg)); playSoundIfEnabled(player1, "countdown"); playSoundIfEnabled(player2, "countdown"); remaining--; } else { // Start match cancel(); startMatch(session); } } } /** * Start the actual match after countdown. */ private void startMatch(GameSession session) { session.setState(GameState.RUNNING); Player player1 = Bukkit.getPlayer(session.getPlayer1Uuid()); Player player2 = Bukkit.getPlayer(session.getPlayer2Uuid()); if (player1 == null || player2 == null) { endMatch(session, null); return; } // Show start title Map placeholders = MessageManager.placeholder("item", formatItemName(session.getTargetItem())); Component title = messageManager.getComponent("match-start-title"); Component subtitle = messageManager.getComponent("match-start-subtitle", placeholders); player1.showTitle(Title.title(title, subtitle, Title.Times.times(Duration.ZERO, Duration.ofSeconds(2), Duration.ofMillis(500)))); player2.showTitle(Title.title(title, subtitle, Title.Times.times(Duration.ZERO, Duration.ofSeconds(2), Duration.ofMillis(500)))); messageManager.sendMessage(player1, "match-start-chat"); messageManager.sendMessage(player2, "match-start-chat"); playSoundIfEnabled(player1, "match-start"); playSoundIfEnabled(player2, "match-start"); } /** * End a match with an optional winner. */ public void endMatch(GameSession session, UUID winnerUuid) { if (session.isFinished()) { return; } session.setWinnerUuid(winnerUuid); session.setState(GameState.FINISHED); Player player1 = Bukkit.getPlayer(session.getPlayer1Uuid()); Player player2 = Bukkit.getPlayer(session.getPlayer2Uuid()); UUID loserUuid = null; Player winner = null; Player loser = null; if (winnerUuid != null) { loserUuid = session.getOpponent(winnerUuid); winner = Bukkit.getPlayer(winnerUuid); loser = Bukkit.getPlayer(loserUuid); // Announce winner if (winner != null && loser != null) { Map winnerPlaceholder = MessageManager.placeholder("player", winner.getName()); messageManager.sendMessage(player1, "match-winner", winnerPlaceholder); messageManager.sendMessage(player2, "match-winner", winnerPlaceholder); messageManager.sendMessage(winner, "you-won"); messageManager.sendMessage(loser, "you-lost"); playSoundIfEnabled(winner, "match-win"); playSoundIfEnabled(loser, "match-lose"); // Update Elo UUID finalLoserUuid = loserUuid; eloManager.updateEloAfterMatch(winnerUuid, loserUuid).thenAccept(eloChanges -> { Bukkit.getScheduler().runTask(plugin, () -> { int gained = eloChanges[0]; int lost = eloChanges[1]; Map gainPlaceholders = MessageManager.placeholders() .add("elo", Math.abs(gained)) .add("new_elo", "Loading...") .build(); Map lossPlaceholders = MessageManager.placeholders() .add("elo", Math.abs(lost)) .add("new_elo", "Loading...") .build(); Player currentWinner = Bukkit.getPlayer(winnerUuid); Player currentLoser = Bukkit.getPlayer(finalLoserUuid); if (currentWinner != null) { messageManager.sendMessage(currentWinner, "elo-gained", gainPlaceholders); } if (currentLoser != null) { messageManager.sendMessage(currentLoser, "elo-lost", lossPlaceholders); } }); }); // Give rewards rewardManager.giveWinnerRewards(winner); } } // Remove boss bars removeBossBar(session); // Teleport players back to lobby if (player1 != null) { lobbyManager.teleportToLobby(player1); messageManager.sendMessage(player1, "returned-to-lobby"); } if (player2 != null) { lobbyManager.teleportToLobby(player2); messageManager.sendMessage(player2, "returned-to-lobby"); } // Cleanup session playerToSession.remove(session.getPlayer1Uuid()); playerToSession.remove(session.getPlayer2Uuid()); activeSessions.remove(session.getSessionId()); // Delete world String worldName = session.getMatchWorld().getName(); Bukkit.getScheduler().runTaskLater(plugin, () -> worldManager.deleteMatchWorld(worldName), 40L); } /** * Handle player win detection. */ public void handlePlayerWin(Player player) { UUID playerUuid = player.getUniqueId(); GameSession session = getPlayerSession(playerUuid); if (session == null || !session.isRunning()) { return; } endMatch(session, playerUuid); } /** * Reset player state for match start. */ private void resetPlayer(Player player) { player.setGameMode(GameMode.SURVIVAL); player.setHealth(20.0); player.setFoodLevel(20); player.setSaturation(20.0f); player.setExp(0); player.setLevel(0); player.setFireTicks(0); player.getInventory().clear(); player.getInventory().setArmorContents(null); player.getActivePotionEffects().forEach(effect -> player.removePotionEffect(effect.getType())); } /** * Create a boss bar for the session. */ private void createBossBar(GameSession session) { String bossBarText = messageManager.getMessage("target-item-bossbar", MessageManager.placeholder("item", formatItemName(session.getTargetItem()))); BossBar bossBar = BossBar.bossBar( Component.text(bossBarText), 1.0f, BossBar.Color.YELLOW, BossBar.Overlay.PROGRESS ); Player player1 = Bukkit.getPlayer(session.getPlayer1Uuid()); Player player2 = Bukkit.getPlayer(session.getPlayer2Uuid()); if (player1 != null) { player1.showBossBar(bossBar); } if (player2 != null) { player2.showBossBar(bossBar); } sessionBossBars.put(session.getSessionId(), bossBar); } /** * Remove boss bar from session. */ private void removeBossBar(GameSession session) { BossBar bossBar = sessionBossBars.remove(session.getSessionId()); if (bossBar == null) { return; } Player player1 = Bukkit.getPlayer(session.getPlayer1Uuid()); Player player2 = Bukkit.getPlayer(session.getPlayer2Uuid()); if (player1 != null) { player1.hideBossBar(bossBar); } if (player2 != null) { player2.hideBossBar(bossBar); } } /** * Format item name for display. */ private String formatItemName(Material material) { String name = material.name().replace("_", " "); String[] words = name.split(" "); StringBuilder formatted = new StringBuilder(); for (String word : words) { if (!formatted.isEmpty()) { formatted.append(" "); } formatted.append(word.substring(0, 1).toUpperCase()) .append(word.substring(1).toLowerCase()); } return formatted.toString(); } /** * Play a sound if enabled in config. */ private void playSoundIfEnabled(Player player, String soundKey) { String soundName = configManager.getString("sounds." + soundKey, ""); if (soundName.isEmpty()) { return; } try { Sound sound = Sound.valueOf(soundName); player.playSound(player.getLocation(), sound, 1.0f, 1.0f); } catch (IllegalArgumentException e) { plugin.getLogger().warning("Invalid sound: " + soundName); } } /** * Get the session a player is in. */ public GameSession getPlayerSession(UUID playerUuid) { UUID sessionId = playerToSession.get(playerUuid); if (sessionId == null) { return null; } return activeSessions.get(sessionId); } /** * Check if a player is in a match. */ public boolean isInMatch(UUID playerUuid) { return playerToSession.containsKey(playerUuid); } /** * Get all active sessions. */ public Collection getActiveSessions() { return activeSessions.values(); } /** * Get the number of active matches. */ public int getActiveMatchCount() { return activeSessions.size(); } /** * End all active matches. */ public void endAllMatches() { List sessions = new ArrayList<>(activeSessions.values()); for (GameSession session : sessions) { endMatch(session, null); } } /** * Handle player disconnect during match. */ public void handlePlayerDisconnect(UUID playerUuid) { GameSession session = getPlayerSession(playerUuid); if (session == null) { return; } UUID opponentUuid = session.getOpponent(playerUuid); Player opponent = Bukkit.getPlayer(opponentUuid); if (opponent != null) { messageManager.sendMessage(opponent, "opponent-disconnected"); } // End match, opponent wins if match was running if (session.isRunning()) { endMatch(session, opponentUuid); } else { endMatch(session, null); } } }