diff --git a/Common/src/main/java/com/tristankechlo/toolleveling/client/ComponentUtil.java b/Common/src/main/java/com/tristankechlo/toolleveling/client/ComponentUtil.java index c607e8f..a8b4041 100644 --- a/Common/src/main/java/com/tristankechlo/toolleveling/client/ComponentUtil.java +++ b/Common/src/main/java/com/tristankechlo/toolleveling/client/ComponentUtil.java @@ -54,14 +54,36 @@ public static Component makeHelpField(String str, Integer number) { return Component.translatable(START + str, number).withStyle(ChatFormatting.GRAY); } - public static Component makeSummary(String str, int iterations, int strength) { - MutableComponent iterationsText = Component.literal("" + iterations).withStyle(ChatFormatting.GREEN); - MutableComponent strengthText = Component.literal("" + strength).withStyle(ChatFormatting.GREEN); - MutableComponent strText = Component.literal("1").withStyle(ChatFormatting.GREEN); - if (strength > 1) { - str += ".multi"; + private static MutableComponent literalFloat(float value) { + int rounded = Math.round(value); + if (rounded == value) { + return Component.literal("" + rounded); + } + else { + return Component.literal("" + value); + } + } + + public static Component makeSummary(String str, float iterations, float minStrength, float strength) { + if (iterations <= 0) { + MutableComponent iterationsText = Component.literal("" + iterations).withStyle(ChatFormatting.GREEN); + return Component.translatable(START + str + ".iterations_too_low", iterationsText).withStyle(ChatFormatting.GRAY); + } + if (strength <= 0) { + MutableComponent iterationsText = Component.literal("" + strength).withStyle(ChatFormatting.GREEN); + return Component.translatable(START + str + ".strength_too_low", iterationsText).withStyle(ChatFormatting.GRAY); + } + MutableComponent iterationsText = literalFloat(iterations).withStyle(ChatFormatting.GREEN); + MutableComponent strengthText = literalFloat(strength).withStyle(ChatFormatting.GREEN); + if (strength > minStrength) { + MutableComponent minStrText = literalFloat(minStrength).withStyle(ChatFormatting.GREEN); + if (minStrength < 0) { + minStrText = Component.translatable(START + ".min_strength_capped", minStrText); + } + return Component.translatable(START + str + ".multi", iterationsText, minStrText, strengthText).withStyle(ChatFormatting.GRAY); + } else { + return Component.translatable(START + str, iterationsText, strengthText).withStyle(ChatFormatting.GRAY); } - return Component.translatable(START + str, iterationsText, strText, strengthText).withStyle(ChatFormatting.GRAY); } } diff --git a/Common/src/main/java/com/tristankechlo/toolleveling/client/ToolLevelingTableScreen.java b/Common/src/main/java/com/tristankechlo/toolleveling/client/ToolLevelingTableScreen.java index ca4ad57..9bf6c63 100644 --- a/Common/src/main/java/com/tristankechlo/toolleveling/client/ToolLevelingTableScreen.java +++ b/Common/src/main/java/com/tristankechlo/toolleveling/client/ToolLevelingTableScreen.java @@ -95,9 +95,10 @@ protected void containerTick() { this.successChanceField.setLines(List.of(ComponentUtil.TITLE_SUCCESS_CHANCE, chanceText, minChanceText, maxChanceText)); // update bonus items - int iterations = this.getMenu().getCycles(); - int strength = this.getMenu().getLevels(); - Component summary = ComponentUtil.makeSummary(".summary.field_text", iterations, strength); + float iterations = this.getMenu().getCycles(); + float minStrength = this.getMenu().getMinLevels(); + float strength = this.getMenu().getLevels(); + Component summary = ComponentUtil.makeSummary(".summary.field_text", iterations, minStrength, strength); int maxPossibleWidth = this.width - (this.leftPos + this.imageWidth) - 10; this.bonusItemField.setLines(List.of(ComponentUtil.TITLE_BONUSES, summary), font, maxPossibleWidth); } diff --git a/Common/src/main/java/com/tristankechlo/toolleveling/config/ToolLevelingConfig.java b/Common/src/main/java/com/tristankechlo/toolleveling/config/ToolLevelingConfig.java index da579a6..84d62f1 100644 --- a/Common/src/main/java/com/tristankechlo/toolleveling/config/ToolLevelingConfig.java +++ b/Common/src/main/java/com/tristankechlo/toolleveling/config/ToolLevelingConfig.java @@ -3,7 +3,8 @@ import com.tristankechlo.toolleveling.ToolLeveling; import com.tristankechlo.toolleveling.config.util.AbstractConfig; import com.tristankechlo.toolleveling.config.values.AbstractConfigValue; -import com.tristankechlo.toolleveling.config.values.IngredientValue; +import com.tristankechlo.toolleveling.config.values.BonusIngredient; +import com.tristankechlo.toolleveling.config.values.BonusIngredientsValue; import com.tristankechlo.toolleveling.config.values.NumberValue; import net.minecraft.util.GsonHelper; import net.minecraft.world.item.ItemStack; @@ -19,8 +20,10 @@ public final class ToolLevelingConfig extends AbstractConfig { private final NumberValue maxSuccessChance; private final NumberValue requiredBookshelves; private final NumberValue requiredBooks; - private final IngredientValue bonusItemMoreEnchantments; - private final IngredientValue bonusItemMoreLevels; + private final NumberValue baseIterations; + private final NumberValue baseMinStrength; + private final NumberValue baseStrength; + private final BonusIngredientsValue bonusIngredients; private final List> values; public static final ToolLevelingConfig INSTANCE = new ToolLevelingConfig(); @@ -31,10 +34,16 @@ private ToolLevelingConfig() { maxSuccessChance = new NumberValue<>("max_success_chance", 100.0F, 0.0F, 100.0F, GsonHelper::getAsFloat); requiredBookshelves = new NumberValue<>("required_bookshelves", 20, 0, 32, GsonHelper::getAsInt); requiredBooks = new NumberValue<>("required_books", 4, 1, 6, GsonHelper::getAsInt); - bonusItemMoreEnchantments = new IngredientValue("bonus_item_more_enchantments", Ingredient.of(Items.NETHER_STAR)); - bonusItemMoreLevels = new IngredientValue("bonus_item_more_levels", Ingredient.of(Items.ENCHANTED_GOLDEN_APPLE)); - - values = List.of(minSuccessChance, maxSuccessChance, requiredBookshelves, requiredBooks, bonusItemMoreEnchantments, bonusItemMoreLevels); + baseIterations = new NumberValue<>("base_num_enchantments", 1.0F, -Float.MAX_VALUE, Float.MAX_VALUE, GsonHelper::getAsFloat); + baseMinStrength = new NumberValue<>("base_num_min_levels", 1.0F, -Float.MAX_VALUE, Float.MAX_VALUE, GsonHelper::getAsFloat); + baseStrength = new NumberValue<>("base_num_levels", 1.0F, -Float.MAX_VALUE, Float.MAX_VALUE, GsonHelper::getAsFloat); + bonusIngredients = new BonusIngredientsValue("bonus_ingredients", new BonusIngredient[]{ + new BonusIngredient(Ingredient.of(Items.NETHER_STAR), 0.0F, 0.0F, 1.0F), + new BonusIngredient(Ingredient.of(Items.ENCHANTED_GOLDEN_APPLE), 0.0F, 1.0F, 0.0F), + }); + + values = List.of(minSuccessChance, maxSuccessChance, requiredBookshelves, requiredBooks, + baseIterations, baseMinStrength, baseStrength, bonusIngredients); } @Override @@ -63,12 +72,46 @@ public int requiredBooks() { return requiredBooks.get(); } - public boolean isBonusItemStrength(ItemStack stack) { - return bonusItemMoreLevels.get().test(stack); + public float getBaseMinStrength() { + return baseMinStrength.get(); + } + + public float getBaseStrength() { + return baseStrength.get(); + } + + public float getBaseIterations() { + return baseIterations.get(); + } + + public float getBonusItemMinStrength(ItemStack stack) { + float total = 0; + for (BonusIngredient bonus : bonusIngredients.get()) { + if (bonus.ingredient().test(stack)) { + total += bonus.minLevelBonus(); + } + } + return total; + } + + public float getBonusItemStrength(ItemStack stack) { + float total = 0; + for (BonusIngredient bonus : bonusIngredients.get()) { + if (bonus.ingredient().test(stack)) { + total += bonus.maxLevelBonus(); + } + } + return total; } - public boolean isBonusItemIterations(ItemStack stack) { - return bonusItemMoreEnchantments.get().test(stack); + public float getBonusItemIterations(ItemStack stack) { + float total = 0; + for (BonusIngredient bonus : bonusIngredients.get()) { + if (bonus.ingredient().test(stack)) { + total += bonus.iterationsBonus(); + } + } + return total; } } diff --git a/Common/src/main/java/com/tristankechlo/toolleveling/config/values/BonusIngredient.java b/Common/src/main/java/com/tristankechlo/toolleveling/config/values/BonusIngredient.java new file mode 100644 index 0000000..d5b9163 --- /dev/null +++ b/Common/src/main/java/com/tristankechlo/toolleveling/config/values/BonusIngredient.java @@ -0,0 +1,34 @@ +package com.tristankechlo.toolleveling.config.values; + +import com.google.gson.JsonObject; +import net.minecraft.util.GsonHelper; +import net.minecraft.world.item.crafting.Ingredient; + +public record BonusIngredient(Ingredient ingredient, float minLevelBonus, float maxLevelBonus, float iterationsBonus) { + + public BonusIngredient { + if (ingredient == null) { + throw new NullPointerException("ingredient of the bonus ingredient can't be null"); + } + if (minLevelBonus == 0 && maxLevelBonus == 0 && iterationsBonus == 0) { + throw new NullPointerException("bonus ingredient must provide at least one bonus"); + } + } + + public static void serialize(BonusIngredient value, JsonObject json) { + json.add("ingredient", value.ingredient().toJson()); + json.addProperty("min_level_bonus", value.minLevelBonus()); + json.addProperty("max_level_bonus", value.maxLevelBonus()); + json.addProperty("iterations_bonus", value.iterationsBonus()); + } + + public static BonusIngredient deserialize(JsonObject json) { + JsonObject obj = GsonHelper.getAsJsonObject(json, "ingredient"); + Ingredient ingredient = Ingredient.fromJson(obj); + float minLevelBonus = GsonHelper.getAsFloat(json, "min_level_bonus", 0.0F); + float maxLevelBonus = GsonHelper.getAsFloat(json, "max_level_bonus", 0.0F); + float iterationsBonus = GsonHelper.getAsFloat(json, "iterations_bonus", 0.0F); + return new BonusIngredient(ingredient, minLevelBonus, maxLevelBonus, iterationsBonus); + } + +} diff --git a/Common/src/main/java/com/tristankechlo/toolleveling/config/values/BonusIngredientsValue.java b/Common/src/main/java/com/tristankechlo/toolleveling/config/values/BonusIngredientsValue.java new file mode 100644 index 0000000..afcc7bb --- /dev/null +++ b/Common/src/main/java/com/tristankechlo/toolleveling/config/values/BonusIngredientsValue.java @@ -0,0 +1,77 @@ +package com.tristankechlo.toolleveling.config.values; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.tristankechlo.toolleveling.ToolLeveling; +import net.minecraft.util.GsonHelper; +import net.minecraft.world.item.crafting.Ingredient; + +public final class BonusIngredientsValue extends AbstractConfigValue { + + private BonusIngredient[] value; + private final BonusIngredient[] defaultValue; + + public BonusIngredientsValue(String name, BonusIngredient[] defaultValue) { + super(name); + this.value = defaultValue; + this.defaultValue = defaultValue; + } + + @Override + public void setToDefault() { + this.value = defaultValue; + } + + @Override + public void serialize(JsonObject json) { + JsonArray arr = new JsonArray(); + for (BonusIngredient bonus : value) { + JsonObject obj = new JsonObject(); + BonusIngredient.serialize(bonus, obj); + arr.add(obj); + } + json.add(getIdentifier(), arr); + } + + @Override + public void deserialize(JsonObject json) { + if (json.has("bonus_item_more_enchantments") && json.has("bonus_item_more_levels")) { + // migrate from one ingredient per bonus + ToolLeveling.LOGGER.info("Migrating for the config value " + getIdentifier()); + try { + JsonObject moreEnchantsObj = GsonHelper.getAsJsonObject(json, "bonus_item_more_enchantments"); + Ingredient maxLevelBonusIngredient = Ingredient.fromJson(moreEnchantsObj); + JsonObject moreLevelsObj = GsonHelper.getAsJsonObject(json, "bonus_item_more_levels"); + Ingredient iterationsBonusIngredient = Ingredient.fromJson(moreLevelsObj); + value = new BonusIngredient[]{ + new BonusIngredient(maxLevelBonusIngredient, 0.0F, 0.0F, 1.0F), + new BonusIngredient(iterationsBonusIngredient, 0.0F, 1.0F, 0.0F) + }; + } catch (Exception e) { + value = defaultValue; + ToolLeveling.LOGGER.warn(e.getMessage()); + ToolLeveling.LOGGER.warn("Error while migrating the config value " + getIdentifier() + ", using default value instead"); + } + } else { + // deserialize the array-based format + try { + JsonArray arr = GsonHelper.getAsJsonArray(json, getIdentifier()); + value = new BonusIngredient[arr.size()]; + for (int i = 0; i < arr.size(); i++) { + JsonObject obj = GsonHelper.convertToJsonObject(arr.get(i), "[" + i + "]"); + value[i] = BonusIngredient.deserialize(obj); + } + } catch (Exception e) { + value = defaultValue; + ToolLeveling.LOGGER.warn(e.getMessage()); + ToolLeveling.LOGGER.warn("Error while loading the config value " + getIdentifier() + ", using default value instead"); + } + } + } + + @Override + public BonusIngredient[] get() { + return value; + } + +} diff --git a/Common/src/main/java/com/tristankechlo/toolleveling/config/values/IngredientValue.java b/Common/src/main/java/com/tristankechlo/toolleveling/config/values/IngredientValue.java deleted file mode 100644 index e724735..0000000 --- a/Common/src/main/java/com/tristankechlo/toolleveling/config/values/IngredientValue.java +++ /dev/null @@ -1,50 +0,0 @@ -package com.tristankechlo.toolleveling.config.values; - -import com.google.gson.JsonElement; -import com.google.gson.JsonObject; -import com.tristankechlo.toolleveling.ToolLeveling; -import net.minecraft.world.item.crafting.Ingredient; - -public final class IngredientValue extends AbstractConfigValue { - - private Ingredient value; - private final Ingredient defaultValue; - - public IngredientValue(String name, Ingredient defaultValue) { - super(name); - this.value = defaultValue; - this.defaultValue = defaultValue; - } - - @Override - public void setToDefault() { - this.value = defaultValue; - } - - @Override - public void serialize(JsonObject json) { - json.add(getIdentifier(), value.toJson()); - } - - @Override - public void deserialize(JsonObject json) { - try { - JsonElement jsonElement = json.get(getIdentifier()); - if (jsonElement != null) { - value = Ingredient.fromJson(jsonElement, true); - } else { - value = defaultValue; - } - } catch (Exception e) { - value = defaultValue; - ToolLeveling.LOGGER.warn(e.getMessage()); - ToolLeveling.LOGGER.warn("Error while loading the config value " + getIdentifier() + ", using default value instead"); - } - } - - @Override - public Ingredient get() { - return value; - } - -} diff --git a/Common/src/main/java/com/tristankechlo/toolleveling/menu/ToolLevelingTableMenu.java b/Common/src/main/java/com/tristankechlo/toolleveling/menu/ToolLevelingTableMenu.java index c30bd04..f92c9be 100644 --- a/Common/src/main/java/com/tristankechlo/toolleveling/menu/ToolLevelingTableMenu.java +++ b/Common/src/main/java/com/tristankechlo/toolleveling/menu/ToolLevelingTableMenu.java @@ -150,11 +150,15 @@ public boolean hasAnyBooks() { return false; } - public int getCycles() { + public float getCycles() { return Util.getIterations(this.table); } - public int getLevels() { + public float getMinLevels() { + return Util.getEnchantmentMinStrength(this.table); + } + + public float getLevels() { return Util.getEnchantmentStrength(this.table); } diff --git a/Common/src/main/java/com/tristankechlo/toolleveling/network/packets/TableUpgradeProcess.java b/Common/src/main/java/com/tristankechlo/toolleveling/network/packets/TableUpgradeProcess.java index b4440d2..ee2289b 100644 --- a/Common/src/main/java/com/tristankechlo/toolleveling/network/packets/TableUpgradeProcess.java +++ b/Common/src/main/java/com/tristankechlo/toolleveling/network/packets/TableUpgradeProcess.java @@ -44,8 +44,13 @@ public static void handle(TableUpgradeProcess msg, ServerLevel level) { return; } - int iterations = Util.getIterations(table); // how often the process will be repeated - int strength = Util.getEnchantmentStrength(table); // the maximum level of the enchantments + float iterations = Util.getIterations(table); // how often the process will be repeated + int trueIterations = (int) Math.floor(iterations); + if (iterations > trueIterations && level.getRandom().nextFloat() < iterations - trueIterations) { + trueIterations++; + } + float minStrength = Util.getEnchantmentMinStrength(table); // the minimum level of the enchantments + float strength = Util.getEnchantmentStrength(table); // the maximum level of the enchantments var possibleEnchantments = table.getEnchantments(); // the possible enchantments, with their weight float successChance = Util.getSuccessChance(level, msg.pos); // the chance of a success in each iteration ItemStack tool = table.getStackToEnchant(); // the tool to enchant @@ -58,7 +63,7 @@ public static void handle(TableUpgradeProcess msg, ServerLevel level) { } // calculate the enchantments to add - for (int i = 0; i < iterations; i++) { + for (int i = 0; i < trueIterations; i++) { float nextFloat = level.getRandom().nextFloat(); if (nextFloat > successChance) { ToolLeveling.LOGGER.info("TableUpgradeProcess failed {} {}", successChance, nextFloat); @@ -70,16 +75,27 @@ public static void handle(TableUpgradeProcess msg, ServerLevel level) { continue; } Enchantment e = o.get().getData(); - int enchantmentLevel = level.getRandom().nextInt(strength) + 1; - if (enchantmentsToAdd.containsKey(e)) { // if the enchantment is already in the map, sum up the levels - enchantmentLevel += enchantmentsToAdd.get(e); + // strength wins if it is lower than minStrengtg + float enchantmentLevel = Math.min(minStrength, strength); + if (strength > minStrength) { + enchantmentLevel += level.getRandom().nextFloat() * (strength - minStrength); + } + int trueEnchantmentLevel = (int) Math.floor(enchantmentLevel); + if (enchantmentLevel > trueEnchantmentLevel && level.getRandom().nextFloat() < enchantmentLevel - trueEnchantmentLevel) { + trueEnchantmentLevel++; + } + // if minimum strength is below 1, the resulting level can be too - don't add or subtract in that case + if (trueEnchantmentLevel > 0) { + if (enchantmentsToAdd.containsKey(e)) { // if the enchantment is already in the map, sum up the levels + trueEnchantmentLevel += enchantmentsToAdd.get(e); + } + enchantmentsToAdd.put(e, trueEnchantmentLevel); } - enchantmentsToAdd.put(e, enchantmentLevel); } // add the enchantments to the item for (var entry : enchantmentsToAdd.entrySet()) { - oldEnchantments.merge(entry.getKey(), entry.getValue(), Integer::sum); + oldEnchantments.merge(entry.getKey(), entry.getValue(), (l, r) -> Math.min(l + r, Short.MAX_VALUE)); } EnchantmentHelper.setEnchantments(oldEnchantments, tool); table.setChanged(); diff --git a/Common/src/main/java/com/tristankechlo/toolleveling/util/Predicates.java b/Common/src/main/java/com/tristankechlo/toolleveling/util/Predicates.java index a7aedcb..3fc7b14 100644 --- a/Common/src/main/java/com/tristankechlo/toolleveling/util/Predicates.java +++ b/Common/src/main/java/com/tristankechlo/toolleveling/util/Predicates.java @@ -11,8 +11,9 @@ public final class Predicates { public static final Predicate IS_BOOK = (stack) -> stack.is(Items.ENCHANTED_BOOK); // purple slots public static final Predicate IS_UPGRADE_ITEM = (stack) -> !IS_BOOK.test(stack) && (stack.isEnchanted() || stack.isEnchantable()); // red slot - public static final Predicate BONUS_ITEM_STRENGTH = ToolLevelingConfig.INSTANCE::isBonusItemStrength; - public static final Predicate BONUS_ITEM_ITERATIONS = ToolLevelingConfig.INSTANCE::isBonusItemIterations; - public static final Predicate IS_BONUS_ITEM = (stack) -> BONUS_ITEM_STRENGTH.test(stack) || BONUS_ITEM_ITERATIONS.test(stack); // green slots + public static final Predicate BONUS_ITEM_MIN_STRENGTH = (stack) -> ToolLevelingConfig.INSTANCE.getBonusItemMinStrength(stack) != 0.0F; + public static final Predicate BONUS_ITEM_STRENGTH = (stack) -> ToolLevelingConfig.INSTANCE.getBonusItemStrength(stack) != 0.0F; + public static final Predicate BONUS_ITEM_ITERATIONS = (stack) -> ToolLevelingConfig.INSTANCE.getBonusItemIterations(stack) != 0.0F; + public static final Predicate IS_BONUS_ITEM = (stack) -> BONUS_ITEM_MIN_STRENGTH.test(stack) || BONUS_ITEM_STRENGTH.test(stack) || BONUS_ITEM_ITERATIONS.test(stack); // green slots } diff --git a/Common/src/main/java/com/tristankechlo/toolleveling/util/Util.java b/Common/src/main/java/com/tristankechlo/toolleveling/util/Util.java index 1490257..d526dac 100644 --- a/Common/src/main/java/com/tristankechlo/toolleveling/util/Util.java +++ b/Common/src/main/java/com/tristankechlo/toolleveling/util/Util.java @@ -12,6 +12,7 @@ import java.util.function.Function; +import static com.tristankechlo.toolleveling.blockentity.ToolLevelingTableBlockEntity.BONUS_SLOTS; import static com.tristankechlo.toolleveling.blockentity.ToolLevelingTableBlockEntity.BOOK_SLOTS; public final class Util { @@ -25,8 +26,11 @@ private static boolean canUpgradeProcessBegin(Function f) { } boolean enoughBooks = bookCount >= ToolLevelingConfig.INSTANCE.requiredBooks(); // the minimum number of books is reached boolean upgradeSlotNotEmpty = !f.apply(0).isEmpty(); // the upgrade slot is not empty + float iterations = getIterations(f); + float strength = getEnchantmentStrength(f); + // no mimumum strength check, it can go below 1 or above strength (which is a waste) - return enoughBooks && upgradeSlotNotEmpty; + return enoughBooks && upgradeSlotNotEmpty && iterations > 0.0F && strength > 0.0F; } public static boolean canUpgradeProcessBegin(AbstractContainerMenu menu) { @@ -58,22 +62,38 @@ public static float getSuccessChance(Level level, BlockPos tablePos) { return minPercentage + ((maxPercentage - minPercentage) * fullPercent); } - public static int getIterations(Container menu) { - int count = 1; - for (int i : ToolLevelingTableBlockEntity.BONUS_SLOTS) { - if (Predicates.BONUS_ITEM_ITERATIONS.test(menu.getItem(i))) { - count++; - } + public static float getIterations(Container menu) { + return getIterations(menu::getItem); + } + + private static float getIterations(Function f) { + float count = ToolLevelingConfig.INSTANCE.getBaseIterations(); + for (int i : BONUS_SLOTS) { + count += ToolLevelingConfig.INSTANCE.getBonusItemIterations(f.apply(i)); } return count; } - public static int getEnchantmentStrength(Container menu) { - int count = 1; - for (int i : ToolLevelingTableBlockEntity.BONUS_SLOTS) { - if (Predicates.BONUS_ITEM_STRENGTH.test(menu.getItem(i))) { - count++; - } + public static float getEnchantmentMinStrength(Container menu) { + return getEnchantmentMinStrength(menu::getItem); + } + + private static float getEnchantmentMinStrength(Function f) { + float count = ToolLevelingConfig.INSTANCE.getBaseMinStrength(); + for (int i : BONUS_SLOTS) { + count += ToolLevelingConfig.INSTANCE.getBonusItemMinStrength(f.apply(i)); + } + return count; + } + + public static float getEnchantmentStrength(Container menu) { + return getEnchantmentStrength(menu::getItem); + } + + private static float getEnchantmentStrength(Function f) { + float count = ToolLevelingConfig.INSTANCE.getBaseStrength(); + for (int i : BONUS_SLOTS) { + count += ToolLevelingConfig.INSTANCE.getBonusItemStrength(f.apply(i)); } return count; } diff --git a/Common/src/main/resources/assets/toolleveling/lang/de_de.json b/Common/src/main/resources/assets/toolleveling/lang/de_de.json index 175ad99..1f0722a 100644 --- a/Common/src/main/resources/assets/toolleveling/lang/de_de.json +++ b/Common/src/main/resources/assets/toolleveling/lang/de_de.json @@ -7,6 +7,9 @@ "screen.toolleveling.tool_leveling_table.summary.field_title": "Zusammenfassung", "screen.toolleveling.tool_leveling_table.summary.field_text": "Bis zu %s Verzauberung(en) werden dem Item hinzugefügt, jede mit einer Stufe von %s", "screen.toolleveling.tool_leveling_table.summary.field_text.multi": "Bis zu %s Verzauberung(en) werden dem Item hinzugefügt, jede mit einer Stufe von %s bis %s", + "screen.toolleveling.tool_leveling_table.summary.field_text.iterations_too_low": "Nicht genug Verzauberungen (%s) f\u00FCr das Upgrade, verwende andere besondere Gegenstände um mindestens 1 Verzauberung zu erreichen", + "screen.toolleveling.tool_leveling_table.summary.field_text.strength_too_low": "Stufe der Verzauberung (%s) zu niedrig f\u00FCr das Upgrade, verwende andere besondere Gegenstände um mindestens Stufe 1 zu erreichen", + "screen.toolleveling.tool_leveling_table.min_strength_capped": "%s (resultierende Stufe mindestens 0)", "screen.toolleveling.tool_leveling_table.percentages.button_text": "Info", "screen.toolleveling.tool_leveling_table.percentages.button_tooltip": "Zeige die Wahrscheinlichkeiten f\u00FCr die Verzauberungen", "screen.toolleveling.tool_leveling_table.percentages.field_title": "Wahrscheinlichkeiten", diff --git a/Common/src/main/resources/assets/toolleveling/lang/en_us.json b/Common/src/main/resources/assets/toolleveling/lang/en_us.json index 674cd0a..94173eb 100644 --- a/Common/src/main/resources/assets/toolleveling/lang/en_us.json +++ b/Common/src/main/resources/assets/toolleveling/lang/en_us.json @@ -11,6 +11,9 @@ "screen.toolleveling.tool_leveling_table.summary.field_title": "Summary", "screen.toolleveling.tool_leveling_table.summary.field_text": "Up to %s enchantment(s) will be added to your item, each with a level of %s", "screen.toolleveling.tool_leveling_table.summary.field_text.multi": "Up to %s enchantment(s) will be added to your item, each with a level between %s and %s", + "screen.toolleveling.tool_leveling_table.summary.field_text.iterations_too_low": "Enchantment count (%s) too low to upgrade, add or remove bonus items for a count of at least 1", + "screen.toolleveling.tool_leveling_table.summary.field_text.strength_too_low": "Enchantment strength (%s) too low to upgrade, add or remove bonus items for a strength of at least 1", + "screen.toolleveling.tool_leveling_table.min_strength_capped": "%s (result lower bounded by 0)", "screen.toolleveling.tool_leveling_table.percentages.button_text": "Info", "screen.toolleveling.tool_leveling_table.percentages.button_tooltip": "Show/Hide the percentages", "screen.toolleveling.tool_leveling_table.percentages.field_title": "Chosen Enchantment",