mirror of
https://github.com/Zrips/Jobs.git
synced 2025-01-09 09:48:21 +01:00
1519 lines
46 KiB
Java
1519 lines
46 KiB
Java
/**
|
|
* Jobs Plugin for Bukkit
|
|
* Copyright (C) 2011 Zak Ford <zak.j.ford@gmail.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 com.gamingmesh.jobs;
|
|
|
|
import java.io.File;
|
|
import java.sql.SQLException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Optional;
|
|
import java.util.UUID;
|
|
import java.util.WeakHashMap;
|
|
import java.util.logging.Logger;
|
|
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.block.Block;
|
|
import org.bukkit.command.CommandSender;
|
|
import org.bukkit.entity.Entity;
|
|
import org.bukkit.entity.LivingEntity;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.event.HandlerList;
|
|
import org.bukkit.plugin.java.JavaPlugin;
|
|
|
|
import com.gamingmesh.jobs.Gui.GuiManager;
|
|
import com.gamingmesh.jobs.Placeholders.Placeholder;
|
|
import com.gamingmesh.jobs.Placeholders.PlaceholderAPIHook;
|
|
import com.gamingmesh.jobs.Signs.SignUtil;
|
|
import com.gamingmesh.jobs.api.JobsExpGainEvent;
|
|
import com.gamingmesh.jobs.api.JobsPrePaymentEvent;
|
|
import com.gamingmesh.jobs.commands.JobsCommands;
|
|
import com.gamingmesh.jobs.config.BlockProtectionManager;
|
|
import com.gamingmesh.jobs.config.BossBarManager;
|
|
import com.gamingmesh.jobs.config.ConfigManager;
|
|
import com.gamingmesh.jobs.config.ExploreManager;
|
|
import com.gamingmesh.jobs.config.GeneralConfigManager;
|
|
import com.gamingmesh.jobs.config.LanguageManager;
|
|
import com.gamingmesh.jobs.config.NameTranslatorManager;
|
|
import com.gamingmesh.jobs.config.RestrictedAreaManager;
|
|
import com.gamingmesh.jobs.config.RestrictedBlockManager;
|
|
import com.gamingmesh.jobs.config.ScheduleManager;
|
|
import com.gamingmesh.jobs.config.ShopManager;
|
|
import com.gamingmesh.jobs.config.TitleManager;
|
|
import com.gamingmesh.jobs.config.YmlMaker;
|
|
import com.gamingmesh.jobs.container.ActionInfo;
|
|
import com.gamingmesh.jobs.container.ActionType;
|
|
import com.gamingmesh.jobs.container.ArchivedJobs;
|
|
import com.gamingmesh.jobs.container.BlockProtection;
|
|
import com.gamingmesh.jobs.container.Boost;
|
|
import com.gamingmesh.jobs.container.Convert;
|
|
import com.gamingmesh.jobs.container.CurrencyLimit;
|
|
import com.gamingmesh.jobs.container.CurrencyType;
|
|
import com.gamingmesh.jobs.container.DBAction;
|
|
import com.gamingmesh.jobs.container.FastPayment;
|
|
import com.gamingmesh.jobs.container.Job;
|
|
import com.gamingmesh.jobs.container.JobInfo;
|
|
import com.gamingmesh.jobs.container.JobProgression;
|
|
import com.gamingmesh.jobs.container.JobsPlayer;
|
|
import com.gamingmesh.jobs.container.JobsWorld;
|
|
import com.gamingmesh.jobs.container.LoadStatus;
|
|
import com.gamingmesh.jobs.container.Log;
|
|
import com.gamingmesh.jobs.container.PlayerInfo;
|
|
import com.gamingmesh.jobs.container.PlayerPoints;
|
|
import com.gamingmesh.jobs.container.Quest;
|
|
import com.gamingmesh.jobs.container.QuestProgression;
|
|
import com.gamingmesh.jobs.container.blockOwnerShip.BlockOwnerShip;
|
|
import com.gamingmesh.jobs.container.blockOwnerShip.BlockTypes;
|
|
import com.gamingmesh.jobs.dao.JobsClassLoader;
|
|
import com.gamingmesh.jobs.dao.JobsDAO;
|
|
import com.gamingmesh.jobs.dao.JobsDAOData;
|
|
import com.gamingmesh.jobs.dao.JobsManager;
|
|
import com.gamingmesh.jobs.economy.BufferedEconomy;
|
|
import com.gamingmesh.jobs.economy.BufferedPayment;
|
|
import com.gamingmesh.jobs.economy.Economy;
|
|
import com.gamingmesh.jobs.economy.PaymentData;
|
|
import com.gamingmesh.jobs.hooks.HookManager;
|
|
import com.gamingmesh.jobs.i18n.Language;
|
|
import com.gamingmesh.jobs.listeners.JobsListener;
|
|
import com.gamingmesh.jobs.listeners.JobsPayment14Listener;
|
|
import com.gamingmesh.jobs.listeners.JobsPaymentListener;
|
|
import com.gamingmesh.jobs.listeners.PistonProtectionListener;
|
|
import com.gamingmesh.jobs.selection.SelectionManager;
|
|
import com.gamingmesh.jobs.stuff.Loging;
|
|
import com.gamingmesh.jobs.stuff.TabComplete;
|
|
import com.gamingmesh.jobs.stuff.ToggleBarHandling;
|
|
import com.gamingmesh.jobs.stuff.Util;
|
|
import com.gamingmesh.jobs.stuff.VersionChecker;
|
|
import com.gamingmesh.jobs.stuff.complement.Complement;
|
|
import com.gamingmesh.jobs.stuff.complement.Complement1;
|
|
import com.gamingmesh.jobs.stuff.complement.Complement2;
|
|
import com.gamingmesh.jobs.stuff.complement.JobsChatEvent;
|
|
import com.gamingmesh.jobs.tasks.BufferedPaymentThread;
|
|
import com.gamingmesh.jobs.tasks.DatabaseSaveThread;
|
|
|
|
import net.Zrips.CMILib.ActionBar.CMIActionBar;
|
|
import net.Zrips.CMILib.Colors.CMIChatColor;
|
|
import net.Zrips.CMILib.Container.PageInfo;
|
|
import net.Zrips.CMILib.Items.CMIMaterial;
|
|
import net.Zrips.CMILib.Locale.LC;
|
|
import net.Zrips.CMILib.Logs.CMIDebug;
|
|
import net.Zrips.CMILib.Messages.CMIMessages;
|
|
import net.Zrips.CMILib.RawMessages.RawMessage;
|
|
import net.Zrips.CMILib.Version.Version;
|
|
|
|
public final class Jobs extends JavaPlugin {
|
|
|
|
private static PlayerManager pManager;
|
|
private static JobsCommands cManager;
|
|
private static Language lManager;
|
|
private static LanguageManager lmManager;
|
|
private static SignUtil signManager;
|
|
private static ScheduleManager scheduleManager;
|
|
private static NameTranslatorManager nameTranslatorManager;
|
|
private static ExploreManager exploreManager;
|
|
private static TitleManager titleManager;
|
|
private static RestrictedBlockManager rbManager;
|
|
private static RestrictedAreaManager raManager;
|
|
private static BossBarManager bbManager;
|
|
private static ShopManager shopManager;
|
|
private static Loging loging;
|
|
private static BlockProtectionManager bpManager;
|
|
private static JobsManager dbManager;
|
|
private static ConfigManager configManager;
|
|
private static GeneralConfigManager gConfigManager;
|
|
|
|
private static BufferedEconomy economy;
|
|
private static PermissionHandler permissionHandler;
|
|
private static PermissionManager permissionManager;
|
|
|
|
private static JobsClassLoader classLoader;
|
|
|
|
private final HashMap<CMIMaterial, BlockOwnerShip> blockOwnerShipsMaterial = new HashMap<>();
|
|
private final HashMap<BlockTypes, BlockOwnerShip> blockOwnerShipsBlockType = new HashMap<>();
|
|
|
|
private boolean kyoriSupported = false;
|
|
|
|
private Complement complement;
|
|
private GuiManager guiManager;
|
|
|
|
private static JobsDAO dao;
|
|
private static List<Job> jobs;
|
|
private static Job noneJob;
|
|
private static Map<Job, Integer> usedSlots = new WeakHashMap<>();
|
|
|
|
public static BufferedPaymentThread paymentThread;
|
|
private static DatabaseSaveThread saveTask;
|
|
|
|
public static LoadStatus status = LoadStatus.Good;
|
|
|
|
private static boolean hasLimitedItems = false;
|
|
|
|
private static final int MAX_ENTRIES = 5;
|
|
public static final LinkedHashMap<UUID, FastPayment> FASTPAYMENT = new LinkedHashMap<UUID, FastPayment>(MAX_ENTRIES + 1, .75F, false) {
|
|
protected boolean removeEldestEntry(Map.Entry<UUID, FastPayment> eldest) {
|
|
return size() > MAX_ENTRIES;
|
|
}
|
|
};
|
|
|
|
protected static VersionChecker versionCheckManager;
|
|
protected static SelectionManager smanager;
|
|
|
|
public Complement getComplement() {
|
|
return complement;
|
|
}
|
|
|
|
public boolean isKyoriSupported() {
|
|
return kyoriSupported;
|
|
}
|
|
|
|
public static JobsClassLoader getJobsClassloader() {
|
|
if (classLoader == null)
|
|
classLoader = new JobsClassLoader(Jobs.getInstance());
|
|
return classLoader;
|
|
}
|
|
|
|
/**
|
|
* Returns the block owner ship for specific {@link CMIMaterial} type.
|
|
*
|
|
* @param type {@link CMIMaterial}
|
|
* @see #getBlockOwnerShip(CMIMaterial, boolean)
|
|
* @return {@link BlockOwnerShip}, otherwise {@link Optional#empty()}
|
|
*/
|
|
public Optional<BlockOwnerShip> getBlockOwnerShip(CMIMaterial type) {
|
|
return getBlockOwnerShip(type, true);
|
|
}
|
|
|
|
/**
|
|
* Returns the block owner ship for specific {@link CMIMaterial} type.
|
|
* If the addNew parameter is enabled, it will cache a new owner ship for specific
|
|
* {@link CMIMaterial} type.
|
|
*
|
|
* @param type {@link CMIMaterial}
|
|
* @param addNew whenever to add a new owner ship
|
|
* @return {@link BlockOwnerShip}, otherwise {@link Optional#empty()}
|
|
*/
|
|
public Optional<BlockOwnerShip> getBlockOwnerShip(CMIMaterial type, boolean addNew) {
|
|
BlockOwnerShip b = blockOwnerShipsMaterial.get(type);
|
|
|
|
if (addNew && b == null) {
|
|
b = new BlockOwnerShip(type);
|
|
blockOwnerShipsMaterial.put(type, b);
|
|
blockOwnerShipsBlockType.put(b.getType(), b);
|
|
}
|
|
|
|
return Optional.ofNullable(b);
|
|
}
|
|
|
|
/**
|
|
* Returns the block owner ship for specific {@link BlockTypes} type.
|
|
*
|
|
* @param type {@link BlockTypes}
|
|
* @return {@link BlockOwnerShip}, otherwise {@link Optional#empty()}
|
|
*/
|
|
public Optional<BlockOwnerShip> getBlockOwnerShip(BlockTypes type) {
|
|
BlockOwnerShip b = blockOwnerShipsBlockType.get(type);
|
|
if (b != null)
|
|
return Optional.ofNullable(b);
|
|
|
|
return Optional.empty();
|
|
}
|
|
|
|
public void removeBlockOwnerShip(org.bukkit.block.Block block) {
|
|
BlockOwnerShip ship = blockOwnerShipsMaterial.get(CMIMaterial.get(block));
|
|
if (ship != null)
|
|
ship.remove(block);
|
|
}
|
|
|
|
/**
|
|
* @return a set of block owner ships.
|
|
*/
|
|
public HashMap<CMIMaterial, BlockOwnerShip> getBlockOwnerShips() {
|
|
return blockOwnerShipsMaterial;
|
|
}
|
|
|
|
private Placeholder placeholder;
|
|
private boolean placeholderAPIEnabled = false;
|
|
|
|
public Placeholder getPlaceholderAPIManager() {
|
|
if (placeholder == null)
|
|
placeholder = new Placeholder(this);
|
|
return placeholder;
|
|
}
|
|
|
|
private boolean setupPlaceHolderAPI() {
|
|
org.bukkit.plugin.Plugin papi = getServer().getPluginManager().getPlugin("PlaceholderAPI");
|
|
if (papi == null || !papi.isEnabled())
|
|
return false;
|
|
|
|
try {
|
|
if (Integer.parseInt(papi
|
|
.getDescription().getVersion().replaceAll("[^\\d]", "")) >= 2100 && new PlaceholderAPIHook(this).register()) {
|
|
consoleMsg("&6PlaceholderAPI &ehooked.");
|
|
}
|
|
} catch (NumberFormatException ex) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static Loging getLoging() {
|
|
if (loging == null)
|
|
loging = new Loging();
|
|
return loging;
|
|
}
|
|
|
|
public static BlockProtectionManager getBpManager() {
|
|
if (bpManager == null)
|
|
bpManager = new BlockProtectionManager();
|
|
return bpManager;
|
|
}
|
|
|
|
public static JobsManager getDBManager() {
|
|
if (dbManager == null)
|
|
dbManager = new JobsManager(getInstance());
|
|
return dbManager;
|
|
}
|
|
|
|
public static ShopManager getShopManager() {
|
|
if (shopManager == null) {
|
|
shopManager = new ShopManager();
|
|
}
|
|
return shopManager;
|
|
}
|
|
|
|
public static ConfigManager getConfigManager() {
|
|
if (configManager == null)
|
|
configManager = new ConfigManager();
|
|
return configManager;
|
|
}
|
|
|
|
public static GeneralConfigManager getGCManager() {
|
|
if (gConfigManager == null)
|
|
gConfigManager = new GeneralConfigManager();
|
|
return gConfigManager;
|
|
}
|
|
|
|
/**
|
|
* @return {@link PlayerManager}
|
|
*/
|
|
public static PlayerManager getPlayerManager() {
|
|
if (pManager == null)
|
|
pManager = new PlayerManager(getInstance());
|
|
return pManager;
|
|
}
|
|
|
|
public static RestrictedBlockManager getRestrictedBlockManager() {
|
|
if (rbManager == null) {
|
|
rbManager = new RestrictedBlockManager();
|
|
}
|
|
|
|
return rbManager;
|
|
}
|
|
|
|
public static RestrictedAreaManager getRestrictedAreaManager() {
|
|
if (raManager == null) {
|
|
raManager = new RestrictedAreaManager();
|
|
}
|
|
|
|
return raManager;
|
|
}
|
|
|
|
/**
|
|
* @return {@link TitleManager}
|
|
*/
|
|
public static TitleManager getTitleManager() {
|
|
if (titleManager == null) {
|
|
titleManager = new TitleManager();
|
|
}
|
|
|
|
return titleManager;
|
|
}
|
|
|
|
public static BossBarManager getBBManager() {
|
|
return bbManager;
|
|
}
|
|
|
|
/**
|
|
* Returns schedule manager
|
|
* @return the schedule manager
|
|
*/
|
|
public static ScheduleManager getScheduleManager() {
|
|
if (scheduleManager == null) {
|
|
scheduleManager = new ScheduleManager(getInstance());
|
|
}
|
|
|
|
return scheduleManager;
|
|
}
|
|
|
|
public static NameTranslatorManager getNameTranslatorManager() {
|
|
if (nameTranslatorManager == null) {
|
|
nameTranslatorManager = new NameTranslatorManager();
|
|
}
|
|
|
|
return nameTranslatorManager;
|
|
}
|
|
|
|
public GuiManager getGUIManager() {
|
|
if (guiManager == null)
|
|
guiManager = new GuiManager(this);
|
|
return guiManager;
|
|
}
|
|
|
|
public static JobsCommands getCommandManager() {
|
|
if (cManager == null) {
|
|
cManager = new JobsCommands(getInstance());
|
|
}
|
|
return cManager;
|
|
}
|
|
|
|
@Deprecated
|
|
public static ExploreManager getExplore() {
|
|
return getExploreManager();
|
|
}
|
|
|
|
public static ExploreManager getExploreManager() {
|
|
if (exploreManager == null)
|
|
exploreManager = new ExploreManager();
|
|
return exploreManager;
|
|
}
|
|
|
|
/**
|
|
* @return returns this class object instance
|
|
*/
|
|
public static Jobs getInstance() {
|
|
return JavaPlugin.getPlugin(Jobs.class);
|
|
}
|
|
|
|
/**
|
|
* Returns sign manager
|
|
* @return the sign manager
|
|
*/
|
|
public static SignUtil getSignUtil() {
|
|
if (signManager == null) {
|
|
signManager = new SignUtil(getInstance());
|
|
}
|
|
|
|
return signManager;
|
|
}
|
|
|
|
/**
|
|
* Returns language manager
|
|
* @return the language manager
|
|
*/
|
|
public static Language getLanguage() {
|
|
if (lManager == null)
|
|
lManager = new Language();
|
|
return lManager;
|
|
}
|
|
|
|
public static LanguageManager getLanguageManager() {
|
|
if (lmManager == null) {
|
|
lmManager = new LanguageManager();
|
|
}
|
|
|
|
return lmManager;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the plugin logger
|
|
* @return the plugin logger
|
|
*/
|
|
public static Logger getPluginLogger() {
|
|
return getInstance().getLogger();
|
|
}
|
|
|
|
public static File getFolder() {
|
|
File folder = getInstance().getDataFolder();
|
|
folder.mkdirs();
|
|
return folder;
|
|
}
|
|
|
|
/**
|
|
* Sets the Data Access Object
|
|
* @param dao - the DAO
|
|
*/
|
|
public static void setDAO(JobsDAO dao) {
|
|
Jobs.dao = dao;
|
|
}
|
|
|
|
/**
|
|
* Get the Data Access Object
|
|
* @return the DAO
|
|
*/
|
|
public static JobsDAO getJobsDAO() {
|
|
return dao;
|
|
}
|
|
|
|
/**
|
|
* Sets the list of jobs
|
|
* @param jobs - list of jobs
|
|
*/
|
|
public static void setJobs(List<Job> jobs) {
|
|
Jobs.jobs = jobs;
|
|
}
|
|
|
|
/**
|
|
* Returns the list of available jobs.
|
|
*
|
|
* @return an unmodifiable list of jobs
|
|
*/
|
|
public static List<Job> getJobs() {
|
|
return Collections.unmodifiableList(jobs);
|
|
}
|
|
|
|
/**
|
|
* Sets the none job
|
|
* @param noneJob - the none job
|
|
*/
|
|
public static void setNoneJob(Job noneJob) {
|
|
Jobs.noneJob = noneJob;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the "none" job
|
|
* @return the none job
|
|
*/
|
|
public static Job getNoneJob() {
|
|
return noneJob;
|
|
}
|
|
|
|
/**
|
|
* Function to return the job information that matches the jobName given
|
|
* @param jobName - the ame of the job given
|
|
* @return the job that matches the name
|
|
*/
|
|
public static Job getJob(String jobName) {
|
|
for (Job job : jobs) {
|
|
if (job.getName().equalsIgnoreCase(jobName) || job.getJobFullName().equalsIgnoreCase(jobName))
|
|
return job;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns a job by identifier.
|
|
*
|
|
* @param id the id of job
|
|
* @return {@link Job}
|
|
*/
|
|
public static Job getJob(int id) {
|
|
for (Job job : jobs) {
|
|
if (job.getId() == id || job.getLegacyId() == id) {
|
|
return job;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public boolean isPlaceholderAPIEnabled() {
|
|
return placeholderAPIEnabled;
|
|
}
|
|
|
|
private static void startup() {
|
|
reload(true);
|
|
|
|
// This goes in sync to avoid issues while loading data
|
|
loadAllPlayersData();
|
|
for (Player online : Bukkit.getServer().getOnlinePlayers())
|
|
getPlayerManager().playerJoin(online);
|
|
}
|
|
|
|
public static void loadAllPlayersData() {
|
|
long time = System.currentTimeMillis();
|
|
HashMap<UUID, PlayerInfo> temp = new HashMap<>(getPlayerManager().getPlayersInfoUUIDMap());
|
|
Map<Integer, List<JobsDAOData>> playersJobs = dao.getAllJobs();
|
|
Map<Integer, PlayerPoints> playersPoints = dao.getAllPoints();
|
|
Map<Integer, Map<String, Log>> playersLogs = dao.getAllLogs();
|
|
Map<Integer, ArchivedJobs> playersArchives = dao.getAllArchivedJobs();
|
|
Map<Integer, PaymentData> playersLimits = dao.loadPlayerLimits();
|
|
for (Iterator<PlayerInfo> it = temp.values().iterator(); it.hasNext();) {
|
|
PlayerInfo one = it.next();
|
|
int id = one.getID();
|
|
JobsPlayer jPlayer = getPlayerManager().getJobsPlayerOffline(
|
|
one,
|
|
playersJobs.get(id),
|
|
playersPoints.get(id),
|
|
playersLogs.get(id),
|
|
playersArchives.get(id),
|
|
playersLimits.get(id));
|
|
if (jPlayer != null)
|
|
getPlayerManager().addPlayerToCache(jPlayer);
|
|
}
|
|
if (!getPlayerManager().getPlayersCache().isEmpty())
|
|
consoleMsg("&ePreloaded &6" + getPlayerManager().getPlayersCache().size() + " &eplayers data in &6" + ((int) ((System.currentTimeMillis() - time) / 1000.0D * 100.0D) / 100.0D));
|
|
}
|
|
|
|
public static void convertDatabase() {
|
|
try {
|
|
List<Convert> archivelist = dao.convertDatabase();
|
|
|
|
getDBManager().switchDataBase();
|
|
getPlayerManager().reload();
|
|
|
|
dao.truncateAllTables();
|
|
|
|
for (Job one : Jobs.getJobs()) {
|
|
dao.recordNewJobName(one, one.getId());
|
|
}
|
|
for (JobsWorld one : Util.getJobsWorlds().values()) {
|
|
dao.recordNewWorld(one.getName(), one.getId());
|
|
}
|
|
|
|
getPlayerManager().convertChacheOfPlayers(true);
|
|
|
|
dao.continueConvertions(archivelist);
|
|
getPlayerManager().clearMaps();
|
|
getPlayerManager().clearCache();
|
|
|
|
dao.saveExplore();
|
|
// Do we really need to convert Block protection?
|
|
// Jobs.getJobsDAO().saveBlockProtection();
|
|
} catch (SQLException e) {
|
|
e.printStackTrace();
|
|
Jobs.consoleMsg("&cCan't write data to data base, please send error log to dev's.");
|
|
return;
|
|
}
|
|
|
|
reload();
|
|
loadAllPlayersData();
|
|
}
|
|
|
|
/**
|
|
* Checks if the given {@link JobsPlayer} have the given {@link ActionType} in one of jobs.
|
|
*
|
|
* @param jPlayer {@link JobsPlayer}
|
|
* @param type {@link ActionType}
|
|
* @return true if the player have the given action
|
|
*/
|
|
public static boolean isPlayerHaveAction(JobsPlayer jPlayer, ActionType type) {
|
|
if (jPlayer == null || type == null)
|
|
return false;
|
|
|
|
boolean found = false;
|
|
|
|
for (JobProgression prog : jPlayer.getJobProgression()) {
|
|
for (JobInfo info : prog.getJob().getJobInfo(type)) {
|
|
if (info.getActionType() == type) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
for (Quest q : prog.getJob().getQuests()) {
|
|
if (q != null && q.hasAction(type)) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (found) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
/**
|
|
* Function to get the number of slots used on the server for this job
|
|
* @param job - the job
|
|
* @return the number of slots
|
|
*/
|
|
public static int getUsedSlots(Job job) {
|
|
return usedSlots.getOrDefault(job, 0);
|
|
}
|
|
|
|
/**
|
|
* Function to increase the number of used slots for a job
|
|
* @param job - the job someone is taking
|
|
*/
|
|
public static void takeSlot(Job job) {
|
|
Integer used = usedSlots.get(job);
|
|
if (used != null)
|
|
usedSlots.put(job, used + 1);
|
|
}
|
|
|
|
/**
|
|
* Function to decrease the number of used slots for a job
|
|
* @param job - the job someone is leaving
|
|
*/
|
|
public static void leaveSlot(Job job) {
|
|
Integer used = usedSlots.get(job);
|
|
if (used != null)
|
|
usedSlots.put(job, used - 1);
|
|
}
|
|
|
|
/**
|
|
* Gets the permission handler
|
|
* @return the permission handler
|
|
*/
|
|
public static PermissionHandler getPermissionHandler() {
|
|
if (permissionHandler == null)
|
|
permissionHandler = new PermissionHandler(getInstance());
|
|
return permissionHandler;
|
|
}
|
|
|
|
public static PermissionManager getPermissionManager() {
|
|
if (permissionManager == null)
|
|
permissionManager = new PermissionManager();
|
|
return permissionManager;
|
|
}
|
|
|
|
/**
|
|
* Sets the economy handler
|
|
* @param eco - the economy handler
|
|
*/
|
|
public static void setEconomy(Economy eco) {
|
|
economy = new BufferedEconomy(getInstance(), eco);
|
|
}
|
|
|
|
/**
|
|
* Gets the economy handler
|
|
* @return the economy handler
|
|
*/
|
|
public static BufferedEconomy getEconomy() {
|
|
return economy;
|
|
}
|
|
|
|
/**
|
|
* Gets the version check manager
|
|
* @return the version check manager
|
|
*/
|
|
public static VersionChecker getVersionCheckManager() {
|
|
if (versionCheckManager == null)
|
|
versionCheckManager = new VersionChecker(getInstance());
|
|
|
|
return versionCheckManager;
|
|
}
|
|
|
|
private final static String prefix = "&6------------- &2Jobs &6-------------";
|
|
private final static String suffix = "&6------------------------------------";
|
|
|
|
@Override
|
|
public void onEnable() {
|
|
CMIMessages.consoleMessage(prefix);
|
|
|
|
try {
|
|
Class.forName("net.kyori.adventure.text.Component");
|
|
org.bukkit.inventory.meta.ItemMeta.class.getDeclaredMethod("displayName");
|
|
kyoriSupported = true;
|
|
} catch (NoSuchMethodException | ClassNotFoundException e) {
|
|
}
|
|
|
|
placeholderAPIEnabled = setupPlaceHolderAPI();
|
|
|
|
try {
|
|
new YmlMaker(getFolder(), "shopItems.yml").saveDefaultConfig();
|
|
new YmlMaker(getFolder(), "restrictedBlocks.yml").saveDefaultConfig();
|
|
|
|
bbManager = new BossBarManager(this);
|
|
|
|
Optional.ofNullable(getCommand("jobs")).ifPresent(j -> {
|
|
j.setExecutor(getCommandManager());
|
|
j.setTabCompleter(new TabComplete());
|
|
});
|
|
|
|
startup();
|
|
|
|
if (status.equals(LoadStatus.MYSQLFailure) || status.equals(LoadStatus.SQLITEFailure)) {
|
|
CMIMessages.consoleMessage("&cCould not connect to " + (status.equals(LoadStatus.MYSQLFailure) ? "MySQL" : "SqLite") + "!");
|
|
CMIMessages.consoleMessage("&cPlugin will be disabled");
|
|
this.onDisable();
|
|
this.setEnabled(false);
|
|
return;
|
|
}
|
|
|
|
if (getGCManager().SignsEnabled) {
|
|
new YmlMaker(getFolder(), "Signs.yml").saveDefaultConfig();
|
|
}
|
|
|
|
HookManager.loadHooks();
|
|
registerListeners();
|
|
|
|
if (Version.isCurrentEqualOrHigher(Version.v1_16_R3) && kyoriSupported) {
|
|
complement = new Complement2();
|
|
//getServer().getPluginManager().registerEvents(new KyoriChatEvent(this), this);
|
|
} else {
|
|
complement = new Complement1();
|
|
}
|
|
|
|
// register economy
|
|
getServer().getScheduler().runTask(this, new HookEconomyTask(this));
|
|
|
|
dao.loadBlockProtection();
|
|
getExploreManager().load();
|
|
getCommandManager().fillCommands();
|
|
getDBManager().getDB().triggerTableIdUpdate();
|
|
|
|
consoleMsg("&ePlugin has been enabled successfully.");
|
|
} catch (Throwable e) {
|
|
e.printStackTrace();
|
|
System.out.println("There was some issues when starting plugin. Please contact dev about this. Plugin will be disabled.");
|
|
setEnabled(false);
|
|
}
|
|
|
|
CMIMessages.consoleMessage(suffix);
|
|
}
|
|
|
|
private static void registerListeners() {
|
|
|
|
org.bukkit.plugin.PluginManager pm = getInstance().getServer().getPluginManager();
|
|
|
|
if (Version.isCurrentEqualOrHigher(Version.v1_9_R1)) {
|
|
pm.registerEvents(new com.gamingmesh.jobs.listeners.Listener1_9(), getInstance());
|
|
}
|
|
|
|
pm.registerEvents(new JobsListener(getInstance()), getInstance());
|
|
pm.registerEvents(new JobsPaymentListener(getInstance()), getInstance());
|
|
if (Version.isCurrentEqualOrHigher(Version.v1_14_R1)) {
|
|
pm.registerEvents(new JobsPayment14Listener(), getInstance());
|
|
}
|
|
|
|
if (getGCManager().useBlockProtection) {
|
|
pm.registerEvents(new PistonProtectionListener(), getInstance());
|
|
}
|
|
|
|
pm.registerEvents(new JobsChatEvent(getInstance()), getInstance());
|
|
|
|
if (HookManager.getMcMMOManager().CheckmcMMO()) {
|
|
HookManager.setMcMMOlistener();
|
|
}
|
|
if (HookManager.checkMythicMobs()) {
|
|
HookManager.getMythicManager().registerListener();
|
|
}
|
|
}
|
|
|
|
public static void reload() {
|
|
reload(false);
|
|
}
|
|
|
|
public static void reload(boolean startup) {
|
|
// unregister all registered listeners by this plugin and register again
|
|
if (!startup) {
|
|
HandlerList.unregisterAll(getInstance());
|
|
registerListeners();
|
|
}
|
|
|
|
if (saveTask != null) {
|
|
saveTask.shutdown();
|
|
}
|
|
|
|
if (paymentThread != null) {
|
|
paymentThread.shutdown();
|
|
}
|
|
|
|
smanager = new SelectionManager();
|
|
|
|
getGCManager().reload();
|
|
getLanguage().reload();
|
|
getConfigManager().reload();
|
|
|
|
hasLimitedItems = Jobs.getJobs().stream().anyMatch(job -> !job.getLimitedItems().isEmpty());
|
|
|
|
getDBManager().getDB().loadAllJobsWorlds();
|
|
getDBManager().getDB().loadAllJobsNames();
|
|
|
|
if (Version.isCurrentEqualOrLower(Version.v1_13_R1)) {
|
|
getInstance().getBlockOwnerShip(CMIMaterial.LEGACY_BREWING_STAND).ifPresent(BlockOwnerShip::load);
|
|
getInstance().getBlockOwnerShip(CMIMaterial.LEGACY_BURNING_FURNACE).ifPresent(BlockOwnerShip::load);
|
|
} else {
|
|
getInstance().getBlockOwnerShip(CMIMaterial.FURNACE).ifPresent(BlockOwnerShip::load);
|
|
getInstance().getBlockOwnerShip(CMIMaterial.BREWING_STAND).ifPresent(BlockOwnerShip::load);
|
|
}
|
|
if (Version.isCurrentEqualOrHigher(Version.v1_14_R1)) {
|
|
getInstance().getBlockOwnerShip(CMIMaterial.BLAST_FURNACE).ifPresent(BlockOwnerShip::load);
|
|
getInstance().getBlockOwnerShip(CMIMaterial.SMOKER).ifPresent(BlockOwnerShip::load);
|
|
}
|
|
|
|
ToggleBarHandling.load();
|
|
usedSlots.clear();
|
|
for (Job job : jobs) {
|
|
usedSlots.put(job, dao.getSlotsTaken(job));
|
|
}
|
|
getPlayerManager().reload();
|
|
getPermissionHandler().registerPermissions();
|
|
|
|
// set the system to auto save
|
|
saveTask = new DatabaseSaveThread(getGCManager().getSavePeriod());
|
|
saveTask.start();
|
|
|
|
// schedule payouts to buffered payments
|
|
paymentThread = new BufferedPaymentThread(getGCManager().getEconomyBatchDelay());
|
|
paymentThread.start();
|
|
|
|
dao.loadPlayerData();
|
|
|
|
// Schedule
|
|
if (getGCManager().enableSchedule) {
|
|
try {
|
|
getScheduleManager().load();
|
|
getScheduleManager().start();
|
|
} catch (Throwable e) {
|
|
e.printStackTrace();
|
|
}
|
|
} else
|
|
getScheduleManager().cancel();
|
|
}
|
|
|
|
@Override
|
|
public void onDisable() {
|
|
|
|
CMIMessages.consoleMessage(prefix);
|
|
HandlerList.unregisterAll(this);
|
|
|
|
if (dao != null) {
|
|
dao.saveExplore();
|
|
}
|
|
|
|
blockOwnerShipsMaterial.values().forEach(BlockOwnerShip::save);
|
|
ToggleBarHandling.save();
|
|
|
|
if (saveTask != null)
|
|
saveTask.shutdown();
|
|
|
|
if (paymentThread != null)
|
|
paymentThread.shutdown();
|
|
|
|
if (pManager != null) {
|
|
pManager.removePlayerAdditions();
|
|
pManager.saveAll();
|
|
}
|
|
|
|
if (dao != null) {
|
|
dao.closeConnections();
|
|
}
|
|
|
|
CMIMessages.consoleMessage(suffix);
|
|
}
|
|
|
|
private static void checkDailyQuests(JobsPlayer jPlayer, Job job, ActionInfo info) {
|
|
if (!job.getQuests().isEmpty()) {
|
|
for (QuestProgression one : jPlayer.getQuestProgressions(job, info.getType())) {
|
|
one.processQuest(jPlayer, info);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Perform an action for the given {@link JobsPlayer} with the given action info.
|
|
*
|
|
* @param jPlayer {@link JobsPlayer}
|
|
* @param info {@link ActionInfo}
|
|
* @see #action(JobsPlayer, ActionInfo, Block, Entity, LivingEntity)
|
|
*/
|
|
public static void action(JobsPlayer jPlayer, ActionInfo info) {
|
|
action(jPlayer, info, null, null, null);
|
|
}
|
|
|
|
/**
|
|
* Perform an action for the given {@link JobsPlayer} with the given action info and block.
|
|
*
|
|
* @param jPlayer {@link JobsPlayer}
|
|
* @param info {@link ActionInfo}
|
|
* @param block {@link Block}
|
|
* @see #action(JobsPlayer, ActionInfo, Block, Entity, LivingEntity)
|
|
*/
|
|
public static void action(JobsPlayer jPlayer, ActionInfo info, Block block) {
|
|
action(jPlayer, info, block, null, null);
|
|
}
|
|
|
|
/**
|
|
* Perform an action for the given {@link JobsPlayer} with the given action info and entity.
|
|
*
|
|
* @param jPlayer {@link JobsPlayer}
|
|
* @param info {@link ActionInfo}
|
|
* @param ent {@link Entity}
|
|
* @see #action(JobsPlayer, ActionInfo, Block, Entity, LivingEntity)
|
|
*/
|
|
public static void action(JobsPlayer jPlayer, ActionInfo info, Entity ent) {
|
|
action(jPlayer, info, null, ent, null);
|
|
}
|
|
|
|
/**
|
|
* Perform an action for the given {@link JobsPlayer} with the given action info,
|
|
* entity and living entity.
|
|
*
|
|
* @param jPlayer {@link JobsPlayer}
|
|
* @param info {@link ActionInfo}
|
|
* @param ent {@link Entity}
|
|
* @param victim {@link LivingEntity}
|
|
* @see #action(JobsPlayer, ActionInfo, Block, Entity, LivingEntity)
|
|
*/
|
|
public static void action(JobsPlayer jPlayer, ActionInfo info, Entity ent, LivingEntity victim) {
|
|
action(jPlayer, info, null, ent, victim);
|
|
}
|
|
|
|
/**
|
|
* Perform an action for the given {@link JobsPlayer} with the parameters.
|
|
* <p>
|
|
* The process:
|
|
* <p>
|
|
* If the player does not have any job progression cached into memory, the player
|
|
* only retrieve the "noneJob" by default. This means that there will be no any
|
|
* extra income calculations and the player does no get the full income from jobs,
|
|
* but the half of it.<br>
|
|
* In other cases if player have at least 1 job cached, they will get the full income
|
|
* with the extra calculated multiplications including bonuses and limits.
|
|
* <p>
|
|
*
|
|
* <b>This usually not be called in your code, to avoid misbehaviour working ability.</b>
|
|
*
|
|
* @param jPlayer {@link JobsPlayer}
|
|
* @param info {@link ActionInfo}
|
|
* @param ent {@link Entity}
|
|
* @param victim {@link LivingEntity}
|
|
* @param block {@link Block}
|
|
*/
|
|
public static void action(JobsPlayer jPlayer, ActionInfo info, Block block, Entity ent, LivingEntity victim) {
|
|
if (jPlayer == null)
|
|
return;
|
|
|
|
List<JobProgression> progression = jPlayer.getJobProgression();
|
|
int numjobs = progression.size();
|
|
|
|
if (!isBpOk(jPlayer, info, block, true))
|
|
return;
|
|
|
|
// no job
|
|
if (numjobs == 0) {
|
|
if (noneJob == null || noneJob.isWorldBlackListed(block) || noneJob.isWorldBlackListed(block, ent) || noneJob.isWorldBlackListed(victim))
|
|
return;
|
|
|
|
JobInfo jobinfo = noneJob.getJobInfo(info, 1);
|
|
|
|
checkDailyQuests(jPlayer, noneJob, info);
|
|
|
|
if (jobinfo == null)
|
|
return;
|
|
|
|
double income = jobinfo.getIncome(1, numjobs, jPlayer.maxJobsEquation);
|
|
double pointAmount = jobinfo.getPoints(1, numjobs, jPlayer.maxJobsEquation);
|
|
|
|
if (income == 0D && pointAmount == 0D)
|
|
return;
|
|
|
|
Boost boost = getPlayerManager().getFinalBonus(jPlayer, noneJob);
|
|
|
|
JobsPrePaymentEvent jobsPrePaymentEvent = new JobsPrePaymentEvent(jPlayer.getPlayer(), noneJob, income,
|
|
pointAmount, block, ent, victim, info);
|
|
Bukkit.getServer().getPluginManager().callEvent(jobsPrePaymentEvent);
|
|
// If event is canceled, don't do anything
|
|
if (jobsPrePaymentEvent.isCancelled()) {
|
|
income = 0D;
|
|
pointAmount = 0D;
|
|
} else {
|
|
income = jobsPrePaymentEvent.getAmount();
|
|
pointAmount = jobsPrePaymentEvent.getPoints();
|
|
}
|
|
|
|
// Calculate income
|
|
if (income != 0D) {
|
|
income = boost.getFinalAmount(CurrencyType.MONEY, income);
|
|
|
|
if (gConfigManager.useMinimumOveralPayment && income > 0) {
|
|
double maxLimit = income * gConfigManager.MinimumOveralPaymentLimit;
|
|
|
|
if (income < maxLimit)
|
|
income = maxLimit;
|
|
}
|
|
}
|
|
|
|
// Calculate points
|
|
if (pointAmount != 0D) {
|
|
pointAmount = boost.getFinalAmount(CurrencyType.POINTS, pointAmount);
|
|
|
|
if (gConfigManager.useMinimumOveralPoints && pointAmount > 0) {
|
|
double maxLimit = pointAmount * gConfigManager.MinimumOveralPointsLimit;
|
|
|
|
if (pointAmount < maxLimit)
|
|
pointAmount = maxLimit;
|
|
}
|
|
}
|
|
|
|
if (!jPlayer.isUnderLimit(CurrencyType.MONEY, income)) {
|
|
if (gConfigManager.useMaxPaymentCurve) {
|
|
double percentOver = jPlayer.percentOverLimit(CurrencyType.MONEY);
|
|
double percentLoss = 100 / ((1 / gConfigManager.maxPaymentCurveFactor * percentOver * percentOver) + 1);
|
|
|
|
income = income - (income * percentLoss / 100);
|
|
} else
|
|
income = 0D;
|
|
if (gConfigManager.getLimit(CurrencyType.MONEY).getStopWith().contains(CurrencyType.POINTS))
|
|
pointAmount = 0D;
|
|
}
|
|
|
|
if (!jPlayer.isUnderLimit(CurrencyType.POINTS, pointAmount)) {
|
|
pointAmount = 0D;
|
|
if (gConfigManager.getLimit(CurrencyType.POINTS).getStopWith().contains(CurrencyType.MONEY))
|
|
income = 0D;
|
|
}
|
|
|
|
if (income == 0D && pointAmount == 0D)
|
|
return;
|
|
|
|
if (info.getType() == ActionType.BREAK && block != null)
|
|
getBpManager().remove(block);
|
|
|
|
if (pointAmount != 0D)
|
|
jPlayer.setSaved(false);
|
|
|
|
Map<CurrencyType, Double> payments = new HashMap<>();
|
|
if (income != 0D)
|
|
payments.put(CurrencyType.MONEY, income);
|
|
if (pointAmount != 0D)
|
|
payments.put(CurrencyType.POINTS, pointAmount);
|
|
|
|
economy.pay(jPlayer, payments);
|
|
|
|
if (gConfigManager.LoggingUse) {
|
|
Map<CurrencyType, Double> amounts = new HashMap<>();
|
|
amounts.put(CurrencyType.MONEY, income);
|
|
getLoging().recordToLog(jPlayer, info, amounts);
|
|
}
|
|
|
|
} else {
|
|
List<Job> expiredJobs = new ArrayList<>();
|
|
for (JobProgression prog : progression) {
|
|
if (prog.getJob().isWorldBlackListed(block) || prog.getJob().isWorldBlackListed(block, ent)
|
|
|| prog.getJob().isWorldBlackListed(victim))
|
|
continue;
|
|
|
|
if (jPlayer.isLeftTimeEnded(prog.getJob())) {
|
|
expiredJobs.add(prog.getJob());
|
|
}
|
|
|
|
JobInfo jobinfo = prog.getJob().getJobInfo(info, prog.getLevel());
|
|
|
|
checkDailyQuests(jPlayer, prog.getJob(), info);
|
|
|
|
if (jobinfo == null || (gConfigManager.disablePaymentIfMaxLevelReached && prog.getLevel() >= prog.getJob().getMaxLevel())) {
|
|
continue;
|
|
}
|
|
|
|
double income = jobinfo.getIncome(prog.getLevel(), numjobs, jPlayer.maxJobsEquation);
|
|
double pointAmount = jobinfo.getPoints(prog.getLevel(), numjobs, jPlayer.maxJobsEquation);
|
|
double expAmount = jobinfo.getExperience(prog.getLevel(), numjobs, jPlayer.maxJobsEquation);
|
|
|
|
if (income == 0D && pointAmount == 0D && expAmount == 0D)
|
|
continue;
|
|
|
|
if (gConfigManager.addXpPlayer()) {
|
|
Player player = jPlayer.getPlayer();
|
|
if (player != null) {
|
|
/*
|
|
* Minecraft experience is calculated in whole numbers only.
|
|
* Calculate the fraction of an experience point and perform a dice roll.
|
|
* That way jobs that give fractions of experience points will slowly give
|
|
* experience in the aggregate
|
|
*/
|
|
int expInt = (int) expAmount;
|
|
double remainder = expAmount - expInt;
|
|
if (Math.abs(remainder) > Math.random()) {
|
|
if (expAmount < 0)
|
|
expInt--;
|
|
else
|
|
expInt++;
|
|
}
|
|
|
|
if (expInt < 0 && getPlayerExperience(player) < -expInt) {
|
|
player.setLevel(0);
|
|
player.setTotalExperience(0);
|
|
player.setExp(0);
|
|
} else
|
|
player.giveExp(expInt);
|
|
}
|
|
}
|
|
|
|
Boost boost = getPlayerManager().getFinalBonus(jPlayer, prog.getJob(), ent, victim);
|
|
|
|
JobsPrePaymentEvent jobsPrePaymentEvent = new JobsPrePaymentEvent(jPlayer.getPlayer(), prog.getJob(), income,
|
|
pointAmount, block, ent, victim, info);
|
|
|
|
Bukkit.getServer().getPluginManager().callEvent(jobsPrePaymentEvent);
|
|
// If event is canceled, don't do anything
|
|
if (jobsPrePaymentEvent.isCancelled()) {
|
|
income = 0D;
|
|
pointAmount = 0D;
|
|
} else {
|
|
income = jobsPrePaymentEvent.getAmount();
|
|
pointAmount = jobsPrePaymentEvent.getPoints();
|
|
}
|
|
|
|
// Calculate income
|
|
if (income != 0D) {
|
|
income = boost.getFinalAmount(CurrencyType.MONEY, income);
|
|
|
|
if (gConfigManager.useMinimumOveralPayment && income > 0) {
|
|
double maxLimit = income * gConfigManager.MinimumOveralPaymentLimit;
|
|
|
|
if (income < maxLimit)
|
|
income = maxLimit;
|
|
}
|
|
}
|
|
|
|
// Calculate points
|
|
if (pointAmount != 0D) {
|
|
pointAmount = boost.getFinalAmount(CurrencyType.POINTS, pointAmount);
|
|
|
|
if (gConfigManager.useMinimumOveralPoints && pointAmount > 0) {
|
|
double maxLimit = pointAmount * gConfigManager.MinimumOveralPointsLimit;
|
|
|
|
if (pointAmount < maxLimit)
|
|
pointAmount = maxLimit;
|
|
}
|
|
}
|
|
|
|
// Calculate exp
|
|
if (expAmount != 0D) {
|
|
expAmount = boost.getFinalAmount(CurrencyType.EXP, expAmount);
|
|
|
|
if (gConfigManager.useMinimumOveralExp && expAmount > 0) {
|
|
double maxLimit = expAmount * gConfigManager.minimumOveralExpLimit;
|
|
|
|
if (expAmount < maxLimit)
|
|
expAmount = maxLimit;
|
|
}
|
|
}
|
|
|
|
if (!jPlayer.isUnderLimit(CurrencyType.MONEY, income)) {
|
|
income = 0D;
|
|
|
|
CurrencyLimit cLimit = gConfigManager.getLimit(CurrencyType.MONEY);
|
|
|
|
if (cLimit.getStopWith().contains(CurrencyType.EXP))
|
|
expAmount = 0D;
|
|
|
|
if (cLimit.getStopWith().contains(CurrencyType.POINTS))
|
|
pointAmount = 0D;
|
|
}
|
|
|
|
if (!jPlayer.isUnderLimit(CurrencyType.EXP, expAmount)) {
|
|
expAmount = 0D;
|
|
|
|
CurrencyLimit cLimit = gConfigManager.getLimit(CurrencyType.EXP);
|
|
|
|
if (cLimit.getStopWith().contains(CurrencyType.MONEY))
|
|
income = 0D;
|
|
|
|
if (cLimit.getStopWith().contains(CurrencyType.POINTS))
|
|
pointAmount = 0D;
|
|
}
|
|
|
|
if (!jPlayer.isUnderLimit(CurrencyType.POINTS, pointAmount)) {
|
|
pointAmount = 0D;
|
|
|
|
CurrencyLimit cLimit = gConfigManager.getLimit(CurrencyType.POINTS);
|
|
|
|
if (cLimit.getStopWith().contains(CurrencyType.MONEY))
|
|
income = 0D;
|
|
|
|
if (cLimit.getStopWith().contains(CurrencyType.EXP))
|
|
expAmount = 0D;
|
|
}
|
|
|
|
if (income == 0D && pointAmount == 0D && expAmount == 0D)
|
|
continue;
|
|
|
|
// JobsPayment event
|
|
JobsExpGainEvent jobsExpGainEvent = new JobsExpGainEvent(jPlayer.getPlayer(), prog.getJob(), expAmount,
|
|
block, ent, victim, info);
|
|
Bukkit.getServer().getPluginManager().callEvent(jobsExpGainEvent);
|
|
// If event is canceled, don't do anything
|
|
expAmount = jobsExpGainEvent.isCancelled() ? 0D : jobsExpGainEvent.getExp();
|
|
|
|
try {
|
|
if (expAmount != 0D && gConfigManager.BossBarEnabled)
|
|
if (gConfigManager.BossBarShowOnEachAction)
|
|
bbManager.ShowJobProgression(jPlayer, prog, expAmount);
|
|
else
|
|
jPlayer.getUpdateBossBarFor().add(prog.getJob().getName());
|
|
} catch (Throwable e) {
|
|
e.printStackTrace();
|
|
consoleMsg("&c[Jobs] Some issues with boss bar feature accured, try disabling it to avoid it.");
|
|
}
|
|
|
|
Map<CurrencyType, Double> payments = new HashMap<>();
|
|
if (income != 0D)
|
|
payments.put(CurrencyType.MONEY, income);
|
|
if (pointAmount != 0D)
|
|
payments.put(CurrencyType.POINTS, pointAmount);
|
|
if (expAmount != 0D)
|
|
payments.put(CurrencyType.EXP, expAmount);
|
|
|
|
FASTPAYMENT.put(jPlayer.getUniqueId(), new FastPayment(jPlayer, info, new BufferedPayment(jPlayer.getPlayer(), payments), prog
|
|
.getJob()));
|
|
|
|
economy.pay(jPlayer, payments);
|
|
int oldLevel = prog.getLevel();
|
|
|
|
if (gConfigManager.LoggingUse) {
|
|
Map<CurrencyType, Double> amounts = new HashMap<>();
|
|
amounts.put(CurrencyType.MONEY, income);
|
|
amounts.put(CurrencyType.EXP, expAmount);
|
|
amounts.put(CurrencyType.POINTS, pointAmount);
|
|
getLoging().recordToLog(jPlayer, info, amounts);
|
|
}
|
|
|
|
if (prog.addExperience(expAmount))
|
|
getPlayerManager().performLevelUp(jPlayer, prog.getJob(), oldLevel);
|
|
}
|
|
|
|
//need to update bp
|
|
if (block != null) {
|
|
BlockProtection bp = getBpManager().getBp(block.getLocation());
|
|
if (bp != null)
|
|
bp.setPaid(true);
|
|
}
|
|
|
|
expiredJobs.forEach(j -> getPlayerManager().leaveJob(jPlayer, j));
|
|
}
|
|
}
|
|
|
|
private static boolean isBpOk(JobsPlayer player, ActionInfo info, Block block, boolean inform) {
|
|
if (block == null || !gConfigManager.useBlockProtection)
|
|
return true;
|
|
|
|
if (info.getType() == ActionType.BREAK) {
|
|
if (block.hasMetadata("JobsExploit")) {
|
|
//player.sendMessage("This block is protected using Rukes' system!");
|
|
return false;
|
|
}
|
|
|
|
BlockProtection bp = getBpManager().getBp(block.getLocation());
|
|
if (bp != null) {
|
|
long time = bp.getTime();
|
|
Integer cd = getBpManager().getBlockDelayTime(block);
|
|
|
|
if (time == -1L) {
|
|
getBpManager().remove(block);
|
|
return false;
|
|
}
|
|
|
|
if (time < System.currentTimeMillis() && bp.getAction() != DBAction.DELETE) {
|
|
getBpManager().remove(block);
|
|
return true;
|
|
}
|
|
|
|
if ((time > System.currentTimeMillis() || bp.isPaid()) && bp.getAction() != DBAction.DELETE) {
|
|
if (inform && player.canGetPaid(info)) {
|
|
int sec = Math.round((time - System.currentTimeMillis()) / 1000L);
|
|
CMIActionBar.send(player.getPlayer(), lManager.getMessage("message.blocktimer", "[time]", sec));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
getBpManager().add(block, cd);
|
|
|
|
if ((cd == null || cd == 0) && gConfigManager.useGlobalTimer) {
|
|
getBpManager().add(block, gConfigManager.globalblocktimer);
|
|
}
|
|
|
|
} else if (gConfigManager.useGlobalTimer) {
|
|
getBpManager().add(block, gConfigManager.globalblocktimer);
|
|
}
|
|
} else if (info.getType() == ActionType.PLACE) {
|
|
BlockProtection bp = getBpManager().getBp(block.getLocation());
|
|
if (bp != null) {
|
|
Long time = bp.getTime();
|
|
Integer cd = getBpManager().getBlockDelayTime(block);
|
|
if (time != -1L) {
|
|
if (time < System.currentTimeMillis() && bp.getAction() != DBAction.DELETE) {
|
|
getBpManager().add(block, cd);
|
|
return true;
|
|
}
|
|
|
|
if ((time > System.currentTimeMillis() || bp.isPaid()) && bp.getAction() != DBAction.DELETE) {
|
|
if (inform && player.canGetPaid(info)) {
|
|
int sec = Math.round((time - System.currentTimeMillis()) / 1000L);
|
|
CMIActionBar.send(player.getPlayer(), lManager.getMessage("message.blocktimer", "[time]", sec));
|
|
}
|
|
|
|
getBpManager().add(block, cd);
|
|
return false;
|
|
}
|
|
|
|
// Lets add protection in any case
|
|
getBpManager().add(block, cd);
|
|
} else if (bp.isPaid() && bp.getTime() == -1L && cd != null && cd == -1) {
|
|
getBpManager().add(block, cd);
|
|
return false;
|
|
} else
|
|
getBpManager().add(block, cd);
|
|
} else
|
|
getBpManager().add(block, getBpManager().getBlockDelayTime(block));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static int getPlayerExperience(Player player) {
|
|
return (expToLevel(player.getLevel()) + Math.round(deltaLevelToExp(player.getLevel()) * player.getExp()));
|
|
}
|
|
|
|
// total xp calculation based by lvl
|
|
private static int expToLevel(int level) {
|
|
if (Version.isCurrentEqualOrLower(Version.v1_7_R4)) {
|
|
if (level <= 16)
|
|
return 17 * level;
|
|
else if (level <= 31)
|
|
return ((3 * level * level) / 2) - ((59 * level) / 2) + 360;
|
|
else
|
|
return ((7 * level * level) / 2) - ((303 * level) / 2) + 2220;
|
|
}
|
|
if (level <= 16)
|
|
return (level * level) + (6 * level);
|
|
else if (level <= 31)
|
|
return (int) ((2.5 * level * level) - (40.5 * level) + 360);
|
|
else
|
|
return (int) ((4.5 * level * level) - (162.5 * level) + 2220);
|
|
}
|
|
|
|
// xp calculation for one current lvl
|
|
private static int deltaLevelToExp(int level) {
|
|
if (Version.isCurrentEqualOrLower(Version.v1_7_R4)) {
|
|
if (level <= 16)
|
|
return 17;
|
|
else if (level <= 31)
|
|
return 3 * level - 31;
|
|
else
|
|
return 7 * level - 155;
|
|
}
|
|
if (level <= 16)
|
|
return 2 * level + 7;
|
|
else if (level <= 31)
|
|
return 5 * level - 38;
|
|
else
|
|
return 9 * level - 158;
|
|
}
|
|
|
|
public static void perform(JobsPlayer jPlayer, ActionInfo info, BufferedPayment payment, Job job) {
|
|
double expPayment = payment.get(CurrencyType.EXP);
|
|
|
|
JobsExpGainEvent jobsExpGainEvent = new JobsExpGainEvent(payment.getOfflinePlayer(), job, expPayment);
|
|
Bukkit.getServer().getPluginManager().callEvent(jobsExpGainEvent);
|
|
// If event is canceled, don't do anything
|
|
if (jobsExpGainEvent.isCancelled())
|
|
return;
|
|
|
|
boolean limited = true;
|
|
for (CurrencyType one : CurrencyType.values()) {
|
|
if (jPlayer.isUnderLimit(one, payment.get(one))) {
|
|
limited = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (limited)
|
|
return;
|
|
|
|
economy.pay(jPlayer, payment.getPayment());
|
|
|
|
JobProgression prog = jPlayer.getJobProgression(job);
|
|
int oldLevel = prog.getLevel();
|
|
|
|
if (gConfigManager.LoggingUse) {
|
|
getLoging().recordToLog(jPlayer, info, payment.getPayment());
|
|
}
|
|
|
|
if (prog.addExperience(expPayment))
|
|
getPlayerManager().performLevelUp(jPlayer, prog.getJob(), oldLevel);
|
|
}
|
|
|
|
public static void consoleMsg(String msg) {
|
|
if (msg != null) {
|
|
Bukkit.getServer().getConsoleSender().sendMessage(CMIChatColor.translate(msg));
|
|
}
|
|
}
|
|
|
|
public static SelectionManager getSelectionManager() {
|
|
return smanager;
|
|
}
|
|
|
|
public static boolean hasPermission(Object sender, String perm, boolean rawEnable) {
|
|
if (!(sender instanceof Player) || ((Player) sender).hasPermission(perm))
|
|
return true;
|
|
|
|
if (!rawEnable) {
|
|
CMIMessages.sendMessage(sender, LC.info_NoPermission);
|
|
return false;
|
|
}
|
|
new RawMessage().addText(LC.info_NoPermission.getLocale()).addHover("&2" + perm).show((Player) sender);
|
|
return false;
|
|
|
|
}
|
|
|
|
public void showPagination(CommandSender sender, PageInfo pi, String cmd) {
|
|
showPagination(sender, pi.getTotalPages(), pi.getCurrentPage(), pi.getTotalEntries(), cmd, null);
|
|
}
|
|
|
|
public void showPagination(CommandSender sender, PageInfo pi, String cmd, String pagePref) {
|
|
showPagination(sender, pi.getTotalPages(), pi.getCurrentPage(), pi.getTotalEntries(), cmd, pagePref);
|
|
}
|
|
|
|
public void showPagination(CommandSender sender, int pageCount, int currentPage, int totalEntries, String cmd, String pagePref) {
|
|
if (!(sender instanceof Player))
|
|
return;
|
|
|
|
if (!cmd.startsWith("/"))
|
|
cmd = "/" + cmd;
|
|
|
|
if (pageCount == 1)
|
|
return;
|
|
|
|
String pagePrefix = pagePref == null ? "" : pagePref;
|
|
|
|
int nextPage = currentPage + 1;
|
|
nextPage = currentPage < pageCount ? nextPage : currentPage;
|
|
|
|
int prevpage = currentPage - 1;
|
|
if (currentPage <= 1) {
|
|
prevpage = currentPage;
|
|
}
|
|
|
|
RawMessage rm = new RawMessage()
|
|
.addText((currentPage > 1 ? LC.info_prevPage.getLocale() : LC.info_prevPageOff.getLocale()))
|
|
.addHover(currentPage > 1 ? LC.info_prevPageHover.getLocale() : LC.info_lastPageHover.getLocale())
|
|
.addCommand(currentPage > 1 ? cmd + " " + pagePrefix + prevpage : cmd + " " + pagePrefix + pageCount);
|
|
|
|
rm.addText(LC.info_pageCount.getLocale("[current]", currentPage, "[total]", pageCount))
|
|
.addHover(LC.info_pageCountHover.getLocale("[totalEntries]", totalEntries));
|
|
|
|
rm.addText(pageCount > currentPage ? LC.info_nextPage.getLocale() : LC.info_nextPageOff.getLocale())
|
|
.addHover(pageCount > currentPage ? LC.info_nextPageHover.getLocale() : LC.info_firstPageHover.getLocale())
|
|
.addCommand(pageCount > currentPage ? cmd + " " + pagePrefix + nextPage : cmd + " " + pagePrefix + 1);
|
|
|
|
if (pageCount != 0)
|
|
rm.show(sender);
|
|
}
|
|
|
|
public static boolean hasLimitedItems() {
|
|
return hasLimitedItems;
|
|
}
|
|
}
|