Untitled

package com.misotheism.minigamemechanics;

import com.misotheism.minigamemechanics.command.ArenaCommand;
import com.misotheism.minigamemechanics.listener.ConnectListener;
import com.misotheism.minigamemechanics.listener.GameListener;
import com.misotheism.minigamemechanics.manager.ArenaManager;
import com.misotheism.minigamemechanics.manager.ConfigManager;
import org.bukkit.Bukkit;
import org.bukkit.plugin.java.JavaPlugin;

public final class Minigame extends JavaPlugin {

    private ArenaManager arenaManager;

    @Override
    public void onEnable() {
        getCommand("arena").setExecutor(new ArenaCommand(this));

        ConfigManager.setupConfig(this);

        Bukkit.getPluginManager().registerEvents(new ConnectListener(this), this);
        Bukkit.getPluginManager().registerEvents(new GameListener(this), this);

       arenaManager = new ArenaManager(this);
    }

    public ArenaManager getArenaManager() { return arenaManager; }
}


package com.misotheism.minigamemechanics;

public enum GameState {

    RECRUITING,
    COUNTDOWN,
    LIVE;
}


package com.misotheism.minigamemechanics.manager;

import com.misotheism.minigamemechanics.Minigame;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.configuration.file.FileConfiguration;

import java.io.File;

public class ConfigManager {

    private static FileConfiguration config;

    // This is going to check if the config exist, if it doesn't it will save the current config
    public static void setupConfig(Minigame minigame) {
        ConfigManager.config = minigame.getConfig();
        minigame.saveConfig();
    }

    public static int getRequiredPlayers() { return config.getInt("required-players"); }

    public static int getCountdownSeconds() { return config.getInt("countdown-seconds"); }

    public static Location getLobbySpawn() {
        return new Location(
                Bukkit.getWorld(config.getString("lobby-spawn.world")),
                config.getDouble("lobby-spawn.x"),
                config.getDouble("lobby-spawn.y"),
                config.getDouble("lobby-spawn.z"),
                (float) config.getDouble("lobby-spawn.yaw"),
                (float) config.getDouble("lobby-spawn.pitch"));
    }
}


package com.misotheism.minigamemechanics.manager;

import com.misotheism.minigamemechanics.instance.Arena;
import com.misotheism.minigamemechanics.Minigame;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.entity.Player;

import java.util.ArrayList;
import java.util.List;

public class ArenaManager {

    private List<Arena> arenas = new ArrayList<>();

    public ArenaManager(Minigame minigame) {
        FileConfiguration config = minigame.getConfig();
        for (String string : config.getConfigurationSection("arenas.").getKeys(false)) {
            arenas.add(new Arena(minigame, Integer.parseInt(string), new Location(
                    Bukkit.getWorld(config.getString("arenas." + string + ".world")),
                    config.getDouble("arenas." + string + ".x"),
                    config.getDouble("arenas." + string + ".y"),
                    config.getDouble("arenas." + string + ".z"),
                    (float) config.getDouble("arenas." + string + ".yaw"),
                    (float) config.getDouble("arenas." + string + ".pitch"))));
        }
    }

    public List<Arena> getArenas() { return arenas; }

    public Arena getArena(Player player) {
        for (Arena arena : arenas) {
            if (arena.getPlayers().contains(player.getUniqueId())) {
                return arena;
            }
        }
        return null;
    }

    public Arena getArena(int id) {
        for (Arena arena : arenas) {
            if (arena.getId() == id) {
                return arena;
            }
        }
        return null;
    }

}


package com.misotheism.minigamemechanics.listener;

import com.misotheism.minigamemechanics.GameState;
import com.misotheism.minigamemechanics.Minigame;
import com.misotheism.minigamemechanics.instance.Arena;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;

public class GameListener implements Listener {

    private Minigame minigame;

    public GameListener(Minigame minigame) {
        this.minigame = minigame;
    }

    @EventHandler
    public void onBlockBreak(BlockBreakEvent e)  {
        Player player = e.getPlayer();

        Arena arena = minigame.getArenaManager().getArena(player);
        if (arena != null && arena.getState().equals(GameState.LIVE)) {
                arena.getGame().addPoint(player);

            }
        }

    }


package com.misotheism.minigamemechanics.listener;

import com.misotheism.minigamemechanics.Minigame;
import com.misotheism.minigamemechanics.instance.Arena;
import com.misotheism.minigamemechanics.manager.ConfigManager;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;

public class ConnectListener implements Listener {

    private Minigame minigame;

    public ConnectListener(Minigame minigame) {
        this.minigame = minigame;
    }
    @EventHandler
    public void onJoin(PlayerJoinEvent e) {
        Player player = e.getPlayer();
        Location location = ConfigManager.getLobbySpawn();

        player.teleport(location);
    }

    @EventHandler
    public void onQuit(PlayerQuitEvent e) {
        Player player = e.getPlayer();

        Arena arena = minigame.getArenaManager().getArena(player);
        if (arena != null) {
            arena.removePlayer(player);
        }
    }
}


package com.misotheism.minigamemechanics.instance;

import com.misotheism.minigamemechanics.GameState;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;

import java.util.HashMap;
import java.util.Random;
import java.util.UUID;

public class Game {

    private Arena arena;
    private HashMap<UUID, Integer> points;
    int blockBreak = getRandomInt(20);

    public static Integer getRandomInt(Integer max) {
        Random ran = new Random();
        return ran.nextInt(max);

    }

    public Game(Arena arena) {
        this.arena = arena;
        this.points = new HashMap<>();
    }

    public void start() {

        arena.setState(GameState.LIVE);
        arena.sendMessage(ChatColor.GOLD + "Game has begun! Your objective is to be the first to break " + ChatColor.YELLOW + ChatColor.BOLD.toString() + blockBreak + ChatColor.GOLD + " in the fastest time, good luck!");

        for (UUID uuid : arena.getPlayers()) {
            points.put(uuid, 0);
        }

    }

    public void addPoint(Player player) {
        int playerPoints = points.get(player.getUniqueId()) + 1;

        if (playerPoints == blockBreak) {
            arena.sendMessage(ChatColor.GREEN + player.getName() + " has won, thanks for playing!");
            arena.reset(true);
            return;
        }
        player.sendMessage(ChatColor.GREEN + "+1");
        points.replace(player.getUniqueId(), playerPoints);
        }
    }


package com.misotheism.minigamemechanics.instance;

import com.misotheism.minigamemechanics.GameState;
import com.misotheism.minigamemechanics.Minigame;
import com.misotheism.minigamemechanics.manager.ConfigManager;
import org.bukkit.ChatColor;
import org.bukkit.scheduler.BukkitRunnable;


public class Countdown extends BukkitRunnable {

    private Minigame minigame;
    private Arena arena;
    private int countdownSeconds;

    public Countdown(Minigame minigame, Arena arena) {
        this.minigame = minigame;
        this.arena = arena;
        this.countdownSeconds = ConfigManager.getCountdownSeconds();
    }

    public void start() {
        arena.setState(GameState.COUNTDOWN);
        runTaskTimer(minigame, 0, 20);
    }

    @Override
    public void run() {

        countdownSeconds--;

        if (countdownSeconds == 0) {
            cancel();
            arena.start();
        } else if (countdownSeconds <= 5 || countdownSeconds % 10 == 0) {
            arena.sendMessage(ChatColor.YELLOW + "The game will start in " + ChatColor.RED.toString() + countdownSeconds + ChatColor.YELLOW + " second" + (countdownSeconds == 1 ? "" : "s") + "!");
            if (countdownSeconds == 1) {
                arena.sendTitle(ChatColor.RED.toString() + countdownSeconds, ChatColor.YELLOW + "Prepare to break!");
            } else {
                arena.sendTitle(ChatColor.RED.toString() + countdownSeconds + " seconds", ChatColor.YELLOW + "Prepare to break!");
            }
        }

        if (countdownSeconds <= 0) {
            arena.sendTitle("", "");
        }
    }

}


package com.misotheism.minigamemechanics.instance;

import com.misotheism.minigamemechanics.GameState;
import com.misotheism.minigamemechanics.Minigame;
import com.misotheism.minigamemechanics.manager.ConfigManager;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.checkerframework.checker.units.qual.C;
import sun.security.krb5.Config;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class Arena {

    private Minigame minigame;

    private int id;
    private Location spawn;

    private GameState state;
    private List<UUID> players;
    private Countdown countdown;
    private Game game;

    public Arena(Minigame minigame, int id, Location spawn) {
        this.minigame = minigame;

        this.id = id;
        this.spawn = spawn;

        this.state = GameState.RECRUITING;
        this.players = new ArrayList<>();
        this.countdown = new Countdown(minigame, this);
        this.game = new Game(this);
    }

    public void start() {
        game.start();
    }

    public void reset(boolean kickPlayers) {
        if (kickPlayers) {
            Location location = ConfigManager.getLobbySpawn();
            for (UUID uuid : players) {
                Bukkit.getPlayer(uuid).teleport(location);
            }
            players.clear();
        }
        sendTitle("", "");
        state = GameState.RECRUITING;
        countdown.cancel();
        countdown = new Countdown(minigame, this);
        game = new Game(this);
    }

    public void sendMessage(String message) {
        for (UUID uuid : players) {
            Bukkit.getPlayer(uuid).sendMessage(message);
        }
    }

    public void sendTitle(String title, String subtitle) {
        for (UUID uuid : players) {
            Bukkit.getPlayer(uuid).sendTitle(title, subtitle);
        }
    }

    public void addPlayer(Player player) {
        players.add(player.getUniqueId());
        player.teleport(spawn);

        if (state.equals(GameState.RECRUITING) && players.size() >= ConfigManager.getRequiredPlayers()) {
            countdown.start();
        }
    }

    public void removePlayer(Player player) {
        players.remove(player.getUniqueId());
        player.teleport(ConfigManager.getLobbySpawn());
        player.sendTitle("", "");

        if (state == GameState.COUNTDOWN && players.size() < ConfigManager.getRequiredPlayers()) {
            sendMessage(ChatColor.RED + "There is not enough players. Countdown stopped.");
            reset(true);
            return;
        }
        if (state == GameState.LIVE && players.size() < ConfigManager.getRequiredPlayers()) {
            sendMessage(ChatColor.RED + "The game has ended as too many players have left.");
            reset(true);
        }
    }

    public int getId() { return id; }

    public GameState getState() { return state; }
    public List<UUID> getPlayers() { return players; }
    public Game getGame() { return  game; }

    public void setState(GameState state) {
        this.state = state;
    }
}


package com.misotheism.minigamemechanics.command;

import com.misotheism.minigamemechanics.GameState;
import com.misotheism.minigamemechanics.Minigame;
import com.misotheism.minigamemechanics.instance.Arena;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

public class ArenaCommand implements CommandExecutor {

    private Minigame minigame;

    public ArenaCommand(Minigame minigame) {
        this.minigame = minigame;

    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (sender instanceof Player) {
            Player player = (Player) sender;

            if (args.length == 1 && args[0].equalsIgnoreCase("list")) {
                player.sendMessage(ChatColor.GREEN + "These are the available arenas:");
                for (Arena arena : minigame.getArenaManager().getArenas()) {
                    player.sendMessage(ChatColor.GREEN + "- " + arena.getId() + " (" + arena.getState().name() + ")");
                }
            } else if (args.length == 1 && args[0].equalsIgnoreCase("leave")) {
                Arena arena = minigame.getArenaManager().getArena(player);

                if (arena != null) {
                    player.sendMessage(ChatColor.RED + "You left the arena.");
                    arena.removePlayer(player);
                } else {
                    player.sendMessage(ChatColor.RED + "You are not in an arena.");
                }
            } else if (args.length == 2 && args[0].equalsIgnoreCase("join")) {
                if (minigame.getArenaManager().getArena(player) != null) {
                    player.sendMessage(ChatColor.RED + "You are already playing in an arena.");
                    return false;
                }
                int id;
                try {
                    id = Integer.parseInt(args[1]);
                } catch (NumberFormatException e) {
                    player.sendMessage(ChatColor.RED + "You have specified an invalid arena ID.");
                    return false;
                }

                if (id >= 0 && id < minigame.getArenaManager().getArenas().size()) {
                    Arena arena = minigame.getArenaManager().getArena(id);
                    if (arena.getState() == GameState.RECRUITING || arena.getState() == GameState.COUNTDOWN) {
                        player.sendMessage(ChatColor.GREEN + "You are now playing in Arena-" + id);
                        arena.addPlayer(player);
                    } else {
                        player.sendMessage(ChatColor.RED + "You cannot join this arena right now.");
                    }
                } else {
                    player.sendMessage(ChatColor.RED + "You have specified an invalid arena ID.");
                }

            } else {
                player.sendMessage(ChatColor.RED + "Invalid usage! These are the options:");
                player.sendMessage(ChatColor.RED + "- /arena list");
                player.sendMessage(ChatColor.RED + "- /arena leave");
                player.sendMessage(ChatColor.RED + "- /arena join <id>");
            }
        }
        return false;
    }
}


required-players: 2
countdown-seconds: 15
lobby-spawn:
  world: 'Hub'
  x: 3.5
  y: 133
  z: 3.5WW
  yaw: -180
  pitch: 0
arenas:
  0:
    world: 'Hub'
    x: 443
    y: 83
    z: 458
    yaw: -180
    pitch: 0
  1:
    world: 'Hub'
    x: 386
    y: 84
    z: 520
    yaw: -180
    pitch: 0