FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightTeam.java

/* 
    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 <https://www.gnu.org/licenses/>.
*/

package de.steamwar.fightsystem.fight;

import com.sk89q.worldedit.extent.clipboard.Clipboard;
import de.steamwar.fightsystem.ArenaMode;
import de.steamwar.fightsystem.Config;
import de.steamwar.fightsystem.FightSystem;
import de.steamwar.fightsystem.countdown.Countdown;
import de.steamwar.fightsystem.listener.FightScoreboard;
import de.steamwar.fightsystem.listener.PersonalKitCreator;
import de.steamwar.fightsystem.record.GlobalRecorder;
import de.steamwar.fightsystem.states.FightState;
import de.steamwar.fightsystem.states.OneShotStateDependent;
import de.steamwar.fightsystem.states.StateDependent;
import de.steamwar.fightsystem.utils.*;
import de.steamwar.inventory.SWItem;
import de.steamwar.sql.SchematicNode;
import de.steamwar.sql.SteamwarUser;
import net.md_5.bungee.api.ChatMessageType;
import org.bukkit.*;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.scoreboard.NameTagVisibility;
import org.bukkit.scoreboard.Team;

import java.util.*;


public class FightTeam {

    private UUID designatedLeader;
    private FightPlayer leader;
    private int schemRank;

    private final Map<Player, FightPlayer> players = new HashMap<>();
    private final Set<Player> invited = new HashSet<>();

    private String name;
    private String prefix;
    private ChatColor color;
    private final FightSchematic schematic;
    private final Team team;
    private final boolean blue;

    private boolean ready;
    private boolean skip;

    private final Location spawn;
    private final Region schemRegion;
    private final Region extendRegion;

    @SuppressWarnings("deprecation")
    public FightTeam(String name, String prefix, Location spawn, Region schemRegion, Region extendRegion, boolean rotate, boolean blue, UUID designatedLeader) {
        this.spawn = spawn;
        this.schemRegion = schemRegion;
        this.extendRegion = extendRegion;
        this.schemRank = 0;
        this.ready = false;
        this.skip = false;
        this.blue = blue;
        this.designatedLeader = designatedLeader;
        setPrefixAndName(prefix, name);
        this.schematic = new FightSchematic(this, rotate);
        new KitLoader();
        new SpectateHandler();

        if(FightScoreboard.getBukkit().getTeam(name) == null)
            team = FightScoreboard.getBukkit().registerNewTeam(name);
        else
            team = FightScoreboard.getBukkit().getTeam(name);
        assert team != null;
        WorldOfColorWrapper.impl.setTeamColor(team, color);
        BountifulWrapper.impl.setNametagVisibility(team);
        team.setNameTagVisibility(NameTagVisibility.HIDE_FOR_OTHER_TEAMS);
        team.setAllowFriendlyFire(false);

        new OneShotStateDependent(ArenaMode.Restartable, FightState.PreLeaderSetup, () -> Bukkit.getScheduler().runTask(FightSystem.getPlugin(), this::reset));
        new OneShotStateDependent(Config.replayserver(), FightState.PreLeaderSetup, () -> Bukkit.getScheduler().runTask(FightSystem.getPlugin(), this::reset));
    }

    public void setPrefixAndName(String prefix, String name){
        this.name = name;
        this.prefix = prefix;
        this.color = ChatColor.getByChar(ChatColor.getLastColors(prefix).replace("§", ""));
    }

    public UUID getDesignatedLeader(){
        return designatedLeader;
    }

    public Region getSchemRegion() {
        return schemRegion;
    }

    public Region getExtendRegion() {
        return extendRegion;
    }

    public boolean canbeLeader(Player p){
        return isLeaderless() && (designatedLeader == null || designatedLeader.equals(p.getUniqueId()));
    }

    public int getSchemRank() {
        return schemRank;
    }

    public void teleportToSpawn(){
        players.forEach((player, fp) -> player.teleport(spawn));
    }

    public FightPlayer getFightPlayer(Player player) {
        return players.get(player);
    }

    public boolean allPlayersOut() {
        for(FightPlayer fightPlayer : players.values()) {
            if(fightPlayer.isLiving())
                return false;
        }
        return true;
    }

    public boolean isPlayerInTeam(Player player) {
        return players.containsKey(player);
    }

    public boolean canPlayerEntern(Player player) {
        return getFightPlayer(player).canEntern();
    }

    public boolean isPlayerLeader(Player player) {
        if(leader != null)
            return leader.getPlayer().equals(player);
        else
            return false;
    }

    public void reset() {
        skip = false;
        ready = false;
        schematic.reset();
        invited.clear();

        Set<Player> playerSet = new HashSet<>(players.keySet());
        for(Player player : playerSet){
            if(!Bukkit.getOnlinePlayers().contains(player))
                removePlayer(player);
        }
        FightPlayer leaderBackup = leader;
        playerSet.removeIf(player -> !Bukkit.getOnlinePlayers().contains(player));
        players.clear();
        leader = null;

        if(leaderBackup != null){
            playerSet.remove(leaderBackup.getPlayer());
            addMember(leaderBackup.getPlayer(), true);
        }

        playerSet.forEach(p -> addMember(p, true));

        if(ArenaMode.VariableTeams.contains(Config.mode) && isLeaderless()){
            for(Player player : Bukkit.getOnlinePlayers()){
                if(Fight.getPlayerTeam(player) == null && canbeLeader(player)){
                    addMember(player);
                    break;
                }
            }
        }
    }

    public void broadcast(String message, Object... params) {
        players.forEach((player, fp) -> FightSystem.getMessage().sendPrefixless(message, player, ChatMessageType.ACTION_BAR, params));
    }

    public void broadcastSystem(String message, Object... params) {
        players.forEach((player, fp) -> FightSystem.getMessage().send(message, player, params));
    }

    public void broadcastChat(Player sender, String message) {
        players.forEach((player, fp) -> FightSystem.getMessage().sendPrefixless("TEAM_CHAT", player, ChatMessageType.CHAT, prefix, sender.getName(), message));
    }

    public void addMember(Player player) {
        addMember(player, false);
    }

    public void addMember(Player player, boolean silent) {
        final List<TechHider.ChunkPos> chunksToReload = TechHider.prepareChunkReload(player, false);
        FightPlayer fightPlayer = new FightPlayer(player, this);
        players.put(player, fightPlayer);
        invited.remove(player);
        team.addEntry(player.getName());

        Fight.setPlayerGamemode(player, GameMode.SURVIVAL);
        player.setHealth(20);
        player.setFoodLevel(20);
        player.getInventory().clear();
        BountifulWrapper.impl.setAttackSpeed(player);
        player.teleport(spawn);
        if(Kit.getAvailableKits(false).size() > 1 || Config.PersonalKits)
            player.getInventory().setItem(1, new ItemBuilder(Material.LEATHER_CHESTPLATE).removeAllAttributs().addEnchantment(Enchantment.DURABILITY, 1).setDisplayName(FightSystem.getMessage().parse("CHOOSE_KIT", player)).build());
        player.getInventory().setItem(7, new ItemBuilder(Material.BEACON).removeAllAttributs().setDisplayName(FightSystem.getMessage().parse("RESPAWN", player)).build());
        GlobalRecorder.getInstance().playerJoins(player);
        TechHider.reloadChunks(player, chunksToReload, false);

        if(isLeaderless())
            setLeader(fightPlayer, silent);
        else if(!silent)
            FightUI.addSubtitle("UI_PLAYER_JOINS", prefix, player.getName());
    }

    public void removePlayer(Player player) {
        FightPlayer fightPlayer = getFightPlayer(player);

        PersonalKitCreator.closeIfInKitCreator(player);
        List<TechHider.ChunkPos> chunksToReload = TechHider.prepareChunkReload(player, true);
        players.remove(player);
        team.removeEntry(player.getName());

        FightUI.addSubtitle("UI_PLAYER_LEAVES", prefix, player.getName());

        if(fightPlayer.equals(leader))
            removeLeader();

        GlobalRecorder.getInstance().entityDespawns(player);
        Fight.setPlayerGamemode(player, GameMode.SPECTATOR);
        player.teleport(Config.SpecSpawn);
        player.getInventory().clear();

        if(player.isOnline()){
            TechHider.reloadChunks(player, chunksToReload, true);
        }
    }

    public boolean isLeaderless() {
        return leader == null;
    }

    public boolean isBlue(){
        return blue;
    }

    public FightPlayer getLeader() {
        return leader;
    }

    private void removeLeader() {
        this.leader = null;
        if(!players.isEmpty()) {
            setLeader(players.values().iterator().next(), false);
        }else if(FightState.getFightState() != FightState.PRE_LEADER_SETUP && !ArenaMode.RankedEvent.contains(Config.mode)){
            Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), FightSystem::setPreLeaderState, 1);
        }
    }

    private void setLeader(FightPlayer leader, boolean silent) {
        PersonalKitCreator.closeIfInKitCreator(leader.getPlayer());

        this.leader = leader;
        designatedLeader = null;
        if(ready)
            setReady(false);

        if(!silent)
            FightUI.addSubtitle("UI_LEADER_JOINS", prefix, leader.getPlayer().getName());

        Optional<Integer> maxRank = SchematicNode.getAllAccessibleSchematicsOfType(SteamwarUser.get(leader.getPlayer().getUniqueId()).getId(), Config.SchematicType.toDB()).stream().map(SchematicNode::getRank).max(Integer::compare);
        if(Config.RanksEnabled)
            schemRank = maxRank.orElse(1);
        else
            schemRank = maxRank.isPresent() ? 1 : 0;

        if(!Config.PersonalKits)
            leader.setKit(Kit.getKitByName(Config.LeaderDefault));

        Player player = leader.getPlayer();
        Inventory inventory = leader.getPlayer().getInventory();
        if (Kit.getAvailableKits(true).size() > 1 || Config.PersonalKits)
            inventory.setItem(1, new ItemBuilder(Material.LEATHER_CHESTPLATE).removeAllAttributs().addEnchantment(Enchantment.DURABILITY, 1).setDisplayName(FightSystem.getMessage().parse("CHOOSE_KIT", player)).build());
        else
            inventory.setItem(1, new ItemBuilder(Material.AIR).build());

        if(!ArenaMode.RankedEvent.contains(Config.mode)){
            inventory.setItem(2, new ItemBuilder(Material.PAPER).removeAllAttributs().setDisplayName(FightSystem.getMessage().parse("INVITE_PLAYERS", player)).build());
            inventory.setItem(3, new ItemBuilder(SWItem.getMaterial("FIREWORK_CHARGE")).removeAllAttributs().setDisplayName(FightSystem.getMessage().parse("REMOVE_PLAYERS", player)).build());
        }

        inventory.setItem(4, new ItemBuilder(SWItem.getDye(10), (short) 10).removeAllAttributs().addEnchantment(Enchantment.DURABILITY, 1).setDisplayName(FightSystem.getMessage().parse("TEAM_NOT_READY", player)).build());

        if(Config.test() || FightState.getFightState() != FightState.POST_SCHEM_SETUP)
            inventory.setItem(0, new ItemBuilder(SWItem.getMaterial("CAULDRON_ITEM")).removeAllAttributs().addEnchantment(Enchantment.DURABILITY, 1).setDisplayName(FightSystem.getMessage().parse("CHOOSE_SCHEMATIC", player, Config.GameName)).build());

        if(FightState.getFightState() == FightState.PRE_LEADER_SETUP && !Fight.getOpposite(this).isLeaderless()){
            FightSystem.setPreSchemState();
        }
    }

    public Collection<FightPlayer> getPlayers() {
        return players.values();
    }

    public boolean isReady() {
        return ready;
    }

    public void pasteSchem() {
        testPasteAction();
    }

    public void pasteSchem(SchematicNode schematic){
        setSchem(schematic);
        testPasteAction();
    }

    public void pasteSchem(int schemId, Clipboard clipboard){
        this.schematic.setSchematic(schemId, clipboard);
        testPasteAction();
    }

    private void testPasteAction(){
        if(Config.test())
            this.schematic.enable();
        else if(Fight.getOpposite(this).schematic.hasSchematic()){
            FightSystem.setPostSchemState();
        }
    }

    public void pasteTeamName(){
        schematic.pasteTeamName();
    }

    public void setSchem(SchematicNode schematic){
        this.schematic.setSchematic(schematic);
        broadcast("SCHEMATIC_CHOSEN", Config.GameName, schematic.getName());
    }

    public void setReady(boolean ready) {
        Player l = leader.getPlayer();

        if(!schematic.hasSchematic()){
            FightSystem.getMessage().sendPrefixless("SCHEMATIC_REQUIRED", l, ChatMessageType.ACTION_BAR);
            return;
        }

        this.ready = ready;
        if(ready) {
            l.getInventory().setItem(4, new ItemBuilder(SWItem.getDye(8), (short) 8).removeAllAttributs().addEnchantment(Enchantment.DURABILITY,1 ).setDisplayName(FightSystem.getMessage().parse("TEAM_READY", l)).build());
            broadcast("TEAM_READY");
            if(Fight.getOpposite(this).isReady() || ArenaMode.SoloLeader.contains(Config.mode))
                FightSystem.setPreRunningState();
        } else {
            l.getInventory().setItem(4, new ItemBuilder(SWItem.getDye(10), (short) 10).removeAllAttributs().addEnchantment(Enchantment.DURABILITY, 1).setDisplayName(FightSystem.getMessage().parse("TEAM_NOT_READY", l)).build());
            broadcast("TEAM_NOT_READY");
        }
    }

    public void skip(){
        this.skip = !skip;
        if(skip){
            broadcast("SKIP_READY");
            if(Fight.getOpposite(this).skip || Config.test()){
                skip = false;
                Fight.getOpposite(this).skip = false;
                Countdown.skip();
            }
        }else{
            broadcast("SKIP_NOT_READY");
        }
    }

    public Set<Player> getInvited() {
        return invited;
    }

    public String getName() {
        return name;
    }

    public String getColoredName() {
        return prefix + name;
    }

    public String getPrefix() {
        return prefix;
    }

    public int getSchematic() {
        return schematic.getId();
    }

    public Location getSpawn() {
        return spawn;
    }

    public double getCurrentHearts() {
        return players.values().stream().filter(FightPlayer::isLiving).mapToDouble(fp -> fp.getPlayer().getHealth()).sum();
    }

    public double getHeartRatio(){
        int maximumHearts = players.size() * 20;
        return maximumHearts != 0 ? getCurrentHearts() / maximumHearts : 0;
    }

    public int getPlayerCount() {
        return players.size();
    }

    public int getAlivePlayers() {
        return (int) players.values().stream().filter(FightPlayer::isLiving).count();
    }

    public ChatColor getColor() {
        return color;
    }

    @Override
    public String toString() {
        return name;
    }

    private class KitLoader extends StateDependent {
        private KitLoader() {
            super(ArenaMode.AntiReplay, FightState.Ingame);
            register();
        }

        @Override
        public void enable() {
            for(FightPlayer fightPlayer : players.values()) {
                Player player = fightPlayer.getPlayer();
                PersonalKitCreator.closeIfInKitCreator(player);

                player.closeInventory();
                player.getInventory().clear();
                Fight.setPlayerGamemode(player, GameMode.SURVIVAL);
                fightPlayer.getKit().loadToPlayer(player);
            }
        }

        @Override
        public void disable() {
            players.values().forEach(fightPlayer -> fightPlayer.getPlayer().getInventory().clear());
        }
    }

    private class SpectateHandler extends StateDependent {
        private SpectateHandler() {
            super(ArenaMode.AntiReplay, FightState.Spectate);
            register();
        }

        @Override
        public void enable() {
            players.values().forEach(fightPlayer -> {
                Fight.setPlayerGamemode(fightPlayer.getPlayer(), GameMode.SPECTATOR);
                fightPlayer.getPlayer().teleport(FightTeam.this.spawn);
            });
        }

        @Override
        public void disable() {
            players.values().forEach(fightPlayer -> Fight.setPlayerGamemode(fightPlayer.getPlayer(), GameMode.SURVIVAL));
        }
    }
}