EpicKnarvik97/Blacksmith
EpicKnarvik97/Blacksmith
1
0
Fork 0
Code Issues Pull Requests Projects Releases 8 Wiki Activity

Implements some necessary code for the scrapper
All checks were successful
EpicKnarvik97/Blacksmith/pipeline/head This commit looks good
Details

Browse Source 
Implements ignored salvage
Implements salvage-able items
Adds some TODOs
Implements salvage fail chance
Moves several methods to ItemHelper
Adds option for allowing extended salvage
This commit is contained in:
Kristian Knarvik 2023-12-30 13:56:33 +01:00
parent 6872dadca8
commit dfae68050e
13 changed files with 482 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/main/java/net/knarcraft/blacksmith/command/blacksmith/BlackSmithConfigCommand.java
View File

@ -19,6 +19,8 @@ import org.bukkit.enchantments.Enchantment;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import java.util.List;
/** /**
* The command used for changing global blacksmith configuration options * The command used for changing global blacksmith configuration options
*/ */
@ -213,12 +215,8 @@ public class BlackSmithConfigCommand implements CommandExecutor {
private void updateAllMatchedPrices(@NotNull GlobalBlacksmithSettings settings, private void updateAllMatchedPrices(@NotNull GlobalBlacksmithSettings settings,
@NotNull BlacksmithSetting blacksmithSetting, @NotNull BlacksmithSetting blacksmithSetting,
@NotNull String materialName, double newPrice) { @NotNull String materialName, double newPrice) {
String search = InputParsingHelper.regExIfy(materialName); List<Material> materials = ItemHelper.getWildcardMatch(materialName);
for (Material material : ItemHelper.getAllReforgeAbleMaterials()) { for (Material material : materials) {
if (!material.name().matches(search)) {
continue;
}
if (blacksmithSetting == BlacksmithSetting.BASE_PRICE) { if (blacksmithSetting == BlacksmithSetting.BASE_PRICE) {
settings.setBasePrice(material, newPrice); settings.setBasePrice(material, newPrice);
} else { } else {

77
src/main/java/net/knarcraft/blacksmith/config/blacksmith/BlacksmithNPCSettings.java
View File

@ -3,21 +3,17 @@ package net.knarcraft.blacksmith.config.blacksmith;
import net.citizensnpcs.api.util.DataKey; import net.citizensnpcs.api.util.DataKey;
import net.knarcraft.blacksmith.BlacksmithPlugin; import net.knarcraft.blacksmith.BlacksmithPlugin;
import net.knarcraft.blacksmith.config.SettingValueType; import net.knarcraft.blacksmith.config.SettingValueType;
import net.knarcraft.blacksmith.config.SmithPreset;
import net.knarcraft.blacksmith.config.TraitSettings; import net.knarcraft.blacksmith.config.TraitSettings;
import net.knarcraft.blacksmith.util.ConfigHelper; import net.knarcraft.blacksmith.util.ConfigHelper;
import net.knarcraft.blacksmith.util.InputParsingHelper; import net.knarcraft.blacksmith.util.InputParsingHelper;
import net.knarcraft.blacksmith.util.ItemHelper; import net.knarcraft.blacksmith.util.ItemHelper;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment; import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Set;
import java.util.logging.Level; import java.util.logging.Level;
/** /**
@ -185,7 +181,7 @@ public class BlacksmithNPCSettings implements TraitSettings<BlacksmithSetting> {
* *
* @return <p>All items reforge-able by this NPC</p> * @return <p>All items reforge-able by this NPC</p>
*/ */
public List<Material> getReforgeAbleItems() { public List<Material> getItems() {
Object currentValue = currentValues.get(BlacksmithSetting.REFORGE_ABLE_ITEMS); Object currentValue = currentValues.get(BlacksmithSetting.REFORGE_ABLE_ITEMS);
if (currentValue == null || String.valueOf(currentValue).isEmpty()) { if (currentValue == null || String.valueOf(currentValue).isEmpty()) {
return globalBlacksmithSettings.getReforgeAbleItems(); return globalBlacksmithSettings.getReforgeAbleItems();
@ -357,28 +353,6 @@ public class BlacksmithNPCSettings implements TraitSettings<BlacksmithSetting> {
return value; return value;
} }
/**
* Replaces placeholders in the given reforge-able value
*
* @param stringList <p>The value specified by a user</p>
* @return <p>The value with placeholders replaced</p>
*/
private static List<String> replaceReforgeAblePresets(List<String> stringList) {
List<String> newStrings = new ArrayList<>();
for (String item : stringList) {
if (item == null) {
continue;
}
String replaced = SmithPreset.replacePreset(item);
if (!replaced.equals(item)) {
newStrings.addAll(List.of(replaced.split(",")));
} else {
newStrings.add(item);
}
}
return newStrings;
}
/** /**
* Updates the list of blocked enchantments * Updates the list of blocked enchantments
*/ */
@ -422,55 +396,8 @@ public class BlacksmithNPCSettings implements TraitSettings<BlacksmithSetting> {
this.reforgeAbleItems.clear(); this.reforgeAbleItems.clear();
List<String> materialStrings = ConfigHelper.asStringList(getValue(BlacksmithSetting.REFORGE_ABLE_ITEMS)); List<String> materialStrings = ConfigHelper.asStringList(getValue(BlacksmithSetting.REFORGE_ABLE_ITEMS));
if (materialStrings != null) { if (materialStrings != null) {
this.reforgeAbleItems.addAll(getReforgeAbleItems(materialStrings)); this.reforgeAbleItems.addAll(ItemHelper.getItems(materialStrings, true));
} }
} }
/**
* Gets a list of the reforgeAbleItems described in the given item list
*
* @param itemList <p>The list of items defined by the user</p>
* @return <p>The materials contained in the item list</p>
*/
public static List<Material> getReforgeAbleItems(List<String> itemList) {
List<Material> reforgeAbleItems = new ArrayList<>();
if (itemList == null) {
return null;
}
//Convert any presets with a list of materials
itemList = replaceReforgeAblePresets(itemList);
Set<Material> blacklisted = new HashSet<>();
//Parse every material, and add to reforgeAble items
for (String item : itemList) {
//Ignore ,,
if (InputParsingHelper.isEmpty(item)) {
continue;
}
boolean blacklist = false;
if (item.startsWith("-")) {
blacklist = true;
item = item.substring(1);
}
Material material = InputParsingHelper.matchMaterial(item);
if (material != null && ItemHelper.isRepairable(new ItemStack(material, 1))) {
if (!blacklist) {
reforgeAbleItems.add(material);
} else {
blacklisted.add(material);
}
} else {
BlacksmithPlugin.getInstance().getLogger().log(Level.WARNING, "Unable to verify " + item +
" as a valid reforge-able item");
}
}
//Remove any blacklisted materials at the end to make sure order of arguments won't matter
reforgeAbleItems.removeAll(blacklisted);
return reforgeAbleItems;
}
} }

101
src/main/java/net/knarcraft/blacksmith/config/blacksmith/GlobalBlacksmithSettings.java
View File

@ -10,6 +10,7 @@ import net.knarcraft.blacksmith.util.InputParsingHelper;
import net.knarcraft.blacksmith.util.ItemHelper; import net.knarcraft.blacksmith.util.ItemHelper;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment; import org.bukkit.enchantments.Enchantment;
import org.jetbrains.annotations.NotNull;
import java.io.File; import java.io.File;
import java.util.ArrayList; import java.util.ArrayList;
@ -19,7 +20,7 @@ import java.util.Map;
import java.util.logging.Level; import java.util.logging.Level;
/** /**
* A class which keeps track of all default NPC settings and all global settings * A class which keeps track of all default blacksmith NPC settings and all global blacksmith settings
*/ */
public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> { public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
@ -38,7 +39,7 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
* @param plugin <p>A reference to the blacksmith plugin</p> * @param plugin <p>A reference to the blacksmith plugin</p>
*/ */
public GlobalBlacksmithSettings(BlacksmithPlugin plugin) { public GlobalBlacksmithSettings(BlacksmithPlugin plugin) {
defaultConfig = new YamlStorage(new File(plugin.getDataFolder() + File.separator + "config.yml"), this.defaultConfig = new YamlStorage(new File(plugin.getDataFolder() + File.separator + "config.yml"),
"Blacksmith Configuration\nWarning: The values under defaults are the values set for a " + "Blacksmith Configuration\nWarning: The values under defaults are the values set for a " +
"blacksmith upon creation. To change any values for existing NPCs, edit the citizens NPC file."); "blacksmith upon creation. To change any values for existing NPCs, edit the citizens NPC file.");
} }
@ -48,20 +49,20 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
*/ */
public void load() { public void load() {
// Load the config from disk // Load the config from disk
defaultConfig.load(); this.defaultConfig.load();
DataKey root = defaultConfig.getKey(""); DataKey root = this.defaultConfig.getKey("");
// Just in case, clear existing values // Just in case, clear existing values
settings.clear(); this.settings.clear();
materialBasePrices.clear(); this.materialBasePrices.clear();
materialPricePerDurabilityPoints.clear(); this.materialPricePerDurabilityPoints.clear();
enchantmentCosts.clear(); this.enchantmentCosts.clear();
// Load/Save settings // Load/Save settings
loadGlobalSettings(root); loadSettings(root);
// Save any modified values to disk // Save any modified values to disk
defaultConfig.save(); this.defaultConfig.save();
} }
/** /**
@ -74,9 +75,9 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
if (blacksmithSetting.getValueType() == SettingValueType.STRING_LIST || if (blacksmithSetting.getValueType() == SettingValueType.STRING_LIST ||
blacksmithSetting.getValueType() == SettingValueType.REFORGE_ABLE_ITEMS) { blacksmithSetting.getValueType() == SettingValueType.REFORGE_ABLE_ITEMS) {
//Workaround to make sure it's treated as the correct type //Workaround to make sure it's treated as the correct type
settings.put(blacksmithSetting, newValue == null ? null : ConfigHelper.asStringList(newValue)); this.settings.put(blacksmithSetting, newValue == null ? null : ConfigHelper.asStringList(newValue));
} else { } else {
settings.put(blacksmithSetting, newValue); this.settings.put(blacksmithSetting, newValue);
} }
save(); save();
if (blacksmithSetting == BlacksmithSetting.REFORGE_ABLE_ITEMS) { if (blacksmithSetting == BlacksmithSetting.REFORGE_ABLE_ITEMS) {
@ -93,7 +94,7 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
* @return <p>The current raw setting value</p> * @return <p>The current raw setting value</p>
*/ */
public Object getRawValue(BlacksmithSetting blacksmithSetting) { public Object getRawValue(BlacksmithSetting blacksmithSetting) {
return settings.get(blacksmithSetting); return this.settings.get(blacksmithSetting);
} }
/** /**
@ -107,12 +108,12 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
if (newEnchantmentCost < 0) { if (newEnchantmentCost < 0) {
throw new IllegalArgumentException("Enchantment cost cannot be negative!"); throw new IllegalArgumentException("Enchantment cost cannot be negative!");
} }
settings.put(BlacksmithSetting.ENCHANTMENT_COST, newEnchantmentCost); this.settings.put(BlacksmithSetting.ENCHANTMENT_COST, newEnchantmentCost);
} else { } else {
if (newEnchantmentCost < 0) { if (newEnchantmentCost < 0) {
enchantmentCosts.put(enchantment, null); this.enchantmentCosts.put(enchantment, null);
} else { } else {
enchantmentCosts.put(enchantment, newEnchantmentCost); this.enchantmentCosts.put(enchantment, newEnchantmentCost);
} }
} }
save(); save();
@ -129,13 +130,13 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
if (newPrice < 0) { if (newPrice < 0) {
throw new IllegalArgumentException("Price per durability point cannot be negative!"); throw new IllegalArgumentException("Price per durability point cannot be negative!");
} }
settings.put(BlacksmithSetting.PRICE_PER_DURABILITY_POINT, newPrice); this.settings.put(BlacksmithSetting.PRICE_PER_DURABILITY_POINT, newPrice);
} else { } else {
//Use a negative price to unset the per-item value //Use a negative price to unset the per-item value
if (newPrice < 0) { if (newPrice < 0) {
materialPricePerDurabilityPoints.put(material, null); this.materialPricePerDurabilityPoints.put(material, null);
} else { } else {
materialPricePerDurabilityPoints.put(material, newPrice); this.materialPricePerDurabilityPoints.put(material, newPrice);
} }
} }
save(); save();
@ -156,9 +157,9 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
} else { } else {
//Use a negative price to unset the per-item value //Use a negative price to unset the per-item value
if (newBasePrice < 0) { if (newBasePrice < 0) {
materialBasePrices.put(material, null); this.materialBasePrices.put(material, null);
} else { } else {
materialBasePrices.put(material, newBasePrice); this.materialBasePrices.put(material, newBasePrice);
} }
} }
save(); save();
@ -201,8 +202,8 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
* @return <p>The base price for the material</p> * @return <p>The base price for the material</p>
*/ */
public double getBasePrice(Material material) { public double getBasePrice(Material material) {
if (materialBasePrices.containsKey(material) && materialBasePrices.get(material) != null) { if (this.materialBasePrices.containsKey(material) && this.materialBasePrices.get(material) != null) {
return materialBasePrices.get(material); return this.materialBasePrices.get(material);
} else { } else {
return asDouble(BlacksmithSetting.BASE_PRICE); return asDouble(BlacksmithSetting.BASE_PRICE);
} }
@ -215,9 +216,9 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
* @return <p>The durability point price for the material</p> * @return <p>The durability point price for the material</p>
*/ */
public double getPricePerDurabilityPoint(Material material) { public double getPricePerDurabilityPoint(Material material) {
if (materialPricePerDurabilityPoints.containsKey(material) && if (this.materialPricePerDurabilityPoints.containsKey(material) &&
materialPricePerDurabilityPoints.get(material) != null) { this.materialPricePerDurabilityPoints.get(material) != null) {
return materialPricePerDurabilityPoints.get(material); return this.materialPricePerDurabilityPoints.get(material);
} else { } else {
return asDouble(BlacksmithSetting.PRICE_PER_DURABILITY_POINT); return asDouble(BlacksmithSetting.PRICE_PER_DURABILITY_POINT);
} }
@ -230,8 +231,8 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
* @return <p>The cost of each enchantment level</p> * @return <p>The cost of each enchantment level</p>
*/ */
public double getEnchantmentCost(Enchantment enchantment) { public double getEnchantmentCost(Enchantment enchantment) {
if (enchantmentCosts.containsKey(enchantment) && enchantmentCosts.get(enchantment) != null) { if (this.enchantmentCosts.containsKey(enchantment) && this.enchantmentCosts.get(enchantment) != null) {
return enchantmentCosts.get(enchantment); return this.enchantmentCosts.get(enchantment);
} else { } else {
return asDouble(BlacksmithSetting.ENCHANTMENT_COST); return asDouble(BlacksmithSetting.ENCHANTMENT_COST);
} }
@ -242,7 +243,7 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
* *
* @return <p>The value of reforgeAbleItems</p> * @return <p>The value of reforgeAbleItems</p>
*/ */
public List<Material> getReforgeAbleItems() { public @NotNull List<Material> getReforgeAbleItems() {
return this.defaultReforgeAbleMaterials; return this.defaultReforgeAbleMaterials;
} }
@ -251,7 +252,7 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
* *
* @return <p>The value of enchantmentBlocklist</p> * @return <p>The value of enchantmentBlocklist</p>
*/ */
public List<Enchantment> getEnchantmentBlocklist() { public @NotNull List<Enchantment> getEnchantmentBlocklist() {
return this.defaultEnchantmentBlocklist; return this.defaultEnchantmentBlocklist;
} }
@ -302,7 +303,7 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
* @return <p>The current value</p> * @return <p>The current value</p>
*/ */
private Object getValue(BlacksmithSetting setting) { private Object getValue(BlacksmithSetting setting) {
Object value = settings.get(setting); Object value = this.settings.get(setting);
//If not set in config.yml, use the default value from the enum //If not set in config.yml, use the default value from the enum
if (value == null) { if (value == null) {
value = setting.getDefaultValue(); value = setting.getDefaultValue();
@ -315,7 +316,7 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
* *
* @param root <p>The root node of all global settings</p> * @param root <p>The root node of all global settings</p>
*/ */
private void loadGlobalSettings(DataKey root) { private void loadSettings(DataKey root) {
for (BlacksmithSetting blacksmithSetting : BlacksmithSetting.values()) { for (BlacksmithSetting blacksmithSetting : BlacksmithSetting.values()) {
if (!root.keyExists(blacksmithSetting.getPath())) { if (!root.keyExists(blacksmithSetting.getPath())) {
//If the setting does not exist in the config file, add it //If the setting does not exist in the config file, add it
@ -340,7 +341,7 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
for (String key : relevantKeys.keySet()) { for (String key : relevantKeys.keySet()) {
String enchantmentName = relevantKeys.get(key); String enchantmentName = relevantKeys.get(key);
Enchantment enchantment = InputParsingHelper.matchEnchantment(enchantmentName); Enchantment enchantment = InputParsingHelper.matchEnchantment(enchantmentName);
setItemPrice(enchantmentCosts, enchantmentName, enchantment, enchantmentCostNode.getDouble(key)); setItemPrice(this.enchantmentCosts, enchantmentName, enchantment, enchantmentCostNode.getDouble(key));
} }
} }
@ -358,10 +359,10 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
double price = basePerDurabilityPriceNode.getDouble(key); double price = basePerDurabilityPriceNode.getDouble(key);
if (materialName.contains("*")) { if (materialName.contains("*")) {
//Treat *CHESTPLATE as a regular expression to match all chest-plates //Treat *CHESTPLATE as a regular expression to match all chest-plates
setMatchedMaterialPrices(materialPricePerDurabilityPoints, materialName, price); setMatchedMaterialPrices(this.materialPricePerDurabilityPoints, materialName, price);
} else { } else {
Material material = InputParsingHelper.matchMaterial(materialName); Material material = InputParsingHelper.matchMaterial(materialName);
setItemPrice(materialPricePerDurabilityPoints, materialName, material, price); setItemPrice(this.materialPricePerDurabilityPoints, materialName, material, price);
} }
} }
} }
@ -380,10 +381,10 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
double price = basePriceNode.getDouble(key); double price = basePriceNode.getDouble(key);
if (materialName.contains("*")) { if (materialName.contains("*")) {
//Treat *CHESTPLATE as a regular expression to match all chest-plates //Treat *CHESTPLATE as a regular expression to match all chest-plates
setMatchedMaterialPrices(materialBasePrices, materialName, price); setMatchedMaterialPrices(this.materialBasePrices, materialName, price);
} else { } else {
Material material = InputParsingHelper.matchMaterial(materialName); Material material = InputParsingHelper.matchMaterial(materialName);
setItemPrice(materialBasePrices, materialName, material, price); setItemPrice(this.materialBasePrices, materialName, material, price);
} }
} }
} }
@ -455,11 +456,11 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
* Loads reforgeAble items from the current value * Loads reforgeAble items from the current value
*/ */
private void loadReforgeAbleItems() { private void loadReforgeAbleItems() {
defaultReforgeAbleMaterials.clear(); this.defaultReforgeAbleMaterials.clear();
List<String> materialNames = ConfigHelper.asStringList(settings.get( List<String> materialNames = ConfigHelper.asStringList(settings.get(
BlacksmithSetting.REFORGE_ABLE_ITEMS)); BlacksmithSetting.REFORGE_ABLE_ITEMS));
if (materialNames != null) { if (materialNames != null) {
defaultReforgeAbleMaterials.addAll(BlacksmithNPCSettings.getReforgeAbleItems(materialNames)); this.defaultReforgeAbleMaterials.addAll(ItemHelper.getItems(materialNames, true));
} }
} }
@ -467,11 +468,11 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
* Loads the enchantment blocklist from the current value * Loads the enchantment blocklist from the current value
*/ */
private void loadEnchantmentBlocklist() { private void loadEnchantmentBlocklist() {
defaultEnchantmentBlocklist.clear(); this.defaultEnchantmentBlocklist.clear();
List<String> enchantmentNames = ConfigHelper.asStringList(settings.get( List<String> enchantmentNames = ConfigHelper.asStringList(settings.get(
BlacksmithSetting.ENCHANTMENT_BLOCKLIST)); BlacksmithSetting.ENCHANTMENT_BLOCKLIST));
if (enchantmentNames != null) { if (enchantmentNames != null) {
defaultEnchantmentBlocklist.addAll(BlacksmithNPCSettings.getEnchantmentBlocklist(enchantmentNames)); this.defaultEnchantmentBlocklist.addAll(BlacksmithNPCSettings.getEnchantmentBlocklist(enchantmentNames));
} }
} }
@ -479,32 +480,32 @@ public class GlobalBlacksmithSettings implements Settings<BlacksmithSetting> {
* Saves all current settings to the config file * Saves all current settings to the config file
*/ */
private void save() { private void save() {
DataKey root = defaultConfig.getKey(""); DataKey root = this.defaultConfig.getKey("");
//Save all default settings //Save all default settings
for (BlacksmithSetting setting : BlacksmithSetting.values()) { for (BlacksmithSetting setting : BlacksmithSetting.values()) {
root.setRaw(setting.getPath(), settings.get(setting)); root.setRaw(setting.getPath(), this.settings.get(setting));
} }
//Save all base prices //Save all base prices
DataKey basePriceNode = root.getRelative(BlacksmithSetting.BASE_PRICE.getPath()); DataKey basePriceNode = root.getRelative(BlacksmithSetting.BASE_PRICE.getPath());
for (Material material : materialBasePrices.keySet()) { for (Material material : this.materialBasePrices.keySet()) {
basePriceNode.setRaw(unNormalizeName(material.name()), materialBasePrices.get(material)); basePriceNode.setRaw(unNormalizeName(material.name()), this.materialBasePrices.get(material));
} }
//Save all per-durability-point prices //Save all per-durability-point prices
DataKey basePerDurabilityPriceNode = root.getRelative(BlacksmithSetting.PRICE_PER_DURABILITY_POINT.getPath()); DataKey basePerDurabilityPriceNode = root.getRelative(BlacksmithSetting.PRICE_PER_DURABILITY_POINT.getPath());
for (Material material : materialPricePerDurabilityPoints.keySet()) { for (Material material : this.materialPricePerDurabilityPoints.keySet()) {
basePerDurabilityPriceNode.setRaw(unNormalizeName(material.name()), materialPricePerDurabilityPoints.get(material)); basePerDurabilityPriceNode.setRaw(unNormalizeName(material.name()), this.materialPricePerDurabilityPoints.get(material));
} }
//Load all enchantment prices //Load all enchantment prices
DataKey enchantmentCostNode = root.getRelative(BlacksmithSetting.ENCHANTMENT_COST.getPath()); DataKey enchantmentCostNode = root.getRelative(BlacksmithSetting.ENCHANTMENT_COST.getPath());
for (Enchantment enchantment : enchantmentCosts.keySet()) { for (Enchantment enchantment : this.enchantmentCosts.keySet()) {
enchantmentCostNode.setRaw(unNormalizeName(enchantment.getKey().getKey()), enchantmentCosts.get(enchantment)); enchantmentCostNode.setRaw(unNormalizeName(enchantment.getKey().getKey()), this.enchantmentCosts.get(enchantment));
} }
//Perform the actual save to disk //Perform the actual save to disk
defaultConfig.save(); this.defaultConfig.save();
} }
} }

119
src/main/java/net/knarcraft/blacksmith/config/scrapper/GlobalScrapperSettings.java
View File

@ -6,14 +6,28 @@ import net.knarcraft.blacksmith.BlacksmithPlugin;
import net.knarcraft.blacksmith.config.SettingValueType; import net.knarcraft.blacksmith.config.SettingValueType;
import net.knarcraft.blacksmith.config.Settings; import net.knarcraft.blacksmith.config.Settings;
import net.knarcraft.blacksmith.util.ConfigHelper; import net.knarcraft.blacksmith.util.ConfigHelper;
import net.knarcraft.blacksmith.util.ItemHelper;
import org.bukkit.Material;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.File; import java.io.File;
import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
/**
* A class which keeps track of all default scrapper NPC settings and all global scrapper settings
*/
public class GlobalScrapperSettings implements Settings<ScrapperSetting> { public class GlobalScrapperSettings implements Settings<ScrapperSetting> {
private final Map<ScrapperSetting, Object> settings = new HashMap<>(); private final Map<ScrapperSetting, Object> settings = new HashMap<>();
private final List<Material> defaultSalvageableMaterials = new ArrayList<>();
private final Map<Material, Set<Material>> ignoredSalvage = new HashMap<>();
private final YamlStorage defaultConfig; private final YamlStorage defaultConfig;
@ -23,7 +37,7 @@ public class GlobalScrapperSettings implements Settings<ScrapperSetting> {
* @param plugin <p>A reference to the blacksmith plugin</p> * @param plugin <p>A reference to the blacksmith plugin</p>
*/ */
public GlobalScrapperSettings(BlacksmithPlugin plugin) { public GlobalScrapperSettings(BlacksmithPlugin plugin) {
defaultConfig = new YamlStorage(new File(plugin.getDataFolder() + File.separator + "config.yml"), this.defaultConfig = new YamlStorage(new File(plugin.getDataFolder() + File.separator + "config.yml"),
"Scrapper Configuration\nWarning: The values under defaults are the values set for a " + "Scrapper Configuration\nWarning: The values under defaults are the values set for a " +
"scrapper upon creation. To change any values for existing NPCs, edit the citizens NPC file."); "scrapper upon creation. To change any values for existing NPCs, edit the citizens NPC file.");
} }
@ -33,17 +47,17 @@ public class GlobalScrapperSettings implements Settings<ScrapperSetting> {
*/ */
public void load() { public void load() {
//Load the config from disk //Load the config from disk
defaultConfig.load(); this.defaultConfig.load();
DataKey root = defaultConfig.getKey(""); DataKey root = this.defaultConfig.getKey("");
//Just in case, clear existing values //Just in case, clear existing values
settings.clear(); this.settings.clear();
//Load/Save global settings //Load/Save global settings
loadSettings(root); loadSettings(root);
//Save any modified values to disk //Save any modified values to disk
defaultConfig.save(); this.defaultConfig.save();
} }
/** /**
@ -52,13 +66,16 @@ public class GlobalScrapperSettings implements Settings<ScrapperSetting> {
* @param scrapperSetting <p>The default NPC setting to change</p> * @param scrapperSetting <p>The default NPC setting to change</p>
* @param newValue <p>The new value for the setting</p> * @param newValue <p>The new value for the setting</p>
*/ */
public void changeValue(ScrapperSetting scrapperSetting, Object newValue) { public void changeValue(@NotNull ScrapperSetting scrapperSetting, @Nullable Object newValue) {
if (scrapperSetting.getValueType() == SettingValueType.STRING_LIST || if (scrapperSetting.getValueType() == SettingValueType.STRING_LIST ||
scrapperSetting.getValueType() == SettingValueType.REFORGE_ABLE_ITEMS) { scrapperSetting.getValueType() == SettingValueType.REFORGE_ABLE_ITEMS) {
//Workaround to make sure it's treated as the correct type //Workaround to make sure it's treated as the correct type
settings.put(scrapperSetting, newValue == null ? null : ConfigHelper.asStringList(newValue)); this.settings.put(scrapperSetting, newValue == null ? null : ConfigHelper.asStringList(newValue));
} else { } else {
settings.put(scrapperSetting, newValue); this.settings.put(scrapperSetting, newValue);
}
if (scrapperSetting == ScrapperSetting.SALVAGE_ABLE_ITEMS) {
loadSalvageAbleItems();
} }
save(); save();
} }
@ -70,7 +87,7 @@ public class GlobalScrapperSettings implements Settings<ScrapperSetting> {
* @return <p>The current raw setting value</p> * @return <p>The current raw setting value</p>
*/ */
public Object getRawValue(ScrapperSetting scrapperSetting) { public Object getRawValue(ScrapperSetting scrapperSetting) {
return settings.get(scrapperSetting); return this.settings.get(scrapperSetting);
} }
/** /**
@ -110,7 +127,7 @@ public class GlobalScrapperSettings implements Settings<ScrapperSetting> {
* @return <p>The current value</p> * @return <p>The current value</p>
*/ */
private Object getValue(ScrapperSetting setting) { private Object getValue(ScrapperSetting setting) {
Object value = settings.get(setting); Object value = this.settings.get(setting);
//If not set in config.yml, use the default value from the enum //If not set in config.yml, use the default value from the enum
if (value == null) { if (value == null) {
value = setting.getDefaultValue(); value = setting.getDefaultValue();
@ -130,23 +147,97 @@ public class GlobalScrapperSettings implements Settings<ScrapperSetting> {
root.setRaw(setting.getPath(), setting.getDefaultValue()); root.setRaw(setting.getPath(), setting.getDefaultValue());
} else { } else {
//Set the setting to the value found in the path //Set the setting to the value found in the path
settings.put(setting, root.getRaw(setting.getPath())); this.settings.put(setting, root.getRaw(setting.getPath()));
} }
} }
loadSalvageAbleItems();
loadIgnoredSalvage();
} }
/** /**
* Saves all current settings to the config file * Saves all current settings to the config file
*/ */
private void save() { private void save() {
DataKey root = defaultConfig.getKey(""); DataKey root = this.defaultConfig.getKey("");
//Save all default settings //Save all default settings
for (ScrapperSetting setting : ScrapperSetting.values()) { for (ScrapperSetting setting : ScrapperSetting.values()) {
root.setRaw(setting.getPath(), settings.get(setting)); root.setRaw(setting.getPath(), this.settings.get(setting));
} }
//Perform the actual save to disk //Perform the actual save to disk
defaultConfig.save(); this.defaultConfig.save();
}
/**
* Gets the value of salvageAbleItems
*
* @return <p>The value of salvageAbleItems</p>
*/
public List<Material> getSalvageAbleItems() {
return this.defaultSalvageableMaterials;
}
/**
* Gets ignored salvage for the given material
*
* <p>The ignored salvage should be ignored when calculating item salvage, in order to increase the probability of
* getting the more expensive materials back.</p>
*
* @param material <p>The material to get ignored salvage for</p>
* @return <p>The ignored salvage</p>
*/
public @Nullable Set<Material> getIgnoredSalvage(@NotNull Material material) {
return this.ignoredSalvage.get(material);
}
/**
* Loads reforgeAble items from the current value
*/
private void loadSalvageAbleItems() {
this.defaultSalvageableMaterials.clear();
List<String> materialNames = ConfigHelper.asStringList(this.settings.get(ScrapperSetting.SALVAGE_ABLE_ITEMS));
if (materialNames != null) {
this.defaultSalvageableMaterials.addAll(ItemHelper.getItems(materialNames, true));
}
}
/**
* Loads all ignored salvage from the configuration file
*/
private void loadIgnoredSalvage() {
this.ignoredSalvage.clear();
List<String> allIgnoredSalvage = ConfigHelper.asStringList(this.settings.get(ScrapperSetting.IGNORED_SALVAGE));
if (allIgnoredSalvage == null) {
return;
}
for (String ignoredSalvageInfo : allIgnoredSalvage) {
// Ignore invalid lines
if (!ignoredSalvageInfo.contains(":")) {
BlacksmithPlugin.getInstance().getLogger().log(Level.WARNING, String.format("The ignored salvage " +
"configuration line %s is invalid", ignoredSalvageInfo));
continue;
}
// Parse all material names
String[] data = ignoredSalvageInfo.split(":");
String[] materialStrings = data[0].split(",");
List<Material> materials = new ArrayList<>();
for (String materialString : materialStrings) {
materials.addAll(ItemHelper.getWildcardMatch(materialString));
}
String[] ignoredSalvageStrings = data[1].split(",");
List<Material> ignored = new ArrayList<>();
for (String ignoredSalvageString : ignoredSalvageStrings) {
ignored.addAll(ItemHelper.getWildcardMatch(ignoredSalvageString));
}
// Add the ignored salvage to all the matched materials
for (Material material : materials) {
ignoredSalvage.computeIfAbsent(material, k -> new HashSet<>());
ignoredSalvage.get(material).addAll(ignored);
}
}
} }
} }

89
src/main/java/net/knarcraft/blacksmith/config/scrapper/ScrapperNPCSettings.java
View File

@ -4,13 +4,19 @@ import net.citizensnpcs.api.util.DataKey;
import net.knarcraft.blacksmith.config.SettingValueType; import net.knarcraft.blacksmith.config.SettingValueType;
import net.knarcraft.blacksmith.config.TraitSettings; import net.knarcraft.blacksmith.config.TraitSettings;
import net.knarcraft.blacksmith.util.ConfigHelper; import net.knarcraft.blacksmith.util.ConfigHelper;
import net.knarcraft.blacksmith.util.ItemHelper;
import org.bukkit.Material;
import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.List;
import java.util.Map; import java.util.Map;
public class ScrapperNPCSettings implements TraitSettings<ScrapperSetting> { public class ScrapperNPCSettings implements TraitSettings<ScrapperSetting> {
private final Map<ScrapperSetting, Object> currentValues = new HashMap<>(); private final Map<ScrapperSetting, Object> currentValues = new HashMap<>();
private final GlobalScrapperSettings globalScrapperSettings; private final GlobalScrapperSettings globalScrapperSettings;
private final List<Material> salvageAbleItems = new ArrayList<>();
/** /**
* Instantiates a new scrapper NPC settings object * Instantiates a new scrapper NPC settings object
@ -59,6 +65,20 @@ public class ScrapperNPCSettings implements TraitSettings<ScrapperSetting> {
} else { } else {
currentValues.put(setting, newValue); currentValues.put(setting, newValue);
} }
if (setting == ScrapperSetting.SALVAGE_ABLE_ITEMS) {
updateSalvageAbleItems();
}
}
/**
* Updates the reforge-able items according to the current value of the setting
*/
private void updateSalvageAbleItems() {
this.salvageAbleItems.clear();
List<String> materialStrings = ConfigHelper.asStringList(getValue(ScrapperSetting.SALVAGE_ABLE_ITEMS));
if (materialStrings != null) {
this.salvageAbleItems.addAll(ItemHelper.getItems(materialStrings, !extendedSalvageEnabled()));
}
} }
/** /**
@ -87,14 +107,23 @@ public class ScrapperNPCSettings implements TraitSettings<ScrapperSetting> {
} }
/** /**
* Gets the message to display when a blacksmith has successfully repaired an item * Gets the message to display when a scrapper has successfully scrapped an item
* *
* @return <p>The reforge success message</p> * @return <p>The salvage success message</p>
*/ */
public String getSuccessMessage() { public String getSuccessMessage() {
return asString(ScrapperSetting.SUCCESS_SALVAGE_MESSAGE); return asString(ScrapperSetting.SUCCESS_SALVAGE_MESSAGE);
} }
/**
* Gets the message to display when a scrapper fails to salvage an item
*
* @return <p>The salvage fail message</p>
*/
public String getFailMessage() {
return asString(ScrapperSetting.FAIL_SALVAGE_MESSAGE);
}
@Override @Override
public String getCoolDownUnexpiredMessage() { public String getCoolDownUnexpiredMessage() {
return asString(ScrapperSetting.COOL_DOWN_UNEXPIRED_MESSAGE); return asString(ScrapperSetting.COOL_DOWN_UNEXPIRED_MESSAGE);
@ -157,6 +186,15 @@ public class ScrapperNPCSettings implements TraitSettings<ScrapperSetting> {
return asInt(ScrapperSetting.MAX_SALVAGE_DELAY) <= 0; return asInt(ScrapperSetting.MAX_SALVAGE_DELAY) <= 0;
} }
/**
* Gets the chance of a salvaging to fail
*
* @return <p>The chance of a salvaging to fail</p>
*/
public int getFailChance() {
return asInt(ScrapperSetting.FAIL_SALVAGE_CHANCE);
}
/** /**
* Gets the given value as an integer * Gets the given value as an integer
* *
@ -201,4 +239,51 @@ public class ScrapperNPCSettings implements TraitSettings<ScrapperSetting> {
return value; return value;
} }
/**
* Gets all item types this NPC is able to salvage
*
* @return <p>All salvageable items</p>
*/
public List<Material> getSalvageAbleItems() {
Object currentValue = currentValues.get(ScrapperSetting.SALVAGE_ABLE_ITEMS);
if (currentValue == null || String.valueOf(currentValue).isEmpty()) {
return globalScrapperSettings.getSalvageAbleItems();
} else {
return new ArrayList<>(this.salvageAbleItems);
}
}
/**
* Whether extended salvaging is enabled
*
* <p>When not extended, only repairable items can be salvaged. When extended, any item produced using a crafting
* recipe or a smithing transformation can be salvaged. This does not include smelting or similar.</p>
*
* @return <p>True if extended salvaging is enabled</p>
*/
public boolean extendedSalvageEnabled() {
return ConfigHelper.asBoolean(getValue(ScrapperSetting.EXTENDED_SALVAGE_ENABLED));
}
/**
* Gets the title of this scrapper NPC
*
* <p>The title is used to specify scrapper sub-types in order to make it clear which items a scrapper can salvage.
* For example, an armor-scrapper would only be able to salvage armor pieces.</p>
*
* @return <p>The title of this scrapper NPC</p>
*/
public String getScrapperTitle() {
return asString(ScrapperSetting.SCRAPPER_TITLE);
}
/**
* Gets the message to display if this NPC is given an item it cannot salvage
*
* @return <p>The message to display</p>
*/
public String getInvalidItemMessage() {
return asString(ScrapperSetting.INVALID_ITEM_MESSAGE);
}
} }

29
src/main/java/net/knarcraft/blacksmith/config/scrapper/ScrapperSetting.java
View File

@ -5,6 +5,9 @@ import net.knarcraft.blacksmith.config.SettingValueType;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.List;
/** /**
* An enum representing all scrapper-related settings * An enum representing all scrapper-related settings
*/ */
@ -64,6 +67,12 @@ public enum ScrapperSetting implements Setting {
SCRAPPER_TITLE("scrapperTitle", SettingValueType.STRING, "scrapper", SCRAPPER_TITLE("scrapperTitle", SettingValueType.STRING, "scrapper",
"The title describing the scrapper's usage/speciality", true, false), "The title describing the scrapper's usage/speciality", true, false),
/**
* The setting for whether the NPC should allow salvaging of any craft-able item instead of just repairable items
*/
EXTENDED_SALVAGE_ENABLED("extendedSalvageEnabled", SettingValueType.BOOLEAN, false,
"Whether to enable salvaging of non-repairable items, such as planks", true, false),
/*----------- /*-----------
| Messages | | Messages |
-----------*/ -----------*/
@ -91,11 +100,12 @@ public enum ScrapperSetting implements Setting {
"on a cool-down from the previous re-forging", true, true), "on a cool-down from the previous re-forging", true, true),
/** /**
* The message displayed if presented with an item that cannot be salvaged by the NPC * The message displayed if the scrapper encounters an item they cannot salvage
*/ */
CANNOT_SALVAGE_MESSAGE("cannotSalvageMessage", SettingValueType.STRING, INVALID_ITEM_MESSAGE("invalidItemMessage", SettingValueType.STRING,
"&cI'm unable to salvage that item", "The message to display if the player tries to salvage" + "&cI'm sorry, but I'm a/an {title}, I don't know how to salvage that!",
" an item the blacksmith cannot salvage", true, true), "The message to display if the player tries to salvage" +
" an item the scrapper cannot salvage", true, true),
/** /**
* The message displayed if salvaging an item would return in no items * The message displayed if salvaging an item would return in no items
@ -146,6 +156,17 @@ public enum ScrapperSetting implements Setting {
*/ */
GIVE_EXPERIENCE("giveExperience", SettingValueType.BOOLEAN, "true", "Whether enchanted " + GIVE_EXPERIENCE("giveExperience", SettingValueType.BOOLEAN, "true", "Whether enchanted " +
"salvaged items should return some amount of exp upon salvage", false, false), "salvaged items should return some amount of exp upon salvage", false, false),
/**
* Which items are ignored when calculating salvage for a given material
*/
IGNORED_SALVAGE("ignoredSalvage", SettingValueType.STRING_LIST,
new ArrayList<>(List.of("*_SHOVEL,*_PICKAXE,*_AXE,*_HOE,*_SWORD:STICK")),
"Items ignored during salvage calculation. This follows the format: " +
"\"MATERIAL[,MATERIAL2][,MATERIAL3]:IGNORED\", so the material or materials listed will ignore " +
"the material specified after the \":\" when calculating salvage (* matches any character). This " +
"causes the player to lose some items during salvaging, but can prevent cases where a diamond " +
"pickaxe is salvaged and only sticks are returned.", false, false),
; ;
private final String path; private final String path;

2
src/main/java/net/knarcraft/blacksmith/trait/BlacksmithTrait.java
View File

@ -67,7 +67,7 @@ public class BlacksmithTrait extends CustomTrait<BlacksmithSetting> {
public void startSession(@NotNull Player player) { public void startSession(@NotNull Player player) {
ItemStack hand = player.getInventory().getItemInMainHand(); ItemStack hand = player.getInventory().getItemInMainHand();
//Refuse if not repairable, or if reforge-able items is set, but doesn't include the held item //Refuse if not repairable, or if reforge-able items is set, but doesn't include the held item
List<Material> reforgeAbleItems = config.getReforgeAbleItems(); List<Material> reforgeAbleItems = config.getItems();
boolean notHoldingAnvil = !this.config.getRepairAnvils() || !ItemHelper.isAnvil(hand.getType(), false); boolean notHoldingAnvil = !this.config.getRepairAnvils() || !ItemHelper.isAnvil(hand.getType(), false);
boolean notHoldingRepairable = !ItemHelper.isRepairable(hand) || boolean notHoldingRepairable = !ItemHelper.isRepairable(hand) ||

2
src/main/java/net/knarcraft/blacksmith/trait/CustomTrait.java
View File

@ -186,6 +186,8 @@ public abstract class CustomTrait<K extends Setting> extends Trait {
Objects.requireNonNull(((LivingEntity) npc.getEntity()).getEquipment()).setItemInMainHand(heldItem); Objects.requireNonNull(((LivingEntity) npc.getEntity()).getEquipment()).setItemInMainHand(heldItem);
} }
//Remove the item from the player's inventory //Remove the item from the player's inventory
// TODO: For a scrapper with extended salvaging enabled, the item needs to be reduced with the amount specified
// in the recipe, or removed as normal in the case where the player has exactly enough items to run the salvage.
player.getInventory().setItemInMainHand(null); player.getInventory().setItemInMainHand(null);
} }

59
src/main/java/net/knarcraft/blacksmith/trait/SalvageSession.java
View File

@ -5,18 +5,22 @@ import net.knarcraft.blacksmith.BlacksmithPlugin;
import net.knarcraft.blacksmith.config.scrapper.ScrapperNPCSettings; import net.knarcraft.blacksmith.config.scrapper.ScrapperNPCSettings;
import net.knarcraft.blacksmith.util.ItemHelper; import net.knarcraft.blacksmith.util.ItemHelper;
import net.knarcraft.blacksmith.util.SalvageHelper; import net.knarcraft.blacksmith.util.SalvageHelper;
import org.bukkit.Material;
import org.bukkit.entity.Damageable;
import org.bukkit.entity.LivingEntity; import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.Calendar; import java.util.Calendar;
import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Objects; import java.util.Objects;
import java.util.Random; import java.util.Random;
import java.util.Set;
import static net.knarcraft.blacksmith.formatting.BlacksmithStringFormatter.sendNPCMessage; import static net.knarcraft.blacksmith.formatting.BlacksmithStringFormatter.sendNPCMessage;
import static net.knarcraft.blacksmith.util.ItemHelper.updateDamage;
/** /**
* A representation of the session between a player and a blacksmith * A representation of the session between a player and a blacksmith
@ -29,6 +33,7 @@ public class SalvageSession extends Session implements Runnable {
private final ScrapperNPCSettings config; private final ScrapperNPCSettings config;
private final List<ItemStack> salvage; private final List<ItemStack> salvage;
private final int enchantmentLevels; private final int enchantmentLevels;
private static final Random random = new Random();
/** /**
* Instantiates a new session * Instantiates a new session
@ -45,9 +50,16 @@ public class SalvageSession extends Session implements Runnable {
this.npc = npc; this.npc = npc;
this.itemToSalvage = player.getInventory().getItemInMainHand(); this.itemToSalvage = player.getInventory().getItemInMainHand();
this.config = config; this.config = config;
// TODO: Implement the list of items to ignore when calculating salvage
// Get the salvage, for the item, but ignore some materials if set, and the item isn't at full durability
Set<Material> ignoredSalvage = BlacksmithPlugin.getInstance().getGlobalScrapperSettings().getIgnoredSalvage(
this.itemToSalvage.getType());
if (ignoredSalvage == null || ItemHelper.getDamage(this.itemToSalvage) == 0) {
ignoredSalvage = new HashSet<>();
}
this.salvage = SalvageHelper.getSalvage(BlacksmithPlugin.getInstance().getServer(), this.itemToSalvage, this.salvage = SalvageHelper.getSalvage(BlacksmithPlugin.getInstance().getServer(), this.itemToSalvage,
new ArrayList<>()); ignoredSalvage);
this.enchantmentLevels = SalvageHelper.getTotalEnchantmentLevels(this.itemToSalvage); this.enchantmentLevels = SalvageHelper.getTotalEnchantmentLevels(this.itemToSalvage);
} }
@ -79,10 +91,7 @@ public class SalvageSession extends Session implements Runnable {
*/ */
@Override @Override
public void run() { public void run() {
// TODO: Tell the player that the salvaging was successful, or cancel giveSalvage + give the original item back? sendNPCMessage(this.npc, player, salvageItem() ? config.getSuccessMessage() : config.getFailMessage());
// Give the player the result of the salvage
giveSalvage();
//Stop the reforged item from displaying in the blacksmith's hand //Stop the reforged item from displaying in the blacksmith's hand
if (npc.getEntity() instanceof Player) { if (npc.getEntity() instanceof Player) {
@ -100,6 +109,42 @@ public class SalvageSession extends Session implements Runnable {
scrapperTrait.addCoolDown(player.getUniqueId(), wait); scrapperTrait.addCoolDown(player.getUniqueId(), wait);
} }
/**
* Trues to salvage an item, and gives the return item
*
* @return <p>True if the salvage was successful. False otherwise.</p>
*/
private boolean salvageItem() {
if (random.nextInt(100) < config.getFailChance()) {
failSalvage();
return false;
} else {
// Give the player the result of the salvage
giveSalvage();
return true;
}
}
/**
* The method to run when a blacksmith fails re-forging an item
*/
private void failSalvage() {
if (itemToSalvage instanceof Damageable) {
//Damage the item
short currentItemDurability = ItemHelper.getDurability(itemToSalvage);
short newDurability = (short) (currentItemDurability + (currentItemDurability * random.nextInt(8)));
short maxDurability = itemToSalvage.getType().getMaxDurability();
if (newDurability <= 0) {
newDurability = (short) (maxDurability / 3);
} else if (currentItemDurability + newDurability > maxDurability) {
newDurability = (short) (maxDurability - random.nextInt(maxDurability - 25));
}
updateDamage(itemToSalvage, maxDurability - newDurability);
} else {
itemToSalvage.setAmount(Math.max(itemToSalvage.getAmount() - 1, 1));
}
}
/** /**
* Gives the player the calculated salvage * Gives the player the calculated salvage
*/ */

24
src/main/java/net/knarcraft/blacksmith/trait/ScrapperTrait.java
View File

@ -4,11 +4,19 @@ import net.citizensnpcs.api.util.DataKey;
import net.knarcraft.blacksmith.BlacksmithPlugin; import net.knarcraft.blacksmith.BlacksmithPlugin;
import net.knarcraft.blacksmith.config.scrapper.ScrapperNPCSettings; import net.knarcraft.blacksmith.config.scrapper.ScrapperNPCSettings;
import net.knarcraft.blacksmith.config.scrapper.ScrapperSetting; import net.knarcraft.blacksmith.config.scrapper.ScrapperSetting;
import net.knarcraft.blacksmith.util.ItemHelper;
import net.knarcraft.knarlib.formatting.StringFormatter;
import org.apache.commons.lang.NotImplementedException; import org.apache.commons.lang.NotImplementedException;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import java.util.List;
import static net.knarcraft.blacksmith.formatting.BlacksmithStringFormatter.sendNPCMessage;
/** /**
* The class representing a scrapper NPC trait * The class representing a scrapper NPC trait
*/ */
@ -64,9 +72,19 @@ public class ScrapperTrait extends CustomTrait<ScrapperSetting> {
* @param player <p>The player to start the session for</p> * @param player <p>The player to start the session for</p>
*/ */
public void startSession(@NotNull Player player) { public void startSession(@NotNull Player player) {
// TODO: Need some method to check which items are salvageable by the specific NPC. It should be similar to ItemStack itemInHand = player.getInventory().getItemInMainHand();
// reforge-able items. Optionally, extended mode can be enabled, which supports any recipe? List<Material> salvageAbleItems = this.config.getSalvageAbleItems();
// TODO: Check if the held item is salvageable, and give appropriate messages boolean extended = this.config.extendedSalvageEnabled();
// If extended mode is disabled, only allow repairable items to be salvaged
boolean notHoldingSalvageable = !ItemHelper.isSalvageable(player.getServer(), itemInHand) ||
(!salvageAbleItems.isEmpty() && !salvageAbleItems.contains(itemInHand.getType())) ||
(!extended && !ItemHelper.isRepairable(itemInHand));
if (notHoldingSalvageable) {
String invalidMessage = StringFormatter.replacePlaceholder(config.getInvalidItemMessage(),
"{title}", config.getScrapperTitle());
sendNPCMessage(this.npc, player, invalidMessage);
return;
}
// TODO: Mark the session start // TODO: Mark the session start
// TODO: Initialize a new session // TODO: Initialize a new session
// TODO: Tell player about the required cost // TODO: Tell player about the required cost

115
src/main/java/net/knarcraft/blacksmith/util/ItemHelper.java
View File

@ -1,14 +1,24 @@
package net.knarcraft.blacksmith.util; package net.knarcraft.blacksmith.util;
import net.knarcraft.blacksmith.BlacksmithPlugin;
import net.knarcraft.blacksmith.config.SmithPreset;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.Server;
import org.bukkit.inventory.CraftingRecipe;
import org.bukkit.inventory.Inventory; import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.Recipe;
import org.bukkit.inventory.SmithingTransformRecipe;
import org.bukkit.inventory.meta.Damageable; import org.bukkit.inventory.meta.Damageable;
import org.bukkit.inventory.meta.ItemMeta; import org.bukkit.inventory.meta.ItemMeta;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Set;
import java.util.logging.Level;
/** /**
* A helper class for getting information about items * A helper class for getting information about items
@ -155,4 +165,109 @@ public final class ItemHelper {
return false; return false;
} }
/**
* Checks whether the given item can be salvaged, assuming no restrictions apply
*
* @param server <p>The server to get recipes from</p>
* @param item <p>The item to check</p>
* @return <p>True if the item can be salvaged</p>
*/
public static boolean isSalvageable(@NotNull Server server, @NotNull ItemStack item) {
for (Recipe recipe : server.getRecipesFor(item)) {
// Only crafting recipes, and smithing transform recipes (diamond -> netherite) are allowed.
if (recipe instanceof CraftingRecipe || recipe instanceof SmithingTransformRecipe &&
item.getAmount() >= recipe.getResult().getAmount()) {
return true;
}
}
return false;
}
/**
* Gets all materials matching the given material wildcard
*
* @param materialName <p>The material name or material wildcard to match</p>
* @return <p>The matched material(s)</p>
*/
public static @NotNull List<Material> getWildcardMatch(@NotNull String materialName) {
String search = InputParsingHelper.regExIfy(materialName);
List<Material> materials = new ArrayList<>();
for (Material material : ItemHelper.getAllReforgeAbleMaterials()) {
if (material.name().matches(search)) {
materials.add(material);
}
}
return materials;
}
/**
* Gets a list of the items described in the given item list
*
* @param itemList <p>The list of items defined by the user</p>
* @param requireRepairable <p>Whether a material must be repairable to be valid.</p>
* @return <p>The materials contained in the item list</p>
*/
public static List<Material> getItems(@Nullable List<String> itemList, boolean requireRepairable) {
List<Material> items = new ArrayList<>();
if (itemList == null) {
return null;
}
//Convert any presets with a list of materials
itemList = replacePresets(itemList);
Set<Material> blacklisted = new HashSet<>();
//Parse every material, and add to reforgeAble items
for (String item : itemList) {
//Ignore ",,"
if (InputParsingHelper.isEmpty(item)) {
continue;
}
boolean blacklist = false;
if (item.startsWith("-")) {
blacklist = true;
item = item.substring(1);
}
Material material = InputParsingHelper.matchMaterial(item);
if (material != null && (!requireRepairable || ItemHelper.isRepairable(new ItemStack(material, 1)))) {
if (!blacklist) {
items.add(material);
} else {
blacklisted.add(material);
}
} else {
BlacksmithPlugin.getInstance().getLogger().log(Level.WARNING, "Unable to verify " + item +
" as a valid repairable item");
}
}
//Remove any blacklisted materials at the end to make sure order of arguments won't matter
items.removeAll(blacklisted);
return items;
}
/**
* Replaces smoth presets in the given list of strings
*
* @param stringList <p>The value specified by a user</p>
* @return <p>The value with smith presets replaced</p>
*/
private static @NotNull List<String> replacePresets(@NotNull List<String> stringList) {
List<String> newStrings = new ArrayList<>();
for (String item : stringList) {
if (item == null) {
continue;
}
String replaced = SmithPreset.replacePreset(item);
if (!replaced.equals(item)) {
newStrings.addAll(List.of(replaced.split(",")));
} else {
newStrings.add(item);
}
}
return newStrings;
}
} }

5
src/main/java/net/knarcraft/blacksmith/util/SalvageHelper.java
View File

@ -11,6 +11,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -46,7 +47,7 @@ public final class SalvageHelper {
* @return <p>The items to return to the user, or null if not salvageable</p> * @return <p>The items to return to the user, or null if not salvageable</p>
*/ */
public static @Nullable List<ItemStack> getSalvage(@NotNull Server server, @Nullable ItemStack salvagedItem, public static @Nullable List<ItemStack> getSalvage(@NotNull Server server, @Nullable ItemStack salvagedItem,
@NotNull List<Material> ignoredSalvage) { @NotNull Collection<Material> ignoredSalvage) {
if (salvagedItem == null || salvagedItem.getAmount() < 1 || if (salvagedItem == null || salvagedItem.getAmount() < 1 ||
!ItemHelper.isRepairable(salvagedItem)) { !ItemHelper.isRepairable(salvagedItem)) {
return null; return null;
@ -71,7 +72,7 @@ public final class SalvageHelper {
* @return <p>A list of items, or null if not a valid type of recipe</p> * @return <p>A list of items, or null if not a valid type of recipe</p>
*/ */
private static @Nullable List<ItemStack> getRecipeSalvage(@NotNull Recipe recipe, @NotNull ItemStack salvagedItem, private static @Nullable List<ItemStack> getRecipeSalvage(@NotNull Recipe recipe, @NotNull ItemStack salvagedItem,
@NotNull List<Material> ignoredSalvage) { @NotNull Collection<Material> ignoredSalvage) {
List<ItemStack> ingredients; List<ItemStack> ingredients;
if (recipe instanceof ShapedRecipe shapedRecipe) { if (recipe instanceof ShapedRecipe shapedRecipe) {
ingredients = getIngredients(shapedRecipe); ingredients = getIngredients(shapedRecipe);

13
src/main/resources/config.yml
View File

@ -123,6 +123,13 @@ scrapper:
# Whether enchanted salvaged items should return some amount of exp upon salvage # Whether enchanted salvaged items should return some amount of exp upon salvage
giveExperience: true giveExperience: true
# Items ignored during salvage calculation. This follows the format: "MATERIAL[,MATERIAL2][,MATERIAL3]:IGNORED", so
# the material or materials listed will ignore the material specified after the ":" when calculating salvage
# (* matches any character). This causes the player to lose some items during salvaging, but can prevent cases
# where a diamond pickaxe is salvaged and only sticks are returned.
ignoredSalvage:
- "*_SHOVEL,*_PICKAXE,*_AXE,*_HOE,*_SWORD:STICK"
# The settings which are set to any new scrapper NPC. To change any of these settings for an existing NPC, you must # The settings which are set to any new scrapper NPC. To change any of these settings for an existing NPC, you must
# change the Citizens NPC file, or use the /scrapper command # change the Citizens NPC file, or use the /scrapper command
defaults: defaults:
@ -150,6 +157,9 @@ scrapper:
# The title describing the scrapper's usage/speciality (e.x armor-scrapper, tool-scrapper, weapon-scrapper) # The title describing the scrapper's usage/speciality (e.x armor-scrapper, tool-scrapper, weapon-scrapper)
scrapperTitle: "scrapper" scrapperTitle: "scrapper"
# Whether to enable salvaging of non-repairable items, such as planks
extendedSalvageEnabled: false
# Default values for messages used by NPCs # Default values for messages used by NPCs
messages: messages:
# The message to display when another player is using the scrapper # The message to display when another player is using the scrapper
@ -178,3 +188,6 @@ scrapper:
# The message to display once the scrapper starts salvaging # The message to display once the scrapper starts salvaging
startSalvageMessage: "&eOk, let's see what I can do..." startSalvageMessage: "&eOk, let's see what I can do..."
# The message to display when holding an item the blacksmith is unable to reforge
invalidItemMessage: "&cI'm sorry, but I'm a/an {title}, I don't know how to salvage that!"