mirror of
https://github.com/mcMMO-Dev/mcMMO.git
synced 2024-11-24 06:06:45 +01:00
569 lines
20 KiB
Java
569 lines
20 KiB
Java
package com.gmail.nossr50;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.InputStreamReader;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
|
|
import net.shatteredlands.shatt.backup.ZipLibrary;
|
|
|
|
import org.bukkit.OfflinePlayer;
|
|
import org.bukkit.block.Block;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.plugin.PluginManager;
|
|
import org.bukkit.plugin.java.JavaPlugin;
|
|
import org.bukkit.scheduler.BukkitScheduler;
|
|
import org.mcstats.Metrics;
|
|
import org.mcstats.Metrics.Graph;
|
|
|
|
import com.gmail.nossr50.util.blockmeta.chunkmeta.ChunkManager;
|
|
import com.gmail.nossr50.util.blockmeta.chunkmeta.ChunkManagerFactory;
|
|
import com.gmail.nossr50.commands.CommandRegistrationHelper;
|
|
import com.gmail.nossr50.commands.player.MccCommand;
|
|
import com.gmail.nossr50.config.AdvancedConfig;
|
|
import com.gmail.nossr50.config.Config;
|
|
import com.gmail.nossr50.config.HiddenConfig;
|
|
import com.gmail.nossr50.config.TreasuresConfig;
|
|
import com.gmail.nossr50.database.Database;
|
|
import com.gmail.nossr50.database.Leaderboard;
|
|
import com.gmail.nossr50.database.runnables.UserPurgeTask;
|
|
import com.gmail.nossr50.datatypes.PlayerProfile;
|
|
import com.gmail.nossr50.listeners.BlockListener;
|
|
import com.gmail.nossr50.listeners.EntityListener;
|
|
import com.gmail.nossr50.listeners.HardcoreListener;
|
|
import com.gmail.nossr50.listeners.InventoryListener;
|
|
import com.gmail.nossr50.listeners.PlayerListener;
|
|
import com.gmail.nossr50.listeners.WorldListener;
|
|
import com.gmail.nossr50.locale.LocaleLoader;
|
|
import com.gmail.nossr50.mods.config.CustomArmorConfig;
|
|
import com.gmail.nossr50.mods.config.CustomBlocksConfig;
|
|
import com.gmail.nossr50.mods.config.CustomEntityConfig;
|
|
import com.gmail.nossr50.mods.config.CustomToolsConfig;
|
|
import com.gmail.nossr50.party.PartyManager;
|
|
import com.gmail.nossr50.party.commands.PtpCommand;
|
|
import com.gmail.nossr50.runnables.MobStoreCleaner;
|
|
import com.gmail.nossr50.runnables.SaveTimer;
|
|
import com.gmail.nossr50.skills.repair.RepairManager;
|
|
import com.gmail.nossr50.skills.repair.RepairManagerFactory;
|
|
import com.gmail.nossr50.skills.repair.Repairable;
|
|
import com.gmail.nossr50.skills.repair.config.RepairConfigManager;
|
|
import com.gmail.nossr50.skills.runnables.BleedTimer;
|
|
import com.gmail.nossr50.skills.runnables.PartyAutoKick;
|
|
import com.gmail.nossr50.skills.runnables.SkillMonitor;
|
|
import com.gmail.nossr50.spout.SpoutConfig;
|
|
import com.gmail.nossr50.spout.SpoutTools;
|
|
import com.gmail.nossr50.util.Users;
|
|
|
|
public class mcMMO extends JavaPlugin {
|
|
private final PlayerListener playerListener = new PlayerListener(this);
|
|
private final BlockListener blockListener = new BlockListener(this);
|
|
private final EntityListener entityListener = new EntityListener(this);
|
|
private final InventoryListener inventoryListener = new InventoryListener(this);
|
|
private final WorldListener worldListener = new WorldListener();
|
|
private final HardcoreListener hardcoreListener = new HardcoreListener();
|
|
|
|
private HashMap<Integer, String> tntTracker = new HashMap<Integer, String>();
|
|
private HashMap<Block, String> furnaceTracker = new HashMap<Block, String>();
|
|
|
|
public static mcMMO p;
|
|
|
|
public static ChunkManager placeStore;
|
|
public static RepairManager repairManager;
|
|
|
|
// Jar Stuff
|
|
public static File mcmmo;
|
|
|
|
// File Paths
|
|
private static String mainDirectory;
|
|
private static String flatFileDirectory;
|
|
private static String usersFile;
|
|
private static String modDirectory;
|
|
|
|
// Spout Check
|
|
public static boolean spoutEnabled = false;
|
|
|
|
// XP Event Check
|
|
private boolean xpEventEnabled = false;
|
|
|
|
/**
|
|
* Things to be run when the plugin is enabled.
|
|
*/
|
|
@Override
|
|
public void onEnable() {
|
|
p = this;
|
|
setupFilePaths();
|
|
setupSpout();
|
|
loadConfigFiles();
|
|
|
|
if (!Config.getInstance().getUseMySQL()) {
|
|
Users.loadUsers();
|
|
}
|
|
|
|
registerEvents();
|
|
|
|
// Setup the leader boards
|
|
if (Config.getInstance().getUseMySQL()) {
|
|
// TODO: Why do we have to check for a connection that hasn't be made yet?
|
|
Database.checkConnected();
|
|
Database.createStructure();
|
|
}
|
|
else {
|
|
Leaderboard.updateLeaderboards();
|
|
}
|
|
|
|
for (Player player : getServer().getOnlinePlayers()) {
|
|
Users.addUser(player); // In case of reload add all users back into PlayerProfile
|
|
}
|
|
|
|
getLogger().info("Version " + getDescription().getVersion() + " is enabled!");
|
|
|
|
scheduleTasks();
|
|
registerCommands();
|
|
setupMetrics();
|
|
|
|
placeStore = ChunkManagerFactory.getChunkManager(); // Get our ChunkletManager
|
|
|
|
new MobStoreCleaner(); // Automatically starts and stores itself
|
|
}
|
|
|
|
/**
|
|
* Setup the various storage file paths
|
|
*/
|
|
private void setupFilePaths() {
|
|
mcmmo = getFile();
|
|
mainDirectory = getDataFolder().getPath() + File.separator;
|
|
flatFileDirectory = mainDirectory + "FlatFileStuff" + File.separator;
|
|
usersFile = flatFileDirectory + "mcmmo.users";
|
|
modDirectory = mainDirectory + "ModConfigs" + File.separator;
|
|
}
|
|
|
|
/**
|
|
* Get profile of the player by name.
|
|
* </br>
|
|
* This function is designed for API usage.
|
|
*
|
|
* @param playerName Name of player whose profile to get
|
|
* @return the PlayerProfile object
|
|
*/
|
|
public PlayerProfile getPlayerProfile(String playerName) {
|
|
return Users.getPlayer(playerName).getProfile();
|
|
}
|
|
|
|
/**
|
|
* Get profile of the player.
|
|
* </br>
|
|
* This function is designed for API usage.
|
|
*
|
|
* @param player player whose profile to get
|
|
* @return the PlayerProfile object
|
|
*/
|
|
public PlayerProfile getPlayerProfile(OfflinePlayer player) {
|
|
return Users.getPlayer(player.getName()).getProfile();
|
|
}
|
|
|
|
/**
|
|
* Get profile of the player.
|
|
* </br>
|
|
* This function is designed for API usage.
|
|
*
|
|
* @param player player whose profile to get
|
|
* @return the PlayerProfile object
|
|
*/
|
|
@Deprecated
|
|
public PlayerProfile getPlayerProfile(Player player) {
|
|
return Users.getProfile(player);
|
|
}
|
|
|
|
/**
|
|
* Things to be run when the plugin is disabled.
|
|
*/
|
|
@Override
|
|
public void onDisable() {
|
|
Users.saveAll(); // Make sure to save player information if the server shuts down
|
|
PartyManager.saveParties();
|
|
getServer().getScheduler().cancelTasks(this); // This removes our tasks
|
|
placeStore.saveAll(); // Save our metadata
|
|
placeStore.cleanUp(); // Cleanup empty metadata stores
|
|
|
|
// Remove other tasks BEFORE starting the Backup, or we just cancel it straight away.
|
|
try {
|
|
ZipLibrary.mcMMObackup();
|
|
}
|
|
catch (IOException e) {
|
|
getLogger().severe(e.toString());
|
|
}
|
|
|
|
getLogger().info("Was disabled."); //How informative!
|
|
}
|
|
|
|
private void loadConfigFiles() {
|
|
// Force the loading of config files
|
|
Config configInstance = Config.getInstance();
|
|
TreasuresConfig.getInstance();
|
|
HiddenConfig.getInstance();
|
|
AdvancedConfig.getInstance();
|
|
PartyManager.loadParties();
|
|
|
|
List<Repairable> repairables = new ArrayList<Repairable>();
|
|
|
|
if (configInstance.getToolModsEnabled()) {
|
|
repairables.addAll(CustomToolsConfig.getInstance().getLoadedRepairables());
|
|
}
|
|
|
|
if (configInstance.getArmorModsEnabled()) {
|
|
repairables.addAll(CustomArmorConfig.getInstance().getLoadedRepairables());
|
|
}
|
|
|
|
if (configInstance.getBlockModsEnabled()) {
|
|
CustomBlocksConfig.getInstance();
|
|
}
|
|
|
|
if (configInstance.getEntityModsEnabled()) {
|
|
CustomEntityConfig.getInstance();
|
|
}
|
|
|
|
// Load repair configs, make manager, and register them at this time
|
|
RepairConfigManager rManager = new RepairConfigManager(this);
|
|
repairables.addAll(rManager.getLoadedRepairables());
|
|
repairManager = RepairManagerFactory.getRepairManager(repairables.size());
|
|
repairManager.registerRepairables(repairables);
|
|
|
|
// Check if Repair Anvil and Salvage Anvil have different itemID's
|
|
if (configInstance.getSalvageAnvilId() == configInstance.getRepairAnvilId()) {
|
|
getLogger().warning("Can't use the same itemID for Repair/Salvage Anvils!");
|
|
}
|
|
}
|
|
|
|
private void setupSpout() {
|
|
// Check for Spout
|
|
if (getServer().getPluginManager().isPluginEnabled("Spout")) {
|
|
spoutEnabled = true;
|
|
|
|
SpoutConfig.getInstance();
|
|
SpoutTools.setupSpoutConfigs();
|
|
SpoutTools.registerCustomEvent();
|
|
SpoutTools.preCacheFiles();
|
|
SpoutTools.reloadSpoutPlayers(); // Handle spout players after a /reload
|
|
}
|
|
}
|
|
|
|
private void registerEvents() {
|
|
PluginManager pluginManager = getServer().getPluginManager();
|
|
|
|
// Register events
|
|
pluginManager.registerEvents(playerListener, this);
|
|
pluginManager.registerEvents(blockListener, this);
|
|
pluginManager.registerEvents(entityListener, this);
|
|
pluginManager.registerEvents(inventoryListener, this);
|
|
pluginManager.registerEvents(worldListener, this);
|
|
|
|
if (Config.getInstance().getHardcoreEnabled()) {
|
|
pluginManager.registerEvents(hardcoreListener, this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register the commands.
|
|
*/
|
|
private void registerCommands() {
|
|
CommandRegistrationHelper.registerSkillCommands();
|
|
|
|
// mc* commands
|
|
CommandRegistrationHelper.registerMcpurgeCommand();
|
|
CommandRegistrationHelper.registerMcremoveCommand();
|
|
CommandRegistrationHelper.registerMcabilityCommand();
|
|
getCommand("mcc").setExecutor(new MccCommand());
|
|
CommandRegistrationHelper.registerMcgodCommand();
|
|
CommandRegistrationHelper.registerMcmmoCommand();
|
|
CommandRegistrationHelper.registerMcrefreshCommand();
|
|
CommandRegistrationHelper.registerMctopCommand();
|
|
CommandRegistrationHelper.registerMcrankCommand();
|
|
CommandRegistrationHelper.registerMcstatsCommand();
|
|
|
|
// Party commands
|
|
CommandRegistrationHelper.registerAdminChatCommand();
|
|
CommandRegistrationHelper.registerPartyCommand();
|
|
CommandRegistrationHelper.registerPartyChatCommand();
|
|
getCommand("ptp").setExecutor(new PtpCommand(this));
|
|
|
|
// Other commands
|
|
CommandRegistrationHelper.registerAddxpCommand();
|
|
CommandRegistrationHelper.registerAddlevelsCommand();
|
|
CommandRegistrationHelper.registerMmoeditCommand();
|
|
CommandRegistrationHelper.registerInspectCommand();
|
|
CommandRegistrationHelper.registerXprateCommand();
|
|
CommandRegistrationHelper.registerMmoupdateCommand();
|
|
CommandRegistrationHelper.registerSkillresetCommand();
|
|
|
|
// Spout commands
|
|
CommandRegistrationHelper.registerXplockCommand();
|
|
CommandRegistrationHelper.registerMchudCommand();
|
|
}
|
|
|
|
private void scheduleTasks() {
|
|
BukkitScheduler scheduler = getServer().getScheduler();
|
|
|
|
// Periodic save timer (Saves every 10 minutes by default)
|
|
scheduler.scheduleSyncRepeatingTask(this, new SaveTimer(), 0, Config.getInstance().getSaveInterval() * 1200L);
|
|
// Regen & Cooldown timer (Runs every second)
|
|
scheduler.scheduleSyncRepeatingTask(this, new SkillMonitor(), 0, 20);
|
|
// Bleed timer (Runs every two seconds)
|
|
scheduler.scheduleSyncRepeatingTask(this, new BleedTimer(), 0, 40);
|
|
|
|
// Old & Powerless User remover
|
|
int purgeInterval = Config.getInstance().getPurgeInterval();
|
|
|
|
if (purgeInterval == 0) {
|
|
scheduler.scheduleSyncDelayedTask(this, new UserPurgeTask(), 40); // Start 2 seconds after startup.
|
|
}
|
|
else if (purgeInterval > 0) {
|
|
scheduler.scheduleSyncRepeatingTask(this, new UserPurgeTask(), 0, purgeInterval * 60L * 60L * 20L);
|
|
}
|
|
|
|
// Automatically remove old members from parties
|
|
long kickInterval = Config.getInstance().getAutoPartyKickInterval();
|
|
|
|
if (kickInterval == 0) {
|
|
scheduler.scheduleSyncDelayedTask(this, new PartyAutoKick(), 40); // Start 2 seconds after startup.
|
|
}
|
|
else if (kickInterval > 0) {
|
|
scheduler.scheduleSyncRepeatingTask(this, new PartyAutoKick(), 0, kickInterval * 60L * 60L * 20L);
|
|
}
|
|
}
|
|
|
|
private void setupMetrics() {
|
|
if (Config.getInstance().getStatsTrackingEnabled()) {
|
|
try {
|
|
Metrics metrics = new Metrics(this);
|
|
|
|
// Timings Graph
|
|
Graph timingsGraph = metrics.createGraph("Percentage of servers using timings");
|
|
|
|
if (getServer().getPluginManager().useTimings()) {
|
|
timingsGraph.addPlotter(new Metrics.Plotter("Enabled") {
|
|
@Override
|
|
public int getValue() {
|
|
return 1;
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
timingsGraph.addPlotter(new Metrics.Plotter("Disabled") {
|
|
@Override
|
|
public int getValue() {
|
|
return 1;
|
|
}
|
|
});
|
|
}
|
|
|
|
// Donut Version Graph
|
|
Graph versionDonutGraph = metrics.createGraph("Donut Version");
|
|
|
|
boolean haveVersionInformation = false;
|
|
boolean isOfficialBuild = false;
|
|
String officialKey = "e14cfacdd442a953343ebd8529138680";
|
|
|
|
String version = getDescription().getVersion();
|
|
|
|
InputStreamReader isr = new InputStreamReader(getResource(".jenkins"));
|
|
BufferedReader br = new BufferedReader(isr);
|
|
char[] key = new char[32];
|
|
br.read(key);
|
|
if (officialKey.equals(String.valueOf(key))) {
|
|
isOfficialBuild = true;
|
|
}
|
|
|
|
if (version.contains("-")) {
|
|
String majorVersion = version.substring(0, version.indexOf("-"));
|
|
String subVersion = "";
|
|
if (isOfficialBuild) {
|
|
int startIndex = version.indexOf("-");
|
|
if (version.substring(startIndex + 1).contains("-")) {
|
|
subVersion = version.substring(startIndex, version.indexOf("-", startIndex + 1));
|
|
} else {
|
|
subVersion = "-release";
|
|
}
|
|
} else {
|
|
subVersion = "-custom";
|
|
}
|
|
|
|
version = majorVersion + "~=~" + subVersion;
|
|
haveVersionInformation = true;
|
|
} else {
|
|
haveVersionInformation = false;
|
|
}
|
|
|
|
if (haveVersionInformation) {
|
|
versionDonutGraph.addPlotter(new Metrics.Plotter(version) {
|
|
@Override
|
|
public int getValue() {
|
|
return 1;
|
|
}
|
|
});
|
|
}
|
|
|
|
// Official v Custom build Graph
|
|
Graph officialGraph = metrics.createGraph("Built by official ci");
|
|
|
|
if (isOfficialBuild) {
|
|
officialGraph.addPlotter(new Metrics.Plotter("Yes") {
|
|
@Override
|
|
public int getValue() {
|
|
return 1;
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
officialGraph.addPlotter(new Metrics.Plotter("No") {
|
|
@Override
|
|
public int getValue() {
|
|
return 1;
|
|
}
|
|
});
|
|
}
|
|
|
|
// Chunkmeta enabled Graph
|
|
Graph chunkmetaGraph = metrics.createGraph("Uses Chunkmeta");
|
|
|
|
if (HiddenConfig.getInstance().getChunkletsEnabled()) {
|
|
chunkmetaGraph.addPlotter(new Metrics.Plotter("Yes") {
|
|
@Override
|
|
public int getValue() {
|
|
return 1;
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
chunkmetaGraph.addPlotter(new Metrics.Plotter("No") {
|
|
@Override
|
|
public int getValue() {
|
|
return 1;
|
|
}
|
|
});
|
|
}
|
|
|
|
// Storage method Graph
|
|
Graph storageGraph = metrics.createGraph("Storage method");
|
|
|
|
if (Config.getInstance().getUseMySQL()) {
|
|
storageGraph.addPlotter(new Metrics.Plotter("SQL") {
|
|
@Override
|
|
public int getValue() {
|
|
return 1;
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
storageGraph.addPlotter(new Metrics.Plotter("Flatfile") {
|
|
@Override
|
|
public int getValue() {
|
|
return 1;
|
|
}
|
|
});
|
|
}
|
|
|
|
// Locale Graph
|
|
Graph localeGraph = metrics.createGraph("Locale");
|
|
|
|
localeGraph.addPlotter(new Metrics.Plotter(LocaleLoader.getCurrentLocale().getDisplayLanguage(Locale.US)) {
|
|
@Override
|
|
public int getValue() {
|
|
return 1;
|
|
}
|
|
});
|
|
|
|
metrics.start();
|
|
}
|
|
catch (IOException e) {
|
|
System.out.println("Failed to submit stats.");
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Add a set of values to the TNT tracker.
|
|
*
|
|
* @param tntID The EntityID of the TNT
|
|
* @param playerName The name of the detonating player
|
|
*/
|
|
public void addToTNTTracker(int tntID, String playerName) {
|
|
tntTracker.put(tntID, playerName);
|
|
}
|
|
|
|
/**
|
|
* Check to see if a given TNT Entity is tracked.
|
|
*
|
|
* @param tntID The EntityID of the TNT
|
|
* @return true if the TNT is being tracked, false otherwise
|
|
*/
|
|
public boolean tntIsTracked(int tntID) {
|
|
return tntTracker.containsKey(tntID);
|
|
}
|
|
|
|
/**
|
|
* Get the player who detonated the TNT.
|
|
*
|
|
* @param tntID The EntityID of the TNT
|
|
* @return the Player who detonated it
|
|
*/
|
|
public Player getTNTPlayer(int tntID) {
|
|
return getServer().getPlayer(tntTracker.get(tntID));
|
|
}
|
|
|
|
/**
|
|
* Remove TNT from the tracker after it explodes.
|
|
*
|
|
* @param tntID The EntityID of the TNT
|
|
*/
|
|
public void removeFromTNTTracker(int tntID) {
|
|
tntTracker.remove(tntID);
|
|
}
|
|
|
|
public void addToOpenFurnaceTracker(Block furnace, String playerName) {
|
|
furnaceTracker.put(furnace, playerName);
|
|
}
|
|
|
|
public boolean furnaceIsTracked(Block furnace) {
|
|
return furnaceTracker.containsKey(furnace);
|
|
}
|
|
|
|
public void removeFromFurnaceTracker(Block furnace) {
|
|
furnaceTracker.remove(furnace);
|
|
}
|
|
|
|
public Player getFurnacePlayer(Block furnace) {
|
|
return getServer().getPlayer(furnaceTracker.get(furnace));
|
|
}
|
|
|
|
public static String getMainDirectory() {
|
|
return mainDirectory;
|
|
}
|
|
|
|
public static String getFlatFileDirectory() {
|
|
return flatFileDirectory;
|
|
}
|
|
|
|
public static String getUsersFilePath() {
|
|
return usersFile;
|
|
}
|
|
|
|
public static String getModDirectory() {
|
|
return modDirectory;
|
|
}
|
|
|
|
public boolean isXPEventEnabled() {
|
|
return xpEventEnabled;
|
|
}
|
|
|
|
public void setXPEventEnabled(boolean enabled) {
|
|
this.xpEventEnabled = enabled;
|
|
}
|
|
|
|
public void toggleXpEventEnabled() {
|
|
xpEventEnabled = !xpEventEnabled;
|
|
}
|
|
}
|