uk.codingbadgers.SurvivalPlus.SurvivalPlus.java Source code

Java tutorial

Introduction

Here is the source code for uk.codingbadgers.SurvivalPlus.SurvivalPlus.java

Source

/**
 * SurvivalPlus 1.0
 * Copyright (C) 2014 CodingBadgers <plugins@mcbadgercraft.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package uk.codingbadgers.SurvivalPlus;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import net.milkbowl.vault.chat.Chat;
import net.milkbowl.vault.economy.Economy;
import net.milkbowl.vault.permission.Permission;
import org.apache.commons.lang.Validate;
import org.bukkit.Achievement;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.RegisteredServiceProvider;
import org.bukkit.plugin.java.JavaPlugin;
import ru.tehkode.permissions.PermissionGroup;
import ru.tehkode.permissions.PermissionManager;
import ru.tehkode.permissions.PermissionUser;
import ru.tehkode.permissions.bukkit.PermissionsEx;
import uk.codingbadgers.SurvivalPlus.bungee.BungeeMessenger;
import uk.codingbadgers.SurvivalPlus.bungee.SimpleBungeeMessenger;
import uk.codingbadgers.SurvivalPlus.message.ClickEventType;
import uk.codingbadgers.SurvivalPlus.message.HoverEventType;
import uk.codingbadgers.SurvivalPlus.message.Message;
import uk.codingbadgers.SurvivalPlus.module.Module;
import uk.codingbadgers.SurvivalPlus.module.loader.BukkitModuleLoader;
import uk.codingbadgers.SurvivalPlus.module.loader.ModuleLoader;
import uk.codingbadgers.SurvivalPlus.module.loader.exception.LoadException;
import uk.codingbadgers.SurvivalPlus.player.FundamentalPlayer;
import uk.codingbadgers.SurvivalPlus.player.FundamentalPlayerArray;
import uk.codingbadgers.SurvivalPlus.player.PlayerData;
import uk.codingbadgers.SurvivalPlus.serialization.AchievementSerializer;
import uk.codingbadgers.SurvivalPlus.serialization.ItemStackSerializer;
import uk.thecodingbadgers.bDatabaseManager.Database.BukkitDatabase;
import uk.thecodingbadgers.bDatabaseManager.bDatabaseManager;
import uk.thecodingbadgers.bDatabaseManager.bDatabaseManager.DatabaseType;

public class SurvivalPlus extends JavaPlugin implements Listener {

    protected static Gson m_gson = null;
    protected static Logger m_log = null;
    protected static SurvivalPlus m_instance = null;

    protected static Permission m_permissions = null;
    protected static Chat m_chat = null;
    protected static Economy m_economy = null;

    protected static BukkitDatabase m_database = null;
    protected static ModuleLoader m_moduleLoader = null;
    protected static ConfigManager m_configuration = null;
    protected static BungeeMessenger m_messenger = null;

    public static FundamentalPlayerArray Players = new FundamentalPlayerArray();

    /**
     * Called on loading. This is called before onEnable.
     * Store the instance here, to do it as early as possible.
     */
    @Override
    public void onLoad() {
        setInstance(this);
        setupGson();

        m_log = getLogger();
        log(Level.INFO, "SurvivalPlus Loading");
    }

    /**
     * Called when the plugin is being enabled
     * Load the configuration and all modules
     * Register the command listener
     */
    @Override
    public void onEnable() {

        // load the configuration into the configuration manager
        try {
            setConfigManager(new BukkitConfigurationManager());
            m_configuration.loadConfiguration(new File(getDataFolder(), "config.yml"));
        } catch (IOException e) {
            e.printStackTrace();
        }

        Bukkit.getMessenger().registerOutgoingPluginChannel(SurvivalPlus.getInstance(), "BungeeCord");
        setBungeeMessenger(new SimpleBungeeMessenger());

        // load the modules in
        try {
            m_moduleLoader = new BukkitModuleLoader();

            m_moduleLoader.addModuleDirectory(new File(getDataFolder().getParent(), "SurvivalPlus-Skills"));
            m_moduleLoader.addModuleDirectory(new File(getDataFolder().getParent(), "SurvivalPlus-Modules"));

            m_moduleLoader.load();
        } catch (LoadException ex) {
            m_log.log(Level.WARNING, "Unhandled exception whilst loading modules", ex);
        }

        /*// check if any of the modules need updating
        if (m_configuration.isAutoUpdateEnabled()) {
        m_moduleLoader.update();
        }*/

        // Register this as a listener
        this.getServer().getPluginManager().registerEvents(this, this);

        getCommand("SurvivalPlus").setExecutor(new CommandHandler());

        SurvivalPlus.log(Level.INFO, "SurvivalPlus Loaded.");
    }

    /**
     * Called when the plugin is being disabled
     * Here we disable the module and thus all modules
     */
    @Override
    public void onDisable() {
        SurvivalPlus.log(Level.INFO, "SurvivalPlus Disabled.");
        m_moduleLoader.unload();
        m_database.freeDatabase();

        // Clear instances
        m_instance = null;
        m_configuration = null;
        m_messenger = null;
        m_gson = null;
    }

    public static void setupGson() {

        if (m_gson != null) {
            throw new RuntimeException("Gson already setup, cannot resetup instance");
        }

        m_gson = new GsonBuilder().registerTypeAdapter(Message.class, new Message.MessageSerializer())
                .registerTypeAdapter(ClickEventType.class, new ClickEventType.ClickEventSerializer())
                .registerTypeAdapter(HoverEventType.class, new HoverEventType.HoverEventSerializer())
                .registerTypeAdapter(ItemStack.class, new ItemStackSerializer())
                .registerTypeAdapter(Achievement.class, new AchievementSerializer()).create();
    }

    public static void setInstance(SurvivalPlus plugin) {
        if (m_instance != null) {
            throw new RuntimeException("Plugin instance already set, cannot redeclare");
        }
        m_instance = plugin;
    }

    public static void setConfigManager(ConfigManager manager) {
        if (m_configuration != null) {
            throw new RuntimeException("Configuration manager already set, cannot redeclare");
        }
        m_configuration = manager;
    }

    public static void setBungeeMessenger(BungeeMessenger manager) {
        if (m_messenger != null) {
            throw new RuntimeException("Bungee messenger already set, cannot redeclare");
        }
        m_messenger = manager;
    }

    /**
     * Get the bFundamentals plugin instance.
     *
     * @return the plugin instance
     */
    public static SurvivalPlus getInstance() {
        return m_instance;
    }

    /**
     * Get the configuration manager
     *
     * @return the configuration manager for bFundamentals
     */
    public static ConfigManager getConfigurationManager() {
        return m_configuration;
    }

    /**
     * Get the Bungee messenger
     *
     * @return the bungee messeneger instance
     */
    public static BungeeMessenger getBungeeMessenger() {
        return m_messenger;
    }

    /**
     * Get the bFundamentals gson instance, has custom serializers for bukkit
     * and minecraft classes
     *
     * @return the gson instance
     */
    public static Gson getGsonInstance() {
        return m_gson;
    }

    /**
     * Access to the bukkit database
     *
     * @return the bukkit database for bFundamentals
     */
    public static BukkitDatabase getBukkitDatabase() {
        if (m_database == null) {
            DatabaseSettings settings = m_configuration.getDatabaseSettings();
            m_database = bDatabaseManager.createDatabase(settings.name, m_instance, settings.type);
            if (settings.type == DatabaseType.SQL) {
                m_database.login(settings.host, settings.user, settings.password, settings.port);
            }
        }
        return m_database;
    }

    /**
     * Static access to vaults permission manager
     *
     * @return the vault permission manager
     * @see Permission
     */
    public static Permission getPermissions() {
        if (m_permissions == null) {
            RegisteredServiceProvider<Permission> permissionProvider = m_instance.getServer().getServicesManager()
                    .getRegistration(net.milkbowl.vault.permission.Permission.class);
            if (permissionProvider != null) {
                m_permissions = permissionProvider.getProvider();
            }
        }
        return m_permissions;
    }

    /**
     * Static access to vaults chat manager
     *
     * @return the vault chat manager
     * @see Chat
     */
    public static Chat getChat() {
        if (m_chat == null) {
            RegisteredServiceProvider<Chat> chatProvider = m_instance.getServer().getServicesManager()
                    .getRegistration(net.milkbowl.vault.chat.Chat.class);
            if (chatProvider != null) {
                m_chat = chatProvider.getProvider();
            }
        }
        return m_chat;
    }

    /**
     * Static access to vaults economy manager
     *
     * @return the vault economy manager
     * @see Economy
     */
    public static Economy getEconomy() {
        if (m_economy == null) {
            RegisteredServiceProvider<Economy> economyProvider = m_instance.getServer().getServicesManager()
                    .getRegistration(net.milkbowl.vault.economy.Economy.class);
            if (economyProvider != null) {
                m_economy = economyProvider.getProvider();
            }
        }
        return m_economy;
    }

    /**
     * Gets the module loader
     *
     * @return the module loader for all bFundamentals modules
     */
    public static ModuleLoader getModuleLoader() {
        return m_moduleLoader;
    }

    /**
     * Handle commands in the modules or plugin.
     *
     * @return True if the command was handled, False otherwise
     */
    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {

        if (label.equalsIgnoreCase("modules")) {
            handleModulesCommand(sender);
            return true;
        }

        return false;
    }

    /**
     * Disable a specific module
     *
     * @param module the module to disable
     */
    public void disableModule(Module module) {
        Validate.notNull(module, "Moudule cannot be null");

        m_moduleLoader.unload(module);
    }

    /**
     * Reloads a specific module
     *
     * @param module the module to reload
     */
    public void reloadModule(Module module) {
        Validate.notNull(module, "Moudule cannot be null");

        m_moduleLoader.unload(module);
        m_moduleLoader.load(module.getFile());
        m_moduleLoader.getModule(module.getName()).onEnable();
    }

    /**
     * Static access to log as bFundamentals
     *
     * @param level the log level
     * @param msg   the message to log
     */
    public static void log(Level level, String msg) {
        Validate.notNull(level, "Log level cannot be null");
        Validate.notNull(msg, "Message cannot be null");

        m_log.log(level, msg);
    }

    /**
     * Static access to log as bFundamentals
     *
     * @param level the log level
     * @param msg   the message to log
     * @param e     the exception to log
     */
    public static void log(Level level, String msg, Throwable e) {
        Validate.notNull(level, "Log level cannot be null");
        Validate.notNull(msg, "Message cannot be null");
        Validate.notNull(e, "The exception to log cannot be null");

        m_log.log(level, msg, e);
    }

    private void handleModulesCommand(CommandSender sender) {
        List<Module> modules = m_moduleLoader.getModules();
        String moduleString = ChatColor.GREEN + "Modules(" + modules.size() + "): ";
        boolean first = true;

        for (Module module : modules) {
            moduleString += (first ? "" : ", ") + module.getName();
            first = false;
        }

        sender.sendMessage(moduleString);
    }

    /**
     * Handle a player join event
     *
     * @param event The player join event
     */
    @EventHandler(priority = EventPriority.NORMAL)
    public void onPlayerJoin(PlayerJoinEvent event) {
        FundamentalPlayer newPlayer = new FundamentalPlayer(event.getPlayer());
        SurvivalPlus.Players.add(newPlayer);

        List<Module> modules = m_moduleLoader.getModules();
        for (Module module : modules) {
            Class<? extends PlayerData> playerDataClass = module.getPlayerDataClass();
            if (playerDataClass != null) {
                try {
                    PlayerData data = (PlayerData) playerDataClass.newInstance();
                    newPlayer.addPlayerData(data.getGroup(), data.getName(), data);
                } catch (Exception ex) {
                    SurvivalPlus.log(Level.WARNING, "Failed to create new player data for '"
                            + event.getPlayer().getName() + "' for module '" + module.getName() + "'", ex);
                }
            }
        }
    }

    /**
     * Handle a player join event
     *
     * @param event The player join event
     */
    @EventHandler(priority = EventPriority.NORMAL)
    public void onPlayerQuit(PlayerQuitEvent event) {
        SurvivalPlus.Players.removePlayer(event.getPlayer());
    }

    /**
     * Get a list of online players for a given rank or group
     *
     * @param rank The rank to get the list of online players from
     * @return An array list of online players within a given rank or group
     */
    public ArrayList<Player> getPlayersOfRank(String rank) {

        PermissionManager pexmanager = null;

        try {
            pexmanager = PermissionsEx.getPermissionManager();
        } catch (Exception ex) {
            // If pex does not exist on the server, just return now, we don't want errors
            return null;
        }

        PermissionGroup group = pexmanager.getGroup(rank);

        // If the group doesn't exist just leave.
        if (group == null) {
            return null;
        }

        //
        ArrayList<Player> players = new ArrayList<Player>();
        for (PermissionUser user : group.getUsers()) {
            Player player = Bukkit.getPlayer(user.getName());
            if (player != null) {
                players.add(player);
            }
        }

        return players;
    }

    /**
     * @param time
     * @return
     */
    public static String formatTime(Long time) {

        Long days = TimeUnit.MILLISECONDS.toDays(time);
        time = time - TimeUnit.DAYS.toMillis(days);

        Long hours = TimeUnit.MILLISECONDS.toHours(time);
        time = time - TimeUnit.HOURS.toMillis(hours);

        Long minutes = TimeUnit.MILLISECONDS.toMinutes(time);
        time = time - TimeUnit.MINUTES.toMillis(minutes);

        Long seconds = TimeUnit.MILLISECONDS.toSeconds(time);

        String formattedTime = "";
        if (days != 0) {
            formattedTime += (days == 1 ? "1 Day" : days + " Days");
        }

        if (hours != 0) {
            if (days != 0) {
                formattedTime += ", ";
            }
            formattedTime += (hours == 1 ? "1 Hour" : hours + " Hours");
        }

        if (minutes != 0) {
            if (days != 0 || hours != 0) {
                formattedTime += ", ";
            }
            formattedTime += (minutes == 1 ? "1 Minute" : minutes + " Minutes");
        }

        if (seconds != 0) {
            if (days != 0 || hours != 0 || minutes != 0) {
                formattedTime += ", ";
            }
            formattedTime += (seconds == 1 ? "1 Second" : seconds + " Seconds");
        }

        return formattedTime;
    }

    /**
     * @param minutes
     * @param seconds
     * @return
     */
    public static Long timeToTicks(int minutes, int seconds) {
        return seconds * 20L + (minutes * (20L * 60L));
    }

    /**
     * Find the player a specific instance of player data belongs to
     *
     * @param data THe data to test
     * @return The player the data belongs to or null
     */
    public static FundamentalPlayer getDataOwner(PlayerData data) {

        for (FundamentalPlayer player : SurvivalPlus.Players) {
            if (player.isDataOwner(data)) {
                return player;
            }
        }
        return null;
    }

    /**
     * Get a module of a given class type
     *
     * @param moduleClass The class of the module to find
     * @return The module if found, or null
     */
    public Module getModuleInstance(Class moduleClass) {
        for (Module module : m_moduleLoader.getModules()) {
            if (moduleClass.isInstance(module)) {
                return module;
            }
        }
        return null;
    }

    /**
     * Get all modules of a given class type
     *
     * @param moduleClass The class of the module to find
     * @return The modules if found, or null
     */
    public <T extends PlayerData> List<T> getModuleInstances(Class<? extends T> moduleClass) {
        List<T> modules = new ArrayList<T>();
        for (Module module : m_moduleLoader.getModules()) {
            if (moduleClass.isInstance(module)) {
                modules.add((T) module);
            }
        }
        return modules;
    }

}