mirror of
https://github.com/hyperdefined/ToolStats.git
synced 2025-12-05 22:31:45 +00:00
1389 lines
63 KiB
Java
1389 lines
63 KiB
Java
/*
|
|
* This file is part of ToolStats.
|
|
*
|
|
* ToolStats 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.
|
|
*
|
|
* ToolStats 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 ToolStats. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package lol.hyper.toolstats.tools;
|
|
|
|
import lol.hyper.toolstats.ToolStats;
|
|
import net.kyori.adventure.text.Component;
|
|
import net.kyori.adventure.text.event.ClickEvent;
|
|
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.event.inventory.PrepareAnvilEvent;
|
|
import org.bukkit.inventory.ItemStack;
|
|
import org.bukkit.inventory.meta.ItemMeta;
|
|
import org.bukkit.persistence.PersistentDataContainer;
|
|
import org.bukkit.persistence.PersistentDataType;
|
|
|
|
import java.util.*;
|
|
|
|
public class ItemLore {
|
|
|
|
private final ToolStats toolStats;
|
|
|
|
public ItemLore(ToolStats toolStats) {
|
|
this.toolStats = toolStats;
|
|
}
|
|
|
|
/**
|
|
* Updates existing lore on an item.
|
|
*
|
|
* @param itemMeta The item's meta.
|
|
* @param oldLine The old line to replace.
|
|
* @param newLine The new line to replace oldLine.
|
|
* @return The item's new lore.
|
|
*/
|
|
public List<Component> updateItemLore(ItemMeta itemMeta, Component oldLine, Component newLine) {
|
|
List<Component> itemLore;
|
|
if (itemMeta.hasLore()) {
|
|
itemLore = itemMeta.lore();
|
|
// keep track of line index
|
|
// this doesn't mess the lore of existing items
|
|
for (int x = 0; x < itemLore.size(); x++) {
|
|
String line = PlainTextComponentSerializer.plainText().serialize(itemLore.get(x));
|
|
// find the old line to update, keeping index
|
|
// this means we update this line only!
|
|
if (line.equals(PlainTextComponentSerializer.plainText().serialize(oldLine))) {
|
|
itemLore.set(x, newLine);
|
|
return itemLore;
|
|
}
|
|
}
|
|
// if the item has lore, but we didn't find the line
|
|
itemLore.add(newLine);
|
|
} else {
|
|
// if the item has no lore, create a new list and add the line
|
|
itemLore = new ArrayList<>();
|
|
itemLore.add(newLine);
|
|
}
|
|
return itemLore;
|
|
}
|
|
|
|
/**
|
|
* Add lore to a given item.
|
|
*
|
|
* @param itemMeta The item's meta.
|
|
* @param newLine The new line to add to the lore.
|
|
* @return The new item's lore.
|
|
*/
|
|
public List<Component> addItemLore(ItemMeta itemMeta, Component newLine) {
|
|
List<Component> itemLore;
|
|
if (itemMeta.hasLore()) {
|
|
itemLore = itemMeta.lore();
|
|
itemLore.add(newLine);
|
|
} else {
|
|
itemLore = new ArrayList<>();
|
|
itemLore.add(newLine);
|
|
}
|
|
return itemLore;
|
|
}
|
|
|
|
/**
|
|
* Remove a given lore from an item.
|
|
*
|
|
* @param inputLore The item's lore.
|
|
* @param toRemove The line to remove.
|
|
* @return The lore with the line removed.
|
|
*/
|
|
public List<Component> removeLore(List<Component> inputLore, Component toRemove) {
|
|
if (inputLore == null) {
|
|
return Collections.emptyList();
|
|
}
|
|
List<Component> newLore = new ArrayList<>(inputLore);
|
|
newLore.removeIf(line -> PlainTextComponentSerializer.plainText().serialize(line).equals(PlainTextComponentSerializer.plainText().serialize(toRemove)));
|
|
return newLore;
|
|
}
|
|
|
|
/**
|
|
* Add x to the crops mined stat.
|
|
*
|
|
* @param playerTool The tool to update.
|
|
*/
|
|
public ItemMeta updateCropsMined(ItemStack playerTool, int add) {
|
|
ItemStack clone = playerTool.clone();
|
|
ItemMeta meta = clone.getItemMeta();
|
|
if (meta == null) {
|
|
toolStats.logger.warning(clone + " does NOT have any meta! Unable to update stats.");
|
|
return null;
|
|
}
|
|
// read the current stats from the item
|
|
// if they don't exist, then start from 0
|
|
PersistentDataContainer container = meta.getPersistentDataContainer();
|
|
|
|
// if it's disabled, don't update the stats
|
|
// check to see if the item has the stats, remove them if it does
|
|
if (!toolStats.config.getBoolean("enabled.crops-harvested")) {
|
|
if (container.has(toolStats.cropsHarvested)) {
|
|
Integer cropsMined = container.get(toolStats.cropsHarvested, PersistentDataType.INTEGER);
|
|
if (cropsMined == null) {
|
|
return null;
|
|
}
|
|
container.remove(toolStats.cropsHarvested);
|
|
// remove the applied token if this stat is disabled
|
|
if (container.has(toolStats.tokenApplied)) {
|
|
String appliedTokens = container.get(toolStats.tokenApplied, PersistentDataType.STRING);
|
|
if (appliedTokens != null) {
|
|
// remove the token from the list
|
|
// if the list is empty, remove the PDC
|
|
// otherwise set the PDC back with the new list
|
|
List<String> newTokens = toolStats.itemChecker.removeToken(appliedTokens, "crops-mined");
|
|
if (!newTokens.isEmpty()) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, String.join(",", newTokens));
|
|
} else {
|
|
container.remove(toolStats.tokenApplied);
|
|
}
|
|
}
|
|
}
|
|
if (meta.hasLore()) {
|
|
String oldCropsMinedFormatted = toolStats.numberFormat.formatInt(cropsMined);
|
|
Component lineToRemove = toolStats.configTools.formatLore("crops-harvested", "{crops}", oldCropsMinedFormatted);
|
|
List<Component> newLore = removeLore(meta.lore(), lineToRemove);
|
|
meta.lore(newLore);
|
|
}
|
|
return meta;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// check for tokens
|
|
boolean validToken = toolStats.itemChecker.checkTokens(container, "crops-mined");
|
|
// check for tokens
|
|
if (toolStats.config.getBoolean("tokens.enabled")) {
|
|
// if the item has stats but no token, add the token
|
|
if (container.has(toolStats.cropsHarvested) && !validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
|
|
// the item does not have a valid token
|
|
if (!validToken) {
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
}
|
|
|
|
Integer cropsMined = 0;
|
|
if (container.has(toolStats.cropsHarvested, PersistentDataType.INTEGER)) {
|
|
cropsMined = container.get(toolStats.cropsHarvested, PersistentDataType.INTEGER);
|
|
}
|
|
|
|
if (cropsMined == null) {
|
|
cropsMined = 0;
|
|
toolStats.logger.warning(clone + " does not have valid crops-mined set! Resting to zero. This should NEVER happen.");
|
|
}
|
|
|
|
container.set(toolStats.cropsHarvested, PersistentDataType.INTEGER, cropsMined + add);
|
|
String oldCropsMinedFormatted = toolStats.numberFormat.formatInt(cropsMined);
|
|
String newCropsMinedFormatted = toolStats.numberFormat.formatInt(cropsMined + add);
|
|
Component oldLine = toolStats.configTools.formatLore("crops-harvested", "{crops}", oldCropsMinedFormatted);
|
|
Component newLine = toolStats.configTools.formatLore("crops-harvested", "{crops}", newCropsMinedFormatted);
|
|
if (oldLine == null || newLine == null) {
|
|
return null;
|
|
}
|
|
List<Component> newLore = updateItemLore(meta, oldLine, newLine);
|
|
meta.lore(newLore);
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* Add x to the blocks mined stat.
|
|
*
|
|
* @param playerTool The tool to update.
|
|
*/
|
|
public ItemMeta updateBlocksMined(ItemStack playerTool, int add) {
|
|
ItemStack clone = playerTool.clone();
|
|
ItemMeta meta = clone.getItemMeta();
|
|
if (meta == null) {
|
|
toolStats.logger.warning(clone + " does NOT have any meta! Unable to update stats.");
|
|
return null;
|
|
}
|
|
|
|
PersistentDataContainer container = meta.getPersistentDataContainer();
|
|
|
|
// if it's disabled, don't update the stats
|
|
// check to see if the item has the stats, remove them if it does
|
|
if (!toolStats.configTools.checkConfig(clone.getType(), "blocks-mined")) {
|
|
if (container.has(toolStats.blocksMined)) {
|
|
Integer blocksMined = container.get(toolStats.blocksMined, PersistentDataType.INTEGER);
|
|
if (blocksMined == null) {
|
|
return null;
|
|
}
|
|
container.remove(toolStats.blocksMined);
|
|
// remove the applied token if this stat is disabled
|
|
if (container.has(toolStats.tokenApplied)) {
|
|
String appliedTokens = container.get(toolStats.tokenApplied, PersistentDataType.STRING);
|
|
if (appliedTokens != null) {
|
|
// remove the token from the list
|
|
// if the list is empty, remove the PDC
|
|
// otherwise set the PDC back with the new list
|
|
List<String> newTokens = toolStats.itemChecker.removeToken(appliedTokens, "blocks-mined");
|
|
if (!newTokens.isEmpty()) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, String.join(",", newTokens));
|
|
} else {
|
|
container.remove(toolStats.tokenApplied);
|
|
}
|
|
}
|
|
}
|
|
if (meta.hasLore()) {
|
|
String oldBlocksMinedFormatted = toolStats.numberFormat.formatInt(blocksMined);
|
|
Component lineToRemove = toolStats.configTools.formatLore("blocks-mined", "{blocks}", oldBlocksMinedFormatted);
|
|
List<Component> newLore = removeLore(meta.lore(), lineToRemove);
|
|
meta.lore(newLore);
|
|
}
|
|
return meta;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
boolean validToken = toolStats.itemChecker.checkTokens(container, "blocks-mined");
|
|
// check for tokens
|
|
if (toolStats.config.getBoolean("tokens.enabled")) {
|
|
// if the item has stats but no token, add the token
|
|
if (container.has(toolStats.blocksMined) && !validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
|
|
// the item does not have a valid token
|
|
if (!validToken) {
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
}
|
|
|
|
// read the current stats from the item
|
|
// if they don't exist, then start from 0
|
|
Integer blocksMined = 0;
|
|
if (container.has(toolStats.blocksMined, PersistentDataType.INTEGER)) {
|
|
blocksMined = container.get(toolStats.blocksMined, PersistentDataType.INTEGER);
|
|
}
|
|
|
|
if (blocksMined == null) {
|
|
blocksMined = 0;
|
|
toolStats.logger.warning(clone + " does not have valid generic-mined set! Resting to zero. This should NEVER happen.");
|
|
}
|
|
|
|
container.set(toolStats.blocksMined, PersistentDataType.INTEGER, blocksMined + add);
|
|
String oldBlocksMinedFormatted = toolStats.numberFormat.formatInt(blocksMined);
|
|
String newBlocksMinedFormatted = toolStats.numberFormat.formatInt(blocksMined + add);
|
|
Component oldLine = toolStats.configTools.formatLore("blocks-mined", "{blocks}", oldBlocksMinedFormatted);
|
|
Component newLine = toolStats.configTools.formatLore("blocks-mined", "{blocks}", newBlocksMinedFormatted);
|
|
if (oldLine == null || newLine == null) {
|
|
return null;
|
|
}
|
|
List<Component> newLore = updateItemLore(meta, oldLine, newLine);
|
|
meta.lore(newLore);
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* Add +1 to the player kills stat.
|
|
*
|
|
* @param playerWeapon The tool to update.
|
|
*/
|
|
public ItemMeta updatePlayerKills(ItemStack playerWeapon, int add) {
|
|
ItemStack clone = playerWeapon.clone();
|
|
ItemMeta meta = clone.getItemMeta();
|
|
if (meta == null) {
|
|
toolStats.logger.warning(clone + " does NOT have any meta! Unable to update stats.");
|
|
return null;
|
|
}
|
|
|
|
PersistentDataContainer container = meta.getPersistentDataContainer();
|
|
|
|
// if it's disabled, don't update the stats
|
|
// check to see if the item has the stats, remove them if it does
|
|
if (!toolStats.configTools.checkConfig(clone.getType(), "player-kills")) {
|
|
if (container.has(toolStats.playerKills)) {
|
|
Integer playerKills = container.get(toolStats.playerKills, PersistentDataType.INTEGER);
|
|
if (playerKills == null) {
|
|
return null;
|
|
}
|
|
container.remove(toolStats.playerKills);
|
|
// remove the applied token if this stat is disabled
|
|
if (container.has(toolStats.tokenApplied)) {
|
|
String appliedTokens = container.get(toolStats.tokenApplied, PersistentDataType.STRING);
|
|
if (appliedTokens != null) {
|
|
// remove the token from the list
|
|
// if the list is empty, remove the PDC
|
|
// otherwise set the PDC back with the new list
|
|
List<String> newTokens = toolStats.itemChecker.removeToken(appliedTokens, "player-kills");
|
|
if (!newTokens.isEmpty()) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, String.join(",", newTokens));
|
|
} else {
|
|
container.remove(toolStats.tokenApplied);
|
|
}
|
|
}
|
|
}
|
|
if (meta.hasLore()) {
|
|
String oldPlayerKillsFormatted = toolStats.numberFormat.formatInt(playerKills);
|
|
Component lineToRemove = toolStats.configTools.formatLore("player-kills", "{kills}", oldPlayerKillsFormatted);
|
|
List<Component> newLore = removeLore(meta.lore(), lineToRemove);
|
|
meta.lore(newLore);
|
|
}
|
|
return meta;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// check for tokens
|
|
boolean validToken = toolStats.itemChecker.checkTokens(container, "player-kills");
|
|
// check for tokens
|
|
if (toolStats.config.getBoolean("tokens.enabled")) {
|
|
// if the item has stats but no token, add the token
|
|
if (container.has(toolStats.playerKills) && !validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
|
|
// the item does not have a valid token
|
|
if (!validToken) {
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
}
|
|
|
|
Integer playerKills = 0;
|
|
if (container.has(toolStats.playerKills, PersistentDataType.INTEGER)) {
|
|
playerKills = container.get(toolStats.playerKills, PersistentDataType.INTEGER);
|
|
}
|
|
|
|
if (playerKills == null) {
|
|
playerKills = 0;
|
|
toolStats.logger.warning(clone + " does not have valid player-kills set! Resting to zero. This should NEVER happen.");
|
|
}
|
|
|
|
container.set(toolStats.playerKills, PersistentDataType.INTEGER, playerKills + add);
|
|
String oldPlayerKillsFormatted = toolStats.numberFormat.formatInt(playerKills);
|
|
String newPlayerKillsFormatted = toolStats.numberFormat.formatInt(playerKills + add);
|
|
Component oldLine = toolStats.configTools.formatLore("kills.player", "{kills}", oldPlayerKillsFormatted);
|
|
Component newLine = toolStats.configTools.formatLore("kills.player", "{kills}", newPlayerKillsFormatted);
|
|
if (oldLine == null || newLine == null) {
|
|
return null;
|
|
}
|
|
List<Component> newLore = updateItemLore(meta, oldLine, newLine);
|
|
meta.lore(newLore);
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* Add x to the mob kills stat.
|
|
*
|
|
* @param playerWeapon The tool to update.
|
|
*/
|
|
public ItemMeta updateMobKills(ItemStack playerWeapon, int add) {
|
|
ItemStack clone = playerWeapon.clone();
|
|
ItemMeta meta = clone.getItemMeta();
|
|
if (meta == null) {
|
|
toolStats.logger.warning(clone + " does NOT have any meta! Unable to update stats.");
|
|
return null;
|
|
}
|
|
|
|
PersistentDataContainer container = meta.getPersistentDataContainer();
|
|
|
|
// if it's disabled, don't update the stats
|
|
// check to see if the item has the stats, remove them if it does
|
|
if (!toolStats.configTools.checkConfig(clone.getType(), "mob-kills")) {
|
|
if (container.has(toolStats.mobKills)) {
|
|
Integer mobKills = container.get(toolStats.mobKills, PersistentDataType.INTEGER);
|
|
if (mobKills == null) {
|
|
return null;
|
|
}
|
|
container.remove(toolStats.mobKills);
|
|
// remove the applied token if this stat is disabled
|
|
if (container.has(toolStats.tokenApplied)) {
|
|
String appliedTokens = container.get(toolStats.tokenApplied, PersistentDataType.STRING);
|
|
if (appliedTokens != null) {
|
|
// remove the token from the list
|
|
// if the list is empty, remove the PDC
|
|
// otherwise set the PDC back with the new list
|
|
List<String> newTokens = toolStats.itemChecker.removeToken(appliedTokens, "mob-kills");
|
|
if (!newTokens.isEmpty()) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, String.join(",", newTokens));
|
|
} else {
|
|
container.remove(toolStats.tokenApplied);
|
|
}
|
|
}
|
|
}
|
|
if (meta.hasLore()) {
|
|
String oldMobKillsFormatted = toolStats.numberFormat.formatInt(mobKills);
|
|
Component lineToRemove = toolStats.configTools.formatLore("mob-kills", "{kills}", oldMobKillsFormatted);
|
|
List<Component> newLore = removeLore(meta.lore(), lineToRemove);
|
|
meta.lore(newLore);
|
|
}
|
|
return meta;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// check for tokens
|
|
boolean validToken = toolStats.itemChecker.checkTokens(container, "mob-kills");
|
|
// check for tokens
|
|
if (toolStats.config.getBoolean("tokens.enabled")) {
|
|
// if the item has stats but no token, add the token
|
|
if (container.has(toolStats.mobKills) && !validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
|
|
// the item does not have a valid token
|
|
if (!validToken) {
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
}
|
|
|
|
Integer mobKills = 0;
|
|
if (container.has(toolStats.mobKills, PersistentDataType.INTEGER)) {
|
|
mobKills = container.get(toolStats.mobKills, PersistentDataType.INTEGER);
|
|
}
|
|
|
|
if (mobKills == null) {
|
|
mobKills = 0;
|
|
toolStats.logger.warning(clone + " does not have valid mob-kills set! Resting to zero. This should NEVER happen.");
|
|
}
|
|
|
|
container.set(toolStats.mobKills, PersistentDataType.INTEGER, mobKills + add);
|
|
String oldMobKillsFormatted = toolStats.numberFormat.formatInt(mobKills);
|
|
String newMobKillsFormatted = toolStats.numberFormat.formatInt(mobKills + add);
|
|
Component oldLine = toolStats.configTools.formatLore("kills.mob", "{kills}", oldMobKillsFormatted);
|
|
Component newLine = toolStats.configTools.formatLore("kills.mob", "{kills}", newMobKillsFormatted);
|
|
if (oldLine == null || newLine == null) {
|
|
return null;
|
|
}
|
|
List<Component> newLore = updateItemLore(meta, oldLine, newLine);
|
|
meta.lore(newLore);
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* Add damage to an armor piece.
|
|
*
|
|
* @param armorPiece The armor to update.
|
|
* @param damage The amount of damage to apply.
|
|
* @param bypass Bypass the negative damage check.
|
|
*/
|
|
public ItemMeta updateArmorDamage(ItemStack armorPiece, double damage, boolean bypass) {
|
|
// ignore if the damage is zero or negative
|
|
if (damage < 0) {
|
|
if (!bypass) {
|
|
return null;
|
|
}
|
|
}
|
|
ItemStack clone = armorPiece.clone();
|
|
ItemMeta meta = clone.getItemMeta();
|
|
if (meta == null) {
|
|
toolStats.logger.warning(clone + " does NOT have any meta! Unable to update stats.");
|
|
return null;
|
|
}
|
|
|
|
PersistentDataContainer container = meta.getPersistentDataContainer();
|
|
|
|
// if it's disabled, don't update the stats
|
|
// check to see if the item has the stats, remove them if it does
|
|
if (!toolStats.config.getBoolean("enabled.armor-damage")) {
|
|
if (container.has(toolStats.armorDamage)) {
|
|
Double armorDamage = container.get(toolStats.armorDamage, PersistentDataType.DOUBLE);
|
|
if (armorDamage == null) {
|
|
return null;
|
|
}
|
|
container.remove(toolStats.armorDamage);
|
|
// remove the applied token if this stat is disabled
|
|
if (container.has(toolStats.tokenApplied)) {
|
|
String appliedTokens = container.get(toolStats.tokenApplied, PersistentDataType.STRING);
|
|
if (appliedTokens != null) {
|
|
// remove the token from the list
|
|
// if the list is empty, remove the PDC
|
|
// otherwise set the PDC back with the new list
|
|
List<String> newTokens = toolStats.itemChecker.removeToken(appliedTokens, "damage-taken");
|
|
if (!newTokens.isEmpty()) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, String.join(",", newTokens));
|
|
} else {
|
|
container.remove(toolStats.tokenApplied);
|
|
}
|
|
}
|
|
}
|
|
if (meta.hasLore()) {
|
|
String oldDamageTakenFormatted = toolStats.numberFormat.formatDouble(armorDamage);
|
|
Component lineToRemove = toolStats.configTools.formatLore("damage-taken", "{damage}", oldDamageTakenFormatted);
|
|
List<Component> newLore = removeLore(meta.lore(), lineToRemove);
|
|
meta.lore(newLore);
|
|
}
|
|
return meta;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// check for tokens
|
|
boolean validToken = toolStats.itemChecker.checkTokens(container, "damage-taken");
|
|
// check for tokens
|
|
if (toolStats.config.getBoolean("tokens.enabled")) {
|
|
// if the item has stats but no token, add the token
|
|
if (container.has(toolStats.armorDamage) && !validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
|
|
// the item does not have a valid token
|
|
if (!validToken) {
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
}
|
|
|
|
Double damageTaken = 0.0;
|
|
if (container.has(toolStats.armorDamage, PersistentDataType.DOUBLE)) {
|
|
damageTaken = container.get(toolStats.armorDamage, PersistentDataType.DOUBLE);
|
|
}
|
|
|
|
if (damageTaken == null) {
|
|
damageTaken = 0.0;
|
|
toolStats.logger.warning(clone + " does not have valid damage-taken set! Resting to zero. This should NEVER happen.");
|
|
}
|
|
|
|
container.set(toolStats.armorDamage, PersistentDataType.DOUBLE, damageTaken + damage);
|
|
String oldDamageFormatted = toolStats.numberFormat.formatDouble(damageTaken);
|
|
String newDamageFormatted = toolStats.numberFormat.formatDouble(damageTaken + damage);
|
|
Component oldLine = toolStats.configTools.formatLore("damage-taken", "{damage}", oldDamageFormatted);
|
|
Component newLine = toolStats.configTools.formatLore("damage-taken", "{damage}", newDamageFormatted);
|
|
if (oldLine == null || newLine == null) {
|
|
return null;
|
|
}
|
|
List<Component> newLore = updateItemLore(meta, oldLine, newLine);
|
|
meta.lore(newLore);
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* Add damage to a weapon.
|
|
*
|
|
* @param weapon The weapon to update.
|
|
* @param damage The amount of damage to apply.
|
|
* @param bypass Bypass the negative damage check.
|
|
*/
|
|
public ItemMeta updateWeaponDamage(ItemStack weapon, double damage, boolean bypass) {
|
|
// ignore if the damage is zero or negative
|
|
if (damage < 0) {
|
|
if (!bypass) {
|
|
return null;
|
|
}
|
|
}
|
|
ItemStack clone = weapon.clone();
|
|
ItemMeta meta = clone.getItemMeta();
|
|
if (meta == null) {
|
|
toolStats.logger.warning(clone + " does NOT have any meta! Unable to update stats.");
|
|
return null;
|
|
}
|
|
|
|
PersistentDataContainer container = meta.getPersistentDataContainer();
|
|
|
|
// if it's disabled, don't update the stats
|
|
// check to see if the item has the stats, remove them if it does
|
|
if (!toolStats.configTools.checkConfig(clone.getType(), "damage-done")) {
|
|
if (container.has(toolStats.damageDone)) {
|
|
Double damageDone = container.get(toolStats.damageDone, PersistentDataType.DOUBLE);
|
|
if (damageDone == null) {
|
|
return null;
|
|
}
|
|
container.remove(toolStats.damageDone);
|
|
// remove the applied token if this stat is disabled
|
|
if (container.has(toolStats.tokenApplied)) {
|
|
String appliedTokens = container.get(toolStats.tokenApplied, PersistentDataType.STRING);
|
|
if (appliedTokens != null) {
|
|
// remove the token from the list
|
|
// if the list is empty, remove the PDC
|
|
// otherwise set the PDC back with the new list
|
|
List<String> newTokens = toolStats.itemChecker.removeToken(appliedTokens, "damage-done");
|
|
if (!newTokens.isEmpty()) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, String.join(",", newTokens));
|
|
} else {
|
|
container.remove(toolStats.tokenApplied);
|
|
}
|
|
}
|
|
}
|
|
if (meta.hasLore()) {
|
|
String oldDamageDoneFormatted = toolStats.numberFormat.formatDouble(damageDone);
|
|
Component lineToRemove = toolStats.configTools.formatLore("damage-done", "{damage}", oldDamageDoneFormatted);
|
|
List<Component> newLore = removeLore(meta.lore(), lineToRemove);
|
|
meta.lore(newLore);
|
|
}
|
|
return meta;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// check for tokens
|
|
boolean validToken = toolStats.itemChecker.checkTokens(container, "damage-done");
|
|
// check for tokens
|
|
if (toolStats.config.getBoolean("tokens.enabled")) {
|
|
// if the item has stats but no token, add the token
|
|
if (container.has(toolStats.damageDone) && !validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
|
|
// the item does not have a valid token
|
|
if (!validToken) {
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
}
|
|
|
|
Double damageDone = 0.0;
|
|
if (container.has(toolStats.damageDone, PersistentDataType.DOUBLE)) {
|
|
damageDone = container.get(toolStats.damageDone, PersistentDataType.DOUBLE);
|
|
}
|
|
|
|
if (damageDone == null) {
|
|
damageDone = 0.0;
|
|
toolStats.logger.warning(clone + " does not have valid damage-done set! Resting to zero. This should NEVER happen.");
|
|
}
|
|
|
|
container.set(toolStats.damageDone, PersistentDataType.DOUBLE, damageDone + damage);
|
|
String oldDamageFormatted = toolStats.numberFormat.formatDouble(damageDone);
|
|
String newDamageFormatted = toolStats.numberFormat.formatDouble(damageDone + damage);
|
|
Component oldLine = toolStats.configTools.formatLore("damage-done", "{damage}", oldDamageFormatted);
|
|
Component newLine = toolStats.configTools.formatLore("damage-done", "{damage}", newDamageFormatted);
|
|
if (oldLine == null || newLine == null) {
|
|
return null;
|
|
}
|
|
List<Component> newLore = updateItemLore(meta, oldLine, newLine);
|
|
meta.lore(newLore);
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* Add flight time to an elytra.
|
|
*
|
|
* @param elytra The player's elytra.
|
|
*/
|
|
public ItemMeta updateFlightTime(ItemStack elytra, long duration) {
|
|
ItemStack clone = elytra.clone();
|
|
ItemMeta meta = clone.getItemMeta();
|
|
if (meta == null) {
|
|
toolStats.logger.warning(clone + " does NOT have any meta! Unable to update stats.");
|
|
return null;
|
|
}
|
|
|
|
PersistentDataContainer container = meta.getPersistentDataContainer();
|
|
|
|
// if it's disabled, don't update the stats
|
|
// check to see if the item has the stats, remove them if it does
|
|
if (!toolStats.config.getBoolean("enabled.flight-time")) {
|
|
if (container.has(toolStats.flightTime)) {
|
|
Long flightTime = container.get(toolStats.flightTime, PersistentDataType.LONG);
|
|
if (flightTime == null) {
|
|
return null;
|
|
}
|
|
container.remove(toolStats.flightTime);
|
|
// remove the applied token if this stat is disabled
|
|
if (container.has(toolStats.tokenApplied)) {
|
|
String appliedTokens = container.get(toolStats.tokenApplied, PersistentDataType.STRING);
|
|
if (appliedTokens != null) {
|
|
// remove the token from the list
|
|
// if the list is empty, remove the PDC
|
|
// otherwise set the PDC back with the new list
|
|
List<String> newTokens = toolStats.itemChecker.removeToken(appliedTokens, "flight-time");
|
|
if (!newTokens.isEmpty()) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, String.join(",", newTokens));
|
|
} else {
|
|
container.remove(toolStats.tokenApplied);
|
|
}
|
|
}
|
|
}
|
|
if (meta.hasLore()) {
|
|
// if the old format is in the config, check to see if the old format is on the elytra
|
|
if (toolStats.config.getString("messages.flight-time-old") != null) {
|
|
String oldFormatFormatted = toolStats.numberFormat.formatDouble((double) flightTime / 1000);
|
|
Component oldFormat = toolStats.configTools.formatLore("flight-time-old", "{time}", oldFormatFormatted);
|
|
List<Component> newLore = removeLore(meta.lore(), oldFormat);
|
|
meta.lore(newLore);
|
|
}
|
|
|
|
Map<String, String> oldFlightTimeFormatted = toolStats.numberFormat.formatTime(flightTime);
|
|
Component lineToRemove = toolStats.configTools.formatLoreMultiplePlaceholders("flight-time", oldFlightTimeFormatted);
|
|
List<Component> newLore = removeLore(meta.lore(), lineToRemove);
|
|
meta.lore(newLore);
|
|
}
|
|
return meta;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// check for tokens
|
|
boolean validToken = toolStats.itemChecker.checkTokens(container, "flight-time");
|
|
// check for tokens
|
|
if (toolStats.config.getBoolean("tokens.enabled")) {
|
|
// if the item has stats but no token, add the token
|
|
if (container.has(toolStats.flightTime) && !validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
|
|
// the item does not have a valid token
|
|
if (!validToken) {
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
}
|
|
|
|
// read the current stats from the item
|
|
// if they don't exist, then start from 0
|
|
Long flightTime = 0L;
|
|
if (container.has(toolStats.flightTime, PersistentDataType.LONG)) {
|
|
flightTime = container.get(toolStats.flightTime, PersistentDataType.LONG);
|
|
}
|
|
|
|
if (flightTime == null) {
|
|
flightTime = 0L;
|
|
toolStats.logger.warning(flightTime + " does not have valid flight-time set! Resting to zero. This should NEVER happen.");
|
|
}
|
|
|
|
container.set(toolStats.flightTime, PersistentDataType.LONG, flightTime + duration);
|
|
Map<String, String> oldFlightFormatted = toolStats.numberFormat.formatTime(flightTime);
|
|
Map<String, String> newFlightFormatted = toolStats.numberFormat.formatTime(flightTime + duration);
|
|
// if the old format is in the config, check to see if the old format is on the elytra
|
|
if (toolStats.config.getString("messages.flight-time-old") != null) {
|
|
if (meta.hasLore()) {
|
|
String oldFormatFormatted = toolStats.numberFormat.formatDouble((double) flightTime / 1000);
|
|
Component oldFormat = toolStats.configTools.formatLore("flight-time-old", "{time}", oldFormatFormatted);
|
|
meta.lore(removeLore(meta.lore(), oldFormat));
|
|
}
|
|
}
|
|
Component oldLine = toolStats.configTools.formatLoreMultiplePlaceholders("flight-time", oldFlightFormatted);
|
|
Component newLine = toolStats.configTools.formatLoreMultiplePlaceholders("flight-time", newFlightFormatted);
|
|
if (oldLine == null || newLine == null) {
|
|
return null;
|
|
}
|
|
List<Component> newLore = updateItemLore(meta, oldLine, newLine);
|
|
meta.lore(newLore);
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* Add x to sheep sheared stat.
|
|
*
|
|
* @param shears The shears.
|
|
*/
|
|
public ItemMeta updateSheepSheared(ItemStack shears, int add) {
|
|
ItemStack clone = shears.clone();
|
|
ItemMeta meta = clone.getItemMeta();
|
|
if (meta == null) {
|
|
toolStats.logger.warning(clone + " does NOT have any meta! Unable to update stats.");
|
|
return null;
|
|
}
|
|
|
|
PersistentDataContainer container = meta.getPersistentDataContainer();
|
|
|
|
// if it's disabled, don't update the stats
|
|
// check to see if the item has the stats, remove them if it does
|
|
if (!toolStats.config.getBoolean("enabled.sheep-sheared")) {
|
|
if (container.has(toolStats.sheepSheared)) {
|
|
Integer sheepSheared = container.get(toolStats.sheepSheared, PersistentDataType.INTEGER);
|
|
if (sheepSheared == null) {
|
|
return null;
|
|
}
|
|
container.remove(toolStats.sheepSheared);
|
|
// remove the applied token if this stat is disabled
|
|
if (container.has(toolStats.tokenApplied)) {
|
|
String appliedTokens = container.get(toolStats.tokenApplied, PersistentDataType.STRING);
|
|
if (appliedTokens != null) {
|
|
// remove the token from the list
|
|
// if the list is empty, remove the PDC
|
|
// otherwise set the PDC back with the new list
|
|
List<String> newTokens = toolStats.itemChecker.removeToken(appliedTokens, "sheep-sheared");
|
|
if (!newTokens.isEmpty()) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, String.join(",", newTokens));
|
|
} else {
|
|
container.remove(toolStats.tokenApplied);
|
|
}
|
|
}
|
|
}
|
|
if (meta.hasLore()) {
|
|
String oldSheepShearedFormatted = toolStats.numberFormat.formatDouble(sheepSheared);
|
|
Component lineToRemove = toolStats.configTools.formatLore("sheep-sheared", "{sheep}", oldSheepShearedFormatted);
|
|
List<Component> newLore = removeLore(meta.lore(), lineToRemove);
|
|
meta.lore(newLore);
|
|
}
|
|
return meta;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// check for tokens
|
|
boolean validToken = toolStats.itemChecker.checkTokens(container, "sheep-sheared");
|
|
// check for tokens
|
|
if (toolStats.config.getBoolean("tokens.enabled")) {
|
|
// if the item has stats but no token, add the token
|
|
if (container.has(toolStats.sheepSheared) && !validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
|
|
// the item does not have a valid token
|
|
if (!validToken) {
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
}
|
|
|
|
Integer sheepSheared = 0;
|
|
if (container.has(toolStats.sheepSheared, PersistentDataType.INTEGER)) {
|
|
sheepSheared = container.get(toolStats.sheepSheared, PersistentDataType.INTEGER);
|
|
}
|
|
|
|
if (sheepSheared == null) {
|
|
sheepSheared = 0;
|
|
toolStats.logger.warning(clone + " does not have valid sheared set! Resting to zero. This should NEVER happen.");
|
|
}
|
|
|
|
container.set(toolStats.sheepSheared, PersistentDataType.INTEGER, sheepSheared + add);
|
|
String oldSheepFormatted = toolStats.numberFormat.formatInt(sheepSheared);
|
|
String newSheepFormatted = toolStats.numberFormat.formatInt(sheepSheared + add);
|
|
Component oldLine = toolStats.configTools.formatLore("sheep-sheared", "{sheep}", oldSheepFormatted);
|
|
Component newLine = toolStats.configTools.formatLore("sheep-sheared", "{sheep}", newSheepFormatted);
|
|
if (oldLine == null || newLine == null) {
|
|
return null;
|
|
}
|
|
List<Component> newLore = updateItemLore(meta, oldLine, newLine);
|
|
meta.lore(newLore);
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* Add x to arrows shot stat.
|
|
*
|
|
* @param bow The bow.
|
|
*/
|
|
public ItemMeta updateArrowsShot(ItemStack bow, int add) {
|
|
ItemStack clone = bow.clone();
|
|
ItemMeta meta = clone.getItemMeta();
|
|
if (meta == null) {
|
|
toolStats.logger.warning(clone + " does NOT have any meta! Unable to update stats.");
|
|
return null;
|
|
}
|
|
|
|
PersistentDataContainer container = meta.getPersistentDataContainer();
|
|
|
|
// if it's disabled, don't update the stats
|
|
// check to see if the item has the stats, remove them if it does
|
|
if (!toolStats.config.getBoolean("enabled.arrows-shot")) {
|
|
if (container.has(toolStats.arrowsShot)) {
|
|
Integer arrowsShot = container.get(toolStats.arrowsShot, PersistentDataType.INTEGER);
|
|
if (arrowsShot == null) {
|
|
return null;
|
|
}
|
|
container.remove(toolStats.arrowsShot);
|
|
// remove the applied token if this stat is disabled
|
|
if (container.has(toolStats.tokenApplied)) {
|
|
String appliedTokens = container.get(toolStats.tokenApplied, PersistentDataType.STRING);
|
|
if (appliedTokens != null) {
|
|
// remove the token from the list
|
|
// if the list is empty, remove the PDC
|
|
// otherwise set the PDC back with the new list
|
|
List<String> newTokens = toolStats.itemChecker.removeToken(appliedTokens, "arrows-shot");
|
|
if (!newTokens.isEmpty()) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, String.join(",", newTokens));
|
|
} else {
|
|
container.remove(toolStats.tokenApplied);
|
|
}
|
|
}
|
|
}
|
|
if (meta.hasLore()) {
|
|
String oldArrowsShotFormatted = toolStats.numberFormat.formatDouble(arrowsShot);
|
|
Component lineToRemove = toolStats.configTools.formatLore("arrows-shot", "{arrows}", oldArrowsShotFormatted);
|
|
List<Component> newLore = removeLore(meta.lore(), lineToRemove);
|
|
meta.lore(newLore);
|
|
}
|
|
return meta;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// check for tokens
|
|
boolean validToken = toolStats.itemChecker.checkTokens(container, "arrows-shot");
|
|
// check for tokens
|
|
if (toolStats.config.getBoolean("tokens.enabled")) {
|
|
// if the item has stats but no token, add the token
|
|
if (container.has(toolStats.arrowsShot) && !validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
|
|
// the item does not have a valid token
|
|
if (!validToken) {
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
}
|
|
|
|
// read the current stats from the item
|
|
// if they don't exist, then start from 0
|
|
Integer arrowsShot = 0;
|
|
if (container.has(toolStats.arrowsShot, PersistentDataType.INTEGER)) {
|
|
arrowsShot = container.get(toolStats.arrowsShot, PersistentDataType.INTEGER);
|
|
}
|
|
|
|
if (arrowsShot == null) {
|
|
arrowsShot = 0;
|
|
toolStats.logger.warning(arrowsShot + " does not have valid arrows-shot set! Resting to zero. This should NEVER happen.");
|
|
}
|
|
|
|
container.set(toolStats.arrowsShot, PersistentDataType.INTEGER, arrowsShot + add);
|
|
String oldArrowsFormatted = toolStats.numberFormat.formatInt(arrowsShot);
|
|
String newArrowsFormatted = toolStats.numberFormat.formatInt(arrowsShot + add);
|
|
Component oldLine = toolStats.configTools.formatLore("arrows-shot", "{arrows}", oldArrowsFormatted);
|
|
Component newLine = toolStats.configTools.formatLore("arrows-shot", "{arrows}", newArrowsFormatted);
|
|
if (oldLine == null || newLine == null) {
|
|
return null;
|
|
}
|
|
List<Component> newLore = updateItemLore(meta, oldLine, newLine);
|
|
meta.lore(newLore);
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* Add x to fish caught stat.
|
|
*
|
|
* @param fishingRod The fishing rod.
|
|
*/
|
|
public ItemMeta updateFishCaught(ItemStack fishingRod, int add) {
|
|
ItemStack clone = fishingRod.clone();
|
|
ItemMeta meta = clone.getItemMeta();
|
|
if (meta == null) {
|
|
toolStats.logger.warning(clone + " does NOT have any meta! Unable to update stats.");
|
|
return null;
|
|
}
|
|
|
|
PersistentDataContainer container = meta.getPersistentDataContainer();
|
|
|
|
// if it's disabled, don't update the stats
|
|
// check to see if the item has the stats, remove them if it does
|
|
if (!toolStats.config.getBoolean("enabled.fish-caught")) {
|
|
if (container.has(toolStats.fishCaught)) {
|
|
Integer fishCaught = container.get(toolStats.fishCaught, PersistentDataType.INTEGER);
|
|
if (fishCaught == null) {
|
|
return null;
|
|
}
|
|
container.remove(toolStats.fishCaught);
|
|
// remove the applied token if this stat is disabled
|
|
if (container.has(toolStats.tokenApplied)) {
|
|
String appliedTokens = container.get(toolStats.tokenApplied, PersistentDataType.STRING);
|
|
if (appliedTokens != null) {
|
|
// remove the token from the list
|
|
// if the list is empty, remove the PDC
|
|
// otherwise set the PDC back with the new list
|
|
List<String> newTokens = toolStats.itemChecker.removeToken(appliedTokens, "fish-caught");
|
|
if (!newTokens.isEmpty()) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, String.join(",", newTokens));
|
|
} else {
|
|
container.remove(toolStats.tokenApplied);
|
|
}
|
|
}
|
|
}
|
|
if (meta.hasLore()) {
|
|
String oldFishCaught = toolStats.numberFormat.formatDouble(fishCaught);
|
|
Component lineToRemove = toolStats.configTools.formatLore("fished.fish-caught", "{fish}", oldFishCaught);
|
|
List<Component> newLore = removeLore(meta.lore(), lineToRemove);
|
|
meta.lore(newLore);
|
|
}
|
|
return meta;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// check for tokens
|
|
boolean validToken = toolStats.itemChecker.checkTokens(container, "fish-caught");
|
|
// check for tokens
|
|
if (toolStats.config.getBoolean("tokens.enabled")) {
|
|
// if the item has stats but no token, add the token
|
|
if (container.has(toolStats.fishCaught) && !validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
|
|
// the item does not have a valid token
|
|
if (!validToken) {
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!validToken) {
|
|
String newTokens = toolStats.itemChecker.addTokensToExisting(clone);
|
|
if (newTokens != null) {
|
|
container.set(toolStats.tokenApplied, PersistentDataType.STRING, newTokens);
|
|
}
|
|
}
|
|
}
|
|
|
|
Integer fishCaught = 0;
|
|
if (container.has(toolStats.fishCaught, PersistentDataType.INTEGER)) {
|
|
fishCaught = container.get(toolStats.fishCaught, PersistentDataType.INTEGER);
|
|
}
|
|
|
|
if (fishCaught == null) {
|
|
fishCaught = 0;
|
|
toolStats.logger.warning(clone + " does not have valid fish-caught set! Resting to zero. This should NEVER happen.");
|
|
}
|
|
|
|
container.set(toolStats.fishCaught, PersistentDataType.INTEGER, fishCaught + add);
|
|
String oldFishFormatted = toolStats.numberFormat.formatInt(fishCaught);
|
|
String newFishFormatted = toolStats.numberFormat.formatInt(fishCaught + add);
|
|
Component oldLine = toolStats.configTools.formatLore("fished.fish-caught", "{fish}", oldFishFormatted);
|
|
Component newLine = toolStats.configTools.formatLore("fished.fish-caught", "{fish}", newFishFormatted);
|
|
if (oldLine == null || newLine == null) {
|
|
return null;
|
|
}
|
|
List<Component> newLore = updateItemLore(meta, oldLine, newLine);
|
|
meta.lore(newLore);
|
|
return meta;
|
|
}
|
|
|
|
/**
|
|
* Format the item owner lore.
|
|
*
|
|
* @param playerName The player's name who owns the items.
|
|
* @param origin The origin type.
|
|
* @param item The item.
|
|
* @return A component with the lore.
|
|
*/
|
|
public Component formatOwner(String playerName, int origin, ItemStack item) {
|
|
switch (origin) {
|
|
case 0: {
|
|
if (toolStats.configTools.checkConfig(item.getType(), "crafted-by")) {
|
|
return toolStats.configTools.formatLore("crafted.crafted-by", "{player}", playerName);
|
|
}
|
|
break;
|
|
}
|
|
case 2: {
|
|
if (toolStats.configTools.checkConfig(item.getType(), "looted-by")) {
|
|
return toolStats.configTools.formatLore("looted.looted-by", "{player}", playerName);
|
|
}
|
|
break;
|
|
}
|
|
case 3: {
|
|
if (toolStats.configTools.checkConfig(item.getType(), "traded-by")) {
|
|
return toolStats.configTools.formatLore("traded.traded-by", "{player}", playerName);
|
|
}
|
|
break;
|
|
}
|
|
case 4: {
|
|
if (toolStats.config.getBoolean("enabled.elytra-tag")) {
|
|
return toolStats.configTools.formatLore("looted.found-by", "{player}", playerName);
|
|
}
|
|
break;
|
|
}
|
|
case 5: {
|
|
if (toolStats.configTools.checkConfig(item.getType(), "fished-by")) {
|
|
return toolStats.configTools.formatLore("fished.caught-by", "{player}", playerName);
|
|
}
|
|
break;
|
|
}
|
|
case 6: {
|
|
if (toolStats.configTools.checkConfig(item.getType(), "spawned-in-by")) {
|
|
return toolStats.configTools.formatLore("spawned-in.spawned-by", "{player}", playerName);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Format the item creation time.
|
|
*
|
|
* @param creationDate When the item was created.
|
|
* @param origin The origin type.
|
|
* @param item The item.
|
|
* @return A component with the lore.
|
|
*/
|
|
public Component formatCreationTime(long creationDate, int origin, ItemStack item) {
|
|
String date = toolStats.numberFormat.formatDate(new Date(creationDate));
|
|
switch (origin) {
|
|
case 0: {
|
|
if (toolStats.configTools.checkConfig(item.getType(), "crafted-on")) {
|
|
return toolStats.configTools.formatLore("crafted.crafted-on", "{date}", date);
|
|
}
|
|
break;
|
|
}
|
|
case 1: {
|
|
if (toolStats.config.getBoolean("enabled.dropped-on")) {
|
|
return toolStats.configTools.formatLore("dropped-on", "{date}", date);
|
|
}
|
|
break;
|
|
}
|
|
case 2: {
|
|
if (toolStats.configTools.checkConfig(item.getType(), "looted-on")) {
|
|
return toolStats.configTools.formatLore("looted.looted-on", "{date}", date);
|
|
}
|
|
break;
|
|
}
|
|
case 3: {
|
|
if (toolStats.configTools.checkConfig(item.getType(), "traded-on")) {
|
|
return toolStats.configTools.formatLore("traded.traded-on", "{date}", date);
|
|
}
|
|
break;
|
|
}
|
|
case 4: {
|
|
if (toolStats.config.getBoolean("enabled.elytra-tag")) {
|
|
return toolStats.configTools.formatLore("looted.found-on", "{date}", date);
|
|
}
|
|
break;
|
|
}
|
|
case 5: {
|
|
if (toolStats.configTools.checkConfig(item.getType(), "fished-on")) {
|
|
return toolStats.configTools.formatLore("fished.caught-on", "{date}", date);
|
|
}
|
|
break;
|
|
}
|
|
case 6: {
|
|
if (toolStats.configTools.checkConfig(item.getType(), "spawned-in-on")) {
|
|
return toolStats.configTools.formatLore("spawned-in.spawned-on", "{date}", date);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Remove all stats, ownership, and creation time from an item.
|
|
*
|
|
* @param inputItem The input item to remove stats from.
|
|
* @param removeMeta Remove ownership and creation time?
|
|
*/
|
|
public ItemStack removeAll(ItemStack inputItem, boolean removeMeta) {
|
|
ItemStack finalItem = inputItem.clone();
|
|
ItemMeta meta = finalItem.getItemMeta();
|
|
PersistentDataContainer container = meta.getPersistentDataContainer();
|
|
|
|
// remove the applied tokens
|
|
if (container.has(toolStats.tokenApplied)) {
|
|
container.remove(toolStats.tokenApplied);
|
|
}
|
|
|
|
if (container.has(toolStats.playerKills)) {
|
|
Integer playerKills = container.get(toolStats.playerKills, PersistentDataType.INTEGER);
|
|
if (playerKills != null) {
|
|
container.remove(toolStats.playerKills);
|
|
|
|
String playerKillsFormatted = toolStats.numberFormat.formatInt(playerKills);
|
|
Component lineToRemove = toolStats.configTools.formatLore("kills.player", "{kills}", playerKillsFormatted);
|
|
meta.lore(removeLore(meta.lore(), lineToRemove));
|
|
finalItem.setItemMeta(meta);
|
|
}
|
|
}
|
|
if (container.has(toolStats.mobKills)) {
|
|
Integer mobKills = container.get(toolStats.mobKills, PersistentDataType.INTEGER);
|
|
if (mobKills != null) {
|
|
container.remove(toolStats.mobKills);
|
|
String mobKillsFormatted = toolStats.numberFormat.formatInt(mobKills);
|
|
Component lineToRemove = toolStats.configTools.formatLore("kills.mob", "{kills}", mobKillsFormatted);
|
|
meta.lore(removeLore(meta.lore(), lineToRemove));
|
|
finalItem.setItemMeta(meta);
|
|
}
|
|
}
|
|
if (container.has(toolStats.blocksMined)) {
|
|
Integer blocksMined = container.get(toolStats.blocksMined, PersistentDataType.INTEGER);
|
|
if (blocksMined != null) {
|
|
container.remove(toolStats.blocksMined);
|
|
String blocksMinedFormatted = toolStats.numberFormat.formatInt(blocksMined);
|
|
Component lineToRemove = toolStats.configTools.formatLore("blocks-mined", "{blocks}", blocksMinedFormatted);
|
|
meta.lore(removeLore(meta.lore(), lineToRemove));
|
|
finalItem.setItemMeta(meta);
|
|
}
|
|
}
|
|
if (container.has(toolStats.cropsHarvested)) {
|
|
Integer cropsHarvested = container.get(toolStats.playerKills, PersistentDataType.INTEGER);
|
|
if (cropsHarvested != null) {
|
|
container.remove(toolStats.cropsHarvested);
|
|
String cropsHarvestedFormatted = toolStats.numberFormat.formatInt(cropsHarvested);
|
|
Component lineToRemove = toolStats.configTools.formatLore("crops-harvested", "{crops}", cropsHarvestedFormatted);
|
|
meta.lore(removeLore(meta.lore(), lineToRemove));
|
|
finalItem.setItemMeta(meta);
|
|
}
|
|
}
|
|
if (container.has(toolStats.fishCaught)) {
|
|
Integer fishCaught = container.get(toolStats.fishCaught, PersistentDataType.INTEGER);
|
|
if (fishCaught != null) {
|
|
container.remove(toolStats.fishCaught);
|
|
String fishCaughtFormatted = toolStats.numberFormat.formatInt(fishCaught);
|
|
Component lineToRemove = toolStats.configTools.formatLore("fished.fish-caught", "{fish}", fishCaughtFormatted);
|
|
meta.lore(removeLore(meta.lore(), lineToRemove));
|
|
finalItem.setItemMeta(meta);
|
|
}
|
|
}
|
|
if (container.has(toolStats.sheepSheared)) {
|
|
Integer sheepSheared = container.get(toolStats.sheepSheared, PersistentDataType.INTEGER);
|
|
if (sheepSheared != null) {
|
|
container.remove(toolStats.sheepSheared);
|
|
String sheepShearedFormatted = toolStats.numberFormat.formatInt(sheepSheared);
|
|
Component lineToRemove = toolStats.configTools.formatLore("sheep.sheared", "{sheep}", sheepShearedFormatted);
|
|
meta.lore(removeLore(meta.lore(), lineToRemove));
|
|
finalItem.setItemMeta(meta);
|
|
}
|
|
}
|
|
if (container.has(toolStats.armorDamage)) {
|
|
Double armorDamage = container.get(toolStats.armorDamage, PersistentDataType.DOUBLE);
|
|
if (armorDamage != null) {
|
|
container.remove(toolStats.armorDamage);
|
|
String armorDamageFormatted = toolStats.numberFormat.formatDouble(armorDamage);
|
|
Component lineToRemove = toolStats.configTools.formatLore("damage-taken", "{damage}", armorDamageFormatted);
|
|
meta.lore(removeLore(meta.lore(), lineToRemove));
|
|
finalItem.setItemMeta(meta);
|
|
}
|
|
}
|
|
if (container.has(toolStats.damageDone)) {
|
|
Double damageDone = container.get(toolStats.damageDone, PersistentDataType.DOUBLE);
|
|
if (damageDone != null) {
|
|
container.remove(toolStats.damageDone);
|
|
String damageDoneFormatted = toolStats.numberFormat.formatDouble(damageDone);
|
|
Component lineToRemove = toolStats.configTools.formatLore("damage-done", "{damage}", damageDoneFormatted);
|
|
meta.lore(removeLore(meta.lore(), lineToRemove));
|
|
finalItem.setItemMeta(meta);
|
|
}
|
|
}
|
|
if (container.has(toolStats.arrowsShot)) {
|
|
Integer arrowsShot = container.get(toolStats.arrowsShot, PersistentDataType.INTEGER);
|
|
if (arrowsShot != null) {
|
|
container.remove(toolStats.arrowsShot);
|
|
|
|
String arrowsShotFormatted = toolStats.numberFormat.formatInt(arrowsShot);
|
|
Component lineToRemove = toolStats.configTools.formatLore("arrows-shot", "{arrows}", arrowsShotFormatted);
|
|
meta.lore(removeLore(meta.lore(), lineToRemove));
|
|
finalItem.setItemMeta(meta);
|
|
}
|
|
}
|
|
if (container.has(toolStats.flightTime)) {
|
|
Long flightTime = container.get(toolStats.flightTime, PersistentDataType.LONG);
|
|
if (flightTime != null) {
|
|
container.remove(toolStats.flightTime);
|
|
Map<String, String> flightTimeFormatted = toolStats.numberFormat.formatTime(flightTime);
|
|
Component lineToRemove = toolStats.configTools.formatLoreMultiplePlaceholders("flight-time", flightTimeFormatted);
|
|
meta.lore(removeLore(meta.lore(), lineToRemove));
|
|
finalItem.setItemMeta(meta);
|
|
}
|
|
}
|
|
if (removeMeta) {
|
|
Integer origin = null;
|
|
if (container.has(toolStats.originType)) {
|
|
origin = container.get(toolStats.originType, PersistentDataType.INTEGER);
|
|
}
|
|
|
|
if (container.has(toolStats.timeCreated)) {
|
|
Long timeCreated = container.get(toolStats.timeCreated, PersistentDataType.LONG);
|
|
if (timeCreated != null && origin != null) {
|
|
container.remove(toolStats.timeCreated);
|
|
Component timeCreatedLore = formatCreationTime(timeCreated, origin, finalItem);
|
|
meta.lore(removeLore(meta.lore(), timeCreatedLore));
|
|
}
|
|
}
|
|
if (container.has(toolStats.itemOwner)) {
|
|
UUID owner = container.get(toolStats.itemOwner, new UUIDDataType());
|
|
if (owner != null && origin != null) {
|
|
container.remove(toolStats.itemOwner);
|
|
String ownerName = Bukkit.getOfflinePlayer(owner).getName();
|
|
if (ownerName != null) {
|
|
Component ownerLore = formatOwner(ownerName, origin, finalItem);
|
|
meta.lore(removeLore(meta.lore(), ownerLore));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (origin != null) {
|
|
container.remove(toolStats.originType);
|
|
}
|
|
|
|
finalItem.setItemMeta(meta);
|
|
}
|
|
|
|
return finalItem;
|
|
}
|
|
}
|