AnuraCore/src/de/anura/core/Features.java

package de.anura.core;

import de.anura.core.API.Core;
import de.anura.core.API.Errors;
import de.anura.core.API.Inventories;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.entity.Boat;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.event.player.PlayerToggleFlightEvent;
import org.bukkit.event.vehicle.VehicleDestroyEvent;
import org.bukkit.event.vehicle.VehicleExitEvent;
import org.bukkit.util.Vector;

public class Features implements Listener {
    
    private final Location atwCenter;

    public enum Feature {

        DOUBLE_JUMP(1),
        BOAT(2);

        private Feature(int id) {
            this.featureId = id;
        }
        private final int featureId;
        private static final HashMap<Integer, Feature> BY_ID = new HashMap<>();
        
        public int getId() {
            return featureId;
        }

        public static Feature getById(Integer id) {
            return BY_ID.get(id);
        }

        static {
            for (Feature feature : values()) {
                BY_ID.put(feature.featureId, feature);
            }
        }
    }

    public Features() {
        Bukkit.getPluginManager().registerEvents(this, AnuraCore.getInstance()); 
        atwCenter = new Location(Bukkit.getWorld("lobby"), -297, 31, -1742);
    }

    private final HashMap<Player, ArrayList<Feature>> playerFeatures = new HashMap<>();
    private final HashMap<Player, Boolean> canDoubleJump = new HashMap<>();
    public final HashMap<Player, HashMap<Feature, Boolean>> featureEnabled = new HashMap<>();
    public static ArrayList<UUID> wantFlight = new ArrayList<>();

    public void updateFeatures(Player P) {
        try {
            if (!mainLobby()) {
                return;
            }
            ResultSet rs = Core.getMySql().querySelect("SELECT featureId FROM coreFeatures WHERE playerId = (SELECT id FROM players WHERE uuid = '" + P.getUniqueId().toString() + "')");
            resetPlayerFeatures(P);
            playerFeatures.put(P, new ArrayList<Feature>());
            featureEnabled.put(P, new HashMap<Feature, Boolean>());
            boolean added = false;
            while (rs.next()) {
                if (!added) {
                    P.getInventory().setItem(2, Inventories.getItem("CHARGE", P));
                    added = true;
                }
                if (Feature.getById(rs.getInt("featureId")) != null) {
                    this.addFeature(P, Feature.getById(rs.getInt("featureId")));
                    featureEnabled.get(P).put(Feature.getById(rs.getInt("featureId")), true);
                }
            }
        } catch (Throwable e) {
            Errors.reportException(e);
        }
    }

    public void updateFeaturesAll() {
        if (!mainLobby()) {
            return;
        }
        for (Player P : Bukkit.getOnlinePlayers()) {
            updateFeatures(P);
        }
    }

    public void reset() {
        for (Player P : Bukkit.getOnlinePlayers()) {
            this.resetPlayerFeatures(P);
        }
    }

    public void disableFeature(Player P, Feature f) {
        try {
            if (!mainLobby()) {
                return;
            }
            if (f == Feature.DOUBLE_JUMP) {
                if (!hasFeature(P, f)) {
                    Core.statusMsg(P, "dont_have_dbl_jump", false);
                    return;
                }
                featureEnabled.get(P).put(f, false);
                canDoubleJump.put(P, false);
                Core.statusMsg(P, "dbl_jump_off", true);
                P.setExp(0);
                if (P.getGameMode() != GameMode.CREATIVE) {
                    P.setAllowFlight(false);
                }
            } else if (f == Feature.BOAT) {
                if (!hasFeature(P, f)) {
                    Core.statusMsg(P, "dont_have_boats", false);
                }
                featureEnabled.get(P).put(f, false);
                Core.statusMsg(P, "boat_off", true);
            }
        } catch (Throwable e) {
            Errors.reportException(e);
        }
    }

    public void enableFeature(Player P, Feature f) {
        try {
            if (!mainLobby()) {
                return;
            }
            if (f == Feature.DOUBLE_JUMP) {
                if (!hasFeature(P, f)) {
                    Core.statusMsg(P, "dont_have_dbl_jump", false);
                    return;
                }
                featureEnabled.get(P).put(f, true);
                P.setAllowFlight(true);
                P.setExp(1);
                canDoubleJump.put(P, true);
                Core.statusMsg(P, "dbl_jump_on", true);
            } else if (f == Feature.BOAT) {
                if (!hasFeature(P, f)) {
                    Core.statusMsg(P, "dont_have_boats", false);
                }
                featureEnabled.get(P).put(f, true);
                Core.statusMsg(P, "boat_on", true);
            }
        } catch (Throwable e) {
            Errors.reportException(e);
        }
    }

    public boolean hasFeature(Player P, Feature f) {
        if (!mainLobby()) {
            return false;
        }
        if (playerFeatures.containsKey(P)) {
            return playerFeatures.get(P).contains(f);
        }
        return false;
    }

    private void resetPlayerFeatures(Player P) {
        if (!playerFeatures.containsKey(P)) {
            return;
        }
        for (Feature f : (ArrayList<Feature>) playerFeatures.get(P).clone()) {
            removeFeature(P, f);
        }
    }

    public void removeFeature(Player P, Feature f) {
        if (!mainLobby()) {
            return;
        }
        if (playerFeatures.containsKey(P)) {
            playerFeatures.get(P).remove(f);
        }
        if (f.equals(Feature.DOUBLE_JUMP)) {
            if (!P.getGameMode().equals(GameMode.CREATIVE)) {
                P.setAllowFlight(false);
                P.setExp(0);
            }
            this.canDoubleJump.put(P, false);
        }
    }

    public void addFeature(Player P, Feature f) {
        if (!mainLobby()) {
            return;
        }
        if (playerFeatures.containsKey(P) && !hasFeature(P, f)) {
            playerFeatures.get(P).add(f);
        }
        if (f.equals(Feature.DOUBLE_JUMP)) {
            P.setAllowFlight(true);
            P.setExp(1);
            this.canDoubleJump.put(P, true);
        }
    }

    private boolean mainLobby() {
        return AnuraCore.getInstance().getConfig().getBoolean("is-main-lobby");
    }

    @EventHandler
    public void onPlayerMove(PlayerMoveEvent event) {
        try {
            if (!mainLobby()) {
                return;
            }
            Player P = event.getPlayer();
            if (this.hasFeature(P, Feature.DOUBLE_JUMP)) {
                if (this.canDoubleJump.containsKey(P) && !this.canDoubleJump.get(P) && ((Entity) P).isOnGround() && this.featureEnabled.get(P).get(Feature.DOUBLE_JUMP)) {
                    this.canDoubleJump.put(P, true);
                    P.setExp(1);
                }
            }

            if (this.hasFeature(P, Feature.BOAT) && featureEnabled.get(P).get(Feature.BOAT)) {
                if (P.getLocation().getBlock().getType().equals(Material.STATIONARY_WATER) && P.getVehicle() == null) {
                    if (P.getWorld().equals(atwCenter.getWorld()) && P.getLocation().distance(atwCenter) < 30) return;
                    Boat b = (Boat) P.getWorld().spawnEntity(event.getTo(), EntityType.BOAT);
                    b.setPassenger(P);
                }
            }
        } catch (Throwable e) {
            Errors.reportException(e);
        }
    }

    @EventHandler
    public void onToggleFlight(PlayerToggleFlightEvent event) {
        try {
            if (!mainLobby()) {
                return;
            }
            Player P = event.getPlayer();

            if (this.hasFeature(P, Feature.DOUBLE_JUMP) && !P.getGameMode().equals(GameMode.CREATIVE)) {
                if (this.canDoubleJump.containsKey(P) && this.canDoubleJump.get(P)) {
                    this.canDoubleJump.put(P, false);
                    P.setExp(0);
                    Vector v = P.getLocation().getDirection();
                    P.setVelocity(v.multiply(new Vector(1, 2, 1)));
                    P.setVelocity(P.getVelocity().setY(1));
                } else {
                    Vector v = P.getVelocity();
                    P.setVelocity(v.setY(-0.4));
                }
                event.setCancelled(true);
            }
        } catch (Throwable e) {
            Errors.reportException(e);
        }
    }

    @EventHandler
    public void onBoatDestory(VehicleDestroyEvent event) {
        try {
            if (event.getVehicle().getType().equals(EntityType.BOAT) && AnuraCore.getInstance().getConfig().getBoolean("is-main-lobby")) {
                event.setCancelled(true);
            }
        } catch (Throwable e) {
            Errors.reportException(e);
        }
    }

    @EventHandler
    public void onExit(VehicleExitEvent event) {
        try {
            if (event.getVehicle().getType().equals(EntityType.BOAT) && AnuraCore.getInstance().getConfig().getBoolean("is-main-lobby")) {
                event.getVehicle().remove();
                Player p = (Player) event.getExited();
                p.setVelocity(p.getVelocity().add(new Vector(0D, 1D, 0D)));
                if (p.getGameMode().equals(GameMode.CREATIVE) && wantFlight.contains(p.getUniqueId())) {
                    p.setFlying(true);
                }
            }
        } catch (Throwable e) {
            Errors.reportException(e);
        }
    }
}